# CipherStash Docs
Source: https://cipherstash.com/docs
CipherStash encrypts your data at the field level. Every value gets its own
key, and the ciphertext stays queryable in Postgres. A breach, a compromised
agent, a curious insider: they all see ciphertext with no key.
Start here [#start-here]
Browse the docs [#browse-the-docs]
AI-ready documentation [#ai-ready-documentation]
Every page is available as clean markdown: append `.mdx` to any page URL, or
fetch the whole corpus via [llms.txt](https://cipherstash.com/docs/llms.txt) and
[llms-full.txt](https://cipherstash.com/docs/llms-full.txt).
# Choose your stack
Source: https://cipherstash.com/docs/get-started/choose-your-stack
Four decisions, in order. The first one matters most; the rest usually follow from what you already run.
1. SDK or Proxy [#1-sdk-or-proxy]
| | [Stack SDK](https://cipherstash.com/docs/reference/stack) | [Proxy](https://cipherstash.com/docs/reference/proxy) |
| ------------------------ | ------------------------------------------------------------------- | --------------------------------------------------------- |
| Where encryption happens | In your application process | In the proxy, which you run |
| Application changes | Encrypt and decrypt calls, or an ORM wrapper that adds them for you | Point your connection string at the proxy |
| Best when | You own the code and want fine-grained control | You cannot change the application, or it isn't TypeScript |
| Language | TypeScript / JavaScript | Any. It speaks the Postgres wire protocol |
| Runs where | Your app | A container or sidecar in your infrastructure |
Both produce the same ciphertext and both speak [EQL](https://cipherstash.com/docs/reference/eql), so this is not a one-way door. You can move a table from one to the other without re-encrypting it.
Start with the SDK unless you already know you can't change the application.
2. Your Postgres [#2-your-postgres]
EQL installs into any Postgres you can connect to. It needs no extension, no superuser, and no `postgresql.conf` changes.
| Platform | Works | Notes |
| ---------------------------- | -------------------- | ----------------------------------------------------------------------------------------------------------------------------------- |
| Supabase | Yes | [Supabase integration](https://cipherstash.com/docs/integrations/supabase). Expose the `eql_v3` schema in the dashboard. |
| Prisma Postgres | Yes | [Prisma Postgres integration](https://cipherstash.com/docs/integrations/prisma/prisma-postgres). EQL is installed through the Prisma ORM 8 migration graph. |
| Neon, RDS, Aurora, Cloud SQL | Yes | `stash eql install` detects a non-superuser role and adapts. |
| Self-hosted Postgres | Yes | Full operator-class support, so the ORE ordering mechanism is available. |
| Postgres behind PgBouncer | Yes, with conditions | Pooler placement matters when you use Proxy. See [Proxy and connection poolers](#proxy-and-connection-poolers). |
| DynamoDB | Yes, without EQL | [DynamoDB integration](https://cipherstash.com/docs/integrations/aws/dynamodb). Encrypted attributes and HMAC key lookups; no EQL, because there's no Postgres. |
| MySQL, MongoDB, others | Not yet | The SDK still encrypts values for you, but nothing is queryable server-side. |
Managed platforms usually block custom operator class creation. That's why the default ordering mechanism is moving to OPE, which indexes under Postgres's default btree operator class. See [SEM specifiers](https://cipherstash.com/docs/reference/eql/core-concepts#sem-specifiers).
Proxy and connection poolers [#proxy-and-connection-poolers]
Proxy opens one Postgres connection for each client connection. It has no upstream connection pool. Proxy also keeps state for each client connection: the active keyset, prepared statement mappings, and the `UNSAFE_DISABLE_MAPPING` setting. A transaction-mode pooler in front of Proxy can hand one client's transaction to a connection that holds another client's state.
Until the supported topologies are documented, use one of these setups:
* **Pooler behind Proxy (recommended).** Run app, then Proxy, then pooler, then Postgres. Use PgBouncer 1.21 or later and set `max_prepared_statements`.
* **Pooler in front of Proxy.** Use session mode only.
Do not use `SET CIPHERSTASH.KEYSET_ID` or `SET CIPHERSTASH.KEYSET_NAME` behind a transaction-mode pooler. See [Multitenant operation](https://cipherstash.com/docs/reference/proxy/multitenant#connection-poolers).
A table of supported topologies is coming. It is tracked as CIP-4167.
3. Your ORM [#3-your-orm]
| Query layer | Path | What it looks like |
| -------------------- | ---------------------------------------------- | ------------------------------------------------------------------------------------ |
| Drizzle | [Drizzle integration](https://cipherstash.com/docs/integrations/drizzle) | Encrypted column types and typed query operators. Your Drizzle code keeps its shape. |
| Supabase JS | [Supabase integration](https://cipherstash.com/docs/integrations/supabase) | `encryptedSupabase` wraps the client. `.eq()`, `.gt()`, `.order()` keep working. |
| Prisma ORM 8 RC | [Prisma integration](https://cipherstash.com/docs/integrations/prisma) | Encrypted fields and query operators are generated from `schema.prisma`. |
| Raw SQL | [Quickstart](https://cipherstash.com/docs/get-started/quickstart) | Encrypt the value, insert it, cast the query operand. |
| An ORM we don't list | The SDK | Encrypt before write, decrypt after read. Every ORM supports that. |
If you use no ORM, nothing is missing. The SDK's `encrypt` and `encryptQuery` are the whole surface.
4. Identity binding [#4-identity-binding]
Reach for this when a value should be decryptable only by the user it belongs to, rather than by anything holding the application's credentials. It is also what shrinks the blast radius of a compromised application process.
It requires an OIDC provider, registered on the [OIDC providers](https://dashboard.cipherstash.com/workspaces/_/oidc-providers) page in the Dashboard.
| Provider | Supported |
| --------------- | ----------------------------------------- |
| Supabase Auth | Yes |
| Clerk | Yes |
| Auth0 | Yes |
| Okta | Yes |
| Any OIDC issuer | Yes, if it publishes a discovery endpoint |
See [provable access control](https://cipherstash.com/docs/solutions/provable-access) for what this buys you, and what it does not.
Where CipherStash sits among the encryption you already have [#where-cipherstash-sits-among-the-encryption-you-already-have]
Encryption at rest and in transit are not alternatives to this. They protect different things, and you should keep both.
| | At rest | In transit | In use |
| --------------------------------- | ------- | ---------- | ------ |
| Protects the disk | Yes | No | Yes |
| Protects the wire | No | Yes | Yes |
| Protects during a query | No | No | Yes |
| Plaintext visible to the database | Yes | Yes | **No** |
| Queryable without decrypting | n/a | n/a | Yes |
A database breach defeats encryption at rest, because the database decrypts on read. That is the gap this fills.
From development to production [#from-development-to-production]
Device auth gives each developer their own identity, so local decryptions are attributable. There is no interactive device profile in CI, hence the switch to explicit credentials. See [Deployment](https://cipherstash.com/docs/guides/deployment) for build-time availability, environment separation, and rollout gates.
Still not sure [#still-not-sure]
A [discovery session](https://cipherstash.com/contact) is a 60-minute conversation with our engineering team. No slides. Bring whoever owns the data layer, and a compliance lead if that's someone else.
Worth thinking through beforehand:
* Which fields are sensitive, and which regulations cover them.
* Whether you need those fields **searchable**, or only stored and retrieved. Encrypt-only columns carry no index terms and leak nothing.
* Whether you need per-user decryption, or per-tenant isolation, or both.
* Your database, ORM, and deployment target, plus any restriction on native Node modules.
You'll leave with a recommended path and answers to whatever is blocking you.
# Get started
Source: https://cipherstash.com/docs/get-started
CipherStash encrypts your data at the field level, in your application, and keeps the ciphertext queryable in Postgres. The database never sees plaintext, and neither do we.
This section gets you from nothing to an encrypted, queryable field. It owns no mechanics: each page links to the reference that does.
Start here [#start-here]
* **[What is CipherStash?](https://cipherstash.com/docs/get-started/what-is-cipherstash)** is the mental model. What the pieces are, what the trade is, and which door to walk through.
* **[Quickstart](https://cipherstash.com/docs/get-started/quickstart)** is ten minutes of typing. Encrypt a field, store it, query it without decrypting it, and read it back. It works against any Postgres: Supabase, Neon, RDS, or a container.
* **[Choose your stack](https://cipherstash.com/docs/get-started/choose-your-stack)** picks your integration path: SDK or Proxy, your platform, your ORM, and your identity provider.
Then pick your path [#then-pick-your-path]
* **Adopting CipherStash into an existing app?** [Integrations](https://cipherstash.com/docs/integrations) covers the platforms, ORMs, frameworks, and auth providers that wrap your existing client, so your queries keep the shape they already have.
* **Can't change the application?** [CipherStash Proxy](https://cipherstash.com/docs/reference/proxy) sits in front of Postgres and encrypts on the wire.
* **Want to understand it before you install it?** [Searchable encryption](https://cipherstash.com/docs/concepts/searchable-encryption) explains how encrypted queries work and what each query capability enables.
* **Evaluating for a security review?** [Architecture & security](https://cipherstash.com/docs/security) is written to be read end to end, starting with [Cryptography](https://cipherstash.com/docs/security/cryptography).
# Quickstart
Source: https://cipherstash.com/docs/get-started/quickstart
CipherStash encrypts your data at the field level. Every value gets its own encryption key, and the database never sees plaintext. A breach, a compromised agent, or a curious insider sees ciphertext.
By the end of this page you will have encrypted a field, stored it in Postgres, queried it **without decrypting it**, and read it back. It takes about ten minutes and works with any Postgres: Supabase, Neon, RDS, or a Docker container.
Before you start [#before-you-start]
* Node.js 22 or later.
* A Postgres database you can connect to.
* A [CipherStash account](https://dashboard.cipherstash.com/sign-up). The free plan is enough.
Initialize your project [#initialize-your-project]
```bash cta cta-type="quickstart" example-id="quickstart-stash-init"
npx stash init
```
This opens a browser for device-based authentication, so local development needs no environment variables and no shared secrets. `init` then:
1. Connects to your workspace.
2. Resolves your database connection and runs `stash eql install`, which installs [EQL](https://cipherstash.com/docs/reference/eql) v3, the Postgres surface that makes encrypted columns queryable.
3. Installs `@cipherstash/stack` if it isn't already present.
4. Scaffolds an encryption module at `src/encryption/index.ts`.
5. Writes `.cipherstash/context.json` with what it detected about your project.
Integration-specific initialization flags include `--supabase`, `--drizzle`, and `--prisma`.
EQL v3 is the default, so `init` installs it directly against the database. Confirm what you ended up with:
```bash example-id="quickstart-eql-status"
npx stash eql status
```
This guide, and the rest of the EQL reference, targets EQL v3.
Define what to encrypt [#define-what-to-encrypt]
`init` scaffolds `src/encryption/index.ts`. It declares which columns are encrypted, and exports a ready-to-use client. Edit it to match your table:
```typescript filename="src/encryption/index.ts"
import { Encryption, encryptedTable, encryptedColumn } from "@cipherstash/stack"
export const users = encryptedTable("users", {
email: encryptedColumn("email").equality(),
})
export const encryptionClient = await Encryption({ schemas: [users] })
```
`.equality()` declares a **capability**: it is what makes `WHERE email = ?` work later. Add `.orderAndRange()` for `ORDER BY` and comparisons, or `.freeTextSearch()` for token containment. Declare only the capabilities you query on, because each one stores an extra index term alongside the ciphertext.
Prefer to have an agent do this? `npx stash plan` inspects your project and drafts `.cipherstash/plan.md` listing the columns worth encrypting. Review it, then `npx stash impl` applies it. This page does it by hand so you can see each moving part.
Create the encrypted column [#create-the-encrypted-column]
An encrypted column is typed with an EQL domain. The domain you pick has to match the capability you declared: `.equality()` on a text column means `public.eql_v3_text_eq`.
```sql filename="schema.sql"
CREATE TABLE users (
id BIGINT GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
email public.eql_v3_text_eq
);
```
The type is what fixes the column's searchable surface. There is no separate configuration table. See [core concepts](https://cipherstash.com/docs/reference/eql/core-concepts) for the full variant model.
Encrypt a value and store it [#encrypt-a-value-and-store-it]
```typescript filename="src/encrypt.ts"
import { encryptionClient, users } from "./encryption"
const encrypted = await encryptionClient.encrypt("alice@example.com", {
column: users.email,
table: users,
})
if (encrypted.failure) {
throw new Error(`Encryption failed: ${encrypted.failure.message}`)
}
await db.query("INSERT INTO users (email) VALUES ($1)", [encrypted.data])
```
Every operation returns a `Result`: either `data` or `failure`, never both. Encryption happens in your process, so the plaintext never leaves it.
Query without decrypting [#query-without-decrypting]
Encrypt the search term, then use it in an ordinary `WHERE` clause.
```typescript filename="src/query.ts"
import { encryptionClient, users } from "./encryption"
const term = await encryptionClient.encryptQuery("alice@example.com", {
column: users.email,
table: users,
})
if (term.failure) {
throw new Error(`Query encryption failed: ${term.failure.message}`)
}
const rows = await db.query(
"SELECT id, email FROM users WHERE email = $1::public.eql_v3_text_eq",
[term.data],
)
```
The cast matters. An encrypted operator only resolves against a **typed operand**, so `$1::public.eql_v3_text_eq` is what tells Postgres to compare encrypted terms rather than fall back to raw `jsonb` semantics. See [typed operands](https://cipherstash.com/docs/reference/eql/core-concepts).
Postgres compares ciphertext against ciphertext. It never sees either plaintext.
`LIKE` and `ILIKE` do not work on encrypted columns, in any variant. Free-text matching uses bloom-filter token containment (`@>`) on a `text_match` or `text_search` column instead. See [text](https://cipherstash.com/docs/reference/eql/text).
Decrypt [#decrypt]
```typescript filename="src/decrypt.ts"
const decrypted = await encryptionClient.decrypt(row.email)
if (decrypted.failure) {
throw new Error(`Decryption failed: ${decrypted.failure.message}`)
}
console.log(decrypted.data) // "alice@example.com"
```
`decrypt` takes the encrypted payload and nothing else. The payload carries the key ID it needs.
What you just built [#what-you-just-built]
You encrypted a field, stored it, queried it without decrypting, and read it back. Underneath:
* **ZeroKMS** returned a key seed, which your application processed with its client key to derive a **unique data key for that value**. The data key existed in your memory for one operation and was then discarded. See [cryptography](https://cipherstash.com/docs/security/cryptography).
* **Your client key** never left your infrastructure. Without it, nothing decrypts, including CipherStash.
* **Your keyset** is the isolation boundary. Data encrypted under one keyset cannot be decrypted with another, which is how you separate tenants or environments.
* **The index term** stored alongside the ciphertext is what let Postgres answer the query. Each capability you declare has a bounded, published leakage profile: an equality term lets an observer see which rows share a value, and nothing more. Declare only the capabilities you query on, so that what a column reveals stays within what your threat model already tolerates. See [searchable encryption](https://cipherstash.com/docs/concepts/searchable-encryption).
Next steps [#next-steps]
* **Using an ORM or Supabase?** The [Drizzle](https://cipherstash.com/docs/integrations/drizzle) and [Supabase](https://cipherstash.com/docs/integrations/supabase) integrations wrap your existing client so queries look normal.
* **No app changes possible?** [CipherStash Proxy](https://cipherstash.com/docs/reference/proxy) sits in front of Postgres and does this transparently.
* **Bind decryption to a user.** [Provable access control](https://cipherstash.com/docs/solutions/provable-access) ties a value to the identity that encrypted it.
* **Ready to deploy?** [Deployment](https://cipherstash.com/docs/guides/deployment) covers credential choices, environment promotion, and production rollout gates.
# What is CipherStash?
Source: https://cipherstash.com/docs/get-started/what-is-cipherstash
CipherStash encrypts individual fields in your application, before they reach the database, and keeps them queryable in Postgres. The database stores ciphertext and can still answer `WHERE`, `ORDER BY`, and containment queries against it.
A breach yields ciphertext. So does a compromised agent, an over-permissioned service, and a curious insider.
Why encrypting a column has meant losing the query [#why-encrypting-a-column-has-meant-losing-the-query]
Encrypting a column has always meant losing the query. So teams encrypt at rest, which protects the disk and nothing else: the moment a query runs, the database has plaintext, and so does anyone who reached the database.
That was tolerable when the thing reading your data was a person. It is less so now that it is an agent running on application credentials, at machine speed, one prompt injection away from exfiltration.
The mental model [#the-mental-model]
Three ideas carry the whole product.
**Encryption happens in your process.** Not in the database, not on our infrastructure. Plaintext never leaves your application.
**Every value gets its own key.** Not a table key or a column key. A per-value key, derived for one operation and discarded. Compromising one value tells an attacker nothing about the next.
**Ciphertext stays queryable.** Alongside each encrypted value, the client stores index terms that let Postgres compare ciphertext without decrypting it. Which terms a column carries is something you choose, and it decides what the database could infer: see [choosing what each column reveals](#choosing-what-each-column-reveals).
The pieces [#the-pieces]
```mermaid
flowchart TB
subgraph app["Your application"]
sdk["Stack SDK
encrypt / decrypt"]
end
subgraph db["Your Postgres"]
eql["EQL
encrypted column types
and operators"]
end
subgraph platform["CipherStash platform"]
zerokms["ZeroKMS
key seeds"]
cts["CTS
identity tokens"]
end
proxy["Proxy
speaks EQL for you"]
sdk -- ciphertext + index terms --> eql
proxy -- ciphertext + index terms --> eql
sdk <-- key seed --> zerokms
proxy <-- key seed --> zerokms
cts -. binds decryption
to an identity .-> sdk
```
| Piece | What it does | When you need it |
| ----------------------------- | ---------------------------------------------------------------------------- | ------------------------------------------------------------------- |
| [Stack SDK](https://cipherstash.com/docs/reference/stack) | Encrypts and decrypts values in your application | The default path. Start here. |
| [EQL](https://cipherstash.com/docs/reference/eql) | The Postgres surface: encrypted column types, operators, and term extractors | Always, if the data lives in Postgres. Installed once per database. |
| [Proxy](https://cipherstash.com/docs/reference/proxy) | Sits in front of Postgres and speaks EQL for you | When you cannot change the application |
| ZeroKMS | Returns a key seed per value; never sees your client key or a data key | Always. See [cryptography](https://cipherstash.com/docs/security/cryptography). |
| CTS | Federates your identity provider so decryption can be bound to a user | Only for [identity-aware encryption](https://cipherstash.com/docs/solutions/provable-access) |
You rarely need all of them at once. The Stack SDK plus EQL is the common case. Proxy is the alternative to the SDK, not an addition to it.
Note that **EQL is only for Postgres**. The SDK also encrypts values that never touch a database, and non-Postgres stores like [DynamoDB](https://cipherstash.com/docs/integrations/aws/dynamodb), with no EQL involved.
Choosing what each column reveals [#choosing-what-each-column-reveals]
Querying ciphertext works because each value carries index terms derived from its plaintext. Those terms are not the plaintext, and what each one reveals is **bounded and published** rather than incidental: each scheme has a formal leakage profile.
That turns leakage into a design choice rather than a surprise. You decide, per column, which capabilities to declare, and that decides what an observer of the database could infer:
| You declare | So you can | An observer could infer |
| ----------- | ------------------------------------ | ---------------------------- |
| Nothing | Store and decrypt | Nothing from the ciphertext |
| Equality | `WHERE email = ?`, `GROUP BY`, joins | Which rows share a value |
| Ordering | `ORDER BY`, ranges, `MIN` / `MAX` | The relative order of values |
| Free-text | Token containment | Probabilistic token overlap |
The engineering is in matching those choices to your threat model. For most columns, knowing that two rows share some unknown value is not an exposure. For a column whose frequency distribution is itself the secret, it might be, and then you encrypt without that capability and filter after decryption.
So the goal is not to eliminate leakage. It is to choose capabilities whose leakage your threat model already tolerates, and to know exactly what you chose. Declare only what you query on. The per-scheme detail is in [searchable encryption](https://cipherstash.com/docs/concepts/searchable-encryption).
Which door [#which-door]
**You are building.** Start with the [Quickstart](https://cipherstash.com/docs/get-started/quickstart), then [choose your stack](https://cipherstash.com/docs/get-started/choose-your-stack) to find the integration that matches your platform and ORM.
**You are evaluating.** [Architecture & security](https://cipherstash.com/docs/security) is self-contained for a vendor review, starting with [cryptography](https://cipherstash.com/docs/security/cryptography). [Solutions](https://cipherstash.com/docs/solutions) covers the problems teams bring us.
**You are deciding whether this is the right tool.** Start with [searchable encryption](https://cipherstash.com/docs/concepts/searchable-encryption) to understand how encrypted queries work. The [comparisons](https://cipherstash.com/docs/concepts/compare) are written to be honest about what CipherStash is not.
Performance [#performance]
Encryption in use is usually assumed to be slow. It is, if you do it with fully homomorphic encryption. Searchable encryption is a different trade: bounded, published leakage in exchange for the database doing ordinary index work on ciphertext.
| | |
| ------------------------------- | ------------------------------------------------------------------------------------------------------------------------ |
| Query overhead | Sub-millisecond. The encrypted operators inline into functional indexes, so Postgres does a normal index scan. |
| vs fully homomorphic encryption | [410,000x faster](https://github.com/cipherstash/tfhe-ore-bench) on the per-row primitives a database actually executes. |
| vs AWS KMS | Up to 14x the throughput, because ZeroKMS derives keys in bulk rather than one call per value. |
The FHE comparison is an open benchmark harness you can run yourself. See [CipherStash vs FHE](https://cipherstash.com/docs/concepts/compare/fhe) for the methodology, and for the workloads where FHE is genuinely the right tool.
What it protects against [#what-it-protects-against]
| Threat | What happens |
| ----------------------------------- | ----------------------------------------------------------------------------------------------------- |
| Database breach | Ciphertext. The keys were never in the database. |
| Compromised application credentials | Ciphertext, unless the attacker also holds the client key. |
| AI agent exfiltration | The agent reaches the database and decrypts nothing, because its credentials are not the user's keys. |
| Curious insider | Every decryption is a key derivation, and ZeroKMS records who performed it. |
What it does **not** protect against: an attacker who has compromised your running application process, holding the client key and able to call `decrypt`. Encryption in the application means the application can decrypt. See [cryptography](https://cipherstash.com/docs/security/cryptography) for the full trust model.
# Deployment
Source: https://cipherstash.com/docs/guides/deployment
CipherStash deployments coordinate application code, database schema, and credentials. Treat each independently deployable stage as a release with its own verification and rollback gate.
For the detailed dual-write, backfill, and cutover procedure for populated columns, follow [Data migration](https://cipherstash.com/docs/guides/migration). This page covers the production rollout around that migration.
Before the first deployment [#before-the-first-deployment]
* Create a separate CipherStash workspace or machine credential set for each environment.
* Store `CS_*` values in the environment's secret manager rather than copying a developer's local profile.
* Confirm the production database connection used by migrations and backfills.
* Test encryption, decryption, and the queries you rely on against a non-production database with the same EQL version.
* Inventory all application versions and background workers that may remain live during a rolling deployment.
* Decide who can approve backfill, read cutover, and plaintext removal.
Credentials at build and runtime [#credentials-at-build-and-runtime]
An encryption client constructed at module load may authenticate when a build tool imports that module. In that case, the four `CS_*` variables shown above must be available during both the build and runtime phases.
Do not let a local `stash auth login` session mask missing deployment credentials. Reproduce the production build in a clean environment that has only the secrets explicitly supplied by the deployment platform.
Backfills must use credentials for the same workspace and keyset as the deployed application. `CS_*` environment variables take precedence over a local CipherStash profile.
Environment order [#environment-order]
Promote each stage through environments in this order:
1. Local or ephemeral development database
2. Shared development or test
3. Staging with production-like data volume and connection behavior
4. Production
Run schema compatibility and application tests after each promotion. Do not use a successful local backfill as evidence that production credentials, row counts, locks, or query plans are safe.
Production rollout [#production-rollout]
| Stage | Change | Verification gate | Rollback |
| --------------------- | ----------------------------------------- | ------------------------------------------------------------ | ------------------------------ |
| Install EQL | Database-only, additive | EQL status and application connectivity | Leave installed |
| Add encrypted mirrors | Nullable columns plus dual-writes | Every writer populates both columns | Revert writers; keep columns |
| Backfill | Out-of-band data job | Zero uncovered rows and sampled decryptions match | Stop and resume later |
| Build indexes | Database-only | Expected indexes engage under `EXPLAIN` | Drop or rebuild the index |
| Cut reads over | Application-only | Known filters, ordering, nulls, and RLS behavior are correct | Revert reads to plaintext |
| Remove plaintext | Application and destructive schema change | Soak complete; no old application versions remain | Restore or migrate from backup |
Keep schema changes backward-compatible with both the old and new application version during rolling deployments. In particular, encrypted mirror columns must remain nullable until every historical row is covered.
Release gates [#release-gates]
Before backfill [#before-backfill]
* Dual-writes are deployed in every process that can mutate the table.
* Known inserts, updates, upserts, imports, and background jobs populate both columns.
* The backfill is using production's CipherStash credentials.
* The primary key and chunk size are suitable for paging through the table.
Before read cutover [#before-read-cutover]
* Coverage queries return zero missing encrypted values.
* Encrypted indexes have been created and verified using [EQL indexes](https://cipherstash.com/docs/reference/eql/indexes).
* Equality, range, ordering, null, and authorization tests pass against representative data.
* The old plaintext read path remains deployable as a rollback.
Before dropping plaintext [#before-dropping-plaintext]
* The encrypted read path has soaked under real traffic.
* No supported application version reads or writes the plaintext column.
* Coverage has been checked again.
* Required backups and restore procedures have been tested.
* The destructive migration has a named approver and maintenance window where required.
Monitor after cutover [#monitor-after-cutover]
Monitor ordinary database and application signals alongside encryption-specific failures:
* Encryption and decryption errors
* ZeroKMS request latency and availability
* Query latency, sequential scans, and index use
* Missing or unexpectedly null values
* Authorization and Row Level Security regressions
* Backfill progress, retry rate, and uncovered-row count
Test the correctness of returned values, not only request success rates. An incorrectly scoped filter or ordering query may return plausible but incomplete data without raising an error.
Rollback principles [#rollback-principles]
Prefer application rollbacks while both plaintext and encrypted columns are being maintained. Before plaintext removal, a read cutover can be reversed without changing data: point reads back to the original columns and leave dual-writes running.
After plaintext is dropped, rollback becomes a data-recovery operation. Avoid reaching that stage until operational evidence shows the encrypted path is stable and every supported application version has moved forward.
Serverless and bundled applications [#serverless-and-bundled-applications]
`@cipherstash/stack` must remain a runtime dependency when a build tool creates
a server bundle. Configure the bundler to leave the package external, then make
sure the deployment artifact installs it for the target platform.
For Next.js, use `serverExternalPackages`:
```typescript filename="next.config.ts"
const nextConfig = {
serverExternalPackages: ["@cipherstash/stack"],
}
export default nextConfig
```
For esbuild, pass `--external:@cipherstash/stack`; for webpack, declare it as a
CommonJS external. An SST function needs both the esbuild exclusion and a
runtime install:
```typescript filename="sst.config.ts"
{
nodejs: {
esbuild: { external: ["@cipherstash/stack"] },
install: ["@cipherstash/stack"],
},
}
```
Build and start the artifact in a Linux container before release when local
development uses macOS or Windows. This catches a lockfile or deployment bundle
that omitted the target platform's runtime package.
Testing and CI [#testing-and-ci]
Use a separate workspace and database for integration tests. Supply the test
workspace's four `CS_*` credentials only to the CI job, install the same EQL
release used by production, and test:
* encryption followed by decryption returns the original typed value;
* every required equality, range, ordering, token, or JSON query returns the
expected records;
* a client without the required keyset grant cannot decrypt the data;
* schema migrations and application code work in both rolling-deployment
orders.
Mocks are useful for business logic that merely passes encrypted values
through, but they do not test ciphertext compatibility, key access, query
terms, or EQL behavior. Keep at least one real end-to-end test for every
encrypted query capability used in production.
Team onboarding [#team-onboarding]
Invite each developer to the organization and workspace, then have them run:
```bash
npx stash init
```
Each device receives its own developer identity and client key. Do not share
production credentials with developers or copy one developer's local profile
into CI. Remove a departing developer from the workspace and revoke their
device client keys without changing application credentials.
See [workspace members](https://cipherstash.com/docs/reference/workspace/members) and
[client keys](https://cipherstash.com/docs/reference/auth/clients) for the complete access model.
Deploying Proxy [#deploying-proxy]
Run CipherStash Proxy as a container in the same private network as PostgreSQL.
Supply database credentials and CipherStash application credentials from the
platform's secret manager, expose the PostgreSQL listener only to application
clients, and expose health or metrics endpoints only to the monitoring plane.
For ECS, Kubernetes, or another orchestrator, keep these concerns separate:
1. Pull the published Proxy image from the approved registry.
2. Grant the task or pod permission to read only its deployment secrets.
3. Configure security groups or network policies for application → Proxy and
Proxy → database traffic.
4. Roll out at least two instances where connection availability requires it.
5. Verify a plaintext write, encrypted database value, encrypted query, and
decrypted read through the deployed endpoint.
Use the [Proxy configuration reference](https://cipherstash.com/docs/reference/proxy/configuration) for
environment variables, TOML settings, ports, logging, and metrics.
# Guides
Source: https://cipherstash.com/docs/guides
{/*
Fumadocs requires an index document when generating a metadata-backed folder.
meta.json excludes this file from the page tree, and Next redirects its route
to Deployment.
*/}
# Data migration
Source: https://cipherstash.com/docs/guides/migration
Encrypting a populated column is a staged application and database migration. Ciphertext must be produced in your application, so a database migration cannot convert existing plaintext by itself.
The safe pattern is to add an encrypted mirror column, dual-write new changes, backfill historical rows, and then move reads to the mirror. The plaintext column remains authoritative until the final cleanup, making every earlier stage reversible.
This guide uses `encryptedSupabase` for its examples. The same sequence applies when the application uses [Drizzle](https://cipherstash.com/docs/integrations/drizzle), [Prisma ORM 8](https://cipherstash.com/docs/integrations/prisma), or the [Stack SDK](https://cipherstash.com/docs/reference/stack): change the adapter-specific code, not the rollout order.
Migration sequence [#migration-sequence]
```text
DEPLOY 1 OUT OF BAND DEPLOY 2 DEPLOY 3
Add encrypted mirror Backfill existing rows Read encrypted mirror Drop plaintext
Begin dual-writes Verify coverage Keep dual-writes Stop dual-writes
Reads stay plaintext Build indexes Soak and verify
```
Do not start the backfill until dual-writes are running in every deployed writer. Otherwise, a row created after the backfill passes it can remain permanently uncovered.
Before you start [#before-you-start]
* Install EQL and configure your encryption client. For Supabase, complete the [Quickstart](https://cipherstash.com/docs/integrations/supabase/quickstart) against a development table first.
* Inventory every writer of the columns: services, jobs, Edge Functions, imports, seeds, RPC functions, webhooks, and administrative tools.
* Make the same CipherStash deployment credentials available to the application and backfill job; see [Credentials at build and runtime](https://cipherstash.com/docs/guides/deployment#credentials-at-build-and-runtime).
* Decide which encrypted capability each column needs by following [EQL core concepts](https://cipherstash.com/docs/reference/eql/core-concepts).
The examples migrate `patients.name` and `patients.date_of_birth`:
```sql
CREATE TABLE patients (
id bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
email text NOT NULL,
name text,
date_of_birth date,
plan text
);
```
Add nullable encrypted mirrors [#add-nullable-encrypted-mirrors]
Add one encrypted column beside each plaintext column:
```sql
ALTER TABLE patients
ADD COLUMN name_encrypted public.eql_v3_text_eq,
ADD COLUMN date_of_birth_encrypted public.eql_v3_date_ord;
```
The new columns must be nullable because existing rows do not have ciphertext yet. The `_encrypted` suffix is the convention used by `stash encrypt backfill`; use `--encrypted-column` if your names differ.
Ship this schema change together with the dual-write code in the next step. Do not rename or remove the plaintext columns.
Dual-write every mutation [#dual-write-every-mutation]
Update every insert, update, and upsert path to write the plaintext column and its encrypted mirror in the same statement:
```typescript title="lib/patients.ts"
import { db } from "./db"
export async function createPatient(input: {
email: string
name: string
dateOfBirth: string
plan: string
}) {
return db.from("patients").insert({
email: input.email,
name: input.name,
name_encrypted: input.name,
date_of_birth: input.dateOfBirth,
date_of_birth_encrypted: input.dateOfBirth,
plan: input.plan,
})
}
export async function updatePatientName(id: number, name: string) {
return db
.from("patients")
.update({ name, name_encrypted: name })
.eq("id", id)
}
```
The encrypted client encrypts the mirror values while passing the original values through unchanged. Keeping both values in one database statement prevents one half of the write from succeeding without the other.
Search the codebase for every writer before deploying. A missed importer, background job, conflict handler, or administrative path can create uncovered rows.
Deploy and verify dual-writes [#deploy-and-verify-dual-writes]
Deploy the schema and application changes to the environment that owns the database. The backfill is not safe while dual-writes exist only locally or in CI.
After the deployment, create and update known rows through each important write path. Confirm that both the plaintext and encrypted columns are populated, then inspect the migration state:
```bash
npx stash encrypt status
```
The application is now in a safe steady state: new writes are mirrored, old rows remain plaintext-only, and reads still use the original columns.
Backfill historical rows [#backfill-historical-rows]
Run one backfill per plaintext column:
```bash
npx stash encrypt backfill --table patients --column name
npx stash encrypt backfill --table patients --column date_of_birth
```
The command pages by primary key, encrypts rows in chunks, and records checkpoints. It is resumable and idempotent. For a non-interactive job, acknowledge the deployment gate with `--confirm-dual-writes-deployed`.
Run the backfill with the same CipherStash workspace and keyset as the deployed application. A local developer profile may point to a different workspace, producing values the production application cannot decrypt. Use the deployed environment's explicit `CS_*` values for the job.
Verify complete coverage [#verify-complete-coverage]
Check that every populated plaintext value has an encrypted mirror:
```sql
SELECT
count(*) FILTER (
WHERE name IS NOT NULL AND name_encrypted IS NULL
) AS name_uncovered,
count(*) FILTER (
WHERE date_of_birth IS NOT NULL
AND date_of_birth_encrypted IS NULL
) AS dob_uncovered
FROM patients;
```
Both counts must be zero. A non-zero result usually means a writer is not dual-writing. Fix and deploy that path, then run the backfill again before continuing.
Also sample known records through the encrypted application client and verify their decrypted values against the plaintext originals.
Build encrypted indexes [#build-encrypted-indexes]
Build the functional indexes required by the queries you will move to the encrypted columns. Do this after the bulk backfill and before changing reads.
Index definitions, supported query shapes, `EXPLAIN` verification, and guidance for large tables are maintained in [EQL indexes](https://cipherstash.com/docs/reference/eql/indexes). Use concurrent index creation where that guide recommends it for a live table.
Cut reads over [#cut-reads-over]
Deploy an application-only change that reads and filters on the encrypted mirror columns:
```typescript
const { data } = await db
.from("patients")
.select("id, email, name_encrypted, date_of_birth_encrypted")
.eq("name_encrypted", "Alice Chen")
.gt("date_of_birth_encrypted", "1980-01-01")
.order("date_of_birth_encrypted", { ascending: false })
```
Keep dual-writes enabled. If the new read path misbehaves, reverting this deployment restores plaintext reads while both sets of columns remain current.
Verify correctness rather than checking only for non-empty results. Test known equality matches, range boundaries, ordering, nulls, and authorization behavior.
Soak, then remove plaintext [#soak-then-remove-plaintext]
Let production traffic exercise the encrypted read path. Monitor query errors, latency, decryption failures, and uncovered-row counts for an appropriate period.
Once you no longer need a plaintext rollback, remove the dual-write code and generate the destructive migration:
```bash
npx stash encrypt drop --table patients --column name
```
Review and apply the generated migration through your normal deployment process. Repeat per column rather than combining unrelated migrations into one irreversible change.
Dropping the plaintext column is the first irreversible stage. Take any required backup, verify coverage again at apply time, and confirm that no old application version still reads or writes the column.
Rollback by stage [#rollback-by-stage]
| Current stage | Safe rollback |
| ------------------------------ | --------------------------------------------------------------------- |
| Mirrors added, before backfill | Revert application writes; leave or remove the empty mirrors |
| Backfill in progress | Stop it and resume later; keep plaintext reads and dual-writes |
| Reads cut over | Revert reads to plaintext; keep dual-writes |
| Plaintext dropped | Restore from an approved backup or perform a new decrypting migration |
For environment ordering, credential handling, release gates, and production monitoring, continue with the [deployment guide](https://cipherstash.com/docs/guides/deployment).
# Integrations
Source: https://cipherstash.com/docs/integrations
Every integration below writes the same ciphertext into the same [EQL](https://cipherstash.com/docs/reference/eql) columns, so none of them is a one-way door. You can move a table from one to another without re-encrypting it, and use more than one at once — an ORM for application queries, raw SQL for migrations.
Database [#database]
Where the encrypted data lives. EQL installs into any Postgres you can connect to, with no extension and no superuser.
Install EQL with the `stash` CLI, then query encrypted columns through PostgREST. Row Level Security, Supabase Auth, and Edge Functions all apply unchanged.
Prisma's managed Postgres, with EQL installed through the Prisma ORM 8 migration graph.
ORM [#orm]
How your application queries it.
`encryptedSupabase` wraps your existing client so `.eq()`, `.in()`, `.gt()`, and `.order()` keep working on encrypted columns.
Encrypted EQL v3 columns declared in `schema.prisma`, with typed encrypted query operators.
Concrete encrypted column types and capability-checked operators. Targets EQL v3.
Not on this list? Any ORM works without an integration — encrypt before a write and decrypt after a read with the [Stack SDK](https://cipherstash.com/docs/reference/stack), which is what the integrations do for you. [CipherStash Proxy](https://cipherstash.com/docs/reference/proxy) covers the case where you cannot change the application at all, and the SDK also encrypts values that never reach Postgres, including non-Postgres stores like [DynamoDB](https://cipherstash.com/docs/integrations/aws/dynamodb).
Still deciding [#still-deciding]
[Choose your stack](https://cipherstash.com/docs/get-started/choose-your-stack) walks the four decisions in order: SDK or Proxy, your Postgres, your ORM, and your identity provider — including which identity providers can bind decryption to the signed-in user.
# Agent skills
Source: https://cipherstash.com/docs/reference/agent-skills
CipherStash Stack 1.0 publishes 13 [agent skills](https://skills.sh/) covering the stable SDK, CLI, database surfaces, deployment workflow, and integrations. The skills give an AI coding assistant the exact APIs, commands, constraints, and rollout sequence it needs without making your application code part of the prompt.
Skills work with AI coding tools that support the skills protocol, including Claude Code, Codex, Cursor, GitHub Copilot, Windsurf, Cline, Gemini, AMP, Goose, Roo, and Trae.
Install every skill [#install-every-skill]
Install the complete collection in your project root:
```bash cta cta-type="install" example-id="install-agent-skills"
npx skills add cipherstash/stack
```
This installs all 13 skills. Your agent activates the relevant ones from the task and code it is working on.
Install through the Stash workflow [#install-through-the-stash-workflow]
The `stash` 1.0 CLI bundles the skills and selects a smaller set for the integration detected by `stash init`. When `stash impl` hands the reviewed plan to an agent, it copies the selected skills into the tool's skill directory or includes their guidance in the generated agent instructions.
| Integration | Skills selected |
| ------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------ |
| Drizzle | `stash-encryption`, `stash-drizzle`, `stash-indexing`, `stash-deployment`, `stash-zerokms`, `stash-auth`, `stash-cli` |
| Supabase | `stash-encryption`, `stash-supabase`, `stash-indexing`, `stash-postgres`, `stash-edge`, `stash-deployment`, `stash-zerokms`, `stash-auth`, `stash-cli` |
| Prisma ORM 8 | `stash-encryption`, `stash-prisma`, `stash-indexing`, `stash-deployment`, `stash-zerokms`, `stash-auth`, `stash-cli` |
| PostgreSQL | `stash-encryption`, `stash-indexing`, `stash-postgres`, `stash-edge`, `stash-deployment`, `stash-zerokms`, `stash-auth`, `stash-cli` |
Claude Code receives skills under `.claude/skills/`; Codex receives them under `.codex/skills/`. Handoffs to tools that do not load a skill directory receive the same guidance through the generated agent instructions.
Available skills [#available-skills]
| Skill | What it covers |
| ----------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `stash-encryption` | The stable `@cipherstash/stack` EQL v3 typed schema, `EncryptionClient`, encryption and model operations, searchable fields, encrypted JSON, bulk operations, and migration lifecycle. |
| `stash-auth` | Credentials, `AutoStrategy`, `AccessKeyStrategy`, `OidcFederationStrategy`, `DeviceSessionStrategy`, the four `CS_*` variables, lock contexts, and authentication failures. |
| `stash-zerokms` | Keysets, clients, client keys, grants, revocation, key hierarchy, multi-tenant isolation, and diagnosing keyset mismatches. |
| `stash-indexing` | Functional indexes over EQL v3 term extractors, managed-Postgres constraints, `ORDER BY` and `GROUP BY` shapes, and `EXPLAIN` verification. |
| `stash-deployment` | The safe multi-deploy encryption rollout, credentials, backfill, read cutover, rollback, Prisma Compute, and preview environments. |
| `stash-cli` | `init`, `plan`, `impl`, `status`, authentication, `eql install/migration/repair/upgrade/status`, validation, backfill, drop, schema generation, and the agent interface. |
| `stash-drizzle` | `@cipherstash/stack-drizzle` 1.0 column factories, schema extraction, indexes, EQL v3 migration generation, and encrypted query operators such as `eq`, `matches`, `contains`, and `selector`. |
| `stash-supabase` | The `encryptedSupabase` wrapper, encrypted mutations and reads, filters and ordering, identity-aware encryption, and PostgREST limitations. |
| `stash-prisma` | `@cipherstash/stack-prisma` 1.0, encrypted Prisma column types, runtime envelopes, `decryptAll`, `eql*` query operators, and Prisma-owned EQL migrations. |
| `stash-postgres` | Hand-written EQL v3 SQL with `pg` or `postgres`, typed bind parameters, operator selection, `encryptQuery`, and double-encoding failures. |
| `stash-edge` | The `@cipherstash/stack/wasm-inline` entry for Deno, Supabase Edge Functions, Cloudflare Workers, and Bun, including explicit credentials and WASM-specific client behavior. |
| `stash-dynamodb` | The `@cipherstash/stack/dynamodb` surface, encrypted attributes, HMAC query attributes, nested values, bulk operations, and DynamoDB table design. |
| `stash-supply-chain-security` | Dependency admission, install cooldowns, lockfile integrity, frozen CI installs, registry pinning, Dependabot, `CODEOWNERS`, and npm provenance. |
How skills work [#how-skills-work]
An installed skill activates when the task matches its description. Integration skills link back to the cross-cutting skills instead of duplicating their rules: authentication questions route to `stash-auth`, index design to `stash-indexing`, production rollout to `stash-deployment`, and key access to `stash-zerokms`.
That separation keeps the guidance consistent. A Drizzle, Supabase, Prisma, or raw PostgreSQL task uses the same released encryption model and deployment safety rules while adding only the query and schema behavior specific to that integration.
Typical workflow [#typical-workflow]
1. **Initialize the project.** Run `npx stash init` with `--drizzle`, `--supabase`, or `--prisma` when appropriate. The CLI authenticates, inspects the project, installs compatible packages, and records context under `.cipherstash/`.
2. **Draft a plan.** Run `npx stash plan`. The selected skills help the agent produce a reviewable `.cipherstash/plan.md` without changing the application.
3. **Review the plan.** Confirm the selected columns, capabilities, indexes, migration sequence, and deployment gates.
4. **Implement it.** Run `npx stash impl`. The CLI hands the plan and integration-specific skill set to your chosen agent.
5. **Track the rollout.** Run `npx stash status` as schema changes, dual writes, backfill, read cutover, and plaintext removal progress.
Requirements for installing agent skills [#requirements-for-installing-agent-skills]
* Node.js 22 or later
* An AI coding tool that supports skills or generated agent instructions
* A CipherStash account ([sign up](https://dashboard.cipherstash.com/sign-up))
# Benchmarks
Source: https://cipherstash.com/docs/reference/benchmarks
CipherStash encrypts data in your application and queries it in PostgreSQL through [EQL](https://cipherstash.com/docs/reference/eql). These benchmarks measure what that costs: the same query shapes run against encrypted columns and against plaintext tables with equivalent indexes, so every figure is an honest encrypted-versus-plaintext ratio rather than a number in isolation.
All results are medians on **Apple M1 Max, PostgreSQL 17, EQL v3**, across datasets from 10,000 to 10,000,000 rows. The full suite (per-scenario SQL, `EXPLAIN` plans, charts, and the v2-to-v3 regression comparison) lives in [cipherstash/benches](https://github.com/cipherstash/benches).
On the fast paths, querying encrypted data costs almost nothing. Exact match and OPE range queries run at about **0.12 ms, within 1.2-1.4x of plaintext PostgreSQL, and stay flat from 10k to 10M rows**. Latency tracks the index, not the row count.
Query latency [#query-latency]
Median latency at 1,000,000 rows, with the ratio to the same query on a plaintext table with an equivalent index.
| Operation | EQL index | Encrypted median | vs plaintext |
| ---------------------------- | ----------------------- | ---------------- | ------------ |
| Exact match (`=`) | B-tree (equality term) | 0.12 ms | 1.3x |
| Range / `ORDER BY` (OPE) | B-tree (OPE order term) | 0.12 ms | 1.2x |
| Range / `ORDER BY` (ORE) | B-tree (ORE order term) | 0.52 ms | 5.2x |
| JSON containment (`@>`) | GIN (SteVec) | 0.40 ms | 1.4x |
| `GROUP BY` (low cardinality) | B-tree (equality term) | 83 ms | 2.2x |
**Range and ordering have two index options.** The `_ord` variants use order-preserving encryption (OPE), which is EQL v3's default: near-plaintext latency, and an index that builds in about 1 s at 1M rows. The `_ord_ore` variants use order-revealing encryption (ORE): roughly 5x plaintext, and the index takes about 44 s to build at 1M. They have different leakage profiles, so the right choice is per column rather than universal, see [Searchable encryption](https://cipherstash.com/docs/concepts/searchable-encryption) for the tradeoff and [Numbers](https://cipherstash.com/docs/reference/eql/numbers) for the variants.
**Free-text match** uses a bloom-filter term (there is no `LIKE` on encrypted text) and runs at about 15.7 ms at 1M rows. What matters most is that the index engages at all: the bloom GIN is **100-400x faster than a sequential scan**. See [Text](https://cipherstash.com/docs/reference/eql/text).
Scaling [#scaling]
Latency on an indexed encrypted column tracks the index, not the table, so the encrypted-versus-plaintext ratio barely moves as the dataset grows 1000x:
| Operation | 10k | 100k | 1M | 10M |
| ----------------- | -------------- | -------------- | -------------- | -------------- |
| Exact match (`=`) | 0.13 ms (1.4x) | 0.11 ms (1.2x) | 0.12 ms (1.3x) | 0.13 ms (1.4x) |
| Range (OPE) | 0.12 ms (1.2x) | 0.12 ms (1.2x) | 0.12 ms (1.2x) | 0.12 ms (1.2x) |
Aggregations that scan every matched row, like `GROUP BY`, grow with the number of rows in the group exactly as they do on plaintext: about 2x plaintext throughout (2.1 ms at 10k, 83 ms at 1M).
Ingest [#ingest]
Encryption happens in your application on write, so insert throughput reflects client-side work rather than database load. On the reference machine, encrypted insert throughput ranges from about **11k rows/s** for exact-match and OPE columns down to about **1.3k rows/s** for the free-text `text_search` domain, which generates a bloom and an order term per value. Batching and parallel writers scale this well past the single-threaded figures here. The per-domain breakdown is in the [ingest report](https://github.com/cipherstash/benches/blob/main/report/BENCHMARK_REPORT.md).
Methodology [#methodology]
* **Environment:** Apple M1 Max, PostgreSQL 17, EQL v3. Datasets of 10k, 100k, 1M, and 10M rows.
* **Baseline:** every encrypted scenario is compared to the same query shape on a plaintext table with an equivalent index (`benches/plaintext_v3.rs`). Ratios are encrypted median divided by plaintext median.
* **Indexes:** queries use functional indexes over EQL's extractor terms, exactly as documented in [Indexes](https://cipherstash.com/docs/reference/eql/indexes). A query that cannot use its index falls back to a sequential scan, as it would on plaintext.
* **Caveats:** medians are single-machine and single-connection, so absolute numbers on your hardware and under concurrency will differ. One outlier is called out in the report: JSON `contains` at 10M rows uses a query recipe that materializes the full GIN bitmap before `LIMIT` (a documented plan artifact, not the operator's real cost).
Reproduce [#reproduce]
```bash
git clone https://github.com/cipherstash/benches
cd benches
mise run setup-db-v3
mise run bench:v3:query:all 1000000
mise run report:v3-compare
```
Related [#related]
The leakage model behind each index type: what exact, range, and match terms reveal.
The functional-index recipes these numbers depend on, and what it takes for an index to engage.
# Glossary
Source: https://cipherstash.com/docs/reference/glossary
A [#a]
ABAC (Attribute Based Access Control) [#abac-attribute-based-access-control]
A dynamic security model that makes access decisions based on a variety of attributes, including user characteristics, resource details, and environmental factors. Unlike [RBAC](#rbac-role-based-access-control), which relies solely on a user's assigned role, ABAC offers more granular and context-aware policies that adapt to changing conditions.
Access key [#access-key]
A persistent authentication credential used for communication with [ZeroKMS](#zerokms) or [CTS](#cts-cipherstash-token-service). See [access keys](https://cipherstash.com/docs/reference/auth/access-keys).
Account management [#account-management]
Activities to administer your CipherStash account, such as billing and adding or removing users. See [billing](https://cipherstash.com/docs/reference/workspace/billing) and [members](https://cipherstash.com/docs/reference/workspace/members).
C [#c]
Ciphertext [#ciphertext]
An encrypted version of plaintext, produced by applying an encryption algorithm (a cipher). It is unreadable without a cipher to decrypt it.
See also: [plaintext](#plaintext).
CipherStash CLI [#cipherstash-cli]
The command line tool (`stash`) for interacting with CipherStash services. See the [CLI reference](https://cipherstash.com/docs/reference/cli).
CipherStash Proxy [#cipherstash-proxy]
A database proxy that sits between an application and a database, adding encryption in use. Proxy works alongside your existing infrastructure and is fully contained within your environment. See the [Proxy reference](https://cipherstash.com/docs/reference/proxy).
Client key [#client-key]
The cryptographic credential assigned to a programmatic access point for a [keyset](#keyset). A client key can have access to many keysets, and a keyset can be shared by multiple client keys.
There are two types:
* **Device-backed client keys** are created automatically by `stash init` and tied to a developer's [device](#device). Used for local development.
* **Application client keys** are created in the Dashboard for production and CI/CD. Identified by a [client ID](#client-id) and client key value, set via environment variables.
See [client keys](https://cipherstash.com/docs/reference/auth/clients).
Client ID [#client-id]
A unique identifier for a [client key](#client-key). Each client key and client ID is unique to your app.
Client key value [#client-key-value]
The secret credential set via `CS_CLIENT_KEY`. Together with the [client ID](#client-id), it forms the credential pair for a [client key](#client-key). The client key value is sensitive and must be kept secret.
CTS (CipherStash Token Service) [#cts-cipherstash-token-service]
CTS manages the trust relationships between a workspace and third-party or customer identity providers. It brokers secure access to CipherStash services such as ZeroKMS, ensuring that only authenticated and authorized users gain entry. See [CTS](https://cipherstash.com/docs/concepts/auth).
D [#d]
Dashboard [#dashboard]
The web interface for managing CipherStash Cloud primitives: workspaces, client keys, keysets, access keys, devices, and members. Available at [dashboard.cipherstash.com](https://dashboard.cipherstash.com/).
The Dashboard manages cloud infrastructure. Product-specific configuration (encryption schemas, secrets, proxy rules) is handled by the SDKs and CLI.
Data access event [#data-access-event]
An event triggered by execution of SQL statements by CipherStash Proxy. Includes metadata of statements executed and records accessed.
Device [#device]
A unique identity tied to a developer's device and user account, created by `stash init`. Each device has an associated [client key](#client-key) that is automatically granted access to the default [keyset](#keyset).
Devices are used for local development authentication, with no environment variables required. Production environments use application [client keys](#client-key) instead. See the [quickstart](https://cipherstash.com/docs/get-started/quickstart).
E [#e]
EQL (Encrypt Query Language) [#eql-encrypt-query-language]
Our [open-source library](https://github.com/cipherstash/encrypt-query-language) for PostgreSQL users. EQL provides the database-side surface for querying encrypted data: encrypted column types, the operators that compare them, and the term-extractor functions that make indexes work. EQL itself never encrypts anything. See the [EQL reference](https://cipherstash.com/docs/reference/eql).
H [#h]
HMAC (Hash-based Message Authentication Code) [#hmac-hash-based-message-authentication-code]
A cryptographic technique that combines a hash function with a secret key to verify both the integrity and authenticity of a message. Unlike raw hash functions such as SHA-256, HMAC requires a secret key, so only parties with the key can generate valid HMACs. This prevents attackers from pre-computing hash tables (rainbow tables) or guessing values.
In searchable encryption, HMACs create encrypted search tokens. The key stays on the application side, so the server can match encrypted search tokens without ever learning the plaintext or being able to generate new tokens. See [searchable encryption](https://cipherstash.com/docs/concepts/searchable-encryption) for what an HMAC term does and does not reveal.
I [#i]
IdP (Identity Provider) [#idp-identity-provider]
A third-party identity provider, such as Auth0, Okta, or Clerk.
J [#j]
JWT (JSON Web Token) [#jwt-json-web-token]
A compact, URL-safe means of representing claims between two parties as a JSON object, typically used for authentication and authorization. JWTs are digitally signed to ensure the integrity and authenticity of the information, allowing systems to verify user identity without maintaining server-side sessions.
K [#k]
Keyset [#keyset]
A core CipherStash Cloud primitive for cryptographic isolation, managed by [ZeroKMS](#zerokms). Each keyset maintains its own set of data encryption keys, and data encrypted under one keyset cannot be decrypted with another.
Use keysets for tenant isolation, environment separation, regional compliance, or any cryptographic boundary your architecture requires. A [client key](#client-key) can access many keysets, and a keyset can be shared by multiple client keys. In the Secrets SDK, environments map directly to keysets.
See [key management](https://cipherstash.com/docs/concepts/key-management#keysets-define-the-isolation-boundary).
O [#o]
OIDC (OpenID Connect) [#oidc-openid-connect]
An identity layer built on top of the OAuth 2.0 protocol that enables applications to verify user identity through an [identity provider](#idp-identity-provider). It facilitates secure single sign-on and standardizes how the identity provider shares identity information, using RESTful APIs and [JSON Web Tokens](#jwt-json-web-token).
ORE (Order Revealing Encryption) [#ore-order-revealing-encryption]
A searchable encryption technique allowing comparison and sorting of encrypted data without decryption. ORE terms reveal the relative order of the values they encode. See [sorting](https://cipherstash.com/docs/reference/eql/sorting) and [searchable encryption](https://cipherstash.com/docs/concepts/searchable-encryption).
P [#p]
Plaintext [#plaintext]
Unencrypted information, readable by humans and computers.
R [#r]
RBAC (Role Based Access Control) [#rbac-role-based-access-control]
A security model that assigns access permissions based on a user's role within an organization, streamlining the management of access rights by grouping permissions into predefined roles. Unlike [ABAC](#abac-attribute-based-access-control), which evaluates policies based on a range of attributes, RBAC relies solely on roles.
S [#s]
Searchable encrypted metadata [#searchable-encrypted-metadata]
An encrypted data structure for finding records in encrypted columns, carried in the value's payload alongside the ciphertext. It replaces the need for full table scans, and supports range, exact, and match queries.
See [core concepts](https://cipherstash.com/docs/reference/eql/core-concepts) for payload anatomy, and [searchable encryption](https://cipherstash.com/docs/concepts/searchable-encryption) for what each index term reveals.
W [#w]
Workspace [#workspace]
A workspace contains [keysets](#keyset), client keys, and configuration. A workspace can separate environments (such as dev and prod), be shared with other users, and be associated with a custom identity provider.
See [workspace and account](https://cipherstash.com/docs/reference/workspace).
Z [#z]
ZeroKMS [#zerokms]
CipherStash's key management service. ZeroKMS provides high-performance batch encryption and decryption, enabling a unique encryption key per field. See [key management](https://cipherstash.com/docs/concepts/key-management).
# Reference
Source: https://cipherstash.com/docs/reference
{/*
Fumadocs requires an index document when generating a metadata-backed folder.
meta.json excludes this file from the page tree, and Next redirects its route
to the first visible Reference page.
*/}
# Access analytics
Source: https://cipherstash.com/docs/concepts/access-analytics
CipherStash Proxy can produce data-access events without requiring application
queries to be instrumented. Its audit pipeline identifies the query pattern,
removes literal values, determines which records were accessed, and associates
the event with the authenticated client or identity context.
This page describes what Proxy contributes to an event. Retention, export, and
SIEM integration depend on the audit service and deployment configuration.
Statement fingerprinting [#statement-fingerprinting]
Proxy fingerprints the parsed SQL statement so semantically equivalent query
shapes can be grouped across parameter values and environments. The fingerprint
identifies a query pattern without using the literal values supplied by the
application.
SQL redaction [#sql-redaction]
Literal values are stripped before SQL is included in an event. Table, column,
and function names remain so the event is useful for investigation. If Proxy
cannot safely parse and redact a statement, it does not transmit the statement
text.
Parameterized queries sent through PostgreSQL's extended protocol already
keep bound values separate from the SQL text; redaction also covers literals
embedded directly in a statement.
Record identification [#record-identification]
Proxy can add missing primary-key columns to an internal form of the query,
then reconcile returned identifiers with their source tables. Injected columns
are removed before the result is returned to the application, so the result
shape remains unchanged.
Event pipeline [#event-pipeline]
1. **Fingerprint** the parsed query shape.
2. **Redact** static values from the SQL representation.
3. **Identify** primary keys for records touched by the query.
4. **Reconcile** identifiers with tables and remove injected fields from the
application result.
5. **Attribute** the event to the client and, when OIDC federation is used, the
authenticated identity.
For cryptographic identity binding and SDK audit metadata, see
[provable access control](https://cipherstash.com/docs/solutions/provable-access#audit-logging). For Proxy
operation and configuration, see the [Proxy reference](https://cipherstash.com/docs/reference/proxy).
# CipherStash Token Service
Source: https://cipherstash.com/docs/concepts/auth
CipherStash Token Service (CTS) is the authentication and identity-federation
layer in front of ZeroKMS. It converts a persistent application credential or
a trusted identity-provider token into a short-lived token scoped to
cryptographic service access.
CTS plays a role similar to AWS STS: the long-lived credential proves who the
caller is, while the issued token is temporary and is what the caller presents
to ZeroKMS.
Request flow [#request-flow]
```mermaid
sequenceDiagram
participant App as Stack SDK or Proxy
participant IdP as Identity provider
participant CTS
participant ZK as ZeroKMS
alt Application authentication
App->>CTS: Client ID + access key
else End-user federation
App->>IdP: Obtain user JWT
IdP-->>App: Signed JWT
App->>CTS: Federate JWT
end
CTS-->>App: Short-lived CTS token
App->>ZK: Key-seed request + CTS token
ZK-->>App: Key seed
```
The Stack SDK refreshes service tokens as required. Application code normally
selects an auth strategy rather than calling CTS directly.
Authentication modes [#authentication-modes]
Application credentials [#application-credentials]
A production service or Proxy instance uses a
[client key](https://cipherstash.com/docs/reference/auth/clients) and
[access key](https://cipherstash.com/docs/reference/auth/access-keys). This authenticates the workload as
an application rather than as a particular end user.
OIDC federation [#oidc-federation]
Register a trusted issuer and use `OidcFederationStrategy` when each request
should carry the signed-in user's identity. CTS validates the provider JWT and
issues the temporary service token. See
[OIDC providers](https://cipherstash.com/docs/reference/auth/oidc-configuration).
Federated identity can also be used with a lock context so key derivation
depends on a JWT claim. That cryptographic binding is described in
[provable access control](https://cipherstash.com/docs/solutions/provable-access).
# Concepts
Source: https://cipherstash.com/docs/concepts
{/*
Fumadocs requires an index document when generating a metadata-backed folder.
meta.json excludes this file from the page tree, and Next redirects its route
to the first visible Concepts page.
*/}
# Key management
Source: https://cipherstash.com/docs/concepts/key-management
Encryption is only as strong as the system that controls its keys. If an application keeps one long-lived key beside the data it protects, encrypting the database changes its appearance without meaningfully changing who can unlock it.
ZeroKMS takes a different approach. Every encrypted value gets a unique data key. No data key is stored, transmitted, or reused, and neither CipherStash nor your application holds enough long-lived material to derive one alone.
This gives CipherStash three properties that are difficult to combine with conventional key management:
* **Fine-grained protection:** compromising one derived data key exposes one value, not a table or batch.
* **Split control:** CipherStash holds one side of the key relationship and your application holds the other. Neither side is sufficient by itself.
* **Production performance:** bulk operations derive unique keys locally after one ZeroKMS interaction instead of making one network request per value.
The problem with conventional envelope encryption [#the-problem-with-conventional-envelope-encryption]
Cloud key-management services commonly use envelope encryption. The KMS generates a data encryption key, returns the plaintext key to the application, and returns a second copy wrapped by a root key. The application encrypts the data, discards the plaintext key, and stores the wrapped key beside the ciphertext.
On read, the application sends the wrapped key back to the KMS and receives the plaintext data key again.
That works well for individual objects. It becomes difficult at database scale. A result containing 100 rows with two independently encrypted fields needs 200 data keys. Using one unique key per value means hundreds of KMS requests; reusing and caching a key makes the application faster but expands the amount of data that key can decrypt.
Caching also weakens observability. Once one cached key unlocks thousands of values, the key service can record that the key was used but cannot tell which individual value the application accessed.
The usual design therefore trades among:
* how much data one key can decrypt;
* how many network calls an operation can tolerate; and
* how precisely key use can be audited.
ZeroKMS is designed to remove that tradeoff.
The ZeroKMS mental model [#the-zerokms-mental-model]
A usable data key is never handed from one system to another. It comes into existence only inside your application, when material from ZeroKMS is processed with material that never leaves your environment.
Four pieces have distinct jobs:
| Material | Where it exists | What it can do alone |
| ----------------- | ----------------------------------------------------------- | -------------------------------------------------------------------------- |
| **Authority key** | ZeroKMS, encrypted at rest under an AWS KMS root key | Produce a key seed; it cannot derive your data keys without the client key |
| **Client key** | Your application environment | Process a key seed; it cannot derive a data key without ZeroKMS |
| **Key seed** | Returned by ZeroKMS for a key ID and held for the operation | Nothing useful without the client key |
| **Data key** | Your application's memory for one operation | Encrypt or decrypt one value; then it is discarded |
The authority key and client key form a split. They are never brought together. ZeroKMS never receives the client key, and your application never receives the authority key.
```mermaid
flowchart LR
keyid["Key ID"] --> zerokms["ZeroKMS
authority key"]
zerokms --> seed["Key seed"]
subgraph app["Your application"]
client["Client key
never leaves"]
combine["Process seed + derive"]
datakey["Unique data key
one value, one operation"]
value["Encrypt or decrypt value"]
discard["Discard data key"]
client --> combine
combine --> datakey --> value --> discard
end
seed --> combine
```
CipherStash uses proxy symmetric re-encryption to produce the seed on the ZeroKMS side. The application then processes that seed with its client key and uses an HMAC-based key derivation function to produce the data key. [Cryptography](https://cipherstash.com/docs/security/cryptography) is the canonical technical description of both layers.
A unique key for every value [#a-unique-key-for-every-value]
Each encrypted value carries a key ID. That ID is not secret and is not key material; it tells ZeroKMS which reproducible seed the client needs for that value.
Encrypt [#encrypt]
1. The client creates a new key ID.
2. ZeroKMS authorizes the request and produces the corresponding key seed.
3. The application processes the seed with its client key and derives a unique data key.
4. The data key encrypts one value, then is discarded.
5. The key ID travels with the ciphertext. The data key does not.
Decrypt [#decrypt]
1. The client reads the key ID from the encrypted payload.
2. ZeroKMS authorizes a request for that ID and reproduces the same seed.
3. The application processes it with the client key and derives the same data key.
4. The value is decrypted and the data key is discarded again.
There is no database of per-value data keys to protect or restore. The persistent state is the much smaller authority/client relationship from which a data key can be reproduced only when both sides participate.
Why split control changes application compromise [#why-split-control-changes-application-compromise]
A compromised application is serious, but it is not equivalent to losing a permanent master key.
**The client key is insufficient on its own.** Stealing it does not let an attacker derive historical data keys offline. The encrypted payload contains a key ID, not a seed or wrapped data key. ZeroKMS must still authorize and participate in each derivation.
**There is no cache of reusable data keys to steal.** A data key exists only while one value is being processed. Capturing it does not unlock the next row.
**Access has a server-side off switch.** Revoking a client's access key or its grant to a keyset prevents future seed requests. Because the decision is made during derivation, revocation does not depend on a compromised process voluntarily honoring a new policy.
**The blast radius is scoped.** A client can derive keys only for the keysets it has been granted. Separate keysets create cryptographic boundaries between tenants, environments, regions, or workloads.
**Identity can narrow it further.** A lock context can bind derivation to a claim from an authenticated end user. Possessing the service's client key is then not enough to decrypt a value locked to a different identity. See [Provable access control](https://cipherstash.com/docs/solutions/provable-access).
**Derivation is observed outside the application.** ZeroKMS records the operation before returning the material required for decryption. An attacker operating only inside the application cannot edit or suppress that service-side record in the way they could alter application logs.
An attacker controlling a live, authorized process may still request the operations available to that process while access remains valid. The important difference is that the capability is **scoped, observable, and revocable**—not a reusable master key that can be copied once and used forever offline.
Keysets define the isolation boundary [#keysets-define-the-isolation-boundary]
A keyset is an independent authority-key scope. The same key ID under two keysets produces unrelated data keys, so ciphertext created under one keyset cannot be decrypted through another.
Common boundaries include:
* one keyset per customer in a multi-tenant application;
* separate keysets for development, staging, and production;
* regional keysets for data-residency requirements; and
* separate keysets for business units or workloads with different operators.
Client access is granted per keyset. Revoking that grant stops the client from deriving any more keys in that boundary without changing database permissions or rewriting the ciphertext.
Keyset design also controls intentional correlation. Encrypted equality and joins work only across compatible values under the same cryptographic scope; separating keysets prevents both decryption and cross-boundary encrypted comparison.
The default workspace keyset is sufficient for many applications. Add more when your security boundary is narrower than the workspace.
Bulk performance without data-key caching [#bulk-performance-without-data-key-caching]
The data-key-per-value model would be impractical if every value needed an independent network and HSM round trip.
ZeroKMS batches the server-side work. A bulk operation can obtain the seed material it needs in one interaction, then derive each value's unique data key locally. Increasing a batch from ten values to a thousand increases local cryptographic work, but does not turn into a thousand sequential requests to the key service.
This is why the Stack SDK's bulk operations are both the performance path and the strongest key-granularity path. They do not improve throughput by reusing a data key.
No **data key** is cached. CipherStash Proxy does cache bounded, keyset-scoped cipher objects so it does not reinitialize them for every statement. Those objects still require the client side of the split, and every value still receives its own derived data key. See [what is cached](https://cipherstash.com/docs/security/cryptography#what-is-cached-and-what-is-not).
Authorization and audit are part of derivation [#authorization-and-audit-are-part-of-derivation]
With a policy check in application code, authorization happens first and decryption happens later. A bug or compromised process can create a gap between the decision and the use of the key.
ZeroKMS evaluates authorization while producing the key seed. The authorization decision and the cryptographic operation are therefore part of the same event: if ZeroKMS does not authorize the request, the application does not receive the material required to derive the data key.
That event also creates an independent audit record. Depending on how the client authenticated, it can identify the service or federated end user, the keyset, the operation, and the time. Lock contexts add the identity claim bound to the value.
This is more useful than a log that says a SQL query ran. It records the operation that made plaintext recovery possible, at the system that had to participate in it.
What is stored [#what-is-stored]
The design deliberately keeps the durable pieces small and separated:
| Location | Stored |
| ---------------------------- | ---------------------------------------------------------- |
| Your database | Ciphertext, key ID, and any searchable index terms |
| Your application environment | Client key and credentials used to authenticate to ZeroKMS |
| ZeroKMS | Authority keys and access-control state |
| Nowhere | Plaintext data keys |
Your encrypted data stays in your database. ZeroKMS handles key material, not application data. This separation also shapes recovery: restoring ZeroKMS restores the ability to reproduce keys; it does not require CipherStash to restore or move your encrypted database. Multi-region application patterns are covered in [Data residency](https://cipherstash.com/docs/solutions/data-residency#multi-region-with-regional-key-isolation).
ZeroKMS and searchable encryption [#zerokms-and-searchable-encryption]
ZeroKMS protects the keys used by the [Stack SDK](https://cipherstash.com/docs/reference/stack) and [CipherStash Proxy](https://cipherstash.com/docs/reference/proxy). Searchable encryption adds purpose-built terms so PostgreSQL can locate ciphertext without those keys.
The responsibilities remain separate:
* ZeroKMS participates in encryption and decryption key derivation.
* The client creates ciphertext and searchable terms in your environment.
* PostgreSQL compares terms but cannot derive a data key or decrypt a result.
Start with [Searchable encryption](https://cipherstash.com/docs/concepts/searchable-encryption) for the query model. Continue to [Cryptography](https://cipherstash.com/docs/security/cryptography) for algorithms, trust boundaries, and the precise data flow.
# Searchable encryption
Source: https://cipherstash.com/docs/concepts/searchable-encryption
Searchable encryption lets you encrypt sensitive data before it reaches PostgreSQL **without giving up the queries your application depends on**.
Your application can still look up a customer by email, order transactions by date, filter records by a range, match text, and query structured JSON. PostgreSQL answers those queries using encrypted indexes. It never receives the plaintext or the keys that decrypt it.
That changes field-level encryption from an archival control into something you can use on live application data.
What searchable encryption makes possible [#what-searchable-encryption-makes-possible]
**A database breach yields ciphertext.** Backups, replicas, database consoles, and direct SQL access no longer expose the protected fields. Encryption happens in your application, outside the database trust boundary.
**Your product keeps working.** `WHERE`, ranges, ordering, grouping, joins, fuzzy text matching, and JSON containment remain available. Existing PostgreSQL indexes continue to do the heavy lifting.
**Search does not grant decryption.** PostgreSQL can find matching rows but returns ciphertext. Decryption is a separate operation performed by an authorized application, and can be bound to an end-user identity with [provable access control](https://cipherstash.com/docs/solutions/provable-access).
**You decrypt less data.** The database narrows millions of encrypted rows to the small result set the application asked for. Only those returned values need to be decrypted.
**Sensitive access becomes auditable.** Every decryption requires key derivation through ZeroKMS. When the client authenticates as the end user, the audit trail records whose identity authorized that operation—not merely which SQL statement ran.
These properties are especially useful for applications and AI agents that need to locate sensitive records without receiving blanket access to every value in the table.
Why ordinary encryption breaks queries [#why-ordinary-encryption-breaks-queries]
Modern authenticated encryption is randomized. Encrypting `ava@example.com` twice produces different ciphertexts, even with the same key. This prevents an observer from recognizing repeated plaintext, but it also means ordinary database operations stop working:
```sql
WHERE email = 'ava@example.com'
ORDER BY date_of_birth
WHERE name LIKE '%martin%'
```
Two ciphertexts cannot be compared for plaintext equality, and sorting random-looking bytes does not sort the underlying values. Decrypting every row inside PostgreSQL would expose the plaintext and turn an indexed lookup into a full-table scan.
Searchable encryption solves this by separating **the value** from **the information needed to query it**.
How CipherStash makes an encrypted column searchable [#how-cipherstash-makes-an-encrypted-column-searchable]
CipherStash stores a randomized ciphertext together with one or more encrypted index terms. Each term has one job: equality, ordering, text matching, or structured JSON search.
For an email column that supports equality, the stored value is conceptually:
```json
{
"ciphertext": "randomized encryption of ava@example.com",
"equalityTerm": "keyed deterministic term"
}
```
The real [EQL payload](https://cipherstash.com/docs/reference/eql/core-concepts#anatomy-of-an-encrypted-value) also carries the metadata needed to validate and decrypt it. PostgreSQL never compares the randomized ciphertext. It extracts and compares the purpose-built term.
```mermaid
flowchart LR
subgraph app["Your application"]
value["Plaintext value"] --> encrypt["Encrypt"]
needle["Plaintext query"] --> queryterm["Create query term"]
decrypt["Decrypt returned values"]
end
subgraph db["Your PostgreSQL"]
payload["Ciphertext + index terms"]
index["Normal PostgreSQL index"]
match["Matching ciphertexts"]
payload --> index --> match
end
encrypt --> payload
queryterm --> index
match --> decrypt
```
Write path [#write-path]
1. The Stack SDK or CipherStash Proxy receives a plaintext value in your application environment.
2. It encrypts the value with a unique data key and creates the terms declared for that column.
3. Your application sends the encrypted payload to PostgreSQL.
4. PostgreSQL stores the payload and indexes its terms. It never sees the plaintext or data key.
Query path [#query-path]
1. The application turns the plaintext query operand into a term using the same cryptographic scope as the column.
2. It sends that term as a bound query parameter.
3. [EQL](https://cipherstash.com/docs/reference/eql) routes the comparison to the matching term, and PostgreSQL uses the appropriate functional index.
4. PostgreSQL returns only the matching ciphertexts.
Read path [#read-path]
1. The application passes a returned payload to the SDK or Proxy.
2. ZeroKMS authorizes the key derivation and returns the material the client needs.
3. The client derives the data key locally, decrypts the value, and discards the key.
Search and decryption are deliberately separate. PostgreSQL can find records, but it cannot decrypt them.
A concrete equality lookup [#a-concrete-equality-lookup]
The column's EQL type declares its capability. An equality-searchable email uses `public.eql_v3_text_eq`:
```sql filename="schema.sql"
CREATE TABLE users (
id BIGINT GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
email public.eql_v3_text_eq
);
CREATE INDEX users_email_eq
ON users USING hash (eql_v3.eq_term(email));
```
The application encrypts both stored values and query operands:
```typescript filename="lookup.ts"
const term = await encryptionClient.encryptQuery("ava@example.com", {
column: users.email,
table: users,
})
if (term.failure) {
throw new Error(term.failure.message)
}
const rows = await db.query(
"SELECT id, email FROM users WHERE email = $1::jsonb::eql_v3.query_text_eq",
[term.data],
)
```
PostgreSQL uses `users_email_eq` to locate the matching term. The result still contains an encrypted email; the application calls `decrypt` only if it is authorized to reveal it. The [Quickstart](https://cipherstash.com/docs/get-started/quickstart) walks through the complete setup.
Query capabilities [#query-capabilities]
You select capabilities per column, so a lookup field does not need to carry the machinery for range or text search.
| Capability | What it enables | Typical uses | EQL term |
| ------------------ | -------------------------------------------------------- | ------------------------------------------------ | ---------------------------------------------- |
| Storage only | Store and decrypt | Secrets or fields never filtered in SQL | None |
| Equality | `=`, `<>`, `IN`, grouping, uniqueness, equijoins | Email lookup, customer IDs, external references | Keyed HMAC (`hm`) |
| Ordering and range | Equality, `<`, `>`, `BETWEEN`, `ORDER BY`, `MIN`, `MAX` | Dates, amounts, scores, measurements | OPE (`op`) or block ORE (`ob`) |
| Free-text match | Probabilistic n-gram matching with `@@` | Names, descriptions, addresses | Encrypted Bloom filter (`bf`) |
| Searchable JSON | Path access, exact containment, ordered leaf comparisons | Flexible metadata and nested application records | Deterministic selectors and ordered leaf terms |
EQL exposes these as concrete domain variants such as `text_eq`, `integer_ord`, and `text_match`. Your ORM integration maps its encrypted column types to the same model. See [EQL core concepts](https://cipherstash.com/docs/reference/eql/core-concepts#variants-declare-capability) for the full matrix.
It still uses PostgreSQL indexes [#it-still-uses-postgresql-indexes]
Searchable encryption is practical because the encrypted terms fit PostgreSQL's existing index machinery:
* hash or B-tree indexes serve exact matching;
* B-tree indexes serve ranges and ordering;
* GIN indexes serve encrypted text matching and JSON containment.
PostgreSQL does not scan and decrypt the table. Once the query operand has been converted to a term, the query follows the same broad execution shape as an indexed plaintext query.
In CipherStash's reference benchmarks at one million rows, exact matching and OPE range queries both run at about **0.12 ms**, within **1.2–1.4×** of equivalent plaintext PostgreSQL queries. Free-text matching is **100–400× faster** with its GIN index than with a sequential scan. Hardware and workloads vary; [Benchmarks](https://cipherstash.com/docs/reference/benchmarks) contains the environment, query plans, and reproducible suite.
Search and access control reinforce each other [#search-and-access-control-reinforce-each-other]
Database access and plaintext access are different permissions:
| Operation | Where it happens | What is required |
| ------------------ | ---------------- | -------------------------------------------------- |
| Find matching rows | PostgreSQL | Encrypted query term and the matching EQL operator |
| Read stored values | PostgreSQL | Database permission; the result is ciphertext |
| Reveal plaintext | Your application | Client key plus an authorized ZeroKMS derivation |
With [provable access control](https://cipherstash.com/docs/solutions/provable-access), decryption can also require the signed-in user's identity. An application or agent can query a shared encrypted dataset, receive candidate rows, and decrypt only the values that identity is permitted to access. ZeroKMS records the derivation that made each decryption possible.
Searchable encryption is what makes that model usable: applications can locate the right protected records before asking to reveal them.
Choosing capabilities [#choosing-capabilities]
Start from the behavior your product needs:
* Use equality for identifiers and lookup fields.
* Use ordering for values that must support ranges or sorting.
* Use free-text match for human-entered text where token matching is useful.
* Use searchable JSON when flexible document structure is part of the data model.
* Use storage-only encryption when the application reads a field by some other key and never filters on it.
The narrower type is often also the clearest schema. A `text_eq` column tells future maintainers that it is a lookup field; a `text_match` column says it supports token matching but not sorting. Unsupported operations fail rather than silently returning an incorrect result.
The security tradeoff [#the-security-tradeoff]
The database needs some information to answer a query. Searchable terms expose defined relationships between encrypted values while keeping the values themselves secret. The capability you select determines that relationship:
| Capability | What a database observer can infer |
| --------------- | -------------------------------------------------------------------------------------------------------------- |
| Storage only | Table shape, row count, nullness, update timing, and approximate value size—but no equality or ordering term |
| Equality | Which comparable values are equal, and therefore their frequency |
| Ordering | Equality, frequency, and the relative order of values |
| Free-text match | Probabilistic token overlap, repeated token sets, and approximate token-set size |
| Searchable JSON | Repeated paths and structures, equality of path/value pairs, document shape, and ordering of searchable leaves |
The terms are keyed. Someone who steals an equality term cannot hash a plaintext dictionary and compare it without the key. However, frequency distributions, known records, and other auxiliary information can still make likely values easier to infer—particularly in small or predictable domains.
Queries add their own observable patterns. A database operator can see repeated searches, which rows match, and where range boundaries fall. This is known as search-pattern and access-pattern leakage. The database still does not receive the plaintext query, but logs, endpoint behavior, or known test records can sometimes label an otherwise encrypted term.
This is why capabilities are selected per column instead of enabled globally. If relative order is sensitive but exact lookup is acceptable, choose equality rather than ordering. If even equality groups are sensitive, use storage-only encryption and filter a smaller candidate set after decryption in the application.
For the application and key-management trust boundary, see [Cryptography](https://cipherstash.com/docs/security/cryptography). For the exact payload fields and EQL operators behind each capability, see [EQL core concepts](https://cipherstash.com/docs/reference/eql/core-concepts).
# AI and RAG
Source: https://cipherstash.com/docs/solutions/ai-and-rag
Retrieval-augmented generation pipelines often store document chunks,
customer metadata, access labels, and vector embeddings in the same database.
The source text may contain PII, financial records, health information, or
confidential business material that should not become plaintext merely because
an application needs semantic retrieval.
CipherStash encrypts sensitive fields in the application before they reach the
database. The vector store can continue retrieving candidate rows while the
application decrypts only the records selected for the prompt.
What to encrypt [#what-to-encrypt]
Treat each part of the RAG record according to how it is used:
| Field | Typical treatment |
| --------------------------- | -------------------------------------------------------------------------------- |
| Source chunk | Encrypt; decrypt only after retrieval and authorization |
| Document title or filename | Encrypt if it contains customer or case information |
| Tenant, owner, or policy ID | Encrypt with equality when the database must filter on it |
| Access labels | Encrypt with the narrowest query capability the filter needs |
| Embedding | Keep separate from source text; assess whether the embedding itself is sensitive |
Embeddings are derived data, not ciphertext. They may reveal properties of the
source and should be covered by the application's data classification and
threat model. Encrypting the source text does not make an exposed embedding
harmless.
Retrieval flow [#retrieval-flow]
```mermaid
sequenceDiagram
participant App as Application
participant Vector as Vector store
participant DB as Encrypted record store
participant ZK as ZeroKMS
participant LLM as Model
App->>Vector: Search with query embedding
Vector-->>App: Candidate record IDs
App->>DB: Fetch authorized encrypted records
DB-->>App: Ciphertext
App->>ZK: Request key seeds for selected values
ZK-->>App: Key seeds
Note over App: Derive keys and decrypt locally
App->>LLM: Minimum required plaintext context
```
The database and vector service do not receive the source plaintext. The model
still receives whichever context the application sends, so model-provider
retention, logging, prompt injection, and authorization remain separate design
decisions.
Tenant and user isolation [#tenant-and-user-isolation]
Use a separate [keyset](https://cipherstash.com/docs/concepts/key-management#keysets-define-the-isolation-boundary)
when tenants or environments require a cryptographic boundary. Use
[identity-bound encryption](https://cipherstash.com/docs/solutions/provable-access) when decryption should
require claims from the signed-in user.
Apply authorization before decryption and again before assembling the prompt.
Vector similarity alone is not an authorization decision: a candidate from
another tenant must be discarded before its ciphertext is decrypted.
Searchable metadata [#searchable-metadata]
If the metadata lives in Postgres, EQL can filter equality, ranges, token
matches, and JSON containment without decrypting every row. Declare only the
capabilities the retrieval pipeline uses; each capability has a documented
leakage profile. See [searchable encryption](https://cipherstash.com/docs/concepts/searchable-encryption)
and [EQL filtering](https://cipherstash.com/docs/reference/eql/filtering).
For implementation, begin with the [Stack SDK](https://cipherstash.com/docs/reference/stack), then follow
the [Data migration](https://cipherstash.com/docs/guides/migration) rollout when existing records must be
encrypted without downtime.
# Data residency
Source: https://cipherstash.com/docs/solutions/data-residency
CipherStash provides data residency guarantees through regional key management, encryption that happens entirely in your infrastructure, and cryptographic key splitting. This page covers the deployment patterns for organizations with cross-border data requirements.
Why the architecture gives you residency [#why-the-architecture-gives-you-residency]
Three properties combine to keep data and key material inside a region:
* **Plaintext never leaves your systems.** Encryption and decryption happen in your infrastructure, in the Stack SDK or Proxy. The cloud service never sees plaintext.
* **Encrypted values never leave your systems either.** Ciphertext lives in your database.
* **Data keys are never transmitted.** They are derived locally, not fetched over the network.
Regional ZeroKMS deployment [#regional-zerokms-deployment]
ZeroKMS is deployed on AWS only. A workspace is tied to one region, and its region identifier forms part of the workspace CRN (`crn:ap-southeast-2.aws:your-workspace-id`).
Selecting a ZeroKMS region controls where authority keys are managed. Combined with your application's deployment region, that determines where all key material exists.
Need a region that is not listed? Contact [support@cipherstash.com](mailto:support@cipherstash.com).
Dual-party key split [#dual-party-key-split]
CipherStash splits key material between two parties:
1. **Authority key**, managed by ZeroKMS in your chosen region.
2. **Client key**, managed by your application in your infrastructure.
Neither key alone derives a data key. ZeroKMS alone cannot access your data, because it holds only half the key material. Your application alone cannot either, because it needs a key seed from ZeroKMS.
The two halves are never brought together in one place. ZeroKMS returns a key seed; your application processes that seed with the client key and derives the data key locally. The client key never leaves your infrastructure, and neither does anything it processes. See [cryptography](https://cipherstash.com/docs/security/cryptography).
Deployment patterns [#deployment-patterns]
Single region [#single-region]
Deploy your application and ZeroKMS in the same region.
```mermaid
flowchart TB
subgraph region["Region: eu-central-1.aws"]
app["Your app
+ client key"]
zerokms["ZeroKMS
+ authority key"]
db[("PostgreSQL
encrypted")]
app <-- key seed --> zerokms
app -- ciphertext --> db
end
```
All key material and data remain in one region. This satisfies most data residency requirements, including GDPR and regional data protection laws.
Multi-region with regional key isolation [#multi-region-with-regional-key-isolation]
For organizations operating across regions with differing requirements, deploy a separate workspace per region.
```mermaid
flowchart LR
subgraph eu["Region: eu-central-1.aws"]
euApp["App
+ client key"]
euKms["ZeroKMS (EU)"]
euDb[("PostgreSQL (EU)")]
euApp <-- key seed --> euKms
euApp -- ciphertext --> euDb
end
subgraph apac["Region: ap-southeast-2.aws"]
apacApp["App
+ client key"]
apacKms["ZeroKMS (APAC)"]
apacDb[("PostgreSQL (APAC)")]
apacApp <-- key seed --> apacKms
apacApp -- ciphertext --> apacDb
end
euDb -. "cannot be decrypted by" .-x apacApp
```
Each region gets its own ZeroKMS workspace with independent authority keys, its own client key (which, like every client key, never leaves your infrastructure), and its own database. Data encrypted in one region cannot be decrypted in another, which enforces the residency boundary cryptographically rather than by policy.
Cross-border access [#cross-border-access]
When a global team needs to reach encrypted data across regions, construct a client per region with that region's credentials.
```typescript filename="regional-access.ts"
import { Encryption } from "@cipherstash/stack"
import { customers } from "./schema"
// A client scoped to the EU workspace
const euClient = await Encryption({
schemas: [customers],
config: {
workspaceCrn: process.env.CS_EU_WORKSPACE_CRN,
clientId: process.env.CS_EU_CLIENT_ID,
clientKey: process.env.CS_EU_CLIENT_KEY,
accessKey: process.env.CS_EU_ACCESS_KEY,
},
})
// Decrypting EU customer data requires EU credentials
const result = await euClient.decrypt(encryptedEuRecord)
if (result.failure) {
throw new Error(`Decryption failed: ${result.failure.message}`)
}
```
Access to each region's data requires that region's credentials, which gives you an auditable, revocable access model. To revoke a team member's access to a region, delete their client credentials in that region's workspace.
Compliance alignment [#compliance-alignment]
| Requirement | How CipherStash addresses it |
| ----------------------------------- | ------------------------------------------------------------------------------------------ |
| Data must not leave the region | Encryption and decryption happen locally; plaintext never leaves your infrastructure |
| Key material must stay in region | ZeroKMS authority keys are region-bound; client keys deploy with your app |
| Audit trail for cross-border access | ZeroKMS logs key derivation requests with identity context |
| Ability to revoke access | Delete client credentials, or revoke [lock context](https://cipherstash.com/docs/solutions/provable-access) identities |
| Cryptographic enforcement | The dual-party key split means a single party cannot decrypt alone |
This architecture supports compliance with GDPR, regional data protection laws, and industry-specific requirements in healthcare and financial services. See [compliance](https://cipherstash.com/docs/security/compliance) for framework-by-framework detail.
Next steps [#next-steps]
* Review [regional ZeroKMS deployment](#regional-zerokms-deployment) for your workspaces.
* [Set up provable access control](https://cipherstash.com/docs/solutions/provable-access) to bind decryption to an identity.
* Review [key management](https://cipherstash.com/docs/concepts/key-management) when designing recovery and revocation procedures.
# Solutions
Source: https://cipherstash.com/docs/solutions
CipherStash encrypts sensitive data at the field level, in your infrastructure, while keeping it queryable. This section covers the problems that solves, and what an implementation looks like for each.
In this section [#in-this-section]
* [Data residency](https://cipherstash.com/docs/solutions/data-residency) covers regional key management and the deployment patterns for cross-border requirements.
* [Provable access control](https://cipherstash.com/docs/solutions/provable-access) binds decryption to an authenticated identity, so access is cryptographically demonstrable rather than merely logged.
What data should I protect? [#what-data-should-i-protect]
When improving your data security practices, it can be difficult to know what data is important enough to protect. These are the common categories of sensitive data worth encrypting.
Personally identifiable information (PII) [#personally-identifiable-information-pii]
Any data that could identify a specific individual: names, phone numbers, dates of birth, addresses, emails, IP addresses, social security numbers, license numbers, passport numbers.
**Applicable regulations:** GDPR, CCPA, HIPAA, APP (Australia), PCI-DSS, SOC 2, ISO 27001.
Protected health information (PHI) [#protected-health-information-phi]
Any information about health status, provision of health care, or payment for health care that can be linked to an individual: medical record numbers, health insurance beneficiary numbers, biometric identifiers, medical conditions, medication histories, payment histories.
**Applicable regulations:** HIPAA, CMIA, GDPR, APP.
Financial information [#financial-information]
Data about money, accounts, and transactions: account numbers and balances, transaction data, TFNs and ITINs, saved payees.
**Applicable regulations:** GDPR, CCPA, PCI-DSS, CDR (Australia), SOC 2, ISO 27001.
Authentication information [#authentication-information]
Credentials used to gain access to accounts and services: usernames, passwords (both plaintext and hashed), OAuth tokens, session cookies.
**Applicable regulations:** SOC 2, ISO 27001, PCI-DSS.
Related [#related]
* [Searchable encryption](https://cipherstash.com/docs/concepts/searchable-encryption) for how querying encrypted data works, and what each index term reveals.
* [Compliance](https://cipherstash.com/docs/security/compliance) for how CipherStash maps onto specific frameworks.
# Provable access control
Source: https://cipherstash.com/docs/solutions/provable-access
Traditional access control relies on application logic. If a bug or misconfiguration exposes data, there is no way to prove afterwards whether access was unauthorized. CipherStash binds decryption to an authenticated identity, so access leaves cryptographic evidence rather than only a log entry.
How auth strategies and lock contexts combine [#how-auth-strategies-and-lock-contexts-combine]
Two pieces combine.
**An auth strategy** decides who the client is when it talks to ZeroKMS. `OidcFederationStrategy` federates a signed-in user's OIDC JWT (from Supabase, Clerk, Auth0, or Okta) into a CipherStash token, so every ZeroKMS request is made *as that user* rather than as your service.
**A lock context** binds a value to a claim from that user's JWT, typically `sub`. ZeroKMS bakes the claim's value into the data key's tag, so only the user who encrypted a value can decrypt it.
The two are layered, not alternatives: lock context requires `OidcFederationStrategy`, but you can use the strategy without lock context. Authenticating as the user gives you an audit trail; adding lock context gives you the cryptographic binding.
That creates a provable access boundary:
* If data was decrypted, the user's identity must have been present.
* ZeroKMS records the identity associated with every key derivation.
* The record cannot be falsified by tampering with application logs, because the evidence is the derivation itself, not the log line describing it.
A lock context restricts **who can decrypt**. It does not hide the ciphertext's existence, nor does it prevent a signed-in user from decrypting the values their own claim unlocks. It moves the enforcement point out of your application and into key derivation.
Identity-aware encryption [#identity-aware-encryption]
Add your identity provider to the workspace first, on the [OIDC providers](https://dashboard.cipherstash.com/workspaces/_/oidc-providers) page in the Dashboard. The `_` in that URL resolves to whichever workspace you have selected.
Authenticate as the end user [#authenticate-as-the-end-user]
Construct the client with `OidcFederationStrategy`. Pass a function that returns the *current* provider JWT: the strategy re-invokes it when it needs to re-federate, so do not capture a token once.
```typescript filename="client.ts"
import { Encryption, OidcFederationStrategy } from "@cipherstash/stack"
import { patients } from "./schema"
// Every ZeroKMS request is authenticated as the signed-in user
export const client = await Encryption({
schemas: [patients],
config: {
authStrategy: OidcFederationStrategy.create(
process.env.CS_WORKSPACE_CRN,
() => getProviderJwt(),
),
},
})
```
`OidcFederationStrategy` is re-exported by `@cipherstash/stack`, so you do not need a separate import from [`@cipherstash/auth`](https://www.npmjs.com/package/@cipherstash/auth).
`OidcFederationStrategy` is the only strategy that supports lock contexts. `AccessKeyStrategy` authenticates as your service rather than as an end user, so there is no user identity for ZeroKMS to resolve the claim against.
Bind encryption to the user's identity [#bind-encryption-to-the-users-identity]
Every example below uses the `client` from above. Without its `authStrategy`, `.withLockContext()` has no end-user identity to bind to.
```typescript filename="identity-encrypt.ts"
// `client` is configured with OidcFederationStrategy, as above
import { client } from "./client"
import { patients } from "./schema"
// The data key is tagged with the authenticated provider's `sub` claim
async function encryptDiagnosis(diagnosis: string) {
const result = await client
.encrypt(diagnosis, { column: patients.diagnosis, table: patients })
.withLockContext({ identityClaim: ["sub"] })
if (result.failure) {
throw new Error(`Encryption failed: ${result.failure.message}`)
}
return result.data
}
```
Decrypt with the same identity claim [#decrypt-with-the-same-identity-claim]
Decryption requires the same lock context, resolved against whichever user the client is currently authenticated as.
```typescript filename="identity-decrypt.ts"
// The same `client`, authenticated as the same user
async function decryptDiagnosis(encryptedDiagnosis: unknown) {
const result = await client
.decrypt(encryptedDiagnosis)
.withLockContext({ identityClaim: ["sub"] })
if (result.failure) {
// Key derivation fails when the identity does not match
throw new Error(`Access denied: ${result.failure.message}`)
}
return result.data
}
```
Lock contexts work with every operation: `encrypt`, `decrypt`, `encryptModel`, `decryptModel`, `bulkEncrypt`, `bulkDecrypt`, `bulkEncryptModels`, and `bulkDecryptModels`.
`lockContext.identify(jwt)` is **deprecated**. Per-operation CTS tokens were removed in `protect-ffi` 0.25, so `identify()` no longer affects encryption: code that still calls it compiles and logs a deprecation warning, but the token it fetches is unused. Authenticate the client with `OidcFederationStrategy` and pass the claim to `.withLockContext()` instead.
Constructing a `LockContext` is not deprecated, it is simply optional here. `.withLockContext()` accepts either a `LockContext` or a plain `{ identityClaim }`.
Audit logging [#audit-logging]
Every encryption and decryption through ZeroKMS produces an audit event:
| Field | Description |
| ----------- | ----------------------------------------- |
| Identity | The authenticated user or service |
| Operation | Encrypt or decrypt |
| Timestamp | When the operation occurred |
| Keyset | Which keyset was used |
| Application | Which application performed the operation |
Combining with Proxy audit [#combining-with-proxy-audit]
[CipherStash Proxy](https://cipherstash.com/docs/reference/proxy) adds statement-level audit on top: statement fingerprinting to identify unique query patterns against encrypted data, SQL redaction to strip sensitive values from logged queries, primary key injection to track which records were touched, and record reconciliation to map access events back to rows. See [Audit logging](https://cipherstash.com/docs/concepts/access-analytics).
Together these answer who accessed what data, when, and using which query.
Use cases [#use-cases]
Healthcare: HIPAA audit requirements [#healthcare-hipaa-audit-requirements]
HIPAA requires audit controls recording who accessed protected health information. Authenticating each request as the signed-in provider means the ZeroKMS audit log records the identity, the operation, the keyset, and the timestamp for each derivation, and a lock context ties each patient record to the provider who encrypted it.
Financial services: segregation of duties [#financial-services-segregation-of-duties]
Encrypt audit records under a compliance-team member's identity. Someone on the trading desk, authenticated as themselves, resolves a different claim value, so key derivation fails and the records do not decrypt. The separation is enforced at derivation, not by a role check in the application.
Multi-tenant SaaS: tenant isolation [#multi-tenant-saas-tenant-isolation]
Bind encryption to a per-user claim so only that user's identity can decrypt their data. For coarser isolation that does not depend on a signed-in end user, separate [keysets](https://cipherstash.com/docs/concepts/key-management#keysets-define-the-isolation-boundary) usually fit better: a keyset boundary is per-client or per-connection, where a lock context is per-identity.
Compared to application-level access control [#compared-to-application-level-access-control]
| Aspect | Application logic | Lock contexts |
| --------------------- | --------------------------------------- | ------------------------------------------------- |
| Enforcement | A software check, which can be bypassed | Key derivation, which cannot be skipped |
| Audit trail | Application logs, which can be edited | ZeroKMS derivation records |
| Proof of access | Circumstantial, from log entries | Direct: decryption required the identity |
| Blast radius of a bug | Data exposed when the check is bypassed | Data stays encrypted when application logic fails |
Next steps [#next-steps]
* [Data residency](https://cipherstash.com/docs/solutions/data-residency) for revoking access per region.
* [Audit logging](https://cipherstash.com/docs/concepts/access-analytics) for statement-level access evidence.
* [Compliance](https://cipherstash.com/docs/security/compliance) for GDPR, HIPAA, and PCI-DSS mapping.
# Cryptography
Source: https://cipherstash.com/docs/security/cryptography
This page is the single reference for CipherStash's cryptographic design. Every other page that touches key management links here rather than restating it.
Cryptographic primitives [#cryptographic-primitives]
| Purpose | Algorithm | Details |
| ----------------------- | ----------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Data encryption | AES-256-GCM-SIV | Authenticated encryption with nonce-misuse resistance |
| Equality search terms | HMAC-SHA-256 | Deterministic terms for exact-match lookups |
| Range and sorting terms | CLLW OPE or block ORE | EQL defaults to a directly sortable CLLW order-preserving term; block ORE is available as a pinned alternative ([Lewi-Wu 2016](https://eprint.iacr.org/2016/612), [Bogatov et al. 2018](https://arxiv.org/abs/1810.05135)) |
| Free-text search terms | Encrypted Bloom filters | Trigram tokenization ([Nojima/Kadobayashi 2009](https://link.springer.com/chapter/10.1007/978-3-642-04474-8_17), [Chum/Zhang 2017](https://link.springer.com/chapter/10.1007/978-3-319-66399-9_15)) |
| Payload integrity | BLAKE3 | Structure validation of the encrypted payload |
| Payload encoding | MessagePack + Base85 | Compact binary serialization, stored as `jsonb` in PostgreSQL |
Encryption and decryption happen in your application process, in the native Rust module. CipherStash infrastructure never sees plaintext.
The key hierarchy [#the-key-hierarchy]
Three distinct things are often all called "the key". Keeping them apart is what makes the rest of this page readable.
| Key | Where it lives | What protects it |
| ----------------- | ---------------------------------- | ----------------------------------------------------------------------- |
| **Authority key** | ZeroKMS, server-side | Encrypted at rest under an AWS KMS root key |
| **Client key** | Your application or workload | You do (`CS_CLIENT_KEY`) |
| **Data key** | Your application's memory, briefly | Nothing. It is derived per value, identified by a key ID, and discarded |
The authority key and the client key are two halves of a split. Neither alone derives a data key, and the two are never brought together in one place. The key seed travels from ZeroKMS to you. The client key never travels at all.
How a data key is produced [#how-a-data-key-is-produced]
The mechanism operates at two layers, and descriptions that name only one of them are incomplete.
Layer 1: the key seed, produced server-side [#layer-1-the-key-seed-produced-server-side]
Your application requests a key seed by sending a **key ID**. ZeroKMS uses **proxy symmetric re-encryption** (patent pending) on the authority key to produce the **key seed** for that ID, and returns it.
The ID is what gives every data key a unique identity. It travels with the encrypted value, so the same seed can be requested again to decrypt it.
ZeroKMS does all of this without the client key. It never receives it, and the request carries no key material of yours, only the ID. That is what makes the architecture zero-knowledge: ZeroKMS produces a seed it cannot itself turn into a data key.
Layer 2: the data key, derived client-side [#layer-2-the-data-key-derived-client-side]
Your application **processes the key seed with the client key**, then expands the result into a **unique data key per value** using an **HMAC-based key derivation function**. The data key encrypts the value with AES-256-GCM-SIV, then is discarded from memory.
The client key never leaves your infrastructure, and neither does anything it processes. Only the seed crosses the boundary, and it crosses inward.
```mermaid
flowchart TD
subgraph zerokms["ZeroKMS (CipherStash)"]
root["AWS KMS root key"]
auth["Authority key"]
seed["Key seed"]
root -. encrypts at rest .-> auth
auth -- "layer 1:
proxy symmetric re-encryption" --> seed
end
subgraph you["Your infrastructure"]
keyid["Key ID
unique per data key"]
client["Client key
never leaves"]
processed["Processed seed"]
datakey["Data key
one per value
discarded after use"]
ciphertext["Ciphertext"]
client -- processes the seed --> processed
processed -- "layer 2:
HMAC-based KDF" --> datakey
datakey -- AES-256-GCM-SIV --> ciphertext
end
keyid -- "requests a seed
(no key material)" --> auth
seed -- returned to your app --> processed
```
Re-encryption describes how the seed is produced. HMAC key derivation describes how the processed seed becomes per-value keys. Both are true, at different layers.
Note what crosses the boundary. Outbound: a key ID, which is not key material. Inbound: the key seed. Nothing else leaves your infrastructure, not the client key, not the processed seed, not the data key.
What is cached, and what is not [#what-is-cached-and-what-is-not]
This distinction matters for a security review, and earlier documentation stated it too broadly. "Nothing is cached" is not accurate. What is true is that **no data key is ever cached, stored, or transmitted.**
| Thing | Cached? | Detail |
| --------------------- | ------------------- | ---------------------------------------------------------------------------------------------------------------------------------- |
| Data keys | Never | Derived per value, held in memory for the duration of one operation, then discarded |
| Key seeds | Not persisted | Held only for the operation that requested them |
| Keyset-scoped ciphers | **Yes, in Proxy** | [CipherStash Proxy](https://cipherstash.com/docs/reference/proxy/configuration) caches keyset-scoped cipher objects so it does not re-initialize per statement |
| Authority keys | At rest, in ZeroKMS | Encrypted under an AWS KMS root key |
Proxy's cipher cache is bounded by `cipher_cache_size` (64 entries) and `cipher_cache_ttl_seconds` (3600 seconds), and its hit rate is exposed as `cipherstash_proxy_keyset_cipher_cache_hits_total`. Caching a keyset-scoped cipher is not the same as caching a data key: the cipher still requires the client key to derive anything, and per-value keys are still derived per value.
The Stack SDK derives per operation and caches nothing.
Trust model [#trust-model]
An attacker must compromise **both** the ZeroKMS authority key and your client key to derive data keys. Compromising either alone is insufficient.
* CipherStash never sees plaintext. Encryption and decryption run in your process.
* CipherStash never sees your client key, nor anything the client key has processed.
* CipherStash never sees a data key. Data keys are derived in your memory.
* Ciphertext never has to leave your infrastructure. ZeroKMS handles key material, not data.
Shared responsibility [#shared-responsibility]
| You | CipherStash |
| --------------------------------------------- | ------------------------------------------------------- |
| Protect the client key (`CS_CLIENT_KEY`) | Protect authority keys, encrypted at rest under AWS KMS |
| Secure your application and database | Operate ZeroKMS with high availability |
| Manage access keys and keysets | Enforce access-control policy on keysets |
| Register identity providers for lock contexts | Operate the CipherStash Token Service (CTS) |
| Store encrypted data in your database | Never store, access, or log plaintext |
Blast radius [#blast-radius]
[Keysets](https://cipherstash.com/docs/concepts/key-management#keysets-define-the-isolation-boundary) scope keys. Each keyset is a full cryptographic boundary: one tenant's keyset cannot decrypt another's data. Compromising a client key affects only the keysets that application can reach, and revoking its access key stops further key derivation immediately.
Data flow [#data-flow]
Write path [#write-path]
1. The application calls `client.encrypt(plaintext, { column, table })`.
2. The SDK requests a key seed from ZeroKMS over TLS, sending a unique key ID. The request carries no key material.
3. ZeroKMS re-encrypts under the authority key and returns the key seed for that ID.
4. The SDK processes the seed with the client key, then derives the data key from the result, locally.
5. The SDK encrypts the plaintext with AES-256-GCM-SIV.
6. If the column declares searchable capability, the SDK generates the index terms (HMAC, CLLW OPE or block ORE, Bloom filter).
7. The SDK packs ciphertext and index terms into an [EQL payload](https://cipherstash.com/docs/reference/eql/core-concepts).
8. The data key is discarded.
9. The application stores the payload in PostgreSQL.
Read path [#read-path]
1. The application reads the payload and calls `client.decrypt(...)`.
2. The SDK requests a key seed using the key ID stored with the value, processes it with the client key, and derives the data key locally.
3. The SDK decrypts the ciphertext, discards the data key, and returns plaintext.
Query path [#query-path]
1. The application encrypts a search term.
2. The SDK generates the appropriate index term (HMAC for equality, CLLW OPE or block ORE for range and ordering, Bloom filter for free text).
3. PostgreSQL compares encrypted terms using [EQL](https://cipherstash.com/docs/reference/eql) operators. The database never sees plaintext.
What querying encrypted data reveals [#what-querying-encrypted-data-reveals]
Searchable encryption is a trade. Each index term reveals bounded information to whoever can read the database: HMAC terms reveal equality and therefore frequency, OPE and ORE terms reveal relative order, and Bloom filter terms reveal probabilistic token membership.
That leakage model is documented once, in [Searchable encryption](https://cipherstash.com/docs/concepts/searchable-encryption), with per-term detail and guidance on when the trade is not worth making. Assess it as part of your threat model. If the ordering or frequency of a column's values is itself sensitive, encrypt that column without a searchable index and filter after decryption.
Network security [#network-security]
All communication between the SDK and CipherStash services uses TLS 1.2 or later:
* SDK to ZeroKMS, for key seeds.
* SDK to CTS, for token exchange during identity-aware encryption.
* SDK to your database: your existing connection. CipherStash does not proxy it.
Key material does not leave the region your workspace is configured in. See [data residency](https://cipherstash.com/docs/solutions/data-residency#regional-zerokms-deployment).
Source availability [#source-availability]
You can read the source for every scheme on this page. Each component is published under one of two kinds of licence:
* **Open source**: an OSI-approved licence that lets you use, modify, and redistribute the code.
* **Source-available**: the source is published so you can review it and check that it matches the builds we ship. The licence restricts how you can modify and use the code.
| Component | What it contains | Source | Licence |
| ------------------- | ----------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------- |
| EQL | PostgreSQL types, operators, and functions | [cipherstash/encrypt-query-language](https://github.com/cipherstash/encrypt-query-language) | MIT (open source) |
| Stack SDK | The TypeScript packages and the native module bindings | [cipherstash/stack](https://github.com/cipherstash/stack), [cipherstash/protect-ffi](https://github.com/cipherstash/protect-ffi) | MIT (open source) |
| Encryption core | AES-256-GCM-SIV encryption, data key derivation, and index-term generation, used by the Stack SDK's native module | [`cipherstash-client`](https://docs.rs/crate/cipherstash-client/latest/source/) | PolyForm Internal Use 1.0.0 (source-available) |
| CLLW ordering terms | The default range and sorting term | [`cllw-ore`](https://docs.rs/crate/cllw-ore/latest/source/) | PolyForm Internal Use 1.0.0 (source-available) |
| Block ORE | The pinned alternative range and sorting term | [cipherstash/ore.rs](https://github.com/cipherstash/ore.rs) | CipherStash Client Library Licence (source-available) |
| CipherStash Proxy | SQL mapping, encryption, and decryption for unmodified applications | [cipherstash/proxy](https://github.com/cipherstash/proxy) | PolyForm Internal Use 1.0.0 (source-available) |
The underlying primitives (AES-GCM-SIV, HMAC, SHA-2, and BLAKE3) come from widely used open-source Rust libraries, principally [RustCrypto](https://github.com/RustCrypto).
ZeroKMS is a managed service operated by CipherStash, and its source is not published.
Related [#related]
* [Searchable encryption](https://cipherstash.com/docs/concepts/searchable-encryption) for the canonical index-term leakage model.
* [Key management](https://cipherstash.com/docs/concepts/key-management) for the isolation boundary.
* [Proxy configuration](https://cipherstash.com/docs/reference/proxy/configuration) for the cipher cache settings.
* [Provable access control](https://cipherstash.com/docs/solutions/provable-access) for binding decryption to an authenticated identity.
# Architecture & security
Source: https://cipherstash.com/docs/security
This section is written to be self-contained. A security team should be able to assess CipherStash from these pages without piecing the story together from reference material elsewhere.
Start with [Cryptography](https://cipherstash.com/docs/security/cryptography). It is the canonical account of the cryptographic design: the key hierarchy, what ZeroKMS learns and does not learn, and what is cached. Every other page that touches key management links to it rather than restating it.
In this section [#in-this-section]
* [Cryptography](https://cipherstash.com/docs/security/cryptography) covers the primitives, the key hierarchy, the trust model, and the data flow.
* [Compliance](https://cipherstash.com/docs/security/compliance) maps CipherStash onto specific frameworks.
Related [#related]
* [Searchable encryption](https://cipherstash.com/docs/concepts/searchable-encryption) is the canonical account of what each index term reveals to the database.
* [Provable access control](https://cipherstash.com/docs/solutions/provable-access) covers binding decryption to an authenticated identity.
# Deployment
Source: https://cipherstash.com/docs/integrations/prisma/deployment
Prisma owns the complete database migration graph for this integration, including the EQL bundle, encrypted columns, and their functional indexes. Application releases still need to be staged carefully when a plaintext column already contains data.
For the reasoning, rollback rules, and adapter-independent sequence, read [Data migration](https://cipherstash.com/docs/guides/migration) and the [deployment guide](https://cipherstash.com/docs/guides/deployment). This page maps that process to Prisma ORM 8.
New tables and empty columns [#new-tables-and-empty-columns]
For a new table or an empty column:
```bash
npx prisma-next contract emit
npx prisma-next migration plan --name add-encrypted-fields
npx prisma-next migrate
```
The CipherStash extension pack contributes EQL to the same graph. Do not run `stash eql install`.
Populated columns [#populated-columns]
Move a populated plaintext column to encryption across separate application releases:
| Release | Prisma and application change | Gate |
| --------------------- | ------------------------------------------------------------------------------------------------- | --------------------------------- |
| 1. Add and dual-write | Add a nullable encrypted twin; write plaintext and ciphertext on every path; keep plaintext reads | Confirm dual-writes are live |
| Backfill | Run `stash encrypt backfill` against the target database with the deployed app's keyset | Confirm zero uncovered rows |
| Index | Add EQL functional indexes as a Prisma raw-SQL migration operation and run `ANALYZE` | Verify plans with `EXPLAIN` |
| 2. Cut over reads | Query and decrypt the encrypted twin; keep dual-writes | Soak under real traffic |
| 3. Stop dual-writing | Write only the encrypted field; retain the plaintext column | Confirm every instance is updated |
| 4. Remove plaintext | Apply a guarded destructive migration, then remove the old field from the contract | Irreversible |
Do not combine these boundaries. In particular, a backfill is safe only after every production write path dual-writes, and the plaintext column must remain until encrypted reads have soaked successfully.
Index migrations [#index-migrations]
Prisma schemas cannot express functional indexes. Keep their DDL as `rawSql` operations from `@prisma-next/postgres/migration` in the Prisma migration history; never apply them ad hoc to production.
Use the recipes in [EQL indexes](https://cipherstash.com/docs/reference/eql/indexes). Build indexes after the bulk backfill and before encrypted reads go live, then run `ANALYZE` and verify the actual query plan.
Credentials [#credentials]
Create separate credentials for each deployed environment. A backfill must use credentials bound to the same keyset as the deployed application; otherwise decryption or encrypted search can fail after a seemingly successful write.
The encryption client is commonly constructed during module import, so make the four `CS_*` variables available at build time as well as runtime.
Runtime packaging [#runtime-packaging]
The Prisma adapter uses the native Stack client. Keep `@cipherstash/stack`, `@cipherstash/protect-ffi`, and `@cipherstash/auth` external to server bundles, and deploy to a runtime that can load native packages. This adapter is not supported on edge runtimes.
For Prisma's hosted deployment behavior, including additive-only push-to-deploy and preview databases, continue with [Prisma Compute](https://cipherstash.com/docs/integrations/prisma/prisma-compute).
# Overview
Source: https://cipherstash.com/docs/integrations/prisma
CipherStash adds searchable, field-level encryption to Prisma ORM 8. Encrypted columns are declared in `schema.prisma`, EQL is installed through Prisma's migration graph, and the generated query API encrypts operands and values before they reach Postgres.
This integration targets the **Prisma ORM 8 release candidate**, formerly known as **Prisma Next**. The prerelease CLI, package names, and configuration file still use `prisma-next` or `@prisma-next/*`; the examples preserve those names exactly. CipherStash setup uses `stash init --prisma`.
It does not extend the classic `@prisma/client` API. For earlier Prisma releases, use the [Stack SDK](https://cipherstash.com/docs/reference/stack) around your existing reads and writes.
Choose your path [#choose-your-path]
| What you want to do | Start here |
| ---------------------------------------------- | ----------------------------------------------------------------- |
| Encrypt and query your first Prisma field | [Prisma ORM Quickstart](https://cipherstash.com/docs/integrations/prisma/quickstart) |
| Choose column types or look up query operators | [Schema and queries](https://cipherstash.com/docs/integrations/prisma/schema-and-queries) |
| Look up every exported function and type | [API reference](https://cipherstash.com/docs/integrations/prisma/api-reference) |
| Encrypt data already in production | [Prisma deployment guide](https://cipherstash.com/docs/integrations/prisma/deployment) |
| Use Prisma's managed database | [Prisma Postgres](https://cipherstash.com/docs/integrations/prisma/prisma-postgres) |
| Deploy the application with Prisma | [Prisma Compute](https://cipherstash.com/docs/integrations/prisma/prisma-compute) |
| Design and verify encrypted indexes | [EQL indexes](https://cipherstash.com/docs/reference/eql/indexes) |
| Look up the Prisma 8 prerelease itself | [Prisma ORM 8 documentation](https://www.prisma.io/docs/orm/next) |
How the Prisma extension encrypts columns [#how-the-prisma-extension-encrypts-columns]
The [`@cipherstash/stack-prisma`](https://www.npmjs.com/package/@cipherstash/stack-prisma) extension has three integration points:
1. Domain-named constructors such as `cipherstash.TextSearch()` declare encrypted EQL v3 columns in `schema.prisma`.
2. The CipherStash extension pack adds EQL and those columns to Prisma's contract and migration graph.
3. `cipherstashFromStack` connects the generated Prisma runtime to the Stack encryption client.
The column type fixes which encrypted queries are possible. For example, `TextEq()` supports equality, while `TextSearch()` also supports ranges, ordering, and token matching. Choosing the narrowest useful type minimizes the information disclosed by searchable encryption. [Schema and queries](https://cipherstash.com/docs/integrations/prisma/schema-and-queries) contains the complete type and operator tables.
EQL and migration ownership [#eql-and-migration-ownership]
This integration targets EQL v3 only. Prisma owns the EQL installation: `npx prisma-next migrate` installs the EQL bundle alongside your application schema. Do not run `stash eql install` in a Prisma ORM 8 project.
Encrypted functional indexes also belong in the Prisma migration graph. `schema.prisma` cannot express expression indexes, so add their SQL as a Prisma raw-SQL migration operation. The canonical recipes and `EXPLAIN` checks live in [EQL indexes](https://cipherstash.com/docs/reference/eql/indexes).
Runtime and authentication [#runtime-and-authentication]
Local development uses the CipherStash developer profile created by `stash init`. CI and deployed applications use credentials created with the CLI or Dashboard. [Credentials](https://cipherstash.com/docs/integrations/prisma/deployment#credentials) lists all three options and the four deployment environment variables.
The Prisma adapter currently uses the native Stack client, so deploy it to a server runtime that can load native packages; it is not an edge-runtime adapter.
For a new project, continue with the [Quickstart](https://cipherstash.com/docs/integrations/prisma/quickstart).
# Prisma Compute
Source: https://cipherstash.com/docs/integrations/prisma/prisma-compute
[Prisma Compute](https://www.prisma.io/docs/compute) deploys TypeScript applications alongside Prisma Postgres. CipherStash has been exercised with Prisma Compute's July 2026 public beta; verify fast-moving CLI and platform details against the current Prisma documentation.
Before the first deploy [#before-the-first-deploy]
The local developer profile is not available on Prisma Compute. Create deployment credentials with `stash env` or the Dashboard, then add all four variables to both the preview and production roles.
These values are needed during the build as well as at runtime because a database module may construct `cipherstashFromStack` when it is imported. Prisma Compute resolves environment variables when it creates a deployment, so redeploy after changing them.
Use separate credentials for preview and production, bound to the keyset intended for each environment.
{/* Screenshot candidate: Prisma Compute environment-variable screen showing the
four CS_* key names, preview/production scopes, and hidden values. */}
Keep native packages external [#keep-native-packages-external]
The Prisma adapter uses CipherStash's native client. For Next.js, exclude its packages from the server bundle:
```typescript title="next.config.ts"
import type { NextConfig } from "next"
const nextConfig: NextConfig = {
serverExternalPackages: [
"@cipherstash/stack",
"@cipherstash/protect-ffi",
"@cipherstash/auth",
],
}
export default nextConfig
```
Do not select an edge runtime for routes that use this Prisma adapter.
Understand push-to-deploy [#understand-push-to-deploy]
A Prisma Compute deployment runs contract emission and `prisma-next db init` against the target branch database.
* Additive changes, including the EQL bundle and new encrypted columns, are reconciled during deployment.
* Destructive changes such as dropping the old plaintext column or setting `NOT NULL` are rejected by the additive-only deployment policy.
* Preview branches receive fresh databases, so a green preview does not prove that a destructive production update will succeed.
Use separate pull requests for each stage in the [Prisma deployment guide](https://cipherstash.com/docs/integrations/prisma/deployment).
Apply destructive migrations deliberately [#apply-destructive-migrations-deliberately]
After the release that stops writing the plaintext column is live, apply the reviewed destructive migration directly to the production database before merging the contract change:
```bash
npx @prisma/cli database list
npx @prisma/cli database show --json
npx @prisma/cli database connection create
npx prisma-next db update --db ""
npx @prisma/cli database connection remove
```
Confirm the production database by name and with `database show`; do not rely on list order or branch metadata. A migration applied to the wrong preview database can succeed while the production deployment continues to fail.
The destructive migration must include an apply-time coverage guard so the plaintext column is not dropped while any row lacks ciphertext.
Operational notes [#operational-notes]
* Keep authorization checks in the page, server action, or route handler rather than relying only on Next.js middleware.
* Runtime output and build output use different Prisma commands: `app logs` and `build logs `.
* A first request after scale-to-zero can cold-start; retry before treating it as an application failure.
{/* Screenshot candidate: Prisma Compute branch page showing an application,
its linked Prisma Postgres database, and separate production/preview state. */}
Prisma Compute is in public beta. Reconfirm platform limitations before using it for a mission-critical workload.
# Prisma Postgres
Source: https://cipherstash.com/docs/integrations/prisma/prisma-postgres
[Prisma Postgres](https://www.prisma.io/docs/postgres) is Prisma's managed Postgres service. CipherStash uses it like any other Postgres database: encryption happens in the application, and EQL plus the encrypted domains live in the database.
Choose the connection URL [#choose-the-connection-url]
Prisma Postgres provides pooled and direct connections:
| Use | Connection |
| ------------------------------------------------------ | ----------------------------------- |
| Application runtime | Pooled URL on `pooled.db.prisma.io` |
| Migrations, administrative work, and one-off backfills | Direct URL on `db.prisma.io` |
Both connections require TLS. Copy the URLs from the Prisma Console and keep them in the relevant environment's secret store.
```dotenv title=".env"
DATABASE_URL=postgresql://...@pooled.db.prisma.io:5432/postgres?sslmode=require
DIRECT_URL=postgresql://...@db.prisma.io:5432/postgres?sslmode=require
```
Use the direct URL when applying the Prisma migration graph or running a long-lived backfill. Use the pooled URL when connecting the deployed application.
{/* Screenshot candidate: Prisma Console connection dialog with pooled and direct
connection choices visible, project names retained, and credentials redacted. */}
Initialize the database [#initialize-the-database]
Set the migration process to the direct connection, then run the normal Prisma flow:
```bash
DATABASE_URL="$DIRECT_URL" npx prisma-next contract emit
DATABASE_URL="$DIRECT_URL" npx prisma-next migration plan --name initial
DATABASE_URL="$DIRECT_URL" npx prisma-next migrate
```
This installs EQL through Prisma's migration graph. Do not install EQL separately with the `stash` CLI.
For a populated column, use the direct connection for the out-of-band backfill and confirm that it targets the intended production or preview database. Follow the [Prisma deployment guide](https://cipherstash.com/docs/integrations/prisma/deployment) before changing live data.
What appears in Prisma tools [#what-appears-in-prisma-tools]
Prisma Studio and the Prisma Console see EQL ciphertext payloads, not plaintext. That is expected: encryption keys remain in the application, outside Prisma Postgres. Read and update encrypted values through the CipherStash-enabled Prisma runtime.
{/* Screenshot candidate: Prisma Studio showing one encrypted field as an EQL
ciphertext payload beside a non-sensitive plaintext field. */}
Branch databases [#branch-databases]
Prisma platform branches can have isolated databases. Treat each branch as a separate CipherStash environment:
* Confirm the database identity before migrations or backfills.
* Use separate `CS_*` credentials for preview and production.
* Keep every writer and one-off job on the keyset intended for that environment.
If the application is also hosted by Prisma, [Prisma Compute](https://cipherstash.com/docs/integrations/prisma/prisma-compute) explains its build, environment-variable, and migration behavior.
# Quickstart
Source: https://cipherstash.com/docs/integrations/prisma/quickstart
This tutorial adds an encrypted, searchable email field to an existing Prisma ORM 8 release candidate project.
Prisma ORM 8 was formerly called Prisma Next. Its prerelease command remains `prisma-next`, while CipherStash initialization uses `--prisma`.
It is designed for a new table or empty column. To encrypt a populated column safely, use the [Prisma deployment guide](https://cipherstash.com/docs/integrations/prisma/deployment).
Before you start [#before-you-start]
You need:
* A Prisma ORM 8 release candidate project with `prisma-next.config.ts`
* A Postgres database and `DATABASE_URL`
* A CipherStash account; initialization signs you in
Initialize CipherStash [#initialize-cipherstash]
From the Prisma project, run:
```bash cta cta-type="install" example-id="prisma-quickstart-init"
npx stash init --prisma
```
`stash init` opens the CipherStash device login when necessary, creates the local developer profile, and installs compatible pinned versions of `@cipherstash/stack`, `@cipherstash/stack-prisma`, and the `stash` CLI.
It intentionally does not install EQL directly. The Prisma migration graph owns that step.
Agents can run the same setup. If no developer profile exists, the agent should start `npx stash auth login --json --region --prisma`, present the returned verification URL, and wait for you to complete device login. It can then run `npx stash init --prisma --region `.
Initialization records project context and can install the CipherStash Prisma, authentication, indexing, deployment, and CLI skills for supported coding agents.
Declare an encrypted field [#declare-an-encrypted-field]
Add the CipherStash type to your schema:
```prisma title="prisma/schema.prisma"
model User {
id String @id
email cipherstash.TextSearch()
}
```
`TextSearch()` supports encrypted equality, range, ordering, and token matching. If you only need equality, prefer `TextEq()`. See [Schema and queries](https://cipherstash.com/docs/integrations/prisma/schema-and-queries) for every column type.
Register the extension pack [#register-the-extension-pack]
Add CipherStash to your existing Prisma configuration:
```typescript title="prisma-next.config.ts"
import cipherstash from "@cipherstash/stack-prisma/control"
import { defineConfig } from "@prisma-next/cli/config-types"
import { prismaContract } from "@prisma-next/sql-contract-psl/provider"
import postgresPack from "@prisma-next/target-postgres/pack"
import { postgresCreateNamespace } from "@prisma-next/target-postgres/types"
export default defineConfig({
// Keep your existing family, target, driver, adapter, and database settings.
extensionPacks: [cipherstash],
contract: prismaContract("./prisma/schema.prisma", {
output: "src/prisma/contract.json",
target: postgresPack,
createNamespace: postgresCreateNamespace,
}),
migrations: { dir: "migrations" },
})
```
If you already use extension packs, include `cipherstash` in the existing array. `createNamespace` is required by Prisma's 0.15 and later prereleases.
Emit and migrate [#emit-and-migrate]
Generate the contract, plan the migration, and apply it:
```bash
npx prisma-next contract emit
npx prisma-next migration plan --name add-encrypted-user
npx prisma-next migrate
```
The final command installs EQL v3 and applies your application migration in one graph. Do not run `stash eql install` for this integration.
Connect the encrypted runtime [#connect-the-encrypted-runtime]
Create the database module from the emitted contract:
```typescript title="src/db.ts"
import "dotenv/config"
import { cipherstashFromStack } from "@cipherstash/stack-prisma/v3"
import postgres from "@prisma-next/postgres/runtime"
import type { Contract } from "./prisma/contract.d"
import contractJson from "./prisma/contract.json" with { type: "json" }
const cipherstash = await cipherstashFromStack({ contractJson })
export const db = postgres({
contractJson,
extensions: cipherstash.extensions,
middleware: cipherstash.middleware,
})
```
`cipherstashFromStack` uses the local developer profile automatically. For CI or a deployed application, see [Credentials](https://cipherstash.com/docs/integrations/prisma/deployment#credentials) for the CLI and Dashboard options.
Write and query encrypted data [#write-and-query-encrypted-data]
Wrap plaintext values at the write boundary, then use the generated `eql*` operators:
```typescript
import {
decryptAll,
EncryptedString,
} from "@cipherstash/stack-prisma/runtime"
import { db } from "./db"
const runtime = await db.connect({ url: process.env.DATABASE_URL! })
try {
await db.orm.public.User.create({
id: "user-0",
email: EncryptedString.from("alice@example.com"),
})
const rows = await db.orm.public.User
.where((user) => user.email.eqlEq("alice@example.com"))
.all()
await decryptAll(rows)
console.log(await rows[0]?.email.decrypt())
// alice@example.com
} finally {
await runtime.close()
}
```
The write value and query operand are encrypted before reaching Postgres. `decryptAll` batches result decryption; `.decrypt()` returns the plaintext value.
Next steps [#next-steps]
* Choose other encrypted field types and operators in [Schema and queries](https://cipherstash.com/docs/integrations/prisma/schema-and-queries).
* Add functional indexes using [EQL indexes](https://cipherstash.com/docs/reference/eql/indexes); keep their raw SQL operations in the Prisma migration graph.
* Follow the [Prisma deployment guide](https://cipherstash.com/docs/integrations/prisma/deployment) before changing a populated production column.
* Continue with [Prisma Postgres](https://cipherstash.com/docs/integrations/prisma/prisma-postgres) or [Prisma Compute](https://cipherstash.com/docs/integrations/prisma/prisma-compute) if you use Prisma's hosted platform.
# Schema and queries
Source: https://cipherstash.com/docs/integrations/prisma/schema-and-queries
The CipherStash Prisma extension separates the encrypted **column type** from the runtime **value envelope**:
* In `schema.prisma`, a domain-named constructor such as `TextEq()` fixes the Postgres plaintext family and searchable capabilities.
* In application code, a primitive-named envelope such as `EncryptedString` wraps a plaintext value for encryption.
Column constructors [#column-constructors]
Choose the plaintext type first, then the narrowest query capability your application needs.
| Plaintext | Storage only | Equality | Order and range | Free-text only | All text queries |
| -------------------- | -------------------------------------------------- | --------------- | ---------------- | -------------- | ---------------- |
| `string` | `Text()` | `TextEq()` | `TextOrd()` | `TextMatch()` | `TextSearch()` |
| `number` (`int4`) | `Integer()` | `IntegerEq()` | `IntegerOrd()` | — | — |
| `number` (`int2`) | `Smallint()` | `SmallintEq()` | `SmallintOrd()` | — | — |
| `bigint` (`int8`) | `BigInt()` | `BigIntEq()` | `BigIntOrd()` | — | — |
| `number` (`numeric`) | `Numeric()` | `NumericEq()` | `NumericOrd()` | — | — |
| `number` (`float4`) | `Real()` | `RealEq()` | `RealOrd()` | — | — |
| `number` (`float8`) | `Double()` | `DoubleEq()` | `DoubleOrd()` | — | — |
| `Date` (`date`) | `Date()` | `DateEq()` | `DateOrd()` | — | — |
| `Date` (`timestamp`) | `Timestamp()` | `TimestampEq()` | `TimestampOrd()` | — | — |
| `boolean` | `Boolean()` | — | — | — | — |
| JSON document | `Json()` supports containment and JSONPath queries | — | — | — | — |
Every `*Ord()` constructor includes equality. `TextMatch()` provides token matching without equality; `TextSearch()` combines equality, range, ordering, and token matching. Bare constructors such as `Text()` are storage-only.
Each constructor maps directly to an EQL v3 Postgres domain. For example, `cipherstash.DoubleOrd()` creates an `eql_v3_double_ord` column. The type cannot be broadened at query time.
Runtime envelopes [#runtime-envelopes]
| Schema family | Write envelope |
| ------------------------------------------------------- | ------------------------------ |
| `Text*` | `EncryptedString.from(value)` |
| `Integer*`, `Smallint*`, `Numeric*`, `Real*`, `Double*` | `EncryptedNumber.from(value)` |
| `BigInt*` | `EncryptedBigInt.from(value)` |
| `Date*`, `Timestamp*` | `EncryptedDate.from(value)` |
| `Boolean` | `EncryptedBoolean.from(value)` |
| `Json` | `EncryptedJson.from(value)` |
Import envelopes and `decryptAll` from `@cipherstash/stack-prisma/runtime`.
```typescript
import {
decryptAll,
EncryptedDate,
EncryptedNumber,
EncryptedString,
} from "@cipherstash/stack-prisma/runtime"
await db.orm.public.User.create({
id: "user-0",
email: EncryptedString.from("alice@example.com"),
salary: EncryptedNumber.from(100_000),
birthday: EncryptedDate.from(new Date("1990-01-01")),
})
const rows = await db.orm.public.User.all()
await decryptAll(rows)
```
`decryptAll` groups a result set by table and column to avoid one encryption-service round trip per value. Call `.decrypt()` on an envelope after the batch completes.
Query operators [#query-operators]
Operators are generated only where the declared domain supports them.
| Operator | Meaning |
| --------------------------------------------------- | ------------------------------ |
| `eqlEq(value)`, `eqlNeq(value)` | Equality and inequality |
| `eqlIn(values)`, `eqlNotIn(values)` | Set membership |
| `eqlMatch(term)` | Free-text token match |
| `eqlGt/Gte/Lt/Lte(value)` | Range comparison |
| `eqlBetween(low, high)`, `eqlNotBetween(low, high)` | Bounded range |
| `eqlAsc(column)`, `eqlDesc(column)` | Encrypted ordering |
| `eqlJsonContains(value)` | JSON containment |
| `eqlJsonPathEq/Neq(path, value)` | Equality at a JSONPath |
| `eqlJsonPathGt/Gte/Lt/Lte(path, value)` | Range comparison at a JSONPath |
| `eqlJsonPathAsc/Desc(column, path)` | Ordering by a JSONPath leaf |
```typescript
import {
eqlAsc,
eqlJsonPathDesc,
} from "@cipherstash/stack-prisma/runtime"
const matches = await db.orm.public.User
.where((user) => user.email.eqlMatch("example.com"))
.all()
const earners = await db.orm.public.User
.where((user) => user.salary.eqlBetween(100_000, 150_000))
.orderBy((user) => eqlAsc(user.salary))
.all()
const preferences = await db.orm.public.User
.where((user) => user.profile.eqlJsonContains({ theme: "dark" }))
.orderBy((user) => eqlJsonPathDesc(user.profile, "$.score"))
.all()
```
Free-text search is token matching, not SQL `ILIKE`. Pass a term such as `example.com`, not a wildcard pattern such as `%example.com%`.
Indexes [#indexes]
Encrypted predicates require functional Postgres indexes at meaningful scale. `schema.prisma` cannot express expression indexes, so put the index DDL in a Prisma raw-SQL migration operation and apply it with `prisma-next migrate`.
The domain-to-index matrix, SQL recipes, rollout timing, `ANALYZE`, and `EXPLAIN` verification are maintained in [EQL indexes](https://cipherstash.com/docs/reference/eql/indexes).
Subpath exports [#subpath-exports]
| Import | Purpose |
| ---------------------------------------- | --------------------------------------------- |
| `@cipherstash/stack-prisma/control` | Prisma extension pack |
| `@cipherstash/stack-prisma/v3` | `cipherstashFromStack` and the EQL v3 adapter |
| `@cipherstash/stack-prisma/runtime` | Envelopes, `decryptAll`, and query helpers |
| `@cipherstash/stack-prisma/column-types` | TypeScript-authored contract factories |
# DynamoDB
Source: https://cipherstash.com/docs/integrations/aws/dynamodb
CipherStash's DynamoDB helper encrypts and decrypts items without wrapping the
AWS SDK. Your application keeps control of every `PutCommand`, `GetCommand`,
and `QueryCommand`; `encryptedDynamoDB` transforms the item immediately before
a write and after a read.
DynamoDB does not use EQL. Equality-enabled attributes store an HMAC search
term alongside the ciphertext so they can participate in key conditions.
Install [#install]
```bash cta cta-type="install" example-id="install-dynamodb"
npm install @cipherstash/stack @aws-sdk/client-dynamodb @aws-sdk/lib-dynamodb
```
Define the encrypted attributes [#define-the-encrypted-attributes]
Use the v3 schema builder. `TextEq` produces an equality term; `Text` is
storage-only.
```typescript filename="encryption.ts"
import { Encryption } from "@cipherstash/stack"
import { encryptedDynamoDB } from "@cipherstash/stack/dynamodb"
import { encryptedTable, types } from "@cipherstash/stack/v3"
export const users = encryptedTable("users", {
email: types.TextEq("email"),
name: types.Text("name"),
})
export const encryptionClient = await Encryption({ schemas: [users] })
export const dynamo = encryptedDynamoDB({ encryptionClient })
```
For an equality-enabled `email`, the encrypted item contains:
| Attribute | Purpose |
| --------------- | ------------------------------------------------------- |
| `email__source` | Ciphertext used for decryption |
| `email__hmac` | Equality term used in a partition key, sort key, or GSI |
Non-encrypted attributes pass through unchanged. Ordering and free-text terms
have no DynamoDB query surface and are not stored.
Encrypt and write an item [#encrypt-and-write-an-item]
```typescript filename="write-user.ts"
import { PutCommand } from "@aws-sdk/lib-dynamodb"
import { docClient } from "./aws"
import { dynamo, users } from "./encryption"
const encrypted = await dynamo.encryptModel(
{ pk: "user#1", email: "alice@example.com", name: "Alice", role: "admin" },
users,
)
if (encrypted.failure) throw encrypted.failure
await docClient.send(new PutCommand({
TableName: "Users",
Item: encrypted.data,
}))
```
The result retains `pk` and `role`, replaces `email` with `email__source` and
`email__hmac`, and replaces `name` with `name__source`.
Read and decrypt [#read-and-decrypt]
```typescript filename="read-user.ts"
import { GetCommand } from "@aws-sdk/lib-dynamodb"
const stored = await docClient.send(new GetCommand({
TableName: "Users",
Key: { pk: "user#1" },
}))
const decrypted = await dynamo.decryptModel(stored.Item ?? {}, users)
if (decrypted.failure) throw decrypted.failure
console.log(decrypted.data.email)
```
Use `bulkEncryptModels` and `bulkDecryptModels` before `BatchWriteCommand` and
after `BatchGetCommand` to process many items in one ZeroKMS round trip.
Query an equality-enabled attribute [#query-an-equality-enabled-attribute]
Encrypt the operand with the same table and column definition, then use its
HMAC as the DynamoDB key value:
```typescript filename="find-by-email.ts"
import { QueryCommand } from "@aws-sdk/lib-dynamodb"
const term = await encryptionClient.encryptQuery("alice@example.com", {
table: users,
column: users.email,
})
if (term.failure) throw term.failure
const result = await docClient.send(new QueryCommand({
TableName: "Users",
IndexName: "EmailIndex",
KeyConditionExpression: "email__hmac = :email",
ExpressionAttributeValues: { ":email": term.data.hm },
}))
const decrypted = await dynamo.bulkDecryptModels(result.Items ?? [], users)
if (decrypted.failure) throw decrypted.failure
```
An encrypted HMAC attribute can back a table key or GSI. Ciphertext source
attributes do not support ranges, `begins_with`, or `contains`.
Read items written by EQL v2 [#read-items-written-by-eql-v2]
Keep the current v3 table declaration and opt into legacy decoding while old
items remain:
```typescript
const decrypted = await dynamo.decryptModel(storedItem, users, {
storedEqlVersion: 2,
})
```
New writes always use the current format. Remove the option after every legacy
item has been rewritten.
For every method, option, and return type, see the generated
[DynamoDB API reference](https://cipherstash.com/docs/reference/stack/api-reference/dynamodb).
# Access keys
Source: https://cipherstash.com/docs/reference/auth/access-keys
Access keys authenticate non-interactive requests to CipherStash services such
as ZeroKMS and CTS. A deployed Stack SDK or Proxy client uses an access key
alongside its [client key](https://cipherstash.com/docs/reference/auth/clients).
Local development normally does not need one. `stash init` creates a
device-backed session and client key for the current developer. Use access
keys for production, CI, or workspace automation where an interactive login is
not available.
Create an access key [#create-an-access-key]
Open **Access Keys** for the workspace in the
[CipherStash Dashboard](https://dashboard.cipherstash.com/workspaces/_/access-keys),
select **Create access key**, and choose the least-privileged role that covers
the workload.
The key value is shown when it is created. Store it in the deployment's secret
manager as `CS_CLIENT_ACCESS_KEY`; do not commit it or share a developer key
with production.
Roles [#roles]
Member [#member]
Use `member` for applications performing cryptographic operations. It can list
keysets and generate or retrieve data-key material:
```text
keyset:list
data_key:generate
data_key:retrieve
```
Control [#control]
Use `control` for workspace automation that manages keysets and client access.
It can create, list, enable, disable, grant, modify, and revoke keysets, and
list clients. It cannot derive data keys.
Admin [#admin]
`admin` combines service administration and cryptographic permissions. Avoid
it in production applications: use `member` for runtime operations and
`control` for automation so a compromised credential has the smallest useful
scope.
Rotate or revoke a key [#rotate-or-revoke-a-key]
Create the replacement first, update every consumer, verify that the new key
is in use, and then delete the old key from the Dashboard. Rotating an access
key changes authentication; it does not re-encrypt stored data.
See [workspace configuration](https://cipherstash.com/docs/reference/workspace/configuration) for the full
production credential set and [Deployment](https://cipherstash.com/docs/guides/deployment) for rollout
gates.
# Client keys
Source: https://cipherstash.com/docs/reference/auth/clients
A client key is the application-held half of CipherStash's split key
architecture. It identifies a developer device or deployed application and is
granted access to one or more keysets. ZeroKMS never receives the client key.
Client key types [#client-key-types]
Device-backed client keys [#device-backed-client-keys]
`stash init` creates a device-backed client key for the current developer and
grants it access to the workspace's default keyset.
* Use it for local development only.
* Each developer and device gets a distinct key.
* Revoking one device does not affect other developers or production.
* No `CS_*` environment variables are required while the device session is
active.
Application client keys [#application-client-keys]
Create an application client key for production, CI, background jobs, or
Proxy—any environment without an interactive device login.
Open **Clients** in the
[CipherStash Dashboard](https://dashboard.cipherstash.com/workspaces/_/clients),
select **Create a new client**, and grant only the keysets that workload needs.
Store its ID and key value as `CS_CLIENT_ID` and `CS_CLIENT_KEY`.
Keyset access [#keyset-access]
A client can use only the keysets it has been granted. Separate keysets are a
cryptographic isolation boundary: a client without the grant cannot derive the
keys required to decrypt that data.
Grant access before deploying a workload. To revoke it, remove the client from
the keyset or delete the client. Revocation prevents future key derivation but
does not modify ciphertext already stored in your database.
See [key management](https://cipherstash.com/docs/concepts/key-management#keysets-define-the-isolation-boundary)
for the isolation model and [workspace configuration](https://cipherstash.com/docs/reference/workspace/configuration)
for production environment variables.
# Auth
Source: https://cipherstash.com/docs/reference/auth
CipherStash separates the credentials used by developers, deployed services,
and signed-in end users. Choose the mechanism that matches who is performing
the cryptographic operation.
| Context | Authentication | Use it for |
| ------------------ | -------------------------------------- | ------------------------------------------------------------ |
| Local development | Device session created by `stash init` | Per-developer access without shared environment variables |
| Production and CI | Application client key plus access key | Non-interactive SDK and Proxy deployments |
| Signed-in end user | OIDC federation | Identity-bound encryption and user-attributed key derivation |
In this section [#in-this-section]
* [Access keys](https://cipherstash.com/docs/reference/auth/access-keys) authenticate programmatic requests
to CipherStash services and define their service-level permissions.
* [Client keys](https://cipherstash.com/docs/reference/auth/clients) supply the client-held half of the
ZeroKMS key split and scope access to keysets.
* [OIDC providers](https://cipherstash.com/docs/reference/auth/oidc-configuration) register an identity
provider for end-user federation.
For the four environment variables used by deployed applications, see
[workspace configuration](https://cipherstash.com/docs/reference/workspace/configuration). For the
cryptographic effect of binding a value to an identity claim, see
[provable access control](https://cipherstash.com/docs/solutions/provable-access).
# OIDC providers
Source: https://cipherstash.com/docs/reference/auth/oidc-configuration
Register an OpenID Connect provider when encryption or decryption must be
performed as the signed-in user. CipherStash federates the provider's JWT into
a short-lived service token; the application does not send an OIDC client
secret to CipherStash.
OIDC is optional. Applications that authenticate only as a deployed service
use an [application client key](https://cipherstash.com/docs/reference/auth/clients) and
[access key](https://cipherstash.com/docs/reference/auth/access-keys) instead.
Supported providers [#supported-providers]
* Auth0
* Clerk
* Okta
* Supabase Auth
Register a provider [#register-a-provider]
1. Open **Authentication → OIDC Providers** for the workspace in the
[Dashboard](https://dashboard.cipherstash.com/workspaces/_/oidc-providers).
2. Select **Add OIDC Provider**.
3. Choose the vendor and enter the issuer URL from the provider's OIDC
discovery document.
| Provider | Example issuer |
| -------- | ----------------------------------------- |
| Auth0 | `https://your-tenant.auth0.com/` |
| Clerk | `https://your-app.clerk.accounts.dev/` |
| Okta | `https://your-org.okta.com/` |
| Supabase | `https://project-ref.supabase.co/auth/v1` |
For Supabase, the [Dashboard integration](https://cipherstash.com/docs/integrations/supabase) can register
the project issuer for you.
CipherStash stores the provider vendor and issuer. Token signatures are
validated using the issuer's published JWKS; no provider client secret is
stored.
Use the provider from Stack [#use-the-provider-from-stack]
Configure `OidcFederationStrategy` with a callback that returns the current
user's JWT:
```typescript filename="encryption.ts"
import { Encryption, OidcFederationStrategy } from "@cipherstash/stack"
const encryption = await Encryption({
schemas: [patients],
config: {
authStrategy: OidcFederationStrategy.create(
process.env.CS_WORKSPACE_CRN,
() => getCurrentUserJwt(),
),
},
})
```
The callback must return the current token rather than a token captured once
at startup, because the strategy invokes it again when federation needs to be
renewed.
Continue with [provable access control](https://cipherstash.com/docs/solutions/provable-access) to bind
encryption to an identity claim using a lock context.
# Overview
Source: https://cipherstash.com/docs/integrations/drizzle
Drizzle keeps its shape. You declare each encrypted column with a concrete EQL type, and a set of query operators encrypt their operands before Drizzle builds the SQL. Your `select`, `where`, and `orderBy` read as they always did, and the database only ever compares ciphertext.
Install [#install]
```bash cta cta-type="install" example-id="install-drizzle"
npm install @cipherstash/stack @cipherstash/stack-drizzle drizzle-orm
npm install --save-dev drizzle-kit
```
Add EQL to your Drizzle migration history:
```bash
npx stash eql migration --drizzle
npx drizzle-kit migrate
```
`stash eql migration --drizzle` uses your project-local `drizzle-kit` to create a custom migration, then fills it with the EQL v3 install SQL. Pass `--out` if your migration directory is not `drizzle/`. For a direct, out-of-band install instead, run `npx stash eql install`.
Credentials [#credentials]
The native Stack client used below discovers the four `CS_*` variables first, then falls back to the developer profile. Use separate credentials for each deployed environment.
Declare the table [#declare-the-table]
The column type *is* the capability. There are no flags to configure. `TextEq` answers equality and nothing else, `IntegerOrd` answers ranges and ordering, `TextMatch` answers free-text matching, and a bare `Text` or `Bigint` is storage-only.
```typescript filename="src/schema.ts"
import { pgTable, integer } from "drizzle-orm/pg-core"
import { encryptedIndexes, types } from "@cipherstash/stack-drizzle"
export const users = pgTable(
"users",
{
id: integer("id").primaryKey().generatedAlwaysAsIdentity(),
email: types.TextEq("email"), // equality
age: types.IntegerOrd("age"), // ranges, ordering, and equality
bio: types.TextMatch("bio"), // free-text token matching
balance: types.Bigint("balance"), // storage only
},
(table) => [...encryptedIndexes(table)],
)
```
Each factory maps to the matching EQL domain, so `types.TextEq("email")` types the column as `public.eql_v3_text_eq`. The variant model behind those names is in [core concepts](https://cipherstash.com/docs/reference/eql/core-concepts).
| Factory | Capability | EQL domain |
| ------------------------ | ----------------------------------- | --------------------------- |
| `types.Text(name)` | Store and decrypt only | `public.eql_v3_text` |
| `types.TextEq(name)` | `eq`, `ne`, `inArray`, `notInArray` | `public.eql_v3_text_eq` |
| `types.TextOrd(name)` | Ranges, ordering, plus equality | `public.eql_v3_text_ord` |
| `types.TextMatch(name)` | `matches` | `public.eql_v3_text_match` |
| `types.TextSearch(name)` | All of the above, on text | `public.eql_v3_text_search` |
| `types.IntegerOrd(name)` | Ranges, ordering, plus equality | `public.eql_v3_integer_ord` |
The same bare / `Eq` / `Ord` pattern exists for `Smallint`, `Bigint`, `Real`, `Double`, `Numeric`, `Date`, and `Timestamp`. `Boolean` is storage-only by design, because a two-value column has too little cardinality for any searchable index to be safe.
Declare only the capability you query on. Each one stores an extra index term alongside the ciphertext, with a bounded, published leakage profile: see [searchable encryption](https://cipherstash.com/docs/concepts/searchable-encryption).
Wire up the client [#wire-up-the-client]
Derive the encryption schema from the Drizzle table, build a typed client, and create the operators:
```typescript filename="src/db.ts"
import { drizzle } from "drizzle-orm/postgres-js"
import {
createEncryptionOperators,
extractEncryptionSchema,
} from "@cipherstash/stack-drizzle"
import { Encryption } from "@cipherstash/stack"
import { users } from "./schema"
export const usersSchema = extractEncryptionSchema(users)
export const client = await Encryption({ schemas: [usersSchema] })
export const ops = createEncryptionOperators(client)
export const db = drizzle({ client: sqlClient })
```
`extractEncryptionSchema` reads the encryption config straight off the column types, so there is no second schema to keep in sync with the first.
Query [#query]
Every where-clause operator is **async**, because it encrypts its operand before Drizzle sees it. `await` each one. `ops.asc` and `ops.desc` are synchronous.
```typescript filename="src/queries.ts"
import { db, ops } from "./db"
import { users } from "./schema"
// Equality — email is TextEq
const exact = await db.select().from(users)
.where(await ops.eq(users.email, "alice@example.com"))
// Ranges and ordering — age is IntegerOrd
const adults = await db.select().from(users)
.where(await ops.gte(users.age, 18))
.orderBy(ops.asc(users.age))
const midBand = await db.select().from(users)
.where(await ops.between(users.age, 25, 40))
// Set membership, built on equality
const listed = await db.select().from(users)
.where(await ops.inArray(users.email, ["alice@example.com", "bob@example.com"]))
// Free-text token containment — bio is TextMatch
const coffee = await db.select().from(users)
.where(await ops.matches(users.bio, "coffee"))
```
The full operator set is `eq`, `ne`, `gt`, `gte`, `lt`, `lte`, `between`, `notBetween`, `matches`, `contains`, `selector`, `inArray`, `notInArray`, `exists`, `notExists`, `and`, `or`, `not`, `isNull`, `isNotNull`, `asc`, and `desc`. Null checks need no encryption, because a SQL `NULL` is never encrypted. See the [API reference](https://cipherstash.com/docs/integrations/drizzle/api-reference#createencryptionoperators) for signatures and per-operator capability requirements.
Applying an operator the column's type cannot answer throws `EncryptionOperatorError` rather than silently returning wrong rows. Ordering a `TextEq` column, for instance, has no ordering term to compare.
There is no `like` or `ilike`. SQL pattern matching is meaningless on ciphertext, so free-text search is `ops.matches`, which compares encrypted token sets. It matches whole indexed tokens rather than arbitrary substrings. `ops.contains` is reserved for encrypted JSON containment.
Insert and read [#insert-and-read]
Rows are encrypted **before** they reach Drizzle, so Drizzle never sees plaintext. Encrypt a batch in one call, which is also one ZeroKMS round trip:
```typescript filename="src/insert.ts"
import { client, db, usersSchema } from "./db"
import { users } from "./schema"
const rows = await client.bulkEncryptModels(
[
{ email: "alice@example.com", age: 30, bio: "climbing and coffee", balance: 100_000n },
{ email: "bob@example.com", age: 41, bio: "cycling and coffee", balance: 250_000n },
],
usersSchema,
)
if (rows.failure) {
throw new Error(rows.failure.message)
}
await db.insert(users).values(rows.data)
```
`Bigint` columns take a native JS `bigint`. Decrypt what comes back with `client.bulkDecryptModels(rows)`, which is likewise one round trip for the batch.
Indexes [#indexes]
`encryptedIndexes(table)` derives the recommended functional indexes from each encrypted column's capabilities. In the schema above it produces equality, ordering, and free-text indexes while ignoring the storage-only `balance` column. Generate and apply the result through your normal `drizzle-kit` migration workflow, then run `ANALYZE users`.
See [`encryptedIndexes`](https://cipherstash.com/docs/integrations/drizzle/api-reference#encryptedindexes) for the emitted index forms. Index selection, `EXPLAIN` verification, and large-table build guidance are in [EQL indexes](https://cipherstash.com/docs/reference/eql/indexes).
Where to next [#where-to-next]
Exported column types, schema helpers, codecs, indexes, and encrypted query operators.
Drizzle over a Supabase Postgres connection.
The variant model behind each column type.
What each capability reveals, and how to choose.
The functional-index recipes behind every query on this page.
# Booleans
Source: https://cipherstash.com/docs/reference/eql/booleans
Every scalar type has a storage-only variant — for `bool` it's the only one. EQL ships `public.eql_v3_boolean` and nothing else: there is no `bool_eq` and no `bool_ord`. An encrypted boolean column can be stored, decrypted, and null-checked; it cannot be filtered, sorted, grouped, or joined on.
Why there are no query variants [#why-there-are-no-query-variants]
A two-value column has too little cardinality for any searchable index to be safe. An equality term over `true` / `false` would partition the table into two visible buckets — leaking the value distribution (and, with any outside knowledge, the values themselves) outright. Rather than ship an index term that can't keep its promise, EQL omits the query variants entirely. See [Searchable encryption](https://cipherstash.com/docs/concepts/searchable-encryption) for the general analysis of what index terms reveal.
What works, what raises [#what-works-what-raises]
`public.eql_v3_boolean` follows the bare-variant contract described in [Core concepts](https://cipherstash.com/docs/reference/eql/core-concepts#variants-declare-capability): it carries no index terms, so `IS NULL` / `IS NOT NULL` are the only predicates that work. Every comparison operator routes to a blocker and raises — the [fail-loud behavior](https://cipherstash.com/docs/reference/eql/core-concepts#unsupported-operations-fail-loudly) shared by all encrypted variants:
```sql
-- ❌ Raises: operator = is not supported for public.eql_v3_boolean
SELECT * FROM users WHERE is_active = $1::public.eql_v3_boolean;
-- ✅ Works: NULL columns are not encrypted
SELECT * FROM users WHERE is_active IS NOT NULL;
```
Filter client-side [#filter-client-side]
Query on other columns, decrypt the boolean in your application, and filter there:
```sql
CREATE TABLE users (
id bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
email public.eql_v3_text_eq, -- exact lookup
created_at public.eql_v3_timestamp_ord, -- range queries, ORDER BY
is_active public.eql_v3_boolean -- storage only (by design)
);
```
```sql
-- Narrow the result set with the columns that do carry index terms…
SELECT id, email, is_active FROM users
WHERE created_at >= $1::public.eql_v3_timestamp_ord;
-- …then decrypt is_active in the client and filter on the plaintext.
```
The [Stack SDK](https://cipherstash.com/docs/reference/stack) and [CipherStash Proxy](https://cipherstash.com/docs/reference/proxy) decrypt the payload back to a plain boolean on read, so the client-side filter is an ordinary `if`.
If a boolean genuinely needs to be a server-side predicate, that is a data-modelling signal: consider whether the flag is actually sensitive. A non-sensitive flag can stay a plain PostgreSQL `boolean` column alongside your encrypted columns.
Storing without querying [#storing-without-querying]
`bool` is the forced case of a pattern available to every scalar type: the bare variant `public.eql_v3_` (for example `public.eql_v3_integer`, `public.eql_v3_text`, `public.eql_v3_timestamp`) is storage-and-decryption only. It carries no index terms, and every comparison operator raises — use it for columns you only ever store and decrypt, so the database holds no searchable material for them at all.
For every type other than `bool`, storage-only is a choice you can walk back. If you later need to query, retype the column as a query variant — or, if the payloads already carry the needed term (the client decides which terms travel in the payload), cast at the call site:
```sql
SELECT * FROM readings WHERE value::public.eql_v3_integer_ord > $1::public.eql_v3_integer_ord;
```
The variant families and what each one enables are covered in [Core concepts](https://cipherstash.com/docs/reference/eql/core-concepts); the per-type specifics live in [Numbers](https://cipherstash.com/docs/reference/eql/numbers), [Dates & times](https://cipherstash.com/docs/reference/eql/dates-and-times), and [Text](https://cipherstash.com/docs/reference/eql/text).
# Core concepts
Source: https://cipherstash.com/docs/reference/eql/core-concepts
Everything in the EQL reference builds on four ideas: columns are typed as **domain variants** that declare what they can do, every value is a **`jsonb` payload** carrying encrypted index terms, **operands must be typed** for the encrypted operators to resolve, and anything a column can't do **fails loudly** instead of returning wrong rows. This page is the canonical home for all four — the per-type and per-query pages link back here rather than restating them.
Variants declare capability [#variants-declare-capability]
EQL ships its searchable-encryption surface as PostgreSQL **domains in the `public` schema**, all backed by `jsonb` (the functions behind them live in `eql_v3` — [The three schemas](#the-three-schemas) explains the split). Each scalar type generates a *family* of domain variants, and the variant you type a column as fixes its query capability. Each domain carries a `CHECK` constraint that validates the encrypted payload on insert, so a malformed or wrong-version value is rejected at write time rather than surfacing at query time.
There is no database-side configuration table. Earlier EQL versions tracked encryption config in the database (`config_add_table`, `config_add_column`, and friends) — those are gone in v3. The searchable surface of a column is fixed by the domain variant you type it as, and which index terms travel in a value's payload is decided by the encryption client (the [Stack SDK](https://cipherstash.com/docs/reference/stack) or [CipherStash Proxy](https://cipherstash.com/docs/reference/proxy)). The domain makes the matching operators resolve; the term in the payload is what makes them answer.
For any scalar type ``, the family looks like this:
| Domain variant | Capability |
| ------------------------------------------- | ------------------------------------------------------------------------------------------ |
| `public.eql_v3_` | Storage and decryption only. |
| `public.eql_v3__eq` | Equality: `=`, `<>`, `IN`, `GROUP BY`, `DISTINCT`, equijoins. |
| `public.eql_v3__ord` | Comparisons (`<` … `>=`), `BETWEEN`, `ORDER BY`, `MIN` / `MAX` — plus equality. |
| `public.eql_v3__ord_ope` | The byte-identical twin of `_ord`, with OPE pinned. See [SEM specifiers](#sem-specifiers). |
| `public.eql_v3__ord_ore` | As `_ord`, with block-ORE pinned. |
| `public.eql_v3_text_match` (text only) | Free-text fuzzy match: `@@`. |
| `public.eql_v3_text_search` (text only) | Equality + ordering + fuzzy match. |
| `public.eql_v3_text_search_ore` (text only) | As `text_search`, with block-ORE pinned. |
Every public domain name carries the `eql_v3_` prefix. It keeps EQL's types from shadowing built-in Postgres type names such as `text` and `json`, and gives each EQL version its own column-type namespace so two versions can coexist. Query-operand domains live in the versioned `eql_v3` schema already, so they are unprefixed: `eql_v3.query_text_eq`, `eql_v3.query_json`.
Two things worth calling out:
* **The bare variant blocks everything.** `public.eql_v3_` carries no index term. Querying it with any comparison operator raises an "operator not supported" exception. Use it for columns you only ever store and decrypt — [Booleans](https://cipherstash.com/docs/reference/eql/booleans) covers this pattern in full.
* **Which index term backs each capability** is an implementation detail of the payload — covered in [Anatomy of an encrypted value](#anatomy-of-an-encrypted-value) below.
SEM specifiers [#sem-specifiers]
A trailing mechanism suffix — the `_ope` in `_ord_ope` — is a **SEM specifier**: it pins *which* searchable-encryption mechanism implements the capability, rather than just declaring the capability itself.
| Variant | Mechanism | Term | Extractor |
| ----------------- | ------------------------------------------ | ---------------- | ----------------------------------------- |
| `_ord` | CLLW OPE (the default) | `op` | `eql_v3.ord_term(col)` |
| `_ord_ope` | CLLW OPE, pinned. Byte-identical to `_ord` | `op` | `eql_v3.ord_term(col)` |
| `_ord_ore` | Block-ORE, pinned | `ob` | `eql_v3.ord_term_ore(col)` |
| `text_search` | CLLW OPE for its ordering term | `hm`, `op`, `bf` | `eq_term` / `ord_term` / `match_term` |
| `text_search_ore` | Block-ORE for its ordering term | `hm`, `ob`, `bf` | `eq_term` / `ord_term_ore` / `match_term` |
The two mechanisms differ in what they demand of the database, not in the capability they declare. `eql_v3_internal.ope_cllw` is a domain over `bytea`, so an ordered functional index on `eql_v3.ord_term(col)` binds `bytea_ops`, the base type's **default** operator class. It works anywhere you can `CREATE INDEX`, with no superuser.
Block-ORE's operator class is hand-written for a composite type and needs superuser to create.
On a database where EQL cannot create that operator class (cloud Supabase and most managed Postgres), the installer **disables every ORE-backed domain**. The types still exist, but a `CHECK` constraint rejects the first value written to one, raising `feature_not_supported` and naming the alternative to use. That is deliberate: installing them anyway leaves `<` and `>` running as unindexable sequential scans while `CREATE INDEX ... (eql_v3.ord_term_ore(col))` fails with an opaque Postgres error. Failing loudly on the first write beats degrading silently.
Use `_ord` unless you have a specific reason to pin block-ORE, and pin `_ord_ope` when you want a column's mechanism frozen against a future default change. Each type page lists its available specifiers under an "SEM specifiers" heading.
Declaring a table is just typing each column as the variant it needs:
```sql
CREATE TABLE users (
id BIGINT GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
email public.eql_v3_text_eq, -- equality only
salary public.eql_v3_integer_ord, -- equality + range + ORDER BY
created_at public.eql_v3_timestamp_ord
);
```
Every scalar type — `int2`, `int4`, `int8`, `numeric`, `float4`, `float8`, `date`, `timestamp`, `text`, and `bool` in EQL 3.0.3 — ships some subset of this family. The per-category pages list exactly which variants each type has and how to choose between them: [Numbers](https://cipherstash.com/docs/reference/eql/numbers), [Dates & times](https://cipherstash.com/docs/reference/eql/dates-and-times), [Text](https://cipherstash.com/docs/reference/eql/text), and [Booleans](https://cipherstash.com/docs/reference/eql/booleans). Encrypted JSON documents use separate domains — `public.eql_v3_json_search` for searchable documents, `public.eql_v3_json` for storage-only ones — with their own operator surface; see [JSON](https://cipherstash.com/docs/reference/eql/json).
The three schemas [#the-three-schemas]
EQL spreads its surface across three PostgreSQL schemas, and the split is what makes EQL **upgradable in place**:
| Schema | Holds | Do you call it? |
| ----------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------- |
| `public` | The encrypted **domain types** — every `public.eql_v3_` variant you type a column as. | Referenced in your table DDL. |
| `eql_v3` | All **user-callable functions and operators** — the searchable-encryption API (`eql_v3.eq_term`, `eql_v3.jsonb_path_query`, the encrypted `=` / `<` / `@>` operators, `eql_v3.version()`). | Yes — this is the API. |
| `eql_v3_internal` | The **implementation functions** the domains and operators are built from. | No — never call these directly. |
**Why the types live in `public`, and carry a version prefix.** Your columns are typed as `public.eql_v3_integer_ord`, `public.eql_v3_text_eq`, and so on — never `eql_v3.*`. Types stay in `public` so a column's type resolves without `search_path` games. The `eql_v3_` prefix does two jobs: it stops EQL's types shadowing Postgres built-ins, since `text`, `json`, and `integer` already resolve in `public`, and it gives each EQL generation its own column-type namespace, so `eql_v3_text_eq` and a future `eql_v4_text_eq` can sit side by side in one database while you migrate table by table.
**Why `eql_v3` is versioned.** The schema name encodes the major API version and is itself part of the public contract — a breaking change introduces a new `eql_vN` schema *beside* the old one rather than mutating it, so you migrate on your own timeline. Everything in `eql_v3` is fair game to call.
**Why `eql_v3_internal` is off-limits.** These are the building blocks — term comparators, unsupported-operator blockers, cast helpers — that the operators and domain `CHECK` constraints wire together. They carry no stability guarantee and can change or disappear between releases. If you're reaching for `eql_v3_internal.*`, there's a `public` type or an `eql_v3` function that does what you want.
Anatomy of an encrypted value [#anatomy-of-an-encrypted-value]
Every EQL encrypted value is a `jsonb` payload with a shared envelope plus the index terms that make it queryable. Earlier CipherStash docs called this format the **CipherCell** — this section is the current definition of the same structure.
Payloads are **produced** by the encryption clients — the [Stack SDK](https://cipherstash.com/docs/reference/stack) and [CipherStash Proxy](https://cipherstash.com/docs/reference/proxy) — and **consumed** by EQL's operators and functions inside Postgres. EQL never sees plaintext: it validates, stores, and compares these payloads; it cannot produce or decrypt them. The division is strict: the clients never rely on the database for key material.
The envelope [#the-envelope]
Every payload carries three envelope keys. Each `eql_v3` domain's `CHECK` constraint requires them, so a value missing any of these is rejected at write time:
| Key | Contents | Notes |
| --- | ------------------------------------------ | -------------------------------------------------------------------------------------------------------------------- |
| `v` | The EQL version | `3` — the payload version matches the EQL major version. The domain `CHECK`s assert it and raise on any other value. |
| `i` | Ident: `{"t": "", "c": ""}` | Binds the ciphertext to the table and column it was encrypted for. Both keys required. |
| `c` | Ciphertext | The opaque, non-deterministic encrypted blob (mp\_base85-encoded). Never used in comparisons. |
Payloads produced by EQL v2 clients carried `v: 2`; from 3.0.0 the payload version and the EQL version move together.
A `k` discriminator (`"ct"` for a scalar ciphertext, `"sv"` for a JSON document) also appears on payloads emitted by the clients, distinguishing the two top-level shapes.
Index-term keys [#index-term-keys]
Alongside the envelope, a payload carries the index terms for its column's capability. Each key is backed by a SEM (searchable encrypted metadata) type in the `eql_v3_internal` schema:
| Key | SEM type | Wire shape | Enables | Reveals |
| ---- | ------------------------------------------------------------------------- | -------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------- |
| `hm` | `eql_v3_internal.hmac_256` (domain over `text`) | Hex string (HMAC-SHA-256) | `=`, `<>` on `_eq` and `text_search` domains | Whether two values are equal — nothing else |
| `op` | `eql_v3_internal.ope_cllw` (domain over `bytea`) | Hex-encoded CLLW OPE ciphertext | `<`, `<=`, `>`, `>=`, `ORDER BY` on `_ord` / `_ord_ope` domains and `text_search`, and on String / Number leaves of `public.eql_v3_json_search` | The relative order of two values |
| `ob` | `eql_v3_internal.ore_block_256` (composite: array of `bytea` block terms) | Array of hex-encoded ORE blocks (block count varies by scalar width) | The same comparisons on the pinned `_ord_ore` and `text_search_ore` domains — and `=` / `<>`, since ORE comparison collapses to equality | The relative order of two values |
| `bf` | `eql_v3_internal.bloom_filter` (domain over `smallint[]`) | Array of set bit positions (**signed** 16-bit — large filters emit negative positions) | `@@` fuzzy match on `_match` and `text_search` domains | Probabilistic token overlap between values |
The capability is encoded as **required keys**: the payload for a `public.eql_v3_text_eq` column must carry `hm`; a `public.eql_v3_integer_ord` payload must carry `op` (and only `op`); a `text_match` payload must carry `bf`; a `text_search` payload carries `hm`, `op`, and `bf`. A payload missing its term key fails the domain `CHECK` — and fails to deserialize in the client bindings.
A scalar payload for a `public.eql_v3_text_search` column (lookup + ordering + free-text match, so all three terms are required):
```json
{
"v": 3,
"i": { "t": "users", "c": "email" },
"c": "mBbKmsMM%bK#QQOx1yLDBHyD...",
"hm": "9c8ec1d2f9932b979b1bf3f09f8a4e2f6a41f8de2f0c8b7a52e1f5c3d4b6a790",
"ob": ["7a1fd0c2...", "d24c9be1...", "03fa66b8..."],
"bf": [42, 1290, -8113, 30201]
}
```
* `v`, `i`, `c` — the envelope
* `hm` — equality term: `WHERE email = $1` compares this
* `ob` — ordering term: `ORDER BY` and range comparisons walk these blocks
* `bf` — bloom-filter term: `@@` fuzzy match tests these bit positions
Encrypted JSON documents use a different payload shape — a document-level key header `h` and an `sv` array with one encrypted entry per path, instead of a root ciphertext — defined in [JSON](https://cipherstash.com/docs/reference/eql/json).
Machine-readable schemas [#machine-readable-schemas]
The [EQL repository](https://github.com/cipherstash/encrypt-query-language) publishes the format as JSON Schema in two places:
* **`crates/eql-bindings/schema/`** — one schema per scalar domain (`$id`s under `https://schemas.cipherstash.com/eql/v3/`), generated from the canonical Rust wire types in the `eql-bindings` crate. TypeScript bindings are generated from the same definitions, so every producer and consumer shares one source of truth.
* **`docs/reference/schema/`** — full-payload schemas covering both the scalar and `sv` document shapes. These files are still named for the v2.x payload releases (`eql-payload-v2.2.schema.json`, `eql-payload-v2.3.schema.json`); the v2.3 schema describes the document shape, with the payload version field moving to `3` alongside the EQL 3.0.0 release.
The typed-operand rule [#the-typed-operand-rule]
The `eql_v3` domains are backed by `jsonb`. When an operand has no known type — a bare string literal, an untyped parameter — PostgreSQL reduces the domain to its `jsonb` base type and resolves the **native `jsonb` operator** instead of the encrypted one. The query doesn't fail; it silently returns native `jsonb` semantics, which are meaningless for encrypted payloads.
```sql
SELECT * FROM users WHERE email = $1;
```
```sql
-- Typed operand — the encrypted `=` resolves.
SELECT * FROM users WHERE email = $1::public.eql_v3_text_eq;
```
Always type the operand: a typed parameter (`$1::public.eql_v3_text_eq`) or an explicit cast (`'…'::public.eql_v3_integer_ord`). The [Stack SDK](https://cipherstash.com/docs/reference/stack) and [CipherStash Proxy](https://cipherstash.com/docs/reference/proxy) type bound parameters automatically — raw SQL must do it by hand.
This is the one place where a mistake is *silent*. Everything else fails loudly:
Unsupported operations fail loudly [#unsupported-operations-fail-loudly]
Unsupported operators are not silent no-ops. Every operator that a variant doesn't support is still *defined* — it routes to a blocker function that raises an `operator … is not supported` exception. A mis-typed query fails loudly instead of silently returning wrong results:
```sql
-- salary is public.eql_v3_bigint_eq (equality only)
SELECT * FROM users WHERE salary > $1::public.eql_v3_bigint_eq;
-- ERROR: operator > is not supported for public.eql_v3_bigint_eq
```
A `NULL` operand still raises — the blockers are deliberately not `STRICT`, so PostgreSQL can't skip the check. (A SQL `NULL` column value is not encrypted, so `IS NULL` / `IS NOT NULL` themselves always work, on every variant.)
`LIKE` and `ILIKE` are blocked on **every** encrypted variant — pattern matching is meaningless on ciphertext. Encrypted text matching is bloom-filter fuzzy match (`@@`) instead; [Text](https://cipherstash.com/docs/reference/eql/text) covers it.
One equality subtlety follows from the term table above, and it splits on whether the column is text.
On the non-text scalars, ordering is equality-lossless: `=` and `<>` on an `_ord` column compare the **ordering term** (`op`, or `ob` on `_ord_ore`), so those payloads carry no `hm` term at all and get equality for free. On text, ordering is *not* equality-lossless, so every orderable text variant carries `hm` alongside its ordering term and resolves `=` and `<>` against it. `_eq` columns always compare `hm`.
What the terms reveal [#what-the-terms-reveal]
Every index term a value carries is extra material stored in the database, and each term class reveals defined structure to an observer who can read the stored payloads: equality terms reveal *value repetition* (which rows share a value), ordering terms reveal *ordering* (which of two values is larger), and bloom terms reveal *probabilistic token overlap*. None of them reveal the plaintext — but you should only carry the terms you actually query on. The full analysis of what each term does and doesn't leak is in [Searchable encryption](https://cipherstash.com/docs/concepts/searchable-encryption).
# Dates & times
Source: https://cipherstash.com/docs/reference/eql/dates-and-times
`date` and `timestamp` columns carry the same capabilities as [encrypted numbers](https://cipherstash.com/docs/reference/eql/numbers) — equality, ranges, ordering, `MIN` / `MAX` — but the queries they serve are temporal: time windows, newest-first listings, retention cutoffs, "when did this last happen".
Variants [#variants]
Both types generate the same `jsonb`-backed domain variants. The generic form:
| Domain variant | Capability |
| --------------------------- | --------------------------------------------------------------------------------------------- |
| `public.eql_v3_` | Storage and decryption only. |
| `public.eql_v3__eq` | Equality: `=`, `<>`, `IN`, `GROUP BY`, `DISTINCT`, equijoins. |
| `public.eql_v3__ord` | Comparisons, `BETWEEN`, `ORDER BY`, `MIN` / `MAX` — plus equality. |
| `public.eql_v3__ord_ope` | The byte-identical twin of `_ord`, with OPE pinned. See [SEM specifiers](#sem-specifiers). |
| `public.eql_v3__ord_ore` | As `_ord`, with the ORE mechanism pinned. |
`` is the encrypted type name from the table below, so `public.eql_v3__ord` is `public.eql_v3_timestamp_ord` for `timestamp`.
And every concrete domain this page covers:
| Type | Variants |
| ----------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `date` | `public.eql_v3_date` · `public.eql_v3_date_eq` · `public.eql_v3_date_ord` · `public.eql_v3_date_ord_ope` · `public.eql_v3_date_ord_ore` |
| `timestamp` | `public.eql_v3_timestamp` · `public.eql_v3_timestamp_eq` · `public.eql_v3_timestamp_ord` · `public.eql_v3_timestamp_ord_ope` · `public.eql_v3_timestamp_ord_ore` |
Time columns are nearly always ranged and sorted, so `_ord` is the usual choice. Declare only the capability you query on — each capability stores extra searchable material with defined leakage (see [Searchable encryption](https://cipherstash.com/docs/concepts/searchable-encryption)), and the variant model itself is covered in [Core concepts](https://cipherstash.com/docs/reference/eql/core-concepts).
Date and time query example [#date-and-time-query-example]
An audit-events table where the timestamps drive time-window queries and sorting:
```sql
CREATE TABLE audit_events (
id bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
occurred_at public.eql_v3_timestamp_ord, -- time windows, newest-first, MIN/MAX
review_due public.eql_v3_date_ord, -- range filters
sealed_on public.eql_v3_date -- store and decrypt only
);
```
SEM specifiers [#sem-specifiers]
Both types take the same mechanism specifiers on their orderable variant (the concept is defined in [Core concepts](https://cipherstash.com/docs/reference/eql/core-concepts#sem-specifiers)):
| Specifier | Mechanism | Ordering term | Extractor |
| ---------- | ------------------------------- | ------------- | --------------------- |
| `_ord` | The default, currently CLLW OPE | `op` | `eql_v3.ord_term` |
| `_ord_ope` | CLLW OPE, pinned explicitly | `op` | `eql_v3.ord_term` |
| `_ord_ore` | Block-ORE, pinned explicitly | `ob` | `eql_v3.ord_term_ore` |
`_ord` and `_ord_ope` are byte-identical today. Pin `_ord_ope` when you want a column's mechanism frozen against a future change of the default.
Block-ORE terms sort only under a custom btree operator class, and creating one requires superuser. Where the EQL installer runs as a non-superuser, which is the case on most managed Postgres including cloud Supabase, it cannot create the class, so it **disables every ORE-backed domain** rather than let them install half-working. `_ord_ore` then raises `feature_not_supported` on the first value written to it. Use `_ord` there.
Payload [#payload]
A value for an `_ord` column carries the shared envelope keys (`v`, `i`, `c` — see [Core concepts](https://cipherstash.com/docs/reference/eql/core-concepts)) plus the `op` ordering term. Here is a payload for the `public.eql_v3_timestamp_ord` `occurred_at` column:
```json
{
"v": 3,
"i": { "t": "audit_events", "c": "occurred_at" },
"c": "mBbKmsMM%bK#QQOx1yLDBHyD...",
"op": "5f2b1a9e4c07d38b6ea15c92..."
}
```
* **`op` is the only index term.** It is a hex-encoded CLLW OPE ciphertext, which Postgres sorts by native `bytea` comparison. An `_ord` payload carries no `hm`, because ordering over a date or timestamp is equality-lossless: `=` and `<>` resolve against the same term.
* **An `_ord_ore` payload carries `ob` in place of `op`**: an array of block-ORE ciphertexts, 12 blocks for a `timestamp`.
Operators [#operators]
| SQL operator | `public.eql_v3_` | `_eq` | `_ord` variants |
| ------------------------------------- | :-----------------: | :------: | :----------------: |
| `=` / `<>` | ❌ | ✅ | ✅ |
| `<` `<=` `>` `>=` | ❌ | ❌ | ✅ |
| `BETWEEN` (desugars to `>=` and `<=`) | ❌ | ❌ | ✅ |
| `IN` (desugars to `=`) | ❌ | ✅ | ✅ |
| `GROUP BY` / `DISTINCT` | ❌ | ✅ | ✅ |
| `ORDER BY` | ❌ | ❌ | ✅ |
| `IS NULL` / `IS NOT NULL` | ✅ | ✅ | ✅ |
Blocked *operator* cells raise an `operator … is not supported` exception — they never silently return wrong rows. `ORDER BY` is the one blocked cell that doesn't raise: it isn't an operator, so sorting a variant without an ordering term runs — but the order is meaningless (see [Sorting](https://cipherstash.com/docs/reference/eql/sorting)). Operands must be typed (`$1::public.eql_v3_timestamp_ord`), or PostgreSQL resolves the native `jsonb` operator instead of the encrypted one. Both rules are covered in [Core concepts](https://cipherstash.com/docs/reference/eql/core-concepts).
Functions [#functions]
{/* GENERATED — do not edit. Produced by scripts/generate-eql-api-docs.ts from the EQL manifest. Edit the generator, not this file. */}
Every operator has a function form, for managed platforms that disallow custom operators — same typed arguments, identical resolution. Each lists the encrypted domains it applies to; the `MIN` / `MAX` aggregates only exist as functions.
eql_v3.eq(a, b) [#fn-eq]
```sql
SELECT * FROM events
WHERE eql_v3.eq(occurred_at, $1::public.eql_v3_timestamp_eq);
```
eql_v3.neq(a, b) [#fn-neq]
```sql
SELECT * FROM events
WHERE eql_v3.neq(occurred_at, $1::public.eql_v3_timestamp_eq);
```
eql_v3.lt / lte / gt / gte [#fn-comparison]
```sql
-- a range uses two of the four
SELECT * FROM events
WHERE eql_v3.gte(occurred_at, $1::public.eql_v3_timestamp_ord)
AND eql_v3.lt(occurred_at, $2::public.eql_v3_timestamp_ord);
```
eql_v3.min(col) [#fn-min]
```sql
-- compares ordering terms; result decrypts client-side
SELECT eql_v3.min(occurred_at) FROM events;
```
eql_v3.max(col) [#fn-max]
```sql
SELECT eql_v3.max(occurred_at) FROM events;
```
Where to next [#where-to-next]
The same capabilities on int, float, and numeric columns.
Btree recipes on `eql_v3.ord_term` for range, ORDER BY, and MIN/MAX.
Why the extractor-form sort key matters, and how to verify with EXPLAIN.
WHERE-clause patterns across all encrypted types.
# Filtering
Source: https://cipherstash.com/docs/reference/eql/filtering
Every filter below is ordinary SQL — the encrypted operators resolve from the column's domain variant, and a functional index on the matching term extractor serves the predicate. One rule applies throughout: **operands must be typed** (`$1::public.eql_v3_text_eq`, not a bare literal), or PostgreSQL falls through to native `jsonb` semantics. See [Core concepts](https://cipherstash.com/docs/reference/eql/core-concepts) for the typed-operand rule and how unsupported operators fail loudly instead of returning wrong rows.
Equality: = and <> [#equality--and-]
Works on `_eq` and every `_ord` variant of every scalar, and on `text_search`:
```sql
SELECT * FROM users WHERE email = $1::public.eql_v3_text_eq;
SELECT * FROM users WHERE tax_id <> $1::public.eql_v3_text_eq;
```
On `_eq` columns, and on every text variant, equality compares the HMAC (`hm`) term. On the `_ord` variants of the non-text scalars there is no `hm`: equality compares the ordering term instead, which is lossless over those domains, so those columns get `=` and `<>` for free. See [Core concepts](https://cipherstash.com/docs/reference/eql/core-concepts) for the mechanism.
```sql
-- salary is public.eql_v3_bigint_ord: equality works without an hm term
SELECT * FROM users WHERE salary = $1::public.eql_v3_bigint_ord;
```
Bare storage-only variants (`public.eql_v3_text`, `public.eql_v3_integer`, …) block every comparison — see the type pages for what each variant supports: [Numbers](https://cipherstash.com/docs/reference/eql/numbers), [Dates & times](https://cipherstash.com/docs/reference/eql/dates-and-times), [Text](https://cipherstash.com/docs/reference/eql/text), [Booleans](https://cipherstash.com/docs/reference/eql/booleans).
IN lists [#in-lists]
`IN` desugars to `=`, so it needs the same equality-capable variants. Each list element is a separately encrypted, typed operand:
```sql
SELECT * FROM users
WHERE email IN ($1::public.eql_v3_text_eq, $2::public.eql_v3_text_eq, $3::public.eql_v3_text_eq);
```
There is no way to encrypt a list as one value — the client encrypts each element and binds it as its own parameter. `IN (subquery)` also works, subject to the same-keyset rule covered in [Joins](https://cipherstash.com/docs/reference/eql/joins).
Ranges and BETWEEN [#ranges-and-between]
`<`, `<=`, `>`, `>=` work on `_ord` / `_ord_ope` variants and `text_search`, which carry an OPE (`op`) term, and on the pinned `_ord_ore` / `text_search_ore` variants, which carry a block-ORE (`ob`) term:
```sql
SELECT * FROM users WHERE salary >= $1::public.eql_v3_bigint_ord;
-- BETWEEN desugars to >= and <=
SELECT * FROM users
WHERE created_at BETWEEN $1::public.eql_v3_timestamp_ord AND $2::public.eql_v3_timestamp_ord;
```
Half-open ranges compose the same way:
```sql
SELECT * FROM events
WHERE occurred_at >= $1::public.eql_v3_timestamp_ord
AND occurred_at < $2::public.eql_v3_timestamp_ord;
```
Text fuzzy matching: @@ [#text-fuzzy-matching-]
There is no `LIKE` on encrypted columns — encrypted free-text matching is bloom-filter fuzzy match via `@@` on a `text_match` or `text_search` column:
```sql
SELECT * FROM users WHERE name @@ $1::public.eql_v3_text_match;
```
The client encrypts the search term into a bloom-filter query value; matching is probabilistic (false positives possible, false negatives not). `@>` / `<@` raise on these domains — they were the old spelling of this match and are now blockers. For the full no-`LIKE` story, short-term behaviour, and match-term tuning, see [Text](https://cipherstash.com/docs/reference/eql/text).
JSON containment and path filters [#json-containment-and-path-filters]
Encrypted JSON documents (`public.eql_v3_json_search`) filter by containment and path existence:
```sql
-- Does the document contain this (encrypted) structure?
SELECT * FROM orders WHERE metadata @> $1::eql_v3.query_json;
-- Does this path exist in the document?
SELECT * FROM orders WHERE eql_v3.jsonb_path_exists(metadata, 'region_selector');
-- Exact match on a field: containment on a value selector, built by the client
SELECT * FROM orders WHERE metadata @> $1::eql_v3.query_json;
```
Field access is by selector hash, not plaintext path — and exact field matching is containment on a **value selector**, not `=` on an extracted leaf, which raises. The full JSON surface — containment, field access, path queries, and range filters on extracted leaves — is in [JSON](https://cipherstash.com/docs/reference/eql/json).
Combining predicates [#combining-predicates]
Encrypted predicates compose with `AND`, `OR`, `NOT`, and parentheses like any other predicate — and plaintext columns filter normally alongside encrypted ones in the same `WHERE` clause:
```sql
SELECT * FROM users
WHERE status = 'active' -- plaintext column, native operator
AND created_at >= $1::public.eql_v3_timestamp_ord -- encrypted range
AND (email = $2::public.eql_v3_text_eq -- encrypted equality
OR name @@ $3::public.eql_v3_text_match); -- encrypted fuzzy match
```
The planner treats each encrypted predicate independently, so it can combine an index on a plaintext column with a functional index on an encrypted one (bitmap-AND, or whichever plan is cheapest).
IS NULL and IS NOT NULL [#is-null-and-is-not-null]
A SQL `NULL` column value is never encrypted — there is no payload to encrypt — so null checks work on **every** variant, including storage-only ones:
```sql
SELECT * FROM users WHERE tax_id IS NULL;
SELECT * FROM users WHERE tax_id IS NOT NULL;
```
Don't confuse this with a JSON `null` *inside* an encrypted document, which is an encrypted value like any other — see [JSON](https://cipherstash.com/docs/reference/eql/json).
Shape summary [#shape-summary]
| Filter shape | Operators | Works on | Index |
| ---------------- | --------------------------- | -------------------------------------------------- | ------------------------------------------------------------------------------------------------- |
| Equality | `=` `<>` `IN` | `_eq`, all `_ord` variants, `text_search` variants | hash (or btree) on `eql_v3.eq_term` — btree on `eql_v3.ord_term` for the non-text `_ord` variants |
| Range | `<` `<=` `>` `>=` `BETWEEN` | all `_ord` variants, `text_search` variants | btree on `eql_v3.ord_term` (`eql_v3.ord_term_ore` on `_ord_ore`) |
| Text fuzzy match | `@@` | `text_match`, `text_search` variants | GIN on `eql_v3.match_term` |
| JSON containment | `@>` `<@` | `public.eql_v3_json_search` | GIN on `eql_v3.to_ste_vec_query(col)::jsonb` |
| Null check | `IS NULL` / `IS NOT NULL` | every variant | — |
Every one of these has a full index recipe — which method, which extractor, and how to confirm the index engages with `EXPLAIN` — in [Indexes](https://cipherstash.com/docs/reference/eql/indexes).
# Functions
Source: https://cipherstash.com/docs/reference/eql/functions
{/* GENERATED — do not edit. Produced by scripts/generate-eql-api-docs.ts from the EQL manifest (v3.0.4). */}
Generated from the **EQL 3.0.4** manifest (the Doxygen'd SQL is the source of truth). For the model behind these — variants, terms, typed operands — see [Core concepts](https://cipherstash.com/docs/reference/eql/core-concepts).
The EQL SQL surface — encrypted domains (in the `public` schema) and the `eql_v3` functions behind them. The type and query pages explain *when* to use these; this page is the exhaustive reference they link to.
Encrypted domains [#encrypted-domains]
A column's capability is declared by its **domain variant**. This matrix comes straight from the Rust catalog (`eql-codegen dump-catalog`) — the source of truth the SQL is generated from. See [Core concepts](https://cipherstash.com/docs/reference/eql/core-concepts) for the model.
| Domain | Type | Variant | Capabilities | Operators |
| --------------------------------- | --------- | ---------------- | ---------------------- | ------------------------------- |
| `public.eql_v3_bigint` | bigint | *(storage only)* | storage | — |
| `public.eql_v3_bigint_eq` | bigint | `_eq` | equality | `=` `<>` |
| `public.eql_v3_bigint_ord` | bigint | `_ord` | equality, order | `=` `<>` `<` `<=` `>` `>=` |
| `public.eql_v3_bigint_ord_ope` | bigint | `_ord_ope` | equality, order | `=` `<>` `<` `<=` `>` `>=` |
| `public.eql_v3_bigint_ord_ore` | bigint | `_ord_ore` | equality, order | `=` `<>` `<` `<=` `>` `>=` |
| `public.eql_v3_boolean` | boolean | *(storage only)* | storage | — |
| `public.eql_v3_date` | date | *(storage only)* | storage | — |
| `public.eql_v3_date_eq` | date | `_eq` | equality | `=` `<>` |
| `public.eql_v3_date_ord` | date | `_ord` | equality, order | `=` `<>` `<` `<=` `>` `>=` |
| `public.eql_v3_date_ord_ope` | date | `_ord_ope` | equality, order | `=` `<>` `<` `<=` `>` `>=` |
| `public.eql_v3_date_ord_ore` | date | `_ord_ore` | equality, order | `=` `<>` `<` `<=` `>` `>=` |
| `public.eql_v3_double` | double | *(storage only)* | storage | — |
| `public.eql_v3_double_eq` | double | `_eq` | equality | `=` `<>` |
| `public.eql_v3_double_ord` | double | `_ord` | equality, order | `=` `<>` `<` `<=` `>` `>=` |
| `public.eql_v3_double_ord_ope` | double | `_ord_ope` | equality, order | `=` `<>` `<` `<=` `>` `>=` |
| `public.eql_v3_double_ord_ore` | double | `_ord_ore` | equality, order | `=` `<>` `<` `<=` `>` `>=` |
| `public.eql_v3_integer` | integer | *(storage only)* | storage | — |
| `public.eql_v3_integer_eq` | integer | `_eq` | equality | `=` `<>` |
| `public.eql_v3_integer_ord` | integer | `_ord` | equality, order | `=` `<>` `<` `<=` `>` `>=` |
| `public.eql_v3_integer_ord_ope` | integer | `_ord_ope` | equality, order | `=` `<>` `<` `<=` `>` `>=` |
| `public.eql_v3_integer_ord_ore` | integer | `_ord_ore` | equality, order | `=` `<>` `<` `<=` `>` `>=` |
| `eql_v3.query_json` | jsonb | *(storage only)* | json | — |
| `public.eql_v3_json` | jsonb | *(storage only)* | storage | — |
| `public.eql_v3_json_entry` | jsonb | *(storage only)* | json | — |
| `public.eql_v3_json_search` | jsonb | *(storage only)* | json | — |
| `public.eql_v3_numeric` | numeric | *(storage only)* | storage | — |
| `public.eql_v3_numeric_eq` | numeric | `_eq` | equality | `=` `<>` |
| `public.eql_v3_numeric_ord` | numeric | `_ord` | equality, order | `=` `<>` `<` `<=` `>` `>=` |
| `public.eql_v3_numeric_ord_ope` | numeric | `_ord_ope` | equality, order | `=` `<>` `<` `<=` `>` `>=` |
| `public.eql_v3_numeric_ord_ore` | numeric | `_ord_ore` | equality, order | `=` `<>` `<` `<=` `>` `>=` |
| `public.eql_v3_real` | real | *(storage only)* | storage | — |
| `public.eql_v3_real_eq` | real | `_eq` | equality | `=` `<>` |
| `public.eql_v3_real_ord` | real | `_ord` | equality, order | `=` `<>` `<` `<=` `>` `>=` |
| `public.eql_v3_real_ord_ope` | real | `_ord_ope` | equality, order | `=` `<>` `<` `<=` `>` `>=` |
| `public.eql_v3_real_ord_ore` | real | `_ord_ore` | equality, order | `=` `<>` `<` `<=` `>` `>=` |
| `public.eql_v3_smallint` | smallint | *(storage only)* | storage | — |
| `public.eql_v3_smallint_eq` | smallint | `_eq` | equality | `=` `<>` |
| `public.eql_v3_smallint_ord` | smallint | `_ord` | equality, order | `=` `<>` `<` `<=` `>` `>=` |
| `public.eql_v3_smallint_ord_ope` | smallint | `_ord_ope` | equality, order | `=` `<>` `<` `<=` `>` `>=` |
| `public.eql_v3_smallint_ord_ore` | smallint | `_ord_ore` | equality, order | `=` `<>` `<` `<=` `>` `>=` |
| `public.eql_v3_text` | text | *(storage only)* | storage | — |
| `public.eql_v3_text_eq` | text | `_eq` | equality | `=` `<>` |
| `public.eql_v3_text_match` | text | `_match` | match | `@@` |
| `public.eql_v3_text_ord` | text | `_ord` | equality, order | `=` `<>` `<` `<=` `>` `>=` |
| `public.eql_v3_text_ord_ope` | text | `_ord_ope` | equality, order | `=` `<>` `<` `<=` `>` `>=` |
| `public.eql_v3_text_ord_ore` | text | `_ord_ore` | equality, order | `=` `<>` `<` `<=` `>` `>=` |
| `public.eql_v3_text_search` | text | `_search` | equality, order, match | `=` `<>` `<` `<=` `>` `>=` `@@` |
| `public.eql_v3_text_search_ore` | text | `_search_ore` | equality, order, match | `=` `<>` `<` `<=` `>` `>=` `@@` |
| `public.eql_v3_timestamp` | timestamp | *(storage only)* | storage | — |
| `public.eql_v3_timestamp_eq` | timestamp | `_eq` | equality | `=` `<>` |
| `public.eql_v3_timestamp_ord` | timestamp | `_ord` | equality, order | `=` `<>` `<` `<=` `>` `>=` |
| `public.eql_v3_timestamp_ord_ope` | timestamp | `_ord_ope` | equality, order | `=` `<>` `<` `<=` `>` `>=` |
| `public.eql_v3_timestamp_ord_ore` | timestamp | `_ord_ore` | equality, order | `=` `<>` `<` `<=` `>` `>=` |
Functions [#functions]
The public `eql_v3` API — 34 functions (1209 overloads). Internal `eql_v3_internal` functions (780) are implementation detail and omitted.
ciphertext [#ciphertext]
Extract ciphertext (c) from a raw jsonb encrypted value.
**Signature:**
```sql
ciphertext(jsonb)
```
| Parameter | Type | Description |
| --------- | ------- | --------------------- |
| `val` | `jsonb` | encrypted EQL payload |
**Returns:** `text` — text The c field verbatim (base85 text).
eq [#eq]
Operator wrapper for public.eql\_v3\_bigint\_eq.
**190 overloads** (one per encrypted type):
```sql
eq(eql_v3_bigint_eq, eql_v3_bigint_eq)
eq(eql_v3_bigint_eq, jsonb)
eq(eql_v3_bigint_eq, query_bigint_eq)
eq(eql_v3_bigint_ord, eql_v3_bigint_ord)
eq(eql_v3_bigint_ord, jsonb)
eq(eql_v3_bigint_ord, query_bigint_ord)
eq(eql_v3_bigint_ord_ope, eql_v3_bigint_ord_ope)
eq(eql_v3_bigint_ord_ope, jsonb)
eq(eql_v3_bigint_ord_ope, query_bigint_ord_ope)
eq(eql_v3_bigint_ord_ore, eql_v3_bigint_ord_ore)
eq(eql_v3_bigint_ord_ore, jsonb)
eq(eql_v3_bigint_ord_ore, query_bigint_ord_ore)
eq(eql_v3_date_eq, eql_v3_date_eq)
eq(eql_v3_date_eq, jsonb)
eq(eql_v3_date_eq, query_date_eq)
eq(eql_v3_date_ord, eql_v3_date_ord)
eq(eql_v3_date_ord, jsonb)
eq(eql_v3_date_ord, query_date_ord)
eq(eql_v3_date_ord_ope, eql_v3_date_ord_ope)
eq(eql_v3_date_ord_ope, jsonb)
eq(eql_v3_date_ord_ope, query_date_ord_ope)
eq(eql_v3_date_ord_ore, eql_v3_date_ord_ore)
eq(eql_v3_date_ord_ore, jsonb)
eq(eql_v3_date_ord_ore, query_date_ord_ore)
eq(eql_v3_double_eq, eql_v3_double_eq)
eq(eql_v3_double_eq, jsonb)
eq(eql_v3_double_eq, query_double_eq)
eq(eql_v3_double_ord, eql_v3_double_ord)
eq(eql_v3_double_ord, jsonb)
eq(eql_v3_double_ord, query_double_ord)
eq(eql_v3_double_ord_ope, eql_v3_double_ord_ope)
eq(eql_v3_double_ord_ope, jsonb)
eq(eql_v3_double_ord_ope, query_double_ord_ope)
eq(eql_v3_double_ord_ore, eql_v3_double_ord_ore)
eq(eql_v3_double_ord_ore, jsonb)
eq(eql_v3_double_ord_ore, query_double_ord_ore)
eq(eql_v3_integer_eq, eql_v3_integer_eq)
eq(eql_v3_integer_eq, jsonb)
eq(eql_v3_integer_eq, query_integer_eq)
eq(eql_v3_integer_ord, eql_v3_integer_ord)
eq(eql_v3_integer_ord, jsonb)
eq(eql_v3_integer_ord, query_integer_ord)
eq(eql_v3_integer_ord_ope, eql_v3_integer_ord_ope)
eq(eql_v3_integer_ord_ope, jsonb)
eq(eql_v3_integer_ord_ope, query_integer_ord_ope)
eq(eql_v3_integer_ord_ore, eql_v3_integer_ord_ore)
eq(eql_v3_integer_ord_ore, jsonb)
eq(eql_v3_integer_ord_ore, query_integer_ord_ore)
eq(eql_v3_numeric_eq, eql_v3_numeric_eq)
eq(eql_v3_numeric_eq, jsonb)
eq(eql_v3_numeric_eq, query_numeric_eq)
eq(eql_v3_numeric_ord, eql_v3_numeric_ord)
eq(eql_v3_numeric_ord, jsonb)
eq(eql_v3_numeric_ord, query_numeric_ord)
eq(eql_v3_numeric_ord_ope, eql_v3_numeric_ord_ope)
eq(eql_v3_numeric_ord_ope, jsonb)
eq(eql_v3_numeric_ord_ope, query_numeric_ord_ope)
eq(eql_v3_numeric_ord_ore, eql_v3_numeric_ord_ore)
eq(eql_v3_numeric_ord_ore, jsonb)
eq(eql_v3_numeric_ord_ore, query_numeric_ord_ore)
eq(eql_v3_real_eq, eql_v3_real_eq)
eq(eql_v3_real_eq, jsonb)
eq(eql_v3_real_eq, query_real_eq)
eq(eql_v3_real_ord, eql_v3_real_ord)
eq(eql_v3_real_ord, jsonb)
eq(eql_v3_real_ord, query_real_ord)
eq(eql_v3_real_ord_ope, eql_v3_real_ord_ope)
eq(eql_v3_real_ord_ope, jsonb)
eq(eql_v3_real_ord_ope, query_real_ord_ope)
eq(eql_v3_real_ord_ore, eql_v3_real_ord_ore)
eq(eql_v3_real_ord_ore, jsonb)
eq(eql_v3_real_ord_ore, query_real_ord_ore)
eq(eql_v3_smallint_eq, eql_v3_smallint_eq)
eq(eql_v3_smallint_eq, jsonb)
eq(eql_v3_smallint_eq, query_smallint_eq)
eq(eql_v3_smallint_ord, eql_v3_smallint_ord)
eq(eql_v3_smallint_ord, jsonb)
eq(eql_v3_smallint_ord, query_smallint_ord)
eq(eql_v3_smallint_ord_ope, eql_v3_smallint_ord_ope)
eq(eql_v3_smallint_ord_ope, jsonb)
eq(eql_v3_smallint_ord_ope, query_smallint_ord_ope)
eq(eql_v3_smallint_ord_ore, eql_v3_smallint_ord_ore)
eq(eql_v3_smallint_ord_ore, jsonb)
eq(eql_v3_smallint_ord_ore, query_smallint_ord_ore)
eq(eql_v3_text_eq, eql_v3_text_eq)
eq(eql_v3_text_eq, jsonb)
eq(eql_v3_text_eq, query_text_eq)
eq(eql_v3_text_ord, eql_v3_text_ord)
eq(eql_v3_text_ord, jsonb)
eq(eql_v3_text_ord, query_text_ord)
eq(eql_v3_text_ord_ope, eql_v3_text_ord_ope)
eq(eql_v3_text_ord_ope, jsonb)
eq(eql_v3_text_ord_ope, query_text_ord_ope)
eq(eql_v3_text_ord_ore, eql_v3_text_ord_ore)
eq(eql_v3_text_ord_ore, jsonb)
eq(eql_v3_text_ord_ore, query_text_ord_ore)
eq(eql_v3_text_search, eql_v3_text_search)
eq(eql_v3_text_search, jsonb)
eq(eql_v3_text_search, query_text_search)
eq(eql_v3_text_search_ore, eql_v3_text_search_ore)
eq(eql_v3_text_search_ore, jsonb)
eq(eql_v3_text_search_ore, query_text_search_ore)
eq(eql_v3_timestamp_eq, eql_v3_timestamp_eq)
eq(eql_v3_timestamp_eq, jsonb)
eq(eql_v3_timestamp_eq, query_timestamp_eq)
eq(eql_v3_timestamp_ord, eql_v3_timestamp_ord)
eq(eql_v3_timestamp_ord, jsonb)
eq(eql_v3_timestamp_ord, query_timestamp_ord)
eq(eql_v3_timestamp_ord_ope, eql_v3_timestamp_ord_ope)
eq(eql_v3_timestamp_ord_ope, jsonb)
eq(eql_v3_timestamp_ord_ope, query_timestamp_ord_ope)
eq(eql_v3_timestamp_ord_ore, eql_v3_timestamp_ord_ore)
eq(eql_v3_timestamp_ord_ore, jsonb)
eq(eql_v3_timestamp_ord_ore, query_timestamp_ord_ore)
eq(jsonb, eql_v3_bigint_eq)
eq(jsonb, eql_v3_bigint_ord)
eq(jsonb, eql_v3_bigint_ord_ope)
eq(jsonb, eql_v3_bigint_ord_ore)
eq(jsonb, eql_v3_date_eq)
eq(jsonb, eql_v3_date_ord)
eq(jsonb, eql_v3_date_ord_ope)
eq(jsonb, eql_v3_date_ord_ore)
eq(jsonb, eql_v3_double_eq)
eq(jsonb, eql_v3_double_ord)
eq(jsonb, eql_v3_double_ord_ope)
eq(jsonb, eql_v3_double_ord_ore)
eq(jsonb, eql_v3_integer_eq)
eq(jsonb, eql_v3_integer_ord)
eq(jsonb, eql_v3_integer_ord_ope)
eq(jsonb, eql_v3_integer_ord_ore)
eq(jsonb, eql_v3_numeric_eq)
eq(jsonb, eql_v3_numeric_ord)
eq(jsonb, eql_v3_numeric_ord_ope)
eq(jsonb, eql_v3_numeric_ord_ore)
eq(jsonb, eql_v3_real_eq)
eq(jsonb, eql_v3_real_ord)
eq(jsonb, eql_v3_real_ord_ope)
eq(jsonb, eql_v3_real_ord_ore)
eq(jsonb, eql_v3_smallint_eq)
eq(jsonb, eql_v3_smallint_ord)
eq(jsonb, eql_v3_smallint_ord_ope)
eq(jsonb, eql_v3_smallint_ord_ore)
eq(jsonb, eql_v3_text_eq)
eq(jsonb, eql_v3_text_ord)
eq(jsonb, eql_v3_text_ord_ope)
eq(jsonb, eql_v3_text_ord_ore)
eq(jsonb, eql_v3_text_search)
eq(jsonb, eql_v3_text_search_ore)
eq(jsonb, eql_v3_timestamp_eq)
eq(jsonb, eql_v3_timestamp_ord)
eq(jsonb, eql_v3_timestamp_ord_ope)
eq(jsonb, eql_v3_timestamp_ord_ore)
eq(query_bigint_eq, eql_v3_bigint_eq)
eq(query_bigint_ord, eql_v3_bigint_ord)
eq(query_bigint_ord_ope, eql_v3_bigint_ord_ope)
eq(query_bigint_ord_ore, eql_v3_bigint_ord_ore)
eq(query_date_eq, eql_v3_date_eq)
eq(query_date_ord, eql_v3_date_ord)
eq(query_date_ord_ope, eql_v3_date_ord_ope)
eq(query_date_ord_ore, eql_v3_date_ord_ore)
eq(query_double_eq, eql_v3_double_eq)
eq(query_double_ord, eql_v3_double_ord)
eq(query_double_ord_ope, eql_v3_double_ord_ope)
eq(query_double_ord_ore, eql_v3_double_ord_ore)
eq(query_integer_eq, eql_v3_integer_eq)
eq(query_integer_ord, eql_v3_integer_ord)
eq(query_integer_ord_ope, eql_v3_integer_ord_ope)
eq(query_integer_ord_ore, eql_v3_integer_ord_ore)
eq(query_numeric_eq, eql_v3_numeric_eq)
eq(query_numeric_ord, eql_v3_numeric_ord)
eq(query_numeric_ord_ope, eql_v3_numeric_ord_ope)
eq(query_numeric_ord_ore, eql_v3_numeric_ord_ore)
eq(query_real_eq, eql_v3_real_eq)
eq(query_real_ord, eql_v3_real_ord)
eq(query_real_ord_ope, eql_v3_real_ord_ope)
eq(query_real_ord_ore, eql_v3_real_ord_ore)
eq(query_smallint_eq, eql_v3_smallint_eq)
eq(query_smallint_ord, eql_v3_smallint_ord)
eq(query_smallint_ord_ope, eql_v3_smallint_ord_ope)
eq(query_smallint_ord_ore, eql_v3_smallint_ord_ore)
eq(query_text_eq, eql_v3_text_eq)
eq(query_text_ord, eql_v3_text_ord)
eq(query_text_ord_ope, eql_v3_text_ord_ope)
eq(query_text_ord_ore, eql_v3_text_ord_ore)
eq(query_text_search, eql_v3_text_search)
eq(query_text_search_ore, eql_v3_text_search_ore)
eq(query_timestamp_eq, eql_v3_timestamp_eq)
eq(query_timestamp_ord, eql_v3_timestamp_ord)
eq(query_timestamp_ord_ope, eql_v3_timestamp_ord_ope)
eq(query_timestamp_ord_ore, eql_v3_timestamp_ord_ore)
```
| Parameter | Type | Description |
| ----------- | ------------------ | ----------- |
| `a public.` | `eql_v3_bigint_eq` | |
| `b public.` | `eql_v3_bigint_eq` | |
**Returns:** `boolean` — boolean
eq_term [#eq_term]
Index extractor for public.eql\_v3\_bigint\_eq.
**29 overloads** (one per encrypted type):
```sql
eq_term(eql_v3_bigint_eq)
eq_term(eql_v3_date_eq)
eq_term(eql_v3_double_eq)
eq_term(eql_v3_integer_eq)
eq_term(eql_v3_json_entry)
eq_term(eql_v3_numeric_eq)
eq_term(eql_v3_real_eq)
eq_term(eql_v3_smallint_eq)
eq_term(eql_v3_text_eq)
eq_term(eql_v3_text_ord)
eq_term(eql_v3_text_ord_ope)
eq_term(eql_v3_text_ord_ore)
eq_term(eql_v3_text_search)
eq_term(eql_v3_text_search_ore)
eq_term(eql_v3_timestamp_eq)
eq_term(query_bigint_eq)
eq_term(query_date_eq)
eq_term(query_double_eq)
eq_term(query_integer_eq)
eq_term(query_numeric_eq)
eq_term(query_real_eq)
eq_term(query_smallint_eq)
eq_term(query_text_eq)
eq_term(query_text_ord)
eq_term(query_text_ord_ope)
eq_term(query_text_ord_ore)
eq_term(query_text_search)
eq_term(query_text_search_ore)
eq_term(query_timestamp_eq)
```
| Parameter | Type | Description |
| ----------- | ------------------ | ----------- |
| `a public.` | `eql_v3_bigint_eq` | |
**Returns:** `eql_v3_internal.hmac_256` — eql\_v3\_internal.hmac\_256
eql_v3_is_valid_ste_vec_document_payload [#eql_v3_is_valid_ste_vec_document_payload]
Validate a root SteVec document payload.
**Signature:**
```sql
eql_v3_is_valid_ste_vec_document_payload(jsonb)
```
| Parameter | Type | Description |
| --------- | ------- | ----------- |
| `val` | `jsonb` | |
**Returns:** `boolean`
eql_v3_is_valid_ste_vec_entry_payload [#eql_v3_is_valid_ste_vec_entry_payload]
Validate a single SteVec entry payload.
**Signature:**
```sql
eql_v3_is_valid_ste_vec_entry_payload(jsonb)
```
| Parameter | Type | Description |
| --------- | ------- | ----------- |
| `val` | `jsonb` | |
**Returns:** `boolean`
eql_v3_is_valid_ste_vec_query_payload [#eql_v3_is_valid_ste_vec_query_payload]
Validate a SteVec containment query payload.
**Signature:**
```sql
eql_v3_is_valid_ste_vec_query_payload(jsonb)
```
| Parameter | Type | Description |
| --------- | ------- | ----------- |
| `val` | `jsonb` | |
**Returns:** `boolean`
grouped_value [#grouped_value]
Return a representative (first non-null) encrypted value per group.
Returns the first non-null value encountered within a GROUP BY group. Its primary use is projecting an encrypted column while grouping by that column's equality term (GROUP BY eql\_v3.eq\_term(col)), where PostgreSQL will not let you SELECT col directly — see the file header for the worked example. Accepts any eql\_v3 encrypted-domain value (each is a jsonb-backed domain) and returns it unchanged, performing no decryption or comparison. PARALLEL SAFE with a combine function, so it works under partial/parallel aggregation on large GROUP BY workloads.
SELECT eql\_v3.grouped\_value(encrypted\_foo) AS encrypted\_foo, count(\*) FROM some\_table GROUP BY eql\_v3.eq\_term(encrypted\_foo);
**Signature:**
```sql
grouped_value(jsonb)
```
| Parameter | Type | Description |
| --------- | ------- | ------------------------------ |
| `input` | `jsonb` | Encrypted values to aggregate. |
**Returns:** `jsonb` — jsonb The first non-null value in the group.
gt [#gt]
Operator wrapper for public.eql\_v3\_bigint\_ord.
**159 overloads** (one per encrypted type):
```sql
gt(eql_v3_bigint_ord, eql_v3_bigint_ord)
gt(eql_v3_bigint_ord, jsonb)
gt(eql_v3_bigint_ord, query_bigint_ord)
gt(eql_v3_bigint_ord_ope, eql_v3_bigint_ord_ope)
gt(eql_v3_bigint_ord_ope, jsonb)
gt(eql_v3_bigint_ord_ope, query_bigint_ord_ope)
gt(eql_v3_bigint_ord_ore, eql_v3_bigint_ord_ore)
gt(eql_v3_bigint_ord_ore, jsonb)
gt(eql_v3_bigint_ord_ore, query_bigint_ord_ore)
gt(eql_v3_date_ord, eql_v3_date_ord)
gt(eql_v3_date_ord, jsonb)
gt(eql_v3_date_ord, query_date_ord)
gt(eql_v3_date_ord_ope, eql_v3_date_ord_ope)
gt(eql_v3_date_ord_ope, jsonb)
gt(eql_v3_date_ord_ope, query_date_ord_ope)
gt(eql_v3_date_ord_ore, eql_v3_date_ord_ore)
gt(eql_v3_date_ord_ore, jsonb)
gt(eql_v3_date_ord_ore, query_date_ord_ore)
gt(eql_v3_double_ord, eql_v3_double_ord)
gt(eql_v3_double_ord, jsonb)
gt(eql_v3_double_ord, query_double_ord)
gt(eql_v3_double_ord_ope, eql_v3_double_ord_ope)
gt(eql_v3_double_ord_ope, jsonb)
gt(eql_v3_double_ord_ope, query_double_ord_ope)
gt(eql_v3_double_ord_ore, eql_v3_double_ord_ore)
gt(eql_v3_double_ord_ore, jsonb)
gt(eql_v3_double_ord_ore, query_double_ord_ore)
gt(eql_v3_integer_ord, eql_v3_integer_ord)
gt(eql_v3_integer_ord, jsonb)
gt(eql_v3_integer_ord, query_integer_ord)
gt(eql_v3_integer_ord_ope, eql_v3_integer_ord_ope)
gt(eql_v3_integer_ord_ope, jsonb)
gt(eql_v3_integer_ord_ope, query_integer_ord_ope)
gt(eql_v3_integer_ord_ore, eql_v3_integer_ord_ore)
gt(eql_v3_integer_ord_ore, jsonb)
gt(eql_v3_integer_ord_ore, query_integer_ord_ore)
gt(eql_v3_json_entry, query_bigint_ord)
gt(eql_v3_json_entry, query_double_ord)
gt(eql_v3_json_entry, query_integer_ord)
gt(eql_v3_json_entry, query_numeric_ord)
gt(eql_v3_json_entry, query_real_ord)
gt(eql_v3_json_entry, query_smallint_ord)
gt(eql_v3_json_entry, query_text_ord)
gt(eql_v3_numeric_ord, eql_v3_numeric_ord)
gt(eql_v3_numeric_ord, jsonb)
gt(eql_v3_numeric_ord, query_numeric_ord)
gt(eql_v3_numeric_ord_ope, eql_v3_numeric_ord_ope)
gt(eql_v3_numeric_ord_ope, jsonb)
gt(eql_v3_numeric_ord_ope, query_numeric_ord_ope)
gt(eql_v3_numeric_ord_ore, eql_v3_numeric_ord_ore)
gt(eql_v3_numeric_ord_ore, jsonb)
gt(eql_v3_numeric_ord_ore, query_numeric_ord_ore)
gt(eql_v3_real_ord, eql_v3_real_ord)
gt(eql_v3_real_ord, jsonb)
gt(eql_v3_real_ord, query_real_ord)
gt(eql_v3_real_ord_ope, eql_v3_real_ord_ope)
gt(eql_v3_real_ord_ope, jsonb)
gt(eql_v3_real_ord_ope, query_real_ord_ope)
gt(eql_v3_real_ord_ore, eql_v3_real_ord_ore)
gt(eql_v3_real_ord_ore, jsonb)
gt(eql_v3_real_ord_ore, query_real_ord_ore)
gt(eql_v3_smallint_ord, eql_v3_smallint_ord)
gt(eql_v3_smallint_ord, jsonb)
gt(eql_v3_smallint_ord, query_smallint_ord)
gt(eql_v3_smallint_ord_ope, eql_v3_smallint_ord_ope)
gt(eql_v3_smallint_ord_ope, jsonb)
gt(eql_v3_smallint_ord_ope, query_smallint_ord_ope)
gt(eql_v3_smallint_ord_ore, eql_v3_smallint_ord_ore)
gt(eql_v3_smallint_ord_ore, jsonb)
gt(eql_v3_smallint_ord_ore, query_smallint_ord_ore)
gt(eql_v3_text_ord, eql_v3_text_ord)
gt(eql_v3_text_ord, jsonb)
gt(eql_v3_text_ord, query_text_ord)
gt(eql_v3_text_ord_ope, eql_v3_text_ord_ope)
gt(eql_v3_text_ord_ope, jsonb)
gt(eql_v3_text_ord_ope, query_text_ord_ope)
gt(eql_v3_text_ord_ore, eql_v3_text_ord_ore)
gt(eql_v3_text_ord_ore, jsonb)
gt(eql_v3_text_ord_ore, query_text_ord_ore)
gt(eql_v3_text_search, eql_v3_text_search)
gt(eql_v3_text_search, jsonb)
gt(eql_v3_text_search, query_text_search)
gt(eql_v3_text_search_ore, eql_v3_text_search_ore)
gt(eql_v3_text_search_ore, jsonb)
gt(eql_v3_text_search_ore, query_text_search_ore)
gt(eql_v3_timestamp_ord, eql_v3_timestamp_ord)
gt(eql_v3_timestamp_ord, jsonb)
gt(eql_v3_timestamp_ord, query_timestamp_ord)
gt(eql_v3_timestamp_ord_ope, eql_v3_timestamp_ord_ope)
gt(eql_v3_timestamp_ord_ope, jsonb)
gt(eql_v3_timestamp_ord_ope, query_timestamp_ord_ope)
gt(eql_v3_timestamp_ord_ore, eql_v3_timestamp_ord_ore)
gt(eql_v3_timestamp_ord_ore, jsonb)
gt(eql_v3_timestamp_ord_ore, query_timestamp_ord_ore)
gt(jsonb, eql_v3_bigint_ord)
gt(jsonb, eql_v3_bigint_ord_ope)
gt(jsonb, eql_v3_bigint_ord_ore)
gt(jsonb, eql_v3_date_ord)
gt(jsonb, eql_v3_date_ord_ope)
gt(jsonb, eql_v3_date_ord_ore)
gt(jsonb, eql_v3_double_ord)
gt(jsonb, eql_v3_double_ord_ope)
gt(jsonb, eql_v3_double_ord_ore)
gt(jsonb, eql_v3_integer_ord)
gt(jsonb, eql_v3_integer_ord_ope)
gt(jsonb, eql_v3_integer_ord_ore)
gt(jsonb, eql_v3_numeric_ord)
gt(jsonb, eql_v3_numeric_ord_ope)
gt(jsonb, eql_v3_numeric_ord_ore)
gt(jsonb, eql_v3_real_ord)
gt(jsonb, eql_v3_real_ord_ope)
gt(jsonb, eql_v3_real_ord_ore)
gt(jsonb, eql_v3_smallint_ord)
gt(jsonb, eql_v3_smallint_ord_ope)
gt(jsonb, eql_v3_smallint_ord_ore)
gt(jsonb, eql_v3_text_ord)
gt(jsonb, eql_v3_text_ord_ope)
gt(jsonb, eql_v3_text_ord_ore)
gt(jsonb, eql_v3_text_search)
gt(jsonb, eql_v3_text_search_ore)
gt(jsonb, eql_v3_timestamp_ord)
gt(jsonb, eql_v3_timestamp_ord_ope)
gt(jsonb, eql_v3_timestamp_ord_ore)
gt(query_bigint_ord, eql_v3_bigint_ord)
gt(query_bigint_ord, eql_v3_json_entry)
gt(query_bigint_ord_ope, eql_v3_bigint_ord_ope)
gt(query_bigint_ord_ore, eql_v3_bigint_ord_ore)
gt(query_date_ord, eql_v3_date_ord)
gt(query_date_ord_ope, eql_v3_date_ord_ope)
gt(query_date_ord_ore, eql_v3_date_ord_ore)
gt(query_double_ord, eql_v3_double_ord)
gt(query_double_ord, eql_v3_json_entry)
gt(query_double_ord_ope, eql_v3_double_ord_ope)
gt(query_double_ord_ore, eql_v3_double_ord_ore)
gt(query_integer_ord, eql_v3_integer_ord)
gt(query_integer_ord, eql_v3_json_entry)
gt(query_integer_ord_ope, eql_v3_integer_ord_ope)
gt(query_integer_ord_ore, eql_v3_integer_ord_ore)
gt(query_numeric_ord, eql_v3_json_entry)
gt(query_numeric_ord, eql_v3_numeric_ord)
gt(query_numeric_ord_ope, eql_v3_numeric_ord_ope)
gt(query_numeric_ord_ore, eql_v3_numeric_ord_ore)
gt(query_real_ord, eql_v3_json_entry)
gt(query_real_ord, eql_v3_real_ord)
gt(query_real_ord_ope, eql_v3_real_ord_ope)
gt(query_real_ord_ore, eql_v3_real_ord_ore)
gt(query_smallint_ord, eql_v3_json_entry)
gt(query_smallint_ord, eql_v3_smallint_ord)
gt(query_smallint_ord_ope, eql_v3_smallint_ord_ope)
gt(query_smallint_ord_ore, eql_v3_smallint_ord_ore)
gt(query_text_ord, eql_v3_json_entry)
gt(query_text_ord, eql_v3_text_ord)
gt(query_text_ord_ope, eql_v3_text_ord_ope)
gt(query_text_ord_ore, eql_v3_text_ord_ore)
gt(query_text_search, eql_v3_text_search)
gt(query_text_search_ore, eql_v3_text_search_ore)
gt(query_timestamp_ord, eql_v3_timestamp_ord)
gt(query_timestamp_ord_ope, eql_v3_timestamp_ord_ope)
gt(query_timestamp_ord_ore, eql_v3_timestamp_ord_ore)
```
| Parameter | Type | Description |
| ----------- | ------------------- | ----------- |
| `a public.` | `eql_v3_bigint_ord` | |
| `b public.` | `eql_v3_bigint_ord` | |
**Returns:** `boolean` — boolean
gte [#gte]
Operator wrapper for public.eql\_v3\_bigint\_ord.
**159 overloads** (one per encrypted type):
```sql
gte(eql_v3_bigint_ord, eql_v3_bigint_ord)
gte(eql_v3_bigint_ord, jsonb)
gte(eql_v3_bigint_ord, query_bigint_ord)
gte(eql_v3_bigint_ord_ope, eql_v3_bigint_ord_ope)
gte(eql_v3_bigint_ord_ope, jsonb)
gte(eql_v3_bigint_ord_ope, query_bigint_ord_ope)
gte(eql_v3_bigint_ord_ore, eql_v3_bigint_ord_ore)
gte(eql_v3_bigint_ord_ore, jsonb)
gte(eql_v3_bigint_ord_ore, query_bigint_ord_ore)
gte(eql_v3_date_ord, eql_v3_date_ord)
gte(eql_v3_date_ord, jsonb)
gte(eql_v3_date_ord, query_date_ord)
gte(eql_v3_date_ord_ope, eql_v3_date_ord_ope)
gte(eql_v3_date_ord_ope, jsonb)
gte(eql_v3_date_ord_ope, query_date_ord_ope)
gte(eql_v3_date_ord_ore, eql_v3_date_ord_ore)
gte(eql_v3_date_ord_ore, jsonb)
gte(eql_v3_date_ord_ore, query_date_ord_ore)
gte(eql_v3_double_ord, eql_v3_double_ord)
gte(eql_v3_double_ord, jsonb)
gte(eql_v3_double_ord, query_double_ord)
gte(eql_v3_double_ord_ope, eql_v3_double_ord_ope)
gte(eql_v3_double_ord_ope, jsonb)
gte(eql_v3_double_ord_ope, query_double_ord_ope)
gte(eql_v3_double_ord_ore, eql_v3_double_ord_ore)
gte(eql_v3_double_ord_ore, jsonb)
gte(eql_v3_double_ord_ore, query_double_ord_ore)
gte(eql_v3_integer_ord, eql_v3_integer_ord)
gte(eql_v3_integer_ord, jsonb)
gte(eql_v3_integer_ord, query_integer_ord)
gte(eql_v3_integer_ord_ope, eql_v3_integer_ord_ope)
gte(eql_v3_integer_ord_ope, jsonb)
gte(eql_v3_integer_ord_ope, query_integer_ord_ope)
gte(eql_v3_integer_ord_ore, eql_v3_integer_ord_ore)
gte(eql_v3_integer_ord_ore, jsonb)
gte(eql_v3_integer_ord_ore, query_integer_ord_ore)
gte(eql_v3_json_entry, query_bigint_ord)
gte(eql_v3_json_entry, query_double_ord)
gte(eql_v3_json_entry, query_integer_ord)
gte(eql_v3_json_entry, query_numeric_ord)
gte(eql_v3_json_entry, query_real_ord)
gte(eql_v3_json_entry, query_smallint_ord)
gte(eql_v3_json_entry, query_text_ord)
gte(eql_v3_numeric_ord, eql_v3_numeric_ord)
gte(eql_v3_numeric_ord, jsonb)
gte(eql_v3_numeric_ord, query_numeric_ord)
gte(eql_v3_numeric_ord_ope, eql_v3_numeric_ord_ope)
gte(eql_v3_numeric_ord_ope, jsonb)
gte(eql_v3_numeric_ord_ope, query_numeric_ord_ope)
gte(eql_v3_numeric_ord_ore, eql_v3_numeric_ord_ore)
gte(eql_v3_numeric_ord_ore, jsonb)
gte(eql_v3_numeric_ord_ore, query_numeric_ord_ore)
gte(eql_v3_real_ord, eql_v3_real_ord)
gte(eql_v3_real_ord, jsonb)
gte(eql_v3_real_ord, query_real_ord)
gte(eql_v3_real_ord_ope, eql_v3_real_ord_ope)
gte(eql_v3_real_ord_ope, jsonb)
gte(eql_v3_real_ord_ope, query_real_ord_ope)
gte(eql_v3_real_ord_ore, eql_v3_real_ord_ore)
gte(eql_v3_real_ord_ore, jsonb)
gte(eql_v3_real_ord_ore, query_real_ord_ore)
gte(eql_v3_smallint_ord, eql_v3_smallint_ord)
gte(eql_v3_smallint_ord, jsonb)
gte(eql_v3_smallint_ord, query_smallint_ord)
gte(eql_v3_smallint_ord_ope, eql_v3_smallint_ord_ope)
gte(eql_v3_smallint_ord_ope, jsonb)
gte(eql_v3_smallint_ord_ope, query_smallint_ord_ope)
gte(eql_v3_smallint_ord_ore, eql_v3_smallint_ord_ore)
gte(eql_v3_smallint_ord_ore, jsonb)
gte(eql_v3_smallint_ord_ore, query_smallint_ord_ore)
gte(eql_v3_text_ord, eql_v3_text_ord)
gte(eql_v3_text_ord, jsonb)
gte(eql_v3_text_ord, query_text_ord)
gte(eql_v3_text_ord_ope, eql_v3_text_ord_ope)
gte(eql_v3_text_ord_ope, jsonb)
gte(eql_v3_text_ord_ope, query_text_ord_ope)
gte(eql_v3_text_ord_ore, eql_v3_text_ord_ore)
gte(eql_v3_text_ord_ore, jsonb)
gte(eql_v3_text_ord_ore, query_text_ord_ore)
gte(eql_v3_text_search, eql_v3_text_search)
gte(eql_v3_text_search, jsonb)
gte(eql_v3_text_search, query_text_search)
gte(eql_v3_text_search_ore, eql_v3_text_search_ore)
gte(eql_v3_text_search_ore, jsonb)
gte(eql_v3_text_search_ore, query_text_search_ore)
gte(eql_v3_timestamp_ord, eql_v3_timestamp_ord)
gte(eql_v3_timestamp_ord, jsonb)
gte(eql_v3_timestamp_ord, query_timestamp_ord)
gte(eql_v3_timestamp_ord_ope, eql_v3_timestamp_ord_ope)
gte(eql_v3_timestamp_ord_ope, jsonb)
gte(eql_v3_timestamp_ord_ope, query_timestamp_ord_ope)
gte(eql_v3_timestamp_ord_ore, eql_v3_timestamp_ord_ore)
gte(eql_v3_timestamp_ord_ore, jsonb)
gte(eql_v3_timestamp_ord_ore, query_timestamp_ord_ore)
gte(jsonb, eql_v3_bigint_ord)
gte(jsonb, eql_v3_bigint_ord_ope)
gte(jsonb, eql_v3_bigint_ord_ore)
gte(jsonb, eql_v3_date_ord)
gte(jsonb, eql_v3_date_ord_ope)
gte(jsonb, eql_v3_date_ord_ore)
gte(jsonb, eql_v3_double_ord)
gte(jsonb, eql_v3_double_ord_ope)
gte(jsonb, eql_v3_double_ord_ore)
gte(jsonb, eql_v3_integer_ord)
gte(jsonb, eql_v3_integer_ord_ope)
gte(jsonb, eql_v3_integer_ord_ore)
gte(jsonb, eql_v3_numeric_ord)
gte(jsonb, eql_v3_numeric_ord_ope)
gte(jsonb, eql_v3_numeric_ord_ore)
gte(jsonb, eql_v3_real_ord)
gte(jsonb, eql_v3_real_ord_ope)
gte(jsonb, eql_v3_real_ord_ore)
gte(jsonb, eql_v3_smallint_ord)
gte(jsonb, eql_v3_smallint_ord_ope)
gte(jsonb, eql_v3_smallint_ord_ore)
gte(jsonb, eql_v3_text_ord)
gte(jsonb, eql_v3_text_ord_ope)
gte(jsonb, eql_v3_text_ord_ore)
gte(jsonb, eql_v3_text_search)
gte(jsonb, eql_v3_text_search_ore)
gte(jsonb, eql_v3_timestamp_ord)
gte(jsonb, eql_v3_timestamp_ord_ope)
gte(jsonb, eql_v3_timestamp_ord_ore)
gte(query_bigint_ord, eql_v3_bigint_ord)
gte(query_bigint_ord, eql_v3_json_entry)
gte(query_bigint_ord_ope, eql_v3_bigint_ord_ope)
gte(query_bigint_ord_ore, eql_v3_bigint_ord_ore)
gte(query_date_ord, eql_v3_date_ord)
gte(query_date_ord_ope, eql_v3_date_ord_ope)
gte(query_date_ord_ore, eql_v3_date_ord_ore)
gte(query_double_ord, eql_v3_double_ord)
gte(query_double_ord, eql_v3_json_entry)
gte(query_double_ord_ope, eql_v3_double_ord_ope)
gte(query_double_ord_ore, eql_v3_double_ord_ore)
gte(query_integer_ord, eql_v3_integer_ord)
gte(query_integer_ord, eql_v3_json_entry)
gte(query_integer_ord_ope, eql_v3_integer_ord_ope)
gte(query_integer_ord_ore, eql_v3_integer_ord_ore)
gte(query_numeric_ord, eql_v3_json_entry)
gte(query_numeric_ord, eql_v3_numeric_ord)
gte(query_numeric_ord_ope, eql_v3_numeric_ord_ope)
gte(query_numeric_ord_ore, eql_v3_numeric_ord_ore)
gte(query_real_ord, eql_v3_json_entry)
gte(query_real_ord, eql_v3_real_ord)
gte(query_real_ord_ope, eql_v3_real_ord_ope)
gte(query_real_ord_ore, eql_v3_real_ord_ore)
gte(query_smallint_ord, eql_v3_json_entry)
gte(query_smallint_ord, eql_v3_smallint_ord)
gte(query_smallint_ord_ope, eql_v3_smallint_ord_ope)
gte(query_smallint_ord_ore, eql_v3_smallint_ord_ore)
gte(query_text_ord, eql_v3_json_entry)
gte(query_text_ord, eql_v3_text_ord)
gte(query_text_ord_ope, eql_v3_text_ord_ope)
gte(query_text_ord_ore, eql_v3_text_ord_ore)
gte(query_text_search, eql_v3_text_search)
gte(query_text_search_ore, eql_v3_text_search_ore)
gte(query_timestamp_ord, eql_v3_timestamp_ord)
gte(query_timestamp_ord_ope, eql_v3_timestamp_ord_ope)
gte(query_timestamp_ord_ore, eql_v3_timestamp_ord_ore)
```
| Parameter | Type | Description |
| ----------- | ------------------- | ----------- |
| `a public.` | `eql_v3_bigint_ord` | |
| `b public.` | `eql_v3_bigint_ord` | |
**Returns:** `boolean` — boolean
jsonb_array [#jsonb_array]
Extract deterministic containment fields (s) per sv element.
Excludes non-deterministic ciphertext so PostgreSQL's native jsonb @> can compare for containment. Use for GIN indexes and containment queries. Exact and structural containment are selector-set containment, so ordering terms are deliberately excluded.
**Signature:**
```sql
jsonb_array(jsonb)
```
| Parameter | Type | Description |
| --------- | ------- | --------------------- |
| `val` | `jsonb` | encrypted EQL payload |
**Returns:** `jsonb[]` — jsonb\[] Array of objects with only deterministic fields.
jsonb_array_elements [#jsonb_array_elements]
Extract elements of an encrypted JSONB array as rows.
**Signature:**
```sql
jsonb_array_elements(jsonb)
```
| Parameter | Type | Description |
| --------- | ------- | ---------------------------------------------- |
| `val` | `jsonb` | encrypted EQL payload (must have a flag true). |
**Returns:** `SETOF` — SETOF public.eql\_v3\_json\_entry One row per element (metadata preserved).
jsonb_array_length [#jsonb_array_length]
Get the length of an encrypted JSONB array.
**Signature:**
```sql
jsonb_array_length(jsonb)
```
| Parameter | Type | Description |
| --------- | ------- | ---------------------------------------------- |
| `val` | `jsonb` | encrypted EQL payload (must have a flag true). |
**Returns:** `integer` — integer Number of elements.
jsonb_contained_by [#jsonb_contained_by]
GIN-indexable "is contained by" check.
**Signature:**
```sql
jsonb_contained_by(jsonb, jsonb)
```
| Parameter | Type | Description |
| --------- | ------- | ------------------ |
| `a` | `jsonb` | Payload to check. |
| `b` | `jsonb` | Container payload. |
**Returns:** `boolean` — boolean True if all elements of a are contained in b.
jsonb_contains [#jsonb_contains]
GIN-indexable containment check: does a contain all of b?
**Signature:**
```sql
jsonb_contains(jsonb, jsonb)
```
| Parameter | Type | Description |
| --------- | ------- | ------------------ |
| `a` | `jsonb` | Container payload. |
| `b` | `jsonb` | Search payload. |
**Returns:** `boolean` — boolean True if a contains all deterministic elements of b.
jsonb_path_exists [#jsonb_path_exists]
Check if a selector path exists in encrypted JSONB.
**Signature:**
```sql
jsonb_path_exists(jsonb, text)
```
| Parameter | Type | Description |
| ---------- | ------- | ---------------------- |
| `val` | `jsonb` | encrypted EQL payload. |
| `selector` | `text` | Selector hash to test. |
**Returns:** `boolean` — boolean True if a matching element exists.
jsonb_path_query [#jsonb_path_query]
Query encrypted JSONB for sv elements matching selector.
Returns one jsonb\_entry row per matching encrypted element. Returns empty set on no match. It deliberately does not wrap multiple matches as an public.eql\_v3\_json\_search document, because the root document domain requires an sv array and single leaves belong to public.eql\_v3\_json\_entry.
**Signature:**
```sql
jsonb_path_query(jsonb, text)
```
| Parameter | Type | Description |
| ---------- | ------- | ------------------------------ |
| `val` | `jsonb` | encrypted EQL payload with sv. |
| `selector` | `text` | Selector hash (s value). |
**Returns:** `SETOF` — SETOF public.eql\_v3\_json\_entry Matching encrypted entries.
jsonb_path_query_first [#jsonb_path_query_first]
Get the first sv element matching selector, or NULL.
**Signature:**
```sql
jsonb_path_query_first(jsonb, text)
```
| Parameter | Type | Description |
| ---------- | ------- | ----------------------- |
| `val` | `jsonb` | encrypted EQL payload. |
| `selector` | `text` | Selector hash to match. |
**Returns:** `public.eql_v3_json_entry` — public.eql\_v3\_json\_entry First matching element or NULL.
lints [#lints]
EQL lint: detect non-inlinable operator implementation functions.
Returns one row per violation found in the installed eql\_v3 surface. The Postgres planner can only inline a function during index matching when:
LANGUAGE sql (plpgsql / C / etc. cannot be inlined)IMMUTABLE or STABLE volatility (VOLATILE cannot be inlined into index expressions)No SET clauses (e.g. SET search\_path = ...)Not SECURITY DEFINERSingle-statement SELECT body
Severity: error — fixable, blocks index matching, ship-blocking. warning — likely-fixable, may not block matching but signals intent. info — observational; useful for review, not a defect on its own.
Categories: inlinability\_language — implementation function isn't LANGUAGE sql. inlinability\_volatility — implementation function is VOLATILE. inlinability\_set\_clause — implementation function has a SET clause. inlinability\_secdef — implementation function is SECURITY DEFINER. inlinability\_transitive — implementation function is itself inlinable but its body invokes a non-inlinable function (depth 1; the planner can't peek through that boundary). blocker\_language — encrypted-domain blocker is not LANGUAGE plpgsql. The planner can inline / elide a LANGUAGE sql body when the result is provably unused, silently bypassing the RAISE that the blocker exists to perform. blocker\_strict — encrypted-domain blocker is STRICT. PostgreSQL skips the body and returns NULL on NULL arguments, silently bypassing the RAISE. domain\_over\_domain — an eql\_v3 encrypted domain is derived from another encrypted domain rather than jsonb. Operators resolve against the ultimate base type, so the derived domain does not inherit the base domain's blocker surface. domain\_opclass — an operator class is declared FOR TYPE on an eql\_v3 encrypted domain. Opclasses on domains bypass operator resolution; use a functional index on the extractor instead. schema\_placement — a naked composite or enum TYPE lives in the public eql\_v3 schema. Internal index-term types (e.g. ore\_block\_256\_term) belong in eql\_v3\_internal; a composite/enum in eql\_v3 clutters the Supabase Table Builder type picker, which the schema split exists to prevent. Move it to eql\_v3\_internal.
SELECT severity, category, object\_name, message FROM eql\_v3.lints() WHERE severity = 'error' ORDER BY category, object\_name;
**Signature:**
```sql
lints()
```
**Returns:** `TABLE` — SETOF record (severity text, category text, object\_name text, message text)
lt [#lt]
Operator wrapper for public.eql\_v3\_bigint\_ord.
**159 overloads** (one per encrypted type):
```sql
lt(eql_v3_bigint_ord, eql_v3_bigint_ord)
lt(eql_v3_bigint_ord, jsonb)
lt(eql_v3_bigint_ord, query_bigint_ord)
lt(eql_v3_bigint_ord_ope, eql_v3_bigint_ord_ope)
lt(eql_v3_bigint_ord_ope, jsonb)
lt(eql_v3_bigint_ord_ope, query_bigint_ord_ope)
lt(eql_v3_bigint_ord_ore, eql_v3_bigint_ord_ore)
lt(eql_v3_bigint_ord_ore, jsonb)
lt(eql_v3_bigint_ord_ore, query_bigint_ord_ore)
lt(eql_v3_date_ord, eql_v3_date_ord)
lt(eql_v3_date_ord, jsonb)
lt(eql_v3_date_ord, query_date_ord)
lt(eql_v3_date_ord_ope, eql_v3_date_ord_ope)
lt(eql_v3_date_ord_ope, jsonb)
lt(eql_v3_date_ord_ope, query_date_ord_ope)
lt(eql_v3_date_ord_ore, eql_v3_date_ord_ore)
lt(eql_v3_date_ord_ore, jsonb)
lt(eql_v3_date_ord_ore, query_date_ord_ore)
lt(eql_v3_double_ord, eql_v3_double_ord)
lt(eql_v3_double_ord, jsonb)
lt(eql_v3_double_ord, query_double_ord)
lt(eql_v3_double_ord_ope, eql_v3_double_ord_ope)
lt(eql_v3_double_ord_ope, jsonb)
lt(eql_v3_double_ord_ope, query_double_ord_ope)
lt(eql_v3_double_ord_ore, eql_v3_double_ord_ore)
lt(eql_v3_double_ord_ore, jsonb)
lt(eql_v3_double_ord_ore, query_double_ord_ore)
lt(eql_v3_integer_ord, eql_v3_integer_ord)
lt(eql_v3_integer_ord, jsonb)
lt(eql_v3_integer_ord, query_integer_ord)
lt(eql_v3_integer_ord_ope, eql_v3_integer_ord_ope)
lt(eql_v3_integer_ord_ope, jsonb)
lt(eql_v3_integer_ord_ope, query_integer_ord_ope)
lt(eql_v3_integer_ord_ore, eql_v3_integer_ord_ore)
lt(eql_v3_integer_ord_ore, jsonb)
lt(eql_v3_integer_ord_ore, query_integer_ord_ore)
lt(eql_v3_json_entry, query_bigint_ord)
lt(eql_v3_json_entry, query_double_ord)
lt(eql_v3_json_entry, query_integer_ord)
lt(eql_v3_json_entry, query_numeric_ord)
lt(eql_v3_json_entry, query_real_ord)
lt(eql_v3_json_entry, query_smallint_ord)
lt(eql_v3_json_entry, query_text_ord)
lt(eql_v3_numeric_ord, eql_v3_numeric_ord)
lt(eql_v3_numeric_ord, jsonb)
lt(eql_v3_numeric_ord, query_numeric_ord)
lt(eql_v3_numeric_ord_ope, eql_v3_numeric_ord_ope)
lt(eql_v3_numeric_ord_ope, jsonb)
lt(eql_v3_numeric_ord_ope, query_numeric_ord_ope)
lt(eql_v3_numeric_ord_ore, eql_v3_numeric_ord_ore)
lt(eql_v3_numeric_ord_ore, jsonb)
lt(eql_v3_numeric_ord_ore, query_numeric_ord_ore)
lt(eql_v3_real_ord, eql_v3_real_ord)
lt(eql_v3_real_ord, jsonb)
lt(eql_v3_real_ord, query_real_ord)
lt(eql_v3_real_ord_ope, eql_v3_real_ord_ope)
lt(eql_v3_real_ord_ope, jsonb)
lt(eql_v3_real_ord_ope, query_real_ord_ope)
lt(eql_v3_real_ord_ore, eql_v3_real_ord_ore)
lt(eql_v3_real_ord_ore, jsonb)
lt(eql_v3_real_ord_ore, query_real_ord_ore)
lt(eql_v3_smallint_ord, eql_v3_smallint_ord)
lt(eql_v3_smallint_ord, jsonb)
lt(eql_v3_smallint_ord, query_smallint_ord)
lt(eql_v3_smallint_ord_ope, eql_v3_smallint_ord_ope)
lt(eql_v3_smallint_ord_ope, jsonb)
lt(eql_v3_smallint_ord_ope, query_smallint_ord_ope)
lt(eql_v3_smallint_ord_ore, eql_v3_smallint_ord_ore)
lt(eql_v3_smallint_ord_ore, jsonb)
lt(eql_v3_smallint_ord_ore, query_smallint_ord_ore)
lt(eql_v3_text_ord, eql_v3_text_ord)
lt(eql_v3_text_ord, jsonb)
lt(eql_v3_text_ord, query_text_ord)
lt(eql_v3_text_ord_ope, eql_v3_text_ord_ope)
lt(eql_v3_text_ord_ope, jsonb)
lt(eql_v3_text_ord_ope, query_text_ord_ope)
lt(eql_v3_text_ord_ore, eql_v3_text_ord_ore)
lt(eql_v3_text_ord_ore, jsonb)
lt(eql_v3_text_ord_ore, query_text_ord_ore)
lt(eql_v3_text_search, eql_v3_text_search)
lt(eql_v3_text_search, jsonb)
lt(eql_v3_text_search, query_text_search)
lt(eql_v3_text_search_ore, eql_v3_text_search_ore)
lt(eql_v3_text_search_ore, jsonb)
lt(eql_v3_text_search_ore, query_text_search_ore)
lt(eql_v3_timestamp_ord, eql_v3_timestamp_ord)
lt(eql_v3_timestamp_ord, jsonb)
lt(eql_v3_timestamp_ord, query_timestamp_ord)
lt(eql_v3_timestamp_ord_ope, eql_v3_timestamp_ord_ope)
lt(eql_v3_timestamp_ord_ope, jsonb)
lt(eql_v3_timestamp_ord_ope, query_timestamp_ord_ope)
lt(eql_v3_timestamp_ord_ore, eql_v3_timestamp_ord_ore)
lt(eql_v3_timestamp_ord_ore, jsonb)
lt(eql_v3_timestamp_ord_ore, query_timestamp_ord_ore)
lt(jsonb, eql_v3_bigint_ord)
lt(jsonb, eql_v3_bigint_ord_ope)
lt(jsonb, eql_v3_bigint_ord_ore)
lt(jsonb, eql_v3_date_ord)
lt(jsonb, eql_v3_date_ord_ope)
lt(jsonb, eql_v3_date_ord_ore)
lt(jsonb, eql_v3_double_ord)
lt(jsonb, eql_v3_double_ord_ope)
lt(jsonb, eql_v3_double_ord_ore)
lt(jsonb, eql_v3_integer_ord)
lt(jsonb, eql_v3_integer_ord_ope)
lt(jsonb, eql_v3_integer_ord_ore)
lt(jsonb, eql_v3_numeric_ord)
lt(jsonb, eql_v3_numeric_ord_ope)
lt(jsonb, eql_v3_numeric_ord_ore)
lt(jsonb, eql_v3_real_ord)
lt(jsonb, eql_v3_real_ord_ope)
lt(jsonb, eql_v3_real_ord_ore)
lt(jsonb, eql_v3_smallint_ord)
lt(jsonb, eql_v3_smallint_ord_ope)
lt(jsonb, eql_v3_smallint_ord_ore)
lt(jsonb, eql_v3_text_ord)
lt(jsonb, eql_v3_text_ord_ope)
lt(jsonb, eql_v3_text_ord_ore)
lt(jsonb, eql_v3_text_search)
lt(jsonb, eql_v3_text_search_ore)
lt(jsonb, eql_v3_timestamp_ord)
lt(jsonb, eql_v3_timestamp_ord_ope)
lt(jsonb, eql_v3_timestamp_ord_ore)
lt(query_bigint_ord, eql_v3_bigint_ord)
lt(query_bigint_ord, eql_v3_json_entry)
lt(query_bigint_ord_ope, eql_v3_bigint_ord_ope)
lt(query_bigint_ord_ore, eql_v3_bigint_ord_ore)
lt(query_date_ord, eql_v3_date_ord)
lt(query_date_ord_ope, eql_v3_date_ord_ope)
lt(query_date_ord_ore, eql_v3_date_ord_ore)
lt(query_double_ord, eql_v3_double_ord)
lt(query_double_ord, eql_v3_json_entry)
lt(query_double_ord_ope, eql_v3_double_ord_ope)
lt(query_double_ord_ore, eql_v3_double_ord_ore)
lt(query_integer_ord, eql_v3_integer_ord)
lt(query_integer_ord, eql_v3_json_entry)
lt(query_integer_ord_ope, eql_v3_integer_ord_ope)
lt(query_integer_ord_ore, eql_v3_integer_ord_ore)
lt(query_numeric_ord, eql_v3_json_entry)
lt(query_numeric_ord, eql_v3_numeric_ord)
lt(query_numeric_ord_ope, eql_v3_numeric_ord_ope)
lt(query_numeric_ord_ore, eql_v3_numeric_ord_ore)
lt(query_real_ord, eql_v3_json_entry)
lt(query_real_ord, eql_v3_real_ord)
lt(query_real_ord_ope, eql_v3_real_ord_ope)
lt(query_real_ord_ore, eql_v3_real_ord_ore)
lt(query_smallint_ord, eql_v3_json_entry)
lt(query_smallint_ord, eql_v3_smallint_ord)
lt(query_smallint_ord_ope, eql_v3_smallint_ord_ope)
lt(query_smallint_ord_ore, eql_v3_smallint_ord_ore)
lt(query_text_ord, eql_v3_json_entry)
lt(query_text_ord, eql_v3_text_ord)
lt(query_text_ord_ope, eql_v3_text_ord_ope)
lt(query_text_ord_ore, eql_v3_text_ord_ore)
lt(query_text_search, eql_v3_text_search)
lt(query_text_search_ore, eql_v3_text_search_ore)
lt(query_timestamp_ord, eql_v3_timestamp_ord)
lt(query_timestamp_ord_ope, eql_v3_timestamp_ord_ope)
lt(query_timestamp_ord_ore, eql_v3_timestamp_ord_ore)
```
| Parameter | Type | Description |
| ----------- | ------------------- | ----------- |
| `a public.` | `eql_v3_bigint_ord` | |
| `b public.` | `eql_v3_bigint_ord` | |
**Returns:** `boolean` — boolean
lte [#lte]
Operator wrapper for public.eql\_v3\_bigint\_ord.
**159 overloads** (one per encrypted type):
```sql
lte(eql_v3_bigint_ord, eql_v3_bigint_ord)
lte(eql_v3_bigint_ord, jsonb)
lte(eql_v3_bigint_ord, query_bigint_ord)
lte(eql_v3_bigint_ord_ope, eql_v3_bigint_ord_ope)
lte(eql_v3_bigint_ord_ope, jsonb)
lte(eql_v3_bigint_ord_ope, query_bigint_ord_ope)
lte(eql_v3_bigint_ord_ore, eql_v3_bigint_ord_ore)
lte(eql_v3_bigint_ord_ore, jsonb)
lte(eql_v3_bigint_ord_ore, query_bigint_ord_ore)
lte(eql_v3_date_ord, eql_v3_date_ord)
lte(eql_v3_date_ord, jsonb)
lte(eql_v3_date_ord, query_date_ord)
lte(eql_v3_date_ord_ope, eql_v3_date_ord_ope)
lte(eql_v3_date_ord_ope, jsonb)
lte(eql_v3_date_ord_ope, query_date_ord_ope)
lte(eql_v3_date_ord_ore, eql_v3_date_ord_ore)
lte(eql_v3_date_ord_ore, jsonb)
lte(eql_v3_date_ord_ore, query_date_ord_ore)
lte(eql_v3_double_ord, eql_v3_double_ord)
lte(eql_v3_double_ord, jsonb)
lte(eql_v3_double_ord, query_double_ord)
lte(eql_v3_double_ord_ope, eql_v3_double_ord_ope)
lte(eql_v3_double_ord_ope, jsonb)
lte(eql_v3_double_ord_ope, query_double_ord_ope)
lte(eql_v3_double_ord_ore, eql_v3_double_ord_ore)
lte(eql_v3_double_ord_ore, jsonb)
lte(eql_v3_double_ord_ore, query_double_ord_ore)
lte(eql_v3_integer_ord, eql_v3_integer_ord)
lte(eql_v3_integer_ord, jsonb)
lte(eql_v3_integer_ord, query_integer_ord)
lte(eql_v3_integer_ord_ope, eql_v3_integer_ord_ope)
lte(eql_v3_integer_ord_ope, jsonb)
lte(eql_v3_integer_ord_ope, query_integer_ord_ope)
lte(eql_v3_integer_ord_ore, eql_v3_integer_ord_ore)
lte(eql_v3_integer_ord_ore, jsonb)
lte(eql_v3_integer_ord_ore, query_integer_ord_ore)
lte(eql_v3_json_entry, query_bigint_ord)
lte(eql_v3_json_entry, query_double_ord)
lte(eql_v3_json_entry, query_integer_ord)
lte(eql_v3_json_entry, query_numeric_ord)
lte(eql_v3_json_entry, query_real_ord)
lte(eql_v3_json_entry, query_smallint_ord)
lte(eql_v3_json_entry, query_text_ord)
lte(eql_v3_numeric_ord, eql_v3_numeric_ord)
lte(eql_v3_numeric_ord, jsonb)
lte(eql_v3_numeric_ord, query_numeric_ord)
lte(eql_v3_numeric_ord_ope, eql_v3_numeric_ord_ope)
lte(eql_v3_numeric_ord_ope, jsonb)
lte(eql_v3_numeric_ord_ope, query_numeric_ord_ope)
lte(eql_v3_numeric_ord_ore, eql_v3_numeric_ord_ore)
lte(eql_v3_numeric_ord_ore, jsonb)
lte(eql_v3_numeric_ord_ore, query_numeric_ord_ore)
lte(eql_v3_real_ord, eql_v3_real_ord)
lte(eql_v3_real_ord, jsonb)
lte(eql_v3_real_ord, query_real_ord)
lte(eql_v3_real_ord_ope, eql_v3_real_ord_ope)
lte(eql_v3_real_ord_ope, jsonb)
lte(eql_v3_real_ord_ope, query_real_ord_ope)
lte(eql_v3_real_ord_ore, eql_v3_real_ord_ore)
lte(eql_v3_real_ord_ore, jsonb)
lte(eql_v3_real_ord_ore, query_real_ord_ore)
lte(eql_v3_smallint_ord, eql_v3_smallint_ord)
lte(eql_v3_smallint_ord, jsonb)
lte(eql_v3_smallint_ord, query_smallint_ord)
lte(eql_v3_smallint_ord_ope, eql_v3_smallint_ord_ope)
lte(eql_v3_smallint_ord_ope, jsonb)
lte(eql_v3_smallint_ord_ope, query_smallint_ord_ope)
lte(eql_v3_smallint_ord_ore, eql_v3_smallint_ord_ore)
lte(eql_v3_smallint_ord_ore, jsonb)
lte(eql_v3_smallint_ord_ore, query_smallint_ord_ore)
lte(eql_v3_text_ord, eql_v3_text_ord)
lte(eql_v3_text_ord, jsonb)
lte(eql_v3_text_ord, query_text_ord)
lte(eql_v3_text_ord_ope, eql_v3_text_ord_ope)
lte(eql_v3_text_ord_ope, jsonb)
lte(eql_v3_text_ord_ope, query_text_ord_ope)
lte(eql_v3_text_ord_ore, eql_v3_text_ord_ore)
lte(eql_v3_text_ord_ore, jsonb)
lte(eql_v3_text_ord_ore, query_text_ord_ore)
lte(eql_v3_text_search, eql_v3_text_search)
lte(eql_v3_text_search, jsonb)
lte(eql_v3_text_search, query_text_search)
lte(eql_v3_text_search_ore, eql_v3_text_search_ore)
lte(eql_v3_text_search_ore, jsonb)
lte(eql_v3_text_search_ore, query_text_search_ore)
lte(eql_v3_timestamp_ord, eql_v3_timestamp_ord)
lte(eql_v3_timestamp_ord, jsonb)
lte(eql_v3_timestamp_ord, query_timestamp_ord)
lte(eql_v3_timestamp_ord_ope, eql_v3_timestamp_ord_ope)
lte(eql_v3_timestamp_ord_ope, jsonb)
lte(eql_v3_timestamp_ord_ope, query_timestamp_ord_ope)
lte(eql_v3_timestamp_ord_ore, eql_v3_timestamp_ord_ore)
lte(eql_v3_timestamp_ord_ore, jsonb)
lte(eql_v3_timestamp_ord_ore, query_timestamp_ord_ore)
lte(jsonb, eql_v3_bigint_ord)
lte(jsonb, eql_v3_bigint_ord_ope)
lte(jsonb, eql_v3_bigint_ord_ore)
lte(jsonb, eql_v3_date_ord)
lte(jsonb, eql_v3_date_ord_ope)
lte(jsonb, eql_v3_date_ord_ore)
lte(jsonb, eql_v3_double_ord)
lte(jsonb, eql_v3_double_ord_ope)
lte(jsonb, eql_v3_double_ord_ore)
lte(jsonb, eql_v3_integer_ord)
lte(jsonb, eql_v3_integer_ord_ope)
lte(jsonb, eql_v3_integer_ord_ore)
lte(jsonb, eql_v3_numeric_ord)
lte(jsonb, eql_v3_numeric_ord_ope)
lte(jsonb, eql_v3_numeric_ord_ore)
lte(jsonb, eql_v3_real_ord)
lte(jsonb, eql_v3_real_ord_ope)
lte(jsonb, eql_v3_real_ord_ore)
lte(jsonb, eql_v3_smallint_ord)
lte(jsonb, eql_v3_smallint_ord_ope)
lte(jsonb, eql_v3_smallint_ord_ore)
lte(jsonb, eql_v3_text_ord)
lte(jsonb, eql_v3_text_ord_ope)
lte(jsonb, eql_v3_text_ord_ore)
lte(jsonb, eql_v3_text_search)
lte(jsonb, eql_v3_text_search_ore)
lte(jsonb, eql_v3_timestamp_ord)
lte(jsonb, eql_v3_timestamp_ord_ope)
lte(jsonb, eql_v3_timestamp_ord_ore)
lte(query_bigint_ord, eql_v3_bigint_ord)
lte(query_bigint_ord, eql_v3_json_entry)
lte(query_bigint_ord_ope, eql_v3_bigint_ord_ope)
lte(query_bigint_ord_ore, eql_v3_bigint_ord_ore)
lte(query_date_ord, eql_v3_date_ord)
lte(query_date_ord_ope, eql_v3_date_ord_ope)
lte(query_date_ord_ore, eql_v3_date_ord_ore)
lte(query_double_ord, eql_v3_double_ord)
lte(query_double_ord, eql_v3_json_entry)
lte(query_double_ord_ope, eql_v3_double_ord_ope)
lte(query_double_ord_ore, eql_v3_double_ord_ore)
lte(query_integer_ord, eql_v3_integer_ord)
lte(query_integer_ord, eql_v3_json_entry)
lte(query_integer_ord_ope, eql_v3_integer_ord_ope)
lte(query_integer_ord_ore, eql_v3_integer_ord_ore)
lte(query_numeric_ord, eql_v3_json_entry)
lte(query_numeric_ord, eql_v3_numeric_ord)
lte(query_numeric_ord_ope, eql_v3_numeric_ord_ope)
lte(query_numeric_ord_ore, eql_v3_numeric_ord_ore)
lte(query_real_ord, eql_v3_json_entry)
lte(query_real_ord, eql_v3_real_ord)
lte(query_real_ord_ope, eql_v3_real_ord_ope)
lte(query_real_ord_ore, eql_v3_real_ord_ore)
lte(query_smallint_ord, eql_v3_json_entry)
lte(query_smallint_ord, eql_v3_smallint_ord)
lte(query_smallint_ord_ope, eql_v3_smallint_ord_ope)
lte(query_smallint_ord_ore, eql_v3_smallint_ord_ore)
lte(query_text_ord, eql_v3_json_entry)
lte(query_text_ord, eql_v3_text_ord)
lte(query_text_ord_ope, eql_v3_text_ord_ope)
lte(query_text_ord_ore, eql_v3_text_ord_ore)
lte(query_text_search, eql_v3_text_search)
lte(query_text_search_ore, eql_v3_text_search_ore)
lte(query_timestamp_ord, eql_v3_timestamp_ord)
lte(query_timestamp_ord_ope, eql_v3_timestamp_ord_ope)
lte(query_timestamp_ord_ore, eql_v3_timestamp_ord_ore)
```
| Parameter | Type | Description |
| ----------- | ------------------- | ----------- |
| `a public.` | `eql_v3_bigint_ord` | |
| `b public.` | `eql_v3_bigint_ord` | |
**Returns:** `boolean` — boolean
match_term [#match_term]
Index extractor for public.eql\_v3\_text\_match.
**6 overloads** (one per encrypted type):
```sql
match_term(eql_v3_text_match)
match_term(eql_v3_text_search)
match_term(eql_v3_text_search_ore)
match_term(query_text_match)
match_term(query_text_search)
match_term(query_text_search_ore)
```
| Parameter | Type | Description |
| ----------- | ------------------- | ----------- |
| `a public.` | `eql_v3_text_match` | |
**Returns:** `eql_v3_internal.bloom_filter` — eql\_v3\_internal.bloom\_filter
matches [#matches]
Operator wrapper for public.eql\_v3\_text\_match.
**15 overloads** (one per encrypted type):
```sql
matches(eql_v3_text_match, eql_v3_text_match)
matches(eql_v3_text_match, jsonb)
matches(eql_v3_text_match, query_text_match)
matches(eql_v3_text_search, eql_v3_text_search)
matches(eql_v3_text_search, jsonb)
matches(eql_v3_text_search, query_text_search)
matches(eql_v3_text_search_ore, eql_v3_text_search_ore)
matches(eql_v3_text_search_ore, jsonb)
matches(eql_v3_text_search_ore, query_text_search_ore)
matches(jsonb, eql_v3_text_match)
matches(jsonb, eql_v3_text_search)
matches(jsonb, eql_v3_text_search_ore)
matches(query_text_match, eql_v3_text_match)
matches(query_text_search, eql_v3_text_search)
matches(query_text_search_ore, eql_v3_text_search_ore)
```
| Parameter | Type | Description |
| ----------- | ------------------- | ----------- |
| `a public.` | `eql_v3_text_match` | |
| `b public.` | `eql_v3_text_match` | |
**Returns:** `boolean` — boolean
max [#max]
max aggregate for public.eql\_v3\_bigint\_ord.
**30 overloads** (one per encrypted type):
```sql
max(public.eql_v3_bigint_ord)
max(public.eql_v3_bigint_ord_ope)
max(public.eql_v3_bigint_ord_ore)
max(public.eql_v3_date_ord)
max(public.eql_v3_date_ord_ope)
max(public.eql_v3_date_ord_ore)
max(public.eql_v3_double_ord)
max(public.eql_v3_double_ord_ope)
max(public.eql_v3_double_ord_ore)
max(public.eql_v3_integer_ord)
max(public.eql_v3_integer_ord_ope)
max(public.eql_v3_integer_ord_ore)
max(public.eql_v3_json_entry)
max(public.eql_v3_numeric_ord)
max(public.eql_v3_numeric_ord_ope)
max(public.eql_v3_numeric_ord_ore)
max(public.eql_v3_real_ord)
max(public.eql_v3_real_ord_ope)
max(public.eql_v3_real_ord_ore)
max(public.eql_v3_smallint_ord)
max(public.eql_v3_smallint_ord_ope)
max(public.eql_v3_smallint_ord_ore)
max(public.eql_v3_text_ord)
max(public.eql_v3_text_ord_ope)
max(public.eql_v3_text_ord_ore)
max(public.eql_v3_text_search)
max(public.eql_v3_text_search_ore)
max(public.eql_v3_timestamp_ord)
max(public.eql_v3_timestamp_ord_ope)
max(public.eql_v3_timestamp_ord_ore)
```
| Parameter | Type | Description |
| --------- | -------------------------- | ----------- |
| `input` | `public.eql_v3_bigint_ord` | |
**Returns:** `public.eql_v3_bigint_ord` — public.eql\_v3\_bigint\_ord
meta_data [#meta_data]
Extract envelope metadata (i, v, h) from a raw jsonb encrypted value.
h is the document's key header — hoisted once to the envelope because every sv entry encrypts under the document's single data key. Grafting it here (the same concat that already grafts i/v) is what keeps an extracted public.eql\_v3\_json\_entry self-contained decryptable: decryption needs the header plus the entry's own s (the nonce source) and c (the raw AEAD output). jsonb\_strip\_nulls drops the keys entirely on payloads that lack them (e.g. a raw scalar envelope has no h), rather than grafting JSON nulls.
**Signature:**
```sql
meta_data(jsonb)
```
| Parameter | Type | Description |
| --------- | ------- | --------------------- |
| `val` | `jsonb` | encrypted EQL payload |
**Returns:** `jsonb` — jsonb Metadata object with i, v, and (for documents) h.
min [#min]
min aggregate for public.eql\_v3\_bigint\_ord.
**30 overloads** (one per encrypted type):
```sql
min(public.eql_v3_bigint_ord)
min(public.eql_v3_bigint_ord_ope)
min(public.eql_v3_bigint_ord_ore)
min(public.eql_v3_date_ord)
min(public.eql_v3_date_ord_ope)
min(public.eql_v3_date_ord_ore)
min(public.eql_v3_double_ord)
min(public.eql_v3_double_ord_ope)
min(public.eql_v3_double_ord_ore)
min(public.eql_v3_integer_ord)
min(public.eql_v3_integer_ord_ope)
min(public.eql_v3_integer_ord_ore)
min(public.eql_v3_json_entry)
min(public.eql_v3_numeric_ord)
min(public.eql_v3_numeric_ord_ope)
min(public.eql_v3_numeric_ord_ore)
min(public.eql_v3_real_ord)
min(public.eql_v3_real_ord_ope)
min(public.eql_v3_real_ord_ore)
min(public.eql_v3_smallint_ord)
min(public.eql_v3_smallint_ord_ope)
min(public.eql_v3_smallint_ord_ore)
min(public.eql_v3_text_ord)
min(public.eql_v3_text_ord_ope)
min(public.eql_v3_text_ord_ore)
min(public.eql_v3_text_search)
min(public.eql_v3_text_search_ore)
min(public.eql_v3_timestamp_ord)
min(public.eql_v3_timestamp_ord_ope)
min(public.eql_v3_timestamp_ord_ore)
```
| Parameter | Type | Description |
| --------- | -------------------------- | ----------- |
| `input` | `public.eql_v3_bigint_ord` | |
**Returns:** `public.eql_v3_bigint_ord` — public.eql\_v3\_bigint\_ord
neq [#neq]
Operator wrapper for public.eql\_v3\_bigint\_eq.
**190 overloads** (one per encrypted type):
```sql
neq(eql_v3_bigint_eq, eql_v3_bigint_eq)
neq(eql_v3_bigint_eq, jsonb)
neq(eql_v3_bigint_eq, query_bigint_eq)
neq(eql_v3_bigint_ord, eql_v3_bigint_ord)
neq(eql_v3_bigint_ord, jsonb)
neq(eql_v3_bigint_ord, query_bigint_ord)
neq(eql_v3_bigint_ord_ope, eql_v3_bigint_ord_ope)
neq(eql_v3_bigint_ord_ope, jsonb)
neq(eql_v3_bigint_ord_ope, query_bigint_ord_ope)
neq(eql_v3_bigint_ord_ore, eql_v3_bigint_ord_ore)
neq(eql_v3_bigint_ord_ore, jsonb)
neq(eql_v3_bigint_ord_ore, query_bigint_ord_ore)
neq(eql_v3_date_eq, eql_v3_date_eq)
neq(eql_v3_date_eq, jsonb)
neq(eql_v3_date_eq, query_date_eq)
neq(eql_v3_date_ord, eql_v3_date_ord)
neq(eql_v3_date_ord, jsonb)
neq(eql_v3_date_ord, query_date_ord)
neq(eql_v3_date_ord_ope, eql_v3_date_ord_ope)
neq(eql_v3_date_ord_ope, jsonb)
neq(eql_v3_date_ord_ope, query_date_ord_ope)
neq(eql_v3_date_ord_ore, eql_v3_date_ord_ore)
neq(eql_v3_date_ord_ore, jsonb)
neq(eql_v3_date_ord_ore, query_date_ord_ore)
neq(eql_v3_double_eq, eql_v3_double_eq)
neq(eql_v3_double_eq, jsonb)
neq(eql_v3_double_eq, query_double_eq)
neq(eql_v3_double_ord, eql_v3_double_ord)
neq(eql_v3_double_ord, jsonb)
neq(eql_v3_double_ord, query_double_ord)
neq(eql_v3_double_ord_ope, eql_v3_double_ord_ope)
neq(eql_v3_double_ord_ope, jsonb)
neq(eql_v3_double_ord_ope, query_double_ord_ope)
neq(eql_v3_double_ord_ore, eql_v3_double_ord_ore)
neq(eql_v3_double_ord_ore, jsonb)
neq(eql_v3_double_ord_ore, query_double_ord_ore)
neq(eql_v3_integer_eq, eql_v3_integer_eq)
neq(eql_v3_integer_eq, jsonb)
neq(eql_v3_integer_eq, query_integer_eq)
neq(eql_v3_integer_ord, eql_v3_integer_ord)
neq(eql_v3_integer_ord, jsonb)
neq(eql_v3_integer_ord, query_integer_ord)
neq(eql_v3_integer_ord_ope, eql_v3_integer_ord_ope)
neq(eql_v3_integer_ord_ope, jsonb)
neq(eql_v3_integer_ord_ope, query_integer_ord_ope)
neq(eql_v3_integer_ord_ore, eql_v3_integer_ord_ore)
neq(eql_v3_integer_ord_ore, jsonb)
neq(eql_v3_integer_ord_ore, query_integer_ord_ore)
neq(eql_v3_numeric_eq, eql_v3_numeric_eq)
neq(eql_v3_numeric_eq, jsonb)
neq(eql_v3_numeric_eq, query_numeric_eq)
neq(eql_v3_numeric_ord, eql_v3_numeric_ord)
neq(eql_v3_numeric_ord, jsonb)
neq(eql_v3_numeric_ord, query_numeric_ord)
neq(eql_v3_numeric_ord_ope, eql_v3_numeric_ord_ope)
neq(eql_v3_numeric_ord_ope, jsonb)
neq(eql_v3_numeric_ord_ope, query_numeric_ord_ope)
neq(eql_v3_numeric_ord_ore, eql_v3_numeric_ord_ore)
neq(eql_v3_numeric_ord_ore, jsonb)
neq(eql_v3_numeric_ord_ore, query_numeric_ord_ore)
neq(eql_v3_real_eq, eql_v3_real_eq)
neq(eql_v3_real_eq, jsonb)
neq(eql_v3_real_eq, query_real_eq)
neq(eql_v3_real_ord, eql_v3_real_ord)
neq(eql_v3_real_ord, jsonb)
neq(eql_v3_real_ord, query_real_ord)
neq(eql_v3_real_ord_ope, eql_v3_real_ord_ope)
neq(eql_v3_real_ord_ope, jsonb)
neq(eql_v3_real_ord_ope, query_real_ord_ope)
neq(eql_v3_real_ord_ore, eql_v3_real_ord_ore)
neq(eql_v3_real_ord_ore, jsonb)
neq(eql_v3_real_ord_ore, query_real_ord_ore)
neq(eql_v3_smallint_eq, eql_v3_smallint_eq)
neq(eql_v3_smallint_eq, jsonb)
neq(eql_v3_smallint_eq, query_smallint_eq)
neq(eql_v3_smallint_ord, eql_v3_smallint_ord)
neq(eql_v3_smallint_ord, jsonb)
neq(eql_v3_smallint_ord, query_smallint_ord)
neq(eql_v3_smallint_ord_ope, eql_v3_smallint_ord_ope)
neq(eql_v3_smallint_ord_ope, jsonb)
neq(eql_v3_smallint_ord_ope, query_smallint_ord_ope)
neq(eql_v3_smallint_ord_ore, eql_v3_smallint_ord_ore)
neq(eql_v3_smallint_ord_ore, jsonb)
neq(eql_v3_smallint_ord_ore, query_smallint_ord_ore)
neq(eql_v3_text_eq, eql_v3_text_eq)
neq(eql_v3_text_eq, jsonb)
neq(eql_v3_text_eq, query_text_eq)
neq(eql_v3_text_ord, eql_v3_text_ord)
neq(eql_v3_text_ord, jsonb)
neq(eql_v3_text_ord, query_text_ord)
neq(eql_v3_text_ord_ope, eql_v3_text_ord_ope)
neq(eql_v3_text_ord_ope, jsonb)
neq(eql_v3_text_ord_ope, query_text_ord_ope)
neq(eql_v3_text_ord_ore, eql_v3_text_ord_ore)
neq(eql_v3_text_ord_ore, jsonb)
neq(eql_v3_text_ord_ore, query_text_ord_ore)
neq(eql_v3_text_search, eql_v3_text_search)
neq(eql_v3_text_search, jsonb)
neq(eql_v3_text_search, query_text_search)
neq(eql_v3_text_search_ore, eql_v3_text_search_ore)
neq(eql_v3_text_search_ore, jsonb)
neq(eql_v3_text_search_ore, query_text_search_ore)
neq(eql_v3_timestamp_eq, eql_v3_timestamp_eq)
neq(eql_v3_timestamp_eq, jsonb)
neq(eql_v3_timestamp_eq, query_timestamp_eq)
neq(eql_v3_timestamp_ord, eql_v3_timestamp_ord)
neq(eql_v3_timestamp_ord, jsonb)
neq(eql_v3_timestamp_ord, query_timestamp_ord)
neq(eql_v3_timestamp_ord_ope, eql_v3_timestamp_ord_ope)
neq(eql_v3_timestamp_ord_ope, jsonb)
neq(eql_v3_timestamp_ord_ope, query_timestamp_ord_ope)
neq(eql_v3_timestamp_ord_ore, eql_v3_timestamp_ord_ore)
neq(eql_v3_timestamp_ord_ore, jsonb)
neq(eql_v3_timestamp_ord_ore, query_timestamp_ord_ore)
neq(jsonb, eql_v3_bigint_eq)
neq(jsonb, eql_v3_bigint_ord)
neq(jsonb, eql_v3_bigint_ord_ope)
neq(jsonb, eql_v3_bigint_ord_ore)
neq(jsonb, eql_v3_date_eq)
neq(jsonb, eql_v3_date_ord)
neq(jsonb, eql_v3_date_ord_ope)
neq(jsonb, eql_v3_date_ord_ore)
neq(jsonb, eql_v3_double_eq)
neq(jsonb, eql_v3_double_ord)
neq(jsonb, eql_v3_double_ord_ope)
neq(jsonb, eql_v3_double_ord_ore)
neq(jsonb, eql_v3_integer_eq)
neq(jsonb, eql_v3_integer_ord)
neq(jsonb, eql_v3_integer_ord_ope)
neq(jsonb, eql_v3_integer_ord_ore)
neq(jsonb, eql_v3_numeric_eq)
neq(jsonb, eql_v3_numeric_ord)
neq(jsonb, eql_v3_numeric_ord_ope)
neq(jsonb, eql_v3_numeric_ord_ore)
neq(jsonb, eql_v3_real_eq)
neq(jsonb, eql_v3_real_ord)
neq(jsonb, eql_v3_real_ord_ope)
neq(jsonb, eql_v3_real_ord_ore)
neq(jsonb, eql_v3_smallint_eq)
neq(jsonb, eql_v3_smallint_ord)
neq(jsonb, eql_v3_smallint_ord_ope)
neq(jsonb, eql_v3_smallint_ord_ore)
neq(jsonb, eql_v3_text_eq)
neq(jsonb, eql_v3_text_ord)
neq(jsonb, eql_v3_text_ord_ope)
neq(jsonb, eql_v3_text_ord_ore)
neq(jsonb, eql_v3_text_search)
neq(jsonb, eql_v3_text_search_ore)
neq(jsonb, eql_v3_timestamp_eq)
neq(jsonb, eql_v3_timestamp_ord)
neq(jsonb, eql_v3_timestamp_ord_ope)
neq(jsonb, eql_v3_timestamp_ord_ore)
neq(query_bigint_eq, eql_v3_bigint_eq)
neq(query_bigint_ord, eql_v3_bigint_ord)
neq(query_bigint_ord_ope, eql_v3_bigint_ord_ope)
neq(query_bigint_ord_ore, eql_v3_bigint_ord_ore)
neq(query_date_eq, eql_v3_date_eq)
neq(query_date_ord, eql_v3_date_ord)
neq(query_date_ord_ope, eql_v3_date_ord_ope)
neq(query_date_ord_ore, eql_v3_date_ord_ore)
neq(query_double_eq, eql_v3_double_eq)
neq(query_double_ord, eql_v3_double_ord)
neq(query_double_ord_ope, eql_v3_double_ord_ope)
neq(query_double_ord_ore, eql_v3_double_ord_ore)
neq(query_integer_eq, eql_v3_integer_eq)
neq(query_integer_ord, eql_v3_integer_ord)
neq(query_integer_ord_ope, eql_v3_integer_ord_ope)
neq(query_integer_ord_ore, eql_v3_integer_ord_ore)
neq(query_numeric_eq, eql_v3_numeric_eq)
neq(query_numeric_ord, eql_v3_numeric_ord)
neq(query_numeric_ord_ope, eql_v3_numeric_ord_ope)
neq(query_numeric_ord_ore, eql_v3_numeric_ord_ore)
neq(query_real_eq, eql_v3_real_eq)
neq(query_real_ord, eql_v3_real_ord)
neq(query_real_ord_ope, eql_v3_real_ord_ope)
neq(query_real_ord_ore, eql_v3_real_ord_ore)
neq(query_smallint_eq, eql_v3_smallint_eq)
neq(query_smallint_ord, eql_v3_smallint_ord)
neq(query_smallint_ord_ope, eql_v3_smallint_ord_ope)
neq(query_smallint_ord_ore, eql_v3_smallint_ord_ore)
neq(query_text_eq, eql_v3_text_eq)
neq(query_text_ord, eql_v3_text_ord)
neq(query_text_ord_ope, eql_v3_text_ord_ope)
neq(query_text_ord_ore, eql_v3_text_ord_ore)
neq(query_text_search, eql_v3_text_search)
neq(query_text_search_ore, eql_v3_text_search_ore)
neq(query_timestamp_eq, eql_v3_timestamp_eq)
neq(query_timestamp_ord, eql_v3_timestamp_ord)
neq(query_timestamp_ord_ope, eql_v3_timestamp_ord_ope)
neq(query_timestamp_ord_ore, eql_v3_timestamp_ord_ore)
```
| Parameter | Type | Description |
| ----------- | ------------------ | ----------- |
| `a public.` | `eql_v3_bigint_eq` | |
| `b public.` | `eql_v3_bigint_eq` | |
**Returns:** `boolean` — boolean
ope_term [#ope_term]
Low-level deterministic OPE byte extractor for a json entry.
Returns the bytea of the entry's deterministic op (CLLW OPE) term, or NULL for a term-less entry (a value entry, or a bool/null/structural path entry — which carry no term because exact matching there is selector presence, not a per-entry term). Entry-to-entry = / \<> are blocked: these bytes are an ordering encoding, not an exact equality representation.
op is deterministic (equal plaintext at a fixed selector ⇒ equal bytes), so byte equality on it is a sound equality for number/string leaves — with the same encoding caveat as the scalar \_ord surface (f64 rounding, string collation make it lossy for bigint/numeric/text). Exact, loss-free equality on a JSON field is selector presence (containment / the value selector), not this term. This extractor remains available only for callers that deliberately need encoded OPE-equivalence buckets. hm is retired — entries no longer carry it.
**Signature:**
```sql
ope_term(eql_v3_json_entry)
```
| Parameter | Type | Description |
| --------------- | ------------------- | ----------- |
| `entry public.` | `eql_v3_json_entry` | |
**Returns:** `bytea` — bytea Decoded op bytes (NULL if the entry has no op, or is NULL).
ord_term [#ord_term]
Index extractor for public.eql\_v3\_bigint\_ord.
**39 overloads** (one per encrypted type):
```sql
ord_term(eql_v3_bigint_ord)
ord_term(eql_v3_bigint_ord_ope)
ord_term(eql_v3_date_ord)
ord_term(eql_v3_date_ord_ope)
ord_term(eql_v3_double_ord)
ord_term(eql_v3_double_ord_ope)
ord_term(eql_v3_integer_ord)
ord_term(eql_v3_integer_ord_ope)
ord_term(eql_v3_json_entry)
ord_term(eql_v3_numeric_ord)
ord_term(eql_v3_numeric_ord_ope)
ord_term(eql_v3_real_ord)
ord_term(eql_v3_real_ord_ope)
ord_term(eql_v3_smallint_ord)
ord_term(eql_v3_smallint_ord_ope)
ord_term(eql_v3_text_ord)
ord_term(eql_v3_text_ord_ope)
ord_term(eql_v3_text_search)
ord_term(eql_v3_timestamp_ord)
ord_term(eql_v3_timestamp_ord_ope)
ord_term(query_bigint_ord)
ord_term(query_bigint_ord_ope)
ord_term(query_date_ord)
ord_term(query_date_ord_ope)
ord_term(query_double_ord)
ord_term(query_double_ord_ope)
ord_term(query_integer_ord)
ord_term(query_integer_ord_ope)
ord_term(query_numeric_ord)
ord_term(query_numeric_ord_ope)
ord_term(query_real_ord)
ord_term(query_real_ord_ope)
ord_term(query_smallint_ord)
ord_term(query_smallint_ord_ope)
ord_term(query_text_ord)
ord_term(query_text_ord_ope)
ord_term(query_text_search)
ord_term(query_timestamp_ord)
ord_term(query_timestamp_ord_ope)
```
| Parameter | Type | Description |
| ----------- | ------------------- | ----------- |
| `a public.` | `eql_v3_bigint_ord` | |
**Returns:** `eql_v3_internal.ope_cllw` — eql\_v3\_internal.ope\_cllw
ord_term_ore [#ord_term_ore]
Index extractor for public.eql\_v3\_bigint\_ord\_ore.
**20 overloads** (one per encrypted type):
```sql
ord_term_ore(eql_v3_bigint_ord_ore)
ord_term_ore(eql_v3_date_ord_ore)
ord_term_ore(eql_v3_double_ord_ore)
ord_term_ore(eql_v3_integer_ord_ore)
ord_term_ore(eql_v3_numeric_ord_ore)
ord_term_ore(eql_v3_real_ord_ore)
ord_term_ore(eql_v3_smallint_ord_ore)
ord_term_ore(eql_v3_text_ord_ore)
ord_term_ore(eql_v3_text_search_ore)
ord_term_ore(eql_v3_timestamp_ord_ore)
ord_term_ore(query_bigint_ord_ore)
ord_term_ore(query_date_ord_ore)
ord_term_ore(query_double_ord_ore)
ord_term_ore(query_integer_ord_ore)
ord_term_ore(query_numeric_ord_ore)
ord_term_ore(query_real_ord_ore)
ord_term_ore(query_smallint_ord_ore)
ord_term_ore(query_text_ord_ore)
ord_term_ore(query_text_search_ore)
ord_term_ore(query_timestamp_ord_ore)
```
| Parameter | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a public.` | `eql_v3_bigint_ord_ore` | |
**Returns:** `eql_v3_internal.ore_block_256` — eql\_v3\_internal.ore\_block\_256
selector [#selector]
Extract selector (s) from a ste\_vec entry.
The DOMAIN CHECK guarantees is present, so this is a simple field access.
**2 overloads** (one per encrypted type):
```sql
selector(eql_v3_json_entry)
selector(jsonb)
```
| Parameter | Type | Description |
| --------------- | ------------------- | ----------- |
| `entry public.` | `eql_v3_json_entry` | |
**Returns:** `text` — text The selector value.
ste_vec [#ste_vec]
Extract the sv element array as raw jsonb\[].
Returns the elements of sv (or a single-element array wrapping the value when there is no sv). No envelope re-wrapping — raw jsonb elements.
**Signature:**
```sql
ste_vec(jsonb)
```
| Parameter | Type | Description |
| --------- | ------- | --------------------- |
| `val` | `jsonb` | encrypted EQL payload |
**Returns:** `jsonb[]` — jsonb\[] Array of sv elements.
ste_vec_contains [#ste_vec_contains]
Does encrypted value a contain all sv elements of b?
Empty b is always contained. Each element of b must have its selector present in some element of a (selector-subset containment).
**2 overloads** (one per encrypted type):
```sql
ste_vec_contains(eql_v3_json_search, eql_v3_json_search)
ste_vec_contains(jsonb, jsonb)
```
| Parameter | Type | Description |
| ----------- | -------------------- | ----------- |
| `a public.` | `eql_v3_json_search` | |
| `b public.` | `eql_v3_json_search` | |
**Returns:** `boolean` — boolean True if all elements of b are contained in a.
to_ste_vec_query [#to_ste_vec_query]
Convert a public.eql\_v3\_json\_search to a query\_json needle.
Normalises each sv element down to its selector s. Exact and structural containment are both selector-set containment; an op carried by a legacy or document-derived needle is accepted at the boundary for compatibility but is not part of the containment predicate. Other fields are stripped. This is the canonical needle shape for @> containment and the functional GIN index expression: GIN (eql\_v3.to\_ste\_vec\_query(col)::jsonb jsonb\_path\_ops).
**2 overloads** (one per encrypted type):
```sql
to_ste_vec_query(eql_v3_json_search)
to_ste_vec_query(query_json)
```
| Parameter | Type | Description |
| ----------- | -------------------- | ----------- |
| `e public.` | `eql_v3_json_search` | |
**Returns:** `eql_v3.query_json` — eql\_v3.query\_json Query-shaped needle, sv elements normalised.
version [#version]
Get the installed EQL version string.
Returns the version string for the installed EQL library. This value is baked in at build time from the release tag.
**Signature:**
```sql
version()
```
**Returns:** `text` — text Version string (e.g. "3.0.0" or "DEV" for development builds)
# Grouping & aggregates
Source: https://cipherstash.com/docs/reference/eql/grouping-and-aggregates
Grouping and deduplication key on the **equality term**, never on the stored ciphertext, so they work on the same variants as `=`: `_eq`, every `_ord` variant, and the `text_search` variants. `MIN` / `MAX` need an ordering term (any `_ord` variant, or `text_search`). Arithmetic aggregates don't work at all — that's the last section. As everywhere, operands and call-site casts must be typed; see [Core concepts](https://cipherstash.com/docs/reference/eql/core-concepts).
GROUP BY and DISTINCT [#group-by-and-distinct]
Encryption is non-deterministic: the same plaintext encrypts to a different ciphertext every time. An encrypted column is a domain over `jsonb`, and Postgres compares a domain using the *base type's* comparison — so the natural forms compare whole encrypted payloads, never the plaintext behind them. They raise no error; they just answer wrongly.
```sql
SELECT email, COUNT(*) FROM logins GROUP BY email; -- one group per row
SELECT DISTINCT email FROM logins; -- every row comes back
```
Key on the equality term instead. It's a deterministic keyed hash, identical for equal plaintexts:
```sql
SELECT COUNT(*)
FROM logins
GROUP BY eql_v3.eq_term(email);
SELECT DISTINCT ON (eql_v3.eq_term(email)) email
FROM logins
ORDER BY eql_v3.eq_term(email);
```
Plain `DISTINCT` has nowhere to put the term, so deduplication is `DISTINCT ON`. Postgres requires the leading `ORDER BY` expression to match the `DISTINCT ON` expression, and the row that survives each group is the first one in that order — add further sort keys after it to choose which.
The term is an HMAC — opaque and one-way — so there's rarely a reason to select it. `DISTINCT ON` puts no restriction on the projection, so the encrypted column comes back alongside it for the client to decrypt; under `GROUP BY` that takes [`eql_v3.grouped_value`](#grouped-value).
Keying on the extractor is also what makes the query fast. `GROUP BY email` would use the entire encrypted payload — 1–2 KB per row — as the hash key: Postgres estimates a hash table far larger than the default `work_mem` and falls back to a disk-spilling `GroupAggregate`. The extractor key is small, so the hash table fits in `work_mem` and the planner picks `HashAggregate` reliably. The same reasoning, from the index-tuning angle, is in [Indexes](https://cipherstash.com/docs/reference/eql/indexes).
eql_v3.grouped_value [#grouped-value]
Grouping by the term costs you the column: Postgres rejects a bare reference to it, because it can't prove the column is constant within each group.
```sql
SELECT email, COUNT(*)
FROM logins
GROUP BY eql_v3.eq_term(email);
```
Every row in a group encrypts the same plaintext, so any one of them represents the group. `eql_v3.grouped_value` is the aggregate that hands one back:
```sql
SELECT eql_v3.grouped_value(email) AS email, COUNT(*)
FROM logins
GROUP BY eql_v3.eq_term(email);
```
What comes back is a real encrypted payload, which the client decrypts as usual — unlike the group key itself, which is a term and can never be decrypted.
```sql
eql_v3.grouped_value(jsonb) RETURNS jsonb
```
One aggregate covers every encrypted type: all the domains are jsonb-backed, and `grouped_value` returns its input unchanged — it never decrypts, inspects, or compares the value. Three details worth knowing:
* It returns the **first non-`NULL`** value in each group. Which value is "first" is arbitrary without an intra-aggregate `ORDER BY`, and not deterministic under parallel aggregation — that's fine here, because every member of the group is an encryption of the same plaintext.
* A group of all-`NULL` values aggregates to `NULL`, matching native aggregate semantics.
* It's `PARALLEL SAFE` with a combine function, so it survives partial aggregation on large `GROUP BY` workloads.
Deduplicating without a per-group aggregate needs none of this — that's `DISTINCT ON`, above.
COUNT and COUNT(DISTINCT) [#count-and-countdistinct]
Plain `COUNT(col)` counts non-`NULL` rows — it never compares values, so it works on **any** variant, including storage-only ones:
```sql
SELECT COUNT(tax_id) FROM users; -- works even on bare public.eql_v3_text
```
`COUNT(DISTINCT col)` deduplicates, so it has the ciphertext problem too: on the raw column it counts distinct ciphertexts, which is just the row count. Count distinct terms instead:
```sql
SELECT COUNT(DISTINCT eql_v3.eq_term(email)) FROM logins;
```
MIN and MAX: eql_v3.min / eql_v3.max [#min-and-max-eql_v3min--eql_v3max]
EQL ships `min` / `max` aggregates per ord-capable variant of every scalar type. The input type selects the aggregate, and the return type matches the input:
```sql
eql_v3.min(public.eql_v3__ord) RETURNS public.eql_v3__ord
eql_v3.max(public.eql_v3__ord) RETURNS public.eql_v3__ord
eql_v3.min(public.eql_v3__ord_ope) RETURNS public.eql_v3__ord_ope
eql_v3.max(public.eql_v3__ord_ope) RETURNS public.eql_v3__ord_ope
eql_v3.min(public.eql_v3__ord_ore) RETURNS public.eql_v3__ord_ore
eql_v3.max(public.eql_v3__ord_ore) RETURNS public.eql_v3__ord_ore
```
Comparison routes through the variant's `<` / `>` operator on the ordering term — no decryption happens in the database, and the result is an encrypted value the client decrypts. `NULL` inputs are skipped; an all-`NULL` input set returns `NULL`, matching native aggregate semantics.
```sql
SELECT eql_v3.min(salary) FROM users;
SELECT eql_v3.max(salary) FROM users WHERE department = 'engineering';
-- Combined with grouping: grouped_value returns the department code encrypted,
-- so the client can decrypt it to label the row.
SELECT eql_v3.grouped_value(department_code) AS department_code,
eql_v3.max(salary)
FROM users
GROUP BY eql_v3.eq_term(department_code);
```
If the column is generic `jsonb` rather than a domain, cast to the right variant at the call site so overload resolution can pick the aggregate:
```sql
SELECT eql_v3.min(salary_jsonb::public.eql_v3_bigint_ord) FROM users;
```
A btree on `eql_v3.ord_term(col)` serves `MIN` / `MAX` — the [Indexes](https://cipherstash.com/docs/reference/eql/indexes) page has the recipe.
No SUM, no AVG [#no-sum-no-avg]
**`SUM`, `AVG`, and every other arithmetic aggregate are unsupported** on encrypted columns — they would require homomorphic encryption, which EQL does not do. `MIN` / `MAX` work because they only need *comparison*, which the ordering term provides. For sums and averages, select the rows (or `MIN`/`MAX`/`COUNT` server-side to narrow them) and aggregate client-side after decryption.
Leaves inside encrypted JSON [#leaves-inside-encrypted-json]
Leaves extracted from an encrypted JSON document (`metadata -> 'region_selector'::text`, a `public.eql_v3_json_entry`) **cannot be grouped by equality**. Entries stopped carrying an equality term in EQL 3.0.1: exact matching on a JSON field became presence of a value selector, which containment answers as a filter — there is no per-field key to hash rows into groups with.
What still works on an extracted leaf is ordering: `eql_v3.min` / `eql_v3.max` on String and Number leaves, via their CLLW OPE term.
```sql
SELECT eql_v3.min(metadata -> 'total_selector'::text) FROM orders;
```
To group by a field, promote it to its own encrypted column — a `text_eq` (or any `_ord`) column alongside the document — and group on that column's equality term as above. Selectors, value selectors, and node capabilities are in [JSON](https://cipherstash.com/docs/reference/eql/json).
Where to go next [#where-to-go-next]
* [Indexes](https://cipherstash.com/docs/reference/eql/indexes) — the hash/btree recipes that back these shapes, and the full `work_mem` / `HashAggregate` story.
* [Joins](https://cipherstash.com/docs/reference/eql/joins) — equality terms across tables, and the same-keyset rule.
* [Filtering](https://cipherstash.com/docs/reference/eql/filtering) — the `WHERE` shapes that feed these aggregates.
# EQL
Source: https://cipherstash.com/docs/reference/eql
Encrypt Query Language (EQL) is a set of types, operators, and functions for storing and querying encrypted data in PostgreSQL. The [Stash CLI](https://cipherstash.com/docs/reference/cli) installs it over an ordinary database connection — no extension packaging, no superuser, no operator classes — so it runs on Supabase, RDS, Cloud SQL, and self-hosted Postgres alike.
EQL itself never encrypts anything. Encryption and decryption happen in the client, using the [Stack SDK](https://cipherstash.com/docs/reference/stack) or [CipherStash Proxy](https://cipherstash.com/docs/reference/proxy). EQL provides the database-side surface those clients query against: encrypted column types, the operators that compare them, and the term-extractor functions that make indexes work.
Every encrypted column is a `jsonb`-backed domain type in the `public` schema (the functions and operators behind them live in `eql_v3`), and the domain variant you choose declares what the column can do — the full model is in [Core concepts](https://cipherstash.com/docs/reference/eql/core-concepts).
Install [#install]
Run the installer [#run-the-installer]
Point the [Stash CLI](https://cipherstash.com/docs/reference/cli) at your database and install the `eql_v3` schema:
```bash
npx stash eql install
```
`stash eql install` scaffolds a [`stash.config.ts`](#eql-install-configuration) if your project doesn't have one, then installs the `eql_v3` schema — all domain types, operators, functions, and aggregates — along with the `cs_migrations` tracking schema that the `stash encrypt` commands depend on. It is idempotent: re-running reports that EQL is already installed and changes nothing. Pass `--force` to reinstall in place.
EQL v3 is the only installation target in `stash` 1.0.0, so no version flag is required. The [EQL v2 reference](https://cipherstash.com/docs/reference/eql/v2) remains available for applications maintaining an existing v2 deployment.
Point the EQL installer at each database [#point-the-eql-installer-at-each-database]
The CLI reads the connection string from `DATABASE_URL` (your environment or a `.env` file) and prompts if it can't find one. Override it for a single run — handy when installing across several databases — with `--database-url`, which is used for that run only and never written to disk:
```bash
npx stash eql install \
--database-url postgres://user:pass@host:5432/mydb
```
Run the installer against every database that stores encrypted columns.
Verify [#verify]
```bash
npx stash eql status
```
Or check directly from SQL:
```sql
SELECT eql_v3.version();
-- '3.0.4'
```
To pull in a newer EQL release later, run `npx stash eql upgrade`.
To uninstall, drop both EQL schemas: `DROP SCHEMA eql_v3, eql_v3_internal CASCADE`. This removes the encrypted operators and functions, so queries against encrypted columns stop resolving — but your data survives: the `public.*` domain types (and the columns typed as them) live in the `public` schema and are left untouched. Remove those separately only if you intend to drop or re-type the columns.
EQL install configuration [#eql-install-configuration]
`stash eql install` reads a `stash.config.ts` at your project root, scaffolding one on first run if it's missing. The same file is used by the `stash db` and `stash encrypt` commands. It exports a `defineConfig` object with two fields:
| Field | Required | Description |
| ------------- | -------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `databaseUrl` | Yes | PostgreSQL connection string. The scaffold sets it to `await resolveDatabaseUrl()`, which resolves from the `--database-url` flag, then `DATABASE_URL` (environment or `.env`), then `supabase status`, then an interactive prompt. The resolved connection string is never written to disk — only the declarative call is. |
| `client` | No | Path to your encryption client file. Defaults to `./src/encryption/index.ts`. |
```ts filename="stash.config.ts"
import { defineConfig, resolveDatabaseUrl } from "stash";
export default defineConfig({
databaseUrl: await resolveDatabaseUrl(),
client: "./src/encryption/index.ts",
});
```
Drizzle migration history [#drizzle-migration-history]
For a Drizzle project, generate a custom migration instead of installing EQL directly:
```bash
npx stash eql migration --drizzle
npx drizzle-kit migrate
```
The command runs your project-local `drizzle-kit`, creates a custom migration, and writes the same EQL v3 SQL that `stash eql install` applies directly. Add `--supabase` when the database is also reached through Supabase PostgREST, and use `--out` when your Drizzle migration directory is not `drizzle/`.
If `drizzle-kit generate` has already emitted an in-place `ALTER COLUMN ... SET DATA TYPE` for an encrypted domain, repair the unapplied migration before running it:
```bash
npx stash eql repair --drizzle --database-url "$DATABASE_URL"
```
See the [`eql migration`](https://cipherstash.com/docs/reference/cli/eql#eql-migration) and [`eql repair`](https://cipherstash.com/docs/reference/cli/eql#eql-repair) references for all options. Prisma ORM 8 installs EQL through its own migration graph and does not use either command.
dbdev [#dbdev]
EQL is also published to [dbdev](https://database.dev/cipherstash/eql). The dbdev release can lag behind GitHub releases, so prefer `stash eql install` when you need the latest version.
Docker for local development [#docker-for-local-development]
Run a Postgres image with EQL pre-installed:
```sh
docker run --rm -p 5432:5432 -e POSTGRES_PASSWORD=postgres \
ghcr.io/cipherstash/postgres-eql:17
```
EQL installs automatically on first boot. Images are available for PostgreSQL 14–17 (`:14` through `:17`), and you can pin a specific EQL version with a suffixed tag (for example `:17-3.0.4`).
Permissions [#permissions]
Installing EQL and running queries against it need different privileges. A common production pattern splits them across two users.
**Migration user** — installs EQL and adds encrypted columns during migrations:
```sql
GRANT CREATE ON DATABASE your_database TO your_migration_user;
GRANT CREATE ON SCHEMA public TO your_migration_user;
GRANT ALTER ON ALL TABLES IN SCHEMA public TO your_migration_user;
```
`CREATE ON DATABASE` lets EQL create its schemas (`eql_v3`, `eql_v3_internal`) and the `public.*` domain types; `CREATE ON SCHEMA` and `ALTER` are needed to add encrypted columns (typed as `public.*` domains, with their `CHECK` constraints) to your tables.
**Runtime user** — the application's day-to-day access:
```sql
-- EQL schema usage (resolves the encrypted operators / extractors)
GRANT USAGE ON SCHEMA eql_v3 TO your_app_user;
GRANT EXECUTE ON ALL FUNCTIONS IN SCHEMA eql_v3 TO your_app_user;
-- User table access (normal application permissions)
GRANT SELECT, INSERT, UPDATE, DELETE ON TABLE your_tables TO your_app_user;
```
Schema changes — adding or removing encrypted columns — always go through the migration user.
Managed Postgres and Supabase [#managed-postgres-and-supabase]
EQL v3 is designed to install without superuser. There are no custom operator classes (which managed platforms typically block), no `postgresql.conf` changes, and no separate Supabase build — the same schema installs everywhere. When the connected role lacks superuser, `stash eql install` detects it and automatically falls back to the no-operator-family install variant, so it works on Supabase, Neon, and RDS without extra flags. Indexing works through ordinary functional indexes over EQL's term-extractor functions, which any user who can `CREATE INDEX` can build. See the [Supabase integration](https://cipherstash.com/docs/integrations/supabase) for platform-specific setup.
Understand [#understand]
Domain variants, the encrypted payload, typed operands, and fail-loud blockers — the model every other page assumes.
Encrypted integers, floats, and numerics.
Encrypted dates and timestamps: time windows, newest-first, retention cutoffs.
Encrypted text: equality, ordering, and free-text token matching — and why there is no `LIKE`.
Encrypted JSON documents: containment, field access, and GIN indexing.
Storage-only by design: why encrypted booleans carry no index terms.
Functional-index recipes over the term extractors, and what it takes for an index to engage.
Use [#use]
`WHERE` clauses on encrypted columns: equality, ranges, and text containment.
`ORDER BY` on encrypted columns, and how to keep the sort in the index.
`GROUP BY` on the equality term, `DISTINCT ON`, `COUNT`, and the `MIN` / `MAX` aggregates.
Equijoins on encrypted columns and the same-keyset rule.
# Indexes
Source: https://cipherstash.com/docs/reference/eql/indexes
EQL indexes are ordinary PostgreSQL functional indexes over **term-extractor functions** — never an index or operator class on the column itself. Each extractor returns a small per-row index term whose return type already carries a default operator class:
| Extractor | Index method | Term | Capability |
| -------------------------- | ------------------- | ------------------- | ---------------------------------------------------------- |
| `eql_v3.eq_term(col)` | `hash` (or `btree`) | `hm` (HMAC-256) | equality |
| `eql_v3.ord_term(col)` | `btree` | `op` (CLLW OPE) | range, `ORDER BY`, `MIN` / `MAX` |
| `eql_v3.ord_term_ore(col)` | `btree` | `ob` (ORE block) | the same, on pinned `_ord_ore` / `text_search_ore` columns |
| `eql_v3.match_term(col)` | `gin` | `bf` (bloom filter) | text fuzzy match (`@@`) |
The extractors are inlinable SQL functions, so the planner rewrites a bare-form predicate into the same expression the index was built on. You don't rewrite queries to use the index:
```sql
SELECT * FROM users WHERE email = $1::public.eql_v3_text_eq;
-- planner inlines `=` to: eql_v3.eq_term(email) = eql_v3.eq_term($1)
-- Index Cond on USING hash (eql_v3.eq_term(email))
```
EQL v3 deliberately ships no operator class for encrypted columns. Operators resolve against the domain's `jsonb` base type, so an opclass on the column would bypass the encrypted surface. Always index through the extractor.
Index recipes [#index-recipes]
Type the column as the domain variant that carries the term (see [Core concepts](https://cipherstash.com/docs/reference/eql/core-concepts) for the variant model, and the per-type pages for specifics), then index the matching extractor:
```sql
-- Equality: hash index on eq_term
-- (columns typed public.eql_v3__eq, any text variant, or text_search; equality on
-- the non-text _ord columns compares ordering terms, so the btree below serves it)
CREATE INDEX users_email_eq
ON users USING hash (eql_v3.eq_term(email));
-- Range / ordering: btree index on ord_term
-- (columns typed public.eql_v3__ord, _ord_ope, or text_search)
CREATE INDEX users_created_at_ord
ON users USING btree (eql_v3.ord_term(created_at));
-- Range / ordering on a pinned block-ORE column: btree on ord_term_ore
-- (columns typed public.eql_v3__ord_ore or text_search_ore)
CREATE INDEX users_created_at_ord_ore
ON users USING btree (eql_v3.ord_term_ore(created_at_ore));
-- Text fuzzy match (`@@`): GIN index on match_term
-- (columns typed public.eql_v3_text_match or text_search)
CREATE INDEX users_name_match
ON users USING gin (eql_v3.match_term(name));
ANALYZE users;
```
Run `ANALYZE` after every index build. `CREATE INDEX` on an expression gathers no statistics for that expression — without `ANALYZE`, the planner has no histogram for `eql_v3.eq_term(email)` and can misjudge the index it just built.
Create indexes when the table has a significant number of rows (typically more than 1,000) and you query the column with the matching operator. Drop indexes for capabilities you no longer query — duplicate indexes compete for cache and slow writes.
Requirements for an index to engage [#requirements-for-an-index-to-engage]
All three must hold:
1. **The value carries the required term.** Range needs `op` (or `ob` on the pinned block-ORE variants), fuzzy match needs `bf`, and equality needs `hm`, except on the non-text `_ord` variants, where equality resolves against the ordering term instead. Which terms travel in a value's payload is decided by the encryption client — a value with only a bloom term will not drive an equality index.
2. **The index was built after the data carried the term.** If you change which terms a column's values carry, recreate the index.
3. **The query operand is typed.** A typed parameter (`$1`, which CipherStash Proxy supplies) or an explicit cast resolves the encrypted operator; a bare `jsonb` literal falls through to native `jsonb` semantics and skips the index entirely:
```sql
-- ✓ resolves the encrypted operator → uses the index
WHERE email = $1::public.eql_v3_text_eq;
WHERE email = $1; -- only when the client (Stack SDK / Proxy) binds $1 typed
-- ✗ falls through to native jsonb semantics
WHERE email = '{"hm":"abc"}'::jsonb;
```
Query shapes [#query-shapes]
Equality [#equality]
```sql
SELECT * FROM users WHERE email = $1::public.eql_v3_text_eq;
-- Index Scan using users_email_eq
-- Index Cond: (eql_v3.eq_term(email) = eql_v3.eq_term($1))
```
Fuzzy match [#fuzzy-match]
`col @@ $1` inlines to bloom array containment over `eql_v3.match_term(col)`, so the GIN index engages:
```sql
SELECT * FROM users WHERE name @@ $1::public.eql_v3_text_match;
-- Bitmap Index Scan on users_name_match
```
**Supply the needle as a bind parameter or a literal.** Since EQL 3.0.3 the match carries an empty-needle guard (see [Text](https://cipherstash.com/docs/reference/eql/text)), which makes `eql_v3.matches` non-`STRICT` and references the needle twice. A needle supplied as an *uncorrelated subquery* — `WHERE name @@ (SELECT …)` — therefore no longer inlines, and the query falls back to a sequential scan. The result is still correct; only the index acceleration is lost.
Range and ORDER BY [#range-and-order-by]
The `<`, `<=`, `>`, `>=` operators inline to comparisons on `eql_v3.ord_term`, so natural-form range predicates match the btree:
```sql
SELECT * FROM users WHERE created_at < $1::public.eql_v3_timestamp_ord;
```
`ORDER BY` needs care. The planner inlines operators in *predicates* but does not rewrite *sort keys*: `ORDER BY created_at` uses the index for the `WHERE` clause but still adds a `Sort` node, which scales linearly with the rows passing the filter. To stream rows out of the btree already ordered, write the sort key in extractor form:
```sql
SELECT * FROM users
WHERE created_at < $1::public.eql_v3_timestamp_ord
ORDER BY eql_v3.ord_term(created_at) DESC
LIMIT 10;
```
ORE terms are order-preserving, so this sorts identically to the natural form — it just lets the index do the ordering. At large row counts this is the difference between seconds and milliseconds.
If you `SELECT col::jsonb ... ORDER BY col`, Postgres folds the cast into the scan and uses `(col)::jsonb` as the sort key — which matches no index. Project the column raw, or write the sort key as `eql_v3.ord_term(col)`, which sidesteps this entirely.
GROUP BY and DISTINCT [#group-by-and-distinct]
Group and deduplicate on the extractor, not the raw column:
```sql
SELECT eql_v3.grouped_value(email) AS email, count(*)
FROM users
GROUP BY eql_v3.eq_term(email);
SELECT DISTINCT ON (eql_v3.eq_term(email)) email
FROM users
ORDER BY eql_v3.eq_term(email);
```
The extractor form is a correctness requirement before it's a tuning one: encryption is non-deterministic and the column is a domain over `jsonb`, so `GROUP BY email` and `SELECT DISTINCT email` compare raw ciphertext and never collapse two encryptions of the same value. It's also the faster shape — `GROUP BY email` uses the entire encrypted payload (1–2 KB per row) as the hash key, so Postgres estimates a hash table far larger than the default `work_mem` and falls back to a disk-spilling `GroupAggregate`, while the small deterministic term fits in `work_mem` and gets a `HashAggregate`. Full treatment in [Grouping and aggregates](https://cipherstash.com/docs/reference/eql/grouping-and-aggregates).
Encrypted JSON [#encrypted-json]
Containment (`@>` / `<@`) on `public.eql_v3_json_search` document columns uses a GIN index over `eql_v3.to_ste_vec_query(col)::jsonb` — the same index that serves exact field matching, which is containment on a value selector. Field-level ordering has its own extractor recipe. See [JSON](https://cipherstash.com/docs/reference/eql/json).
Verify with EXPLAIN [#verify-with-explain]
The first move on a slow query is `EXPLAIN (COSTS OFF)`:
* **`Index Scan using `** — the functional index is engaged.
* **`Index Cond:` referencing the extractor** (`eql_v3.eq_term(...)`, `eql_v3.ord_term(...)`) — the inlined predicate matched the index.
* **`Seq Scan`** — no index used. Check the three requirements above.
* **`Filter:` showing the raw operator** — inlining did not happen. Usual causes: a pinned `search_path` on a customised function, or the planner judging another plan cheaper.
* **`Sort` node above an Index Scan** — natural-form `ORDER BY`. Switch the sort key to `eql_v3.ord_term(col)` to eliminate it.
Once the plan looks right, repeat with `EXPLAIN ANALYZE` to measure actual timings. Compare estimated and actual row counts as well as the chosen scan; a large mismatch usually means the planner needs fresh statistics before the index definition itself is changed.
Building indexes on large tables [#building-indexes-on-large-tables]
Index *build* time is a separate axis from query time — a functional index that queries in a millisecond can take hours to `CREATE` on a large table.
**Raise `maintenance_work_mem`.** `CREATE INDEX` draws on `maintenance_work_mem` (default 64 MB — far too small for a multi-million-row build). It's the single highest-leverage knob:
```sql
SET maintenance_work_mem = '2GB';
CREATE INDEX users_email_eq ON users USING btree (eql_v3.eq_term(email));
```
**Prefer `btree` over `hash` for equality on large tables.** A btree build sorts then bulk-loads with sequential writes and can parallelise; a hash build scatters rows to random buckets and degrades to random I/O once the index outgrows cache — it cannot parallelise. A btree on `eql_v3.eq_term(col)` serves `=` exactly as well as a hash index, with no query-side cost. Hash is fine up to mid-six-figure row counts.
**Expect a de-TOAST floor.** A functional index over a large encrypted column de-TOASTs the whole stored value once per row to evaluate the extractor. This cost is identical across access methods and sets the build's floor rate. Index builds are also I/O-heavy in a way queries are not — containerised Postgres on a virtualised filesystem (Docker Desktop on macOS, notably) pays a steep penalty, so run large builds on native storage.
**Watch the build.** From a second session while `CREATE INDEX` runs:
```sql
SELECT phase, tuples_done, tuples_total,
round(100.0 * tuples_done / nullif(tuples_total, 0), 1) AS pct
FROM pg_stat_progress_create_index;
```
A steady `tuples_done` rate is healthy. A rate that decays over time is the cache/memory wall — raise `maintenance_work_mem`, and if it's a hash index, rebuild it as a btree.
Why this works on managed Postgres [#why-this-works-on-managed-postgres]
Everything above is a functional index over an `IMMUTABLE` SQL function — no operator class on a column, no superuser, no `postgresql.conf` changes. Managed platforms that block custom operator classes (Supabase among them) run these recipes unchanged, so the indexing model is identical on Supabase, RDS, Cloud SQL, and self-hosted Postgres. See the [Supabase integration](https://cipherstash.com/docs/integrations/supabase).
Troubleshooting indexes on encrypted columns [#troubleshooting-indexes-on-encrypted-columns]
**Index not being used:**
1. Verify the value carries the term:
```sql
SELECT email::jsonb ? 'hm' AS has_hmac,
email::jsonb ? 'ob' AS has_ore_block,
email::jsonb ? 'bf' AS has_bloom
FROM users LIMIT 1;
```
2. Verify the operand is typed (`$1::public.eql_v3_text_eq`, not `$1::jsonb`).
3. Recreate the index if the column's terms changed after it was built.
4. Run `ANALYZE`. Very small tables may still choose a sequential scan — that's correct.
**`=` returns zero rows on a populated column:** equality requires the term its variant compares — `hm` on `_eq` / `text_search`, `ob` on `_ord` variants. Type the column as an equality-capable variant and confirm the encryption client is emitting that term.
# Joins
Source: https://cipherstash.com/docs/reference/eql/joins
Equijoins work on equality-capable variants (`_eq`, every `_ord` variant, `text_search` variants) — the join condition is just encrypted equality. But there is one constraint that has no plaintext equivalent, and it is the single thing to internalize on this page:
**Both sides of the join must be encrypted with the same keyset and typed as a matching variant.** Encrypted equality compares deterministic index terms, and those terms are derived from the encryption keys. Two columns encrypted under different keysets produce different terms for the *same plaintext* — their terms can **never** match, and the join returns no rows. This is not an error the database can detect: the query is valid, the plan is fine, the result is simply empty.
"Matching variant" means both sides are the same domain, so the equality operator resolves and both sides compare the same term kind: `_eq` columns compare HMAC terms, and so does every text variant; the `_ord` variants of the non-text scalars compare ordering terms. An `_eq` column can't join an `_ord` column, because EQL defines its equality operators per domain and none exists between the two. See [Core concepts](https://cipherstash.com/docs/reference/eql/core-concepts) for the term model.
Equijoin [#equijoin]
```sql
SELECT u.*, o.total
FROM users u
JOIN orders o ON u.email = o.customer_email;
-- both columns public.eql_v3_text_eq, encrypted with the same keyset
```
No typed-operand cast is needed here — both operands are encrypted columns, so their domain types resolve the encrypted operator directly. All join types (`INNER`, `LEFT`, `RIGHT`, `FULL`) work; `LEFT JOIN` null-extension behaves normally because SQL `NULL`s are not encrypted.
Index both sides for anything beyond small tables — a hash (or btree) index on `eql_v3.eq_term(col)` on each column. Recipes are in [Indexes](https://cipherstash.com/docs/reference/eql/indexes).
IN (subquery) and set operations [#in-subquery-and-set-operations]
Both follow the same rule, because both compare equality terms across two column sources:
```sql
-- IN (subquery): users.email and orders.customer_email must share a keyset
SELECT * FROM users
WHERE email IN (SELECT customer_email FROM orders WHERE flagged);
-- Set-operation dedup: UNION / INTERSECT / EXCEPT dedupe by equality term
SELECT email FROM users
UNION
SELECT customer_email FROM orders;
```
If the two columns are under different keysets, `IN (subquery)` matches nothing, `INTERSECT` is empty, `EXCEPT` returns everything, and `UNION` never merges duplicates — all silently.
Worked example [#worked-example]
Two tables sharing an encrypted customer identifier, both columns typed `public.eql_v3_text_eq` and encrypted by the same client configuration (same keyset):
```sql
CREATE TABLE users (
id BIGINT GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
email public.eql_v3_text_eq
);
CREATE TABLE orders (
id BIGINT GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
customer_email public.eql_v3_text_eq,
total BIGINT NOT NULL
);
CREATE INDEX users_email_eq ON users USING hash (eql_v3.eq_term(email));
CREATE INDEX orders_cust_eq ON orders USING hash (eql_v3.eq_term(customer_email));
ANALYZE users; ANALYZE orders;
```
Orders per user, filtered by an encrypted lookup on one side:
```sql
SELECT u.id, COUNT(o.id) AS order_count
FROM users u
LEFT JOIN orders o ON u.email = o.customer_email
WHERE u.email = $1::public.eql_v3_text_eq
GROUP BY u.id;
```
The `WHERE` engages the hash index on `users`; the join condition engages the one on `orders`. The grouping key here is a plaintext `id`, so no extractor is needed — grouping on encrypted columns is covered in [Grouping & aggregates](https://cipherstash.com/docs/reference/eql/grouping-and-aggregates).
Anti-pattern: joining across keysets [#anti-pattern-joining-across-keysets]
The failure mode is quiet. A join across keysets doesn't raise, doesn't warn, and produces a plan that looks healthy — the terms just never match, so it behaves exactly like a join where no rows happen to correlate:
```sql
-- users encrypted by service A's keyset, partners by service B's:
SELECT * FROM users u JOIN partners p ON u.email = p.contact_email;
-- 0 rows. Always. Even when the plaintext emails overlap.
```
To diagnose a join that returns fewer rows than expected (or none):
1. **Check the variants.** Both columns must be equality-capable and compare the same term kind. A blocked operator raises loudly, so if the query *runs*, the variants at least resolve — but confirm they compare the same term (`hm` vs `ob`).
2. **Compare terms for a known-matching pair.** Take one row from each table that you know holds the same plaintext and compare their equality terms:
```sql
SELECT eql_v3.eq_term(u.email) = eql_v3.eq_term(p.contact_email) AS terms_match
FROM users u, partners p
WHERE u.id = 42 AND p.id = 7; -- rows known to share a plaintext value
```
`false` for plaintext-identical values means the terms were derived under different keysets (or different client configurations) — no SQL will make them join.
3. **Fix it at the encryption layer.** Configure both columns under the same keyset in the [Stack SDK](https://cipherstash.com/docs/reference/stack) or [CipherStash Proxy](https://cipherstash.com/docs/reference/proxy) and re-encrypt one side. Cross-keyset correlation otherwise has to happen in the client, after decryption.
Treat shared keysets as part of your schema design: columns you intend to join are a unit, the same way a foreign key pair is.
Where to go next [#where-to-go-next]
* [Filtering](https://cipherstash.com/docs/reference/eql/filtering) — the equality and `IN` shapes joins are built from.
* [Grouping & aggregates](https://cipherstash.com/docs/reference/eql/grouping-and-aggregates) — grouping joined results on encrypted keys.
* [Indexes](https://cipherstash.com/docs/reference/eql/indexes) — equality index recipes for both sides of a join.
* [Core concepts](https://cipherstash.com/docs/reference/eql/core-concepts) — index terms, variants, and why determinism makes joins possible at all.
# JSON
Source: https://cipherstash.com/docs/reference/eql/json
`public.eql_v3_json_search` is EQL's searchable encrypted JSON document type, built on structured encryption (**ste\_vec**). The document is encrypted as a vector of encrypted entries — one entry per path inside the document — and every path is queryable without decryption: containment, field and array access, exact field matching, and range comparisons on extracted leaves.
Like every EQL type, it holds ciphertext the database can't read. Encryption, decryption, and selector generation happen in the client — the [Stack SDK](https://cipherstash.com/docs/reference/stack) or [CipherStash Proxy](https://cipherstash.com/docs/reference/proxy). See [Searchable encryption](https://cipherstash.com/docs/concepts/searchable-encryption) for how querying ciphertext works at all.
The types [#the-types]
Four `jsonb`-backed domains make up the encrypted JSON surface. The family follows the same convention as the scalars: the bare name is storage-only, and a suffix adds capability.
| Type | What it is |
| --------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `public.eql_v3_json_search` | The searchable column type. An encrypted document envelope carrying an `sv` array — one encrypted entry per path in the document. |
| `public.eql_v3_json` | Storage-only encrypted JSON: one opaque ciphertext (`{v, i, c}`), no index terms, no server-side searchability. Every comparison and containment operator is blocked on it. |
| `public.eql_v3_json_entry` | A single entry from the vector: a selector, a ciphertext, and an optional ordering term. This is what `->` returns. |
| `eql_v3.query_json` | A containment needle: entries with selectors but **no ciphertext**. This is what you cast a `@>` operand to. |
These domains were renamed in EQL 3.0.1: the searchable document was `public.eql_v3_json`, the entry was `public.eql_v3_jsonb_entry`, and the needle was `eql_v3.query_jsonb`. The bare `public.eql_v3_json` name now means the storage-only domain, which rejects a ste\_vec document, so retype searchable columns: `ALTER TABLE t ALTER COLUMN doc TYPE public.eql_v3_json_search`.
Payload shape [#payload-shape]
An encrypted JSON document uses a different payload shape from the scalar types: the standard envelope keys are present (`v`, `i`, plus the `k: "sv"` discriminator — envelope anatomy is covered in [Core concepts](https://cipherstash.com/docs/reference/eql/core-concepts)), but there is no root ciphertext — the root document's ciphertext is the root `sv` entry. Two document-level keys plus the vector:
| Key | Contents |
| ---- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `h` | Key header — the key-retrieval material (IV, tag, descriptor, keyset) for the whole document. Required. Hoisted here once rather than repeated in every entry, which shrinks a document by roughly 30%. |
| `sv` | The vector: one encrypted entry per path in the document. |
Each entry has:
| Key | Contents |
| ---- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `s` | Selector — a deterministic hash. On a **path entry** it covers the JSON path; on a **value entry** it covers the path *and* the canonical value, which is what makes exact matching work. Required; entry matching compares selectors first. |
| `c` | Ciphertext for the node at that path — raw AEAD output, with the nonce derived from the entry's own selector rather than a shared per-document IV. A value entry encrypts a fixed versioned sentinel, so it stays distinguishable from a genuine `""` leaf. |
| `op` | Optional ordering term (CLLW OPE, backed by `eql_v3_internal.ope_cllw`) on String and Number path entries. |
| `a` | Optional array marker — `true` when the selector points at an array context. |
The decoded `op` value starts with a domain-tag byte (`0x00` numeric, `0x01` string) followed by the CLLW ciphertext, so numeric and string values in one column keep a consistent total order. Pre-release payloads named this key `oc` and backed it with CLLW ORE, and older ones split it further, into `ocf` (fixed-width, numeric) and `ocv` (variable-width, string).
**Entries no longer carry `hm`.** The per-value HMAC equality term was retired in EQL 3.0.1 in favour of value-inclusive selectors, and an `hm`-bearing entry now fails the domain `CHECK`. Along with the key header and the selector-derived nonces, that makes this a wire-format change: stored documents need re-encrypting by a current client, and there is no mechanical conversion.
A document payload for a `public.eql_v3_json_search` column:
```json
{
"v": 3,
"k": "sv",
"i": { "t": "orders", "c": "metadata" },
"h": "a4f1c2...",
"sv": [
{ "s": "2517068c0d1f9d4d41d2c666211f785e", "c": "mBbKmM..." },
{ "s": "f510853a4ab9d4f75f51a533ac264c5d", "c": "mBbKmQ...", "op": "01a3f2..." },
{ "s": "33743aed3ae636f6bf05cff11ac4b519", "c": "mBbKmR...", "op": "004e19..." }
]
}
```
* First entry: an object root — no ordering term
* Second entry: a string leaf — `op` starting with tag `01`
* Third entry: a numeric leaf — `op` starting with tag `00`
A containment **query** payload (`eql_v3.query_json`) has the same `sv` shape but its entries carry no `c` — containment matches selectors, never ciphertexts. This is the needle the client builds for a `@>` query:
```json
{
"sv": [
{ "s": "f510853a4ab9d4f75f51a533ac264c5d", "op": "01a3f2..." }
]
}
```
Storing encrypted JSON [#storing-encrypted-json]
Type the column as `public.eql_v3_json_search`:
```sql
CREATE TABLE orders (
id BIGINT GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
metadata public.eql_v3_json_search
);
```
There is no database-side configuration step. Which selectors and terms a document carries is decided by the encryption client; typing the column as `public.eql_v3_json_search` is what makes the encrypted operators and functions resolve. The domain's `CHECK` constraint validates the payload shape on insert, so malformed values are rejected at write time.
For a document you never search, type the column as the storage-only `public.eql_v3_json` instead: it takes the plain `{v, i, c}` envelope, rejects a ste\_vec document, and blocks every comparison operator — the JSON analogue of `public.eql_v3_boolean`.
Insert and read through the Stack SDK or Proxy, which encrypt the document into the ste\_vec payload on write and decrypt it on read.
What each node type supports [#what-each-node-type-supports]
During encryption, the client flattens the document: each unique path gets a deterministic **selector** hash. Each node then emits a **path entry** (selector over the path, carrying the ordering term where the type has one) and a **value entry**, whose selector covers the path *and* the canonical value:
| JSON node type | Ordering term | Exact match (`@>` on the value selector) | Ordering (`<` … `>=`, `MIN`/`MAX`) |
| --------------------- | ------------------------------- | :--------------------------------------: | :--------------------------------: |
| Object | — | Yes | No |
| Array | — | Yes | No |
| Boolean / JSON `null` | — | Yes | No |
| String | `op` (CLLW OPE, string domain) | Yes | Yes |
| Number | `op` (CLLW OPE, numeric domain) | Yes | Yes |
Exact matching is the *presence* of a value selector in the stored document, which makes it injective and loss-free for every type — including `text`, `bigint` and `numeric`, where the old ordering-term comparison collided (`"café"` with `"cafe"`, `9007199254740993` with `…992`). It is expressed as document containment, not as `=` on an extracted leaf:
```sql
SELECT * FROM orders WHERE metadata @> $1::eql_v3.query_json;
```
JSON `null` here means a `null` literal *inside* the document. A SQL `NULL` column value is not encrypted at all.
Blocked native jsonb operators [#blocked-native-jsonb-operators]
These native PostgreSQL `jsonb` operators are **blocked** on `public.eql_v3_json_search`. They raise an error rather than silently running plaintext-jsonb semantics against the encrypted payload:
* Key/path existence: `?`, `?|`, `?&`, `@?`, `@@`
* Path extraction: `#>`, `#>>`
* Mutation: `-`, `#-`, `||`
* Root-document comparison: `=`, `<>`, `<`, `<=`, `>`, `>=`
Equality on the **extract surface** raises too: `col -> 'sel'::text = $1::…` is a blocker for every family, because an extracted path entry carries no value selector and so cannot answer an exact match. Use value-selector containment for that.
Use containment (`@>` / `<@`), field access (`->` / `->>`), or the `eql_v3.jsonb_path_*` functions instead. There is no server-side mutation of an encrypted document — updates re-encrypt in the client.
**Operands must be typed** (`doc -> 'email'::text`, not `doc -> 'email'`) — an untyped operand resolves the native `jsonb` operator, bypassing both the encrypted operator and the blockers. See [Core concepts](https://cipherstash.com/docs/reference/eql/core-concepts).
Functions [#functions]
Every JSON query addresses paths by **selector hash** — the deterministic identifier the client emits for a JSON path during encryption, not a plaintext path like `$.customer.tier`. Operands must be typed, or PostgreSQL resolves the native `jsonb` operator instead of the encrypted one.
The examples below all query one encrypted `metadata` document. In plaintext:
```json
{
"customer": {
"tier": "premium",
"region": "apac"
},
"total": 149.95,
"items": ["sku-1042", "sku-2210"]
}
```
The `*_selector` placeholders stand for the selector hash of each path: `region_selector` for `$.customer.region`, `total_selector` for `$.total`, and `items_selector` for `$.items`.
Containment and exact matching [#fn-contains]
`@>` tests whether the encrypted document contains a structure; `<@` is the reverse. Build the needle in the client and cast it to `eql_v3.query_json`; `eql_v3.ste_vec_contains(a, b)` is the function form. This is both the structural-containment operator and the way to match a field exactly — the client emits a value-selector needle for the field and value you're matching.
```sql
SELECT * FROM orders
WHERE metadata @> $1::eql_v3.query_json;
```
For large tables, back containment with a GIN index. The typed `@>` inlines to a native `jsonb @>` over `eql_v3.to_ste_vec_query(col)::jsonb`, so a GIN index on that same expression engages:
```sql
CREATE INDEX orders_metadata_gin
ON orders USING gin (eql_v3.to_ste_vec_query(metadata)::jsonb jsonb_path_ops);
```
Field access [#fn-field-access]
`->` returns a `public.eql_v3_json_entry`; `->>` serializes that entry as ciphertext text. Fields are addressed by selector hash, and array elements by 0-based index.
```sql
SELECT metadata -> 'selector_hash'::text FROM orders; -- entry
SELECT metadata ->> 'selector_hash'::text FROM orders; -- entry as ciphertext text
SELECT metadata -> 0 FROM orders; -- array element by index
```
An extracted `public.eql_v3_json_entry` is ordered-comparable, but not equality-comparable: `=` / `<>` on it raise.
`eql_v3.eq_term` has a `public.eql_v3_json_entry` overload, but it is **deprecated** — it is an alias for `eql_v3.ope_term`, returning raw OPE bytes rather than an exact equality term, so it inherits the ordering term's encoding collisions (float rounding on large integers, collation on text). Exact field matching is value-selector containment, above.
eql_v3.ord_term [#fn-ord-term]
Range comparisons and `ORDER BY` on an extracted **String or Number** leaf, via `eql_v3.ord_term`.
```sql
SELECT * FROM orders
WHERE (metadata -> 'total_selector'::text) > $1::public.eql_v3_json_entry;
```
A btree on `eql_v3.ord_term(col -> ''::text)` engages range and `ORDER BY`; the GIN index on `eql_v3.to_ste_vec_query(col)::jsonb` engages exact matching. See [Indexes](https://cipherstash.com/docs/reference/eql/indexes).
eql_v3.min / max [#fn-min-max]
`MIN` / `MAX` over an extracted ordered leaf.
```sql
SELECT eql_v3.min(metadata -> 'total_selector'::text) FROM orders;
```
eql_v3.jsonb_path_query [#fn-path-query]
Path queries take the same selector hashes. `jsonb_path_query` returns every matching entry, `jsonb_path_query_first` the first, and `jsonb_path_exists` a boolean.
```sql
SELECT eql_v3.jsonb_path_query(metadata, 'selector_hash') FROM orders; -- all matches
SELECT eql_v3.jsonb_path_query_first(metadata, 'selector_hash') FROM orders; -- first match
SELECT eql_v3.jsonb_path_exists(metadata, 'selector_hash') FROM orders; -- boolean
```
eql_v3.jsonb_array_* [#fn-array]
Helpers over an encrypted array node. `jsonb_array_elements` yields encrypted entries — each carrying the grafted key header, which makes it the decryptable unit.
```sql
SELECT eql_v3.jsonb_array_length(metadata -> 'items_selector'::text) FROM orders;
SELECT eql_v3.jsonb_array_elements(metadata -> 'items_selector'::text) FROM orders;
```
`eql_v3.jsonb_array_elements_text`, which streamed each element as bare ciphertext text, was **removed** in EQL 3.0.1: an entry's ciphertext is no longer independently decryptable, so the rows it produced were useless. Use `eql_v3.jsonb_array_elements`.
Worked example [#worked-example]
An `orders` table with an encrypted `metadata` document. The plaintext your application works with:
```json
{
"customer": {
"tier": "premium",
"region": "apac"
},
"items": ["sku-1042", "sku-2210"]
}
```
The client encrypts this into a ste\_vec payload with selectors for `$`, `$.customer`, `$.customer.tier`, `$.customer.region`, `$.items`, and each array element — every path becomes queryable.
Create the table and insert [#create-the-table-and-insert]
```sql
CREATE TABLE orders (
id BIGINT GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
metadata public.eql_v3_json_search
);
INSERT INTO orders (metadata) VALUES ($1);
-- $1 is the encrypted ste_vec payload produced by the Stack SDK or Proxy
```
Query by containment [#query-by-containment]
Find premium orders. The client encrypts the needle `{"customer": {"tier": "premium"}}` into a `ste_vec_query` — a value-selector needle, so this is an exact match on the field, not a fuzzy one:
```sql
SELECT id FROM orders
WHERE metadata @> $1::eql_v3.query_json;
```
Add the GIN index from above once the table grows.
Query by path [#query-by-path]
Path existence and range comparisons work on the extract surface — the database never sees `"apac"` or `149.95`:
```sql
SELECT id FROM orders
WHERE eql_v3.jsonb_path_exists(metadata, 'region_selector')
AND (metadata -> 'total_selector'::text) > $1::public.eql_v3_json_entry;
```
The rows come back as ciphertext; decrypt them in the client.
Where to next [#where-to-next]
The envelope anatomy, typed-operand rule, and fail-loud behavior shared by every EQL type.
GIN containment and field-level functional index recipes.
WHERE-clause patterns across all encrypted types.
# Numbers
Source: https://cipherstash.com/docs/reference/eql/numbers
Six numeric types share one identical query surface: `int2`, `int4`, `int8`, `float4`, `float8`, and `numeric`. These are the columns you filter by range, sort, and take a `MIN` / `MAX` over — salaries, totals, rates, quantities.
Date and time columns have the same capabilities but their own semantics — see [Dates & times](https://cipherstash.com/docs/reference/eql/dates-and-times). There is no free-text matching for numeric types — `_match` and `_search` are [text-only variants](https://cipherstash.com/docs/reference/eql/text).
Variants [#variants]
Each numeric type generates the same `jsonb`-backed domain variants. The generic form:
| Domain variant | Capability |
| --------------------------- | --------------------------------------------------------------------------------------------- |
| `public.eql_v3_` | Storage and decryption only. |
| `public.eql_v3__eq` | Equality: `=`, `<>`, `IN`, `GROUP BY`, `DISTINCT`, equijoins. |
| `public.eql_v3__ord` | Comparisons, `BETWEEN`, `ORDER BY`, `MIN` / `MAX` — plus equality. |
| `public.eql_v3__ord_ope` | The byte-identical twin of `_ord`, with OPE pinned. See [SEM specifiers](#sem-specifiers). |
| `public.eql_v3__ord_ore` | As `_ord`, with the ORE mechanism pinned. |
`` is the encrypted type name from the table below, so `public.eql_v3__ord` is `public.eql_v3_bigint_ord` for `int8`.
And every concrete domain this page covers:
| Type | Variants |
| --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `int2` | `public.eql_v3_smallint` · `public.eql_v3_smallint_eq` · `public.eql_v3_smallint_ord` · `public.eql_v3_smallint_ord_ope` · `public.eql_v3_smallint_ord_ore` |
| `int4` | `public.eql_v3_integer` · `public.eql_v3_integer_eq` · `public.eql_v3_integer_ord` · `public.eql_v3_integer_ord_ope` · `public.eql_v3_integer_ord_ore` |
| `int8` | `public.eql_v3_bigint` · `public.eql_v3_bigint_eq` · `public.eql_v3_bigint_ord` · `public.eql_v3_bigint_ord_ope` · `public.eql_v3_bigint_ord_ore` |
| `float4` | `public.eql_v3_real` · `public.eql_v3_real_eq` · `public.eql_v3_real_ord` · `public.eql_v3_real_ord_ope` · `public.eql_v3_real_ord_ore` |
| `float8` | `public.eql_v3_double` · `public.eql_v3_double_eq` · `public.eql_v3_double_ord` · `public.eql_v3_double_ord_ope` · `public.eql_v3_double_ord_ore` |
| `numeric` | `public.eql_v3_numeric` · `public.eql_v3_numeric_eq` · `public.eql_v3_numeric_ord` · `public.eql_v3_numeric_ord_ope` · `public.eql_v3_numeric_ord_ore` |
Declare only the capability you query on — each capability stores extra searchable material with defined leakage (see [Searchable encryption](https://cipherstash.com/docs/concepts/searchable-encryption)), and the variant model itself is covered in [Core concepts](https://cipherstash.com/docs/reference/eql/core-concepts).
Numeric query example [#numeric-query-example]
A payroll table mixing the variants by how each column is queried:
```sql
CREATE TABLE employees (
id bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
salary public.eql_v3_bigint_ord, -- range queries, ORDER BY, MIN/MAX
tax_rate public.eql_v3_numeric_eq, -- exact lookup only
net_worth public.eql_v3_numeric -- store and decrypt only, never queried
);
```
SEM specifiers [#sem-specifiers]
All six types take the same mechanism specifiers on their orderable variant (the concept is defined in [Core concepts](https://cipherstash.com/docs/reference/eql/core-concepts#sem-specifiers)):
| Specifier | Mechanism | Ordering term | Extractor |
| ---------- | ------------------------------- | ------------- | --------------------- |
| `_ord` | The default, currently CLLW OPE | `op` | `eql_v3.ord_term` |
| `_ord_ope` | CLLW OPE, pinned explicitly | `op` | `eql_v3.ord_term` |
| `_ord_ore` | Block-ORE, pinned explicitly | `ob` | `eql_v3.ord_term_ore` |
`_ord` and `_ord_ope` are byte-identical today. Pin `_ord_ope` when you want a column's mechanism frozen against a future change of the default.
Block-ORE terms sort only under a custom btree operator class, and creating one requires superuser. Where the EQL installer runs as a non-superuser, which is the case on most managed Postgres including cloud Supabase, it cannot create the class, so it **disables every ORE-backed domain** rather than let them install half-working. `_ord_ore` then raises `feature_not_supported` on the first value written to it. Use `_ord` there.
Payload [#payload]
A value for an `_ord` column carries the shared envelope keys (`v`, `i`, `c` — see [Core concepts](https://cipherstash.com/docs/reference/eql/core-concepts)) plus the `op` ordering term. Here is a payload for the `public.eql_v3_bigint_ord` `salary` column:
```json
{
"v": 3,
"i": { "t": "employees", "c": "salary" },
"c": "mBbKmsMM%bK#QQOx1yLDBHyD...",
"op": "5f2b1a9e4c07d38b6ea15c92..."
}
```
* **`op` is the only index term.** It is a hex-encoded CLLW OPE ciphertext, which Postgres sorts by native `bytea` comparison. An `_ord` payload carries no `hm`, because ordering over a numeric scalar is equality-lossless: `=` and `<>` resolve against the same term. Only `_eq` payloads carry `hm` (a single hex HMAC-SHA-256 string) instead.
* **An `_ord_ore` payload carries `ob` in place of `op`**: an array of block-ORE ciphertexts, 8 blocks for the int types and 14 for `numeric`.
Operators [#operators]
| SQL operator | `public.eql_v3_` | `_eq` | `_ord` variants |
| ------------------------------------- | :-----------------: | :------: | :----------------: |
| `=` / `<>` | ❌ | ✅ | ✅ |
| `<` `<=` `>` `>=` | ❌ | ❌ | ✅ |
| `BETWEEN` (desugars to `>=` and `<=`) | ❌ | ❌ | ✅ |
| `IN` (desugars to `=`) | ❌ | ✅ | ✅ |
| `GROUP BY` / `DISTINCT` | ❌ | ✅ | ✅ |
| `ORDER BY` | ❌ | ❌ | ✅ |
| `IS NULL` / `IS NOT NULL` | ✅ | ✅ | ✅ |
Blocked *operator* cells raise an `operator … is not supported` exception — they never silently return wrong rows. `ORDER BY` is the one blocked cell that doesn't raise: it isn't an operator, so sorting a variant without an ordering term runs — but the order is meaningless (see [Sorting](https://cipherstash.com/docs/reference/eql/sorting)). Operands must be typed (`$1::public.eql_v3_bigint_ord`), or PostgreSQL resolves the native `jsonb` operator instead of the encrypted one. Both rules are covered in [Core concepts](https://cipherstash.com/docs/reference/eql/core-concepts).
Functions [#functions]
{/* GENERATED — do not edit. Produced by scripts/generate-eql-api-docs.ts from the EQL manifest. Edit the generator, not this file. */}
Every operator has a function form, for managed platforms that disallow custom operators — same typed arguments, identical resolution. Each lists the encrypted domains it applies to; the `MIN` / `MAX` aggregates only exist as functions.
eql_v3.eq(a, b) [#fn-eq]
```sql
SELECT * FROM payments
WHERE eql_v3.eq(amount, $1::public.eql_v3_bigint_eq);
```
eql_v3.neq(a, b) [#fn-neq]
```sql
SELECT * FROM payments
WHERE eql_v3.neq(amount, $1::public.eql_v3_bigint_eq);
```
eql_v3.lt / lte / gt / gte [#fn-comparison]
```sql
-- a range uses two of the four
SELECT * FROM payments
WHERE eql_v3.gte(amount, $1::public.eql_v3_bigint_ord)
AND eql_v3.lt(amount, $2::public.eql_v3_bigint_ord);
```
eql_v3.min(col) [#fn-min]
```sql
-- compares ordering terms; result decrypts client-side
SELECT eql_v3.min(amount) FROM payments;
```
eql_v3.max(col) [#fn-max]
```sql
SELECT eql_v3.max(amount) FROM payments;
```
**`SUM`, `AVG`, and other arithmetic aggregates are not supported** on encrypted columns — they would require homomorphic encryption. `MIN` / `MAX` work because they only need comparison; for sums and averages, decrypt at the application boundary and aggregate client-side.
Where to next [#where-to-next]
The same capabilities on date and timestamp columns.
Btree recipes on `eql_v3.ord_term` for range, ORDER BY, and MIN/MAX.
WHERE-clause patterns across all encrypted types.
GROUP BY, DISTINCT, and the aggregate surface on encrypted columns.
# Sorting
Source: https://cipherstash.com/docs/reference/eql/sorting
`ORDER BY` on an encrypted column needs an ordering term: it works on the `_ord`, `_ord_ope`, and `_ord_ore` variants of every scalar, and on `text_search` / `text_search_ore`. Ordering terms are order-preserving, so the database sorts ciphertext in exactly the order the plaintext would sort — without decrypting anything. Which variants carry the term is covered in [Numbers](https://cipherstash.com/docs/reference/eql/numbers), [Dates & times](https://cipherstash.com/docs/reference/eql/dates-and-times), and [Text](https://cipherstash.com/docs/reference/eql/text); the variant model itself is in [Core concepts](https://cipherstash.com/docs/reference/eql/core-concepts).
Sorting a variant *without* an ordering term (`_eq`, `text_match`, bare storage variants) won't raise — but the order is meaningless. Type the column as an `_ord` variant when ordering matters.
The mechanism behind the term, CLLW OPE (`op`) or block-ORE (`ob`), changes nothing about how you write the query. `eql_v3.ord_term` is the extractor for `_ord`, `_ord_ope`, and `text_search`; `eql_v3.ord_term_ore` is the extractor for `_ord_ore` and `text_search_ore`. Everything on this page applies to both, with one exception: only the OPE term indexes under Postgres's default btree operator class, so on managed Postgres it is the only mechanism available. See [SEM specifiers](https://cipherstash.com/docs/reference/eql/core-concepts#sem-specifiers).
Bare form vs extractor form [#bare-form-vs-extractor-form]
Both of these sort correctly:
```sql
-- Bare form
SELECT * FROM users ORDER BY created_at DESC;
-- Extractor form
SELECT * FROM users ORDER BY eql_v3.ord_term(created_at) DESC;
```
The difference is the plan. The planner inlines encrypted operators in *predicates*, so a `WHERE created_at < $1` matches a btree on `eql_v3.ord_term(created_at)` without rewriting — but it does **not** rewrite *sort keys*. Bare `ORDER BY created_at` therefore adds a `Sort` node above the scan, and that sort's cost scales linearly with the rows passing the filter.
Writing the sort key in extractor form makes it textually match the index expression, so rows stream out of the btree already ordered — no `Sort` node at all:
```sql
CREATE INDEX users_created_at_ord
ON users USING btree (eql_v3.ord_term(created_at));
ANALYZE users;
SELECT * FROM users
WHERE created_at < $1::public.eql_v3_timestamp_ord
ORDER BY eql_v3.ord_term(created_at) DESC
LIMIT 10;
-- Index Scan Backward using users_created_at_ord — no Sort node
```
At large row counts this is the difference between seconds and milliseconds, and it matters most for `LIMIT` queries: with a `Sort` node, Postgres must sort *every* matching row before it can return the top 10; streaming from the index, it stops after 10.
Rule of thumb: bare form is fine for small result sets or when no ordering index exists; any hot query with `ORDER BY ... LIMIT` should use the extractor form. Confirm with `EXPLAIN (COSTS OFF)` — a `Sort` node above an `Index Scan` means the sort key didn't match the index. Full plan-reading guidance is in [Indexes](https://cipherstash.com/docs/reference/eql/indexes).
ASC, DESC, and NULLS [#asc-desc-and-nulls]
`ASC` / `DESC` behave normally — a btree serves both directions (backward scans handle `DESC`). SQL `NULL` column values are not encrypted, so `NULLS FIRST` / `NULLS LAST` also behave normally:
```sql
SELECT * FROM users
ORDER BY eql_v3.ord_term(last_login) DESC NULLS LAST;
```
Keyset pagination [#keyset-pagination]
`OFFSET` pagination degrades on encrypted columns the same way it does on plaintext ones — every page re-sorts and discards the rows before the offset. Keyset (cursor) pagination composes an encrypted range filter with an extractor-form sort:
```sql
-- Page 1
SELECT id, email, created_at FROM users
ORDER BY eql_v3.ord_term(created_at) DESC
LIMIT 20;
-- Next page: pass the last row's created_at back, re-encrypted as the cursor
SELECT id, email, created_at FROM users
WHERE created_at < $1::public.eql_v3_timestamp_ord
ORDER BY eql_v3.ord_term(created_at) DESC
LIMIT 20;
```
Both the filter and the sort ride the same btree on `eql_v3.ord_term(created_at)`, so every page is an index scan that stops after 20 rows. The client re-encrypts the cursor value for the next request — the database only ever sees ciphertext.
The ::jsonb projection trap [#the-jsonb-projection-trap]
If you project the column with a cast and sort on it — `SELECT col::jsonb ... ORDER BY col` — Postgres folds the cast into the scan and uses `(col)::jsonb` as the sort key, which matches no index. Project the column raw and let the client decode it, or write the sort key as `eql_v3.ord_term(col)`, which sidesteps the problem entirely.
Sorting extracted JSON leaves [#sorting-extracted-json-leaves]
String and Number leaves inside an encrypted JSON document carry a CLLW OPE term, so they sort too — the extractor is `eql_v3.ord_term` on the extracted entry:
```sql
SELECT * FROM orders
ORDER BY eql_v3.ord_term(metadata -> 'total_selector'::text) DESC
LIMIT 10;
```
A btree on the same `eql_v3.ord_term(...)` expression streams this ordered, exactly like `ord_term` on a scalar column. Selectors, node types, and which leaves are orderable are covered in [JSON](https://cipherstash.com/docs/reference/eql/json).
Where to go next [#where-to-go-next]
* [Indexes](https://cipherstash.com/docs/reference/eql/indexes) — the btree recipe behind every sort on this page, plus `EXPLAIN` verification and large-table build guidance.
* [Filtering](https://cipherstash.com/docs/reference/eql/filtering) — the range predicates that pair with these sorts.
* [Grouping & aggregates](https://cipherstash.com/docs/reference/eql/grouping-and-aggregates) — `MIN` / `MAX`, which use the same ordering term.
# Text
Source: https://cipherstash.com/docs/reference/eql/text
Text is the richest encrypted scalar. Beyond the variants every scalar type gets, `text` adds its own: `text_match` for encrypted free-text matching, and `text_search` for columns you need to look up, sort, *and* search. Emails, names, tax IDs, addresses — this page is the full surface for all of them.
Variants [#variants]
All of these are `jsonb`-backed domains. Which one you declare fixes the column's query capability — the variant model itself is covered in [Core concepts](https://cipherstash.com/docs/reference/eql/core-concepts):
| Domain variant | Capability |
| ------------------------------- | ---------------------------------------------------------------------------------------------- |
| `public.eql_v3_text` | Storage and decryption only. |
| `public.eql_v3_text_eq` | Equality: `=`, `<>`, `IN`, `GROUP BY`, `DISTINCT`, equijoins. |
| `public.eql_v3_text_ord` | Comparisons, `BETWEEN`, `ORDER BY`, `MIN` / `MAX` — plus equality. |
| `public.eql_v3_text_ord_ope` | The byte-identical twin of `text_ord`, with OPE pinned. See [SEM specifiers](#sem-specifiers). |
| `public.eql_v3_text_ord_ore` | As `text_ord`, with the ORE mechanism pinned. |
| `public.eql_v3_text_match` | Free-text fuzzy match: `@@`. |
| `public.eql_v3_text_search` | Equality + ordering + fuzzy match. |
| `public.eql_v3_text_search_ore` | As `text_search`, with the ORE mechanism pinned. |
Declare only the capabilities you query on — each capability stores extra searchable material with defined leakage (see [Searchable encryption](https://cipherstash.com/docs/concepts/searchable-encryption)).
Text query example [#text-query-example]
A users table mixing the variants by how each column is queried:
```sql
CREATE TABLE users (
id bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
email public.eql_v3_text_search, -- lookup, sort, and free-text match
name public.eql_v3_text_match, -- free-text match only
tax_id public.eql_v3_text_eq, -- exact lookup only
notes public.eql_v3_text -- store and decrypt only
);
```
SEM specifiers [#sem-specifiers]
Text takes the same mechanism specifiers as the other orderable types (the concept is defined in [Core concepts](https://cipherstash.com/docs/reference/eql/core-concepts#sem-specifiers)):
| Specifier | Mechanism | Ordering term | Extractor |
| ----------------- | ------------------------------- | ------------- | --------------------- |
| `_ord` | The default, currently CLLW OPE | `op` | `eql_v3.ord_term` |
| `_ord_ope` | CLLW OPE, pinned explicitly | `op` | `eql_v3.ord_term` |
| `_ord_ore` | Block-ORE, pinned explicitly | `ob` | `eql_v3.ord_term_ore` |
| `text_search` | The default, currently CLLW OPE | `op` | `eql_v3.ord_term` |
| `text_search_ore` | Block-ORE, pinned explicitly | `ob` | `eql_v3.ord_term_ore` |
`text_ord` and `text_ord_ope` are byte-identical today. Pin `_ord_ope` when you want a column's mechanism frozen against a future change of the default.
Block-ORE terms sort only under a custom btree operator class, and creating one requires superuser. Where the EQL installer runs as a non-superuser, which is the case on most managed Postgres including cloud Supabase, it cannot create the class, so it **disables every ORE-backed domain** rather than let them install half-working. `text_ord_ore` and `text_search_ore` then raise `feature_not_supported` on the first value written to them. Use `text_ord` or `text_search` there.
Payload [#payload]
A value for a `text_search` column carries the shared envelope keys (`v`, `i`, `c` — see [Core concepts](https://cipherstash.com/docs/reference/eql/core-concepts)) plus all three index terms:
```json
{
"v": 3,
"i": { "t": "users", "c": "email" },
"c": "mBbKmsMM%bK#QQOx1yLDBHyD...",
"hm": "9c8ec1d2f9932b979b1bf3f09f8a4e2f6a41f8de2f0c8b7a52e1f5c3d4b6a790",
"op": "5f2b1a9e4c07d38b6ea15c92...",
"bf": [42, 1290, -8113, 30201]
}
```
* `hm` — equality term: `WHERE email = $1` compares this
* `op` — ordering term: a hex-encoded CLLW OPE ciphertext, which `ORDER BY` and range comparisons sort by native `bytea` comparison
* `bf` — bloom-filter term: `@@` fuzzy match tests these bit positions
A `text_search_ore` payload carries `ob` in place of `op`: an array of block-ORE ciphertexts rather than a single string.
The narrower variants carry only their own terms. A `text_eq` payload carries `hm` alone, `text_match` carries `bf` alone, and the orderable variants carry `hm` plus their ordering term (`op` for `text_ord` / `text_ord_ope`, `ob` for `text_ord_ore`). Text keeps `hm` on every orderable variant, because ordering over text is not equality-lossless the way it is over the numeric scalars: `=` and `<>` resolve against the HMAC term rather than the ordering term. A payload missing its variant's required term fails the domain `CHECK` at write time.
**`bf` positions are signed**: EQL stores the filter as PostgreSQL `smallint[]`, and filters sized above 32768 emit upper-half bit positions as *negative* signed values. Consumers must use a signed 16-bit integer type.
Operators [#operators]
| SQL operator | `public.eql_v3_text` | `text_eq` | `text_ord` variants | `text_match` | `text_search` variants |
| ------------------------------- | :------------------: | :-------: | :-----------------: | :----------: | :--------------------: |
| `=` / `<>` | ❌ | ✅ | ✅ | ❌ | ✅ |
| `<` `<=` `>` `>=` | ❌ | ❌ | ✅ | ❌ | ✅ |
| `@@` (fuzzy match) | ❌ | ❌ | ❌ | ✅ | ✅ |
| `@>` / `<@` | ❌ | ❌ | ❌ | ❌ | ❌ |
| `LIKE` / `ILIKE` (`~~` / `~~*`) | ❌ | ❌ | ❌ | ❌ | ❌ |
| `IN` / `GROUP BY` / `DISTINCT` | ❌ | ✅ | ✅ | ❌ | ✅ |
| `ORDER BY` | ❌ | ❌ | ✅ | ❌ | ✅ |
| `IS NULL` / `IS NOT NULL` | ✅ | ✅ | ✅ | ✅ | ✅ |
Blocked *operator* cells raise an `operator … is not supported` exception — they never silently return wrong rows. `ORDER BY` is the one blocked cell that doesn't raise: it isn't an operator, so sorting a variant without an ordering term runs — but the order is meaningless (see [Sorting](https://cipherstash.com/docs/reference/eql/sorting)). Operands must be typed (`$1::public.eql_v3_text_eq`), or PostgreSQL resolves the native `jsonb` operator instead of the encrypted one. Both rules are covered in [Core concepts](https://cipherstash.com/docs/reference/eql/core-concepts).
Functions [#functions]
{/* GENERATED — do not edit. Produced by scripts/generate-eql-api-docs.ts from the EQL manifest. Edit the generator, not this file. */}
Every operator has a function form, for managed platforms that disallow custom operators — same typed arguments, identical resolution. Each lists the encrypted domains it applies to; the `MIN` / `MAX` aggregates only exist as functions.
eql_v3.eq(a, b) [#fn-eq]
```sql
SELECT * FROM users
WHERE eql_v3.eq(email, $1::public.eql_v3_text_eq);
```
eql_v3.neq(a, b) [#fn-neq]
```sql
SELECT * FROM users
WHERE eql_v3.neq(email, $1::public.eql_v3_text_eq);
```
eql_v3.lt / lte / gt / gte [#fn-comparison]
```sql
-- any of the four; ordering is the usual reason to index text
SELECT id, email FROM users
WHERE eql_v3.gt(email, $1::public.eql_v3_text_ord)
ORDER BY eql_v3.ord_term(email);
```
eql_v3.matches(a, b) [#fn-matches]
```sql
-- probabilistic fuzzy match on the bloom-filter term
SELECT * FROM users
WHERE eql_v3.matches(email, $1::public.eql_v3_text_match);
```
eql_v3.min(col) [#fn-min]
```sql
-- compares ordering terms; result decrypts client-side
SELECT eql_v3.min(email) FROM users;
```
eql_v3.max(col) [#fn-max]
```sql
SELECT eql_v3.max(email) FROM users;
```
There are no `like` / `ilike` function forms — encrypted text matching is `eql_v3.matches` on a `text_match` value.
There is no LIKE [#there-is-no-like]
`LIKE` and `ILIKE` (`~~` / `~~*`) raise on **every** encrypted-domain variant — including `text_match` and `text_search`. SQL pattern matching is meaningless on ciphertext. Encrypted text matching is bloom-filter fuzzy match — `@@` on a `text_match` or `text_search` column:
```sql
SELECT * FROM users WHERE email LIKE '%alice%';
```
```sql
-- Encrypted free-text match
SELECT * FROM users WHERE email @@ $1::public.eql_v3_text_match;
-- Function form
SELECT * FROM users WHERE eql_v3.matches(email, $1::public.eql_v3_text_match);
```
`@@` is **probabilistic ngram-bloom matching** — it reduces to array containment over two bloom filters built from the downcased 3-gram token sets, so a `true` may be a false positive and a `false` never is. It is not `LIKE`, and it is not containment: it is order- and multiplicity-insensitive. The client encrypts the search term into a bloom-filter query value.
**`@>` / `<@` raise on the match variants.** The fuzzy match was renamed in EQL 3.0.1: it used to be spelled `@>` / `<@`, backed by `eql_v3.contains` / `eql_v3.contained_by`, which are no longer public functions on these domains. That naming promised containment semantics it never had, so the operator became the directional `@@` and the old spellings are now blockers that raise `operator … is not supported`. Genuine containment on encrypted JSON is unaffected and keeps `@>` / `<@`; see [JSON](https://cipherstash.com/docs/reference/eql/json). Repoint any query, view, or adapter still emitting the old form, and coordinate with the client: an SDK emitting `eql_v3.contains(` for text match must move to `eql_v3.matches(` in the same release.
Search terms too short to tokenise [#search-terms-too-short-to-tokenise]
A search string below the tokeniser's floor — a 2-character term, say — produces no 3-grams and encrypts to an empty bloom (`bf: []`). Because an empty array is contained by every array, such a needle once matched **every row in the table**, silently. Since EQL 3.0.3 the match is guarded, giving `LIKE ''`-shaped semantics:
| Stored value's bloom | Needle's bloom | `LIKE` analogue | Result |
| -------------------- | -------------- | ----------------- | :---------: |
| empty | empty | `'' LIKE ''` | ✅ |
| non-empty | empty | `'catty' LIKE ''` | ❌ (was ✅) |
| empty | non-empty | `'' LIKE 'cat'` | ❌ |
| non-empty | non-empty | — | bloom match |
Only the second row changed: an empty needle now matches only a value whose own bloom is also empty. Nothing to rewrite, and values legitimately stored with an empty bloom are unaffected. On EQL 3.0.2 and earlier, reject sub-floor search terms client-side — the SDK already does.
Where to next [#where-to-next]
Hash on `eq_term`, btree on `ord_term`, GIN on `match_term`.
WHERE-clause patterns across all encrypted types.
Extractor-form sort keys and index-backed ordering.
Equijoins on encrypted text columns, and the same-keyset rule.
# Configuration
Source: https://cipherstash.com/docs/reference/proxy/configuration
CipherStash Proxy is available as a [container image](https://hub.docker.com/r/cipherstash/proxy) on Docker Hub. Deploy it locally, as a cloud sidecar, or as a standalone binary. It speaks the PostgreSQL protocol, so your application connects to Proxy exactly the same way it connects to PostgreSQL.
Installing Proxy [#installing-proxy]
The quickest way to run Proxy alongside your application is to add a container to your `docker-compose.yml`:
```yaml filename="docker-compose.yml"
services:
app:
# Your app container config
db:
# Your Postgres container config
proxy:
image: cipherstash/proxy:latest
container_name: proxy
ports:
- 6432:6432
- 9930:9930
environment:
- CS_DATABASE__HOST=${CS_DATABASE__HOST}
- CS_DATABASE__PORT=${CS_DATABASE__PORT}
- CS_DATABASE__USERNAME=${CS_DATABASE__USERNAME}
- CS_DATABASE__PASSWORD=${CS_DATABASE__PASSWORD}
- CS_DATABASE__NAME=${CS_DATABASE__NAME}
- CS_WORKSPACE_CRN=${CS_WORKSPACE_CRN}
- CS_CLIENT_ACCESS_KEY=${CS_CLIENT_ACCESS_KEY}
- CS_DEFAULT_KEYSET_ID=${CS_DEFAULT_KEYSET_ID}
- CS_CLIENT_ID=${CS_CLIENT_ID}
- CS_CLIENT_KEY=${CS_CLIENT_KEY}
- CS_PROMETHEUS__ENABLED=${CS_PROMETHEUS__ENABLED:-true}
```
For a fully working example, see the [docker-compose.yml](https://github.com/cipherstash/proxy/blob/main/docker-compose.yml) in the Proxy repository.
Start the container, then connect your PostgreSQL client to Proxy on TCP 6432:
```bash cta cta-type="install" example-id="proxy-docker-compose-up"
docker compose up
```
Unlike the Stack SDK, Proxy **always requires credentials to be supplied explicitly**, because it runs as a separate process or container and cannot use the host's device-based authentication.
Create the four variables with `stash env` or the Dashboard, then supply them to the Proxy container. [Workspace credentials](https://cipherstash.com/docs/reference/workspace/configuration#credentials) shows both options and the complete environment block.
Setting up the database schema [#setting-up-the-database-schema]
Proxy queries encrypted data through [EQL](https://cipherstash.com/docs/reference/eql), which must be installed in the target database. Encrypted columns are typed with an EQL domain such as `public.eql_v3_text_eq`, and that type is what fixes the column's searchable capability. There is no database-side configuration table.
* [Install EQL](https://cipherstash.com/docs/reference/eql) covers the install itself, including the permissions split and Supabase.
* [Core concepts](https://cipherstash.com/docs/reference/eql/core-concepts) covers the variant model and which domain type to choose.
* [Indexes](https://cipherstash.com/docs/reference/eql/indexes) covers adding functional indexes over the term extractors.
In development, the Proxy container can install EQL for you on startup:
```bash
CS_DATABASE__INSTALL_EQL=true
```
Check the installed version:
```sql
SELECT eql_v3.version();
```
`CS_DATABASE__INSTALL_EQL` is for development only. In production, install EQL as a database migration.
Configuration loading order [#configuration-loading-order]
Proxy accepts configuration from a TOML file, environment variables, or both.
1. If `cipherstash-proxy.toml` exists in the current working directory, Proxy reads it first.
2. Proxy then reads any environment variables that are set.
3. When both are present, environment variables override values from the TOML file.
Config options [#config-options]
[server] [#server]
| Option | Env variable | Default | Description |
| -------------------------- | ------------------------------------- | -------------------------- | ------------------------------------------------------------------------------------------- |
| `host` | `CS_SERVER__HOST` | `0.0.0.0` | Proxy listen address |
| `port` | `CS_SERVER__PORT` | `6432` | Proxy listen port |
| `require_tls` | `CS_SERVER__REQUIRE_TLS` | `false` | Enforce TLS for client-to-proxy connections |
| `shutdown_timeout` | `CS_SERVER__SHUTDOWN_TIMEOUT` | `2000` | Milliseconds to wait for connections to drain on shutdown |
| `worker_threads` | `CS_SERVER__WORKER_THREADS` | `NUMBER_OF_CORES/2` or `4` | Number of server worker threads |
| `thread_stack_size` | `CS_SERVER__THREAD_STACK_SIZE` | `2097152` (2 MiB) | Thread stack size in bytes. Automatically set to 4 MiB when log level is `debug` or `trace` |
| `cipher_cache_size` | `CS_SERVER__CIPHER_CACHE_SIZE` | `64` | Maximum number of encryption/decryption operations to cache |
| `cipher_cache_ttl_seconds` | `CS_SERVER__CIPHER_CACHE_TTL_SECONDS` | `3600` | Seconds before cached cipher operations expire |
[database] [#database]
| Option | Env variable | Default | Description |
| ------------------------ | ------------------------------------- | ---------- | --------------------------------------------------------------------------------------------------------------------------------- |
| `host` | `CS_DATABASE__HOST` | `0.0.0.0` | Database host address |
| `port` | `CS_DATABASE__PORT` | `5432` | Database port |
| `name` | `CS_DATABASE__NAME` | (required) | Database name |
| `username` | `CS_DATABASE__USERNAME` | (required) | Database username |
| `password` | `CS_DATABASE__PASSWORD` | (required) | Database password |
| `connection_timeout` | `CS_DATABASE__CONNECTION_TIMEOUT` | none | Milliseconds to hold an idle connection open. In production, set this higher than your application's connection pool idle timeout |
| `with_tls_verification` | `CS_DATABASE__WITH_TLS_VERIFICATION` | `false` | Enable TLS verification between Proxy and the database |
| `config_reload_interval` | `CS_DATABASE__CONFIG_RELOAD_INTERVAL` | `60` | Seconds between encrypted index configuration reloads |
| `schema_reload_interval` | `CS_DATABASE__SCHEMA_RELOAD_INTERVAL` | `60` | Seconds between database schema reloads |
[tls] [#tls]
Configure TLS for client-to-proxy connections. Provide either file paths or inline PEM strings.
| Option | Env variable | Description |
| ------------------ | -------------------------- | ------------------------------------------ |
| `certificate_path` | `CS_TLS__CERTIFICATE_PATH` | Path to the public certificate `.crt` file |
| `private_key_path` | `CS_TLS__PRIVATE_KEY_PATH` | Path to the private key file |
| `certificate_pem` | `CS_TLS__CERTIFICATE_PEM` | Public certificate as a PEM string |
| `private_key_pem` | `CS_TLS__PRIVATE_KEY_PEM` | Private key as a PEM string |
[auth] [#auth]
| Option | Env variable | Description |
| ------------------- | ---------------------- | ----------------------------- |
| `workspace_crn` | `CS_WORKSPACE_CRN` | CipherStash workspace CRN |
| `client_access_key` | `CS_CLIENT_ACCESS_KEY` | CipherStash client access key |
[encrypt] [#encrypt]
| Option | Env variable | Description |
| ------------------- | ---------------------- | ------------------------------------------------------------------------------------ |
| `default_keyset_id` | `CS_DEFAULT_KEYSET_ID` | Default keyset. Omit to enable [multitenant operation](https://cipherstash.com/docs/reference/proxy/multitenant) |
| `client_id` | `CS_CLIENT_ID` | CipherStash client ID |
| `client_key` | `CS_CLIENT_KEY` | CipherStash client key |
[log] [#log]
| Option | Env variable | Default | Description |
| ---------------------------------- | ------------------------------------------ | ------------------------------------------------ | ------------------------------------------------------------------------------ |
| `level` | `CS_LOG__LEVEL` | `info` | Global log level. Valid values: `error`, `warn`, `info`, `debug`, `trace` |
| `format` | `CS_LOG__FORMAT` | `pretty` (terminal), `structured` (non-terminal) | Log format. Valid values: `pretty`, `text`, `structured` (JSON) |
| `output` | `CS_LOG__OUTPUT` | `stdout` | Log output destination. Valid values: `stdout`, `stderr` |
| `ansi_enabled` | `CS_LOG__ANSI_ENABLED` | `true` (terminal), `false` (non-terminal) | Enable colored output |
| `slow_statements` | `CS_LOG__SLOW_STATEMENTS` | `false` | Enable slow statement logging |
| `slow_statement_min_duration_ms` | `CS_LOG__SLOW_STATEMENT_MIN_DURATION_MS` | `2000` | Minimum duration in milliseconds for a statement to be considered slow |
| `slow_db_response_min_duration_ms` | `CS_LOG__SLOW_DB_RESPONSE_MIN_DURATION_MS` | `100` | Minimum duration in milliseconds for a database response to be considered slow |
[prometheus] [#prometheus]
| Option | Env variable | Default | Description |
| --------- | ------------------------ | ------- | -------------------------------------- |
| `enabled` | `CS_PROMETHEUS__ENABLED` | `false` | Enable the Prometheus metrics exporter |
| `port` | `CS_PROMETHEUS__PORT` | `9930` | Port for the Prometheus exporter |
Full TOML example [#full-toml-example]
```toml filename="cipherstash-proxy.toml"
[server]
host = "0.0.0.0"
port = "6432"
require_tls = "false"
shutdown_timeout = "2000"
worker_threads = "4"
thread_stack_size = "2097152"
cipher_cache_size = "64"
cipher_cache_ttl_seconds = "3600"
[database]
host = "0.0.0.0"
port = "5432"
name = "database"
username = "username"
password = "password"
connection_timeout = "300000"
with_tls_verification = "false"
config_reload_interval = "60"
schema_reload_interval = "60"
[tls]
certificate_path = "./server.crt"
private_key_path = "./server.key"
[auth]
workspace_crn = "cipherstash-workspace-crn"
client_access_key = "cipherstash-client-access-key"
[encrypt]
default_keyset_id = "cipherstash-keyset-id"
client_id = "cipherstash-client-id"
client_key = "cipherstash-client-key"
[log]
level = "info"
format = "pretty"
output = "stdout"
ansi_enabled = "true"
slow_statements = "false"
slow_statement_min_duration_ms = "2000"
slow_db_response_min_duration_ms = "100"
[prometheus]
enabled = "false"
port = "9930"
```
Development settings [#development-settings]
Defaults are tuned for production. When running Proxy locally, override these for a better development experience. None of these settings are appropriate for production.
Enable colored, human-readable logs:
```bash
CS_LOG__FORMAT="pretty"
CS_LOG__ANSI_ENABLED="true"
```
Reduce reload intervals when iterating on your schema:
```bash
CS_DATABASE__CONFIG_RELOAD_INTERVAL="10"
CS_DATABASE__SCHEMA_RELOAD_INTERVAL="10"
```
Slow query logging [#slow-query-logging]
Slow query logging identifies statements that take longer than expected:
```bash
CS_LOG__SLOW_STATEMENTS="true"
```
By default, any statement taking longer than 2000 ms is flagged. Tune the thresholds to match your latency expectations:
```bash
CS_LOG__SLOW_STATEMENT_MIN_DURATION_MS="500" # statement total time
CS_LOG__SLOW_DB_RESPONSE_MIN_DURATION_MS="200" # database round-trip only
```
When a slow statement is detected, Proxy emits a structured log line at the `SLOW_STATEMENTS` target. With `format = "pretty"`, it looks like:
```
WARN slow_statement duration_ms=620 query="SELECT * FROM users WHERE ..."
```
Use these lines to find queries that need indexes. A query that is unexpectedly slow is usually missing a functional index over the term extractor, or is passing an untyped operand. See [query performance](https://cipherstash.com/docs/reference/eql/indexes).
To isolate slow-statement output in production, set `CS_LOG__SLOW_STATEMENTS_LEVEL=warn` while keeping the global level at `error`.
Docker-specific options [#docker-specific-options]
These environment variables are only available in the Docker container image, not in the binary.
| Env variable | Description |
| ------------------------------------------ | ------------------------------------------------------- |
| `CS_DATABASE__INSTALL_EQL` | Install EQL on container startup |
| `CS_DATABASE__INSTALL_EXAMPLE_SCHEMA` | Load the example schema on container startup |
| `CS_DATABASE__INSTALL_AWS_RDS_CERT_BUNDLE` | Add the AWS RDS certificate bundle for TLS verification |
`CS_DATABASE__INSTALL_EQL` and `CS_DATABASE__INSTALL_EXAMPLE_SCHEMA` are for development use only. Install EQL as a database migration in production.
Per-target log levels [#per-target-log-levels]
Override the log level for specific internal components using the pattern `CS_LOG__{TARGET}_LEVEL`. These accept the same values as `CS_LOG__LEVEL`.
| Env variable | Target | Description |
| ------------------------------- | ----------------- | ------------------------------------------------------ |
| `CS_LOG__DEVELOPMENT_LEVEL` | `DEVELOPMENT` | General development logging |
| `CS_LOG__AUTHENTICATION_LEVEL` | `AUTHENTICATION` | Client authentication and SASL |
| `CS_LOG__CONFIG_LEVEL` | `CONFIG` | Configuration loading |
| `CS_LOG__CONTEXT_LEVEL` | `CONTEXT` | Connection context |
| `CS_LOG__ENCODING_LEVEL` | `ENCODING` | Data encoding and decoding |
| `CS_LOG__ENCRYPT_LEVEL` | `ENCRYPT` | Encryption operations |
| `CS_LOG__DECRYPT_LEVEL` | `DECRYPT` | Decryption operations |
| `CS_LOG__ENCRYPT_CONFIG_LEVEL` | `ENCRYPT_CONFIG` | Encryption configuration loading |
| `CS_LOG__ZEROKMS_LEVEL` | `ZEROKMS` | ZeroKMS cipher initialization, cache, and connectivity |
| `CS_LOG__MIGRATE_LEVEL` | `MIGRATE` | Schema migration |
| `CS_LOG__PROTOCOL_LEVEL` | `PROTOCOL` | PostgreSQL wire protocol |
| `CS_LOG__MAPPER_LEVEL` | `MAPPER` | SQL statement mapping and transformation |
| `CS_LOG__SCHEMA_LEVEL` | `SCHEMA` | Database schema analysis |
| `CS_LOG__SLOW_STATEMENTS_LEVEL` | `SLOW_STATEMENTS` | Slow statement detection |
CLI reference [#cli-reference]
```bash
cipherstash-proxy [OPTIONS] [DBNAME] [COMMAND]
```
Commands [#commands]
| Command | Description |
| --------- | ----------------------------------------------- |
| `encrypt` | Encrypt existing plaintext data in the database |
| `help` | Print help information |
The `encrypt` command encrypts existing plaintext data in place. Follow the safeguards in [Data migration](https://cipherstash.com/docs/guides/migration) before running it against populated production data.
Arguments and options [#arguments-and-options]
| Flag | Default | Description |
| ------------------------------------------- | ------------------------------------------------ | ------------------------------------ |
| `DBNAME` | | Database name (positional, optional) |
| `-H, --db-host ` | `127.0.0.1` | Database host |
| `-u, --db-user ` | `postgres` | Database user |
| `-p, --config-file-path ` | `cipherstash-proxy.toml` | Path to the TOML config file |
| `-l, --log-level ` | `info` | Log level |
| `-f, --log-format ` | `pretty` (terminal), `structured` (non-terminal) | Log format |
Prometheus metrics [#prometheus-metrics]
Enable the exporter with `CS_PROMETHEUS__ENABLED=true`. Metrics are exposed on port `9930` by default.
| Metric | Type | Description |
| --------------------------------------------------------- | --------- | ----------------------------------------------------------------- |
| `cipherstash_proxy_keyset_cipher_cache_hits_total` | Counter | Keyset-scoped cipher cache hits |
| `cipherstash_proxy_keyset_cipher_cache_miss_total` | Counter | Cipher cache misses requiring initialization |
| `cipherstash_proxy_keyset_cipher_init_total` | Counter | New keyset-scoped cipher initializations |
| `cipherstash_proxy_keyset_cipher_init_duration_seconds` | Histogram | Duration of cipher initialization, including ZeroKMS network call |
| `cipherstash_proxy_clients_active_connections` | Gauge | Current active client connections |
| `cipherstash_proxy_clients_bytes_received_total` | Counter | Bytes received from clients |
| `cipherstash_proxy_clients_bytes_sent_total` | Counter | Bytes sent to clients |
| `cipherstash_proxy_decrypted_values_total` | Counter | Individual values decrypted |
| `cipherstash_proxy_decryption_duration_seconds` | Histogram | Time spent performing decryption |
| `cipherstash_proxy_decryption_duration_seconds_count` | Counter | Number of decryption timing observations |
| `cipherstash_proxy_decryption_duration_seconds_sum` | Counter | Total cumulative decryption time |
| `cipherstash_proxy_decryption_error_total` | Counter | Unsuccessful decryption operations |
| `cipherstash_proxy_decryption_requests_total` | Counter | ZeroKMS decrypt requests |
| `cipherstash_proxy_encrypted_values_total` | Counter | Individual values encrypted |
| `cipherstash_proxy_encryption_duration_seconds` | Histogram | Time spent performing encryption |
| `cipherstash_proxy_encryption_duration_seconds_count` | Counter | Number of encryption timing observations |
| `cipherstash_proxy_encryption_duration_seconds_sum` | Counter | Total cumulative encryption time |
| `cipherstash_proxy_encryption_error_total` | Counter | Unsuccessful encryption operations |
| `cipherstash_proxy_encryption_requests_total` | Counter | ZeroKMS encrypt requests |
| `cipherstash_proxy_rows_encrypted_total` | Counter | Encrypted rows returned to clients |
| `cipherstash_proxy_rows_passthrough_total` | Counter | Non-encrypted rows returned to clients |
| `cipherstash_proxy_rows_total` | Counter | Total rows returned to clients |
| `cipherstash_proxy_server_bytes_received_total` | Counter | Bytes received from the PostgreSQL server |
| `cipherstash_proxy_server_bytes_sent_total` | Counter | Bytes sent to the PostgreSQL server |
| `cipherstash_proxy_statements_execution_duration_seconds` | Histogram | Database SQL execution time |
| `cipherstash_proxy_statements_session_duration_seconds` | Histogram | Total statement processing time (encrypt, execute, decrypt) |
| `cipherstash_proxy_statements_encrypted_total` | Counter | Statements requiring encryption |
| `cipherstash_proxy_statements_passthrough_total` | Counter | Statements not requiring encryption |
| `cipherstash_proxy_statements_total` | Counter | Total statements processed |
| `cipherstash_proxy_statements_unmappable_total` | Counter | Statements that could not be mapped |
Reloading configuration [#reloading-configuration]
When Proxy receives a `SIGHUP`, it reloads application-level configuration (`database`, `auth`, `encrypt`, `log`, `prometheus`, `development`) without disrupting active connections.
Network settings require a full restart: `server.host`, `server.port`, `server.require_tls`, `server.worker_threads`, and any `tls` configuration.
Supported architectures [#supported-architectures]
CipherStash Proxy is available as a Docker container image for `linux/arm64`.
# Errors
Source: https://cipherstash.com/docs/reference/proxy/errors
Errors CipherStash Proxy can return, grouped by category, with steps to diagnose and resolve each one.
Authentication errors [#authentication-errors]
Database authentication failed [#database-authentication-failed]
**Error:** `Database authentication failed. Check username and password`
Proxy could not authenticate with the upstream PostgreSQL database.
1. Check that the configured username and password are correct and can connect to the database.
2. Check that the database uses a supported authentication method: `password`, `md5`, or `scram-sha-256`. See [PostgreSQL password authentication](https://www.postgresql.org/docs/17/auth-password.html).
Client authentication failed [#client-authentication-failed]
**Error:** `Client authentication failed. Check username and password.`
Proxy rejected the client connection because the credentials were incorrect. Check that the username and password your application sends match the values configured in Proxy.
ZeroKMS authentication failed [#zerokms-authentication-failed]
**Error:** `ZeroKMS authentication failed. Check the configured credentials.`
Proxy could not authenticate with ZeroKMS.
1. Check that the configured `client` credentials are correct.
2. Check that the active `keyset_name` or `keyset_id` is associated with a keyset in the configured workspace.
Mapping errors [#mapping-errors]
Invalid parameter [#invalid-parameter]
**Error:** `Invalid parameter for column 'column_name' of type 'cast' in table 'table_name'. (OID 'oid')`
Each encrypted column has a target type. When encrypting a parameter or literal, Proxy decodes and casts the data into that type. This error means the data cannot be decoded and cast to the expected type.
Some parameter types are converted automatically. For example, PostgreSQL `INT2`, `INT4`, and `INT8` are converted to the corresponding encrypted integer types.
Check that the parameter or literal matches the type of the encrypted column. See [core concepts](https://cipherstash.com/docs/reference/eql/core-concepts) for the variant model.
Invalid SQL statement [#invalid-sql-statement]
**Error:** `sql parser error: Expected: SELECT, VALUES, or a subquery in the query body` (varies)
Proxy could not parse the SQL statement. Check that the statement is valid PostgreSQL. If the statement is correct and the parser is wrong, contact [CipherStash support](https://cipherstash.com/support).
Unsupported parameter type [#unsupported-parameter-type]
**Error:** `Encryption of PostgreSQL {name} (OID {oid}) types is not currently supported.`
The parameter's data type is not supported for encryption. See the [EQL type reference](https://cipherstash.com/docs/reference/eql/core-concepts) for the supported types.
Statement could not be type checked [#statement-could-not-be-type-checked]
**Error:** `Statement could not be type checked: '{type-check-error-message}'`
Proxy checks SQL statements against the database schema in order to transparently encrypt and decrypt data. The behaviour when a type check fails depends on the `mapping_errors_enabled` configuration:
* When `mapping_errors_enabled` is `false` (default), the error is logged and the statement passes through to the database.
* When `mapping_errors_enabled` is `true`, the error is raised and statement execution halts.
The default passes statements through because most production systems have a small number of encrypted columns, and blocking on false negatives causes more harm. A statement that passes through unmapped cannot silently write plaintext: the encrypted column's domain `CHECK` rejects any payload missing its required index terms, so the write fails with a PostgreSQL type error instead. See [core concepts](https://cipherstash.com/docs/reference/eql/core-concepts).
Check that you are running the latest version of Proxy, and contact [CipherStash support](https://cipherstash.com/support) if the error persists.
Internal mapper error [#internal-mapper-error]
**Error:** `Statement encountered an internal error. This may be a bug in the statement mapping module of CipherStash Proxy.`
An unexpected error occurred in the statement mapping module. Update to the latest version, and contact [CipherStash support](https://cipherstash.com/support) if the error persists.
Encrypt errors [#encrypt-errors]
Column could not be encrypted [#column-could-not-be-encrypted]
**Error:** `Column 'column_name' in table 'table_name' could not be encrypted.`
Proxy uses ZeroKMS for encryption operations. The most likely cause is a network issue reaching the service.
1. Check that ZeroKMS is available on the [status page](https://status.cipherstash.com/).
2. Check that Proxy has network access to ZeroKMS in the appropriate region.
3. Check that the column's encrypted type matches the data being written.
KeysetId could not be parsed [#keysetid-could-not-be-parsed]
**Error:** `KeysetId '{id}' could not be parsed using 'SET CIPHERSTASH.KEYSET_ID'. KeysetId should be a valid UUID.`
The value passed to `SET CIPHERSTASH.KEYSET_ID` is not a valid UUID. The correct syntax is:
```sql
SET [SESSION] CIPHERSTASH.KEYSET_ID { TO | = } '{KeysetId}'
```
KeysetId could not be set [#keysetid-could-not-be-set]
**Error:** `Keyset Id could not be set using 'SET CIPHERSTASH.KEYSET_ID'`
1. Check the syntax: the `keyset_id` value must be in single quotes.
2. Check that the `keyset_id` is a valid UUID.
3. Check that the value is a literal. PostgreSQL `SET` does not support parameterised queries.
KeysetName could not be set [#keysetname-could-not-be-set]
**Error:** `Keyset Name could not be set using 'SET CIPHERSTASH.KEYSET_NAME'`
1. Check the syntax: the `keyset_name` value must be in single quotes.
2. Check that the value is a literal. PostgreSQL `SET` does not support parameterised queries.
Unknown keyset identifier [#unknown-keyset-identifier]
**Error:** `Unknown keyset name or id '{keyset}'`
Proxy could not find a keyset matching the name or ID.
1. Check that the active `keyset_name` or `keyset_id` is associated with a keyset in the configured workspace.
2. Check that the configured `client` has been granted access to the keyset in the Dashboard.
3. Keyset names are case-sensitive. Check for an exact match.
4. Check that the configured `client` credentials are correct.
Could not decrypt data for keyset [#could-not-decrypt-data-for-keyset]
**Error:** `Could not decrypt data for keyset '{keyset_id}'`
The active `keyset_id` does not match the `keyset_id` of the data being decrypted. Each encrypted record belongs to a keyset with a unique identifier, and Proxy encrypts data using the currently active keyset. If the record's keyset does not match the active one, the data cannot be decrypted.
1. Check that the `keyset_id` in the configuration matches the `keyset_id` of the encrypted records.
2. If using `SET CIPHERSTASH.KEYSET_ID`, check that the value matches the encrypted records.
3. Check that the configured `client` has been granted access to the `keyset_id`.
See [multitenant operation](https://cipherstash.com/docs/reference/proxy/multitenant) for per-connection keyset scoping.
Plaintext could not be encoded [#plaintext-could-not-be-encoded]
**Error:** `Decrypted column could not be encoded as the expected type.`
When Proxy decrypts data, it casts and encodes the result as the PostgreSQL representation of the column's type. Changing an encrypted column's type after data has been written can cause this error.
1. Check that the column has the correct encrypted type.
2. Check that the column type has not changed since the data was written.
Unknown column [#unknown-column]
**Error:** `Column 'column_name' in table 'table_name' has no Encrypt configuration`
Proxy has no encrypted-column mapping for this column. In EQL v3 a column's searchable capability is fixed by the [domain variant](https://cipherstash.com/docs/reference/eql/core-concepts) it is typed as, so a column Proxy cannot map is usually one that was never given an EQL type:
```sql
ALTER TABLE users ALTER COLUMN email TYPE public.eql_v3_text_eq;
```
Proxy reloads the database schema on the interval set by `CS_DATABASE__SCHEMA_RELOAD_INTERVAL` (60 seconds by default), so a newly typed column may take up to that long to become mappable.
Unknown table [#unknown-table]
**Error:** `Table 'table_name' has no Encrypt configuration`
The table has no columns Proxy recognises as encrypted. Type at least one column with an EQL domain variant, as above.
Unknown index term [#unknown-index-term]
**Error:** `Unknown Index Term for column '{column_name}' in table '{table_name}'.`
The encrypted column carries an index term Proxy does not recognise. EQL validates payloads against the column's domain `CHECK`, but direct database writes can bypass the encryption client and store a malformed payload.
Check the column's type and the payload's term keys against [core concepts](https://cipherstash.com/docs/reference/eql/core-concepts).
Column configuration mismatch [#column-configuration-mismatch]
**Error:** `Column configuration for column '{column_name}' in table '{table_name}' does not match the encrypted column.`
Proxy validates that encrypted columns match their expected type before decrypting. This check prevents confused deputy attacks and should not appear during normal operation. Contact [CipherStash support](https://cipherstash.com/support) if it persists.
Decrypt errors [#decrypt-errors]
Column could not be deserialised [#column-could-not-be-deserialised]
**Error:** `Column 'column_name' in table 'table_name' could not be deserialised.`
Proxy stores encrypted data and search terms as `jsonb`. This error indicates an internal issue deserialising and extracting the ciphertext for decryption. It can occur if the encrypted data has been altered by another process.
Check that the data in the encrypted column is a well-formed EQL payload. See [payload anatomy](https://cipherstash.com/docs/reference/eql/core-concepts). Contact [CipherStash support](https://cipherstash.com/support) if the error persists.
Configuration errors [#configuration-errors]
Missing or invalid TLS configuration [#missing-or-invalid-tls-configuration]
**Errors:**
```
Invalid Transport Layer Security (TLS) certificate.
Invalid Transport Layer Security (TLS) private key.
Missing Transport Layer Security (TLS) certificate at path: {path}.
Missing Transport Layer Security (TLS) private key at path: {path}.
```
For path-based configuration, check that the certificate and key exist at the specified paths and are valid. For PEM-based configuration, check that the certificate and key values are valid. See [TLS configuration](https://cipherstash.com/docs/reference/proxy/configuration).
Network configuration change requires restart [#network-configuration-change-requires-restart]
**Error:** `Network configuration change requires restart`
When Proxy receives a `SIGHUP`, it reloads application-level configuration without disrupting active connections. These network settings require a full restart:
* `server.host`
* `server.port`
* `server.require_tls`
* `server.worker_threads`
* `tls` (any TLS configuration)
Stop Proxy, update the configuration, then restart.
# Proxy
Source: https://cipherstash.com/docs/reference/proxy
CipherStash Proxy sits between your application and PostgreSQL, encrypting query parameters on the way in and decrypting results on the way out. Your application connects to Proxy exactly as it connects to PostgreSQL, so adopting encryption needs no application changes.
Proxy speaks the PostgreSQL wire protocol (it is based on [pgcat](https://github.com/pgcat/pgcat)) and is distributed as a [container image](https://hub.docker.com/r/cipherstash/proxy) on Docker Hub. It is an [EQL](https://cipherstash.com/docs/reference/eql) client: it produces the encrypted payloads EQL stores, and types the bound parameters EQL's operators resolve against.
In this section [#in-this-section]
* [Configuration](https://cipherstash.com/docs/reference/proxy/configuration) covers installation, the TOML and environment-variable options, logging, Prometheus metrics, and the CLI.
* [Message flow](https://cipherstash.com/docs/reference/proxy/message-flow) explains how Proxy intercepts the extended query protocol, for debugging unmappable statements.
* [Multitenant operation](https://cipherstash.com/docs/reference/proxy/multitenant) covers per-connection keyset scoping and encrypted mapping.
* [Errors](https://cipherstash.com/docs/reference/proxy/errors) lists the errors Proxy returns, with causes and remediation.
Related [#related]
* [EQL reference](https://cipherstash.com/docs/reference/eql) for the database-side surface Proxy queries against.
* [Stack SDK](https://cipherstash.com/docs/reference/stack) for the application-level alternative to Proxy.
# Message flow
Source: https://cipherstash.com/docs/reference/proxy/message-flow
This page explains the internal message handling flow, for advanced users debugging unmappable statements or unexpected Proxy behaviour. CipherStash Proxy sits between your application and PostgreSQL and intercepts the PostgreSQL extended query protocol. It encrypts parameters before they reach the database and decrypts values before they reach your application.
Extended query protocol overview [#extended-query-protocol-overview]
The PostgreSQL extended query protocol uses a sequence of messages to execute parameterised queries. The two most relevant messages for encryption are:
* **Parse**: the client sends a SQL statement with parameter placeholders (`$1`, `$2`, and so on). Proxy inspects the statement and maps column references to their encrypted column types.
* **Bind**: the client sends parameter values to bind to a prepared statement. If Proxy recognised the statement during Parse, it encrypts the parameters here before forwarding them.
Binding a parameter is also what types it. EQL's encrypted operators only resolve against a typed operand, so the Bind step is what makes an index-backed query possible. See [typed operands](https://cipherstash.com/docs/reference/eql/core-concepts) for why.
Parse flow [#parse-flow]
When Proxy receives a Parse message, it determines whether the SQL statement references encrypted columns.
1. Proxy checks whether the statement is encryptable, that is, whether it references at least one encrypted column.
2. If it is encryptable, Proxy maps the column references to their encrypted column types.
3. If the statement includes literal parameter values, Proxy rewrites them as encrypted values immediately.
4. Proxy adds the statement and its column mapping to the connection context for use during Bind.
5. Proxy forwards the (possibly rewritten) Parse message to PostgreSQL.
If the statement is not encryptable, Proxy forwards it unchanged.
Bind flow [#bind-flow]
When Proxy receives a Bind message, it looks up the corresponding statement in the connection context.
1. Proxy checks whether the statement that this Bind message references is in the context, that is, whether it was processed during Parse.
2. If it is, Proxy encrypts each parameter value according to the column mapping recorded during Parse.
3. Proxy rewrites the parameter values in the Bind message with the encrypted payloads.
4. Proxy creates a portal for the bound statement and adds it to the context.
5. Proxy forwards the rewritten Bind message to PostgreSQL.
If the statement is not in context, Proxy creates a portal without encryption and forwards it unchanged.
Pipelining [#pipelining]
PostgreSQL supports pipelining: the client can send multiple messages without waiting for responses. Proxy must track Describe and Execute messages to correlate server responses with the right statements or portals, since responses arrive in order but may interleave.
```
Sequential Pipelined
| Client | Server | | Client | Server |
|----------------|-----------------| |----------------|-----------------|
| send query 1 | | | send query 1 | |
| | process query 1 | | send query 2 | process query 1 |
| receive rows 1 | | | send query 3 | process query 2 |
| send query 2 | | | receive rows 1 | process query 3 |
| | process query 2 | | receive rows 2 | |
| receive rows 2 | | | receive rows 3 | |
```
The PostgreSQL server always processes queries in sequential order, even when pipelined. Proxy preserves this ordering when encrypting parameters and decrypting results.
Unmappable statements [#unmappable-statements]
Some statements cannot be mapped to an encrypted column. This happens when:
* The statement uses a function or expression that obscures the column reference, for example `CAST(email AS text)`.
* The column is referenced through a view, subquery, or CTE that Proxy cannot resolve.
* The statement uses a SQL feature Proxy does not yet parse, for example certain `COPY` forms.
When a statement is unmappable, Proxy forwards it to PostgreSQL unmodified. No encryption or decryption occurs. The `cipherstash_proxy_statements_unmappable_total` Prometheus metric tracks how often this happens. Set `CS_LOG__MAPPER_LEVEL=debug` to see which statements are unmappable and why.
An unmappable `SELECT` returns the raw encrypted payload rather than plaintext. An unmappable `INSERT` or `UPDATE` fails the encrypted column's domain `CHECK` rather than writing plaintext, so a mapping failure never silently stores unencrypted data.
Related [#related]
* [Proxy configuration](https://cipherstash.com/docs/reference/proxy/configuration) for `CS_LOG__MAPPER_LEVEL` and the Prometheus metrics.
* [Proxy errors](https://cipherstash.com/docs/reference/proxy/errors) for the errors raised when mapping or type checking fails.
* [EQL core concepts](https://cipherstash.com/docs/reference/eql/core-concepts) for the typed-operand rule and the domain `CHECK`.
# Multitenant operation
Source: https://cipherstash.com/docs/reference/proxy/multitenant
CipherStash Proxy supports multitenant applications using ZeroKMS keysets, giving strong cryptographic separation between tenants.
Each tenant is associated with a keyset, and data is protected by separate encryption keys. Scope a Proxy connection to a specific keyset at runtime with the `SET CIPHERSTASH.KEYSET` commands. Once a keyset is set for a connection, all subsequent operations are scoped to it, and data can only be decrypted by the keyset that encrypted it.
A keyset `name` is unique to a workspace and functions as an alias, so you can associate a keyset with an arbitrary identifier such as an internal `TenantId`.
Proxy must be configured **without** a `CS_DEFAULT_KEYSET_ID` to enable multitenant operation. If a default keyset is configured, the `SET CIPHERSTASH.KEYSET` commands return an error.
Keyset commands [#keyset-commands]
SET CIPHERSTASH.KEYSET_ID [#set-cipherstashkeyset_id]
Sets the active keyset for the current connection using a keyset UUID.
```sql
SET CIPHERSTASH.KEYSET_ID = '2cace9db-3a2a-4b46-a184-ba412b3e0730';
```
SET CIPHERSTASH.KEYSET_NAME [#set-cipherstashkeyset_name]
Sets the active keyset for the current connection using a keyset name.
```sql
SET CIPHERSTASH.KEYSET_NAME = 'tenant-1';
```
Usage notes [#usage-notes]
* Execute `SET CIPHERSTASH.KEYSET` before performing any encryption operations.
* The keyset remains active for the duration of the connection, or until a subsequent `SET CIPHERSTASH.KEYSET` command.
* The active keyset is connection-scoped and does not affect other connections.
* Both commands take a literal value in single quotes. PostgreSQL `SET` does not support parameterised queries.
Do not use `SET CIPHERSTASH.KEYSET_ID` or `SET CIPHERSTASH.KEYSET_NAME` behind a transaction-mode connection pooler that sits in front of Proxy. The keyset belongs to the Proxy connection, not to your transaction. The pooler can run a later transaction on a Proxy connection with a different keyset, which encrypts or decrypts with the wrong tenant's keys. Run the pooler behind Proxy, or use session mode. See [connection poolers](#connection-poolers).
Joining encrypted columns across two keysets does not work, because equality is only meaningful within a keyset. See [joins](https://cipherstash.com/docs/reference/eql/joins) for the same-keyset constraint.
Connection poolers [#connection-poolers]
Proxy holds keyset, prepared statement, and mapping state for each client connection. Where you place a pooler decides whether that state stays consistent.
* **Pooler behind Proxy.** App, then Proxy, then pooler, then Postgres. Proxy sees one stable connection per client, so keyset state holds. Use PgBouncer 1.21 or later with `max_prepared_statements` set so prepared statements survive pooling.
* **Pooler in front of Proxy.** Use session mode. In transaction mode, a client's `SET CIPHERSTASH.KEYSET_*`, `SET CIPHERSTASH.UNSAFE_DISABLE_MAPPING`, and prepared statements can land on another client's Proxy connection. A statement prepared on one Proxy connection and executed on another can return undecrypted results.
Transaction-mode pooling in front of Proxy is untested. A table of supported topologies is coming (CIP-4167).
Disabling encrypted mapping [#disabling-encrypted-mapping]
CipherStash Proxy transforms the plaintext SQL statements your application issues into statements on encrypted columns. This process is called encrypted mapping.
In some circumstances you may need to disable encrypted mapping for one or more SQL statements, for example when performing a data transformation with complex logic directly in the database using `plpgsql`.
Use `SET` to change the `CIPHERSTASH.UNSAFE_DISABLE_MAPPING` configuration parameter. It is always scoped to the connection session.
```sql
SET CIPHERSTASH.UNSAFE_DISABLE_MAPPING = true; -- disable
SET CIPHERSTASH.UNSAFE_DISABLE_MAPPING = false; -- re-enable
```
If mapping is disabled, sensitive data may not be encrypted and may appear in logs.
Proxy and EQL together give some protection against reading or writing plaintext in encrypted columns. An unmapped `SELECT` returns the encrypted payload rather than plaintext. An unmapped `INSERT` or `UPDATE` fails the encrypted column's domain `CHECK` with a PostgreSQL type error, because every EQL domain variant requires its index terms to be present in the payload. See [core concepts](https://cipherstash.com/docs/reference/eql/core-concepts) for the variant model.
Prepared statements and mapping [#prepared-statements-and-mapping]
CipherStash Proxy only decrypts data from SQL statements it has explicitly checked and mapped.
If mapping is disabled, any subsequent `PREPARE` skips the mapping process. If mapping is re-enabled later, data returned from those prepared statements is still not decrypted.
To restore mapping, encryption, and decryption of prepared statements, either open a new connection or prepare the statement again after re-enabling mapping.
This behaviour is expected. When a client prepares a statement, it sends the SQL in a `parse` message. Once prepared, the client refers to the statement by name and skips the `parse` step. If mapping was disabled during `parse`, Proxy never mapped the statement, so data returned from subsequent executions is never decrypted. See [message flow](https://cipherstash.com/docs/reference/proxy/message-flow).
Related [#related]
* [Key management](https://cipherstash.com/docs/concepts/key-management#keysets-define-the-isolation-boundary) for the cryptographic isolation model.
* [Proxy configuration](https://cipherstash.com/docs/reference/proxy/configuration) for `CS_DEFAULT_KEYSET_ID`.
# Supabase Auth
Source: https://cipherstash.com/docs/integrations/supabase/auth
Supabase Auth already knows who your user is. This page connects that identity to CipherStash in two layers you can adopt independently:
1. **Federation** — exchange the user's Supabase session for a CipherStash token, so every encryption and decryption request authenticates *as that user* instead of as a shared service credential. This is the foundation.
2. **Identity-bound encryption (lock context)** — an optional layer on top of federation that binds a value to the user's identity claim, so only that user can decrypt it — enforced by ZeroKMS, not by your application code.
Federation is useful on its own. Lock context requires it. Start with federation; add lock context where per-user secrecy matters.
Register Supabase as an OIDC provider [#register-supabase-as-an-oidc-provider]
CipherStash needs to trust your Supabase project as an OIDC issuer before it will accept a Supabase session token. Add the provider once, in the CipherStash dashboard at [dashboard.cipherstash.com/workspaces/\_/oidc-providers](https://dashboard.cipherstash.com/workspaces/_/oidc-providers) (the `_` resolves to whichever workspace you select). A Supabase project's issuer is:
```
https://.supabase.co/auth/v1
```
> **Good to know**: the [CipherStash dashboard](https://dashboard.cipherstash.com) can register this for you in one click while it is connected to your Supabase project over OAuth. Manual OIDC configuration is covered in the [auth reference](https://cipherstash.com/docs/reference/auth).
Federate the Supabase session [#federate-the-supabase-session]
Authenticate the `Encryption` client with an `OidcFederationStrategy`. It takes your workspace CRN and a `getJwt` callback that returns the user's **current** Supabase access token — the strategy calls it on first use and again on every re-federation, so return a fresh token each time rather than capturing one:
```typescript title="lib/db.ts"
import { createClient } from "@supabase/supabase-js"
import { OidcFederationStrategy } from "@cipherstash/stack"
import { encryptedSupabase } from "@cipherstash/stack-supabase"
const supabaseClient = createClient(
process.env.SUPABASE_URL!,
process.env.SUPABASE_ANON_KEY!,
)
// Return the current Supabase session token — re-invoked on every re-federation.
const getJwt = async () => {
const { data: { session } } = await supabaseClient.auth.getSession()
if (!session) throw new Error("No active Supabase session")
return session.access_token
}
const federation = OidcFederationStrategy.create(
process.env.CS_WORKSPACE_CRN!,
getJwt,
)
if (federation.failure) throw new Error(federation.failure.error.message)
export const db = await encryptedSupabase(supabaseClient, {
config: {
authStrategy: federation.data,
},
})
```
That's the whole integration. Every `db.from(...)` query now encrypts and decrypts under the signed-in user's identity, and your Supabase Auth session and RLS policies apply to the underlying request exactly as before.
Run the federation strategy **server-side only**: a Next.js Route Handler or Server Action, or an Edge Function. Never in the browser, where it would expose the session token. For the Edge runtime, see [Edge Functions](https://cipherstash.com/docs/integrations/supabase/edge-functions).
The federation endpoint issues no refresh token. When the CipherStash token expires, the strategy re-federates by calling `getJwt` again, and because `getJwt` reads from `supabaseClient.auth.getSession()`, supabase-js's own token refresh keeps it valid.
Identity-bound encryption (lock context) [#identity-bound-encryption-lock-context]
Federation authenticates *as* the user. **Lock context** goes further: it bakes a claim from the user's JWT (by default `sub`, which for Supabase Auth is the user's UUID) into the data key, so a value can only be decrypted by presenting the same identity. Even your own backend — holding valid workspace credentials — cannot decrypt another user's locked values.
Lock context requires the client to be authenticated with `OidcFederationStrategy` (above). It cannot be used with `AccessKeyStrategy`, which authenticates a *service*, not a user — there is no user `sub` claim to bind to. Lock context also requires a Business or Enterprise workspace plan.
Attach a lock context to any [`encryptedSupabase`](https://cipherstash.com/docs/integrations/supabase/api-reference) query with `.withLockContext()`. `sub` is the Supabase user's UUID:
```typescript
import { db } from "./lib/db"
const lockContext = { identityClaim: ["sub"] }
// Insert — the value is bound to the signed-in user's `sub` claim
await db.from("patients")
.insert({ email: "alice@example.com", name: "Alice Chen" })
.withLockContext(lockContext)
// Read — the same user must be authenticated
const { data } = await db.from("patients")
.select("id, email, name")
.eq("email", "alice@example.com")
.withLockContext(lockContext)
```
The query builder accepts either the plain `{ identityClaim: ["sub"] }` shape shown above or a `LockContext` instance. The plain shape is sufficient for new code.
ZeroKMS resolves the claim's *value* from the token that authenticated the request — the federated Supabase identity — so no separate identify step or per-operation token is needed. Reading a locked value without a matching context, or as a different user, fails with an encryption error regardless of what RLS allows.
Earlier releases used `new LockContext().identify(jwt)` to fetch a per-operation token. `identify()` and `getLockContext()` are **deprecated** — per-operation CTS tokens were removed in protect-ffi 0.25. The `LockContext` constructor itself is not deprecated. Authenticate the client with `OidcFederationStrategy` and pass the context straight to `.withLockContext()`, as above.
When to lock a column to a user [#when-to-lock-a-column-to-a-user]
* **Per-user data** (a user's own medical history, messages, documents): lock to `sub`. The row is useless to anyone but its owner — including operators with database access and your own service role.
* **Shared / tenant data** (a support queue, org-wide records): don't lock it, or you'll be unable to decrypt it outside a user session. Federation alone still authenticates access as the user; RLS scopes which rows they see.
* **Server-side jobs** that must read locked data need the owning user's session — by design. If a background job must read a field, that field shouldn't be identity-locked.
Federation and lock context errors [#federation-and-lock-context-errors]
Both federation and lock context surface failures as values, not throws.
| Scenario | What you see |
| ------------------------------------------ | -------------------------------------------------------------------------------------------------- |
| Provider not registered with the workspace | Federation fails — register the Supabase OIDC issuer first |
| Expired or invalid Supabase session | `getJwt` throws / returns no session; federation cannot proceed |
| CipherStash token expired mid-request | Strategy re-federates automatically via `getJwt` |
| Decrypting another user's locked value | `encryptionError` on the [query response](https://cipherstash.com/docs/integrations/supabase/supabase-js#responses-and-errors) |
The strategy's own factory and token errors follow the `@cipherstash/auth` `Result` shape (`failure.type`); see the [auth reference](https://cipherstash.com/docs/reference/auth).
Where to next [#where-to-next]
The concept: federation, lock contexts, and what identity binding proves.
Run the federation strategy server-side in Supabase Edge Functions.
`.withLockContext()` and `.audit()` on the query builder.
OIDC providers, federation strategies, and access keys.
# Edge Functions
Source: https://cipherstash.com/docs/integrations/supabase/edge-functions
Encryption and decryption must run somewhere your keys and credentials are safe — never in the browser. Supabase Edge Functions are that place: server-side compute next to your database. CipherStash ships a **WebAssembly build** of the SDK for exactly this runtime, so the same encrypt/decrypt code runs in Deno with no native bindings.
Why the wasm build [#why-the-wasm-build]
Supabase Edge Functions run on Deno, which loads npm packages through the `node` compatibility layer. The SDK's default entry resolves to native NAPI bindings that don't exist in that runtime, so the edge uses a dedicated entry: `@cipherstash/stack/wasm-inline`. It embeds the WebAssembly module as base64 inside the JS bundle — no separate `.wasm` fetch, no bundler plugins, no `static_files` config. The same applies to the auth package (`@cipherstash/auth/wasm-inline`).
Set up the function [#set-up-the-function]
Map the `wasm-inline` entries in your function's `deno.json`:
```jsonc title="supabase/functions/encrypt/deno.json"
{
"imports": {
"@cipherstash/stack/wasm-inline": "npm:@cipherstash/stack@^1.0.0/wasm-inline",
"@cipherstash/auth/wasm-inline": "npm:@cipherstash/auth@^0.42/wasm-inline",
"@cipherstash/auth/cookies": "npm:@cipherstash/auth@^0.42/cookies"
}
}
```
**The developer profile is not supported in Edge Functions.** `stash auth login` creates a profile for the native Node.js SDK on your development machine. An Edge Function runs the WebAssembly client inside an isolated Deno runtime, where that profile and automatic credential discovery are unavailable.
Provide the four `CS_*` values explicitly through an env file when serving locally and through Supabase secrets when deployed.
For an Edge Function, use the CLI or Dashboard option; the developer profile cannot cross into the Deno runtime. To create a dedicated local credential set and write it directly to the function's env file:
```bash example-id="supabase-edge-stash-env"
npx stash env --name edge-dev --write ./supabase/functions/.env.local
```
Never commit this file. Each successful `stash env` run creates a new credential with a unique name, and the access key cannot be shown again.
Then serve the function against that file:
```bash
supabase functions serve --env-file ./supabase/functions/.env.local
```
For deployed functions, add the same four values as [Edge Function secrets](https://supabase.com/dashboard/project/_/settings/functions). Use a separate credential set for production rather than copying the local values.
Encrypt and decrypt in a function [#encrypt-and-decrypt-in-a-function]
Each invocation builds a fresh client, but the CipherStash service token is cached in an HTTP-only cookie via `cookieStore`, so only the first request per session pays the full round-trip to CipherStash:
```typescript title="supabase/functions/encrypt/index.ts"
import { Encryption, AccessKeyStrategy, encryptedTable, encryptedColumn } from "@cipherstash/stack/wasm-inline"
import { cookieStore } from "@cipherstash/auth/cookies"
const patients = encryptedTable("patients", {
email: encryptedColumn("email").equality(),
})
Deno.serve(async (req) => {
const responseHeaders = new Headers({ "content-type": "application/json" })
// Cache the CipherStash token across invocations in an HTTP-only cookie
const authStrategy = AccessKeyStrategy.create(
Deno.env.get("CS_WORKSPACE_CRN")!,
Deno.env.get("CS_CLIENT_ACCESS_KEY")!,
{ store: cookieStore({ request: req, responseHeaders }) },
)
if (authStrategy.failure) {
return Response.json({ error: authStrategy.failure.type }, { status: 500, headers: responseHeaders })
}
const client = await Encryption({
schemas: [patients],
config: {
authStrategy: authStrategy.data,
clientId: Deno.env.get("CS_CLIENT_ID")!,
clientKey: Deno.env.get("CS_CLIENT_KEY")!,
},
})
const encrypted = await client.encrypt("alice@example.com", { column: patients.email, table: patients })
const decrypted = await client.decrypt(encrypted.data)
return Response.json({ ok: decrypted.data === "alice@example.com" }, { headers: responseHeaders })
})
```
Note the `.failure` / `.data` result shape: on the wasm entry, `AccessKeyStrategy.create` returns a `Result` you unwrap (unlike the Node build, where it returns the strategy directly).
Per-user identity on the edge [#per-user-identity-on-the-edge]
To encrypt as the signed-in Supabase user rather than a service credential, swap `AccessKeyStrategy` for `OidcFederationStrategy` — its `getJwt` callback returns the current Supabase session token. The mechanics and the identity-lock layer are covered in [Supabase Auth](https://cipherstash.com/docs/integrations/supabase/auth); the only edge-specific difference is the `wasm-inline` import and the `Result` unwrap:
```typescript
import { OidcFederationStrategy } from "@cipherstash/stack/wasm-inline"
import { cookieStore } from "@cipherstash/auth/cookies"
const authStrategy = OidcFederationStrategy.create(
Deno.env.get("CS_WORKSPACE_CRN")!,
() => getSupabaseSessionToken(req), // return the current session JWT
{ store: cookieStore({ request: req, responseHeaders }) },
)
```
Caveats of running CipherStash in Edge Functions [#caveats-of-running-cipherstash-in-edge-functions]
* **Cold start.** The first request pays the full path: WebAssembly compile, auth round-trip to CipherStash, and ZeroKMS dataset-key initialization. Subsequent requests reuse the cookie-cached token and only pay for the encrypt/decrypt work.
* **Bundle size.** The inline wasm build is larger than a native binding (the module ships as base64 in the JS). That's the trade for zero runtime config — acceptable for an edge function that boots once per worker.
* **Server-side only.** These credentials and the session token must never reach the browser. Keep this code in the Edge Function.
Where to next [#where-to-next]
Federation and identity-locked encryption — the full identity story.
The standard (Node) setup with the encryptedSupabase wrapper.
The core Encryption client API used here.
# Overview
Source: https://cipherstash.com/docs/integrations/supabase
CipherStash adds searchable, field-level encryption to Supabase. Your application encrypts sensitive values before they reach Postgres, so the database, backups, replication streams, and Supabase dashboard contain ciphertext rather than plaintext.
Unlike ordinary application-level encryption, protected columns remain queryable. Equality filters, range queries, and ordering use the same Supabase query-builder methods as plaintext columns, while CipherStash encrypts query values and decrypts results around each request.
How CipherStash encrypts Supabase data [#how-cipherstash-encrypts-supabase-data]
CipherStash has two parts:
1. [Encrypt Query Language (EQL)](https://cipherstash.com/docs/reference/eql) adds encrypted column types, operators, and functions to your Supabase Postgres database.
2. [`encryptedSupabase`](https://cipherstash.com/docs/integrations/supabase/api-reference) wraps the Supabase JavaScript client and performs encryption and decryption in your application.
The EQL type assigned to a column declares what can be queried. For example, an equality column supports `.eq()` and `.in()`, while an ordered column also supports ranges and `.order()`. Choose only the capabilities you need, because searchable encryption has defined leakage characteristics. See [EQL core concepts](https://cipherstash.com/docs/reference/eql/core-concepts) for the complete model.
With EQL 3.0.4, the Supabase wrapper supports encrypted equality, range, and ordering queries. Encrypted free-text and JSON queries require an adapter such as Drizzle or Prisma ORM 8 because PostgREST cannot express the typed operands those operations require. The [supabase-js guide](https://cipherstash.com/docs/integrations/supabase/supabase-js#free-text-and-encrypted-json-queries) documents the limitation.
Choose your path [#choose-your-path]
| What you want to do | Start here |
| -------------------------------------------- | ------------------------------------------------------------------------- |
| Encrypt and query your first Supabase column | [Supabase Quickstart](https://cipherstash.com/docs/integrations/supabase/quickstart) |
| Use the Supabase JavaScript client | [supabase-js guide](https://cipherstash.com/docs/integrations/supabase/supabase-js) |
| Look up the complete wrapper API | [`encryptedSupabase` API reference](https://cipherstash.com/docs/integrations/supabase/api-reference) |
| Bind decryption to the signed-in user | [Supabase Auth](https://cipherstash.com/docs/integrations/supabase/auth) |
| Encrypt inside Supabase Edge Functions | [Edge Functions](https://cipherstash.com/docs/integrations/supabase/edge-functions) |
| Choose local or deployment credentials | [Workspace credentials](https://cipherstash.com/docs/reference/workspace/configuration#credentials) |
| Use an ORM against Supabase Postgres | [Drizzle](https://cipherstash.com/docs/integrations/drizzle) or [Prisma ORM 8](https://cipherstash.com/docs/integrations/prisma) |
| Encrypt columns that already contain data | [Data migration](https://cipherstash.com/docs/guides/migration) |
| Plan a production rollout or rollback | [Deployment guide](https://cipherstash.com/docs/guides/deployment) |
Supabase, Drizzle, and Prisma [#supabase-drizzle-and-prisma]
Supabase is Postgres, so you are not limited to PostgREST or `supabase-js`. CipherStash's [Drizzle](https://cipherstash.com/docs/integrations/drizzle) and [Prisma ORM 8](https://cipherstash.com/docs/integrations/prisma) integrations can read and write the same EQL columns through a direct database connection. They produce the same ciphertext, so an application can use more than one adapter without re-encrypting its data.
Use `encryptedSupabase` when you want Supabase's query builder and automatic propagation of the caller's JWT. Use an ORM when it better fits your application or when you need encrypted free-text or JSON queries. A privileged direct database connection may bypass Row Level Security, so preserve tenant or user scoping in the connection role or ORM query.
Row Level Security and indexes [#row-level-security-and-indexes]
Encryption complements Supabase Row Level Security rather than replacing it. RLS controls which rows a caller may query; encryption controls whether the values in those rows can be read. Keep RLS predicates on plaintext ownership columns such as `user_id`, and encrypt the sensitive contents of the row. [Supabase Auth](https://cipherstash.com/docs/integrations/supabase/auth) can additionally bind decryption to the authenticated user's identity.
Encrypted columns use ordinary functional Postgres indexes over EQL term-extractor functions. The recipes, query shapes, `EXPLAIN` checks, and large-table guidance are maintained in [EQL indexes](https://cipherstash.com/docs/reference/eql/indexes).
In the Supabase Table Editor, encrypted columns appear as ciphertext payloads. Read and edit them through an application using CipherStash; the dashboard does not hold the keys required to decrypt them.
# Quickstart
Source: https://cipherstash.com/docs/integrations/supabase/quickstart
This tutorial creates a Supabase table with one encrypted column, writes a value through the Supabase JavaScript client, and queries it without sending plaintext to Postgres.
It is designed for a new table or an empty column. If the column already contains production data, use [Data migration](https://cipherstash.com/docs/guides/migration) instead.
Before you start [#before-you-start]
You need:
* A Supabase project and its database connection string
* A Node.js project
* A CipherStash account; the setup flow signs you in
Initialize CipherStash [#initialize-cipherstash]
Add your Supabase settings to the project's environment:
```sh title=".env"
SUPABASE_URL=https://.supabase.co
SUPABASE_ANON_KEY=...
DATABASE_URL=postgresql://postgres:...@db..supabase.co:5432/postgres
```
Then run the Supabase setup flow:
```bash cta cta-type="install" example-id="supabase-quickstart-eql-install"
npx stash init --supabase
```
`stash init`:
* Opens the CipherStash device login if you do not already have a developer profile
* Resolves the database configuration
* Installs compatible, pinned versions of `@cipherstash/stack`, `@cipherstash/stack-supabase`, and the `stash` CLI
* Installs EQL v3 with the grants required by Supabase's `anon`, `authenticated`, and `service_role` roles
* Scaffolds the encryption client and records context for coding agents
If the command generates a Supabase migration instead of applying EQL directly, run the apply command it prints before continuing. Confirm that EQL is available with:
```bash
npx stash eql status
```
The native Stack client automatically uses the developer profile created by this login. You do not need the four deployment environment variables for local development. When you deploy, [choose a deployment credential source](https://cipherstash.com/docs/guides/deployment#credentials-at-build-and-runtime).
**Using an agent?** An agent can drive the same setup. If no developer profile exists, it should start `npx stash auth login --json --region --supabase`, show you the returned verification URL, and leave the command running until authorization completes. It can then run `npx stash init --supabase --region `.
At the end of interactive initialization, you can continue into `stash plan`. Choosing Codex or Claude Code installs the Supabase-specific CipherStash skills into the agent's project directory; editor agents receive the same guidance through `AGENTS.md`. The skills cover Supabase, authentication, EQL indexes, deployment, and the CLI, giving the agent the context needed to plan and implement encryption changes safely.
Create an encrypted column [#create-an-encrypted-column]
Run this in the Supabase SQL Editor or add it to a new migration:
```sql
CREATE TABLE contacts (
id bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
email public.eql_v3_text_eq NOT NULL,
display_name text
);
```
`email` is an EQL equality column, so it can be stored, decrypted, and queried with methods such as `.eq()` and `.in()`. `display_name` is ordinary plaintext and passes through unchanged.
The column type is the encryption schema. There is no separate application declaration to keep synchronized. For other data types and query capabilities, see [EQL core concepts](https://cipherstash.com/docs/reference/eql/core-concepts).
Create the encrypted Supabase client [#create-the-encrypted-supabase-client]
`stash init` installed the CipherStash packages. If this project does not already use the Supabase JavaScript client, install it:
```bash
npm install @supabase/supabase-js
```
Create a client:
```typescript title="lib/db.ts"
import { encryptedSupabase } from "@cipherstash/stack-supabase"
export const db = await encryptedSupabase(
process.env.SUPABASE_URL!,
process.env.SUPABASE_ANON_KEY!,
)
```
At startup, `encryptedSupabase` uses `DATABASE_URL` to inspect the database and recognize `contacts.email` as encrypted. Plaintext tables and columns continue to behave normally.
Insert and query a value [#insert-and-query-a-value]
Write plaintext application values as usual:
```typescript
import { db } from "./lib/db"
const { error: insertError } = await db.from("contacts").insert({
email: "alice@example.com",
display_name: "Alice",
})
if (insertError) throw insertError
```
The wrapper encrypts `email` before it leaves the application. It then encrypts the filter value when you query the column and decrypts the matching result:
```typescript
const { data, error } = await db
.from("contacts")
.select("id, email, display_name")
.eq("email", "alice@example.com")
.single()
if (error) throw error
console.log(data)
// { id: 1, email: "alice@example.com", display_name: "Alice" }
```
Supabase Row Level Security still applies because the wrapper sends the request through the Supabase client. Add policies just as you would for an unencrypted table.
Confirm that Supabase sees ciphertext [#confirm-that-supabase-sees-ciphertext]
Open `contacts` in the Supabase Table Editor. The `email` cell contains an EQL ciphertext payload, while `display_name` remains readable.
The Table Editor cannot decrypt or meaningfully filter the encrypted value because its keys remain outside the database. Read and update encrypted fields through a CipherStash-enabled application.
Next steps [#next-steps]
* Learn the supported mutations, filters, ordering, response types, and errors in the [supabase-js guide](https://cipherstash.com/docs/integrations/supabase/supabase-js).
* Use the complete [`encryptedSupabase` API reference](https://cipherstash.com/docs/integrations/supabase/api-reference) when you need method-level detail.
* Add functional indexes when the table reaches meaningful row counts by following [EQL indexes](https://cipherstash.com/docs/reference/eql/indexes).
* For a populated table, follow the safe dual-write and backfill process in [Data migration](https://cipherstash.com/docs/guides/migration).
* To use a direct Postgres ORM connection, continue with [Drizzle](https://cipherstash.com/docs/integrations/drizzle) or [Prisma ORM 8](https://cipherstash.com/docs/integrations/prisma).
# supabase-js
Source: https://cipherstash.com/docs/integrations/supabase/supabase-js
`encryptedSupabase` wraps a [`@supabase/supabase-js`](https://supabase.com/docs/reference/javascript/introduction) client. It encrypts values before mutations leave your application, encrypts query operands for searchable columns, and decrypts selected rows before returning them. Plaintext columns pass through unchanged.
The result is the familiar supabase-js query shape:
```typescript
const { data, error } = await db
.from("patients")
.select("id, name, date_of_birth")
.eq("name", "Alice Chen")
```
The `name` operand and returned `name` value are plaintext in your code. Supabase and Postgres only receive their encrypted representations.
This guide assumes EQL is installed and your encrypted columns use `public.eql_v3_*` domain types. Complete the [Quickstart](https://cipherstash.com/docs/integrations/supabase/quickstart) first if your database is not ready.
Install [#install]
Install the Stack SDK, its Supabase adapter, supabase-js, and the Postgres driver used for schema introspection:
```bash cta cta-type="install" example-id="install-supabase-js"
npm install @cipherstash/stack @cipherstash/stack-supabase @supabase/supabase-js pg
```
Your server needs these environment variables:
```bash
SUPABASE_URL=https://.supabase.co
SUPABASE_ANON_KEY=...
DATABASE_URL=postgresql://...
```
Credentials [#credentials]
The [Quickstart setup](https://cipherstash.com/docs/integrations/supabase/quickstart#initialize-cipherstash) creates and uses the developer profile. In CI or a deployed application, add the four `CS_*` variables to the same server environment as the Supabase settings above.
Create the client [#create-the-client]
Pass your Supabase URL and key to `encryptedSupabase`. The async factory uses `DATABASE_URL` once at startup to inspect the `public` schema and identify its EQL columns. Application queries still go through the Supabase URL and PostgREST.
```typescript title="lib/db.ts"
import { encryptedSupabase } from "@cipherstash/stack-supabase"
export const db = await encryptedSupabase(
process.env.SUPABASE_URL!,
process.env.SUPABASE_ANON_KEY!,
)
```
Pass `databaseUrl` when your direct connection uses another environment variable:
```typescript
export const db = await encryptedSupabase(supabaseUrl, supabaseKey, {
databaseUrl: process.env.SUPABASE_DATABASE_URL,
})
```
If your application already creates a Supabase client, wrap that instance instead. Its Auth session, custom headers, and Row Level Security context are preserved:
```typescript title="lib/db.ts"
import { createClient } from "@supabase/supabase-js"
import { encryptedSupabase } from "@cipherstash/stack-supabase"
const supabase = createClient(supabaseUrl, supabaseAnonKey)
export const db = await encryptedSupabase(supabase, {
databaseUrl: process.env.DATABASE_URL,
})
```
Create this client on the server. It needs a direct database connection and CipherStash credentials, so it cannot run in a browser or Worker. For Deno, use the [Edge Functions guide](https://cipherstash.com/docs/integrations/supabase/edge-functions).
`encryptedSupabaseV3` remains as a deprecated, type-identical alias for existing applications. Use `encryptedSupabase` in new code.
Add optional TypeScript schemas [#add-optional-typescript-schemas]
Database introspection is enough at runtime. An optional declared schema adds compile-time row and filter types, and verifies at startup that the declaration matches the live database.
```typescript title="lib/db.ts"
import { encryptedTable, types } from "@cipherstash/stack/eql/v3"
import { encryptedSupabase } from "@cipherstash/stack-supabase"
const patients = encryptedTable("patients", {
name: types.TextEq("name"),
dateOfBirth: types.DateOrd("date_of_birth"),
})
export const typedDb = await encryptedSupabase(supabaseUrl, supabaseAnonKey, {
schemas: { patients },
})
```
The record key must match the database table name. A property may map to a different database column, as `dateOfBirth` does above; the wrapper applies that mapping to selects, mutations, filters, and returned rows.
Insert, update, and upsert [#insert-update-and-upsert]
Write plaintext values. The wrapper encrypts only the columns backed by EQL domains and sends every other column through unchanged.
```typescript
const { data, error } = await db
.from("patients")
.insert({
email: "alice@example.com", // plaintext column
name: "Alice Chen", // encrypted column
date_of_birth: "1988-06-15", // encrypted column
plan: "standard", // plaintext column
})
.select("id, email, name, date_of_birth, plan")
.single()
await db
.from("patients")
.update({ name: "Alice Jones" })
.eq("id", data!.id)
await db.from("patients").upsert(
{ email: "alice@example.com", name: "Alice Jones" },
{ onConflict: "email" },
)
```
`insert` and `upsert` accept one row or an array. The wrapper batches a mutation's encryption work into one ZeroKMS round trip.
Select and filter [#select-and-filter]
Encrypted values are decrypted before they appear in `data`. Bare `.select()` and `.select("*")` work because the wrapper expands the column list discovered during introspection.
```typescript
const { data } = await db
.from("patients")
.select("*")
.eq("name", "Alice Chen")
```
The EQL domain on each encrypted column determines which filters it accepts:
| supabase-js method | Required encrypted domain | Behaviour |
| ------------------------------------------ | ------------------------------- | -------------------------------------------- |
| `.eq()`, `.neq()`, `.in()` | `_eq`, `_ord`, or `text_search` | Compares encrypted equality terms |
| `.gt()`, `.gte()`, `.lt()`, `.lte()` | `_ord` or `text_search` | Compares encrypted ordering terms |
| `.is(column, null)` | Any column | Passes SQL `NULL` through without encryption |
| `.match()`, `.or()`, `.not()`, `.filter()` | Depends on the operator | Encrypts operands for encrypted columns |
| `.contains()` | Plaintext JSON or array | Uses native PostgREST containment |
Encrypted and plaintext predicates compose in the same query:
```typescript
const { data } = await db
.from("patients")
.select("id, name, date_of_birth, plan")
.gte("date_of_birth", "1980-01-01") // encrypted range
.lt("date_of_birth", "1990-01-01") // encrypted range
.eq("plan", "standard") // plaintext equality
```
Use `.is(column, null)` for null checks. Passing `null` to a comparison such as `.eq()` cannot create an encrypted query term and is forwarded to PostgREST; it is almost never the intended SQL operation.
Order and paginate [#order-and-paginate]
`.order()` works on plaintext columns and OPE-backed encrypted ordering domains such as `date_ord`, `integer_ord`, and `text_search`. The wrapper orders an encrypted column by the `op` term inside its payload, reproducing plaintext order without decrypting in Postgres.
```typescript
const { data } = await db
.from("patients")
.select("id, name, date_of_birth")
.order("date_of_birth", { ascending: false })
.range(0, 19)
```
Storage-only, equality-only, and match-only encrypted columns cannot be ordered. ORE-backed `_ord_ore` domains also cannot be ordered through PostgREST; Supabase installations disable those domains because their operator class requires superuser privileges.
`.limit()`, `.range()`, `.single()`, `.maybeSingle()`, `.abortSignal()`, `.throwOnError()`, and `.returns()` otherwise mirror supabase-js. `.csv()` throws because PostgREST serializes ciphertext before the wrapper has a chance to decrypt it; select rows normally and serialize the plaintext result in your application.
Free-text and encrypted JSON queries [#free-text-and-encrypted-json-queries]
**The current EQL 3.0.4 release cannot run encrypted free-text or encrypted JSON queries through supabase-js.** `.matches()`, encrypted `.contains()`, `.selectorEq()`, and `.selectorNe()` fail before a request is sent. Their SQL operators require an `eql_v3.query_*` cast that PostgREST cannot express. This PostgREST boundary was introduced in EQL 3.0.2 and remains in 3.0.4, which is why the runtime error describes it as `3.0.2+`.
Inserts, selects, decryption, equality, ranges, and ordering are unaffected. Use [Drizzle](https://cipherstash.com/docs/integrations/drizzle), [Prisma ORM 8](https://cipherstash.com/docs/integrations/prisma), or a carefully scoped SQL/RPC function for free-text and encrypted JSON queries.
Scalar encrypted filters currently use a full encrypted storage envelope as the PostgREST operand because PostgREST cannot cast a term-only query envelope. PostgREST sends filters in GET query strings, so configure application and proxy logs not to retain query strings. The operand is encrypted, but it can contain ciphertext and every index term for the queried value.
Responses and errors [#responses-and-errors]
Awaiting the builder returns the normal supabase-js response fields. Encryption failures use the same response path and add `error.encryptionError`:
```typescript
const { data, error, count, status, statusText } = await db
.from("patients")
.select("id, name")
.eq("name", "Alice Chen")
if (error?.encryptionError) {
// CipherStash authentication, encryption, or decryption failed
} else if (error) {
// Supabase or Postgres rejected the request
}
```
Chain `.throwOnError()` when the surrounding code prefers exceptions. Chain `.audit({ metadata })` to attach context to ZeroKMS audit events, or `.withLockContext({ identityClaim: ["sub"] })` to bind encryption to a federated user. See [Supabase Auth](https://cipherstash.com/docs/integrations/supabase/auth) before using lock contexts.
Where to next [#where-to-next]
Preserve the signed-in Supabase user and optionally lock decryption to their identity.
Run encryption in Deno with the WebAssembly build.
The complete query-builder API, response types, and implementation details.
# Overview
Source: https://cipherstash.com/docs/reference/stack
`@cipherstash/stack` is the core TypeScript SDK for CipherStash. It encrypts and decrypts values in your application, defines the searchable capabilities of encrypted columns, and creates encrypted operands for queries against [EQL](https://cipherstash.com/docs/reference/eql).
Database and framework wrappers are separate packages. Use the [Supabase](https://cipherstash.com/docs/integrations/supabase), [Prisma ORM 8](https://cipherstash.com/docs/integrations/prisma), or [Drizzle](https://cipherstash.com/docs/integrations/drizzle) integration when you want encryption built into that library's query flow.
What the package provides [#what-the-package-provides]
| Area | Purpose |
| ----------------- | ------------------------------------------------------------------------- |
| Encryption client | Encrypt and decrypt individual values, batches, and models. |
| Schema builders | Describe tables, columns, value types, and searchable capabilities. |
| Query encryption | Produce typed encrypted operands for equality, range, and search queries. |
| Identity controls | Bind encryption and decryption to federated identity claims. |
| DynamoDB helpers | Encrypt and decrypt DynamoDB attributes and expressions. |
| Error types | Inspect operation failures without parsing error messages. |
Start here [#start-here]
Install the package, define an encrypted schema, and encrypt, query, and decrypt a value.
Browse the generated functions, classes, interfaces, and type aliases exported by the package.
# Usage
Source: https://cipherstash.com/docs/reference/stack/usage
Install [#install]
```bash cta cta-type="install" example-id="install-stack"
npm install @cipherstash/stack
```
Authenticate locally with `stash auth login`, or configure the `CS_*` machine credentials described in [workspace configuration](https://cipherstash.com/docs/reference/workspace/configuration).
Define a schema and client [#define-a-schema-and-client]
The application schema tells Stack which columns are encrypted and which query capabilities they need. It must match the [EQL domain](https://cipherstash.com/docs/reference/eql/core-concepts) used by the database column.
```typescript filename="src/encryption.ts"
import { Encryption, encryptedColumn, encryptedTable } from "@cipherstash/stack"
export const users = encryptedTable("users", {
email: encryptedColumn("email").equality(),
})
export const encryption = await Encryption({ schemas: [users] })
```
An equality-enabled text column uses the corresponding EQL type:
```sql
CREATE TABLE users (
id bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
email public.eql_v3_text_eq
);
```
Encrypt and store [#encrypt-and-store]
Stack operations return a `Result` with either `data` or `failure`:
```typescript
const encrypted = await encryption.encrypt("alice@example.com", {
table: users,
column: users.email,
})
if (encrypted.failure) throw encrypted.failure
await db.query("INSERT INTO users (email) VALUES ($1)", [encrypted.data])
```
Encryption happens before the value leaves the application process.
Query an encrypted column [#query-an-encrypted-column]
Encrypt the operand with the same table and column definition, then cast it to the column's EQL domain in SQL:
```typescript
const term = await encryption.encryptQuery("alice@example.com", {
table: users,
column: users.email,
})
if (term.failure) throw term.failure
const result = await db.query(
"SELECT id, email FROM users WHERE email = $1::public.eql_v3_text_eq",
[term.data],
)
```
The database compares encrypted terms and never receives the plaintext operand. See [EQL filtering](https://cipherstash.com/docs/reference/eql/filtering) for the available query forms.
Decrypt a result [#decrypt-a-result]
```typescript
const decrypted = await encryption.decrypt(result.rows[0].email)
if (decrypted.failure) throw decrypted.failure
console.log(decrypted.data)
```
For every exported signature and option, use the [generated API reference](https://cipherstash.com/docs/reference/stack/api-reference). For an end-to-end project setup, follow the [quickstart](https://cipherstash.com/docs/get-started/quickstart).
Upgrading from @cipherstash/protect [#upgrading-from-cipherstashprotect]
The current package is `@cipherstash/stack`. Replace the retired package and
rename its schema builders:
| Retired API | Stack API |
| ------------------------ | --------------------------------------------------------- |
| `protect(config)` | `Encryption(config)` |
| `csTable(name, columns)` | `encryptedTable(name, columns)` |
| `csColumn(name)` | A typed column from `types`, such as `types.TextEq(name)` |
```bash
npm uninstall @cipherstash/protect
npm install @cipherstash/stack
```
Use the v3 exports shown above for new schemas. Data already written in an
older format needs an explicit migration plan; do not change the package and
database column format in a single irreversible deployment. Follow
[Data migration](https://cipherstash.com/docs/guides/migration) for the staged rollout.
# Billing
Source: https://cipherstash.com/docs/reference/workspace/billing
CipherStash uses a **per-workspace billing model**. Each workspace has its own plan and usage limits. Organizations and team members are always free and unlimited.
Plans [#plans]
Each workspace is on a plan. Plans differ in their usage limits and in which features they unlock, such as keyset isolation and [lock contexts](https://cipherstash.com/docs/solutions/provable-access). See [pricing](https://cipherstash.com/pricing) for the current plans, their prices, and their limits.
Enterprise is an organization-level plan with custom pricing and dedicated support. Enterprise organizations bypass per-workspace billing entirely. Contact [sales@cipherstash.com](mailto:sales@cipherstash.com).
Managing workspace billing [#managing-workspace-billing]
Each workspace has a billing page reachable from the workspace sidebar in the [Dashboard](https://dashboard.cipherstash.com). From there you can view your current plan and usage metrics, upgrade or downgrade, cancel your subscription, and open the Stripe billing portal for payment methods and invoices.
How billing works [#how-billing-works]
* **One Stripe customer per organization.** All workspaces in your organization share the same Stripe customer.
* **One subscription per workspace.** Each workspace has its own Stripe subscription tied to its plan.
* **Proration on upgrades.** Upgrading mid-cycle charges a prorated amount for the remainder of the billing period.
* **Downgrades at period end.** Downgrading takes effect at the end of the current billing period.
* **Cancellation.** Canceling keeps the plan active until the end of the billing period, then reverts to Free.
Enterprise and AWS Marketplace [#enterprise-and-aws-marketplace]
Organizations on Enterprise plans or subscribed through AWS Marketplace have billing managed at the organization level, and all their workspaces have unlimited access to all features. Manage enterprise billing from the Organization Profile.
Need help? [#need-help]
Contact [support@cipherstash.com](mailto:support@cipherstash.com) for billing questions.
# Configuration
Source: https://cipherstash.com/docs/reference/workspace/configuration
A workspace is identified by its **CRN** and accessed with a **client key** and an **access key**. How those credentials reach your application differs between local development and production.
Credentials [#credentials]
What the deployment variables mean [#what-the-deployment-variables-mean]
| Credential | Description |
| ------------- | ------------------------------------------------------------------------------------------------ |
| Workspace CRN | Identifies your workspace and its region, for example `crn:ap-southeast-2.aws:your-workspace-id` |
| Client ID | Identifies your application client key |
| Client key | Your half of the dual-party key split |
| Access key | Authenticates API calls to CipherStash |
These are the same credentials the [Stack SDK](https://cipherstash.com/docs/reference/stack) and [Proxy](https://cipherstash.com/docs/reference/proxy/configuration) consume. For build-time availability, environment separation, and production rollout gates, see [Deployment](https://cipherstash.com/docs/guides/deployment).
Keysets [#keysets]
A workspace can hold many keysets. Data encrypted under one keyset cannot be decrypted with another, which is what makes keysets the boundary for tenant isolation, environment separation, and regional compliance.
To use a specific keyset, pass the `keyset` option when constructing the client:
```typescript filename="keyset-config.ts"
const client = await Encryption({
schemas: [users],
config: {
keyset: { name: "tenant-a" },
},
})
```
Proxy scopes keysets per connection instead. See [multitenant operation](https://cipherstash.com/docs/reference/proxy/multitenant).
Related [#related]
* [Key management](https://cipherstash.com/docs/concepts/key-management#keysets-define-the-isolation-boundary) for the isolation model.
* [Billing](https://cipherstash.com/docs/reference/workspace/billing) for the plans and how per-workspace billing works.
# Workspace & account
Source: https://cipherstash.com/docs/reference/workspace
A **workspace** is the unit of isolation and billing in CipherStash. It holds your keysets, clients, access keys, and configuration. Workspaces belong to an **organization**, which owns the member list and the billing relationship.
Use workspaces to separate environments (development from production), to scope access for a team, or to associate a custom identity provider.
In this section [#in-this-section]
* [Configuration](https://cipherstash.com/docs/reference/workspace/configuration) covers workspace credentials, the workspace CRN, and keyset selection.
* [Members](https://cipherstash.com/docs/reference/workspace/members) covers organization and workspace membership, and developer device onboarding.
* [Billing](https://cipherstash.com/docs/reference/workspace/billing) covers the per-workspace billing model, and how upgrades and downgrades work.
Related [#related]
* [Access keys](https://cipherstash.com/docs/reference/auth/access-keys) for the credentials that authenticate to ZeroKMS and CTS.
* [Glossary](https://cipherstash.com/docs/reference/glossary) for the difference between a workspace, a keyset, a client key, and a device.
# Members
Source: https://cipherstash.com/docs/reference/workspace/members
There are two types of membership in CipherStash: organization memberships and workspace memberships. Every user belongs to at least one organization, and can be invited to any number of workspaces inside that organization.
Organization memberships [#organization-memberships]
Organization memberships control which users have access to CipherStash in general. Once a user is added to an organization, they can be granted access to any number of workspaces inside it.
Add a member from **Members** in the Dashboard's organization sidebar.
Workspace memberships [#workspace-memberships]
Workspace memberships control which users have access to a specific workspace. Once a user is added to a workspace, they have full access to managing it, including creating and managing keysets, clients, and access keys.
Add a member from the [workspace settings](https://dashboard.cipherstash.com/workspaces/_/settings) page in the Dashboard.
Developer device onboarding [#developer-device-onboarding]
After a member is added to an organization and granted workspace access, they initialize their local development environment:
```bash cta cta-type="quickstart" example-id="stash-init-member"
npx stash init
```
This creates a unique [device](https://cipherstash.com/docs/reference/glossary#device) and [client key](https://cipherstash.com/docs/reference/glossary#client-key) for that developer, with automatic access to the default [keyset](https://cipherstash.com/docs/reference/glossary#keyset). No environment variables are needed for local development.
See [team onboarding](https://cipherstash.com/docs/guides/deployment#team-onboarding) for the full workflow.
# stash auth
Source: https://cipherstash.com/docs/reference/cli/auth
{/* GENERATED — do not edit. Produced by scripts/generate-cli-docs.ts from the committed `stash manifest --json` fixture (v1.1.1). To describe a newer release: bump CLI_VERSION_PIN in that script, run `bun run generate-docs:cli:refresh`, and commit the result. */}
Generated from **`stash` v1.1.1**, via that release's own `manifest --json`. Run `npx stash@1.1.1 --help` to see the live command surface.
The `stash auth` command group.
auth login [#auth-login]
Runs the OAuth 2.0 device authorization flow:
1. Pick a region for your workspace.
2. Approve in the browser — the URL is printed, so it works over SSH/headless.
3. The CLI polls until you approve, then stores a short-lived token.
4. Your device is bound to the workspace's default keyset, so later
commands authenticate without a fresh login.
```bash
npx stash auth login [flags]
```
stash auth login flags [#stash-auth-login-flags]
| Flag | Description |
| ----------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `--region ` | Region to authenticate against (e.g. us-east-1). Skips the interactive region picker. (env: `STASH_REGION`) |
| `--json` | Emit newline-delimited JSON events instead of prose. The first event (authorization\_required) carries the device verification URL for a human to open. Implies no prompt and no browser auto-open. |
| `--no-open` | Don't auto-open the verification URL in a browser (already implied by --json). |
| `--supabase` | Track Supabase as the referrer. |
| `--drizzle` | Track Drizzle as the referrer. |
| `--prisma` | Track Prisma as the referrer. |
stash auth login examples [#stash-auth-login-examples]
```bash
npx stash auth login
npx stash auth login --region us-east-1
npx stash auth login --supabase
npx stash auth login --region us-east-1 --json
```
auth regions [#auth-regions]
List the regions you can authenticate against
```bash
npx stash auth regions [flags]
```
stash auth regions flags [#stash-auth-regions-flags]
| Flag | Description |
| -------- | ----------------------------------------------------------------- |
| `--json` | Emit machine-readable \[\{ slug, label }] instead of a text list. |
stash auth regions examples [#stash-auth-regions-examples]
```bash
npx stash auth regions
npx stash auth regions --json
```
Switching workspaces [#switching-workspaces]
`stash` 1.0.0 keeps one active device-session profile at
`~/.cipherstash/auth.json`. To switch workspaces, run `npx stash auth login`
again and complete authorization for the target workspace. The new login
replaces the active session.
`stash init` reuses the active session when it is still valid, so switch
workspaces before running `init`. There is no separate profile manager or
workspace-switch command in `stash` 1.0.0.
# stash db
Source: https://cipherstash.com/docs/reference/cli/db
{/* GENERATED — do not edit. Produced by scripts/generate-cli-docs.ts from the committed `stash manifest --json` fixture (v1.1.1). To describe a newer release: bump CLI_VERSION_PIN in that script, run `bun run generate-docs:cli:refresh`, and commit the result. */}
Generated from **`stash` v1.1.1**, via that release's own `manifest --json`. Run `npx stash@1.1.1 --help` to see the live command surface.
The `stash db` command group.
db migrate [#db-migrate]
Run pending encrypt config migrations (not yet implemented)
```bash
npx stash db migrate
```
db test-connection [#db-test-connection]
Test database connectivity
```bash
npx stash db test-connection [flags]
```
stash db test-connection flags [#stash-db-test-connection-flags]
| Flag | Description |
| ---------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `--database-url ` | Database URL for this run only — never written to disk. Highest precedence in the resolution order: --database-url flag → DATABASE\_URL env → supabase status → interactive prompt. A stash.config.ts is not a separate tier (its default databaseUrl re-runs this same chain); a hand-set literal databaseUrl in the config bypasses the resolver and wins over all of these. (env: `DATABASE_URL`) |
# stash doctor
Source: https://cipherstash.com/docs/reference/cli/doctor
{/* GENERATED — do not edit. Produced by scripts/generate-cli-docs.ts from the committed `stash manifest --json` fixture (v1.1.1). To describe a newer release: bump CLI_VERSION_PIN in that script, run `bun run generate-docs:cli:refresh`, and commit the result. */}
Generated from **`stash` v1.1.1**, via that release's own `manifest --json`. Run `npx stash@1.1.1 --help` to see the live command surface.
Diagnose install problems (native binaries, runtime)
```bash
npx stash doctor
```
# stash encrypt
Source: https://cipherstash.com/docs/reference/cli/encrypt
{/* GENERATED — do not edit. Produced by scripts/generate-cli-docs.ts from the committed `stash manifest --json` fixture (v1.1.1). To describe a newer release: bump CLI_VERSION_PIN in that script, run `bun run generate-docs:cli:refresh`, and commit the result. */}
Generated from **`stash` v1.1.1**, via that release's own `manifest --json`. Run `npx stash@1.1.1 --help` to see the live command surface.
The `stash encrypt` command group.
encrypt status [#encrypt-status]
Show per-column migration status (phase, progress, drift)
```bash
npx stash encrypt status
```
encrypt plan [#encrypt-plan]
Diff intent (.cipherstash/migrations.json) vs observed state
```bash
npx stash encrypt plan
```
encrypt backfill [#encrypt-backfill]
Resumably encrypt plaintext into the encrypted column
```bash
npx stash encrypt backfill [flags]
```
stash encrypt backfill flags [#stash-encrypt-backfill-flags]
| Flag | Description |
| -------------------------------- | ---------------------------------------------------------------- |
| `--table ` | Target table. |
| `--column ` | Target column. |
| `--pk-column ` | Primary-key column used to page through rows. |
| `--chunk-size ` | Rows encrypted per batch. |
| `--encrypted-column ` | Destination encrypted column. |
| `--schema-column-key ` | Schema key identifying the column config. |
| `--confirm-dual-writes-deployed` | Assert the app is dual-writing before backfilling (safety gate). |
| `--force` | Proceed past non-fatal safety checks. |
encrypt drop [#encrypt-drop]
Generate a migration to drop the plaintext column
```bash
npx stash encrypt drop [flags]
```
stash encrypt drop flags [#stash-encrypt-drop-flags]
| Flag | Description |
| ------------------------- | ------------------------------------------- |
| `--table ` | Target table. |
| `--column ` | Target column. |
| `--migrations-dir ` | Directory to write the drop migration into. |
# stash env
Source: https://cipherstash.com/docs/reference/cli/env
{/* GENERATED — do not edit. Produced by scripts/generate-cli-docs.ts from the committed `stash manifest --json` fixture (v1.1.1). To describe a newer release: bump CLI_VERSION_PIN in that script, run `bun run generate-docs:cli:refresh`, and commit the result. */}
Generated from **`stash` v1.1.1**, via that release's own `manifest --json`. Run `npx stash@1.1.1 --help` to see the live command surface.
Mints a fresh ZeroKMS client and a CipherStash access key from your
device-code session (`stash auth login`), then prints the four env
vars a deployed app needs: CS\_WORKSPACE\_CRN, CS\_CLIENT\_ID,
CS\_CLIENT\_KEY, CS\_CLIENT\_ACCESS\_KEY.
The access key is created with the member role (the CLI never mints
admin keys) and is shown exactly once — pipe the output into your
deployment secret store. Creating access keys requires your user to
have the admin role in the workspace.
Stdout carries only the dotenv block (or the --json events);
progress UI goes to stderr, so `stash env --name x > prod.env`
and pipes into secret stores are safe.
```bash
npx stash env [flags]
```
Flags [#flags]
| Flag | Description |
| ---------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `--name ` | Name for the minted access key and ZeroKMS client. Prompted for interactively; required in non-interactive runs. |
| `--write [path]` | Write the vars to a file (default .env.production.local, mode 0600) instead of printing them. An existing file prompts before overwriting — and is refused non-interactively — before anything is minted. |
| `--json` | Emit machine-readable NDJSON (a \{ status: "minted" } object, or \{ status: "written" } with --write — deliberately secret-free since the secrets are in the file; failures are \{ status: "error" }). Implies no prompts. |
stash env examples [#stash-env-examples]
```bash
npx stash env --name my-app-prod
npx stash env --name my-app-prod --write
npx stash env --name staging --write .env.staging.local
npx stash env --name edge-dev --json
```
# stash eql
Source: https://cipherstash.com/docs/reference/cli/eql
{/* GENERATED — do not edit. Produced by scripts/generate-cli-docs.ts from the committed `stash manifest --json` fixture (v1.1.1). To describe a newer release: bump CLI_VERSION_PIN in that script, run `bun run generate-docs:cli:refresh`, and commit the result. */}
Generated from **`stash` v1.1.1**, via that release's own `manifest --json`. Run `npx stash@1.1.1 --help` to see the live command surface.
The `stash eql` command group.
eql preflight [#eql-preflight]
Read-only: probes the connected role — superuser, membership of
`postgres`, CREATE on the database and on `public`, pgcrypto, and
whether the EQL v3 schemas already exist — and names the statement
each gap blocks. Exits 1 when a gap would abort `eql install`.
Membership of `postgres` is reported but never blocks: on managed
platforms whose role is not a member (e.g. Lovable), `eql install`
skips the optional owner-scoped ALTER DEFAULT PRIVILEGES statements
— the install is complete without them, since stash re-grants every
object on each install/upgrade.
```bash
npx stash eql preflight [flags]
```
stash eql preflight flags [#stash-eql-preflight-flags]
| Flag | Description |
| ---------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `--json` | Emit the machine-readable preflight result instead of the table. |
| `--database-url ` | Database URL for this run only — never written to disk. Highest precedence in the resolution order: --database-url flag → DATABASE\_URL env → supabase status → interactive prompt. A stash.config.ts is not a separate tier (its default databaseUrl re-runs this same chain); a hand-set literal databaseUrl in the config bypasses the resolver and wins over all of these. (env: `DATABASE_URL`) |
stash eql preflight examples [#stash-eql-preflight-examples]
```bash
npx stash eql preflight
npx stash eql preflight --json
```
eql install [#eql-install]
Scaffold stash.config.ts (if missing) and install EQL extensions
```bash
npx stash eql install [flags]
```
stash eql install flags [#stash-eql-install-flags]
| Flag | Description |
| ---------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `--force` | Reinstall / overwrite even if already installed. |
| `--dry-run` | Show what would happen without making changes. |
| `--supabase` | Use Supabase-compatible mode (auto-detected from DATABASE\_URL). |
| `--database-url ` | Database URL for this run only — never written to disk. Highest precedence in the resolution order: --database-url flag → DATABASE\_URL env → supabase status → interactive prompt. A stash.config.ts is not a separate tier (its default databaseUrl re-runs this same chain); a hand-set literal databaseUrl in the config bypasses the resolver and wins over all of these. (env: `DATABASE_URL`) |
eql verify [#eql-verify]
Compare what the database actually has against everything the pinned
EQL v3 bundle installs — every domain, function overload, operator,
cast, and the ORE operator class — via read-only catalog queries. A
partial install (domains present, some comparison functions or
operators absent) reports success at install time and fails at query
time on a specific predicate; this is the check that catches it.
Expected absences read as such: on managed Postgres the bundle
legitimately skips the ORE operator class (creating it requires
superuser) and poisons the `_ord_ore` domains to fail loudly — that
is a supported configuration, reported as info.
Exit 0 means exactly one thing: the surface was checked and found
complete. Damage, EQL not installed, and a version mismatch with
the pinned bundle all exit 1 — on a mismatch the object-level diff
is skipped (the pinned bundle is the wrong manifest to compare
against) and the command suggests `eql upgrade` (or a one-shot
`eql install --force --database-url ...` where no stash.config.ts
exists — `eql upgrade` requires one).
Runs automatically at the end of `stash eql install`, on the
fresh-install path and the already-installed early exit alike.
There, only damage fails the install — a version mismatch warns
and continues, keeping a no-op re-run over an older EQL exit 0
for idempotent provisioning scripts.
```bash
npx stash eql verify [flags]
```
stash eql verify flags [#stash-eql-verify-flags]
| Flag | Description |
| ---------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `--json` | Emit the machine-readable verification report instead of the table. |
| `--database-url ` | One-shot, like `eql install`'s: bypasses config loading entirely, so the database you name is the database that gets judged. Also settable via DATABASE\_URL. (env: `DATABASE_URL`) |
stash eql verify examples [#stash-eql-verify-examples]
```bash
npx stash eql verify
npx stash eql verify --json
```
eql migration [#eql-migration]
Migration-first is the preferred way to install EQL: it lands in your
migration history and ships to every environment through the same
migrate step as the rest of your schema. On Supabase it is the only
durable way — `supabase db reset` replays the migrations directory, so
a direct `eql install` is wiped by the next reset.
```bash
npx stash eql migration [flags]
```
stash eql migration flags [#stash-eql-migration-flags]
| Flag | Description |
| --------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `--drizzle` | Emit a Drizzle custom migration containing the EQL v3 install SQL. |
| `--prisma` | Not needed: Prisma Next installs EQL through its own migration framework — run `prisma-next migrate` instead. |
| `--supabase` | On its own, write the install into supabase/migrations/ so it survives `supabase db reset`. With --drizzle, instead append the Supabase role grants (eql\_v3 + eql\_v3\_internal for anon/authenticated/service\_role) to the Drizzle migration. |
| `--name ` | Name for the generated migration (Drizzle). Letters, numbers, dashes, underscores only. Defaults to `install-eql`. |
| `--out ` | Where the migration is written. Drizzle: your drizzle.config.ts `out` decides that, and stash follows the path drizzle-kit reports — this is only the fallback directory to look in (defaults to `drizzle`) if it reports none. Supabase: leave it alone. The Supabase CLI replays `supabase/migrations` and has no setting to move it, so pointing elsewhere means `supabase db reset` / `db push` never apply the install; the command warns when you do. |
| `--force` | Write a Supabase install migration even though one already exists. Not needed for --drizzle (drizzle-kit numbers each generated migration). |
| `--dry-run` | Show what would happen without making changes. |
stash eql migration examples [#stash-eql-migration-examples]
```bash
npx stash eql migration --drizzle
npx stash eql migration --drizzle --supabase
npx stash eql migration --supabase
npx stash eql migration --supabase --force
```
eql repair [#eql-repair]
Sweep an existing Drizzle output directory for in-place
`ALTER COLUMN ... SET DATA TYPE ` statements — which cannot run,
because Postgres has no cast from text/numeric to an EQL domain — and rewrite
each into an additive encrypted column that preserves the source column.
This is the same sweep `eql migration --drizzle` runs, without having to
generate an EQL install migration you do not want just to trigger it.
Migrations the database has already applied are reported and left alone:
rewriting one would leave its .sql describing a shape that database never got
from it, so a fresh CI or staging database replaying the file would silently
diverge. Pass --database-url so that check can run; without it the repair
proceeds and warns that applied state could not be verified. If your
drizzle.config.ts overrides `migrations.table` / `migrations.schema`, name
the ledger with --migrations-table — otherwise the check queries the default
relation, finds nothing, and reports applied state as unverified.
```bash
npx stash eql repair [flags]
```
stash eql repair flags [#stash-eql-repair-flags]
| Flag | Description |
| ------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `--drizzle` | Repair a Drizzle migration directory. |
| `--out ` | Directory holding the migrations to sweep. Defaults to `drizzle`; set it to match your drizzle.config.ts. |
| `--migrations-table <[schema.]table>` | Drizzle's migration ledger, when drizzle.config.ts overrides `migrations.table` / `migrations.schema`. Defaults to `drizzle.__drizzle_migrations`. Only read with --database-url. |
| `--dry-run` | Show what would happen without making changes. |
| `--database-url ` | Database URL for this run only — never written to disk. Highest precedence in the resolution order: --database-url flag → DATABASE\_URL env → supabase status → interactive prompt. A stash.config.ts is not a separate tier (its default databaseUrl re-runs this same chain); a hand-set literal databaseUrl in the config bypasses the resolver and wins over all of these. (env: `DATABASE_URL`) |
stash eql repair examples [#stash-eql-repair-examples]
```bash
npx stash eql repair --drizzle
npx stash eql repair --drizzle --dry-run
npx stash eql repair --drizzle --out db/migrations --database-url postgres://…
```
eql upgrade [#eql-upgrade]
Upgrade EQL extensions to the latest version
```bash
npx stash eql upgrade [flags]
```
stash eql upgrade flags [#stash-eql-upgrade-flags]
| Flag | Description |
| ---------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `--dry-run` | Show what would happen without making changes. |
| `--supabase` | Use Supabase-compatible mode. |
| `--database-url ` | Database URL for this run only — never written to disk. Highest precedence in the resolution order: --database-url flag → DATABASE\_URL env → supabase status → interactive prompt. A stash.config.ts is not a separate tier (its default databaseUrl re-runs this same chain); a hand-set literal databaseUrl in the config bypasses the resolver and wins over all of these. (env: `DATABASE_URL`) |
eql status [#eql-status]
Show EQL installation status
```bash
npx stash eql status [flags]
```
stash eql status flags [#stash-eql-status-flags]
| Flag | Description |
| ---------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `--database-url ` | Database URL for this run only — never written to disk. Highest precedence in the resolution order: --database-url flag → DATABASE\_URL env → supabase status → interactive prompt. A stash.config.ts is not a separate tier (its default databaseUrl re-runs this same chain); a hand-set literal databaseUrl in the config bypasses the resolver and wins over all of these. (env: `DATABASE_URL`) |
eql validate [#eql-validate]
Read the tables passed to `Encryption({ schemas })` and check each encrypted
column against the EQL v3 domain vocabulary — then, if a database is
reachable, against what that database actually has.
Schema checks (no database needed): an `_ord_ore` domain, whose ORE operator
class only a superuser can create; storage-only columns, reported so an
unsearchable column is a decision rather than a surprise; and hand-authored
configs that ask for free-text match on a non-text domain, encrypted-JSONB
search without `types.Json`, or a searchable boolean.
Database checks (skipped with a notice when no database is reachable):
declared columns missing from the database, a column whose domain has drifted
from the schema, an `_ord_ore` column on a database whose EQL install could
not create the ORE operator class, and queryable columns with no functional
index over their term extractor.
Exits 1 on errors only — warnings and info do not fail the command.
```bash
npx stash eql validate [flags]
```
stash eql validate flags [#stash-eql-validate-flags]
| Flag | Description |
| ---------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `--supabase` | Use Supabase-compatible mode. |
| `--database-url ` | Database URL for this run only — never written to disk. Highest precedence in the resolution order: --database-url flag → DATABASE\_URL env → supabase status → interactive prompt. A stash.config.ts is not a separate tier (its default databaseUrl re-runs this same chain); a hand-set literal databaseUrl in the config bypasses the resolver and wins over all of these. (env: `DATABASE_URL`) |
stash eql validate examples [#stash-eql-validate-examples]
```bash
npx stash eql validate
npx stash eql validate --database-url postgres://…
```
# stash impl
Source: https://cipherstash.com/docs/reference/cli/impl
{/* GENERATED — do not edit. Produced by scripts/generate-cli-docs.ts from the committed `stash manifest --json` fixture (v1.1.1). To describe a newer release: bump CLI_VERSION_PIN in that script, run `bun run generate-docs:cli:refresh`, and commit the result. */}
Generated from **`stash` v1.1.1**, via that release's own `manifest --json`. Run `npx stash@1.1.1 --help` to see the live command surface.
Execute the plan with a local agent
```bash
npx stash impl [flags]
```
Flags [#flags]
| Flag | Description |
| ------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------- |
| `--continue-without-plan` | Skip planning and go straight to implementation (interactively confirms before proceeding). |
| `--target ` | Skip the agent-target picker and hand off directly to one of claude-code \| codex \| agents-md \| lovable \| wizard. Safe in non-TTY contexts. |
stash impl examples [#stash-impl-examples]
```bash
npx stash impl
npx stash impl --continue-without-plan
npx stash impl --target claude-code
```
# CLI
Source: https://cipherstash.com/docs/reference/cli
{/* GENERATED — do not edit. Produced by scripts/generate-cli-docs.ts from the committed `stash manifest --json` fixture (v1.1.1). To describe a newer release: bump CLI_VERSION_PIN in that script, run `bun run generate-docs:cli:refresh`, and commit the result. */}
Generated from **`stash` v1.1.1**, via that release's own `manifest --json`. Run `npx stash@1.1.1 --help` to see the live command surface.
The `stash` CLI. Install with `npx stash@1.1.1`. Every command accepts `--help` and `--version`.
Setup & workflow [#setup--workflow]
| Command | Description |
| --------------------------------------- | ---------------------------------------------------------- |
| [`init`](https://cipherstash.com/docs/reference/cli/init) | Initialize CipherStash for your project |
| [`plan`](https://cipherstash.com/docs/reference/cli/plan) | Draft a reviewable encryption plan at .cipherstash/plan.md |
| [`impl`](https://cipherstash.com/docs/reference/cli/impl) | Execute the plan with a local agent |
| [`status`](https://cipherstash.com/docs/reference/cli/status) | Displays implementation status |
| [`wizard`](https://cipherstash.com/docs/reference/cli/wizard) | AI-guided encryption setup (reads your codebase) |
| [`doctor`](https://cipherstash.com/docs/reference/cli/doctor) | Diagnose install problems (native binaries, runtime) |
| [`manifest`](https://cipherstash.com/docs/reference/cli/manifest) | Print the structured, versioned command surface |
| [`telemetry`](https://cipherstash.com/docs/reference/cli/telemetry) | Manage anonymous usage analytics |
Auth [#auth]
| Command | Description |
| -------------------------------------------------- | --------------------------------------------- |
| [`auth login`](https://cipherstash.com/docs/reference/cli/auth#auth-login) | Authenticate with CipherStash |
| [`auth regions`](https://cipherstash.com/docs/reference/cli/auth#auth-regions) | List the regions you can authenticate against |
EQL [#eql]
| Command | Description |
| --------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------- |
| [`eql preflight`](https://cipherstash.com/docs/reference/cli/eql#eql-preflight) | Report whether this database role can install EQL, before trying |
| [`eql install`](https://cipherstash.com/docs/reference/cli/eql#eql-install) | Scaffold stash.config.ts (if missing) and install EQL extensions |
| [`eql verify`](https://cipherstash.com/docs/reference/cli/eql#eql-verify) | Check the installed EQL surface is complete, not just present |
| [`eql migration`](https://cipherstash.com/docs/reference/cli/eql#eql-migration) | Generate an EQL v3 install migration (Drizzle, or supabase/migrations/; Prisma Next installs EQL through its own migrations) |
| [`eql repair`](https://cipherstash.com/docs/reference/cli/eql#eql-repair) | Repair migrations drizzle-kit generated with an un-runnable ALTER COLUMN to an encrypted type |
| [`eql upgrade`](https://cipherstash.com/docs/reference/cli/eql#eql-upgrade) | Upgrade EQL extensions to the latest version |
| [`eql status`](https://cipherstash.com/docs/reference/cli/eql#eql-status) | Show EQL installation status |
| [`eql validate`](https://cipherstash.com/docs/reference/cli/eql#eql-validate) | Validate your encryption schema against EQL v3 |
Database [#database]
| Command | Description |
| ------------------------------------------------------------ | ----------------------------------------------------------- |
| [`db migrate`](https://cipherstash.com/docs/reference/cli/db#db-migrate) | Run pending encrypt config migrations (not yet implemented) |
| [`db test-connection`](https://cipherstash.com/docs/reference/cli/db#db-test-connection) | Test database connectivity |
Schema [#schema]
| Command | Description |
| ---------------------------------------------------- | --------------------------------------------- |
| [`schema build`](https://cipherstash.com/docs/reference/cli/schema#schema-build) | Build an encryption schema from your database |
Encrypt [#encrypt]
| Command | Description |
| ------------------------------------------------------------- | ------------------------------------------------------------ |
| [`encrypt status`](https://cipherstash.com/docs/reference/cli/encrypt#encrypt-status) | Show per-column migration status (phase, progress, drift) |
| [`encrypt plan`](https://cipherstash.com/docs/reference/cli/encrypt#encrypt-plan) | Diff intent (.cipherstash/migrations.json) vs observed state |
| [`encrypt backfill`](https://cipherstash.com/docs/reference/cli/encrypt#encrypt-backfill) | Resumably encrypt plaintext into the encrypted column |
| [`encrypt drop`](https://cipherstash.com/docs/reference/cli/encrypt#encrypt-drop) | Generate a migration to drop the plaintext column |
Deployment [#deployment]
| Command | Description |
| --------------------------- | ------------------------------------------------------ |
| [`env`](https://cipherstash.com/docs/reference/cli/env) | Mint deployment credentials and print them as env vars |
# stash init
Source: https://cipherstash.com/docs/reference/cli/init
{/* GENERATED — do not edit. Produced by scripts/generate-cli-docs.ts from the committed `stash manifest --json` fixture (v1.1.1). To describe a newer release: bump CLI_VERSION_PIN in that script, run `bun run generate-docs:cli:refresh`, and commit the result. */}
Generated from **`stash` v1.1.1**, via that release's own `manifest --json`. Run `npx stash@1.1.1 --help` to see the live command surface.
Set up CipherStash end-to-end: authenticate, introspect your database,
install dependencies, install EQL, and hand off the rest to your local
coding agent. Every prompt has a non-interactive escape hatch, so init
never blocks waiting on a TTY (CI, agents, pipes).
```bash
npx stash init [flags]
```
Flags [#flags]
| Flag | Description |
| ----------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `--supabase` | Use Supabase-specific setup flow. |
| `--drizzle` | Use Drizzle-specific setup flow. |
| `--prisma` | Use Prisma Next-specific setup flow (EQL bundle installed via prisma-next migrate). |
| `--region ` | Region to authenticate against (e.g. us-east-1). Skips the interactive region picker. Required for non-interactive init when not already logged in. (env: `STASH_REGION`) |
| `--target ` | Which agent to install the bundled skills for: claude-code (.claude/skills) or codex (.codex/skills). Skips agent detection. Unlike `plan --target` and `impl --target`, this selects the skills destination only — init performs no handoff. agents-md, lovable and wizard install no skill directories (those handoffs inline the skills instead), so passing one here installs nothing. |
stash init examples [#stash-init-examples]
```bash
npx stash init
npx stash init --supabase
npx stash init --prisma
npx stash init --region us-east-1
npx stash init --target claude-code
```
# stash manifest
Source: https://cipherstash.com/docs/reference/cli/manifest
{/* GENERATED — do not edit. Produced by scripts/generate-cli-docs.ts from the committed `stash manifest --json` fixture (v1.1.1). To describe a newer release: bump CLI_VERSION_PIN in that script, run `bun run generate-docs:cli:refresh`, and commit the result. */}
Generated from **`stash` v1.1.1**, via that release's own `manifest --json`. Run `npx stash@1.1.1 --help` to see the live command surface.
Emit the CLI command surface as data. `--json` produces the machine-
readable manifest the docs generator and agents consume; without it a
grouped command list is printed. The manifest is stamped with the CLI
version, so a page generated from it always names the version it describes.
```bash
npx stash manifest [flags]
```
Flags [#flags]
| Flag | Description |
| -------- | --------------------------------------------------------- |
| `--json` | Emit the structured JSON manifest instead of a text list. |
stash manifest examples [#stash-manifest-examples]
```bash
npx stash manifest --json
npx stash manifest
```
# stash plan
Source: https://cipherstash.com/docs/reference/cli/plan
{/* GENERATED — do not edit. Produced by scripts/generate-cli-docs.ts from the committed `stash manifest --json` fixture (v1.1.1). To describe a newer release: bump CLI_VERSION_PIN in that script, run `bun run generate-docs:cli:refresh`, and commit the result. */}
Generated from **`stash` v1.1.1**, via that release's own `manifest --json`. Run `npx stash@1.1.1 --help` to see the live command surface.
Draft a reviewable encryption plan at .cipherstash/plan.md
```bash
npx stash plan [flags]
```
Flags [#flags]
| Flag | Description |
| -------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `--complete-rollout` | Plan the entire encryption lifecycle (schema-add through drop) in one document. Skips the production-deploy gate; only safe when this database is not backing a deployed application. Needs confirmation — an interactive prompt, or --yes non-interactively (else it exits non-zero without drafting). |
| `--yes` | Confirm --complete-rollout's gate-skip without a prompt (for automation / CI). No effect without --complete-rollout. |
| `--target ` | Skip the agent-target picker and hand off directly to one of claude-code \| codex \| agents-md \| lovable \| wizard. Safe in non-TTY contexts. |
stash plan examples [#stash-plan-examples]
```bash
npx stash plan
npx stash plan --target claude-code
npx stash plan --complete-rollout --yes --target claude-code
```
# stash schema
Source: https://cipherstash.com/docs/reference/cli/schema
{/* GENERATED — do not edit. Produced by scripts/generate-cli-docs.ts from the committed `stash manifest --json` fixture (v1.1.1). To describe a newer release: bump CLI_VERSION_PIN in that script, run `bun run generate-docs:cli:refresh`, and commit the result. */}
Generated from **`stash` v1.1.1**, via that release's own `manifest --json`. Run `npx stash@1.1.1 --help` to see the live command surface.
The `stash schema` command group.
schema build [#schema-build]
Build an encryption schema from your database
```bash
npx stash schema build [flags]
```
stash schema build flags [#stash-schema-build-flags]
| Flag | Description |
| ---------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `--supabase` | Use Supabase-compatible mode. |
| `--database-url ` | Database URL for this run only — never written to disk. Highest precedence in the resolution order: --database-url flag → DATABASE\_URL env → supabase status → interactive prompt. A stash.config.ts is not a separate tier (its default databaseUrl re-runs this same chain); a hand-set literal databaseUrl in the config bypasses the resolver and wins over all of these. (env: `DATABASE_URL`) |
# stash status
Source: https://cipherstash.com/docs/reference/cli/status
{/* GENERATED — do not edit. Produced by scripts/generate-cli-docs.ts from the committed `stash manifest --json` fixture (v1.1.1). To describe a newer release: bump CLI_VERSION_PIN in that script, run `bun run generate-docs:cli:refresh`, and commit the result. */}
Generated from **`stash` v1.1.1**, via that release's own `manifest --json`. Run `npx stash@1.1.1 --help` to see the live command surface.
Displays implementation status
```bash
npx stash status [flags]
```
Flags [#flags]
| Flag | Description |
| --------- | ---------------------------------------------------------------------------- |
| `--quest` | Force the quest-log output (emoji + progress bars) even in non-TTY contexts. |
| `--plain` | Force the plain-text output even in TTY contexts. |
| `--json` | Emit a structured JSON document instead. |
# stash telemetry
Source: https://cipherstash.com/docs/reference/cli/telemetry
{/* GENERATED — do not edit. Produced by scripts/generate-cli-docs.ts from the committed `stash manifest --json` fixture (v1.1.1). To describe a newer release: bump CLI_VERSION_PIN in that script, run `bun run generate-docs:cli:refresh`, and commit the result. */}
Generated from **`stash` v1.1.1**, via that release's own `manifest --json`. Run `npx stash@1.1.1 --help` to see the live command surface.
Manage the anonymous, opt-out usage analytics the CLI collects to
improve the tool. `status` (the default) reports whether telemetry is
on and which setting governs it; `enable` / `disable` write your saved
preference. Telemetry is also disabled by the DO\_NOT\_TRACK or
STASH\_TELEMETRY\_DISABLED environment variables and automatically in CI.
No plaintext, schema, table/column names, or connection details are
ever collected. See [https://cipherstash.com/docs/reference/cli](https://cipherstash.com/docs/reference/cli).
```bash
npx stash telemetry
```
stash telemetry examples [#stash-telemetry-examples]
```bash
npx stash telemetry status
npx stash telemetry disable
npx stash telemetry enable
```
# stash wizard
Source: https://cipherstash.com/docs/reference/cli/wizard
{/* GENERATED — do not edit. Produced by scripts/generate-cli-docs.ts from the committed `stash manifest --json` fixture (v1.1.1). To describe a newer release: bump CLI_VERSION_PIN in that script, run `bun run generate-docs:cli:refresh`, and commit the result. */}
Generated from **`stash` v1.1.1**, via that release's own `manifest --json`. Run `npx stash@1.1.1 --help` to see the live command surface.
AI-guided encryption setup (reads your codebase)
```bash
npx stash wizard
```
# CipherStash vs AWS KMS
Source: https://cipherstash.com/docs/concepts/compare/aws-kms
AWS Key Management Service and CipherStash overlap at key management, but they operate at different layers.
AWS KMS is a general-purpose cloud key service. It protects root keys in AWS-managed hardware security modules and performs cryptographic operations under IAM control. CipherStash is an application-data protection system: the Stack SDK or CipherStash Proxy encrypts individual values, while ZeroKMS supplies one half of a split key-derivation process.
They are often complementary. AWS KMS is a strong fit for infrastructure encryption and conventional envelope encryption. CipherStash is designed for field-level application data that needs per-value isolation, searchable ciphertext, and a key service that cannot decrypt the data by itself.
The architectural difference [#the-architectural-difference]
The conventional AWS KMS pattern is envelope encryption:
1. The application asks KMS to generate or unwrap a data encryption key.
2. KMS returns the plaintext data key to the authorized application.
3. The application encrypts data locally.
4. It stores the wrapped copy of the data key beside the ciphertext.
5. Decryption sends the wrapped key back to KMS to recover the plaintext data key.
ZeroKMS does not return a data key:
1. ZeroKMS produces a key seed from its authority key and the value's key ID.
2. The application processes that seed with a client key that never leaves its environment.
3. A unique data key comes into existence locally for one value.
4. The data key is discarded after the operation; it is never stored or transmitted.
The full mechanism is described in [Cryptography](https://cipherstash.com/docs/security/cryptography#how-a-data-key-is-produced).
| Property | AWS KMS envelope encryption | CipherStash ZeroKMS |
| ------------------------------- | ---------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------- |
| Root of trust | KMS key protected by AWS-managed HSMs | ZeroKMS authority key plus a client key held by the application |
| Material returned to the client | Plaintext and wrapped data key when using `GenerateDataKey`, or a plaintext key from `Decrypt` | A key seed that is unusable without the client key |
| Data-key persistence | Wrapped data key is normally stored with the ciphertext | Data key is never stored; the payload carries a reproducible key ID |
| Key granularity | Chosen by the application; keys are commonly reused or cached | Unique data key for every encrypted value |
| Server acting alone | KMS can perform an authorized decrypt operation | ZeroKMS cannot derive a usable data key without the client side of the split |
Trust and compromise [#trust-and-compromise]
AWS KMS keeps key material inside its managed boundary and gives customers detailed IAM policies, grants, encryption context, rotation, and CloudTrail integration. The application still needs credentials that authorize KMS operations, and an authorized KMS response contains the plaintext data key or plaintext data.
ZeroKMS separates the capability across two systems. Stealing only the application's client key does not permit offline decryption of historical ciphertext, because the attacker still needs an authorized ZeroKMS interaction. Compromising only ZeroKMS is also insufficient because it never receives the client key.
A live attacker controlling an authorized application can still request operations available to that application until access is revoked. The difference is that the capability remains scoped by keyset and authorization, is observed outside the application, and cannot be copied once as a reusable master key. See the [ZeroKMS trust model](https://cipherstash.com/docs/security/cryptography#trust-model).
Per-value keys without data-key caching [#per-value-keys-without-data-key-caching]
AWS KMS cryptographic APIs operate on individual requests and share regional request quotas. AWS recommends data-key caching when applications need to reduce `GenerateDataKey` traffic. Caching improves throughput by allowing one plaintext data key to protect multiple values, but it also increases the amount of data that key can decrypt.
ZeroKMS batches the server-side work, then derives each value's distinct key locally. A bulk operation therefore avoids one network round trip per value without turning the batch into one cryptographic failure domain.
This distinction matters for reads as well as writes. With envelope encryption, independently keyed values require their wrapped keys to be unwrapped. Reusing cached data keys reduces those calls only by placing more values under each reusable key. ZeroKMS retains per-value granularity across scattered query results.
Audit granularity [#audit-granularity]
CloudTrail can record the KMS API operation, principal, KMS key, and request context. If one unwrapped or cached data key decrypts many application values locally, KMS cannot infer which of those values the application read.
CipherStash key derivation is tied to the value's key ID and keyset. ZeroKMS participates before plaintext recovery, so the independent audit event follows the same per-value boundary as the encryption design. When federated identity is used, that event can also be associated with the authenticated user and lock context.
Searching encrypted data [#searching-encrypted-data]
AWS KMS encrypts and decrypts bytes; it does not make ciphertext queryable. Building searchable fields on top of envelope encryption requires a separate indexing design, query transformation, and leakage analysis.
CipherStash includes that layer. The client emits ciphertext plus only the searchable terms declared for the column, and [EQL](https://cipherstash.com/docs/reference/eql) gives PostgreSQL typed equality, ordering, range, and fuzzy-match operations. The trade-offs of those terms are covered in [Searchable encryption](https://cipherstash.com/docs/concepts/searchable-encryption).
Performance and cost model [#performance-and-cost-model]
AWS KMS charges for customer-managed keys and API use; cryptographic operations also consume regional request quotas. The exact price and quota depend on key type and region, so production estimates should use the current [AWS KMS pricing](https://aws.amazon.com/kms/pricing/) and [request quota](https://docs.aws.amazon.com/kms/latest/developerguide/requests-per-second.html) documentation.
CipherStash moves repeated work into local derivation and supports bulk operations. That makes its network cost track the batch rather than the number of values in the batch. Database query performance is a separate concern: published EQL measurements are in [Benchmarks](https://cipherstash.com/docs/reference/benchmarks).
Which should you use? [#which-should-you-use]
AWS KMS is usually the better fit when [#aws-kms-is-usually-the-better-fit-when]
* you are encrypting AWS infrastructure such as S3 objects, EBS volumes, or service-managed resources;
* AWS IAM, CloudTrail, and regional KMS controls are already the operational standard; or
* the application does not need to query encrypted fields.
CipherStash is usually the better fit when [#cipherstash-is-usually-the-better-fit-when]
* performance is a primary requirement: ZeroKMS batches the server-side work and derives per-value keys locally, avoiding one KMS network operation per value;
* individual application values need independent keys;
* the key service must not be capable of decrypting data by itself;
* encrypted PostgreSQL fields still need equality, range, ordering, or fuzzy-match queries;
* application identity needs to participate in cryptographic authorization; or
* batching must not require reusing data keys.
Use both when [#use-both-when]
AWS KMS protects infrastructure and root key material while CipherStash protects sensitive fields inside the application. CipherStash does not replace disk, volume, object, or backup encryption; those layers protect different failure modes.
Related [#related]
* [Cryptography and key derivation](https://cipherstash.com/docs/security/cryptography)
* [Searchable encryption](https://cipherstash.com/docs/concepts/searchable-encryption)
* [AWS KMS concepts](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html)
# CipherStash vs homomorphic encryption
Source: https://cipherstash.com/docs/concepts/compare/fhe
CipherStash is sometimes described as homomorphic encryption for databases. It is not. CipherStash uses several specialized searchable-encryption mechanisms, each built for a database operation such as equality, ordering, range, or fuzzy text matching.
Fully homomorphic encryption (FHE) pursues a more general goal: evaluate arbitrary computations over ciphertext and decrypt the result without revealing the inputs to the computing party.
That difference in ambition drives the practical trade-off. FHE can express computations that CipherStash cannot. CipherStash supports a deliberately narrower query surface that runs inside ordinary PostgreSQL with conventional indexes.
At a glance [#at-a-glance]
| | Fully homomorphic encryption | CipherStash searchable encryption |
| -------------------------------------- | ------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------- |
| Goal | General computation over ciphertext | Practical encrypted database queries |
| Computation model | Arithmetic or Boolean circuits supported by the FHE scheme | Purpose-built equality, ordering, range, fuzzy-match, and JSON terms |
| Database integration | Usually custom application and execution layers | PostgreSQL domains, operators, functions, B-tree and GIN indexes through EQL |
| Information revealed to the data store | Depends on the scheme and surrounding protocol; ciphertext aims to hide inputs and intermediate values | Explicitly reveals equality, order, or probabilistic token overlap for enabled query capabilities |
| Unsupported today in CipherStash | Arbitrary functions, encrypted `SUM` and `AVG`, general ML inference | Not applicable |
| Best fit | Computation where hiding inputs from the computing party justifies substantial complexity | OLTP and application search over protected PostgreSQL fields |
Why specialization is faster [#why-specialization-is-faster]
An FHE comparison or equality operation is evaluated as a cryptographic circuit. CipherStash does not evaluate that circuit. It stores a purpose-built term that PostgreSQL can compare or index directly.
For example:
* an equality-enabled column carries an HMAC term;
* an orderable column carries an OPE or block-ORE term; and
* a fuzzy-match text column carries an encrypted Bloom-filter term.
The database learns the structure required for that operation, but gains a query path that resembles a normal indexed PostgreSQL query. [Searchable encryption](https://cipherstash.com/docs/concepts/searchable-encryption) explains exactly what each term reveals.
Primitive benchmark: TFHE and ORE [#primitive-benchmark-tfhe-and-ore]
CipherStash maintains a small open-source benchmark that compares similar primitive operations in the `tfhe` and `ore-rs` libraries. On the recorded Apple M2 run:
| Operation | TFHE | ORE | Approximate difference |
| ----------------- | ------: | -----: | ---------------------: |
| Encrypt one value | 11.3 ms | 374 µs | 30x |
| Equality | 151 ms | 756 ns | 200,000x |
| Greater than | 162 ms | 750 ns | 215,000x |
| Less than | 166 ms | 755 ns | 220,000x |
These are **primitive microbenchmarks**, not a claim that every FHE system or every CipherStash query has those timings. They compare one TFHE implementation with one ORE implementation on one machine. The harness and full results are published at [cipherstash/tfhe-ore-bench](https://github.com/cipherstash/tfhe-ore-bench).
The comparison illustrates why a specialized predicate can be dramatically cheaper than evaluating a general encrypted circuit. End-to-end database performance also includes planning, index traversal, row retrieval, network time, and client decryption.
Database performance [#database-performance]
EQL's database benchmarks compare encrypted columns with plaintext PostgreSQL using equivalent indexes. At one million rows on the reference machine:
| Query | Encrypted median | Relative to plaintext |
| ---------------------------- | ---------------: | --------------------: |
| Exact equality | 0.12 ms | 1.3x |
| OPE range and ordering | 0.12 ms | 1.2x |
| Block-ORE range and ordering | 0.52 ms | 5.2x |
| JSON containment | 0.40 ms | 1.4x |
Those results measure EQL v3 on PostgreSQL 17, not the SDK-to-database round trip. Methodology, scaling results, ingest performance, and reproduction commands are in [Benchmarks](https://cipherstash.com/docs/reference/benchmarks).
What CipherStash supports [#what-cipherstash-supports]
EQL v3 column domains declare the searchable capability stored with each value:
| Capability | Typical operations | Stored structure |
| ------------------ | --------------------------------------------------------- | ------------------------------------------------------------------------------- |
| Equality | `=`, `<>`, `IN`, equijoins, `GROUP BY`, `DISTINCT` | HMAC equality term, or an equality-lossless ordering term for some scalar types |
| Ordering and range | `<`, `<=`, `>`, `>=`, `BETWEEN`, `ORDER BY`, `MIN`, `MAX` | CLLW OPE or block-ORE term |
| Fuzzy text match | `@@` | Encrypted Bloom-filter term |
| JSON search | Path equality, range, and containment | Per-path searchable terms |
The full type and operator surface is in [EQL core concepts](https://cipherstash.com/docs/reference/eql/core-concepts).
CipherStash does not currently support arithmetic over encrypted values. `SUM`, `AVG`, multiplication, and arbitrary user-defined computations require decryption at the application boundary or a different cryptographic system. That boundary is intentional rather than hidden behind an inefficient fallback.
Leakage is the central trade-off [#leakage-is-the-central-trade-off]
FHE is designed so the computing party can evaluate a supported circuit without learning the plaintext inputs or intermediate values. Its practical security still depends on the complete protocol, including who holds keys, which outputs are revealed, and whether access patterns are visible.
CipherStash makes a different bargain. A column stores only the terms required by its declared query capabilities:
* equality terms reveal which encrypted values repeat;
* ordering terms reveal relative order; and
* fuzzy-match terms reveal probabilistic token overlap.
This structure is what lets PostgreSQL use ordinary index machinery. Teams should enable only the capabilities the application actually needs, especially for low-cardinality or highly predictable data.
Operational differences [#operational-differences]
CipherStash keeps the database model familiar:
* encrypted values are JSON-backed EQL domains;
* ordinary SQL operators express supported queries;
* B-tree and GIN indexes accelerate the corresponding terms;
* the Stack SDK, ORM integrations, or Proxy encrypt query operands; and
* PostgreSQL never receives the data key or plaintext operand.
FHE applications generally need a computation expressed for a particular scheme or compiler, ciphertext parameter management, evaluation-key distribution, and an execution environment sized for the circuit. That can be the correct engineering choice when the computation itself must remain hidden, but it is a different system from adding encrypted predicates to an existing relational application.
Which should you use? [#which-should-you-use]
FHE is the better fit when [#fhe-is-the-better-fit-when]
* an untrusted compute service must evaluate a genuinely general function over private inputs;
* the required computation cannot be reduced to CipherStash's supported query capabilities;
* encrypted inference, private analytics, or multiparty computation is central to the product; and
* the latency, ciphertext size, and operational complexity fit the workload.
CipherStash is the better fit when [#cipherstash-is-the-better-fit-when]
* the application needs equality, range, ordering, fuzzy matching, or JSON search over protected fields;
* queries must run in standard PostgreSQL and work with existing SQL tooling;
* low-latency OLTP behavior matters; and
* the team accepts the explicit leakage profile of the selected capabilities.
The choice is not “strong cryptography versus weak cryptography.” It is general encrypted computation versus specialized encrypted queries with different performance and disclosure properties.
Related [#related]
* [Searchable encryption](https://cipherstash.com/docs/concepts/searchable-encryption)
* [EQL reference](https://cipherstash.com/docs/reference/eql)
* [EQL benchmarks](https://cipherstash.com/docs/reference/benchmarks)
* [TFHE/ORE benchmark source](https://github.com/cipherstash/tfhe-ore-bench)
# CipherStash vs HashiCorp Vault
Source: https://cipherstash.com/docs/concepts/compare/hashicorp-vault
HashiCorp Vault is a broad secrets-management and cryptographic platform. The closest comparison with CipherStash is its **Transit secrets engine**, which offers encryption operations without storing the application data.
For high-volume application data encryption, ZeroKMS has two decisive advantages:
1. **Performance:** ZeroKMS was designed to derive a unique key for every value in bulk. A batch requires one service interaction, while final key derivation and encryption happen locally and scale with the application.
2. **Security:** Vault either receives the plaintext or holds everything required to unwrap its data keys. ZeroKMS never receives plaintext and cannot derive a usable data key without the client key held in your environment.
Vault remains a strong general-purpose platform for secrets, PKI, signing, and centralized cryptographic services. ZeroKMS is the stronger fit when the workload is protecting large volumes of application values.
Performance is the first difference [#performance-is-the-first-difference]
Vault Transit supports batching, but the work still follows one of two centralized models.
Direct Transit centralizes every cryptographic operation [#direct-transit-centralizes-every-cryptographic-operation]
In direct mode, the application sends every plaintext value to Vault. Vault encrypts every value and returns the ciphertext. `batch_input` reduces the number of HTTP round trips, but it does not move the cryptographic work out of the Vault cluster.
Throughput therefore depends on the capacity of the Vault deployment. Scaling application workers does not scale encryption unless the Vault cluster scales with them. Every byte of plaintext also crosses the service boundary in both directions over its lifetime: into Vault for encryption and out of Vault after decryption.
Transit envelope mode still produces complete data keys [#transit-envelope-mode-still-produces-complete-data-keys]
Envelope mode moves the final encryption into the application. Vault generates a plaintext data key plus a wrapped copy, the application encrypts locally, and the wrapped data key is stored with the ciphertext. Decryption sends that wrapped key back to Vault to recover the plaintext data key.
Current Vault versions document a plural `datakeys` endpoint that can return multiple key pairs in one request. That removes the old one-request-per-key limitation, but Vault must still generate and wrap a complete data key for every independently keyed value. The application must persist every wrapped data key and send it back for unwrapping on reads.
ZeroKMS was designed for per-value bulk encryption [#zerokms-was-designed-for-per-value-bulk-encryption]
ZeroKMS returns key seeds rather than complete data keys. One bulk service interaction supplies the material for a batch, then the application combines each seed with its client key and derives each value's unique data key locally.
The final derivation and AES operations scale horizontally with the application rather than being concentrated in the key-service cluster. No plaintext data key is transmitted, no wrapped data key is persisted, and performance does not depend on reusing or caching a data key across values.
| Performance property | Vault direct | Vault envelope | ZeroKMS |
| ---------------------------------------- | -------------------------------------- | -------------------------------------------------- | ----------------------------------------------------- |
| Network interactions for a batch | One with `batch_input` | One where plural `datakeys` is available | One bulk interaction |
| Who performs value encryption? | Vault cluster | Application | Application |
| Server-side work per value | Encrypt or decrypt the value | Generate, wrap, or unwrap a complete data key | Produce seed material; final derivation remains local |
| Material stored per value | Vault ciphertext | Ciphertext plus wrapped data key | Ciphertext plus non-secret key ID |
| How encryption throughput scales | Scale the Vault cluster | Scale Vault key generation and application workers | Scale application workers |
| Does performance require data-key reuse? | A named Transit key is normally shared | Reuse is optional but expands key blast radius | No; every value always receives a unique key |
The exact latency of Vault depends on cluster size, storage, seal configuration, network placement, and mode. The architectural distinction is stable: ZeroKMS keeps the network interaction at batch granularity while distributing the final cryptographic work across the application fleet.
The security model is the second difference [#the-security-model-is-the-second-difference]
Vault direct mode sees plaintext [#vault-direct-mode-sees-plaintext]
Direct Transit is encryption as a remote service. The application sends plaintext to Vault and Vault returns it during decryption. Anyone who controls the authorized Vault boundary has a path to both keys and data during the operation.
Policies, audit devices, HSM-backed seals, and operational controls can harden that boundary. They do not remove it from the plaintext trust model.
Vault envelope mode can unwrap every data key [#vault-envelope-mode-can-unwrap-every-data-key]
Envelope encryption keeps application plaintext out of Vault, but Vault still holds the Transit key that unwraps every stored data key. An authorized Vault operation can return a complete plaintext data key without needing cryptographic material held separately by the application.
Envelope mode also introduces durable wrapped-key material that must be stored and mapped to the correct ciphertext. If a plaintext data key is copied from application memory, it remains usable offline for every value protected by that key.
ZeroKMS splits the decryption capability [#zerokms-splits-the-decryption-capability]
ZeroKMS holds an authority key. The application holds a client key that never leaves its environment. Neither side can derive a data key alone, and the two long-lived components are never brought together.
The encrypted payload contains a key ID, not a wrapped data key. Stealing the client key alone does not permit offline decryption of historical ciphertext; ZeroKMS must still authorize and participate in future derivations. Compromising ZeroKMS alone is also insufficient because it never receives the client key.
A live attacker controlling an authorized application can use the operations granted to it until access is revoked. The important difference is that the capability remains **scoped, observable, and revocable** rather than becoming a complete key that can be copied and used offline.
| Security property | Vault direct | Vault envelope | ZeroKMS |
| -------------------------------------------- | ------------------------------------------------- | ------------------------------------------------------------------ | ---------------------------------------------------------- |
| Plaintext reaches the key service | Yes | No | No |
| Key service can enable decryption alone | Yes | Yes, by unwrapping the data key | No |
| Client-held cryptographic half required | No | No | Yes |
| Complete data key crosses the network | Not exposed to the application in direct mode | Yes | No |
| Per-value key material stored | Ciphertext carries the Transit key version | Wrapped data key | Non-secret key ID |
| Unique key per value | Must be designed through context or separate keys | Must be designed through separate data keys | Always |
| Offline value of a copied application secret | A Vault token still needs the Vault service | A copied plaintext data key can decrypt every value that reused it | The client key alone cannot derive any historical data key |
The full ZeroKMS mechanism and compromise model are in [Cryptography](https://cipherstash.com/docs/security/cryptography#trust-model).
Audit granularity [#audit-granularity]
Vault audit devices record requests to the service. In direct mode, a batch records a Transit operation over the batch. In envelope mode, Vault observes data-key generation and unwrapping; how those keys map to application records is left to the application's storage and metadata design.
ZeroKMS makes the value's key ID and keyset part of derivation. Every decryption needs server participation before plaintext recovery, so independent audit follows the same per-value boundary as the key model. Federated identity and lock contexts can also bind that operation to an authenticated end user. See [Provable access control](https://cipherstash.com/docs/solutions/provable-access).
Searching encrypted data [#searching-encrypted-data]
Vault's convergent encryption can make the same plaintext and context produce the same ciphertext, enabling limited deterministic lookup. It exposes equality directly in the ciphertext and does not provide range, ordering, fuzzy matching, JSON search, or PostgreSQL operator integration by itself.
CipherStash separates randomized ciphertext from purpose-built search terms. The EQL domain selected for a column declares exactly which operations it supports and which structure the database learns. See [Searchable encryption](https://cipherstash.com/docs/concepts/searchable-encryption) for the leakage model and [EQL core concepts](https://cipherstash.com/docs/reference/eql/core-concepts) for the type system.
Which should you use? [#which-should-you-use]
CipherStash ZeroKMS is usually the better fit when [#cipherstash-zerokms-is-usually-the-better-fit-when]
* **performance is a primary requirement for high-volume field encryption;**
* the key service must never receive plaintext or possess enough material to decrypt alone;
* unique per-value keys must not require key caching or reuse;
* PostgreSQL must query protected fields while they remain encrypted; or
* key derivation, database types, SDKs, ORM wrappers, audit, and identity binding should work as one system.
Vault Transit is usually the better fit when [#vault-transit-is-usually-the-better-fit-when]
* Vault is already the organization's standard security platform;
* the workload needs Vault's broader secrets, PKI, signing, HMAC, or tokenization capabilities;
* centralized encryption inside the Vault boundary is acceptable; or
* the organization wants to own and operate the complete cryptographic service.
The products can coexist: Vault can manage infrastructure secrets and other cryptographic workloads while CipherStash protects high-volume, queryable application data.
Related [#related]
* [Vault Transit documentation](https://developer.hashicorp.com/vault/docs/secrets/transit)
* [Vault Transit API](https://developer.hashicorp.com/vault/api-docs/secret/transit)
* [Cryptography and key derivation](https://cipherstash.com/docs/security/cryptography)
* [Searchable encryption](https://cipherstash.com/docs/concepts/searchable-encryption)
# Comparisons
Source: https://cipherstash.com/docs/concepts/compare
CipherStash combines application-level encryption, zero-trust key management, and purpose-built searchable encryption. These pages compare that combination with tools that overlap with one part of the system.
Centralized cloud key management compared with ZeroKMS split control and per-value key derivation.
Vault Transit direct and envelope modes compared with ZeroKMS and searchable encryption.
Where HSMs fit, what operating one entails, and how the two approaches can complement each other.
Specialized encrypted database queries compared with general computation over ciphertext.
# ZeroKMS vs hardware security modules
Source: https://cipherstash.com/docs/concepts/compare/zerokms-vs-hsm
A hardware security module (HSM) is a tamper-resistant hardware boundary for generating, storing, and using cryptographic keys. ZeroKMS is a key-management protocol and service for deriving application data keys without either the service or application holding enough long-lived material to derive them alone.
They are not exact substitutes. An HSM answers **where and under whose physical control a key is protected**. ZeroKMS answers **how authority is divided and how a unique key is made practical for every application value**.
Where HSMs fit [#where-hsms-fit]
HSMs are commonly used to protect certificate-authority keys, payment keys, code-signing keys, database master keys, and the root keys behind managed KMS products. They provide a well-defined cryptographic boundary, strong resistance to key extraction, and certifications required by some regulatory or procurement regimes.
An HSM does not by itself provide an application encryption model. Teams still need to decide:
* which keys exist and how much data each protects;
* how applications authenticate and are authorized;
* whether applications send plaintext to the HSM boundary or receive data keys;
* how keys are rotated, backed up, replicated, and destroyed; and
* how database queries work over encrypted fields.
ZeroKMS is focused on those application-level decisions. Its authority keys are protected server-side, while each workload holds a separate client key. The two sides produce unique data keys locally through the process described in [Cryptography](https://cipherstash.com/docs/security/cryptography#how-a-data-key-is-produced).
Comparison [#comparison]
| Property | Dedicated HSM deployment | CipherStash ZeroKMS |
| ------------------------------- | --------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------ |
| Primary security boundary | Tamper-resistant hardware and its operator controls | Split authority key and client key in separate environments |
| Long-lived key custody | Customer or cloud operator controls the HSM partition | CipherStash protects the authority side; customer protects the client side |
| Application data-key model | Designed by the customer or KMS layer built above it | Unique derived key for every encrypted value |
| Can one boundary decrypt alone? | Usually yes, when the HSM and authorization policy permit the operation | No; neither authority nor client key is sufficient alone |
| Application integration | PKCS #11, JCE, CNG, or a KMS/service layer | Stack SDK, ORM integrations, or CipherStash Proxy |
| Scaling | Appliance, partition, cluster, or provider capacity planning | Batched server interaction and local per-value derivation |
| High availability and recovery | Customer or provider must design clustering, backup, quorum, and ceremonies | Operated as part of the ZeroKMS service; encrypted application data remains in the customer's database |
| Searchable database fields | Not supplied by the HSM | Built into CipherStash through EQL |
Custody and split control [#custody-and-split-control]
Owning an HSM gives an organization direct control over the hardware boundary and its administrative procedures. That can be essential when a policy requires customer-held hardware, witnessed key ceremonies, a particular FIPS validation level, or an offline signing environment.
Hardware custody does not automatically create split cryptographic control. An authorized application or operator may still ask the HSM to use the protected key. The security boundary is strong, but it is centralized.
ZeroKMS distributes that capability. The authority side can produce only a key seed; it cannot turn that seed into a data key. The client side cannot reproduce seeds by itself. Compromise must cross both boundaries, and client access can be revoked at ZeroKMS without relying on the application to honor the decision.
Integration and operations [#integration-and-operations]
Direct HSM integration normally uses low-level standards such as PKCS #11, or a higher-level key-management service built on top. Production operation also needs capacity planning, redundant devices or partitions, secure backup, credential quorum, monitoring, firmware management, and tested disaster recovery.
Those costs can be worthwhile when the HSM boundary is itself the requirement. They are often unnecessary complexity when the real requirement is protecting application fields with fine-grained, revocable keys.
CipherStash provides that higher layer. The SDK and Proxy handle encryption payloads, key IDs, bulk derivation, searchable terms, and identity binding. The database stores ciphertext while ZeroKMS handles only the server side of key derivation.
Performance and key granularity [#performance-and-key-granularity]
An HSM performs bounded cryptographic operations. Giving every database value a unique HSM-backed key can turn a bulk query into many service or device operations, so systems commonly introduce envelope keys, caching, or reuse.
ZeroKMS batches the server-side work and derives the final keys locally. Every value can retain a distinct key without sending every encryption operation through a hardware boundary and without keeping a cache of plaintext data keys.
When to choose an HSM [#when-to-choose-an-hsm]
A dedicated HSM is usually appropriate when:
* a regulation, customer contract, or internal policy explicitly requires a validated hardware boundary;
* the organization must retain physical or administrative custody of root keys;
* keys must operate in an offline or air-gapped environment;
* the workload is certificate issuance, payment processing, signing, or another HSM-native use case; or
* the organization already has the people and procedures to operate the hardware safely.
When to choose ZeroKMS [#when-to-choose-zerokms]
ZeroKMS is usually appropriate when:
* the workload is field-level application encryption;
* one service or operator must not hold unilateral decryption capability;
* each value needs an independent key and audit boundary;
* high-volume batches must not require data-key reuse; or
* encrypted PostgreSQL data still needs to be queried.
Using ZeroKMS and an HSM together [#using-zerokms-and-an-hsm-together]
The strongest design may use both. An HSM or HSM-backed cloud KMS can protect root key material, while ZeroKMS supplies split control and per-value derivation above it. The HSM remains the hardened foundation; ZeroKMS defines the application-facing trust model.
Related [#related]
* [Cryptography and key derivation](https://cipherstash.com/docs/security/cryptography)
* [ZeroKMS vs AWS KMS](https://cipherstash.com/docs/concepts/compare/aws-kms)
# Compliance
Source: https://cipherstash.com/docs/security/compliance
CipherStash supplies technical controls that can support a compliance program:
field-level encryption, regional key management, cryptographic isolation,
identity-bound decryption, and data-access evidence. A framework outcome still
depends on how those controls are configured and on the surrounding application,
cloud, operational, and organizational controls.
Capability map [#capability-map]
| Requirement area | Relevant CipherStash capability | Customer responsibility |
| ------------------------------- | --------------------------------------------------------- | ---------------------------------------------------------------------------------------- |
| Protect sensitive stored data | Application-level field encryption | Classify fields and ensure every write path encrypts them |
| Restrict key access | Client keys, access-key roles, and keyset grants | Apply least privilege, rotate credentials, and control the deployment secret store |
| Isolate tenants or environments | Separate keysets or workspaces | Define and enforce the boundary consistently in application and database access |
| Attribute access to a user | OIDC federation and lock contexts | Configure the identity provider and choose stable, appropriate claims |
| Produce data-access evidence | ZeroKMS derivation context and Proxy audit events | Configure retention, review, alerting, and SIEM ingestion |
| Keep key material regional | Region-bound workspaces | Deploy applications and databases in the intended region and govern cross-border access |
| Remove access to encrypted data | Revoke client grants or destroy the relevant key boundary | Confirm scope, backups, legal holds, and recovery requirements before destructive action |
Common frameworks [#common-frameworks]
These capabilities can contribute evidence or control implementation for
frameworks such as SOC 2, HIPAA, GDPR, PCI DSS, ISO 27001, and regional privacy
laws. They do not by themselves make a workload compliant, and the exact
mapping depends on the organization's scope and assessor interpretation.
Use the following pages when building a control narrative:
* [Cryptography](https://cipherstash.com/docs/security/cryptography) for algorithms, key hierarchy, data
flow, and trust boundaries.
* [Key management](https://cipherstash.com/docs/concepts/key-management) for per-value keys, split control,
keysets, and revocation.
* [Data residency](https://cipherstash.com/docs/solutions/data-residency) for regional deployment patterns.
* [Provable access control](https://cipherstash.com/docs/solutions/provable-access) and
[audit logging](https://cipherstash.com/docs/concepts/access-analytics) for identity and evidence.
* [Access keys](https://cipherstash.com/docs/reference/auth/access-keys) and
[client keys](https://cipherstash.com/docs/reference/auth/clients) for least-privilege credentials.
Contact [support@cipherstash.com](mailto:support@cipherstash.com) for current
assurance reports, contractual documents, or framework-specific questions.
# codec-types
Source: https://cipherstash.com/docs/integrations/prisma/api-reference/codec-types
[**@cipherstash/stack-prisma**](./)
***
Type Aliases [#type-aliases]
CodecTypes [#codectypes]
```ts
type CodecTypes = {
cipherstash/eql-v3/eql_v3_integer@1: V3Codec<number, EncryptedNumber, V3TraitsNone>;
cipherstash/eql-v3/eql_v3_integer_eq@1: V3Codec<number, EncryptedNumber, V3TraitsEq>;
cipherstash/eql-v3/eql_v3_integer_ord_ore@1: V3Codec<number, EncryptedNumber, V3TraitsOrd>;
cipherstash/eql-v3/eql_v3_integer_ord@1: V3Codec<number, EncryptedNumber, V3TraitsOrd>;
cipherstash/eql-v3/eql_v3_smallint@1: V3Codec<number, EncryptedNumber, V3TraitsNone>;
cipherstash/eql-v3/eql_v3_smallint_eq@1: V3Codec<number, EncryptedNumber, V3TraitsEq>;
cipherstash/eql-v3/eql_v3_smallint_ord_ore@1: V3Codec<number, EncryptedNumber, V3TraitsOrd>;
cipherstash/eql-v3/eql_v3_smallint_ord@1: V3Codec<number, EncryptedNumber, V3TraitsOrd>;
cipherstash/eql-v3/eql_v3_bigint@1: V3Codec<bigint, EncryptedBigInt, V3TraitsNone>;
cipherstash/eql-v3/eql_v3_bigint_eq@1: V3Codec<bigint, EncryptedBigInt, V3TraitsEq>;
cipherstash/eql-v3/eql_v3_bigint_ord_ore@1: V3Codec<bigint, EncryptedBigInt, V3TraitsOrd>;
cipherstash/eql-v3/eql_v3_bigint_ord@1: V3Codec<bigint, EncryptedBigInt, V3TraitsOrd>;
cipherstash/eql-v3/eql_v3_date@1: V3Codec<Date, EncryptedDate, V3TraitsNone>;
cipherstash/eql-v3/eql_v3_date_eq@1: V3Codec<Date, EncryptedDate, V3TraitsEq>;
cipherstash/eql-v3/eql_v3_date_ord_ore@1: V3Codec<Date, EncryptedDate, V3TraitsOrd>;
cipherstash/eql-v3/eql_v3_date_ord@1: V3Codec<Date, EncryptedDate, V3TraitsOrd>;
cipherstash/eql-v3/eql_v3_timestamp@1: V3Codec<Date, EncryptedDate, V3TraitsNone>;
cipherstash/eql-v3/eql_v3_timestamp_eq@1: V3Codec<Date, EncryptedDate, V3TraitsEq>;
cipherstash/eql-v3/eql_v3_timestamp_ord_ore@1: V3Codec<Date, EncryptedDate, V3TraitsOrd>;
cipherstash/eql-v3/eql_v3_timestamp_ord@1: V3Codec<Date, EncryptedDate, V3TraitsOrd>;
cipherstash/eql-v3/eql_v3_numeric@1: V3Codec<number, EncryptedNumber, V3TraitsNone>;
cipherstash/eql-v3/eql_v3_numeric_eq@1: V3Codec<number, EncryptedNumber, V3TraitsEq>;
cipherstash/eql-v3/eql_v3_numeric_ord_ore@1: V3Codec<number, EncryptedNumber, V3TraitsOrd>;
cipherstash/eql-v3/eql_v3_numeric_ord@1: V3Codec<number, EncryptedNumber, V3TraitsOrd>;
cipherstash/eql-v3/eql_v3_text@1: V3Codec<string, EncryptedString, V3TraitsNone>;
cipherstash/eql-v3/eql_v3_text_eq@1: V3Codec<string, EncryptedString, V3TraitsEq>;
cipherstash/eql-v3/eql_v3_text_match@1: V3Codec<string, EncryptedString, V3TraitsMatch>;
cipherstash/eql-v3/eql_v3_text_ord_ore@1: V3Codec<string, EncryptedString, V3TraitsOrd>;
cipherstash/eql-v3/eql_v3_text_ord@1: V3Codec<string, EncryptedString, V3TraitsOrd>;
cipherstash/eql-v3/eql_v3_text_search@1: V3Codec<string, EncryptedString, V3TraitsSearch>;
cipherstash/eql-v3/eql_v3_boolean@1: V3Codec<boolean, EncryptedBoolean, V3TraitsNone>;
cipherstash/eql-v3/eql_v3_real@1: V3Codec<number, EncryptedNumber, V3TraitsNone>;
cipherstash/eql-v3/eql_v3_real_eq@1: V3Codec<number, EncryptedNumber, V3TraitsEq>;
cipherstash/eql-v3/eql_v3_real_ord_ore@1: V3Codec<number, EncryptedNumber, V3TraitsOrd>;
cipherstash/eql-v3/eql_v3_real_ord@1: V3Codec<number, EncryptedNumber, V3TraitsOrd>;
cipherstash/eql-v3/eql_v3_double@1: V3Codec<number, EncryptedNumber, V3TraitsNone>;
cipherstash/eql-v3/eql_v3_double_eq@1: V3Codec<number, EncryptedNumber, V3TraitsEq>;
cipherstash/eql-v3/eql_v3_double_ord_ore@1: V3Codec<number, EncryptedNumber, V3TraitsOrd>;
cipherstash/eql-v3/eql_v3_double_ord@1: V3Codec<number, EncryptedNumber, V3TraitsOrd>;
cipherstash/eql-v3/eql_v3_json_search@1: {
input: unknown;
output: EncryptedJson;
traits: V3TraitsJson;
};
};
```
Defined in: [codec-types.ts:94](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/types/codec-types.ts#L94)
Codec-types subpath entry for the cipherstash extension. Re-exports
the hand-written `CodecTypes` table from `../types/codec-types` so
the contract emitter can pull it via
`import type { CodecTypes as CipherstashTypes } from '@prisma-next/extension-cipherstash/codec-types'`.
Mirrors `packages/3-extensions/pgvector/src/exports/codec-types.ts`.
Properties [#properties]
cipherstash/eql-v3/eql_v3_integer@1 [#cipherstasheql-v3eql_v3_integer1]
```ts
readonly cipherstash/eql-v3/eql_v3_integer@1: V3Codec<number, EncryptedNumber, V3TraitsNone>;
```
Defined in: [codec-types.ts:103](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/types/codec-types.ts#L103)
cipherstash/eql-v3/eql_v3_integer_eq@1 [#cipherstasheql-v3eql_v3_integer_eq1]
```ts
readonly cipherstash/eql-v3/eql_v3_integer_eq@1: V3Codec<number, EncryptedNumber, V3TraitsEq>;
```
Defined in: [codec-types.ts:108](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/types/codec-types.ts#L108)
cipherstash/eql-v3/eql_v3_integer_ord_ore@1 [#cipherstasheql-v3eql_v3_integer_ord_ore1]
```ts
readonly cipherstash/eql-v3/eql_v3_integer_ord_ore@1: V3Codec<number, EncryptedNumber, V3TraitsOrd>;
```
Defined in: [codec-types.ts:113](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/types/codec-types.ts#L113)
cipherstash/eql-v3/eql_v3_integer_ord@1 [#cipherstasheql-v3eql_v3_integer_ord1]
```ts
readonly cipherstash/eql-v3/eql_v3_integer_ord@1: V3Codec<number, EncryptedNumber, V3TraitsOrd>;
```
Defined in: [codec-types.ts:118](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/types/codec-types.ts#L118)
cipherstash/eql-v3/eql_v3_smallint@1 [#cipherstasheql-v3eql_v3_smallint1]
```ts
readonly cipherstash/eql-v3/eql_v3_smallint@1: V3Codec<number, EncryptedNumber, V3TraitsNone>;
```
Defined in: [codec-types.ts:123](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/types/codec-types.ts#L123)
cipherstash/eql-v3/eql_v3_smallint_eq@1 [#cipherstasheql-v3eql_v3_smallint_eq1]
```ts
readonly cipherstash/eql-v3/eql_v3_smallint_eq@1: V3Codec<number, EncryptedNumber, V3TraitsEq>;
```
Defined in: [codec-types.ts:128](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/types/codec-types.ts#L128)
cipherstash/eql-v3/eql_v3_smallint_ord_ore@1 [#cipherstasheql-v3eql_v3_smallint_ord_ore1]
```ts
readonly cipherstash/eql-v3/eql_v3_smallint_ord_ore@1: V3Codec<number, EncryptedNumber, V3TraitsOrd>;
```
Defined in: [codec-types.ts:133](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/types/codec-types.ts#L133)
cipherstash/eql-v3/eql_v3_smallint_ord@1 [#cipherstasheql-v3eql_v3_smallint_ord1]
```ts
readonly cipherstash/eql-v3/eql_v3_smallint_ord@1: V3Codec<number, EncryptedNumber, V3TraitsOrd>;
```
Defined in: [codec-types.ts:138](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/types/codec-types.ts#L138)
cipherstash/eql-v3/eql_v3_bigint@1 [#cipherstasheql-v3eql_v3_bigint1]
```ts
readonly cipherstash/eql-v3/eql_v3_bigint@1: V3Codec<bigint, EncryptedBigInt, V3TraitsNone>;
```
Defined in: [codec-types.ts:143](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/types/codec-types.ts#L143)
cipherstash/eql-v3/eql_v3_bigint_eq@1 [#cipherstasheql-v3eql_v3_bigint_eq1]
```ts
readonly cipherstash/eql-v3/eql_v3_bigint_eq@1: V3Codec<bigint, EncryptedBigInt, V3TraitsEq>;
```
Defined in: [codec-types.ts:148](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/types/codec-types.ts#L148)
cipherstash/eql-v3/eql_v3_bigint_ord_ore@1 [#cipherstasheql-v3eql_v3_bigint_ord_ore1]
```ts
readonly cipherstash/eql-v3/eql_v3_bigint_ord_ore@1: V3Codec<bigint, EncryptedBigInt, V3TraitsOrd>;
```
Defined in: [codec-types.ts:153](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/types/codec-types.ts#L153)
cipherstash/eql-v3/eql_v3_bigint_ord@1 [#cipherstasheql-v3eql_v3_bigint_ord1]
```ts
readonly cipherstash/eql-v3/eql_v3_bigint_ord@1: V3Codec<bigint, EncryptedBigInt, V3TraitsOrd>;
```
Defined in: [codec-types.ts:158](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/types/codec-types.ts#L158)
cipherstash/eql-v3/eql_v3_date@1 [#cipherstasheql-v3eql_v3_date1]
```ts
readonly cipherstash/eql-v3/eql_v3_date@1: V3Codec<Date, EncryptedDate, V3TraitsNone>;
```
Defined in: [codec-types.ts:163](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/types/codec-types.ts#L163)
cipherstash/eql-v3/eql_v3_date_eq@1 [#cipherstasheql-v3eql_v3_date_eq1]
```ts
readonly cipherstash/eql-v3/eql_v3_date_eq@1: V3Codec<Date, EncryptedDate, V3TraitsEq>;
```
Defined in: [codec-types.ts:168](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/types/codec-types.ts#L168)
cipherstash/eql-v3/eql_v3_date_ord_ore@1 [#cipherstasheql-v3eql_v3_date_ord_ore1]
```ts
readonly cipherstash/eql-v3/eql_v3_date_ord_ore@1: V3Codec<Date, EncryptedDate, V3TraitsOrd>;
```
Defined in: [codec-types.ts:173](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/types/codec-types.ts#L173)
cipherstash/eql-v3/eql_v3_date_ord@1 [#cipherstasheql-v3eql_v3_date_ord1]
```ts
readonly cipherstash/eql-v3/eql_v3_date_ord@1: V3Codec<Date, EncryptedDate, V3TraitsOrd>;
```
Defined in: [codec-types.ts:178](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/types/codec-types.ts#L178)
cipherstash/eql-v3/eql_v3_timestamp@1 [#cipherstasheql-v3eql_v3_timestamp1]
```ts
readonly cipherstash/eql-v3/eql_v3_timestamp@1: V3Codec<Date, EncryptedDate, V3TraitsNone>;
```
Defined in: [codec-types.ts:183](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/types/codec-types.ts#L183)
cipherstash/eql-v3/eql_v3_timestamp_eq@1 [#cipherstasheql-v3eql_v3_timestamp_eq1]
```ts
readonly cipherstash/eql-v3/eql_v3_timestamp_eq@1: V3Codec<Date, EncryptedDate, V3TraitsEq>;
```
Defined in: [codec-types.ts:188](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/types/codec-types.ts#L188)
cipherstash/eql-v3/eql_v3_timestamp_ord_ore@1 [#cipherstasheql-v3eql_v3_timestamp_ord_ore1]
```ts
readonly cipherstash/eql-v3/eql_v3_timestamp_ord_ore@1: V3Codec<Date, EncryptedDate, V3TraitsOrd>;
```
Defined in: [codec-types.ts:193](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/types/codec-types.ts#L193)
cipherstash/eql-v3/eql_v3_timestamp_ord@1 [#cipherstasheql-v3eql_v3_timestamp_ord1]
```ts
readonly cipherstash/eql-v3/eql_v3_timestamp_ord@1: V3Codec<Date, EncryptedDate, V3TraitsOrd>;
```
Defined in: [codec-types.ts:198](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/types/codec-types.ts#L198)
cipherstash/eql-v3/eql_v3_numeric@1 [#cipherstasheql-v3eql_v3_numeric1]
```ts
readonly cipherstash/eql-v3/eql_v3_numeric@1: V3Codec<number, EncryptedNumber, V3TraitsNone>;
```
Defined in: [codec-types.ts:203](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/types/codec-types.ts#L203)
cipherstash/eql-v3/eql_v3_numeric_eq@1 [#cipherstasheql-v3eql_v3_numeric_eq1]
```ts
readonly cipherstash/eql-v3/eql_v3_numeric_eq@1: V3Codec<number, EncryptedNumber, V3TraitsEq>;
```
Defined in: [codec-types.ts:208](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/types/codec-types.ts#L208)
cipherstash/eql-v3/eql_v3_numeric_ord_ore@1 [#cipherstasheql-v3eql_v3_numeric_ord_ore1]
```ts
readonly cipherstash/eql-v3/eql_v3_numeric_ord_ore@1: V3Codec<number, EncryptedNumber, V3TraitsOrd>;
```
Defined in: [codec-types.ts:213](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/types/codec-types.ts#L213)
cipherstash/eql-v3/eql_v3_numeric_ord@1 [#cipherstasheql-v3eql_v3_numeric_ord1]
```ts
readonly cipherstash/eql-v3/eql_v3_numeric_ord@1: V3Codec<number, EncryptedNumber, V3TraitsOrd>;
```
Defined in: [codec-types.ts:218](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/types/codec-types.ts#L218)
cipherstash/eql-v3/eql_v3_text@1 [#cipherstasheql-v3eql_v3_text1]
```ts
readonly cipherstash/eql-v3/eql_v3_text@1: V3Codec<string, EncryptedString, V3TraitsNone>;
```
Defined in: [codec-types.ts:223](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/types/codec-types.ts#L223)
cipherstash/eql-v3/eql_v3_text_eq@1 [#cipherstasheql-v3eql_v3_text_eq1]
```ts
readonly cipherstash/eql-v3/eql_v3_text_eq@1: V3Codec<string, EncryptedString, V3TraitsEq>;
```
Defined in: [codec-types.ts:228](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/types/codec-types.ts#L228)
cipherstash/eql-v3/eql_v3_text_match@1 [#cipherstasheql-v3eql_v3_text_match1]
```ts
readonly cipherstash/eql-v3/eql_v3_text_match@1: V3Codec<string, EncryptedString, V3TraitsMatch>;
```
Defined in: [codec-types.ts:233](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/types/codec-types.ts#L233)
cipherstash/eql-v3/eql_v3_text_ord_ore@1 [#cipherstasheql-v3eql_v3_text_ord_ore1]
```ts
readonly cipherstash/eql-v3/eql_v3_text_ord_ore@1: V3Codec<string, EncryptedString, V3TraitsOrd>;
```
Defined in: [codec-types.ts:238](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/types/codec-types.ts#L238)
cipherstash/eql-v3/eql_v3_text_ord@1 [#cipherstasheql-v3eql_v3_text_ord1]
```ts
readonly cipherstash/eql-v3/eql_v3_text_ord@1: V3Codec<string, EncryptedString, V3TraitsOrd>;
```
Defined in: [codec-types.ts:243](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/types/codec-types.ts#L243)
cipherstash/eql-v3/eql_v3_text_search@1 [#cipherstasheql-v3eql_v3_text_search1]
```ts
readonly cipherstash/eql-v3/eql_v3_text_search@1: V3Codec<string, EncryptedString, V3TraitsSearch>;
```
Defined in: [codec-types.ts:248](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/types/codec-types.ts#L248)
cipherstash/eql-v3/eql_v3_boolean@1 [#cipherstasheql-v3eql_v3_boolean1]
```ts
readonly cipherstash/eql-v3/eql_v3_boolean@1: V3Codec<boolean, EncryptedBoolean, V3TraitsNone>;
```
Defined in: [codec-types.ts:253](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/types/codec-types.ts#L253)
cipherstash/eql-v3/eql_v3_real@1 [#cipherstasheql-v3eql_v3_real1]
```ts
readonly cipherstash/eql-v3/eql_v3_real@1: V3Codec<number, EncryptedNumber, V3TraitsNone>;
```
Defined in: [codec-types.ts:258](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/types/codec-types.ts#L258)
cipherstash/eql-v3/eql_v3_real_eq@1 [#cipherstasheql-v3eql_v3_real_eq1]
```ts
readonly cipherstash/eql-v3/eql_v3_real_eq@1: V3Codec<number, EncryptedNumber, V3TraitsEq>;
```
Defined in: [codec-types.ts:263](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/types/codec-types.ts#L263)
cipherstash/eql-v3/eql_v3_real_ord_ore@1 [#cipherstasheql-v3eql_v3_real_ord_ore1]
```ts
readonly cipherstash/eql-v3/eql_v3_real_ord_ore@1: V3Codec<number, EncryptedNumber, V3TraitsOrd>;
```
Defined in: [codec-types.ts:268](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/types/codec-types.ts#L268)
cipherstash/eql-v3/eql_v3_real_ord@1 [#cipherstasheql-v3eql_v3_real_ord1]
```ts
readonly cipherstash/eql-v3/eql_v3_real_ord@1: V3Codec<number, EncryptedNumber, V3TraitsOrd>;
```
Defined in: [codec-types.ts:273](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/types/codec-types.ts#L273)
cipherstash/eql-v3/eql_v3_double@1 [#cipherstasheql-v3eql_v3_double1]
```ts
readonly cipherstash/eql-v3/eql_v3_double@1: V3Codec<number, EncryptedNumber, V3TraitsNone>;
```
Defined in: [codec-types.ts:278](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/types/codec-types.ts#L278)
cipherstash/eql-v3/eql_v3_double_eq@1 [#cipherstasheql-v3eql_v3_double_eq1]
```ts
readonly cipherstash/eql-v3/eql_v3_double_eq@1: V3Codec<number, EncryptedNumber, V3TraitsEq>;
```
Defined in: [codec-types.ts:283](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/types/codec-types.ts#L283)
cipherstash/eql-v3/eql_v3_double_ord_ore@1 [#cipherstasheql-v3eql_v3_double_ord_ore1]
```ts
readonly cipherstash/eql-v3/eql_v3_double_ord_ore@1: V3Codec<number, EncryptedNumber, V3TraitsOrd>;
```
Defined in: [codec-types.ts:288](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/types/codec-types.ts#L288)
cipherstash/eql-v3/eql_v3_double_ord@1 [#cipherstasheql-v3eql_v3_double_ord1]
```ts
readonly cipherstash/eql-v3/eql_v3_double_ord@1: V3Codec<number, EncryptedNumber, V3TraitsOrd>;
```
Defined in: [codec-types.ts:293](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/types/codec-types.ts#L293)
cipherstash/eql-v3/eql_v3_json_search@1 [#cipherstasheql-v3eql_v3_json_search1]
```ts
readonly cipherstash/eql-v3/eql_v3_json_search@1: {
input: unknown;
output: EncryptedJson;
traits: V3TraitsJson;
};
```
Defined in: [codec-types.ts:302](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/types/codec-types.ts#L302)
input [#input]
```ts
readonly input: unknown;
```
output [#output]
```ts
readonly output: EncryptedJson;
```
traits [#traits]
```ts
readonly traits: V3TraitsJson;
```
# column-types
Source: https://cipherstash.com/docs/integrations/prisma/api-reference/column-types
[**@cipherstash/stack-prisma**](./)
***
Interfaces [#interfaces]
V3ColumnDescriptor [#v3columndescriptor]
Defined in: [column-types.ts:53](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/exports/column-types.ts#L53)
Literal-preserving authoring descriptor, generic over the concrete stack
column `C`. `codecId`, `nativeType`, and `capabilities` are the domain's
LITERAL types (not `string` / `unknown`), so two domains' factories are
mutually non-assignable — this is the type spine (design "Type Discipline").
`castAs` is the one field the stack widens (`build(): ColumnSchema`), which
is harmless: `nativeType` already discriminates every domain. Pinned by the
type-level tests in `test/v3/column-types.test-d.ts`.
Type Parameters [#type-parameters]
C [#c]
`C` *extends* `AnyEncryptedV3Column`
Properties [#properties]
codecId [#codecid]
```ts
readonly codecId: `cipherstash/eql-v3/${StripPublic<EqlTypeFromGetter<C>>}@1`;
```
Defined in: [column-types.ts:54](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/exports/column-types.ts#L54)
nativeType [#nativetype]
```ts
readonly nativeType: EqlTypeFromGetter<C>;
```
Defined in: [column-types.ts:55](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/exports/column-types.ts#L55)
typeParams [#typeparams]
```ts
readonly typeParams: {
castAs: V3CastAs;
capabilities: CapabilitiesFromGetter<C>;
};
```
Defined in: [column-types.ts:56](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/exports/column-types.ts#L56)
castAs [#castas]
```ts
readonly castAs: V3CastAs;
```
capabilities [#capabilities]
```ts
readonly capabilities: CapabilitiesFromGetter<C>;
```
Variables [#variables]
text() [#text]
```ts
const text: () => V3ColumnDescriptor<EncryptedTextColumn>;
```
Defined in: [column-types.ts:105](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/exports/column-types.ts#L105)
Returns [#returns]
[`V3ColumnDescriptor`](https://cipherstash.com/docs/integrations/prisma/api-reference/column-types#v3columndescriptor)\<`EncryptedTextColumn`>
***
textEq() [#texteq]
```ts
const textEq: () => V3ColumnDescriptor<EncryptedTextEqColumn>;
```
Defined in: [column-types.ts:106](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/exports/column-types.ts#L106)
Returns [#returns-1]
[`V3ColumnDescriptor`](https://cipherstash.com/docs/integrations/prisma/api-reference/column-types#v3columndescriptor)\<`EncryptedTextEqColumn`>
***
textOrd() [#textord]
```ts
const textOrd: () => V3ColumnDescriptor<EncryptedTextOrdColumn>;
```
Defined in: [column-types.ts:107](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/exports/column-types.ts#L107)
Returns [#returns-2]
[`V3ColumnDescriptor`](https://cipherstash.com/docs/integrations/prisma/api-reference/column-types#v3columndescriptor)\<`EncryptedTextOrdColumn`>
***
textMatch() [#textmatch]
```ts
const textMatch: () => V3ColumnDescriptor<EncryptedTextMatchColumn>;
```
Defined in: [column-types.ts:108](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/exports/column-types.ts#L108)
Returns [#returns-3]
[`V3ColumnDescriptor`](https://cipherstash.com/docs/integrations/prisma/api-reference/column-types#v3columndescriptor)\<`EncryptedTextMatchColumn`>
***
textSearch() [#textsearch]
```ts
const textSearch: () => V3ColumnDescriptor<EncryptedTextSearchColumn>;
```
Defined in: [column-types.ts:109](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/exports/column-types.ts#L109)
Returns [#returns-4]
[`V3ColumnDescriptor`](https://cipherstash.com/docs/integrations/prisma/api-reference/column-types#v3columndescriptor)\<`EncryptedTextSearchColumn`>
***
integer() [#integer]
```ts
const integer: () => V3ColumnDescriptor<EncryptedIntegerColumn>;
```
Defined in: [column-types.ts:111](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/exports/column-types.ts#L111)
Returns [#returns-5]
[`V3ColumnDescriptor`](https://cipherstash.com/docs/integrations/prisma/api-reference/column-types#v3columndescriptor)\<`EncryptedIntegerColumn`>
***
integerEq() [#integereq]
```ts
const integerEq: () => V3ColumnDescriptor<EncryptedIntegerEqColumn>;
```
Defined in: [column-types.ts:112](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/exports/column-types.ts#L112)
Returns [#returns-6]
[`V3ColumnDescriptor`](https://cipherstash.com/docs/integrations/prisma/api-reference/column-types#v3columndescriptor)\<`EncryptedIntegerEqColumn`>
***
integerOrd() [#integerord]
```ts
const integerOrd: () => V3ColumnDescriptor<EncryptedIntegerOrdColumn>;
```
Defined in: [column-types.ts:113](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/exports/column-types.ts#L113)
Returns [#returns-7]
[`V3ColumnDescriptor`](https://cipherstash.com/docs/integrations/prisma/api-reference/column-types#v3columndescriptor)\<`EncryptedIntegerOrdColumn`>
***
smallint() [#smallint]
```ts
const smallint: () => V3ColumnDescriptor<EncryptedSmallintColumn>;
```
Defined in: [column-types.ts:115](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/exports/column-types.ts#L115)
Returns [#returns-8]
[`V3ColumnDescriptor`](https://cipherstash.com/docs/integrations/prisma/api-reference/column-types#v3columndescriptor)\<`EncryptedSmallintColumn`>
***
smallintEq() [#smallinteq]
```ts
const smallintEq: () => V3ColumnDescriptor<EncryptedSmallintEqColumn>;
```
Defined in: [column-types.ts:116](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/exports/column-types.ts#L116)
Returns [#returns-9]
[`V3ColumnDescriptor`](https://cipherstash.com/docs/integrations/prisma/api-reference/column-types#v3columndescriptor)\<`EncryptedSmallintEqColumn`>
***
smallintOrd() [#smallintord]
```ts
const smallintOrd: () => V3ColumnDescriptor<EncryptedSmallintOrdColumn>;
```
Defined in: [column-types.ts:117](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/exports/column-types.ts#L117)
Returns [#returns-10]
[`V3ColumnDescriptor`](https://cipherstash.com/docs/integrations/prisma/api-reference/column-types#v3columndescriptor)\<`EncryptedSmallintOrdColumn`>
***
bigInt() [#bigint]
```ts
const bigInt: () => V3ColumnDescriptor<EncryptedBigintColumn>;
```
Defined in: [column-types.ts:119](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/exports/column-types.ts#L119)
Returns [#returns-11]
[`V3ColumnDescriptor`](https://cipherstash.com/docs/integrations/prisma/api-reference/column-types#v3columndescriptor)\<`EncryptedBigintColumn`>
***
bigIntEq() [#biginteq]
```ts
const bigIntEq: () => V3ColumnDescriptor<EncryptedBigintEqColumn>;
```
Defined in: [column-types.ts:120](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/exports/column-types.ts#L120)
Returns [#returns-12]
[`V3ColumnDescriptor`](https://cipherstash.com/docs/integrations/prisma/api-reference/column-types#v3columndescriptor)\<`EncryptedBigintEqColumn`>
***
bigIntOrd() [#bigintord]
```ts
const bigIntOrd: () => V3ColumnDescriptor<EncryptedBigintOrdColumn>;
```
Defined in: [column-types.ts:121](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/exports/column-types.ts#L121)
Returns [#returns-13]
[`V3ColumnDescriptor`](https://cipherstash.com/docs/integrations/prisma/api-reference/column-types#v3columndescriptor)\<`EncryptedBigintOrdColumn`>
***
numeric() [#numeric]
```ts
const numeric: () => V3ColumnDescriptor<EncryptedNumericColumn>;
```
Defined in: [column-types.ts:123](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/exports/column-types.ts#L123)
Returns [#returns-14]
[`V3ColumnDescriptor`](https://cipherstash.com/docs/integrations/prisma/api-reference/column-types#v3columndescriptor)\<`EncryptedNumericColumn`>
***
numericEq() [#numericeq]
```ts
const numericEq: () => V3ColumnDescriptor<EncryptedNumericEqColumn>;
```
Defined in: [column-types.ts:124](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/exports/column-types.ts#L124)
Returns [#returns-15]
[`V3ColumnDescriptor`](https://cipherstash.com/docs/integrations/prisma/api-reference/column-types#v3columndescriptor)\<`EncryptedNumericEqColumn`>
***
numericOrd() [#numericord]
```ts
const numericOrd: () => V3ColumnDescriptor<EncryptedNumericOrdColumn>;
```
Defined in: [column-types.ts:125](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/exports/column-types.ts#L125)
Returns [#returns-16]
[`V3ColumnDescriptor`](https://cipherstash.com/docs/integrations/prisma/api-reference/column-types#v3columndescriptor)\<`EncryptedNumericOrdColumn`>
***
real() [#real]
```ts
const real: () => V3ColumnDescriptor<EncryptedRealColumn>;
```
Defined in: [column-types.ts:127](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/exports/column-types.ts#L127)
Returns [#returns-17]
[`V3ColumnDescriptor`](https://cipherstash.com/docs/integrations/prisma/api-reference/column-types#v3columndescriptor)\<`EncryptedRealColumn`>
***
realEq() [#realeq]
```ts
const realEq: () => V3ColumnDescriptor<EncryptedRealEqColumn>;
```
Defined in: [column-types.ts:128](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/exports/column-types.ts#L128)
Returns [#returns-18]
[`V3ColumnDescriptor`](https://cipherstash.com/docs/integrations/prisma/api-reference/column-types#v3columndescriptor)\<`EncryptedRealEqColumn`>
***
realOrd() [#realord]
```ts
const realOrd: () => V3ColumnDescriptor<EncryptedRealOrdColumn>;
```
Defined in: [column-types.ts:129](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/exports/column-types.ts#L129)
Returns [#returns-19]
[`V3ColumnDescriptor`](https://cipherstash.com/docs/integrations/prisma/api-reference/column-types#v3columndescriptor)\<`EncryptedRealOrdColumn`>
***
double() [#double]
```ts
const double: () => V3ColumnDescriptor<EncryptedDoubleColumn>;
```
Defined in: [column-types.ts:131](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/exports/column-types.ts#L131)
Returns [#returns-20]
[`V3ColumnDescriptor`](https://cipherstash.com/docs/integrations/prisma/api-reference/column-types#v3columndescriptor)\<`EncryptedDoubleColumn`>
***
doubleEq() [#doubleeq]
```ts
const doubleEq: () => V3ColumnDescriptor<EncryptedDoubleEqColumn>;
```
Defined in: [column-types.ts:132](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/exports/column-types.ts#L132)
Returns [#returns-21]
[`V3ColumnDescriptor`](https://cipherstash.com/docs/integrations/prisma/api-reference/column-types#v3columndescriptor)\<`EncryptedDoubleEqColumn`>
***
doubleOrd() [#doubleord]
```ts
const doubleOrd: () => V3ColumnDescriptor<EncryptedDoubleOrdColumn>;
```
Defined in: [column-types.ts:133](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/exports/column-types.ts#L133)
Returns [#returns-22]
[`V3ColumnDescriptor`](https://cipherstash.com/docs/integrations/prisma/api-reference/column-types#v3columndescriptor)\<`EncryptedDoubleOrdColumn`>
***
date() [#date]
```ts
const date: () => V3ColumnDescriptor<EncryptedDateColumn>;
```
Defined in: [column-types.ts:135](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/exports/column-types.ts#L135)
Returns [#returns-23]
[`V3ColumnDescriptor`](https://cipherstash.com/docs/integrations/prisma/api-reference/column-types#v3columndescriptor)\<`EncryptedDateColumn`>
***
dateEq() [#dateeq]
```ts
const dateEq: () => V3ColumnDescriptor<EncryptedDateEqColumn>;
```
Defined in: [column-types.ts:136](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/exports/column-types.ts#L136)
Returns [#returns-24]
[`V3ColumnDescriptor`](https://cipherstash.com/docs/integrations/prisma/api-reference/column-types#v3columndescriptor)\<`EncryptedDateEqColumn`>
***
dateOrd() [#dateord]
```ts
const dateOrd: () => V3ColumnDescriptor<EncryptedDateOrdColumn>;
```
Defined in: [column-types.ts:137](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/exports/column-types.ts#L137)
Returns [#returns-25]
[`V3ColumnDescriptor`](https://cipherstash.com/docs/integrations/prisma/api-reference/column-types#v3columndescriptor)\<`EncryptedDateOrdColumn`>
***
timestamp() [#timestamp]
```ts
const timestamp: () => V3ColumnDescriptor<EncryptedTimestampColumn>;
```
Defined in: [column-types.ts:139](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/exports/column-types.ts#L139)
Returns [#returns-26]
[`V3ColumnDescriptor`](https://cipherstash.com/docs/integrations/prisma/api-reference/column-types#v3columndescriptor)\<`EncryptedTimestampColumn`>
***
timestampEq() [#timestampeq]
```ts
const timestampEq: () => V3ColumnDescriptor<EncryptedTimestampEqColumn>;
```
Defined in: [column-types.ts:140](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/exports/column-types.ts#L140)
Returns [#returns-27]
[`V3ColumnDescriptor`](https://cipherstash.com/docs/integrations/prisma/api-reference/column-types#v3columndescriptor)\<`EncryptedTimestampEqColumn`>
***
timestampOrd() [#timestampord]
```ts
const timestampOrd: () => V3ColumnDescriptor<EncryptedTimestampOrdColumn>;
```
Defined in: [column-types.ts:141](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/exports/column-types.ts#L141)
Returns [#returns-28]
[`V3ColumnDescriptor`](https://cipherstash.com/docs/integrations/prisma/api-reference/column-types#v3columndescriptor)\<`EncryptedTimestampOrdColumn`>
***
boolean() [#boolean]
```ts
const boolean: () => V3ColumnDescriptor<EncryptedBooleanColumn>;
```
Defined in: [column-types.ts:143](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/exports/column-types.ts#L143)
Returns [#returns-29]
[`V3ColumnDescriptor`](https://cipherstash.com/docs/integrations/prisma/api-reference/column-types#v3columndescriptor)\<`EncryptedBooleanColumn`>
***
json() [#json]
```ts
const json: () => V3ColumnDescriptor<EncryptedJsonColumn>;
```
Defined in: [column-types.ts:145](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/exports/column-types.ts#L145)
Returns [#returns-30]
[`V3ColumnDescriptor`](https://cipherstash.com/docs/integrations/prisma/api-reference/column-types#v3columndescriptor)\<`EncryptedJsonColumn`>
# control
Source: https://cipherstash.com/docs/integrations/prisma/api-reference/control
[**@cipherstash/stack-prisma**](./)
***
Variables [#variables]
cipherstashExtensionDescriptor [#cipherstashextensiondescriptor]
```ts
const cipherstashExtensionDescriptor: SqlControlExtensionDescriptor<"postgres">;
```
Defined in: [control.ts:109](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/exports/control.ts#L109)
References [#references]
default [#default]
Renames and re-exports [cipherstashExtensionDescriptor](https://cipherstash.com/docs/integrations/prisma/api-reference/control#cipherstashextensiondescriptor)
# @cipherstash/stack-prisma
Source: https://cipherstash.com/docs/integrations/prisma/api-reference
**@cipherstash/stack-prisma**
***
Modules [#modules]
* [codec-types](https://cipherstash.com/docs/integrations/prisma/api-reference/codec-types)
* [column-types](https://cipherstash.com/docs/integrations/prisma/api-reference/column-types)
* [control](https://cipherstash.com/docs/integrations/prisma/api-reference/control)
* [operation-types](https://cipherstash.com/docs/integrations/prisma/api-reference/operation-types)
* [pack](https://cipherstash.com/docs/integrations/prisma/api-reference/pack)
* [runtime](https://cipherstash.com/docs/integrations/prisma/api-reference/runtime)
* [stack](https://cipherstash.com/docs/integrations/prisma/api-reference/stack)
* [v3](https://cipherstash.com/docs/integrations/prisma/api-reference/v3)
# operation-types
Source: https://cipherstash.com/docs/integrations/prisma/api-reference/operation-types
[**@cipherstash/stack-prisma**](./)
***
Type Aliases [#type-aliases]
QueryOperationTypes [#queryoperationtypes]
```ts
type QueryOperationTypes<CT> = CT extends CodecTypesBase ? {
eqlEq: {
self: {
traits: V3EqualityMarker;
};
impl: (self, other) => PgBoolReturn;
};
eqlNeq: {
self: {
traits: V3EqualityMarker;
};
impl: (self, other) => PgBoolReturn;
};
eqlIn: {
self: {
traits: V3EqualityMarker;
};
impl: (self, values) => PgBoolReturn;
};
eqlNotIn: {
self: {
traits: V3EqualityMarker;
};
impl: (self, values) => PgBoolReturn;
};
eqlGt: {
self: {
traits: V3OrderAndRangeMarker;
};
impl: (self, other) => PgBoolReturn;
};
eqlGte: {
self: {
traits: V3OrderAndRangeMarker;
};
impl: (self, other) => PgBoolReturn;
};
eqlLt: {
self: {
traits: V3OrderAndRangeMarker;
};
impl: (self, other) => PgBoolReturn;
};
eqlLte: {
self: {
traits: V3OrderAndRangeMarker;
};
impl: (self, other) => PgBoolReturn;
};
eqlBetween: {
self: {
traits: V3OrderAndRangeMarker;
};
impl: (self, low, high) => PgBoolReturn;
};
eqlNotBetween: {
self: {
traits: V3OrderAndRangeMarker;
};
impl: (self, low, high) => PgBoolReturn;
};
eqlMatch: {
self: {
traits: V3FreeTextSearchMarker;
};
impl: (self, needle) => PgBoolReturn;
};
eqlJsonContains: {
self: {
traits: V3SearchableJsonMarker;
};
impl: (self, needle) => PgBoolReturn;
};
eqlJsonPathEq: {
self: {
traits: V3SearchableJsonMarker;
};
impl: (self, path, value) => PgBoolReturn;
};
eqlJsonPathNeq: {
self: {
traits: V3SearchableJsonMarker;
};
impl: (self, path, value) => PgBoolReturn;
};
eqlJsonPathGt: {
self: {
traits: V3SearchableJsonMarker;
};
impl: (self, path, value) => PgBoolReturn;
};
eqlJsonPathGte: {
self: {
traits: V3SearchableJsonMarker;
};
impl: (self, path, value) => PgBoolReturn;
};
eqlJsonPathLt: {
self: {
traits: V3SearchableJsonMarker;
};
impl: (self, path, value) => PgBoolReturn;
};
eqlJsonPathLte: {
self: {
traits: V3SearchableJsonMarker;
};
impl: (self, path, value) => PgBoolReturn;
};
} : never;
```
Defined in: [operation-types.ts:87](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/types/operation-types.ts#L87)
Flat operation signatures consumed by the SQL query builder. Read
via the `queryOperations` slot on the runtime context to project the
cipherstash `eql*` predicate methods onto cipherstash column
accessors inside `model.where(...)` / `sql(t).where(...)` callbacks.
Every operator's runtime impl (`../v3/operators-v3.ts`) encrypts the
user-supplied argument(s) at lowering time and stamps the column's
`(table, column)` routing context, then lowers to the canonical EQL
v3 function call. The comparand argument type is intentionally
permissive (`unknown`): the column `self` is the encrypted column;
the comparand is plaintext the operator encrypts on the user's
behalf.
Type Parameters [#type-parameters]
CT [#ct]
`CT` *extends* `CodecTypesBase`
# pack
Source: https://cipherstash.com/docs/integrations/prisma/api-reference/pack
[**@cipherstash/stack-prisma**](./)
***
Variables [#variables]
default [#default]
```ts
const default: {
kind: "extension";
id: "cipherstash";
familyId: "sql";
targetId: "postgres";
version: "0.0.1";
authoring: {
type: AuthoringTypeNamespace;
};
types: {
codecTypes: {
codecInstances: readonly CipherstashCodecMetadata[];
import: {
package: "@prisma-next/extension-cipherstash/codec-types";
named: "CodecTypes";
alias: "CipherstashTypes";
};
typeImports: readonly [{
package: "@prisma-next/extension-cipherstash/runtime";
named: "EncryptedString";
alias: "EncryptedString";
}, {
package: "@prisma-next/extension-cipherstash/runtime";
named: "EncryptedBigInt";
alias: "EncryptedBigInt";
}, {
package: "@prisma-next/extension-cipherstash/runtime";
named: "EncryptedDate";
alias: "EncryptedDate";
}, {
package: "@prisma-next/extension-cipherstash/runtime";
named: "EncryptedBoolean";
alias: "EncryptedBoolean";
}, {
package: "@prisma-next/extension-cipherstash/runtime";
named: "EncryptedJson";
alias: "EncryptedJson";
}, {
package: "@prisma-next/extension-cipherstash/runtime";
named: "EncryptedNumber";
alias: "EncryptedNumber";
}];
};
queryOperationTypes: {
import: {
package: "@prisma-next/extension-cipherstash/operation-types";
named: "QueryOperationTypes";
alias: "CipherstashQueryOperationTypes";
};
};
storage: readonly {
typeId: string;
familyId: "sql";
targetId: "postgres";
nativeType: string;
}[];
};
};
```
Defined in: [descriptor-meta.ts:35](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/extension-metadata/descriptor-meta.ts#L35)
Pack entry point for the cipherstash extension.
Re-exports the SDK-free pack metadata so TS contract authoring
(`defineContract({ extensionPacks: { cipherstash: cipherstashPack } })`)
can enable the `cipherstash.*` PSL/TS namespace and the storage type
registration without pulling in any runtime code (envelope, SDK,
codec runtime, middleware).
Type Declaration [#type-declaration]
kind [#kind]
```ts
readonly kind: "extension" = 'extension';
```
id [#id]
```ts
readonly id: "cipherstash" = CIPHERSTASH_SPACE_ID;
```
familyId [#familyid]
```ts
readonly familyId: "sql" = 'sql';
```
targetId [#targetid]
```ts
readonly targetId: "postgres" = 'postgres';
```
version [#version]
```ts
readonly version: "0.0.1" = CIPHERSTASH_EXTENSION_VERSION;
```
authoring [#authoring]
```ts
readonly authoring: {
type: AuthoringTypeNamespace;
};
```
authoring.type [#authoringtype]
```ts
readonly type: AuthoringTypeNamespace = cipherstashAuthoringTypes;
```
types [#types]
```ts
readonly types: {
codecTypes: {
codecInstances: readonly CipherstashCodecMetadata[];
import: {
package: "@prisma-next/extension-cipherstash/codec-types";
named: "CodecTypes";
alias: "CipherstashTypes";
};
typeImports: readonly [{
package: "@prisma-next/extension-cipherstash/runtime";
named: "EncryptedString";
alias: "EncryptedString";
}, {
package: "@prisma-next/extension-cipherstash/runtime";
named: "EncryptedBigInt";
alias: "EncryptedBigInt";
}, {
package: "@prisma-next/extension-cipherstash/runtime";
named: "EncryptedDate";
alias: "EncryptedDate";
}, {
package: "@prisma-next/extension-cipherstash/runtime";
named: "EncryptedBoolean";
alias: "EncryptedBoolean";
}, {
package: "@prisma-next/extension-cipherstash/runtime";
named: "EncryptedJson";
alias: "EncryptedJson";
}, {
package: "@prisma-next/extension-cipherstash/runtime";
named: "EncryptedNumber";
alias: "EncryptedNumber";
}];
};
queryOperationTypes: {
import: {
package: "@prisma-next/extension-cipherstash/operation-types";
named: "QueryOperationTypes";
alias: "CipherstashQueryOperationTypes";
};
};
storage: readonly {
typeId: string;
familyId: "sql";
targetId: "postgres";
nativeType: string;
}[];
};
```
types.codecTypes [#typescodectypes]
```ts
readonly codecTypes: {
codecInstances: readonly CipherstashCodecMetadata[];
import: {
package: "@prisma-next/extension-cipherstash/codec-types";
named: "CodecTypes";
alias: "CipherstashTypes";
};
typeImports: readonly [{
package: "@prisma-next/extension-cipherstash/runtime";
named: "EncryptedString";
alias: "EncryptedString";
}, {
package: "@prisma-next/extension-cipherstash/runtime";
named: "EncryptedBigInt";
alias: "EncryptedBigInt";
}, {
package: "@prisma-next/extension-cipherstash/runtime";
named: "EncryptedDate";
alias: "EncryptedDate";
}, {
package: "@prisma-next/extension-cipherstash/runtime";
named: "EncryptedBoolean";
alias: "EncryptedBoolean";
}, {
package: "@prisma-next/extension-cipherstash/runtime";
named: "EncryptedJson";
alias: "EncryptedJson";
}, {
package: "@prisma-next/extension-cipherstash/runtime";
named: "EncryptedNumber";
alias: "EncryptedNumber";
}];
};
```
types.codecTypes.codecInstances [#typescodectypescodecinstances]
```ts
readonly codecInstances: readonly CipherstashCodecMetadata[];
```
types.codecTypes.import [#typescodectypesimport]
```ts
readonly import: {
package: "@prisma-next/extension-cipherstash/codec-types";
named: "CodecTypes";
alias: "CipherstashTypes";
};
```
types.codecTypes.import.package [#typescodectypesimportpackage]
```ts
readonly package: "@prisma-next/extension-cipherstash/codec-types" = '@prisma-next/extension-cipherstash/codec-types';
```
types.codecTypes.import.named [#typescodectypesimportnamed]
```ts
readonly named: "CodecTypes" = 'CodecTypes';
```
types.codecTypes.import.alias [#typescodectypesimportalias]
```ts
readonly alias: "CipherstashTypes" = 'CipherstashTypes';
```
types.codecTypes.typeImports [#typescodectypestypeimports]
```ts
readonly typeImports: readonly [{
package: "@prisma-next/extension-cipherstash/runtime";
named: "EncryptedString";
alias: "EncryptedString";
}, {
package: "@prisma-next/extension-cipherstash/runtime";
named: "EncryptedBigInt";
alias: "EncryptedBigInt";
}, {
package: "@prisma-next/extension-cipherstash/runtime";
named: "EncryptedDate";
alias: "EncryptedDate";
}, {
package: "@prisma-next/extension-cipherstash/runtime";
named: "EncryptedBoolean";
alias: "EncryptedBoolean";
}, {
package: "@prisma-next/extension-cipherstash/runtime";
named: "EncryptedJson";
alias: "EncryptedJson";
}, {
package: "@prisma-next/extension-cipherstash/runtime";
named: "EncryptedNumber";
alias: "EncryptedNumber";
}];
```
types.queryOperationTypes [#typesqueryoperationtypes]
```ts
readonly queryOperationTypes: {
import: {
package: "@prisma-next/extension-cipherstash/operation-types";
named: "QueryOperationTypes";
alias: "CipherstashQueryOperationTypes";
};
};
```
types.queryOperationTypes.import [#typesqueryoperationtypesimport]
```ts
readonly import: {
package: "@prisma-next/extension-cipherstash/operation-types";
named: "QueryOperationTypes";
alias: "CipherstashQueryOperationTypes";
};
```
types.queryOperationTypes.import.package [#typesqueryoperationtypesimportpackage]
```ts
readonly package: "@prisma-next/extension-cipherstash/operation-types" = '@prisma-next/extension-cipherstash/operation-types';
```
types.queryOperationTypes.import.named [#typesqueryoperationtypesimportnamed]
```ts
readonly named: "QueryOperationTypes" = 'QueryOperationTypes';
```
types.queryOperationTypes.import.alias [#typesqueryoperationtypesimportalias]
```ts
readonly alias: "CipherstashQueryOperationTypes" = 'CipherstashQueryOperationTypes';
```
types.storage [#typesstorage]
```ts
readonly storage: readonly {
typeId: string;
familyId: "sql";
targetId: "postgres";
nativeType: string;
}[];
```
# runtime
Source: https://cipherstash.com/docs/integrations/prisma/api-reference/runtime
[**@cipherstash/stack-prisma**](./)
***
Classes [#classes]
EncryptedBigInt [#encryptedbigint]
Defined in: [envelope-bigint.ts:27](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/execution/envelope-bigint.ts#L27)
Extends [#extends]
* `EncryptedEnvelopeBase`\<`bigint`>
Methods [#methods]
from() [#from]
```ts
static from(plaintext): EncryptedBigInt;
```
Defined in: [envelope-bigint.ts:79](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/execution/envelope-bigint.ts#L79)
Construct a write-side envelope from a plaintext `bigint`.
Bulk-encrypt middleware populates the handle's ciphertext slot
before the codec encodes the envelope to wire format.
Parameters [#parameters]
plaintext [#plaintext]
`bigint`
Returns [#returns]
[`EncryptedBigInt`](https://cipherstash.com/docs/integrations/prisma/api-reference/runtime#encryptedbigint)
fromInternal() [#frominternal]
```ts
static fromInternal(args): EncryptedBigInt;
```
Defined in: [envelope-bigint.ts:94](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/execution/envelope-bigint.ts#L94)
Construct a read-side envelope from a wire ciphertext + the column
identity + the SDK used to decrypt the cell. Called from the codec
`decode` body.
Parameters [#parameters-1]
args [#args]
`EncryptedEnvelopeFromInternalArgs`
Returns [#returns-1]
[`EncryptedBigInt`](https://cipherstash.com/docs/integrations/prisma/api-reference/runtime#encryptedbigint)
***
EncryptedBoolean [#encryptedboolean]
Defined in: [envelope-boolean.ts:21](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/execution/envelope-boolean.ts#L21)
Extends [#extends-1]
* `EncryptedEnvelopeBase`\<`boolean`>
Methods [#methods-1]
from() [#from-1]
```ts
static from(plaintext): EncryptedBoolean;
```
Defined in: [envelope-boolean.ts:26](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/execution/envelope-boolean.ts#L26)
Parameters [#parameters-2]
plaintext [#plaintext-1]
`boolean`
Returns [#returns-2]
[`EncryptedBoolean`](https://cipherstash.com/docs/integrations/prisma/api-reference/runtime#encryptedboolean)
fromInternal() [#frominternal-1]
```ts
static fromInternal(args): EncryptedBoolean;
```
Defined in: [envelope-boolean.ts:36](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/execution/envelope-boolean.ts#L36)
Parameters [#parameters-3]
args [#args-1]
`EncryptedEnvelopeFromInternalArgs`
Returns [#returns-3]
[`EncryptedBoolean`](https://cipherstash.com/docs/integrations/prisma/api-reference/runtime#encryptedboolean)
***
EncryptedDate [#encrypteddate]
Defined in: [envelope-date.ts:33](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/execution/envelope-date.ts#L33)
Extends [#extends-2]
* `EncryptedEnvelopeBase`\<`Date`>
Methods [#methods-2]
from() [#from-2]
```ts
static from(plaintext): EncryptedDate;
```
Defined in: [envelope-date.ts:79](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/execution/envelope-date.ts#L79)
Construct a write-side envelope from a `Date` plaintext.
Bulk-encrypt middleware populates the handle's ciphertext slot
before the codec encodes the envelope to wire format.
Parameters [#parameters-4]
plaintext [#plaintext-2]
`Date`
Returns [#returns-4]
[`EncryptedDate`](https://cipherstash.com/docs/integrations/prisma/api-reference/runtime#encrypteddate)
fromInternal() [#frominternal-2]
```ts
static fromInternal(args): EncryptedDate;
```
Defined in: [envelope-date.ts:99](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/execution/envelope-date.ts#L99)
Construct a read-side envelope from a wire ciphertext + the column
identity + the SDK used to decrypt the cell. Called from the codec
`decode` body.
Parameters [#parameters-5]
args [#args-2]
`EncryptedEnvelopeFromInternalArgs`
Returns [#returns-5]
[`EncryptedDate`](https://cipherstash.com/docs/integrations/prisma/api-reference/runtime#encrypteddate)
***
EncryptedJson [#encryptedjson]
Defined in: [envelope-json.ts:29](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/execution/envelope-json.ts#L29)
Extends [#extends-3]
* `EncryptedEnvelopeBase`\<`unknown`>
Methods [#methods-3]
from() [#from-3]
```ts
static from(plaintext): EncryptedJson;
```
Defined in: [envelope-json.ts:34](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/execution/envelope-json.ts#L34)
Parameters [#parameters-6]
plaintext [#plaintext-3]
`unknown`
Returns [#returns-6]
[`EncryptedJson`](https://cipherstash.com/docs/integrations/prisma/api-reference/runtime#encryptedjson)
fromInternal() [#frominternal-3]
```ts
static fromInternal(args): EncryptedJson;
```
Defined in: [envelope-json.ts:44](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/execution/envelope-json.ts#L44)
Parameters [#parameters-7]
args [#args-3]
`EncryptedEnvelopeFromInternalArgs`
Returns [#returns-7]
[`EncryptedJson`](https://cipherstash.com/docs/integrations/prisma/api-reference/runtime#encryptedjson)
***
EncryptedString [#encryptedstring]
Defined in: [envelope-string.ts:37](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/execution/envelope-string.ts#L37)
Extends [#extends-4]
* `EncryptedEnvelopeBase`\<`string`>
Methods [#methods-4]
from() [#from-4]
```ts
static from(plaintext): EncryptedString;
```
Defined in: [envelope-string.ts:47](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/execution/envelope-string.ts#L47)
Construct a write-side envelope from plaintext. Bulk-encrypt
middleware populates the handle's ciphertext slot before the codec
encodes the envelope to wire format.
Parameters [#parameters-8]
plaintext [#plaintext-4]
`string`
Returns [#returns-8]
[`EncryptedString`](https://cipherstash.com/docs/integrations/prisma/api-reference/runtime#encryptedstring)
fromInternal() [#frominternal-4]
```ts
static fromInternal(args): EncryptedString;
```
Defined in: [envelope-string.ts:62](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/execution/envelope-string.ts#L62)
Construct a read-side envelope from a wire ciphertext + the column
identity + the SDK used to decrypt the cell. Called from the codec
`decode` body.
Parameters [#parameters-9]
args [#args-4]
`EncryptedEnvelopeFromInternalArgs`
Returns [#returns-9]
[`EncryptedString`](https://cipherstash.com/docs/integrations/prisma/api-reference/runtime#encryptedstring)
***
CipherstashV3CellCodec [#cipherstashv3cellcodec]
Defined in: [codec-runtime-v3.ts:158](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/v3/codec-runtime-v3.ts#L158)
Extends [#extends-5]
* `CodecImpl`\<`string`, readonly `CodecTrait`\[], `unknown`, `E`>
Type Parameters [#type-parameters]
E [#e]
`E` *extends* `EncryptedEnvelopeBase`\<`unknown`>
Constructors [#constructors]
Constructor [#constructor]
```ts
new CipherstashV3CellCodec<E>(
descriptor,
sdk,
typeName,
fromInternal): CipherstashV3CellCodec<E>;
```
Defined in: [codec-runtime-v3.ts:173](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/v3/codec-runtime-v3.ts#L173)
Parameters [#parameters-10]
descriptor [#descriptor]
`AnyCodecDescriptor`
sdk [#sdk]
[`CipherstashSdk`](https://cipherstash.com/docs/integrations/prisma/api-reference/runtime#cipherstashsdk)
typeName [#typename]
`string`
fromInternal [#frominternal-5]
`FromInternal`
Returns [#returns-10]
[`CipherstashV3CellCodec`](https://cipherstash.com/docs/integrations/prisma/api-reference/runtime#cipherstashv3cellcodec)\<`E`>
Overrides [#overrides]
```ts
CodecImpl<string, readonly CodecTrait[], unknown, E>.constructor
```
Methods [#methods-5]
encode() [#encode]
```ts
encode(value, _ctx): Promise<unknown>;
```
Defined in: [codec-runtime-v3.ts:185](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/v3/codec-runtime-v3.ts#L185)
Parameters [#parameters-11]
value [#value]
`E`
_ctx [#_ctx]
`SqlCodecCallContext`
Returns [#returns-11]
`Promise`\<`unknown`>
Overrides [#overrides-1]
```ts
CodecImpl.encode
```
decode() [#decode]
```ts
decode(wire, ctx): Promise<E>;
```
Defined in: [codec-runtime-v3.ts:234](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/v3/codec-runtime-v3.ts#L234)
Parameters [#parameters-12]
wire [#wire]
`unknown`
ctx [#ctx]
`SqlCodecCallContext`
Returns [#returns-12]
`Promise`\<`E`>
Overrides [#overrides-2]
```ts
CodecImpl.decode
```
encodeJson() [#encodejson]
```ts
encodeJson(_value): JsonValue;
```
Defined in: [codec-runtime-v3.ts:315](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/v3/codec-runtime-v3.ts#L315)
Parameters [#parameters-13]
_value [#_value]
`E`
Returns [#returns-13]
`JsonValue`
Overrides [#overrides-3]
```ts
CodecImpl.encodeJson
```
decodeJson() [#decodejson]
```ts
decodeJson(json): E;
```
Defined in: [codec-runtime-v3.ts:347](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/v3/codec-runtime-v3.ts#L347)
Decode a v3 payload embedded in a database-produced JSON value —
the path the SQL runtime takes for a relation `include()`, where a
cell arrives inside a `json_agg` / `json_build_object` document with
no `SqlColumnRef` attached.
Routing comes from the payload's own `i` identifier, which is all
this path needs: the codec instance already closes over the SDK, so
the envelope it builds is indistinguishable from one built by
`decode`, and `decryptAll` batches it into the same
`(sdk, table, column)` group.
Note this is NOT the inverse of `encodeJson`, which deliberately
renders the opaque `$encrypted*` marker so a serialised envelope
never carries ciphertext. Round-tripping an `encodeJson` marker back
through here is not supported and raises below — the two methods
serve the write and read directions of different planes.
No NULL handling here by design: the SQL runtime short-circuits a
NULL cell before ever reaching a codec — the include-decode loop
(`sql-orm-client` `collection-dispatch`) skips `null`/`undefined`
column values, and the many-typed path skips `null` elements — so
this method, like `decode` (guarded by the runtime's `decodeField`),
only receives a non-null JSON payload. NULL-handling is the runtime's
contract, not the codec's; returning `null` here would also break the
framework's `decodeJson(json): TInput` (envelope) signature.
Parameters [#parameters-14]
json [#json]
`JsonValue`
Returns [#returns-14]
`E`
Overrides [#overrides-4]
```ts
CodecImpl.decodeJson
```
***
EncryptedNumber [#encryptednumber]
Defined in: [envelope-number.ts:29](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/v3/envelope-number.ts#L29)
Extends [#extends-6]
* `EncryptedEnvelopeBase`\<`number`>
Methods [#methods-6]
from() [#from-5]
```ts
static from(plaintext): EncryptedNumber;
```
Defined in: [envelope-number.ts:39](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/v3/envelope-number.ts#L39)
Construct a write-side envelope from a plaintext number. Bulk-encrypt
middleware populates the handle's ciphertext slot before the codec
encodes the envelope to wire format.
Parameters [#parameters-15]
plaintext [#plaintext-5]
`number`
Returns [#returns-15]
[`EncryptedNumber`](https://cipherstash.com/docs/integrations/prisma/api-reference/runtime#encryptednumber)
fromInternal() [#frominternal-6]
```ts
static fromInternal(args): EncryptedNumber;
```
Defined in: [envelope-number.ts:54](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/v3/envelope-number.ts#L54)
Construct a read-side envelope from a wire ciphertext + the column
identity + the SDK used to decrypt the cell. Called from the codec
`decode` body.
Parameters [#parameters-16]
args [#args-5]
`EncryptedEnvelopeFromInternalArgs`
Returns [#returns-16]
[`EncryptedNumber`](https://cipherstash.com/docs/integrations/prisma/api-reference/runtime#encryptednumber)
***
EncryptionOperatorError [#encryptionoperatorerror]
Defined in: [query-term.ts:37](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/v3/query-term.ts#L37)
A dedicated error for v3 operator gating, operand-coercion, and
misuse failures, carrying the offending column/table/operator for
diagnostics.
INTENTIONAL FORK of `@cipherstash/stack-drizzle`'s error of the same
name (same shape, same rationale): sharing it would couple two
independently-versioned public packages. v3-owned — the v2 operator
surface keeps throwing plain `TypeError`s.
Extends [#extends-7]
* `Error`
Constructors [#constructors-1]
Constructor [#constructor-1]
```ts
new EncryptionOperatorError(message, context?): EncryptionOperatorError;
```
Defined in: [query-term.ts:38](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/v3/query-term.ts#L38)
Parameters [#parameters-17]
message [#message]
`string`
context? [#context]
columnName? [#columnname]
`string`
tableName? [#tablename]
`string`
operator? [#operator]
`string`
Returns [#returns-17]
[`EncryptionOperatorError`](https://cipherstash.com/docs/integrations/prisma/api-reference/runtime#encryptionoperatorerror)
Overrides [#overrides-5]
```ts
Error.constructor
```
Properties [#properties]
context? [#context-1]
```ts
readonly optional context: {
columnName?: string;
tableName?: string;
operator?: string;
};
```
Defined in: [query-term.ts:40](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/v3/query-term.ts#L40)
columnName? [#columnname-1]
```ts
optional columnName: string;
```
tableName? [#tablename-1]
```ts
optional tableName: string;
```
operator? [#operator-1]
```ts
optional operator: string;
```
Interfaces [#interfaces]
DecryptAllOptions [#decryptalloptions]
Defined in: [decrypt-all.ts:68](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/execution/decrypt-all.ts#L68)
Runtime-plane entry point for the CipherStash extension (EQL v3).
Consumed at query time by application runtimes: the value envelopes
(`EncryptedString`, `EncryptedNumber`, `EncryptedBigInt`, …),
`decryptAll`, the CipherStash SDK shape the v3 codec runtime +
bulk-encrypt middleware depend on, and the v3 runtime descriptor /
operators.
The runtime entry point is deliberately separate from `./control`
(descriptor, codec lifecycle hook, contract-space artefacts) so apps
that only emit migrations against cipherstash never load the runtime,
and apps that only run queries never load the migration-time
descriptor — the control plane and runtime plane are tree-shakable
along this seam.
`createCipherstashV3RuntimeDescriptor({ sdk })` is the recommended
composition entry — it bundles the SDK-bound v3 codecs and the
runtime-plane `codecDescriptors` slot into a single
`SqlRuntimeExtensionDescriptor<'postgres'>`. The bulk-encrypt
middleware ships as `bulkEncryptMiddlewareV3(sdk)`.
Properties [#properties-1]
signal? [#signal]
```ts
readonly optional signal: AbortSignal;
```
Defined in: [decrypt-all.ts:69](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/execution/decrypt-all.ts#L69)
***
CipherstashRoutingKey [#cipherstashroutingkey]
Defined in: [sdk.ts:29](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/execution/sdk.ts#L29)
Routing-key tuple used by `bulkEncrypt`/`bulkDecrypt` to group requests
so each ZeroKMS round-trip handles one homogeneous batch. Routing key
is `(table, column)`.
Properties [#properties-2]
table [#table]
```ts
readonly table: string;
```
Defined in: [sdk.ts:30](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/execution/sdk.ts#L30)
column [#column]
```ts
readonly column: string;
```
Defined in: [sdk.ts:31](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/execution/sdk.ts#L31)
***
CipherstashSingleDecryptArgs [#cipherstashsingledecryptargs]
Defined in: [sdk.ts:34](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/execution/sdk.ts#L34)
Properties [#properties-3]
ciphertext [#ciphertext]
```ts
readonly ciphertext: unknown;
```
Defined in: [sdk.ts:40](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/execution/sdk.ts#L40)
The wire ciphertext to decrypt. Opaque to the framework; the SDK
inspects the embedded `i.t` / `i.c` schema markers to pick the
right `cast_as` for the round-trip.
table [#table-1]
```ts
readonly table: string;
```
Defined in: [sdk.ts:41](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/execution/sdk.ts#L41)
column [#column-1]
```ts
readonly column: string;
```
Defined in: [sdk.ts:42](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/execution/sdk.ts#L42)
signal? [#signal-1]
```ts
readonly optional signal: AbortSignal;
```
Defined in: [sdk.ts:43](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/execution/sdk.ts#L43)
***
CipherstashBulkEncryptArgs [#cipherstashbulkencryptargs]
Defined in: [sdk.ts:46](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/execution/sdk.ts#L46)
Properties [#properties-4]
routingKey [#routingkey]
```ts
readonly routingKey: CipherstashRoutingKey;
```
Defined in: [sdk.ts:47](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/execution/sdk.ts#L47)
values [#values]
```ts
readonly values: readonly unknown[];
```
Defined in: [sdk.ts:54](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/execution/sdk.ts#L54)
Plaintext values to encrypt. Polymorphic at the SDK boundary: each
batch is homogeneously typed by its `(table, column)` routing key,
so the SDK derives the EQL `cast_as` from the search-config already
registered on the column rather than from a per-batch hint.
signal? [#signal-2]
```ts
readonly optional signal: AbortSignal;
```
Defined in: [sdk.ts:55](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/execution/sdk.ts#L55)
***
CipherstashBulkDecryptArgs [#cipherstashbulkdecryptargs]
Defined in: [sdk.ts:58](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/execution/sdk.ts#L58)
Properties [#properties-5]
routingKey [#routingkey-1]
```ts
readonly routingKey: CipherstashRoutingKey;
```
Defined in: [sdk.ts:59](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/execution/sdk.ts#L59)
ciphertexts [#ciphertexts]
```ts
readonly ciphertexts: readonly unknown[];
```
Defined in: [sdk.ts:60](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/execution/sdk.ts#L60)
signal? [#signal-3]
```ts
readonly optional signal: AbortSignal;
```
Defined in: [sdk.ts:61](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/execution/sdk.ts#L61)
***
CipherstashSdk [#cipherstashsdk]
Defined in: [sdk.ts:70](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/execution/sdk.ts#L70)
The framework-native CipherStash SDK contract consumed by the envelope,
codec, middleware, and `decryptAll` surfaces. Real implementations wrap
a CipherStash `EncryptionClient`; tests construct mock SDKs that
implement these three methods directly.
Methods [#methods-7]
decrypt() [#decrypt]
```ts
decrypt(args): Promise<string>;
```
Defined in: [sdk.ts:71](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/execution/sdk.ts#L71)
Parameters [#parameters-18]
args [#args-6]
[`CipherstashSingleDecryptArgs`](https://cipherstash.com/docs/integrations/prisma/api-reference/runtime#cipherstashsingledecryptargs)
Returns [#returns-18]
`Promise`\<`string`>
bulkEncrypt() [#bulkencrypt]
```ts
bulkEncrypt(args): Promise<readonly unknown[]>;
```
Defined in: [sdk.ts:72](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/execution/sdk.ts#L72)
Parameters [#parameters-19]
args [#args-7]
[`CipherstashBulkEncryptArgs`](https://cipherstash.com/docs/integrations/prisma/api-reference/runtime#cipherstashbulkencryptargs)
Returns [#returns-19]
`Promise`\
bulkDecrypt() [#bulkdecrypt]
```ts
bulkDecrypt(args): Promise<readonly unknown[]>;
```
Defined in: [sdk.ts:73](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/execution/sdk.ts#L73)
Parameters [#parameters-20]
args [#args-8]
[`CipherstashBulkDecryptArgs`](https://cipherstash.com/docs/integrations/prisma/api-reference/runtime#cipherstashbulkdecryptargs)
Returns [#returns-20]
`Promise`\
***
CipherstashV3CodecParams [#cipherstashv3codecparams]
Defined in: [codec-runtime-v3.ts:64](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/v3/codec-runtime-v3.ts#L64)
Per-domain params emitted by v3 authoring as a static `typeParams`
block. Purely descriptive — the runtime codec ignores them (the
capability set already determined the descriptor's traits at
derivation time).
Properties [#properties-6]
castAs [#castas]
```ts
readonly castAs: string;
```
Defined in: [codec-runtime-v3.ts:65](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/v3/codec-runtime-v3.ts#L65)
capabilities [#capabilities]
```ts
readonly capabilities: object;
```
Defined in: [codec-runtime-v3.ts:66](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/v3/codec-runtime-v3.ts#L66)
***
CreateCipherstashV3RuntimeDescriptorOptions [#createcipherstashv3runtimedescriptoroptions]
Defined in: [runtime-v3.ts:36](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/v3/runtime-v3.ts#L36)
Properties [#properties-7]
sdk [#sdk-1]
```ts
readonly sdk: CipherstashSdk;
```
Defined in: [runtime-v3.ts:37](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/v3/runtime-v3.ts#L37)
Type Aliases [#type-aliases]
EncryptedBigIntHandle [#encryptedbiginthandle]
```ts
type EncryptedBigIntHandle = EncryptedEnvelopeHandle<bigint>;
```
Defined in: [envelope-bigint.ts:23](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/execution/envelope-bigint.ts#L23)
***
EncryptedBigIntFromInternalArgs [#encryptedbigintfrominternalargs]
```ts
type EncryptedBigIntFromInternalArgs = EncryptedEnvelopeFromInternalArgs;
```
Defined in: [envelope-bigint.ts:25](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/execution/envelope-bigint.ts#L25)
***
EncryptedBooleanHandle [#encryptedbooleanhandle]
```ts
type EncryptedBooleanHandle = EncryptedEnvelopeHandle<boolean>;
```
Defined in: [envelope-boolean.ts:17](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/execution/envelope-boolean.ts#L17)
***
EncryptedBooleanFromInternalArgs [#encryptedbooleanfrominternalargs]
```ts
type EncryptedBooleanFromInternalArgs = EncryptedEnvelopeFromInternalArgs;
```
Defined in: [envelope-boolean.ts:19](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/execution/envelope-boolean.ts#L19)
***
EncryptedDateHandle [#encrypteddatehandle]
```ts
type EncryptedDateHandle = EncryptedEnvelopeHandle<Date>;
```
Defined in: [envelope-date.ts:29](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/execution/envelope-date.ts#L29)
***
EncryptedDateFromInternalArgs [#encrypteddatefrominternalargs]
```ts
type EncryptedDateFromInternalArgs = EncryptedEnvelopeFromInternalArgs;
```
Defined in: [envelope-date.ts:31](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/execution/envelope-date.ts#L31)
***
EncryptedJsonHandle [#encryptedjsonhandle]
```ts
type EncryptedJsonHandle = EncryptedEnvelopeHandle<unknown>;
```
Defined in: [envelope-json.ts:25](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/execution/envelope-json.ts#L25)
***
EncryptedJsonFromInternalArgs [#encryptedjsonfrominternalargs]
```ts
type EncryptedJsonFromInternalArgs = EncryptedEnvelopeFromInternalArgs;
```
Defined in: [envelope-json.ts:27](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/execution/envelope-json.ts#L27)
***
EncryptedStringHandle [#encryptedstringhandle]
```ts
type EncryptedStringHandle = EncryptedEnvelopeHandle<string>;
```
Defined in: [envelope-string.ts:33](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/execution/envelope-string.ts#L33)
***
EncryptedStringFromInternalArgs [#encryptedstringfrominternalargs]
```ts
type EncryptedStringFromInternalArgs = EncryptedEnvelopeFromInternalArgs;
```
Defined in: [envelope-string.ts:35](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/execution/envelope-string.ts#L35)
***
CipherstashV3CodecId [#cipherstashv3codecid]
```ts
type CipherstashV3CodecId = `cipherstash/eql-v3/${StripSchema<EqlTypeFromGetter<AnyEncryptedV3Column>>}@1`;
```
Defined in: [constants-v3.ts:45](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/extension-metadata/constants-v3.ts#L45)
Compile-time closed union: one concrete codec id per catalog domain. A
catalog change that adds/drops a domain surfaces as a type error at the
`satisfies` line below. The domain segment is the GA registry key VERBATIM
(`eql_v3_*`); the leading `eql-v3` path token is the logical version tag.
***
EncryptedNumberHandle [#encryptednumberhandle]
```ts
type EncryptedNumberHandle = EncryptedEnvelopeHandle<number>;
```
Defined in: [envelope-number.ts:25](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/v3/envelope-number.ts#L25)
***
EncryptedNumberFromInternalArgs [#encryptednumberfrominternalargs]
```ts
type EncryptedNumberFromInternalArgs = EncryptedEnvelopeFromInternalArgs;
```
Defined in: [envelope-number.ts:27](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/v3/envelope-number.ts#L27)
***
V3QueryTermType [#v3querytermtype]
```ts
type V3QueryTermType = Extract<QueryTypeName,
| "equality"
| "orderAndRange"
| "freeTextSearch"
| "searchableJson"
| "steVecSelector"
| "steVecValueSelector"
| "steVecTerm">;
```
Defined in: [query-term.ts:57](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/v3/query-term.ts#L57)
The query-term flavours a v3 operator can mint — the subset of the
stack's `QueryTypeName` union used by the v3 operators. JSON selector
predicates use the explicit SteVec flavours because path hashing,
value-selector equality, and scalar ordering have distinct wire shapes.
Variables [#variables]
CIPHERSTASH_V3_CODEC_IDS [#cipherstash_v3_codec_ids]
```ts
const CIPHERSTASH_V3_CODEC_IDS: readonly ["cipherstash/eql-v3/eql_v3_integer@1", "cipherstash/eql-v3/eql_v3_integer_eq@1", "cipherstash/eql-v3/eql_v3_integer_ord_ore@1", "cipherstash/eql-v3/eql_v3_integer_ord@1", "cipherstash/eql-v3/eql_v3_smallint@1", "cipherstash/eql-v3/eql_v3_smallint_eq@1", "cipherstash/eql-v3/eql_v3_smallint_ord_ore@1", "cipherstash/eql-v3/eql_v3_smallint_ord@1", "cipherstash/eql-v3/eql_v3_bigint@1", "cipherstash/eql-v3/eql_v3_bigint_eq@1", "cipherstash/eql-v3/eql_v3_bigint_ord_ore@1", "cipherstash/eql-v3/eql_v3_bigint_ord@1", "cipherstash/eql-v3/eql_v3_date@1", "cipherstash/eql-v3/eql_v3_date_eq@1", "cipherstash/eql-v3/eql_v3_date_ord_ore@1", "cipherstash/eql-v3/eql_v3_date_ord@1", "cipherstash/eql-v3/eql_v3_timestamp@1", "cipherstash/eql-v3/eql_v3_timestamp_eq@1", "cipherstash/eql-v3/eql_v3_timestamp_ord_ore@1", "cipherstash/eql-v3/eql_v3_timestamp_ord@1", "cipherstash/eql-v3/eql_v3_numeric@1", "cipherstash/eql-v3/eql_v3_numeric_eq@1", "cipherstash/eql-v3/eql_v3_numeric_ord_ore@1", "cipherstash/eql-v3/eql_v3_numeric_ord@1", "cipherstash/eql-v3/eql_v3_text@1", "cipherstash/eql-v3/eql_v3_text_eq@1", "cipherstash/eql-v3/eql_v3_text_match@1", "cipherstash/eql-v3/eql_v3_text_ord_ore@1", "cipherstash/eql-v3/eql_v3_text_ord@1", "cipherstash/eql-v3/eql_v3_text_search@1", "cipherstash/eql-v3/eql_v3_boolean@1", "cipherstash/eql-v3/eql_v3_real@1", "cipherstash/eql-v3/eql_v3_real_eq@1", "cipherstash/eql-v3/eql_v3_real_ord_ore@1", "cipherstash/eql-v3/eql_v3_real_ord@1", "cipherstash/eql-v3/eql_v3_double@1", "cipherstash/eql-v3/eql_v3_double_eq@1", "cipherstash/eql-v3/eql_v3_double_ord_ore@1", "cipherstash/eql-v3/eql_v3_double_ord@1", "cipherstash/eql-v3/eql_v3_json_search@1"];
```
Defined in: [constants-v3.ts:62](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/extension-metadata/constants-v3.ts#L62)
PINNED literal tuple — the compile-time source of truth for the v3 codec-id
set. Hand-listed, one entry per catalog domain (INCLUDING the `*_ord_ore`
variants that authoring does not expose but the codec/derivation layer still
decodes). This is deliberately NOT `V3_CODEC_IDS as readonly CipherstashV3CodecId[]`
— that is a masking cast that asserts the derived array IS the union and so
catches NO drift. Here, catalog drift fails to COMPILE in both directions:
* `satisfies readonly CipherstashV3CodecId[]` fails if a listed id is no
longer a catalog domain (a domain removed / renamed).
* `_NoUnpinnedDomain` (below) fails if the catalog gained a domain not
pinned here.
The runtime drift test additionally asserts this equals the registry-derived
`V3_CODEC_IDS` (guarding the derivation itself).
***
CIPHERSTASH_V3_SPACE_ID [#cipherstash_v3_space_id]
```ts
const CIPHERSTASH_V3_SPACE_ID: "cipherstash-eql-v3";
```
Defined in: [constants-v3.ts:160](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/extension-metadata/constants-v3.ts#L160)
***
CIPHERSTASH_V3_EXTENSION_VERSION [#cipherstash_v3_extension_version]
```ts
const CIPHERSTASH_V3_EXTENSION_VERSION: "1.0.0";
```
Defined in: [constants-v3.ts:161](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/extension-metadata/constants-v3.ts#L161)
***
cipherstashV3ParamsSchema [#cipherstashv3paramsschema]
```ts
const cipherstashV3ParamsSchema: Type<{
castAs: string;
capabilities: object;
}, {
}>;
```
Defined in: [codec-runtime-v3.ts:69](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/v3/codec-runtime-v3.ts#L69)
Functions [#functions]
decryptAll() [#decryptall]
```ts
function decryptAll(rows, opts?): Promise<void>;
```
Defined in: [decrypt-all.ts:95](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/execution/decrypt-all.ts#L95)
Walk a result set and bulk-decrypt every cipherstash envelope (any
`EncryptedEnvelopeBase` subclass) reachable from it. After the
returned promise resolves, every touched envelope's `decrypt()`
returns the cached plaintext synchronously without consulting the
SDK. Heterogeneous result sets are supported — envelopes of
different concrete types (e.g. `EncryptedString` and
`EncryptedDate` reachable from the same row) are grouped by
`(sdk, table, column)` and the SDK's polymorphic `bulkDecrypt`
return is narrowed per envelope through each subclass's
EncryptedEnvelopeBase.parseDecryptedValue hook.
The walker is a no-op when no envelopes are reachable (returns
without making any SDK call), so it is cheap to call defensively
after queries that may or may not contain encrypted columns.
Parameters [#parameters-21]
rows [#rows]
`unknown`
opts? [#opts]
[`DecryptAllOptions`](https://cipherstash.com/docs/integrations/prisma/api-reference/runtime#decryptalloptions)
Returns [#returns-21]
`Promise`\<`void`>
***
isCipherstashV3CodecId() [#iscipherstashv3codecid]
```ts
function isCipherstashV3CodecId(id): id is "cipherstash/eql-v3/eql_v3_text_search@1" | "cipherstash/eql-v3/eql_v3_integer@1" | "cipherstash/eql-v3/eql_v3_integer_eq@1" | "cipherstash/eql-v3/eql_v3_integer_ord_ore@1" | "cipherstash/eql-v3/eql_v3_integer_ord@1" | "cipherstash/eql-v3/eql_v3_smallint@1" | "cipherstash/eql-v3/eql_v3_smallint_eq@1" | "cipherstash/eql-v3/eql_v3_smallint_ord_ore@1" | "cipherstash/eql-v3/eql_v3_smallint_ord@1" | "cipherstash/eql-v3/eql_v3_bigint@1" | "cipherstash/eql-v3/eql_v3_bigint_eq@1" | "cipherstash/eql-v3/eql_v3_bigint_ord_ore@1" | "cipherstash/eql-v3/eql_v3_bigint_ord@1" | "cipherstash/eql-v3/eql_v3_date@1" | "cipherstash/eql-v3/eql_v3_date_eq@1" | "cipherstash/eql-v3/eql_v3_date_ord_ore@1" | "cipherstash/eql-v3/eql_v3_date_ord@1" | "cipherstash/eql-v3/eql_v3_timestamp@1" | "cipherstash/eql-v3/eql_v3_timestamp_eq@1" | "cipherstash/eql-v3/eql_v3_timestamp_ord_ore@1" | "cipherstash/eql-v3/eql_v3_timestamp_ord@1" | "cipherstash/eql-v3/eql_v3_numeric@1" | "cipherstash/eql-v3/eql_v3_numeric_eq@1" | "cipherstash/eql-v3/eql_v3_numeric_ord_ore@1" | "cipherstash/eql-v3/eql_v3_numeric_ord@1" | "cipherstash/eql-v3/eql_v3_text@1" | "cipherstash/eql-v3/eql_v3_text_eq@1" | "cipherstash/eql-v3/eql_v3_text_match@1" | "cipherstash/eql-v3/eql_v3_text_ord_ore@1" | "cipherstash/eql-v3/eql_v3_text_ord@1" | "cipherstash/eql-v3/eql_v3_boolean@1" | "cipherstash/eql-v3/eql_v3_real@1" | "cipherstash/eql-v3/eql_v3_real_eq@1" | "cipherstash/eql-v3/eql_v3_real_ord_ore@1" | "cipherstash/eql-v3/eql_v3_real_ord@1" | "cipherstash/eql-v3/eql_v3_double@1" | "cipherstash/eql-v3/eql_v3_double_eq@1" | "cipherstash/eql-v3/eql_v3_double_ord_ore@1" | "cipherstash/eql-v3/eql_v3_double_ord@1" | "cipherstash/eql-v3/eql_v3_json_search@1";
```
Defined in: [constants-v3.ts:124](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/extension-metadata/constants-v3.ts#L124)
Parameters [#parameters-22]
id [#id]
`string`
Returns [#returns-22]
id is "cipherstash/eql-v3/eql\_v3\_text\_search\@1" | "cipherstash/eql-v3/eql\_v3\_integer\@1" | "cipherstash/eql-v3/eql\_v3\_integer\_eq\@1" | "cipherstash/eql-v3/eql\_v3\_integer\_ord\_ore\@1" | "cipherstash/eql-v3/eql\_v3\_integer\_ord\@1" | "cipherstash/eql-v3/eql\_v3\_smallint\@1" | "cipherstash/eql-v3/eql\_v3\_smallint\_eq\@1" | "cipherstash/eql-v3/eql\_v3\_smallint\_ord\_ore\@1" | "cipherstash/eql-v3/eql\_v3\_smallint\_ord\@1" | "cipherstash/eql-v3/eql\_v3\_bigint\@1" | "cipherstash/eql-v3/eql\_v3\_bigint\_eq\@1" | "cipherstash/eql-v3/eql\_v3\_bigint\_ord\_ore\@1" | "cipherstash/eql-v3/eql\_v3\_bigint\_ord\@1" | "cipherstash/eql-v3/eql\_v3\_date\@1" | "cipherstash/eql-v3/eql\_v3\_date\_eq\@1" | "cipherstash/eql-v3/eql\_v3\_date\_ord\_ore\@1" | "cipherstash/eql-v3/eql\_v3\_date\_ord\@1" | "cipherstash/eql-v3/eql\_v3\_timestamp\@1" | "cipherstash/eql-v3/eql\_v3\_timestamp\_eq\@1" | "cipherstash/eql-v3/eql\_v3\_timestamp\_ord\_ore\@1" | "cipherstash/eql-v3/eql\_v3\_timestamp\_ord\@1" | "cipherstash/eql-v3/eql\_v3\_numeric\@1" | "cipherstash/eql-v3/eql\_v3\_numeric\_eq\@1" | "cipherstash/eql-v3/eql\_v3\_numeric\_ord\_ore\@1" | "cipherstash/eql-v3/eql\_v3\_numeric\_ord\@1" | "cipherstash/eql-v3/eql\_v3\_text\@1" | "cipherstash/eql-v3/eql\_v3\_text\_eq\@1" | "cipherstash/eql-v3/eql\_v3\_text\_match\@1" | "cipherstash/eql-v3/eql\_v3\_text\_ord\_ore\@1" | "cipherstash/eql-v3/eql\_v3\_text\_ord\@1" | "cipherstash/eql-v3/eql\_v3\_boolean\@1" | "cipherstash/eql-v3/eql\_v3\_real\@1" | "cipherstash/eql-v3/eql\_v3\_real\_eq\@1" | "cipherstash/eql-v3/eql\_v3\_real\_ord\_ore\@1" | "cipherstash/eql-v3/eql\_v3\_real\_ord\@1" | "cipherstash/eql-v3/eql\_v3\_double\@1" | "cipherstash/eql-v3/eql\_v3\_double\_eq\@1" | "cipherstash/eql-v3/eql\_v3\_double\_ord\_ore\@1" | "cipherstash/eql-v3/eql\_v3\_double\_ord\@1" | "cipherstash/eql-v3/eql\_v3\_json\_search\@1"
***
bulkEncryptMiddlewareV3() [#bulkencryptmiddlewarev3]
```ts
function bulkEncryptMiddlewareV3(sdk): SqlMiddleware;
```
Defined in: [bulk-encrypt-v3.ts:72](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/v3/bulk-encrypt-v3.ts#L72)
Construct the v3 bulk-encrypt middleware. The returned middleware is
stateless aside from the captured `sdk` reference; one instance per
(v3) runtime extension is the expected pattern.
Parameters [#parameters-23]
sdk [#sdk-2]
[`CipherstashSdk`](https://cipherstash.com/docs/integrations/prisma/api-reference/runtime#cipherstashsdk)
Returns [#returns-23]
`SqlMiddleware`
***
createV3CodecDescriptors() [#createv3codecdescriptors]
```ts
function createV3CodecDescriptors(sdk): readonly RuntimeParameterizedCodecDescriptor<CipherstashV3CodecParams>[];
```
Defined in: [codec-runtime-v3.ts:437](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/v3/codec-runtime-v3.ts#L437)
One runtime descriptor per catalog domain (all 40, including the
authoring-unexposed `*_ord_ore` variants — the codec layer must decode
whatever the catalog can name), closed over `sdk` so multi-tenant
deployments can compose multiple cipherstash extensions side-by-side
without cross-talk.
Parameters [#parameters-24]
sdk [#sdk-3]
[`CipherstashSdk`](https://cipherstash.com/docs/integrations/prisma/api-reference/runtime#cipherstashsdk)
Returns [#returns-24]
readonly `RuntimeParameterizedCodecDescriptor`\<[`CipherstashV3CodecParams`](https://cipherstash.com/docs/integrations/prisma/api-reference/runtime#cipherstashv3codecparams)>\[]
***
cipherstashV3QueryOperations() [#cipherstashv3queryoperations]
```ts
function cipherstashV3QueryOperations(): SqlOperationDescriptors;
```
Defined in: [operators-v3.ts:796](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/v3/operators-v3.ts#L796)
Cipherstash's v3 query-operations contributions. Wired into the v3
runtime descriptor (Task 7's `createCipherstashV3RuntimeDescriptor`)
— and ONLY that descriptor (decision 1b: a client is v2 or v3, never
both; pinned in `test/v3/operator-gating-v3.test.ts`).
Operator → trait → lowering:
* `eqlEq` / `eqlNeq` / `eqlIn` / `eqlNotIn`
(`cipherstash:equality`) →
`eql_v3.eq` / `eql_v3.neq` / OR-of-eq
* `eqlGt` / `eqlGte` / `eqlLt` / `eqlLte` / `eqlBetween` /
`eqlNotBetween` (`cipherstash:order-and-range`) →
`eql_v3.gt`/`gte`/`lt`/`lte`, range as a self-parenthesised
`(gte AND lte)` conjunction
* `eqlMatch` (`cipherstash:free-text-search`) → `eql_v3.matches`
— a bloom-filter TOKEN MATCH (order/multiplicity-insensitive,
one-sided: may false-positive), NOT SQL pattern matching. Guarded
up front: needles the column's match index cannot answer are
rejected (`matchNeedleError`), and SQL wildcards are normalised
away or rejected (see matchOperator).
* `eqlJsonContains` (`cipherstash:searchable-json`) →
exact jsonb containment via `OPERATOR(public.@>)`.
* `eqlJsonPathEq/Neq/Gt/Gte/Lt/Lte`
(`cipherstash:searchable-json`) → exact value-selector containment for
equality, or selector extraction plus a ciphertext-free scalar query
term for ordering.
Every operand renders as `$n::eql_v3.query_<domain>` (irregularly
`::eql_v3.query_json` for JSON), matching the stack-drizzle v3
dialect byte-for-byte.
Returns [#returns-25]
`SqlOperationDescriptors`
***
eqlAsc() [#eqlasc]
```ts
function eqlAsc(col): OrderByItem;
```
Defined in: [operators-v3.ts:938](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/v3/operators-v3.ts#L938)
ASC sort over an order-capable v3 column, via the encrypted
order-term extractor: `ORDER BY eql_v3.ord_term(col) ASC` (or
`ord_term_ore` on a block-ORE domain).
A free-standing helper, not a registered operator — same rationale
as the v2 `cipherstashAsc`: sort returns an `OrderByItem`, not the
boolean predicate the registry's where-binding pipeline expects. The
`eql` prefix keeps the export distinct from the v2 helper AND names
the vocabulary it belongs to (free-standing exports share one barrel
namespace). Unlike v2 (bare-column sort over `eql_v2_encrypted`'s
native operator family), v3 domains have no cross-row comparison
operators — sorting MUST extract the order term. Synchronous: no
operand, so no query term is minted.
Parameters [#parameters-25]
col [#col]
`Expression`\<`ScopeField`>
Returns [#returns-26]
`OrderByItem`
***
eqlDesc() [#eqldesc]
```ts
function eqlDesc(col): OrderByItem;
```
Defined in: [operators-v3.ts:945](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/v3/operators-v3.ts#L945)
DESC sort over an order-capable v3 column. See [eqlAsc](https://cipherstash.com/docs/integrations/prisma/api-reference/runtime#eqlasc).
Parameters [#parameters-26]
col [#col-1]
`Expression`\<`ScopeField`>
Returns [#returns-27]
`OrderByItem`
***
eqlJsonPathAsc() [#eqljsonpathasc]
```ts
function eqlJsonPathAsc(col, path): OrderByItem;
```
Defined in: [operators-v3.ts:994](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/v3/operators-v3.ts#L994)
ASC sort over a scalar leaf in an encrypted JSON document. Missing paths
produce SQL NULL and follow PostgreSQL's normal NULL ordering.
Parameters [#parameters-27]
col [#col-2]
`Expression`\<`ScopeField`>
path [#path]
`string`
Returns [#returns-28]
`OrderByItem`
***
eqlJsonPathDesc() [#eqljsonpathdesc]
```ts
function eqlJsonPathDesc(col, path): OrderByItem;
```
Defined in: [operators-v3.ts:1004](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/v3/operators-v3.ts#L1004)
DESC counterpart to [eqlJsonPathAsc](https://cipherstash.com/docs/integrations/prisma/api-reference/runtime#eqljsonpathasc).
Parameters [#parameters-28]
col [#col-3]
`Expression`\<`ScopeField`>
path [#path-1]
`string`
Returns [#returns-29]
`OrderByItem`
***
markV3QueryTerm() [#markv3queryterm]
```ts
function markV3QueryTerm(envelope, queryType): void;
```
Defined in: [query-term.ts:88](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/v3/query-term.ts#L88)
Mark an envelope as a v3 QUERY TERM of the given flavour. Stamped by
every operator at lowering time; consumed by the v3 SDK boundary
(Task 7), which must encrypt marked envelopes via
`encryptQuery({ queryType })` — a ciphertext-free term — instead of
the storage `bulkEncrypt` path. Write-once-wins with a conflict
check, mirroring `setHandleRoutingKey`: one envelope instance feeds
one query flavour.
Parameters [#parameters-29]
envelope [#envelope]
`EncryptedEnvelopeBase`\<`unknown`>
queryType [#querytype]
[`V3QueryTermType`](https://cipherstash.com/docs/integrations/prisma/api-reference/runtime#v3querytermtype)
Returns [#returns-30]
`void`
***
v3QueryTermTypeOf() [#v3querytermtypeof]
```ts
function v3QueryTermTypeOf(envelope):
| V3QueryTermType
| undefined;
```
Defined in: [query-term.ts:105](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/v3/query-term.ts#L105)
Read an envelope's query-term mark. `undefined` means the envelope
is a storage value (write path), not a query term.
Parameters [#parameters-30]
envelope [#envelope-1]
`unknown`
Returns [#returns-31]
\| [`V3QueryTermType`](https://cipherstash.com/docs/integrations/prisma/api-reference/runtime#v3querytermtype)
\| `undefined`
***
createCipherstashV3RuntimeDescriptor() [#createcipherstashv3runtimedescriptor]
```ts
function createCipherstashV3RuntimeDescriptor(opts): SqlRuntimeExtensionDescriptor<"postgres">;
```
Defined in: [runtime-v3.ts:49](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/v3/runtime-v3.ts#L49)
Compose the SDK-bound v3 codec descriptors + query operations into a
single `SqlRuntimeExtensionDescriptor<'postgres'>`.
The descriptor is per-SDK: each codec captures the SDK for the
read-side decrypt path. Multi-tenant deployments construct one
descriptor per tenant SDK so per-tenant key material never crosses
runtimes (same contract as v2).
Parameters [#parameters-31]
opts [#opts-1]
[`CreateCipherstashV3RuntimeDescriptorOptions`](https://cipherstash.com/docs/integrations/prisma/api-reference/runtime#createcipherstashv3runtimedescriptoroptions)
Returns [#returns-32]
`SqlRuntimeExtensionDescriptor`\<`"postgres"`>
***
v3ToDriver() [#v3todriver]
```ts
function v3ToDriver(value): string | null;
```
Defined in: [wire-v3.ts:29](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/v3/wire-v3.ts#L29)
Serialise an EQL payload to plain JSONB text; `null`/`undefined` → `null`.
Parameters [#parameters-32]
value [#value-1]
`unknown`
Returns [#returns-33]
`string` | `null`
***
v3FromDriver() [#v3fromdriver]
Call Signature [#call-signature]
```ts
function v3FromDriver<T>(value): T;
```
Defined in: [wire-v3.ts:44](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/v3/wire-v3.ts#L44)
Parse a JSONB wire back to the EQL payload. Text wires are
`JSON.parse`d; objects (drivers that pre-parse jsonb) pass through;
`null`/`undefined` are preserved as-is — the overloads keep that
passthrough visible to callers (a nullable input yields a nullable
result) instead of laundering `null` into `T`.
Type Parameters [#type-parameters-1]
T [#t]
`T`
Parameters [#parameters-33]
value [#value-2]
`string` | `object`
Returns [#returns-34]
`T`
Call Signature [#call-signature-1]
```ts
function v3FromDriver<T>(value): T | null | undefined;
```
Defined in: [wire-v3.ts:45](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/v3/wire-v3.ts#L45)
Parse a JSONB wire back to the EQL payload. Text wires are
`JSON.parse`d; objects (drivers that pre-parse jsonb) pass through;
`null`/`undefined` are preserved as-is — the overloads keep that
passthrough visible to callers (a nullable input yields a nullable
result) instead of laundering `null` into `T`.
Type Parameters [#type-parameters-2]
T [#t-1]
`T`
Parameters [#parameters-34]
value [#value-3]
`string` | `object` | `null` | `undefined`
Returns [#returns-35]
`T` | `null` | `undefined`
# stack
Source: https://cipherstash.com/docs/integrations/prisma/api-reference/stack
[**@cipherstash/stack-prisma**](./)
***
Interfaces [#interfaces]
CipherstashFromStackV3Options [#cipherstashfromstackv3options]
Defined in: [from-stack-v3.ts:46](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/stack/from-stack-v3.ts#L46)
`@cipherstash/stack-prisma/stack` — one-call setup for the
`@cipherstash/stack` SDK against a Prisma Next contract (EQL v3).
Most consumers want [cipherstashFromStack](https://cipherstash.com/docs/integrations/prisma/api-reference/stack#cipherstashfromstack): it derives the v3
encryption schemas from your contract, constructs the
`@cipherstash/stack` `Encryption` client from your `CS_*` env vars or
local profile, builds the SDK adapter, and returns ready-to-spread
`extensions` / `middleware` for `postgres<Contract>({...})`. The
remaining exports are the primitives it composes, for advanced users
who need to interpose custom logic (custom keyset, multi-tenant
routing).
This subpath imports `@cipherstash/stack` directly. Consumers who
implement `CipherstashSdk` against a different SDK should use
`./runtime` instead and pay no `@cipherstash/stack` bundle cost.
Properties [#properties]
contractJson [#contractjson]
```ts
readonly contractJson: V3ContractShape;
```
Defined in: [from-stack-v3.ts:48](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/stack/from-stack-v3.ts#L48)
The contract.json artefact emitted by `prisma-next contract emit`.
schemasV3? [#schemasv3]
```ts
readonly optional schemasV3: readonly AnyV3Table[];
```
Defined in: [from-stack-v3.ts:56](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/stack/from-stack-v3.ts#L56)
Optional schema override. Use this to add tables the contract does
not model. For tables the contract **does** declare, the override
must match on column names and EXACT `public.eql_v3_*` domain
identity — divergence throws at setup.
encryptionConfig? [#encryptionconfig]
```ts
readonly optional encryptionConfig: ClientConfig;
```
Defined in: [from-stack-v3.ts:70](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/stack/from-stack-v3.ts#L70)
Pass-through to `Encryption({ config })` (keyset overrides, logging, …).
`ClientConfig` no longer carries an `eqlVersion` field — `@cipherstash/stack`
always authors EQL v3 — so there is no v2 escape hatch to reach from here.
`Encryption()` throws on the mere PRESENCE of the key
(`` `config.eqlVersion` has been removed ``), whatever its value — an
explicit `undefined` excepted, since the type admits that one and cannot
reject it — and whatever the schema set, so a config object carrying a
leftover `eqlVersion` fails at setup rather than silently selecting a wire
format.
***
CipherstashFromStackV3Result [#cipherstashfromstackv3result]
Defined in: [from-stack-v3.ts:73](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/stack/from-stack-v3.ts#L73)
`@cipherstash/stack-prisma/stack` — one-call setup for the
`@cipherstash/stack` SDK against a Prisma Next contract (EQL v3).
Most consumers want [cipherstashFromStack](https://cipherstash.com/docs/integrations/prisma/api-reference/stack#cipherstashfromstack): it derives the v3
encryption schemas from your contract, constructs the
`@cipherstash/stack` `Encryption` client from your `CS_*` env vars or
local profile, builds the SDK adapter, and returns ready-to-spread
`extensions` / `middleware` for `postgres<Contract>({...})`. The
remaining exports are the primitives it composes, for advanced users
who need to interpose custom logic (custom keyset, multi-tenant
routing).
This subpath imports `@cipherstash/stack` directly. Consumers who
implement `CipherstashSdk` against a different SDK should use
`./runtime` instead and pay no `@cipherstash/stack` bundle cost.
Properties [#properties-1]
extensions [#extensions]
```ts
readonly extensions: readonly SqlRuntimeExtensionDescriptor<"postgres">[];
```
Defined in: [from-stack-v3.ts:75](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/stack/from-stack-v3.ts#L75)
Ready to spread into `postgres<Contract>({ extensions })`.
middleware [#middleware]
```ts
readonly middleware: readonly SqlMiddleware<Record<string, unknown>>[];
```
Defined in: [from-stack-v3.ts:77](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/stack/from-stack-v3.ts#L77)
Ready to spread into `postgres<Contract>({ middleware })`.
encryptionClient [#encryptionclient]
```ts
readonly encryptionClient: EncryptionClient<readonly AnyV3Table[]>;
```
Defined in: [from-stack-v3.ts:82](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/stack/from-stack-v3.ts#L82)
The initialised v3 `EncryptionClient` for direct SDK access
outside the ORM path (`encryptModel`, `encryptQuery`, …).
***
V3ContractShape [#v3contractshape]
Defined in: [derive-schemas-v3.ts:51](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/v3/derive-schemas-v3.ts#L51)
Structural shape of the subset of `contract.json` this derivation
reads — the 0.14 `storage.namespaces.<ns>.entries.table` envelope,
mirroring the v2 `ContractStorageView`. Declared structurally (vs
importing the framework type) so the derivation has no
`@prisma-next/*` import-edge and is callable against a raw
JSON-typed import.
Properties [#properties-2]
storage? [#storage]
```ts
readonly optional storage: {
namespaces?: Readonly<Record<string, {
entries?: {
table?: Readonly<Record<..., ...>>;
};
}>>;
};
```
Defined in: [derive-schemas-v3.ts:52](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/v3/derive-schemas-v3.ts#L52)
namespaces? [#namespaces]
```ts
readonly optional namespaces: Readonly<Record<string, {
entries?: {
table?: Readonly<Record<..., ...>>;
};
}>>;
```
***
V3ContractColumnEntry [#v3contractcolumnentry]
Defined in: [derive-schemas-v3.ts:79](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/v3/derive-schemas-v3.ts#L79)
One contract column, flattened out of the namespace envelope.
Properties [#properties-3]
tableName [#tablename]
```ts
readonly tableName: string;
```
Defined in: [derive-schemas-v3.ts:80](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/v3/derive-schemas-v3.ts#L80)
columnName [#columnname]
```ts
readonly columnName: string;
```
Defined in: [derive-schemas-v3.ts:81](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/v3/derive-schemas-v3.ts#L81)
codecId [#codecid]
```ts
readonly codecId: string | undefined;
```
Defined in: [derive-schemas-v3.ts:82](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/v3/derive-schemas-v3.ts#L82)
nativeType [#nativetype]
```ts
readonly nativeType: string | undefined;
```
Defined in: [derive-schemas-v3.ts:83](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/v3/derive-schemas-v3.ts#L83)
***
CipherstashV3Client [#cipherstashv3client]
Defined in: [sdk-adapter-v3.ts:74](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/v3/sdk-adapter-v3.ts#L74)
Minimal structural view of the stack v3 client this adapter drives —
satisfied by the `EncryptionClient` that `Encryption` returns
(whatever its schema tuple) AND by a hand-rolled test double, neither
needing a cast.
`encryptQuery`'s `never` operands are deliberate (same rationale as
`@cipherstash/stack-drizzle`'s `OperandEncryptionClient`): the real
client's `encryptQuery` is generic — `queryType` is constrained to
the column's own query types — which a concrete signature here cannot
match. `never` params keep the structural surface satisfiable by that
generic method; the call sites cast their real operands.
Methods [#methods]
bulkEncrypt() [#bulkencrypt]
```ts
bulkEncrypt(payload, opts): PromiseLike<StackResult<readonly {
data: unknown;
}[]>>;
```
Defined in: [sdk-adapter-v3.ts:75](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/v3/sdk-adapter-v3.ts#L75)
Parameters [#parameters]
payload [#payload]
readonly \{
`plaintext`: `unknown`;
}\[]
opts [#opts]
table [#table]
`AnyV3Table`
column [#column]
`AnyEncryptedV3Column`
Returns [#returns]
`PromiseLike`\<`StackResult`\>
decrypt() [#decrypt]
```ts
decrypt(encrypted): PromiseLike<StackResult<unknown>>;
```
Defined in: [sdk-adapter-v3.ts:79](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/v3/sdk-adapter-v3.ts#L79)
Parameters [#parameters-1]
encrypted [#encrypted]
`unknown`
Returns [#returns-1]
`PromiseLike`\<`StackResult`\<`unknown`>>
bulkDecrypt() [#bulkdecrypt]
```ts
bulkDecrypt(payloads): PromiseLike<StackResult<readonly {
data?: unknown;
error?: unknown;
}[]>>;
```
Defined in: [sdk-adapter-v3.ts:80](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/v3/sdk-adapter-v3.ts#L80)
Parameters [#parameters-2]
payloads [#payloads]
readonly \{
`data`: `unknown`;
}\[]
Returns [#returns-2]
`PromiseLike`\<`StackResult`\>
encryptQuery() [#encryptquery]
Call Signature [#call-signature]
```ts
encryptQuery(plaintext, opts): PromiseLike<StackResult<unknown>>;
```
Defined in: [sdk-adapter-v3.ts:87](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/v3/sdk-adapter-v3.ts#L87)
Parameters [#parameters-3]
plaintext [#plaintext]
`never`
opts [#opts-1]
`never`
Returns [#returns-3]
`PromiseLike`\<`StackResult`\<`unknown`>>
Call Signature [#call-signature-1]
```ts
encryptQuery(terms): PromiseLike<StackResult<readonly unknown[]>>;
```
Defined in: [sdk-adapter-v3.ts:88](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/v3/sdk-adapter-v3.ts#L88)
Parameters [#parameters-4]
terms [#terms]
`never`
Returns [#returns-4]
`PromiseLike`\<`StackResult`\>
Functions [#functions]
cipherstashFromStack() [#cipherstashfromstack]
```ts
function cipherstashFromStack(opts): Promise<CipherstashFromStackV3Result>;
```
Defined in: [from-stack-v3.ts:85](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/stack/from-stack-v3.ts#L85)
Parameters [#parameters-5]
opts [#opts-2]
[`CipherstashFromStackV3Options`](https://cipherstash.com/docs/integrations/prisma/api-reference/stack#cipherstashfromstackv3options)
Returns [#returns-5]
`Promise`\<[`CipherstashFromStackV3Result`](https://cipherstash.com/docs/integrations/prisma/api-reference/stack#cipherstashfromstackv3result)>
***
v3ContractColumnEntries() [#v3contractcolumnentries]
```ts
function v3ContractColumnEntries(contractJson): V3ContractColumnEntry[];
```
Defined in: [derive-schemas-v3.ts:92](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/v3/derive-schemas-v3.ts#L92)
Flatten every contract column across all namespaces/tables. Shared by
[deriveStackSchemasV3](https://cipherstash.com/docs/integrations/prisma/api-reference/stack#derivestackschemasv3) and `cipherstashFromStack`'s
v2-codec-id scan (a v3 client is v3-only; foreign cipherstash codec
ids are a hard error there).
Parameters [#parameters-6]
contractJson [#contractjson-1]
[`V3ContractShape`](https://cipherstash.com/docs/integrations/prisma/api-reference/stack#v3contractshape)
Returns [#returns-6]
[`V3ContractColumnEntry`](https://cipherstash.com/docs/integrations/prisma/api-reference/stack#v3contractcolumnentry)\[]
***
deriveStackSchemasV3() [#derivestackschemasv3]
```ts
function deriveStackSchemasV3(contractJson): readonly AnyV3Table[];
```
Defined in: [derive-schemas-v3.ts:117](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/v3/derive-schemas-v3.ts#L117)
Derive an array of v3 `EncryptedTable` builders from a Prisma Next
contract. Returns an empty array when no v3 cipherstash columns are
present; callers must still pass at least one table to
`Encryption({ schemas })`, which requires a non-empty array.
Parameters [#parameters-7]
contractJson [#contractjson-2]
[`V3ContractShape`](https://cipherstash.com/docs/integrations/prisma/api-reference/stack#v3contractshape)
Returns [#returns-7]
readonly `AnyV3Table`\[]
***
assertV3SchemasAgree() [#assertv3schemasagree]
```ts
function assertV3SchemasAgree(derived, override): void;
```
Defined in: [from-stack-v3-validate.ts:22](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/v3/from-stack-v3-validate.ts#L22)
Assert that a user-supplied v3 table override agrees with the
contract-derived table on every column: same column set (keyed by the
physical DB column name) and, per column, the same concrete
`public.eql_v3_*` domain. Throws with a fix-the-schema hint on the
first divergence.
Parameters [#parameters-8]
derived [#derived]
`AnyV3Table`
override [#override]
`AnyV3Table`
Returns [#returns-8]
`void`
***
createCipherstashV3Sdk() [#createcipherstashv3sdk]
```ts
function createCipherstashV3Sdk(client, schemas): CipherstashSdk;
```
Defined in: [sdk-adapter-v3.ts:112](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-prisma/src/v3/sdk-adapter-v3.ts#L112)
Build a `CipherstashSdk` from a stack v3 client plus the v3 schemas
it was constructed with.
`schemas` should be the exact `AnyV3Table[]` passed to
`Encryption({ schemas })` (typically the return value of
`deriveStackSchemasV3`). The adapter uses it to translate framework
`(table, column)` routing-key strings back to the typed schema
objects the client's operations expect.
Parameters [#parameters-9]
client [#client]
[`CipherstashV3Client`](https://cipherstash.com/docs/integrations/prisma/api-reference/stack#cipherstashv3client)
schemas [#schemas]
readonly `AnyV3Table`\[]
Returns [#returns-9]
[`CipherstashSdk`](https://cipherstash.com/docs/integrations/prisma/api-reference/runtime#cipherstashsdk)
# v3
Source: https://cipherstash.com/docs/integrations/prisma/api-reference/v3
[**@cipherstash/stack-prisma**](./)
***
References [#references]
CIPHERSTASH_V3_CODEC_IDS [#cipherstash_v3_codec_ids]
Re-exports [CIPHERSTASH\_V3\_CODEC\_IDS](https://cipherstash.com/docs/integrations/prisma/api-reference/runtime#cipherstash_v3_codec_ids)
***
CIPHERSTASH_V3_EXTENSION_VERSION [#cipherstash_v3_extension_version]
Re-exports [CIPHERSTASH\_V3\_EXTENSION\_VERSION](https://cipherstash.com/docs/integrations/prisma/api-reference/runtime#cipherstash_v3_extension_version)
***
CIPHERSTASH_V3_SPACE_ID [#cipherstash_v3_space_id]
Re-exports [CIPHERSTASH\_V3\_SPACE\_ID](https://cipherstash.com/docs/integrations/prisma/api-reference/runtime#cipherstash_v3_space_id)
***
CipherstashV3CodecId [#cipherstashv3codecid]
Re-exports [CipherstashV3CodecId](https://cipherstash.com/docs/integrations/prisma/api-reference/runtime#cipherstashv3codecid)
***
isCipherstashV3CodecId [#iscipherstashv3codecid]
Re-exports [isCipherstashV3CodecId](https://cipherstash.com/docs/integrations/prisma/api-reference/runtime#iscipherstashv3codecid)
***
CipherstashFromStackV3Options [#cipherstashfromstackv3options]
Re-exports [CipherstashFromStackV3Options](https://cipherstash.com/docs/integrations/prisma/api-reference/stack#cipherstashfromstackv3options)
***
CipherstashFromStackV3Result [#cipherstashfromstackv3result]
Re-exports [CipherstashFromStackV3Result](https://cipherstash.com/docs/integrations/prisma/api-reference/stack#cipherstashfromstackv3result)
***
cipherstashFromStack [#cipherstashfromstack]
Re-exports [cipherstashFromStack](https://cipherstash.com/docs/integrations/prisma/api-reference/stack#cipherstashfromstack)
***
bulkEncryptMiddlewareV3 [#bulkencryptmiddlewarev3]
Re-exports [bulkEncryptMiddlewareV3](https://cipherstash.com/docs/integrations/prisma/api-reference/runtime#bulkencryptmiddlewarev3)
***
CipherstashV3CellCodec [#cipherstashv3cellcodec]
Re-exports [CipherstashV3CellCodec](https://cipherstash.com/docs/integrations/prisma/api-reference/runtime#cipherstashv3cellcodec)
***
CipherstashV3CodecParams [#cipherstashv3codecparams]
Re-exports [CipherstashV3CodecParams](https://cipherstash.com/docs/integrations/prisma/api-reference/runtime#cipherstashv3codecparams)
***
cipherstashV3ParamsSchema [#cipherstashv3paramsschema]
Re-exports [cipherstashV3ParamsSchema](https://cipherstash.com/docs/integrations/prisma/api-reference/runtime#cipherstashv3paramsschema)
***
createV3CodecDescriptors [#createv3codecdescriptors]
Re-exports [createV3CodecDescriptors](https://cipherstash.com/docs/integrations/prisma/api-reference/runtime#createv3codecdescriptors)
***
V3ContractColumnEntry [#v3contractcolumnentry]
Re-exports [V3ContractColumnEntry](https://cipherstash.com/docs/integrations/prisma/api-reference/stack#v3contractcolumnentry)
***
V3ContractShape [#v3contractshape]
Re-exports [V3ContractShape](https://cipherstash.com/docs/integrations/prisma/api-reference/stack#v3contractshape)
***
deriveStackSchemasV3 [#derivestackschemasv3]
Re-exports [deriveStackSchemasV3](https://cipherstash.com/docs/integrations/prisma/api-reference/stack#derivestackschemasv3)
***
v3ContractColumnEntries [#v3contractcolumnentries]
Re-exports [v3ContractColumnEntries](https://cipherstash.com/docs/integrations/prisma/api-reference/stack#v3contractcolumnentries)
***
assertV3SchemasAgree [#assertv3schemasagree]
Re-exports [assertV3SchemasAgree](https://cipherstash.com/docs/integrations/prisma/api-reference/stack#assertv3schemasagree)
***
cipherstashV3QueryOperations [#cipherstashv3queryoperations]
Re-exports [cipherstashV3QueryOperations](https://cipherstash.com/docs/integrations/prisma/api-reference/runtime#cipherstashv3queryoperations)
***
eqlAsc [#eqlasc]
Re-exports [eqlAsc](https://cipherstash.com/docs/integrations/prisma/api-reference/runtime#eqlasc)
***
eqlDesc [#eqldesc]
Re-exports [eqlDesc](https://cipherstash.com/docs/integrations/prisma/api-reference/runtime#eqldesc)
***
eqlJsonPathAsc [#eqljsonpathasc]
Re-exports [eqlJsonPathAsc](https://cipherstash.com/docs/integrations/prisma/api-reference/runtime#eqljsonpathasc)
***
eqlJsonPathDesc [#eqljsonpathdesc]
Re-exports [eqlJsonPathDesc](https://cipherstash.com/docs/integrations/prisma/api-reference/runtime#eqljsonpathdesc)
***
EncryptionOperatorError [#encryptionoperatorerror]
Re-exports [EncryptionOperatorError](https://cipherstash.com/docs/integrations/prisma/api-reference/runtime#encryptionoperatorerror)
***
markV3QueryTerm [#markv3queryterm]
Re-exports [markV3QueryTerm](https://cipherstash.com/docs/integrations/prisma/api-reference/runtime#markv3queryterm)
***
V3QueryTermType [#v3querytermtype]
Re-exports [V3QueryTermType](https://cipherstash.com/docs/integrations/prisma/api-reference/runtime#v3querytermtype)
***
v3QueryTermTypeOf [#v3querytermtypeof]
Re-exports [v3QueryTermTypeOf](https://cipherstash.com/docs/integrations/prisma/api-reference/runtime#v3querytermtypeof)
***
CreateCipherstashV3RuntimeDescriptorOptions [#createcipherstashv3runtimedescriptoroptions]
Re-exports [CreateCipherstashV3RuntimeDescriptorOptions](https://cipherstash.com/docs/integrations/prisma/api-reference/runtime#createcipherstashv3runtimedescriptoroptions)
***
createCipherstashV3RuntimeDescriptor [#createcipherstashv3runtimedescriptor]
Re-exports [createCipherstashV3RuntimeDescriptor](https://cipherstash.com/docs/integrations/prisma/api-reference/runtime#createcipherstashv3runtimedescriptor)
***
CipherstashV3Client [#cipherstashv3client]
Re-exports [CipherstashV3Client](https://cipherstash.com/docs/integrations/prisma/api-reference/stack#cipherstashv3client)
***
createCipherstashV3Sdk [#createcipherstashv3sdk]
Re-exports [createCipherstashV3Sdk](https://cipherstash.com/docs/integrations/prisma/api-reference/stack#createcipherstashv3sdk)
***
v3FromDriver [#v3fromdriver]
Re-exports [v3FromDriver](https://cipherstash.com/docs/integrations/prisma/api-reference/runtime#v3fromdriver)
***
v3ToDriver [#v3todriver]
Re-exports [v3ToDriver](https://cipherstash.com/docs/integrations/prisma/api-reference/runtime#v3todriver)
***
EncryptedBigInt [#encryptedbigint]
Re-exports [EncryptedBigInt](https://cipherstash.com/docs/integrations/prisma/api-reference/runtime#encryptedbigint)
***
EncryptedBoolean [#encryptedboolean]
Re-exports [EncryptedBoolean](https://cipherstash.com/docs/integrations/prisma/api-reference/runtime#encryptedboolean)
***
EncryptedDate [#encrypteddate]
Re-exports [EncryptedDate](https://cipherstash.com/docs/integrations/prisma/api-reference/runtime#encrypteddate)
***
EncryptedJson [#encryptedjson]
Re-exports [EncryptedJson](https://cipherstash.com/docs/integrations/prisma/api-reference/runtime#encryptedjson)
***
EncryptedString [#encryptedstring]
Re-exports [EncryptedString](https://cipherstash.com/docs/integrations/prisma/api-reference/runtime#encryptedstring)
***
EncryptedNumber [#encryptednumber]
Re-exports [EncryptedNumber](https://cipherstash.com/docs/integrations/prisma/api-reference/runtime#encryptednumber)
# @cipherstash/stack-drizzle
Source: https://cipherstash.com/docs/integrations/drizzle/api-reference
**@cipherstash/stack-drizzle**
***
Classes [#classes]
EqlV3CodecError [#eqlv3codecerror]
Defined in: [codec.ts:11](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-drizzle/src/codec.ts#L11)
Thrown when a driver value cannot be read back as an EQL v3 envelope.
Extends [#extends]
* `Error`
Constructors [#constructors]
Constructor [#constructor]
```ts
new EqlV3CodecError(message, options?): EqlV3CodecError;
```
Defined in: [codec.ts:12](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-drizzle/src/codec.ts#L12)
Parameters [#parameters]
message [#message]
`string`
options? [#options]
`ErrorOptions`
Returns [#returns]
[`EqlV3CodecError`](https://cipherstash.com/docs/integrations/drizzle/api-reference#eqlv3codecerror)
Overrides [#overrides]
```ts
Error.constructor
```
***
EncryptionOperatorError [#encryptionoperatorerror]
Defined in: [operators.ts:95](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-drizzle/src/operators.ts#L95)
A dedicated error for v3 operator gating and operand-encryption failures,
carrying the offending column/table/operator for diagnostics.
INTENTIONAL FORK: this mirrors the v2 adapter's `EncryptionOperatorError`
rather than sharing it. Unifying the two would couple `./drizzle` and
`./eql/v3/drizzle` — two independently-versioned public entry points — so the
duplication is deliberate, not an oversight.
Extends [#extends-1]
* `Error`
Constructors [#constructors-1]
Constructor [#constructor-1]
```ts
new EncryptionOperatorError(message, context?): EncryptionOperatorError;
```
Defined in: [operators.ts:96](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-drizzle/src/operators.ts#L96)
Parameters [#parameters-1]
message [#message-1]
`string`
context? [#context]
columnName? [#columnname]
`string`
tableName? [#tablename]
`string`
operator? [#operator]
`string`
Returns [#returns-1]
[`EncryptionOperatorError`](https://cipherstash.com/docs/integrations/drizzle/api-reference#encryptionoperatorerror)
Overrides [#overrides-1]
```ts
Error.constructor
```
Properties [#properties]
context? [#context-1]
```ts
readonly optional context: {
columnName?: string;
tableName?: string;
operator?: string;
};
```
Defined in: [operators.ts:98](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-drizzle/src/operators.ts#L98)
columnName? [#columnname-1]
```ts
optional columnName: string;
```
tableName? [#tablename-1]
```ts
optional tableName: string;
```
operator? [#operator-1]
```ts
optional operator: string;
```
Variables [#variables]
types [#types]
```ts
const types: {
Integer: (name) => EqlV3Column<EncryptedIntegerColumn>;
IntegerEq: (name) => EqlV3Column<EncryptedIntegerEqColumn>;
IntegerOrdOre: (name) => EqlV3Column<EncryptedIntegerOrdOreColumn>;
IntegerOrd: (name) => EqlV3Column<EncryptedIntegerOrdColumn>;
Smallint: (name) => EqlV3Column<EncryptedSmallintColumn>;
SmallintEq: (name) => EqlV3Column<EncryptedSmallintEqColumn>;
SmallintOrdOre: (name) => EqlV3Column<EncryptedSmallintOrdOreColumn>;
SmallintOrd: (name) => EqlV3Column<EncryptedSmallintOrdColumn>;
Bigint: (name) => EqlV3Column<EncryptedBigintColumn>;
BigintEq: (name) => EqlV3Column<EncryptedBigintEqColumn>;
BigintOrdOre: (name) => EqlV3Column<EncryptedBigintOrdOreColumn>;
BigintOrd: (name) => EqlV3Column<EncryptedBigintOrdColumn>;
Date: (name) => EqlV3Column<EncryptedDateColumn>;
DateEq: (name) => EqlV3Column<EncryptedDateEqColumn>;
DateOrdOre: (name) => EqlV3Column<EncryptedDateOrdOreColumn>;
DateOrd: (name) => EqlV3Column<EncryptedDateOrdColumn>;
Timestamp: (name) => EqlV3Column<EncryptedTimestampColumn>;
TimestampEq: (name) => EqlV3Column<EncryptedTimestampEqColumn>;
TimestampOrdOre: (name) => EqlV3Column<EncryptedTimestampOrdOreColumn>;
TimestampOrd: (name) => EqlV3Column<EncryptedTimestampOrdColumn>;
Numeric: (name) => EqlV3Column<EncryptedNumericColumn>;
NumericEq: (name) => EqlV3Column<EncryptedNumericEqColumn>;
NumericOrdOre: (name) => EqlV3Column<EncryptedNumericOrdOreColumn>;
NumericOrd: (name) => EqlV3Column<EncryptedNumericOrdColumn>;
Text: (name) => EqlV3Column<EncryptedTextColumn>;
TextEq: (name) => EqlV3Column<EncryptedTextEqColumn>;
TextMatch: (name) => EqlV3Column<EncryptedTextMatchColumn>;
TextOrdOre: (name) => EqlV3Column<EncryptedTextOrdOreColumn>;
TextOrd: (name) => EqlV3Column<EncryptedTextOrdColumn>;
TextSearch: (name) => EqlV3Column<EncryptedTextSearchColumn>;
Boolean: (name) => EqlV3Column<EncryptedBooleanColumn>;
Real: (name) => EqlV3Column<EncryptedRealColumn>;
RealEq: (name) => EqlV3Column<EncryptedRealEqColumn>;
RealOrdOre: (name) => EqlV3Column<EncryptedRealOrdOreColumn>;
RealOrd: (name) => EqlV3Column<EncryptedRealOrdColumn>;
Double: (name) => EqlV3Column<EncryptedDoubleColumn>;
DoubleEq: (name) => EqlV3Column<EncryptedDoubleEqColumn>;
DoubleOrdOre: (name) => EqlV3Column<EncryptedDoubleOrdOreColumn>;
DoubleOrd: (name) => EqlV3Column<EncryptedDoubleOrdColumn>;
Json: (name) => EqlV3Column<EncryptedJsonColumn>;
};
```
Defined in: [types.ts:10](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-drizzle/src/types.ts#L10)
Drizzle-native mirror of `@/eql/v3`'s `types` namespace. Each PascalCase
factory returns a Drizzle column wrapping the matching concrete v3 builder.
Type Declaration [#type-declaration]
Integer() [#integer]
```ts
readonly Integer: (name) => EqlV3Column<EncryptedIntegerColumn>;
```
Parameters [#parameters-2]
name [#name]
`string`
Returns [#returns-2]
`EqlV3Column`\<`EncryptedIntegerColumn`>
IntegerEq() [#integereq]
```ts
readonly IntegerEq: (name) => EqlV3Column<EncryptedIntegerEqColumn>;
```
Parameters [#parameters-3]
name [#name-1]
`string`
Returns [#returns-3]
`EqlV3Column`\<`EncryptedIntegerEqColumn`>
IntegerOrdOre() [#integerordore]
```ts
readonly IntegerOrdOre: (name) => EqlV3Column<EncryptedIntegerOrdOreColumn>;
```
Parameters [#parameters-4]
name [#name-2]
`string`
Returns [#returns-4]
`EqlV3Column`\<`EncryptedIntegerOrdOreColumn`>
IntegerOrd() [#integerord]
```ts
readonly IntegerOrd: (name) => EqlV3Column<EncryptedIntegerOrdColumn>;
```
Parameters [#parameters-5]
name [#name-3]
`string`
Returns [#returns-5]
`EqlV3Column`\<`EncryptedIntegerOrdColumn`>
Smallint() [#smallint]
```ts
readonly Smallint: (name) => EqlV3Column<EncryptedSmallintColumn>;
```
Parameters [#parameters-6]
name [#name-4]
`string`
Returns [#returns-6]
`EqlV3Column`\<`EncryptedSmallintColumn`>
SmallintEq() [#smallinteq]
```ts
readonly SmallintEq: (name) => EqlV3Column<EncryptedSmallintEqColumn>;
```
Parameters [#parameters-7]
name [#name-5]
`string`
Returns [#returns-7]
`EqlV3Column`\<`EncryptedSmallintEqColumn`>
SmallintOrdOre() [#smallintordore]
```ts
readonly SmallintOrdOre: (name) => EqlV3Column<EncryptedSmallintOrdOreColumn>;
```
Parameters [#parameters-8]
name [#name-6]
`string`
Returns [#returns-8]
`EqlV3Column`\<`EncryptedSmallintOrdOreColumn`>
SmallintOrd() [#smallintord]
```ts
readonly SmallintOrd: (name) => EqlV3Column<EncryptedSmallintOrdColumn>;
```
Parameters [#parameters-9]
name [#name-7]
`string`
Returns [#returns-9]
`EqlV3Column`\<`EncryptedSmallintOrdColumn`>
Bigint() [#bigint]
```ts
readonly Bigint: (name) => EqlV3Column<EncryptedBigintColumn>;
```
Parameters [#parameters-10]
name [#name-8]
`string`
Returns [#returns-10]
`EqlV3Column`\<`EncryptedBigintColumn`>
BigintEq() [#biginteq]
```ts
readonly BigintEq: (name) => EqlV3Column<EncryptedBigintEqColumn>;
```
Parameters [#parameters-11]
name [#name-9]
`string`
Returns [#returns-11]
`EqlV3Column`\<`EncryptedBigintEqColumn`>
BigintOrdOre() [#bigintordore]
```ts
readonly BigintOrdOre: (name) => EqlV3Column<EncryptedBigintOrdOreColumn>;
```
Parameters [#parameters-12]
name [#name-10]
`string`
Returns [#returns-12]
`EqlV3Column`\<`EncryptedBigintOrdOreColumn`>
BigintOrd() [#bigintord]
```ts
readonly BigintOrd: (name) => EqlV3Column<EncryptedBigintOrdColumn>;
```
Parameters [#parameters-13]
name [#name-11]
`string`
Returns [#returns-13]
`EqlV3Column`\<`EncryptedBigintOrdColumn`>
Date() [#date]
```ts
readonly Date: (name) => EqlV3Column<EncryptedDateColumn>;
```
Parameters [#parameters-14]
name [#name-12]
`string`
Returns [#returns-14]
`EqlV3Column`\<`EncryptedDateColumn`>
DateEq() [#dateeq]
```ts
readonly DateEq: (name) => EqlV3Column<EncryptedDateEqColumn>;
```
Parameters [#parameters-15]
name [#name-13]
`string`
Returns [#returns-15]
`EqlV3Column`\<`EncryptedDateEqColumn`>
DateOrdOre() [#dateordore]
```ts
readonly DateOrdOre: (name) => EqlV3Column<EncryptedDateOrdOreColumn>;
```
Parameters [#parameters-16]
name [#name-14]
`string`
Returns [#returns-16]
`EqlV3Column`\<`EncryptedDateOrdOreColumn`>
DateOrd() [#dateord]
```ts
readonly DateOrd: (name) => EqlV3Column<EncryptedDateOrdColumn>;
```
Parameters [#parameters-17]
name [#name-15]
`string`
Returns [#returns-17]
`EqlV3Column`\<`EncryptedDateOrdColumn`>
Timestamp() [#timestamp]
```ts
readonly Timestamp: (name) => EqlV3Column<EncryptedTimestampColumn>;
```
Parameters [#parameters-18]
name [#name-16]
`string`
Returns [#returns-18]
`EqlV3Column`\<`EncryptedTimestampColumn`>
TimestampEq() [#timestampeq]
```ts
readonly TimestampEq: (name) => EqlV3Column<EncryptedTimestampEqColumn>;
```
Parameters [#parameters-19]
name [#name-17]
`string`
Returns [#returns-19]
`EqlV3Column`\<`EncryptedTimestampEqColumn`>
TimestampOrdOre() [#timestampordore]
```ts
readonly TimestampOrdOre: (name) => EqlV3Column<EncryptedTimestampOrdOreColumn>;
```
Parameters [#parameters-20]
name [#name-18]
`string`
Returns [#returns-20]
`EqlV3Column`\<`EncryptedTimestampOrdOreColumn`>
TimestampOrd() [#timestampord]
```ts
readonly TimestampOrd: (name) => EqlV3Column<EncryptedTimestampOrdColumn>;
```
Parameters [#parameters-21]
name [#name-19]
`string`
Returns [#returns-21]
`EqlV3Column`\<`EncryptedTimestampOrdColumn`>
Numeric() [#numeric]
```ts
readonly Numeric: (name) => EqlV3Column<EncryptedNumericColumn>;
```
Parameters [#parameters-22]
name [#name-20]
`string`
Returns [#returns-22]
`EqlV3Column`\<`EncryptedNumericColumn`>
NumericEq() [#numericeq]
```ts
readonly NumericEq: (name) => EqlV3Column<EncryptedNumericEqColumn>;
```
Parameters [#parameters-23]
name [#name-21]
`string`
Returns [#returns-23]
`EqlV3Column`\<`EncryptedNumericEqColumn`>
NumericOrdOre() [#numericordore]
```ts
readonly NumericOrdOre: (name) => EqlV3Column<EncryptedNumericOrdOreColumn>;
```
Parameters [#parameters-24]
name [#name-22]
`string`
Returns [#returns-24]
`EqlV3Column`\<`EncryptedNumericOrdOreColumn`>
NumericOrd() [#numericord]
```ts
readonly NumericOrd: (name) => EqlV3Column<EncryptedNumericOrdColumn>;
```
Parameters [#parameters-25]
name [#name-23]
`string`
Returns [#returns-25]
`EqlV3Column`\<`EncryptedNumericOrdColumn`>
Text() [#text]
```ts
readonly Text: (name) => EqlV3Column<EncryptedTextColumn>;
```
Parameters [#parameters-26]
name [#name-24]
`string`
Returns [#returns-26]
`EqlV3Column`\<`EncryptedTextColumn`>
TextEq() [#texteq]
```ts
readonly TextEq: (name) => EqlV3Column<EncryptedTextEqColumn>;
```
Parameters [#parameters-27]
name [#name-25]
`string`
Returns [#returns-27]
`EqlV3Column`\<`EncryptedTextEqColumn`>
TextMatch() [#textmatch]
```ts
readonly TextMatch: (name) => EqlV3Column<EncryptedTextMatchColumn>;
```
Parameters [#parameters-28]
name [#name-26]
`string`
Returns [#returns-28]
`EqlV3Column`\<`EncryptedTextMatchColumn`>
TextOrdOre() [#textordore]
```ts
readonly TextOrdOre: (name) => EqlV3Column<EncryptedTextOrdOreColumn>;
```
Parameters [#parameters-29]
name [#name-27]
`string`
Returns [#returns-29]
`EqlV3Column`\<`EncryptedTextOrdOreColumn`>
TextOrd() [#textord]
```ts
readonly TextOrd: (name) => EqlV3Column<EncryptedTextOrdColumn>;
```
Parameters [#parameters-30]
name [#name-28]
`string`
Returns [#returns-30]
`EqlV3Column`\<`EncryptedTextOrdColumn`>
TextSearch() [#textsearch]
```ts
readonly TextSearch: (name) => EqlV3Column<EncryptedTextSearchColumn>;
```
Parameters [#parameters-31]
name [#name-29]
`string`
Returns [#returns-31]
`EqlV3Column`\<`EncryptedTextSearchColumn`>
Boolean() [#boolean]
```ts
readonly Boolean: (name) => EqlV3Column<EncryptedBooleanColumn>;
```
Parameters [#parameters-32]
name [#name-30]
`string`
Returns [#returns-32]
`EqlV3Column`\<`EncryptedBooleanColumn`>
Real() [#real]
```ts
readonly Real: (name) => EqlV3Column<EncryptedRealColumn>;
```
Parameters [#parameters-33]
name [#name-31]
`string`
Returns [#returns-33]
`EqlV3Column`\<`EncryptedRealColumn`>
RealEq() [#realeq]
```ts
readonly RealEq: (name) => EqlV3Column<EncryptedRealEqColumn>;
```
Parameters [#parameters-34]
name [#name-32]
`string`
Returns [#returns-34]
`EqlV3Column`\<`EncryptedRealEqColumn`>
RealOrdOre() [#realordore]
```ts
readonly RealOrdOre: (name) => EqlV3Column<EncryptedRealOrdOreColumn>;
```
Parameters [#parameters-35]
name [#name-33]
`string`
Returns [#returns-35]
`EqlV3Column`\<`EncryptedRealOrdOreColumn`>
RealOrd() [#realord]
```ts
readonly RealOrd: (name) => EqlV3Column<EncryptedRealOrdColumn>;
```
Parameters [#parameters-36]
name [#name-34]
`string`
Returns [#returns-36]
`EqlV3Column`\<`EncryptedRealOrdColumn`>
Double() [#double]
```ts
readonly Double: (name) => EqlV3Column<EncryptedDoubleColumn>;
```
Parameters [#parameters-37]
name [#name-35]
`string`
Returns [#returns-37]
`EqlV3Column`\<`EncryptedDoubleColumn`>
DoubleEq() [#doubleeq]
```ts
readonly DoubleEq: (name) => EqlV3Column<EncryptedDoubleEqColumn>;
```
Parameters [#parameters-38]
name [#name-36]
`string`
Returns [#returns-38]
`EqlV3Column`\<`EncryptedDoubleEqColumn`>
DoubleOrdOre() [#doubleordore]
```ts
readonly DoubleOrdOre: (name) => EqlV3Column<EncryptedDoubleOrdOreColumn>;
```
Parameters [#parameters-39]
name [#name-37]
`string`
Returns [#returns-39]
`EqlV3Column`\<`EncryptedDoubleOrdOreColumn`>
DoubleOrd() [#doubleord]
```ts
readonly DoubleOrd: (name) => EqlV3Column<EncryptedDoubleOrdColumn>;
```
Parameters [#parameters-40]
name [#name-38]
`string`
Returns [#returns-40]
`EqlV3Column`\<`EncryptedDoubleOrdColumn`>
Json() [#json]
```ts
readonly Json: (name) => EqlV3Column<EncryptedJsonColumn>;
```
Parameters [#parameters-41]
name [#name-39]
`string`
Returns [#returns-41]
`EqlV3Column`\<`EncryptedJsonColumn`>
Functions [#functions]
v3ToDriver() [#v3todriver]
```ts
function v3ToDriver(value): string | null;
```
Defined in: [codec.ts:67](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-drizzle/src/codec.ts#L67)
Serialise an encrypted envelope to a jsonb string for the driver. Null and
undefined map to SQL NULL (JS `null`), never the JSON `null` literal.
Parameters [#parameters-42]
value [#value]
`EncryptedPayload` | `null` | `undefined`
Returns [#returns-42]
`string` | `null`
***
v3FromDriver() [#v3fromdriver]
```ts
function v3FromDriver(value): EncryptedPayload | null;
```
Defined in: [codec.ts:81](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-drizzle/src/codec.ts#L81)
Parse a driver jsonb value back into an encrypted envelope. `postgres`
hands back an already-parsed object for jsonb; a string is parsed. Null and
undefined normalise to `null` (SQL NULL).
Malformed and non-envelope payloads throw [EqlV3CodecError](https://cipherstash.com/docs/integrations/drizzle/api-reference#eqlv3codecerror) rather than
surfacing a raw `SyntaxError` or passing a bare scalar through as though it
were an envelope — a wrong value here reaches `decrypt` as garbage.
Parameters [#parameters-43]
value [#value-1]
`string` | `object` | `null` | `undefined`
Returns [#returns-43]
`EncryptedPayload` | `null`
***
makeEqlV3Column() [#makeeqlv3column]
```ts
function makeEqlV3Column<C>(builder): EqlV3Column<C>;
```
Defined in: [column.ts:221](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-drizzle/src/column.ts#L221)
Type Parameters [#type-parameters]
C [#c]
`C` *extends* `AnyEncryptedV3Column`
Parameters [#parameters-44]
builder [#builder]
`C`
Returns [#returns-44]
`EqlV3Column`\<`C`>
***
getEqlV3Column() [#geteqlv3column]
```ts
function getEqlV3Column(columnName, column): AnyEncryptedV3Column | undefined;
```
Defined in: [column.ts:265](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-drizzle/src/column.ts#L265)
Parameters [#parameters-45]
columnName [#columnname-2]
`string`
column [#column]
`unknown`
Returns [#returns-45]
`AnyEncryptedV3Column` | `undefined`
***
isEqlV3Column() [#iseqlv3column]
```ts
function isEqlV3Column(column): boolean;
```
Defined in: [column.ts:277](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-drizzle/src/column.ts#L277)
Parameters [#parameters-46]
column [#column-1]
`unknown`
Returns [#returns-46]
`boolean`
***
encryptedIndexes() [#encryptedindexes]
```ts
function encryptedIndexes(columns): IndexBuilder[];
```
Defined in: [indexes.ts:56](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-drizzle/src/indexes.ts#L56)
Derive the recommended functional indexes for every encrypted column in a
table, from the same per-domain capability record the operator layer gates
on (`builder.build().indexes`) — so the emitted indexes and the operators
that engage them cannot drift.
Call it inside `pgTable`'s third-argument callback and spread the result:
```ts
import { integer, pgTable } from 'drizzle-orm/pg-core'
import { encryptedIndexes, types } from '@cipherstash/stack-drizzle'
export const users = pgTable(
'users',
{
id: integer('id').primaryKey(),
email: types.TextEq('email'),
bio: types.TextSearch('bio'),
},
(t) => [...encryptedIndexes(t)],
)
```
Emitted per capability, named `_<column>_<capability>`:
* equality (`hm` term) → `USING btree (eql_v3.eq_term(col))`
* ordering (`op` term) → `USING btree (eql_v3.ord_term(col))`
* ORE ordering (`ob`) → `USING btree (eql_v3.ord_term_ore(col))`
* free-text match (`bf`) → `USING gin (eql_v3.match_term(col))`
* encrypted JSON → `USING gin ((eql_v3.to_ste_vec_query(col)::jsonb) jsonb_path_ops)`
A `types.TextSearch` column therefore yields three indexes. Ordering
columns differ by type: a numeric, date, or timestamp `*Ord` / `*OrdOre`
column yields a single ordering index that also serves `=` (EQL compares
those columns by their ordering term directly), while `types.TextOrd` /
`TextOrdOre` yield an equality index alongside the ordering one (text
equality runs on a separate term). A storage-only column (bare
`types.Text`, `types.Boolean`, …) yields none — it has no queryable term —
and non-encrypted columns are ignored. Field-level selector indexes on
encrypted JSON cannot be derived here (the selector hash is data the
crypto layer emits, not schema) — declare those by hand; see the
`stash-indexing` skill for the recipe.
Existing tables adopt these through a normal `drizzle-kit generate`
migration; run `ANALYZE ` after it applies — an expression index
gathers no statistics at `CREATE INDEX` time. The gap this closes (#753):
the integration emitted operators but no index DDL, so encrypted
predicates sequential-scanned by default.
Parameters [#parameters-47]
columns [#columns]
`Record`\<`string`, `unknown`>
Returns [#returns-47]
`IndexBuilder`\[]
***
createEncryptionOperators() [#createencryptionoperators]
```ts
function createEncryptionOperators(client, defaults?): {
eq: (l, r, opts?) => Promise<SQL<unknown>>;
ne: (l, r, opts?) => Promise<SQL<unknown>>;
gt: (l, r, opts?) => Promise<SQL<unknown>>;
gte: (l, r, opts?) => Promise<SQL<unknown>>;
lt: (l, r, opts?) => Promise<SQL<unknown>>;
lte: (l, r, opts?) => Promise<SQL<unknown>>;
between: (l, min, max, opts?) => Promise<SQL<unknown>>;
notBetween: (l, min, max, opts?) => Promise<SQL<unknown>>;
matches: (l, r, opts?) => Promise<SQL<unknown>>;
contains: (l, r, opts?) => Promise<SQL<unknown>>;
selector: (l, path) => {
eq: (value, opts?) => Promise<SQL<unknown>>;
ne: (value, opts?) => Promise<SQL<unknown>>;
gt: (value, opts?) => Promise<SQL<unknown>>;
gte: (value, opts?) => Promise<SQL<unknown>>;
lt: (value, opts?) => Promise<SQL<unknown>>;
lte: (value, opts?) => Promise<SQL<unknown>>;
asc: (opts?) => Promise<SQL<unknown>>;
desc: (opts?) => Promise<SQL<unknown>>;
};
inArray: (l, values, opts?) => Promise<SQL<unknown>>;
notInArray: (l, values, opts?) => Promise<SQL<unknown>>;
asc: (c) => SQL<unknown>;
desc: (c) => SQL<unknown>;
and: (...conds) => Promise<SQL<unknown>>;
or: (...conds) => Promise<SQL<unknown>>;
isNull: (value) => SQL;
isNotNull: (value) => SQL;
not: (condition) => SQL;
exists: (subquery) => SQL;
notExists: (subquery) => SQL;
};
```
Defined in: [operators.ts:204](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-drizzle/src/operators.ts#L204)
Build v3-aware query operators (`eq`, `gte`, `matches`, `contains`, `asc`, …) bound to an
encryption `client`. Each comparison/containment operator AUTO-ENCRYPTS its
plaintext operand into an EQL v3 query term before handing it to Drizzle, so
callers pass plaintext and the emitted SQL compares encrypted values. Every
operator also gates on the target column's capabilities and throws
[EncryptionOperatorError](https://cipherstash.com/docs/integrations/drizzle/api-reference#encryptionoperatorerror) when the column can't answer the operator
(e.g. ordering a non-`ore` column).
Parameters [#parameters-48]
client [#client]
`OperandEncryptionClient`
anything that can `encryptQuery`: an `EncryptionClient` at any
schema-tuple instantiation, including the narrowed one
`Encryption({ schemas })` returns, or a partial client supplying just that
capability. No cast needed in either case.
defaults? [#defaults]
`EncryptionOperatorCallOpts` = `{}`
lock context / audit applied to every operand encryption
unless a per-call override is supplied.
Returns [#returns-48]
eq() [#eq]
```ts
eq: (l, r, opts?) => Promise<SQL<unknown>>;
```
Equality: `column = value`. Encrypts `r` and emits `eql_v3.eq`.
Requires a `unique` or `ore` index on the column.
Parameters [#parameters-49]
l [#l]
`SQLWrapper`
r [#r]
`unknown`
opts? [#opts]
`EncryptionOperatorCallOpts`
Returns [#returns-49]
`Promise`\<`SQL`\<`unknown`>>
ne() [#ne]
```ts
ne: (l, r, opts?) => Promise<SQL<unknown>>;
```
Inequality: `column <> value`. Encrypts `r` and emits `eql_v3.neq`.
Requires a `unique` or `ore` index on the column.
Parameters [#parameters-50]
l [#l-1]
`SQLWrapper`
r [#r-1]
`unknown`
opts? [#opts-1]
`EncryptionOperatorCallOpts`
Returns [#returns-50]
`Promise`\<`SQL`\<`unknown`>>
gt() [#gt]
```ts
gt: (l, r, opts?) => Promise<SQL<unknown>>;
```
Greater-than: `column > value`. Encrypts `r` and emits `eql_v3.gt`.
Requires an `ore` (order/range) index.
Parameters [#parameters-51]
l [#l-2]
`SQLWrapper`
r [#r-2]
`unknown`
opts? [#opts-2]
`EncryptionOperatorCallOpts`
Returns [#returns-51]
`Promise`\<`SQL`\<`unknown`>>
gte() [#gte]
```ts
gte: (l, r, opts?) => Promise<SQL<unknown>>;
```
Greater-than-or-equal: `column >= value`. Encrypts `r` and emits
`eql_v3.gte`. Requires an `ore` (order/range) index.
Parameters [#parameters-52]
l [#l-3]
`SQLWrapper`
r [#r-3]
`unknown`
opts? [#opts-3]
`EncryptionOperatorCallOpts`
Returns [#returns-52]
`Promise`\<`SQL`\<`unknown`>>
lt() [#lt]
```ts
lt: (l, r, opts?) => Promise<SQL<unknown>>;
```
Less-than: `column < value`. Encrypts `r` and emits `eql_v3.lt`.
Requires an `ore` (order/range) index.
Parameters [#parameters-53]
l [#l-4]
`SQLWrapper`
r [#r-4]
`unknown`
opts? [#opts-4]
`EncryptionOperatorCallOpts`
Returns [#returns-53]
`Promise`\<`SQL`\<`unknown`>>
lte() [#lte]
```ts
lte: (l, r, opts?) => Promise<SQL<unknown>>;
```
Less-than-or-equal: `column <= value`. Encrypts `r` and emits
`eql_v3.lte`. Requires an `ore` (order/range) index.
Parameters [#parameters-54]
l [#l-5]
`SQLWrapper`
r [#r-5]
`unknown`
opts? [#opts-5]
`EncryptionOperatorCallOpts`
Returns [#returns-54]
`Promise`\<`SQL`\<`unknown`>>
between() [#between]
```ts
between: (l, min, max, opts?) => Promise<SQL<unknown>>;
```
Inclusive range `min <= column <= max`. Encrypts both bounds
concurrently. Requires an `ore` (order/range) index.
Parameters [#parameters-55]
l [#l-6]
`SQLWrapper`
min [#min]
`unknown`
max [#max]
`unknown`
opts? [#opts-6]
`EncryptionOperatorCallOpts`
Returns [#returns-55]
`Promise`\<`SQL`\<`unknown`>>
notBetween() [#notbetween]
```ts
notBetween: (l, min, max, opts?) => Promise<SQL<unknown>>;
```
Negated inclusive range `NOT (min <= column <= max)`. Encrypts both
bounds concurrently. Requires an `ore` (order/range) index.
Parameters [#parameters-56]
l [#l-7]
`SQLWrapper`
min [#min-1]
`unknown`
max [#max-1]
`unknown`
opts? [#opts-7]
`EncryptionOperatorCallOpts`
Returns [#returns-56]
`Promise`\<`SQL`\<`unknown`>>
matches() [#matches]
```ts
matches: (l, r, opts?) => Promise<SQL<unknown>>;
```
Fuzzy free-text token match — the needle's 3-gram set is (bloom-)tested
as a subset of the column's. NOT containment: order/multiplicity-
insensitive and one-sided (a `true` may be a false positive). Encrypts
`r`. Requires a `match` (free-text search) index.
Parameters [#parameters-57]
l [#l-8]
`SQLWrapper`
r [#r-6]
`unknown`
opts? [#opts-8]
`EncryptionOperatorCallOpts`
Returns [#returns-57]
`Promise`\<`SQL`\<`unknown`>>
contains() [#contains]
```ts
contains: (l, r, opts?) => Promise<SQL<unknown>>;
```
Exact encrypted-JSONB containment (`@>`): matches rows whose document
contains the given sub-object. No false positives. Encrypts `r`. Requires
a `ste_vec` index (a `types.Json` column).
Parameters [#parameters-58]
l [#l-9]
`SQLWrapper`
r [#r-7]
`unknown`
opts? [#opts-9]
`EncryptionOperatorCallOpts`
Returns [#returns-58]
`Promise`\<`SQL`\<`unknown`>>
selector() [#selector]
```ts
selector: (l, path) => {
eq: (value, opts?) => Promise<SQL<unknown>>;
ne: (value, opts?) => Promise<SQL<unknown>>;
gt: (value, opts?) => Promise<SQL<unknown>>;
gte: (value, opts?) => Promise<SQL<unknown>>;
lt: (value, opts?) => Promise<SQL<unknown>>;
lte: (value, opts?) => Promise<SQL<unknown>>;
asc: (opts?) => Promise<SQL<unknown>>;
desc: (opts?) => Promise<SQL<unknown>>;
};
```
JSONPath selector-with-constraint on a `types.Json` (`ste_vec`) column.
Returns comparison and ordering methods bound to `col->'path'` — e.g.
`await ops.selector(users.doc, '$.age').gt(21)` emits
`col->'<sel>' > <entry>`, while `.asc()` emits
`ORDER BY eql_v3.ord_term(col->'<sel>')`. Its unique power over `contains`
is ordering at a path (`gt`/`gte`/`lt`/`lte` and `asc`/`desc`); `eq`/`ne`
are also provided. Dot-notation object paths only in v1.
Parameters [#parameters-59]
l [#l-10]
`SQLWrapper`
path [#path]
`string`
Returns [#returns-59]
eq() [#eq-1]
```ts
eq: (value, opts?) => Promise<SQL<unknown>>;
```
`col->'path' = value` (encrypted equality at the selector). A row whose
document lacks `path` is excluded (it is not equal to `value`).
Parameters [#parameters-60]
value [#value-2]
`unknown`
opts? [#opts-10]
`EncryptionOperatorCallOpts`
Returns [#returns-60]
`Promise`\<`SQL`\<`unknown`>>
ne() [#ne-1]
```ts
ne: (value, opts?) => Promise<SQL<unknown>>;
```
`col->'path' <> value`, INCLUDING rows whose document lacks `path`
("not equal to value" covers "has no value").
Parameters [#parameters-61]
value [#value-3]
`unknown`
opts? [#opts-11]
`EncryptionOperatorCallOpts`
Returns [#returns-61]
`Promise`\<`SQL`\<`unknown`>>
gt() [#gt-1]
```ts
gt: (value, opts?) => Promise<SQL<unknown>>;
```
`col->'path' > value` (encrypted ordering at the selector).
Parameters [#parameters-62]
value [#value-4]
`unknown`
opts? [#opts-12]
`EncryptionOperatorCallOpts`
Returns [#returns-62]
`Promise`\<`SQL`\<`unknown`>>
gte() [#gte-1]
```ts
gte: (value, opts?) => Promise<SQL<unknown>>;
```
`col->'path' >= value`.
Parameters [#parameters-63]
value [#value-5]
`unknown`
opts? [#opts-13]
`EncryptionOperatorCallOpts`
Returns [#returns-63]
`Promise`\<`SQL`\<`unknown`>>
lt() [#lt-1]
```ts
lt: (value, opts?) => Promise<SQL<unknown>>;
```
`col->'path' < value`.
Parameters [#parameters-64]
value [#value-6]
`unknown`
opts? [#opts-14]
`EncryptionOperatorCallOpts`
Returns [#returns-64]
`Promise`\<`SQL`\<`unknown`>>
lte() [#lte-1]
```ts
lte: (value, opts?) => Promise<SQL<unknown>>;
```
`col->'path' <= value`.
Parameters [#parameters-65]
value [#value-7]
`unknown`
opts? [#opts-15]
`EncryptionOperatorCallOpts`
Returns [#returns-65]
`Promise`\<`SQL`\<`unknown`>>
asc() [#asc]
```ts
asc: (opts?) => Promise<SQL<unknown>>;
```
Order rows ascending by the encrypted scalar at `path`. Missing paths
produce SQL NULL and follow PostgreSQL's normal NULL ordering.
Parameters [#parameters-66]
opts? [#opts-16]
`EncryptionOperatorCallOpts`
Returns [#returns-66]
`Promise`\<`SQL`\<`unknown`>>
desc() [#desc]
```ts
desc: (opts?) => Promise<SQL<unknown>>;
```
Order rows descending by the encrypted scalar at `path`. Missing paths
produce SQL NULL and follow PostgreSQL's normal NULL ordering.
Parameters [#parameters-67]
opts? [#opts-17]
`EncryptionOperatorCallOpts`
Returns [#returns-67]
`Promise`\<`SQL`\<`unknown`>>
inArray() [#inarray]
```ts
inArray: (l, values, opts?) => Promise<SQL<unknown>>;
```
Membership: ORs one encrypted `eq` term per value. The whole list is
encrypted in one `encryptQuery` batch crossing. Rejects an empty list;
requires a `unique` or `ore` index.
Parameters [#parameters-68]
l [#l-11]
`SQLWrapper`
values [#values]
`unknown`\[]
opts? [#opts-18]
`EncryptionOperatorCallOpts`
Returns [#returns-68]
`Promise`\<`SQL`\<`unknown`>>
notInArray() [#notinarray]
```ts
notInArray: (l, values, opts?) => Promise<SQL<unknown>>;
```
Non-membership: ANDs one encrypted `ne` term per value. The whole list
is encrypted in one `encryptQuery` batch crossing. Rejects an empty list;
requires a `unique` or `ore` index.
Parameters [#parameters-69]
l [#l-12]
`SQLWrapper`
values [#values-1]
`unknown`\[]
opts? [#opts-19]
`EncryptionOperatorCallOpts`
Returns [#returns-69]
`Promise`\<`SQL`\<`unknown`>>
asc() [#asc-1]
```ts
asc: (c) => SQL<unknown>;
```
Ascending order by the encrypted order term (`eql_v3.ord_term` /
`eql_v3.ord_term_ore`, by the column's ordering flavour).
Synchronous (no operand to encrypt). Requires an ordering index.
Parameters [#parameters-70]
c [#c-1]
`SQLWrapper`
Returns [#returns-70]
`SQL`\<`unknown`>
desc() [#desc-1]
```ts
desc: (c) => SQL<unknown>;
```
Descending order by the encrypted order term (`eql_v3.ord_term` /
`eql_v3.ord_term_ore`, by the column's ordering flavour).
Synchronous (no operand to encrypt). Requires an ordering index.
Parameters [#parameters-71]
c [#c-2]
`SQLWrapper`
Returns [#returns-71]
`SQL`\<`unknown`>
and() [#and]
```ts
and: (...conds) => Promise<SQL<unknown>>;
```
Conjunction of the given conditions, awaiting any async operands and
dropping `undefined`. Empty input resolves to `true`.
Parameters [#parameters-72]
conds [#conds]
...(
\| `SQLWrapper`
\| `SQL`\<`unknown`>
\| `Promise`\<`SQL`\<`unknown`>>
\| `undefined`)\[]
Returns [#returns-72]
`Promise`\<`SQL`\<`unknown`>>
or() [#or]
```ts
or: (...conds) => Promise<SQL<unknown>>;
```
Disjunction of the given conditions, awaiting any async operands and
dropping `undefined`. Empty input resolves to `false`.
Parameters [#parameters-73]
conds [#conds-1]
...(
\| `SQLWrapper`
\| `SQL`\<`unknown`>
\| `Promise`\<`SQL`\<`unknown`>>
\| `undefined`)\[]
Returns [#returns-73]
`Promise`\<`SQL`\<`unknown`>>
isNull() [#isnull]
```ts
isNull: (value) => SQL;
```
Drizzle's `isNull`, re-exported unchanged — `column IS NULL` needs no
encryption and works on any (nullable) encrypted column.
Test whether an expression is NULL. By the SQL standard,
NULL is neither equal nor not equal to itself, so
it's recommended to use `isNull` and `notIsNull` for
comparisons to NULL.
Examples [#examples]
```ts
// Select cars that have no discontinuedAt date.
db.select().from(cars)
.where(isNull(cars.discontinuedAt))
```
Parameters [#parameters-74]
value [#value-8]
`SQLWrapper`
Returns [#returns-74]
`SQL`
See [#see]
isNotNull for the inverse of this test
isNotNull() [#isnotnull]
```ts
isNotNull: (value) => SQL;
```
Drizzle's `isNotNull`, re-exported unchanged — `column IS NOT NULL`
needs no encryption.
Test whether an expression is not NULL. By the SQL standard,
NULL is neither equal nor not equal to itself, so
it's recommended to use `isNull` and `notIsNull` for
comparisons to NULL.
Examples [#examples-1]
```ts
// Select cars that have been discontinued.
db.select().from(cars)
.where(isNotNull(cars.discontinuedAt))
```
Parameters [#parameters-75]
value [#value-9]
`SQLWrapper`
Returns [#returns-75]
`SQL`
See [#see-1]
isNull for the inverse of this test
not() [#not]
```ts
not: (condition) => SQL;
```
Drizzle's `not`, re-exported unchanged — negates an already-built
(encrypted) predicate. Safe over any operator here, including `between`,
whose fragment is self-parenthesising.
Negate the meaning of an expression using the `not` keyword.
Examples [#examples-2]
```ts
// Select cars _not_ made by GM or Ford.
db.select().from(cars)
.where(not(inArray(cars.make, ['GM', 'Ford'])))
```
Parameters [#parameters-76]
condition [#condition]
`SQLWrapper`
Returns [#returns-76]
`SQL`
exists() [#exists]
```ts
exists: (subquery) => SQL;
```
Drizzle's `exists`, re-exported unchanged — for correlated subqueries.
Test whether a subquery evaluates to have any rows.
Examples [#examples-3]
```ts
// Users whose `homeCity` column has a match in a cities
// table.
db
.select()
.from(users)
.where(
exists(db.select()
.from(cities)
.where(eq(users.homeCity, cities.id))),
);
```
Parameters [#parameters-77]
subquery [#subquery]
`SQLWrapper`
Returns [#returns-77]
`SQL`
See [#see-2]
notExists for the inverse of this test
notExists() [#notexists]
```ts
notExists: (subquery) => SQL;
```
Drizzle's `notExists`, re-exported unchanged — for correlated
subqueries.
Test whether a subquery doesn't include any result
rows.
Examples [#examples-4]
```ts
// Users whose `homeCity` column doesn't match
// a row in the cities table.
db
.select()
.from(users)
.where(
notExists(db.select()
.from(cities)
.where(eq(users.homeCity, cities.id))),
);
```
Parameters [#parameters-78]
subquery [#subquery-1]
`SQLWrapper`
Returns [#returns-78]
`SQL`
See [#see-3]
exists for the inverse of this test
Example [#example]
```typescript
const ops = createEncryptionOperators(await Encryption({ schemas: [users] }))
await db.select().from(users).where(await ops.eq(users.email, 'a@b.com'))
```
***
extractEncryptionSchema() [#extractencryptionschema]
```ts
function extractEncryptionSchema<T>(table): ExtractedEncryptionSchema<T>;
```
Defined in: [schema-extraction.ts:81](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-drizzle/src/schema-extraction.ts#L81)
Rebuild a Drizzle table's encrypted columns as an eql/v3 EncryptedTable.
The return type mirrors what `encryptedTable()` itself returns —
`EncryptedTable<Cols> & Cols` — so the result is both a schema for
`Encryption({ schemas })` and a column accessor (`schema.email`), with each
column's concrete domain preserved. That is what keeps `InferPlaintext` /
`encryptModel` / `bulkEncryptModels` precisely typed against an extracted
schema.
Type Parameters [#type-parameters-1]
T [#t]
`T` *extends* `PgTable`\<`TableConfig`>
Parameters [#parameters-79]
table [#table]
`T`
Returns [#returns-79]
`ExtractedEncryptionSchema`\<`T`>
# EQL v2
Source: https://cipherstash.com/docs/reference/eql/v2
This section documents **EQL v2** (v2.2), the release existing CipherStash deployments run. Starting a new project? Use **EQL v3** — see the [EQL reference](https://cipherstash.com/docs/reference/eql).
**Encrypt Query Language (EQL)** is a set of PostgreSQL types, operators, and functions that enable queries on encrypted data without decryption. EQL works seamlessly with the [CipherCell](https://cipherstash.com/docs/reference/eql/v2/payload) format to provide searchable encryption capabilities directly in PostgreSQL.
What is EQL? [#what-is-eql]
EQL provides the database-side components needed to query encrypted data. Unlike traditional PostgreSQL extensions, EQL is implemented as a collection of types, operators, and functions, making it compatible with managed database providers like AWS RDS that restrict extension installation.
When combined with the [Stack SDK](https://cipherstash.com/docs/reference/stack) or [CipherStash Proxy](https://cipherstash.com/docs/reference/proxy), EQL enables:
* **Exact match queries** using encrypted equality operators
* **Range queries** with order-preserving encryption
* **Pattern matching** using encrypted Bloom filters
* **Unique constraints** on encrypted columns
* **JSON/JSONB operations** on encrypted structured data
Core components [#core-components]
The eql_v2_encrypted type [#the-eql_v2_encrypted-type]
The foundation of EQL is the `eql_v2_encrypted` data type, which stores [CipherCells](https://cipherstash.com/docs/reference/eql/v2/payload) containing encrypted data and searchable encrypted metadata.
```sql
CREATE TABLE users (
id SERIAL PRIMARY KEY,
email eql_v2_encrypted,
name eql_v2_encrypted
);
```
The `eql_v2_encrypted` type is required for searchable encryption in PostgreSQL. Regular `JSON` or `JSONB` types can store CipherCells but do not support encrypted queries.
Operators [#operators]
EQL provides PostgreSQL operators that work directly with encrypted data:
```sql
-- Exact match
SELECT * FROM users WHERE email = 'encrypted_search_value'::eql_v2_encrypted;
-- Range queries
SELECT * FROM products WHERE price > 'encrypted_value'::eql_v2_encrypted;
-- Pattern matching
SELECT * FROM documents WHERE content LIKE '%encrypted_pattern%';
```
Functions [#functions]
EQL ships in the `eql_v2` schema, with functions in three groups:
* **Configuration** — register tables, columns, and searchable indexes in the EQL configuration.
* **Index-term extraction** — `eql_v2.hmac_256()` (exact match), `eql_v2.bloom_filter()` (pattern matching), and `eql_v2.ore_block_u64_8_256()` (range) extract a searchable term from an encrypted value. These back the functional indexes — see [Setting up indexes](https://cipherstash.com/docs/reference/eql/v2/indexes).
* **Comparison** — operators (`=`, `<`, `LIKE`, `@>`, …) are the query surface over encrypted columns.
For the complete function reference — every signature, parameter, and return type — see [EQL functions](https://cipherstash.com/docs/reference/eql/functions).
Index types [#index-types]
EQL supports multiple searchable encryption index types. Each index type enables different query patterns:
unique: Exact match [#unique-exact-match]
Enables exact equality queries and unique constraints using HMAC-SHA256.
[Learn more about equality queries](https://cipherstash.com/docs/concepts/searchable-encryption#query-capabilities)
ore: Range queries [#ore-range-queries]
Enables range comparisons (`<`, `>`, `BETWEEN`) and ordering (`ORDER BY`) using Order Revealing Encryption.
[Learn more about range queries](https://cipherstash.com/docs/concepts/searchable-encryption#query-capabilities)
match: Pattern matching [#match-pattern-matching]
Enables substring and full-text search (`LIKE`, `ILIKE`) using encrypted Bloom filters with trigrams.
[Learn more about token matching](https://cipherstash.com/docs/concepts/searchable-encryption#query-capabilities)
ste_vec: Structured data [#ste_vec-structured-data]
Enables containment queries and JSON-style operations on encrypted arrays and JSONB data.
How EQL v2 queries encrypted data [#how-eql-v2-queries-encrypted-data]
EQL leverages PostgreSQL's native indexing capabilities to enable efficient queries on encrypted data. The searchable encrypted metadata within [CipherCells](https://cipherstash.com/docs/reference/eql/v2/payload) is indexed using standard PostgreSQL index types (B-tree for exact/range, GIN for pattern matching).
When a query is executed:
1. **Client-side**: The application encrypts the search value using the same encryption scheme, producing a CipherCell with the appropriate searchable encrypted metadata
2. **Database-side**: EQL operators extract and compare the searchable encrypted metadata from both the stored CipherCells and the search CipherCell
3. **Result**: Matching rows are returned without ever decrypting the data in the database
Compatibility [#compatibility]
EQL is designed to work with:
* **PostgreSQL 14+**: Full support for all EQL features
* **Managed databases**: Works with AWS RDS, Azure Database, Google Cloud SQL, and other managed PostgreSQL providers
* **CipherStash SDKs**: Integrates with all CipherStash SDKs as well as CipherStash Proxy
Unlike PostgreSQL extensions that require `CREATE EXTENSION`, EQL types and functions are installed directly into your database schema, making it compatible with managed database environments that restrict extension installation.
Related documentation [#related-documentation]
* [CipherCell format](https://cipherstash.com/docs/reference/eql/v2/payload): The data structure used by EQL
* [Searchable encryption](https://cipherstash.com/docs/concepts/searchable-encryption): Available encrypted query capabilities
# Setting up indexes
Source: https://cipherstash.com/docs/reference/eql/v2/indexes
EQL v2 reference, for existing v2.2 deployments. New projects use [EQL v3](https://cipherstash.com/docs/reference/eql).
Encrypted columns need PostgreSQL indexes for fast queries. Without an index, the database performs a sequential scan: correct but slow at scale.
Index syntax differs between deployment types. Self-hosted PostgreSQL with full EQL installed supports custom operator classes and can use B-tree indexes directly on `eql_v2_encrypted` columns. Managed databases like Supabase cannot install operator families (they require superuser), so indexes must use extraction functions instead.
Deployment matrix [#deployment-matrix]
| Query type | Self-hosted (full EQL) | Supabase |
| ----------------- | ------------------------------------------------------------------------ | ---------------------------------------- |
| Equality | `USING btree (col)` with opclass, or `USING hash (eql_v2.hmac_256(col))` | `USING hash (eql_v2.hmac_256(col))` only |
| Range / ORDER BY | `USING btree (col)` with opclass | None (OPE-index work in progress) |
| Pattern match | `USING gin (eql_v2.bloom_filter(col))` | Same |
| JSONB containment | `USING gin (eql_v2.ste_vec(col))` | Same |
Range filters (`>`, `>=`, `<`, `<=`) work on Supabase without a range index (they use a sequential scan). `ORDER BY` on encrypted columns is not supported on Supabase at all. Sort application-side after decrypting results. Operator family support for Supabase is in development.
***
Equality [#equality]
Equality indexes speed up `WHERE col = $1` queries and `IN` lists.
**Self-hosted (B-tree with operator class):**
```sql
CREATE INDEX ON users USING btree (email);
```
This works because the full EQL install registers a B-tree operator class for `eql_v2_encrypted` that compares HMAC terms.
**Self-hosted or Supabase (hash on extraction function):**
```sql
CREATE INDEX ON users USING hash (eql_v2.hmac_256(email));
```
This form works on both deployment types. Use it when you want one index that works everywhere, or when you are on Supabase.
See queries: [Equality queries](https://cipherstash.com/docs/reference/eql/v2/queries#equality)
***
Match [#match]
Match indexes speed up `WHERE col LIKE $1` and `ILIKE` queries. They use a GIN index on the Bloom filter extracted from each encrypted value.
```sql
CREATE INDEX ON users USING gin (eql_v2.bloom_filter(name));
```
This form is identical for self-hosted and Supabase.
See queries: [Match queries](https://cipherstash.com/docs/reference/eql/v2/queries#match-free-text)
***
Range and order [#range-and-order]
Range indexes support `>`, `>=`, `<`, `<=`, `BETWEEN`, and `ORDER BY` on encrypted columns.
**Self-hosted (B-tree with operator class):**
```sql
CREATE INDEX ON users USING btree (age);
```
Requires the EQL operator family (`CREATE OPERATOR FAMILY`) to be installed. The full EQL install includes this. The `--exclude-operator-family` install flag omits it.
**Supabase:**
Functional range indexes for Supabase are not yet available. Range *filters* work without an index (sequential scan). `ORDER BY` on encrypted columns is not supported on Supabase.
See queries: [Range queries](https://cipherstash.com/docs/reference/eql/v2/queries#range-and-ordering)
***
JSONB [#jsonb]
JSONB indexes support path existence and containment queries on encrypted JSON columns.
```sql
CREATE INDEX ON documents USING gin (eql_v2.ste_vec(metadata));
```
This form is identical for self-hosted and Supabase.
See queries: [JSONB queries](https://cipherstash.com/docs/reference/eql/v2/queries#jsonb-queries)
***
Supabase query forms [#supabase-query-forms]
This is the most common source of silent performance problems with encrypted columns on Supabase.
A functional index on `eql_v2.hmac_256(email)` is only engaged when the query uses the same extraction function. A bare `WHERE email = $1` query does not use the index, even if the index exists. The database falls back to a sequential scan: your query returns correct results, but it scans every row.
**Wrong (does not use functional index):**
```sql
SELECT * FROM users WHERE email = $1::eql_v2_encrypted;
```
**Right (engages the functional index):**
```sql
SELECT * FROM users WHERE eql_v2.hmac_256(email) = eql_v2.hmac_256($1::eql_v2_encrypted);
```
SDK wrappers (Drizzle adapter, Supabase wrapper) generate the correct query form automatically. This only matters when you write raw SQL queries against Supabase encrypted columns. If you are using the Drizzle adapter or Supabase wrapper, no action is needed.
The same principle applies to `eql_v2.bloom_filter` and `eql_v2.ste_vec` indexes: the extraction function must appear in both the index definition and the query predicate.
***
Complete example [#complete-example]
```sql filename="migrations/add_encrypted_indexes.sql"
-- Equality index (Supabase-compatible form)
CREATE INDEX users_email_eq_idx ON users USING hash (eql_v2.hmac_256(email));
-- Match index
CREATE INDEX users_name_match_idx ON users USING gin (eql_v2.bloom_filter(name));
-- JSONB index
CREATE INDEX documents_metadata_ste_idx ON documents USING gin (eql_v2.ste_vec(metadata));
-- Range index (self-hosted only — requires operator family)
CREATE INDEX users_age_range_idx ON users USING btree (age);
```
***
Related [#related]
* [Searchable encryption queries](https://cipherstash.com/docs/reference/eql/v2/queries): Query patterns for each index type
* [Searchable encryption overview](https://cipherstash.com/docs/concepts/searchable-encryption): How searchable indexes work
* [Supabase integration](https://cipherstash.com/docs/integrations/supabase): Supabase-specific setup and limitations
* [EQL guide](https://cipherstash.com/docs/reference/eql/v2): Full reference for EQL types and functions
# The CipherCell
Source: https://cipherstash.com/docs/reference/eql/v2/payload
EQL v2 reference, for existing v2.2 deployments. New projects use [EQL v3](https://cipherstash.com/docs/reference/eql).
The **CipherCell** is CipherStash's standard format for storing encrypted data in a database. It is a JSON-based structure that combines **encrypted values**, **searchable encrypted metadata**, and **non-sensitive metadata** into a single, self-contained record.
CipherCells are designed to make encrypted data practical to work with in real applications. They can be stored in existing databases (such as PostgreSQL jsonb columns), indexed, queried, and audited without exposing plaintext.
What a CipherCell contains [#what-a-ciphercell-contains]
A CipherCell typically includes:
* **Encrypted data**
* The ciphertext for one or more sensitive values.
* Each value is encrypted independently using strong authenticated encryption and unique per-value keys.
* **Searchable Encrypted Metadata (SEM)**
* Additional cryptographic material derived from the plaintext that enables secure querying using searchable encryption.
* This metadata allows operations such as equality checks, range queries, or text search to be performed **without decrypting the data**.
* The database can evaluate queries over this metadata, but cannot recover the original values.
* **Non-sensitive metadata**
* Plaintext fields that are safe to expose, such as schema identifiers, versioning information, timestamps, or application-level IDs.
* Keeping this metadata unencrypted allows efficient filtering, indexing, and integration with existing tooling.
How CipherCells are used [#how-ciphercells-are-used]
CipherCells are stored directly in the database, usually in a JSON-compatible column.
[Encrypt Query Language (EQL)](https://cipherstash.com/docs/reference/eql/v2) understands this structure and provides database functions and operators that work over CipherCells, enabling encrypted search and filtering while preserving strong security guarantees.
From an application's perspective, a CipherCell behaves like a regular database value:
* Applications write encrypted data as JSON
* Databases store and index it
* Queries operate on Searchable Encrypted Metadata (SEM)
* Decryption happens only in trusted application code with the right keys and claims
Why CipherCells exist [#why-ciphercells-exist]
The CipherCell format solves a common problem with encryption at rest: traditional encryption makes data opaque and hard to query. CipherCells retain the benefits of encryption while enabling:
* Fine-grained, **per-value** protection
* Searchable encryption over structured data
* Compatibility with existing databases and ORMs
* Clear separation between sensitive and non-sensitive information
A CipherCell is the **unit of encrypted storage** in CipherStash: a portable, self-describing JSON record that makes encrypted data usable, searchable, and auditable by default.
Structure [#structure]
**Required fields**: Only `i` (identifier) and `v` (version) are required.
**Payload requirement**: Either `c` (ciphertext) or `sv` (structured encryption vector) must be present, but never both.
**Optional fields**: All searchable encrypted metadata (SEM) fields are optional and only included when the corresponding index types are configured.
A CipherCell is stored as a JSON object with the following top-level structure:
```json
{
"i": {
"t": "table_name",
"c": "column_name"
},
"v": 2,
"c": "encrypted_data_in_messagepack_base85",
"hm": "2e182f0c444d1d51f5f70f32d778b2eaa854f5921a4a2acaa4446c44055cb777",
"ob": ["ore_block_1", "ore_block_2"],
"bf": [1234, 5678, 9012]
}
```
Top-level fields [#top-level-fields]
i - Identifier [#i---identifier]
The table and column identifier for this encrypted data.
**Type**: Object with `t` (table) and `c` (column) properties
**Required**: Yes
```json
{
"i": {
"t": "users",
"c": "email"
}
}
```
This field identifies which table and column the encrypted data belongs to, enabling proper decryption and index usage.
v - Version [#v---version]
The encryption version used for this CipherCell.
**Type**: Integer
**Required**: Yes
```json
{
"v": 2
}
```
The version field allows for cryptographic algorithm upgrades over time while maintaining backward compatibility.
c - Ciphertext (required unless sv is present) [#c---ciphertext-required-unless-sv-is-present]
The encrypted record containing the actual plaintext data.
**Type**: String (MessagePack encoded and Base85 encoded)
**Required**: Yes (unless `sv` field is present)
```json
{
"c": "Xk}0>Z*pVbW@%*8a%F0@"
}
```
Either `c` or `sv` must be present in every CipherCell, but never both. Use `c` for standard encrypted values and `sv` for structured encryption vectors (arrays or JSON structures).
a - Array item flag [#a---array-item-flag]
Indicates whether this CipherCell represents an item within an array.
**Type**: Boolean
**Required**: No
```json
{
"a": true
}
```
Searchable Encrypted Metadata (SEM) [#searchable-encrypted-metadata-sem]
The CipherCell can contain various types of searchable encrypted metadata, each enabling different query capabilities. All SEM fields are optional and only included when the corresponding index type is configured.
hm - HMAC-SHA256 [#hm---hmac-sha256]
Enables exact match queries using HMAC-SHA256.
**Type**: Hex-encoded string (64 characters)
**Index Type**: [Equality](https://cipherstash.com/docs/concepts/searchable-encryption#query-capabilities)
```json
{
"hm": "2e182f0c444d1d51f5f70f32d778b2eaa854f5921a4a2acaa4446c44055cb777"
}
```
ob - ORE Block [#ob---ore-block]
Enables range queries and ordering using Order Revealing Encryption.
**Type**: Array of strings
**Index Type**: [Order / Range](https://cipherstash.com/docs/concepts/searchable-encryption#query-capabilities)
```json
{
"ob": [
"01a2b3c4d5e6f7g8h9i0",
"j1k2l3m4n5o6p7q8r9s0"
]
}
```
bf - Bloom Filter [#bf---bloom-filter]
Enables substring and pattern matching queries using encrypted Bloom filters with trigrams.
**Type**: Array of integers
**Index Type**: [Match](https://cipherstash.com/docs/concepts/searchable-encryption#query-capabilities)
```json
{
"bf": [1234, 5678, 9012, 3456, 7890]
}
```
b3 - Blake3 [#b3---blake3]
Blake3 hash for exact matches in structured encryption vectors.
**Type**: Hex-encoded string
**Used in**: SteVec (Structured Encryption Vector) subfield
s - Selector [#s---selector]
Selector value for field selection in structured encryption vectors.
**Type**: String
**Used in**: SteVec (Structured Encryption Vector) subfield
ocf - ORE CLWW Fixed-Width [#ocf---ore-clww-fixed-width]
ORE CLWW (Chenette-Lewi-Weis-Wu) fixed-width scheme for 64-bit integer values in structured encryption vectors.
**Type**: String
**Used in**: SteVec (Structured Encryption Vector) subfield
ocv - ORE CLWW Variable-Width [#ocv---ore-clww-variable-width]
ORE CLWW variable-width scheme for string comparison in structured encryption vectors.
**Type**: String
**Used in**: SteVec (Structured Encryption Vector) subfield
sv - Structured Encryption Vector (SteVec) (required unless c is present) [#sv---structured-encryption-vector-stevec-required-unless-c-is-present]
Nested array of CipherCells for supporting containment queries and JSON-style operations.
**Type**: Array of CipherCell objects
**Required**: Yes (unless `c` attribute is present)
```json
{
"sv": [
{
"c": "Xk}0>Z*pVbW@%*8a%F0@",
"hm": "hash1...",
"s": "selector1"
},
{
"c": "Yl~1?A+qWcX#&+9b&G1#",
"hm": "hash2...",
"s": "selector2"
}
]
}
```
SteVec enables queries on array elements and JSON document structures while maintaining encryption. Each element in the `sv` array is itself a CipherCell that can contain SEM fields like `b3`, `s`, `ocf`, and `ocv`.
Complete example [#complete-example]
Here's a complete CipherCell with multiple index types enabled:
```json
{
"i": {
"t": "products",
"c": "price"
},
"v": 2,
"c": "Xk}0>Z*pVbW@%*8a%F0@Yl~1?A+qWcX#&+9b&G1#",
"hm": "2e182f0c444d1d51f5f70f32d778b2eaa854f5921a4a2acaa4446c44055cb777",
"ob": [
"01a2b3c4d5e6f7g8h9i0",
"j1k2l3m4n5o6p7q8r9s0",
"t1u2v3w4x5y6z7a8b9c0"
],
"bf": [1234, 5678, 9012, 3456, 7890, 2345, 6789]
}
```
This CipherCell:
* Belongs to the `price` column of the `products` table
* Uses encryption version 2
* Contains the encrypted plaintext value
* Supports exact match queries via `hm`
* Supports range queries and ordering via `ob`
* Supports pattern matching via `bf`
Design principles [#design-principles]
Minimal storage [#minimal-storage]
Only the index types configured for a column are included in the CipherCell. This minimizes storage overhead and ensures optimal performance.
Composable indexes [#composable-indexes]
Multiple index types can be combined on a single column, enabling both exact matches and range queries, or exact matches and pattern matching, depending on application needs.
Forward compatibility [#forward-compatibility]
The version field (`v`) enables cryptographic algorithm upgrades without requiring full database re-encryption. Older versions can coexist with newer versions during migration.
Standardized format [#standardized-format]
The CipherCell format is consistent across all CipherStash SDKs and tools, ensuring interoperability and portability of encrypted data.
Database storage [#database-storage]
CipherCells can be stored as JSON in any database that supports JSON data types.
However, for search to be supported using the [Stack SDK](https://cipherstash.com/docs/reference/stack) or [CipherStash Proxy](https://cipherstash.com/docs/reference/proxy), the `eql_v2.encrypted` database type must be used which is available when the Encrypt Query Language (EQL) helpers have been installed.
# Searchable encryption queries
Source: https://cipherstash.com/docs/reference/eql/v2/queries
EQL v2 reference, for existing v2.2 deployments. New projects use [EQL v3](https://cipherstash.com/docs/reference/eql).
This page covers the three query families available for encrypted columns: equality, match (free-text), and range/order. Each section shows the SDK predicate, the raw SQL form, the underlying EQL index, and links to the corresponding index setup.
For index creation (the `CREATE INDEX` statements your database needs), see [Setting up indexes](https://cipherstash.com/docs/reference/eql/v2/indexes).
For a conceptual overview of how searchable encryption works, see [Searchable encryption](https://cipherstash.com/docs/concepts/searchable-encryption).
Equality [#equality]
Exact match on an encrypted column. Uses the `unique` (HMAC-SHA256) index.
**Schema:**
```typescript filename="src/schema.ts"
import { encryptedTable, encryptedColumn } from "@cipherstash/stack/schema"
const users = encryptedTable("users", {
email: encryptedColumn("email").equality(),
})
```
**SDK (single value):**
```typescript filename="src/queries.ts"
const term = await client.encryptQuery("alice@example.com", {
column: users.email,
table: users,
queryType: "equality",
})
const result = await pgClient.query(
"SELECT * FROM users WHERE email = $1",
[term.data],
)
```
**SDK (IN list):**
```typescript filename="src/queries.ts"
const terms = await client.encryptQuery([
{ value: "alice@example.com", column: users.email, table: users, queryType: "equality" as const },
{ value: "bob@example.com", column: users.email, table: users, queryType: "equality" as const },
])
// Use each term.data as a separate parameter, or build an ANY($1) query.
```
**Drizzle:**
```typescript filename="src/queries.ts"
const results = await db
.select()
.from(usersTable)
.where(await encryptionOps.eq(usersTable.email, "alice@example.com"))
```
**Supabase wrapper:**
```typescript filename="src/queries.ts"
const { data } = await eSupabase
.from("users", users)
.select("id, email")
.eq("email", "alice@example.com")
```
**Raw SQL (self-hosted with EQL operator classes):**
```sql
SELECT * FROM users WHERE email = $1::eql_v2_encrypted;
```
**Raw SQL (Supabase / functional index form):**
```sql
SELECT * FROM users WHERE eql_v2.hmac_256(email) = eql_v2.hmac_256($1::eql_v2_encrypted);
```
On Supabase, bare `WHERE email = $1` does not use the functional index. Wrap both sides with `eql_v2.hmac_256()` to engage the hash index. The SDK wrappers (Drizzle, Supabase wrapper) handle this automatically. See [Index setup: Supabase callout](https://cipherstash.com/docs/reference/eql/v2/indexes#supabase-query-forms).
**Underlying index:** [Equality index setup](https://cipherstash.com/docs/reference/eql/v2/indexes#equality)
***
Match (free-text) [#match-free-text]
Substring and full-text search on an encrypted column. Uses the `match` (Bloom filter) index. Corresponds to `LIKE` / `ILIKE` semantics.
**Schema:**
```typescript filename="src/schema.ts"
const users = encryptedTable("users", {
name: encryptedColumn("name").freeTextSearch(),
})
```
**SDK:**
```typescript filename="src/queries.ts"
const term = await client.encryptQuery("alice", {
column: users.name,
table: users,
queryType: "freeTextSearch",
})
const result = await pgClient.query(
"SELECT * FROM users WHERE name LIKE $1",
[term.data],
)
```
**Drizzle:**
```typescript filename="src/queries.ts"
const results = await db
.select()
.from(usersTable)
.where(await encryptionOps.ilike(usersTable.name, "%alice%"))
```
**Supabase wrapper:**
```typescript filename="src/queries.ts"
const { data } = await eSupabase
.from("users", users)
.select("id, name")
.ilike("name", "%alice%")
```
**Raw SQL:**
```sql
SELECT * FROM users WHERE name LIKE $1;
```
The Bloom filter index uses a GIN index on the extracted filter term. See [Match index setup](https://cipherstash.com/docs/reference/eql/v2/indexes#match).
**Underlying index:** [Match index setup](https://cipherstash.com/docs/reference/eql/v2/indexes#match)
***
Range and ordering [#range-and-ordering]
Comparison (`>`, `>=`, `<`, `<=`, `BETWEEN`) and `ORDER BY` on an encrypted column. Uses the `ore` (Order Revealing Encryption) index.
**Schema:**
```typescript filename="src/schema.ts"
const users = encryptedTable("users", {
age: encryptedColumn("age").dataType("number").orderAndRange(),
})
```
**SDK (range filter):**
```typescript filename="src/queries.ts"
const term = await client.encryptQuery(21, {
column: users.age,
table: users,
queryType: "orderAndRange",
})
const result = await pgClient.query(
"SELECT * FROM users WHERE age > $1",
[term.data],
)
```
**SDK, ORDER BY (self-hosted only):**
```typescript filename="src/queries.ts"
// Self-hosted PostgreSQL with EQL operator families installed:
const result = await pgClient.query(
"SELECT * FROM users ORDER BY age ASC",
)
// Without operator family support (Supabase, or --exclude-operator-family):
const result = await pgClient.query(
"SELECT * FROM users ORDER BY eql_v2.ore_block_u64_8_256(age) ASC",
)
```
**Drizzle:**
```typescript filename="src/queries.ts"
// Range
const results = await db
.select()
.from(usersTable)
.where(await encryptionOps.gte(usersTable.age, 18))
// Sort (requires operator family support; not available on Supabase)
const results = await db
.select()
.from(usersTable)
.orderBy(encryptionOps.asc(usersTable.age))
```
**Supabase wrapper:**
```typescript filename="src/queries.ts"
// Range filter works
const { data } = await eSupabase
.from("users", users)
.select("id, age")
.gte("age", 18)
// ORDER BY on encrypted columns is not supported on Supabase.
// Sort application-side after decrypting.
```
`ORDER BY` on encrypted columns requires EQL operator families, which need superuser access to install. Supabase does not grant superuser. Range *filters* (`>`, `>=`, `<`, `<=`) work on both self-hosted and Supabase. Sorting on encrypted columns is not currently supported on Supabase. Sort application-side after decrypting results. Operator family support for Supabase is being developed in collaboration with the Supabase and CipherStash teams.
**Underlying index:** [Range index setup](https://cipherstash.com/docs/reference/eql/v2/indexes#range-and-order)
***
JSONB queries [#jsonb-queries]
Query encrypted JSON columns using path existence or containment. Uses the `ste_vec` index.
**Schema:**
```typescript filename="src/schema.ts"
const documents = encryptedTable("documents", {
metadata: encryptedColumn("metadata").searchableJson(),
})
```
**SDK (path existence):**
```typescript filename="src/queries.ts"
const term = await client.encryptQuery("$.user.role", {
column: documents.metadata,
table: documents,
})
const result = await pgClient.query(
"SELECT * FROM documents WHERE eql_v2.ste_vec(metadata) @> $1",
[term.data],
)
```
**SDK (containment):**
```typescript filename="src/queries.ts"
const term = await client.encryptQuery({ role: "admin" }, {
column: documents.metadata,
table: documents,
})
```
**Drizzle:**
```typescript filename="src/queries.ts"
const results = await db
.select()
.from(documentsTable)
.where(await encryptionOps.jsonbPathExists(documentsTable.metadata, "$.user.role"))
```
**Underlying index:** [JSONB index setup](https://cipherstash.com/docs/reference/eql/v2/indexes#jsonb)
# @cipherstash/stack-supabase
Source: https://cipherstash.com/docs/integrations/supabase/api-reference
**@cipherstash/stack-supabase**
***
Interfaces [#interfaces]
EncryptedQueryBuilder [#encryptedquerybuilder]
Defined in: [types.ts:303](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-supabase/src/types.ts#L303)
The v3 builder type: the shared [EncryptedQueryBuilderCore](https://cipherstash.com/docs/integrations/supabase/api-reference#encryptedquerybuildercore) surface with
filter methods narrowed to [FilterableKeys](https://cipherstash.com/docs/integrations/supabase/api-reference#filterablekeys) and `order()` to
OrderableKeys.
`like`/`ilike` are absent by construction. EQL v3 free-text search is fuzzy
bloom-filter token matching (`@>`), not SQL wildcard matching — `%` is
tokenized like any other character, so a `like` pattern is a category error.
The v3 dialect of Drizzle omits them for the same reason. Use `matches`.
Extends [#extends]
* [`EncryptedQueryBuilderCore`](https://cipherstash.com/docs/integrations/supabase/api-reference#encryptedquerybuildercore)\<`Row`, [`FilterableKeys`](https://cipherstash.com/docs/integrations/supabase/api-reference#filterablekeys)\<`Table`, `Row`> & `StringKeyOf`\<`Row`>, [`EncryptedQueryBuilder`](https://cipherstash.com/docs/integrations/supabase/api-reference#encryptedquerybuilder)\<`Table`, `Row`>, `OrderableKeys`\<`Table`, `Row`> & `StringKeyOf`\<`Row`>, `PlaintextKeys`\<`Table`, `Row`> & `StringKeyOf`\<`Row`>>
Type Parameters [#type-parameters]
Table [#table]
`Table` *extends* `AnyV3Table`
Row [#row]
`Row` *extends* `Record`\<`string`, `unknown`>
Methods [#methods]
matches() [#matches]
```ts
matches<K>(column, value): EncryptedQueryBuilder<Table, Row>;
```
Defined in: [types.ts:320](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-supabase/src/types.ts#L320)
Encrypted free-text token match on legacy EQL versions. EQL 3.0.2+
requires a query-domain cast PostgREST cannot express, so this fails fast.
Type Parameters [#type-parameters-1]
K [#k]
`K` *extends* `string`
Parameters [#parameters]
column [#column]
`K`
value [#value]
`string`
Returns [#returns]
[`EncryptedQueryBuilder`](https://cipherstash.com/docs/integrations/supabase/api-reference#encryptedquerybuilder)\<`Table`, `Row`>
contains() [#contains]
Call Signature [#call-signature]
```ts
contains<K>(column, value): EncryptedQueryBuilder<Table, Row>;
```
Defined in: [types.ts:327](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-supabase/src/types.ts#L327)
Native (exact) jsonb/array containment (`@>`). Plaintext columns only — an
encrypted column is a compile error (use [matches](https://cipherstash.com/docs/integrations/supabase/api-reference#matches)). A scalar plaintext
column resolves its operand to `never` (`@>` is array/jsonb only).
Type Parameters [#type-parameters-2]
K [#k-1]
`K` *extends* `string`
Parameters [#parameters-1]
column [#column-1]
`K`
value [#value-1]
`PlaintextContainsValue`\<`Row`\[`K`]>
Returns [#returns-1]
[`EncryptedQueryBuilder`](https://cipherstash.com/docs/integrations/supabase/api-reference#encryptedquerybuilder)\<`Table`, `Row`>
Call Signature [#call-signature-1]
```ts
contains<K>(column, value): EncryptedQueryBuilder<Table, Row>;
```
Defined in: [types.ts:334](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-supabase/src/types.ts#L334)
Encrypted JSON containment on legacy EQL versions. EQL 3.0.2+ requires an
`eql_v3.query_json` cast PostgREST cannot express, so this fails fast before
encrypting an operand into the request URL.
Type Parameters [#type-parameters-3]
K [#k-2]
`K` *extends* `string`
Parameters [#parameters-2]
column [#column-2]
`K`
value [#value-2]
`EncryptedJsonContainsValue`
Returns [#returns-2]
[`EncryptedQueryBuilder`](https://cipherstash.com/docs/integrations/supabase/api-reference#encryptedquerybuilder)\<`Table`, `Row`>
selectorEq() [#selectoreq]
```ts
selectorEq<K>(
column,
path,
value): EncryptedQueryBuilder<Table, Row>;
```
Defined in: [types.ts:340](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-supabase/src/types.ts#L340)
Encrypted JSONPath equality on legacy EQL versions. EQL 3.0.2+ fails fast
because PostgREST cannot express the required query-domain cast.
Type Parameters [#type-parameters-4]
K [#k-3]
`K` *extends* `string`
Parameters [#parameters-3]
column [#column-3]
`K`
path [#path]
`string`
value [#value-3]
`SelectorLeafValue`
Returns [#returns-3]
[`EncryptedQueryBuilder`](https://cipherstash.com/docs/integrations/supabase/api-reference#encryptedquerybuilder)\<`Table`, `Row`>
selectorNe() [#selectorne]
```ts
selectorNe<K>(
column,
path,
value): EncryptedQueryBuilder<Table, Row>;
```
Defined in: [types.ts:347](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-supabase/src/types.ts#L347)
Encrypted JSONPath inequality on legacy EQL versions. EQL 3.0.2+ fails
fast because PostgREST cannot express the required query-domain cast.
Type Parameters [#type-parameters-5]
K [#k-4]
`K` *extends* `string`
Parameters [#parameters-4]
column [#column-4]
`K`
path [#path-1]
`string`
value [#value-4]
`SelectorLeafValue`
Returns [#returns-4]
[`EncryptedQueryBuilder`](https://cipherstash.com/docs/integrations/supabase/api-reference#encryptedquerybuilder)\<`Table`, `Row`>
filter() [#filter]
Call Signature [#call-signature-2]
```ts
filter<K>(
column,
operator,
value): EncryptedQueryBuilder<Table, Row>;
```
Defined in: [types.ts:353](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-supabase/src/types.ts#L353)
Raw legacy containment spelling. EQL 3.0.2+ rejects this before sending.
Type Parameters [#type-parameters-6]
K [#k-5]
`K` *extends* `string`
Parameters [#parameters-5]
column [#column-5]
`K`
operator [#operator]
`"cs"`
value [#value-5]
`EncryptedJsonContainsValue`
Returns [#returns-5]
[`EncryptedQueryBuilder`](https://cipherstash.com/docs/integrations/supabase/api-reference#encryptedquerybuilder)\<`Table`, `Row`>
Overrides [#overrides]
[`EncryptedQueryBuilderCore`](https://cipherstash.com/docs/integrations/supabase/api-reference#encryptedquerybuildercore).[`filter`](https://cipherstash.com/docs/integrations/supabase/api-reference#filter-1)
Call Signature [#call-signature-3]
```ts
filter<K>(
column,
operator,
value): EncryptedQueryBuilder<Table, Row>;
```
Defined in: [types.ts:358](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-supabase/src/types.ts#L358)
Type Parameters [#type-parameters-7]
K [#k-6]
`K` *extends* `string`
Parameters [#parameters-6]
column [#column-6]
`K`
operator [#operator-1]
`string`
value [#value-6]
`Row`\[`K`]
Returns [#returns-6]
[`EncryptedQueryBuilder`](https://cipherstash.com/docs/integrations/supabase/api-reference#encryptedquerybuilder)\<`Table`, `Row`>
Overrides [#overrides-1]
```ts
EncryptedQueryBuilderCore.filter
```
not() [#not]
Call Signature [#call-signature-4]
```ts
not<K>(
column,
operator,
value): EncryptedQueryBuilder<Table, Row>;
```
Defined in: [types.ts:365](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-supabase/src/types.ts#L365)
Negated legacy containment spelling. EQL 3.0.2+ rejects this before
sending.
Type Parameters [#type-parameters-8]
K [#k-7]
`K` *extends* `string`
Parameters [#parameters-7]
column [#column-7]
`K`
operator [#operator-2]
`"contains"`
value [#value-7]
`EncryptedJsonContainsValue`
Returns [#returns-7]
[`EncryptedQueryBuilder`](https://cipherstash.com/docs/integrations/supabase/api-reference#encryptedquerybuilder)\<`Table`, `Row`>
Overrides [#overrides-2]
[`EncryptedQueryBuilderCore`](https://cipherstash.com/docs/integrations/supabase/api-reference#encryptedquerybuildercore).[`not`](https://cipherstash.com/docs/integrations/supabase/api-reference#not-1)
Call Signature [#call-signature-5]
```ts
not<K>(
column,
operator,
value): EncryptedQueryBuilder<Table, Row>;
```
Defined in: [types.ts:370](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-supabase/src/types.ts#L370)
Type Parameters [#type-parameters-9]
K [#k-8]
`K` *extends* `string`
Parameters [#parameters-8]
column [#column-8]
`K`
operator [#operator-3]
`string`
value [#value-8]
`Row`\[`K`]
Returns [#returns-8]
[`EncryptedQueryBuilder`](https://cipherstash.com/docs/integrations/supabase/api-reference#encryptedquerybuilder)\<`Table`, `Row`>
Overrides [#overrides-3]
```ts
EncryptedQueryBuilderCore.not
```
***
EncryptedQueryBuilderUntyped [#encryptedquerybuilderuntyped]
Defined in: [types.ts:390](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-supabase/src/types.ts#L390)
The builder for a table with no declared schema. Without capability
information `contains` cannot be narrowed to match-indexed columns — the
runtime guard in the term-encryption path is the only protection — and
`order()`/`is(col, true)` cannot be narrowed either, so this surface takes
[EncryptedQueryBuilderCore](https://cipherstash.com/docs/integrations/supabase/api-reference#encryptedquerybuildercore)'s `OK`/`BK` defaults. `like`/`ilike` are
absent here as on the typed surface.
For the same reason nothing here can tell an encrypted match column from a
plaintext jsonb one, so `matches`/`contains` accept the full native operand
union (which subsumes the encrypted column's `string`); the runtime resolves
the column and picks the encoding (and rejects the wrong-column-kind pairing).
Extends [#extends-1]
* [`EncryptedQueryBuilderCore`](https://cipherstash.com/docs/integrations/supabase/api-reference#encryptedquerybuildercore)\<`Row`, `StringKeyOf`\<`Row`>, [`EncryptedQueryBuilderUntyped`](https://cipherstash.com/docs/integrations/supabase/api-reference#encryptedquerybuilderuntyped)\<`Row`>>
Type Parameters [#type-parameters-10]
Row [#row-1]
`Row` *extends* `object`
Methods [#methods-1]
matches() [#matches-1]
```ts
matches<K>(column, value): EncryptedQueryBuilderUntyped<Row>;
```
Defined in: [types.ts:399](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-supabase/src/types.ts#L399)
Fuzzy free-text token match on an encrypted match/search column. The
operand is always the string term to tokenize (never an array/object), even
on the untyped surface where the column kind is unknown.
Type Parameters [#type-parameters-11]
K [#k-9]
`K` *extends* `string`
Parameters [#parameters-9]
column [#column-9]
`K`
value [#value-9]
`string`
Returns [#returns-9]
[`EncryptedQueryBuilderUntyped`](https://cipherstash.com/docs/integrations/supabase/api-reference#encryptedquerybuilderuntyped)\<`Row`>
contains() [#contains-1]
```ts
contains<K>(column, value): EncryptedQueryBuilderUntyped<Row>;
```
Defined in: [types.ts:405](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-supabase/src/types.ts#L405)
Native jsonb/array containment on plaintext columns. Encrypted JSON
containment fails fast on EQL 3.0.2+.
Type Parameters [#type-parameters-12]
K [#k-10]
`K` *extends* `string`
Parameters [#parameters-10]
column [#column-10]
`K`
value [#value-10]
`NativeContainsValue`
Returns [#returns-10]
[`EncryptedQueryBuilderUntyped`](https://cipherstash.com/docs/integrations/supabase/api-reference#encryptedquerybuilderuntyped)\<`Row`>
selectorEq() [#selectoreq-1]
```ts
selectorEq<K>(
column,
path,
value): EncryptedQueryBuilderUntyped<Row>;
```
Defined in: [types.ts:410](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-supabase/src/types.ts#L410)
Legacy encrypted JSONPath equality; fails fast on EQL 3.0.2+.
Type Parameters [#type-parameters-13]
K [#k-11]
`K` *extends* `string`
Parameters [#parameters-11]
column [#column-11]
`K`
path [#path-2]
`string`
value [#value-11]
`SelectorLeafValue`
Returns [#returns-11]
[`EncryptedQueryBuilderUntyped`](https://cipherstash.com/docs/integrations/supabase/api-reference#encryptedquerybuilderuntyped)\<`Row`>
selectorNe() [#selectorne-1]
```ts
selectorNe<K>(
column,
path,
value): EncryptedQueryBuilderUntyped<Row>;
```
Defined in: [types.ts:416](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-supabase/src/types.ts#L416)
Legacy encrypted JSONPath inequality; fails fast on EQL 3.0.2+.
Type Parameters [#type-parameters-14]
K [#k-12]
`K` *extends* `string`
Parameters [#parameters-12]
column [#column-12]
`K`
path [#path-3]
`string`
value [#value-12]
`SelectorLeafValue`
Returns [#returns-12]
[`EncryptedQueryBuilderUntyped`](https://cipherstash.com/docs/integrations/supabase/api-reference#encryptedquerybuilderuntyped)\<`Row`>
***
EncryptedSupabaseInstance [#encryptedsupabaseinstance]
Defined in: [types.ts:425](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-supabase/src/types.ts#L425)
Untyped instance (no `schemas`): rows default to `Record<string, unknown>`
and `from` accepts any table name.
Methods [#methods-2]
from() [#from]
```ts
from<Row>(tableName): EncryptedQueryBuilderUntyped<Row>;
```
Defined in: [types.ts:426](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-supabase/src/types.ts#L426)
Type Parameters [#type-parameters-15]
Row [#row-2]
`Row` *extends* `object` = `Record`\<`string`, `unknown`>
Parameters [#parameters-13]
tableName [#tablename]
`string`
Returns [#returns-13]
[`EncryptedQueryBuilderUntyped`](https://cipherstash.com/docs/integrations/supabase/api-reference#encryptedquerybuilderuntyped)\<`Row`>
***
TypedEncryptedSupabaseInstance [#typedencryptedsupabaseinstance]
Defined in: [types.ts:445](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-supabase/src/types.ts#L445)
Typed instance (with `schemas: S`): a declared table name resolves to the
narrowed v3 builder; any other table name falls back to the untyped surface.
The fallback overload is REQUIRED, not a convenience. The design spec
promises a gradient — "declare one table, leave the rest introspected;
undeclared tables behave exactly as they would with no `schemas` at all".
With only the `keyof S` overload, `schemas: { users }` makes `from('orders')`
a compile error even though `orders` was introspected and works perfectly at
runtime. Declaring one table would silently make every other table
unreachable.
Overload order matters: the literal-constrained signature is declared first,
so TypeScript prefers it whenever the argument is a declared key and only
falls through to `string` otherwise.
Type Parameters [#type-parameters-16]
S [#s]
`S` *extends* [`V3Schemas`](https://cipherstash.com/docs/integrations/supabase/api-reference#v3schemas)
Methods [#methods-3]
from() [#from-1]
Call Signature [#call-signature-6]
```ts
from<K>(table): EncryptedQueryBuilder<S[K], InferPlaintext<S[K]>>;
```
Defined in: [types.ts:446](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-supabase/src/types.ts#L446)
Type Parameters [#type-parameters-17]
K [#k-13]
`K` *extends* `string`
Parameters [#parameters-14]
table [#table-1]
`K`
Returns [#returns-14]
[`EncryptedQueryBuilder`](https://cipherstash.com/docs/integrations/supabase/api-reference#encryptedquerybuilder)\<`S`\[`K`], `InferPlaintext`\<`S`\[`K`]>>
Call Signature [#call-signature-7]
```ts
from<Row>(table): EncryptedQueryBuilderUntyped<Row>;
```
Defined in: [types.ts:449](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-supabase/src/types.ts#L449)
Type Parameters [#type-parameters-18]
Row [#row-3]
`Row` *extends* `object` = `Record`\<`string`, `unknown`>
Parameters [#parameters-15]
table [#table-2]
`string`
Returns [#returns-15]
[`EncryptedQueryBuilderUntyped`](https://cipherstash.com/docs/integrations/supabase/api-reference#encryptedquerybuilderuntyped)\<`Row`>
***
EncryptedSingleQueryBuilder [#encryptedsinglequerybuilder]
Defined in: [types.ts:482](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-supabase/src/types.ts#L482)
The builder returned by `single()`/`maybeSingle()`: awaits to a SINGLE row
(`data: T | null`) instead of an array.
FILTERS and TRANSFORMS are deliberately absent — applying one after `single()`
would change the query the single-row promise was made about.
What IS carried is exactly: `then` (via `PromiseLike`), `abortSignal`,
`throwOnError`, `returns`, `withLockContext` and `audit`. That is a
hand-written list, not a passthrough. It narrows the static API only:
`single()`/`maybeSingle()` return the same builder instance, so a method
omitted here is still a property of that object at runtime — the type is what
stops you reaching it, not the implementation.
It is therefore NOT parity with postgrest-js, which carries a different set:
its `single()` returns a `PostgrestBuilder`, carrying
`returns`/`overrideTypes`/`throwOnError`/`setHeader` (and NOT `abortSignal`,
which lives on `PostgrestTransformBuilder`). Relative to that, this adapter
keeps `abortSignal` as a deliberate superset — an abort is not a query change
— and adds the two encryption-specific configurators, which the runtime reads
at execute time and so remain valid after `single()`; but postgrest-js's
`overrideTypes` and `setHeader` have NO adapter equivalent, on this surface or
any other.
Extends [#extends-2]
* `PromiseLike`\<[`EncryptedSupabaseResponse`](https://cipherstash.com/docs/integrations/supabase/api-reference#encryptedsupabaseresponse)\<`T`>>
Type Parameters [#type-parameters-19]
T [#t]
`T`
Methods [#methods-4]
abortSignal() [#abortsignal]
```ts
abortSignal(signal): EncryptedSingleQueryBuilder<T>;
```
Defined in: [types.ts:484](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-supabase/src/types.ts#L484)
Parameters [#parameters-16]
signal [#signal]
`AbortSignal`
Returns [#returns-16]
[`EncryptedSingleQueryBuilder`](https://cipherstash.com/docs/integrations/supabase/api-reference#encryptedsinglequerybuilder)\<`T`>
throwOnError() [#throwonerror]
```ts
throwOnError(): EncryptedSingleQueryBuilder<T>;
```
Defined in: [types.ts:485](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-supabase/src/types.ts#L485)
Returns [#returns-17]
[`EncryptedSingleQueryBuilder`](https://cipherstash.com/docs/integrations/supabase/api-reference#encryptedsinglequerybuilder)\<`T`>
returns() [#returns-18]
```ts
returns<U>(): EncryptedSingleQueryBuilder<U>;
```
Defined in: [types.ts:490](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-supabase/src/types.ts#L490)
Re-type the ROW. The single-row awaited shape is preserved — `U`, not `U[]`.
`object`, not `Record<string, unknown>`: an `interface` row type has no
implicit index signature and would be rejected by the latter (upstream
postgrest-js constrains its `returns` type parameter not at all).
Type Parameters [#type-parameters-20]
U [#u]
`U` *extends* `object`
Returns [#returns-19]
[`EncryptedSingleQueryBuilder`](https://cipherstash.com/docs/integrations/supabase/api-reference#encryptedsinglequerybuilder)\<`U`>
withLockContext() [#withlockcontext]
```ts
withLockContext(lockContext): EncryptedSingleQueryBuilder<T>;
```
Defined in: [types.ts:492](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-supabase/src/types.ts#L492)
Bind identity-aware encryption. Read at execute time, so order-independent.
Parameters [#parameters-17]
lockContext [#lockcontext]
`LockContextInput`
Returns [#returns-20]
[`EncryptedSingleQueryBuilder`](https://cipherstash.com/docs/integrations/supabase/api-reference#encryptedsinglequerybuilder)\<`T`>
audit() [#audit]
```ts
audit(config): EncryptedSingleQueryBuilder<T>;
```
Defined in: [types.ts:494](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-supabase/src/types.ts#L494)
Attach audit metadata. Read at execute time, so order-independent.
Parameters [#parameters-18]
config [#config]
`AuditConfig`
Returns [#returns-21]
[`EncryptedSingleQueryBuilder`](https://cipherstash.com/docs/integrations/supabase/api-reference#encryptedsinglequerybuilder)\<`T`>
***
SupabaseClientLike [#supabaseclientlike]
Defined in: [types.ts:806](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-supabase/src/types.ts#L806)
Methods [#methods-5]
from() [#from-2]
```ts
from(table): any;
```
Defined in: [types.ts:807](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-supabase/src/types.ts#L807)
Parameters [#parameters-19]
table [#table-3]
`string`
Returns [#returns-22]
`any`
***
EncryptedQueryBuilderCore [#encryptedquerybuildercore]
Defined in: [types.ts:847](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-supabase/src/types.ts#L847)
Every builder method shared by the TYPED ([EncryptedQueryBuilder](https://cipherstash.com/docs/integrations/supabase/api-reference#encryptedquerybuilder)) and
UNTYPED ([EncryptedQueryBuilderUntyped](https://cipherstash.com/docs/integrations/supabase/api-reference#encryptedquerybuilderuntyped)) surfaces. Both are EQL v3 —
they differ only in how much they can narrow, not in dialect.
`Self` is the concrete builder each method returns, so a surface that omits a
method does not have it laundered back in by a chained call whose return type
widened to the base interface.
Free-text search lives on the sub-interfaces rather than here, because its
key set differs between the two: `matches()` narrows to the encrypted
match/search columns on the typed surface, and to every row key on the
untyped one. Neither surface carries `like`/`ilike` — EQL v3 free-text is
fuzzy bloom-token matching, not SQL pattern matching, so the builder rewrites
a `like` on an encrypted column to `matches` at record time (see
`query-builder.ts`). They survive in this file only as the internal
FilterOp union and on the raw SupabaseQueryBuilder seam, both
of which still serve plaintext columns.
Extends [#extends-3]
* `PromiseLike`\<[`EncryptedSupabaseResponse`](https://cipherstash.com/docs/integrations/supabase/api-reference#encryptedsupabaseresponse)\<`T`\[]>>
Extended by [#extended-by]
* [`EncryptedQueryBuilder`](https://cipherstash.com/docs/integrations/supabase/api-reference#encryptedquerybuilder)
* [`EncryptedQueryBuilderUntyped`](https://cipherstash.com/docs/integrations/supabase/api-reference#encryptedquerybuilderuntyped)
Type Parameters [#type-parameters-21]
T [#t-1]
`T` *extends* `object`
FK [#fk]
`FK` *extends* `StringKeyOf`\<`T`>
Self [#self]
`Self`
OK [#ok]
`OK` *extends* `StringKeyOf`\<`T`> = `FK`
BK [#bk]
`BK` *extends* `StringKeyOf`\<`T`> = `FK`
Methods [#methods-6]
select() [#select]
```ts
select(columns?, options?): Self;
```
Defined in: [types.ts:866](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-supabase/src/types.ts#L866)
`columns` defaults to `'*'`, matching supabase-js. A `'*'` select expands
to the introspected column list; when none is available (a client that
could not introspect) both `select()` and `select('*')` throw, because an
unexpanded `*` cannot cast the encrypted columns with `::jsonb`.
Parameters [#parameters-20]
columns? [#columns]
`string`
options? [#options]
head? [#head]
`boolean`
count? [#count]
`"exact"` | `"planned"` | `"estimated"`
Returns [#returns-23]
`Self`
insert() [#insert]
```ts
insert(data, options?): Self;
```
Defined in: [types.ts:870](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-supabase/src/types.ts#L870)
Parameters [#parameters-21]
data [#data]
`Partial`\<`T`> | `Partial`\<`T`>\[]
options? [#options-1]
count? [#count-1]
`"exact"` | `"planned"` | `"estimated"`
defaultToNull? [#defaulttonull]
`boolean`
onConflict? [#onconflict]
`string`
Returns [#returns-24]
`Self`
update() [#update]
```ts
update(data, options?): Self;
```
Defined in: [types.ts:878](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-supabase/src/types.ts#L878)
Parameters [#parameters-22]
data [#data-1]
`Partial`\<`T`>
options? [#options-2]
count? [#count-2]
`"exact"` | `"planned"` | `"estimated"`
Returns [#returns-25]
`Self`
upsert() [#upsert]
```ts
upsert(data, options?): Self;
```
Defined in: [types.ts:882](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-supabase/src/types.ts#L882)
Parameters [#parameters-23]
data [#data-2]
`Partial`\<`T`> | `Partial`\<`T`>\[]
options? [#options-3]
count? [#count-3]
`"exact"` | `"planned"` | `"estimated"`
onConflict? [#onconflict-1]
`string`
ignoreDuplicates? [#ignoreduplicates]
`boolean`
defaultToNull? [#defaulttonull-1]
`boolean`
Returns [#returns-26]
`Self`
delete() [#delete]
```ts
delete(options?): Self;
```
Defined in: [types.ts:891](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-supabase/src/types.ts#L891)
Parameters [#parameters-24]
options? [#options-4]
count? [#count-4]
`"exact"` | `"planned"` | `"estimated"`
Returns [#returns-27]
`Self`
eq() [#eq]
```ts
eq<K>(column, value): Self;
```
Defined in: [types.ts:892](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-supabase/src/types.ts#L892)
Type Parameters [#type-parameters-22]
K [#k-14]
`K` *extends* `string`
Parameters [#parameters-25]
column [#column-13]
`K`
value [#value-13]
`T`\[`K`]
Returns [#returns-28]
`Self`
neq() [#neq]
```ts
neq<K>(column, value): Self;
```
Defined in: [types.ts:893](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-supabase/src/types.ts#L893)
Type Parameters [#type-parameters-23]
K [#k-15]
`K` *extends* `string`
Parameters [#parameters-26]
column [#column-14]
`K`
value [#value-14]
`T`\[`K`]
Returns [#returns-29]
`Self`
gt() [#gt]
```ts
gt<K>(column, value): Self;
```
Defined in: [types.ts:894](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-supabase/src/types.ts#L894)
Type Parameters [#type-parameters-24]
K [#k-16]
`K` *extends* `string`
Parameters [#parameters-27]
column [#column-15]
`K`
value [#value-15]
`T`\[`K`]
Returns [#returns-30]
`Self`
gte() [#gte]
```ts
gte<K>(column, value): Self;
```
Defined in: [types.ts:895](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-supabase/src/types.ts#L895)
Type Parameters [#type-parameters-25]
K [#k-17]
`K` *extends* `string`
Parameters [#parameters-28]
column [#column-16]
`K`
value [#value-16]
`T`\[`K`]
Returns [#returns-31]
`Self`
lt() [#lt]
```ts
lt<K>(column, value): Self;
```
Defined in: [types.ts:896](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-supabase/src/types.ts#L896)
Type Parameters [#type-parameters-26]
K [#k-18]
`K` *extends* `string`
Parameters [#parameters-29]
column [#column-17]
`K`
value [#value-17]
`T`\[`K`]
Returns [#returns-32]
`Self`
lte() [#lte]
```ts
lte<K>(column, value): Self;
```
Defined in: [types.ts:897](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-supabase/src/types.ts#L897)
Type Parameters [#type-parameters-27]
K [#k-19]
`K` *extends* `string`
Parameters [#parameters-30]
column [#column-18]
`K`
value [#value-18]
`T`\[`K`]
Returns [#returns-33]
`Self`
is() [#is]
Call Signature [#call-signature-8]
```ts
is<K>(column, value): Self;
```
Defined in: [types.ts:917](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-supabase/src/types.ts#L917)
`IS NULL` / `IS TRUE` / `IS FALSE`.
The `null` form is widened to EVERY row key, not just the filterable ones.
`is` is the one predicate never encrypted — `isEncryptableTerm` rejects it
outright, so no term is collected and no capability guard runs — and a NULL
plaintext is stored as a SQL NULL rather than a ciphertext. On a v3
storage-only column (`types.Boolean`, `types.Integer`, …) `IS NULL` is
therefore not merely legal but the ONLY predicate available, so narrowing it
to `FK` would deny the sole query those columns support.
The boolean form narrows to `BK`: `IS TRUE` against a jsonb ciphertext
column compares an envelope to a plaintext boolean, which is a type error in
the database, not a filter. `FK` is the wrong gate for it — that set
excludes only the STORAGE-ONLY columns, so a queryable encrypted column
(`types.TextSearch`, `types.TextEq`, any `*_ord`) is in `FK` and would still
compile `is(col, true)`. Every encrypted column stores an envelope,
capability or not, so `BK` excludes them all.
Type Parameters [#type-parameters-28]
K [#k-20]
`K` *extends* `string`
Parameters [#parameters-31]
column [#column-19]
`K`
value [#value-19]
`boolean` | `null`
Returns [#returns-34]
`Self`
Call Signature [#call-signature-9]
```ts
is<K>(column, value): Self;
```
Defined in: [types.ts:918](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-supabase/src/types.ts#L918)
Type Parameters [#type-parameters-29]
K [#k-21]
`K` *extends* `string`
Parameters [#parameters-32]
column [#column-20]
`K`
value [#value-20]
`null`
Returns [#returns-35]
`Self`
in() [#in]
```ts
in<K>(column, values): Self;
```
Defined in: [types.ts:919](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-supabase/src/types.ts#L919)
Type Parameters [#type-parameters-30]
K [#k-22]
`K` *extends* `string`
Parameters [#parameters-33]
column [#column-21]
`K`
values [#values]
`T`\[`K`]\[]
Returns [#returns-36]
`Self`
filter() [#filter-1]
```ts
filter<K>(
column,
operator,
value): Self;
```
Defined in: [types.ts:920](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-supabase/src/types.ts#L920)
Type Parameters [#type-parameters-31]
K [#k-23]
`K` *extends* `string`
Parameters [#parameters-34]
column [#column-22]
`K`
operator [#operator-4]
`string`
value [#value-21]
`T`\[`K`]
Returns [#returns-37]
`Self`
not() [#not-1]
```ts
not<K>(
column,
operator,
value): Self;
```
Defined in: [types.ts:921](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-supabase/src/types.ts#L921)
Type Parameters [#type-parameters-32]
K [#k-24]
`K` *extends* `string`
Parameters [#parameters-35]
column [#column-23]
`K`
operator [#operator-5]
`string`
value [#value-22]
`T`\[`K`]
Returns [#returns-38]
`Self`
or() [#or]
Call Signature [#call-signature-10]
```ts
or(filters, options?): Self;
```
Defined in: [types.ts:922](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-supabase/src/types.ts#L922)
Parameters [#parameters-36]
filters [#filters]
`string`
options? [#options-5]
referencedTable? [#referencedtable]
`string`
foreignTable? [#foreigntable]
`string`
Returns [#returns-39]
`Self`
Call Signature [#call-signature-11]
```ts
or(conditions, options?): Self;
```
Defined in: [types.ts:926](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-supabase/src/types.ts#L926)
Parameters [#parameters-37]
conditions [#conditions]
[`PendingOrCondition`](https://cipherstash.com/docs/integrations/supabase/api-reference#pendingorcondition)\[]
options? [#options-6]
referencedTable? [#referencedtable-1]
`string`
foreignTable? [#foreigntable-1]
`string`
Returns [#returns-40]
`Self`
match() [#match]
```ts
match(query): Self;
```
Defined in: [types.ts:930](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-supabase/src/types.ts#L930)
Parameters [#parameters-38]
query [#query]
`Partial`\<`T`>
Returns [#returns-41]
`Self`
order() [#order]
```ts
order<K>(column, options?): Self;
```
Defined in: [types.ts:935](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-supabase/src/types.ts#L935)
Type Parameters [#type-parameters-33]
K [#k-25]
`K` *extends* `string`
Parameters [#parameters-39]
column [#column-24]
`K`
options? [#options-7]
ascending? [#ascending]
`boolean`
nullsFirst? [#nullsfirst]
`boolean`
referencedTable? [#referencedtable-2]
`string`
foreignTable? [#foreigntable-2]
`string`
Returns [#returns-42]
`Self`
limit() [#limit]
```ts
limit(count, options?): Self;
```
Defined in: [types.ts:944](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-supabase/src/types.ts#L944)
Parameters [#parameters-40]
count [#count-5]
`number`
options? [#options-8]
referencedTable? [#referencedtable-3]
`string`
foreignTable? [#foreigntable-3]
`string`
Returns [#returns-43]
`Self`
range() [#range]
```ts
range(
from,
to,
options?): Self;
```
Defined in: [types.ts:948](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-supabase/src/types.ts#L948)
Parameters [#parameters-41]
from [#from-3]
`number`
to [#to]
`number`
options? [#options-9]
referencedTable? [#referencedtable-4]
`string`
foreignTable? [#foreigntable-4]
`string`
Returns [#returns-44]
`Self`
single() [#single]
```ts
single(): EncryptedSingleQueryBuilder<T>;
```
Defined in: [types.ts:963](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-supabase/src/types.ts#L963)
Return ONE row rather than an array — so the awaited `data` is `T | null`,
not `T[]`. Returns [EncryptedSingleQueryBuilder](https://cipherstash.com/docs/integrations/supabase/api-reference#encryptedsinglequerybuilder) rather than `Self`
because that change of shape is the whole point of the call: typing it
`Self` would keep promising `T[]` while the runtime hands back one object,
forcing every caller through a cast (`data as unknown as Row`).
Filters and transforms are not chainable afterwards, matching supabase-js —
`single()` is applied last.
Returns [#returns-45]
[`EncryptedSingleQueryBuilder`](https://cipherstash.com/docs/integrations/supabase/api-reference#encryptedsinglequerybuilder)\<`T`>
maybeSingle() [#maybesingle]
```ts
maybeSingle(): EncryptedSingleQueryBuilder<T>;
```
Defined in: [types.ts:967](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-supabase/src/types.ts#L967)
As [single](https://cipherstash.com/docs/integrations/supabase/api-reference#single), but a zero-row result is `data: null` rather than an
error. Same `T | null` awaited shape — `single()` reports the missing row
through `error` instead.
Returns [#returns-46]
[`EncryptedSingleQueryBuilder`](https://cipherstash.com/docs/integrations/supabase/api-reference#encryptedsinglequerybuilder)\<`T`>
csv() [#csv]
```ts
csv(): Self;
```
Defined in: [types.ts:978](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-supabase/src/types.ts#L978)
Always THROWS. PostgREST serializes rows server-side, so a CSV response
carries ciphertext the adapter never gets to decrypt. Declared so the call
is a loud runtime failure rather than a missing method, and typed `Self`
only to keep the chain shape — it never returns. Select rows normally and
serialize the decrypted data yourself.
Returns [#returns-47]
`Self`
Deprecated [#deprecated]
Always throws on an encrypted query — select the rows normally,
then serialize the decrypted data to CSV yourself.
abortSignal() [#abortsignal-1]
```ts
abortSignal(signal): Self;
```
Defined in: [types.ts:979](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-supabase/src/types.ts#L979)
Parameters [#parameters-42]
signal [#signal-1]
`AbortSignal`
Returns [#returns-48]
`Self`
throwOnError() [#throwonerror-1]
```ts
throwOnError(): Self;
```
Defined in: [types.ts:980](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-supabase/src/types.ts#L980)
Returns [#returns-49]
`Self`
returns() [#returns-50]
```ts
returns<U>(): EncryptedQueryBuilderUntyped<U>;
```
Defined in: [types.ts:985](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-supabase/src/types.ts#L985)
Escape hatch: re-types the rows and drops back to the untyped v3 builder
surface. `object`, not `Record<string, unknown>`: an `interface` row type
has no implicit index signature and would be rejected by the latter, while
`object` still excludes `string`/`number` row types.
Type Parameters [#type-parameters-34]
U [#u-1]
`U` *extends* `object`
Returns [#returns-51]
[`EncryptedQueryBuilderUntyped`](https://cipherstash.com/docs/integrations/supabase/api-reference#encryptedquerybuilderuntyped)\<`U`>
withLockContext() [#withlockcontext-1]
```ts
withLockContext(lockContext): Self;
```
Defined in: [types.ts:988](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-supabase/src/types.ts#L988)
Bind identity-aware encryption. Accepts either a plain
`{ identityClaim }` (the common form) or a `LockContext` instance.
Parameters [#parameters-43]
lockContext [#lockcontext-1]
`LockContextInput`
Returns [#returns-52]
`Self`
audit() [#audit-1]
```ts
audit(config): Self;
```
Defined in: [types.ts:989](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-supabase/src/types.ts#L989)
Parameters [#parameters-44]
config [#config-1]
`AuditConfig`
Returns [#returns-53]
`Self`
Type Aliases [#type-aliases]
V3Schemas [#v3schemas]
```ts
type V3Schemas = Record<string, AnyV3Table>;
```
Defined in: [schema-builder.ts:7](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-supabase/src/schema-builder.ts#L7)
A record of declared v3 tables, keyed by table name.
***
EncryptedSupabaseOptions [#encryptedsupabaseoptions]
```ts
type EncryptedSupabaseOptions<S> = {
databaseUrl?: string;
config?: ClientConfig;
schemas?: S;
};
```
Defined in: [types.ts:26](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-supabase/src/types.ts#L26)
Options for import('./index').encryptedSupabase.
Type Parameters [#type-parameters-35]
S [#s-1]
`S` *extends*
\| [`V3Schemas`](https://cipherstash.com/docs/integrations/supabase/api-reference#v3schemas)
\| `undefined` = `undefined`
declared v3 tables. When present, `from()` is constrained to
the declared table names and returns typed builders, and the tables are
verified against the database at construction.
Properties [#properties]
databaseUrl? [#databaseurl]
```ts
optional databaseUrl: string;
```
Defined in: [types.ts:31](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-supabase/src/types.ts#L31)
Postgres connection string for introspection. Defaults to
`process.env.DATABASE_URL`.
config? [#config-2]
```ts
optional config: ClientConfig;
```
Defined in: [types.ts:33](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-supabase/src/types.ts#L33)
Passed through to the v3-only encryption client.
schemas? [#schemas]
```ts
optional schemas: S;
```
Defined in: [types.ts:45](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-supabase/src/types.ts#L45)
Optional declared v3 tables, keyed by table name (each record key MUST
equal its table's `tableName`). Declaring a table adds compile-time types
and startup verification; undeclared tables behave exactly as with no
`schemas`.
Declaring a `text_search` column does NOT change its match behaviour: a
declared and a synthesized `text_search` column build byte-identically, and
neither `types.TextSearch` nor `EncryptedTextSearchColumn` accepts match
options. See the `contains` note on `EncryptedQueryBuilderImpl`.
***
FilterableKeys [#filterablekeys]
```ts
type FilterableKeys<Table, Row> = Exclude<Extract<keyof Row, string>, NonScalarQueryableV3Keys<Table>>;
```
Defined in: [types.ts:106](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-supabase/src/types.ts#L106)
Row keys a v3 builder accepts in SCALAR filter methods: every row key except
the table's encrypted columns with no scalar capability (storage-only
columns, and `types.Json` documents — see NonScalarQueryableV3Keys;
before #650's `searchableJson` arm the two sets coincided). Plaintext
(non-schema) columns pass through untouched.
Type Parameters [#type-parameters-36]
Table [#table-4]
`Table` *extends* `AnyV3Table`
Row [#row-4]
`Row` *extends* `Record`\<`string`, `unknown`>
***
FreeTextSearchableKeys [#freetextsearchablekeys]
```ts
type FreeTextSearchableKeys<Table, Row> = Exclude<Extract<keyof Row, string>, NonFreeTextSearchV3Keys<Table>>;
```
Defined in: [types.ts:132](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-supabase/src/types.ts#L132)
Row keys a v3 builder accepts in `contains()`: every row key except the
table's encrypted columns that lack a match index. Plaintext columns pass
through, where `contains` is PostgREST's native jsonb/array containment.
Type Parameters [#type-parameters-37]
Table [#table-5]
`Table` *extends* `AnyV3Table`
Row [#row-5]
`Row` *extends* `Record`\<`string`, `unknown`>
***
EncryptedSupabaseResponse [#encryptedsupabaseresponse]
```ts
type EncryptedSupabaseResponse<T> = {
data: T | null;
error: | EncryptedSupabaseError
| null;
count: number | null;
status: number;
statusText: string;
};
```
Defined in: [types.ts:497](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-supabase/src/types.ts#L497)
Type Parameters [#type-parameters-38]
T [#t-2]
`T`
Properties [#properties-1]
data [#data-3]
```ts
data: T | null;
```
Defined in: [types.ts:498](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-supabase/src/types.ts#L498)
error [#error]
```ts
error:
| EncryptedSupabaseError
| null;
```
Defined in: [types.ts:499](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-supabase/src/types.ts#L499)
count [#count-6]
```ts
count: number | null;
```
Defined in: [types.ts:500](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-supabase/src/types.ts#L500)
status [#status]
```ts
status: number;
```
Defined in: [types.ts:501](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-supabase/src/types.ts#L501)
statusText [#statustext]
```ts
statusText: string;
```
Defined in: [types.ts:502](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-supabase/src/types.ts#L502)
***
EncryptedSupabaseError [#encryptedsupabaseerror]
```ts
type EncryptedSupabaseError = {
message: string;
details?: string;
hint?: string;
code?: string;
encryptionError?: EncryptionError;
};
```
Defined in: [types.ts:505](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-supabase/src/types.ts#L505)
Properties [#properties-2]
message [#message]
```ts
message: string;
```
Defined in: [types.ts:506](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-supabase/src/types.ts#L506)
details? [#details]
```ts
optional details: string;
```
Defined in: [types.ts:507](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-supabase/src/types.ts#L507)
hint? [#hint]
```ts
optional hint: string;
```
Defined in: [types.ts:508](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-supabase/src/types.ts#L508)
code? [#code]
```ts
optional code: string;
```
Defined in: [types.ts:509](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-supabase/src/types.ts#L509)
encryptionError? [#encryptionerror]
```ts
optional encryptionError: EncryptionError;
```
Defined in: [types.ts:510](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-supabase/src/types.ts#L510)
***
PendingOrCondition [#pendingorcondition]
```ts
type PendingOrCondition = {
column: string;
op: FilterOp;
negate?: boolean;
value: unknown;
sourceSpan?: {
start: number;
end: number;
};
};
```
Defined in: [types.ts:549](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-supabase/src/types.ts#L549)
Properties [#properties-3]
column [#column-25]
```ts
column: string;
```
Defined in: [types.ts:550](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-supabase/src/types.ts#L550)
op [#op]
```ts
op: FilterOp;
```
Defined in: [types.ts:551](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-supabase/src/types.ts#L551)
negate? [#negate]
```ts
optional negate: boolean;
```
Defined in: [types.ts:554](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-supabase/src/types.ts#L554)
PostgREST's `column.not.<op>.<value>` negation. Kept off `op` so the
`in`-list split and the query-type mapping both key on the real operator.
value [#value-23]
```ts
value: unknown;
```
Defined in: [types.ts:555](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-supabase/src/types.ts#L555)
sourceSpan? [#sourcespan]
```ts
optional sourceSpan: {
start: number;
end: number;
};
```
Defined in: [types.ts:559](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-supabase/src/types.ts#L559)
Character range in the caller's original string-form `.or()` expression.
Internal only: lets the encrypted adapter replace this leaf without
rebuilding (and corrupting) surrounding `and(...)` / `or(...)` groups.
start [#start]
```ts
start: number;
```
end [#end]
```ts
end: number;
```
***
EncryptedSupabaseV3Options [#encryptedsupabasev3options]
```ts
type EncryptedSupabaseV3Options<S> = EncryptedSupabaseOptions<S>;
```
Defined in: [types.ts:999](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-supabase/src/types.ts#L999)
Type Parameters [#type-parameters-39]
S [#s-2]
`S` *extends*
\| [`V3Schemas`](https://cipherstash.com/docs/integrations/supabase/api-reference#v3schemas)
\| `undefined` = `undefined`
Deprecated [#deprecated-1]
Use [EncryptedSupabaseOptions](https://cipherstash.com/docs/integrations/supabase/api-reference#encryptedsupabaseoptions).
***
V3FilterableKeys [#v3filterablekeys]
```ts
type V3FilterableKeys<Table, Row> = FilterableKeys<Table, Row>;
```
Defined in: [types.ts:1008](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-supabase/src/types.ts#L1008)
Type Parameters [#type-parameters-40]
Table [#table-6]
`Table` *extends* `AnyV3Table`
Row [#row-6]
`Row` *extends* `Record`\<`string`, `unknown`>
Deprecated [#deprecated-2]
Use [FilterableKeys](https://cipherstash.com/docs/integrations/supabase/api-reference#filterablekeys).
***
V3FreeTextSearchableKeys [#v3freetextsearchablekeys]
```ts
type V3FreeTextSearchableKeys<Table, Row> = FreeTextSearchableKeys<Table, Row>;
```
Defined in: [types.ts:1014](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-supabase/src/types.ts#L1014)
Type Parameters [#type-parameters-41]
Table [#table-7]
`Table` *extends* `AnyV3Table`
Row [#row-7]
`Row` *extends* `Record`\<`string`, `unknown`>
Deprecated [#deprecated-3]
Use [FreeTextSearchableKeys](https://cipherstash.com/docs/integrations/supabase/api-reference#freetextsearchablekeys).
***
EncryptedQueryBuilderV3 [#encryptedquerybuilderv3]
```ts
type EncryptedQueryBuilderV3<Table, Row> = EncryptedQueryBuilder<Table, Row>;
```
Defined in: [types.ts:1048](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-supabase/src/types.ts#L1048)
Type Parameters [#type-parameters-42]
Table [#table-8]
`Table` *extends* `AnyV3Table`
Row [#row-8]
`Row` *extends* `Record`\<`string`, `unknown`>
Deprecated [#deprecated-4]
Use [EncryptedQueryBuilder](https://cipherstash.com/docs/integrations/supabase/api-reference#encryptedquerybuilder).
***
EncryptedQueryBuilderV3Untyped [#encryptedquerybuilderv3untyped]
```ts
type EncryptedQueryBuilderV3Untyped<Row> = EncryptedQueryBuilderUntyped<Row>;
```
Defined in: [types.ts:1054](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-supabase/src/types.ts#L1054)
Type Parameters [#type-parameters-43]
Row [#row-9]
`Row` *extends* `Record`\<`string`, `unknown`>
Deprecated [#deprecated-5]
Use [EncryptedQueryBuilderUntyped](https://cipherstash.com/docs/integrations/supabase/api-reference#encryptedquerybuilderuntyped).
***
EncryptedSupabaseV3Instance [#encryptedsupabasev3instance]
```ts
type EncryptedSupabaseV3Instance = EncryptedSupabaseInstance;
```
Defined in: [types.ts:1059](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-supabase/src/types.ts#L1059)
Deprecated [#deprecated-6]
Use [EncryptedSupabaseInstance](https://cipherstash.com/docs/integrations/supabase/api-reference#encryptedsupabaseinstance).
***
TypedEncryptedSupabaseV3Instance [#typedencryptedsupabasev3instance]
```ts
type TypedEncryptedSupabaseV3Instance<S> = TypedEncryptedSupabaseInstance<S>;
```
Defined in: [types.ts:1062](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-supabase/src/types.ts#L1062)
Type Parameters [#type-parameters-44]
S [#s-3]
`S` *extends* [`V3Schemas`](https://cipherstash.com/docs/integrations/supabase/api-reference#v3schemas)
Deprecated [#deprecated-7]
Use [TypedEncryptedSupabaseInstance](https://cipherstash.com/docs/integrations/supabase/api-reference#typedencryptedsupabaseinstance).
Variables [#variables]
encryptedSupabaseV3() [#encryptedsupabasev3]
```ts
const encryptedSupabaseV3: {
<S> (supabaseUrl, supabaseKey, options): Promise<TypedEncryptedSupabaseInstance<S>>;
(supabaseUrl, supabaseKey, options?): Promise<EncryptedSupabaseInstance>;
<S> (supabaseClient, options): Promise<TypedEncryptedSupabaseInstance<S>>;
(supabaseClient, options?): Promise<EncryptedSupabaseInstance>;
} = encryptedSupabase;
```
Defined in: [index.ts:275](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-supabase/src/index.ts#L275)
Call Signature [#call-signature-12]
```ts
<S>(
supabaseUrl,
supabaseKey,
options): Promise<TypedEncryptedSupabaseInstance<S>>;
```
Create an encrypted Supabase wrapper over **native EQL v3 column domains** by
introspecting the database at connect time. Detects EQL v3 columns by their
Postgres domain and derives each column's encryption config from it — callers
do not pass a schema to `from()`. Supplying `schemas` is optional: it adds
compile-time types and verifies the declared tables against the database at
construction.
Encrypted data is stored as EQL v3 payloads. This wrapper is EQL v3 only — it
both authors and reads v3, and the legacy v2 authoring surface (a hand-written
client-side schema and `from(tableName, schema)`) has been removed. It does
not auto-read an `eql_v2_encrypted` column: introspection recognises the
`public.eql_v3_*` domains exclusively, so a v2 column never enters the
encrypt config and is returned as an untouched passthrough. No v2 ciphertext
is stranded — decryption in `@cipherstash/stack` is generation-agnostic, so
legacy payloads still decrypt through the core client (`decrypt` /
`decryptModel`). Handle mixed-generation data explicitly on the caller side.
Requires a Postgres connection (`options.databaseUrl` or `DATABASE_URL`) for
introspection, so it cannot run in a Worker or the browser.
A column is an EQL v3 column when its type is one of the `public` domains the
EQL v3 bundle installs. The domain names the capabilities, and introspection
turns it into the column's encryption config:
```sql
CREATE TABLE users (
id bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
email public.eql_v3_text_search, -- equality, ordering, free-text match
age public.eql_v3_integer_ord, -- equality, ordering
name text -- plaintext passthrough, untouched
);
```
Type Parameters [#type-parameters-45]
S [#s-4]
`S` *extends* [`V3Schemas`](https://cipherstash.com/docs/integrations/supabase/api-reference#v3schemas)
Parameters [#parameters-45]
supabaseUrl [#supabaseurl]
`string`
supabaseKey [#supabasekey]
`string`
options [#options-10]
[`EncryptedSupabaseOptions`](https://cipherstash.com/docs/integrations/supabase/api-reference#encryptedsupabaseoptions)\<`S`> & \{
`schemas`: `S`;
}
Returns [#returns-54]
`Promise`\<[`TypedEncryptedSupabaseInstance`](https://cipherstash.com/docs/integrations/supabase/api-reference#typedencryptedsupabaseinstance)\<`S`>>
Example [#example]
```typescript
const supabase = await encryptedSupabase(supabaseUrl, supabaseKey)
await supabase.from('users').insert({ email: 'alice@example.com' })
const { data } = await supabase.from('users').select().eq('email', 'alice@example.com')
```
Call Signature [#call-signature-13]
```ts
(
supabaseUrl,
supabaseKey,
options?): Promise<EncryptedSupabaseInstance>;
```
Create an encrypted Supabase wrapper over **native EQL v3 column domains** by
introspecting the database at connect time. Detects EQL v3 columns by their
Postgres domain and derives each column's encryption config from it — callers
do not pass a schema to `from()`. Supplying `schemas` is optional: it adds
compile-time types and verifies the declared tables against the database at
construction.
Encrypted data is stored as EQL v3 payloads. This wrapper is EQL v3 only — it
both authors and reads v3, and the legacy v2 authoring surface (a hand-written
client-side schema and `from(tableName, schema)`) has been removed. It does
not auto-read an `eql_v2_encrypted` column: introspection recognises the
`public.eql_v3_*` domains exclusively, so a v2 column never enters the
encrypt config and is returned as an untouched passthrough. No v2 ciphertext
is stranded — decryption in `@cipherstash/stack` is generation-agnostic, so
legacy payloads still decrypt through the core client (`decrypt` /
`decryptModel`). Handle mixed-generation data explicitly on the caller side.
Requires a Postgres connection (`options.databaseUrl` or `DATABASE_URL`) for
introspection, so it cannot run in a Worker or the browser.
A column is an EQL v3 column when its type is one of the `public` domains the
EQL v3 bundle installs. The domain names the capabilities, and introspection
turns it into the column's encryption config:
```sql
CREATE TABLE users (
id bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
email public.eql_v3_text_search, -- equality, ordering, free-text match
age public.eql_v3_integer_ord, -- equality, ordering
name text -- plaintext passthrough, untouched
);
```
Parameters [#parameters-46]
supabaseUrl [#supabaseurl-1]
`string`
supabaseKey [#supabasekey-1]
`string`
options? [#options-11]
[`EncryptedSupabaseOptions`](https://cipherstash.com/docs/integrations/supabase/api-reference#encryptedsupabaseoptions)
Returns [#returns-55]
`Promise`\<[`EncryptedSupabaseInstance`](https://cipherstash.com/docs/integrations/supabase/api-reference#encryptedsupabaseinstance)>
Example [#example-1]
```typescript
const supabase = await encryptedSupabase(supabaseUrl, supabaseKey)
await supabase.from('users').insert({ email: 'alice@example.com' })
const { data } = await supabase.from('users').select().eq('email', 'alice@example.com')
```
Call Signature [#call-signature-14]
```ts
<S>(supabaseClient, options): Promise<TypedEncryptedSupabaseInstance<S>>;
```
Create an encrypted Supabase wrapper over **native EQL v3 column domains** by
introspecting the database at connect time. Detects EQL v3 columns by their
Postgres domain and derives each column's encryption config from it — callers
do not pass a schema to `from()`. Supplying `schemas` is optional: it adds
compile-time types and verifies the declared tables against the database at
construction.
Encrypted data is stored as EQL v3 payloads. This wrapper is EQL v3 only — it
both authors and reads v3, and the legacy v2 authoring surface (a hand-written
client-side schema and `from(tableName, schema)`) has been removed. It does
not auto-read an `eql_v2_encrypted` column: introspection recognises the
`public.eql_v3_*` domains exclusively, so a v2 column never enters the
encrypt config and is returned as an untouched passthrough. No v2 ciphertext
is stranded — decryption in `@cipherstash/stack` is generation-agnostic, so
legacy payloads still decrypt through the core client (`decrypt` /
`decryptModel`). Handle mixed-generation data explicitly on the caller side.
Requires a Postgres connection (`options.databaseUrl` or `DATABASE_URL`) for
introspection, so it cannot run in a Worker or the browser.
A column is an EQL v3 column when its type is one of the `public` domains the
EQL v3 bundle installs. The domain names the capabilities, and introspection
turns it into the column's encryption config:
```sql
CREATE TABLE users (
id bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
email public.eql_v3_text_search, -- equality, ordering, free-text match
age public.eql_v3_integer_ord, -- equality, ordering
name text -- plaintext passthrough, untouched
);
```
Type Parameters [#type-parameters-46]
S [#s-5]
`S` *extends* [`V3Schemas`](https://cipherstash.com/docs/integrations/supabase/api-reference#v3schemas)
Parameters [#parameters-47]
supabaseClient [#supabaseclient]
[`SupabaseClientLike`](https://cipherstash.com/docs/integrations/supabase/api-reference#supabaseclientlike)
options [#options-12]
[`EncryptedSupabaseOptions`](https://cipherstash.com/docs/integrations/supabase/api-reference#encryptedsupabaseoptions)\<`S`> & \{
`schemas`: `S`;
}
Returns [#returns-56]
`Promise`\<[`TypedEncryptedSupabaseInstance`](https://cipherstash.com/docs/integrations/supabase/api-reference#typedencryptedsupabaseinstance)\<`S`>>
Example [#example-2]
```typescript
const supabase = await encryptedSupabase(supabaseUrl, supabaseKey)
await supabase.from('users').insert({ email: 'alice@example.com' })
const { data } = await supabase.from('users').select().eq('email', 'alice@example.com')
```
Call Signature [#call-signature-15]
```ts
(supabaseClient, options?): Promise<EncryptedSupabaseInstance>;
```
Create an encrypted Supabase wrapper over **native EQL v3 column domains** by
introspecting the database at connect time. Detects EQL v3 columns by their
Postgres domain and derives each column's encryption config from it — callers
do not pass a schema to `from()`. Supplying `schemas` is optional: it adds
compile-time types and verifies the declared tables against the database at
construction.
Encrypted data is stored as EQL v3 payloads. This wrapper is EQL v3 only — it
both authors and reads v3, and the legacy v2 authoring surface (a hand-written
client-side schema and `from(tableName, schema)`) has been removed. It does
not auto-read an `eql_v2_encrypted` column: introspection recognises the
`public.eql_v3_*` domains exclusively, so a v2 column never enters the
encrypt config and is returned as an untouched passthrough. No v2 ciphertext
is stranded — decryption in `@cipherstash/stack` is generation-agnostic, so
legacy payloads still decrypt through the core client (`decrypt` /
`decryptModel`). Handle mixed-generation data explicitly on the caller side.
Requires a Postgres connection (`options.databaseUrl` or `DATABASE_URL`) for
introspection, so it cannot run in a Worker or the browser.
A column is an EQL v3 column when its type is one of the `public` domains the
EQL v3 bundle installs. The domain names the capabilities, and introspection
turns it into the column's encryption config:
```sql
CREATE TABLE users (
id bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
email public.eql_v3_text_search, -- equality, ordering, free-text match
age public.eql_v3_integer_ord, -- equality, ordering
name text -- plaintext passthrough, untouched
);
```
Parameters [#parameters-48]
supabaseClient [#supabaseclient-1]
[`SupabaseClientLike`](https://cipherstash.com/docs/integrations/supabase/api-reference#supabaseclientlike)
options? [#options-13]
[`EncryptedSupabaseOptions`](https://cipherstash.com/docs/integrations/supabase/api-reference#encryptedsupabaseoptions)
Returns [#returns-57]
`Promise`\<[`EncryptedSupabaseInstance`](https://cipherstash.com/docs/integrations/supabase/api-reference#encryptedsupabaseinstance)>
Example [#example-3]
```typescript
const supabase = await encryptedSupabase(supabaseUrl, supabaseKey)
await supabase.from('users').insert({ email: 'alice@example.com' })
const { data } = await supabase.from('users').select().eq('email', 'alice@example.com')
```
Deprecated [#deprecated-8]
Use [encryptedSupabase](https://cipherstash.com/docs/integrations/supabase/api-reference#encryptedsupabase). `encryptedSupabaseV3` is a
type-identical alias kept for existing imports; the `V3` suffix is redundant
now that EQL v3 is the only generation this wrapper authors.
Functions [#functions]
encryptedSupabase() [#encryptedsupabase]
Call Signature [#call-signature-16]
```ts
function encryptedSupabase<S>(
supabaseUrl,
supabaseKey,
options): Promise<TypedEncryptedSupabaseInstance<S>>;
```
Defined in: [index.ts:85](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-supabase/src/index.ts#L85)
Create an encrypted Supabase wrapper over **native EQL v3 column domains** by
introspecting the database at connect time. Detects EQL v3 columns by their
Postgres domain and derives each column's encryption config from it — callers
do not pass a schema to `from()`. Supplying `schemas` is optional: it adds
compile-time types and verifies the declared tables against the database at
construction.
Encrypted data is stored as EQL v3 payloads. This wrapper is EQL v3 only — it
both authors and reads v3, and the legacy v2 authoring surface (a hand-written
client-side schema and `from(tableName, schema)`) has been removed. It does
not auto-read an `eql_v2_encrypted` column: introspection recognises the
`public.eql_v3_*` domains exclusively, so a v2 column never enters the
encrypt config and is returned as an untouched passthrough. No v2 ciphertext
is stranded — decryption in `@cipherstash/stack` is generation-agnostic, so
legacy payloads still decrypt through the core client (`decrypt` /
`decryptModel`). Handle mixed-generation data explicitly on the caller side.
Requires a Postgres connection (`options.databaseUrl` or `DATABASE_URL`) for
introspection, so it cannot run in a Worker or the browser.
A column is an EQL v3 column when its type is one of the `public` domains the
EQL v3 bundle installs. The domain names the capabilities, and introspection
turns it into the column's encryption config:
```sql
CREATE TABLE users (
id bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
email public.eql_v3_text_search, -- equality, ordering, free-text match
age public.eql_v3_integer_ord, -- equality, ordering
name text -- plaintext passthrough, untouched
);
```
Type Parameters [#type-parameters-47]
S [#s-6]
`S` *extends* [`V3Schemas`](https://cipherstash.com/docs/integrations/supabase/api-reference#v3schemas)
Parameters [#parameters-49]
supabaseUrl [#supabaseurl-2]
`string`
supabaseKey [#supabasekey-2]
`string`
options [#options-14]
[`EncryptedSupabaseOptions`](https://cipherstash.com/docs/integrations/supabase/api-reference#encryptedsupabaseoptions)\<`S`> & \{
`schemas`: `S`;
}
Returns [#returns-58]
`Promise`\<[`TypedEncryptedSupabaseInstance`](https://cipherstash.com/docs/integrations/supabase/api-reference#typedencryptedsupabaseinstance)\<`S`>>
Example [#example-4]
```typescript
const supabase = await encryptedSupabase(supabaseUrl, supabaseKey)
await supabase.from('users').insert({ email: 'alice@example.com' })
const { data } = await supabase.from('users').select().eq('email', 'alice@example.com')
```
Call Signature [#call-signature-17]
```ts
function encryptedSupabase(
supabaseUrl,
supabaseKey,
options?): Promise<EncryptedSupabaseInstance>;
```
Defined in: [index.ts:90](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-supabase/src/index.ts#L90)
Create an encrypted Supabase wrapper over **native EQL v3 column domains** by
introspecting the database at connect time. Detects EQL v3 columns by their
Postgres domain and derives each column's encryption config from it — callers
do not pass a schema to `from()`. Supplying `schemas` is optional: it adds
compile-time types and verifies the declared tables against the database at
construction.
Encrypted data is stored as EQL v3 payloads. This wrapper is EQL v3 only — it
both authors and reads v3, and the legacy v2 authoring surface (a hand-written
client-side schema and `from(tableName, schema)`) has been removed. It does
not auto-read an `eql_v2_encrypted` column: introspection recognises the
`public.eql_v3_*` domains exclusively, so a v2 column never enters the
encrypt config and is returned as an untouched passthrough. No v2 ciphertext
is stranded — decryption in `@cipherstash/stack` is generation-agnostic, so
legacy payloads still decrypt through the core client (`decrypt` /
`decryptModel`). Handle mixed-generation data explicitly on the caller side.
Requires a Postgres connection (`options.databaseUrl` or `DATABASE_URL`) for
introspection, so it cannot run in a Worker or the browser.
A column is an EQL v3 column when its type is one of the `public` domains the
EQL v3 bundle installs. The domain names the capabilities, and introspection
turns it into the column's encryption config:
```sql
CREATE TABLE users (
id bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
email public.eql_v3_text_search, -- equality, ordering, free-text match
age public.eql_v3_integer_ord, -- equality, ordering
name text -- plaintext passthrough, untouched
);
```
Parameters [#parameters-50]
supabaseUrl [#supabaseurl-3]
`string`
supabaseKey [#supabasekey-3]
`string`
options? [#options-15]
[`EncryptedSupabaseOptions`](https://cipherstash.com/docs/integrations/supabase/api-reference#encryptedsupabaseoptions)
Returns [#returns-59]
`Promise`\<[`EncryptedSupabaseInstance`](https://cipherstash.com/docs/integrations/supabase/api-reference#encryptedsupabaseinstance)>
Example [#example-5]
```typescript
const supabase = await encryptedSupabase(supabaseUrl, supabaseKey)
await supabase.from('users').insert({ email: 'alice@example.com' })
const { data } = await supabase.from('users').select().eq('email', 'alice@example.com')
```
Call Signature [#call-signature-18]
```ts
function encryptedSupabase<S>(supabaseClient, options): Promise<TypedEncryptedSupabaseInstance<S>>;
```
Defined in: [index.ts:95](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-supabase/src/index.ts#L95)
Create an encrypted Supabase wrapper over **native EQL v3 column domains** by
introspecting the database at connect time. Detects EQL v3 columns by their
Postgres domain and derives each column's encryption config from it — callers
do not pass a schema to `from()`. Supplying `schemas` is optional: it adds
compile-time types and verifies the declared tables against the database at
construction.
Encrypted data is stored as EQL v3 payloads. This wrapper is EQL v3 only — it
both authors and reads v3, and the legacy v2 authoring surface (a hand-written
client-side schema and `from(tableName, schema)`) has been removed. It does
not auto-read an `eql_v2_encrypted` column: introspection recognises the
`public.eql_v3_*` domains exclusively, so a v2 column never enters the
encrypt config and is returned as an untouched passthrough. No v2 ciphertext
is stranded — decryption in `@cipherstash/stack` is generation-agnostic, so
legacy payloads still decrypt through the core client (`decrypt` /
`decryptModel`). Handle mixed-generation data explicitly on the caller side.
Requires a Postgres connection (`options.databaseUrl` or `DATABASE_URL`) for
introspection, so it cannot run in a Worker or the browser.
A column is an EQL v3 column when its type is one of the `public` domains the
EQL v3 bundle installs. The domain names the capabilities, and introspection
turns it into the column's encryption config:
```sql
CREATE TABLE users (
id bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
email public.eql_v3_text_search, -- equality, ordering, free-text match
age public.eql_v3_integer_ord, -- equality, ordering
name text -- plaintext passthrough, untouched
);
```
Type Parameters [#type-parameters-48]
S [#s-7]
`S` *extends* [`V3Schemas`](https://cipherstash.com/docs/integrations/supabase/api-reference#v3schemas)
Parameters [#parameters-51]
supabaseClient [#supabaseclient-2]
[`SupabaseClientLike`](https://cipherstash.com/docs/integrations/supabase/api-reference#supabaseclientlike)
options [#options-16]
[`EncryptedSupabaseOptions`](https://cipherstash.com/docs/integrations/supabase/api-reference#encryptedsupabaseoptions)\<`S`> & \{
`schemas`: `S`;
}
Returns [#returns-60]
`Promise`\<[`TypedEncryptedSupabaseInstance`](https://cipherstash.com/docs/integrations/supabase/api-reference#typedencryptedsupabaseinstance)\<`S`>>
Example [#example-6]
```typescript
const supabase = await encryptedSupabase(supabaseUrl, supabaseKey)
await supabase.from('users').insert({ email: 'alice@example.com' })
const { data } = await supabase.from('users').select().eq('email', 'alice@example.com')
```
Call Signature [#call-signature-19]
```ts
function encryptedSupabase(supabaseClient, options?): Promise<EncryptedSupabaseInstance>;
```
Defined in: [index.ts:99](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack-supabase/src/index.ts#L99)
Create an encrypted Supabase wrapper over **native EQL v3 column domains** by
introspecting the database at connect time. Detects EQL v3 columns by their
Postgres domain and derives each column's encryption config from it — callers
do not pass a schema to `from()`. Supplying `schemas` is optional: it adds
compile-time types and verifies the declared tables against the database at
construction.
Encrypted data is stored as EQL v3 payloads. This wrapper is EQL v3 only — it
both authors and reads v3, and the legacy v2 authoring surface (a hand-written
client-side schema and `from(tableName, schema)`) has been removed. It does
not auto-read an `eql_v2_encrypted` column: introspection recognises the
`public.eql_v3_*` domains exclusively, so a v2 column never enters the
encrypt config and is returned as an untouched passthrough. No v2 ciphertext
is stranded — decryption in `@cipherstash/stack` is generation-agnostic, so
legacy payloads still decrypt through the core client (`decrypt` /
`decryptModel`). Handle mixed-generation data explicitly on the caller side.
Requires a Postgres connection (`options.databaseUrl` or `DATABASE_URL`) for
introspection, so it cannot run in a Worker or the browser.
A column is an EQL v3 column when its type is one of the `public` domains the
EQL v3 bundle installs. The domain names the capabilities, and introspection
turns it into the column's encryption config:
```sql
CREATE TABLE users (
id bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
email public.eql_v3_text_search, -- equality, ordering, free-text match
age public.eql_v3_integer_ord, -- equality, ordering
name text -- plaintext passthrough, untouched
);
```
Parameters [#parameters-52]
supabaseClient [#supabaseclient-3]
[`SupabaseClientLike`](https://cipherstash.com/docs/integrations/supabase/api-reference#supabaseclientlike)
options? [#options-17]
[`EncryptedSupabaseOptions`](https://cipherstash.com/docs/integrations/supabase/api-reference#encryptedsupabaseoptions)
Returns [#returns-61]
`Promise`\<[`EncryptedSupabaseInstance`](https://cipherstash.com/docs/integrations/supabase/api-reference#encryptedsupabaseinstance)>
Example [#example-7]
```typescript
const supabase = await encryptedSupabase(supabaseUrl, supabaseKey)
await supabase.from('users').insert({ email: 'alice@example.com' })
const { data } = await supabase.from('users').select().eq('email', 'alice@example.com')
```
# Package exports
Source: https://cipherstash.com/docs/reference/stack/api-reference/Package-exports
[**@cipherstash/stack**](./)
***
Exports available from the `@cipherstash/stack` package root.
Interfaces [#interfaces]
TokenResult [#tokenresult]
Defined in: ../../../node\_modules/.bun/@cipherstash+auth\@0.42.0/node\_modules/@cipherstash/auth/native.d.ts:11
The result of a successful `getToken()` call.
Contains the bearer credential and decoded JWT claims for service discovery.
Properties [#properties]
token [#token]
```ts
token: string;
```
Defined in: ../../../node\_modules/.bun/@cipherstash+auth\@0.42.0/node\_modules/@cipherstash/auth/native.d.ts:13
The bearer token string (used as `Authorization: Bearer <token>`).
subject [#subject]
```ts
subject: string;
```
Defined in: ../../../node\_modules/.bun/@cipherstash+auth\@0.42.0/node\_modules/@cipherstash/auth/native.d.ts:15
The subject claim from the JWT (e.g. `"CS|auth0|user123"` or `"CS|CSAKkeyId"`).
workspaceId [#workspaceid]
```ts
workspaceId: string;
```
Defined in: ../../../node\_modules/.bun/@cipherstash+auth\@0.42.0/node\_modules/@cipherstash/auth/native.d.ts:17
The workspace identifier from the JWT.
issuer [#issuer]
```ts
issuer: string;
```
Defined in: ../../../node\_modules/.bun/@cipherstash+auth\@0.42.0/node\_modules/@cipherstash/auth/native.d.ts:19
The issuer URL from the JWT `iss` claim (i.e. the CTS host).
services [#services]
```ts
services: Record<string, string>;
```
Defined in: ../../../node\_modules/.bun/@cipherstash+auth\@0.42.0/node\_modules/@cipherstash/auth/native.d.ts:21
Service endpoint URLs from the JWT `services` claim (e.g. `{ zerokms: "https://..." }`).
***
EncryptionClient [#encryptionclient]
Defined in: [client-v3.ts:155](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/encryption/client-v3.ts#L155)
The client type [Encryption](https://cipherstash.com/docs/reference/stack/api-reference/encryption#encryption) resolves to for the schema tuple `S`: a
strongly-typed view over the native FFI-backed client, for EQL v3 schemas.
Every method derives its types from the concrete `table` / `column` builder
arguments (which carry their branded types at the call site), so:
* `encrypt` / `encryptQuery` pin the plaintext to the column's domain type
(`text → string`, `timestamp → Date`, …);
* `encryptQuery` additionally constrains `queryType` to the column's
capabilities and rejects storage-only columns outright;
* `encryptModel` / `bulkEncryptModels` validate schema-column fields against
their inferred plaintext type (passthrough fields are untouched) and return
a precise encrypted model;
* `decryptModel` / `bulkDecryptModels` return the precise plaintext model,
reconstructing `Date` values from the encrypt-config `cast_as`.
This is **the** way to name the client — reach for it whenever you need to
declare a variable, field or return type before the `await` that produces it:
```typescript
const users = encryptedTable("users", { email: types.TextSearch("email") })
let client: EncryptionClient<readonly [typeof users]>
client = await Encryption({ schemas: [users] })
```
For code that is generic over its schemas — integration adapters that build a
table per test family, say — name the loose array:
```typescript
let client: EncryptionClient<readonly AnyV3Table[]>
```
That keeps `table` and `column` arguments checked, but NOT the model input:
with `S` loose, `V3ModelInput<AnyV3Table, T>` cannot resolve a per-column
plaintext, so `encryptModel` / `bulkEncryptModels` reject a
`Record<string, unknown>` model. An adapter holding untyped rows needs a cast
at that boundary (`@cipherstash/stack-supabase` has exactly one, for exactly
this reason). Name a concrete tuple wherever the schema IS known statically —
that is the only form with full model typing.
Prefer this named type to `Awaited<ReturnType<typeof Encryption>>` when the
concrete schema tuple matters: TypeScript's `ReturnType` reads the final
overload and therefore produces the intentionally widened default client.
Type Parameters [#type-parameters]
S [#s]
`S` *extends* readonly [`AnyV3Table`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#anyv3table)\[] = readonly [`AnyV3Table`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#anyv3table)\[]
the tuple of registered v3 tables; `table` arguments must be a
member of this tuple.
Methods [#methods]
encrypt() [#encrypt]
```ts
encrypt<Table, Col>(plaintext, opts): EncryptOperation;
```
Defined in: [client-v3.ts:158](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/encryption/client-v3.ts#L158)
Type Parameters [#type-parameters-1]
Table [#table]
`Table` *extends* [`AnyV3Table`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#anyv3table)
Col [#col]
`Col` *extends* [`AnyEncryptedV3Column`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#anyencryptedv3column)
Parameters [#parameters]
plaintext [#plaintext]
[`PlaintextForColumn`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#plaintextforcolumn)\<`Col`>
opts [#opts]
table [#table-1]
`Table`
column [#column]
`Col`
Returns [#returns]
[`EncryptOperation`](https://cipherstash.com/docs/reference/stack/api-reference/encryption#encryptoperation)
encryptQuery() [#encryptquery]
Call Signature [#call-signature]
```ts
encryptQuery<Table, Col, QT>(plaintext, opts): EncryptQueryOperation;
```
Defined in: [client-v3.ts:163](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/encryption/client-v3.ts#L163)
Type Parameters [#type-parameters-2]
Table [#table-2]
`Table` *extends* [`AnyV3Table`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#anyv3table)
Col [#col-1]
`Col` *extends* [`AnyEncryptedV3Column`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#anyencryptedv3column)
QT [#qt]
`QT` *extends* `"equality"` | `"orderAndRange"` | `"freeTextSearch"` | `"searchableJson"` = [`QueryTypesForColumn`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#querytypesforcolumn)\<`Col`>
Parameters [#parameters-1]
plaintext [#plaintext-1]
[`PlaintextForColumn`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#plaintextforcolumn)\<`Col`>
opts [#opts-1]
table [#table-3]
`Table`
column [#column-1]
`Col`
queryType? [#querytype]
`QT`
returnType? [#returntype]
[`EncryptedReturnType`](https://cipherstash.com/docs/reference/stack/api-reference/types-public#encryptedreturntype)
Returns [#returns-1]
[`EncryptQueryOperation`](https://cipherstash.com/docs/reference/stack/api-reference/encryption#encryptqueryoperation)
Call Signature [#call-signature-1]
```ts
encryptQuery(terms): BatchEncryptQueryOperation;
```
Defined in: [client-v3.ts:178](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/encryption/client-v3.ts#L178)
Batch query terms remain correlated by table, column, value and capability.
Parameters [#parameters-2]
terms [#terms]
readonly `QueryTermForSchemas`\<`S`>\[]
Returns [#returns-2]
[`BatchEncryptQueryOperation`](https://cipherstash.com/docs/reference/stack/api-reference/encryption#batchencryptqueryoperation)
encryptModel() [#encryptmodel]
```ts
encryptModel<Table, T>(input, table): EncryptModelOperation<V3EncryptedModel<Table, T>>;
```
Defined in: [client-v3.ts:182](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/encryption/client-v3.ts#L182)
Type Parameters [#type-parameters-3]
Table [#table-4]
`Table` *extends* [`AnyV3Table`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#anyv3table)
T [#t]
`T` *extends* `Record`\<`string`, `unknown`>
Parameters [#parameters-3]
input [#input]
[`V3ModelInput`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#v3modelinput)\<`Table`, `T`>
table [#table-5]
`Table`
Returns [#returns-3]
[`EncryptModelOperation`](https://cipherstash.com/docs/reference/stack/api-reference/encryption#encryptmodeloperation)\<[`V3EncryptedModel`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#v3encryptedmodel)\<`Table`, `T`>>
bulkEncryptModels() [#bulkencryptmodels]
```ts
bulkEncryptModels<Table, T>(input, table): BulkEncryptModelsOperation<V3EncryptedModel<Table, T>>;
```
Defined in: [client-v3.ts:187](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/encryption/client-v3.ts#L187)
Type Parameters [#type-parameters-4]
Table [#table-6]
`Table` *extends* [`AnyV3Table`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#anyv3table)
T [#t-1]
`T` *extends* `Record`\<`string`, `unknown`>
Parameters [#parameters-4]
input [#input-1]
[`V3ModelInput`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#v3modelinput)\<`Table`, `T`>\[]
table [#table-7]
`Table`
Returns [#returns-4]
[`BulkEncryptModelsOperation`](https://cipherstash.com/docs/reference/stack/api-reference/encryption#bulkencryptmodelsoperation)\<[`V3EncryptedModel`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#v3encryptedmodel)\<`Table`, `T`>>
decrypt() [#decrypt]
```ts
decrypt(encrypted): DecryptOperation;
```
Defined in: [client-v3.ts:220](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/encryption/client-v3.ts#L220)
Decrypt a single stored payload, resolving to the FFI plaintext union
(`JsPlaintext`) unchanged.
**A `date` / `timestamp` column comes back as the string it was stored as,
not a `Date`** — where `decryptModel(row, table)` reconstructs it. Same
value, two JavaScript types, depending on which method read it (#779).
The scalar form cannot be strongly *typed*: TypeScript has no way to know
which column a runtime `Encrypted` came from, so the static type has to be
the whole union. That is a statement about the type layer only. At runtime
every payload carries its own `i: { t, c }` table/column identity, so for
one of the tables this client was initialized with, the `cast_as` is
reachable from here — skipping reconstruction is a deliberate contract
line, not a missing capability. `JsPlaintext` excludes `Date` by
construction, and that is the type callers have annotated against;
reconstructing without widening it would make the type a lie.
(A payload from a table NOT in the client's schemas — the legacy EQL v2
read path — is the one case where the capability genuinely is absent: the
`i` names a table there is no encrypt config to resolve. The contract is
the same either way, which is why the boundary is drawn at the method and
not per payload.)
For `Date` values, read through [decryptModel](https://cipherstash.com/docs/reference/stack/api-reference/Package-exports#decryptmodel) /
[bulkDecryptModels](https://cipherstash.com/docs/reference/stack/api-reference/Package-exports#bulkdecryptmodels) with the table, or rebuild at the call site
(`new Date(value)`).
Parameters [#parameters-5]
encrypted [#encrypted]
`EncryptedPayload`
Returns [#returns-5]
[`DecryptOperation`](https://cipherstash.com/docs/reference/stack/api-reference/encryption#decryptoperation)
decryptModel() [#decryptmodel]
Call Signature [#call-signature-2]
```ts
decryptModel<Table, T>(
input,
table,
lockContext): LockBoundDecryptModelOperation<V3ModelInput<Table, T>>;
```
Defined in: [client-v3.ts:239](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/encryption/client-v3.ts#L239)
Decrypt a model, returning the precise plaintext shape for `table`. `Date`
columns are reconstructed from the encrypt-config `cast_as`.
Pass `lockContext` to decrypt identity-bound data — the same context that
was supplied at encrypt time must be provided here (or chain
`.withLockContext()` on the returned operation).
Returns a chainable AuditableDecryptModelOperation: await it for the
`Result`, or chain `.audit({ metadata })` / `.withLockContext()` first. The
per-row `Date` reconstruction is applied to the successful result.
Passing `lockContext` positionally returns the
LockBoundDecryptModelOperation instead, which offers `.audit()` but
not `.withLockContext()` — a context binds exactly once, and binding twice
throws.
Type Parameters [#type-parameters-5]
Table [#table-8]
`Table` *extends* [`AnyV3Table`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#anyv3table)
T [#t-2]
`T` *extends* `Record`\<`string`, `unknown`>
Parameters [#parameters-6]
input [#input-2]
`T`
table [#table-9]
`Table`
lockContext [#lockcontext]
[`LockContextInput`](https://cipherstash.com/docs/reference/stack/api-reference/identity#lockcontextinput) | `undefined`
Returns [#returns-6]
`LockBoundDecryptModelOperation`\<[`V3ModelInput`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#v3modelinput)\<`Table`, `T`>>
Call Signature [#call-signature-3]
```ts
decryptModel<Table, T>(input, table): AuditableDecryptModelOperation<V3ModelInput<Table, T>>;
```
Defined in: [client-v3.ts:244](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/encryption/client-v3.ts#L244)
Type Parameters [#type-parameters-6]
Table [#table-10]
`Table` *extends* [`AnyV3Table`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#anyv3table)
T [#t-3]
`T` *extends* `Record`\<`string`, `unknown`>
Parameters [#parameters-7]
input [#input-3]
`T`
table [#table-11]
`Table`
Returns [#returns-7]
`AuditableDecryptModelOperation`\<[`V3ModelInput`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#v3modelinput)\<`Table`, `T`>>
Call Signature [#call-signature-4]
```ts
decryptModel<T>(input): AuditableDecryptModelOperation<Decrypted<T>>;
```
Defined in: [client-v3.ts:266](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/encryption/client-v3.ts#L266)
Table-less form: decrypt whatever encrypted fields the model carries, with
no `Date` reconstruction and no precise plaintext shape. The `table`
argument is what selects the reconstruction map, and `Decrypted<T>` types
every decrypted field as `string` to match. (For a table that IS
registered, the payload's own `i: { t, c }` would resolve the `cast_as` —
declining to use it is what keeps this arity's runtime agreeing with its
declared type. #779.)
This is the read path for rows that predate this client's schemas — legacy
**EQL v2** models above all, whose table is not, and cannot be, a member of
`S`. It is also the arity the pre-v3 client exposed, so callers and adapters
written against that shape keep compiling. The runtime has always accepted
the one-arg call; without this signature the type layer forbids the very
compatibility the client promises. Prefer the two-arg form whenever the
table IS registered.
Type Parameters [#type-parameters-7]
T [#t-4]
`T` *extends* `Record`\<`string`, `unknown`>
Parameters [#parameters-8]
input [#input-4]
`T`
Returns [#returns-8]
`AuditableDecryptModelOperation`\<[`Decrypted`](https://cipherstash.com/docs/reference/stack/api-reference/types-public#decrypted)\<`T`>>
bulkDecryptModels() [#bulkdecryptmodels]
Call Signature [#call-signature-5]
```ts
bulkDecryptModels<Table, T>(
input,
table,
lockContext): LockBoundDecryptModelOperation<V3ModelInput<Table, T>[]>;
```
Defined in: [client-v3.ts:270](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/encryption/client-v3.ts#L270)
Type Parameters [#type-parameters-8]
Table [#table-12]
`Table` *extends* [`AnyV3Table`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#anyv3table)
T [#t-5]
`T` *extends* `Record`\<`string`, `unknown`>
Parameters [#parameters-9]
input [#input-5]
`T`\[]
table [#table-13]
`Table`
lockContext [#lockcontext-1]
[`LockContextInput`](https://cipherstash.com/docs/reference/stack/api-reference/identity#lockcontextinput) | `undefined`
Returns [#returns-9]
`LockBoundDecryptModelOperation`\<[`V3ModelInput`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#v3modelinput)\<`Table`, `T`>\[]>
Call Signature [#call-signature-6]
```ts
bulkDecryptModels<Table, T>(input, table): AuditableDecryptModelOperation<V3ModelInput<Table, T>[]>;
```
Defined in: [client-v3.ts:275](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/encryption/client-v3.ts#L275)
Type Parameters [#type-parameters-9]
Table [#table-14]
`Table` *extends* [`AnyV3Table`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#anyv3table)
T [#t-6]
`T` *extends* `Record`\<`string`, `unknown`>
Parameters [#parameters-10]
input [#input-6]
`T`\[]
table [#table-15]
`Table`
Returns [#returns-10]
`AuditableDecryptModelOperation`\<[`V3ModelInput`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#v3modelinput)\<`Table`, `T`>\[]>
Call Signature [#call-signature-7]
```ts
bulkDecryptModels<T>(input): AuditableDecryptModelOperation<Decrypted<T>[]>;
```
Defined in: [client-v3.ts:281](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/encryption/client-v3.ts#L281)
Table-less bulk form — see the one-arg [decryptModel](https://cipherstash.com/docs/reference/stack/api-reference/Package-exports#decryptmodel) overload.
Type Parameters [#type-parameters-10]
T [#t-7]
`T` *extends* `Record`\<`string`, `unknown`>
Parameters [#parameters-11]
input [#input-7]
`T`\[]
Returns [#returns-11]
`AuditableDecryptModelOperation`\<[`Decrypted`](https://cipherstash.com/docs/reference/stack/api-reference/types-public#decrypted)\<`T`>\[]>
bulkEncrypt() [#bulkencrypt]
```ts
bulkEncrypt<Table, Col>(plaintexts, opts): BulkEncryptOperation;
```
Defined in: [client-v3.ts:285](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/encryption/client-v3.ts#L285)
Type Parameters [#type-parameters-11]
Table [#table-16]
`Table` *extends* [`AnyV3Table`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#anyv3table)
Col [#col-2]
`Col` *extends* [`AnyEncryptedV3Column`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#anyencryptedv3column)
Parameters [#parameters-12]
plaintexts [#plaintexts]
`BulkEncryptPayloadFor`\<`Col`>
opts [#opts-2]
table [#table-17]
`Table`
column [#column-2]
`Col`
Returns [#returns-12]
[`BulkEncryptOperation`](https://cipherstash.com/docs/reference/stack/api-reference/encryption#bulkencryptoperation)
bulkDecrypt() [#bulkdecrypt]
```ts
bulkDecrypt(payloads): BulkDecryptOperation;
```
Defined in: [client-v3.ts:299](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/encryption/client-v3.ts#L299)
Decrypt many stored payloads in one ZeroKMS round trip, position-stable
with a per-item `{ data } | { error }` entry.
Draws the same boundary as [decrypt](https://cipherstash.com/docs/reference/stack/api-reference/Package-exports#decrypt), for the same reason: **no
`Date` reconstruction** — date-like columns arrive as their stored strings.
Prefer [bulkDecryptModels](https://cipherstash.com/docs/reference/stack/api-reference/Package-exports#bulkdecryptmodels) with the table when you want the column's
declared plaintext type back (#779).
Parameters [#parameters-13]
payloads [#payloads]
[`BulkDecryptPayload`](https://cipherstash.com/docs/reference/stack/api-reference/types-public#bulkdecryptpayload)
Returns [#returns-13]
[`BulkDecryptOperation`](https://cipherstash.com/docs/reference/stack/api-reference/encryption#bulkdecryptoperation)
getEncryptConfig() [#getencryptconfig]
```ts
getEncryptConfig():
| {
v: number;
tables: Record<string, Record<string, {
cast_as: | "string"
| "number"
| "bigint"
| "boolean"
| "date"
| "text"
| "timestamp"
| "json";
indexes: {
ore?: {
};
ope?: {
};
unique?: {
token_filters?: {
kind: ...;
}[];
};
match?: {
tokenizer?: | {
kind: "standard";
}
| {
kind: "ngram";
token_length: number;
};
token_filters?: {
kind: ...;
}[];
k?: number;
m?: number;
include_original?: boolean;
};
ste_vec?: {
prefix: string;
array_index_mode?: | "all"
| "none"
| {
item?: ... | ... | ...;
wildcard?: ... | ... | ...;
position?: ... | ... | ...;
};
mode?: "standard" | "compat";
};
};
}>>;
}
| undefined;
```
Defined in: [client-v3.ts:300](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/encryption/client-v3.ts#L300)
Returns [#returns-14]
\| \{
`v`: `number`;
`tables`: `Record`\<`string`, `Record`\<`string`, \{
`cast_as`: | `"string"`
\| `"number"`
\| `"bigint"`
\| `"boolean"`
\| `"date"`
\| `"text"`
\| `"timestamp"`
\| `"json"`;
`indexes`: \{
`ore?`: \{
};
`ope?`: \{
};
`unique?`: \{
`token_filters?`: \{
`kind`: ...;
}\[];
};
`match?`: \{
`tokenizer?`: | \{
`kind`: `"standard"`;
}
\| \{
`kind`: `"ngram"`;
`token_length`: `number`;
};
`token_filters?`: \{
`kind`: ...;
}\[];
`k?`: `number`;
`m?`: `number`;
`include_original?`: `boolean`;
};
`ste_vec?`: \{
`prefix`: `string`;
`array_index_mode?`: | `"all"`
\| `"none"`
\| \{
`item?`: ... | ... | ...;
`wildcard?`: ... | ... | ...;
`position?`: ... | ... | ...;
};
`mode?`: `"standard"` | `"compat"`;
};
};
}>>;
}
\| `undefined`
Type Aliases [#type-aliases]
AuthFailure [#authfailure]
```ts
type AuthFailure =
| FailureBase & {
type: "REQUEST_ERROR";
}
| FailureBase & {
type: "ACCESS_DENIED";
}
| FailureBase & {
type: "EXPIRED_TOKEN";
}
| FailureBase & {
type: "INVALID_GRANT";
}
| FailureBase & {
type: "INVALID_CLIENT";
}
| FailureBase & {
type: "INVALID_URL";
}
| FailureBase & {
type: "INVALID_REGION";
}
| FailureBase & {
type: "INVALID_TOKEN";
}
| FailureBase & {
type: "SERVER_ERROR";
}
| FailureBase & {
type: "NOT_AUTHENTICATED";
}
| FailureBase & {
type: "MISSING_WORKSPACE_CRN";
}
| FailureBase & {
type: "INVALID_ACCESS_KEY";
}
| FailureBase & {
type: "INVALID_CRN";
}
| FailureBase & {
type: "WORKSPACE_MISMATCH";
expected: string;
actual: string;
}
| FailureBase & {
type: "INVALID_WORKSPACE_ID";
}
| FailureBase & {
type: "ALREADY_CONSUMED";
}
| FailureBase & {
type: "INTERNAL_ERROR";
}
| FailureBase & {
type: "CUSTOM";
}
| FailureBase & {
type: "STORE_ERROR";
};
```
Defined in: ../../../node\_modules/.bun/@cipherstash+auth\@0.42.0/node\_modules/@cipherstash/auth/index.d.ts:42
A domain failure returned in the `failure` arm of a `Result`. Discriminated
by `type`; narrow on it to access per-variant payload (e.g.
`WORKSPACE_MISMATCH`'s `expected`/`actual`).
***
AuthErrorCode [#autherrorcode]
```ts
type AuthErrorCode = AuthFailure["type"];
```
Defined in: ../../../node\_modules/.bun/@cipherstash+auth\@0.42.0/node\_modules/@cipherstash/auth/index.d.ts:64
The machine-readable discriminant carried by every [AuthFailure](https://cipherstash.com/docs/reference/stack/api-reference/Package-exports#authfailure).
***
AccessKeyStrategy [#accesskeystrategy]
```ts
type AccessKeyStrategy = InstanceType<typeof auth.AccessKeyStrategy>;
```
Defined in: [index.ts:26](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/index.ts#L26)
***
AutoStrategy [#autostrategy]
```ts
type AutoStrategy = InstanceType<typeof auth.AutoStrategy>;
```
Defined in: [index.ts:28](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/index.ts#L28)
***
DeviceSessionStrategy [#devicesessionstrategy]
```ts
type DeviceSessionStrategy = InstanceType<typeof auth.DeviceSessionStrategy>;
```
Defined in: [index.ts:30](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/index.ts#L30)
***
OidcFederationStrategy [#oidcfederationstrategy]
```ts
type OidcFederationStrategy = InstanceType<typeof auth.OidcFederationStrategy>;
```
Defined in: [index.ts:34](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/index.ts#L34)
***
Encrypted [#encrypted-1]
```ts
type Encrypted = CipherStashEncryptedPayload;
```
Defined in: [types.ts:63](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/types.ts#L63)
Structural type representing encrypted data stored in the database. Always
carries a ciphertext. Covers BOTH wire formats: the EQL v2.3 payloads
(`k: "ct"` / `k: "sv"`) and the EQL v3 payloads (flat `{v: 3, i, c, …}`
scalars and `{v: 3, k: "sv", i, sv}` SteVec documents). Schema authoring is
v3-only, so `encrypt` always produces v3; `decrypt` accepts both regardless.
v3 scalars carry no `k` discriminator, so narrow with `'k' in payload`
before reading it. See also `EncryptedValue` for branded nominal typing,
and [EncryptedQuery](https://cipherstash.com/docs/reference/stack/api-reference/types-public#encryptedquery) for the search-term shape returned by
`encryptQuery`.
Variables [#variables]
AccessKeyStrategy [#accesskeystrategy-1]
```ts
const AccessKeyStrategy: typeof AccessKeyStrategy = auth.AccessKeyStrategy;
```
Defined in: [index.ts:26](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/index.ts#L26)
***
AutoStrategy [#autostrategy-1]
```ts
const AutoStrategy: typeof AutoStrategy = auth.AutoStrategy;
```
Defined in: [index.ts:28](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/index.ts#L28)
***
DeviceSessionStrategy [#devicesessionstrategy-1]
```ts
const DeviceSessionStrategy: typeof DeviceSessionStrategy = auth.DeviceSessionStrategy;
```
Defined in: [index.ts:30](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/index.ts#L30)
***
OidcFederationStrategy [#oidcfederationstrategy-1]
```ts
const OidcFederationStrategy: typeof OidcFederationStrategy = auth.OidcFederationStrategy;
```
Defined in: [index.ts:34](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/index.ts#L34)
Functions [#functions]
encryptedToPgComposite() [#encryptedtopgcomposite]
```ts
function encryptedToPgComposite(obj): EncryptedPgComposite;
```
Defined in: [index.ts:31](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/encryption/helpers/index.ts#L31)
Helper function to transform an encrypted payload into a PostgreSQL composite type.
Use this when inserting data via Supabase or similar clients.
Parameters [#parameters-14]
obj [#obj]
`EncryptedPayload`
Returns [#returns-15]
`EncryptedPgComposite`
***
isEncryptedPayload() [#isencryptedpayload]
```ts
function isEncryptedPayload(value): value is EncryptedPayload;
```
Defined in: [index.ts:129](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/encryption/helpers/index.ts#L129)
Helper function to check if a value is an encrypted payload
Parameters [#parameters-15]
value [#value]
`unknown`
Returns [#returns-16]
`value is EncryptedPayload`
References [#references]
Encryption [#encryption]
Re-exports [Encryption](https://cipherstash.com/docs/reference/stack/api-reference/encryption#encryption)
# adapter-kit
Source: https://cipherstash.com/docs/reference/stack/api-reference/adapter-kit
[**@cipherstash/stack**](./)
***
Classes [#classes]
EncryptedV3Column [#encryptedv3column]
Defined in: [columns.ts:440](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/eql/v3/columns.ts#L440)
Extended by [#extended-by]
* [`EncryptedBigintColumn`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptedbigintcolumn)
* [`EncryptedBigintEqColumn`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptedbiginteqcolumn)
* [`EncryptedBigintOrdColumn`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptedbigintordcolumn)
* [`EncryptedBigintOrdOreColumn`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptedbigintordorecolumn)
* [`EncryptedBooleanColumn`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptedbooleancolumn)
* [`EncryptedDateColumn`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encrypteddatecolumn)
* [`EncryptedDateEqColumn`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encrypteddateeqcolumn)
* [`EncryptedDateOrdColumn`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encrypteddateordcolumn)
* [`EncryptedDateOrdOreColumn`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encrypteddateordorecolumn)
* [`EncryptedDoubleColumn`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encrypteddoublecolumn)
* [`EncryptedDoubleEqColumn`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encrypteddoubleeqcolumn)
* [`EncryptedDoubleOrdColumn`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encrypteddoubleordcolumn)
* [`EncryptedDoubleOrdOreColumn`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encrypteddoubleordorecolumn)
* [`EncryptedIntegerColumn`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptedintegercolumn)
* [`EncryptedIntegerEqColumn`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptedintegereqcolumn)
* [`EncryptedIntegerOrdColumn`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptedintegerordcolumn)
* [`EncryptedIntegerOrdOreColumn`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptedintegerordorecolumn)
* [`EncryptedJsonColumn`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptedjsoncolumn)
* [`EncryptedNumericColumn`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptednumericcolumn)
* [`EncryptedNumericEqColumn`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptednumericeqcolumn)
* [`EncryptedNumericOrdColumn`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptednumericordcolumn)
* [`EncryptedNumericOrdOreColumn`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptednumericordorecolumn)
* [`EncryptedRealColumn`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptedrealcolumn)
* [`EncryptedRealEqColumn`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptedrealeqcolumn)
* [`EncryptedRealOrdColumn`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptedrealordcolumn)
* [`EncryptedRealOrdOreColumn`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptedrealordorecolumn)
* [`EncryptedSmallintColumn`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptedsmallintcolumn)
* [`EncryptedSmallintEqColumn`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptedsmallinteqcolumn)
* [`EncryptedSmallintOrdColumn`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptedsmallintordcolumn)
* [`EncryptedSmallintOrdOreColumn`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptedsmallintordorecolumn)
* [`EncryptedTextColumn`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptedtextcolumn)
* [`EncryptedTextEqColumn`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptedtexteqcolumn)
* [`EncryptedTextMatchColumn`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptedtextmatchcolumn)
* [`EncryptedTextOrdColumn`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptedtextordcolumn)
* [`EncryptedTextOrdOreColumn`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptedtextordorecolumn)
* [`EncryptedTextSearchColumn`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptedtextsearchcolumn)
* [`EncryptedTimestampColumn`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptedtimestampcolumn)
* [`EncryptedTimestampEqColumn`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptedtimestampeqcolumn)
* [`EncryptedTimestampOrdColumn`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptedtimestampordcolumn)
* [`EncryptedTimestampOrdOreColumn`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptedtimestampordorecolumn)
Type Parameters [#type-parameters]
D [#d]
`D` *extends* `V3DomainDefinition`
Constructors [#constructors]
Constructor [#constructor]
```ts
new EncryptedV3Column<D>(columnName, definition): EncryptedV3Column<D>;
```
Defined in: [columns.ts:474](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/eql/v3/columns.ts#L474)
Parameters [#parameters]
columnName [#columnname]
`string`
definition [#definition]
`D`
Returns [#returns]
[`EncryptedV3Column`](https://cipherstash.com/docs/reference/stack/api-reference/adapter-kit#encryptedv3column)\<`D`>
Methods [#methods]
getName() [#getname]
```ts
getName(): string;
```
Defined in: [columns.ts:479](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/eql/v3/columns.ts#L479)
Returns [#returns-1]
`string`
getEqlType() [#geteqltype]
```ts
getEqlType(): D["eqlType"];
```
Defined in: [columns.ts:484](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/eql/v3/columns.ts#L484)
The concrete EQL v3 domain name. Metadata only; not emitted by `build()`.
Returns [#returns-2]
`D`\[`"eqlType"`]
getQueryCapabilities() [#getquerycapabilities]
```ts
getQueryCapabilities(): D["capabilities"];
```
Defined in: [columns.ts:489](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/eql/v3/columns.ts#L489)
The semantic query capabilities this domain exposes. Metadata only.
Returns [#returns-3]
`D`\[`"capabilities"`]
isQueryable() [#isqueryable]
```ts
isQueryable(): QueryableFlag<D>;
```
Defined in: [columns.ts:494](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/eql/v3/columns.ts#L494)
`true` when this domain can produce at least one kind of query term.
Returns [#returns-4]
`QueryableFlag`\<`D`>
build() [#build]
```ts
build(): {
cast_as: | "string"
| "number"
| "bigint"
| "boolean"
| "date"
| "text"
| "timestamp"
| "json";
indexes: {
ore?: {
};
ope?: {
};
unique?: {
token_filters?: {
kind: "downcase";
}[];
};
match?: {
tokenizer?: | {
kind: "standard";
}
| {
kind: "ngram";
token_length: number;
};
token_filters?: {
kind: "downcase";
}[];
k?: number;
m?: number;
include_original?: boolean;
};
ste_vec?: {
prefix: string;
array_index_mode?: | "all"
| "none"
| {
item?: boolean;
wildcard?: boolean;
position?: boolean;
};
mode?: "standard" | "compat";
};
};
};
```
Defined in: [columns.ts:501](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/eql/v3/columns.ts#L501)
Emit the encrypt-config column: `cast_as` plus capability-derived indexes.
Returns [#returns-5]
```ts
{
cast_as: | "string"
| "number"
| "bigint"
| "boolean"
| "date"
| "text"
| "timestamp"
| "json";
indexes: {
ore?: {
};
ope?: {
};
unique?: {
token_filters?: {
kind: "downcase";
}[];
};
match?: {
tokenizer?: | {
kind: "standard";
}
| {
kind: "ngram";
token_length: number;
};
token_filters?: {
kind: "downcase";
}[];
k?: number;
m?: number;
include_original?: boolean;
};
ste_vec?: {
prefix: string;
array_index_mode?: | "all"
| "none"
| {
item?: boolean;
wildcard?: boolean;
position?: boolean;
};
mode?: "standard" | "compat";
};
};
}
```
cast_as [#cast_as]
```ts
cast_as:
| "string"
| "number"
| "bigint"
| "boolean"
| "date"
| "text"
| "timestamp"
| "json" = castAsEnum;
```
indexes [#indexes]
```ts
indexes: {
ore?: {
};
ope?: {
};
unique?: {
token_filters?: {
kind: "downcase";
}[];
};
match?: {
tokenizer?: | {
kind: "standard";
}
| {
kind: "ngram";
token_length: number;
};
token_filters?: {
kind: "downcase";
}[];
k?: number;
m?: number;
include_original?: boolean;
};
ste_vec?: {
prefix: string;
array_index_mode?: | "all"
| "none"
| {
item?: boolean;
wildcard?: boolean;
position?: boolean;
};
mode?: "standard" | "compat";
};
} = indexesSchema;
```
indexes.ore? [#indexesore]
```ts
optional ore: {
};
```
indexes.ope? [#indexesope]
```ts
optional ope: {
};
```
indexes.unique? [#indexesunique]
```ts
optional unique: {
token_filters?: {
kind: "downcase";
}[];
};
```
indexes.unique.token_filters? [#indexesuniquetoken_filters]
```ts
optional token_filters: {
kind: "downcase";
}[];
```
indexes.match? [#indexesmatch]
```ts
optional match: {
tokenizer?: | {
kind: "standard";
}
| {
kind: "ngram";
token_length: number;
};
token_filters?: {
kind: "downcase";
}[];
k?: number;
m?: number;
include_original?: boolean;
};
```
indexes.match.tokenizer? [#indexesmatchtokenizer]
```ts
optional tokenizer:
| {
kind: "standard";
}
| {
kind: "ngram";
token_length: number;
} = tokenizerSchema;
```
indexes.match.token_filters? [#indexesmatchtoken_filters]
```ts
optional token_filters: {
kind: "downcase";
}[];
```
indexes.match.k? [#indexesmatchk]
```ts
optional k: number;
```
indexes.match.m? [#indexesmatchm]
```ts
optional m: number;
```
indexes.match.include_original? [#indexesmatchinclude_original]
```ts
optional include_original: boolean;
```
indexes.ste_vec? [#indexesste_vec]
```ts
optional ste_vec: {
prefix: string;
array_index_mode?: | "all"
| "none"
| {
item?: boolean;
wildcard?: boolean;
position?: boolean;
};
mode?: "standard" | "compat";
};
```
indexes.ste_vec.prefix [#indexesste_vecprefix]
```ts
prefix: string;
```
indexes.ste_vec.array_index_mode? [#indexesste_vecarray_index_mode]
```ts
optional array_index_mode:
| "all"
| "none"
| {
item?: boolean;
wildcard?: boolean;
position?: boolean;
};
```
indexes.ste_vec.mode? [#indexesste_vecmode]
```ts
optional mode: "standard" | "compat";
```
Type Aliases [#type-aliases]
AuditConfig [#auditconfig]
```ts
type AuditConfig = {
metadata?: Record<string, unknown>;
};
```
Defined in: [base-operation.ts:4](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/encryption/operations/base-operation.ts#L4)
Properties [#properties]
metadata? [#metadata]
```ts
optional metadata: Record<string, unknown>;
```
Defined in: [base-operation.ts:5](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/encryption/operations/base-operation.ts#L5)
Variables [#variables]
DATE_LIKE_CASTS [#date_like_casts]
```ts
const DATE_LIKE_CASTS: readonly ["date", "timestamp"];
```
Defined in: [columns.ts:36](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/eql/v3/columns.ts#L36)
The `cast_as` kinds whose decrypted plaintext reconstructs to a JS `Date`.
SINGLE SOURCE OF TRUTH for the date-like set. Both the type-level
PlaintextFromKind and the runtime `rowReconstructor` (encryption/v3.ts)
derive their "reconstructs to `Date`" decision from this array, so the next
`Date`-backed cast is added in exactly one place — never hand-synced across a
type and a runtime guard that could silently drift.
(`timestamp` reconstructs to `Date` just like `date`, but its `cast_as` tells
the FFI not to truncate the time-of-day.)
***
DOMAIN_REGISTRY [#domain_registry]
```ts
const DOMAIN_REGISTRY: Record<string, V3ColumnFactory>;
```
Defined in: [domain-registry.ts:37](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/eql/v3/domain-registry.ts#L37)
Unqualified Postgres `domain_name` → the `eql/v3/types.ts` factory that
builds that domain's column.
DERIVED, not hand-listed. Every factory already carries its domain in the
constant it passes to the column constructor, so the key is recoverable from
the factory itself — and `types` and this registry cannot drift. Adding a
domain to `types` is enough; forgetting an entry here is no longer possible.
The keys are an external contract (they are the `information_schema` query
parameter in `../../supabase/introspect.ts`). Because they are derived from
`getEqlType()`, no test that also derives them can detect a corrupted domain
constant — `eql-v3-domain-registry.test.ts` pins them against a hand-written
literal list for exactly that reason.
`factory('_probe')` runs at module load, so a non-factory value in `types`
would throw here and take the importing modules (`../../supabase/introspect.ts`,
`schema-builder.ts`, `verify.ts`) down with it. `types` is declared
`satisfies Record<string, V3ColumnFactory>` so that mistake is a compile error
at its source instead. Do not reintroduce a cast on `Object.values` below: it
would silence exactly the check that keeps this loop total.
***
logger [#logger]
```ts
const logger: {
debug: void;
info: void;
warn: void;
error: void;
};
```
Defined in: [index.ts:80](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/utils/logger/index.ts#L80)
Type Declaration [#type-declaration]
debug() [#debug]
```ts
debug(...args): void;
```
Parameters [#parameters-1]
args [#args]
...`unknown`\[]
Returns [#returns-6]
`void`
info() [#info]
```ts
info(...args): void;
```
Parameters [#parameters-2]
args [#args-1]
...`unknown`\[]
Returns [#returns-7]
`void`
warn() [#warn]
```ts
warn(...args): void;
```
Parameters [#parameters-3]
args [#args-2]
...`unknown`\[]
Returns [#returns-8]
`void`
error() [#error]
```ts
error(...args): void;
```
Parameters [#parameters-4]
args [#args-3]
...`unknown`\[]
Returns [#returns-9]
`void`
Functions [#functions]
modelToEncryptedPgComposites() [#modeltoencryptedpgcomposites]
```ts
function modelToEncryptedPgComposites<T>(model): T;
```
Defined in: [index.ts:89](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/encryption/helpers/index.ts#L89)
Helper function to transform a model's encrypted fields into PostgreSQL composite types
Type Parameters [#type-parameters-1]
T [#t]
`T` *extends* `Record`\<`string`, `unknown`>
Parameters [#parameters-5]
model [#model]
`T`
Returns [#returns-10]
`T`
***
bulkModelsToEncryptedPgComposites() [#bulkmodelstoencryptedpgcomposites]
```ts
function bulkModelsToEncryptedPgComposites<T>(models): T[];
```
Defined in: [index.ts:108](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/encryption/helpers/index.ts#L108)
Helper function to transform multiple models' encrypted fields into PostgreSQL composite types
Type Parameters [#type-parameters-2]
T [#t-1]
`T` *extends* `Record`\<`string`, `unknown`>
Parameters [#parameters-6]
models [#models]
`T`\[]
Returns [#returns-11]
`T`\[]
***
reconstructDateValue() [#reconstructdatevalue]
```ts
function reconstructDateValue(value): unknown;
```
Defined in: [date-reconstruction.ts:12](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/eql/v3/date-reconstruction.ts#L12)
Rebuild a decrypted plaintext for a date-like model field into a `Date`.
Non-date values and already-constructed Dates pass through untouched.
The `Number.isNaN` guard is the point of the function, not a formality: an
unparseable stored value — a date column written in a non-ISO format, or
corrupted — makes `new Date(...)` an Invalid Date. Returning the raw value
instead means the caller sees what is actually stored, rather than an
Invalid Date whose later `.toISOString()` throws far from the column that
produced it (#742 review).
Parameters [#parameters-7]
value [#value]
`unknown`
Returns [#returns-12]
`unknown`
***
reconstructDatePaths() [#reconstructdatepaths]
```ts
function reconstructDatePaths(row, paths): Record<string, unknown>;
```
Defined in: [date-reconstruction.ts:26](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/eql/v3/date-reconstruction.ts#L26)
Reconstruct date-like values at dotted model paths without mutating the
decrypted input row. Missing paths and non-object intermediates are ignored.
Parameters [#parameters-8]
row [#row]
`Record`\<`string`, `unknown`>
paths [#paths]
readonly `string`\[]
Returns [#returns-13]
`Record`\<`string`, `unknown`>
***
stripDomainSchema() [#stripdomainschema]
```ts
function stripDomainSchema(eqlType): string;
```
Defined in: [domain-registry.ts:52](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/eql/v3/domain-registry.ts#L52)
Strip a leading `public.` schema qualifier from a qualified `eqlType`.
Parameters [#parameters-9]
eqlType [#eqltype]
`string`
Returns [#returns-14]
`string`
***
factoryForDomain() [#factoryfordomain]
```ts
function factoryForDomain(domainName): V3ColumnFactory | undefined;
```
Defined in: [domain-registry.ts:65](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/eql/v3/domain-registry.ts#L65)
Look up the factory for an unqualified domain name, or `undefined`.
`Object.hasOwn` is required, not decorative: without it a domain named
`constructor` / `toString` / `valueOf` / `__proto__` resolves to an inherited
`Object.prototype` member and violates the "unknown domain = plaintext" rule.
Parameters [#parameters-10]
domainName [#domainname]
`string`
Returns [#returns-15]
`V3ColumnFactory` | `undefined`
***
parseSelectorSegments() [#parseselectorsegments]
```ts
function parseSelectorSegments(path): string[];
```
Defined in: [selector-path.ts:32](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/eql/v3/selector-path.ts#L32)
Parse a dot-notation JSONPath into its object-key segments. Rejects, each with
a clear message: array-index/wildcard syntax (v1 is object-keys-only), the
empty/root path, malformed paths (`..`, stray/leading/trailing dots, so we
never silently query a *different* path), and prototype-pollution keys.
`'$.a.b'` / `' a.b '` → `['a', 'b']`.
Parameters [#parameters-11]
path [#path]
`string`
Returns [#returns-16]
`string`\[]
***
jsonPathOf() [#jsonpathof]
```ts
function jsonPathOf(segments): string;
```
Defined in: [selector-path.ts:72](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/eql/v3/selector-path.ts#L72)
`$`-rooted JSONPath for `encryptQuery`'s selector needle.
Parameters [#parameters-12]
segments [#segments]
`string`\[]
Returns [#returns-17]
`string`
***
unsupportedLeafReason() [#unsupportedleafreason]
```ts
function unsupportedLeafReason(value, ordering): string | null;
```
Defined in: [selector-path.ts:83](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/eql/v3/selector-path.ts#L83)
A selector compares a single scalar LEAF. Returns a reason string when `value`
is unsupported — a non-JSON scalar (object/array/Date/bigint), or a boolean
under an ordering operator (no ordering term) — else `null`. Callers raise it
as their adapter's operator error with column context, so a bad value is an
actionable SDK error rather than a deferred, opaque DB failure.
Parameters [#parameters-13]
value [#value-1]
`unknown`
ordering [#ordering]
`boolean`
Returns [#returns-18]
`string` | `null`
***
reconstructSelectorDocument() [#reconstructselectordocument]
```ts
function reconstructSelectorDocument(segments, value): Record<string, unknown>;
```
Defined in: [selector-path.ts:120](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/eql/v3/selector-path.ts#L120)
Nest `value` under the segments: `['a','b']` → `{ a: { b: value } }`. The
storage-needle document whose ste\_vec entry at the path supplies the
ciphertext-bearing comparison entry.
Parameters [#parameters-14]
segments [#segments-1]
`string`\[]
value [#value-2]
`unknown`
Returns [#returns-19]
`Record`\<`string`, `unknown`>
***
matchNeedleError() [#matchneedleerror]
```ts
function matchNeedleError(needle, opts): string | undefined;
```
Defined in: [match-defaults.ts:131](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/schema/match-defaults.ts#L131)
Why a needle cannot be answered by this match index, or `undefined` when it
can. Callers throw their own error type with this as the reason.
A needle that tokenizes to NOTHING has an empty bloom filter, and
`stored_bf @> '{}'` is true for every row ("contains nothing, contained by
everything"). Such a query is unanswerable rather than merely unmatched, so
it must fail loudly instead of silently returning the whole table. Two ways
to tokenize to nothing:
* the empty needle, under ANY tokenizer;
* a needle shorter than the ngram tokenizer's `token_length`.
The ngram floor counts Unicode CODEPOINTS, because that is what the tokenizer
counts. `needle.length` would count UTF-16 code units and wave through an
astral-plane needle: `'👍👍'` is 4 code units but only 2 codepoints, yields no
trigram, and (measured live) matched every row. Graphemes are the wrong unit
in the other direction — NFD `'éé'` is 4 codepoints but 2 grapheme clusters,
and does yield trigrams.
Wired into the v3 adapter surfaces and the core v3 `encryptQuery` preflight.
It lives here, beside the shared match defaults, because v2 builds the same
bloom filters and needs the same floor — but v2's `like`/`ilike` path remains
separate. Do not reuse this for v2 without first
measuring what its tokenizer actually receives: v2 needles carry SQL wildcards
(`'%ada%'`), so the floor may have to apply to the unwrapped term rather than
to the string the caller passed.
Parameters [#parameters-15]
needle [#needle]
`unknown`
opts [#opts]
tokenizer? [#tokenizer]
\| \{
`kind`: `"standard"`;
}
\| \{
`kind`: `"ngram"`;
`token_length`: `number`;
} = `tokenizerSchema`
token_filters? [#token_filters]
\{
`kind`: `"downcase"`;
}\[] = `...`
k? [#k]
`number` = `...`
m? [#m]
`number` = `...`
include_original? [#include_original]
`boolean` = `...`
Returns [#returns-20]
`string` | `undefined`
***
hasBuildColumnKeyMap() [#hasbuildcolumnkeymap]
```ts
function hasBuildColumnKeyMap<T>(table): table is T & { buildColumnKeyMap: () => Record<string, string> };
```
Defined in: [types.ts:251](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/types.ts#L251)
The canonical EQL v3 marker: v3 tables expose `buildColumnKeyMap()`, v2 tables
don't. This is the single predicate the codebase uses to decide which wire
version a table targets — a second hand-written spelling of the check is how a
v2 envelope eventually gets built for a v3 table once the marker drifts, so
every site (`encryption/index.ts`, `wasm-inline.ts`, `dynamodb/helpers.ts`)
routes through here.
Type Parameters [#type-parameters-3]
T [#t-2]
`T` *extends* `object`
Parameters [#parameters-16]
table [#table]
`T`
Returns [#returns-21]
`table is T & { buildColumnKeyMap: () => Record<string, string> }`
References [#references]
AnyEncryptedV3Column [#anyencryptedv3column]
Re-exports [AnyEncryptedV3Column](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#anyencryptedv3column)
# dynamodb
Source: https://cipherstash.com/docs/reference/stack/api-reference/dynamodb
[**@cipherstash/stack**](./)
***
Classes [#classes]
BulkDecryptModelsOperation [#bulkdecryptmodelsoperation]
Defined in: [bulk-decrypt-models.ts:24](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/dynamodb/operations/bulk-decrypt-models.ts#L24)
Extends [#extends]
* `DynamoDBOperation`\<[`Decrypted`](https://cipherstash.com/docs/reference/stack/api-reference/types-public#decrypted)\<`T`>\[]>
Type Parameters [#type-parameters]
T [#t]
`T` *extends* `Record`\<`string`, `unknown`>
Constructors [#constructors]
Constructor [#constructor]
```ts
new BulkDecryptModelsOperation<T>(
encryptionClient,
items,
table,
readOptions?,
options?): BulkDecryptModelsOperation<T>;
```
Defined in: [bulk-decrypt-models.ts:32](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/dynamodb/operations/bulk-decrypt-models.ts#L32)
Parameters [#parameters]
encryptionClient [#encryptionclient]
[`DynamoDBEncryptionClient`](https://cipherstash.com/docs/reference/stack/api-reference/dynamodb#dynamodbencryptionclient)
items [#items]
`Record`\<`string`, `unknown`>\[]
table [#table]
[`AnyV3Table`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#anyv3table)
readOptions? [#readoptions]
[`DynamoDBReadOptions`](https://cipherstash.com/docs/reference/stack/api-reference/dynamodb#dynamodbreadoptions) = `{}`
options? [#options]
`DynamoDBOperationOptions`
Returns [#returns]
[`BulkDecryptModelsOperation`](https://cipherstash.com/docs/reference/stack/api-reference/dynamodb#bulkdecryptmodelsoperation)\<`T`>
Overrides [#overrides]
```ts
DynamoDBOperation<Decrypted<T>[]>.constructor
```
Methods [#methods]
execute() [#execute]
```ts
execute(): Promise<Result<Decrypted<T>[], EncryptedDynamoDBError>>;
```
Defined in: [bulk-decrypt-models.ts:46](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/dynamodb/operations/bulk-decrypt-models.ts#L46)
Execute the operation and return a Result
Returns [#returns-1]
`Promise`\<[`Result`](https://www.npmjs.com/package/@byteslice/result)\<[`Decrypted`](https://cipherstash.com/docs/reference/stack/api-reference/types-public#decrypted)\<`T`>\[], [`EncryptedDynamoDBError`](https://cipherstash.com/docs/reference/stack/api-reference/dynamodb#encrypteddynamodberror)>>
Overrides [#overrides-1]
```ts
DynamoDBOperation.execute
```
***
BulkEncryptModelsOperation [#bulkencryptmodelsoperation]
Defined in: [bulk-encrypt-models.ts:22](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/dynamodb/operations/bulk-encrypt-models.ts#L22)
Extends [#extends-1]
* `DynamoDBOperation`\<`T`\[]>
Type Parameters [#type-parameters-1]
T [#t-1]
`T` *extends* `Record`\<`string`, `unknown`>
Constructors [#constructors-1]
Constructor [#constructor-1]
```ts
new BulkEncryptModelsOperation<T>(
encryptionClient,
items,
table,
options?): BulkEncryptModelsOperation<T>;
```
Defined in: [bulk-encrypt-models.ts:29](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/dynamodb/operations/bulk-encrypt-models.ts#L29)
Parameters [#parameters-1]
encryptionClient [#encryptionclient-1]
[`DynamoDBEncryptionClient`](https://cipherstash.com/docs/reference/stack/api-reference/dynamodb#dynamodbencryptionclient)
items [#items-1]
`T`\[]
table [#table-1]
[`AnyV3Table`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#anyv3table)
options? [#options-1]
`DynamoDBOperationOptions`
Returns [#returns-2]
[`BulkEncryptModelsOperation`](https://cipherstash.com/docs/reference/stack/api-reference/dynamodb#bulkencryptmodelsoperation)\<`T`>
Overrides [#overrides-2]
```ts
DynamoDBOperation<T[]>.constructor
```
Methods [#methods-1]
execute() [#execute-1]
```ts
execute(): Promise<Result<T[], EncryptedDynamoDBError>>;
```
Defined in: [bulk-encrypt-models.ts:41](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/dynamodb/operations/bulk-encrypt-models.ts#L41)
Execute the operation and return a Result
Returns [#returns-3]
`Promise`\<[`Result`](https://www.npmjs.com/package/@byteslice/result)\<`T`\[], [`EncryptedDynamoDBError`](https://cipherstash.com/docs/reference/stack/api-reference/dynamodb#encrypteddynamodberror)>>
Overrides [#overrides-3]
```ts
DynamoDBOperation.execute
```
***
DecryptModelOperation [#decryptmodeloperation]
Defined in: [decrypt-model.ts:24](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/dynamodb/operations/decrypt-model.ts#L24)
Extends [#extends-2]
* `DynamoDBOperation`\<[`Decrypted`](https://cipherstash.com/docs/reference/stack/api-reference/types-public#decrypted)\<`T`>>
Type Parameters [#type-parameters-2]
T [#t-2]
`T` *extends* `Record`\<`string`, `unknown`>
Constructors [#constructors-2]
Constructor [#constructor-2]
```ts
new DecryptModelOperation<T>(
encryptionClient,
item,
table,
readOptions?,
options?): DecryptModelOperation<T>;
```
Defined in: [decrypt-model.ts:32](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/dynamodb/operations/decrypt-model.ts#L32)
Parameters [#parameters-2]
encryptionClient [#encryptionclient-2]
[`DynamoDBEncryptionClient`](https://cipherstash.com/docs/reference/stack/api-reference/dynamodb#dynamodbencryptionclient)
item [#item]
`Record`\<`string`,
\| [`EncryptedValue`](https://cipherstash.com/docs/reference/stack/api-reference/types-public#encryptedvalue)
\| `unknown`>
table [#table-2]
[`AnyV3Table`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#anyv3table)
readOptions? [#readoptions-1]
[`DynamoDBReadOptions`](https://cipherstash.com/docs/reference/stack/api-reference/dynamodb#dynamodbreadoptions) = `{}`
options? [#options-2]
`DynamoDBOperationOptions`
Returns [#returns-4]
[`DecryptModelOperation`](https://cipherstash.com/docs/reference/stack/api-reference/dynamodb#decryptmodeloperation)\<`T`>
Overrides [#overrides-4]
```ts
DynamoDBOperation<Decrypted<T>>.constructor
```
Methods [#methods-2]
execute() [#execute-2]
```ts
execute(): Promise<Result<Decrypted<T>, EncryptedDynamoDBError>>;
```
Defined in: [decrypt-model.ts:46](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/dynamodb/operations/decrypt-model.ts#L46)
Execute the operation and return a Result
Returns [#returns-5]
`Promise`\<[`Result`](https://www.npmjs.com/package/@byteslice/result)\<[`Decrypted`](https://cipherstash.com/docs/reference/stack/api-reference/types-public#decrypted)\<`T`>, [`EncryptedDynamoDBError`](https://cipherstash.com/docs/reference/stack/api-reference/dynamodb#encrypteddynamodberror)>>
Overrides [#overrides-5]
```ts
DynamoDBOperation.execute
```
***
EncryptModelOperation [#encryptmodeloperation]
Defined in: [encrypt-model.ts:22](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/dynamodb/operations/encrypt-model.ts#L22)
Extends [#extends-3]
* `DynamoDBOperation`\<`T`>
Type Parameters [#type-parameters-3]
T [#t-3]
`T` *extends* `Record`\<`string`, `unknown`>
Constructors [#constructors-3]
Constructor [#constructor-3]
```ts
new EncryptModelOperation<T>(
encryptionClient,
item,
table,
options?): EncryptModelOperation<T>;
```
Defined in: [encrypt-model.ts:29](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/dynamodb/operations/encrypt-model.ts#L29)
Parameters [#parameters-3]
encryptionClient [#encryptionclient-3]
[`DynamoDBEncryptionClient`](https://cipherstash.com/docs/reference/stack/api-reference/dynamodb#dynamodbencryptionclient)
item [#item-1]
`T`
table [#table-3]
[`AnyV3Table`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#anyv3table)
options? [#options-3]
`DynamoDBOperationOptions`
Returns [#returns-6]
[`EncryptModelOperation`](https://cipherstash.com/docs/reference/stack/api-reference/dynamodb#encryptmodeloperation)\<`T`>
Overrides [#overrides-6]
```ts
DynamoDBOperation<T>.constructor
```
Methods [#methods-3]
execute() [#execute-3]
```ts
execute(): Promise<Result<T, EncryptedDynamoDBError>>;
```
Defined in: [encrypt-model.ts:41](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/dynamodb/operations/encrypt-model.ts#L41)
Execute the operation and return a Result
Returns [#returns-7]
`Promise`\<[`Result`](https://www.npmjs.com/package/@byteslice/result)\<`T`, [`EncryptedDynamoDBError`](https://cipherstash.com/docs/reference/stack/api-reference/dynamodb#encrypteddynamodberror)>>
Overrides [#overrides-7]
```ts
DynamoDBOperation.execute
```
Interfaces [#interfaces]
EncryptedDynamoDBConfig [#encrypteddynamodbconfig]
Defined in: [types.ts:98](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/dynamodb/types.ts#L98)
Properties [#properties]
encryptionClient [#encryptionclient-4]
```ts
encryptionClient:
| EncryptionClient<readonly AnyV3Table[]>
| DynamoDBEncryptionClient;
```
Defined in: [types.ts:102](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/dynamodb/types.ts#L102)
The client returned by `Encryption(...)` for this table.
options? [#options-4]
```ts
optional options: {
logger?: {
error: (message, error) => void;
};
errorHandler?: (error) => void;
};
```
Defined in: [types.ts:105](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/dynamodb/types.ts#L105)
logger? [#logger]
```ts
optional logger: {
error: (message, error) => void;
};
```
logger.error() [#loggererror]
```ts
error: (message, error) => void;
```
Parameters [#parameters-4]
message [#message]
`string`
error [#error]
`Error`
Returns [#returns-8]
`void`
errorHandler()? [#errorhandler]
```ts
optional errorHandler: (error) => void;
```
Parameters [#parameters-5]
error [#error-1]
[`EncryptedDynamoDBError`](https://cipherstash.com/docs/reference/stack/api-reference/dynamodb#encrypteddynamodberror)
Returns [#returns-9]
`void`
***
EncryptedDynamoDBError [#encrypteddynamodberror]
Defined in: [types.ts:113](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/dynamodb/types.ts#L113)
Extends [#extends-4]
* `Error`
Properties [#properties-1]
code [#code]
```ts
code: ProtectErrorCode | "DYNAMODB_ENCRYPTION_ERROR";
```
Defined in: [types.ts:114](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/dynamodb/types.ts#L114)
details? [#details]
```ts
optional details: Record<string, unknown>;
```
Defined in: [types.ts:115](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/dynamodb/types.ts#L115)
***
EncryptedDynamoDBInstance [#encrypteddynamodbinstance]
Defined in: [types.ts:236](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/dynamodb/types.ts#L236)
Methods [#methods-4]
encryptModel() [#encryptmodel]
```ts
encryptModel<Table, T>(item, table): EncryptModelOperation<Simplify<{ [K in string | number | symbol as K extends keyof V3Columns<Table> & string ? `${K}__source` : K]: K extends keyof V3Columns<Table> ? SourceAttribute<V3Columns<Table>[K]> : T[K] } & { [K in string | number | symbol as K extends keyof V3Columns<Table> & string ? HasSearchTerm<V3Columns<Table>[K]> extends true ? `${K}__hmac` : never : never]?: string }>>;
```
Defined in: [types.ts:241](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/dynamodb/types.ts#L241)
EQL v3: the input model is checked against the table's column types, and
the result is the [EncryptedAttributes](https://cipherstash.com/docs/reference/stack/api-reference/dynamodb#encryptedattributes) storage split.
Type Parameters [#type-parameters-4]
Table [#table-4]
`Table` *extends* [`AnyV3Table`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#anyv3table)
T [#t-4]
`T` *extends* `Record`\<`string`, `unknown`>
Parameters [#parameters-6]
item [#item-2]
[`V3ModelInput`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#v3modelinput)\<`Table`, `T`>
table [#table-5]
`Table`
Returns [#returns-10]
[`EncryptModelOperation`](https://cipherstash.com/docs/reference/stack/api-reference/dynamodb#encryptmodeloperation)\<`Simplify`\<\{ \[K in string | number | symbol as K extends keyof V3Columns\<Table\> & string ? \`$\{K}\_\_source\` : K]: K extends keyof V3Columns\<Table\> ? SourceAttribute\<V3Columns\<Table\>\[K]> : T\[K] } & \{ \[K in string | number | symbol as K extends keyof V3Columns\<Table\> & string ? HasSearchTerm\<V3Columns\<Table\>\[K]> extends true ? \`$\{K}\_\_hmac\` : never : never]?: string }>>
bulkEncryptModels() [#bulkencryptmodels]
```ts
bulkEncryptModels<Table, T>(items, table): BulkEncryptModelsOperation<Simplify<{ [K in string | number | symbol as K extends keyof V3Columns<Table> & string ? `${K}__source` : K]: K extends keyof V3Columns<Table> ? SourceAttribute<V3Columns<Table>[K]> : T[K] } & { [K in string | number | symbol as K extends keyof V3Columns<Table> & string ? HasSearchTerm<V3Columns<Table>[K]> extends true ? `${K}__hmac` : never : never]?: string }>>;
```
Defined in: [types.ts:247](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/dynamodb/types.ts#L247)
EQL v3. See [EncryptedDynamoDBInstance.encryptModel](https://cipherstash.com/docs/reference/stack/api-reference/dynamodb#encryptmodel-1).
Type Parameters [#type-parameters-5]
Table [#table-6]
`Table` *extends* [`AnyV3Table`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#anyv3table)
T [#t-5]
`T` *extends* `Record`\<`string`, `unknown`>
Parameters [#parameters-7]
items [#items-2]
[`V3ModelInput`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#v3modelinput)\<`Table`, `T`>\[]
table [#table-7]
`Table`
Returns [#returns-11]
[`BulkEncryptModelsOperation`](https://cipherstash.com/docs/reference/stack/api-reference/dynamodb#bulkencryptmodelsoperation)\<`Simplify`\<\{ \[K in string | number | symbol as K extends keyof V3Columns\<Table\> & string ? \`$\{K}\_\_source\` : K]: K extends keyof V3Columns\<Table\> ? SourceAttribute\<V3Columns\<Table\>\[K]> : T\[K] } & \{ \[K in string | number | symbol as K extends keyof V3Columns\<Table\> & string ? HasSearchTerm\<V3Columns\<Table\>\[K]> extends true ? \`$\{K}\_\_hmac\` : never : never]?: string }>>
decryptModel() [#decryptmodel]
```ts
decryptModel<Table, T>(
item,
table,
options?): DecryptModelOperation<Simplify<{ [K in string | number | symbol as K extends `${Base}__hmac` ? Base extends keyof V3Columns<Table> ? never : K : K extends `${Base}__source` ? Base extends keyof V3Columns<Table> ? Base : K : K]: K extends `${Base}__source` ? Base extends keyof InferPlaintext<Table> ? InferPlaintext<Table>[Base] : T[K] : T[K] }>>;
```
Defined in: [types.ts:260](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/dynamodb/types.ts#L260)
EQL v3: `item` is the stored attribute map (`<col>__source` /
`<col>__hmac`), and the result is the [DecryptedAttributes](https://cipherstash.com/docs/reference/stack/api-reference/dynamodb#decryptedattributes) plaintext
model it folds back to.
Type Parameters [#type-parameters-6]
Table [#table-8]
`Table` *extends* [`AnyV3Table`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#anyv3table)
T [#t-6]
`T` *extends* `Record`\<`string`, `unknown`>
Parameters [#parameters-8]
item [#item-3]
`T`
table [#table-9]
`Table`
options? [#options-5]
[`DynamoDBReadOptions`](https://cipherstash.com/docs/reference/stack/api-reference/dynamodb#dynamodbreadoptions)
Returns [#returns-12]
[`DecryptModelOperation`](https://cipherstash.com/docs/reference/stack/api-reference/dynamodb#decryptmodeloperation)\<`Simplify`\<\{ \[K in string | number | symbol as K extends \`$\{Base}\_\_hmac\` ? Base extends keyof V3Columns\<Table\> ? never : K : K extends \`$\{Base}\_\_source\` ? Base extends keyof V3Columns\<Table\> ? Base : K : K]: K extends \`$\{Base}\_\_source\` ? Base extends keyof InferPlaintext\<Table\> ? InferPlaintext\<Table\>\[Base] : T\[K] : T\[K] }>>
bulkDecryptModels() [#bulkdecryptmodels]
```ts
bulkDecryptModels<Table, T>(
items,
table,
options?): BulkDecryptModelsOperation<Simplify<{ [K in string | number | symbol as K extends `${Base}__hmac` ? Base extends keyof V3Columns<Table> ? never : K : K extends `${Base}__source` ? Base extends keyof V3Columns<Table> ? Base : K : K]: K extends `${Base}__source` ? Base extends keyof InferPlaintext<Table> ? InferPlaintext<Table>[Base] : T[K] : T[K] }>>;
```
Defined in: [types.ts:267](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/dynamodb/types.ts#L267)
EQL v3. See [EncryptedDynamoDBInstance.decryptModel](https://cipherstash.com/docs/reference/stack/api-reference/dynamodb#decryptmodel-1).
Type Parameters [#type-parameters-7]
Table [#table-10]
`Table` *extends* [`AnyV3Table`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#anyv3table)
T [#t-7]
`T` *extends* `Record`\<`string`, `unknown`>
Parameters [#parameters-9]
items [#items-3]
`T`\[]
table [#table-11]
`Table`
options? [#options-6]
[`DynamoDBReadOptions`](https://cipherstash.com/docs/reference/stack/api-reference/dynamodb#dynamodbreadoptions)
Returns [#returns-13]
[`BulkDecryptModelsOperation`](https://cipherstash.com/docs/reference/stack/api-reference/dynamodb#bulkdecryptmodelsoperation)\<`Simplify`\<\{ \[K in string | number | symbol as K extends \`$\{Base}\_\_hmac\` ? Base extends keyof V3Columns\<Table\> ? never : K : K extends \`$\{Base}\_\_source\` ? Base extends keyof V3Columns\<Table\> ? Base : K : K]: K extends \`$\{Base}\_\_source\` ? Base extends keyof InferPlaintext\<Table\> ? InferPlaintext\<Table\>\[Base] : T\[K] : T\[K] }>>
Type Aliases [#type-aliases]
AuditConfig [#auditconfig]
```ts
type AuditConfig = {
metadata?: Record<string, unknown>;
};
```
Defined in: [base-operation.ts:4](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/dynamodb/operations/base-operation.ts#L4)
Properties [#properties-2]
metadata? [#metadata]
```ts
optional metadata: Record<string, unknown>;
```
Defined in: [base-operation.ts:5](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/dynamodb/operations/base-operation.ts#L5)
***
AnyEncryptedTable [#anyencryptedtable]
```ts
type AnyEncryptedTable = AnyV3Table;
```
Defined in: [types.ts:18](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/dynamodb/types.ts#L18)
An EQL v3 table accepted by every adapter operation.
***
DynamoDBReadOptions [#dynamodbreadoptions]
```ts
type DynamoDBReadOptions = {
storedEqlVersion?: 2 | 3;
};
```
Defined in: [types.ts:20](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/dynamodb/types.ts#L20)
Properties [#properties-3]
storedEqlVersion? [#storedeqlversion]
```ts
optional storedEqlVersion: 2 | 3;
```
Defined in: [types.ts:22](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/dynamodb/types.ts#L22)
Wire generation of the payload before DynamoDB stripped its envelope.
***
DynamoDBEncryptionClient [#dynamodbencryptionclient]
```ts
type DynamoDBEncryptionClient = {
encryptModel: unknown;
bulkEncryptModels: unknown;
decryptModel: unknown;
bulkDecryptModels: unknown;
};
```
Defined in: [types.ts:50](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/dynamodb/types.ts#L50)
The client capability this adapter consumes, declared structurally so it is
satisfied by [EncryptionClient](https://cipherstash.com/docs/reference/stack/api-reference/Package-exports#encryptionclient) and by the WASM client.
Mirrors the approach the Drizzle v3 operators take for the same reason: a
nominal `EncryptionClient<S>` parameter would reject a client built for
a narrower schema tuple.
The NATIVE client returns a chainable operation on every path: its
decrypt-model methods hand back a `MappedDecryptOperation` wrapping the
underlying `DecryptModelOperation`, and both of those carry `.audit()`. The
operation classes handle either shape; see `DecryptModelOperation` and
`resolveDecryptResult`.
The wasm-inline client does not, on EITHER path: its encrypt and decrypt are
plain `async` methods returning a bare `Promise<WasmResult>`, so audit
metadata is dropped (observably — `resolveDecryptResult` and
`resolveEncryptResult` log it). Chaining `.audit()` unconditionally is
therefore a bug, not just a lost audit record; the encrypt path made exactly
that mistake and failed every v3 write on this entry (#788 review follow-up).
Its EQL v2 READ path is supported, however. The legacy read reconstructs the
v2 envelope around the current v3 table and forwards that table like any
other read, so nothing on this entry needs a v2 schema — which is just as
well, since its `Encryption()` rejects one.
Methods [#methods-5]
encryptModel() [#encryptmodel-1]
```ts
encryptModel(input, table): unknown;
```
Defined in: [types.ts:51](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/dynamodb/types.ts#L51)
Parameters [#parameters-10]
input [#input]
`never`
table [#table-12]
`never`
Returns [#returns-14]
`unknown`
bulkEncryptModels() [#bulkencryptmodels-1]
```ts
bulkEncryptModels(input, table): unknown;
```
Defined in: [types.ts:52](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/dynamodb/types.ts#L52)
Parameters [#parameters-11]
input [#input-1]
`never`
table [#table-13]
`never`
Returns [#returns-15]
`unknown`
decryptModel() [#decryptmodel-1]
```ts
decryptModel(input, table): unknown;
```
Defined in: [types.ts:53](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/dynamodb/types.ts#L53)
Parameters [#parameters-12]
input [#input-2]
`never`
table [#table-14]
`never`
Returns [#returns-16]
`unknown`
bulkDecryptModels() [#bulkdecryptmodels-1]
```ts
bulkDecryptModels(input, table): unknown;
```
Defined in: [types.ts:54](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/dynamodb/types.ts#L54)
Parameters [#parameters-13]
input [#input-3]
`never`
table [#table-15]
`never`
Returns [#returns-17]
`unknown`
***
EncryptedAttributes [#encryptedattributes]
```ts
type EncryptedAttributes<Table, T> = Simplify<{ [K in keyof T as K extends keyof V3Columns<Table> & string ? `${K}${CiphertextSuffix}` : K]: K extends keyof V3Columns<Table> ? SourceAttribute<V3Columns<Table>[K]> : T[K] } & { [K in keyof T as K extends keyof V3Columns<Table> & string ? HasSearchTerm<V3Columns<Table>[K]> extends true ? `${K}${SearchTermSuffix}` : never : never]?: string }>;
```
Defined in: [types.ts:192](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/dynamodb/types.ts#L192)
The DynamoDB attribute map `encryptModel` actually returns for a v3 table.
A declared column `email` does NOT survive as `email`: the adapter deletes it
and writes `email__source` (plus `email__hmac` for equality domains). Typing
the result as the input model is a lie that type-checks `result.data.email`
(always `undefined` at runtime) and rejects `result.data.email__source` (the
value you actually want).
Keys that name no column pass through untouched — partition/sort keys, GSI
attributes, anything else on the item.
LIMITATION: a v3 column declared under a dotted path (`'profile.ssn'`) is
split *inside* the nested `profile` map at runtime. The model key is
`profile`, not `profile.ssn`, so it passes through here unchanged and the
nested split is not modelled.
LIMITATION: values inside an ARRAY are not descended into — the write path
skips arrays, so a payload in a list is stored whole rather than split into
`<attr>__source`/`__hmac`. It still decrypts on read, but this mapped type
describes it as its plaintext input shape, not a split. Documented in the
DynamoDB skill's limitations.
Type Parameters [#type-parameters-8]
Table [#table-16]
`Table` *extends* [`AnyV3Table`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#anyv3table)
T [#t-8]
`T`
***
DecryptedAttributes [#decryptedattributes]
```ts
type DecryptedAttributes<Table, T> = Simplify<{ [K in keyof T as K extends `${infer Base}${SearchTermSuffix}` ? Base extends keyof V3Columns<Table> ? never : K : K extends `${infer Base}${CiphertextSuffix}` ? Base extends keyof V3Columns<Table> ? Base : K : K]: K extends `${infer Base}${CiphertextSuffix}` ? Base extends keyof InferPlaintext<Table> ? InferPlaintext<Table>[Base] : T[K] : T[K] }>;
```
Defined in: [types.ts:220](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/dynamodb/types.ts#L220)
The inverse of [EncryptedAttributes](https://cipherstash.com/docs/reference/stack/api-reference/dynamodb#encryptedattributes): the plaintext model
`decryptModel` returns for an item read back out of DynamoDB.
`<col>__source` folds back to `col` with the column's plaintext type,
`<col>__hmac` is dropped (it is a query term, not data), and every other
attribute passes through. Declared this way — rather than taking the
plaintext model as the input parameter — so `T` is inferred from the argument
a caller actually has: the stored attribute map.
Type Parameters [#type-parameters-9]
Table [#table-17]
`Table` *extends* [`AnyV3Table`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#anyv3table)
T [#t-9]
`T`
Functions [#functions]
encryptedDynamoDB() [#encrypteddynamodb]
```ts
function encryptedDynamoDB(config): EncryptedDynamoDBInstance;
```
Defined in: [index.ts:140](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/dynamodb/index.ts#L140)
Create an encrypted DynamoDB helper bound to an `EncryptionClient`.
Returns an object with `encryptModel`, `decryptModel`, `bulkEncryptModels`,
and `bulkDecryptModels` methods that transparently encrypt/decrypt DynamoDB
items according to the provided table schema.
Every operation uses an EQL v3 table. To read attributes stored as EQL v2,
pass `{ storedEqlVersion: 2 }` to a decrypt method; the table still supplies
current column identity and type reconstruction.
Only equality is meaningful on DynamoDB: an `hm` term is stored alongside the
ciphertext as `<attr>__hmac` and can back a key condition. Ordering and
free-text terms have no DynamoDB query surface and are not stored, so values
in those domains remain decryptable but not searchable within DynamoDB.
Parameters [#parameters-14]
config [#config]
[`EncryptedDynamoDBConfig`](https://cipherstash.com/docs/reference/stack/api-reference/dynamodb#encrypteddynamodbconfig)
Configuration containing the `encryptionClient` and optional
logging / error-handling callbacks.
Returns [#returns-18]
[`EncryptedDynamoDBInstance`](https://cipherstash.com/docs/reference/stack/api-reference/dynamodb#encrypteddynamodbinstance)
An [EncryptedDynamoDBInstance](https://cipherstash.com/docs/reference/stack/api-reference/dynamodb#encrypteddynamodbinstance) with encrypt/decrypt operations.
Examples [#examples]
```typescript
import { Encryption } from "@cipherstash/stack"
import { encryptedTable, types } from "@cipherstash/stack/v3"
import { encryptedDynamoDB } from "@cipherstash/stack/dynamodb"
const users = encryptedTable("users", {
email: types.TextEq("email"), // equality → queryable via email__hmac
name: types.Text("name"), // storage only
})
const client = await Encryption({ schemas: [users] })
const dynamo = encryptedDynamoDB({ encryptionClient: client })
const encrypted = await dynamo.encryptModel({ email: "a@b.com" }, users)
```
```typescript
import { Encryption } from "@cipherstash/stack"
import { encryptedTable, types } from "@cipherstash/stack/v3"
import { encryptedDynamoDB } from "@cipherstash/stack/dynamodb"
// The CURRENT v3 table — there is no v2 builder and no v2-mode client. It
// supplies column identity and type reconstruction for the legacy read, so
// keep it declared for as long as v2 items remain in the table.
const users = encryptedTable("users", {
email: types.TextEq("email"),
})
const client = await Encryption({ schemas: [users] })
const dynamo = encryptedDynamoDB({ encryptionClient: client })
// `storedItem` is an item written before the v3 cutover.
const decrypted = await dynamo.decryptModel(storedItem, users, {
storedEqlVersion: 2,
})
```
# encryption
Source: https://cipherstash.com/docs/reference/stack/api-reference/encryption
[**@cipherstash/stack**](./)
***
Classes [#classes]
BatchEncryptQueryOperation [#batchencryptqueryoperation]
Defined in: [batch-encrypt-query.ts:98](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/encryption/operations/batch-encrypt-query.ts#L98)
Extends [#extends]
* `EncryptionOperation`\<[`EncryptedQueryResult`](https://cipherstash.com/docs/reference/stack/api-reference/types-public#encryptedqueryresult)\[]>
Constructors [#constructors]
Constructor [#constructor]
```ts
new BatchEncryptQueryOperation(client, terms): BatchEncryptQueryOperation;
```
Defined in: [batch-encrypt-query.ts:101](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/encryption/operations/batch-encrypt-query.ts#L101)
Parameters [#parameters]
client [#client]
[`Client`](https://cipherstash.com/docs/reference/stack/api-reference/types-public#client)
terms [#terms]
readonly [`ScalarQueryTerm`](https://cipherstash.com/docs/reference/stack/api-reference/types-public#scalarqueryterm)\[]
Returns [#returns]
[`BatchEncryptQueryOperation`](https://cipherstash.com/docs/reference/stack/api-reference/encryption#batchencryptqueryoperation)
Overrides [#overrides]
```ts
EncryptionOperation<
EncryptedQueryResult[]
>.constructor
```
Methods [#methods]
withLockContext() [#withlockcontext]
```ts
withLockContext(lockContext): BatchEncryptQueryOperationWithLockContext;
```
Defined in: [batch-encrypt-query.ts:108](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/encryption/operations/batch-encrypt-query.ts#L108)
Parameters [#parameters-1]
lockContext [#lockcontext]
[`LockContextInput`](https://cipherstash.com/docs/reference/stack/api-reference/identity#lockcontextinput)
Returns [#returns-1]
`BatchEncryptQueryOperationWithLockContext`
execute() [#execute]
```ts
execute(): Promise<Result<EncryptedQueryResult[], EncryptionError>>;
```
Defined in: [batch-encrypt-query.ts:119](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/encryption/operations/batch-encrypt-query.ts#L119)
Execute the operation and return a Result
Returns [#returns-2]
`Promise`\<[`Result`](https://www.npmjs.com/package/@byteslice/result)\<[`EncryptedQueryResult`](https://cipherstash.com/docs/reference/stack/api-reference/types-public#encryptedqueryresult)\[], [`EncryptionError`](https://cipherstash.com/docs/reference/stack/api-reference/errors#encryptionerror-1)>>
Overrides [#overrides-1]
```ts
EncryptionOperation.execute
```
***
BulkDecryptModelsOperation [#bulkdecryptmodelsoperation]
Defined in: [bulk-decrypt-models.ts:14](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/encryption/operations/bulk-decrypt-models.ts#L14)
Extends [#extends-1]
* `EncryptionOperation`\<[`Decrypted`](https://cipherstash.com/docs/reference/stack/api-reference/types-public#decrypted)\<`T`>\[]>
Type Parameters [#type-parameters]
T [#t]
`T` *extends* `Record`\<`string`, `unknown`>
Constructors [#constructors-1]
Constructor [#constructor-1]
```ts
new BulkDecryptModelsOperation<T>(client, models): BulkDecryptModelsOperation<T>;
```
Defined in: [bulk-decrypt-models.ts:20](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/encryption/operations/bulk-decrypt-models.ts#L20)
Parameters [#parameters-2]
client [#client-1]
[`Client`](https://cipherstash.com/docs/reference/stack/api-reference/types-public#client)
models [#models]
`T`\[]
Returns [#returns-3]
[`BulkDecryptModelsOperation`](https://cipherstash.com/docs/reference/stack/api-reference/encryption#bulkdecryptmodelsoperation)\<`T`>
Overrides [#overrides-2]
```ts
EncryptionOperation<Decrypted<T>[]>.constructor
```
Methods [#methods-1]
withLockContext() [#withlockcontext-1]
```ts
withLockContext(lockContext): BulkDecryptModelsOperationWithLockContext<T>;
```
Defined in: [bulk-decrypt-models.ts:26](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/encryption/operations/bulk-decrypt-models.ts#L26)
Parameters [#parameters-3]
lockContext [#lockcontext-1]
[`LockContextInput`](https://cipherstash.com/docs/reference/stack/api-reference/identity#lockcontextinput)
Returns [#returns-4]
`BulkDecryptModelsOperationWithLockContext`\<`T`>
execute() [#execute-1]
```ts
execute(): Promise<Result<Decrypted<T>[], EncryptionError>>;
```
Defined in: [bulk-decrypt-models.ts:32](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/encryption/operations/bulk-decrypt-models.ts#L32)
Execute the operation and return a Result
Returns [#returns-5]
`Promise`\<[`Result`](https://www.npmjs.com/package/@byteslice/result)\<[`Decrypted`](https://cipherstash.com/docs/reference/stack/api-reference/types-public#decrypted)\<`T`>\[], [`EncryptionError`](https://cipherstash.com/docs/reference/stack/api-reference/errors#encryptionerror-1)>>
Overrides [#overrides-3]
```ts
EncryptionOperation.execute
```
getOperation() [#getoperation]
```ts
getOperation(): {
client: Client;
models: T[];
};
```
Defined in: [bulk-decrypt-models.ts:63](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/encryption/operations/bulk-decrypt-models.ts#L63)
Returns [#returns-6]
```ts
{
client: Client;
models: T[];
}
```
client [#client-2]
```ts
client: Client;
```
models [#models-1]
```ts
models: T[];
```
***
BulkDecryptOperation [#bulkdecryptoperation]
Defined in: [bulk-decrypt.ts:60](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/encryption/operations/bulk-decrypt.ts#L60)
Extends [#extends-2]
* `EncryptionOperation`\<[`BulkDecryptedData`](https://cipherstash.com/docs/reference/stack/api-reference/types-public#bulkdecrypteddata)>
Constructors [#constructors-2]
Constructor [#constructor-2]
```ts
new BulkDecryptOperation(client, encryptedPayloads): BulkDecryptOperation;
```
Defined in: [bulk-decrypt.ts:64](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/encryption/operations/bulk-decrypt.ts#L64)
Parameters [#parameters-4]
client [#client-3]
[`Client`](https://cipherstash.com/docs/reference/stack/api-reference/types-public#client)
encryptedPayloads [#encryptedpayloads]
[`BulkDecryptPayload`](https://cipherstash.com/docs/reference/stack/api-reference/types-public#bulkdecryptpayload)
Returns [#returns-7]
[`BulkDecryptOperation`](https://cipherstash.com/docs/reference/stack/api-reference/encryption#bulkdecryptoperation)
Overrides [#overrides-4]
```ts
EncryptionOperation<BulkDecryptedData>.constructor
```
Methods [#methods-2]
withLockContext() [#withlockcontext-2]
```ts
withLockContext(lockContext): BulkDecryptOperationWithLockContext;
```
Defined in: [bulk-decrypt.ts:70](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/encryption/operations/bulk-decrypt.ts#L70)
Parameters [#parameters-5]
lockContext [#lockcontext-2]
[`LockContextInput`](https://cipherstash.com/docs/reference/stack/api-reference/identity#lockcontextinput)
Returns [#returns-8]
`BulkDecryptOperationWithLockContext`
execute() [#execute-2]
```ts
execute(): Promise<Result<BulkDecryptedData, EncryptionError>>;
```
Defined in: [bulk-decrypt.ts:76](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/encryption/operations/bulk-decrypt.ts#L76)
Execute the operation and return a Result
Returns [#returns-9]
`Promise`\<[`Result`](https://www.npmjs.com/package/@byteslice/result)\<[`BulkDecryptedData`](https://cipherstash.com/docs/reference/stack/api-reference/types-public#bulkdecrypteddata), [`EncryptionError`](https://cipherstash.com/docs/reference/stack/api-reference/errors#encryptionerror-1)>>
Overrides [#overrides-5]
```ts
EncryptionOperation.execute
```
getOperation() [#getoperation-1]
```ts
getOperation(): {
client: Client;
encryptedPayloads: BulkDecryptPayload;
};
```
Defined in: [bulk-decrypt.ts:118](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/encryption/operations/bulk-decrypt.ts#L118)
Returns [#returns-10]
```ts
{
client: Client;
encryptedPayloads: BulkDecryptPayload;
}
```
client [#client-4]
```ts
client: Client;
```
encryptedPayloads [#encryptedpayloads-1]
```ts
encryptedPayloads: BulkDecryptPayload;
```
***
BulkEncryptModelsOperation [#bulkencryptmodelsoperation]
Defined in: [bulk-encrypt-models.ts:14](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/encryption/operations/bulk-encrypt-models.ts#L14)
Extends [#extends-3]
* `EncryptionOperation`\<`T`\[]>
Type Parameters [#type-parameters-1]
T [#t-1]
`T` *extends* `Record`\<`string`, `unknown`>
Constructors [#constructors-3]
Constructor [#constructor-3]
```ts
new BulkEncryptModelsOperation<T>(
client,
models,
table): BulkEncryptModelsOperation<T>;
```
Defined in: [bulk-encrypt-models.ts:21](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/encryption/operations/bulk-encrypt-models.ts#L21)
Parameters [#parameters-6]
client [#client-5]
[`Client`](https://cipherstash.com/docs/reference/stack/api-reference/types-public#client)
models [#models-2]
`Record`\<`string`, `unknown`>\[]
table [#table]
`BuildableTable`
Returns [#returns-11]
[`BulkEncryptModelsOperation`](https://cipherstash.com/docs/reference/stack/api-reference/encryption#bulkencryptmodelsoperation)\<`T`>
Overrides [#overrides-6]
```ts
EncryptionOperation<T[]>.constructor
```
Methods [#methods-3]
withLockContext() [#withlockcontext-3]
```ts
withLockContext(lockContext): BulkEncryptModelsOperationWithLockContext<T>;
```
Defined in: [bulk-encrypt-models.ts:32](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/encryption/operations/bulk-encrypt-models.ts#L32)
Parameters [#parameters-7]
lockContext [#lockcontext-3]
[`LockContextInput`](https://cipherstash.com/docs/reference/stack/api-reference/identity#lockcontextinput)
Returns [#returns-12]
`BulkEncryptModelsOperationWithLockContext`\<`T`>
execute() [#execute-3]
```ts
execute(): Promise<Result<T[], EncryptionError>>;
```
Defined in: [bulk-encrypt-models.ts:38](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/encryption/operations/bulk-encrypt-models.ts#L38)
Execute the operation and return a Result
Returns [#returns-13]
`Promise`\<[`Result`](https://www.npmjs.com/package/@byteslice/result)\<`T`\[], [`EncryptionError`](https://cipherstash.com/docs/reference/stack/api-reference/errors#encryptionerror-1)>>
Overrides [#overrides-7]
```ts
EncryptionOperation.execute
```
getOperation() [#getoperation-2]
```ts
getOperation(): {
client: Client;
models: Record<string, unknown>[];
table: BuildableTable;
};
```
Defined in: [bulk-encrypt-models.ts:75](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/encryption/operations/bulk-encrypt-models.ts#L75)
Returns [#returns-14]
```ts
{
client: Client;
models: Record<string, unknown>[];
table: BuildableTable;
}
```
client [#client-6]
```ts
client: Client;
```
models [#models-3]
```ts
models: Record<string, unknown>[];
```
table [#table-1]
```ts
table: BuildableTable;
```
***
BulkEncryptOperation [#bulkencryptoperation]
Defined in: [bulk-encrypt.ts:73](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/encryption/operations/bulk-encrypt.ts#L73)
Extends [#extends-4]
* `EncryptionOperation`\<[`BulkEncryptedData`](https://cipherstash.com/docs/reference/stack/api-reference/types-public#bulkencrypteddata)>
Constructors [#constructors-4]
Constructor [#constructor-4]
```ts
new BulkEncryptOperation(
client,
plaintexts,
opts): BulkEncryptOperation;
```
Defined in: [bulk-encrypt.ts:79](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/encryption/operations/bulk-encrypt.ts#L79)
Parameters [#parameters-8]
client [#client-7]
[`Client`](https://cipherstash.com/docs/reference/stack/api-reference/types-public#client)
plaintexts [#plaintexts]
[`BulkEncryptPayload`](https://cipherstash.com/docs/reference/stack/api-reference/types-public#bulkencryptpayload)
opts [#opts]
[`EncryptOptions`](https://cipherstash.com/docs/reference/stack/api-reference/types-public#encryptoptions)
Returns [#returns-15]
[`BulkEncryptOperation`](https://cipherstash.com/docs/reference/stack/api-reference/encryption#bulkencryptoperation)
Overrides [#overrides-8]
```ts
EncryptionOperation<BulkEncryptedData>.constructor
```
Methods [#methods-4]
withLockContext() [#withlockcontext-4]
```ts
withLockContext(lockContext): BulkEncryptOperationWithLockContext;
```
Defined in: [bulk-encrypt.ts:91](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/encryption/operations/bulk-encrypt.ts#L91)
Parameters [#parameters-9]
lockContext [#lockcontext-4]
[`LockContextInput`](https://cipherstash.com/docs/reference/stack/api-reference/identity#lockcontextinput)
Returns [#returns-16]
`BulkEncryptOperationWithLockContext`
execute() [#execute-4]
```ts
execute(): Promise<Result<BulkEncryptedData, EncryptionError>>;
```
Defined in: [bulk-encrypt.ts:97](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/encryption/operations/bulk-encrypt.ts#L97)
Execute the operation and return a Result
Returns [#returns-17]
`Promise`\<[`Result`](https://www.npmjs.com/package/@byteslice/result)\<[`BulkEncryptedData`](https://cipherstash.com/docs/reference/stack/api-reference/types-public#bulkencrypteddata), [`EncryptionError`](https://cipherstash.com/docs/reference/stack/api-reference/errors#encryptionerror-1)>>
Overrides [#overrides-9]
```ts
EncryptionOperation.execute
```
getOperation() [#getoperation-3]
```ts
getOperation(): {
client: Client;
plaintexts: BulkEncryptPayload;
column: BuildableColumn;
table: BuildableTable;
};
```
Defined in: [bulk-encrypt.ts:148](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/encryption/operations/bulk-encrypt.ts#L148)
Returns [#returns-18]
```ts
{
client: Client;
plaintexts: BulkEncryptPayload;
column: BuildableColumn;
table: BuildableTable;
}
```
client [#client-8]
```ts
client: Client;
```
plaintexts [#plaintexts-1]
```ts
plaintexts: BulkEncryptPayload;
```
column [#column]
```ts
column: BuildableColumn;
```
table [#table-2]
```ts
table: BuildableTable;
```
***
DecryptModelOperation [#decryptmodeloperation]
Defined in: [decrypt-model.ts:14](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/encryption/operations/decrypt-model.ts#L14)
Extends [#extends-5]
* `EncryptionOperation`\<[`Decrypted`](https://cipherstash.com/docs/reference/stack/api-reference/types-public#decrypted)\<`T`>>
Type Parameters [#type-parameters-2]
T [#t-2]
`T` *extends* `Record`\<`string`, `unknown`>
Constructors [#constructors-5]
Constructor [#constructor-5]
```ts
new DecryptModelOperation<T>(client, model): DecryptModelOperation<T>;
```
Defined in: [decrypt-model.ts:20](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/encryption/operations/decrypt-model.ts#L20)
Parameters [#parameters-10]
client [#client-9]
[`Client`](https://cipherstash.com/docs/reference/stack/api-reference/types-public#client)
model [#model]
`T`
Returns [#returns-19]
[`DecryptModelOperation`](https://cipherstash.com/docs/reference/stack/api-reference/encryption#decryptmodeloperation)\<`T`>
Overrides [#overrides-10]
```ts
EncryptionOperation<Decrypted<T>>.constructor
```
Methods [#methods-5]
withLockContext() [#withlockcontext-5]
```ts
withLockContext(lockContext): DecryptModelOperationWithLockContext<T>;
```
Defined in: [decrypt-model.ts:26](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/encryption/operations/decrypt-model.ts#L26)
Parameters [#parameters-11]
lockContext [#lockcontext-5]
[`LockContextInput`](https://cipherstash.com/docs/reference/stack/api-reference/identity#lockcontextinput)
Returns [#returns-20]
`DecryptModelOperationWithLockContext`\<`T`>
execute() [#execute-5]
```ts
execute(): Promise<Result<Decrypted<T>, EncryptionError>>;
```
Defined in: [decrypt-model.ts:32](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/encryption/operations/decrypt-model.ts#L32)
Execute the operation and return a Result
Returns [#returns-21]
`Promise`\<[`Result`](https://www.npmjs.com/package/@byteslice/result)\<[`Decrypted`](https://cipherstash.com/docs/reference/stack/api-reference/types-public#decrypted)\<`T`>, [`EncryptionError`](https://cipherstash.com/docs/reference/stack/api-reference/errors#encryptionerror-1)>>
Overrides [#overrides-11]
```ts
EncryptionOperation.execute
```
getOperation() [#getoperation-4]
```ts
getOperation(): {
client: Client;
model: T;
};
```
Defined in: [decrypt-model.ts:62](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/encryption/operations/decrypt-model.ts#L62)
Returns [#returns-22]
```ts
{
client: Client;
model: T;
}
```
client [#client-10]
```ts
client: Client;
```
model [#model-1]
```ts
model: T;
```
***
DecryptOperation [#decryptoperation]
Defined in: [decrypt.ts:18](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/encryption/operations/decrypt.ts#L18)
Decrypts an encrypted payload using the provided client.
This is the type returned by the [decrypt](https://cipherstash.com/docs/reference/stack/api-reference/Package-exports#decrypt) method of the [EncryptionClient](https://cipherstash.com/docs/reference/stack/api-reference/Package-exports#encryptionclient).
Extends [#extends-6]
* `EncryptionOperation`\<`JsPlaintext`>
Constructors [#constructors-6]
Constructor [#constructor-6]
```ts
new DecryptOperation(client, encryptedData): DecryptOperation;
```
Defined in: [decrypt.ts:26](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/encryption/operations/decrypt.ts#L26)
Parameters [#parameters-12]
client [#client-11]
[`Client`](https://cipherstash.com/docs/reference/stack/api-reference/types-public#client)
encryptedData [#encrypteddata]
`EncryptedPayload` | `null`
Returns [#returns-23]
[`DecryptOperation`](https://cipherstash.com/docs/reference/stack/api-reference/encryption#decryptoperation)
Overrides [#overrides-12]
```ts
EncryptionOperation<JsPlaintext>.constructor
```
Methods [#methods-6]
withLockContext() [#withlockcontext-6]
```ts
withLockContext(lockContext): DecryptOperationWithLockContext;
```
Defined in: [decrypt.ts:32](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/encryption/operations/decrypt.ts#L32)
Parameters [#parameters-13]
lockContext [#lockcontext-6]
[`LockContextInput`](https://cipherstash.com/docs/reference/stack/api-reference/identity#lockcontextinput)
Returns [#returns-24]
`DecryptOperationWithLockContext`
execute() [#execute-6]
```ts
execute(): Promise<Result<JsPlaintext, EncryptionError>>;
```
Defined in: [decrypt.ts:38](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/encryption/operations/decrypt.ts#L38)
Execute the operation and return a Result
Returns [#returns-25]
`Promise`\<[`Result`](https://www.npmjs.com/package/@byteslice/result)\<`JsPlaintext`, [`EncryptionError`](https://cipherstash.com/docs/reference/stack/api-reference/errors#encryptionerror-1)>>
Overrides [#overrides-13]
```ts
EncryptionOperation.execute
```
getOperation() [#getoperation-5]
```ts
getOperation(): {
client: Client;
encryptedData: EncryptedPayload | null;
auditData?: Record<string, unknown>;
};
```
Defined in: [decrypt.ts:76](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/encryption/operations/decrypt.ts#L76)
Returns [#returns-26]
```ts
{
client: Client;
encryptedData: EncryptedPayload | null;
auditData?: Record<string, unknown>;
}
```
client [#client-12]
```ts
client: Client;
```
encryptedData [#encrypteddata-1]
```ts
encryptedData: EncryptedPayload | null;
```
auditData? [#auditdata]
```ts
optional auditData: Record<string, unknown>;
```
***
EncryptModelOperation [#encryptmodeloperation]
Defined in: [encrypt-model.ts:14](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/encryption/operations/encrypt-model.ts#L14)
Extends [#extends-7]
* `EncryptionOperation`\<`T`>
Type Parameters [#type-parameters-3]
T [#t-3]
`T` *extends* `Record`\<`string`, `unknown`>
Constructors [#constructors-7]
Constructor [#constructor-7]
```ts
new EncryptModelOperation<T>(
client,
model,
table): EncryptModelOperation<T>;
```
Defined in: [encrypt-model.ts:21](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/encryption/operations/encrypt-model.ts#L21)
Parameters [#parameters-14]
client [#client-13]
[`Client`](https://cipherstash.com/docs/reference/stack/api-reference/types-public#client)
model [#model-2]
`Record`\<`string`, `unknown`>
table [#table-3]
`BuildableTable`
Returns [#returns-27]
[`EncryptModelOperation`](https://cipherstash.com/docs/reference/stack/api-reference/encryption#encryptmodeloperation)\<`T`>
Overrides [#overrides-14]
```ts
EncryptionOperation<T>.constructor
```
Methods [#methods-7]
withLockContext() [#withlockcontext-7]
```ts
withLockContext(lockContext): EncryptModelOperationWithLockContext<T>;
```
Defined in: [encrypt-model.ts:32](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/encryption/operations/encrypt-model.ts#L32)
Parameters [#parameters-15]
lockContext [#lockcontext-7]
[`LockContextInput`](https://cipherstash.com/docs/reference/stack/api-reference/identity#lockcontextinput)
Returns [#returns-28]
`EncryptModelOperationWithLockContext`\<`T`>
execute() [#execute-7]
```ts
execute(): Promise<Result<T, EncryptionError>>;
```
Defined in: [encrypt-model.ts:38](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/encryption/operations/encrypt-model.ts#L38)
Execute the operation and return a Result
Returns [#returns-29]
`Promise`\<[`Result`](https://www.npmjs.com/package/@byteslice/result)\<`T`, [`EncryptionError`](https://cipherstash.com/docs/reference/stack/api-reference/errors#encryptionerror-1)>>
Overrides [#overrides-15]
```ts
EncryptionOperation.execute
```
getOperation() [#getoperation-6]
```ts
getOperation(): {
client: Client;
model: Record<string, unknown>;
table: BuildableTable;
};
```
Defined in: [encrypt-model.ts:74](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/encryption/operations/encrypt-model.ts#L74)
Returns [#returns-30]
```ts
{
client: Client;
model: Record<string, unknown>;
table: BuildableTable;
}
```
client [#client-14]
```ts
client: Client;
```
model [#model-3]
```ts
model: Record<string, unknown>;
```
table [#table-4]
```ts
table: BuildableTable;
```
***
EncryptQueryOperation [#encryptqueryoperation]
Defined in: [encrypt-query.ts:26](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/encryption/operations/encrypt-query.ts#L26)
Extends [#extends-8]
* `EncryptionOperation`\<[`EncryptedQueryResult`](https://cipherstash.com/docs/reference/stack/api-reference/types-public#encryptedqueryresult)>
Constructors [#constructors-8]
Constructor [#constructor-8]
```ts
new EncryptQueryOperation(
client,
plaintext,
opts): EncryptQueryOperation;
```
Defined in: [encrypt-query.ts:27](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/encryption/operations/encrypt-query.ts#L27)
Parameters [#parameters-16]
client [#client-15]
[`Client`](https://cipherstash.com/docs/reference/stack/api-reference/types-public#client)
plaintext [#plaintext]
`Plaintext` | `null` | `undefined`
opts [#opts-1]
`QueryTermBase`
Returns [#returns-31]
[`EncryptQueryOperation`](https://cipherstash.com/docs/reference/stack/api-reference/encryption#encryptqueryoperation)
Overrides [#overrides-16]
```ts
EncryptionOperation<EncryptedQueryResult>.constructor
```
Methods [#methods-8]
withLockContext() [#withlockcontext-8]
```ts
withLockContext(lockContext): EncryptQueryOperationWithLockContext;
```
Defined in: [encrypt-query.ts:35](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/encryption/operations/encrypt-query.ts#L35)
Parameters [#parameters-17]
lockContext [#lockcontext-8]
[`LockContextInput`](https://cipherstash.com/docs/reference/stack/api-reference/identity#lockcontextinput)
Returns [#returns-32]
`EncryptQueryOperationWithLockContext`
execute() [#execute-8]
```ts
execute(): Promise<Result<EncryptedQueryResult, EncryptionError>>;
```
Defined in: [encrypt-query.ts:47](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/encryption/operations/encrypt-query.ts#L47)
Execute the operation and return a Result
Returns [#returns-33]
`Promise`\<[`Result`](https://www.npmjs.com/package/@byteslice/result)\<[`EncryptedQueryResult`](https://cipherstash.com/docs/reference/stack/api-reference/types-public#encryptedqueryresult), [`EncryptionError`](https://cipherstash.com/docs/reference/stack/api-reference/errors#encryptionerror-1)>>
Overrides [#overrides-17]
```ts
EncryptionOperation.execute
```
getOperation() [#getoperation-7]
```ts
getOperation(): {
client: Client;
plaintext: Plaintext | null | undefined;
column: BuildableQueryColumn;
table: BuildableTable;
queryType?: QueryTypeName;
returnType?: EncryptedReturnType;
};
```
Defined in: [encrypt-query.ts:119](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/encryption/operations/encrypt-query.ts#L119)
Returns [#returns-34]
```ts
{
client: Client;
plaintext: Plaintext | null | undefined;
column: BuildableQueryColumn;
table: BuildableTable;
queryType?: QueryTypeName;
returnType?: EncryptedReturnType;
}
```
client [#client-16]
```ts
client: Client;
```
plaintext [#plaintext-1]
```ts
plaintext: Plaintext | null | undefined;
```
column [#column-1]
```ts
column: BuildableQueryColumn;
```
table [#table-5]
```ts
table: BuildableTable;
```
queryType? [#querytype]
```ts
optional queryType: QueryTypeName;
```
returnType? [#returntype]
```ts
optional returnType: EncryptedReturnType;
```
***
EncryptOperation [#encryptoperation]
Defined in: [encrypt.ts:22](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/encryption/operations/encrypt.ts#L22)
Extends [#extends-9]
* `EncryptionOperation`\<[`Encrypted`](https://cipherstash.com/docs/reference/stack/api-reference/Package-exports#encrypted)>
Constructors [#constructors-9]
Constructor [#constructor-9]
```ts
new EncryptOperation(
client,
plaintext,
opts): EncryptOperation;
```
Defined in: [encrypt.ts:32](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/encryption/operations/encrypt.ts#L32)
Parameters [#parameters-18]
client [#client-17]
[`Client`](https://cipherstash.com/docs/reference/stack/api-reference/types-public#client)
plaintext [#plaintext-2]
`Plaintext` | `null`
opts [#opts-2]
[`EncryptOptions`](https://cipherstash.com/docs/reference/stack/api-reference/types-public#encryptoptions)
Returns [#returns-35]
[`EncryptOperation`](https://cipherstash.com/docs/reference/stack/api-reference/encryption#encryptoperation)
Overrides [#overrides-18]
```ts
EncryptionOperation<Encrypted>.constructor
```
Methods [#methods-9]
withLockContext() [#withlockcontext-9]
```ts
withLockContext(lockContext): EncryptOperationWithLockContext;
```
Defined in: [encrypt.ts:44](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/encryption/operations/encrypt.ts#L44)
Parameters [#parameters-19]
lockContext [#lockcontext-9]
[`LockContextInput`](https://cipherstash.com/docs/reference/stack/api-reference/identity#lockcontextinput)
Returns [#returns-36]
`EncryptOperationWithLockContext`
execute() [#execute-9]
```ts
execute(): Promise<Result<EncryptedPayload, EncryptionError>>;
```
Defined in: [encrypt.ts:50](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/encryption/operations/encrypt.ts#L50)
Execute the operation and return a Result
Returns [#returns-37]
`Promise`\<[`Result`](https://www.npmjs.com/package/@byteslice/result)\<`EncryptedPayload`, [`EncryptionError`](https://cipherstash.com/docs/reference/stack/api-reference/errors#encryptionerror-1)>>
Overrides [#overrides-19]
```ts
EncryptionOperation.execute
```
getOperation() [#getoperation-8]
```ts
getOperation(): {
client: Client;
plaintext: Plaintext | null;
column: BuildableColumn;
table: BuildableTable;
};
```
Defined in: [encrypt.ts:102](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/encryption/operations/encrypt.ts#L102)
Returns [#returns-38]
```ts
{
client: Client;
plaintext: Plaintext | null;
column: BuildableColumn;
table: BuildableTable;
}
```
client [#client-18]
```ts
client: Client;
```
plaintext [#plaintext-3]
```ts
plaintext: Plaintext | null;
```
column [#column-2]
```ts
column: BuildableColumn;
```
table [#table-6]
```ts
table: BuildableTable;
```
Functions [#functions]
noClientError() [#noclienterror]
```ts
function noClientError(): Error;
```
Defined in: [index.ts:64](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/encryption/index.ts#L64)
Returns [#returns-39]
`Error`
***
Encryption() [#encryption]
Call Signature [#call-signature]
```ts
function Encryption<S>(config): Promise<EncryptionClient<S>>;
```
Defined in: [index.ts:870](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/encryption/index.ts#L870)
Type Parameters [#type-parameters-4]
S [#s]
`S` *extends* readonly \[[`AnyV3Table`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#anyv3table), [`AnyV3Table`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#anyv3table)]
Parameters [#parameters-20]
config [#config]
schemas [#schemas]
`S`
config? [#config-1]
[`ClientConfig`](https://cipherstash.com/docs/reference/stack/api-reference/types-public#clientconfig)
Returns [#returns-40]
`Promise`\<[`EncryptionClient`](https://cipherstash.com/docs/reference/stack/api-reference/Package-exports#encryptionclient)\<`S`>>
Call Signature [#call-signature-1]
```ts
function Encryption<S>(config): Promise<EncryptionClient<S>>;
```
Defined in: [index.ts:873](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/encryption/index.ts#L873)
Type Parameters [#type-parameters-5]
S [#s-1]
`S` *extends* readonly [`AnyV3Table`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#anyv3table)\[]
Parameters [#parameters-21]
config [#config-2]
schemas [#schemas-1]
`NonEmptyV3`\<`S`>
config? [#config-3]
[`ClientConfig`](https://cipherstash.com/docs/reference/stack/api-reference/types-public#clientconfig)
Returns [#returns-41]
`Promise`\<[`EncryptionClient`](https://cipherstash.com/docs/reference/stack/api-reference/Package-exports#encryptionclient)\<`S`>>
References [#references]
EncryptionClient [#encryptionclient]
Re-exports [EncryptionClient](https://cipherstash.com/docs/reference/stack/api-reference/Package-exports#encryptionclient)
# encryption/v3
Source: https://cipherstash.com/docs/reference/stack/api-reference/encryption.v3
[**@cipherstash/stack**](./)
***
References [#references]
EncryptionClient [#encryptionclient]
Re-exports [EncryptionClient](https://cipherstash.com/docs/reference/stack/api-reference/Package-exports#encryptionclient)
***
Encryption [#encryption]
Re-exports [Encryption](https://cipherstash.com/docs/reference/stack/api-reference/encryption#encryption)
***
AnyEncryptedV3Column [#anyencryptedv3column]
Re-exports [AnyEncryptedV3Column](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#anyencryptedv3column)
***
EncryptedV3TableColumn [#encryptedv3tablecolumn]
Re-exports [EncryptedV3TableColumn](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptedv3tablecolumn)
***
EqlTypeForColumn [#eqltypeforcolumn]
Re-exports [EqlTypeForColumn](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#eqltypeforcolumn)
***
JsonDocument [#jsondocument]
Re-exports [JsonDocument](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#jsondocument)
***
JsonValue [#jsonvalue]
Re-exports [JsonValue](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#jsonvalue)
***
PlaintextForColumn [#plaintextforcolumn]
Re-exports [PlaintextForColumn](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#plaintextforcolumn)
***
QueryCapabilities [#querycapabilities]
Re-exports [QueryCapabilities](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#querycapabilities)
***
QueryTypesForColumn [#querytypesforcolumn]
Re-exports [QueryTypesForColumn](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#querytypesforcolumn)
***
EncryptedBigintColumn [#encryptedbigintcolumn]
Re-exports [EncryptedBigintColumn](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptedbigintcolumn)
***
EncryptedBigintEqColumn [#encryptedbiginteqcolumn]
Re-exports [EncryptedBigintEqColumn](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptedbiginteqcolumn)
***
EncryptedBigintOrdColumn [#encryptedbigintordcolumn]
Re-exports [EncryptedBigintOrdColumn](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptedbigintordcolumn)
***
EncryptedBigintOrdOreColumn [#encryptedbigintordorecolumn]
Re-exports [EncryptedBigintOrdOreColumn](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptedbigintordorecolumn)
***
EncryptedBooleanColumn [#encryptedbooleancolumn]
Re-exports [EncryptedBooleanColumn](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptedbooleancolumn)
***
EncryptedDateColumn [#encrypteddatecolumn]
Re-exports [EncryptedDateColumn](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encrypteddatecolumn)
***
EncryptedDateEqColumn [#encrypteddateeqcolumn]
Re-exports [EncryptedDateEqColumn](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encrypteddateeqcolumn)
***
EncryptedDateOrdColumn [#encrypteddateordcolumn]
Re-exports [EncryptedDateOrdColumn](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encrypteddateordcolumn)
***
EncryptedDateOrdOreColumn [#encrypteddateordorecolumn]
Re-exports [EncryptedDateOrdOreColumn](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encrypteddateordorecolumn)
***
EncryptedDoubleColumn [#encrypteddoublecolumn]
Re-exports [EncryptedDoubleColumn](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encrypteddoublecolumn)
***
EncryptedDoubleEqColumn [#encrypteddoubleeqcolumn]
Re-exports [EncryptedDoubleEqColumn](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encrypteddoubleeqcolumn)
***
EncryptedDoubleOrdColumn [#encrypteddoubleordcolumn]
Re-exports [EncryptedDoubleOrdColumn](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encrypteddoubleordcolumn)
***
EncryptedDoubleOrdOreColumn [#encrypteddoubleordorecolumn]
Re-exports [EncryptedDoubleOrdOreColumn](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encrypteddoubleordorecolumn)
***
EncryptedIntegerColumn [#encryptedintegercolumn]
Re-exports [EncryptedIntegerColumn](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptedintegercolumn)
***
EncryptedIntegerEqColumn [#encryptedintegereqcolumn]
Re-exports [EncryptedIntegerEqColumn](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptedintegereqcolumn)
***
EncryptedIntegerOrdColumn [#encryptedintegerordcolumn]
Re-exports [EncryptedIntegerOrdColumn](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptedintegerordcolumn)
***
EncryptedIntegerOrdOreColumn [#encryptedintegerordorecolumn]
Re-exports [EncryptedIntegerOrdOreColumn](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptedintegerordorecolumn)
***
EncryptedJsonColumn [#encryptedjsoncolumn]
Re-exports [EncryptedJsonColumn](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptedjsoncolumn)
***
EncryptedNumericColumn [#encryptednumericcolumn]
Re-exports [EncryptedNumericColumn](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptednumericcolumn)
***
EncryptedNumericEqColumn [#encryptednumericeqcolumn]
Re-exports [EncryptedNumericEqColumn](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptednumericeqcolumn)
***
EncryptedNumericOrdColumn [#encryptednumericordcolumn]
Re-exports [EncryptedNumericOrdColumn](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptednumericordcolumn)
***
EncryptedNumericOrdOreColumn [#encryptednumericordorecolumn]
Re-exports [EncryptedNumericOrdOreColumn](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptednumericordorecolumn)
***
EncryptedRealColumn [#encryptedrealcolumn]
Re-exports [EncryptedRealColumn](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptedrealcolumn)
***
EncryptedRealEqColumn [#encryptedrealeqcolumn]
Re-exports [EncryptedRealEqColumn](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptedrealeqcolumn)
***
EncryptedRealOrdColumn [#encryptedrealordcolumn]
Re-exports [EncryptedRealOrdColumn](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptedrealordcolumn)
***
EncryptedRealOrdOreColumn [#encryptedrealordorecolumn]
Re-exports [EncryptedRealOrdOreColumn](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptedrealordorecolumn)
***
EncryptedSmallintColumn [#encryptedsmallintcolumn]
Re-exports [EncryptedSmallintColumn](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptedsmallintcolumn)
***
EncryptedSmallintEqColumn [#encryptedsmallinteqcolumn]
Re-exports [EncryptedSmallintEqColumn](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptedsmallinteqcolumn)
***
EncryptedSmallintOrdColumn [#encryptedsmallintordcolumn]
Re-exports [EncryptedSmallintOrdColumn](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptedsmallintordcolumn)
***
EncryptedSmallintOrdOreColumn [#encryptedsmallintordorecolumn]
Re-exports [EncryptedSmallintOrdOreColumn](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptedsmallintordorecolumn)
***
EncryptedTextColumn [#encryptedtextcolumn]
Re-exports [EncryptedTextColumn](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptedtextcolumn)
***
EncryptedTextEqColumn [#encryptedtexteqcolumn]
Re-exports [EncryptedTextEqColumn](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptedtexteqcolumn)
***
EncryptedTextMatchColumn [#encryptedtextmatchcolumn]
Re-exports [EncryptedTextMatchColumn](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptedtextmatchcolumn)
***
EncryptedTextOrdColumn [#encryptedtextordcolumn]
Re-exports [EncryptedTextOrdColumn](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptedtextordcolumn)
***
EncryptedTextOrdOreColumn [#encryptedtextordorecolumn]
Re-exports [EncryptedTextOrdOreColumn](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptedtextordorecolumn)
***
EncryptedTextSearchColumn [#encryptedtextsearchcolumn]
Re-exports [EncryptedTextSearchColumn](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptedtextsearchcolumn)
***
EncryptedTimestampColumn [#encryptedtimestampcolumn]
Re-exports [EncryptedTimestampColumn](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptedtimestampcolumn)
***
EncryptedTimestampEqColumn [#encryptedtimestampeqcolumn]
Re-exports [EncryptedTimestampEqColumn](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptedtimestampeqcolumn)
***
EncryptedTimestampOrdColumn [#encryptedtimestampordcolumn]
Re-exports [EncryptedTimestampOrdColumn](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptedtimestampordcolumn)
***
EncryptedTimestampOrdOreColumn [#encryptedtimestampordorecolumn]
Re-exports [EncryptedTimestampOrdOreColumn](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptedtimestampordorecolumn)
***
TEXT_SEARCH_EQL_TYPE [#text_search_eql_type]
Re-exports [TEXT\_SEARCH\_EQL\_TYPE](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#text_search_eql_type)
***
AnyV3Table [#anyv3table]
Re-exports [AnyV3Table](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#anyv3table)
***
ColumnsOf [#columnsof]
Re-exports [ColumnsOf](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#columnsof)
***
InferEncrypted [#inferencrypted]
Re-exports [InferEncrypted](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#inferencrypted)
***
InferPlaintext [#inferplaintext]
Re-exports [InferPlaintext](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#inferplaintext)
***
QueryableColumnsOf [#queryablecolumnsof]
Re-exports [QueryableColumnsOf](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#queryablecolumnsof)
***
V3DecryptedModel [#v3decryptedmodel]
Re-exports [V3DecryptedModel](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#v3decryptedmodel)
***
V3EncryptedModel [#v3encryptedmodel]
Re-exports [V3EncryptedModel](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#v3encryptedmodel)
***
V3ModelInput [#v3modelinput]
Re-exports [V3ModelInput](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#v3modelinput)
***
buildEncryptConfig [#buildencryptconfig]
Re-exports [buildEncryptConfig](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#buildencryptconfig)
***
EncryptedTable [#encryptedtable]
Re-exports [EncryptedTable](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptedtable)
***
encryptedTable [#encryptedtable-1]
Re-exports [encryptedTable](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptedtable-1)
***
types [#types]
Re-exports [types](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#types)
# eql/v3
Source: https://cipherstash.com/docs/reference/stack/api-reference/eql.v3
[**@cipherstash/stack**](./)
***
Classes [#classes]
EncryptedTextSearchColumn [#encryptedtextsearchcolumn]
Defined in: [columns.ts:540](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/eql/v3/columns.ts#L540)
Builder for a `public.eql_v3_text_search` column.
The concrete type inherently enables equality + order/range + free-text
match — there are no capability-enabling or tuning methods. The match index
is always emitted with the default configuration.
NOTE — querying: a `text_search` column emits all three indexes (`unique`,
`ope`, `match`), and the shared index-inference picks them by fixed priority
`unique > match > ordering`. So `encryptQuery(value, { column, table })` with NO
explicit `queryType` builds an EQUALITY term (via `unique`), NOT a free-text
match — a substring like `'joh'` then matches nothing. To run a free-text
match query you MUST pass `queryType: 'freeTextSearch'`:
```typescript
// equality (default): exact value only
client.encryptQuery('john@example.com', { column: users.email, table: users })
// free-text match: substring/token search
client.encryptQuery('joh', { column: users.email, table: users, queryType: 'freeTextSearch' })
```
Extends [#extends]
* [`EncryptedV3Column`](https://cipherstash.com/docs/reference/stack/api-reference/adapter-kit#encryptedv3column)\<*typeof* `TEXT_SEARCH_DOMAIN`>
Constructors [#constructors]
Constructor [#constructor]
```ts
new EncryptedTextSearchColumn(columnName): EncryptedTextSearchColumn;
```
Defined in: [columns.ts:543](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/eql/v3/columns.ts#L543)
Parameters [#parameters]
columnName [#columnname]
`string`
Returns [#returns]
[`EncryptedTextSearchColumn`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptedtextsearchcolumn)
Overrides [#overrides]
[`EncryptedV3Column`](https://cipherstash.com/docs/reference/stack/api-reference/adapter-kit#encryptedv3column).[`constructor`](https://cipherstash.com/docs/reference/stack/api-reference/adapter-kit#constructor)
***
EncryptedIntegerColumn [#encryptedintegercolumn]
Defined in: [columns.ts:559](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/eql/v3/columns.ts#L559)
Extends [#extends-1]
* [`EncryptedV3Column`](https://cipherstash.com/docs/reference/stack/api-reference/adapter-kit#encryptedv3column)\<*typeof* `INTEGER`>
***
EncryptedIntegerEqColumn [#encryptedintegereqcolumn]
Defined in: [columns.ts:560](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/eql/v3/columns.ts#L560)
Extends [#extends-2]
* [`EncryptedV3Column`](https://cipherstash.com/docs/reference/stack/api-reference/adapter-kit#encryptedv3column)\<*typeof* `INTEGER_EQ`>
***
EncryptedIntegerOrdOreColumn [#encryptedintegerordorecolumn]
Defined in: [columns.ts:563](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/eql/v3/columns.ts#L563)
Extends [#extends-3]
* [`EncryptedV3Column`](https://cipherstash.com/docs/reference/stack/api-reference/adapter-kit#encryptedv3column)\<*typeof* `INTEGER_ORD_ORE`>
***
EncryptedIntegerOrdColumn [#encryptedintegerordcolumn]
Defined in: [columns.ts:566](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/eql/v3/columns.ts#L566)
Extends [#extends-4]
* [`EncryptedV3Column`](https://cipherstash.com/docs/reference/stack/api-reference/adapter-kit#encryptedv3column)\<*typeof* `INTEGER_ORD`>
***
EncryptedSmallintColumn [#encryptedsmallintcolumn]
Defined in: [columns.ts:571](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/eql/v3/columns.ts#L571)
Extends [#extends-5]
* [`EncryptedV3Column`](https://cipherstash.com/docs/reference/stack/api-reference/adapter-kit#encryptedv3column)\<*typeof* `SMALLINT`>
***
EncryptedSmallintEqColumn [#encryptedsmallinteqcolumn]
Defined in: [columns.ts:574](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/eql/v3/columns.ts#L574)
Extends [#extends-6]
* [`EncryptedV3Column`](https://cipherstash.com/docs/reference/stack/api-reference/adapter-kit#encryptedv3column)\<*typeof* `SMALLINT_EQ`>
***
EncryptedSmallintOrdOreColumn [#encryptedsmallintordorecolumn]
Defined in: [columns.ts:577](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/eql/v3/columns.ts#L577)
Extends [#extends-7]
* [`EncryptedV3Column`](https://cipherstash.com/docs/reference/stack/api-reference/adapter-kit#encryptedv3column)\<*typeof* `SMALLINT_ORD_ORE`>
***
EncryptedSmallintOrdColumn [#encryptedsmallintordcolumn]
Defined in: [columns.ts:580](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/eql/v3/columns.ts#L580)
Extends [#extends-8]
* [`EncryptedV3Column`](https://cipherstash.com/docs/reference/stack/api-reference/adapter-kit#encryptedv3column)\<*typeof* `SMALLINT_ORD`>
***
EncryptedBigintColumn [#encryptedbigintcolumn]
Defined in: [columns.ts:586](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/eql/v3/columns.ts#L586)
Extends [#extends-9]
* [`EncryptedV3Column`](https://cipherstash.com/docs/reference/stack/api-reference/adapter-kit#encryptedv3column)\<*typeof* `BIGINT`>
***
EncryptedBigintEqColumn [#encryptedbiginteqcolumn]
Defined in: [columns.ts:587](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/eql/v3/columns.ts#L587)
Extends [#extends-10]
* [`EncryptedV3Column`](https://cipherstash.com/docs/reference/stack/api-reference/adapter-kit#encryptedv3column)\<*typeof* `BIGINT_EQ`>
***
EncryptedBigintOrdOreColumn [#encryptedbigintordorecolumn]
Defined in: [columns.ts:590](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/eql/v3/columns.ts#L590)
Extends [#extends-11]
* [`EncryptedV3Column`](https://cipherstash.com/docs/reference/stack/api-reference/adapter-kit#encryptedv3column)\<*typeof* `BIGINT_ORD_ORE`>
***
EncryptedBigintOrdColumn [#encryptedbigintordcolumn]
Defined in: [columns.ts:593](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/eql/v3/columns.ts#L593)
Extends [#extends-12]
* [`EncryptedV3Column`](https://cipherstash.com/docs/reference/stack/api-reference/adapter-kit#encryptedv3column)\<*typeof* `BIGINT_ORD`>
***
EncryptedDateColumn [#encrypteddatecolumn]
Defined in: [columns.ts:598](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/eql/v3/columns.ts#L598)
Extends [#extends-13]
* [`EncryptedV3Column`](https://cipherstash.com/docs/reference/stack/api-reference/adapter-kit#encryptedv3column)\<*typeof* `DATE`>
***
EncryptedDateEqColumn [#encrypteddateeqcolumn]
Defined in: [columns.ts:599](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/eql/v3/columns.ts#L599)
Extends [#extends-14]
* [`EncryptedV3Column`](https://cipherstash.com/docs/reference/stack/api-reference/adapter-kit#encryptedv3column)\<*typeof* `DATE_EQ`>
***
EncryptedDateOrdOreColumn [#encrypteddateordorecolumn]
Defined in: [columns.ts:600](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/eql/v3/columns.ts#L600)
Extends [#extends-15]
* [`EncryptedV3Column`](https://cipherstash.com/docs/reference/stack/api-reference/adapter-kit#encryptedv3column)\<*typeof* `DATE_ORD_ORE`>
***
EncryptedDateOrdColumn [#encrypteddateordcolumn]
Defined in: [columns.ts:603](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/eql/v3/columns.ts#L603)
Extends [#extends-16]
* [`EncryptedV3Column`](https://cipherstash.com/docs/reference/stack/api-reference/adapter-kit#encryptedv3column)\<*typeof* `DATE_ORD`>
***
EncryptedTimestampColumn [#encryptedtimestampcolumn]
Defined in: [columns.ts:608](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/eql/v3/columns.ts#L608)
Extends [#extends-17]
* [`EncryptedV3Column`](https://cipherstash.com/docs/reference/stack/api-reference/adapter-kit#encryptedv3column)\<*typeof* `TIMESTAMP`>
***
EncryptedTimestampEqColumn [#encryptedtimestampeqcolumn]
Defined in: [columns.ts:611](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/eql/v3/columns.ts#L611)
Extends [#extends-18]
* [`EncryptedV3Column`](https://cipherstash.com/docs/reference/stack/api-reference/adapter-kit#encryptedv3column)\<*typeof* `TIMESTAMP_EQ`>
***
EncryptedTimestampOrdOreColumn [#encryptedtimestampordorecolumn]
Defined in: [columns.ts:614](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/eql/v3/columns.ts#L614)
Extends [#extends-19]
* [`EncryptedV3Column`](https://cipherstash.com/docs/reference/stack/api-reference/adapter-kit#encryptedv3column)\<*typeof* `TIMESTAMP_ORD_ORE`>
***
EncryptedTimestampOrdColumn [#encryptedtimestampordcolumn]
Defined in: [columns.ts:617](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/eql/v3/columns.ts#L617)
Extends [#extends-20]
* [`EncryptedV3Column`](https://cipherstash.com/docs/reference/stack/api-reference/adapter-kit#encryptedv3column)\<*typeof* `TIMESTAMP_ORD`>
***
EncryptedNumericColumn [#encryptednumericcolumn]
Defined in: [columns.ts:622](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/eql/v3/columns.ts#L622)
Extends [#extends-21]
* [`EncryptedV3Column`](https://cipherstash.com/docs/reference/stack/api-reference/adapter-kit#encryptedv3column)\<*typeof* `NUMERIC`>
***
EncryptedNumericEqColumn [#encryptednumericeqcolumn]
Defined in: [columns.ts:623](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/eql/v3/columns.ts#L623)
Extends [#extends-22]
* [`EncryptedV3Column`](https://cipherstash.com/docs/reference/stack/api-reference/adapter-kit#encryptedv3column)\<*typeof* `NUMERIC_EQ`>
***
EncryptedNumericOrdOreColumn [#encryptednumericordorecolumn]
Defined in: [columns.ts:626](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/eql/v3/columns.ts#L626)
Extends [#extends-23]
* [`EncryptedV3Column`](https://cipherstash.com/docs/reference/stack/api-reference/adapter-kit#encryptedv3column)\<*typeof* `NUMERIC_ORD_ORE`>
***
EncryptedNumericOrdColumn [#encryptednumericordcolumn]
Defined in: [columns.ts:629](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/eql/v3/columns.ts#L629)
Extends [#extends-24]
* [`EncryptedV3Column`](https://cipherstash.com/docs/reference/stack/api-reference/adapter-kit#encryptedv3column)\<*typeof* `NUMERIC_ORD`>
***
EncryptedTextColumn [#encryptedtextcolumn]
Defined in: [columns.ts:634](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/eql/v3/columns.ts#L634)
Extends [#extends-25]
* [`EncryptedV3Column`](https://cipherstash.com/docs/reference/stack/api-reference/adapter-kit#encryptedv3column)\<*typeof* `TEXT`>
***
EncryptedTextEqColumn [#encryptedtexteqcolumn]
Defined in: [columns.ts:635](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/eql/v3/columns.ts#L635)
Extends [#extends-26]
* [`EncryptedV3Column`](https://cipherstash.com/docs/reference/stack/api-reference/adapter-kit#encryptedv3column)\<*typeof* `TEXT_EQ`>
***
EncryptedTextMatchColumn [#encryptedtextmatchcolumn]
Defined in: [columns.ts:636](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/eql/v3/columns.ts#L636)
Extends [#extends-27]
* [`EncryptedV3Column`](https://cipherstash.com/docs/reference/stack/api-reference/adapter-kit#encryptedv3column)\<*typeof* `TEXT_MATCH`>
***
EncryptedTextOrdOreColumn [#encryptedtextordorecolumn]
Defined in: [columns.ts:639](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/eql/v3/columns.ts#L639)
Extends [#extends-28]
* [`EncryptedV3Column`](https://cipherstash.com/docs/reference/stack/api-reference/adapter-kit#encryptedv3column)\<*typeof* `TEXT_ORD_ORE`>
***
EncryptedTextOrdColumn [#encryptedtextordcolumn]
Defined in: [columns.ts:642](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/eql/v3/columns.ts#L642)
Extends [#extends-29]
* [`EncryptedV3Column`](https://cipherstash.com/docs/reference/stack/api-reference/adapter-kit#encryptedv3column)\<*typeof* `TEXT_ORD`>
***
EncryptedBooleanColumn [#encryptedbooleancolumn]
Defined in: [columns.ts:647](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/eql/v3/columns.ts#L647)
Extends [#extends-30]
* [`EncryptedV3Column`](https://cipherstash.com/docs/reference/stack/api-reference/adapter-kit#encryptedv3column)\<*typeof* `BOOLEAN`>
***
EncryptedRealColumn [#encryptedrealcolumn]
Defined in: [columns.ts:650](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/eql/v3/columns.ts#L650)
Extends [#extends-31]
* [`EncryptedV3Column`](https://cipherstash.com/docs/reference/stack/api-reference/adapter-kit#encryptedv3column)\<*typeof* `REAL`>
***
EncryptedRealEqColumn [#encryptedrealeqcolumn]
Defined in: [columns.ts:651](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/eql/v3/columns.ts#L651)
Extends [#extends-32]
* [`EncryptedV3Column`](https://cipherstash.com/docs/reference/stack/api-reference/adapter-kit#encryptedv3column)\<*typeof* `REAL_EQ`>
***
EncryptedRealOrdOreColumn [#encryptedrealordorecolumn]
Defined in: [columns.ts:652](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/eql/v3/columns.ts#L652)
Extends [#extends-33]
* [`EncryptedV3Column`](https://cipherstash.com/docs/reference/stack/api-reference/adapter-kit#encryptedv3column)\<*typeof* `REAL_ORD_ORE`>
***
EncryptedRealOrdColumn [#encryptedrealordcolumn]
Defined in: [columns.ts:655](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/eql/v3/columns.ts#L655)
Extends [#extends-34]
* [`EncryptedV3Column`](https://cipherstash.com/docs/reference/stack/api-reference/adapter-kit#encryptedv3column)\<*typeof* `REAL_ORD`>
***
EncryptedDoubleColumn [#encrypteddoublecolumn]
Defined in: [columns.ts:660](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/eql/v3/columns.ts#L660)
Extends [#extends-35]
* [`EncryptedV3Column`](https://cipherstash.com/docs/reference/stack/api-reference/adapter-kit#encryptedv3column)\<*typeof* `DOUBLE`>
***
EncryptedDoubleEqColumn [#encrypteddoubleeqcolumn]
Defined in: [columns.ts:661](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/eql/v3/columns.ts#L661)
Extends [#extends-36]
* [`EncryptedV3Column`](https://cipherstash.com/docs/reference/stack/api-reference/adapter-kit#encryptedv3column)\<*typeof* `DOUBLE_EQ`>
***
EncryptedDoubleOrdOreColumn [#encrypteddoubleordorecolumn]
Defined in: [columns.ts:664](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/eql/v3/columns.ts#L664)
Extends [#extends-37]
* [`EncryptedV3Column`](https://cipherstash.com/docs/reference/stack/api-reference/adapter-kit#encryptedv3column)\<*typeof* `DOUBLE_ORD_ORE`>
***
EncryptedDoubleOrdColumn [#encrypteddoubleordcolumn]
Defined in: [columns.ts:667](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/eql/v3/columns.ts#L667)
Extends [#extends-38]
* [`EncryptedV3Column`](https://cipherstash.com/docs/reference/stack/api-reference/adapter-kit#encryptedv3column)\<*typeof* `DOUBLE_ORD`>
***
EncryptedJsonColumn [#encryptedjsoncolumn]
Defined in: [columns.ts:690](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/eql/v3/columns.ts#L690)
Builder for a `public.eql_v3_json_search` column — an encrypted JSONB document
(a [JsonDocument](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#jsondocument): object, array, or null). It round-trips through
`encrypt`/`decrypt`, and containment queries use the encrypted-JSONB index
emitted by `build()`. (The stored payload is protect-ffi's `SteVecDocument`,
and the config index kind is `ste_vec` — both protect-ffi names.)
Extends [#extends-39]
* [`EncryptedV3Column`](https://cipherstash.com/docs/reference/stack/api-reference/adapter-kit#encryptedv3column)\<*typeof* `JSON_DOMAIN`>
Constructors [#constructors-1]
Constructor [#constructor-1]
```ts
new EncryptedJsonColumn(columnName): EncryptedJsonColumn;
```
Defined in: [columns.ts:691](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/eql/v3/columns.ts#L691)
Parameters [#parameters-1]
columnName [#columnname-1]
`string`
Returns [#returns-1]
[`EncryptedJsonColumn`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptedjsoncolumn)
Overrides [#overrides-1]
[`EncryptedV3Column`](https://cipherstash.com/docs/reference/stack/api-reference/adapter-kit#encryptedv3column).[`constructor`](https://cipherstash.com/docs/reference/stack/api-reference/adapter-kit#constructor)
***
EncryptedTable [#encryptedtable]
Defined in: [table.ts:18](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/eql/v3/table.ts#L18)
A v3 encrypted table. Mirrors the v2 `EncryptedTable` but only accepts v3
column builders. Emits the same `{ tableName, columns }` definition shape.
Type Parameters [#type-parameters]
T [#t]
`T` *extends* [`EncryptedV3TableColumn`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptedv3tablecolumn)
Constructors [#constructors-2]
Constructor [#constructor-2]
```ts
new EncryptedTable<T>(tableName, columnBuilders): EncryptedTable<T>;
```
Defined in: [table.ts:22](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/eql/v3/table.ts#L22)
Parameters [#parameters-2]
tableName [#tablename]
`string`
columnBuilders [#columnbuilders]
`T`
Returns [#returns-2]
[`EncryptedTable`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptedtable)\<`T`>
Properties [#properties]
tableName [#tablename-1]
```ts
readonly tableName: string;
```
Defined in: [table.ts:23](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/eql/v3/table.ts#L23)
columnBuilders [#columnbuilders-1]
```ts
readonly columnBuilders: T;
```
Defined in: [table.ts:24](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/eql/v3/table.ts#L24)
Methods [#methods]
build() [#build]
```ts
build(): TableDefinition;
```
Defined in: [table.ts:27](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/eql/v3/table.ts#L27)
Returns [#returns-3]
`TableDefinition`
buildColumnKeyMap() [#buildcolumnkeymap]
```ts
buildColumnKeyMap(): Record<string, string>;
```
Defined in: [table.ts:77](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/eql/v3/table.ts#L77)
Map each column's JS property name to its DB column name (`getName()`).
The model path matches user models by property name but must address the
encrypt config and FFI by DB name — `build()` keys columns by DB name, so
the two only agree when property == name. This recovers the mapping that
`build()` discards.
NULL PROTOTYPE — load-bearing. Callers index this map by a column name that
ultimately comes from the database (`addJsonbCastsV3`, `filterColumnName`,
the mutation transform). On a plain object literal, a column named
`constructor` / `toString` / `valueOf` / `__proto__` resolves to an
inherited `Object.prototype` member, which is truthy — so a *plaintext*
column with such a name would be mistaken for a mapped encrypted column and
its `Object.prototype` value interpolated into the emitted select string.
`encryptedTable()` rejects such names as JS *properties*, but nothing
constrains the DB column names a table may contain.
Returns [#returns-4]
`Record`\<`string`, `string`>
Type Aliases [#type-aliases]
QueryCapabilities [#querycapabilities]
```ts
type QueryCapabilities = Readonly<{
equality: boolean;
orderAndRange: boolean;
freeTextSearch: boolean;
searchableJson?: boolean;
}>;
```
Defined in: [columns.ts:17](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/eql/v3/columns.ts#L17)
The query capabilities a v3 concrete domain exposes. These are SDK-facing
semantic flags describing what kinds of query terms a column can produce —
NOT the raw EQL index keys. They are metadata only and never emitted by
`build()`.
* `equality`: exact-match lookups (EQL `hm`, or comparison via `ob`).
* `orderAndRange`: comparison / range lookups (EQL `op`, or `ob` on `_ord_ore` domains).
* `freeTextSearch`: tokenised substring match (EQL `bf`).
* `searchableJson`: encrypted-JSONB containment / selector lookups (EQL
`ste_vec`). Optional and mutually exclusive with the scalar flags — a
`public.eql_v3_json_search` document is queried by structure, not by scalar term.
***
AnyEncryptedV3Column [#anyencryptedv3column]
```ts
type AnyEncryptedV3Column =
| EncryptedIntegerColumn
| EncryptedIntegerEqColumn
| EncryptedIntegerOrdOreColumn
| EncryptedIntegerOrdColumn
| EncryptedSmallintColumn
| EncryptedSmallintEqColumn
| EncryptedSmallintOrdOreColumn
| EncryptedSmallintOrdColumn
| EncryptedBigintColumn
| EncryptedBigintEqColumn
| EncryptedBigintOrdOreColumn
| EncryptedBigintOrdColumn
| EncryptedDateColumn
| EncryptedDateEqColumn
| EncryptedDateOrdOreColumn
| EncryptedDateOrdColumn
| EncryptedTimestampColumn
| EncryptedTimestampEqColumn
| EncryptedTimestampOrdOreColumn
| EncryptedTimestampOrdColumn
| EncryptedNumericColumn
| EncryptedNumericEqColumn
| EncryptedNumericOrdOreColumn
| EncryptedNumericOrdColumn
| EncryptedTextColumn
| EncryptedTextEqColumn
| EncryptedTextMatchColumn
| EncryptedTextOrdOreColumn
| EncryptedTextOrdColumn
| EncryptedTextSearchColumn
| EncryptedBooleanColumn
| EncryptedRealColumn
| EncryptedRealEqColumn
| EncryptedRealOrdOreColumn
| EncryptedRealOrdColumn
| EncryptedDoubleColumn
| EncryptedDoubleEqColumn
| EncryptedDoubleOrdOreColumn
| EncryptedDoubleOrdColumn
| EncryptedJsonColumn;
```
Defined in: [columns.ts:700](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/eql/v3/columns.ts#L700)
Union of every v3 concrete column type. Used as the value type for v3 table
columns so a table may mix any generated domains.
***
EncryptedV3TableColumn [#encryptedv3tablecolumn]
```ts
type EncryptedV3TableColumn = {
[key: string]: AnyEncryptedV3Column;
};
```
Defined in: [columns.ts:755](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/eql/v3/columns.ts#L755)
Shape of v3 table columns: every value is a v3 concrete column builder.
(Nested fields are deferred to later increments.)
Index Signature [#index-signature]
```ts
[key: string]: AnyEncryptedV3Column
```
***
JsonValue [#jsonvalue]
```ts
type JsonValue =
| string
| number
| boolean
| null
| JsonValue[]
| {
[key: string]: JsonValue;
};
```
Defined in: [columns.ts:760](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/eql/v3/columns.ts#L760)
A JSON value at any depth. Used for the values NESTED inside a document.
***
JsonDocument [#jsondocument]
```ts
type JsonDocument =
| null
| JsonValue[]
| {
[key: string]: JsonValue;
};
```
Defined in: [columns.ts:776](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/eql/v3/columns.ts#L776)
The plaintext a `public.eql_v3_json_search` column encrypts and reconstructs: a JSON
DOCUMENT — an object, an array, or `null`. NOT a bare top-level scalar:
protect-ffi's `json` cast rejects a top-level string/number/boolean
("Cannot convert … to Json"), because a scalar belongs in a scalar domain
(`types.TextEq`, `types.IntegerEq`, …). Nested scalars are ordinary
[JsonValue](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#jsonvalue)s and are fully supported.
***
PlaintextForColumn [#plaintextforcolumn]
```ts
type PlaintextForColumn<C> = C extends EncryptedV3Column<infer D> ? PlaintextFromKind<D["castAs"]> : never;
```
Defined in: [columns.ts:800](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/eql/v3/columns.ts#L800)
The plaintext type for a single v3 column, read from the literal domain
definition carried on the base class's private field. This is stable across
empty subclasses that share the same base generic — a subclass-name
conditional would collapse because those subclasses are structurally
assignable to one another.
Type Parameters [#type-parameters-1]
C [#c]
`C`
***
QueryTypesForColumn [#querytypesforcolumn]
```ts
type QueryTypesForColumn<C> = C extends EncryptedV3Column<infer D> ?
| D["capabilities"]["equality"] extends true ? "equality" : never
| D["capabilities"]["orderAndRange"] extends true ? "orderAndRange" : never
| D["capabilities"]["freeTextSearch"] extends true ? "freeTextSearch" : never
| D["capabilities"]["searchableJson"] extends true ? "searchableJson" : never : never;
```
Defined in: [columns.ts:809](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/eql/v3/columns.ts#L809)
The user-facing `queryType` names a v3 column supports, derived 1:1 from its
capability flags. Resolves to `never` for a storage-only column (all flags
`false`) and for any non-v3 value. The names mirror the [QueryCapabilities](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#querycapabilities)
keys, each of which is also a import('@/types').QueryTypeName member.
Type Parameters [#type-parameters-2]
C [#c-1]
`C`
***
EqlTypeForColumn [#eqltypeforcolumn]
```ts
type EqlTypeForColumn<C> = C extends EncryptedV3Column<infer D> ? D["eqlType"] : never;
```
Defined in: [columns.ts:836](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/eql/v3/columns.ts#L836)
The concrete EQL v3 type string for a single column, read from the literal
domain definition carried on the base class's private field (mirrors
[PlaintextForColumn](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#plaintextforcolumn)). Distributes over a union of columns, so
`EqlTypeForColumn<AnyEncryptedV3Column>` yields the union of every domain's
`eqlType` — the canonical, source-of-truth key set for a type-driven test
matrix keyed by domain.
Type Parameters [#type-parameters-3]
C [#c-2]
`C`
***
InferPlaintext [#inferplaintext]
```ts
type InferPlaintext<T> = T extends EncryptedTable<infer C> ? { [K in keyof C]: PlaintextForColumn<C[K]> } : never;
```
Defined in: [table.ts:171](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/eql/v3/table.ts#L171)
Infer the plaintext (decrypted) shape from a v3 table schema. Each column maps
to the TypeScript type of its domain's `castAs` kind.
Type Parameters [#type-parameters-4]
T [#t-1]
`T` *extends* [`EncryptedTable`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptedtable)\<[`EncryptedV3TableColumn`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptedv3tablecolumn)>
***
InferEncrypted [#inferencrypted]
```ts
type InferEncrypted<T> = T extends EncryptedTable<infer C> ? { [K in keyof C]: Encrypted } : never;
```
Defined in: [table.ts:180](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/eql/v3/table.ts#L180)
Infer the encrypted shape from a v3 table schema. See [InferPlaintext](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#inferplaintext)
for why no key-remap filter is needed in the flat single-type model.
Type Parameters [#type-parameters-5]
T [#t-2]
`T` *extends* [`EncryptedTable`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptedtable)\<[`EncryptedV3TableColumn`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptedv3tablecolumn)>
***
AnyV3Table [#anyv3table]
```ts
type AnyV3Table = EncryptedTable<EncryptedV3TableColumn>;
```
Defined in: [table.ts:188](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/eql/v3/table.ts#L188)
Any v3 table, regardless of its column map.
***
ColumnsOf [#columnsof]
```ts
type ColumnsOf<T> = T extends EncryptedTable<infer C> ? C[keyof C] : never;
```
Defined in: [table.ts:191](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/eql/v3/table.ts#L191)
Union of the concrete column builders declared on a v3 table.
Type Parameters [#type-parameters-6]
T [#t-3]
`T` *extends* [`AnyV3Table`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#anyv3table)
***
QueryableColumnsOf [#queryablecolumnsof]
```ts
type QueryableColumnsOf<T> = T extends EncryptedTable<infer C> ? { [K in keyof C]: [QueryTypesForColumn<C[K]>] extends [never] ? never : C[K] }[keyof C] : never;
```
Defined in: [table.ts:199](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/eql/v3/table.ts#L199)
Union of the *queryable* column builders on a v3 table. Storage-only columns
(whose [QueryTypesForColumn](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#querytypesforcolumn) is `never`) are filtered out, so they can't
be passed to a query method.
Type Parameters [#type-parameters-7]
T [#t-4]
`T` *extends* [`AnyV3Table`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#anyv3table)
***
V3ModelInput [#v3modelinput]
```ts
type V3ModelInput<Table, T> = { [K in keyof T]: K extends keyof InferPlaintext<Table> ? null extends T[K] ? InferPlaintext<Table>[K] | null : InferPlaintext<Table>[K] : T[K] };
```
Defined in: [table.ts:214](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/eql/v3/table.ts#L214)
The accepted input model for import('@/encryption/v3').EncryptionClient.encryptModel.
`T` is inferred from the argument: keys that name a schema column are pinned to
the column's plaintext type (nullable if the field is nullable), so a wrong-typed
field fails assignability; all other keys pass through unchanged.
Type Parameters [#type-parameters-8]
Table [#table]
`Table` *extends* [`AnyV3Table`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#anyv3table)
T [#t-5]
`T`
***
V3EncryptedModel [#v3encryptedmodel]
```ts
type V3EncryptedModel<Table, T> = { [K in keyof T]: K extends keyof InferPlaintext<Table> ? null extends T[K] ? Encrypted | null : Encrypted : T[K] };
```
Defined in: [table.ts:223](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/eql/v3/table.ts#L223)
The encrypted result model: schema columns become `Encrypted`, others pass through.
Type Parameters [#type-parameters-9]
Table [#table-1]
`Table` *extends* [`AnyV3Table`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#anyv3table)
T [#t-6]
`T`
***
V3DecryptedModel [#v3decryptedmodel]
```ts
type V3DecryptedModel<Table, T> = V3ModelInput<Table, T>;
```
Defined in: [table.ts:238](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/eql/v3/table.ts#L238)
The decrypted result model: schema columns become their plaintext type, others
pass through. Structurally identical to [V3ModelInput](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#v3modelinput) — decrypt yields
the same plaintext shape encrypt accepts — so it is aliased rather than
re-declared to keep the input and output shapes from silently drifting when
one copy is edited. The distinct name is kept for call-site readability.
Type Parameters [#type-parameters-10]
Table [#table-2]
`Table` *extends* [`AnyV3Table`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#anyv3table)
T [#t-7]
`T`
Variables [#variables]
TEXT_SEARCH_EQL_TYPE [#text_search_eql_type]
```ts
const TEXT_SEARCH_EQL_TYPE: "public.eql_v3_text_search" = 'public.eql_v3_text_search';
```
Defined in: [columns.ts:110](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/eql/v3/columns.ts#L110)
The concrete EQL v3 domain name for a full-capability text column.
Recorded as metadata for future DDL / query-dialect increments; it is
intentionally absent from the emitted encrypt config.
***
types [#types]
```ts
const types: {
Integer: (name) => EncryptedIntegerColumn;
IntegerEq: (name) => EncryptedIntegerEqColumn;
IntegerOrdOre: (name) => EncryptedIntegerOrdOreColumn;
IntegerOrd: (name) => EncryptedIntegerOrdColumn;
Smallint: (name) => EncryptedSmallintColumn;
SmallintEq: (name) => EncryptedSmallintEqColumn;
SmallintOrdOre: (name) => EncryptedSmallintOrdOreColumn;
SmallintOrd: (name) => EncryptedSmallintOrdColumn;
Bigint: (name) => EncryptedBigintColumn;
BigintEq: (name) => EncryptedBigintEqColumn;
BigintOrdOre: (name) => EncryptedBigintOrdOreColumn;
BigintOrd: (name) => EncryptedBigintOrdColumn;
Date: (name) => EncryptedDateColumn;
DateEq: (name) => EncryptedDateEqColumn;
DateOrdOre: (name) => EncryptedDateOrdOreColumn;
DateOrd: (name) => EncryptedDateOrdColumn;
Timestamp: (name) => EncryptedTimestampColumn;
TimestampEq: (name) => EncryptedTimestampEqColumn;
TimestampOrdOre: (name) => EncryptedTimestampOrdOreColumn;
TimestampOrd: (name) => EncryptedTimestampOrdColumn;
Numeric: (name) => EncryptedNumericColumn;
NumericEq: (name) => EncryptedNumericEqColumn;
NumericOrdOre: (name) => EncryptedNumericOrdOreColumn;
NumericOrd: (name) => EncryptedNumericOrdColumn;
Text: (name) => EncryptedTextColumn;
TextEq: (name) => EncryptedTextEqColumn;
TextMatch: (name) => EncryptedTextMatchColumn;
TextOrdOre: (name) => EncryptedTextOrdOreColumn;
TextOrd: (name) => EncryptedTextOrdColumn;
TextSearch: (name) => EncryptedTextSearchColumn;
Boolean: (name) => EncryptedBooleanColumn;
Real: (name) => EncryptedRealColumn;
RealEq: (name) => EncryptedRealEqColumn;
RealOrdOre: (name) => EncryptedRealOrdOreColumn;
RealOrd: (name) => EncryptedRealOrdColumn;
Double: (name) => EncryptedDoubleColumn;
DoubleEq: (name) => EncryptedDoubleEqColumn;
DoubleOrdOre: (name) => EncryptedDoubleOrdOreColumn;
DoubleOrd: (name) => EncryptedDoubleOrdColumn;
Json: (name) => EncryptedJsonColumn;
};
```
Defined in: [types.ts:113](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/eql/v3/types.ts#L113)
The v3 column-type namespace. Each member is a public, semantic factory name
for a concrete EQL v3 column. Most members mirror the underlying domain name;
JS-friendly scalar names map to Postgres concrete domains, e.g.
`types.IntegerOrd` builds a `public.eql_v3_integer_ord` column and `types.Boolean`
builds a `public.eql_v3_boolean` column.
If these factory names stop matching the emitted capability/domain surface,
the stack package is out of sync with the underlying EQL build. That is a
version mismatch, not a harmless naming drift.
Each factory returns the CONCRETE column class instance (never the widened
`AnyEncryptedV3Column`) so per-column plaintext / query-capability inference
stays precise.
```ts
import { encryptedTable, types } from '@cipherstash/stack/eql/v3'
const events = encryptedTable('events', {
actor: types.TextEq('actor'), // equality
weight: types.IntegerOrd('weight'), // order + range
createdAt: types.Timestamp('created_at'), // storage only
})
```
`types.TextSearch` is fully described by its type — like every other domain,
it has no capability-bearing or tuning chain. Its match index is always
emitted with the default configuration; run a free-text query by passing
`queryType: 'freeTextSearch'` to `encryptQuery`.
Type Declaration [#type-declaration]
Integer() [#integer]
```ts
readonly Integer: (name) => EncryptedIntegerColumn;
```
Parameters [#parameters-3]
name [#name]
`string`
Returns [#returns-5]
[`EncryptedIntegerColumn`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptedintegercolumn)
IntegerEq() [#integereq]
```ts
readonly IntegerEq: (name) => EncryptedIntegerEqColumn;
```
Parameters [#parameters-4]
name [#name-1]
`string`
Returns [#returns-6]
[`EncryptedIntegerEqColumn`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptedintegereqcolumn)
IntegerOrdOre() [#integerordore]
```ts
readonly IntegerOrdOre: (name) => EncryptedIntegerOrdOreColumn;
```
Parameters [#parameters-5]
name [#name-2]
`string`
Returns [#returns-7]
[`EncryptedIntegerOrdOreColumn`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptedintegerordorecolumn)
IntegerOrd() [#integerord]
```ts
readonly IntegerOrd: (name) => EncryptedIntegerOrdColumn;
```
Parameters [#parameters-6]
name [#name-3]
`string`
Returns [#returns-8]
[`EncryptedIntegerOrdColumn`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptedintegerordcolumn)
Smallint() [#smallint]
```ts
readonly Smallint: (name) => EncryptedSmallintColumn;
```
Parameters [#parameters-7]
name [#name-4]
`string`
Returns [#returns-9]
[`EncryptedSmallintColumn`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptedsmallintcolumn)
SmallintEq() [#smallinteq]
```ts
readonly SmallintEq: (name) => EncryptedSmallintEqColumn;
```
Parameters [#parameters-8]
name [#name-5]
`string`
Returns [#returns-10]
[`EncryptedSmallintEqColumn`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptedsmallinteqcolumn)
SmallintOrdOre() [#smallintordore]
```ts
readonly SmallintOrdOre: (name) => EncryptedSmallintOrdOreColumn;
```
Parameters [#parameters-9]
name [#name-6]
`string`
Returns [#returns-11]
[`EncryptedSmallintOrdOreColumn`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptedsmallintordorecolumn)
SmallintOrd() [#smallintord]
```ts
readonly SmallintOrd: (name) => EncryptedSmallintOrdColumn;
```
Parameters [#parameters-10]
name [#name-7]
`string`
Returns [#returns-12]
[`EncryptedSmallintOrdColumn`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptedsmallintordcolumn)
Bigint() [#bigint]
```ts
readonly Bigint: (name) => EncryptedBigintColumn;
```
Parameters [#parameters-11]
name [#name-8]
`string`
Returns [#returns-13]
[`EncryptedBigintColumn`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptedbigintcolumn)
BigintEq() [#biginteq]
```ts
readonly BigintEq: (name) => EncryptedBigintEqColumn;
```
Parameters [#parameters-12]
name [#name-9]
`string`
Returns [#returns-14]
[`EncryptedBigintEqColumn`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptedbiginteqcolumn)
BigintOrdOre() [#bigintordore]
```ts
readonly BigintOrdOre: (name) => EncryptedBigintOrdOreColumn;
```
Parameters [#parameters-13]
name [#name-10]
`string`
Returns [#returns-15]
[`EncryptedBigintOrdOreColumn`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptedbigintordorecolumn)
BigintOrd() [#bigintord]
```ts
readonly BigintOrd: (name) => EncryptedBigintOrdColumn;
```
Parameters [#parameters-14]
name [#name-11]
`string`
Returns [#returns-16]
[`EncryptedBigintOrdColumn`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptedbigintordcolumn)
Date() [#date]
```ts
readonly Date: (name) => EncryptedDateColumn;
```
Parameters [#parameters-15]
name [#name-12]
`string`
Returns [#returns-17]
[`EncryptedDateColumn`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encrypteddatecolumn)
DateEq() [#dateeq]
```ts
readonly DateEq: (name) => EncryptedDateEqColumn;
```
Parameters [#parameters-16]
name [#name-13]
`string`
Returns [#returns-18]
[`EncryptedDateEqColumn`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encrypteddateeqcolumn)
DateOrdOre() [#dateordore]
```ts
readonly DateOrdOre: (name) => EncryptedDateOrdOreColumn;
```
Parameters [#parameters-17]
name [#name-14]
`string`
Returns [#returns-19]
[`EncryptedDateOrdOreColumn`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encrypteddateordorecolumn)
DateOrd() [#dateord]
```ts
readonly DateOrd: (name) => EncryptedDateOrdColumn;
```
Parameters [#parameters-18]
name [#name-15]
`string`
Returns [#returns-20]
[`EncryptedDateOrdColumn`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encrypteddateordcolumn)
Timestamp() [#timestamp]
```ts
readonly Timestamp: (name) => EncryptedTimestampColumn;
```
Parameters [#parameters-19]
name [#name-16]
`string`
Returns [#returns-21]
[`EncryptedTimestampColumn`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptedtimestampcolumn)
TimestampEq() [#timestampeq]
```ts
readonly TimestampEq: (name) => EncryptedTimestampEqColumn;
```
Parameters [#parameters-20]
name [#name-17]
`string`
Returns [#returns-22]
[`EncryptedTimestampEqColumn`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptedtimestampeqcolumn)
TimestampOrdOre() [#timestampordore]
```ts
readonly TimestampOrdOre: (name) => EncryptedTimestampOrdOreColumn;
```
Parameters [#parameters-21]
name [#name-18]
`string`
Returns [#returns-23]
[`EncryptedTimestampOrdOreColumn`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptedtimestampordorecolumn)
TimestampOrd() [#timestampord]
```ts
readonly TimestampOrd: (name) => EncryptedTimestampOrdColumn;
```
Parameters [#parameters-22]
name [#name-19]
`string`
Returns [#returns-24]
[`EncryptedTimestampOrdColumn`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptedtimestampordcolumn)
Numeric() [#numeric]
```ts
readonly Numeric: (name) => EncryptedNumericColumn;
```
Parameters [#parameters-23]
name [#name-20]
`string`
Returns [#returns-25]
[`EncryptedNumericColumn`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptednumericcolumn)
NumericEq() [#numericeq]
```ts
readonly NumericEq: (name) => EncryptedNumericEqColumn;
```
Parameters [#parameters-24]
name [#name-21]
`string`
Returns [#returns-26]
[`EncryptedNumericEqColumn`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptednumericeqcolumn)
NumericOrdOre() [#numericordore]
```ts
readonly NumericOrdOre: (name) => EncryptedNumericOrdOreColumn;
```
Parameters [#parameters-25]
name [#name-22]
`string`
Returns [#returns-27]
[`EncryptedNumericOrdOreColumn`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptednumericordorecolumn)
NumericOrd() [#numericord]
```ts
readonly NumericOrd: (name) => EncryptedNumericOrdColumn;
```
Parameters [#parameters-26]
name [#name-23]
`string`
Returns [#returns-28]
[`EncryptedNumericOrdColumn`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptednumericordcolumn)
Text() [#text]
```ts
readonly Text: (name) => EncryptedTextColumn;
```
Parameters [#parameters-27]
name [#name-24]
`string`
Returns [#returns-29]
[`EncryptedTextColumn`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptedtextcolumn)
TextEq() [#texteq]
```ts
readonly TextEq: (name) => EncryptedTextEqColumn;
```
Parameters [#parameters-28]
name [#name-25]
`string`
Returns [#returns-30]
[`EncryptedTextEqColumn`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptedtexteqcolumn)
TextMatch() [#textmatch]
```ts
readonly TextMatch: (name) => EncryptedTextMatchColumn;
```
Parameters [#parameters-29]
name [#name-26]
`string`
Returns [#returns-31]
[`EncryptedTextMatchColumn`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptedtextmatchcolumn)
TextOrdOre() [#textordore]
```ts
readonly TextOrdOre: (name) => EncryptedTextOrdOreColumn;
```
Parameters [#parameters-30]
name [#name-27]
`string`
Returns [#returns-32]
[`EncryptedTextOrdOreColumn`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptedtextordorecolumn)
TextOrd() [#textord]
```ts
readonly TextOrd: (name) => EncryptedTextOrdColumn;
```
Parameters [#parameters-31]
name [#name-28]
`string`
Returns [#returns-33]
[`EncryptedTextOrdColumn`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptedtextordcolumn)
TextSearch() [#textsearch]
```ts
readonly TextSearch: (name) => EncryptedTextSearchColumn;
```
Parameters [#parameters-32]
name [#name-29]
`string`
Returns [#returns-34]
[`EncryptedTextSearchColumn`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptedtextsearchcolumn)
Boolean() [#boolean]
```ts
readonly Boolean: (name) => EncryptedBooleanColumn;
```
Parameters [#parameters-33]
name [#name-30]
`string`
Returns [#returns-35]
[`EncryptedBooleanColumn`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptedbooleancolumn)
Real() [#real]
```ts
readonly Real: (name) => EncryptedRealColumn;
```
Parameters [#parameters-34]
name [#name-31]
`string`
Returns [#returns-36]
[`EncryptedRealColumn`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptedrealcolumn)
RealEq() [#realeq]
```ts
readonly RealEq: (name) => EncryptedRealEqColumn;
```
Parameters [#parameters-35]
name [#name-32]
`string`
Returns [#returns-37]
[`EncryptedRealEqColumn`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptedrealeqcolumn)
RealOrdOre() [#realordore]
```ts
readonly RealOrdOre: (name) => EncryptedRealOrdOreColumn;
```
Parameters [#parameters-36]
name [#name-33]
`string`
Returns [#returns-38]
[`EncryptedRealOrdOreColumn`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptedrealordorecolumn)
RealOrd() [#realord]
```ts
readonly RealOrd: (name) => EncryptedRealOrdColumn;
```
Parameters [#parameters-37]
name [#name-34]
`string`
Returns [#returns-39]
[`EncryptedRealOrdColumn`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptedrealordcolumn)
Double() [#double]
```ts
readonly Double: (name) => EncryptedDoubleColumn;
```
Parameters [#parameters-38]
name [#name-35]
`string`
Returns [#returns-40]
[`EncryptedDoubleColumn`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encrypteddoublecolumn)
DoubleEq() [#doubleeq]
```ts
readonly DoubleEq: (name) => EncryptedDoubleEqColumn;
```
Parameters [#parameters-39]
name [#name-36]
`string`
Returns [#returns-41]
[`EncryptedDoubleEqColumn`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encrypteddoubleeqcolumn)
DoubleOrdOre() [#doubleordore]
```ts
readonly DoubleOrdOre: (name) => EncryptedDoubleOrdOreColumn;
```
Parameters [#parameters-40]
name [#name-37]
`string`
Returns [#returns-42]
[`EncryptedDoubleOrdOreColumn`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encrypteddoubleordorecolumn)
DoubleOrd() [#doubleord]
```ts
readonly DoubleOrd: (name) => EncryptedDoubleOrdColumn;
```
Parameters [#parameters-41]
name [#name-38]
`string`
Returns [#returns-43]
[`EncryptedDoubleOrdColumn`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encrypteddoubleordcolumn)
Json() [#json]
```ts
readonly Json: (name) => EncryptedJsonColumn;
```
Parameters [#parameters-42]
name [#name-39]
`string`
Returns [#returns-44]
[`EncryptedJsonColumn`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptedjsoncolumn)
Functions [#functions]
encryptedTable() [#encryptedtable-1]
```ts
function encryptedTable<T>(tableName, columns): EncryptedTable<T> & T;
```
Defined in: [table.ts:118](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/eql/v3/table.ts#L118)
Define a v3 encrypted table. Intentionally shadows the v2 `encryptedTable`
name but lives on the `/eql/v3` subpath — the importer picks the model by
import path. The returned object is also a column accessor (`users.email`).
Type Parameters [#type-parameters-11]
T [#t-8]
`T` *extends* [`EncryptedV3TableColumn`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptedv3tablecolumn)
Parameters [#parameters-43]
tableName [#tablename-2]
`string`
columns [#columns]
`T`
Returns [#returns-45]
[`EncryptedTable`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptedtable)\<`T`> & `T`
***
buildEncryptConfig() [#buildencryptconfig]
```ts
function buildEncryptConfig(...tables): {
v: number;
tables: Record<string, Record<string, {
cast_as: | "string"
| "number"
| "bigint"
| "boolean"
| "date"
| "text"
| "timestamp"
| "json";
indexes: {
ore?: {
};
ope?: {
};
unique?: {
token_filters?: {
kind: "downcase";
}[];
};
match?: {
tokenizer?: | {
kind: "standard";
}
| {
kind: "ngram";
token_length: number;
};
token_filters?: {
kind: "downcase";
}[];
k?: number;
m?: number;
include_original?: boolean;
};
ste_vec?: {
prefix: string;
array_index_mode?: | "all"
| "none"
| {
item?: boolean;
wildcard?: boolean;
position?: boolean;
};
mode?: "standard" | "compat";
};
};
}>>;
};
```
Defined in: [table.ts:143](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/eql/v3/table.ts#L143)
Build an `EncryptConfig` (`v: 1`) from one or more v3 tables. Emits the same
shape as v2's `buildEncryptConfig`.
Parameters [#parameters-44]
tables [#tables]
...[`EncryptedTable`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptedtable)\<[`EncryptedV3TableColumn`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptedv3tablecolumn)>\[]
Returns [#returns-46]
```ts
{
v: number;
tables: Record<string, Record<string, {
cast_as: | "string"
| "number"
| "bigint"
| "boolean"
| "date"
| "text"
| "timestamp"
| "json";
indexes: {
ore?: {
};
ope?: {
};
unique?: {
token_filters?: {
kind: "downcase";
}[];
};
match?: {
tokenizer?: | {
kind: "standard";
}
| {
kind: "ngram";
token_length: number;
};
token_filters?: {
kind: "downcase";
}[];
k?: number;
m?: number;
include_original?: boolean;
};
ste_vec?: {
prefix: string;
array_index_mode?: | "all"
| "none"
| {
item?: boolean;
wildcard?: boolean;
position?: boolean;
};
mode?: "standard" | "compat";
};
};
}>>;
}
```
v [#v]
```ts
v: number;
```
tables [#tables-1]
```ts
tables: Record<string, Record<string, {
cast_as: | "string"
| "number"
| "bigint"
| "boolean"
| "date"
| "text"
| "timestamp"
| "json";
indexes: {
ore?: {
};
ope?: {
};
unique?: {
token_filters?: {
kind: "downcase";
}[];
};
match?: {
tokenizer?: | {
kind: "standard";
}
| {
kind: "ngram";
token_length: number;
};
token_filters?: {
kind: "downcase";
}[];
k?: number;
m?: number;
include_original?: boolean;
};
ste_vec?: {
prefix: string;
array_index_mode?: | "all"
| "none"
| {
item?: boolean;
wildcard?: boolean;
position?: boolean;
};
mode?: "standard" | "compat";
};
};
}>> = tablesSchema;
```
# errors
Source: https://cipherstash.com/docs/reference/stack/api-reference/errors
[**@cipherstash/stack**](./)
***
Interfaces [#interfaces]
EncryptionError [#encryptionerror]
Defined in: [index.ts:37](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/errors/index.ts#L37)
Base error interface returned by all encryption operations.
Every operation that can fail returns `Result<T, EncryptionError>`.
Use the `type` field to narrow to a specific error kind, or use
[StackError](https://cipherstash.com/docs/reference/stack/api-reference/errors#stackerror) for an exhaustive discriminated union.
Example [#example]
```typescript
const result = await client.encrypt(value, opts)
if (result.failure) {
switch (result.failure.type) {
case EncryptionErrorTypes.EncryptionError:
console.error('Encryption failed:', result.failure.message)
break
case EncryptionErrorTypes.LockContextError:
console.error('Lock context issue:', result.failure.message)
break
}
}
```
Properties [#properties]
type [#type]
```ts
type:
| "ClientInitError"
| "EncryptionError"
| "DecryptionError"
| "LockContextError"
| "CtsTokenError";
```
Defined in: [index.ts:38](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/errors/index.ts#L38)
message [#message]
```ts
message: string;
```
Defined in: [index.ts:39](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/errors/index.ts#L39)
code? [#code]
```ts
optional code: ProtectErrorCode;
```
Defined in: [index.ts:40](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/errors/index.ts#L40)
***
ClientInitError [#clientiniterror]
Defined in: [index.ts:47](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/errors/index.ts#L47)
Properties [#properties-1]
type [#type-1]
```ts
type: "ClientInitError";
```
Defined in: [index.ts:48](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/errors/index.ts#L48)
message [#message-1]
```ts
message: string;
```
Defined in: [index.ts:49](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/errors/index.ts#L49)
***
EncryptionOperationError [#encryptionoperationerror]
Defined in: [index.ts:52](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/errors/index.ts#L52)
Properties [#properties-2]
type [#type-2]
```ts
type: "EncryptionError";
```
Defined in: [index.ts:53](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/errors/index.ts#L53)
message [#message-2]
```ts
message: string;
```
Defined in: [index.ts:54](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/errors/index.ts#L54)
code? [#code-1]
```ts
optional code: ProtectErrorCode;
```
Defined in: [index.ts:55](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/errors/index.ts#L55)
***
DecryptionOperationError [#decryptionoperationerror]
Defined in: [index.ts:58](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/errors/index.ts#L58)
Properties [#properties-3]
type [#type-3]
```ts
type: "DecryptionError";
```
Defined in: [index.ts:59](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/errors/index.ts#L59)
message [#message-3]
```ts
message: string;
```
Defined in: [index.ts:60](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/errors/index.ts#L60)
code? [#code-2]
```ts
optional code: ProtectErrorCode;
```
Defined in: [index.ts:61](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/errors/index.ts#L61)
***
LockContextError [#lockcontexterror]
Defined in: [index.ts:64](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/errors/index.ts#L64)
Properties [#properties-4]
type [#type-4]
```ts
type: "LockContextError";
```
Defined in: [index.ts:65](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/errors/index.ts#L65)
message [#message-4]
```ts
message: string;
```
Defined in: [index.ts:66](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/errors/index.ts#L66)
***
CtsTokenError [#ctstokenerror]
Defined in: [index.ts:69](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/errors/index.ts#L69)
Properties [#properties-5]
type [#type-5]
```ts
type: "CtsTokenError";
```
Defined in: [index.ts:70](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/errors/index.ts#L70)
message [#message-5]
```ts
message: string;
```
Defined in: [index.ts:71](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/errors/index.ts#L71)
Type Aliases [#type-aliases]
StackError [#stackerror]
```ts
type StackError =
| ClientInitError
| EncryptionOperationError
| DecryptionOperationError
| LockContextError
| CtsTokenError;
```
Defined in: [index.ts:102](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/errors/index.ts#L102)
Discriminated union of all specific error types.
Use `StackError` when you need exhaustive error handling via `switch` on the `type` field.
Example [#example-1]
```typescript
function handleError(error: StackError) {
switch (error.type) {
case 'ClientInitError':
// re-initialize client
break
case 'EncryptionError':
case 'DecryptionError':
// log and retry
break
case 'LockContextError':
// re-authenticate
break
case 'CtsTokenError':
// refresh token
break
default:
error satisfies never
}
}
```
Variables [#variables]
EncryptionErrorTypes [#encryptionerrortypes]
```ts
const EncryptionErrorTypes: {
ClientInitError: "ClientInitError";
EncryptionError: "EncryptionError";
DecryptionError: "DecryptionError";
LockContextError: "LockContextError";
CtsTokenError: "CtsTokenError";
};
```
Defined in: [index.ts:7](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/errors/index.ts#L7)
Type Declaration [#type-declaration]
ClientInitError [#clientiniterror-1]
```ts
readonly ClientInitError: "ClientInitError" = 'ClientInitError';
```
EncryptionError [#encryptionerror-1]
```ts
readonly EncryptionError: "EncryptionError" = 'EncryptionError';
```
DecryptionError [#decryptionerror]
```ts
readonly DecryptionError: "DecryptionError" = 'DecryptionError';
```
LockContextError [#lockcontexterror-1]
```ts
readonly LockContextError: "LockContextError" = 'LockContextError';
```
CtsTokenError [#ctstokenerror-1]
```ts
readonly CtsTokenError: "CtsTokenError" = 'CtsTokenError';
```
Functions [#functions]
getErrorMessage() [#geterrormessage]
```ts
function getErrorMessage(error): string;
```
Defined in: [index.ts:117](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/errors/index.ts#L117)
Safely extract an error message from an unknown thrown value.
Unlike `(error as Error).message`, this handles non-Error values gracefully.
Parameters [#parameters]
error [#error]
`unknown`
Returns [#returns]
`string`
# identity
Source: https://cipherstash.com/docs/reference/stack/api-reference/identity
[**@cipherstash/stack**](./)
***
Classes [#classes]
LockContext [#lockcontext]
Defined in: [index.ts:81](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/identity/index.ts#L81)
Binds an encryption/decryption operation to a user's identity by selecting
which JWT claim(s) ZeroKMS bakes into the data key's tag (the *lock context*).
The claim **value** is resolved by ZeroKMS from the token that authenticates
the request — so to bind to a real end user, authenticate the client as that
user with an `OidcFederationStrategy` (from `@cipherstash/auth`) and pass the
claim to `.withLockContext()`. The same context must be supplied to decrypt.
You can pass a plain `{ identityClaim }` directly — constructing a
`LockContext` is optional.
Example [#example]
```typescript
import { Encryption } from "@cipherstash/stack"
import { OidcFederationStrategy } from "@cipherstash/auth"
// Authenticate the client as the end user (replaces the old identify() flow).
const client = await Encryption({
schemas,
config: {
authStrategy: OidcFederationStrategy.create(workspaceCrn, () => getJwt()),
},
})
// Bind the key to the user's `sub` claim — no token, no identify().
const result = await client
.encrypt(value, { column: users.email, table: users })
.withLockContext({ identityClaim: ["sub"] })
```
Constructors [#constructors]
Constructor [#constructor]
```ts
new LockContext(__namedParameters?): LockContext;
```
Defined in: [index.ts:86](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/identity/index.ts#L86)
Parameters [#parameters]
__namedParameters? [#__namedparameters]
[`LockContextOptions`](https://cipherstash.com/docs/reference/stack/api-reference/identity#lockcontextoptions) = `{}`
Returns [#returns]
[`LockContext`](https://cipherstash.com/docs/reference/stack/api-reference/identity#lockcontext)
Accessors [#accessors]
identityContext [#identitycontext]
Get Signature [#get-signature]
```ts
get identityContext(): Context;
```
Defined in: [index.ts:112](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/identity/index.ts#L112)
The identity-claim context this lock context binds to, e.g.
`{ identityClaim: ['sub'] }`. Resolved synchronously — `.withLockContext()`
uses this directly; no CTS token is required.
Returns [#returns-1]
[`Context`](https://cipherstash.com/docs/reference/stack/api-reference/identity#context)
Methods [#methods]
identify() [#identify]
```ts
identify(jwtToken): Promise<Result<LockContext, EncryptionError>>;
```
Defined in: [index.ts:129](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/identity/index.ts#L129)
Exchange a user's JWT for a CTS token and bind it to this lock context.
Parameters [#parameters-1]
jwtToken [#jwttoken]
`string`
A valid OIDC / JWT token for the current user.
Returns [#returns-2]
`Promise`\<[`Result`](https://www.npmjs.com/package/@byteslice/result)\<[`LockContext`](https://cipherstash.com/docs/reference/stack/api-reference/identity#lockcontext), [`EncryptionError`](https://cipherstash.com/docs/reference/stack/api-reference/errors#encryptionerror-1)>>
A `Result` containing this `LockContext` or an error.
Deprecated [#deprecated]
Per-operation CTS tokens were removed in protect-ffi 0.25.
Authenticate the client as the user with an `OidcFederationStrategy`
(`config.authStrategy`) instead, and pass the claim to `.withLockContext()`.
The token fetched here is no longer used by encryption operations. This
method is kept for backwards compatibility and will be removed in a
future major release.
getLockContext() [#getlockcontext]
```ts
getLockContext(): Promise<Result<GetLockContextResponse, EncryptionError>>;
```
Defined in: [index.ts:192](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/identity/index.ts#L192)
Retrieve the identity context (and CTS token, if one was set).
Returns [#returns-3]
`Promise`\<[`Result`](https://www.npmjs.com/package/@byteslice/result)\<[`GetLockContextResponse`](https://cipherstash.com/docs/reference/stack/api-reference/identity#getlockcontextresponse), [`EncryptionError`](https://cipherstash.com/docs/reference/stack/api-reference/errors#encryptionerror-1)>>
Deprecated [#deprecated-1]
Encryption operations no longer consume a CTS token — they read
the identity claim directly via [identityContext](https://cipherstash.com/docs/reference/stack/api-reference/identity#identitycontext). Pass the claim to
`.withLockContext()` and authenticate the client with an
`OidcFederationStrategy` instead. Kept for backwards compatibility; the
returned `ctsToken` is `undefined` unless one was supplied to the
constructor or [identify](https://cipherstash.com/docs/reference/stack/api-reference/identity#identify) was called.
Type Aliases [#type-aliases]
CtsRegions [#ctsregions]
```ts
type CtsRegions = "ap-southeast-2";
```
Defined in: [index.ts:6](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/identity/index.ts#L6)
***
IdentifyOptions [#identifyoptions]
```ts
type IdentifyOptions = {
fetchFromCts?: boolean;
};
```
Defined in: [index.ts:8](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/identity/index.ts#L8)
Properties [#properties]
fetchFromCts? [#fetchfromcts]
```ts
optional fetchFromCts: boolean;
```
Defined in: [index.ts:9](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/identity/index.ts#L9)
***
CtsToken [#ctstoken]
```ts
type CtsToken = {
accessToken: string;
expiry: number;
};
```
Defined in: [index.ts:12](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/identity/index.ts#L12)
Properties [#properties-1]
accessToken [#accesstoken]
```ts
accessToken: string;
```
Defined in: [index.ts:13](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/identity/index.ts#L13)
expiry [#expiry]
```ts
expiry: number;
```
Defined in: [index.ts:14](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/identity/index.ts#L14)
***
Context [#context]
```ts
type Context = {
identityClaim: string[];
};
```
Defined in: [index.ts:17](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/identity/index.ts#L17)
Properties [#properties-2]
identityClaim [#identityclaim]
```ts
identityClaim: string[];
```
Defined in: [index.ts:18](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/identity/index.ts#L18)
***
LockContextOptions [#lockcontextoptions]
```ts
type LockContextOptions = {
context?: Context;
ctsToken?: CtsToken;
};
```
Defined in: [index.ts:21](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/identity/index.ts#L21)
Properties [#properties-3]
context? [#context-1]
```ts
optional context: Context;
```
Defined in: [index.ts:22](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/identity/index.ts#L22)
ctsToken? [#ctstoken-1]
```ts
optional ctsToken: CtsToken;
```
Defined in: [index.ts:23](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/identity/index.ts#L23)
***
GetLockContextResponse [#getlockcontextresponse]
```ts
type GetLockContextResponse = {
ctsToken?: CtsToken;
context: Context;
};
```
Defined in: [index.ts:26](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/identity/index.ts#L26)
Properties [#properties-4]
ctsToken? [#ctstoken-2]
```ts
optional ctsToken: CtsToken;
```
Defined in: [index.ts:27](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/identity/index.ts#L27)
context [#context-2]
```ts
context: Context;
```
Defined in: [index.ts:28](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/identity/index.ts#L28)
***
LockContextInput [#lockcontextinput]
```ts
type LockContextInput =
| LockContext
| Context;
```
Defined in: [index.ts:35](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/identity/index.ts#L35)
The accepted argument to `.withLockContext()` — either a [LockContext](https://cipherstash.com/docs/reference/stack/api-reference/identity#lockcontext)
or a plain identity-claim spec (e.g. `{ identityClaim: ['sub'] }`).
Functions [#functions]
resolveLockContext() [#resolvelockcontext]
```ts
function resolveLockContext(input): Context;
```
Defined in: [index.ts:41](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/identity/index.ts#L41)
Resolve a [LockContextInput](https://cipherstash.com/docs/reference/stack/api-reference/identity#lockcontextinput) to the [Context](https://cipherstash.com/docs/reference/stack/api-reference/identity#context) (identity claim)
that protect-ffi expects. Synchronous — no token round-trip.
Parameters [#parameters-2]
input [#input]
[`LockContextInput`](https://cipherstash.com/docs/reference/stack/api-reference/identity#lockcontextinput)
Returns [#returns-4]
[`Context`](https://cipherstash.com/docs/reference/stack/api-reference/identity#context)
# @cipherstash/stack
Source: https://cipherstash.com/docs/reference/stack/api-reference
**@cipherstash/stack**
***
Modules [#modules]
* [adapter-kit](https://cipherstash.com/docs/reference/stack/api-reference/adapter-kit)
* [dynamodb](https://cipherstash.com/docs/reference/stack/api-reference/dynamodb)
* [encryption](https://cipherstash.com/docs/reference/stack/api-reference/encryption)
* [encryption/v3](https://cipherstash.com/docs/reference/stack/api-reference/encryption.v3)
* [eql/v3](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3)
* [errors](https://cipherstash.com/docs/reference/stack/api-reference/errors)
* [identity](https://cipherstash.com/docs/reference/stack/api-reference/identity)
* [Package exports](https://cipherstash.com/docs/reference/stack/api-reference/Package-exports)
* [schema](https://cipherstash.com/docs/reference/stack/api-reference/schema)
* [types-public](https://cipherstash.com/docs/reference/stack/api-reference/types-public)
* [wasm-inline](https://cipherstash.com/docs/reference/stack/api-reference/wasm-inline)
# schema
Source: https://cipherstash.com/docs/reference/stack/api-reference/schema
[**@cipherstash/stack**](./)
***
Type Aliases [#type-aliases]
CastAs [#castas]
```ts
type CastAs = z.infer<typeof castAsEnum>;
```
Defined in: [internal.ts:183](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/schema/internal.ts#L183)
Type-safe alias for [castAsEnum](https://cipherstash.com/docs/reference/stack/api-reference/schema#castasenum) used to specify the *unencrypted* data type of a column or value.
This is important because once encrypted, all data is stored as binary blobs.
See [#see]
[castAsEnum](https://cipherstash.com/docs/reference/stack/api-reference/schema#castasenum) for possible values.
***
EqlCastAs [#eqlcastas]
```ts
type EqlCastAs = z.infer<typeof eqlCastAsEnum>;
```
Defined in: [internal.ts:184](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/schema/internal.ts#L184)
Low-level encryption configuration primitives.
Schema authoring is EQL v3-only; import `encryptedTable` and `types` from
`@cipherstash/stack/v3`. This subpath remains for packages that inspect or
validate the generated protect-ffi configuration.
***
TokenFilter [#tokenfilter]
```ts
type TokenFilter = z.infer<typeof tokenFilterSchema>;
```
Defined in: [internal.ts:185](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/schema/internal.ts#L185)
Low-level encryption configuration primitives.
Schema authoring is EQL v3-only; import `encryptedTable` and `types` from
`@cipherstash/stack/v3`. This subpath remains for packages that inspect or
validate the generated protect-ffi configuration.
***
MatchIndexOpts [#matchindexopts]
```ts
type MatchIndexOpts = z.infer<typeof matchIndexOptsSchema>;
```
Defined in: [internal.ts:186](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/schema/internal.ts#L186)
Low-level encryption configuration primitives.
Schema authoring is EQL v3-only; import `encryptedTable` and `types` from
`@cipherstash/stack/v3`. This subpath remains for packages that inspect or
validate the generated protect-ffi configuration.
***
SteVecIndexOpts [#stevecindexopts]
```ts
type SteVecIndexOpts = z.infer<typeof steVecIndexOptsSchema>;
```
Defined in: [internal.ts:187](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/schema/internal.ts#L187)
Low-level encryption configuration primitives.
Schema authoring is EQL v3-only; import `encryptedTable` and `types` from
`@cipherstash/stack/v3`. This subpath remains for packages that inspect or
validate the generated protect-ffi configuration.
***
UniqueIndexOpts [#uniqueindexopts]
```ts
type UniqueIndexOpts = z.infer<typeof uniqueIndexOptsSchema>;
```
Defined in: [internal.ts:188](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/schema/internal.ts#L188)
Low-level encryption configuration primitives.
Schema authoring is EQL v3-only; import `encryptedTable` and `types` from
`@cipherstash/stack/v3`. This subpath remains for packages that inspect or
validate the generated protect-ffi configuration.
***
OreIndexOpts [#oreindexopts]
```ts
type OreIndexOpts = z.infer<typeof oreIndexOptsSchema>;
```
Defined in: [internal.ts:189](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/schema/internal.ts#L189)
Low-level encryption configuration primitives.
Schema authoring is EQL v3-only; import `encryptedTable` and `types` from
`@cipherstash/stack/v3`. This subpath remains for packages that inspect or
validate the generated protect-ffi configuration.
***
OpeIndexOpts [#opeindexopts]
```ts
type OpeIndexOpts = z.infer<typeof opeIndexOptsSchema>;
```
Defined in: [internal.ts:190](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/schema/internal.ts#L190)
Low-level encryption configuration primitives.
Schema authoring is EQL v3-only; import `encryptedTable` and `types` from
`@cipherstash/stack/v3`. This subpath remains for packages that inspect or
validate the generated protect-ffi configuration.
***
ColumnSchema [#columnschema]
```ts
type ColumnSchema = z.infer<typeof columnSchema>;
```
Defined in: [internal.ts:191](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/schema/internal.ts#L191)
Low-level encryption configuration primitives.
Schema authoring is EQL v3-only; import `encryptedTable` and `types` from
`@cipherstash/stack/v3`. This subpath remains for packages that inspect or
validate the generated protect-ffi configuration.
***
EncryptConfig [#encryptconfig]
```ts
type EncryptConfig = z.infer<typeof encryptConfigSchema>;
```
Defined in: [internal.ts:212](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/schema/internal.ts#L212)
Low-level encryption configuration primitives.
Schema authoring is EQL v3-only; import `encryptedTable` and `types` from
`@cipherstash/stack/v3`. This subpath remains for packages that inspect or
validate the generated protect-ffi configuration.
Variables [#variables]
eqlCastAsEnum [#eqlcastasenum]
```ts
const eqlCastAsEnum: ZodDefault<ZodEnum<["text", "int", "small_int", "big_int", "real", "double", "boolean", "date", "timestamp", "jsonb"]>>;
```
Defined in: [internal.ts:32](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/schema/internal.ts#L32)
EQL cast types — the PostgreSQL-aligned types that EQL actually accepts.
These are stored in the `cast_as` field of the EncryptConfig.
***
castAsEnum [#castasenum]
```ts
const castAsEnum: ZodDefault<ZodEnum<["bigint", "boolean", "date", "timestamp", "number", "string", "json", "text"]>>;
```
Defined in: [internal.ts:54](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/schema/internal.ts#L54)
SDK-facing data types — developer-friendly aliases accepted by `dataType()`.
`timestamp` is distinct from `date`: `date` is calendar-date only (time-of-day
truncated to midnight), while `timestamp` preserves the full date+time. v3
`timestamp` domains set `cast_as: 'timestamp'` so the FFI keeps the instant.
Functions [#functions]
toEqlCastAs() [#toeqlcastas]
```ts
function toEqlCastAs(value):
| "boolean"
| "date"
| "text"
| "int"
| "small_int"
| "big_int"
| "real"
| "double"
| "timestamp"
| "jsonb";
```
Defined in: [internal.ts:73](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/schema/internal.ts#L73)
Map SDK-facing data types to EQL `cast_as` values.
The SDK accepts developer-friendly types like `'string'` and `'number'`,
but EQL expects PostgreSQL-aligned types like `'text'` and `'double'`.
Parameters [#parameters]
value [#value]
`"string"` | `"number"` | `"bigint"` | `"boolean"` | `"date"` | `"text"` | `"timestamp"` | `"json"`
Returns [#returns]
\| `"boolean"`
\| `"date"`
\| `"text"`
\| `"int"`
\| `"small_int"`
\| `"big_int"`
\| `"real"`
\| `"double"`
\| `"timestamp"`
\| `"jsonb"`
# types-public
Source: https://cipherstash.com/docs/reference/stack/api-reference/types-public
[**@cipherstash/stack**](./)
***
Type Aliases [#type-aliases]
AuthStrategy [#authstrategy]
```ts
type AuthStrategy = {
getToken: () => Promise<TokenResult | TokenResultEnvelope>;
};
```
Defined in: ../../../node\_modules/.bun/@cipherstash+protect-ffi\@0.30.0/node\_modules/@cipherstash/protect-ffi/lib/index.d.cts:367
Auth strategy shape compatible with `@cipherstash/auth` strategies (e.g.
`AccessKeyStrategy`, `OidcFederationStrategy`). Only `getToken` is required.
`getToken` may resolve either shape — the native and WASM clients accept both
(see `crates/protect-ffi/src/lib.rs` and `crates/protect-ffi/src/wasm.rs`):
* `{ token }` — the bare payload, used by `@cipherstash/auth` \<= 0.40 and by
custom strategies.
* `{ data: { token } }` / `{ failure }` — the `Result` envelope, used by
`@cipherstash/auth` \>= 0.41. A `failure` is reconstructed into the
corresponding `AuthError`.
Both have been accepted at runtime since 0.28.0; this type previously
declared only the bare payload, so a real `@cipherstash/auth` >= 0.41
strategy could not be assigned to it.
Properties [#properties]
getToken() [#gettoken]
```ts
getToken: () => Promise<TokenResult | TokenResultEnvelope>;
```
Defined in: ../../../node\_modules/.bun/@cipherstash+protect-ffi\@0.30.0/node\_modules/@cipherstash/protect-ffi/lib/index.d.cts:368
Returns [#returns]
`Promise`\<`TokenResult` | `TokenResultEnvelope`>
***
Client [#client]
```ts
type Client = Awaited<ReturnType<typeof newClient>> | undefined;
```
Defined in: [types.ts:49](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/types.ts#L49)
Public type re-exports for `@cipherstash/stack/types`.
This module exposes only the public types from the internal types module.
Internal helpers (`queryTypeToFfi`, `queryTypeToQueryOp`, `FfiIndexTypeName`,
`QueryTermBase`) are excluded.
***
EncryptedValue [#encryptedvalue]
```ts
type EncryptedValue = Brand<CipherStashEncrypted, "encrypted">;
```
Defined in: [types.ts:52](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/types.ts#L52)
A branded type representing encrypted data. Cannot be accidentally used as plaintext.
***
EncryptedQuery [#encryptedquery]
```ts
type EncryptedQuery = CipherStashEncryptedQuery | CipherStashEncryptedV3Query;
```
Defined in: [types.ts:70](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/types.ts#L70)
Structural type representing an encrypted query term (search needle)
returned by `encryptQuery` / `encryptQueryBulk` for scalar
(`unique` / `match` / `ore`) lookups and SteVec JSON selector,
value-selector, ordering, and `eql_v3.query_json` containment queries.
Carries no ciphertext — matched against stored values, never decrypted.
***
KeysetIdentifier [#keysetidentifier]
```ts
type KeysetIdentifier =
| {
name: string;
}
| {
id: string;
};
```
Defined in: [types.ts:98](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/types.ts#L98)
Public type re-exports for `@cipherstash/stack/types`.
This module exposes only the public types from the internal types module.
Internal helpers (`queryTypeToFfi`, `queryTypeToQueryOp`, `FfiIndexTypeName`,
`QueryTermBase`) are excluded.
***
ClientConfig [#clientconfig]
```ts
type ClientConfig = {
workspaceCrn?: string;
accessKey?: string;
clientId?: string;
clientKey?: string;
keyset?: KeysetIdentifier;
authStrategy?: AuthStrategy;
strategy?: AuthStrategy;
eqlVersion?: never;
};
```
Defined in: [types.ts:100](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/types.ts#L100)
Public type re-exports for `@cipherstash/stack/types`.
This module exposes only the public types from the internal types module.
Internal helpers (`queryTypeToFfi`, `queryTypeToQueryOp`, `FfiIndexTypeName`,
`QueryTermBase`) are excluded.
Properties [#properties-1]
workspaceCrn? [#workspacecrn]
```ts
optional workspaceCrn: string;
```
Defined in: [types.ts:106](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/types.ts#L106)
The CipherStash workspace CRN (Cloud Resource Name).
Format: `crn:<region>.aws:<workspace-id>`.
Can also be set via the `CS_WORKSPACE_CRN` environment variable.
accessKey? [#accesskey]
```ts
optional accessKey: string;
```
Defined in: [types.ts:113](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/types.ts#L113)
The API access key used for authenticating with the CipherStash API.
Can also be set via the `CS_CLIENT_ACCESS_KEY` environment variable.
Obtain this from the CipherStash dashboard after creating a workspace.
clientId? [#clientid]
```ts
optional clientId: string;
```
Defined in: [types.ts:120](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/types.ts#L120)
The client identifier used to authenticate with CipherStash services.
Can also be set via the `CS_CLIENT_ID` environment variable.
Generated during workspace onboarding in the CipherStash dashboard.
clientKey? [#clientkey]
```ts
optional clientKey: string;
```
Defined in: [types.ts:127](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/types.ts#L127)
The client key material used in combination with ZeroKMS for encryption operations.
Can also be set via the `CS_CLIENT_KEY` environment variable.
Generated during workspace onboarding in the CipherStash dashboard.
keyset? [#keyset]
```ts
optional keyset: KeysetIdentifier;
```
Defined in: [types.ts:144](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/types.ts#L144)
An optional keyset identifier for multi-tenant encryption.
Each keyset provides cryptographic isolation, giving each tenant its own keyspace.
Specify by name (`{ name: "tenant-a" }`) or UUID (`{ id: "..." }`).
Keysets are created and managed in the
[dashboard](https://dashboard.cipherstash.com/workspaces/_/keysets); omit to
use the default keyset of the ZeroKMS client behind your credentials — the
keyset it was created against, which is the workspace's `default` keyset if
using the profile credentials in a dev environment. A client is bound to
one keyset for its lifetime — encrypt and query always use it, while
decrypt follows each payload's own keyset (subject to grants) — so use one
client per tenant.
See [#see]
Encryption for the full keysets walkthrough.
authStrategy? [#authstrategy-1]
```ts
optional authStrategy: AuthStrategy;
```
Defined in: [types.ts:168](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/types.ts#L168)
An optional authentication strategy for ZeroKMS requests, from
`@cipherstash/auth` (re-exported by `@cipherstash/stack`). When provided,
its `getToken()` is invoked on every ZeroKMS request and takes precedence
over the default `auto` strategy (the `clientKey` is still required for
encryption). Use:
* `OidcFederationStrategy` for per-user, identity-bound encryption —
federates an end user's OIDC JWT into a CTS service token, so requests
authenticate as that user. Pair with `.withLockContext({ identityClaim })`
to bind the data key to a claim. This replaces the older
`LockContext.identify()` ceremony.
* `AccessKeyStrategy` for service-to-service / CI, or any custom
`{ getToken() }` object for bespoke token acquisition / caching.
Leave unset to use the default `auto` strategy, which reads credentials
from the `CS_*` environment variables and falls back to the local dev
profile created by `npx stash auth login`.
See [#see-1]
* [AuthStrategy](https://cipherstash.com/docs/reference/stack/api-reference/types-public#authstrategy)
* Encryption for a full walkthrough of the authentication options.
strategy? [#strategy]
```ts
optional strategy: AuthStrategy;
```
Defined in: [types.ts:175](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/types.ts#L175)
Deprecated [#deprecated]
Renamed to [ClientConfig.authStrategy](https://cipherstash.com/docs/reference/stack/api-reference/types-public#authstrategy-1). Still honoured for
backwards compatibility — passing it logs a deprecation warning at runtime —
but it will be removed in a future release. Set `authStrategy` instead.
eqlVersion? [#eqlversion]
```ts
optional eqlVersion: never;
```
Defined in: [types.ts:196](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/types.ts#L196)
Removed: Stack always authors EQL v3. Declared as `never` rather than
omitted so the type rejects it wherever it appears — every other property
here is optional, so excess-property checking was the only thing catching a
leftover `eqlVersion`, and that fires on FRESH object literals alone. A
shared config const (`const cfg = { …, eqlVersion: 2 }`) — the shape a
v2 → v3 migration most plausibly has — therefore type-checked clean and
threw at `Encryption()`.
`Encryption` keeps its runtime guard: JS and JSON callers bypass types
entirely, so this is defence in depth, not a replacement for it.
One asymmetry the guard has to account for: without
`exactOptionalPropertyTypes` — which this repo does not enable — `?: never`
has declared type `undefined`, so `eqlVersion: undefined` is accepted here
and no declaration can reject it. The runtime therefore tolerates exactly
that value (it names no version) while still rejecting every real one,
`eqlVersion: 3` included.
***
EncryptionClientConfig [#encryptionclientconfig]
```ts
type EncryptionClientConfig<S> = {
schemas: S["length"] extends 0 ? never : S;
config?: ClientConfig;
};
```
Defined in: [types.ts:279](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/types.ts#L279)
The `Encryption({ schemas, config })` argument, as a named type.
The default MUST be a non-empty tuple, not `readonly AnyV3Table[]`: with the
widened default, `S['length']` resolves to `number`, `number extends 0` is
false, and the conditional hands back the widened array — so
`const cfg: EncryptionClientConfig = { schemas: [] }` typechecked clean and
threw at `Encryption()`. Excess-property checking only catches the FRESH
literal `Encryption({ schemas: [] })`; a config object built once and passed
around, which is exactly what this type exists to serve, slipped through.
The conditional stays for an explicit `EncryptionClientConfig<[]>`, and the
type parameter stays so a caller can pin their own schema tuple. The factory
keeps accepting widened arrays inline through its overloads — that is a
separate concern from what this exported type can prove.
Mirrors `WasmEncryptionConfig` on the `wasm-inline` entry.
Type Parameters [#type-parameters]
S [#s]
`S` *extends* readonly [`AnyV3Table`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#anyv3table)\[] = readonly \[[`AnyV3Table`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#anyv3table), `...AnyV3Table[]`]
Properties [#properties-2]
schemas [#schemas]
```ts
schemas: S["length"] extends 0 ? never : S;
```
Defined in: [types.ts:282](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/types.ts#L282)
config? [#config]
```ts
optional config: ClientConfig;
```
Defined in: [types.ts:283](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/types.ts#L283)
***
EncryptOptions [#encryptoptions]
```ts
type EncryptOptions = {
column: BuildableColumn;
table: BuildableTable;
};
```
Defined in: [types.ts:335](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/types.ts#L335)
Options for single-value encrypt operations.
Use a column from your table schema (from encryptedColumn) or a nested
field (from encryptedField) as the target for encryption.
Properties [#properties-3]
column [#column]
```ts
column: BuildableColumn;
```
Defined in: [types.ts:337](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/types.ts#L337)
The column or nested field to encrypt into. From EncryptedColumn or EncryptedField.
table [#table]
```ts
table: BuildableTable;
```
Defined in: [types.ts:338](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/types.ts#L338)
***
EncryptedReturnType [#encryptedreturntype]
```ts
type EncryptedReturnType = "eql" | "composite-literal" | "escaped-composite-literal";
```
Defined in: [types.ts:342](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/types.ts#L342)
Format for encrypted query/search term return values
***
EncryptedSearchTerm [#encryptedsearchterm]
```ts
type EncryptedSearchTerm =
| Encrypted
| EncryptedQuery
| string;
```
Defined in: [types.ts:357](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/types.ts#L357)
Encrypted search term result. `eql` returns the query-only scalar or SteVec
term; the `composite-literal` return types yield a string. The `Encrypted`
arm remains for legacy v2 scalar query compatibility.
***
EncryptedQueryResult [#encryptedqueryresult]
```ts
type EncryptedQueryResult =
| Encrypted
| EncryptedQuery
| string
| null;
```
Defined in: [types.ts:365](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/types.ts#L365)
Result of encryptQuery (single or batch). `eql` return type yields either a
storage payload (`Encrypted`) or a query-only term (`EncryptedQuery`); the
`composite-literal` return types yield a string.
***
EncryptedFields [#encryptedfields]
```ts
type EncryptedFields<T> = { [K in keyof T as NonNullable<T[K]> extends Encrypted ? K : never]: T[K] };
```
Defined in: [types.ts:371](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/types.ts#L371)
Public type re-exports for `@cipherstash/stack/types`.
This module exposes only the public types from the internal types module.
Internal helpers (`queryTypeToFfi`, `queryTypeToQueryOp`, `FfiIndexTypeName`,
`QueryTermBase`) are excluded.
Type Parameters [#type-parameters-1]
T [#t]
`T`
***
OtherFields [#otherfields]
```ts
type OtherFields<T> = { [K in keyof T as NonNullable<T[K]> extends Encrypted ? never : K]: T[K] };
```
Defined in: [types.ts:375](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/types.ts#L375)
Public type re-exports for `@cipherstash/stack/types`.
This module exposes only the public types from the internal types module.
Internal helpers (`queryTypeToFfi`, `queryTypeToQueryOp`, `FfiIndexTypeName`,
`QueryTermBase`) are excluded.
Type Parameters [#type-parameters-2]
T [#t-1]
`T`
***
DecryptedFields [#decryptedfields]
```ts
type DecryptedFields<T> = { [K in keyof T as NonNullable<T[K]> extends Encrypted ? K : never]: null extends T[K] ? string | null : string };
```
Defined in: [types.ts:379](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/types.ts#L379)
Public type re-exports for `@cipherstash/stack/types`.
This module exposes only the public types from the internal types module.
Internal helpers (`queryTypeToFfi`, `queryTypeToQueryOp`, `FfiIndexTypeName`,
`QueryTermBase`) are excluded.
Type Parameters [#type-parameters-3]
T [#t-2]
`T`
***
Decrypted [#decrypted]
```ts
type Decrypted<T> = OtherFields<T> & DecryptedFields<T>;
```
Defined in: [types.ts:386](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/types.ts#L386)
Model with encrypted fields replaced by plaintext (decrypted) values
Type Parameters [#type-parameters-4]
T [#t-3]
`T`
***
BulkEncryptPayload [#bulkencryptpayload]
```ts
type BulkEncryptPayload = {
id?: string;
plaintext: Plaintext | null;
}[];
```
Defined in: [types.ts:428](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/types.ts#L428)
Public type re-exports for `@cipherstash/stack/types`.
This module exposes only the public types from the internal types module.
Internal helpers (`queryTypeToFfi`, `queryTypeToQueryOp`, `FfiIndexTypeName`,
`QueryTermBase`) are excluded.
Type Declaration [#type-declaration]
id? [#id]
```ts
optional id: string;
```
plaintext [#plaintext]
```ts
plaintext: Plaintext | null;
```
***
BulkEncryptedData [#bulkencrypteddata]
```ts
type BulkEncryptedData = {
id?: string;
data: | Encrypted
| null;
}[];
```
Defined in: [types.ts:433](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/types.ts#L433)
Public type re-exports for `@cipherstash/stack/types`.
This module exposes only the public types from the internal types module.
Internal helpers (`queryTypeToFfi`, `queryTypeToQueryOp`, `FfiIndexTypeName`,
`QueryTermBase`) are excluded.
Type Declaration [#type-declaration-1]
id? [#id-1]
```ts
optional id: string;
```
data [#data]
```ts
data:
| Encrypted
| null;
```
***
BulkDecryptPayload [#bulkdecryptpayload]
```ts
type BulkDecryptPayload = {
id?: string;
data: | Encrypted
| null;
}[];
```
Defined in: [types.ts:434](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/types.ts#L434)
Public type re-exports for `@cipherstash/stack/types`.
This module exposes only the public types from the internal types module.
Internal helpers (`queryTypeToFfi`, `queryTypeToQueryOp`, `FfiIndexTypeName`,
`QueryTermBase`) are excluded.
Type Declaration [#type-declaration-2]
id? [#id-2]
```ts
optional id: string;
```
data [#data-1]
```ts
data:
| Encrypted
| null;
```
***
BulkDecryptedData [#bulkdecrypteddata]
```ts
type BulkDecryptedData = DecryptionResult<JsPlaintext | null>[];
```
Defined in: [types.ts:435](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/types.ts#L435)
Public type re-exports for `@cipherstash/stack/types`.
This module exposes only the public types from the internal types module.
Internal helpers (`queryTypeToFfi`, `queryTypeToQueryOp`, `FfiIndexTypeName`,
`QueryTermBase`) are excluded.
***
DecryptionResult [#decryptionresult]
```ts
type DecryptionResult<T> = DecryptionSuccess<T> | DecryptionError<T>;
```
Defined in: [types.ts:445](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/types.ts#L445)
Result type for individual items in bulk decrypt operations.
Uses `error`/`data` fields (not `failure`/`data`) since bulk operations
can have per-item failures.
Type Parameters [#type-parameters-5]
T [#t-4]
`T`
***
QueryTypeName [#querytypename]
```ts
type QueryTypeName =
| "orderAndRange"
| "freeTextSearch"
| "equality"
| "steVecSelector"
| "steVecValueSelector"
| "steVecTerm"
| "searchableJson";
```
Defined in: [types.ts:462](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/types.ts#L462)
User-facing query type names for encrypting query values.
* `'equality'`: Exact match. [Exact Queries](https://cipherstash.com/docs/stack/cipherstash/encryption/searchable-encryption)
* `'freeTextSearch'`: Text search. [Match Queries](https://cipherstash.com/docs/stack/cipherstash/encryption/searchable-encryption)
* `'orderAndRange'`: Comparison and range. [Range Queries](https://cipherstash.com/docs/stack/cipherstash/encryption/searchable-encryption)
* `'steVecSelector'`: JSONPath selector (e.g. `'$.user.email'`)
* `'steVecValueSelector'`: Exact value at a JSONPath (`{ path, value }`)
* `'steVecTerm'`: Ordering term for a scalar JSON value
* `'searchableJson'`: Auto-infers selector or containment from plaintext type (recommended)
***
EncryptQueryOptions [#encryptqueryoptions]
```ts
type EncryptQueryOptions = QueryTermBase;
```
Defined in: [types.ts:512](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/types.ts#L512)
Public type re-exports for `@cipherstash/stack/types`.
This module exposes only the public types from the internal types module.
Internal helpers (`queryTypeToFfi`, `queryTypeToQueryOp`, `FfiIndexTypeName`,
`QueryTermBase`) are excluded.
***
ScalarQueryTerm [#scalarqueryterm]
```ts
type ScalarQueryTerm = QueryTermBase & {
value: Plaintext;
};
```
Defined in: [types.ts:514](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/types.ts#L514)
Public type re-exports for `@cipherstash/stack/types`.
This module exposes only the public types from the internal types module.
Internal helpers (`queryTypeToFfi`, `queryTypeToQueryOp`, `FfiIndexTypeName`,
`QueryTermBase`) are excluded.
Type Declaration [#type-declaration-3]
value [#value]
```ts
value: Plaintext;
```
Variables [#variables]
queryTypes [#querytypes]
```ts
const queryTypes: {
orderAndRange: "orderAndRange";
freeTextSearch: "freeTextSearch";
equality: "equality";
steVecSelector: "steVecSelector";
steVecValueSelector: "steVecValueSelector";
steVecTerm: "steVecTerm";
searchableJson: "searchableJson";
};
```
Defined in: [types.ts:474](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/types.ts#L474)
Type Declaration [#type-declaration-4]
orderAndRange [#orderandrange]
```ts
readonly orderAndRange: "orderAndRange" = 'orderAndRange';
```
freeTextSearch [#freetextsearch]
```ts
readonly freeTextSearch: "freeTextSearch" = 'freeTextSearch';
```
equality [#equality]
```ts
readonly equality: "equality" = 'equality';
```
steVecSelector [#stevecselector]
```ts
readonly steVecSelector: "steVecSelector" = 'steVecSelector';
```
steVecValueSelector [#stevecvalueselector]
```ts
readonly steVecValueSelector: "steVecValueSelector" = 'steVecValueSelector';
```
steVecTerm [#stevecterm]
```ts
readonly steVecTerm: "steVecTerm" = 'steVecTerm';
```
searchableJson [#searchablejson]
```ts
readonly searchableJson: "searchableJson" = 'searchableJson';
```
References [#references]
Encrypted [#encrypted]
Re-exports [Encrypted](https://cipherstash.com/docs/reference/stack/api-reference/Package-exports#encrypted)
# wasm-inline
Source: https://cipherstash.com/docs/reference/stack/api-reference/wasm-inline
[**@cipherstash/stack**](./)
***
Classes [#classes]
AccessKeyStrategy [#accesskeystrategy]
Defined in: ../../../node\_modules/.bun/@cipherstash+auth\@0.42.0/node\_modules/@cipherstash/auth/wasm-inline.d.ts:106
An auth strategy that uses a static access key for service-to-service
or CI/CD authentication, scoped to a single workspace identified by a
CRN. The region is derived from the CRN, so there's no separate
`region` argument and no chance of the strategy operating against a
region the caller didn't expect.
Every issued token's `workspace` JWT claim is verified against the
CRN's workspace ID. A mismatch fails the `getToken()` call with an
`AuthError` whose `code` is `"WORKSPACE_MISMATCH"` — the strategy
never silently lets a multi-workspace access key operate on the
wrong workspace.
Methods [#methods]
create() [#create]
```ts
static create(
workspaceCrn,
accessKey,
options?): Result<AccessKeyStrategy, AuthFailure>;
```
Defined in: ../../../node\_modules/.bun/@cipherstash+auth\@0.42.0/node\_modules/@cipherstash/auth/wasm-inline.d.ts:122
Create a new `AccessKeyStrategy` for the given workspace CRN and
access key.
The CRN format is `crn:<region>:<workspace-id>` (e.g.
`"crn:ap-southeast-2.aws:ZVATKW3VHMFG27DY"`). Region is parsed from
the CRN and used for service discovery; the workspace ID is used
to verify every issued token belongs to the right workspace.
Pass `options.store` to back the strategy with a persistent cache —
see TokenStore and the
[\`@cipherstash/auth/cookies\`](https://www.npmjs.com/package/@cipherstash/auth)
helper.
Parameters [#parameters]
workspaceCrn [#workspacecrn]
`string`
accessKey [#accesskey]
`string`
options? [#options]
`AccessKeyStrategyOptions`
Returns [#returns]
[`Result`](https://www.npmjs.com/package/@byteslice/result)\<[`AccessKeyStrategy`](https://cipherstash.com/docs/reference/stack/api-reference/wasm-inline#accesskeystrategy), `AuthFailure`>
getToken() [#gettoken]
```ts
getToken(): Promise<GetTokenResult>;
```
Defined in: ../../../node\_modules/.bun/@cipherstash+auth\@0.42.0/node\_modules/@cipherstash/auth/wasm-inline.d.ts:128
Retrieve a valid access token, refreshing or re-authenticating as needed.
Returns [#returns-1]
`Promise`\<`GetTokenResult`>
free() [#free]
```ts
free(): void;
```
Defined in: ../../../node\_modules/.bun/@cipherstash+auth\@0.42.0/node\_modules/@cipherstash/auth/wasm-inline.d.ts:130
Release the underlying wasm resources.
Returns [#returns-2]
`void`
***
OidcFederationStrategy [#oidcfederationstrategy]
Defined in: ../../../node\_modules/.bun/@cipherstash+auth\@0.42.0/node\_modules/@cipherstash/auth/wasm-inline.d.ts:160
An auth strategy that federates a third-party OIDC JWT (Clerk, Supabase, …)
into a CipherStash CTS service token via `/api/authorise`.
Methods [#methods-1]
create() [#create-1]
```ts
static create(
workspaceCrn,
getJwt,
options?): Result<OidcFederationStrategy, AuthFailure>;
```
Defined in: ../../../node\_modules/.bun/@cipherstash+auth\@0.42.0/node\_modules/@cipherstash/auth/wasm-inline.d.ts:174
Create an `OidcFederationStrategy` for the given workspace CRN.
The CRN format is `crn:<region>:<workspace-id>` (e.g.
`"crn:ap-southeast-2.aws:ZVATKW3VHMFG27DY"`). Region is parsed from the
CRN and used for service discovery; the workspace ID is used to verify
every federated token belongs to the right workspace.
`getJwt` must return the current third-party OIDC JWT (it is re-invoked
on every re-federation). Pass `options.store` to back the strategy with a
persistent cache — see TokenStore.
Parameters [#parameters-1]
workspaceCrn [#workspacecrn-1]
`string`
getJwt [#getjwt]
`OidcProvider`
options? [#options-1]
`OidcFederationStrategyOptions`
Returns [#returns-3]
[`Result`](https://www.npmjs.com/package/@byteslice/result)\<[`OidcFederationStrategy`](https://cipherstash.com/docs/reference/stack/api-reference/wasm-inline#oidcfederationstrategy), `AuthFailure`>
getToken() [#gettoken-1]
```ts
getToken(): Promise<GetTokenResult>;
```
Defined in: ../../../node\_modules/.bun/@cipherstash+auth\@0.42.0/node\_modules/@cipherstash/auth/wasm-inline.d.ts:180
Retrieve a valid CTS service token, federating or re-federating as needed.
Returns [#returns-4]
`Promise`\<`GetTokenResult`>
free() [#free-1]
```ts
free(): void;
```
Defined in: ../../../node\_modules/.bun/@cipherstash+auth\@0.42.0/node\_modules/@cipherstash/auth/wasm-inline.d.ts:182
Release the underlying wasm resources.
Returns [#returns-5]
`void`
***
WasmEncryptionClient [#wasmencryptionclient]
Defined in: [wasm-inline.ts:731](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/wasm-inline.ts#L731)
WASM encryption client. Returned by [Encryption](https://cipherstash.com/docs/reference/stack/api-reference/wasm-inline#encryption).
Wraps an opaque `wasmNewClient` handle and exposes `encrypt`, `decrypt`,
`isEncrypted`, `encryptQuery` / `encryptQueryBulk` for minting v3 query
terms (#662, which made searchable encryption reachable on the edge),
`bulkEncrypt` / `bulkDecrypt` for single-round-trip list reads and writes
(#737), and the model helpers `encryptModel` / `decryptModel` /
`bulkEncryptModels` / `bulkDecryptModels` (#742).
Every fallible method returns a Result [#every-fallible-method-returns-a-result]
`{ data } | { failure }`, with `failure.type` drawn from
`EncryptionErrorTypes` — the same contract the native entry honours, and
the one `AGENTS.md` states outright: *"Operations return `{ data }` or
`{ failure }`. Preserve this shape and error `type` values in
`EncryptionErrorTypes`."*
This entry THREW until #741. That was drift, not a design decision: nothing
about WASM prevents it (`@byteslice/result` is already bundled into
`dist/wasm-inline.js` — see `tsup.config.ts` `noExternal`), and the
divergence just meant edge code had to be written in a different shape from
every other surface, with failures that were easy to miss. Aligned before
1.0 so it never had to be a breaking change afterwards.
`isEncrypted` is the one exception, and stays a plain `boolean`: it is a
pure predicate with nothing to fail at, exactly as on the native entry.
The model helpers run the SAME traversal the native entry uses
(`@/encryption/helpers/model-traversal` — shared, not ported, so the two
entries cannot drift on which fields get encrypted), and each call is one
ZeroKMS round trip regardless of how many fields or models it covers. What
still differs from the native surface is deliberate and local: failures come
back as this entry's `{ failure }` Results (rather than a thenable operation
with `.audit()`).
There is also no `.withLockContext()` here, and that one is a **gap, not a
design decision** (#797). An earlier version of this comment said
identity-bound encryption is "configured at client construction via
`config.authStrategy` instead" (#663 context). That is wrong, and the
conflation is worth naming because it is the one people arrive with:
an auth strategy decides WHO THE CLIENT IS; a lock context decides WHO CAN
RETRIEVE A VALUE'S DATA KEY (the claim from the encrypting caller's service
token is bound to the key, and retrieval requires presenting the same
claim). They are orthogonal, and only the first exists on this entry.
The consequences are silent, which is why they are stated here rather than
left to a failed decrypt: values written from this entry carry no identity
condition on key retrieval — any client with keyset access can decrypt
them — even when the client is authenticated as an end user, and this
entry cannot read anything the native entry wrote under a lock context,
since key retrieval requires the same claim. `skills/stash-auth` is
canonical for the model; `skills/stash-edge` documents this entry's gap.
The binding accepts a lock context on both paths — `lockContext` is an
option field on the single calls and per-payload-item on the bulk ones — so
closing this is plumbing rather than a new capability. It is not plumbed
here yet, and shipping it would want a live round-trip test first: a wrong
or missing claim surfaces as a failed decrypt, not a key error.
Construct via [Encryption](https://cipherstash.com/docs/reference/stack/api-reference/wasm-inline#encryption) — the constructor is private to
prevent callers from wrapping arbitrary objects in this type.
Properties [#properties]
requiresTableForDecrypt [#requirestablefordecrypt]
```ts
readonly requiresTableForDecrypt: true = true;
```
Defined in: [wasm-inline.ts:748](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/wasm-inline.ts#L748)
This client's `decryptModel` / `bulkDecryptModels` REQUIRE the table — they
resolve date fields from a per-table map and throw without it. The native
clients derive the table from the payloads instead, so callers that hold a
client structurally cannot tell the two apart.
Declared rather than sniffed so the capability is a stated fact, not a
guess about arity or constructor name (#772 review, finding 10).
This does NOT imply the entry cannot serve a legacy EQL v2 read. It once
did: `encryptedDynamoDB` used to omit the table on that path, reaching
`requireTable` with `undefined`. It now forwards the registered v3 table on
every read, v2 storage included — the reconstructor map is keyed by the
current schema either way, and protect-ffi's `decrypt` accepts both wire
generations regardless of the client's `eqlVersion`.
Methods [#methods-2]
encrypt() [#encrypt]
```ts
encrypt(plaintext, opts): Promise<WasmResult<EncryptedPayload>>;
```
Defined in: [wasm-inline.ts:806](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/wasm-inline.ts#L806)
Parameters [#parameters-2]
plaintext [#plaintext]
[`WasmPlaintext`](https://cipherstash.com/docs/reference/stack/api-reference/wasm-inline#wasmplaintext)
opts [#opts]
[`WasmEncryptOptions`](https://cipherstash.com/docs/reference/stack/api-reference/wasm-inline#wasmencryptoptions)
Returns [#returns-6]
`Promise`\<[`WasmResult`](https://cipherstash.com/docs/reference/stack/api-reference/wasm-inline#wasmresult)\<`EncryptedPayload`>>
decrypt() [#decrypt]
```ts
decrypt(encrypted): Promise<WasmResult<WasmPlaintext>>;
```
Defined in: [wasm-inline.ts:837](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/wasm-inline.ts#L837)
Decrypt a single stored payload, resolving to the plaintext union unchanged.
**A `date` / `timestamp` column comes back as the string it was stored as,
not a `Date`** — where `decryptModel(row, table)` reconstructs it via
datePropertyPaths. Same boundary the native client draws, and for
the same reason: reconstruction is a property of the MODEL path, which is
handed a table to read `cast_as` from. Not because the identity is missing
— every payload carries `i: { t, c }` — but because this method's declared
plaintext union excludes `Date`, and returning one would make the type a
lie (#779). Read through the model helpers, or `new Date(value)` yourself.
Parameters [#parameters-3]
encrypted [#encrypted]
`EncryptedPayload`
Returns [#returns-7]
`Promise`\<[`WasmResult`](https://cipherstash.com/docs/reference/stack/api-reference/wasm-inline#wasmresult)\<[`WasmPlaintext`](https://cipherstash.com/docs/reference/stack/api-reference/wasm-inline#wasmplaintext)>>
isEncrypted() [#isencrypted]
```ts
isEncrypted(value): boolean;
```
Defined in: [wasm-inline.ts:850](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/wasm-inline.ts#L850)
Parameters [#parameters-4]
value [#value]
`unknown`
Returns [#returns-8]
`boolean`
encryptQuery() [#encryptquery]
```ts
encryptQuery(plaintext, opts): Promise<WasmResult<
| EncryptedQuery
| null>>;
```
Defined in: [wasm-inline.ts:929](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/wasm-inline.ts#L929)
Encrypt a QUERY TERM (search needle) for a queryable v3 column —
equality, free-text match, ORE range, or JSON containment/selector.
The returned term is **ciphertext-free**: it is matched against stored
envelopes, never decrypted, so it is safe to log-scrub less aggressively
than storage payloads (though it still derives from the plaintext).
Interpolate it as a parameter and cast to the column's
`eql_v3.query_<domain>` type to reach the indexed operators — the domain
suffix mirrors the storage domain (`eql_v3_text_eq` →
`eql_v3.query_text_eq`; irregular: `eql_v3_json_search` → `eql_v3.query_json`).
Parameters [#parameters-5]
plaintext [#plaintext-1]
[`WasmPlaintext`](https://cipherstash.com/docs/reference/stack/api-reference/wasm-inline#wasmplaintext)
The search needle. `null`/`undefined` returns `null`
without contacting ZeroKMS (nothing to search for), mirroring the
native client.
opts [#opts-1]
[`WasmEncryptQueryOptions`](https://cipherstash.com/docs/reference/stack/api-reference/wasm-inline#wasmencryptqueryoptions)
Table, column, and (optionally) which index to target —
see [WasmEncryptQueryOptions.queryType](https://cipherstash.com/docs/reference/stack/api-reference/wasm-inline#querytype) for the inference rules.
Returns [#returns-9]
`Promise`\<[`WasmResult`](https://cipherstash.com/docs/reference/stack/api-reference/wasm-inline#wasmresult)\<
\| [`EncryptedQuery`](https://cipherstash.com/docs/reference/stack/api-reference/types-public#encryptedquery)
\| `null`>>
`{ data }` with the v3 query term (or `null` for null
plaintext), or `{ failure }` when the requested `queryType` isn't
configured on the column, the column has no indexes at all, the value
fails the same pre-flight validation the native client runs (NaN /
Infinity / out-of-int64 bigint, or a numeric value against a
`freeTextSearch` index), or encryption fails.
Examples [#examples]
```ts
const term = await client.encryptQuery("alice@example.com", {
table: users, column: users.email, queryType: "equality",
})
if (term.failure) throw new Error(term.failure.message)
// postgres-js — bind the unwrapped term, not the Result:
sql`SELECT * FROM users
WHERE email = ${term.data}::jsonb::eql_v3.query_text_eq`
```
```ts
const term = await client.encryptQuery("needle", {
table: users, column: users.bio, queryType: "freeTextSearch",
})
if (term.failure) throw new Error(term.failure.message)
sql`SELECT * FROM users
WHERE eql_v3.matches(bio, ${term.data}::jsonb::eql_v3.query_text_search)`
```
```ts
const term = await client.encryptQuery(42, {
table: users, column: users.age, queryType: "orderAndRange",
})
if (term.failure) throw new Error(term.failure.message)
sql`SELECT * FROM users
WHERE eql_v3.gte(age, ${term.data}::jsonb::eql_v3.query_integer_ord)`
```
```ts
// Object value → containment needle (a v3 envelope):
const contains = await client.encryptQuery({ role: "admin" }, {
table: users, column: users.prefs, queryType: "searchableJson",
})
if (contains.failure) throw new Error(contains.failure.message)
sql`SELECT * FROM users
WHERE prefs @> ${contains.data}::jsonb::eql_v3.query_json`
// String value → JSONPath selector. NOTE: v3 has no encrypted-selector
// envelope — this returns the BARE selector-hash string, bound as the
// text argument of -> / ->>:
const selector = await client.encryptQuery("$.role", {
table: users, column: users.prefs, queryType: "searchableJson",
})
if (selector.failure) throw new Error(selector.failure.message)
sql`SELECT prefs -> ${selector.data} FROM users`
```
encryptQueryBulk() [#encryptquerybulk]
```ts
encryptQueryBulk(terms): Promise<WasmResult<(
| EncryptedQuery
| null)[]>>;
```
Defined in: [wasm-inline.ts:971](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/wasm-inline.ts#L971)
Batch form of [encryptQuery](https://cipherstash.com/docs/reference/stack/api-reference/wasm-inline#encryptquery) — one ZeroKMS round trip for many
terms, which is the shape query builders want (encrypt every needle in
a WHERE clause together).
Position-stable: the result array is index-aligned with `terms`, and a
`null`/`undefined` value yields `null` at the same index (an all-null
batch short-circuits without calling ZeroKMS). Terms may mix query
types and columns freely.
Parameters [#parameters-6]
terms [#terms]
readonly [`WasmQueryTerm`](https://cipherstash.com/docs/reference/stack/api-reference/wasm-inline#wasmqueryterm)\[]
The needles to encrypt; see [WasmQueryTerm](https://cipherstash.com/docs/reference/stack/api-reference/wasm-inline#wasmqueryterm).
Returns [#returns-10]
`Promise`\<[`WasmResult`](https://cipherstash.com/docs/reference/stack/api-reference/wasm-inline#wasmresult)\<(
\| [`EncryptedQuery`](https://cipherstash.com/docs/reference/stack/api-reference/types-public#encryptedquery)
\| `null`)\[]>>
`{ data }` with an index-aligned array of v3 query terms (`null`
per null value), or `{ failure }` — the first invalid term aborts the
batch, as [encryptQuery](https://cipherstash.com/docs/reference/stack/api-reference/wasm-inline#encryptquery).
Example [#example]
```ts
const terms = await client.encryptQueryBulk([
{ value: "alice@example.com", table: users, column: users.email,
queryType: "equality" },
{ value: "needle", table: users, column: users.bio,
queryType: "freeTextSearch" },
])
if (terms.failure) throw new Error(terms.failure.message)
const [emailEq, bioMatch] = terms.data
```
bulkEncrypt() [#bulkencrypt]
```ts
bulkEncrypt(items): Promise<WasmResult<(EncryptedPayload | null)[]>>;
```
Defined in: [wasm-inline.ts:1040](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/wasm-inline.ts#L1040)
Encrypt many storage values in ONE ZeroKMS round trip.
Without this, an edge function writing N rows pays N round trips — the
property `AGENTS.md` calls out ("prefer bulk operations to exercise
ZeroKMS bulk speed") was unreachable from the WASM entry entirely (#737).
Position-stable: the result is index-aligned with `items`, and a
`null`/`undefined` plaintext yields `null` at the same index without
being sent to ZeroKMS (an all-null batch short-circuits entirely).
Entries may mix tables and columns freely — see [WasmBulkPlaintext](https://cipherstash.com/docs/reference/stack/api-reference/wasm-inline#wasmbulkplaintext).
How this differs from the native bulkEncrypt [#how-this-differs-from-the-native-bulkencrypt]
The failure shape is the SAME — `{ data } | { failure }`, per
`AGENTS.md` — but the batch shape differs: the Node entry takes one
column for the whole batch and wraps values in `{ id, plaintext }`
envelopes, where this takes per-item routing and plain values.
That divergence is about capability, not convention. Per-item routing is
what makes the round-trip saving real (one call covers several columns
across many rows), and the `id` bookkeeping buys nothing once positions
are stable — the FFI's `EncryptPayload` has no `id` field, so the native
one is dropped at the boundary anyway.
Parameters [#parameters-7]
items [#items]
readonly [`WasmBulkPlaintext`](https://cipherstash.com/docs/reference/stack/api-reference/wasm-inline#wasmbulkplaintext)\[]
Values to encrypt, each with its own table and column.
Returns [#returns-11]
`Promise`\<[`WasmResult`](https://cipherstash.com/docs/reference/stack/api-reference/wasm-inline#wasmresult)\<(`EncryptedPayload` | `null`)\[]>>
`{ data }` with an index-aligned array of storage payloads
(`null` per null input), or `{ failure }`. The batch is all-or-nothing:
ZeroKMS rejects the call as a whole, so there is no per-item error to
report (unlike [bulkDecrypt](https://cipherstash.com/docs/reference/stack/api-reference/wasm-inline#bulkdecrypt), whose FFI primitive IS fallible).
Example [#example-1]
```ts
const rows = [{ email: "a@b.com", bio: "hi" }, { email: "c@d.com", bio: "yo" }]
const encrypted = await client.bulkEncrypt(
rows.flatMap((r) => [
{ plaintext: r.email, table: users, column: users.email },
{ plaintext: r.bio, table: users, column: users.bio },
]),
)
if (encrypted.failure) throw new Error(encrypted.failure.message)
// encrypted.data[0] = email of row 0, [1] = bio of row 0, …
```
bulkDecrypt() [#bulkdecrypt]
```ts
bulkDecrypt(ciphertexts): Promise<WasmResult<WasmPlaintext[]>>;
```
Defined in: [wasm-inline.ts:1110](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/wasm-inline.ts#L1110)
Decrypt many stored payloads in ONE ZeroKMS round trip.
This is the half that matters most on the edge: rendering a list of N
encrypted rows cost N round trips before this existed, which is what made
list endpoints impractical on Deno / Workers (#737).
Position-stable, same contract as [bulkEncrypt](https://cipherstash.com/docs/reference/stack/api-reference/wasm-inline#bulkencrypt): index-aligned with
`ciphertexts`, `null`/`undefined` passes through as `null` without
reaching ZeroKMS, and an all-null batch short-circuits.
Partial failure [#partial-failure]
The underlying primitive is `decryptBulkFallible`, which reports success
or failure PER ITEM — one undecryptable row does not fail the call at the
FFI level. Any failure still collapses the whole call into a single
`{ failure }`, but its message names EVERY failed index and reason rather
than surfacing the first and discarding the rest. So a caller debugging
one bad row in a page of 50 learns which row, and that the other 49 were
fine.
(A per-item `Result[]` would preserve the partial success too, and is
worth considering if callers ask for it — but it is a different return
type from every other method here, so it is not the default.)
No date reconstruction [#no-date-reconstruction]
Same boundary as [decrypt](https://cipherstash.com/docs/reference/stack/api-reference/wasm-inline#decrypt): date-like columns arrive as their stored
strings, not `Date` values. Prefer [bulkDecryptModels](https://cipherstash.com/docs/reference/stack/api-reference/wasm-inline#bulkdecryptmodels) with the table
when you want the column's declared plaintext type back (#779).
Parameters [#parameters-8]
ciphertexts [#ciphertexts]
readonly (`EncryptedPayload` | `null` | `undefined`)\[]
Stored payloads; `null`/`undefined` entries allowed.
Returns [#returns-12]
`Promise`\<[`WasmResult`](https://cipherstash.com/docs/reference/stack/api-reference/wasm-inline#wasmresult)\<[`WasmPlaintext`](https://cipherstash.com/docs/reference/stack/api-reference/wasm-inline#wasmplaintext)\[]>>
`{ data }` with an index-aligned array of plaintexts (`null` per
null input), or `{ failure }` naming each failing index and its reason.
Example [#example-2]
```ts
const rows = await sql`SELECT email FROM users LIMIT 50`
const emails = await client.bulkDecrypt(rows.map((r) => r.email))
if (emails.failure) throw new Error(emails.failure.message)
// one ZeroKMS call, not 50
```
encryptModel() [#encryptmodel]
```ts
encryptModel<Table, T>(model, table): Promise<WasmResult<V3EncryptedModel<Table, T>>>;
```
Defined in: [wasm-inline.ts:1188](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/wasm-inline.ts#L1188)
Encrypt a model's schema-declared fields in ONE ZeroKMS round trip.
Walks `model` against `table`'s columns — matched by JS property name,
nested fields via a column's dotted path (`'profile.ssn'`) — and encrypts
exactly the declared fields. Everything else passes through untouched,
and a `null`/`undefined` schema field is preserved as-is without
reaching ZeroKMS. The traversal is the native entry's own, shared from
`@/encryption/helpers/model-traversal` (#742): a column added to the
schema is picked up by construction, instead of by remembering to extend
a hand-written `bulkEncrypt` mapping — the failure mode of that mapping
is a field that silently persists in PLAINTEXT.
`Date` plaintexts (date/timestamp domains) are sent as ISO-8601 strings —
[WasmPlaintext](https://cipherstash.com/docs/reference/stack/api-reference/wasm-inline#wasmplaintext) carries no `Date` across the WASM serde boundary —
and [decryptModel](https://cipherstash.com/docs/reference/stack/api-reference/wasm-inline#decryptmodel) rebuilds them into `Date` values on the way out.
Type Parameters [#type-parameters]
Table [#table]
`Table` *extends* [`AnyV3Table`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#anyv3table)
T [#t]
`T` *extends* `Record`\<`string`, `unknown`>
Parameters [#parameters-9]
model [#model]
[`V3ModelInput`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#v3modelinput)\<`Table`, `T`>
table [#table-1]
`Table`
Returns [#returns-13]
`Promise`\<[`WasmResult`](https://cipherstash.com/docs/reference/stack/api-reference/wasm-inline#wasmresult)\<[`V3EncryptedModel`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#v3encryptedmodel)\<`Table`, `T`>>>
Example [#example-3]
```ts
const row = await client.encryptModel(
{ id: 1, email: "alice@example.com", verified: true },
users,
)
if (row.failure) throw new Error(row.failure.message)
// row.data = { id: 1, email: <EQL envelope>, verified: true }
```
bulkEncryptModels() [#bulkencryptmodels]
```ts
bulkEncryptModels<Table, T>(models, table): Promise<WasmResult<V3EncryptedModel<Table, T>[]>>;
```
Defined in: [wasm-inline.ts:1214](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/wasm-inline.ts#L1214)
Encrypt many models in ONE ZeroKMS round trip — [encryptModel](https://cipherstash.com/docs/reference/stack/api-reference/wasm-inline#encryptmodel)'s
traversal applied per model, with every collected field across every
model batched into a single FFI call. N models × M columns is still one
crossing, the same economics as [bulkEncrypt](https://cipherstash.com/docs/reference/stack/api-reference/wasm-inline#bulkencrypt).
The result array is index-aligned with `models`. An empty input returns
`{ data: [] }` without contacting ZeroKMS.
Type Parameters [#type-parameters-1]
Table [#table-2]
`Table` *extends* [`AnyV3Table`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#anyv3table)
T [#t-1]
`T` *extends* `Record`\<`string`, `unknown`>
Parameters [#parameters-10]
models [#models]
[`V3ModelInput`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#v3modelinput)\<`Table`, `T`>\[]
table [#table-3]
`Table`
Returns [#returns-14]
`Promise`\<[`WasmResult`](https://cipherstash.com/docs/reference/stack/api-reference/wasm-inline#wasmresult)\<[`V3EncryptedModel`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#v3encryptedmodel)\<`Table`, `T`>\[]>>
decryptModel() [#decryptmodel]
```ts
decryptModel<Table, T>(model, table): Promise<WasmResult<V3ModelInput<Table, T>>>;
```
Defined in: [wasm-inline.ts:1250](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/wasm-inline.ts#L1250)
Decrypt every encrypted payload in a model, in ONE ZeroKMS round trip.
Schema-blind on the way in — any value that IS an EQL envelope is
decrypted, wherever it nests; everything else (nulls included) passes
through untouched, and the caller's model is never mutated. Schema-aware
on the way out: `table`'s date-like columns (`date` / `timestamp` domains,
matched by JS property name) are rebuilt into `Date` values, so a value
this client encrypted round-trips `Date` → `Date`. `table` must be one the
client was initialized with, else the call fails (as the native client).
Partial failure [#partial-failure-1]
Built on the same per-item-fallible primitive as [bulkDecrypt](https://cipherstash.com/docs/reference/stack/api-reference/wasm-inline#bulkdecrypt):
one undecryptable field does not mask the rest. Any failure collapses to
a single `{ failure }` whose message names EVERY failed field by its
path in the model (e.g. `profile.ssn`), with its per-item code.
Type Parameters [#type-parameters-2]
Table [#table-4]
`Table` *extends* [`AnyV3Table`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#anyv3table)
T [#t-2]
`T` *extends* `Record`\<`string`, `unknown`>
Parameters [#parameters-11]
model [#model-1]
`T`
table [#table-5]
`Table`
Returns [#returns-15]
`Promise`\<[`WasmResult`](https://cipherstash.com/docs/reference/stack/api-reference/wasm-inline#wasmresult)\<[`V3ModelInput`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#v3modelinput)\<`Table`, `T`>>>
bulkDecryptModels() [#bulkdecryptmodels]
```ts
bulkDecryptModels<Table, T>(models, table): Promise<WasmResult<V3ModelInput<Table, T>[]>>;
```
Defined in: [wasm-inline.ts:1272](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/wasm-inline.ts#L1272)
Decrypt many models in ONE ZeroKMS round trip — [decryptModel](https://cipherstash.com/docs/reference/stack/api-reference/wasm-inline#decryptmodel)
across a list, which is the shape a page of database rows arrives in.
The result array is index-aligned with `models`; an empty input returns
`{ data: [] }` without contacting ZeroKMS. Failures are reported for
every bad field across the whole batch, labelled `[model <i>] <field>`.
Type Parameters [#type-parameters-3]
Table [#table-6]
`Table` *extends* [`AnyV3Table`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#anyv3table)
T [#t-3]
`T` *extends* `Record`\<`string`, `unknown`>
Parameters [#parameters-12]
models [#models-1]
`T`\[]
table [#table-7]
`Table`
Returns [#returns-16]
`Promise`\<[`WasmResult`](https://cipherstash.com/docs/reference/stack/api-reference/wasm-inline#wasmresult)\<[`V3ModelInput`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#v3modelinput)\<`Table`, `T`>\[]>>
Type Aliases [#type-aliases]
WasmPlaintext [#wasmplaintext]
```ts
type WasmPlaintext =
| string
| number
| bigint
| boolean
| null
| Record<string, unknown>
| WasmPlaintext[];
```
Defined in: [wasm-inline.ts:191](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/wasm-inline.ts#L191)
The plaintext shape accepted by `encrypt` and returned by `decrypt`.
Mirrors protect-ffi's `JsPlaintext` (recursive: arrays of any of
these are valid), plus `bigint` for `int8` columns. Re-defined here so
the wasm-inline `.d.ts` doesn't pull in the Node-only protect-ffi types.
`bigint` is carried natively across the wasm boundary by protect-ffi
0.28's Rust `encode_plaintext` (which i64-bounds-checks on encrypt and
builds a `js_sys::BigInt` on decrypt), so widening the type here is all
the SDK needs to accept/return `bigint` on the wasm entry point.
***
WasmClientConfig [#wasmclientconfig]
```ts
type WasmClientConfig = {
clientId: string;
clientKey: string;
eqlVersion?: never;
} &
| {
workspaceCrn: string;
accessKey: string;
authStrategy?: never;
strategy?: never;
}
| {
workspaceCrn?: string;
accessKey?: never;
authStrategy: WasmAuthStrategy;
strategy?: WasmAuthStrategy;
}
| {
workspaceCrn?: string;
accessKey?: never;
authStrategy?: never;
strategy: WasmAuthStrategy;
};
```
Defined in: [wasm-inline.ts:221](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/wasm-inline.ts#L221)
Config for [Encryption](https://cipherstash.com/docs/reference/stack/api-reference/wasm-inline#encryption) on the WASM entry point.
The workspace CRN is the single source of truth for workspace
identity and deployment region — matching the Node entry and
protect-ffi 0.25+, which read `CS_WORKSPACE_CRN` and no longer
consult a separate `CS_REGION`. The CRN is passed straight to the
underlying `AccessKeyStrategy`, which derives the region from it, so
there is no `region` field to keep in sync.
For service-to-service / CI use, pass `accessKey` plus the workspace
`clientId` / `clientKey` and we construct an `AccessKeyStrategy` for
you. To plug in a custom token store (cookies on Supabase Edge, KV on
Cloudflare Workers, …) or to bind encryption to an end user, build the
strategy yourself — `AccessKeyStrategy` or `OidcFederationStrategy` —
and hand it to `config.authStrategy` instead. A pre-built strategy
already carries the CRN, so `workspaceCrn` is optional on that path.
Mirrors the Node `ClientConfig`: `authStrategy` is the documented field,
`strategy` is retained as a deprecated alias (see below).
Type Declaration [#type-declaration]
clientId [#clientid]
```ts
clientId: string;
```
Workspace client identifier — required by the WASM client.
clientKey [#clientkey]
```ts
clientKey: string;
```
Workspace client key — required by the WASM client.
eqlVersion? [#eqlversion]
```ts
optional eqlVersion: never;
```
Removed: this entry always emits EQL v3. Declared as `never` rather than
omitted because excess-property checking — the only thing that caught a
leftover `eqlVersion` — fires on FRESH object literals alone. A shared
config const, which is what a v2 → v3 migration actually holds, therefore
type-checked clean and then hit the runtime guard in [Encryption](https://cipherstash.com/docs/reference/stack/api-reference/wasm-inline#encryption).
On the shared base so it applies across all three auth arms below; a copy
per arm would drift. Mirrors `ClientConfig.eqlVersion` on the native entry,
whose guard this one is a byte-for-byte mirror of — the type is defence in
depth for the JS/JSON callers that bypass it, not a replacement.
As on the native entry, `?: never` still admits `eqlVersion: undefined`
without `exactOptionalPropertyTypes` (not enabled in this repo) and cannot
be made to reject it, so the runtime tolerates that one value and rejects
every real one.
***
WasmAuthStrategy [#wasmauthstrategy]
```ts
type WasmAuthStrategy =
| AccessKeyStrategy
| OidcFederationStrategy;
```
Defined in: [wasm-inline.ts:303](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/wasm-inline.ts#L303)
Any auth strategy accepted on the WASM path. Both expose
`getToken(): Promise<Result<TokenResult, AuthFailure>>` — as of
`@cipherstash/auth` 0.41 the token is wrapped in a `@byteslice/result`
envelope. `@cipherstash/protect-ffi` 0.28+ unwraps that envelope (reading
`.data.token`, surfacing `.failure`) inside its WASM `newClient`; 0.27 read
`.token` off the envelope and saw `undefined`, so keep the ffi floor at 0.28.
* [AccessKeyStrategy](https://cipherstash.com/docs/reference/stack/api-reference/wasm-inline#accesskeystrategy) — static M2M / CI access key.
* [OidcFederationStrategy](https://cipherstash.com/docs/reference/stack/api-reference/wasm-inline#oidcfederationstrategy) — federates an end-user OIDC JWT into a
CTS service token, for per-user identity-bound encryption.
***
WasmEncryptionConfig [#wasmencryptionconfig]
```ts
type WasmEncryptionConfig = {
schemas: readonly [AnyV3Table, ...AnyV3Table[]];
config: WasmClientConfig;
};
```
Defined in: [wasm-inline.ts:305](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/wasm-inline.ts#L305)
Properties [#properties-1]
schemas [#schemas]
```ts
schemas: readonly [AnyV3Table, ...AnyV3Table[]];
```
Defined in: [wasm-inline.ts:320](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/wasm-inline.ts#L320)
One or more EQL v3 tables, authored with `types` / `encryptedTable` from
this entry. The WASM entry is EQL v3 only.
`readonly` (not the mutable tuple this once was) for the same reason the
native entry was widened in A-4: a mutable tuple rejects every shape that
is not an array literal — a shared `export const all: AnyV3Table[]`, a
`ReadonlyArray`, anything spread. But non-emptiness stays HERE rather than
moving entirely onto the [Encryption](https://cipherstash.com/docs/reference/stack/api-reference/wasm-inline#encryption) overloads: a loose
`readonly AnyV3Table[]` on the exported type laundered an empty set past
both overloads, because `NonEmptyV3<readonly AnyV3Table[]>` resolves
`S['length']` to `number`, not `0`. A config object built once and passed
around — precisely what this type exists for — then reached the runtime
throw with a clean typecheck. The overloads still accept widened arrays
passed INLINE, which is the case A-4 was actually about.
config [#config]
```ts
config: WasmClientConfig;
```
Defined in: [wasm-inline.ts:321](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/wasm-inline.ts#L321)
***
WasmEncryptOptions [#wasmencryptoptions]
```ts
type WasmEncryptOptions = {
table: AnyV3Table;
column: AnyEncryptedV3Column;
};
```
Defined in: [wasm-inline.ts:335](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/wasm-inline.ts#L335)
Properties [#properties-2]
table [#table-8]
```ts
table: AnyV3Table;
```
Defined in: [wasm-inline.ts:336](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/wasm-inline.ts#L336)
column [#column]
```ts
column: AnyEncryptedV3Column;
```
Defined in: [wasm-inline.ts:337](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/wasm-inline.ts#L337)
***
WasmEncryptQueryOptions [#wasmencryptqueryoptions]
```ts
type WasmEncryptQueryOptions = {
table: AnyV3Table;
column: WasmQueryableV3Column;
queryType?: QueryTypeName;
};
```
Defined in: [wasm-inline.ts:352](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/wasm-inline.ts#L352)
Options for [WasmEncryptionClient.encryptQuery](https://cipherstash.com/docs/reference/stack/api-reference/wasm-inline#encryptquery).
The column must be a QUERYABLE v3 column (authored via the `types.*`
factories re-exported from this entry) — storage-only columns like
`types.Text` with no indexes have nothing to query.
Properties [#properties-3]
table [#table-9]
```ts
table: AnyV3Table;
```
Defined in: [wasm-inline.ts:354](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/wasm-inline.ts#L354)
The `encryptedTable(...)` the column belongs to.
column [#column-1]
```ts
column: WasmQueryableV3Column;
```
Defined in: [wasm-inline.ts:356](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/wasm-inline.ts#L356)
The queryable v3 column the term targets, e.g. `users.email`.
queryType? [#querytype]
```ts
optional queryType: QueryTypeName;
```
Defined in: [wasm-inline.ts:375](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/wasm-inline.ts#L375)
Which of the column's indexes the term targets:
* `'equality'` — exact match (`unique` index; `=` / `IN`)
* `'freeTextSearch'` — fuzzy token match (`match` index; one-sided —
a match may be a false positive, a non-match never is)
* `'orderAndRange'` — comparisons and ranges (`ore` index; `<` `>`
`BETWEEN` / `ORDER BY`)
* `'searchableJson'` — encrypted JSON (`ste_vec` index): a **string**
value is treated as a JSONPath selector (`'$.user.email'`), any other
value as a containment needle (`{ role: 'admin' }`)
Omit to infer from the column's configured indexes (priority:
`unique > match > ore > ste_vec`, matching the native client) —
unambiguous for single-index columns like `types.TextEq`, but be
explicit for multi-index domains like `types.TextSearch` (which
carries all three scalar indexes).
***
WasmQueryTerm [#wasmqueryterm]
```ts
type WasmQueryTerm = WasmEncryptQueryOptions & {
value: WasmPlaintext;
};
```
Defined in: [wasm-inline.ts:384](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/wasm-inline.ts#L384)
One term for [WasmEncryptionClient.encryptQueryBulk](https://cipherstash.com/docs/reference/stack/api-reference/wasm-inline#encryptquerybulk) — the
[WasmEncryptQueryOptions](https://cipherstash.com/docs/reference/stack/api-reference/wasm-inline#wasmencryptqueryoptions) plus the plaintext needle. A `null`
value yields `null` at the same position in the result (nothing to
search for).
Type Declaration [#type-declaration-1]
value [#value-1]
```ts
value: WasmPlaintext;
```
***
WasmBulkPlaintext [#wasmbulkplaintext]
```ts
type WasmBulkPlaintext = {
plaintext: | WasmPlaintext
| undefined;
table: AnyV3Table;
column: AnyEncryptedV3Column;
};
```
Defined in: [wasm-inline.ts:403](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/wasm-inline.ts#L403)
One storage value in a [WasmEncryptionClient.bulkEncrypt](https://cipherstash.com/docs/reference/stack/api-reference/wasm-inline#bulkencrypt) batch.
Each entry carries its OWN table and column, rather than the batch taking a
single `WasmEncryptOptions` the way [WasmEncryptionClient.encrypt](https://cipherstash.com/docs/reference/stack/api-reference/wasm-inline#encrypt) does.
That mirrors [WasmQueryTerm](https://cipherstash.com/docs/reference/stack/api-reference/wasm-inline#wasmqueryterm) — and it is what makes the round-trip
saving worth having: rendering a page of rows means encrypting several
columns across many rows, and a single-column batch would still cost one
ZeroKMS call per column. The FFI's `EncryptPayload` is per-item
(`{ plaintext, table, column }`), so mixing is free at the boundary.
(The native entry's `bulkEncrypt` takes one column for the whole batch and
wraps values in `{ id, plaintext }` envelopes. This surface does neither —
see [WasmEncryptionClient.bulkEncrypt](https://cipherstash.com/docs/reference/stack/api-reference/wasm-inline#bulkencrypt) for why.)
Properties [#properties-4]
plaintext [#plaintext-2]
```ts
plaintext:
| WasmPlaintext
| undefined;
```
Defined in: [wasm-inline.ts:415](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/wasm-inline.ts#L415)
The value to encrypt. `null`/`undefined` yields `null` at this index
without reaching ZeroKMS.
`undefined` is admitted explicitly — unlike [WasmQueryTerm.value](https://cipherstash.com/docs/reference/stack/api-reference/wasm-inline#wasmqueryterm),
which is `WasmPlaintext` alone. Both are guarded identically at runtime,
but the shapes fed to them differ: a query needle is written by hand,
whereas a bulk batch is mapped straight off database rows, where an
absent column is `undefined`. Typing it out would force `?? null` at
every call site to satisfy a check the runtime does anyway.
table [#table-10]
```ts
table: AnyV3Table;
```
Defined in: [wasm-inline.ts:416](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/wasm-inline.ts#L416)
column [#column-2]
```ts
column: AnyEncryptedV3Column;
```
Defined in: [wasm-inline.ts:417](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/wasm-inline.ts#L417)
***
WasmResult [#wasmresult]
```ts
type WasmResult<T> =
| {
data: T;
failure?: never;
}
| {
data?: never;
failure: EncryptionError;
};
```
Defined in: [wasm-inline.ts:444](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/wasm-inline.ts#L444)
The `{ data } | { failure }` envelope every fallible method here returns.
Structurally identical to `@byteslice/result`'s `Result<T, EncryptionError>`
— which is what `withResult` actually produces — but declared LOCALLY on
purpose, for the same reason [WasmPlaintext](https://cipherstash.com/docs/reference/stack/api-reference/wasm-inline#wasmplaintext) re-declares protect-ffi's
`JsPlaintext`: `@byteslice/result` is bundled into `dist/wasm-inline.js`
(tsup `noExternal`), so it is not a package an edge consumer can resolve.
Re-exporting its type put `import { Result } from '@byteslice/result'` at the
top of the emitted `.d.ts`, which a Deno consumer cannot resolve at all — the
e2e import map maps only the three `/wasm-inline` subpaths.
Declaring it here keeps the published types self-contained.
Type Parameters [#type-parameters-4]
T [#t-4]
`T`
Functions [#functions]
isEncrypted() [#isencrypted-1]
```ts
function isEncrypted(value): boolean;
```
Defined in: [wasm-inline.ts:165](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/wasm-inline.ts#L165)
Re-exported convenience predicate — same as the raw protect-ffi one.
Parameters [#parameters-13]
value [#value-2]
`unknown`
Returns [#returns-17]
`boolean`
***
Encryption() [#encryption]
Call Signature [#call-signature]
```ts
function Encryption<S>(config): Promise<WasmEncryptionClient>;
```
Defined in: [wasm-inline.ts:1460](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/wasm-inline.ts#L1460)
Initialize a WASM-backed encryption client.
Mirrors the Node entry's import('./encryption').Encryption
factory, but constructs the protect-ffi client via the WASM strategy
API. Use from Deno / Edge / Workers / Bun.
Type Parameters [#type-parameters-5]
S [#s]
`S` *extends* readonly \[[`AnyV3Table`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#anyv3table), [`AnyV3Table`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#anyv3table)]
Parameters [#parameters-14]
config [#config-1]
schemas [#schemas-1]
`S`
config [#config-2]
[`WasmClientConfig`](https://cipherstash.com/docs/reference/stack/api-reference/wasm-inline#wasmclientconfig)
Returns [#returns-18]
`Promise`\<[`WasmEncryptionClient`](https://cipherstash.com/docs/reference/stack/api-reference/wasm-inline#wasmencryptionclient)>
Call Signature [#call-signature-1]
```ts
function Encryption<S>(config): Promise<WasmEncryptionClient>;
```
Defined in: [wasm-inline.ts:1466](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/wasm-inline.ts#L1466)
Initialize a WASM-backed encryption client.
Mirrors the Node entry's import('./encryption').Encryption
factory, but constructs the protect-ffi client via the WASM strategy
API. Use from Deno / Edge / Workers / Bun.
Type Parameters [#type-parameters-6]
S [#s-1]
`S` *extends* readonly [`AnyV3Table`](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#anyv3table)\[]
Parameters [#parameters-15]
config [#config-3]
schemas [#schemas-2]
`NonEmptyV3`\<`S`>
config [#config-4]
[`WasmClientConfig`](https://cipherstash.com/docs/reference/stack/api-reference/wasm-inline#wasmclientconfig)
Returns [#returns-19]
`Promise`\<[`WasmEncryptionClient`](https://cipherstash.com/docs/reference/stack/api-reference/wasm-inline#wasmencryptionclient)>
***
toWasmFfiPlaintext() [#towasmffiplaintext]
```ts
function toWasmFfiPlaintext(value): unknown;
```
Defined in: [wasm-inline.ts:1625](https://github.com/cipherstash/stack/blob/a3198ebc60b432e173522f12263406594fab2e1d/packages/stack/src/wasm-inline.ts#L1625)
Normalise a value for the wasm serde boundary, applied at EVERY encrypt/query
crossing (#742 review — previously only the model path did this).
A JS `Date` has no enumerable own properties, so wasm-bindgen carries it
across as `{}` — silent corruption of every `date`/`timestamp` column.
Serialise it to RFC 3339 (which protect-ffi's `parse_naive_date` accepts for
both casts, yielding the same canonical value as the native Date-object
path) and reject an invalid `Date` rather than emit `"Invalid Date"`.
`WasmPlaintext` excludes `Date` so TS callers are already stopped; this is
the runtime guard for plain-JS callers, the same belt-and-braces rationale
`assertValidNumericValue` uses on the numeric path. Everything else passes
through unchanged.
Parameters [#parameters-16]
value [#value-3]
`unknown`
Returns [#returns-20]
`unknown`
References [#references]
AnyEncryptedV3Column [#anyencryptedv3column]
Re-exports [AnyEncryptedV3Column](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#anyencryptedv3column)
***
EncryptedV3TableColumn [#encryptedv3tablecolumn]
Re-exports [EncryptedV3TableColumn](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptedv3tablecolumn)
***
EqlTypeForColumn [#eqltypeforcolumn]
Re-exports [EqlTypeForColumn](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#eqltypeforcolumn)
***
JsonDocument [#jsondocument]
Re-exports [JsonDocument](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#jsondocument)
***
JsonValue [#jsonvalue]
Re-exports [JsonValue](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#jsonvalue)
***
PlaintextForColumn [#plaintextforcolumn]
Re-exports [PlaintextForColumn](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#plaintextforcolumn)
***
QueryCapabilities [#querycapabilities]
Re-exports [QueryCapabilities](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#querycapabilities)
***
QueryTypesForColumn [#querytypesforcolumn]
Re-exports [QueryTypesForColumn](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#querytypesforcolumn)
***
EncryptedBigintColumn [#encryptedbigintcolumn]
Re-exports [EncryptedBigintColumn](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptedbigintcolumn)
***
EncryptedBigintEqColumn [#encryptedbiginteqcolumn]
Re-exports [EncryptedBigintEqColumn](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptedbiginteqcolumn)
***
EncryptedBigintOrdColumn [#encryptedbigintordcolumn]
Re-exports [EncryptedBigintOrdColumn](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptedbigintordcolumn)
***
EncryptedBigintOrdOreColumn [#encryptedbigintordorecolumn]
Re-exports [EncryptedBigintOrdOreColumn](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptedbigintordorecolumn)
***
EncryptedBooleanColumn [#encryptedbooleancolumn]
Re-exports [EncryptedBooleanColumn](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptedbooleancolumn)
***
EncryptedDateColumn [#encrypteddatecolumn]
Re-exports [EncryptedDateColumn](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encrypteddatecolumn)
***
EncryptedDateEqColumn [#encrypteddateeqcolumn]
Re-exports [EncryptedDateEqColumn](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encrypteddateeqcolumn)
***
EncryptedDateOrdColumn [#encrypteddateordcolumn]
Re-exports [EncryptedDateOrdColumn](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encrypteddateordcolumn)
***
EncryptedDateOrdOreColumn [#encrypteddateordorecolumn]
Re-exports [EncryptedDateOrdOreColumn](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encrypteddateordorecolumn)
***
EncryptedDoubleColumn [#encrypteddoublecolumn]
Re-exports [EncryptedDoubleColumn](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encrypteddoublecolumn)
***
EncryptedDoubleEqColumn [#encrypteddoubleeqcolumn]
Re-exports [EncryptedDoubleEqColumn](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encrypteddoubleeqcolumn)
***
EncryptedDoubleOrdColumn [#encrypteddoubleordcolumn]
Re-exports [EncryptedDoubleOrdColumn](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encrypteddoubleordcolumn)
***
EncryptedDoubleOrdOreColumn [#encrypteddoubleordorecolumn]
Re-exports [EncryptedDoubleOrdOreColumn](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encrypteddoubleordorecolumn)
***
EncryptedIntegerColumn [#encryptedintegercolumn]
Re-exports [EncryptedIntegerColumn](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptedintegercolumn)
***
EncryptedIntegerEqColumn [#encryptedintegereqcolumn]
Re-exports [EncryptedIntegerEqColumn](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptedintegereqcolumn)
***
EncryptedIntegerOrdColumn [#encryptedintegerordcolumn]
Re-exports [EncryptedIntegerOrdColumn](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptedintegerordcolumn)
***
EncryptedIntegerOrdOreColumn [#encryptedintegerordorecolumn]
Re-exports [EncryptedIntegerOrdOreColumn](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptedintegerordorecolumn)
***
EncryptedJsonColumn [#encryptedjsoncolumn]
Re-exports [EncryptedJsonColumn](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptedjsoncolumn)
***
EncryptedNumericColumn [#encryptednumericcolumn]
Re-exports [EncryptedNumericColumn](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptednumericcolumn)
***
EncryptedNumericEqColumn [#encryptednumericeqcolumn]
Re-exports [EncryptedNumericEqColumn](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptednumericeqcolumn)
***
EncryptedNumericOrdColumn [#encryptednumericordcolumn]
Re-exports [EncryptedNumericOrdColumn](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptednumericordcolumn)
***
EncryptedNumericOrdOreColumn [#encryptednumericordorecolumn]
Re-exports [EncryptedNumericOrdOreColumn](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptednumericordorecolumn)
***
EncryptedRealColumn [#encryptedrealcolumn]
Re-exports [EncryptedRealColumn](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptedrealcolumn)
***
EncryptedRealEqColumn [#encryptedrealeqcolumn]
Re-exports [EncryptedRealEqColumn](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptedrealeqcolumn)
***
EncryptedRealOrdColumn [#encryptedrealordcolumn]
Re-exports [EncryptedRealOrdColumn](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptedrealordcolumn)
***
EncryptedRealOrdOreColumn [#encryptedrealordorecolumn]
Re-exports [EncryptedRealOrdOreColumn](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptedrealordorecolumn)
***
EncryptedSmallintColumn [#encryptedsmallintcolumn]
Re-exports [EncryptedSmallintColumn](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptedsmallintcolumn)
***
EncryptedSmallintEqColumn [#encryptedsmallinteqcolumn]
Re-exports [EncryptedSmallintEqColumn](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptedsmallinteqcolumn)
***
EncryptedSmallintOrdColumn [#encryptedsmallintordcolumn]
Re-exports [EncryptedSmallintOrdColumn](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptedsmallintordcolumn)
***
EncryptedSmallintOrdOreColumn [#encryptedsmallintordorecolumn]
Re-exports [EncryptedSmallintOrdOreColumn](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptedsmallintordorecolumn)
***
EncryptedTextColumn [#encryptedtextcolumn]
Re-exports [EncryptedTextColumn](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptedtextcolumn)
***
EncryptedTextEqColumn [#encryptedtexteqcolumn]
Re-exports [EncryptedTextEqColumn](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptedtexteqcolumn)
***
EncryptedTextMatchColumn [#encryptedtextmatchcolumn]
Re-exports [EncryptedTextMatchColumn](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptedtextmatchcolumn)
***
EncryptedTextOrdColumn [#encryptedtextordcolumn]
Re-exports [EncryptedTextOrdColumn](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptedtextordcolumn)
***
EncryptedTextOrdOreColumn [#encryptedtextordorecolumn]
Re-exports [EncryptedTextOrdOreColumn](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptedtextordorecolumn)
***
EncryptedTextSearchColumn [#encryptedtextsearchcolumn]
Re-exports [EncryptedTextSearchColumn](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptedtextsearchcolumn)
***
EncryptedTimestampColumn [#encryptedtimestampcolumn]
Re-exports [EncryptedTimestampColumn](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptedtimestampcolumn)
***
EncryptedTimestampEqColumn [#encryptedtimestampeqcolumn]
Re-exports [EncryptedTimestampEqColumn](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptedtimestampeqcolumn)
***
EncryptedTimestampOrdColumn [#encryptedtimestampordcolumn]
Re-exports [EncryptedTimestampOrdColumn](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptedtimestampordcolumn)
***
EncryptedTimestampOrdOreColumn [#encryptedtimestampordorecolumn]
Re-exports [EncryptedTimestampOrdOreColumn](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptedtimestampordorecolumn)
***
TEXT_SEARCH_EQL_TYPE [#text_search_eql_type]
Re-exports [TEXT\_SEARCH\_EQL\_TYPE](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#text_search_eql_type)
***
AnyV3Table [#anyv3table]
Re-exports [AnyV3Table](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#anyv3table)
***
ColumnsOf [#columnsof]
Re-exports [ColumnsOf](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#columnsof)
***
InferEncrypted [#inferencrypted]
Re-exports [InferEncrypted](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#inferencrypted)
***
InferPlaintext [#inferplaintext]
Re-exports [InferPlaintext](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#inferplaintext)
***
QueryableColumnsOf [#queryablecolumnsof]
Re-exports [QueryableColumnsOf](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#queryablecolumnsof)
***
V3DecryptedModel [#v3decryptedmodel]
Re-exports [V3DecryptedModel](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#v3decryptedmodel)
***
V3EncryptedModel [#v3encryptedmodel]
Re-exports [V3EncryptedModel](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#v3encryptedmodel)
***
V3ModelInput [#v3modelinput]
Re-exports [V3ModelInput](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#v3modelinput)
***
buildEncryptConfig [#buildencryptconfig]
Re-exports [buildEncryptConfig](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#buildencryptconfig)
***
EncryptedTable [#encryptedtable]
Re-exports [EncryptedTable](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptedtable)
***
encryptedTable [#encryptedtable-1]
Re-exports [encryptedTable](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#encryptedtable-1)
***
types [#types]
Re-exports [types](https://cipherstash.com/docs/reference/stack/api-reference/eql.v3#types)
***
EncryptionError [#encryptionerror]
Re-exports [EncryptionError](https://cipherstash.com/docs/reference/stack/api-reference/errors#encryptionerror-1)
***
EncryptionErrorTypes [#encryptionerrortypes]
Re-exports [EncryptionErrorTypes](https://cipherstash.com/docs/reference/stack/api-reference/errors#encryptionerrortypes)
***
Encrypted [#encrypted-1]
Re-exports [Encrypted](https://cipherstash.com/docs/reference/stack/api-reference/Package-exports#encrypted)
# CipherStash Documentation
Source: https://cipherstash.com/docs/stack
CipherStash is Data Level Access Control for Postgres. Encrypt fields, query ciphertext, bind keys to identities, and audit every access. Zero-knowledge by design.
```bash
npx stash init
```
One command. Device-based authentication, no environment variables for local dev. See the [Getting started](https://cipherstash.com/docs/stack/quickstart) guide.
Choose your path [#choose-your-path]
Two integration paths. Same key hierarchy, same encryption, same audit trail.
| | TypeScript SDK | CipherStash Proxy |
| ---------------- | -------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------- |
| **How it works** | Encryption SDK and CLI available as an NPM package | Postgres Encryption - Postgres wire protocol Proxy built on top of the Encryption SDK to transparently encrypt data in Postgres |
| **Best for** | Teams moving quickly and building TypeScript apps | More complex app architectures or non TypeScript applications using Postgres |
| **Language** | TypeScript / JavaScript (Node.js, Deno, Bun) | Any language (connects via PostgreSQL wire protocol) |
| **Setup** | `npx stash init` | Docker container or binary |
Most teams start with the **SDK** for the best developer experience.
Get started [#get-started]
Products [#products]
Operations [#operations]
How it fits together [#how-it-fits-together]
Everything builds on [ZeroKMS](https://cipherstash.com/docs/stack/cipherstash/kms) and its core primitive, the [Keyset](https://cipherstash.com/docs/stack/cipherstash/kms/keysets). A keyset is the unit of isolation.
* **[Encryption](https://cipherstash.com/docs/stack/cipherstash/encryption)** uses keysets for [tenant isolation](https://cipherstash.com/docs/stack/cipherstash/encryption/configuration#keysets). One keyset per customer. Provable cryptographic separation.
* **Secrets (coming soon)** uses keysets for environment isolation. Production, staging, and development secrets can never cross boundaries.
* **[Proxy](https://cipherstash.com/docs/stack/cipherstash/proxy)** encrypts data transparently via PostgreSQL, backed by the same ZeroKMS key hierarchy.
Understand the architecture [#understand-the-architecture]
# Quickstart
Source: https://cipherstash.com/docs/stack/quickstart
CipherStash encrypts your data at the field level. Every value gets its own key, bound to an identity. A breach, a compromised agent, a curious insider — they all see ciphertext with no key.
Here's how to set it up. Works with any Postgres — Supabase, Neon, RDS, a Docker container, whatever.
Set up your project [#set-up-your-project]
The CLI handles install, database setup, and encryption scaffolding as three explicit save-points.
Step 1: Initialize [#step-1-initialize]
```bash
npx stash init
```
This opens a browser for device-based authentication. No shared secrets, no environment variables for local dev. Init:
1. Authenticates your device and connects to your workspace
2. Resolves your database connection and installs the EQL extension
3. Scaffolds an encryption client at `./src/encryption/index.ts`
4. Installs `@cipherstash/stack` and `stash` if not already present
5. Writes `.cipherstash/context.json` with detected facts about your project
When init finishes, it prompts: `Continue to stash plan now?` (default-yes).
Step 2: Draft a plan [#step-2-draft-a-plan]
```bash
npx stash plan
```
Hands off to a coding agent (Claude Code, Codex, or others) which reads your project and writes `.cipherstash/plan.md`. The plan lists the tables and columns to encrypt and whether each column is new or needs migration from plaintext. Review the plan before proceeding.
Step 3: Implement [#step-3-implement]
```bash
npx stash impl
```
Reads the plan, shows a summary panel, asks you to confirm, then dispatches to an agent to make the changes.
Define your encryption schema [#define-your-encryption-schema]
After `stash plan` produces the plan, the agent edits `./src/encryption/index.ts` based on your project. The file defines which columns to encrypt:
```typescript filename="src/encryption/index.ts"
import { encryptedTable, encryptedColumn } from "@cipherstash/stack"
export const users = encryptedTable("users", {
email: encryptedColumn("email")
.equality() // WHERE email = ?
.freeTextSearch() // WHERE email LIKE '%alice%'
})
```
Each column gets its own encryption key. The index methods (`.equality()`, `.freeTextSearch()`, `.orderAndRange()`) define what queries work on the encrypted data.
Encrypt a value [#encrypt-a-value]
```typescript filename="src/encrypt.ts"
import { Encryption } from "@cipherstash/stack"
import { users } from "./encryption/schema"
const enc = await Encryption({ schemas: [users] })
const encrypted = await enc.encrypt("alice@example.com", {
column: users.email,
table: users,
})
// encrypted.data is ciphertext — store it in your database
```
Store it [#store-it]
Use any database client, ORM, or raw SQL:
```sql
INSERT INTO users (email) VALUES ($1)
-- $1 is encrypted.data (ciphertext)
```
Query encrypted data [#query-encrypted-data]
Encrypt your search term, then query as usual:
```typescript filename="src/query.ts"
const query = await enc.encryptQuery("alice@example.com", {
column: users.email,
table: users,
})
// Use query.data in a WHERE clause — Postgres searches ciphertext
```
```sql
SELECT * FROM users WHERE cs_match_v1(email) = $1
-- $1 is query.data
```
The database never sees plaintext. The query runs over encrypted indexes.
Decrypt [#decrypt]
```typescript filename="src/decrypt.ts"
const result = await enc.decrypt(row.email, {
column: users.email,
table: users,
})
console.log(result.data) // "alice@example.com"
```
What you just built [#what-you-just-built]
You encrypted a field, stored it, queried it without decrypting, and got the plaintext back. Here's what happened under the hood:
* **ZeroKMS** derived a unique encryption key for the value. The key was created on your device and never stored anywhere.
* **Your client key** — the unit of identity — is the only thing that can decrypt it. Another client key, a stolen credential, an AI agent running on application credentials — none of them have the key.
* **Your keyset** — the unit of isolation — defines the cryptographic boundary. Data encrypted under one keyset cannot be decrypted with another. Use keysets to isolate tenants, environments, or services.
* **The encrypted index** lets Postgres evaluate queries without decrypting. The index terms are themselves encrypted — they reveal nothing about the plaintext.
This is Data Level Access Control. The rules aren't configured in a policy file. They're enforced in the cryptography.
Next steps [#next-steps]
**Using Drizzle ORM?** The [Drizzle integration](https://cipherstash.com/docs/stack/cipherstash/encryption/drizzle) adds encrypted column types and query operators so your Drizzle code looks normal.
**Using the Supabase JS SDK?** The [Supabase integration](https://cipherstash.com/docs/stack/cipherstash/encryption/supabase) wraps the Supabase client with automatic encryption.
**Secrets (coming soon).** End-to-end encrypted config without .env files. [Join the waitlist](https://cipherstash.com/stack/secrets).
**Ready to deploy?** [Going to production](https://cipherstash.com/docs/stack/deploy/going-to-production) covers the switch from device auth to environment variables.
**Manage your workspace.** [Open the dashboard](https://dashboard.cipherstash.com/workspaces) to view keysets, create client keys, manage access keys, and check usage.
# Deploying to AWS ECS
Source: https://cipherstash.com/docs/stack/deploy/aws-ecs
Deploying CipherStash Proxy to AWS ECS [#deploying-cipherstash-proxy-to-aws-ecs]
Prerequisites [#prerequisites]
* **AWS Account**: An active [AWS account](https://aws.amazon.com/account/)
* **AWS CLI**: Installed and configured with appropriate permissions ([install guide](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html))
* **Docker**: [Installed](https://docs.docker.com/engine/install/) if you need to push the image to ECR
* **CipherStash Proxy config**: Refer to the [Proxy config reference](https://github.com/cipherstash/proxy/blob/main/docs/reference/index.md)
* **AWS RDS instance**: A [PostgreSQL RDS instance](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Welcome.html) in the same VPC as your ECS cluster
Set up CipherStash credentials [#set-up-cipherstash-credentials]
You need CipherStash credentials for your production Proxy deployment. Create an application client key and access key in the Dashboard — see [Going to production](https://cipherstash.com/docs/stack/deploy/going-to-production) for the full guide.
You will need:
* `CS_WORKSPACE_CRN` — your workspace identifier
* `CS_CLIENT_ID` — application client ID
* `CS_CLIENT_KEY` — application client key
* `CS_CLIENT_ACCESS_KEY` — access key with the **member** role
Note these credentials. You need them in later steps.
Prepare your Docker image [#prepare-your-docker-image]
Docker images are available from:
* [AWS Marketplace](https://aws.amazon.com/marketplace/pp/prodview-x4kffsfxcrreg)
* [Docker Hub](https://hub.docker.com/r/cipherstash/proxy)
If using Docker Hub, push the image to Amazon ECR:
```bash
# Ensure you have set these environment variables:
# export AWS_ACCOUNT_ID=111222333444
# export AWS_REGION=ap-southeast-2
set -u
aws ecr create-repository --repository-name cipherstash-proxy
aws ecr get-login-password | docker login \
--username AWS \
--password-stdin $AWS_ACCOUNT_ID.dkr.ecr.$AWS_REGION.amazonaws.com
docker tag cipherstash/proxy:latest \
$AWS_ACCOUNT_ID.dkr.ecr.$AWS_REGION.amazonaws.com/cipherstash-proxy:latest
docker push \
$AWS_ACCOUNT_ID.dkr.ecr.$AWS_REGION.amazonaws.com/cipherstash-proxy:latest
```
Create secrets [#create-secrets]
Using the credentials from Step 1, create `cipherstash-proxy-secrets.json`:
```json
{
"CS_WORKSPACE_ID": "...",
"CS_CLIENT_ID": "...",
"CS_DEFAULT_KEYSET_ID": "...",
"CS_CLIENT_KEY": "...",
"CS_CLIENT_ACCESS_KEY": "...",
"CS_DATABASE__PASSWORD": "..."
}
```
The value of `CS_DATABASE__PASSWORD` is the password of your PostgreSQL RDS instance.
Create the secret in Secrets Manager:
```bash
aws secretsmanager create-secret \
--name cipherstash-proxy \
--secret-string file://cipherstash-proxy-secrets.json
```
Note the ARN. You need it for the task definition.
Set up IAM roles and permissions [#set-up-iam-roles-and-permissions]
Trust policy [#trust-policy]
Create `ecs-tasks-trust-policy.json`:
```json
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "",
"Effect": "Allow",
"Principal": {
"Service": "ecs-tasks.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
```
Create the IAM role:
```bash
aws iam create-role \
--role-name ecsTaskExecutionRole \
--assume-role-policy-document file://ecs-tasks-trust-policy.json
```
Inline policy [#inline-policy]
Create `cipherstash-proxy-ecs-policy.json`, substituting the ARN of your Secrets Manager secret:
```json
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"secretsmanager:GetSecretValue",
"kms:Decrypt"
],
"Resource": [
"ARN_OF_SECRETSMANAGER_SECRET"
]
}
]
}
```
Attach the inline policy:
```bash
aws iam put-role-policy \
--role-name ecsTaskExecutionRole \
--policy-name CipherStashProxyECSPolicy \
--policy-document file://cipherstash-proxy-ecs-policy.json
```
Managed policy [#managed-policy]
Attach the ECS task execution managed policy:
```bash
aws iam attach-role-policy \
--role-name ecsTaskExecutionRole \
--policy-arn arn:aws:iam::aws:policy/service-role/AmazonECSTaskExecutionRolePolicy
```
Create an ECS task definition [#create-an-ecs-task-definition]
Create `cipherstash-proxy-task-def.json`, replacing placeholders with values from previous steps:
```json
{
"family": "cipherstash-proxy",
"networkMode": "awsvpc",
"executionRoleArn": "ARN_OF_ROLE",
"cpu": "256",
"memory": "512",
"containerDefinitions": [
{
"name": "cipherstash-proxy",
"image": "IMAGE_FROM_STEP_2",
"essential": true,
"portMappings": [
{ "containerPort": 6432, "hostPort": 6432 },
{ "containerPort": 9930, "hostPort": 9930 }
],
"environment": [
{ "name": "CS_DATABASE__USERNAME", "value": "RDS_USERNAME" },
{ "name": "CS_DATABASE__NAME", "value": "RDS_DATABASE_NAME" },
{ "name": "CS_DATABASE__HOST", "value": "RDS_HOSTNAME" },
{ "name": "CS_DATABASE__PORT", "value": "RDS_PORT" },
{ "name": "CS_PROMETHEUS__ENABLED", "value": "true" },
{ "name": "CS_DATABASE__INSTALL_EQL", "value": "true" }
],
"secrets": [
{ "name": "CS_WORKSPACE_ID", "valueFrom": "SECRET_ARN:CS_WORKSPACE_ID::" },
{ "name": "CS_CLIENT_ID", "valueFrom": "SECRET_ARN:CS_CLIENT_ID::" },
{ "name": "CS_DEFAULT_KEYSET_ID", "valueFrom": "SECRET_ARN:CS_DEFAULT_KEYSET_ID::" },
{ "name": "CS_CLIENT_KEY", "valueFrom": "SECRET_ARN:CS_CLIENT_KEY::" },
{ "name": "CS_CLIENT_ACCESS_KEY", "valueFrom": "SECRET_ARN:CS_CLIENT_ACCESS_KEY::" },
{ "name": "CS_DATABASE__PASSWORD", "valueFrom": "SECRET_ARN:CS_DATABASE__PASSWORD::" }
],
"logConfiguration": {
"logDriver": "awslogs",
"options": {
"awslogs-group": "cipherstash-proxy",
"awslogs-region": "AWS_REGION",
"awslogs-stream-prefix": "cipherstash-proxy"
}
}
}
],
"requiresCompatibilities": ["FARGATE"],
"runtimePlatform": {
"operatingSystemFamily": "LINUX",
"cpuArchitecture": "ARM64"
}
}
```
Register the task definition:
```bash
aws ecs register-task-definition \
--cli-input-json file://cipherstash-proxy-task-def.json
```
Create an ECS cluster and service [#create-an-ecs-cluster-and-service]
Create the cluster and log group:
```bash
aws ecs create-cluster --cluster-name ecs-app
aws logs create-log-group --log-group-name cipherstash-proxy
```
Create an ECS service (ensure you have the subnet and security group of your RDS instance):
```bash
# Ensure you have set these environment variables:
# export SUBNETS=subnet-xxx
# export SECURITY_GROUP=sg-xxx
aws ecs create-service \
--cluster ecs-app \
--service-name CipherStashProxy \
--task-definition cipherstash-proxy \
--desired-count 1 \
--launch-type FARGATE \
--network-configuration "awsvpcConfiguration={subnets=[$SUBNETS],securityGroups=[$SECURITY_GROUP],assignPublicIp=ENABLED}"
```
Verify the deployment [#verify-the-deployment]
Check the service and task status:
```bash
# List services running in the cluster
aws ecs list-services --cluster ecs-app
# Show details of CipherStashProxy service
aws ecs describe-services --cluster ecs-app --services CipherStashProxy
# Tail the logs
aws logs tail --since 6h --follow cipherstash-proxy
```
Notes and considerations [#notes-and-considerations]
* **Security**: Store secrets (keys and passwords) in AWS Secrets Manager or Parameter Store, not in environment variables or task definitions.
* **Networking**: Configure security groups and subnets so your ECS tasks can reach your RDS instance.
* **Scaling**: Monitor ECS service metrics and adjust `desired-count` based on load.
# Bundling
Source: https://cipherstash.com/docs/stack/deploy/bundling
`@cipherstash/stack` is a native Node.js module that relies on native `require` to load platform-specific binaries at runtime. It cannot be processed by bundlers like webpack or esbuild. You must exclude it from bundling.
**You must exclude `@cipherstash/stack` from bundling.**
`@cipherstash/stack` uses Node.js-specific features and requires the [native Node.js `require`](https://nodejs.org/api/modules.html#requireid). Bundlers that attempt to inline or transform it will break the native addon loading.
Next.js [#nextjs]
Next.js bundles Server Components by default. You need to tell Next.js to skip `@cipherstash/stack` and use native `require` instead.
Next.js 15+ [#nextjs-15]
Add `@cipherstash/stack` to `serverExternalPackages` in your `next.config.ts`:
```typescript filename="next.config.ts"
const nextConfig = {
serverExternalPackages: ["@cipherstash/stack"],
}
export default nextConfig
```
See the [Next.js serverExternalPackages documentation](https://nextjs.org/docs/app/api-reference/config/next-config-js/serverExternalPackages) for more details.
Next.js 14 [#nextjs-14]
Use the experimental configuration in `next.config.mjs`:
```javascript filename="next.config.mjs"
const nextConfig = {
experimental: {
serverComponentsExternalPackages: ["@cipherstash/stack"],
},
}
export default nextConfig
```
See the [Next.js 14 serverComponentsExternalPackages documentation](https://nextjs.org/docs/14/app/api-reference/next-config-js/serverComponentsExternalPackages) for more details.
webpack [#webpack]
Configure `externals` in your `webpack.config.js`:
```javascript filename="webpack.config.js"
module.exports = {
externals: {
"@cipherstash/stack": "commonjs @cipherstash/stack",
},
}
```
This tells webpack to leave `require('@cipherstash/stack')` as-is in the output instead of trying to resolve and bundle the module.
esbuild [#esbuild]
Use the `--external` flag:
```bash
esbuild app.js --bundle --external:@cipherstash/stack --platform=node
```
Or in your build configuration:
```javascript filename="build.js"
require("esbuild").build({
entryPoints: ["app.js"],
bundle: true,
external: ["@cipherstash/stack"],
platform: "node",
outfile: "out.js",
})
```
SST and AWS Lambda [#sst-and-aws-lambda]
When deploying with [SST](https://sst.dev/), configure esbuild externals and install the package into the Lambda deployment bundle:
```typescript filename="sst.config.ts"
{
nodejs: {
esbuild: {
external: ["@cipherstash/stack"],
},
install: ["@cipherstash/stack"],
},
}
```
The `external` option prevents esbuild from bundling the package. The `install` option ensures it gets installed into the Lambda deployment artifact so it's available at runtime.
See the [SST Function documentation](https://sst.dev/docs/component/aws/function/#nodejs) for more details.
Troubleshooting Linux deployments [#troubleshooting-linux-deployments]
Some npm users experience deployment failures on Linux (e.g., AWS Lambda, Docker containers) when their `package-lock.json` was created on macOS or Windows.
Who is affected [#who-is-affected]
* You use `npm ci` in CI/CD
* Your `package-lock.json` is version 3 and was generated on macOS/Windows
* You deploy on Linux (Lambda, containers, EC2, etc.)
Symptoms [#symptoms]
Build succeeds, but the app fails to start on Linux with an error like:
* `failed to load native addon`
* `module not found` related to the native engine
Why this happens [#why-this-happens]
With `package-lock.json` version 3, npm only records optional native binaries for the platform that created the lockfile. Linux builds can miss the native engine that `@cipherstash/stack` needs at runtime.
Solutions [#solutions]
Option 1: Use bun (recommended) [#option-1-use-bun-recommended]
bun installs the correct native binaries for each platform automatically:
```bash
bun install --frozen-lockfile
```
Option 2: Generate lockfile on Linux in CI [#option-2-generate-lockfile-on-linux-in-ci]
Ensure the Linux build records what Linux needs:
```bash
rm -f package-lock.json
npm install --package-lock-only --ignore-scripts \
--no-audit --no-fund --platform=linux --arch=x64
npm ci
```
Alternative using environment variables:
```bash
npm_config_platform=linux npm_config_arch=x64 \
npm install --package-lock-only --ignore-scripts --no-audit --no-fund
npm ci
```
Option 3: Pin lockfile to version 2 [#option-3-pin-lockfile-to-version-2]
Keep using npm but pin lockfile v2 (npm 8):
Locally:
```bash
npm install --package-lock-only --lockfile-version=2
```
In CI:
```bash
npm i -g npm@8
npm ci
```
Quick verification [#quick-verification]
Before deploying to Linux, verify the native engine loads by running your app inside a Linux container or CI job.
# Going to production
Source: https://cipherstash.com/docs/stack/deploy/going-to-production
Local development uses device-based authentication — each developer is uniquely identified via `npx stash init`.
Production and CI/CD environments don't have a physical device or interactive login, so they use environment variables instead.
How auth differs between environments [#how-auth-differs-between-environments]
| Environment | Auth mechanism | How it works |
| ------------------ | --------------------- | --------------------------------------------------------------------------- |
| Local development | Device-based | `npx stash init` creates a device and client key. No env vars needed. |
| CI/CD pipelines | Environment variables | Application client key identified by `CS_CLIENT_ID` and `CS_CLIENT_KEY`. |
| Production hosting | Environment variables | Same as CI/CD. Application client keys have keyset access without a device. |
Setting up production credentials [#setting-up-production-credentials]
Create an application client key [#create-an-application-client-key]
In the [CipherStash Dashboard](https://dashboard.cipherstash.com), navigate to **Clients** and create a new client key.
This is an **application client key** — it has no device attached and is identified solely by its client ID and key.
Save the **Client ID** and **Client Key**. The client key is shown only once.
Create an access key [#create-an-access-key]
Navigate to **Access Keys** and create a new access key.
Use the **member** role for production workloads. This follows the principle of least privilege and only allows encrypt/decrypt operations.
| Role | Use case |
| ----------- | ---------------------------------------------------------- |
| **Member** | Application workloads — encrypt, decrypt, list keysets |
| **Control** | Infrastructure automation — manage keysets and client keys |
| **Admin** | Full access. Not recommended for production. |
Save the **access key**. It is shown only once.
See [Access keys](https://cipherstash.com/docs/stack/cipherstash/kms/access-keys) for details on roles and scopes.
Grant keyset access [#grant-keyset-access]
Ensure the application client key has access to the appropriate keyset(s).
By default, new client keys are granted access to the **default keyset**.
For multi-tenant deployments, grant access to specific keysets as needed.
See [Keysets](https://cipherstash.com/docs/stack/cipherstash/kms/keysets) for details on managing keyset access.
Set environment variables [#set-environment-variables]
In your hosting platform or CI/CD system, set the following environment variables:
```bash
CS_WORKSPACE_CRN=crn:region.aws:your-workspace-id
CS_CLIENT_ID=your-application-client-id
CS_CLIENT_KEY=your-application-client-key
CS_CLIENT_ACCESS_KEY=your-access-key
```
These four variables are required for all CipherStash products (Encryption SDK, Secrets, and Proxy) in production.
Set a writable config path (if needed) [#set-a-writable-config-path-if-needed]
In serverless or containerized environments, the default config directory may not be writable.
Set `CS_CONFIG_PATH` to a writable location:
```bash
CS_CONFIG_PATH=/tmp/.cipherstash
```
This has been tested on Vercel, AWS Lambda, and Docker containers.
CI/CD pipeline examples [#cicd-pipeline-examples]
GitHub Actions [#github-actions]
```yaml filename=".github/workflows/deploy.yml"
env:
CS_WORKSPACE_CRN: ${{ secrets.CS_WORKSPACE_CRN }}
CS_CLIENT_ID: ${{ secrets.CS_CLIENT_ID }}
CS_CLIENT_KEY: ${{ secrets.CS_CLIENT_KEY }}
CS_CLIENT_ACCESS_KEY: ${{ secrets.CS_CLIENT_ACCESS_KEY }}
```
Docker [#docker]
```bash filename=".env.production"
CS_WORKSPACE_CRN=crn:region.aws:your-workspace-id
CS_CLIENT_ID=your-application-client-id
CS_CLIENT_KEY=your-application-client-key
CS_CLIENT_ACCESS_KEY=your-access-key
```
```yaml filename="docker-compose.yml"
services:
app:
env_file:
- .env.production
```
Never commit `.env.production` or any file containing credentials to version control.
Add it to your `.gitignore`.
Avoid using environment variables locally [#avoid-using-environment-variables-locally]
Setting `CS_*` environment variables for local development is an anti-pattern.
Device-based auth provides:
* **Per-developer identity** — audit trails show who performed each operation
* **No shared secrets** — each developer has their own device credentials
* **Automatic session management** — no manual credential rotation
If you have `CS_*` variables in a local `.env` file, remove them and run `npx stash init` instead.
Bundler configuration [#bundler-configuration]
Production deployments often require bundler configuration to ensure `@cipherstash/stack` is not bundled with your application code.
See [Bundling](https://cipherstash.com/docs/stack/deploy/bundling) for setup instructions for Next.js, webpack, esbuild, and SST.
Next steps [#next-steps]
* [Bundling for production](https://cipherstash.com/docs/stack/deploy/bundling) — Configure your bundler for deployment
* [Deploying Proxy to AWS ECS](https://cipherstash.com/docs/stack/deploy/aws-ecs) — Run CipherStash Proxy in production
* [Access keys](https://cipherstash.com/docs/stack/cipherstash/kms/access-keys) — Understand access key roles and scopes
* [Team onboarding](https://cipherstash.com/docs/stack/deploy/team-onboarding) — Set up per-developer access for your team
# Deploy
Source: https://cipherstash.com/docs/stack/deploy
Local dev uses device-based authentication. Production uses environment variables and application client keys. This section covers the transition.
* **[Going to production](https://cipherstash.com/docs/stack/deploy/going-to-production)** — Switch from device auth to environment variables.
* **[Team onboarding](https://cipherstash.com/docs/stack/deploy/team-onboarding)** — Set up per-developer access.
* **[Bundling](https://cipherstash.com/docs/stack/deploy/bundling)** — Configure webpack, esbuild, Next.js, and other build tools.
* **[SST](https://cipherstash.com/docs/stack/deploy/sst)** — SST and serverless configuration.
* **[Testing](https://cipherstash.com/docs/stack/deploy/testing)** — Test applications that use encryption.
* **[AWS ECS](https://cipherstash.com/docs/stack/deploy/aws-ecs)** — Deploy CipherStash Proxy to ECS.
* **[Troubleshooting](https://cipherstash.com/docs/stack/deploy/troubleshooting)** — Common issues and fixes.
# SST
Source: https://cipherstash.com/docs/stack/deploy/sst
When deploying `@cipherstash/stack` in serverless functions with [SST](https://sst.dev/), you need to exclude the package from esbuild bundling and install it into the Lambda deployment artifact.
Configure `nodejs.esbuild.external` and `nodejs.install` in your `sst.config.ts`:
```typescript title="sst.config.ts"
{
nodejs: {
esbuild: {
external: ["@cipherstash/stack"],
},
install: ["@cipherstash/stack"],
},
}
```
The `external` option prevents esbuild from bundling the package. The `install` option ensures it gets installed into the Lambda deployment artifact so it's available at runtime.
See the [SST Function documentation](https://sst.dev/docs/component/aws/function/#nodejs) for more details.
For other bundler configurations (webpack, esbuild, Next.js) and Linux deployment troubleshooting, see [Bundling](https://cipherstash.com/docs/stack/deploy/bundling).
# Team onboarding
Source: https://cipherstash.com/docs/stack/deploy/team-onboarding
Every developer on your team gets their own device and client key when they initialize CipherStash.
This means every encrypt, decrypt, and secret access operation is traceable to a specific developer.
How team access works [#how-team-access-works]
When a developer runs `npx stash init`, CipherStash creates:
* A **device** tied to that developer's user account and device
* A **client key** associated with the device, used for cryptographic operations
* Automatic access to the **default keyset** in your workspace
No credentials are shared between developers.
Each person has their own identity, and access can be granted or revoked individually.
Adding a team member [#adding-a-team-member]
Invite them to your organization [#invite-them-to-your-organization]
In the [CipherStash Dashboard](https://dashboard.cipherstash.com), navigate to **Members** in the organization sidebar.
Add the new team member's email address.
They will receive an invitation to create a CipherStash account (or join with an existing one).
Grant workspace access [#grant-workspace-access]
Once they accept the invitation, grant them access to the relevant workspace(s) in **Settings** for your workspace.
Developer runs init [#developer-runs-init]
The new team member runs the init command on their device:
```bash
npx stash init
```
This authenticates them via the browser, creates their unique device and client key, and grants access to the default keyset.
They are now ready to develop locally with full CipherStash functionality — no environment variables needed.
Managing team access [#managing-team-access]
Viewing active client keys [#viewing-active-client-keys]
Navigate to **Clients** in the Dashboard to see all active client keys, including device-backed client keys created by `npx stash init`.
Each client key shows which developer and device it belongs to.
Revoking a developer's access [#revoking-a-developers-access]
To remove a developer's access:
1. Remove their client key from keyset access in the Dashboard
2. Remove them from the workspace
3. Optionally, remove them from the organization
Revoked client keys can no longer perform encrypt, decrypt, or secret operations.
Multiple devices [#multiple-devices]
If a developer works on more than one device (e.g., a laptop and a desktop), they run `npx stash init` on each device.
Each device gets its own device identity and client key.
This is by design — you can revoke access per device without affecting their other devices.
Relationship to production [#relationship-to-production]
Team devices are for **local development only**.
Production environments use separate [application client keys](https://cipherstash.com/docs/stack/deploy/going-to-production) configured with environment variables.
This separation ensures that:
* Developer credentials never appear in production infrastructure
* Production access is controlled independently from developer access
* Revoking a developer's device does not affect production systems
Next steps [#next-steps]
* [Getting started](https://cipherstash.com/docs/stack/quickstart) — The init guide to share with new team members
* [Going to production](https://cipherstash.com/docs/stack/deploy/going-to-production) — Set up application client keys for deployment
* [Access keys](https://cipherstash.com/docs/stack/cipherstash/kms/access-keys) — Understand access key roles
* [Client keys](https://cipherstash.com/docs/stack/cipherstash/kms/clients) — Learn more about device-backed and application client keys
# Testing
Source: https://cipherstash.com/docs/stack/deploy/testing
This guide covers strategies for testing applications that use CipherStash encryption.
Test environment setup [#test-environment-setup]
CipherStash encryption requires valid credentials to derive keys via ZeroKMS. For testing, you have two options:
Option 1: Use a dedicated test workspace (recommended) [#option-1-use-a-dedicated-test-workspace-recommended]
Create a separate CipherStash workspace for testing. This gives you real encryption behavior with isolated keys that don't affect production.
```bash filename=".env.test"
CS_WORKSPACE_CRN=crn:ap-southeast-2.aws:your-test-workspace-id
CS_CLIENT_ID=your-test-client-id
CS_CLIENT_KEY=your-test-client-key
CS_CLIENT_ACCESS_KEY=your-test-access-key
```
This approach tests the full encryption path including ZeroKMS key derivation.
Option 2: Mock the encryption client [#option-2-mock-the-encryption-client]
For unit tests where you don't need real encryption, mock the client to return predictable values:
```typescript filename="__mocks__/encryption.ts"
import type { InferEncrypted } from "@cipherstash/stack/schema"
export function createMockClient() {
return {
encrypt: async (plaintext: unknown) => ({
data: { __mock: true, plaintext },
}),
decrypt: async (encrypted: unknown) => ({
data: (encrypted as any).plaintext,
}),
encryptModel: async (model: unknown) => ({
data: model,
}),
decryptModel: async (model: unknown) => ({
data: model,
}),
bulkEncrypt: async (items: any[]) => ({
data: items.map(i => ({ id: i.id, data: { __mock: true, plaintext: i.plaintext } })),
}),
bulkDecrypt: async (items: any[]) => ({
data: items.map(i => ({ id: i.id, data: i.plaintext })),
}),
}
}
```
Mocking bypasses all encryption. Use this for testing business logic, not for validating that encryption works correctly. Always run integration tests with a real workspace.
Integration tests with PostgreSQL [#integration-tests-with-postgresql]
For integration tests that verify searchable encryption queries, you need:
1. A PostgreSQL database with [EQL](https://cipherstash.com/docs/stack/reference/eql-guide) installed (see [CipherStash CLI](https://cipherstash.com/docs/stack/cipherstash/cli))
2. A test CipherStash workspace
3. Your schema definitions
```typescript filename="test/setup.ts"
import { Encryption } from "@cipherstash/stack"
import { users } from "../src/schema"
import { Pool } from "pg"
let client: Awaited>
let pool: Pool
beforeAll(async () => {
pool = new Pool({ connectionString: process.env.TEST_DATABASE_URL })
// EQL must be installed before running tests.
// Run `npx stash db install` against your test database first.
// See: /stack/cipherstash/cli
// Initialize encryption client with test credentials
// Encryption() throws on failure, so wrap in try/catch
try {
client = await Encryption({ schemas: [users] })
} catch (error) {
throw new Error(`Test setup failed: ${(error as Error).message}`)
}
})
afterAll(async () => {
await pool.end()
})
```
Testing encrypt and decrypt round-trips [#testing-encrypt-and-decrypt-round-trips]
```typescript filename="test/encryption.test.ts"
test("encrypt and decrypt returns original value", async () => {
const original = "alice@example.com"
const encrypted = await client.encrypt(original, {
column: users.email,
table: users,
})
expect(encrypted.failure).toBeUndefined()
const decrypted = await client.decrypt(encrypted.data)
expect(decrypted.failure).toBeUndefined()
expect(decrypted.data).toBe(original)
})
```
Testing searchable queries [#testing-searchable-queries]
```typescript filename="test/search.test.ts"
test("equality search finds encrypted record", async () => {
// Encrypt and store a value
const encrypted = await client.encrypt("alice@example.com", {
column: users.email,
table: users,
})
await pool.query(
"INSERT INTO users (email) VALUES ($1::jsonb)",
[JSON.stringify(encrypted.data)]
)
// Encrypt the search term
const query = await client.encryptQuery("alice@example.com", {
column: users.email,
table: users,
queryType: "equality",
})
// Query the database
const result = await pool.query(
"SELECT * FROM users WHERE email @> $1::jsonb",
[JSON.stringify(query.data)]
)
expect(result.rows.length).toBe(1)
})
```
CI/CD setup [#cicd-setup]
GitHub Actions [#github-actions]
Store your test credentials as GitHub Actions secrets and expose them as environment variables:
```yaml filename=".github/workflows/test.yml"
name: Tests
on: [push, pull_request]
jobs:
test:
runs-on: ubuntu-latest
services:
postgres:
image: postgres:16
env:
POSTGRES_DB: test
POSTGRES_PASSWORD: postgres
ports:
- 5432:5432
steps:
- uses: actions/checkout@v4
- uses: actions/setup-node@v4
with:
node-version: 20
- run: bun install --frozen-lockfile
- run: bun test
env:
CS_WORKSPACE_CRN: ${{ secrets.CS_TEST_WORKSPACE_CRN }}
CS_CLIENT_ID: ${{ secrets.CS_TEST_CLIENT_ID }}
CS_CLIENT_KEY: ${{ secrets.CS_TEST_CLIENT_KEY }}
CS_CLIENT_ACCESS_KEY: ${{ secrets.CS_TEST_ACCESS_KEY }}
TEST_DATABASE_URL: postgres://postgres:postgres@localhost:5432/test
```
Use a dedicated test workspace with limited access keys. Never use production credentials in CI.
Docker-based tests [#docker-based-tests]
If your CI uses Docker, ensure the native addon loads correctly by using a Linux-compatible lockfile. See [Bundling: Linux deployments](https://cipherstash.com/docs/stack/deploy/bundling#troubleshooting-linux-deployments) for details.
Schema builders in test code [#schema-builders-in-test-code]
The `@cipherstash/stack/client` subpath provides schema builders without the native FFI module. This is useful for importing schemas in client-side test code or test utilities that don't perform encryption:
```typescript filename="test/utils.ts"
import { encryptedTable, encryptedColumn } from "@cipherstash/stack/client"
// This import works without the native addon
const users = encryptedTable("users", {
email: encryptedColumn("email").equality().freeTextSearch(),
})
```
# Troubleshooting
Source: https://cipherstash.com/docs/stack/deploy/troubleshooting
Client initialization fails [#client-initialization-fails]
Missing environment variables [#missing-environment-variables]
The SDK reads `CS_*` environment variables by default. If any are missing, initialization fails with a `ClientInitError`.
```text
ClientInitError: Missing workspace CRN
```
**Fix**: Set all required environment variables:
```bash
CS_WORKSPACE_CRN=crn:ap-southeast-2.aws:your-workspace-id
CS_CLIENT_ID=your-client-id
CS_CLIENT_KEY=your-client-key
CS_CLIENT_ACCESS_KEY=your-access-key
```
Or pass them explicitly in config:
```typescript filename="explicit-config.ts"
const client = await Encryption({
schemas: [users],
config: {
workspaceCrn: "crn:ap-southeast-2.aws:your-workspace-id",
clientId: "your-client-id",
clientKey: "your-client-key",
accessKey: "your-access-key",
},
})
```
ZeroKMS connection timeout [#zerokms-connection-timeout]
If the SDK cannot reach ZeroKMS, initialization times out.
**Check**:
* Your application has outbound HTTPS access
* No firewall or security group is blocking connections to `*.viturhosted.net`
* The region in your `CS_WORKSPACE_CRN` matches your workspace's actual region
No schemas provided [#no-schemas-provided]
The `Encryption()` function requires at least one schema:
```typescript filename="schema-required.ts"
// This will fail
const client = await Encryption({ schemas: [] })
// Provide at least one schema
const client = await Encryption({ schemas: [users] })
```
Decryption errors [#decryption-errors]
Wrong keyset [#wrong-keyset]
Decryption fails if the client uses a different keyset than the one used during encryption. Keysets provide cryptographic isolation.
**Fix**: Ensure the client is configured with the same keyset that was used during encryption. Check the `keyset` option in your config or verify which keyset your client is associated with in the [dashboard](https://cipherstash.com/docs/stack/cipherstash/kms/clients).
Lock context mismatch [#lock-context-mismatch]
If data was encrypted with [identity-aware encryption](https://cipherstash.com/docs/stack/cipherstash/encryption/identity), it can only be decrypted with the same user's identity.
```text
DecryptionError: Lock context mismatch
```
**Fix**: Ensure you're using the same user's JWT for decryption that was used during encryption. The lock context binds encryption to the identity claims in the JWT.
Corrupted or tampered ciphertext [#corrupted-or-tampered-ciphertext]
If the stored ciphertext has been modified, decryption fails. AES-256-GCM-SIV provides authenticated encryption, which detects tampering.
**Fix**: Check that no database triggers, application code, or migrations have modified the encrypted column values.
Search queries return no results [#search-queries-return-no-results]
Missing EQL extension [#missing-eql-extension]
Searchable encryption requires the [EQL PostgreSQL extension](https://cipherstash.com/docs/stack/reference/eql-guide). Without it, queries against encrypted columns won't work.
**Fix**: Install EQL using the [CipherStash CLI](https://cipherstash.com/docs/stack/cipherstash/cli):
```bash
npx stash db install
```
Wrong query type [#wrong-query-type]
If you're searching with the wrong query type for your column's indexes, queries may return no results.
**Check**:
* Using `equality` queries? The column needs `.equality()` in its schema.
* Using `freeTextSearch` queries? The column needs `.freeTextSearch()` in its schema.
* Using `orderAndRange` queries? The column needs `.orderAndRange()` in its schema.
Schema mismatch [#schema-mismatch]
The schema used to encrypt data must match the schema used to encrypt query terms. If you've changed your schema definition (added/removed indexes), existing encrypted data may not be searchable with the new schema.
**Fix**: Re-encrypt existing data with the updated schema if you've changed index configurations.
Native addon fails to load [#native-addon-fails-to-load]
Symptoms [#symptoms]
```text
Error: failed to load native addon
Error: module not found: @cipherstash/protect-ffi
```
Bundler not configured [#bundler-not-configured]
`@cipherstash/stack` uses a native Node.js addon and cannot be processed by bundlers. You must exclude it.
**Fix**: See [Bundling](https://cipherstash.com/docs/stack/deploy/bundling) for configuration for Next.js, webpack, esbuild, and SST.
Linux deployment with npm lockfile v3 [#linux-deployment-with-npm-lockfile-v3]
Some npm users see deployment failures on Linux (e.g., AWS Lambda) when their `package-lock.json` was created on macOS or Windows.
This happens with `package-lock.json` version 3, where npm only records native dependencies for the platform that created the lockfile. Linux builds can miss the native engine that `@cipherstash/stack` needs at runtime.
**Who is affected**:
* You use `npm ci` in CI/CD
* Your `package-lock.json` is version 3 and was generated on macOS or Windows
* You deploy on Linux (Lambda, containers, EC2, etc.)
**Fix**: Use one of these solutions:
**Option 1: Use bun (recommended)**
```bash
bun install --frozen-lockfile
```
**Option 2: Generate lockfile on Linux in CI**
```bash
rm -f package-lock.json
npm install --package-lock-only --ignore-scripts --no-audit --no-fund --platform=linux --arch=x64
npm ci
```
**Option 3: Pin lockfile to version 2**
```bash
npm install --package-lock-only --lockfile-version=2
```
Quick verification [#quick-verification]
Before deploying, verify the native engine loads by running your app inside a Linux container or CI job.
Performance [#performance]
Slow encrypt/decrypt operations [#slow-encryptdecrypt-operations]
CipherStash encryption adds \< 5ms overhead per operation. If you're seeing higher latency:
1. **Check network latency to ZeroKMS.** Key derivation requires a round-trip to ZeroKMS. Deploy your application in the same AWS region as your workspace.
2. **Use bulk operations.** `bulkEncrypt` and `bulkDecrypt` make a single ZeroKMS call regardless of record count, which is significantly faster for multiple values.
3. **Check your connection pool.** If you're creating a new `Encryption` client per request, you're paying initialization cost each time. Initialize once and reuse the client.
Optimizing bulk operations [#optimizing-bulk-operations]
For best performance with bulk operations:
```typescript filename="bulk-optimization.ts"
// Slow: one ZeroKMS call per value
for (const user of users) {
await client.encrypt(user.email, { column: schema.email, table: schema })
}
// Fast: one ZeroKMS call for all values
const plaintexts = users.map(u => ({ id: u.id, plaintext: u.email }))
await client.bulkEncrypt(plaintexts, { column: schema.email, table: schema })
```
Debugging [#debugging]
Enable debug logging to see detailed operation information:
```bash
STASH_STACK_LOG=debug
```
This logs key derivation requests, operation timing, and connection details. The SDK never logs plaintext data or key material at any log level.
# CipherStash
Source: https://cipherstash.com/docs/stack/cipherstash
CipherStash is one product with four capabilities:
* **[Encryption](https://cipherstash.com/docs/stack/cipherstash/encryption)**: Searchable field-level encryption. The core primitive. Every value encrypted with its own unique key. Range queries, exact match, free-text search, and JSON queries over ciphertext.
* **[Secrets (coming soon)](https://cipherstash.com/stack/secrets)**: Secrets without the .env. End-to-end encrypted config with cryptographically isolated environments.
* **[Proxy](https://cipherstash.com/docs/stack/cipherstash/proxy)**: Transparent encryption for existing PostgreSQL databases. Zero code changes. Also useful as a DevOps tool for inspecting encrypted data.
* **[ZeroKMS](https://cipherstash.com/docs/stack/cipherstash/kms)**: The key management layer. Unique key per value, derived on demand, never stored. Powers everything else.
* **[CLI](https://cipherstash.com/docs/stack/cipherstash/cli)**: CLI tools for managing EQL installation, encryption schemas, and database setup.
Start with the [Quickstart](https://cipherstash.com/docs/stack/quickstart) to encrypt your first fields in 15 minutes.
# PostgreSQL
Source: https://cipherstash.com/docs/stack/cipherstash/postgres
PostgreSQL [#postgresql]
CipherStash provides field-level encryption for PostgreSQL databases. You choose the integration depth. All paths use the same key management ([ZeroKMS](https://cipherstash.com/docs/stack/cipherstash/kms)), the same searchable encryption primitives ([EQL](https://cipherstash.com/docs/stack/reference/eql-guide)), and produce the same encrypted storage format.
Choose your integration [#choose-your-integration]
| If you want... | Use |
| ----------------------------------------------------------------- | -------------------------------------------------------- |
| Zero application code changes, transparent encryption at the wire | [Proxy](https://cipherstash.com/docs/stack/cipherstash/proxy) |
| Application-level control, ORM-agnostic | [Encryption SDK](https://cipherstash.com/docs/stack/cipherstash/encryption) |
| First-class Drizzle ORM integration | [Drizzle adapter](https://cipherstash.com/docs/stack/cipherstash/encryption/drizzle) |
| First-class Supabase JS SDK integration | [Supabase wrapper](https://cipherstash.com/docs/stack/cipherstash/supabase) |
Proxy [#proxy]
[CipherStash Proxy](https://cipherstash.com/docs/stack/cipherstash/proxy) sits between your application and PostgreSQL. Your application connects to the proxy with a standard PostgreSQL connection string. The proxy encrypts and decrypts fields transparently using a policy file. No application code changes are required.
Best for: existing applications you cannot modify, or teams who want encryption with zero SDK dependencies.
Encryption SDK [#encryption-sdk]
The [Encryption SDK](https://cipherstash.com/docs/stack/cipherstash/encryption) is a Node.js library that encrypts values before they reach the database and decrypts them on the way back. You call `encrypt` and `decrypt` explicitly in your data layer. The SDK is ORM-agnostic and works with any PostgreSQL client.
Best for: new applications or teams who want explicit control over which fields are encrypted and when.
Drizzle adapter [#drizzle-adapter]
The [Drizzle adapter](https://cipherstash.com/docs/stack/cipherstash/encryption/drizzle) wraps the Encryption SDK with Drizzle-native types and operators. Define encrypted columns with `encryptedType` in your Drizzle schema. Query them with `encryptionOps.eq`, `encryptionOps.ilike`, and other typed operators that mirror the standard Drizzle API.
Best for: teams already using Drizzle ORM who want type-safe encrypted queries without writing raw SQL.
Supabase wrapper [#supabase-wrapper]
The [Supabase wrapper](https://cipherstash.com/docs/stack/cipherstash/supabase) wraps the Supabase JS client with transparent encryption on mutations and decryption on selects. Queries read identically to standard Supabase queries. It uses the Encryption SDK internally.
Best for: teams using the Supabase JS client who want minimal query-layer changes.
What is EQL? [#what-is-eql]
EQL (Encrypt Query Language) is the PostgreSQL extension that makes encrypted queries possible. It provides the `eql_v2_encrypted` column type and the functions that index and compare encrypted values without decrypting them. Every integration path above relies on EQL.
See [Encrypt Query Language](https://cipherstash.com/docs/stack/reference/eql-guide) for the full reference.
Index setup [#index-setup]
Encrypted columns require indexes for fast queries. Index syntax differs between self-hosted PostgreSQL (full EQL with operator classes) and managed databases like Supabase (no superuser, no operator families). See [Setting up indexes](https://cipherstash.com/docs/stack/cipherstash/encryption/indexes) for the complete setup guide, including the right index form for each deployment.
How these compose [#how-these-compose]
Proxy and the Encryption SDK are not mutually exclusive. A single PostgreSQL database can serve both:
* One application uses the Proxy (legacy service with no code changes)
* Another application uses the Encryption SDK directly (new service with full control)
Both write to the same `eql_v2_encrypted` columns and use the same keysets. Data encrypted by one path is readable by the other.
The Drizzle and Supabase adapters sit on top of the Encryption SDK. They are not separate encryption implementations. Swapping between the raw SDK and an adapter does not change how data is stored or which keys are used.
```
Your application
│
├── Drizzle adapter ──┐
├── Supabase wrapper ─┤
└── Raw SDK ──────────┤
▼
Encryption SDK
│
▼
ZeroKMS
│
▼
PostgreSQL
(eql_v2_encrypted)
```
The Proxy is a separate path that does not use the SDK, but it writes the same encrypted format and reads from the same keysets.
Next steps [#next-steps]
* [Quickstart](https://cipherstash.com/docs/stack/quickstart): Encrypt your first fields in 15 minutes
* [Setting up indexes](https://cipherstash.com/docs/stack/cipherstash/encryption/indexes): Create PostgreSQL indexes for encrypted queries
* [Searchable encryption queries](https://cipherstash.com/docs/stack/cipherstash/encryption/queries): Equality, match, and range query patterns
* [Planning guide](https://cipherstash.com/docs/stack/reference/planning-guide): Architecture decisions and integration path selection
# Supabase
Source: https://cipherstash.com/docs/stack/cipherstash/supabase
Field-level encryption that works with your Supabase project out of the box.
Connect from the dashboard [#connect-from-the-dashboard]
You can connect Supabase from the [CipherStash Dashboard](https://dashboard.cipherstash.com) instead of starting entirely from the CLI.
Open workspace integrations [#open-workspace-integrations]
In your workspace, go to **Settings → Integrations** and click **Connect Supabase**.
Authorize Supabase OAuth [#authorize-supabase-oauth]
Approve access for the CipherStash OAuth app. Tokens are stored encrypted on the workspace.
Use the setup hub [#use-the-setup-hub]
Select a Supabase project, verify EQL and OIDC readiness, configure Supabase as an OIDC provider with one click, and copy Stack onboarding commands plus a `.env.local` snippet tailored to that project.
You can also install CipherStash from the **Supabase Marketplace** — the dashboard supports both simple and signed redirect install flows.
Full reference: [Supabase dashboard integration](https://cipherstash.com/docs/stack/reference/dashboard-supabase-integration)
How this works [#how-this-works]
What is EQL? [#what-is-eql]
EQL (Encrypted Query Language) is a Postgres extension CipherStash installs into your database. It provides the `eql_v2_encrypted` column type and the internal functions that make encrypted search possible. You don't write EQL directly. The SDK handles it.
Why your columns must be eql_v2_encrypted [#why-your-columns-must-be-eql_v2_encrypted]
Encrypted values aren't strings or plain JSONB. They're structured ciphertext objects that hold the ciphertext plus optional search indexes. Postgres needs the column type so the SDK and Postgres agree on which functions handle inserts and queries.
What the CLI installs on Supabase [#what-the-cli-installs-on-supabase]
`db install --supabase` uses a Supabase-compatible EQL variant. It omits `CREATE OPERATOR FAMILY` (which requires superuser), and grants `USAGE`, table, routine, and sequence permissions on the `eql_v2` schema to `anon`, `authenticated`, and `service_role`.
Packages [#packages]
CipherStash splits its functionality across two packages: a runtime SDK that your application imports, and a CLI for setup and schema management.
| Package | Role | Install as |
| -------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------- |
| `@cipherstash/stack` | Runtime encryption and decryption. Your application imports this to encrypt values before they're written to Supabase and decrypt them on the way back. | dependency |
| `stash` | Setup and schema management. Installs EQL into your database, scaffolds your encryption client, and generates migrations when your encryption schema changes. Comparable to Prisma CLI or Drizzle Kit. | devDependency |
Setup [#setup]
Install the packages [#install-the-packages]
Install the runtime SDK as a dependency and the CLI as a dev dependency.
```bash cta cta-type="install" example-id="install-supabase"
npm install @cipherstash/stack
npm install -D stash
```
Run init --supabase [#run-init---supabase]
Init runs nearly silently, with prompts only when it can't make a sensible default choice:
* Authenticates you with CipherStash via your browser (only when you aren't already logged in).
* Resolves your database connection via `DATABASE_URL`.
* Generates an encryption client at `./src/encryption/index.ts`. Only prompts you if a file already exists at that path.
* Installs `@cipherstash/stack` and `stash` if either is missing — one combined prompt, skipped entirely when both are already present.
* Installs EQL into your database.
The `--supabase` flag tailors the next-steps output to Supabase users.
```bash
npx stash init --supabase
```
Control how EQL is installed (optional) [#control-how-eql-is-installed-optional]
`stash init` installs EQL automatically. If you need to control the install method — for example, to write a Supabase migration file instead of pushing directly — run `stash db install` with explicit flags.
The CLI prompts you to choose how EQL is installed. If a `supabase/migrations/` directory is detected, the migration-file option is pre-selected.
As a migration (recommended) [#as-a-migration-recommended]
Pass `--migration` to write the EQL SQL into a Supabase migration file, or choose "Create a Supabase migration file" at the prompt.
```bash
npx stash db install --supabase --migration
```
The CLI writes the EQL SQL to:
```
supabase/migrations/00000000000000_cipherstash_eql.sql
```
The all-zero timestamp prefix ensures this migration runs before any user migrations that reference `eql_v2_encrypted`. Run `supabase db reset` or `supabase migration up` to apply it.
To write the migration file to a different directory, use `--migrations-dir`:
```bash
npx stash db install --supabase --migration --migrations-dir ./db/migrations
```
`--migration`, `--direct`, and `--migrations-dir` all require `--supabase` to be passed explicitly. Passing them without `--supabase` will error.
Direct push [#direct-push]
Pass `--direct` to push EQL directly to the database without creating a migration file.
```bash
npx stash db install --supabase --direct
```
Direct-push installs do not survive `supabase db reset`. The reset command drops the database and reruns only files in `supabase/migrations/`. EQL installed directly is not in migrations and will be wiped. Use the migration-file path for projects that use `supabase db reset`. See [Supabase db reset](https://cipherstash.com/docs/stack/cipherstash/cli/troubleshooting#supabase-db-reset).
If you hit issues with `supabase db reset` wiping EQL, see [Supabase db reset removes EQL](https://cipherstash.com/docs/stack/cipherstash/cli/troubleshooting#supabase-db-reset).
Database schema [#database-schema]
Encrypted columns must use the `eql_v2_encrypted` type. Define them in your Supabase SQL editor or a migration file.
```sql filename="supabase/migrations/20240101000001_create_users.sql"
CREATE TABLE users (
id SERIAL PRIMARY KEY,
email eql_v2_encrypted NOT NULL,
name eql_v2_encrypted NOT NULL
);
```
Choose your integration [#choose-your-integration]
Three paths. Same encryption, same key management, same searchable queries. Pick the one that fits your stack.
Encryption SDK (any Postgres client) [#encryption-sdk-any-postgres-client]
Works with any client that connects to your Supabase Postgres database. Define a schema, encrypt fields, store and query with raw SQL or any library.
```typescript
import { Encryption, encryptedTable, encryptedColumn } from "@cipherstash/stack"
const users = encryptedTable("users", {
email: encryptedColumn("email").equality().freeTextSearch(),
})
const enc = await Encryption({ schemas: [users] })
// Encrypt
const encrypted = await enc.encrypt("alice@example.com", {
column: users.email, table: users,
})
// Store with any client
await sql`INSERT INTO users (email) VALUES (${encrypted.data})`
// Query — search ciphertext without decrypting
const query = await enc.encryptQuery("alice@example.com", {
column: users.email, table: users,
})
```
This is the universal approach. It works regardless of which client library you use to connect to Supabase.
Full reference: [Storing encrypted data](https://cipherstash.com/docs/stack/cipherstash/encryption/storing-data)
Supabase JS SDK [#supabase-js-sdk]
If you're using the Supabase JavaScript client, the `encryptedSupabase` wrapper gives you automatic encryption with the same API you already know.
```typescript
import { encryptedSupabase } from "@cipherstash/stack/supabase"
const eSupabase = await encryptedSupabase(supabaseUrl, supabaseKey)
// Insert — automatically encrypted
await eSupabase.from("users").insert({
email: "alice@example.com",
})
// Query — automatically encrypts the search term
const { data } = await eSupabase
.from("users")
.select()
.eq("email", "alice@example.com")
```
The wrapper handles encryption, decryption, type casting, and search term formatting. Your queries look identical to standard Supabase queries.
Full reference: [Supabase JS SDK integration](https://cipherstash.com/docs/stack/cipherstash/encryption/supabase)
Drizzle ORM [#drizzle-orm]
If you're using Drizzle ORM with Supabase, define encrypted columns directly in your Drizzle schema.
```typescript
import { encryptedType } from "@cipherstash/stack/drizzle"
export const users = pgTable("users", {
id: serial("id").primaryKey(),
email: encryptedType("email"),
})
```
Encrypted query operators work like standard Drizzle operators.
Full reference: [Drizzle ORM integration](https://cipherstash.com/docs/stack/cipherstash/encryption/drizzle)
What you get [#what-you-get]
1. **Searchable encryption.** Equality, free-text search, range, ordering, and JSON queries over ciphertext. Your Postgres indexes work on encrypted data.
2. **Works alongside Row Level Security.** CipherStash encryption and Supabase RLS are complementary. RLS controls who can access rows. CipherStash controls who can decrypt values. Defense in depth.
3. **Schema-first.** Define encrypted columns once. Type-safe across your entire application.
4. **Identity-bound keys.** Tie encryption to a user's identity. Only that user can decrypt their data.
5. **Zero-knowledge.** CipherStash never sees your plaintext data. Keys are derived on your device and never stored.
Encrypted columns on Supabase require functional indexes and a specific query form to avoid silent sequential scans. See [Setting up indexes](https://cipherstash.com/docs/stack/cipherstash/encryption/indexes) for the correct `CREATE INDEX` statements and query patterns.
Going to production [#going-to-production]
Local development uses device-based authentication. Production uses environment variables. See [Going to production](https://cipherstash.com/docs/stack/deploy/going-to-production).
Next steps [#next-steps]
* [Supabase dashboard integration](https://cipherstash.com/docs/stack/reference/dashboard-supabase-integration) — OAuth connect, setup hub, Marketplace install, and production config
* [Quickstart](https://cipherstash.com/docs/stack/quickstart) — Encrypt your first fields in 15 minutes
* [Supabase JS SDK reference](https://cipherstash.com/docs/stack/cipherstash/encryption/supabase) — Full API for the encryptedSupabase wrapper
* [Drizzle ORM reference](https://cipherstash.com/docs/stack/cipherstash/encryption/drizzle) — Encrypted column types and operators
* [Searchable encryption](https://cipherstash.com/docs/stack/cipherstash/encryption/searchable-encryption) — How queries over ciphertext work
* [Supabase db reset removes EQL](https://cipherstash.com/docs/stack/cipherstash/cli/troubleshooting#supabase-db-reset) — Fix for direct-push installs
* [Dashboard](https://dashboard.cipherstash.com/workspaces) — Manage keysets, clients, and access keys
# Agent Skills
Source: https://cipherstash.com/docs/stack/reference/agent-skills
CipherStash publishes a set of [agent skills](https://skills.sh/) that give AI coding assistants deep knowledge of the CipherStash SDK, CLI, and integrations. When installed, your agent can accurately generate encryption schemas, write integration code, and guide you through database setup without hallucinating API surfaces.
Skills are compatible with any AI coding tool that supports the skills protocol, including Claude Code, Cursor, GitHub Copilot, Windsurf, Cline, Gemini, AMP, Goose, Roo, Trae, and others.
Install skills [#install-skills]
Skills are installed per-project. Run this in your project root:
```bash
npx skills add cipherstash/stack
```
This installs all six CipherStash skills into your project. Your AI coding agent will automatically activate the relevant skill based on what you are working on.
Install via the wizard [#install-via-the-wizard]
`@cipherstash/wizard` prompts you to install integration-appropriate skills after its post-agent steps. It offers to copy skills into `./.claude/skills/` based on your integration:
* **Drizzle**: `stash-encryption`, `stash-drizzle`, `stash-cli`
* **Supabase**: `stash-encryption`, `stash-supabase`, `stash-cli`
* **Prisma / generic**: `stash-encryption`, `stash-cli`
Available skills [#available-skills]
The `cipherstash/stack` skill pack includes six skills. Each one covers a specific area of the CipherStash platform.
stash-encryption [#stash-encryption]
Core field-level encryption with `@cipherstash/stack`. This is the foundational skill that covers the full encryption API.
**Covers:**
* Schema definition with `encryptedTable` and `encryptedColumn`
* Single and bulk encrypt/decrypt operations
* Model operations (`encryptModel`, `decryptModel`, `bulkEncryptModels`, `bulkDecryptModels`)
* Searchable encryption (equality, free-text search, range queries, encrypted JSONB)
* Identity-aware encryption with `OidcFederationStrategy` and `.withLockContext()`
* Multi-tenant isolation with keysets
* Error handling with the `Result` pattern
* Migration from `@cipherstash/protect`
**When it activates:** Your agent loads this skill when you are defining encrypted schemas, writing encrypt/decrypt logic, or working with the `@cipherstash/stack` package.
**Related docs:** [Encryption](https://cipherstash.com/docs/stack/cipherstash/encryption)
stash-cli [#stash-cli]
The CipherStash CLI (`stash`) for database setup, schema management, and project initialization.
**Covers:**
* `stash.config.ts` configuration
* Setup lifecycle: `init` (scaffold + EQL + context), `plan` (draft plan.md), `impl` (execute plan), `status` (lifecycle map)
* Database commands: `db install`, `db upgrade`, `db push`, `db validate`, `db status`, `db test-connection`
* Schema building with `schema build`
* Authentication with `auth login`
* Programmatic API (`EQLInstaller`, `loadStashConfig`, `defineConfig`, `loadBundledEqlSql`)
* Drizzle migration mode (`--drizzle`)
* Supabase-compatible installs (`--supabase`)
* Automatic Supabase and Drizzle detection
* Automatic OPE fallback on managed databases
**When it activates:** Your agent loads this skill when you are working with `stash.config.ts`, running CLI commands, or setting up EQL in a database.
**Related docs:** [CipherStash CLI](https://cipherstash.com/docs/stack/cipherstash/cli)
stash-drizzle [#stash-drizzle]
Drizzle ORM integration using `@cipherstash/stack/drizzle`.
**Covers:**
* `encryptedType()` column type for Drizzle table schemas
* `extractEncryptionSchema()` to convert Drizzle tables to CipherStash schemas
* `createEncryptionOperators()` for type-safe encrypted queries
* All query operators: `eq`, `ne`, `like`, `ilike`, `gt`, `gte`, `lt`, `lte`, `between`, `inArray`, `asc`, `desc`
* Encrypted JSONB operators: `jsonbPathExists`, `jsonbPathQueryFirst`, `jsonbGet`
* Batched `and()` / `or()` conditions for efficient multi-condition queries
* EQL migration generation
* Non-encrypted column fallback behavior
* Complete Express/Hono/Next.js API examples
**When it activates:** Your agent loads this skill when you are using Drizzle ORM with encrypted columns or importing from `@cipherstash/stack/drizzle`.
**Related docs:** [Drizzle integration](https://cipherstash.com/docs/stack/cipherstash/encryption/drizzle)
stash-supabase [#stash-supabase]
Supabase integration using `@cipherstash/stack/supabase`.
**Covers:**
* `encryptedSupabase()` wrapper for the Supabase JS client
* Transparent encryption on `insert`, `update`, and `upsert`
* Transparent decryption on `select`, `single`, and `maybeSingle`
* Encrypted query filters: `eq`, `neq`, `like`, `ilike`, `gt`, `gte`, `lt`, `lte`, `in`, `match`, `or`, `not`, `filter`
* Identity-aware encryption with `.withLockContext()`
* Audit logging with `.audit()`
* Response types and error handling
* Supabase-specific database setup (JSONB columns, EQL extension)
**When it activates:** Your agent loads this skill when you are using Supabase with encrypted columns or importing from `@cipherstash/stack/supabase`.
**Related docs:** [Supabase integration](https://cipherstash.com/docs/stack/cipherstash/encryption/supabase)
stash-dynamodb [#stash-dynamodb]
Amazon DynamoDB integration using `@cipherstash/stack/dynamodb`.
**Covers:**
* `encryptedDynamoDB()` helper for encrypting items before writes and decrypting after reads
* DynamoDB attribute naming conventions (`__source` and `__hmac` suffixes)
* Single and bulk encrypt/decrypt model operations
* Querying encrypted partition keys, sort keys, and GSI keys via HMAC attributes
* Nested object encryption with `encryptedField`
* Audit logging
* DynamoDB table design patterns for encrypted attributes
* Complete examples with `PutCommand`, `GetCommand`, `QueryCommand`, and `BatchWriteCommand`
**When it activates:** Your agent loads this skill when you are using DynamoDB with encrypted attributes or importing from `@cipherstash/stack/dynamodb`.
**Related docs:** [DynamoDB integration](https://cipherstash.com/docs/stack/cipherstash/encryption/dynamodb)
stash-secrets [#stash-secrets]
Encrypted secrets management with `@cipherstash/stack`.
**Covers:**
* `Secrets` class API: `set`, `get`, `getMany`, `list`, `delete`
* Environment-based isolation with per-environment encryption keysets
* Bulk secret retrieval with `getMany` (2 to 100 secrets per call)
* Error types: `ApiError`, `NetworkError`, `ClientError`, `EncryptionError`, `DecryptionError`
* Configuration via `CS_*` environment variables or explicit config
* Patterns for loading secrets at application startup
**When it activates:** Your agent loads this skill when you are storing or retrieving secrets, or working with the `Secrets` class from `@cipherstash/stack/secrets`.
**Related docs:** [Secrets (coming soon)](https://cipherstash.com/stack/secrets)
How skills work [#how-skills-work]
When you ask your AI coding agent to help with a CipherStash task, it checks which skills are installed and activates the relevant one based on your request. The skill provides the agent with:
* Complete API surface documentation (method signatures, types, return values)
* Correct code examples that match the current SDK version
* Integration-specific patterns and best practices
* Known limitations and workarounds
This means your agent can write accurate CipherStash code on the first try, rather than guessing at API shapes or generating outdated patterns.
Typical workflow [#typical-workflow]
After installing skills, your AI coding agent can assist with the full CipherStash setup:
1. **Initialize your project:** Ask your agent to set up CipherStash and it will run `npx stash init`. Init authenticates you, installs EQL, scaffolds the encryption client, and writes `.cipherstash/context.json`.
2. **Draft a plan:** Run `npx stash plan`. The agent produces `.cipherstash/plan.md` listing the tables and columns to encrypt. Review the plan before proceeding.
3. **Execute the plan:** Run `npx stash impl`. The agent reads the plan and wires up `encryptModel`/`decryptModel` in your codebase. Skills give it accurate knowledge of the current API surface.
4. **Handle edge cases:** The agent knows about searchable encryption constraints, operator family limitations, identity-aware encryption, and multi-tenant keysets.
Requirements [#requirements]
* An AI coding tool that supports the [skills protocol](https://skills.sh/)
* Node.js 18 or later
* A CipherStash account ([sign up](https://dashboard.cipherstash.com/sign-up))
# Billing
Source: https://cipherstash.com/docs/stack/reference/billing
CipherStash uses a **per-workspace billing model**. Each workspace has its own plan and usage limits. Organizations and team members are always free and unlimited.
Plans [#plans]
| | Free | Pro ($99/mo) | Business ($870/mo) | Enterprise |
| ----------------- | -------- | ------------ | ------------------ | ---------- |
| Protect ops/month | 10,000 | 50,000 | 500,000 | Unlimited |
| Secrets | 100 | 500 | 2,000 | Unlimited |
| Keysets | 2 | 10 | 25 | Unlimited |
| Clients | 2 | 10 | 50 | Unlimited |
| OIDC providers | 0 | 0 | 5 | Unlimited |
| Keyset isolation | No | Yes | Yes | Yes |
| Lock contexts | No | No | Yes | Yes |
| Workspace members | 1 | 5 | 25 | Unlimited |
| Workspace type | Dev only | Dev + Prod | Dev + Prod | Dev + Prod |
Free plan [#free-plan]
The Free plan is designed for non-commercial personal projects and experimentation. Free workspaces are limited to development environments only.
Pro plan [#pro-plan]
The Pro plan is for teams and production applications. It includes development and production workspace support with higher limits.
Business plan [#business-plan]
The Business plan offers predictable pricing for demanding workloads with multi-tenant encryption and [Lock Contexts](https://cipherstash.com/docs/stack/cipherstash/encryption/identity) support.
Enterprise plan [#enterprise-plan]
Enterprise is an organization-level plan with custom pricing, unlimited limits across all workspaces, and dedicated support. Enterprise organizations bypass per-workspace billing entirely. Contact [sales@cipherstash.com](mailto:sales@cipherstash.com) for details.
Managing workspace billing [#managing-workspace-billing]
Each workspace has a dedicated billing page accessible from the workspace sidebar. From there you can:
* View your current plan and usage metrics
* Upgrade or downgrade your plan
* Cancel your subscription
* Access the Stripe billing portal for payment methods and invoices
How billing works [#how-billing-works]
* **One Stripe customer per organization**: All workspaces in your organization share the same Stripe customer for billing.
* **One subscription per workspace**: Each workspace has its own Stripe subscription tied to its plan.
* **Proration on upgrades**: When upgrading mid-cycle, you're charged a prorated amount for the remainder of the billing period.
* **Downgrades at period end**: When downgrading, the change takes effect at the end of your current billing period.
* **Cancellation**: Canceling a subscription keeps the plan active until the end of the billing period, then reverts to Free.
Enterprise and AWS Marketplace [#enterprise-and-aws-marketplace]
Organizations on Enterprise plans or subscribed through AWS Marketplace have billing managed at the organization level. All workspaces in these organizations have unlimited access to all features. Visit the Organization Profile to manage enterprise billing.
Need help? [#need-help]
Contact [support@cipherstash.com](mailto:support@cipherstash.com) for billing questions.
# The CipherCell
Source: https://cipherstash.com/docs/stack/reference/cipher-cell
The **CipherCell** is CipherStash's standard format for storing encrypted data in a database. It is a JSON-based structure that combines **encrypted values**, **searchable encrypted metadata**, and **non-sensitive metadata** into a single, self-contained record.
CipherCells are designed to make encrypted data practical to work with in real applications. They can be stored in existing databases (such as PostgreSQL jsonb columns), indexed, queried, and audited without exposing plaintext.
What a CipherCell contains [#what-a-ciphercell-contains]
A CipherCell typically includes:
* **Encrypted data**
* The ciphertext for one or more sensitive values.
* Each value is encrypted independently using strong authenticated encryption and unique per-value keys.
* **Searchable Encrypted Metadata (SEM)**
* Additional cryptographic material derived from the plaintext that enables secure querying using searchable encryption.
* This metadata allows operations such as equality checks, range queries, or text search to be performed **without decrypting the data**.
* The database can evaluate queries over this metadata, but cannot recover the original values.
* **Non-sensitive metadata**
* Plaintext fields that are safe to expose, such as schema identifiers, versioning information, timestamps, or application-level IDs.
* Keeping this metadata unencrypted allows efficient filtering, indexing, and integration with existing tooling.
How CipherCells are used [#how-ciphercells-are-used]
CipherCells are stored directly in the database, usually in a JSON-compatible column.
[Encrypt Query Language (EQL)](https://cipherstash.com/docs/stack/reference/eql-guide) understands this structure and provides database functions and operators that work over CipherCells, enabling encrypted search and filtering while preserving strong security guarantees.
From an application's perspective, a CipherCell behaves like a regular database value:
* Applications write encrypted data as JSON
* Databases store and index it
* Queries operate on Searchable Encrypted Metadata (SEM)
* Decryption happens only in trusted application code with the right keys and claims
Why CipherCells exist [#why-ciphercells-exist]
The CipherCell format solves a common problem with encryption at rest: traditional encryption makes data opaque and hard to query. CipherCells retain the benefits of encryption while enabling:
* Fine-grained, **per-value** protection
* Searchable encryption over structured data
* Compatibility with existing databases and ORMs
* Clear separation between sensitive and non-sensitive information
A CipherCell is the **unit of encrypted storage** in CipherStash: a portable, self-describing JSON record that makes encrypted data usable, searchable, and auditable by default.
Structure [#structure]
**Required fields**: Only `i` (identifier) and `v` (version) are required.
**Payload requirement**: Either `c` (ciphertext) or `sv` (structured encryption vector) must be present, but never both.
**Optional fields**: All searchable encrypted metadata (SEM) fields are optional and only included when the corresponding index types are configured.
A CipherCell is stored as a JSON object with the following top-level structure:
```json
{
"i": {
"t": "table_name",
"c": "column_name"
},
"v": 2,
"c": "encrypted_data_in_messagepack_base85",
"hm": "2e182f0c444d1d51f5f70f32d778b2eaa854f5921a4a2acaa4446c44055cb777",
"ob": ["ore_block_1", "ore_block_2"],
"bf": [1234, 5678, 9012]
}
```
Top-level fields [#top-level-fields]
i - Identifier [#i---identifier]
The table and column identifier for this encrypted data.
**Type**: Object with `t` (table) and `c` (column) properties
**Required**: Yes
```json
{
"i": {
"t": "users",
"c": "email"
}
}
```
This field identifies which table and column the encrypted data belongs to, enabling proper decryption and index usage.
v - Version [#v---version]
The encryption version used for this CipherCell.
**Type**: Integer
**Required**: Yes
```json
{
"v": 2
}
```
The version field allows for cryptographic algorithm upgrades over time while maintaining backward compatibility.
c - Ciphertext (required unless sv is present) [#c---ciphertext-required-unless-sv-is-present]
The encrypted record containing the actual plaintext data.
**Type**: String (MessagePack encoded and Base85 encoded)
**Required**: Yes (unless `sv` field is present)
```json
{
"c": "Xk}0>Z*pVbW@%*8a%F0@"
}
```
Either `c` or `sv` must be present in every CipherCell, but never both. Use `c` for standard encrypted values and `sv` for structured encryption vectors (arrays or JSON structures).
a - Array item flag [#a---array-item-flag]
Indicates whether this CipherCell represents an item within an array.
**Type**: Boolean
**Required**: No
```json
{
"a": true
}
```
Searchable Encrypted Metadata (SEM) [#searchable-encrypted-metadata-sem]
The CipherCell can contain various types of searchable encrypted metadata, each enabling different query capabilities. All SEM fields are optional and only included when the corresponding index type is configured.
hm - HMAC-SHA256 [#hm---hmac-sha256]
Enables exact match queries using HMAC-SHA256.
**Type**: Hex-encoded string (64 characters)
**Index Type**: [Exact](https://cipherstash.com/docs/stack/cipherstash/encryption/searchable-encryption#exact-matching)
```json
{
"hm": "2e182f0c444d1d51f5f70f32d778b2eaa854f5921a4a2acaa4446c44055cb777"
}
```
ob - ORE Block [#ob---ore-block]
Enables range queries and ordering using Order Revealing Encryption.
**Type**: Array of strings
**Index Type**: [Order / Range](https://cipherstash.com/docs/stack/cipherstash/encryption/searchable-encryption#sorting-and-range-queries)
```json
{
"ob": [
"01a2b3c4d5e6f7g8h9i0",
"j1k2l3m4n5o6p7q8r9s0"
]
}
```
bf - Bloom Filter [#bf---bloom-filter]
Enables substring and pattern matching queries using encrypted Bloom filters with trigrams.
**Type**: Array of integers
**Index Type**: [Match](https://cipherstash.com/docs/stack/cipherstash/encryption/searchable-encryption#free-text-search)
```json
{
"bf": [1234, 5678, 9012, 3456, 7890]
}
```
b3 - Blake3 [#b3---blake3]
Blake3 hash for exact matches in structured encryption vectors.
**Type**: Hex-encoded string
**Used in**: SteVec (Structured Encryption Vector) subfield
s - Selector [#s---selector]
Selector value for field selection in structured encryption vectors.
**Type**: String
**Used in**: SteVec (Structured Encryption Vector) subfield
ocf - ORE CLWW Fixed-Width [#ocf---ore-clww-fixed-width]
ORE CLWW (Chenette-Lewi-Weis-Wu) fixed-width scheme for 64-bit integer values in structured encryption vectors.
**Type**: String
**Used in**: SteVec (Structured Encryption Vector) subfield
ocv - ORE CLWW Variable-Width [#ocv---ore-clww-variable-width]
ORE CLWW variable-width scheme for string comparison in structured encryption vectors.
**Type**: String
**Used in**: SteVec (Structured Encryption Vector) subfield
sv - Structured Encryption Vector (SteVec) (required unless c is present) [#sv---structured-encryption-vector-stevec-required-unless-c-is-present]
Nested array of CipherCells for supporting containment queries and JSON-style operations.
**Type**: Array of CipherCell objects
**Required**: Yes (unless `c` attribute is present)
```json
{
"sv": [
{
"c": "Xk}0>Z*pVbW@%*8a%F0@",
"hm": "hash1...",
"s": "selector1"
},
{
"c": "Yl~1?A+qWcX#&+9b&G1#",
"hm": "hash2...",
"s": "selector2"
}
]
}
```
SteVec enables queries on array elements and JSON document structures while maintaining encryption. Each element in the `sv` array is itself a CipherCell that can contain SEM fields like `b3`, `s`, `ocf`, and `ocv`.
Complete example [#complete-example]
Here's a complete CipherCell with multiple index types enabled:
```json
{
"i": {
"t": "products",
"c": "price"
},
"v": 2,
"c": "Xk}0>Z*pVbW@%*8a%F0@Yl~1?A+qWcX#&+9b&G1#",
"hm": "2e182f0c444d1d51f5f70f32d778b2eaa854f5921a4a2acaa4446c44055cb777",
"ob": [
"01a2b3c4d5e6f7g8h9i0",
"j1k2l3m4n5o6p7q8r9s0",
"t1u2v3w4x5y6z7a8b9c0"
],
"bf": [1234, 5678, 9012, 3456, 7890, 2345, 6789]
}
```
This CipherCell:
* Belongs to the `price` column of the `products` table
* Uses encryption version 2
* Contains the encrypted plaintext value
* Supports exact match queries via `hm`
* Supports range queries and ordering via `ob`
* Supports pattern matching via `bf`
Design principles [#design-principles]
Minimal storage [#minimal-storage]
Only the index types configured for a column are included in the CipherCell. This minimizes storage overhead and ensures optimal performance.
Composable indexes [#composable-indexes]
Multiple index types can be combined on a single column, enabling both exact matches and range queries, or exact matches and pattern matching, depending on application needs.
Forward compatibility [#forward-compatibility]
The version field (`v`) enables cryptographic algorithm upgrades without requiring full database re-encryption. Older versions can coexist with newer versions during migration.
Standardized format [#standardized-format]
The CipherCell format is consistent across all CipherStash SDKs and tools, ensuring interoperability and portability of encrypted data.
Database storage [#database-storage]
CipherCells can be stored as JSON in any database that supports JSON data types.
However, for search to be supported using the [Encryption SDK](https://cipherstash.com/docs/stack/cipherstash/encryption) or [CipherStash Proxy](https://cipherstash.com/docs/stack/cipherstash/proxy), the `eql_v2.encrypted` database type must be used which is available when the Encrypt Query Language (EQL) helpers have been installed.
# Compliance
Source: https://cipherstash.com/docs/stack/reference/compliance
CipherStash helps organizations meet compliance requirements through field-level encryption, identity-bound access controls, and audit logging. This page summarizes how CipherStash maps to common compliance frameworks and what capabilities are available.
Compliance frameworks [#compliance-frameworks]
CipherStash's encryption and access control capabilities support the following compliance frameworks:
| Framework | How CipherStash helps |
| ----------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------- |
| **SOC 2 Type II** | Field-level encryption, access key scoping, audit logging of every decrypt operation, key rotation via keysets |
| **HIPAA** | Encryption of PHI at the field level, identity-aware access controls (lock contexts), audit trails for data access |
| **GDPR** | Encryption of personal data, data residency controls via [regional deployment](https://cipherstash.com/docs/stack/cipherstash/kms/regions), crypto-shredding by deleting keysets |
| **PCI-DSS** | Encryption of cardholder data fields, key management via ZeroKMS, separation of key material from encrypted data |
| **ISO 27001** | Cryptographic controls (A.10), access control (A.9), logging and monitoring (A.12) |
| **CCPA** | Encryption of consumer personal information, access controls, audit trails |
Contact [support@cipherstash.com](mailto:support@cipherstash.com) to request SOC 2 reports, sign a HIPAA Business Associate Agreement (BAA), or obtain a GDPR Data Processing Agreement (DPA).
Data residency [#data-residency]
CipherStash workspaces are deployed to specific AWS regions. Key material and encryption operations stay within the configured region.
Available regions are listed on the [Regions](https://cipherstash.com/docs/stack/cipherstash/kms/regions) page. When you create a workspace, you select a region and all ZeroKMS key material is stored and processed in that region.
Audit logging [#audit-logging]
CipherStash logs every key derivation event. Every encrypt and decrypt operation is recorded with context about who performed it, when, and for which keyset.
Audit logs are available through the CipherStash dashboard. For programmatic access or SIEM integration, contact [support@cipherstash.com](mailto:support@cipherstash.com).
What is logged [#what-is-logged]
| Field | Description |
| ---------------- | ------------------------------------------------------------------------------------- |
| Timestamp | When the operation occurred |
| Operation type | Encrypt or decrypt |
| Client ID | Which application performed the operation |
| Keyset | Which keyset was used |
| Identity context | The identity claim (if using [lock contexts](https://cipherstash.com/docs/stack/cipherstash/encryption/identity)) |
Audit with the SDK [#audit-with-the-sdk]
The SDK supports attaching audit metadata to any operation:
```typescript filename="audit-example.ts"
const result = await client
.encrypt(plaintext, { column: users.email, table: users })
.audit({ metadata: { action: "create", resource: "user" } })
```
This metadata is included in the audit log alongside the standard fields.
Crypto-shredding [#crypto-shredding]
CipherStash supports crypto-shredding: permanently destroying data by deleting the encryption keys rather than the ciphertext.
Because each [keyset](https://cipherstash.com/docs/stack/cipherstash/kms/keysets) provides cryptographic isolation, you can:
1. Delete a keyset to make all data encrypted under it permanently irrecoverable.
2. Use per-tenant keysets to support GDPR right-to-erasure (Article 17) by deleting a tenant's keyset.
The encrypted data remains in your database but can never be decrypted.
Key rotation [#key-rotation]
CipherStash supports key rotation at the keyset level. Key rotation generates new key material without interrupting running applications.
For rotation procedures, see [Keysets](https://cipherstash.com/docs/stack/cipherstash/kms/keysets).
Security architecture [#security-architecture]
For a complete description of the cryptographic design, key hierarchy, and trust model, see [Security architecture](https://cipherstash.com/docs/stack/reference/security-architecture).
# Supabase dashboard integration
Source: https://cipherstash.com/docs/stack/reference/dashboard-supabase-integration
The CipherStash dashboard can connect to your Supabase account with OAuth, guide Stack onboarding for a specific project, and register Supabase as an OIDC provider for identity-aware encryption.
Use this when you want a guided setup path instead of configuring everything from the CLI alone.
Where to find it [#where-to-find-it]
In the [CipherStash Dashboard](https://dashboard.cipherstash.com):
1. Open a workspace
2. Go to **Settings → Integrations**
3. Click **Connect Supabase** (or **Open setup** if already connected)
Connected workspaces also have a dedicated setup page at:
```
/workspaces/{workspaceId}/settings/integrations/supabase
```
Connect Supabase (OAuth) [#connect-supabase-oauth]
The dashboard uses Supabase OAuth with PKCE. Tokens are encrypted at rest in the CipherStash database and scoped to the workspace you connect from.
Start OAuth [#start-oauth]
On **Settings → Integrations**, click **Connect Supabase**. You are redirected to Supabase to authorize the CipherStash OAuth app.
Complete authorization [#complete-authorization]
After you approve access, the dashboard stores encrypted access and refresh tokens for that workspace and redirects you to the Supabase setup hub.
Disconnect (optional) [#disconnect-optional]
From the setup hub, click **Disconnect** to remove the integration from the workspace. The dashboard marks the integration disconnected immediately and revokes the refresh token in the background.
OAuth scopes [#oauth-scopes]
The integration requests these Supabase OAuth scopes:
| Scope | Purpose |
| --------------- | -------------------------------------------------------------- |
| `projects:read` | List projects and read project metadata via the Management API |
| `database:read` | Run read-only SQL checks (EQL version, encrypted columns) |
Configure these scopes on your Supabase OAuth app. The dashboard does **not** request `secrets:read`.
Setup hub [#setup-hub]
After connecting, the setup hub helps you onboard a specific Supabase project with Stack.
Project selection [#project-selection]
The hub lists Supabase projects available to the connected account. Select the project you want to encrypt. Readiness checks and onboarding commands update when you change projects.
If you arrived from the Supabase Marketplace with a pre-selected project, that project is chosen automatically via a `?project=` query parameter.
Readiness checks [#readiness-checks]
For the selected project, the dashboard verifies:
| Check | What it means |
| ------------------------------------- | ------------------------------------------------------------ |
| **Project services healthy** | Supabase project health from the Management API |
| **EQL installed** | `SELECT eql_v2.version() AS version;` succeeds |
| **Encrypted columns detected** | Columns using `eql_v2_encrypted` in `information_schema` |
| **Supabase OIDC provider configured** | A Supabase issuer is registered on the CipherStash workspace |
When project health, EQL, and OIDC are all satisfied, the hub shows a **Stack-ready** badge.
EQL detection uses `eql_v2.version()`, not a `pg_extension` lookup. If EQL is missing, run `npx stash db install --supabase --migration` in your application repo.
Configure OIDC from the dashboard [#configure-oidc-from-the-dashboard]
If Supabase OIDC is not registered yet, click **Configure OIDC for this project** on the readiness panel.
The dashboard registers a Supabase OIDC provider on your CipherStash workspace with issuer:
```
https://{projectRef}.supabase.co/auth/v1
```
This enables [identity-aware encryption](https://cipherstash.com/docs/stack/cipherstash/encryption/identity) with Supabase Auth JWTs via `LockContext`.
See [OIDC Providers](https://cipherstash.com/docs/stack/cipherstash/kms/oidc) for manual registration and usage from code.
Stack onboarding commands [#stack-onboarding-commands]
The hub copies the official Supabase + Stack workflow:
```bash
npm install @cipherstash/stack
npm install -D stash
npx stash auth login
npx stash init --supabase
npx stash db install --supabase --migration
```
It also generates a `.env.local` snippet for the selected project, including:
* `DATABASE_URL` (Postgres host `db.{projectRef}.supabase.co`)
* `SUPABASE_URL` and `SUPABASE_ANON_KEY` (when available from the Management API)
* Comments for local dev (`~/.cipherstash/`) vs production (`CS_*` access keys)
For the full CLI and SDK path, see [Supabase](https://cipherstash.com/docs/stack/cipherstash/supabase).
Encrypted schema [#encrypted-schema]
When the selected project already has `eql_v2_encrypted` columns, the hub lists them by schema, table, and column name.
Install from the Supabase Marketplace [#install-from-the-supabase-marketplace]
CipherStash supports the [Supabase partner integration guide](https://supabase.com/docs/guides/integrations/partner-integration-guide) for the **Install Integration** button in the Supabase Marketplace.
There are two redirect methods. Both create a one-time install record and send the user to a handler page where they pick a CipherStash workspace and complete OAuth.
Method 1 — Simple redirect [#method-1--simple-redirect]
Supabase redirects the user to:
```
GET {APP_URL}/api/integrations/supabase/install?project_id={ref}&organization_slug={slug}
```
The API creates an install record and redirects to:
```
{APP_URL}/integrations/supabase/install/{integrationId}
```
Method 2 — Signed redirect [#method-2--signed-redirect]
Supabase POSTs a signed JWT to the same install endpoint:
```http
POST {APP_URL}/api/integrations/supabase/install
Content-Type: application/json
{ "token": "" }
```
On success, the API returns:
```json
{
"integrationId": "...",
"redirectUrl": "{APP_URL}/integrations/supabase/install/{integrationId}",
"expiresAt": "..."
}
```
Supabase redirects the user to `redirectUrl`.
Install handler flow [#install-handler-flow]
1. User lands on `/integrations/supabase/install/{integrationId}`
2. If not signed in to CipherStash, they authenticate first
3. User selects the workspace where Supabase should be connected
4. OAuth completes and binds the install record to that workspace (bind-once)
5. User lands on the setup hub, optionally with the Supabase project pre-selected
Install links expire. If a link is invalid or expired, return to Supabase and click **Install Integration** again.
The normal in-dashboard **Connect Supabase** button does not use partner install records. Partner logic runs only when an `installId` is present in the OAuth flow.
Production configuration (CipherStash operators) [#production-configuration-cipherstash-operators]
These environment variables configure the dashboard deployment (for example on Vercel):
```bash
NEXT_PUBLIC_APP_URL="https://dashboard.cipherstash.com"
# Supabase OAuth (Connect button)
SUPABASE_OAUTH_CLIENT_ID="..."
SUPABASE_OAUTH_CLIENT_SECRET="..."
# Optional — defaults to {NEXT_PUBLIC_APP_URL}/api/integrations/supabase/callback
# SUPABASE_OAUTH_REDIRECT_URI="..."
# Supabase Marketplace signed redirect (Method 2)
SUPABASE_PARTNER_JWT_AUDIENCE="https://dashboard.cipherstash.com"
SUPABASE_PARTNER_JWT_PUBLIC_KEYS='{"pik_xxx":"-----BEGIN PUBLIC KEY-----\n...\n-----END PUBLIC KEY-----"}'
```
Register the OAuth callback URL on your Supabase OAuth app:
```
{NEXT_PUBLIC_APP_URL}/api/integrations/supabase/callback
```
Values to provide Supabase (Marketplace) [#values-to-provide-supabase-marketplace]
| Item | Example (production) |
| ------------------------ | --------------------------------------------------------------------------------- |
| Redirect record endpoint | `https://dashboard.cipherstash.com/api/integrations/supabase/install` |
| Redirect handler pattern | `https://dashboard.cipherstash.com/integrations/supabase/install/{integrationId}` |
| JWT `aud` claim | `https://dashboard.cipherstash.com` |
Verify signed redirect is enabled:
```bash
curl -I https://dashboard.cipherstash.com/api/integrations/supabase/install
```
When JWT verification is configured, the response includes:
```
X-Supabase-Partner-Signed-Redirect: enabled
```
Database migrations [#database-migrations]
The dashboard requires these migrations:
* `supabase_integrations` — encrypted OAuth tokens per workspace
* `supabase_partner_installs` — one-time Marketplace install records
* `supabase_oauth_sessions` — PKCE OAuth state keyed by `state`
Apply them before enabling the integration in production.
Security notes [#security-notes]
* OAuth tokens are encrypted at rest; integration queries run under organization RLS
* Partner install IDs bind to a single workspace on first use (prevents hijacking)
* OAuth PKCE state is stored in the database keyed by OAuth `state` (multi-tab safe)
* Sign-in and sign-up redirects are validated as internal paths only
* `NEXT_PUBLIC_APP_URL` is required in production (Host header is not trusted)
* Public install endpoints are rate limited
* Partner JWTs are verified with `ES256`, a 5-minute max age, and required claims
Next steps [#next-steps]
* [Supabase](https://cipherstash.com/docs/stack/cipherstash/supabase) — CLI setup, EQL install, and SDK integration paths
* [Supabase JS SDK integration](https://cipherstash.com/docs/stack/cipherstash/encryption/supabase) — `encryptedSupabase` API reference
* [OIDC Providers](https://cipherstash.com/docs/stack/cipherstash/kms/oidc) — Register and use identity providers
* [Identity-aware encryption](https://cipherstash.com/docs/stack/cipherstash/encryption/identity) — Bind encryption to user JWTs
* [Going to production](https://cipherstash.com/docs/stack/deploy/going-to-production) — `CS_*` credentials for deployed apps
# Discovery session
Source: https://cipherstash.com/docs/stack/reference/discovery-session
Discovery session [#discovery-session]
A discovery session is a structured 60-minute conversation between your engineering or security team and CipherStash. The goal is to map your data security requirements to the right integration path and identify anything that needs attention before you start building.
This page differs from the [planning guide](https://cipherstash.com/docs/stack/reference/planning-guide). The planning guide is self-serve technical reading you do before or after a session. This page is preparation for the conversation itself.
Who should attend [#who-should-attend]
Bring the people who can answer questions about your data architecture and compliance requirements. Typically:
* An engineer who owns the data layer or ORM setup
* A security, compliance, or privacy lead (if separate from engineering)
You do not need to have any CipherStash code written yet.
What to prepare [#what-to-prepare]
Work through the following before the session. You do not need written answers. Thinking through these areas in advance makes the conversation more productive.
Current data security posture [#current-data-security-posture]
* Which sensitive fields does your application store (PII, payment data, health records)?
* Are those fields encrypted today? If so, at what layer (disk, TLS, application)?
* Do you have column-level or field-level encryption anywhere?
Regulated data inventory [#regulated-data-inventory]
* Which regulations apply to your data (GDPR, HIPAA, PCI-DSS, SOC 2, BDSG)?
* Which specific fields are in scope for each regulation?
* Do you have data residency requirements (EU-only, US-only)?
Target outcomes [#target-outcomes]
* What is the threat model you are trying to address (breach, insider access, accidental exposure)?
* Do you need searchable encrypted fields, or encrypt-only?
* Do you need per-user encryption (identity-aware, lock contexts)?
* What does success look like at 30 days, 90 days?
Architecture constraints [#architecture-constraints]
* Which database are you using (PostgreSQL self-hosted, Supabase, RDS, DynamoDB)?
* Which ORM or query layer sits above it (Drizzle, Prisma, raw SQL, Supabase JS SDK)?
* Do you use a connection proxy or PgBouncer?
* What is your deployment environment (Vercel, AWS Lambda, containers, bare metal)?
* Do you have restrictions on native Node.js modules or binary dependencies?
What to expect during the session [#what-to-expect-during-the-session]
1. **Context gathering (15 min).** The CipherStash team walks through the areas above with you. No slides, no sales deck.
2. **Integration path recommendation (20 min).** Based on your database and ORM, the team recommends one of: Proxy (zero code changes), Encryption SDK (application-layer control), Drizzle adapter, or Supabase wrapper. See [the PostgreSQL options overview](https://cipherstash.com/docs/stack/cipherstash/postgres) for a preview of this decision.
3. **Key questions and blockers (15 min).** Open discussion about anything that could block adoption: compliance requirements, deployment constraints, managed database limitations.
4. **Next steps (10 min).** Concrete actions for both sides, with timelines.
You will leave with a clear recommended path, answers to your blockers, and a point of contact for technical questions during your trial.
Book a session [#book-a-session]
[Contact the CipherStash team](https://cipherstash.com/contact) to schedule a discovery session.
# Drizzle adapter reference
Source: https://cipherstash.com/docs/stack/reference/drizzle
`@cipherstash/stack/drizzle` integrates CipherStash field-level encryption with Drizzle ORM. It provides a custom column type for encrypted fields and drop-in query operators that encrypt search values before they reach PostgreSQL. This page covers the operators, batching patterns, and migration generation. The step-by-step integration guide is at [Drizzle integration guide](https://cipherstash.com/docs/stack/cipherstash/encryption/drizzle). Full type signatures live in the auto-generated API reference.
Public entry points [#public-entry-points]
| Export | Purpose |
| --------------------------- | ----------------------------------------------------------------------------------------------------------------------------- |
| `encryptedType` | Custom Drizzle column type for an encrypted field. Accepts a `dataType` and index config. |
| `extractEncryptionSchema` | Converts a Drizzle `pgTable` definition into a CipherStash `EncryptedTable` schema for the SDK. |
| `createEncryptionOperators` | Returns an object with all Drizzle query operators wrapped for encrypted columns. |
| `EncryptedColumnConfig` | Type alias for the column configuration object (`dataType`, `equality`, `freeTextSearch`, `orderAndRange`, `searchableJson`). |
| `EncryptionConfigError` | Thrown when a column lacks the index required by an operator. |
| `EncryptionOperatorError` | Thrown for operator-level failures (invalid arguments, unsupported operations). |
Encrypted query operators [#encrypted-query-operators]
`createEncryptionOperators` returns a set of operators that mirror the standard Drizzle operator names. Each operator encrypts the search value before constructing the SQL fragment.
**Key pattern:** Most operators are async. `await` the operator call in the `.where()` clause, or pass un-awaited operators to `encryptionOps.and()` / `encryptionOps.or()` for batching.
| Operator | EQL function / mechanism | Required column index | Notes |
| -------------------------------- | ------------------------------------- | ---------------------- | ----------------------------------------------- |
| `eq(col, value)` | PostgreSQL `=` on `eql_v2_encrypted` | `equality: true` | Also accepts `orderAndRange: true` |
| `ne(col, value)` | PostgreSQL `!=` on `eql_v2_encrypted` | `equality: true` | Also accepts `orderAndRange: true` |
| `like(col, pattern)` | Bloom filter via `eql_v2_encrypted` | `freeTextSearch: true` | Case sensitivity depends on token filter config |
| `ilike(col, pattern)` | Bloom filter via `eql_v2_encrypted` | `freeTextSearch: true` | Case sensitivity depends on token filter config |
| `notIlike(col, pattern)` | Bloom filter via `eql_v2_encrypted` | `freeTextSearch: true` | |
| `gt(col, value)` | `eql_v2.gt()` ORE function | `orderAndRange: true` | |
| `gte(col, value)` | `eql_v2.gte()` ORE function | `orderAndRange: true` | |
| `lt(col, value)` | `eql_v2.lt()` ORE function | `orderAndRange: true` | |
| `lte(col, value)` | `eql_v2.lte()` ORE function | `orderAndRange: true` | |
| `between(col, min, max)` | `eql_v2.gte()` + `eql_v2.lte()` | `orderAndRange: true` | Inclusive |
| `notBetween(col, min, max)` | ORE negation | `orderAndRange: true` | |
| `inArray(col, values)` | Multiple equality encryptions | `equality: true` | |
| `notInArray(col, values)` | Multiple equality encryptions | `equality: true` | |
| `asc(col)` | ORE sort expression | `orderAndRange: true` | Sync, no `await` needed |
| `desc(col)` | ORE sort expression | `orderAndRange: true` | Sync, no `await` needed |
| `jsonbPathExists(col, path)` | `eql_v2.jsonb_path_exists()` | `searchableJson: true` | Returns boolean for use in `WHERE` |
| `jsonbPathQueryFirst(col, path)` | `eql_v2.jsonb_path_query_first()` | `searchableJson: true` | Returns encrypted value for use in `SELECT` |
| `jsonbGet(col, path)` | `->` operator on `eql_v2_encrypted` | `searchableJson: true` | Returns encrypted value for use in `SELECT` |
Non-encrypted columns fall back to the standard Drizzle operator automatically.
Sorting encrypted columns with `asc()` or `desc()` requires operator family support in the database. On managed databases (Supabase, RDS) or when EQL is installed with `--exclude-operator-family`, sort application-side after decrypting instead.
```typescript filename="queries.ts"
import { drizzle } from "drizzle-orm/postgres-js"
import { Encryption } from "@cipherstash/stack"
import { extractEncryptionSchema, createEncryptionOperators } from "@cipherstash/stack/drizzle"
import { usersTable } from "./schema"
import postgres from "postgres"
const usersSchema = extractEncryptionSchema(usersTable)
const client = await Encryption({ schemas: [usersSchema] })
const ops = createEncryptionOperators(client)
const db = drizzle({ client: postgres(process.env.DATABASE_URL!) })
// Equality lookup
const exact = await db
.select()
.from(usersTable)
.where(await ops.eq(usersTable.email, "alice@example.com"))
// Range query on an encrypted number column
const adults = await db
.select()
.from(usersTable)
.where(await ops.gte(usersTable.age, 18))
```
Batching conditions with and and or [#batching-conditions-with-and-and-or]
Passing multiple operators to `encryptionOps.and()` or `encryptionOps.or()` batches all encryption into a single ZeroKMS call. This is more efficient than `await`ing each operator separately.
Pass each operator without `await` as an argument to `and()` or `or()`, then `await` the outer call.
```typescript filename="batched-query.ts"
// All three encryptions happen in one ZeroKMS call
const results = await db
.select()
.from(usersTable)
.where(
await ops.and(
ops.gte(usersTable.age, 18),
ops.lte(usersTable.age, 65),
ops.ilike(usersTable.email, "%@example.com"),
),
)
```
Both `and()` and `or()` filter out `undefined` conditions, which makes conditional query building safe:
```typescript filename="conditional-query.ts"
const results = await db
.select()
.from(usersTable)
.where(
await ops.and(
searchEmail ? ops.ilike(usersTable.email, `%${searchEmail}%`) : undefined,
ops.gte(usersTable.age, minAge),
),
)
```
EQL migration generation [#eql-migration-generation]
`extractEncryptionSchema` produces a CipherStash schema object from your Drizzle table. The `@cipherstash/cli` uses this schema to generate the EQL database migration that installs the required PostgreSQL indexes.
Run the migration generator after defining your table:
```bash
npx @cipherstash/cli db install
```
The CLI reads your Drizzle config and calls `extractEncryptionSchema` internally to determine which columns need EQL indexes. It then produces a timestamped SQL migration file in your Drizzle migrations directory.
See the [CipherStash CLI reference](https://cipherstash.com/docs/stack/cipherstash/cli) for all `db install` options.
Cross-links [#cross-links]
* Integration guide: [Drizzle integration guide](https://cipherstash.com/docs/stack/cipherstash/encryption/drizzle)
* Index types: [Encrypted indexes](https://cipherstash.com/docs/stack/cipherstash/encryption/indexes)
* Query patterns: [Encrypted queries](https://cipherstash.com/docs/stack/cipherstash/encryption/queries)
* PostgreSQL setup: [Postgres setup](https://cipherstash.com/docs/stack/cipherstash/postgres)
Full API surface [#full-api-surface]
The Drizzle adapter now ships as its own package, `@cipherstash/stack-drizzle`, with the EQL v3 dialect on `@cipherstash/stack-drizzle/v3`. This page documents the older `@cipherstash/stack/drizzle` entry point; the [Drizzle integration](https://cipherstash.com/docs/integrations/drizzle) is the current, EQL v3 surface:
* `encryptedType` — column builder
* `extractEncryptionSchema` — schema conversion
* `createEncryptionOperators` — operator factory
* `EncryptedColumnConfig` — column config type
# Encryption SDK reference
Source: https://cipherstash.com/docs/stack/reference/encryption-sdk
`@cipherstash/stack` is CipherStash's field-level encryption SDK for TypeScript. It encrypts individual column values client-side using per-value keys derived from ZeroKMS (backed by AWS KMS), before data leaves the application. This page summarises the public surface, data type rules, and configuration options. Full type signatures live in the [auto-generated API reference](https://cipherstash.com/docs/reference/stack/api-reference).
Public entry points [#public-entry-points]
| Export | Import path | Purpose |
| ------------------------------------------------------- | ------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------- |
| `Encryption(config)` | `@cipherstash/stack` | Factory function. Returns a `Promise`. [Reference](https://cipherstash.com/docs/reference/stack/api-reference) |
| `EncryptionClient` | `@cipherstash/stack/encryption` | Class with all encrypt/decrypt methods. Obtain via `Encryption()`, not `new`. [Reference](https://cipherstash.com/docs/reference/stack/api-reference) |
| `encryptedTable` / `encryptedColumn` / `encryptedField` | `@cipherstash/stack/schema` | Schema builders. Define which tables and columns to encrypt, and which search indexes to create. [Reference](https://cipherstash.com/docs/reference/stack/api-reference) |
| `LockContext` | `@cipherstash/stack/identity` | Identity-aware encryption. Ties an encrypted value to a specific JWT identity. [Reference](https://cipherstash.com/docs/reference/stack/api-reference) |
| `Secrets` | `@cipherstash/stack/secrets` | End-to-end encrypted secret storage. Separate from field-level encryption. [Reference](https://cipherstash.com/docs/reference/stack/api-reference) |
| Error types | `@cipherstash/stack/errors` | `StackError`, `EncryptionErrorTypes`, `getErrorMessage`. [Reference](https://cipherstash.com/docs/reference/stack/api-reference) |
Adapter packages [#adapter-packages]
| Adapter | Import path | Guide |
| ----------- | ----------------------------- | -------------------------------------------------------- |
| Drizzle ORM | `@cipherstash/stack/drizzle` | [Drizzle guide](https://cipherstash.com/docs/stack/cipherstash/encryption/drizzle) |
| DynamoDB | `@cipherstash/stack/dynamodb` | [DynamoDB guide](https://cipherstash.com/docs/stack/cipherstash/encryption/dynamodb) |
| Supabase | `@cipherstash/stack/supabase` | [Supabase guide](https://cipherstash.com/docs/stack/cipherstash/encryption/supabase) |
Supported data types [#supported-data-types]
Each encrypted column has a declared `dataType`. This tells the SDK how to serialise the value before encryption and how to deserialise it after decryption.
| Data type | `dataType()` value | Cast required? |
| ------------ | -------------------- | -------------- |
| String | `"string"` (default) | No |
| Text (alias) | `"text"` | No |
| Number | `"number"` | Yes |
| Bigint | `"bigint"` | Yes |
| Boolean | `"boolean"` | Yes |
| Date | `"date"` | Yes |
| JSON | `"json"` | Yes |
**Why casting is required for non-string types.** The schema describes the shape of a column but not the runtime value. When you encrypt a `number`, the SDK serialises it as a number so that ORE (Order-Revealing Encryption) indexes preserve ordering. Without an explicit `dataType`, the SDK defaults to string serialisation. Mixing declared types and actual values produces decryption errors, so always set `dataType` when the column holds a non-string value.
```typescript filename="schema.ts"
import { encryptedTable, encryptedColumn } from "@cipherstash/stack/schema"
const users = encryptedTable("users", {
email: encryptedColumn("email").equality().freeTextSearch(),
age: encryptedColumn("age").dataType("number").orderAndRange(),
metadata: encryptedColumn("metadata").dataType("json").searchableJson(),
})
```
Special-value handling [#special-value-handling]
Some numeric inputs are invalid for encryption. The following table covers the behaviours documented and validated by the SDK.
| Input | Result |
| ------------------------ | ---------------------------------- |
| `NaN` | Error (rejected before encryption) |
| `Infinity` / `-Infinity` | Error (rejected before encryption) |
Passing `NaN` or `Infinity` to an encrypted numeric column throws at the operation level, not at the type level. TypeScript will not catch these at compile time. Validate your inputs before calling `encrypt` or `encryptModel`.
ProtectClientConfig highlights [#protectclientconfig-highlights]
`Encryption()` accepts an `EncryptionClientConfig` object. The `config` field is a `ClientConfig`. All credentials fall back to environment variables when omitted.
| Option | Env variable | Description |
| -------------- | ---------------------- | ---------------------------------------------------------------------------- |
| `workspaceCrn` | `CS_WORKSPACE_CRN` | Workspace Cloud Resource Name. Format: `crn:.aws:` |
| `accessKey` | `CS_CLIENT_ACCESS_KEY` | API access key for authenticating with CipherStash |
| `clientId` | `CS_CLIENT_ID` | Client identifier generated during workspace onboarding |
| `clientKey` | `CS_CLIENT_KEY` | Client key material used for ZeroKMS encryption operations |
| `keyset` | (none) | Multi-tenant isolation. Specify `{ name: "tenant-a" }` or `{ id: "" }` |
See [the generated API reference](https://cipherstash.com/docs/reference/stack/api-reference) for the complete `EncryptionClientConfig` and `ClientConfig` types.
```typescript filename="init.ts"
import { Encryption } from "@cipherstash/stack"
import { users } from "./schema"
// Reads CS_* env vars automatically when config is omitted
const client = await Encryption({ schemas: [users] })
// Or pass credentials explicitly
const client = await Encryption({
schemas: [users],
config: {
workspaceCrn: "crn:ap-southeast-2.aws:your-workspace-id",
clientId: "your-client-id",
clientKey: "your-client-key",
accessKey: "your-access-key",
},
})
```
Logging [#logging]
Set `STASH_STACK_LOG` to control log verbosity. The SDK never logs plaintext data.
| Value | Output |
| ----------------- | ----------------------- |
| `error` (default) | Errors only |
| `info` | Info and errors |
| `debug` | Debug, info, and errors |
Full API surface [#full-api-surface]
Everything else is in the auto-generated TypeDoc reference:
* [Generated API reference](https://cipherstash.com/docs/reference/stack/api-reference) — encryption, schema, identity, configuration, and error exports
# Encrypt Query Language (EQL)
Source: https://cipherstash.com/docs/stack/reference/eql-guide
**Encrypt Query Language (EQL)** is a set of PostgreSQL types, operators, and functions that enable queries on encrypted data without decryption. EQL works seamlessly with the [CipherCell](https://cipherstash.com/docs/stack/reference/cipher-cell) format to provide searchable encryption capabilities directly in PostgreSQL.
What is EQL? [#what-is-eql]
EQL provides the database-side components needed to query encrypted data. Unlike traditional PostgreSQL extensions, EQL is implemented as a collection of types, operators, and functions, making it compatible with managed database providers like AWS RDS that restrict extension installation.
When combined with the [Encryption SDK](https://cipherstash.com/docs/stack/cipherstash/encryption) or [CipherStash Proxy](https://cipherstash.com/docs/stack/cipherstash/proxy), EQL enables:
* **Exact match queries** using encrypted equality operators
* **Range queries** with order-preserving encryption
* **Pattern matching** using encrypted Bloom filters
* **Unique constraints** on encrypted columns
* **JSON/JSONB operations** on encrypted structured data
Core components [#core-components]
The eql_v2_encrypted type [#the-eql_v2_encrypted-type]
The foundation of EQL is the `eql_v2_encrypted` data type, which stores [CipherCells](https://cipherstash.com/docs/stack/reference/cipher-cell) containing encrypted data and searchable encrypted metadata.
```sql
CREATE TABLE users (
id SERIAL PRIMARY KEY,
email eql_v2_encrypted,
name eql_v2_encrypted
);
```
The `eql_v2_encrypted` type is required for searchable encryption in PostgreSQL. Regular `JSON` or `JSONB` types can store CipherCells but do not support encrypted queries.
Operators [#operators]
EQL provides PostgreSQL operators that work directly with encrypted data:
```sql
-- Exact match
SELECT * FROM users WHERE email = 'encrypted_search_value'::eql_v2_encrypted;
-- Range queries
SELECT * FROM products WHERE price > 'encrypted_value'::eql_v2_encrypted;
-- Pattern matching
SELECT * FROM documents WHERE content LIKE '%encrypted_pattern%';
```
Functions [#functions]
EQL includes functions for configuration, querying, and working with encrypted data:
Configuration functions [#configuration-functions]
Functions to set up and manage encrypted columns:
* `eql_v2.add_column()`: Initialize a column for encryption
* `eql_v2.add_search_config()`: Add searchable indexes to encrypted columns
* `eql_v2.remove_column()`: Remove column configuration
* `eql_v2.config()`: View current configuration
Query functions [#query-functions]
Functions for querying encrypted data (operator equivalents also available):
* Equality checks: `eql_v2.encrypted_eq()`
* Range comparisons: `eql_v2.encrypted_lt()`, `eql_v2.encrypted_gt()`, etc.
* Pattern matching: `eql_v2.encrypted_like()`, `eql_v2.encrypted_ilike()`
Index term extraction [#index-term-extraction]
Functions to extract searchable terms from CipherCells:
* `eql_v2.encrypted_get_hmac_256()`: Extract HMAC term for exact matches
* `eql_v2.encrypted_get_bloom_filter()`: Extract Bloom filter for pattern matching
* `eql_v2.encrypted_get_ore()`: Extract ORE term for range queries
Index types [#index-types]
EQL supports multiple searchable encryption index types. Each index type enables different query patterns:
unique: Exact match [#unique-exact-match]
Enables exact equality queries and unique constraints using HMAC-SHA256.
[Learn more about exact indexes](https://cipherstash.com/docs/stack/cipherstash/encryption/searchable-encryption#exact-matching)
ore: Range queries [#ore-range-queries]
Enables range comparisons (`<`, `>`, `BETWEEN`) and ordering (`ORDER BY`) using Order Revealing Encryption.
[Learn more about range indexes](https://cipherstash.com/docs/stack/cipherstash/encryption/searchable-encryption#sorting-and-range-queries)
match: Pattern matching [#match-pattern-matching]
Enables substring and full-text search (`LIKE`, `ILIKE`) using encrypted Bloom filters with trigrams.
[Learn more about match indexes](https://cipherstash.com/docs/stack/cipherstash/encryption/searchable-encryption#free-text-search)
ste_vec: Structured data [#ste_vec-structured-data]
Enables containment queries and JSON-style operations on encrypted arrays and JSONB data.
How it works [#how-it-works]
EQL leverages PostgreSQL's native indexing capabilities to enable efficient queries on encrypted data. The searchable encrypted metadata within [CipherCells](https://cipherstash.com/docs/stack/reference/cipher-cell) is indexed using standard PostgreSQL index types (B-tree for exact/range, GIN for pattern matching).
When a query is executed:
1. **Client-side**: The application encrypts the search value using the same encryption scheme, producing a CipherCell with the appropriate searchable encrypted metadata
2. **Database-side**: EQL operators extract and compare the searchable encrypted metadata from both the stored CipherCells and the search CipherCell
3. **Result**: Matching rows are returned without ever decrypting the data in the database
Compatibility [#compatibility]
EQL is designed to work with:
* **PostgreSQL 14+**: Full support for all EQL features
* **Managed databases**: Works with AWS RDS, Azure Database, Google Cloud SQL, and other managed PostgreSQL providers
* **CipherStash SDKs**: Integrates with all CipherStash SDKs as well as CipherStash Proxy
Unlike PostgreSQL extensions that require `CREATE EXTENSION`, EQL types and functions are installed directly into your database schema, making it compatible with managed database environments that restrict extension installation.
Related documentation [#related-documentation]
* [CipherCell format](https://cipherstash.com/docs/stack/reference/cipher-cell): The data structure used by EQL
* [Supported queries](https://cipherstash.com/docs/stack/cipherstash/encryption/searchable-encryption): Available searchable encryption schemes
# Error handling
Source: https://cipherstash.com/docs/stack/reference/error-handling
All async methods in the SDK return a `Result` object — a discriminated union with either a `data` key (success) or a `failure` key (error). You never get both.
The one exception is `Encryption()` initialization, which throws on failure rather than returning a `Result`. See [Handling initialization errors](#handling-initialization-errors) below.
The Result pattern [#the-result-pattern]
```typescript title="result-check.ts"
const result = await client.encrypt("hello@example.com", {
column: users.email,
table: users,
})
if (result.failure) {
// result.failure.type: string (e.g. "EncryptionError")
// result.failure.message: string (human-readable description)
console.error(result.failure.type, result.failure.message)
} else {
// result.data: Encrypted payload
console.log(result.data)
}
```
This pattern applies to every async method: `encrypt`, `decrypt`, `encryptModel`, `decryptModel`, `bulkEncrypt`, `bulkDecrypt`, `bulkEncryptModels`, `bulkDecryptModels`, and `encryptQuery`. The one exception is `Encryption()` initialization, which throws on failure.
Error types [#error-types]
| Type | When it occurs | Common causes |
| ------------------ | -------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------- |
| `ClientInitError` | `Encryption()` initialization | Missing or invalid credentials, unreachable ZeroKMS endpoint, no schemas provided |
| `EncryptionError` | `encrypt`, `encryptModel`, `bulkEncrypt`, `encryptQuery` | Invalid plaintext for the column's data type, NaN/Infinity for numeric columns, non-string value for `freeTextSearch` column |
| `DecryptionError` | `decrypt`, `decryptModel`, `bulkDecrypt` | Corrupted ciphertext, wrong keyset, lock context mismatch (data was encrypted with a different identity) |
| `LockContextError` | `LockContext` operations | Invalid JWT, missing required claims, CTS endpoint unreachable |
| `CtsTokenError` | CTS token exchange | JWT rejected by CipherStash Token Service, expired token, CTS endpoint misconfigured |
Handling initialization errors [#handling-initialization-errors]
Client initialization is the most common place to encounter errors. Unlike other SDK operations, `Encryption()` throws on failure rather than returning a `Result`.
```typescript title="init-error.ts"
import { Encryption } from "@cipherstash/stack"
import { users } from "./schema"
try {
const client = await Encryption({ schemas: [users] })
} catch (error) {
// Check your CS_* environment variables
console.error("Failed to initialize:", error.message)
process.exit(1)
}
```
Common initialization issues [#common-initialization-issues]
| Symptom | Cause | Fix |
| ------------------------- | ------------------------------ | ------------------------------------------------ |
| `"Missing workspace CRN"` | `CS_WORKSPACE_CRN` not set | Set the env var or pass `workspaceCrn` in config |
| `"Missing client ID"` | `CS_CLIENT_ID` not set | Set the env var or pass `clientId` in config |
| `"Missing client key"` | `CS_CLIENT_KEY` not set | Set the env var or pass `clientKey` in config |
| `"Missing access key"` | `CS_CLIENT_ACCESS_KEY` not set | Set the env var or pass `accessKey` in config |
| Connection timeout | ZeroKMS endpoint unreachable | Check network connectivity and firewall rules |
Handling encrypt/decrypt errors [#handling-encryptdecrypt-errors]
```typescript title="encrypt-error.ts"
const encrypted = await client.encrypt(value, {
column: users.email,
table: users,
})
if (encrypted.failure) {
switch (encrypted.failure.type) {
case "EncryptionError":
// Log the error and decide whether to retry or fail
console.error("Encryption failed:", encrypted.failure.message)
break
}
}
```
Common encrypt/decrypt issues [#common-encryptdecrypt-issues]
| Symptom | Cause | Fix |
| ---------------------------------------- | ------------------------------------------------------ | --------------------------------------------------------------- |
| `"NaN is not a valid value"` | Passed `NaN` to a numeric column | Validate inputs before encrypting |
| `"Infinity is not a valid value"` | Passed `Infinity` to a numeric column | Validate inputs before encrypting |
| `"Expected string value"` | Non-string value for a column with `.freeTextSearch()` | Convert to string or remove the `freeTextSearch` index |
| Decryption fails with lock context error | Data was encrypted with a different identity | Ensure the same user's JWT is used for both encrypt and decrypt |
| Decryption returns corrupted data error | Wrong keyset or tampered ciphertext | Verify the keyset matches the one used during encryption |
Handling bulk operation errors [#handling-bulk-operation-errors]
Bulk operations (`bulkDecrypt`, `bulkDecryptModels`) support **per-item error handling**. The overall operation succeeds but individual items may fail.
```typescript title="bulk-error.ts"
const result = await client.bulkDecrypt(encryptedPayloads)
if (result.failure) {
// Entire operation failed (e.g., ZeroKMS unreachable)
console.error("Bulk decrypt failed:", result.failure.message)
} else {
// Per-item results
for (const item of result.data) {
if ("data" in item) {
console.log(`${item.id}: decrypted successfully`)
} else {
// Individual item failed
console.error(`${item.id}: ${item.error}`)
}
}
}
```
Handling identity errors [#handling-identity-errors]
When using [identity-aware encryption](https://cipherstash.com/docs/stack/cipherstash/encryption/identity), errors can occur while federating the user's JWT or while binding a lock context. Both surface on the operation's `Result`.
```typescript title="identity-error.ts"
const result = await client
.encrypt("sensitive data", { column: users.email, table: users })
.withLockContext({ identityClaim: ["sub"] })
if (result.failure) {
console.error("Identity-aware encryption failed:", result.failure.message)
}
```
Common identity issues [#common-identity-issues]
| Symptom | Cause | Fix |
| --------------------------------- | --------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------ |
| Missing claim | The JWT doesn't contain the configured identity claim | Check your JWT contains the `sub` claim (or your custom claims) |
| Federation rejected | The JWT is expired, or the provider is not registered | Return a live token from the `OidcFederationStrategy` callback, and add the provider to your workspace |
| Decryption fails for a valid user | The value was encrypted under a different `identityClaim`, or as a different user | Supply the same claim used at encrypt time |
Error type constants and utilities [#error-type-constants-and-utilities]
The `@cipherstash/stack/errors` subpath exports runtime constants, the `StackError` union type, and a utility for safely extracting error messages.
StackError union type [#stackerror-union-type]
`StackError` is a discriminated union of all error types, enabling exhaustive `switch` handling:
```typescript title="error-types.ts"
import { EncryptionErrorTypes, type StackError, getErrorMessage } from "@cipherstash/stack/errors"
function handleError(error: StackError) {
switch (error.type) {
case EncryptionErrorTypes.ClientInitError:
console.error("Init failed:", error.message)
break
case EncryptionErrorTypes.EncryptionError:
console.error("Encrypt failed:", error.message, error.code)
break
case EncryptionErrorTypes.DecryptionError:
console.error("Decrypt failed:", error.message)
break
case EncryptionErrorTypes.LockContextError:
console.error("Lock context failed:", error.message)
break
case EncryptionErrorTypes.CtsTokenError:
console.error("CTS token failed:", error.message)
break
default:
// TypeScript ensures exhaustiveness
const _exhaustive: never = error
}
}
```
getErrorMessage [#geterrormessage]
Use `getErrorMessage` to safely extract a message from any thrown value:
```typescript title="get-error-message.ts"
import { getErrorMessage } from "@cipherstash/stack/errors"
try {
await client.encrypt("data", { column: users.email, table: users })
} catch (e) {
console.error(getErrorMessage(e))
}
```
Wrapping errors in application code [#wrapping-errors-in-application-code]
Create a helper that converts `Result` into thrown errors for frameworks that expect exceptions (e.g., Express, Next.js API routes):
```typescript title="helpers.ts"
function unwrap(result: { data?: T; failure?: { type: string; message: string } }): T {
if (result.failure) {
throw new Error(`[${result.failure.type}] ${result.failure.message}`)
}
return result.data as T
}
// Usage
const encrypted = unwrap(await client.encrypt("hello", { column: users.email, table: users }))
```
The `Result` pattern is intentionally designed to avoid thrown exceptions. Use the `unwrap` helper only at your application's boundaries where exceptions are expected.
Logging [#logging]
Control SDK log verbosity with the `STASH_STACK_LOG` environment variable:
```bash
STASH_STACK_LOG=error # debug | info | error (default: error)
```
| Value | What is logged |
| ------- | ----------------------- |
| `error` | Errors only (default) |
| `info` | Info and errors |
| `debug` | Debug, info, and errors |
The SDK never logs plaintext data or key material at any log level.
# Glossary
Source: https://cipherstash.com/docs/stack/reference/glossary
A [#a]
ABAC (Attribute Based Access Control) [#abac-attribute-based-access-control]
ABAC is a dynamic security model that makes access decisions based on a variety of attributes, including user characteristics, resource details, and environmental factors.
Unlike [RBAC](#rbac-role-based-access-control), which relies solely on a user's assigned role, ABAC offers more granular and context-aware policies that adapt to changing conditions and diverse scenarios.
Access key [#access-key]
A persistent authentication credential used for communication with [ZeroKMS](#zerokms) or [CTS](#cts-cipherstash-token-service).
See [Access keys](https://cipherstash.com/docs/stack/cipherstash/kms/access-keys) for details.
Account management [#account-management]
Activities to administer your CipherStash account, like billing, adding, and removing users.
C [#c]
Ciphertext [#ciphertext]
An encrypted version of plaintext, produced by applying an encryption algorithm (a cipher). It is unreadable without a cipher to decrypt it.
See also: [Plaintext](#plaintext)
CipherStash CLI [#cipherstash-cli]
The command line tool for interacting with CipherStash services.
CipherStash Proxy [#cipherstash-proxy]
A database proxy that sits between an application and a database, enhancing your existing database with encryption in use.
CipherStash Proxy works in-tandem with your existing infrastructure and is fully contained within your environment.
See [CipherStash Proxy](https://cipherstash.com/docs/stack/cipherstash/proxy) for details.
Client key [#client-key]
The cryptographic credential assigned to a programmatic access point for a [keyset](#keyset). A client key can have access to many keysets, and a keyset can also be shared by multiple client keys.
There are two types of client keys:
* **Device-backed client keys** are created automatically by `npx stash init` and tied to a developer's [device](#device). Used for local development.
* **Application client keys** are created in the Dashboard for production and CI/CD. Identified by a [client ID](#client-id) and [client key](#client-key) set via environment variables.
See [Client keys](https://cipherstash.com/docs/stack/cipherstash/kms/clients) for details.
Client ID [#client-id]
A unique identifier for a [client key](#client-key). Each client key and client ID is unique to your app.
Client key value [#client-key-value]
The secret credential set via `CS_CLIENT_KEY`. Together with the [client ID](#client-id), it forms the credential pair for a [client key](#client-key). The client key value is sensitive and must be kept secret.
CTS (CipherStash Token Service) [#cts-cipherstash-token-service]
CTS manages the trust relationships between a workspace and third-party or customer identity providers.
It brokers secure access to CipherStash services like ZeroKMS, ensuring that only authenticated and authorized users gain entry.
See [CTS](https://cipherstash.com/docs/stack/cipherstash/kms/cts) for details.
D [#d]
Dashboard [#dashboard]
The web interface for managing CipherStash Cloud primitives — workspaces, client keys, keysets, access keys, devices, and members.
Available at [dashboard.cipherstash.com](https://dashboard.cipherstash.com/).
The Dashboard manages cloud infrastructure; product-specific configuration (encryption schemas, secrets, proxy rules) is handled by the SDKs and CLI.
Device [#device]
A unique identity tied to a developer's device and user account, created by `npx stash init`.
Each device has an associated [client key](#client-key) that is automatically granted access to the default [keyset](#keyset).
Devices are used for local development authentication — no environment variables required.
Production environments use application [client keys](#client-key) with environment variables instead.
See [Getting started](https://cipherstash.com/docs/stack/quickstart) for setup.
Data access event [#data-access-event]
An event triggered by execution of SQL statements by CipherStash Proxy. Includes metadata of statements executed and records accessed.
E [#e]
EQL (Encrypt Query Language) [#eql-encrypt-query-language]
Our [open-source library](https://github.com/cipherstash/encrypt-query-language) for PostgreSQL users. It simplifies the process of encrypting and querying sensitive data, giving you powerful tools to encrypt data transparently at the field level, query encrypted data directly using familiar SQL commands, and leverage encrypted indexes for secure and efficient searches.
See [EQL](https://cipherstash.com/docs/stack/reference/eql-guide) for details.
H [#h]
HMAC (Hash-based Message Authentication Code) [#hmac-hash-based-message-authentication-code]
A cryptographic technique that combines a hash function with a secret key to verify both the integrity and authenticity of a message.
Unlike raw hash functions (such as SHA-256), HMAC requires a secret key, which means only parties with the key can generate valid HMACs.
This prevents attackers from pre-computing hash tables (rainbow tables) or guessing values.
In searchable encryption, HMACs are used to create encrypted search tokens. The key stays on the application side, so the server can match encrypted search tokens without ever learning the plaintext or being able to generate new tokens.
I [#i]
IdP (Identity Provider) [#idp-identity-provider]
A third party identity provider, like Auth0, Okta, or Clerk.
J [#j]
JWT (JSON Web Token) [#jwt-json-web-token]
JWT is a compact, URL-safe means of representing claims between two parties as a JSON object, typically used for authentication and authorization.
They are digitally signed to ensure the integrity and authenticity of the information, allowing systems to verify user identity without maintaining server-side sessions.
K [#k]
Keyset [#keyset]
A core CipherStash Cloud primitive for cryptographic isolation, managed by [ZeroKMS](#zerokms).
Each keyset maintains its own set of data encryption keys — data encrypted under one keyset cannot be decrypted with another.
Use keysets for tenant isolation, environment separation, regional compliance, or any cryptographic boundary your architecture requires.
A [client key](#client-key) can access many keysets, and a keyset can be shared by multiple client keys.
In the Secrets SDK, [environments](#environment) map directly to keysets.
See [Keysets](https://cipherstash.com/docs/stack/cipherstash/kms/keysets) for details.
O [#o]
OIDC (OpenID Connect) [#oidc-openid-connect]
OIDC is an identity layer built on top of the OAuth 2.0 protocol that enables applications to verify user identity through an [Identity Provider](#idp-identity-provider).
It facilitates secure single sign-on (SSO) and simplifies the authentication process by allowing the Identity Provider to share standardized identity information using RESTful APIs and [JSON Web Tokens](#jwt-json-web-token) (JWTs).
ORE (Order Revealing Encryption) [#ore-order-revealing-encryption]
A searchable encryption technique allowing for search, comparison, and sorting of encrypted data without decryption.
See [Range queries](https://cipherstash.com/docs/stack/cipherstash/encryption/searchable-encryption#sorting-and-range-queries) for details.
P [#p]
Plaintext [#plaintext]
Unencrypted information, readable by humans and computers.
R [#r]
RBAC (Role Based Access Control) [#rbac-role-based-access-control]
RBAC is a security model that assigns access permissions based on a user's role within an organization, streamlining the management of access rights by grouping permissions into predefined roles.
Unlike [ABAC](#abac-attribute-based-access-control), which evaluates policies based on a range of attributes, RBAC relies solely on roles to determine access.
S [#s]
Searchable encrypted metadata [#searchable-encrypted-metadata]
An encrypted data structure for finding records in encrypted columns. Essential for querying encrypted data, as it replaces the need for full table scans, improving performance.
This is a core feature of CipherStash, supporting range, exact, and match queries.
See [Supported queries](https://cipherstash.com/docs/stack/cipherstash/encryption/searchable-encryption) for details.
W [#w]
Workspace [#workspace]
CipherStash uses workspaces to keep things organized.
A workspace contains [keysets](#keyset), client keys, and configuration, and can:
* Be used to separate environments (e.g. dev and prod)
* Be shared with other users
* Be associated with a custom identity provider
See [Platform](https://cipherstash.com/docs/stack/reference) for details.
Z [#z]
ZeroKMS [#zerokms]
CipherStash's specialized key management service. ZeroKMS provides high performance batch encryption and decryption, enabling a unique encryption key per field.
See [ZeroKMS](https://cipherstash.com/docs/stack/cipherstash/kms) for details.
# API Reference
Source: https://cipherstash.com/docs/stack/reference
Auto-generated TypeDoc reference for CipherStash packages. For hand-written guides and examples, see the [Encryption docs](https://cipherstash.com/docs/stack/cipherstash/encryption).
Packages [#packages]
@cipherstash/stack [#cipherstashstack]
The core CipherStash SDK. Includes Encryption (`Encryption()`, `EncryptionClient`, schema builders, type inference, Lock Context), Secrets API, and integrations (Drizzle, Supabase, DynamoDB, and more).
[Browse @cipherstash/stack reference](https://cipherstash.com/docs/reference/stack/api-reference)
EQL API [#eql-api]
PostgreSQL types, operators, and functions for the Encrypt Query Language (EQL) extension. Enables searchable encryption and encrypted queries directly in the database.
[Browse EQL API reference](https://cipherstash.com/docs/stack/reference/eql)
# Members
Source: https://cipherstash.com/docs/stack/reference/members
There are two types of memberships in CipherStash:
* Organization memberships
* Workspace memberships
Every user belongs to at least one organization, and can be invited to any number of workspaces inside that organization.
Organization memberships [#organization-memberships]
Organization memberships are used to manage which users in your organization have access to CipherStash in general.
Once a user is added to an organization, they can be granted access to any number of workspaces inside that organization.
Workspace memberships [#workspace-memberships]
Workspace memberships are used to manage which users have access to a specific workspace.
Once a user is added to a workspace, they have full access to managing the workspace, including creating and managing keysets, clients, and access keys.
Adding a member to an organization [#adding-a-member-to-an-organization]
To add a member to an organization, navigate to **Members** in the Dashboard's organization sidebar.
Adding a member to a workspace [#adding-a-member-to-a-workspace]
To add a member to a workspace, go to the [Settings](https://dashboard.cipherstash.com/workspaces/_/settings) page for your workspace in the Dashboard and grant access to a user.
Developer device onboarding [#developer-device-onboarding]
After a member is added to an organization and granted workspace access, they initialize their local development environment:
```bash
npx stash init
```
This creates a unique [device](https://cipherstash.com/docs/stack/reference/glossary#device) and [client key](https://cipherstash.com/docs/stack/reference/glossary#client-key) for that developer, with automatic access to the default [keyset](https://cipherstash.com/docs/stack/cipherstash/kms/keysets).
No environment variables are needed for local development.
See [Team onboarding](https://cipherstash.com/docs/stack/deploy/team-onboarding) for the full workflow.
# Migration guide
Source: https://cipherstash.com/docs/stack/reference/migration
Migration from @cipherstash/protect [#migration-from-cipherstashprotect]
Use the following table to map the old API to the new one.
Import changes [#import-changes]
| `@cipherstash/protect` | `@cipherstash/stack` | Import path |
| ---------------------------------------------------------------- | ----------------------------------------------------------- | ----------------------------- |
| `protect(config)` | `Encryption(config)` | `@cipherstash/stack` |
| `csTable(name, cols)` | `encryptedTable(name, cols)` | `@cipherstash/stack/schema` |
| `csColumn(name)` | `encryptedColumn(name)` | `@cipherstash/stack/schema` |
| `import { LockContext } from "@cipherstash/encryption/identify"` | `import { LockContext } from "@cipherstash/stack/identity"` | `@cipherstash/stack/identity` |
New features in @cipherstash/stack [#new-features-in-cipherstashstack]
| Feature | Import path |
| --------------- | ---------------------------- |
| `Secrets` class | `@cipherstash/stack/secrets` |
| `stash` CLI | `npx stash` |
What stays the same [#what-stays-the-same]
All method signatures on the encryption client (`encrypt`, `decrypt`, `encryptModel`, `decryptModel`, `bulkEncrypt`, `bulkDecrypt`, `bulkEncryptModels`, `bulkDecryptModels`) remain the same.
The `Result` pattern (`data` / `failure`) is unchanged.
Step-by-step [#step-by-step]
1. Install the new package:
```bash cta cta-type="install" example-id="install-stack-migration"
npm install @cipherstash/stack
npm uninstall @cipherstash/protect
```
If you're using Bun, version 1.3 or later is required.
2. Update imports:
```typescript
// Before
import { protect } from "@cipherstash/protect"
import { csTable, csColumn } from "@cipherstash/protect"
// After
import { Encryption } from "@cipherstash/stack"
import { encryptedTable, encryptedColumn } from "@cipherstash/stack/schema"
```
3. Rename function calls:
```typescript
// Before
const client = await protect({ schemas: [users] })
// After
const client = await Encryption({ schemas: [users] })
```
4. Update schema definitions:
```typescript
// Before
const users = csTable("users", {
email: csColumn("email").equality().freeTextSearch(),
})
// After
const users = encryptedTable("users", {
email: encryptedColumn("email").equality().freeTextSearch(),
})
```
Your encrypt/decrypt calls need no changes. They work the same way.
# Planning guide
Source: https://cipherstash.com/docs/stack/reference/planning-guide
This guide helps you plan a CipherStash integration. Use it to evaluate your security posture, choose the right integration path, and understand the architecture.
Key discovery areas [#key-discovery-areas]
Before starting, assess the following:
* **Current data security posture**: How do you currently encrypt sensitive data? Are you relying solely on encryption-at-rest?
* **Compliance requirements**: What regulations apply (GDPR, HIPAA, PCI-DSS, SOC2)?
* **Architecture constraints**: What databases and application frameworks are you using?
* **Security concerns**: What attack vectors are you most concerned about (breaches, insider threats, accidental exposure)?
Understanding encryption types [#understanding-encryption-types]
Encryption-at-rest [#encryption-at-rest]
Data is encrypted when stored on disk but decrypted for any operation. A database breach that exposes memory or query results reveals plaintext data.
Encryption-in-transit [#encryption-in-transit]
Data is encrypted between services (TLS) but decrypted at each endpoint. Data is exposed in application memory and during processing.
Encryption-in-use [#encryption-in-use]
Data remains encrypted during search and processing. CipherStash provides encryption-in-use through searchable encryption. You can query encrypted data without decrypting it first.
| Capability | At-rest | In-transit | In-use (CipherStash) |
| ----------------------------- | ------- | ---------- | -------------------- |
| Protects stored data | Yes | No | Yes |
| Protects data in transit | No | Yes | Yes |
| Protects data during queries | No | No | Yes |
| Searchable without decryption | No | No | Yes |
| Zero-trust architecture | No | No | Yes |
Architecture considerations [#architecture-considerations]
Zero-knowledge design [#zero-knowledge-design]
CipherStash uses a split-key architecture. [ZeroKMS](https://cipherstash.com/docs/stack/cipherstash/kms) manages an authority key that is necessary but not sufficient to derive data keys. Your application holds an independent client key. Data keys are derived locally and never leave your infrastructure.
This means:
* Plaintext data never leaves your systems
* Data keys are never transmitted over the network
* Even CipherStash cannot access your data
PostgreSQL integration [#postgresql-integration]
CipherStash is designed around PostgreSQL, the most popular open-source database. Integration requires no architecture changes:
* **[EQL](https://cipherstash.com/docs/stack/reference/eql-guide)** provides native PostgreSQL types for encrypted data
* Existing queries and applications work with minimal modification
* Performance overhead is minimal (sub-millisecond for most operations)
Integration paths [#integration-paths]
| Path | Best for | Code changes |
| ----------------------------------------------- | ---------------------------------------------------------- | --------------------------------------------------- |
| [Encryption SDK](https://cipherstash.com/docs/stack/cipherstash/encryption) | Application-layer encryption with fine-grained control | Moderate (encrypt/decrypt calls in your data layer) |
| [CipherStash Proxy](https://cipherstash.com/docs/stack/cipherstash/proxy) | Existing PostgreSQL applications with minimal code changes | Minimal (point your connection at the proxy) |
ORM support [#orm-support]
The Encryption SDK integrates with popular ORMs:
* **[Drizzle ORM](https://cipherstash.com/docs/stack/cipherstash/encryption/drizzle)**: Custom encrypted column types with query operators
* **[Supabase](https://cipherstash.com/docs/stack/cipherstash/encryption/supabase)**: Transparent encryption wrapper around the Supabase client
* **[DynamoDB](https://cipherstash.com/docs/stack/cipherstash/encryption/dynamodb)**: Encrypted attributes with searchable capabilities
ZeroKMS overview [#zerokms-overview]
[ZeroKMS](https://cipherstash.com/docs/stack/cipherstash/kms) is CipherStash's zero-trust key management service:
* **Key hierarchy**: Authority keys, client keys, and derived data keys provide defense in depth
* **Regional deployment**: Available in [multiple regions](https://cipherstash.com/docs/stack/cipherstash/kms/regions) for data sovereignty
* **Audit logging**: Complete visibility into key usage and access patterns
* **Disaster recovery**: Multi-region key replication with [automated failover](https://cipherstash.com/docs/stack/cipherstash/kms/disaster-recovery)
Development to production journey [#development-to-production-journey]
| Stage | Auth model | Setup |
| ----------------- | --------------------- | ------------------------------------------------------ |
| Local development | Device-based | `npx stash init` per developer — no env vars needed |
| Staging / CI | Environment variables | Application client key + `CS_*` env vars |
| Production | Environment variables | Application client key + `CS_*` env vars (member role) |
Local development uses device-based auth for zero-config setup and per-developer identity.
Each developer is uniquely identified via their device, providing audit trails and individual access control.
Staging and production use environment variables because there is no interactive device.
See [Going to production](https://cipherstash.com/docs/stack/deploy/going-to-production) for the full transition guide and [Team onboarding](https://cipherstash.com/docs/stack/deploy/team-onboarding) for setting up your development team.
Enterprise features [#enterprise-features]
Lock contexts [#lock-contexts]
[Lock contexts](https://cipherstash.com/docs/stack/cipherstash/encryption/identity) provide identity-aware encryption. Bind encryption operations to authenticated users using JWTs for:
* Temporal access control: time-limited access to sensitive data
* Provable access boundaries: cryptographic proof of who accessed what
* Audit trails: complete record of all data access events
Multi-tenant encryption [#multi-tenant-encryption]
Cryptographic tenant isolation ensures complete separation between tenants. Each tenant's data is encrypted with independent key material, meeting strict data residency and compliance requirements.
Next steps [#next-steps]
1. **Get started**: Run `npx stash init` to set up [device-based auth](https://cipherstash.com/docs/stack/quickstart)
2. **Choose your integration path**: [Encryption SDK](https://cipherstash.com/docs/stack/quickstart) or [CipherStash Proxy](https://cipherstash.com/docs/stack/cipherstash/proxy/getting-started)
3. **Build locally**: Device auth handles credentials automatically — focus on your integration
4. **Go to production**: Set up [application client keys and env vars](https://cipherstash.com/docs/stack/deploy/going-to-production) for deployment
# Error reference
Source: https://cipherstash.com/docs/stack/reference/proxy-errors
This page covers every error CipherStash Proxy can return, grouped by category, with steps to diagnose and resolve each one.
Authentication errors [#authentication-errors]
Database authentication failed [#database-authentication-failed]
**Error:** `Database authentication failed. Check username and password`
The proxy could not authenticate with the upstream PostgreSQL database.
1. Check that the configured username and password are correct and can connect to the database.
2. Check that the database uses a supported authentication method. Supported methods: `password`, `md5`, `scram-sha-256`. See [PostgreSQL password authentication](https://www.postgresql.org/docs/17/auth-password.html).
Client authentication failed [#client-authentication-failed]
**Error:** `Client authentication failed. Check username and password.`
The proxy rejected the client connection because the credentials were incorrect.
Check that the username and password your application sends match the values configured in the proxy.
ZeroKMS authentication failed [#zerokms-authentication-failed]
**Error:** `ZeroKMS authentication failed. Check the configured credentials.`
The proxy could not authenticate with CipherStash ZeroKMS.
1. Check that the configured `client` credentials are correct.
2. Check that the active `keyset_name` or `keyset_id` is associated with a keyset in the configured workspace.
***
Mapping errors [#mapping-errors]
Invalid parameter [#invalid-parameter]
**Error:** `Invalid parameter for column 'column_name' of type 'cast' in table 'table_name'. (OID 'oid')`
Each encrypted column definition includes a target `cast` type. When encrypting a parameter or literal, the proxy decodes and casts the data into that type. This error means the passed data cannot be decoded and cast to the expected type.
In some cases, parameter types are automatically converted. For example, PostgreSQL `INT2`, `INT4`, and `INT8` are converted to the corresponding encrypted integer types.
Check that the parameter or literal matches the type configured for the encrypted column.
Invalid SQL statement [#invalid-sql-statement]
**Error:** `sql parser error: Expected: SELECT, VALUES, or a subquery in the query body` (varies)
The proxy could not parse the SQL statement.
Check that the statement is valid PostgreSQL SQL. If you believe the statement is correct and the parser is wrong, contact [CipherStash support](https://cipherstash.com/support).
Unsupported parameter type [#unsupported-parameter-type]
**Error:** `Encryption of PostgreSQL {name} (OID {oid}) types is not currently supported.`
The data type of the parameter is not supported for encryption.
Check the supported types for encrypted columns.
Statement could not be type checked [#statement-could-not-be-type-checked]
**Error:** `Statement could not be type checked: '{type-check-error-message}'`
The proxy checks SQL statements against the database schema to transparently encrypt and decrypt data. The behavior when a type check fails depends on the `mapping_errors_enabled` configuration:
* When `mapping_errors_enabled` is `false` (default): the error is logged and the statement passes through to the database.
* When `mapping_errors_enabled` is `true`: the error is raised and statement execution halts.
The default behavior passes statements through because most production systems have a small number of encrypted columns, and blocking on false negatives causes more harm. When a statement does pass through, the database's EQL column constraints catch invalid data and return an error like:
```sql
ERROR: Encrypted column missing version (v) field: 34234
CONTEXT: PL/pgSQL function _cs_encrypted_check_v(jsonb) line 6 at RAISE
SQL function "cs_check_encrypted_v1" statement 1
```
Check that you are running the latest version of CipherStash Proxy. Contact [CipherStash support](https://cipherstash.com/support) if the error persists.
Internal mapper error [#internal-mapper-error]
**Error:** `Statement encountered an internal error. This may be a bug in the statement mapping module of CipherStash Proxy.`
An unexpected error occurred in the statement mapping module.
Update to the latest version. Contact [CipherStash support](https://cipherstash.com/support) if the error persists.
***
Encrypt errors [#encrypt-errors]
Column could not be encrypted [#column-could-not-be-encrypted]
**Error:** `Column 'column_name' in table 'table_name' could not be encrypted.`
The proxy uses CipherStash ZeroKMS for encryption operations. The most likely cause is a network issue reaching the ZeroKMS service.
1. Check that CipherStash ZeroKMS is available at the [status page](https://status.cipherstash.com/).
2. Check that the proxy has network access to ZeroKMS in the appropriate region.
3. Check that the encrypted configuration `cast` matches the expected type.
KeysetId could not be parsed [#keysetid-could-not-be-parsed]
**Error:** `KeysetId '{id}' could not be parsed using 'SET CIPHERSTASH.KEYSET_ID'. KeysetId should be a valid UUID.`
The value passed to `SET CIPHERSTASH.KEYSET_ID` is not a valid UUID.
Check that the `KeysetId` is a valid UUID. The correct syntax is:
```sql
SET [SESSION] CIPHERSTASH.KEYSET_ID { TO | = } '{KeysetId}'
```
KeysetId could not be set [#keysetid-could-not-be-set]
**Error:** `Keyset Id could not be set using 'SET CIPHERSTASH.KEYSET_ID'`
1. Check the syntax: the `keyset_id` value must be in single quotes.
2. Check that the `keyset_id` is a valid UUID.
3. Check that the value is a literal. PostgreSQL `SET` does not support parameterised queries.
KeysetName could not be set [#keysetname-could-not-be-set]
**Error:** `Keyset Name could not be set using 'SET CIPHERSTASH.KEYSET_NAME'`
1. Check the syntax: the `keyset_name` value must be in single quotes.
2. Check that the value is a literal. PostgreSQL `SET` does not support parameterised queries.
Unknown keyset identifier [#unknown-keyset-identifier]
**Error:** `Unknown keyset name or id '{keyset}'`
The proxy could not find a keyset matching the name or ID.
1. Check that the active `keyset_name` or `keyset_id` is associated with a keyset in the configured workspace.
2. Check that the configured `client` has been granted access to the keyset in the dashboard.
3. Keyset names are case-sensitive. Check for an exact match.
4. Check that the configured `client` credentials are correct.
Could not decrypt data for keyset [#could-not-decrypt-data-for-keyset]
**Error:** `Could not decrypt data for keyset '{keyset_id}'`
The active `keyset_id` does not match the `keyset_id` of the data being decrypted. Each encrypted record belongs to a keyset with a unique identifier. The proxy encrypts data using the currently active keyset. If the record's `keyset_id` does not match the active `keyset_id`, the data cannot be decrypted.
You can set a default keyset in the proxy configuration, or use `SET CIPHERSTASH.KEYSET_ID` to set the active keyset at runtime.
1. Check that the `keyset_id` in the configuration matches the `keyset_id` of the encrypted records.
2. If using `SET CIPHERSTASH.KEYSET_ID`, check that the value matches the encrypted records.
3. Check that the configured `client` has been granted access to the `keyset_id`.
Plaintext could not be encoded [#plaintext-could-not-be-encoded]
**Error:** `Decrypted column could not be encoded as the expected type.`
Each encrypted column definition includes a target `cast` type. When the proxy decrypts data, it casts and encodes the result as the PostgreSQL representation of that type. Changing the encrypted column definition after data has been written can cause this error.
1. Check that the encrypted configuration has the correct type.
2. Check that the column configuration has not changed since the data was written.
Unknown column [#unknown-column]
**Error:** `Column 'column_name' in table 'table_name' has no Encrypt configuration`
The column has an encrypted type (`eql_v2_encrypted`) but no encryption configuration has been defined.
Define the encrypted configuration using EQL:
```sql
SELECT cs_add_column_v1('users', 'email');
```
Unknown table [#unknown-table]
**Error:** `Table 'table_name' has no Encrypt configuration`
The table has one or more encrypted columns but no encryption configuration has been defined.
Define the encrypted configuration using EQL:
```sql
SELECT cs_add_column_v1('users', 'email');
```
Unknown index term [#unknown-index-term]
**Error:** `Unknown Index Term for column '{column_name}' in table '{table_name}'.`
The encrypted column has an unrecognised index configuration. EQL validates indexes when they are added, but direct database changes can misconfigure the setup.
Check the Encrypt configuration for the column and redefine it if necessary.
Column configuration mismatch [#column-configuration-mismatch]
**Error:** `Column configuration for column '{column_name}' in table '{table_name}' does not match the encrypted column.`
The proxy validates that encrypted columns match their configuration before decrypting. This check prevents confused deputy attacks and should not appear during normal operation. Contact [CipherStash support](https://cipherstash.com/support) if it persists.
***
Decrypt errors [#decrypt-errors]
Column could not be deserialised [#column-could-not-be-deserialised]
**Error:** `Column 'column_name' in table 'table_name' could not be deserialised.`
The proxy stores encrypted data and search terms as `jsonb`. This error indicates an internal issue deserialising and extracting the ciphertext for decryption. It may occur if the encrypted data has been altered by another process.
Check that the data in the encrypted column is in the correct EQL format. Contact [CipherStash support](https://cipherstash.com/support) if the error persists.
***
Configuration errors [#configuration-errors]
Missing or invalid TLS configuration [#missing-or-invalid-tls-configuration]
**Errors:**
```
Invalid Transport Layer Security (TLS) certificate.
Invalid Transport Layer Security (TLS) private key.
Missing Transport Layer Security (TLS) certificate at path: {path}.
Missing Transport Layer Security (TLS) private key at path: {path}.
```
For path-based configuration, check that the certificate and key exist at the specified paths and are valid. For PEM-based configuration, check that the certificate and key values are valid.
Network configuration change requires restart [#network-configuration-change-requires-restart]
**Error:** `Network configuration change requires restart`
When the proxy receives a `SIGHUP` signal, it reloads application-level configuration without disrupting active connections. However, the following network settings require a full restart:
* `server.host`
* `server.port`
* `server.require_tls`
* `server.worker_threads`
* `tls` (any TLS configuration)
Application-level settings (`database`, `auth`, `encrypt`, `log`, `prometheus`, `development`) can be reloaded without a restart using `SIGHUP`.
Stop the proxy, update the configuration, then restart the proxy.
# Reference
Source: https://cipherstash.com/docs/stack/reference/proxy-reference
Configuration loading order [#configuration-loading-order]
Proxy accepts configuration from a TOML file, environment variables, or both.
1. If `cipherstash-proxy.toml` exists in the current working directory, Proxy reads it first.
2. Proxy then reads any environment variables that are set.
3. When both are present, environment variables override values from the TOML file.
Config options [#config-options]
[server] [#server]
| Option | Env variable | Default | Description |
| -------------------------- | ------------------------------------- | -------------------------- | ------------------------------------------------------------------------------------------- |
| `host` | `CS_SERVER__HOST` | `0.0.0.0` | Proxy listen address |
| `port` | `CS_SERVER__PORT` | `6432` | Proxy listen port |
| `require_tls` | `CS_SERVER__REQUIRE_TLS` | `false` | Enforce TLS for client-to-proxy connections |
| `shutdown_timeout` | `CS_SERVER__SHUTDOWN_TIMEOUT` | `2000` | Milliseconds to wait for connections to drain on shutdown |
| `worker_threads` | `CS_SERVER__WORKER_THREADS` | `NUMBER_OF_CORES/2` or `4` | Number of server worker threads |
| `thread_stack_size` | `CS_SERVER__THREAD_STACK_SIZE` | `2097152` (2 MiB) | Thread stack size in bytes. Automatically set to 4 MiB when log level is `debug` or `trace` |
| `cipher_cache_size` | `CS_SERVER__CIPHER_CACHE_SIZE` | `64` | Maximum number of encryption/decryption operations to cache |
| `cipher_cache_ttl_seconds` | `CS_SERVER__CIPHER_CACHE_TTL_SECONDS` | `3600` | Seconds before cached cipher operations expire |
[database] [#database]
| Option | Env variable | Default | Description |
| ------------------------ | ------------------------------------- | ---------- | --------------------------------------------------------------------------------------------------------------------------------- |
| `host` | `CS_DATABASE__HOST` | `0.0.0.0` | Database host address |
| `port` | `CS_DATABASE__PORT` | `5432` | Database port |
| `name` | `CS_DATABASE__NAME` | (required) | Database name |
| `username` | `CS_DATABASE__USERNAME` | (required) | Database username |
| `password` | `CS_DATABASE__PASSWORD` | (required) | Database password |
| `connection_timeout` | `CS_DATABASE__CONNECTION_TIMEOUT` | none | Milliseconds to hold an idle connection open. In production, set this higher than your application's connection pool idle timeout |
| `with_tls_verification` | `CS_DATABASE__WITH_TLS_VERIFICATION` | `false` | Enable TLS verification between Proxy and the database |
| `config_reload_interval` | `CS_DATABASE__CONFIG_RELOAD_INTERVAL` | `60` | Seconds between encrypted index configuration reloads |
| `schema_reload_interval` | `CS_DATABASE__SCHEMA_RELOAD_INTERVAL` | `60` | Seconds between database schema reloads |
[tls] [#tls]
Configure TLS for client-to-proxy connections. Provide either file paths or inline PEM strings.
| Option | Env variable | Description |
| ------------------ | -------------------------- | ------------------------------------------ |
| `certificate_path` | `CS_TLS__CERTIFICATE_PATH` | Path to the public certificate `.crt` file |
| `private_key_path` | `CS_TLS__PRIVATE_KEY_PATH` | Path to the private key file |
| `certificate_pem` | `CS_TLS__CERTIFICATE_PEM` | Public certificate as a PEM string |
| `private_key_pem` | `CS_TLS__PRIVATE_KEY_PEM` | Private key as a PEM string |
[auth] [#auth]
| Option | Env variable | Description |
| ------------------- | ---------------------- | ----------------------------- |
| `workspace_crn` | `CS_WORKSPACE_CRN` | CipherStash Workspace CRN |
| `client_access_key` | `CS_CLIENT_ACCESS_KEY` | CipherStash Client Access Key |
[encrypt] [#encrypt]
| Option | Env variable | Description |
| ------------------- | ---------------------- | ---------------------- |
| `default_keyset_id` | `CS_DEFAULT_KEYSET_ID` | CipherStash Dataset ID |
| `client_id` | `CS_CLIENT_ID` | CipherStash Client ID |
| `client_key` | `CS_CLIENT_KEY` | CipherStash Client Key |
[log] [#log]
| Option | Env variable | Default | Description |
| ---------------------------------- | ------------------------------------------ | ------------------------------------------------ | ------------------------------------------------------------------------------ |
| `level` | `CS_LOG__LEVEL` | `info` | Global log level. Valid values: `error`, `warn`, `info`, `debug`, `trace` |
| `format` | `CS_LOG__FORMAT` | `pretty` (terminal), `structured` (non-terminal) | Log format. Valid values: `pretty`, `text`, `structured` (JSON) |
| `output` | `CS_LOG__OUTPUT` | `stdout` | Log output destination. Valid values: `stdout`, `stderr` |
| `ansi_enabled` | `CS_LOG__ANSI_ENABLED` | `true` (terminal), `false` (non-terminal) | Enable colored output |
| `slow_statements` | `CS_LOG__SLOW_STATEMENTS` | `false` | Enable slow statement logging |
| `slow_statement_min_duration_ms` | `CS_LOG__SLOW_STATEMENT_MIN_DURATION_MS` | `2000` | Minimum duration in milliseconds for a statement to be considered slow |
| `slow_db_response_min_duration_ms` | `CS_LOG__SLOW_DB_RESPONSE_MIN_DURATION_MS` | `100` | Minimum duration in milliseconds for a database response to be considered slow |
[prometheus] [#prometheus]
| Option | Env variable | Default | Description |
| --------- | ------------------------ | ------- | -------------------------------------- |
| `enabled` | `CS_PROMETHEUS__ENABLED` | `false` | Enable the Prometheus metrics exporter |
| `port` | `CS_PROMETHEUS__PORT` | `9930` | Port for the Prometheus exporter |
Full TOML example [#full-toml-example]
```toml filename="cipherstash-proxy.toml"
[server]
host = "0.0.0.0"
port = "6432"
require_tls = "false"
shutdown_timeout = "2000"
worker_threads = "4"
thread_stack_size = "2097152"
cipher_cache_size = "64"
cipher_cache_ttl_seconds = "3600"
[database]
host = "0.0.0.0"
port = "5432"
name = "database"
username = "username"
password = "password"
connection_timeout = "300000"
with_tls_verification = "false"
config_reload_interval = "60"
schema_reload_interval = "60"
[tls]
certificate_path = "./server.crt"
private_key_path = "./server.key"
[auth]
workspace_crn = "cipherstash-workspace-crn"
client_access_key = "cipherstash-client-access-key"
[encrypt]
default_keyset_id = "cipherstash-dataset-id"
client_id = "cipherstash-client-id"
client_key = "cipherstash-client-key"
[log]
level = "info"
format = "pretty"
output = "stdout"
ansi_enabled = "true"
slow_statements = "false"
slow_statement_min_duration_ms = "2000"
slow_db_response_min_duration_ms = "100"
[prometheus]
enabled = "false"
port = "9930"
```
Development settings [#development-settings]
Default settings are tuned for production. When running Proxy locally, override these for a better development experience. None of these settings are appropriate for production.
Enable colored, human-readable logs:
```bash
CS_LOG__FORMAT="pretty"
CS_LOG__ANSI_ENABLED="true"
```
Reduce reload intervals when iterating on your schema:
```bash
CS_DATABASE__CONFIG_RELOAD_INTERVAL="10"
CS_DATABASE__SCHEMA_RELOAD_INTERVAL="10"
```
Slow query logging [#slow-query-logging]
Slow query logging helps you identify statements that take longer than expected. Enable it with:
```bash
CS_LOG__SLOW_STATEMENTS="true"
```
By default, any statement taking longer than 2000 ms is flagged. Tune the thresholds to match your latency expectations:
```bash
CS_LOG__SLOW_STATEMENT_MIN_DURATION_MS="500" # statement total time
CS_LOG__SLOW_DB_RESPONSE_MIN_DURATION_MS="200" # database round-trip only
```
When a slow statement is detected, Proxy emits a structured log line at the `SLOW_STATEMENTS` target. With `format = "pretty"`, it looks like:
```
WARN slow_statement duration_ms=620 query="SELECT * FROM users WHERE ..."
```
Use these log lines to identify queries that need indexes or to spot unexpectedly slow EQL operations. To isolate slow-statement output in production, set `CS_LOG__SLOW_STATEMENTS_LEVEL=warn` while keeping the global level at `error`.
Docker-specific options [#docker-specific-options]
These environment variables are only available in the Docker container image and are not present in the binary.
| Env variable | Description |
| ------------------------------------------ | ------------------------------------------------------- |
| `CS_DATABASE__INSTALL_EQL` | Install EQL on container startup |
| `CS_DATABASE__INSTALL_EXAMPLE_SCHEMA` | Load the example schema on container startup |
| `CS_DATABASE__INSTALL_AWS_RDS_CERT_BUNDLE` | Add the AWS RDS certificate bundle for TLS verification |
`CS_DATABASE__INSTALL_EQL` and `CS_DATABASE__INSTALL_EXAMPLE_SCHEMA` are for development use only. Install EQL using the [installation script](https://github.com/cipherstash/encrypt-query-language/releases) as a database migration in production.
Per-target log levels [#per-target-log-levels]
Override the log level for specific internal components using the pattern `CS_LOG__{TARGET}_LEVEL`. These environment variables accept the same values as `CS_LOG__LEVEL`.
| Env variable | Target | Description |
| ------------------------------- | ----------------- | ------------------------------------------------------ |
| `CS_LOG__DEVELOPMENT_LEVEL` | `DEVELOPMENT` | General development logging |
| `CS_LOG__AUTHENTICATION_LEVEL` | `AUTHENTICATION` | Client authentication and SASL |
| `CS_LOG__CONFIG_LEVEL` | `CONFIG` | Configuration loading |
| `CS_LOG__CONTEXT_LEVEL` | `CONTEXT` | Connection context |
| `CS_LOG__ENCODING_LEVEL` | `ENCODING` | Data encoding and decoding |
| `CS_LOG__ENCRYPT_LEVEL` | `ENCRYPT` | Encryption operations |
| `CS_LOG__DECRYPT_LEVEL` | `DECRYPT` | Decryption operations |
| `CS_LOG__ENCRYPT_CONFIG_LEVEL` | `ENCRYPT_CONFIG` | Encryption configuration loading |
| `CS_LOG__ZEROKMS_LEVEL` | `ZEROKMS` | ZeroKMS cipher initialization, cache, and connectivity |
| `CS_LOG__MIGRATE_LEVEL` | `MIGRATE` | Schema migration |
| `CS_LOG__PROTOCOL_LEVEL` | `PROTOCOL` | PostgreSQL wire protocol |
| `CS_LOG__MAPPER_LEVEL` | `MAPPER` | SQL statement mapping and transformation |
| `CS_LOG__SCHEMA_LEVEL` | `SCHEMA` | Database schema analysis |
| `CS_LOG__SLOW_STATEMENTS_LEVEL` | `SLOW_STATEMENTS` | Slow statement detection |
CLI reference [#cli-reference]
```bash
cipherstash-proxy [OPTIONS] [DBNAME] [COMMAND]
```
Commands [#commands]
| Command | Description |
| --------- | ----------------------------------------------- |
| `encrypt` | Encrypt existing plaintext data in the database |
| `help` | Print help information |
Arguments and options [#arguments-and-options]
| Flag | Default | Description |
| ------------------------------------------- | ------------------------------------------------ | ------------------------------------ |
| `DBNAME` | | Database name (positional, optional) |
| `-H, --db-host ` | `127.0.0.1` | Database host |
| `-u, --db-user ` | `postgres` | Database user |
| `-p, --config-file-path ` | `cipherstash-proxy.toml` | Path to the TOML config file |
| `-l, --log-level ` | `info` | Log level |
| `-f, --log-format ` | `pretty` (terminal), `structured` (non-terminal) | Log format |
Prometheus metrics [#prometheus-metrics]
Enable the Prometheus exporter by setting `CS_PROMETHEUS__ENABLED=true`. Metrics are exposed on port `9930` by default.
| Metric | Type | Description |
| --------------------------------------------------------- | --------- | ----------------------------------------------------------------- |
| `cipherstash_proxy_keyset_cipher_cache_hits_total` | Counter | Keyset-scoped cipher cache hits |
| `cipherstash_proxy_keyset_cipher_cache_miss_total` | Counter | Cipher cache misses requiring initialization |
| `cipherstash_proxy_keyset_cipher_init_total` | Counter | New keyset-scoped cipher initializations |
| `cipherstash_proxy_keyset_cipher_init_duration_seconds` | Histogram | Duration of cipher initialization, including ZeroKMS network call |
| `cipherstash_proxy_clients_active_connections` | Gauge | Current active client connections |
| `cipherstash_proxy_clients_bytes_received_total` | Counter | Bytes received from clients |
| `cipherstash_proxy_clients_bytes_sent_total` | Counter | Bytes sent to clients |
| `cipherstash_proxy_decrypted_values_total` | Counter | Individual values decrypted |
| `cipherstash_proxy_decryption_duration_seconds` | Histogram | Time spent performing decryption |
| `cipherstash_proxy_decryption_duration_seconds_count` | Counter | Number of decryption timing observations |
| `cipherstash_proxy_decryption_duration_seconds_sum` | Counter | Total cumulative decryption time |
| `cipherstash_proxy_decryption_error_total` | Counter | Unsuccessful decryption operations |
| `cipherstash_proxy_decryption_requests_total` | Counter | ZeroKMS decrypt requests |
| `cipherstash_proxy_encrypted_values_total` | Counter | Individual values encrypted |
| `cipherstash_proxy_encryption_duration_seconds` | Histogram | Time spent performing encryption |
| `cipherstash_proxy_encryption_duration_seconds_count` | Counter | Number of encryption timing observations |
| `cipherstash_proxy_encryption_duration_seconds_sum` | Counter | Total cumulative encryption time |
| `cipherstash_proxy_encryption_error_total` | Counter | Unsuccessful encryption operations |
| `cipherstash_proxy_encryption_requests_total` | Counter | ZeroKMS encrypt requests |
| `cipherstash_proxy_rows_encrypted_total` | Counter | Encrypted rows returned to clients |
| `cipherstash_proxy_rows_passthrough_total` | Counter | Non-encrypted rows returned to clients |
| `cipherstash_proxy_rows_total` | Counter | Total rows returned to clients |
| `cipherstash_proxy_server_bytes_received_total` | Counter | Bytes received from the PostgreSQL server |
| `cipherstash_proxy_server_bytes_sent_total` | Counter | Bytes sent to the PostgreSQL server |
| `cipherstash_proxy_statements_execution_duration_seconds` | Histogram | Database SQL execution time |
| `cipherstash_proxy_statements_session_duration_seconds` | Histogram | Total statement processing time (encrypt + execute + decrypt) |
| `cipherstash_proxy_statements_encrypted_total` | Counter | Statements requiring encryption |
| `cipherstash_proxy_statements_passthrough_total` | Counter | Statements not requiring encryption |
| `cipherstash_proxy_statements_total` | Counter | Total statements processed |
| `cipherstash_proxy_statements_unmappable_total` | Counter | Statements that could not be mapped |
Supported architectures [#supported-architectures]
CipherStash Proxy is available as a Docker container image for `linux/arm64` architectures.
# Security architecture
Source: https://cipherstash.com/docs/stack/reference/security-architecture
This page is the single reference for CipherStash's cryptographic design. It covers the key hierarchy, encryption primitives, trust model, and data flow so security teams can evaluate CipherStash without piecing together information from multiple sources.
Cryptographic primitives [#cryptographic-primitives]
| Purpose | Algorithm | Details |
| ------------------------- | ----------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Data encryption | AES-256-GCM-SIV | 256-bit keys, authenticated encryption with nonce-misuse resistance |
| Equality search tokens | HMAC-SHA-256 | Deterministic tokens for exact-match lookups |
| Range and sorting indexes | Block ORE | Order-Revealing Encryption ([Lewi-Wu 2016](https://eprint.iacr.org/2016/612)) with security enhancements from [Bogatov et al 2018](https://arxiv.org/abs/1810.05135) |
| Free-text search indexes | Encrypted Bloom filters | Trigram-based tokenization ([Nojima/Kadobayashi 2009](https://link.springer.com/chapter/10.1007/978-3-642-04474-8_17), [Chum/Zhang 2017](https://link.springer.com/chapter/10.1007/978-3-319-66399-9_15)) |
| Ciphertext integrity | Blake3 | Fast cryptographic hash for CipherCell structure validation |
| Ciphertext encoding | MessagePack + Base85 | Compact binary serialization stored as JSONB in PostgreSQL |
All encryption happens client-side in the application process. CipherStash infrastructure never sees plaintext data.
Key hierarchy [#key-hierarchy]
CipherStash uses a **distributed trust model** with a dual-party key split. No single party (including CipherStash) can derive data encryption keys alone.
Key types [#key-types]
| Key | Where it lives | Protected by |
| ----------------- | --------------------------- | ------------------------------------------------------------------ |
| **Authority key** | ZeroKMS (server-side) | Encrypted at rest under an AWS KMS root key |
| **Client key** | Your application / workload | You (`CS_CLIENT_KEY` env var). It never leaves your infrastructure |
| **Data key** | Ephemeral (in-memory only) | Nothing. Derived per value, then discarded |
Key derivation [#key-derivation]
The mechanism operates at two layers. Descriptions that name only one of them are incomplete.
**Layer 1, server-side.** Your application requests a key seed by sending a **key ID**. ZeroKMS applies **proxy symmetric re-encryption** (patent pending) to the authority key and returns the **key seed** for that ID. It does this *without* the client key: ZeroKMS never receives it, and the request carries no key material of yours, only the ID.
The ID is what gives every data key a unique identity, so a value can be decrypted later by requesting the seed for the same ID.
**Layer 2, client-side.** Your application **processes the key seed with the client key**, then expands the result into a unique data encryption key per value, using an **HMAC-based key derivation function**. The data key encrypts the value with AES-256-GCM-SIV, then is discarded.
Only the key seed crosses the boundary, and it crosses inward. Nothing crosses outward: not the client key, not the processed seed, not the data key.
Re-encryption describes how the seed is produced. HMAC key derivation describes how the processed seed becomes per-value keys. Both are true, at different layers.
What is cached, and what is not [#what-is-cached-and-what-is-not]
Data keys are **never stored, cached, or transmitted**. They are derived per value, held for one operation, and discarded. This eliminates wrapped-key storage overhead.
[CipherStash Proxy](https://cipherstash.com/docs/stack/cipherstash/proxy) does cache **keyset-scoped cipher objects**, bounded by `cipher_cache_size` (64 entries) and `cipher_cache_ttl_seconds` (3600 seconds), with hit rates exposed as `cipherstash_proxy_keyset_cipher_cache_hits_total`. That is not the same as caching a data key: the cipher still requires the client key to derive anything, and per-value keys are still derived per value. The Encryption SDK derives per operation and caches nothing.
Why this matters [#why-this-matters]
| Traditional KMS | CipherStash ZeroKMS |
| ---------------------------------------------- | ----------------------------------------------------------------------------------------------------------- |
| Wrapped data keys stored alongside data | Data keys are ephemeral (never stored) |
| Data keys cached to make performance tolerable | No data key is ever cached, at any layer |
| Single point of trust (KMS provider) | Distributed trust: both authority key and client key required |
| Compromising KMS exposes all data keys | Compromising ZeroKMS alone is insufficient. An attacker also needs the client key, which ZeroKMS never sees |
Trust model [#trust-model]
CipherStash implements a **zero-knowledge architecture**:
* **CipherStash never sees plaintext data.** All encryption and decryption happens in your application using the native Rust FFI module.
* **CipherStash never sees your client key,** nor anything the client key has processed.
* **CipherStash never sees unwrapped data keys.** Data keys are derived ephemerally and exist only in the client's memory.
* **Both parties are required.** An attacker must compromise both the ZeroKMS authority key and the client key to derive data keys.
Shared responsibility [#shared-responsibility]
| Your responsibility | CipherStash responsibility |
| ---------------------------------------------- | ----------------------------------------------------- |
| Protect the client key (`CS_CLIENT_KEY`) | Protect authority keys in ZeroKMS (HSM-backed) |
| Secure your application and database | Operate ZeroKMS infrastructure with high availability |
| Manage access keys and keysets | Enforce access control policies on keysets |
| Configure identity providers for lock contexts | Operate the CipherStash Token Service (CTS) |
| Store encrypted data in your database | Never store, access, or log plaintext data |
Blast radius [#blast-radius]
CipherStash uses [keysets](https://cipherstash.com/docs/stack/cipherstash/kms/keysets) to scope encryption keys:
* Each keyset provides **full cryptographic isolation**. Tenant A's keyset cannot decrypt Tenant B's data.
* Compromising a single client key affects only the keysets that application has access to.
* Revoking an application's access key immediately prevents further key derivation requests.
Data flow [#data-flow]
Encryption (write path) [#encryption-write-path]
1. Application calls `client.encrypt(plaintext, { column, table })`.
2. SDK requests a key seed from ZeroKMS (over TLS), sending a unique key ID. The request carries no key material.
3. ZeroKMS re-encrypts under the authority key → returns the key seed for that ID.
4. SDK processes the seed with the client key, then derives the data key from the result, locally.
5. SDK encrypts the plaintext using AES-256-GCM-SIV with the data key.
6. SDK generates search index tokens (HMAC, ORE, Bloom filter) if the column has indexes configured.
7. SDK packages ciphertext + index tokens into a [CipherCell](https://cipherstash.com/docs/stack/reference/cipher-cell) (JSON payload).
8. Data key is discarded from memory.
9. Application stores the CipherCell in PostgreSQL (as `eql_v2_encrypted` or `jsonb`).
Decryption (read path) [#decryption-read-path]
1. Application reads the CipherCell from PostgreSQL.
2. Application calls `client.decrypt(encryptedData)`.
3. SDK requests a key seed from ZeroKMS, sending the key ID stored with the value.
4. ZeroKMS re-encrypts under the authority key → returns the key seed for that ID.
5. SDK processes the seed with the client key, derives the data key, and decrypts the ciphertext.
6. Data key is discarded from memory.
7. Plaintext is returned to the application.
Search (query path) [#search-query-path]
1. Application calls `client.encryptQuery(searchTerm, { column, table, queryType })`.
2. SDK generates search tokens (HMAC for equality, ORE for range, Bloom filter for free-text) using a key derived from ZeroKMS.
3. Application sends the encrypted tokens to PostgreSQL.
4. PostgreSQL's [EQL extension](https://cipherstash.com/docs/stack/reference/eql-guide) compares encrypted tokens using the appropriate index. The database never sees plaintext.
Searchable encryption security properties [#searchable-encryption-security-properties]
Searchable encryption enables queries on encrypted data but involves inherent security tradeoffs. Each index type reveals specific, bounded information to the database server.
| Index type | What is revealed to the database | Mitigation |
| ---------------------------- | -------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------- |
| **HMAC (equality)** | Whether two encrypted values are identical (frequency information) | Per-column unique keys prevent cross-column correlation |
| **ORE (range/sort)** | Relative ordering of encrypted values | Block ORE limits leakage to block-level ordering ([Lewi-Wu 2016](https://eprint.iacr.org/2016/612)) |
| **Bloom filter (free-text)** | Probabilistic token membership with configurable false positive rate | Parameters `k` and `m` control the tradeoff between search accuracy and information leakage |
When to use searchable encryption [#when-to-use-searchable-encryption]
* **Use it** when you need to query encrypted data and the leakage profile is acceptable for your threat model.
* **Don't use it** when the mere ordering or frequency of values is sensitive (e.g., exact salary rankings). In those cases, encrypt without indexes and decrypt application-side.
For a deeper analysis of each index type, see [Searchable encryption](https://cipherstash.com/docs/stack/cipherstash/encryption/searchable-encryption) and [Supported queries](https://cipherstash.com/docs/stack/cipherstash/encryption/searchable-encryption).
Network security [#network-security]
All communication between the SDK and CipherStash services uses **TLS 1.2+** over HTTPS:
* SDK → ZeroKMS: Key derivation requests over HTTPS
* SDK → CTS: Token exchange requests over HTTPS (for identity-aware encryption)
* SDK → your database: Your existing database connection (CipherStash does not proxy this)
CipherStash services are deployed across [multiple AWS regions](https://cipherstash.com/docs/stack/cipherstash/kms/regions). Key material does not leave the region your workspace is configured in.
Open-source components [#open-source-components]
| Component | Repository | License |
| ---------------------------- | ------------------------------------------------------------------------------------------------------ | ----------- |
| EQL (Encrypt Query Language) | [github.com/cipherstash/encrypt-query-language](https://github.com/cipherstash/encrypt-query-language) | Open source |
| ORE implementation | [github.com/cipherstash/ore.rs](https://github.com/cipherstash/ore.rs) | Open source |
| CipherStash Proxy | [github.com/cipherstash/proxy](https://github.com/cipherstash/proxy) | Open source |
The core cryptographic implementations (ORE, Bloom filter construction) are open source and independently auditable. ZeroKMS is a managed service operated by CipherStash.
Further reading [#further-reading]
* [What is CipherStash?](https://cipherstash.com/docs/stack/reference/what-is-cipherstash): Platform overview and threat model
* [ZeroKMS](https://cipherstash.com/docs/stack/cipherstash/kms): Key management and keyset isolation
* [CipherCell format](https://cipherstash.com/docs/stack/reference/cipher-cell): Encrypted payload structure
* [Disaster recovery](https://cipherstash.com/docs/stack/cipherstash/kms/disaster-recovery): Key recovery and outage behavior
# Supported solutions
Source: https://cipherstash.com/docs/stack/reference/supported-solutions
CipherStash offers multiple integration paths designed for developer productivity and production readiness.
Integration options [#integration-options]
Encryption SDK [#encryption-sdk]
**Best for**: Teams who want fine-grained control over data encryption directly in their application.
The `@cipherstash/stack` SDK provides application-layer encryption with full TypeScript support, schema-based configuration, and searchable encryption capabilities.
* **Languages**: TypeScript / JavaScript (Node.js)
* **ORMs**: [Drizzle](https://cipherstash.com/docs/stack/cipherstash/encryption/drizzle), [Supabase](https://cipherstash.com/docs/stack/cipherstash/encryption/supabase)
* **Dashboard**: [Connect Supabase from the dashboard](https://cipherstash.com/docs/stack/reference/dashboard-supabase-integration) — OAuth, EQL readiness, OIDC, and Marketplace install
* **Get started**: [Encryption SDK guide](https://cipherstash.com/docs/stack/quickstart)
CipherStash Proxy [#cipherstash-proxy]
**Best for**: DevOps teams who want to add encryption to existing PostgreSQL applications with little to no code changes.
A drop-in SQL proxy for PostgreSQL that automatically handles encryption and decryption operations.
* **Database**: PostgreSQL only
* **Get started**: [Proxy guide](https://cipherstash.com/docs/stack/cipherstash/proxy/getting-started)
Supported databases [#supported-databases]
Database compatibility [#database-compatibility]
| Database | Standard encryption | Searchable encryption |
| ----------------------------------- | ------------------- | ------------------------------------------------ |
| PostgreSQL 15+ | Yes | Yes |
| AWS RDS PostgreSQL | Yes | Yes |
| AWS Aurora PostgreSQL | Yes | Yes |
| GCP Cloud SQL for PostgreSQL | Yes | Yes |
| Azure Database for PostgreSQL | Yes | Yes |
| OCI Database Service for PostgreSQL | Yes | Yes |
| DynamoDB | Yes | Yes |
| Supabase | Yes | Yes ([EQL + Stack](https://cipherstash.com/docs/stack/cipherstash/supabase)) |
| Neon Postgres | Yes | — |
| MySQL | Yes | — |
| CockroachDB | Yes | — |
**Standard encryption** works with any database that supports JSON or JSONB column types. Encrypted values are stored as JSON objects ([CipherCells](https://cipherstash.com/docs/stack/reference/cipher-cell)).
**Searchable encryption** requires [EQL](https://cipherstash.com/docs/stack/reference/eql-guide) (for PostgreSQL) or native integration (for DynamoDB). Searchable encryption enables equality lookups, range queries, ordering, and free-text search on encrypted data without decryption.
Performance characteristics [#performance-characteristics]
SDK integration [#sdk-integration]
* **Latency**: Less than 5ms overhead for most operations
* **Throughput**: Scales with your application
* **Setup time**: Running in local dev in under 1 hour, production in under 3 days
Proxy integration [#proxy-integration]
* **Latency**: Less than 5ms overhead for most operations
* **Throughput**: Horizontally scalable based on database throughput
* **Setup time**: Operational in hours with existing PostgreSQL
Getting started [#getting-started]
1. **Choose your integration path** based on your application type and requirements
2. **Review the getting started guide** for your selected solution: [Encryption SDK](https://cipherstash.com/docs/stack/quickstart) or [Proxy](https://cipherstash.com/docs/stack/cipherstash/proxy/getting-started)
3. **Set up your development environment** with the appropriate SDK or proxy
4. **Provision credentials** in the [CipherStash Dashboard](https://dashboard.cipherstash.com/)
5. **Deploy to production** with confidence in your security posture
# What is CipherStash?
Source: https://cipherstash.com/docs/stack/reference/what-is-cipherstash
CipherStash is Data Level Access Control for Postgres. Encrypt fields at the application layer, query ciphertext without decryption, bind keys to identities, and audit every access event cryptographically.
A breach yields ciphertext, nothing useful.
The problem [#the-problem]
For thirty years, the database has been readable to anyone who reached it. Encrypting a column meant losing the query. Traditional security assumes a human is watching. AI agents ship code at machine speed. The credentials they run on are application credentials. Prompt injection is a one-step exfiltration attack.
The stack [#the-stack]
CipherStash solves this with four primitives:
/ENCRYPTION [#encryption]
Searchable field-level encryption. Range queries, exact match, and free-text fuzzy search over ciphertext with sub-millisecond overhead. Works with any managed Postgres provider. [Read more](https://cipherstash.com/docs/stack/cipherstash/encryption).
/KEY-MANAGEMENT [#key-management]
ZeroKMS. 100x faster than AWS KMS. Unique key per value, derived on demand, never stored. Identity and policy baked into every key. [Read more](https://cipherstash.com/docs/stack/cipherstash/kms).
/SECRETS (coming soon) [#secrets-coming-soon]
Secrets without the .env. Every secret encrypted at the field level. Cryptographically isolated environments. Identity-bound access. [Join the waitlist](https://cipherstash.com/stack/secrets).
/PROXY [#proxy]
Transparent searchable encryption for existing PostgreSQL databases. Zero application code changes. [Read more](https://cipherstash.com/docs/stack/cipherstash/proxy).
How it works [#how-it-works]
Zero-knowledge architecture. The platform never sees data keys.
1. Every sensitive value is encrypted with a unique key.
2. Keys are derived on demand via ZeroKMS and never stored.
3. Identity and policy are baked into the key itself.
4. Decryption is enforced at the moment of access, wherever the data ends up.
5. Every decryption event is recorded: who, what, when, from where.
Attackers, over-permissioned agents, and curious insiders all see the same thing: ciphertext with no key.
Threat model [#threat-model]
**Database breach.** Encrypted data remains ciphertext. Zero-knowledge architecture means compromised credentials yield nothing useful.
**Insider threats.** Identity-bound keys enforce per-value access control. Full audit trail for every decryption.
**Supply chain attacks.** Instant access revocation. No waiting on vendors.
**AI agent exfiltration.** Prompt injection reaches the database but decrypts nothing. The agent's credentials are not the user's keys.
Performance [#performance]
* **\< 1ms** query overhead
* **100x** faster than AWS KMS
* **100,000x** faster than fully homomorphic encryption
* **Quantum safe**
Compliance [#compliance]
HIPAA, SOC 2, GDPR. Continuous assurance, not point-in-time snapshots. Cryptographic audit trails provide proof, not just logs.
Integration paths [#integration-paths]
* **[Encryption SDK](https://cipherstash.com/docs/stack/cipherstash/encryption)** for TypeScript applications with fine-grained control.
* **[CipherStash Proxy](https://cipherstash.com/docs/stack/cipherstash/proxy)** for existing PostgreSQL apps with zero code changes.
# Programmatic API
Source: https://cipherstash.com/docs/stack/cipherstash/cli/api
Import `stash` directly for custom tooling or CI scripts.
EQLInstaller [#eqlinstaller]
```typescript filename="scripts/setup-db.ts"
import { EQLInstaller, loadStashConfig } from 'stash'
const config = await loadStashConfig()
const installer = new EQLInstaller({
databaseUrl: config.databaseUrl,
})
const permissions = await installer.checkPermissions()
if (!permissions.ok) {
console.error('Missing permissions:', permissions.missing)
process.exit(1)
}
if (await installer.isInstalled()) {
console.log('EQL is already installed')
} else {
await installer.install()
}
```
Methods [#methods]
| Method | Returns | Description |
| ----------------------- | -------------------------------- | --------------------------------------------------- |
| `checkPermissions()` | `Promise` | Check if the database role has required permissions |
| `isInstalled()` | `Promise` | Check if the `eql_v2` schema exists |
| `getInstalledVersion()` | `Promise` | Get the installed EQL version (or `null`) |
| `install(options?)` | `Promise` | Execute the EQL install SQL in a transaction |
Install options [#install-options]
```typescript filename="scripts/setup-db.ts"
await installer.install({
excludeOperatorFamily: true, // Skip CREATE OPERATOR FAMILY
supabase: true, // Supabase mode (implies excludeOperatorFamily + grants roles)
latest: true, // Fetch latest from GitHub instead of bundled
})
```
PermissionCheckResult [#permissioncheckresult]
```typescript filename="types.ts"
interface PermissionCheckResult {
ok: boolean
missing: string[] // Human-readable descriptions of missing permissions
}
```
loadBundledEqlSql [#loadbundledeqlsql]
Load the bundled EQL install SQL as a string for custom install workflows:
```typescript filename="scripts/custom-install.ts"
import { loadBundledEqlSql } from 'stash'
const sql = loadBundledEqlSql() // standard
const sql = loadBundledEqlSql({ supabase: true }) // supabase variant
const sql = loadBundledEqlSql({ excludeOperatorFamily: true }) // no operator family
```
downloadEqlSql [#downloadeqlsql]
Download the latest EQL install SQL from GitHub:
```typescript filename="scripts/custom-install.ts"
import { downloadEqlSql } from 'stash'
const sql = await downloadEqlSql() // standard
const sql = await downloadEqlSql(true) // no operator family variant
```
defineConfig [#defineconfig]
Type-safe identity function for `stash.config.ts`. Provides autocompletion and type checking without runtime overhead:
```typescript filename="stash.config.ts"
import { defineConfig } from 'stash'
export default defineConfig({
databaseUrl: process.env.DATABASE_URL!,
})
```
loadStashConfig [#loadstashconfig]
Finds and loads the nearest `stash.config.ts`, validates it with Zod, applies defaults, and returns the typed config:
```typescript filename="scripts/setup-db.ts"
import { loadStashConfig } from 'stash'
const config = await loadStashConfig()
// config.databaseUrl — guaranteed to be a non-empty string
// config.client — path to encryption client (default: './src/encryption/index.ts')
```
Exits with a helpful error if the config file is not found or fails validation.
# Execute an encryption plan
Source: https://cipherstash.com/docs/stack/cipherstash/cli/impl
Execute an encryption plan [#execute-an-encryption-plan]
`stash impl` is the third step in the setup lifecycle. It reads your plan, confirms the scope, and hands off to a coding agent to make the changes. Run `stash plan` first to produce `.cipherstash/plan.md`.
```bash
npx stash impl
```
Prerequisites [#prerequisites]
`stash impl` reads `.cipherstash/context.json`, which is written by `stash init`. If that file is missing, the command errors with a message pointing you to run `stash init` first.
Behaviour overview [#behaviour-overview]
`stash impl` branches based on three conditions: whether a plan file exists, whether you are in a TTY, and whether `--continue-without-plan` is set.
| Condition | Behaviour |
| ---------------------------------- | ---------------------------------------------------------------------------------------- |
| Plan exists, TTY | Render plan summary. Ask "Proceed with implementation against this plan?" (default-yes). |
| Plan exists, non-TTY | Log the plan path and proceed without confirmation. |
| No plan, `--continue-without-plan` | Ask "Implementation can take some time. Continue?" (default-no). Proceed if confirmed. |
| No plan, TTY | Show a picker: "Draft a plan first (recommended)" or "Continue without a plan". |
| No plan, non-TTY | Error with a clear message. Requires `stash plan` or `--continue-without-plan`. |
Plan-summary confirmation [#plan-summary-confirmation]
When `.cipherstash/plan.md` exists and a machine-readable summary block is present, `stash impl` renders a panel like:
```
Plan summary
3 columns across 2 tables
◇ users.email add new encrypted column
◇ users.phone migrate existing column
◇ orders.notes migrate existing column
Includes migrate-existing columns — implementation is staged across
4 deploys (schema-add → backfill → cutover → drop).
```
It then asks:
```
Proceed with implementation against this plan? (Y/n)
```
Answering no cancels cleanly. Answering yes dispatches to the agent.
If the plan file has no summary block (older plans or plans produced without the structured header), `stash impl` shows a soft prompt to open the file in your editor before proceeding, then continues to the agent picker.
No-plan picker [#no-plan-picker]
If no plan exists and you are in a TTY (without `--continue-without-plan`), `stash impl` shows:
```
No plan found. What would you like to do?
> Draft a plan first (recommended) [runs `stash plan` — usually 1–3 min]
Continue without a plan [skip the planning checkpoint]
```
Selecting "Draft a plan first" delegates to `stash plan`. When `stash plan` completes, you return to `stash impl` automatically.
Selecting "Continue without a plan" shows the security confirm (default-no) before proceeding.
Security confirm (no-plan path) [#security-confirm-no-plan-path]
When bypassing the plan checkpoint, the command asks:
```
Implementation can take some time. Continue? (y/N)
```
This prompt defaults to no. It requires an explicit `y` or `yes`. Pressing enter cancels.
Flags [#flags]
| Flag | Description |
| ------------------------- | ---------------------------------------------------------------------------- |
| `--continue-without-plan` | Skip the no-plan picker. Goes straight to the security confirm (default-no). |
There is no `--yes` or `--force` that bypasses the security confirm. The confirm on the no-plan path always requires an explicit affirmative. This is intentional: implementation can take tens of minutes and makes real changes to your codebase.
Agent options [#agent-options]
`stash impl` offers four handoff targets:
| Agent | Detected by | Notes |
| ----------------- | ------------------- | ----------------------------------------------- |
| Claude Code | `claude` on `$PATH` | Launched interactively if detected. |
| Codex | `codex` on `$PATH` | Launched interactively if detected. |
| CipherStash Agent | Always available | Runs `stash wizard`. |
| Write AGENTS.md | Always available | Works with Cursor, Windsurf, Cline, and others. |
The command defaults to Claude Code if detected, then Codex, then AGENTS.md (the broadest "works without anything else installed" option). The CipherStash Agent is never selected by default.
Non-TTY behaviour [#non-tty-behaviour]
In CI and piped contexts, `stash impl` requires either a plan on disk or `--continue-without-plan`:
```bash
# CI with a plan already committed
npx stash impl
# CI without a plan
npx stash impl --continue-without-plan
```
Without `--continue-without-plan` and no plan on disk, the command errors:
```
No plan at `.cipherstash/plan.md`. Run `stash plan` first, or pass --continue-without-plan to skip planning.
```
After implementation [#after-implementation]
When the agent handoff completes, `stash impl` prints:
```
Implementation handoff complete. Run `stash db status` to verify state.
```
Run `stash db status` to check EQL installation and `stash encrypt status` for per-column migration state.
Next steps [#next-steps]
# CipherStash CLI
Source: https://cipherstash.com/docs/stack/cipherstash/cli
`stash` is a dev-time CLI and library for managing CipherStash EQL (Encrypted Query Language) in PostgreSQL.
`@cipherstash/stack` is the runtime encryption SDK. It stays lean with no heavy dependencies like `pg`. `stash` is a devDependency that handles database tooling: installing EQL extensions, checking permissions, validating schemas, and managing the schema lifecycle.
Think of it like Prisma CLI or Drizzle Kit. It sets up the database while the main SDK handles runtime operations.
| Package | Role | Install as |
| -------------------- | ------------------------------------ | ------------- |
| `@cipherstash/stack` | Runtime encryption and decryption | dependency |
| `stash` | Database setup and schema management | devDependency |
Quick start [#quick-start]
Interactive (recommended) [#interactive-recommended]
The setup lifecycle has three explicit save-points. Each command can be run standalone; the chain prompts after `init` and `plan` are convenience for first-time users.
Run init [#run-init]
`stash init` authenticates you, resolves your database, scaffolds an encryption client, installs dependencies, installs EQL, and writes `.cipherstash/context.json`.
```bash
npx stash init
```
When init finishes, it asks (default-yes) whether to continue to `stash plan`.
Draft an encryption plan [#draft-an-encryption-plan]
`stash plan` hands off to a coding agent (Claude Code or Codex), which reads your project and writes `.cipherstash/plan.md`. The plan lists the tables and columns to encrypt. Review it before proceeding.
```bash
npx stash plan
```
When plan finishes, it asks (default-yes) whether to continue to `stash impl`.
Execute the plan [#execute-the-plan]
`stash impl` reads the plan, shows a summary panel, asks you to confirm, and dispatches to the agent to make the changes.
```bash
npx stash impl
```
Manual setup [#manual-setup]
If you prefer to configure things yourself rather than running `stash init`, you can scaffold the config file manually and run `stash db install` directly.
Install the CLI [#install-the-cli]
```bash
npm install -D stash
```
Create stash.config.ts [#create-stashconfigts]
Create `stash.config.ts` in your project root:
```typescript filename="stash.config.ts"
import { defineConfig } from 'stash'
export default defineConfig({
databaseUrl: process.env.DATABASE_URL!,
})
```
Add your database URL [#add-your-database-url]
```bash filename=".env"
DATABASE_URL=postgresql://user:password@localhost:5432/mydb
```
Install EQL [#install-eql]
```bash
npx stash db install
```
> **Good to know**: Using Drizzle? The CLI auto-detects a `drizzle.config.*` file or `drizzle-orm`/`drizzle-kit` in `package.json` and generates a migration automatically. You can also pass `--drizzle` explicitly. Run `npx drizzle-kit migrate` after to apply it.
Configuration [#configuration]
The `stash.config.ts` file is the single source of truth for the CLI. Use `defineConfig` for type safety.
```typescript filename="stash.config.ts"
import { defineConfig } from 'stash'
export default defineConfig({
databaseUrl: process.env.DATABASE_URL!,
client: './src/encryption/index.ts',
})
```
| Option | Required | Default | Description |
| ------------- | -------- | --------------------------- | ------------------------------------------------------------------- |
| `databaseUrl` | Yes | | PostgreSQL connection string |
| `client` | No | `./src/encryption/index.ts` | Path to your encryption client file. Used by `push` and `validate`. |
The CLI loads `.env.local`, `.env.development.local`, `.env.development`, then `.env` (first-win, Next.js precedence) before evaluating the config, so `process.env` references work without any extra setup. The config file is resolved by walking up from the current working directory, similar to how `tsconfig.json` resolution works.
Wizard [#wizard]
`stash wizard` (also available as `@cipherstash/wizard`) is the CipherStash-hosted AI setup tool. It reads your codebase, asks which columns to encrypt, and wires up `@cipherstash/stack` for you.
The primary setup path is `stash init` → `stash plan` → `stash impl`, which can hand off to Claude Code, Codex, AGENTS.md (Cursor, Windsurf, Cline), or the wizard. The wizard is one handoff target among these options.
Run it directly with:
```bash
npx stash wizard
```
Or via the package runner:
```bash
npx @cipherstash/wizard # npm / Node
pnpm dlx @cipherstash/wizard # pnpm
bunx @cipherstash/wizard # bun
yarn dlx @cipherstash/wizard # yarn
```
Prerequisites [#prerequisites]
Before running the wizard, your project should have:
* An authenticated CipherStash session (`npx stash auth login`)
* A `stash.config.ts` (run `npx stash init` or `npx stash db install` to scaffold one)
* A reachable database via `DATABASE_URL`
What the wizard does [#what-the-wizard-does]
1. Detects your framework (Drizzle, Supabase, Prisma, generic) and TypeScript usage.
2. Runs health checks against the CipherStash gateway and your database.
3. Prompts you to pick the tables and columns to encrypt.
4. Sends a prompt to the Claude Agent SDK, which edits your schema and call sites to use `@cipherstash/stack`'s encryption APIs. The agent runs against a CipherStash-hosted LLM gateway. No Anthropic API key is required.
5. Runs post-agent steps: package install, `db install`, `db push`, and framework-specific migrations.
6. Scans for remaining call sites that need `encryptModel`/`decryptModel` wiring and prints a summary. These locations are not edited automatically.
7. Offers to install integration-appropriate [agent skills](https://cipherstash.com/docs/stack/reference/agent-skills) into `./.claude/skills/`.
Wizard log [#wizard-log]
Each run writes a timestamped log to `.cipherstash/wizard-log.md` in your project root. The log records phases, decisions, and touched files.
Backfilling existing data [#backfilling-existing-data]
When the wizard adds `encryptedType` to columns that already have data, you must backfill the existing rows with `encryptModel` before dropping the old column. The wizard prints a reminder with the recommended pattern. You are responsible for writing and running this backfill.
Experimental commands [#experimental-commands]
env [#env]
The `env` command prints a `.env.production.local` block with your CipherStash credentials. Pass `--write` to write it to disk.
```bash
STASH_EXPERIMENTAL_ENV_CMD=1 npx stash env
STASH_EXPERIMENTAL_ENV_CMD=1 npx stash env --write
```
This command is experimental and gated behind the `STASH_EXPERIMENTAL_ENV_CMD=1` environment variable. It is not ready for production use.
Next steps [#next-steps]
# Interactive setup
Source: https://cipherstash.com/docs/stack/cipherstash/cli/init
`npx stash init` is the first step in the CipherStash setup lifecycle. It authenticates you, resolves your database, scaffolds an encryption client, installs dependencies, installs the EQL extension, and writes a context file. When it finishes, it prompts you to continue to `stash plan`.
```bash
npx stash init
```
What init does [#what-init-does]
Init runs six steps with minimal prompts:
1. **Authenticates with CipherStash**: If you are already authenticated, it logs `Using workspace (region)` and moves on. No prompt. If you are not authenticated, it opens your browser for device-based authentication. Your token is saved to `~/.cipherstash/auth.json`.
2. **Resolves the database**: Reads your `DATABASE_URL` and verifies a connection can be made. Detects your Postgres provider (Supabase from the URL host, or generic Postgres).
3. **Generates the encryption client file**: Auto-detects your integration (Drizzle from `drizzle.config.*` or `drizzle-orm`/`drizzle-kit` in `package.json`, Supabase from the `DATABASE_URL` host, or generic Postgres). Writes a placeholder client to `./src/encryption/index.ts` silently. If that file already exists, it prompts you to keep it or overwrite it.
4. **Installs dependencies**: Checks whether `@cipherstash/stack` and `stash` are already in `node_modules`. If both are present, skips silently. If either is missing, shows a single combined install prompt. Detects your package manager (npm, pnpm, yarn, bun) automatically.
5. **Installs EQL**: Runs the same logic as `stash db install`. Scaffolds `stash.config.ts` if missing, detects your provider, and installs the EQL extension into your database. You do not need to run `stash db install` separately after init.
6. **Gathers context**: Writes `.cipherstash/context.json` with the detected integration, package manager, schemas, environment keys, and available agents. This file is required by `stash plan` and `stash impl`.
Best case: 0 prompts (already authenticated, both packages installed, no existing client file, database reachable). Worst case: 2 prompts (region selection for first-time login, install confirmation for missing packages).
| Flag | Description |
| ------------ | --------------------------------------------------------------------------------------------------------------------------------- |
| `--supabase` | Changes the intro message and next-steps output to the Supabase path. Detection handles file scaffolding regardless of this flag. |
| `--drizzle` | Changes the intro message and next-steps output to the Drizzle path. Detection handles file scaffolding regardless of this flag. |
Generated files [#generated-files]
Init produces two files:
**`./src/encryption/index.ts`**: A placeholder encryption client. The template matches your detected integration. For a generic Postgres project it generates:
```typescript filename="src/encryption/index.ts"
import { Encryption } from "@cipherstash/stack"
import { encryptedTable, encryptedColumn } from "@cipherstash/stack/schema"
const users = encryptedTable("users", {
email: encryptedColumn("email").equality().freeTextSearch(),
name: encryptedColumn("name").equality().freeTextSearch(),
})
export default await Encryption({ schemas: [users] })
```
**`.cipherstash/context.json`**: Detected facts about your project. `stash plan` and `stash impl` read this file. It includes your integration type, package manager, detected schemas, environment keys, and available coding agents.
After init [#after-init]
When init completes, it shows a summary panel:
```
Setup complete
✓ Authenticated to CipherStash
✓ Database connection verified
✓ Encryption client scaffolded
✓ `@cipherstash/stack` installed
✓ `stash` CLI installed
✓ EQL extension installed
```
Then it asks (default-yes):
```
Continue to `stash plan` now to draft your encryption plan? (Y/n)
```
Answering yes launches `stash plan` immediately. Answering no (or running non-interactively) prints:
```
Next: run `stash plan` to draft your encryption plan.
```
db install flags [#db-install-flags]
If you need to run EQL installation with specific flags (for example, writing a Supabase migration file), use `stash db install` directly after init:
```bash
npx stash db install --supabase --migration
npx stash db install --drizzle
npx stash db install --drizzle --supabase
```
> **Good to know**: You can pass `--drizzle` and `--supabase` together. The CLI combines both behaviors: Supabase-compatible SQL output as a Drizzle migration.
See [Install and upgrade EQL](https://cipherstash.com/docs/stack/cipherstash/cli/install) for the full flag reference.
Next steps [#next-steps]
# Install and upgrade EQL
Source: https://cipherstash.com/docs/stack/cipherstash/cli/install
install [#install]
Install the CipherStash EQL extensions into your database. Uses bundled SQL by default for offline, deterministic installs.
```bash
npx stash db install [options]
```
`db install` scaffolds `stash.config.ts` if it is missing. The command:
1. **Scaffolds `stash.config.ts`** with the database URL and client path (if the file does not already exist).
2. **Scaffolds the encryption client file** at the path referenced in `stash.config.ts` if the file does not exist. Uses the same auto-detected integration template as `init` (Drizzle, Supabase, or generic Postgres). Silent, no prompt.
3. **Checks permissions** and auto-selects the right SQL variant based on your database role.
4. **Installs EQL extensions** in your database.
After a successful install, the CLI prints a summary of what was installed. If you reached this step via `stash init`, EQL was already installed as part of init. Manual invocation is useful when you need specific flags (for example, `--supabase --migration` to write a Supabase migration file) or when you skipped the database connection during init.
| Option | Description |
| --------------------------- | ---------------------------------------------------------------------------------------------------- |
| `--dry-run` | Show what would happen without making changes |
| `--force` | Reinstall even if EQL is already installed |
| `--supabase` | Use Supabase-compatible install (excludes operator families and grants Supabase roles) |
| `--migration` | Write EQL into a Supabase migration file instead of pushing directly. Requires `--supabase`. |
| `--direct` | Push EQL directly to the database, skipping the migration-file prompt. Requires `--supabase`. |
| `--migrations-dir ` | Override the Supabase migrations directory (default: `supabase/migrations/`). Requires `--supabase`. |
| `--exclude-operator-family` | Skip operator family creation (for non-superuser database roles) |
| `--drizzle` | Generate a Drizzle migration instead of direct install |
| `--latest` | Fetch the latest EQL from GitHub instead of using the bundled version |
| `--name ` | Migration name when using `--drizzle` (default: `install-eql`) |
| `--out ` | Drizzle output directory when using `--drizzle` (default: `drizzle`) |
Standard install:
```bash
npx stash db install
```
Dry run to preview changes:
```bash
npx stash db install --dry-run
```
Fetch the latest EQL from GitHub:
```bash
npx stash db install --latest
```
Auto-detection [#auto-detection]
`db install` auto-detects two things before prompting you:
* **Supabase**: If `DATABASE_URL` contains a `*.supabase.co`, `*.supabase.com`, or `*.pooler.supabase.com` host, the CLI uses the Supabase-compatible install automatically. You can still pass `--supabase` explicitly to override.
* **Drizzle**: If a `drizzle.config.*` file exists or `drizzle-orm`/`drizzle-kit` appears in `package.json`, the CLI generates a Drizzle migration automatically. You can still pass `--drizzle` explicitly.
Automatic OPE fallback [#automatic-ope-fallback]
On managed databases (Supabase, Neon, RDS), the connected role is often not a superuser. `db install` detects this and automatically uses the no-operator-family (OPE) install variant, logging a line to inform you. You do not need to pass `--exclude-operator-family` manually on these hosts.
Supabase install [#supabase-install]
```bash
npx stash db install --supabase
```
The `--supabase` flag uses the Supabase-specific SQL variant. It omits `CREATE OPERATOR FAMILY` and grants `USAGE`, table, routine, and sequence permissions on the `eql_v2` schema to `anon`, `authenticated`, and `service_role`.
When `--supabase` is passed and a `supabase/migrations/` directory is detected, the CLI prompts:
```
How should EQL be installed?
> Create a Supabase migration file (recommended)
Push directly to the database
```
The migration-file path writes EQL SQL into `supabase/migrations/00000000000000_cipherstash_eql.sql`. The all-zero timestamp prefix ensures it runs before any user migrations that reference `eql_v2_encrypted`. Use `--migration` to skip the prompt and always create the file, or `--direct` to skip the prompt and always push directly.
```bash
# Write EQL as a migration file
npx stash db install --supabase --migration
# Push EQL directly to the database
npx stash db install --supabase --direct
# Override the migrations directory
npx stash db install --supabase --migration --migrations-dir ./db/migrations
```
`--migration`, `--direct`, and `--migrations-dir` all require `--supabase` to be passed explicitly. Passing them without `--supabase` will error. `--latest` is not compatible with `--migration`.
EQL installed via direct push does not survive `supabase db reset`. The reset command drops the database and reruns only files in `supabase/migrations/`. If you use `supabase db reset`, install EQL as a migration file instead. See [Supabase db reset removes EQL](https://cipherstash.com/docs/stack/cipherstash/cli/troubleshooting#supabase-db-reset).
Without operator families, `ORDER BY` on encrypted columns is not supported, regardless of the client or ORM used. Sort application-side after decrypting results as a workaround. This limitation also applies when using `--exclude-operator-family` on any database.
Drizzle migrations [#drizzle-migrations]
If you use Drizzle ORM and want EQL installation as part of your migration history, use `--drizzle`:
```bash
npx stash db install --drizzle
npx drizzle-kit migrate
```
This process:
1. Runs `drizzle-kit generate --custom --name=` to create an empty migration.
2. Loads the bundled EQL install SQL (or downloads from GitHub with `--latest`).
3. Writes the EQL SQL into the generated migration file.
To customize the migration name and output directory:
```bash
npx stash db install --drizzle --name setup-eql --out ./migrations
```
`drizzle-kit` must be installed. The `--out` value must match your Drizzle config.
You can combine `--drizzle` and `--supabase`:
```bash
npx stash db install --drizzle --supabase
```
This generates a Supabase-compatible EQL migration file.
Encrypting existing columns [#encrypting-existing-columns]
When you add `encryptedType` to a Drizzle column that already has data, `drizzle-kit generate` emits an `ALTER TABLE ... ALTER COLUMN ... SET DATA TYPE eql_v2_encrypted` statement. Postgres cannot cast existing data to `eql_v2_encrypted` implicitly, so this migration would fail.
`db install --drizzle` automatically rewrites those statements into a safe `ADD COLUMN / DROP COLUMN / RENAME COLUMN` sequence. The rewrite adds a comment in the migration to remind you to backfill the new column with `encryptModel` before dropping the old one. You are responsible for writing and running that backfill in your application code before applying the DROP step.
Permission pre-checks [#permission-pre-checks]
Before installing, the CLI verifies you have the following permissions:
* `CREATE` on the database (for `CREATE SCHEMA` and `CREATE EXTENSION`)
* `CREATE` on the `public` schema (for `CREATE TYPE "public"."eql_v2_encrypted"`)
* `SUPERUSER` or extension owner (for `CREATE EXTENSION pgcrypto`, if not already installed)
If the role is not a superuser, the CLI falls back automatically to the OPE (no-operator-family) variant instead of exiting with an error.
***
upgrade [#upgrade]
Upgrade an existing EQL installation to the version bundled with the package, or to the latest version from GitHub.
```bash
npx stash db upgrade [options]
```
| Option | Description |
| --------------------------- | --------------------------------------------------------------------- |
| `--dry-run` | Show what would happen without making changes |
| `--supabase` | Use Supabase-compatible upgrade |
| `--exclude-operator-family` | Skip operator family creation |
| `--latest` | Fetch the latest EQL from GitHub instead of using the bundled version |
The EQL install SQL is idempotent and safe to re-run. The CLI checks the current version, re-runs the install SQL, and reports the new version. If EQL is not installed, the CLI suggests running `npx stash db install` instead.
Bundled EQL SQL [#bundled-eql-sql]
The EQL install SQL is bundled with the package for offline, deterministic installs. The bundled version is pinned to the package version. Use `--latest` to fetch the newest version from GitHub.
Three SQL variants are included:
| File | Used when |
| -------------------------------------------- | ---------------------------------------------------------- |
| `cipherstash-encrypt.sql` | Default install |
| `cipherstash-encrypt-supabase.sql` | `--supabase` flag |
| `cipherstash-encrypt-no-operator-family.sql` | `--exclude-operator-family` flag or automatic OPE fallback |
# Draft an encryption plan
Source: https://cipherstash.com/docs/stack/cipherstash/cli/plan
Draft an encryption plan [#draft-an-encryption-plan]
`stash plan` is the second step in the setup lifecycle. It hands off to a coding agent, which reads your project and produces a reviewable encryption plan at `.cipherstash/plan.md`. No code is changed. The plan is a checkpoint you review before running `stash impl`.
```bash
npx stash plan
```
Prerequisites [#prerequisites]
`stash plan` reads `.cipherstash/context.json`, which is written by `stash init`. If that file is missing, the command errors with a message pointing you to run `stash init` first.
What plan does [#what-plan-does]
1. Reads `.cipherstash/context.json` to understand your project (integration, schemas, environment, installed agents).
2. Checks for an existing `.cipherstash/plan.md`. If one is found, warns you that the agent will be asked to revise it. Delete the file first to start fresh.
3. Asks which agent should write the plan. All four handoff targets are available: Claude Code, Codex, AGENTS.md (for Cursor/Windsurf/Cline), and the CipherStash Agent (`@cipherstash/wizard`). Each target produces a plan-mode artifact: Claude Code / Codex / AGENTS.md read the mode-aware `setup-prompt.md`; the wizard receives `--mode plan` and the gateway returns its planning prompt.
4. Hands off to the selected agent with a planning prompt. The agent reads your codebase and produces `.cipherstash/plan.md`.
5. After the agent finishes, asks (default-yes) whether to continue to `stash impl` now.
The plan.md artifact [#the-planmd-artifact]
The agent writes `.cipherstash/plan.md` as a human-readable Markdown file. At the top, it embeds a machine-readable summary block:
```
```
`stash impl` parses this block to render a confirmation panel before launching implementation.
Column paths [#column-paths]
Each entry in `columns` has a `path` field with one of two values:
| Path | Meaning | Implementation |
| --------- | -------------------------------------- | ---------------------------------------------------------------------------------- |
| `new` | Column does not yet exist as encrypted | Additive. Single deploy: add the encrypted column and update write paths. |
| `migrate` | Column has existing plaintext data | Staged across four deploys: add encrypted twin, backfill, cutover, drop plaintext. |
If `stash impl` finds a plan without the summary block (for example, a plan written before this feature was added), it falls back to a soft prompt asking you to open the file in your editor before proceeding.
Agent options [#agent-options]
`stash plan` offers all four handoff targets:
| Agent | Detected by | Notes |
| ----------------- | ------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Claude Code | `claude` on `$PATH` | Launched interactively if detected. |
| Codex | `codex` on `$PATH` | Launched interactively if detected. |
| AGENTS.md | — | Writes `AGENTS.md` plus `.cipherstash/setup-prompt.md` for Cursor, Windsurf, Cline, and other editor-based agents. |
| CipherStash Agent | — | Runs the in-house wizard package (`stash wizard`) with `--mode plan`. The wizard skips its column-selection TUI and post-agent install/push/migrate steps; the gateway returns a planning prompt. |
The command defaults to Claude Code if detected, then Codex, otherwise AGENTS.md. The CipherStash Agent is never selected by default. Pick it explicitly if you want the in-house wizard. Each target produces a `.cipherstash/plan.md` with the same machine-readable summary block at the top, so the choice of target doesn't change what `stash impl` parses later.
Chain prompt [#chain-prompt]
After the agent completes the plan, `stash plan` shows:
```
Plan drafted at `.cipherstash/plan.md`. Continue to `stash impl` now? (Y/n)
```
Answering yes launches `stash impl` immediately. Answering no (or running non-interactively) prints the next step and exits:
```
Plan drafted at `.cipherstash/plan.md`. Review it, then run `stash impl` to implement.
```
Non-TTY environments (CI, pipes) skip the prompt and always print the hint.
Reviewing the plan [#reviewing-the-plan]
Before running `stash impl`, open `.cipherstash/plan.md` and verify:
* The tables and columns listed match your intent.
* The `path` values are correct. A `migrate` path triggers the full four-deploy lifecycle. Confirm this is what you want for any column with existing data.
* Any columns with `path: migrate` have a backfill strategy accounted for.
Next steps [#next-steps]
# Push and status
Source: https://cipherstash.com/docs/stack/cipherstash/cli/push
push [#push]
Push your encryption schema to the database.
```bash
npx stash db push [options]
```
| Option | Description |
| ----------- | ------------------------------------------------------------------------- |
| `--dry-run` | Load and validate the schema, then print it as JSON. No database changes. |
`push` is only required when using [CipherStash Proxy](https://cipherstash.com/docs/stack/cipherstash/proxy). If you're using the SDK directly (Drizzle, Supabase, or plain PostgreSQL), this step is not needed. The schema lives in your application code.
How push works [#how-push-works]
When pushing, the CLI:
1. Loads the encryption client from the path in `stash.config.ts`
2. Runs [schema validation](https://cipherstash.com/docs/stack/cipherstash/cli/validate) (warns but doesn't block)
3. Transforms SDK data types to EQL-compatible `cast_as` values
4. Connects to Postgres and marks existing `eql_v2_configuration` rows as `inactive`
5. Inserts the new config as an `active` row
SDK to EQL type mapping [#sdk-to-eql-type-mapping]
The SDK uses developer-friendly type names, but EQL expects PostgreSQL-aligned types. The `push` command maps these automatically:
| SDK type (`dataType()`) | EQL `cast_as` |
| ----------------------- | ------------- |
| `string` | `text` |
| `text` | `text` |
| `number` | `double` |
| `bigint` | `big_int` |
| `boolean` | `boolean` |
| `date` | `date` |
| `json` | `jsonb` |
status [#status]
Show the current state of EQL in your database.
```bash
npx stash db status
```
Reports:
* Whether EQL is installed and which version
* Database permission status
* Whether an active encrypt config exists in `eql_v2_configuration` (only relevant for CipherStash Proxy)
test-connection [#test-connection]
Verify that the database URL in your config is valid and the database is reachable.
```bash
npx stash db test-connection
```
Reports the database name, connected user/role, and PostgreSQL server version. Useful for debugging connection issues before running `install` or `push`.
# Project status
Source: https://cipherstash.com/docs/stack/cipherstash/cli/status
Project status [#project-status]
`stash status` shows where your project stands in the CipherStash setup lifecycle. It reads disk state only: no network, no database connection, no authentication. It runs in milliseconds.
```bash
npx stash status
```
What it checks [#what-it-checks]
`stash status` inspects three files:
| File | What it signals |
| ------------------------------ | ----------------------------------------------- |
| `.cipherstash/context.json` | `stash init` has run successfully |
| `.cipherstash/plan.md` | `stash plan` has produced an encryption plan |
| `.cipherstash/setup-prompt.md` | `stash impl` has engaged an agent at least once |
Output [#output]
`stash status` renders a lifecycle panel followed by a deeper-inspection block:
```
CipherStash project status
Lifecycle
✓ Initialized supabase · npm · 3 tables
◯ Plan written run `stash plan` to draft
◯ Implementation waiting on plan
Deeper inspection
Database state: `stash db status`
Per-column state: `stash encrypt status`
Next: run `stash plan` to draft your encryption plan.
```
Stage markers [#stage-markers]
| Marker | Meaning |
| ------ | ----------------- |
| `✓` | Stage is complete |
| `◯` | Stage is pending |
Stages [#stages]
**Initialized**: `stash init` has run and `.cipherstash/context.json` exists. The detail line shows the detected integration, package manager, and number of tables in the schema.
**Plan written**: `.cipherstash/plan.md` exists. The detail line shows the plan file path. If the project is initialized but no plan exists, it shows the next command to run.
**Implementation**: An agent has been engaged at least once (`.cipherstash/setup-prompt.md` exists). This stage is always shown as pending because disk state cannot tell you whether the agent finished. Check `stash encrypt status` for per-column state. If no agent has been engaged, the detail line shows the next command to run.
Deeper inspection [#deeper-inspection]
`stash status` points to two commands for state that requires a database connection:
| Command | What it shows |
| ---------------------- | ------------------------------------------------------------------- |
| `stash db status` | EQL installation state, database permissions, active encrypt config |
| `stash encrypt status` | Per-column migration state: phase, progress, and drift |
When to use stash status [#when-to-use-stash-status]
Run `stash status` any time you want a quick answer to "where am I?" without triggering auth or a database round-trip. It is safe to run repeatedly, in any environment, including CI.
Common use cases:
* After onboarding to a new device, to check what has already been set up
* Before running `stash plan` or `stash impl`, to confirm prerequisites are met
* In a CI pre-flight check, to verify context.json is committed
Next steps [#next-steps]
# Troubleshooting
Source: https://cipherstash.com/docs/stack/cipherstash/cli/troubleshooting
Common errors [#common-errors]
| Error | Cause | Fix |
| ------------------------------------------------ | -------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------- |
| `Could not find stash.config.ts` | No config file in cwd or parent dirs | Run `npx stash init` (which runs `db install` automatically), or run `npx stash db install` directly, or create `stash.config.ts` manually |
| `databaseUrl is required` | Config missing `databaseUrl` | Add `databaseUrl` to config and check `.env` is loaded |
| `must be superuser to create an operator family` | Standard SQL requires superuser | The CLI falls back to OPE mode automatically on managed databases. Pass `--exclude-operator-family` if you see this on self-hosted Postgres. |
| `Insufficient database permissions` | Role lacks `CREATE` privileges | Connect as superuser or grant permissions |
| `EQL is already installed` | `eql_v2` schema exists | Use `--force` to reinstall |
| `Encrypt client file not found` | `push`/`validate` can't find the file at `config.client` | Set `client` in `stash.config.ts` to the correct path |
| `drizzle-kit generate failed` | drizzle-kit not installed or wrong output dir | Install `drizzle-kit` and set `--out` to match your Drizzle config |
| EQL missing after `supabase db reset` | EQL was installed via direct push, not as a migration | Re-run `db install --supabase --migration` to add EQL to `supabase/migrations/`. See [below](#supabase-db-reset). |
Permission issues [#permission-issues]
The `install` command checks database permissions before running. On managed databases (Supabase, Neon, RDS), the CLI detects a non-superuser role and automatically uses the no-operator-family (OPE) install variant.
If you still see permission errors:
1. Run `npx stash db test-connection` to verify your database URL is correct.
2. Run `npx stash db status` to check the current EQL state.
3. Ensure the connected role has `CREATE` privileges on the database and `public` schema.
4. For the `pgcrypto` extension, the role needs `SUPERUSER` or extension owner privileges.
Supabase-specific issues [#supabase-specific-issues]
When using `--supabase` or the automatic Supabase detection:
* `ORDER BY` on encrypted columns is not supported. Sort application-side after decrypting.
* The `anon`, `authenticated`, and `service_role` roles are Supabase-specific. Don't use `--supabase` on standard PostgreSQL.
Drizzle migration issues [#drizzle-migration-issues]
If `--drizzle` fails:
1. Ensure `drizzle-kit` is installed: `npm install -D drizzle-kit`
2. Ensure the `--out` directory matches your `drizzle.config.ts` output directory.
3. Check that your Drizzle config is valid by running `npx drizzle-kit generate` manually.
Encrypting existing columns [#encrypting-existing-columns]
When adding `encryptedType` to a column that already has data, the CLI rewrites `ALTER COLUMN ... SET DATA TYPE eql_v2_encrypted` statements into a safe `ADD COLUMN / DROP COLUMN / RENAME COLUMN` sequence. You must backfill the new column with `encryptModel` in your application code before applying the DROP step on non-empty tables.
Supabase db reset [#supabase-db-reset]
Why it happens [#why-it-happens]
`supabase db reset` drops the entire database and reruns only the SQL files in `supabase/migrations/`. If you installed EQL via direct push (the default before the `--migration` flag was added), EQL is not in your migrations directory and gets wiped by the reset.
Fix for new installs [#fix-for-new-installs]
Re-run `db install` and choose the migration-file path:
```bash
npx stash db install --supabase --migration
```
The CLI writes EQL SQL to `supabase/migrations/00000000000000_cipherstash_eql.sql`. The all-zero timestamp prefix ensures it runs before any user migrations that reference `eql_v2_encrypted`. After the file is created, `supabase db reset` will reinstall EQL automatically on every reset.
Upgrade path for existing direct-push installs [#upgrade-path-for-existing-direct-push-installs]
If you already ran a direct-push install and your live database is working, your existing install is not broken. To get a migration file going forward without disrupting the live database, run:
```bash
npx stash db install --supabase --migration --force
```
The EQL SQL is idempotent. The `--force` flag regenerates the install even though EQL is already present. Your live install is unaffected. After this, `supabase db reset` reinstalls EQL from the migration file.
# Schema validation
Source: https://cipherstash.com/docs/stack/cipherstash/cli/validate
The `validate` command checks your encryption schema for common misconfigurations.
```bash
npx stash db validate [options]
```
| Option | Description |
| --------------------------- | ------------------------------------------------------------------------------ |
| `--supabase` | Check for Supabase-specific issues (e.g. `ORDER BY` without operator families) |
| `--exclude-operator-family` | Check for issues when operator families are excluded |
Validation rules [#validation-rules]
| Rule | Severity | Description |
| ----------------------------------------- | -------- | ----------------------------------------------- |
| `freeTextSearch` on non-string column | Warning | Free-text search only works with string data |
| `orderAndRange` without operator families | Warning | `ORDER BY` won't work without operator families |
| No indexes on encrypted column | Info | Column is encrypted but not searchable |
| `searchableJson` without `json` data type | Error | `searchableJson` requires `dataType("json")` |
Examples [#examples]
Basic validation:
```bash
npx stash db validate
```
Validate with Supabase context (checks for operator family issues):
```bash
npx stash db validate --supabase
```
How validation works [#how-validation-works]
The command loads your encryption schema from the file specified by `client` in `stash.config.ts` and runs it through the validation rules.
* **Errors** cause the command to exit with code 1.
* **Warnings** and **info** messages are printed but don't cause a non-zero exit.
* Validation also runs automatically before [`push`](https://cipherstash.com/docs/stack/cipherstash/cli/push). Issues are logged as warnings but don't block the push.
# Bulk operations
Source: https://cipherstash.com/docs/stack/cipherstash/encryption/bulk-operations
Bulk operations [#bulk-operations]
`bulkEncrypt` and `bulkDecrypt` encrypt or decrypt an array of raw values in a single call to ZeroKMS. Every value still gets its own unique key. The batch just pays the network round-trip once, regardless of how many items you pass.
This page covers the raw-value variants. If you want to encrypt whole objects (records with multiple fields), see [Model operations](https://cipherstash.com/docs/stack/cipherstash/encryption/models) instead.
For full method signatures, see the [`EncryptionClient` API reference](https://cipherstash.com/docs/reference/stack/api-reference).
Why bulk matters [#why-bulk-matters]
Calling `encrypt` in a loop makes one ZeroKMS request per value. For 100 emails that is 100 round-trips. `bulkEncrypt` collapses those into one.
The throughput gain is significant for any batch larger than a handful of records. Use bulk operations whenever you are processing more than one value at a time.
bulkEncrypt [#bulkencrypt]
Pass an array of `{ id, plaintext }` objects. The `id` is your correlation key: it flows through to the output so you can match encrypted results back to your source records.
```typescript filename="bulk-encrypt.ts"
import { Encryption } from "@cipherstash/stack"
import { encryptedTable, encryptedColumn } from "@cipherstash/stack/schema"
const users = encryptedTable("users", {
email: encryptedColumn("email").equality().freeTextSearch(),
})
const client = await Encryption({ schemas: [users] })
const plaintexts = [
{ id: "u1", plaintext: "alice@example.com" },
{ id: "u2", plaintext: "bob@example.com" },
{ id: "u3", plaintext: "charlie@example.com" },
]
const result = await client.bulkEncrypt(plaintexts, {
column: users.email,
table: users,
})
if (result.failure) {
throw new Error(`Bulk encryption failed: ${result.failure.message}`)
}
// result.data is an array of { id: string, data: Encrypted }
// The id matches the id you passed in
const encrypted = result.data
```
Input shape [#input-shape]
Each element in the input array takes this shape:
| Field | Type | Required | Description |
| ----------- | ------------------------------------- | -------- | -------------------------------------- |
| `id` | `string` | No | Correlation key returned in the output |
| `plaintext` | `string \| number \| boolean \| null` | Yes | The value to encrypt |
You can omit `id` when you do not need to correlate results (for example, when processing an ordered list where position is the correlation).
Mapping results back to records [#mapping-results-back-to-records]
When `id` is present, use it to build a lookup map:
```typescript filename="bulk-encrypt-map.ts"
const encryptedByUserId = Object.fromEntries(
result.data.map((item) => [item.id, item.data]),
)
// encryptedByUserId["u1"] → Encrypted payload for alice
```
bulkDecrypt [#bulkdecrypt]
Pass the array produced by `bulkEncrypt`. Results come back in the same order, with per-item success or failure.
```typescript filename="bulk-decrypt.ts"
const decrypted = await client.bulkDecrypt(encrypted)
if (decrypted.failure) {
throw new Error(`Bulk decryption failed: ${decrypted.failure.message}`)
}
for (const item of decrypted.data) {
if ("data" in item) {
console.log(`${item.id}: ${item.data}`)
} else {
console.error(`${item.id} failed: ${item.error}`)
}
}
```
Per-item failure handling [#per-item-failure-handling]
`bulkDecrypt` returns a top-level `Result` wrapping an array where each element is either a success or a per-item error. The top-level `failure` fires for infrastructure errors (network, auth). Individual decryption failures surface as `{ id, error }` items in the array.
```typescript filename="bulk-decrypt-errors.ts"
const successful: string[] = []
const failed: string[] = []
for (const item of decrypted.data) {
if ("data" in item) {
successful.push(item.data as string)
} else {
failed.push(item.id)
}
}
```
Ordering guarantee [#ordering-guarantee]
`bulkDecrypt` returns items in the same order as the input array. If you do not use `id`, you can rely on index position for correlation.
Complete example: bulk insert with UNNEST [#complete-example-bulk-insert-with-unnest]
This pattern encrypts an array of values and inserts them into PostgreSQL with a single multi-row statement.
```typescript filename="bulk-insert.ts"
import { Pool } from "pg"
const pool = new Pool({ connectionString: process.env.DATABASE_URL })
async function insertUsers(emails: string[]) {
const plaintexts = emails.map((email, i) => ({
id: String(i),
plaintext: email,
}))
const encryptResult = await client.bulkEncrypt(plaintexts, {
column: users.email,
table: users,
})
if (encryptResult.failure) {
throw new Error(`Encryption failed: ${encryptResult.failure.message}`)
}
const encryptedValues = encryptResult.data.map((item) => item.data)
const result = await pool.query(
`INSERT INTO users (email)
SELECT * FROM UNNEST($1::jsonb[])
RETURNING id`,
[encryptedValues],
)
return result.rows.map((row) => row.id)
}
```
Always use the `::jsonb` cast when passing encrypted values to PostgreSQL. This ensures PostgreSQL handles the CipherCell JSON payload correctly.
For the table setup and single-record insert pattern, see [Storing encrypted data](https://cipherstash.com/docs/stack/cipherstash/encryption/storing-data).
Identity-aware bulk encryption [#identity-aware-bulk-encryption]
Lock an entire batch to a user's identity by chaining `.withLockContext()`. The client must be authenticated as that user with `OidcFederationStrategy`.
```typescript filename="bulk-encrypt-identity.ts"
const claim = { identityClaim: ["sub"] }
const encrypted = await client
.bulkEncrypt(plaintexts, { column: users.email, table: users })
.withLockContext(claim)
const decrypted = await client
.bulkDecrypt(encrypted.data)
.withLockContext(claim)
```
See [Identity-aware encryption](https://cipherstash.com/docs/stack/cipherstash/encryption/identity) for the full lock context flow.
When to use bulk vs model operations [#when-to-use-bulk-vs-model-operations]
| Scenario | Recommended method |
| ------------------------------------------------------- | ----------------------------------------- |
| Encrypting one field from a list of records | `bulkEncrypt` / `bulkDecrypt` |
| Encrypting whole records with multiple encrypted fields | `bulkEncryptModels` / `bulkDecryptModels` |
| Migrating a single column in an existing table | `bulkEncrypt` |
| Inserting new records from a form or API payload | `bulkEncryptModels` |
The rule of thumb: use raw bulk methods when you are working with a single field across many records. Use model methods when you have whole objects to round-trip.
See [Model operations](https://cipherstash.com/docs/stack/cipherstash/encryption/models) for `bulkEncryptModels` and `bulkDecryptModels`.
ORM integrations [#orm-integrations]
Drizzle and DynamoDB have adapter-level bulk support that wraps these methods:
* [Drizzle bulk insert](https://cipherstash.com/docs/stack/cipherstash/encryption/drizzle): `bulkEncryptModels` with Drizzle `.values()`
* [DynamoDB bulk operations](https://cipherstash.com/docs/stack/cipherstash/encryption/dynamodb): `BatchWriteItem` and `BatchGetItem` wrappers
Next steps [#next-steps]
* [Model operations](https://cipherstash.com/docs/stack/cipherstash/encryption/models): encrypt whole records in one call
* [Storing encrypted data](https://cipherstash.com/docs/stack/cipherstash/encryption/storing-data): raw SQL insert and retrieve patterns
* [Identity-aware encryption](https://cipherstash.com/docs/stack/cipherstash/encryption/identity): scope encryption to a user's JWT
# Configuration
Source: https://cipherstash.com/docs/stack/cipherstash/encryption/configuration
Local development (recommended) [#local-development-recommended]
If you have run `npx stash init`, no configuration is needed for local development.
The SDK automatically uses device-based authentication to access your workspace and default keyset.
See [Getting started](https://cipherstash.com/docs/stack/quickstart) for setup instructions.
Production and CI/CD configuration [#production-and-cicd-configuration]
In production environments where device-based auth is not available, the SDK supports two configuration methods: environment variables and programmatic config. Environment variables take precedence over programmatic config.
Environment variables [#environment-variables]
Set these in your hosting platform or CI/CD system:
| Variable | Description | Required |
| ---------------------- | --------------------------------------------------- | --------------------------------------------- |
| `CS_WORKSPACE_CRN` | The workspace identifier (CRN format) | Yes |
| `CS_CLIENT_ID` | The client key identifier | Yes |
| `CS_CLIENT_KEY` | Client key material used with ZeroKMS | Yes |
| `CS_CLIENT_ACCESS_KEY` | API key for authenticating with the CipherStash API | Yes |
| `CS_CONFIG_PATH` | Temporary path for client configuration | No (default: `/home/{username}/.cipherstash`) |
| `STASH_STACK_LOG` | Log level (`debug`, `info`, `error`) | No (default: `error`) |
See [Going to production](https://cipherstash.com/docs/stack/deploy/going-to-production) for a step-by-step guide to generating production credentials.
Avoid setting `CS_*` environment variables for local development.
Device-based auth provides per-developer identity, no shared secrets, and automatic session management.
See [Getting started](https://cipherstash.com/docs/stack/quickstart) to set up device auth.
Programmatic config [#programmatic-config]
Pass config directly when initializing the client. Use this approach in production when loading credentials from a secret manager:
```typescript filename="encryption/index.ts"
import { Encryption, type EncryptionClientConfig } from "@cipherstash/stack"
import { users } from "./schema"
const config: EncryptionClientConfig = {
schemas: [users],
config: {
workspaceCrn: "your-workspace-crn",
accessKey: "your-access-key",
clientId: "your-client-id",
clientKey: "your-client-key",
},
}
const client = await Encryption(config)
```
Subpath exports [#subpath-exports]
The SDK provides multiple subpath exports for importing only what you need:
| Import path | Provides |
| ------------------------------- | ---------------------------------------------------------------------------------------------------------------------- |
| `@cipherstash/stack` | `Encryption` function, `Secrets` class, `encryptedTable`, `encryptedColumn`, `encryptedField` (convenience re-exports) |
| `@cipherstash/stack/schema` | `encryptedTable`, `encryptedColumn`, `encryptedField`, schema types |
| `@cipherstash/stack/identity` | `LockContext` class and identity types |
| `@cipherstash/stack/secrets` | `Secrets` class and secrets types |
| `@cipherstash/stack/drizzle` | `encryptedType`, `extractEncryptionSchema`, `createEncryptionOperators` for Drizzle ORM |
| `@cipherstash/stack/supabase` | `encryptedSupabase` wrapper for Supabase |
| `@cipherstash/stack/dynamodb` | `encryptedDynamoDB` helper for DynamoDB |
| `@cipherstash/stack/encryption` | `EncryptionClient` class, `Encryption` function |
| `@cipherstash/stack/errors` | `EncryptionErrorTypes`, `StackError`, error subtypes, `getErrorMessage` |
| `@cipherstash/stack/client` | Client-safe exports: schema builders, schema types, `EncryptionClient` type (no native FFI) |
| `@cipherstash/stack/types` | All TypeScript types |
Keysets [#keysets]
[Key Sets](https://cipherstash.com/docs/stack/cipherstash/kms/keysets) are a ZeroKMS primitive for cryptographic isolation.
Each Key Set maintains its own set of data encryption keys. Data encrypted under one Key Set cannot be decrypted with another.
This is the same primitive that will power environment isolation in Secrets (coming soon).
You can specify a Key Set by ID or by name:
By ID [#by-id]
```typescript filename="encryption/index.ts"
const client = await Encryption({
schemas: [users],
config: {
workspaceCrn: "your-workspace-crn",
accessKey: "your-access-key",
clientId: "your-client-id",
clientKey: "your-client-key",
keyset: { id: "123e4567-e89b-12d3-a456-426614174000" },
},
})
```
By name [#by-name]
```typescript filename="encryption/index.ts"
const client = await Encryption({
schemas: [users],
config: {
workspaceCrn: "your-workspace-crn",
accessKey: "your-access-key",
clientId: "your-client-id",
clientKey: "your-client-key",
keyset: { name: "Company A" },
},
})
```
For full details on creating and managing Key Sets, see the [Key Sets reference](https://cipherstash.com/docs/stack/cipherstash/kms/keysets).
Logging [#logging]
Control log verbosity with the `STASH_STACK_LOG` environment variable:
```bash
STASH_STACK_LOG=error # debug | info | error (default: error)
```
| Value | What is logged |
| ------- | ----------------------- |
| `error` | Errors only (default) |
| `info` | Info and errors |
| `debug` | Debug, info, and errors |
The SDK never logs plaintext data.
Deploying to production [#deploying-to-production]
For a complete guide to transitioning from local device-based auth to production environment variables, see [Going to production](https://cipherstash.com/docs/stack/deploy/going-to-production).
File system write permissions [#file-system-write-permissions]
In most hosting environments, set `CS_CONFIG_PATH` to a writable directory:
```bash
CS_CONFIG_PATH=/tmp/.cipherstash
```
This has been tested on [Vercel](https://vercel.com/) and [AWS Lambda](https://aws.amazon.com/lambda/).
Bundler configuration [#bundler-configuration]
`@cipherstash/stack` includes a native FFI module that must be excluded from bundling:
* **Next.js**: See [Bundling: Next.js](https://cipherstash.com/docs/stack/deploy/bundling#nextjs)
* **SST / serverless**: See [SST setup](https://cipherstash.com/docs/stack/deploy/sst)
* **Webpack / esbuild**: Add `@cipherstash/stack` to your externals configuration
Platform requirements [#platform-requirements]
* **Node.js** >= 18
* See [Troubleshooting](https://cipherstash.com/docs/stack/deploy/troubleshooting) for npm lockfile issues on Linux
# Drizzle ORM
Source: https://cipherstash.com/docs/stack/cipherstash/encryption/drizzle
CipherStash provides first-class Drizzle ORM integration through `@cipherstash/stack/drizzle`. Define encrypted columns directly in your Drizzle table schema, and use auto-encrypting operators that make encrypted queries look like standard Drizzle code.
Installation [#installation]
```bash cta cta-type="install" example-id="install-drizzle"
npm install @cipherstash/stack drizzle-orm
```
If you're using Bun, version 1.3 or later is required.
The Drizzle integration is included in `@cipherstash/stack` and imports from `@cipherstash/stack/drizzle`.
Database setup [#database-setup]
Install EQL via Drizzle migrations [#install-eql-via-drizzle-migrations]
Use the [CipherStash CLI](https://cipherstash.com/docs/stack/cipherstash/cli) to generate a Drizzle migration that installs the [EQL](https://cipherstash.com/docs/stack/reference/eql-guide) extension:
```bash
npx stash db install --drizzle
npx drizzle-kit migrate
```
| Flag | Default | Description |
| ---------------- | ------------- | ------------------------------------------------- |
| `--name ` | `install-eql` | Migration name |
| `--out ` | `drizzle` | Output directory (must match your Drizzle config) |
See [CipherStash CLI — Drizzle migrations](https://cipherstash.com/docs/stack/cipherstash/cli/install#drizzle-migrations) for details.
Column storage [#column-storage]
Encrypted columns use the `eql_v2_encrypted` PostgreSQL type (installed by EQL). If not using EQL directly, use JSONB:
```sql filename="create-table.sql"
CREATE TABLE users (
id SERIAL PRIMARY KEY,
email eql_v2_encrypted, -- with EQL extension
name jsonb NOT NULL, -- or use jsonb
age INTEGER -- non-encrypted columns are normal types
);
```
Schema definition [#schema-definition]
Use `encryptedType()` to define encrypted columns directly in your Drizzle table schema. TypeScript property names in camelCase map to their corresponding snake\_case database column names (e.g., `createdAt` in TypeScript maps to `created_at` in the database).
```typescript filename="schema.ts"
import { pgTable, integer, timestamp, varchar } from "drizzle-orm/pg-core"
import { encryptedType } from "@cipherstash/stack/drizzle"
const usersTable = pgTable("users", {
id: integer("id").primaryKey().generatedAlwaysAsIdentity(),
// Encrypted string with search capabilities
email: encryptedType("email", {
equality: true, // enables: eq, ne, inArray
freeTextSearch: true, // enables: like, ilike
orderAndRange: true, // enables: gt, gte, lt, lte, between, asc, desc
}),
// Encrypted number
age: encryptedType("age", {
dataType: "number",
equality: true,
orderAndRange: true,
}),
// Encrypted JSON object with searchable JSONB queries
profile: encryptedType<{ name: string; bio: string }>("profile", {
dataType: "json",
searchableJson: true,
}),
// Non-encrypted columns
role: varchar("role", { length: 50 }),
createdAt: timestamp("created_at").defaultNow(),
})
```
encryptedType(name, config?) [#encryptedtypetdataname-config]
| Config Option | Type | Description |
| ---------------- | ----------------------------------------------------------------------------- | ------------------------------------------------------- |
| `dataType` | `"string"` \| `"number"` \| `"json"` \| `"boolean"` \| `"bigint"` \| `"date"` | Plaintext data type (default: `"string"`) |
| `equality` | `boolean` \| `TokenFilter[]` | Enable equality index |
| `freeTextSearch` | `boolean` \| `MatchIndexOpts` | Enable free-text search index |
| `orderAndRange` | `boolean` | Enable ORE index for sorting and range queries |
| `searchableJson` | `boolean` | Enable JSONB path queries (requires `dataType: "json"`) |
The generic type parameter `` sets the TypeScript type for the decrypted value.
Initialization [#initialization]
1. Extract schema from Drizzle table [#1-extract-schema-from-drizzle-table]
```typescript filename="init.ts"
import {
extractEncryptionSchema,
createEncryptionOperators,
} from "@cipherstash/stack/drizzle"
import { Encryption } from "@cipherstash/stack"
// Convert Drizzle table definition to CipherStash schema
const usersSchema = extractEncryptionSchema(usersTable)
```
2. Initialize encryption client [#2-initialize-encryption-client]
```typescript filename="init.ts"
const encryptionClient = await Encryption({
schemas: [usersSchema],
})
```
3. Create query operators [#3-create-query-operators]
```typescript filename="init.ts"
const encryptionOps = createEncryptionOperators(encryptionClient)
```
4. Create Drizzle instance [#4-create-drizzle-instance]
```typescript filename="init.ts"
import { drizzle } from "drizzle-orm/postgres-js"
import postgres from "postgres"
const db = drizzle({ client: postgres(process.env.DATABASE_URL!) })
```
For fine-grained control over encryption timing (e.g., caching encrypted values, debugging, or building custom abstractions), you can use the manual `encryptionClient.encrypt()` pattern instead of the auto-encrypting operators. See [Encrypt and decrypt](https://cipherstash.com/docs/stack/cipherstash/encryption/encrypt-decrypt) for the low-level API.
Insert encrypted data [#insert-encrypted-data]
Encrypt models before inserting:
```typescript filename="insert.ts"
// Single insert
const encrypted = await encryptionClient.encryptModel(
{ email: "alice@example.com", age: 30, role: "admin" },
usersSchema,
)
if (!encrypted.failure) {
await db.insert(usersTable).values(encrypted.data)
}
// Bulk insert
const encrypted = await encryptionClient.bulkEncryptModels(
[
{ email: "alice@example.com", age: 30, role: "admin" },
{ email: "bob@example.com", age: 25, role: "user" },
],
usersSchema,
)
if (!encrypted.failure) {
await db.insert(usersTable).values(encrypted.data)
}
```
Query encrypted data [#query-encrypted-data]
Equality [#equality]
```typescript filename="query-equality.ts"
// Exact match — await the operator
const results = await db
.select()
.from(usersTable)
.where(await encryptionOps.eq(usersTable.email, "alice@example.com"))
```
Text search [#text-search]
```typescript filename="query-text-search.ts"
// Case-insensitive search
const results = await db
.select()
.from(usersTable)
.where(await encryptionOps.ilike(usersTable.email, "%alice%"))
// Case-sensitive search
const results = await db
.select()
.from(usersTable)
.where(await encryptionOps.like(usersTable.email, "%@example.com"))
```
Range queries [#range-queries]
```typescript filename="query-range.ts"
// Greater than or equal
const results = await db
.select()
.from(usersTable)
.where(await encryptionOps.gte(usersTable.age, 18))
// Between (inclusive)
const results = await db
.select()
.from(usersTable)
.where(await encryptionOps.between(usersTable.age, 18, 65))
```
Array operators [#array-operators]
```typescript filename="query-array.ts"
const results = await db
.select()
.from(usersTable)
.where(await encryptionOps.inArray(usersTable.email, [
"alice@example.com",
"bob@example.com",
]))
```
Sorting [#sorting]
Sort operators are synchronous — no `await` needed:
```typescript filename="query-sort.ts"
// Sort by encrypted column ascending
const results = await db
.select()
.from(usersTable)
.orderBy(encryptionOps.asc(usersTable.age))
// Sort descending
const results = await db
.select()
.from(usersTable)
.orderBy(encryptionOps.desc(usersTable.age))
```
Select specific columns [#select-specific-columns]
```typescript filename="query-select.ts"
const results = await db.select({
id: usersTable.id,
email: usersTable.email,
createdAt: usersTable.createdAt,
}).from(usersTable)
```
Pagination [#pagination]
```typescript filename="query-pagination.ts"
// First page
const results = await db.select().from(usersTable).limit(10)
// Second page
const results = await db.select().from(usersTable).limit(10).offset(10)
```
Aggregation [#aggregation]
```typescript filename="query-aggregation.ts"
import { sql } from "drizzle-orm"
// Total count
const result = await db.select({ count: sql`count(*)` }).from(usersTable)
// Count with condition
const result = await db
.select({ count: sql`count(*)` })
.from(usersTable)
.where(await encryptionOps.gte(usersTable.age, 18))
```
Date and timestamp queries [#date-and-timestamp-queries]
```typescript filename="date-query.ts"
const now = new Date()
const twoWeeksAgo = new Date(now.getTime() - 14 * 24 * 60 * 60 * 1000)
const results = await db
.select()
.from(usersTable)
.where(
await encryptionOps.and(
encryptionOps.gte(usersTable.createdAt, twoWeeksAgo),
encryptionOps.lte(usersTable.createdAt, now),
),
)
```
JSONB queries [#jsonb-queries]
Query encrypted JSON columns using JSONB operators. These require `searchableJson: true` and `dataType: "json"` in the column's `encryptedType` config.
Check path existence [#check-path-existence]
```typescript filename="query-jsonb.ts"
// Check if a JSONB path exists in an encrypted column
const results = await db
.select()
.from(usersTable)
.where(await encryptionOps.jsonbPathExists(usersTable.profile, "$.bio"))
```
Extract value at path [#extract-value-at-path]
```typescript filename="query-jsonb-extract.ts"
// Extract the first matching value at a JSONB path
const result = await encryptionOps.jsonbPathQueryFirst(usersTable.profile, "$.name")
```
Get value with -> operator [#get-value-with---operator]
```typescript filename="query-jsonb-get.ts"
// Get a value using the JSONB -> operator
const result = await encryptionOps.jsonbGet(usersTable.profile, "$.name")
```
`jsonbPathExists` returns a boolean and can be used in `WHERE` clauses. `jsonbPathQueryFirst` and `jsonbGet` return encrypted values — use them in `SELECT` expressions.
Batched conditions (and / or) [#batched-conditions-and--or]
Use `encryptionOps.and()` and `encryptionOps.or()` to batch multiple encrypted conditions into a single ZeroKMS call. This is more efficient than awaiting each operator individually.
```typescript filename="query-batched.ts"
// Batched AND — all encryptions happen in one call
const results = await db
.select()
.from(usersTable)
.where(
await encryptionOps.and(
encryptionOps.gte(usersTable.age, 18), // no await — lazy operator
encryptionOps.lte(usersTable.age, 65), // no await — lazy operator
encryptionOps.ilike(usersTable.email, "%example.com"),
eq(usersTable.role, "admin"), // mix with regular Drizzle ops
),
)
// Batched OR
const results = await db
.select()
.from(usersTable)
.where(
await encryptionOps.or(
encryptionOps.eq(usersTable.email, "alice@example.com"),
encryptionOps.eq(usersTable.email, "bob@example.com"),
),
)
```
Pass lazy operators (no `await`) to `and()`/`or()`, then `await` the outer call. This batches all encryption into a single operation.
Decrypt results [#decrypt-results]
```typescript filename="decrypt.ts"
// Single model
const decrypted = await encryptionClient.decryptModel(results[0])
if (!decrypted.failure) {
console.log(decrypted.data.email) // "alice@example.com"
}
// Bulk decrypt
const decrypted = await encryptionClient.bulkDecryptModels(results)
if (!decrypted.failure) {
for (const user of decrypted.data) {
console.log(user.email)
}
}
```
Non-encrypted column fallback [#non-encrypted-column-fallback]
All operators automatically detect whether a column is encrypted. If the column is a regular Drizzle column, the operator falls back to the standard Drizzle operator:
```typescript filename="fallback.ts"
// This works for both encrypted and non-encrypted columns
await encryptionOps.eq(usersTable.email, "alice@example.com") // encrypted
await encryptionOps.eq(usersTable.role, "admin") // falls back to drizzle eq()
```
Operator reference [#operator-reference]
Encrypted operators (async) [#encrypted-operators-async]
| Operator | Usage | Required Index |
| ------------------------------------ | ----------------------------------- | ----------------------------- |
| `eq(col, value)` | Equality | `equality` or `orderAndRange` |
| `ne(col, value)` | Not equal | `equality` or `orderAndRange` |
| `gt(col, value)` | Greater than | `orderAndRange` |
| `gte(col, value)` | Greater than or equal | `orderAndRange` |
| `lt(col, value)` | Less than | `orderAndRange` |
| `lte(col, value)` | Less than or equal | `orderAndRange` |
| `between(col, min, max)` | Between (inclusive) | `orderAndRange` |
| `notBetween(col, min, max)` | Not between | `orderAndRange` |
| `like(col, pattern)` | LIKE pattern match | `freeTextSearch` |
| `ilike(col, pattern)` | ILIKE case-insensitive | `freeTextSearch` |
| `notIlike(col, pattern)` | NOT ILIKE | `freeTextSearch` |
| `inArray(col, values)` | IN array | `equality` |
| `notInArray(col, values)` | NOT IN array | `equality` |
| `jsonbPathQueryFirst(col, selector)` | Extract first value at JSONB path | `searchableJson` |
| `jsonbGet(col, selector)` | Get value using JSONB `->` operator | `searchableJson` |
| `jsonbPathExists(col, selector)` | Check if JSONB path exists | `searchableJson` |
Sort operators (sync) [#sort-operators-sync]
| Operator | Usage | Required Index |
| ----------- | --------------- | --------------- |
| `asc(col)` | Ascending sort | `orderAndRange` |
| `desc(col)` | Descending sort | `orderAndRange` |
Logical operators (async, batched) [#logical-operators-async-batched]
| Operator | Usage | Description |
| -------------------- | ---------------- | ------------------ |
| `and(...conditions)` | Combine with AND | Batches encryption |
| `or(...conditions)` | Combine with OR | Batches encryption |
Both `and()` and `or()` accept `undefined` conditions, which are filtered out. This is useful for conditional query building:
```typescript filename="conditional-query.ts"
const results = await db
.select()
.from(usersTable)
.where(
await encryptionOps.and(
maybeCond ? encryptionOps.eq(usersTable.email, value) : undefined,
encryptionOps.gte(usersTable.age, 18),
),
)
```
Passthrough operators (sync, no encryption) [#passthrough-operators-sync-no-encryption]
`exists`, `notExists`, `isNull`, `isNotNull`, `not`, `arrayContains`, `arrayContained`, `arrayOverlaps`
These are re-exported from Drizzle and work identically.
Complete example: Express API [#complete-example-express-api]
```typescript filename="server.ts"
import "dotenv/config"
import express from "express"
import { eq } from "drizzle-orm"
import { drizzle } from "drizzle-orm/postgres-js"
import postgres from "postgres"
import { pgTable, integer, timestamp, varchar } from "drizzle-orm/pg-core"
import {
encryptedType,
extractEncryptionSchema,
createEncryptionOperators,
EncryptionOperatorError,
EncryptionConfigError,
} from "@cipherstash/stack/drizzle"
import { Encryption } from "@cipherstash/stack"
// Schema
const usersTable = pgTable("users", {
id: integer("id").primaryKey().generatedAlwaysAsIdentity(),
email: encryptedType("email", {
equality: true,
freeTextSearch: true,
}),
age: encryptedType("age", {
dataType: "number",
orderAndRange: true,
}),
role: varchar("role", { length: 50 }),
createdAt: timestamp("created_at").defaultNow(),
})
// Init
const usersSchema = extractEncryptionSchema(usersTable)
const encryptionClient = await Encryption({ schemas: [usersSchema] })
const encryptionOps = createEncryptionOperators(encryptionClient)
const db = drizzle({ client: postgres(process.env.DATABASE_URL!) })
const app = express()
app.use(express.json())
// Create user
app.post("/users", async (req, res) => {
const encrypted = await encryptionClient.encryptModel(req.body, usersSchema)
if (encrypted.failure) {
return res.status(500).json({ error: encrypted.failure.message })
}
const [user] = await db.insert(usersTable).values(encrypted.data).returning()
res.json(user)
})
// Search users
app.get("/users", async (req, res) => {
const conditions = []
if (req.query.email) {
conditions.push(
encryptionOps.ilike(usersTable.email, `%${req.query.email}%`),
)
}
if (req.query.minAge) {
conditions.push(
encryptionOps.gte(usersTable.age, Number(req.query.minAge)),
)
}
if (req.query.role) {
conditions.push(eq(usersTable.role, req.query.role as string))
}
let query = db.select().from(usersTable)
if (conditions.length > 0) {
query = query.where(
await encryptionOps.and(...conditions),
) as typeof query
}
const results = await query
const decrypted = await encryptionClient.bulkDecryptModels(results)
if (decrypted.failure) {
return res.status(500).json({ error: decrypted.failure.message })
}
res.json(decrypted.data)
})
app.listen(3000)
```
Error handling [#error-handling]
Individual operators (e.g., `eq()`, `gte()`, `like()`) throw when called with invalid configuration or missing indexes:
* **`EncryptionOperatorError`**: thrown for operator-level issues (e.g., invalid arguments, unsupported operations).
* **`EncryptionConfigError`**: thrown for configuration issues (e.g., using `like` on a column without `freeTextSearch: true`).
```typescript filename="error-handling.ts"
import {
createEncryptionOperators,
EncryptionOperatorError,
EncryptionConfigError,
} from "@cipherstash/stack/drizzle"
try {
const result = await encryptionOps.like(usersTable.age, "%foo%")
} catch (err) {
if (err instanceof EncryptionConfigError) {
// Column does not have freeTextSearch enabled
console.error("Config error:", err.message, err.context)
} else if (err instanceof EncryptionOperatorError) {
console.error("Operator error:", err.message, err.context)
}
}
```
Encryption client operations return `Result` objects with `data` or `failure`. See [Error handling](https://cipherstash.com/docs/stack/reference/error-handling) for details.
# DynamoDB
Source: https://cipherstash.com/docs/stack/cipherstash/encryption/dynamodb
import { faqPrivacy, faqKms, faqFreeTier } from "@/components/faq/shared";
CipherStash provides a DynamoDB integration through `@cipherstash/stack/dynamodb`. The `encryptedDynamoDB` helper encrypts items before writing to DynamoDB and decrypts them after reading — it does not wrap the AWS SDK, so you keep full control of your DynamoDB operations.
Installation [#installation]
```bash cta cta-type="install" example-id="install-dynamodb"
npm install @cipherstash/stack @aws-sdk/client-dynamodb @aws-sdk/lib-dynamodb
```
If you're using Bun, version 1.3 or later is required.
The DynamoDB integration is included in `@cipherstash/stack` and imports from `@cipherstash/stack/dynamodb`.
How it works [#how-it-works]
CipherStash encrypts each attribute into two DynamoDB attributes:
| Original attribute | Stored as | Purpose |
| ------------------ | --------------- | -------------------------------------------------------- |
| `email` | `email__source` | Encrypted ciphertext |
| `email` | `email__hmac` | HMAC for equality lookups (only if `.equality()` is set) |
Non-encrypted attributes pass through unchanged. On decryption, the `__source` and `__hmac` attributes are recombined back into the original attribute name with the plaintext value.
Setup [#setup]
Define an encrypted schema [#define-an-encrypted-schema]
Use `encryptedTable` and `encryptedColumn` from `@cipherstash/stack/schema` to declare which attributes to encrypt:
```typescript filename="schema.ts"
import { encryptedTable, encryptedColumn } from "@cipherstash/stack/schema"
const users = encryptedTable("users", {
email: encryptedColumn("email").equality(), // searchable via HMAC
name: encryptedColumn("name"), // encrypt-only, no search
phone: encryptedColumn("phone"), // encrypt-only
metadata: encryptedColumn("metadata").dataType("json"), // encrypted JSON
})
```
Only attributes with `.equality()` get an `__hmac` attribute for querying. Attributes without it are encrypted but cannot be searched.
`encryptedColumn` supports `.orderAndRange()`, `.freeTextSearch()`, and `.searchableJson()` index methods. Only `.equality()` produces HMAC values usable for DynamoDB key condition queries.
See [Schema definition](https://cipherstash.com/docs/stack/cipherstash/encryption/schema) for full details on index types, data types, and nested objects.
Initialize the clients [#initialize-the-clients]
```typescript filename="setup.ts"
import { DynamoDBClient } from "@aws-sdk/client-dynamodb"
import { DynamoDBDocumentClient } from "@aws-sdk/lib-dynamodb"
import { Encryption } from "@cipherstash/stack"
import { encryptedDynamoDB } from "@cipherstash/stack/dynamodb"
const dynamoClient = new DynamoDBClient({ region: "us-east-1" })
const docClient = DynamoDBDocumentClient.from(dynamoClient)
const encryptionClient = await Encryption({ schemas: [users] })
const dynamo = encryptedDynamoDB({ encryptionClient })
```
Optional: logger and error handler [#optional-logger-and-error-handler]
```typescript filename="setup-with-options.ts"
const dynamo = encryptedDynamoDB({
encryptionClient,
options: {
logger: {
error: (message, error) => console.error(`[DynamoDB] ${message}`, error),
},
errorHandler: (error) => {
console.error(`[${error.code}] ${error.message}`)
},
},
})
```
Encrypt and write [#encrypt-and-write]
Single item [#single-item]
Encrypt a model, then pass the result to a standard DynamoDB `PutCommand`:
```typescript filename="encrypt-single.ts"
import { PutCommand } from "@aws-sdk/lib-dynamodb"
const user = {
pk: "user#1",
email: "alice@example.com", // will be encrypted
name: "Alice Smith", // will be encrypted
role: "admin", // not in schema, passes through
}
const result = await dynamo.encryptModel(user, users)
if (result.failure) {
console.error("Encryption failed:", result.failure.message)
} else {
await docClient.send(new PutCommand({
TableName: "Users",
Item: result.data,
// result.data looks like:
// {
// pk: "user#1",
// email__source: "",
// email__hmac: "",
// name__source: "",
// role: "admin",
// }
}))
}
```
Bulk items [#bulk-items]
```typescript filename="encrypt-bulk.ts"
import { BatchWriteCommand } from "@aws-sdk/lib-dynamodb"
const items = [
{ pk: "user#1", email: "alice@example.com", name: "Alice" },
{ pk: "user#2", email: "bob@example.com", name: "Bob" },
]
const result = await dynamo.bulkEncryptModels(items, users)
if (!result.failure) {
await docClient.send(new BatchWriteCommand({
RequestItems: {
Users: result.data.map(item => ({
PutRequest: { Item: item },
})),
},
}))
}
```
Read and decrypt [#read-and-decrypt]
Single item [#single-item-1]
```typescript filename="decrypt-single.ts"
import { GetCommand } from "@aws-sdk/lib-dynamodb"
const getResult = await docClient.send(new GetCommand({
TableName: "Users",
Key: { pk: "user#1" },
}))
const result = await dynamo.decryptModel(getResult.Item, users)
if (!result.failure) {
console.log(result.data)
// { pk: "user#1", email: "alice@example.com", name: "Alice Smith", role: "admin" }
}
```
Bulk items [#bulk-items-1]
```typescript filename="decrypt-bulk.ts"
import { BatchGetCommand } from "@aws-sdk/lib-dynamodb"
const batchResult = await docClient.send(new BatchGetCommand({
RequestItems: {
Users: {
Keys: [{ pk: "user#1" }, { pk: "user#2" }],
},
},
}))
const result = await dynamo.bulkDecryptModels(
batchResult.Responses?.Users ?? [],
users,
)
if (!result.failure) {
for (const user of result.data) {
console.log(user.email) // plaintext
}
}
```
Querying with encrypted keys [#querying-with-encrypted-keys]
DynamoDB queries use key conditions, so you need to encrypt the search value into its HMAC form. Use `encryptionClient.encryptQuery()` to get the HMAC, then use it in your key condition.
Encrypted partition key [#encrypted-partition-key]
When an encrypted attribute is the partition key (e.g., `email__hmac`):
```typescript filename="query-partition-key.ts"
import { QueryCommand } from "@aws-sdk/lib-dynamodb"
// 1. Encrypt the search value to get the HMAC
const queryResult = await encryptionClient.encryptQuery([{
value: "alice@example.com",
column: users.email,
table: users,
queryType: "equality",
}])
if (queryResult.failure) {
throw new Error(`Query encryption failed: ${queryResult.failure.message}`)
}
const emailHmac = queryResult.data[0]?.hm
// 2. Use the HMAC in a DynamoDB query
const result = await docClient.send(new QueryCommand({
TableName: "Users",
KeyConditionExpression: "email__hmac = :email",
ExpressionAttributeValues: {
":email": emailHmac,
},
}))
// 3. Decrypt the results
const decrypted = await dynamo.bulkDecryptModels(result.Items ?? [], users)
```
Encrypted sort key [#encrypted-sort-key]
When an encrypted attribute is used as a sort key:
```typescript filename="query-sort-key.ts"
const result = await docClient.send(new GetCommand({
TableName: "Users",
Key: {
pk: "org#1", // partition key (plain)
email__hmac: emailHmac, // sort key (encrypted HMAC)
},
}))
const decrypted = await dynamo.decryptModel(result.Item, users)
```
Encrypted attribute in a GSI [#encrypted-attribute-in-a-gsi]
When querying a Global Secondary Index where the GSI key is an encrypted HMAC:
```typescript filename="query-gsi.ts"
const result = await docClient.send(new QueryCommand({
TableName: "Users",
IndexName: "EmailIndex",
KeyConditionExpression: "email__hmac = :email",
ExpressionAttributeValues: {
":email": emailHmac,
},
Limit: 1,
}))
if (result.Items?.length) {
const decrypted = await dynamo.decryptModel(result.Items[0], users)
}
```
Nested objects [#nested-objects]
The DynamoDB helper supports nested object encryption using `encryptedField`:
```typescript filename="schema.ts"
import { encryptedTable, encryptedColumn, encryptedField } from "@cipherstash/stack/schema"
const users = encryptedTable("users", {
email: encryptedColumn("email"),
profile: {
name: encryptedField("profile.name"),
address: {
street: encryptedField("profile.address.street"),
},
},
})
```
```typescript filename="nested-encrypt.ts"
const user = {
id: "1",
email: "user@example.com",
profile: {
name: "Alice Johnson",
address: {
street: "123 Main St",
city: "Sydney", // not in schema — unchanged
},
},
}
const encryptedResult = await dynamo.encryptModel(user, users)
```
Nested objects support encryption up to 3 levels deep. Searchable encryption is not supported on nested fields.
Table design considerations [#table-design-considerations]
Key schema patterns [#key-schema-patterns]
| Pattern | Partition key | Sort key | Use case |
| ------------ | ------------- | ------------- | ----------------------------------------------------------------- |
| Plain PK | `pk` (plain) | — | Standard lookup by ID |
| Encrypted PK | `email__hmac` | — | Lookup by encrypted attribute |
| Encrypted SK | `pk` (plain) | `email__hmac` | Composite key with encrypted sort |
| GSI on HMAC | `pk` (plain) | — | Query by encrypted attribute via GSI with `email__hmac` as GSI PK |
What you can query [#what-you-can-query]
* Equality on `__hmac` attributes (exact match only)
* `attribute_exists(email__source)` / `attribute_not_exists(email__source)` in condition expressions
What you cannot query [#what-you-cannot-query]
* Range or comparison on encrypted attributes (no `BETWEEN`, `<`, `>` on `__source`)
* Substring matching on encrypted attributes (no `begins_with`, `contains` on `__source`)
* `__source` values are encrypted binary — only equality via `__hmac` is supported
Audit logging [#audit-logging]
All operations support `.audit()` chaining for audit metadata:
```typescript filename="audit.ts"
const result = await dynamo
.encryptModel(user, users)
.audit({
metadata: {
sub: "user-id-123",
action: "user_registration",
timestamp: new Date().toISOString(),
},
})
```
Error handling [#error-handling]
All operations return `Result` with either `data` or `failure`:
```typescript filename="error-handling.ts"
const result = await dynamo.encryptModel(user, users)
if (result.failure) {
console.error(result.failure.message)
console.error(result.failure.code) // ProtectErrorCode | "DYNAMODB_ENCRYPTION_ERROR"
console.error(result.failure.details)
}
```
See [Error handling](https://cipherstash.com/docs/stack/reference/error-handling) for details on error codes and handling patterns.
API reference [#api-reference]
encryptedDynamoDB(config) [#encrypteddynamodbconfig]
```typescript filename="api-reference.ts"
import { encryptedDynamoDB } from "@cipherstash/stack/dynamodb"
const dynamo = encryptedDynamoDB({
encryptionClient: EncryptionClient,
options?: {
logger?: { error: (message: string, error: Error) => void }
errorHandler?: (error: EncryptedDynamoDBError) => void
}
})
```
Instance methods [#instance-methods]
| Method | Signature | Returns |
| ------------------- | ----------------------------------------------------------------------------- | -------------------------------------------------------------- |
| `encryptModel` | `(item: T, table: EncryptedTable)` | `EncryptModelOperation` |
| `bulkEncryptModels` | `(items: T[], table: EncryptedTable)` | `BulkEncryptModelsOperation` |
| `decryptModel` | `(item: Record, table: EncryptedTable)` | `DecryptModelOperation` (resolves to `Decrypted`) |
| `bulkDecryptModels` | `(items: Record[], table: EncryptedTable)` | `BulkDecryptModelsOperation` (resolves to `Decrypted[]`) |
All operations are thenable (awaitable) and support `.audit({ metadata })` chaining.
Querying encrypted attributes [#querying-encrypted-attributes]
Use the encryption client directly (not the DynamoDB helper):
```typescript filename="query-single.ts"
// Single value form (recommended for DynamoDB lookups):
const result = await encryptionClient.encryptQuery(
"search-value",
{ column: schema.fieldName, table: schema, queryType: "equality" }
)
const hmac = result.data?.hm
```
```typescript filename="query-batch.ts"
// Batch array form:
const batchResult = await encryptionClient.encryptQuery([{
value: "search-value",
column: schema.fieldName,
table: schema,
queryType: "equality",
}])
const hmac = batchResult.data[0]?.hm // Use in DynamoDB key conditions
```
Complete example [#complete-example]
```typescript filename="complete-example.ts"
import { DynamoDBClient } from "@aws-sdk/client-dynamodb"
import {
DynamoDBDocumentClient,
PutCommand,
GetCommand,
QueryCommand,
} from "@aws-sdk/lib-dynamodb"
import { Encryption } from "@cipherstash/stack"
import { encryptedDynamoDB } from "@cipherstash/stack/dynamodb"
import { encryptedTable, encryptedColumn } from "@cipherstash/stack/schema"
// Schema
const users = encryptedTable("users", {
email: encryptedColumn("email").equality(),
name: encryptedColumn("name"),
})
// Clients
const dynamoClient = new DynamoDBClient({ region: "us-east-1" })
const docClient = DynamoDBDocumentClient.from(dynamoClient)
const encryptionClient = await Encryption({ schemas: [users] })
const dynamo = encryptedDynamoDB({ encryptionClient })
// Write
const user = { pk: "user#1", email: "alice@example.com", name: "Alice" }
const encResult = await dynamo.encryptModel(user, users)
if (!encResult.failure) {
await docClient.send(new PutCommand({
TableName: "Users",
Item: encResult.data,
}))
}
// Read by primary key
const getResult = await docClient.send(new GetCommand({
TableName: "Users",
Key: { pk: "user#1" },
}))
const decResult = await dynamo.decryptModel(getResult.Item, users)
if (!decResult.failure) {
console.log(decResult.data.email) // "alice@example.com"
}
// Query by encrypted email (via HMAC)
const queryEnc = await encryptionClient.encryptQuery([{
value: "alice@example.com",
column: users.email,
table: users,
queryType: "equality",
}])
const hmac = queryEnc.data[0]?.hm
const queryResult = await docClient.send(new QueryCommand({
TableName: "Users",
IndexName: "EmailIndex",
KeyConditionExpression: "email__hmac = :e",
ExpressionAttributeValues: { ":e": hmac },
}))
const decrypted = await dynamo.bulkDecryptModels(queryResult.Items ?? [], users)
```
FAQ [#faq]
Yes, for exact equality. Each encrypted attribute stores an{" "}
__hmac term you match against, so you can look up by an
encrypted partition key, sort key, or GSI. Range, comparison, and
substring queries on encrypted attributes are not supported.
),
},
{
title: "Do I have to change how I write DynamoDB operations?",
answer: (
<>
No. encryptedDynamoDB encrypts items before writing and
decrypts them after reading; it does not wrap the AWS SDK, so you keep
full control of your PutItem, GetItem, and Query calls.
),
},
{
title: "What does adopting it look like?",
answer: (
<>
Install @cipherstash/stack, define an encrypted schema for
the attributes you want to protect, initialize the client, and encrypt
values before writing them. You can adopt it one table at a time.
),
},
faqKms,
faqFreeTier,
]}
/>
# Encrypt and decrypt
Source: https://cipherstash.com/docs/stack/cipherstash/encryption/encrypt-decrypt
All operations return a `Result` object with either a `data` key (success) or a `failure` key (error).
See [Error handling](https://cipherstash.com/docs/stack/reference/error-handling) for details.
Single values [#single-values]
Encrypt [#encrypt]
```typescript filename="encrypt.ts"
const encrypted = await client.encrypt("user@example.com", {
column: users.email,
table: users,
})
if (encrypted.failure) {
console.error(encrypted.failure.type, encrypted.failure.message)
} else {
console.log(encrypted.data)
}
```
Decrypt [#decrypt]
```typescript filename="decrypt.ts"
const decrypted = await client.decrypt(encrypted.data)
if (decrypted.failure) {
console.error(decrypted.failure.message)
} else {
console.log(decrypted.data) // "user@example.com"
}
```
Model operations [#model-operations]
Encrypt or decrypt an entire object. Only fields matching your schema are encrypted. Other fields pass through unchanged.
Encrypt a model [#encrypt-a-model]
```typescript filename="encrypt-model.ts"
const user = {
id: "1",
email: "user@example.com", // defined in schema -> encrypted
address: "123 Main St", // defined in schema -> encrypted
createdAt: new Date(), // not in schema -> unchanged
metadata: { role: "admin" }, // not in schema -> unchanged
}
const encryptedResult = await client.encryptModel(user, users)
if (encryptedResult.failure) {
console.error("Encryption failed:", encryptedResult.failure.message)
return
}
const encryptedUser = encryptedResult.data
// {
// id: '1',
// email: { c: 'encrypted_data...' },
// address: { c: 'encrypted_data...' },
// createdAt: Date,
// metadata: { role: 'admin' }
// }
```
Decrypt a model [#decrypt-a-model]
`decryptModel` automatically detects and decrypts any encrypted fields:
```typescript filename="decrypt-model.ts"
const decryptedResult = await client.decryptModel(encryptedUser)
if (decryptedResult.failure) {
console.error("Decryption failed:", decryptedResult.failure.message)
return
}
const decryptedUser = decryptedResult.data
```
Schema-aware return types [#schema-aware-return-types]
The return type of `encryptModel` is schema-aware: fields matching the table schema are typed as `Encrypted`, while other fields retain their original types. Let TypeScript infer the type parameters from the arguments:
```typescript filename="encrypt-model.ts"
const result = await client.encryptModel(user, users)
// result.data.email is typed as Encrypted
// result.data.id is typed as string
// result.data.createdAt is typed as Date
```
Passing an explicit type parameter (e.g., `client.encryptModel(...)`) is supported for backward compatibility. The return type degrades to `User`:
```typescript filename="encrypt-model.ts"
type User = {
id: string
email: string | null
address: string | null
createdAt: Date
}
const result = await client.encryptModel(user, users)
const back = await client.decryptModel(encryptedUser)
```
For full schema-aware types with explicit parameters, provide both the model type and the schema type:
```typescript filename="encrypt-model.ts"
const result = await client.encryptModel(user, users)
```
Bulk operations [#bulk-operations]
All bulk methods make a single call to ZeroKMS regardless of the number of records, while still using a unique key per value.
Bulk encrypt and decrypt values [#bulk-encrypt-and-decrypt-values]
```typescript filename="bulk-encrypt.ts"
const plaintexts = [
{ id: "u1", plaintext: "alice@example.com" },
{ id: "u2", plaintext: "bob@example.com" },
{ id: "u3", plaintext: null }, // null values are preserved
]
const encrypted = await client.bulkEncrypt(plaintexts, {
column: users.email,
table: users,
})
```
```typescript filename="bulk-decrypt.ts"
const decrypted = await client.bulkDecrypt(encrypted.data)
for (const item of decrypted.data) {
if ("data" in item) {
console.log(`${item.id}: ${item.data}`)
} else {
console.error(`${item.id} failed: ${item.error}`)
}
}
```
Bulk encrypt and decrypt models [#bulk-encrypt-and-decrypt-models]
```typescript filename="bulk-encrypt-models.ts"
const userModels = [
{ id: "1", email: "alice@example.com", address: "123 Main St" },
{ id: "2", email: "bob@example.com", address: "456 Oak Ave" },
]
const encrypted = await client.bulkEncryptModels(userModels, users)
const decrypted = await client.bulkDecryptModels(encrypted.data)
```
Bulk model operations also support type parameters:
```typescript filename="bulk-encrypt-models.ts"
const result = await client.bulkEncryptModels(userModels, users)
const back = await client.bulkDecryptModels(encrypted.data)
```
Identity-aware operations [#identity-aware-operations]
Any encrypt or decrypt operation can be bound to a claim from the signed-in user's JWT, provided the client is authenticated as that user with `OidcFederationStrategy`.
See [Identity-aware encryption](https://cipherstash.com/docs/stack/cipherstash/encryption/identity) for details.
```typescript filename="identity-encrypt.ts"
const claim = { identityClaim: ["sub"] }
const encrypted = await client
.encryptModel(user, users)
.withLockContext(claim)
const decrypted = await client
.decryptModel(encryptedUser)
.withLockContext(claim)
// Also works with bulk operations
const bulkEncrypted = await client
.bulkEncryptModels(userModels, users)
.withLockContext(claim)
const bulkDecrypted = await client
.bulkDecryptModels(encryptedUsers)
.withLockContext(claim)
```
Audit logging [#audit-logging]
All operations support `.audit()` for attaching metadata to the ZeroKMS audit trail. Pass any structured metadata you want recorded alongside the operation.
```typescript filename="audit.ts"
const result = await client
.encrypt(plaintext, { column: users.email, table: users })
.audit({ metadata: { action: "create" } })
```
Chain `.audit()` with `.withLockContext()` on the same operation:
```typescript filename="audit-model.ts"
const result = await client
.encryptModel(user, users)
.withLockContext({ identityClaim: ["sub"] })
.audit({ metadata: { action: "user-signup", requestId: "abc-123" } })
```
# Identity-aware encryption
Source: https://cipherstash.com/docs/stack/cipherstash/encryption/identity
Lock encryption to a specific user, so a value can only be decrypted while the client is authenticated as the identity that encrypted it.
How it works [#how-it-works]
Lock contexts require a Business or Enterprise workspace plan.
Two pieces combine.
**An auth strategy** decides who the client is when it talks to ZeroKMS. `OidcFederationStrategy` federates a signed-in user's OIDC JWT (from Supabase, Clerk, Auth0, or Okta) into a CipherStash token, so every ZeroKMS request is made as that user rather than as your service.
**A lock context** names which claim from that user's JWT to bind the value to, typically `sub`. ZeroKMS resolves the claim's value from the token authenticating the request and bakes it into the data key's tag.
Lock context is layered on top of the strategy: it requires `OidcFederationStrategy`, but the strategy does not require lock context. Authenticating as the user gives you a per-user audit trail; adding lock context gives you the cryptographic binding.
Lock contexts are useful for:
* Multi-tenant applications where each user's data must be isolated
* Compliance requirements that demand per-user encryption boundaries
* Applications where you need to prove that only authorized users accessed specific records
Basic usage [#basic-usage]
Register your identity provider with the workspace first, on the [OIDC providers](https://dashboard.cipherstash.com/workspaces/_/oidc-providers) page in the Dashboard. The `_` in that URL resolves to whichever workspace you have selected.
Construct the client with `OidcFederationStrategy`. Pass a function returning the **current** provider JWT: the strategy calls it again whenever it needs to re-federate, so do not capture a token once.
```typescript filename="client.ts"
import { Encryption, OidcFederationStrategy } from "@cipherstash/stack"
import { users } from "./schema"
export const client = await Encryption({
schemas: [users],
config: {
authStrategy: OidcFederationStrategy.create(
process.env.CS_WORKSPACE_CRN,
() => getUserJwt(),
),
},
})
```
`OidcFederationStrategy` is re-exported from `@cipherstash/stack`, so a separate `@cipherstash/auth` import is not needed.
`OidcFederationStrategy` is the only strategy that supports lock contexts. `AccessKeyStrategy` authenticates as your service rather than as an end user, so there is no user identity for ZeroKMS to resolve the claim against.
Then bind operations to the user's claim. Every example below uses the `client` above: without its `authStrategy`, `.withLockContext()` has no end-user identity to bind to.
```typescript filename="identity.ts"
// Encrypt, binding the data key to the user's `sub` claim
const encrypted = await client
.encrypt("sensitive data", { column: users.email, table: users })
.withLockContext({ identityClaim: ["sub"] })
// Decrypt with the same claim, as the same user
const decrypted = await client
.decrypt(encrypted.data)
.withLockContext({ identityClaim: ["sub"] })
```
`lockContext.identify(jwt)` is **deprecated**. Per-operation CTS tokens were removed in `protect-ffi` 0.25, so `identify()` no longer affects encryption: code that still calls it compiles and logs a deprecation warning, but the token it fetches is unused. Authenticate the client with `OidcFederationStrategy` and pass the claim to `.withLockContext()` instead.
Constructing a `LockContext` is not deprecated, it is simply optional here. `.withLockContext()` accepts either a `LockContext` or a plain `{ identityClaim }`.
Supported operations [#supported-operations]
Lock contexts work with all encrypt and decrypt operations:
```typescript filename="identity.ts"
const claim = { identityClaim: ["sub"] }
// Single operations
const encrypted = await client.encryptModel(user, users).withLockContext(claim)
const decrypted = await client.decryptModel(encryptedUser).withLockContext(claim)
// Bulk operations
const bulkEncrypted = await client
.bulkEncryptModels(userModels, users)
.withLockContext(claim)
const bulkDecrypted = await client
.bulkDecryptModels(encryptedUsers)
.withLockContext(claim)
// Query operations
const term = await client
.encryptQuery("user@example.com", { column: users.email, table: users })
.withLockContext(claim)
```
Custom identity claims [#custom-identity-claims]
`identityClaim` selects which claim (or claims) of the user's JWT ZeroKMS binds to.
| Identity claim | Description |
| -------------- | ----------------------------------------- |
| `sub` | The user's subject identifier |
| `scopes` | The user's scopes, set by your IdP policy |
Combine claims to scope by identity and permissions together:
```typescript filename="identity.ts"
await client
.encrypt("sensitive data", { column: users.email, table: users })
.withLockContext({ identityClaim: ["sub", "scopes"] })
```
The same claim must be supplied to decrypt. A value encrypted under `["sub"]` will not decrypt under `["sub", "scopes"]`.
Using with Clerk and Next.js [#using-with-clerk-and-nextjs]
Clerk is an OIDC provider like any other: hand `OidcFederationStrategy` a function that returns the current Clerk session token.
```typescript filename="client.ts"
import { auth } from "@clerk/nextjs/server"
import { Encryption, OidcFederationStrategy } from "@cipherstash/stack"
import { users } from "./schema"
export async function getClient() {
return Encryption({
schemas: [users],
config: {
authStrategy: OidcFederationStrategy.create(
process.env.CS_WORKSPACE_CRN,
async () => {
const { getToken } = await auth()
return await getToken()
},
),
},
})
}
```
Because the callback is re-invoked on every re-federation, it picks up a refreshed Clerk token automatically.
The `@cipherstash/nextjs` package (`protectClerkMiddleware`, `getCtsToken`) belongs to the earlier CTS-token flow, in which a token was fetched per request and handed to `new LockContext({ ctsToken })`. Encryption operations no longer consume a CTS token, so that middleware is not required for identity-aware encryption.
Error handling [#error-handling]
Encryption operations return a `Result`.
```typescript filename="identity.ts"
const result = await client
.encrypt("sensitive data", { column: users.email, table: users })
.withLockContext({ identityClaim: ["sub"] })
if (result.failure) {
console.error("Encryption failed:", result.failure.message)
}
```
Common failure scenarios:
| Scenario | Description |
| ------------------------------- | ----------------------------------------------------------------------------------------- |
| Invalid or expired provider JWT | Federation is rejected. The callback should return a live token, not one captured earlier |
| Provider not registered | The OIDC provider has not been added to the workspace |
| Network failure | The CipherStash API could not be reached |
| Missing workspace | `CS_WORKSPACE_CRN` is not configured |
| Claim mismatch on decrypt | The value was encrypted under a different `identityClaim`, or as a different user |
See [Error handling](https://cipherstash.com/docs/stack/reference/error-handling) for the full set of error types.
# /ENCRYPTION
Source: https://cipherstash.com/docs/stack/cipherstash/encryption
Searchable field-level encryption for Postgres. Every value encrypted with its own unique key via [ZeroKMS](https://cipherstash.com/docs/stack/cipherstash/kms). Range queries, exact match, free-text fuzzy search, and JSON queries over ciphertext. Sub-millisecond overhead on existing indexes.
This is the primitive everything else depends on.
What you get [#what-you-get]
1. **Unique key per value.** Not a shared table key. Each field gets its own data encryption key, derived via ZeroKMS.
2. **Searchable encryption.** Exact match, free-text search, range queries, and ordering over ciphertext in PostgreSQL.
3. **Encrypted JSONB.** Query encrypted JSON fields using JSONPath selectors and containment operators.
4. **Bulk operations.** Encrypt or decrypt thousands of values in a single ZeroKMS call.
5. **Identity-aware encryption.** Tie encryption to a user's JWT. Only that user decrypts their data.
6. **Tenant isolation via keysets.** One [keyset](https://cipherstash.com/docs/stack/cipherstash/kms/keysets) per customer. Provable cryptographic separation, not policy enforcement.
7. **TypeScript-first.** Strongly typed schemas, results, and model operations.
How it works [#how-it-works]
1. **Initialize your project:** Run `npx stash init` to authenticate, install EQL, scaffold the encryption client, and write `.cipherstash/context.json`.
2. **Draft a plan:** Run `npx stash plan` to hand off to a coding agent, which produces a reviewable plan at `.cipherstash/plan.md`.
3. **Execute the plan:** Run `npx stash impl` to confirm the plan and let the agent wire up encryption in your codebase.
4. **Encrypt and store:** Encrypt values before writing to your database.
5. **Query encrypted data:** Encrypt query terms and run them against your encrypted columns.
6. **Decrypt on read:** Decrypt values when reading from the database.
All key management (key generation, derivation, and isolation) is handled by [ZeroKMS](https://cipherstash.com/docs/stack/cipherstash/kms). Encryption keys are organized into [Key Sets](https://cipherstash.com/docs/stack/cipherstash/kms/keysets), the same primitive that will power Secrets (coming soon) environment isolation.
Integration paths [#integration-paths]
| | Encryption SDK | CipherStash Proxy |
| ------------ | -------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------- |
| **Best for** | Teams who want fine-grained control over data encryption directly in their application | DevOps teams who want to add encryption to existing PostgreSQL apps with little to no code changes |
| **Setup** | `npx stash init` | Docker container, configure environment variables |
| **Database** | PostgreSQL (full searchable encryption) | PostgreSQL (transparent proxy) |
Performance [#performance]
* **Latency**: \< 5ms overhead for most operations ([benchmarks](https://app.artillery.io/share/sh_75edb9d22a060633bfdce04777ffd60d1bcfc88989393dc38d3a4924b83fc6cd))
* **Throughput**: Scales with your application performance
* **Setup time**: Running in local dev in \< 1 hour, production in \< 3 days
CipherStash CLI [#cipherstash-cli]
[CipherStash CLI](https://cipherstash.com/docs/stack/cipherstash/cli) (`stash`) is the dev-time CLI for setting up your database. It handles installing the EQL extension, validating schemas, and managing the encryption lifecycle. Think of it like Drizzle Kit or Prisma CLI: a companion tool that sets up the database while `@cipherstash/stack` handles runtime encryption.
`stash init` scaffolds the encryption client, installs EQL, and writes `.cipherstash/context.json`. Then run `stash plan` to draft an encryption plan and `stash impl` to execute it.
```bash
npx stash init # Interactive project setup (auth, EQL install, client scaffold)
npx stash plan # Draft a reviewable encryption plan
npx stash impl # Execute the plan with a coding agent
npx stash db validate # Check schema for misconfigurations
npx stash db status # Show EQL installation state
```
Next steps [#next-steps]
# Setting up indexes
Source: https://cipherstash.com/docs/stack/cipherstash/encryption/indexes
Setting up indexes [#setting-up-indexes]
Encrypted columns need PostgreSQL indexes for fast queries. Without an index, the database performs a sequential scan: correct but slow at scale.
Index syntax differs between deployment types. Self-hosted PostgreSQL with full EQL installed supports custom operator classes and can use B-tree indexes directly on `eql_v2_encrypted` columns. Managed databases like Supabase cannot install operator families (they require superuser), so indexes must use extraction functions instead.
Deployment matrix [#deployment-matrix]
| Query type | Self-hosted (full EQL) | Supabase |
| ----------------- | ------------------------------------------------------------------------ | ---------------------------------------- |
| Equality | `USING btree (col)` with opclass, or `USING hash (eql_v2.hmac_256(col))` | `USING hash (eql_v2.hmac_256(col))` only |
| Range / ORDER BY | `USING btree (col)` with opclass | None (OPE-index work in progress) |
| Pattern match | `USING gin (eql_v2.bloom_filter(col))` | Same |
| JSONB containment | `USING gin (eql_v2.ste_vec(col))` | Same |
Range filters (`>`, `>=`, `<`, `<=`) work on Supabase without a range index (they use a sequential scan). `ORDER BY` on encrypted columns is not supported on Supabase at all. Sort application-side after decrypting results. Operator family support for Supabase is in development.
***
Equality [#equality]
Equality indexes speed up `WHERE col = $1` queries and `IN` lists.
**Self-hosted (B-tree with operator class):**
```sql
CREATE INDEX ON users USING btree (email);
```
This works because the full EQL install registers a B-tree operator class for `eql_v2_encrypted` that compares HMAC terms.
**Self-hosted or Supabase (hash on extraction function):**
```sql
CREATE INDEX ON users USING hash (eql_v2.hmac_256(email));
```
This form works on both deployment types. Use it when you want one index that works everywhere, or when you are on Supabase.
See queries: [Equality queries](https://cipherstash.com/docs/stack/cipherstash/encryption/queries#equality)
***
Match [#match]
Match indexes speed up `WHERE col LIKE $1` and `ILIKE` queries. They use a GIN index on the Bloom filter extracted from each encrypted value.
```sql
CREATE INDEX ON users USING gin (eql_v2.bloom_filter(name));
```
This form is identical for self-hosted and Supabase.
See queries: [Match queries](https://cipherstash.com/docs/stack/cipherstash/encryption/queries#match-free-text)
***
Range and order [#range-and-order]
Range indexes support `>`, `>=`, `<`, `<=`, `BETWEEN`, and `ORDER BY` on encrypted columns.
**Self-hosted (B-tree with operator class):**
```sql
CREATE INDEX ON users USING btree (age);
```
Requires the EQL operator family (`CREATE OPERATOR FAMILY`) to be installed. The full EQL install includes this. The `--exclude-operator-family` install flag omits it.
**Supabase:**
Functional range indexes for Supabase are not yet available. Range *filters* work without an index (sequential scan). `ORDER BY` on encrypted columns is not supported on Supabase.
See queries: [Range queries](https://cipherstash.com/docs/stack/cipherstash/encryption/queries#range-and-ordering)
***
JSONB [#jsonb]
JSONB indexes support path existence and containment queries on encrypted JSON columns.
```sql
CREATE INDEX ON documents USING gin (eql_v2.ste_vec(metadata));
```
This form is identical for self-hosted and Supabase.
See queries: [JSONB queries](https://cipherstash.com/docs/stack/cipherstash/encryption/queries#jsonb-queries)
***
Supabase query forms [#supabase-query-forms]
This is the most common source of silent performance problems with encrypted columns on Supabase.
A functional index on `eql_v2.hmac_256(email)` is only engaged when the query uses the same extraction function. A bare `WHERE email = $1` query does not use the index, even if the index exists. The database falls back to a sequential scan: your query returns correct results, but it scans every row.
**Wrong (does not use functional index):**
```sql
SELECT * FROM users WHERE email = $1::eql_v2_encrypted;
```
**Right (engages the functional index):**
```sql
SELECT * FROM users WHERE eql_v2.hmac_256(email) = eql_v2.hmac_256($1::eql_v2_encrypted);
```
SDK wrappers (Drizzle adapter, Supabase wrapper) generate the correct query form automatically. This only matters when you write raw SQL queries against Supabase encrypted columns. If you are using the Drizzle adapter or Supabase wrapper, no action is needed.
The same principle applies to `eql_v2.bloom_filter` and `eql_v2.ste_vec` indexes: the extraction function must appear in both the index definition and the query predicate.
***
Complete example [#complete-example]
```sql filename="migrations/add_encrypted_indexes.sql"
-- Equality index (Supabase-compatible form)
CREATE INDEX users_email_eq_idx ON users USING hash (eql_v2.hmac_256(email));
-- Match index
CREATE INDEX users_name_match_idx ON users USING gin (eql_v2.bloom_filter(name));
-- JSONB index
CREATE INDEX documents_metadata_ste_idx ON documents USING gin (eql_v2.ste_vec(metadata));
-- Range index (self-hosted only — requires operator family)
CREATE INDEX users_age_range_idx ON users USING btree (age);
```
***
Related [#related]
* [Searchable encryption queries](https://cipherstash.com/docs/stack/cipherstash/encryption/queries): Query patterns for each index type
* [Searchable encryption overview](https://cipherstash.com/docs/stack/cipherstash/encryption/searchable-encryption): How searchable indexes work
* [Supabase integration](https://cipherstash.com/docs/stack/cipherstash/supabase): Supabase-specific setup and limitations
* [EQL guide](https://cipherstash.com/docs/stack/reference/eql-guide): Full reference for EQL types and functions
# Model operations
Source: https://cipherstash.com/docs/stack/cipherstash/encryption/models
Model operations [#model-operations]
Model methods encrypt or decrypt an entire object in one call. The SDK inspects your schema to find which fields to encrypt and leaves all other fields on the object unchanged.
This is the recommended approach when working with database records: pass the object in, get the encrypted (or decrypted) version back, and write it to the database.
For full method signatures, see the [`EncryptionClient` API reference](https://cipherstash.com/docs/reference/stack/api-reference).
How schema-driven selection works [#how-schema-driven-selection-works]
When you call `encryptModel(record, schema)`, the SDK compares the object's keys against the columns declared in your `encryptedTable` schema. Fields that match a schema column are encrypted. Everything else passes through as-is.
Given this schema:
```typescript filename="schema.ts"
import { encryptedTable, encryptedColumn } from "@cipherstash/stack/schema"
const users = encryptedTable("users", {
email: encryptedColumn("email").equality().freeTextSearch(),
ssn: encryptedColumn("ssn").equality(),
})
```
And this record:
```typescript
const user = {
id: "user_123", // not in schema
email: "alice@example.com", // in schema
ssn: "123-45-6789", // in schema
createdAt: new Date(), // not in schema
role: "admin", // not in schema
}
```
The field selection looks like this:
| Field | In schema | After `encryptModel` |
| ----------- | --------- | -------------------- |
| `id` | No | `string` (unchanged) |
| `email` | Yes | `Encrypted` |
| `ssn` | Yes | `Encrypted` |
| `createdAt` | No | `Date` (unchanged) |
| `role` | No | `string` (unchanged) |
encryptModel [#encryptmodel]
Encrypts one object. Returns a `Result` wrapping the encrypted object.
```typescript filename="encrypt-model.ts"
import { Encryption } from "@cipherstash/stack"
import { encryptedTable, encryptedColumn } from "@cipherstash/stack/schema"
const users = encryptedTable("users", {
email: encryptedColumn("email").equality().freeTextSearch(),
ssn: encryptedColumn("ssn").equality(),
})
const client = await Encryption({ schemas: [users] })
const user = {
id: "user_123",
email: "alice@example.com",
ssn: "123-45-6789",
createdAt: new Date(),
}
const result = await client.encryptModel(user, users)
if (result.failure) {
throw new Error(`Encryption failed: ${result.failure.message}`)
}
const encryptedUser = result.data
// encryptedUser.email → Encrypted
// encryptedUser.ssn → Encrypted
// encryptedUser.id → "user_123" (unchanged)
```
Schema-aware types [#schema-aware-types]
TypeScript infers the return type from the schema. Let the compiler do the work: do not pass an explicit type parameter unless you need backward compatibility.
```typescript filename="encrypt-model-types.ts"
// Let TypeScript infer — the return type reflects exactly which fields are encrypted
const result = await client.encryptModel(user, users)
// result.data.email is typed as Encrypted
// result.data.id is typed as string
// Explicit type parameter — return type degrades to User
const result = await client.encryptModel(user, users)
// Explicit model and schema types — fully schema-aware
const result = await client.encryptModel(user, users)
```
decryptModel [#decryptmodel]
Decrypts one encrypted object. The SDK detects which fields are encrypted payloads and decrypts them. Non-encrypted fields pass through.
```typescript filename="decrypt-model.ts"
const decResult = await client.decryptModel(encryptedUser)
if (decResult.failure) {
throw new Error(`Decryption failed: ${decResult.failure.message}`)
}
const decryptedUser = decResult.data
// decryptedUser.email → "alice@example.com"
// decryptedUser.ssn → "123-45-6789"
// decryptedUser.id → "user_123"
```
`decryptModel` does not require a schema argument. It detects encrypted fields by inspecting the payload structure.
bulkEncryptModels [#bulkencryptmodels]
Encrypts an array of objects in a single ZeroKMS round-trip. All records share one network call, while each field in each record still gets its own unique key.
```typescript filename="bulk-encrypt-models.ts"
const records = [
{ id: "1", email: "alice@example.com", ssn: "111-22-3333", role: "admin" },
{ id: "2", email: "bob@example.com", ssn: "444-55-6666", role: "user" },
{ id: "3", email: "cara@example.com", ssn: "777-88-9999", role: "user" },
]
const result = await client.bulkEncryptModels(records, users)
if (result.failure) {
throw new Error(`Bulk encryption failed: ${result.failure.message}`)
}
// result.data is an array of encrypted records, same order as input
const encryptedRecords = result.data
```
Writing encrypted records to PostgreSQL [#writing-encrypted-records-to-postgresql]
```typescript filename="bulk-insert.ts"
import { Pool } from "pg"
const pool = new Pool({ connectionString: process.env.DATABASE_URL })
async function createUsers(users: { email: string; ssn: string; role: string }[]) {
const result = await client.bulkEncryptModels(users, usersSchema)
if (result.failure) {
throw new Error(result.failure.message)
}
const values = result.data.map((r) => [r.email, r.ssn, r.role])
await pool.query(
`INSERT INTO users (email, ssn, role)
SELECT * FROM UNNEST($1::jsonb[], $2::jsonb[], $3::text[])`,
[
result.data.map((r) => r.email),
result.data.map((r) => r.ssn),
result.data.map((r) => r.role),
],
)
}
```
bulkDecryptModels [#bulkdecryptmodels]
Decrypts an array of encrypted records in a single ZeroKMS call. Returns `Decrypted[]` — an array of plain objects with all encrypted fields resolved back to their original types.
```typescript filename="bulk-decrypt-models.ts"
const decResult = await client.bulkDecryptModels(encryptedRecords)
if (decResult.failure) {
throw new Error(`Bulk decryption failed: ${decResult.failure.message}`)
}
for (const user of decResult.data) {
console.log(user.email, user.ssn)
}
```
Decrypting database query results [#decrypting-database-query-results]
Fetch rows from PostgreSQL and pass the array directly to `bulkDecryptModels`:
```typescript filename="fetch-decrypt.ts"
const { rows } = await pool.query("SELECT * FROM users LIMIT 100")
const decResult = await client.bulkDecryptModels(rows)
if (decResult.failure) {
throw new Error(decResult.failure.message)
}
const users = decResult.data
```
Failure handling [#failure-handling]
All model methods return a `Result` object. The top-level `failure` fires when the entire operation fails (network error, auth failure, invalid credentials). There is no per-item failure for model operations: if any record fails, the whole call fails.
```typescript filename="error-handling.ts"
const result = await client.bulkEncryptModels(records, users)
if (result.failure) {
console.error(result.failure.type) // e.g. "EncryptionError"
console.error(result.failure.message) // human-readable description
}
```
See [Error handling](https://cipherstash.com/docs/stack/reference/error-handling) for the full set of error types.
Identity-aware model operations [#identity-aware-model-operations]
Chain `.withLockContext()` to bind encryption to a claim from the signed-in user's JWT. The client must be authenticated as that user with `OidcFederationStrategy`.
```typescript filename="model-with-identity.ts"
const claim = { identityClaim: ["sub"] }
// Single record
const encrypted = await client
.encryptModel(user, users)
.withLockContext(claim)
// Bulk records — one ZeroKMS call, all locked to the same identity
const bulkEncrypted = await client
.bulkEncryptModels(records, users)
.withLockContext(claim)
const bulkDecrypted = await client
.bulkDecryptModels(encryptedRecords)
.withLockContext(claim)
```
See [Identity-aware encryption](https://cipherstash.com/docs/stack/cipherstash/encryption/identity) for the full flow.
When to use model methods vs raw bulk [#when-to-use-model-methods-vs-raw-bulk]
| Scenario | Recommended method |
| --------------------------------------------------------------------- | ------------------------------------ |
| Inserting new records from an API payload | `encryptModel` / `bulkEncryptModels` |
| Reading records from a database and decrypting for display | `decryptModel` / `bulkDecryptModels` |
| Encrypting one specific field across many records (migration, import) | `bulkEncrypt` |
| Encrypting a single value for a query term | `encrypt` |
Use model methods when you have whole records to round-trip. Use raw bulk methods when you are targeting a single field across many records.
See [Bulk operations](https://cipherstash.com/docs/stack/cipherstash/encryption/bulk-operations) for `bulkEncrypt` and `bulkDecrypt`.
ORM integrations [#orm-integrations]
The Drizzle, Supabase, and DynamoDB adapters wrap model methods behind their own APIs:
* [Drizzle ORM](https://cipherstash.com/docs/stack/cipherstash/encryption/drizzle): `encryptModel` and `bulkEncryptModels` used behind `db.insert()`
* [Supabase](https://cipherstash.com/docs/stack/cipherstash/encryption/supabase): `encryptedSupabase` handles model encryption transparently
* [DynamoDB](https://cipherstash.com/docs/stack/cipherstash/encryption/dynamodb): `encryptedDynamoDB` wraps `PutItem` and `GetItem`
Next steps [#next-steps]
* [Bulk operations](https://cipherstash.com/docs/stack/cipherstash/encryption/bulk-operations): raw-value bulk encrypt and decrypt
* [Schema definition](https://cipherstash.com/docs/stack/cipherstash/encryption/schema): declare which fields to encrypt
* [Storing encrypted data](https://cipherstash.com/docs/stack/cipherstash/encryption/storing-data): raw SQL insert and retrieve patterns
* [Identity-aware encryption](https://cipherstash.com/docs/stack/cipherstash/encryption/identity): scope encryption to a user's JWT
# Prisma Next
Source: https://cipherstash.com/docs/stack/cipherstash/encryption/prisma-next
Prisma Next [#prisma-next]
CipherStash provides first-class [Prisma Next](https://www.npmjs.com/package/@prisma-next/cli) integration through [`@cipherstash/prisma-next`](https://www.npmjs.com/package/@cipherstash/prisma-next). Declare encrypted columns directly in `schema.prisma` with `cipherstash.Encrypted*()` constructors, and use auto-encrypting query operators that make encrypted queries look like standard Prisma Next code.
The Prisma Next integration has a meaningfully shorter onboarding path than the [Drizzle](https://cipherstash.com/docs/stack/cipherstash/encryption/drizzle) or [Supabase](https://cipherstash.com/docs/stack/cipherstash/encryption/supabase) integrations because the framework's migration system absorbs the database-side install. **You do not run `stash db install` for the EQL bundle** — `prisma-next migration apply` installs the EQL extension in the same control-plane sweep that creates your application tables.
Installation [#installation]
```bash cta cta-type="install" example-id="install-prisma-next"
npm install @cipherstash/stack @cipherstash/prisma-next
```
`@cipherstash/prisma-next` ships subpath exports for the control plane, the runtime plane, the bulk-encrypt middleware, and the all-in-one `./stack` setup helper. See the [subpath reference](#subpath-exports) below.
Authentication [#authentication]
CipherStash uses a per-developer identity model so every encrypt and decrypt against your workspace is attributable to a real user — not a shared `.env` file.
```bash
stash auth login # one-time, per developer
```
`stash auth login` runs a PKCE flow and caches the resulting credentials in your OS keychain. The `@cipherstash/stack` encryption client picks them up automatically with no env-var threading in local development.
The four `CS_*` env vars (`CS_WORKSPACE_CRN`, `CS_CLIENT_ID`, `CS_CLIENT_KEY`, `CS_CLIENT_ACCESS_KEY`) are reserved for production deployments and CI runners (application accounts where no human is at the keyboard). Provision them via the [CipherStash dashboard](https://dashboard.cipherstash.com/workspaces) → Settings → Access Keys when you're ready to deploy.
This identity story is universal across CipherStash integrations — Drizzle, Supabase, and Prisma Next all use the same PKCE / env-var split.
Database setup [#database-setup]
Prisma Next models its database state as **contract spaces**, and `@cipherstash/prisma-next` ships its EQL bundle (the `eql_v2_configuration` table, the `eql_v2_encrypted` composite type, the `ore_*` types, the `eql_v2.*` functions and operators) as one of those contract spaces. Registering the extension is the only thing you need to do — the framework handles plan, apply, and verify the same way it manages your application schema.
Register the extension [#register-the-extension]
```typescript filename="prisma-next.config.ts"
import { defineConfig } from "@prisma-next/cli/config-types"
import postgresAdapter from "@prisma-next/adapter-postgres/control"
import postgresDriver from "@prisma-next/driver-postgres/control"
import sql from "@prisma-next/family-sql/control"
import { prismaContract } from "@prisma-next/sql-contract-psl/provider"
import postgres from "@prisma-next/target-postgres/control"
import cipherstash from "@cipherstash/prisma-next/control"
export default defineConfig({
family: sql,
target: postgres,
driver: postgresDriver,
adapter: postgresAdapter,
extensionPacks: [cipherstash],
contract: prismaContract("./prisma/schema.prisma", {
output: "src/prisma/contract.json",
target: postgres,
}),
migrations: { dir: "migrations" },
})
```
Adding `cipherstash` to `extensionPacks` hands the framework the EQL bundle contract space; everything downstream (plan, apply, codec registration, `add_search_config` migration ops) follows from that single registration.
Install EQL + apply your schema in one step [#install-eql--apply-your-schema-in-one-step]
```bash
npx prisma-next contract emit # PSL → contract.{json,d.ts}
npx prisma-next migration plan --name initial
npx prisma-next migration apply # installs EQL bundle + your app schema
```
The apply step runs **two** contract spaces' migrations in the same transaction: the cipherstash extension's baseline (installs the EQL bundle SQL byte-for-byte, creates the `eql_v2_configuration` table, registers `eql_v2_encrypted`) and your application's own migrations (creates your tables with `eql_v2_encrypted` columns and `eql_v2_encrypted_constraint_*` check constraints). One command, both halves of the install.
Schema definition [#schema-definition]
Use `cipherstash.Encrypted*()` to declare encrypted columns directly in `schema.prisma`. Search-mode flags (`equality`, `freeTextSearch`, `orderAndRange`, `searchableJson`) default to `true`, so searchable encryption is the default for every cipherstash column.
```prisma filename="prisma/schema.prisma"
model User {
id String @id
email cipherstash.EncryptedString()
salary cipherstash.EncryptedDouble()
accountId cipherstash.EncryptedBigInt() @map("accountid")
birthday cipherstash.EncryptedDate()
emailVerified cipherstash.EncryptedBoolean() @map("emailverified")
preferences cipherstash.EncryptedJson()
@@map("users")
}
```
This is the **only** place per-column search-mode flags are declared. The stack-side `encryptedTable(...)` / `encryptedColumn(...)` schema, the EQL `add_search_config` migration ops, and the SDK's per-column index set are all derived from this file at runtime via [`cipherstashFromStack({ contractJson })`](#initialization).
Encrypted column types [#encrypted-column-types]
Each PSL constructor maps a JS plaintext to an EQL `cast_as` value and ships with a per-codec set of search-mode flags. Every flag defaults to `true`; pass `false` to opt out (`cipherstash.EncryptedString({ freeTextSearch: false })`).
| PSL constructor | JS plaintext | EQL `cast_as` | Search-mode flags |
| ------------------------------ | ----------------------- | ------------- | --------------------------------------------- |
| `cipherstash.EncryptedString` | `string` | `text` | `equality`, `freeTextSearch`, `orderAndRange` |
| `cipherstash.EncryptedDouble` | `number` (IEEE-754) | `double` | `equality`, `orderAndRange` |
| `cipherstash.EncryptedBigInt` | `bigint` | `big_int` | `equality`, `orderAndRange` |
| `cipherstash.EncryptedDate` | `Date` (calendar date) | `date` | `equality`, `orderAndRange` |
| `cipherstash.EncryptedBoolean` | `boolean` | `boolean` | `equality` |
| `cipherstash.EncryptedJson` | JSON-serialisable value | `jsonb` | `searchableJson` |
Each enabled flag installs one EQL search-config index — see [Indexes](https://cipherstash.com/docs/stack/cipherstash/encryption/indexes) for the index families.
When in doubt, leave every flag enabled. Enabling unused flags costs migration time (one extra `add_search_config` DDL op per flag per column) and EQL index storage; it does not affect the encrypt / decrypt path.
TypeScript schema authoring [#typescript-schema-authoring]
If you author your contract in TypeScript instead of PSL, the column factories are exported from `@cipherstash/prisma-next/column-types`:
```typescript filename="contract.ts"
import {
encryptedBigInt,
encryptedBoolean,
encryptedDate,
encryptedDouble,
encryptedJson,
encryptedString,
} from "@cipherstash/prisma-next/column-types"
import cipherstash from "@cipherstash/prisma-next/pack"
import sqlFamily from "@prisma-next/family-sql/pack"
import { defineContract, field, model } from "@prisma-next/sql-contract-ts/contract-builder"
import postgres from "@prisma-next/target-postgres/pack"
export const contract = defineContract({
family: sqlFamily,
target: postgres,
extensionPacks: { cipherstash },
models: {
User: model("User", {
fields: {
id: field.column({ codecId: "pg/int4@1", nativeType: "int4" })
.defaultSql("autoincrement()").id(),
email: field.column(encryptedString({ orderAndRange: true })),
salary: field.column(encryptedDouble()),
accountId: field.column(encryptedBigInt()).columnName("accountid"),
birthday: field.column(encryptedDate()),
emailVerified: field.column(encryptedBoolean()).columnName("emailverified"),
profile: field.column(encryptedJson()),
},
}).sql({ table: "users" }),
},
})
```
PSL- and TS-authored contracts emit byte-identical `contract.json` for every codec.
Initialization [#initialization]
`cipherstashFromStack({ contractJson })` is the one-call setup. It derives the stack encryption schemas from your contract, constructs the `@cipherstash/stack` `EncryptionClient`, builds the SDK adapter, and returns ready-to-spread `extensions` and `middleware` for `postgres({...})`.
```typescript filename="src/db.ts"
import "dotenv/config"
import { cipherstashFromStack } from "@cipherstash/prisma-next/stack"
import postgres from "@prisma-next/postgres/runtime"
import type { Contract } from "./prisma/contract.d"
import contractJson from "./prisma/contract.json" with { type: "json" }
const cipherstash = await cipherstashFromStack({ contractJson })
export const db = postgres({
contractJson,
extensions: cipherstash.extensions,
middleware: cipherstash.middleware,
})
```
That's the entire setup. The bundled `cipherstash.encryptionClient` is also exposed on the return value if you need to talk to the SDK directly outside the ORM path (e.g. encrypting a search term for a custom raw-SQL query).
The schema-derivation step keeps one source of truth: `schema.prisma`. You never write a second `encryptedTable(...)` declaration that has to stay in lockstep with the PSL constructors — if you do supply an override `schemas` array, `cipherstashFromStack` validates it against the contract and throws on divergence at setup time.
Subpath exports [#subpath-exports]
| Subpath | Purpose |
| --------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------- |
| `@cipherstash/prisma-next/stack` | One-call setup against `@cipherstash/stack`: `cipherstashFromStack`, `deriveStackSchemas`, `createCipherstashSdk` |
| `@cipherstash/prisma-next/control` | `SqlControlExtensionDescriptor` (contract space + pack meta + codec lifecycle hooks) |
| `@cipherstash/prisma-next/runtime` | Six envelope classes + `CipherstashSdk` + codec runtime + `decryptAll` + four free-standing helpers |
| `@cipherstash/prisma-next/middleware` | `bulkEncryptMiddleware(sdk)` |
| `@cipherstash/prisma-next/pack` | `cipherstashPackMeta` for TypeScript contract authoring |
| `@cipherstash/prisma-next/column-types` | Six TS factories: `encryptedString`, `encryptedDouble`, `encryptedBigInt`, `encryptedDate`, `encryptedBoolean`, `encryptedJson` |
`./control`, `./runtime`, `./middleware`, and `./stack` are tree-shakable along the same seams documented in the [DEVELOPING guide](https://github.com/cipherstash/stack/blob/main/packages/prisma-next/DEVELOPING.md). A runtime consumer never pulls the EQL bundle SQL; a control-plane consumer never pulls the envelope classes.
Insert encrypted data [#insert-encrypted-data]
Wrap each plaintext value in the corresponding `Encrypted*.from(...)` factory. The bulk-encrypt middleware coalesces every plaintext placeholder across a query into one `bulkEncrypt` SDK round-trip per `(table, column)` group — so an insert with N rows and M encrypted columns runs `min(N, M)` ZeroKMS round-trips, not N × M.
```typescript filename="insert.ts"
import {
EncryptedBigInt,
EncryptedBoolean,
EncryptedDate,
EncryptedDouble,
EncryptedJson,
EncryptedString,
} from "@cipherstash/prisma-next/runtime"
import { db } from "./db"
await db.orm.User.create({
id: "user-0",
email: EncryptedString.from("alice@example.com"),
salary: EncryptedDouble.from(95_000),
accountId: EncryptedBigInt.from(100_000_000_001n),
birthday: EncryptedDate.from(new Date("1990-04-12")),
emailVerified: EncryptedBoolean.from(true),
preferences: EncryptedJson.from({ theme: "dark", notifications: true }),
})
```
Query encrypted data [#query-encrypted-data]
Predicate operators are surfaced as **column methods** on the model accessor — `m.email.cipherstashEq(...)`. Sort and JSON SELECT-expression helpers are **free-standing functions** imported from `@cipherstash/prisma-next/runtime`.
Equality [#equality]
```typescript filename="query-equality.ts"
const rows = await db.orm.User
.where((u) => u.email.cipherstashEq("alice@example.com"))
.all()
```
Text search [#text-search]
```typescript filename="query-text-search.ts"
// ILIKE — case-insensitive substring match (requires freeTextSearch: true)
const rows = await db.orm.User
.where((u) => u.email.cipherstashIlike("%@example.com"))
.all()
```
Range queries [#range-queries]
```typescript filename="query-range.ts"
// Greater than
const rows = await db.orm.User
.where((u) => u.salary.cipherstashGt(100_000))
.all()
// Between (inclusive)
const rows = await db.orm.User
.where((u) =>
u.birthday.cipherstashBetween(
new Date("1985-01-01"),
new Date("1995-12-31"),
),
)
.all()
```
Array operators [#array-operators]
```typescript filename="query-array.ts"
// IN [...] on bigint
const rows = await db.orm.User
.where((u) =>
u.accountId.cipherstashInArray([100_000_000_001n, 100_000_000_004n]),
)
.all()
// Equality on a boolean column is expressed as a single-element InArray —
// booleans only carry the equality trait, so cipherstashEq is not surfaced.
const rows = await db.orm.User
.where((u) => u.emailVerified.cipherstashInArray([true]))
.all()
```
Sorting [#sorting]
Sort helpers are free-standing functions, imported from `@cipherstash/prisma-next/runtime`:
```typescript filename="query-sort.ts"
import { cipherstashAsc, cipherstashDesc } from "@cipherstash/prisma-next/runtime"
const rows = await db.orm.User
.orderBy((u) => cipherstashAsc(u.email))
.all()
```
Sort lowering uses the bare-column form (`ORDER BY ASC|DESC`) against the EQL ORE index — there's no `eql_v2.order_by_*(col)` wrapper to remember.
Combining conditions [#combining-conditions]
```typescript filename="query-combined.ts"
import { and } from "@prisma-next/sql-orm-client"
const rows = await db.orm.User
.where((u) =>
and(
u.email.cipherstashIlike("%@example.com"),
u.salary.cipherstashGt(50_000),
u.birthday.cipherstashLt(new Date("1990-01-01")),
),
)
.all()
```
JSONB queries [#jsonb-queries]
Encrypted JSON columns (`cipherstash.EncryptedJson`) support SELECT-expression helpers for path extraction. These require `searchableJson: true` (the default).
Extract value at path [#extract-value-at-path]
```typescript filename="query-jsonb-extract.ts"
import { cipherstashJsonbPathQueryFirst } from "@cipherstash/prisma-next/runtime"
// `cipherstashJsonbPathQueryFirst` returns Expression
// — the same encrypted type as the column — so it chains into follow-on
// JSON helpers or predicates.
const expr = cipherstashJsonbPathQueryFirst(u.preferences, "$.theme")
```
Get value with -> operator [#get-value-with---operator]
```typescript filename="query-jsonb-get.ts"
import { cipherstashJsonbGet } from "@cipherstash/prisma-next/runtime"
const expr = cipherstashJsonbGet(u.preferences, "$.theme")
```
`cipherstashJsonbPathExists` exists in the predicate surface but currently returns zero rows against the live EQL bundle — the EQL `jsonb_path_exists` function expects a client-side-hashed STE-VEC selector. Workaround: project all rows with `cipherstashJsonbPathQueryFirst` / `cipherstashJsonbGet` and apply client-side post-filtering. Tracked at [TML-2504](https://linear.app/prisma-company/issue/TML-2504).
Decrypt results [#decrypt-results]
Every read-side envelope carries the `(table, column)` it was decoded from, so `decrypt` and `decryptAll` route their bulk SDK calls by that key.
```typescript filename="decrypt.ts"
import { decryptAll } from "@cipherstash/prisma-next/runtime"
const rows = await db.orm.User.where(/* … */).all()
// One bulkDecrypt SDK round-trip per (table, column) group across the
// full result set, then synchronous plaintext reads off the cached envelopes.
await decryptAll(rows)
for (const row of rows) {
console.log(await row.email.decrypt()) // sync after decryptAll
console.log(await row.salary.decrypt())
}
```
Without `decryptAll`, each `await row.column.decrypt()` would round-trip individually.
Operator reference [#operator-reference]
Predicate operators (column methods) [#predicate-operators-column-methods]
| Operator | Required flag | Lowering | Applies to |
| -------------------------------------- | ---------------- | ----------------------------------------------------- | ---------------------------------------------------------------------------------- |
| `cipherstashEq(plaintext)` | `equality` | `eql_v2.eq(self, $N)` | every cipherstash codec |
| `cipherstashNe(plaintext)` | `equality` | `NOT eql_v2.eq(self, $N)` | every cipherstash codec |
| `cipherstashInArray([p1, p2, ...])` | `equality` | `(eql_v2.eq(self, $1) OR eql_v2.eq(self, $2) OR ...)` | every cipherstash codec |
| `cipherstashNotInArray([p1, p2, ...])` | `equality` | `NOT (eql_v2.eq(self, $1) OR ...)` | every cipherstash codec |
| `cipherstashIlike(pattern)` | `freeTextSearch` | `eql_v2.ilike(self, $N)` | `EncryptedString` |
| `cipherstashNotIlike(pattern)` | `freeTextSearch` | `NOT eql_v2.ilike(self, $N)` | `EncryptedString` |
| `cipherstashGt(plaintext)` | `orderAndRange` | `eql_v2.gt(self, $N)` | `EncryptedString`, `EncryptedDouble`, `EncryptedBigInt`, `EncryptedDate` |
| `cipherstashGte(plaintext)` | `orderAndRange` | `eql_v2.gte(self, $N)` | as above |
| `cipherstashLt(plaintext)` | `orderAndRange` | `eql_v2.lt(self, $N)` | as above |
| `cipherstashLte(plaintext)` | `orderAndRange` | `eql_v2.lte(self, $N)` | as above |
| `cipherstashBetween(lo, hi)` | `orderAndRange` | `eql_v2.gte(self, $1) AND eql_v2.lte(self, $2)` | as above |
| `cipherstashNotBetween(lo, hi)` | `orderAndRange` | `NOT (eql_v2.gte(self, $1) AND eql_v2.lte(self, $2))` | as above |
| `cipherstashJsonbPathExists(path)` | `searchableJson` | `eql_v2.jsonb_path_exists(self, $N)` | `EncryptedJson` (see [TML-2504](https://linear.app/prisma-company/issue/TML-2504)) |
Free-standing helpers [#free-standing-helpers]
| Helper | Required flag | Returns | Applies to |
| ------------------------------------------- | ---------------- | ------------------------------------- | ------------------------------------------------------------------------ |
| `cipherstashAsc(col)` | `orderAndRange` | `OrderByItem` (`ORDER BY ASC`) | `EncryptedString`, `EncryptedDouble`, `EncryptedBigInt`, `EncryptedDate` |
| `cipherstashDesc(col)` | `orderAndRange` | `OrderByItem` (`ORDER BY DESC`) | as above |
| `cipherstashJsonbPathQueryFirst(col, path)` | `searchableJson` | `Expression` | `EncryptedJson` |
| `cipherstashJsonbGet(col, path)` | `searchableJson` | `Expression` | `EncryptedJson` |
Why cipherstash-namespaced operators? [#why-cipherstash-namespaced-operators]
EQL ciphertexts contain randomized nonces, so SQL `=` / `<` / `>` against an `eql_v2_encrypted` column always returns `false` for two encrypts of the same plaintext. The cipherstash codecs declare zero of the framework's built-in traits, so `m.email.eq(...)` is a **compile-time error** on a cipherstash column — no wrong-SQL footgun is possible. The namespaced replacements (`cipherstashEq`, etc.) lower to the corresponding `eql_v2.*` functions which short-circuit through the per-column EQL search-config index.
Override surface [#override-surface]
`cipherstashFromStack` accepts two optional overrides:
* **`schemas`** — extra `EncryptedTable` declarations for tables the contract doesn't model (e.g. legacy tables not yet under Prisma Next). For tables the contract **does** declare, the override must agree on column names, `cast_as`, and the installed index set — divergence throws at setup time so ZeroKMS can't end up with an index set that disagrees with the EQL bundle's installed configuration.
* **`encryptionConfig`** — pass-through to `Encryption({ config })` (keyset overrides, logging, alternate workspace).
If `cipherstashFromStack` isn't a fit (custom SDK against a non-stack KMS, multi-tenant routing), drop one layer down to the primitives exported from the same subpath:
* **`deriveStackSchemas(contractJson)`** — pure function returning `EncryptedTable[]` derived from the contract.
* **`createCipherstashSdk(encryptionClient, schemas)`** — wraps an already-constructed stack `EncryptionClient` in the framework-native `CipherstashSdk` shape.
Complete example [#complete-example]
A runnable end-to-end example lives at [`cipherstash/stack:examples/prisma`](https://github.com/cipherstash/stack/tree/main/examples/prisma). It bundles a docker-compose Postgres, a six-codec `User` schema, and a flow that exercises every operator category against a live ZeroKMS workspace.
```bash
git clone https://github.com/cipherstash/stack
cd stack/examples/prisma
cp .env.example .env
stash auth login
docker compose up -d
pnpm install
pnpm emit
pnpm migration:plan --name initial
pnpm migration:apply
pnpm start
```
Expected output:
```text
--- Insert (mixed-codec round-trip) ---
Inserted 4 rows across six cipherstash codecs.
--- cipherstashEq (string equality) ---
Found 1 row(s) for alice@example.com.
user-0: alice@example.com
--- cipherstashIlike (string free-text-search) ---
Found 3 row(s) matching %@example.com.
user-0: alice@example.com
user-1: bob@example.com
user-2: carol@example.com
--- cipherstashGt (double order-and-range) ---
Found 2 user(s) with salary > 100,000.
--- cipherstashBetween (date order-and-range) ---
Found 3 user(s) born between 1985 and 1995.
--- cipherstashInArray (bigint equality) ---
Found 2 user(s) whose accountId is in the supplied array.
--- cipherstashInArray (boolean equality-only) ---
Found 3 user(s) with emailVerified = true.
--- cipherstashAsc (bare-column ORDER BY) ---
user-0: email=alice@example.com
user-1: email=bob@example.com
user-2: email=carol@example.com
user-3: email=dave@otherorg.test
```
Security model [#security-model]
* **Plaintext lifetime.** Write-side handles retain their plaintext slot post-encrypt — JS strings are immutable and zeroing is best-effort, so the GC-driven lifecycle is the sufficient bound. The `Encrypted.from(plaintext)` envelope's `decrypt()` returns the plaintext synchronously without consulting the SDK.
* **Ciphertext routing.** Every read-side envelope carries the `(table, column)` it was decoded from; `decrypt` / `decryptAll` route their bulk SDK calls by that key so the SDK picks the right key material per column.
* **Operator semantics.** Encrypted equality uses `eql_v2.eq` (deterministic-index lookup over the `unique` index); free-text uses `eql_v2.ilike` (bloom-filter lookup over `match`); range uses `eql_v2.gt` / `lt` / `eql_v2_encrypted` operator overloads (order-revealing-encryption lookup over `ore`). The framework's built-in `eq` / `gt` / `ilike` are unreachable on cipherstash columns — no wrong-SQL footgun where a randomized EQL ciphertext is compared with `=` directly.
* **Plaintext redaction in implicit serialisation paths.** Every envelope's `toJSON`, `toString`, `valueOf`, `Symbol.toPrimitive`, and `Symbol.for('nodejs.util.inspect.custom')` paths return `[REDACTED]` (or, for `toJSON`, a `{ "$encryptedX": "" }` placeholder). Accidental `console.log`, `JSON.stringify`, template-literal interpolation, error string construction, and `util.inspect` paths cannot leak plaintext. Explicit access is via `envelope.expose()`.
* **Cancellation.** Every cipherstash-internal SDK call accepts an `AbortSignal`; mid-flight cancellation surfaces a `RUNTIME.ABORTED` envelope with a phase tag (`bulk-encrypt`, `decrypt`, or `decrypt-all`).
Known limitations [#known-limitations]
* **`cipherstashJsonbPathExists` predicate** — currently returns zero rows against the live EQL bundle because the function expects a client-side-hashed STE-VEC selector. The non-predicate JSON helpers (`cipherstashJsonbPathQueryFirst`, `cipherstashJsonbGet`) work correctly. Tracked at [TML-2504](https://linear.app/prisma-company/issue/TML-2504).
* **`EncryptedBigInt` capped at `Number.MAX_SAFE_INTEGER`** — `@cipherstash/stack`'s SDK accepts numeric plaintexts only for the `big_int` cast, and `createCipherstashSdk` converts `bigint → Number` at the SDK boundary with an eager safe-integer bounds check (throws on overflow). Values beyond `Number.MAX_SAFE_INTEGER` cannot be encrypted today.
* **Encrypted timestamp / datetime** — lexical comparison over text-serialised timestamps is correctness-fragile (timezones, DST, format variation). CipherStash currently offers only calendar-date encryption via `EncryptedDate`.
* **Non-bigint integer variants** — EQL supports `int`, `small_int`, `big_int`, `real`; the extension currently ships `bigint` (`big_int`) and IEEE-754 (`double`) only.
* **Re-encryption migration** — flipping a populated column from plain to encrypted requires re-encrypting existing rows. The codec lifecycle hook emits the right search-config DDL but does not touch row data. Use a hand-authored `dataTransform` migration until a framework primitive lands.
References [#references]
* [`@cipherstash/prisma-next` on npm](https://www.npmjs.com/package/@cipherstash/prisma-next)
* [Package README](https://github.com/cipherstash/stack/blob/main/packages/prisma-next/README.md) — authoritative technical spec.
* [Runnable example](https://github.com/cipherstash/stack/tree/main/examples/prisma).
* [Prisma Next CLI](https://www.npmjs.com/package/@prisma-next/cli).
* [EQL reference](https://cipherstash.com/docs/stack/reference/eql-guide) — encrypted operator semantics and search-config index types.
* [Indexes](https://cipherstash.com/docs/stack/cipherstash/encryption/indexes) — `unique`, `match`, `ore`, `ste_vec` index family details.
* [CipherStash CLI](https://cipherstash.com/docs/stack/cipherstash/cli) — `stash auth login`, workspace management, secrets.
# Searchable encryption queries
Source: https://cipherstash.com/docs/stack/cipherstash/encryption/queries
Searchable encryption queries [#searchable-encryption-queries]
This page covers the three query families available for encrypted columns: equality, match (free-text), and range/order. Each section shows the SDK predicate, the raw SQL form, the underlying EQL index, and links to the corresponding index setup.
For index creation (the `CREATE INDEX` statements your database needs), see [Setting up indexes](https://cipherstash.com/docs/stack/cipherstash/encryption/indexes).
For a conceptual overview of how searchable encryption works, see [Searchable encryption](https://cipherstash.com/docs/stack/cipherstash/encryption/searchable-encryption).
Equality [#equality]
Exact match on an encrypted column. Uses the `unique` (HMAC-SHA256) index.
**Schema:**
```typescript filename="src/schema.ts"
import { encryptedTable, encryptedColumn } from "@cipherstash/stack/schema"
const users = encryptedTable("users", {
email: encryptedColumn("email").equality(),
})
```
**SDK (single value):**
```typescript filename="src/queries.ts"
const term = await client.encryptQuery("alice@example.com", {
column: users.email,
table: users,
queryType: "equality",
})
const result = await pgClient.query(
"SELECT * FROM users WHERE email = $1",
[term.data],
)
```
**SDK (IN list):**
```typescript filename="src/queries.ts"
const terms = await client.encryptQuery([
{ value: "alice@example.com", column: users.email, table: users, queryType: "equality" as const },
{ value: "bob@example.com", column: users.email, table: users, queryType: "equality" as const },
])
// Use each term.data as a separate parameter, or build an ANY($1) query.
```
**Drizzle:**
```typescript filename="src/queries.ts"
const results = await db
.select()
.from(usersTable)
.where(await encryptionOps.eq(usersTable.email, "alice@example.com"))
```
**Supabase wrapper:**
```typescript filename="src/queries.ts"
const { data } = await eSupabase
.from("users", users)
.select("id, email")
.eq("email", "alice@example.com")
```
**Raw SQL (self-hosted with EQL operator classes):**
```sql
SELECT * FROM users WHERE email = $1::eql_v2_encrypted;
```
**Raw SQL (Supabase / functional index form):**
```sql
SELECT * FROM users WHERE eql_v2.hmac_256(email) = eql_v2.hmac_256($1::eql_v2_encrypted);
```
On Supabase, bare `WHERE email = $1` does not use the functional index. Wrap both sides with `eql_v2.hmac_256()` to engage the hash index. The SDK wrappers (Drizzle, Supabase wrapper) handle this automatically. See [Index setup: Supabase callout](https://cipherstash.com/docs/stack/cipherstash/encryption/indexes#supabase-query-forms).
**Underlying index:** [Equality index setup](https://cipherstash.com/docs/stack/cipherstash/encryption/indexes#equality)
***
Match (free-text) [#match-free-text]
Substring and full-text search on an encrypted column. Uses the `match` (Bloom filter) index. Corresponds to `LIKE` / `ILIKE` semantics.
**Schema:**
```typescript filename="src/schema.ts"
const users = encryptedTable("users", {
name: encryptedColumn("name").freeTextSearch(),
})
```
**SDK:**
```typescript filename="src/queries.ts"
const term = await client.encryptQuery("alice", {
column: users.name,
table: users,
queryType: "freeTextSearch",
})
const result = await pgClient.query(
"SELECT * FROM users WHERE name LIKE $1",
[term.data],
)
```
**Drizzle:**
```typescript filename="src/queries.ts"
const results = await db
.select()
.from(usersTable)
.where(await encryptionOps.ilike(usersTable.name, "%alice%"))
```
**Supabase wrapper:**
```typescript filename="src/queries.ts"
const { data } = await eSupabase
.from("users", users)
.select("id, name")
.ilike("name", "%alice%")
```
**Raw SQL:**
```sql
SELECT * FROM users WHERE name LIKE $1;
```
The Bloom filter index uses a GIN index on the extracted filter term. See [Match index setup](https://cipherstash.com/docs/stack/cipherstash/encryption/indexes#match).
**Underlying index:** [Match index setup](https://cipherstash.com/docs/stack/cipherstash/encryption/indexes#match)
***
Range and ordering [#range-and-ordering]
Comparison (`>`, `>=`, `<`, `<=`, `BETWEEN`) and `ORDER BY` on an encrypted column. Uses the `ore` (Order Revealing Encryption) index.
**Schema:**
```typescript filename="src/schema.ts"
const users = encryptedTable("users", {
age: encryptedColumn("age").dataType("number").orderAndRange(),
})
```
**SDK (range filter):**
```typescript filename="src/queries.ts"
const term = await client.encryptQuery(21, {
column: users.age,
table: users,
queryType: "orderAndRange",
})
const result = await pgClient.query(
"SELECT * FROM users WHERE age > $1",
[term.data],
)
```
**SDK, ORDER BY (self-hosted only):**
```typescript filename="src/queries.ts"
// Self-hosted PostgreSQL with EQL operator families installed:
const result = await pgClient.query(
"SELECT * FROM users ORDER BY age ASC",
)
// Without operator family support (Supabase, or --exclude-operator-family):
const result = await pgClient.query(
"SELECT * FROM users ORDER BY eql_v2.ore_block_u64_8_256(age) ASC",
)
```
**Drizzle:**
```typescript filename="src/queries.ts"
// Range
const results = await db
.select()
.from(usersTable)
.where(await encryptionOps.gte(usersTable.age, 18))
// Sort (requires operator family support; not available on Supabase)
const results = await db
.select()
.from(usersTable)
.orderBy(encryptionOps.asc(usersTable.age))
```
**Supabase wrapper:**
```typescript filename="src/queries.ts"
// Range filter works
const { data } = await eSupabase
.from("users", users)
.select("id, age")
.gte("age", 18)
// ORDER BY on encrypted columns is not supported on Supabase.
// Sort application-side after decrypting.
```
`ORDER BY` on encrypted columns requires EQL operator families, which need superuser access to install. Supabase does not grant superuser. Range *filters* (`>`, `>=`, `<`, `<=`) work on both self-hosted and Supabase. Sorting on encrypted columns is not currently supported on Supabase. Sort application-side after decrypting results. Operator family support for Supabase is being developed in collaboration with the Supabase and CipherStash teams.
**Underlying index:** [Range index setup](https://cipherstash.com/docs/stack/cipherstash/encryption/indexes#range-and-order)
***
SELECT DISTINCT [#select-distinct]
`SELECT DISTINCT` on an encrypted column deduplicates by plaintext. The stored ciphertext is randomized per row, so identical plaintexts would not otherwise collapse — CipherStash Proxy rewrites the query so they do. No query changes are needed.
**Raw SQL:**
```sql
SELECT DISTINCT email FROM users;
```
**With `ORDER BY`:**
`SELECT DISTINCT ... ORDER BY ` is also supported, with no query changes needed.
```sql
SELECT DISTINCT age FROM users ORDER BY age ASC;
```
Deduplication is equality-based. A column with no equality index — most commonly a storage-only column with no `.equality()`, `.freeTextSearch()`, or `.orderAndRange()` configured — cannot be deduplicated. `SELECT DISTINCT` on that column raises a capability error.
Unsupported shapes [#unsupported-shapes]
Two combinations of `DISTINCT` and `ORDER BY` on an encrypted column are not supported and raise an error:
**`DISTINCT ON (...)` combined with `ORDER BY`:**
```sql
-- Not supported
SELECT DISTINCT ON (email) * FROM users ORDER BY email;
```
**`DISTINCT *` combined with `ORDER BY`, or with an encrypted column anywhere in the projection:**
```sql
-- Not supported: DISTINCT * with ORDER BY on an encrypted column
SELECT DISTINCT * FROM users ORDER BY email;
-- Not supported: an encrypted column reached via `*` in the projection
SELECT DISTINCT * FROM users;
```
List columns explicitly instead of using `*`:
```sql
SELECT DISTINCT id, email FROM users ORDER BY email;
```
**Underlying index:** [Equality index setup](https://cipherstash.com/docs/stack/cipherstash/encryption/indexes#equality)
***
JSONB queries [#jsonb-queries]
Query encrypted JSON columns using path existence or containment. Uses the `ste_vec` index.
**Schema:**
```typescript filename="src/schema.ts"
const documents = encryptedTable("documents", {
metadata: encryptedColumn("metadata").searchableJson(),
})
```
**SDK (path existence):**
```typescript filename="src/queries.ts"
const term = await client.encryptQuery("$.user.role", {
column: documents.metadata,
table: documents,
})
const result = await pgClient.query(
"SELECT * FROM documents WHERE cs_ste_vec_v2(metadata) @> $1",
[term.data],
)
```
**SDK (containment):**
```typescript filename="src/queries.ts"
const term = await client.encryptQuery({ role: "admin" }, {
column: documents.metadata,
table: documents,
})
```
**Drizzle:**
```typescript filename="src/queries.ts"
const results = await db
.select()
.from(documentsTable)
.where(await encryptionOps.jsonbPathExists(documentsTable.metadata, "$.user.role"))
```
**Underlying index:** [JSONB index setup](https://cipherstash.com/docs/stack/cipherstash/encryption/indexes#jsonb)
# Schema definition
Source: https://cipherstash.com/docs/stack/cipherstash/encryption/schema
Schemas tell the SDK which database columns to encrypt and what types of queries to support on the encrypted data.
Creating schema files [#creating-schema-files]
Declare your encryption schema in TypeScript, either in a single file or split across multiple files:
```txt
src/encryption/
└── schema.ts # single file
```
```txt
src/encryption/schemas/
├── users.ts # per-table files
└── posts.ts
```
Defining a schema [#defining-a-schema]
A schema maps your database tables and columns using `encryptedTable` and `encryptedColumn`:
```typescript filename="schema.ts"
import { encryptedTable, encryptedColumn } from "@cipherstash/stack/schema"
// TypeScript name Database table name
// ↓ ↓
export const protectedUsers = encryptedTable("users", {
// TypeScript name Database column name
// ↓ ↓
email: encryptedColumn("email"),
})
```
Index types [#index-types]
Full searchable encryption is only supported in Postgres. See [Searchable encryption](https://cipherstash.com/docs/stack/cipherstash/encryption/searchable-encryption) for details.
Index types determine what queries you can run on encrypted data. Methods are chainable. Call as many as you need on a single column.
```typescript filename="schema.ts"
export const protectedUsers = encryptedTable("users", {
email: encryptedColumn("email")
.equality() // exact match queries
.freeTextSearch() // full-text search
.orderAndRange(), // sorting and range queries
})
```
| Method | Purpose | SQL equivalent |
| ------------------- | -------------------------------------------- | -------------------------------------- |
| `.equality()` | Exact match lookups | `WHERE email = 'user@example.com'` |
| `.freeTextSearch()` | Full-text / fuzzy search | `WHERE description LIKE '%example%'` |
| `.orderAndRange()` | Sorting, comparison, range queries | `ORDER BY price ASC` |
| `.searchableJson()` | Encrypted JSONB path and containment queries | `WHERE metadata @> '{"role":"admin"}'` |
Only enable the indexes you need. Each additional index type has a performance cost.
Equality token filters [#equality-token-filters]
The `.equality()` method accepts an optional array of token filters that are applied before indexing:
```typescript filename="schema.ts"
email: encryptedColumn("email").equality([{ kind: "downcase" }])
```
| Filter | Description |
| ---------------------- | ------------------------------------------------------------------------------------------- |
| `{ kind: 'downcase' }` | Converts values to lowercase before comparison, enabling case-insensitive equality matching |
For columns storing JSON data, `.searchableJson()` is the recommended index. It automatically configures the column for encrypted JSONB path and containment queries. See [Searchable encryption](https://cipherstash.com/docs/stack/cipherstash/encryption/searchable-encryption) for details.
Data types [#data-types]
Use `.dataType()` to specify the plaintext type for a column:
```typescript filename="schema.ts"
encryptedColumn("age").dataType("number").orderAndRange()
```
| Data type | Description |
| ----------- | --------------------------------------------------------------- |
| `'string'` | Text values. This is the default. |
| `'text'` | Long-form text values. |
| `'number'` | Numeric values (integers and floats). |
| `'boolean'` | Boolean `true` / `false` values. |
| `'date'` | Date or timestamp values. |
| `'bigint'` | Large integer values. |
| `'json'` | JSON objects. Automatically set when using `.searchableJson()`. |
Free-text search options [#free-text-search-options]
Customize the tokenizer and filter settings for `.freeTextSearch()`:
```typescript filename="schema.ts"
encryptedColumn("bio").freeTextSearch({
tokenizer: { kind: "ngram", token_length: 3 }, // or { kind: "standard" }
token_filters: [{ kind: "downcase" }],
k: 6,
m: 2048,
include_original: false,
})
```
| Option | Type | Default | Description |
| ------------------ | ------------------------------------------------------------------- | ------------------------------------ | -------------------------------------------------- |
| `tokenizer` | `{ kind: 'standard' }` or `{ kind: 'ngram', token_length: number }` | `{ kind: 'ngram', token_length: 3 }` | Tokenization strategy |
| `token_filters` | `TokenFilter[]` | `[{ kind: 'downcase' }]` | Filters applied to tokens before indexing |
| `k` | `number` | `6` | Number of hash functions for the bloom filter |
| `m` | `number` | `2048` | Size of the bloom filter in bits |
| `include_original` | `boolean` | `true` | Whether to include the original value in the index |
Nested objects [#nested-objects]
CipherStash Encryption supports nested objects in your schema, allowing you to encrypt nested properties. You can define nested objects up to 3 levels deep using `encryptedField`.
Searchable encryption is not supported on nested objects. This is most useful for NoSQL databases or less structured data.
Using nested objects is not recommended for SQL databases. You should either use a JSON data type and encrypt the entire object, or use a separate column for each nested property.
```typescript filename="schema.ts"
import { encryptedTable, encryptedColumn, encryptedField } from "@cipherstash/stack/schema"
export const protectedUsers = encryptedTable("users", {
email: encryptedColumn("email").equality().freeTextSearch(),
profile: {
name: encryptedField("profile.name"),
address: {
street: encryptedField("profile.address.street"),
location: {
coordinates: encryptedField("profile.address.location.coordinates"),
},
},
},
})
```
When working with nested objects:
* Each level can have its own encrypted fields
* The maximum nesting depth is 3 levels
* Null and undefined values are supported at any level
* Optional nested objects are supported
The schema builder does not validate values passed to `encryptedField` or `encryptedColumn`. Values must be unique. Duplicate or incorrect values cause unexpected behavior.
Encrypted JSONB [#encrypted-jsonb]
For columns that store JSON objects, use `.searchableJson()` to enable encrypted JSONB queries:
```typescript filename="schema.ts"
const documents = encryptedTable("documents", {
metadata: encryptedColumn("metadata").searchableJson(),
})
```
This enables both JSONPath selector queries and containment queries on the encrypted data.
Multiple tables [#multiple-tables]
Pass multiple schemas when initializing the client:
```typescript filename="encryption/index.ts"
import { Encryption } from "@cipherstash/stack"
const client = await Encryption({ schemas: [protectedUsers, documents] })
```
Type inference [#type-inference]
Infer plaintext and encrypted types from your schema:
```typescript filename="schema.ts"
import type { InferPlaintext, InferEncrypted } from "@cipherstash/stack/schema"
type UserPlaintext = InferPlaintext
// { email: string; ... }
type UserEncrypted = InferEncrypted
// { email: Encrypted; ... }
```
Client-safe exports [#client-safe-exports]
For client-side code where the native FFI module is not available, import schema builders from the `@cipherstash/stack/client` subpath:
```typescript filename="schema.ts"
import { encryptedTable, encryptedColumn } from "@cipherstash/stack/client"
```
This exports schema builders and types only — no native module dependency.
# Searchable encryption
Source: https://cipherstash.com/docs/stack/cipherstash/encryption/searchable-encryption
Query encrypted data without decryption. Standard encryption breaks queries: encrypt a column and `WHERE`, `ORDER BY`, and `LIKE` stop working. CipherStash solves this with searchable encryption indexes that enable queries over ciphertext.
How it works [#how-it-works]
Each encrypted column can have one or more searchable indexes. When you encrypt a value, CipherStash creates index terms alongside the ciphertext. These terms are themselves encrypted — they reveal nothing about the plaintext — but they allow PostgreSQL to evaluate queries without decrypting.
The result: your data is encrypted at rest, in transit, and during query evaluation. CipherStash is [410,000x faster](https://github.com/cipherstash/tfhe-ore-bench) than homomorphic encryption, with sub-millisecond overhead on existing PostgreSQL indexes. Every decryption event is logged in [ZeroKMS](https://cipherstash.com/docs/stack/cipherstash/kms), giving you an audit trail for compliance with [SOC 2](https://cipherstash.com/compliance/soc2) and [BDSG](https://cipherstash.com/compliance/bdsg).
Supported query types [#supported-query-types]
| Query type | Index | Example |
| ------------------ | ---------------- | ----------------------------------------- |
| Exact match | `equality` | `WHERE email = ?` |
| Free-text search | `freeTextSearch` | `WHERE name LIKE '%alice%'` |
| Range / comparison | `orderAndRange` | `WHERE age > 21`, `ORDER BY created_at` |
| JSON containment | `searchableJson` | `WHERE metadata @> '{"role": "admin"}'` |
| Ordering | `orderAndRange` | `ORDER BY salary DESC` |
| Grouping | `equality` | `GROUP BY department` |
| Deduplication | `equality` | `SELECT DISTINCT email` |
| Uniqueness | `equality` | `UNIQUE` constraints on encrypted columns |
Prerequisites [#prerequisites]
1. Install [EQL](https://cipherstash.com/docs/stack/reference/eql-guide) in your PostgreSQL database using the [CipherStash CLI](https://cipherstash.com/docs/stack/cipherstash/cli):
```bash
npx stash db install
```
2. Define your encryption schema with the appropriate search indexes
3. Create PostgreSQL indexes on your encrypted columns. See [Setting up indexes](https://cipherstash.com/docs/stack/cipherstash/encryption/indexes) for the correct `CREATE INDEX` syntax for your deployment (self-hosted vs Supabase).
Index creation syntax differs between self-hosted PostgreSQL and Supabase. On Supabase, queries against encrypted columns require a specific function-wrapped form to engage functional indexes. See [Setting up indexes](https://cipherstash.com/docs/stack/cipherstash/encryption/indexes) for the full guide.
What is EQL? [#what-is-eql]
EQL (Encrypt Query Language) is a set of PostgreSQL extensions that enable searching and sorting on encrypted data. It provides custom data types, comparison functions, and index support for encrypted values.
Any encrypted column must use the `eql_v2_encrypted` type:
```sql
CREATE TABLE users (
id BIGINT GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
email eql_v2_encrypted
);
```
The encryptQuery function [#the-encryptquery-function]
Encrypt a query term so you can search encrypted data in PostgreSQL:
```typescript filename="search.ts"
const term = await client.encryptQuery("user@example.com", {
column: schema.email,
table: schema,
})
if (term.failure) {
// Handle the error
}
console.log(term.data) // encrypted query term
```
Properties [#properties]
| Property | Description |
| ------------ | ----------------------------------------------------------------------------------------------------------- |
| `value` | The value to search for |
| `column` | The column to search in |
| `table` | The table to search in |
| `queryType` | *(optional)* The query type — auto-inferred from the column's indexes when omitted |
| `returnType` | *(optional)* The output format — `'eql'` (default), `'composite-literal'`, or `'escaped-composite-literal'` |
returnType options [#returntype-options]
| `returnType` | Return type | Description |
| ----------------------------- | ------------------ | ------------------------------------------------------------------------------------------------------------------------- |
| `'eql'` (default) | `Encrypted` object | Raw EQL JSON payload. Use with parameterized queries (`$1`) or ORMs that accept JSON objects. |
| `'composite-literal'` | `string` | PostgreSQL composite literal format `("json")`. Use with Supabase `.eq()` or other APIs that require a string value. |
| `'escaped-composite-literal'` | `string` | Escaped composite literal `"(\"json\")"`. Use when the query string will be embedded inside another string or JSON value. |
Batch queries [#batch-queries]
Encrypt multiple query terms in a single call:
```typescript filename="search.ts"
const terms = await client.encryptQuery([
{ value: "user@example.com", column: schema.email, table: schema },
{ value: "18", column: schema.age, table: schema },
])
```
Query types [#query-types]
Exact matching [#exact-matching]
Use `.equality()` for exact match lookups:
```typescript filename="search.ts"
const term = await client.encryptQuery("user@example.com", {
column: schema.email,
table: schema,
})
const result = await pgClient.query(
"SELECT * FROM users WHERE email_encrypted = $1",
[term.data]
)
```
Free-text search [#free-text-search]
Use `.freeTextSearch()` for text-based searches:
```typescript filename="search.ts"
const term = await client.encryptQuery("example", {
column: schema.email,
table: schema,
})
const result = await pgClient.query(
"SELECT * FROM users WHERE email_encrypted LIKE $1",
[term.data]
)
```
Sorting and range queries [#sorting-and-range-queries]
Use `.orderAndRange()` for sorting and range operations:
If your PostgreSQL database does not support EQL Operator families, use the `eql_v2.ore_block_u64_8_256()` function for `ORDER BY`. Databases with Operator family support can use `ORDER BY` directly on the encrypted column name.
```typescript filename="search.ts"
const result = await pgClient.query(
"SELECT * FROM users ORDER BY eql_v2.ore_block_u64_8_256(age_encrypted) ASC"
)
```
JSONB queries with .searchableJson() [#jsonb-queries-with-searchablejson]
For columns storing JSON data, `.searchableJson()` is the recommended approach. It automatically infers the correct query operation from the plaintext value type.
```typescript filename="schema.ts"
const documents = encryptedTable("documents", {
metadata: encryptedColumn("metadata_encrypted").searchableJson(),
})
```
Auto-inference [#auto-inference]
| Plaintext type | Inferred operation | Use case |
| ----------------------------------- | ------------------ | ------------------------- |
| `string` (e.g. `'$.user.email'`) | `steVecSelector` | JSONPath selector queries |
| `object` (e.g. `{ role: 'admin' }`) | `steVecTerm` | Containment queries |
| `array` (e.g. `['admin', 'user']`) | `steVecTerm` | Containment queries |
| `null` | Returns `null` | Null handling |
JSONPath selector queries [#jsonpath-selector-queries]
Pass a string to query by JSON path:
```typescript filename="search.ts"
const pathTerm = await client.encryptQuery("$.user.email", {
column: documents.metadata,
table: documents,
})
// Nested path
const nestedTerm = await client.encryptQuery("$.user.profile.role", {
column: documents.metadata,
table: documents,
})
// Array index
const arrayTerm = await client.encryptQuery("$.items[0].name", {
column: documents.metadata,
table: documents,
})
```
Use the `toJsonPath` helper to convert dot-notation paths:
```typescript filename="search.ts"
import { toJsonPath } from "@cipherstash/stack"
toJsonPath("user.email") // '$.user.email'
toJsonPath("$.user.email") // '$.user.email' (unchanged)
toJsonPath("name") // '$.name'
```
Containment queries [#containment-queries]
Pass an object or array to query by containment:
```typescript filename="search.ts"
// Key-value containment
const roleTerm = await client.encryptQuery({ role: "admin" }, {
column: documents.metadata,
table: documents,
})
// Nested object containment
const nestedTerm = await client.encryptQuery(
{ user: { profile: { role: "admin" } } },
{ column: documents.metadata, table: documents }
)
// Array containment
const tagsTerm = await client.encryptQuery(["admin", "user"], {
column: documents.metadata,
table: documents,
})
```
Bare numbers and booleans are not supported as top-level `searchableJson` query values. For `orderAndRange` queries, bare numbers are supported directly. Wrap them in an object or array for `searchableJson`.
```typescript filename="search.ts"
// Wrong for searchableJson: will fail (works for orderAndRange)
await client.encryptQuery(42, { column: documents.metadata, table: documents })
// Correct — wrap in an object
await client.encryptQuery({ value: 42 }, { column: documents.metadata, table: documents })
```
Use the `buildNestedObject` helper to construct nested containment queries:
```typescript filename="search.ts"
import { buildNestedObject } from "@cipherstash/stack"
buildNestedObject("user.role", "admin")
// Returns: { user: { role: 'admin' } }
```
Using JSONB queries in SQL [#using-jsonb-queries-in-sql]
Specify `returnType: 'composite-literal'` for direct use in SQL:
```typescript filename="search.ts"
const term = await client.encryptQuery([{
value: "$.user.email",
column: documents.metadata,
table: documents,
returnType: "composite-literal",
}])
const result = await pgClient.query(
"SELECT * FROM documents WHERE cs_ste_vec_v2(metadata_encrypted) @> $1",
[term.data[0]]
)
```
Batch JSONB queries [#batch-jsonb-queries]
Use `encryptQuery` with an array to encrypt multiple JSONB query terms in a single call. Each item can have a different plaintext type:
```typescript filename="search.ts"
const terms = await client.encryptQuery([
{
value: "$.user.email", // string -> JSONPath selector
column: documents.metadata,
table: documents,
},
{
value: { role: "admin" }, // object -> containment
column: documents.metadata,
table: documents,
},
{
value: ["tag1", "tag2"], // array -> containment
column: documents.metadata,
table: documents,
},
])
```
Advanced: Explicit query types [#advanced-explicit-query-types]
For advanced use cases, you can specify the query type explicitly instead of relying on auto-inference:
| Approach | `queryType` | When to use |
| -------------------------------- | ----------------------------- | ------------------------------------------------------------- |
| **searchableJson** (recommended) | `'searchableJson'` or omitted | Auto-infers from plaintext type. Use for most JSONB queries. |
| **steVecSelector** (explicit) | `'steVecSelector'` | When you want to be explicit about JSONPath selector queries. |
| **steVecTerm** (explicit) | `'steVecTerm'` | When you want to be explicit about containment queries. |
```typescript filename="search.ts"
// Explicit steVecSelector
const selectorTerm = await client.encryptQuery("$.user.email", {
column: documents.metadata,
table: documents,
queryType: "steVecSelector",
})
// Explicit steVecTerm
const containTerm = await client.encryptQuery({ role: "admin" }, {
column: documents.metadata,
table: documents,
queryType: "steVecTerm",
})
```
Implementation example [#implementation-example]
Using the pg client [#using-the-pg-client]
```typescript filename="search.ts"
import { Client } from "pg"
import { Encryption } from "@cipherstash/stack"
import { encryptedTable, encryptedColumn } from "@cipherstash/stack/schema"
const schema = encryptedTable("users", {
email: encryptedColumn("email_encrypted")
.equality()
.freeTextSearch()
.orderAndRange(),
})
const pgClient = new Client({ connectionString: process.env.DATABASE_URL })
const client = await Encryption({ schemas: [schema] })
// Insert encrypted data
const encryptedData = await client.encryptModel({ email: "user@example.com" }, schema)
await pgClient.query(
"INSERT INTO users (email_encrypted) VALUES ($1::jsonb)",
[encryptedData.data.email_encrypted]
)
// Search encrypted data
const searchTerm = await client.encryptQuery("example.com", {
column: schema.email,
table: schema,
})
const result = await pgClient.query(
"SELECT * FROM users WHERE email_encrypted LIKE $1",
[searchTerm.data]
)
// Decrypt results
const decryptedData = await client.bulkDecryptModels(result.rows)
```
Best practices [#best-practices]
Schema design [#schema-design]
* Use `.equality()` for exact matches (most efficient)
* Use `.freeTextSearch()` for text-based searches (more expensive)
* Use `.orderAndRange()` for numerical data and sorting (most expensive)
* Only enable features you need to minimize performance impact
* Use `eql_v2_encrypted` column type in your database schema for encrypted columns
Security [#security]
* Never store unencrypted sensitive data
* Keep your CipherStash secrets secure
* Use parameterized queries to prevent SQL injection
Performance [#performance]
* Index your encrypted columns appropriately
* Use bulk operations (`bulkEncryptModels`, `bulkDecryptModels`) when working with multiple records
* Monitor query performance and consider the impact of search operations on your database
* Cache frequently accessed data
Error handling [#error-handling]
* Always check for failures with any `@cipherstash/stack` method
* Handle encryption errors aggressively
* Handle decryption errors gracefully
# Storing encrypted data
Source: https://cipherstash.com/docs/stack/cipherstash/encryption/storing-data
This guide shows how to persist encrypted values in your database and retrieve them later using raw SQL. If you're using an ORM, see the [Drizzle integration](https://cipherstash.com/docs/stack/cipherstash/encryption/drizzle) or [Supabase integration](https://cipherstash.com/docs/stack/cipherstash/encryption/supabase) instead.
Database compatibility [#database-compatibility]
The Encryption SDK works with any database that supports JSON or JSONB column types. Searchable encryption is available in PostgreSQL (via [EQL](https://cipherstash.com/docs/stack/reference/eql-guide)) and [DynamoDB](https://cipherstash.com/docs/stack/cipherstash/encryption/dynamodb).
| Database | Standard encryption | Searchable encryption |
| ----------------------------------- | ------------------- | --------------------- |
| PostgreSQL 15+ | Yes | Yes |
| AWS RDS PostgreSQL | Yes | Yes |
| AWS Aurora PostgreSQL | Yes | Yes |
| GCP Cloud SQL for PostgreSQL | Yes | Yes |
| Azure Database for PostgreSQL | Yes | Yes |
| OCI Database Service for PostgreSQL | Yes | Yes |
| DynamoDB | Yes | Yes |
| Supabase | Yes | Yes |
| Neon Postgres | Yes | — |
| MySQL | Yes | — |
| CockroachDB | Yes | — |
PostgreSQL guide [#postgresql-guide]
Install EQL (optional) [#install-eql-optional]
To enable searchable encryption in PostgreSQL, install [EQL](https://cipherstash.com/docs/stack/reference/eql-guide) using the [CipherStash CLI](https://cipherstash.com/docs/stack/cipherstash/cli) so you can use the `eql_v2_encrypted` data type. If you don't need searchable encryption, use `jsonb` instead (you can migrate to EQL later).
```bash
npx stash db install
```
* Use `eql_v2_encrypted` if you need searchable encryption (or want the option later)
* Use `jsonb` if you don't need searchable encryption or don't mind changing the data type later
Create a table [#create-a-table]
Encrypted values ([CipherCells](https://cipherstash.com/docs/stack/reference/cipher-cell)) are stored as either `jsonb` or `eql_v2_encrypted` in PostgreSQL.
With EQL:
```sql
CREATE TABLE users (
id SERIAL PRIMARY KEY,
email eql_v2_encrypted NOT NULL
);
```
With JSONB:
```sql
CREATE TABLE users (
id SERIAL PRIMARY KEY,
email jsonb NOT NULL
);
```
Encrypt and insert data [#encrypt-and-insert-data]
Encrypt the plaintext value and insert the resulting CipherCell into your database:
```typescript filename="insert.ts"
import { Encryption } from "@cipherstash/stack"
import { encryptedTable, encryptedColumn } from "@cipherstash/stack/schema"
import { Pool } from "pg"
const users = encryptedTable("users", {
email: encryptedColumn("email").equality(),
})
const client = await Encryption({ schemas: [users] })
const pool = new Pool({
host: process.env.DB_HOST,
database: process.env.DB_NAME,
user: process.env.DB_USER,
password: process.env.DB_PASSWORD,
port: parseInt(process.env.DB_PORT || "5432"),
})
async function insertUser(email: string) {
const encryptResult = await client.encrypt(email, {
column: users.email,
table: users,
})
if (encryptResult.failure) {
throw new Error(`Encryption failed: ${encryptResult.failure.message}`)
}
// Use the ::jsonb cast to ensure Postgres treats the data as JSONB
const result = await pool.query(
"INSERT INTO users (email) VALUES ($1::jsonb) RETURNING id",
[encryptResult.data]
)
return result.rows[0].id
}
```
Always use the `::jsonb` cast when inserting encrypted values, even when using the `eql_v2_encrypted` column type. This ensures PostgreSQL correctly handles the CipherCell object.
Retrieve and decrypt data [#retrieve-and-decrypt-data]
Query the database and pass the CipherCell to the `decrypt` method:
```typescript filename="retrieve.ts"
async function getUserEmail(userId: number) {
const fetchResult = await pool.query(
"SELECT email FROM users WHERE id = $1",
[userId]
)
if (fetchResult.rows.length === 0) {
throw new Error("User not found")
}
const decryptResult = await client.decrypt(fetchResult.rows[0].email)
if (decryptResult.failure) {
throw new Error(`Decryption failed: ${decryptResult.failure.message}`)
}
return decryptResult.data
}
```
Bulk insert with UNNEST [#bulk-insert-with-unnest]
When inserting many rows, use `bulkEncrypt` with PostgreSQL's `UNNEST` for efficient batch inserts:
```typescript filename="bulk-insert.ts"
async function insertUsers(emails: string[]) {
const plaintexts = emails.map((email) => ({ plaintext: email }))
const encryptedResult = await client.bulkEncrypt(plaintexts, {
column: users.email,
table: users,
})
if (encryptedResult.failure) {
throw new Error(`Bulk encryption failed: ${encryptedResult.failure.message}`)
}
const result = await pool.query(
`INSERT INTO users (email)
SELECT * FROM UNNEST($1::jsonb[])`,
[encryptedResult.data.map((item) => item.data)]
)
return result.rowCount
}
```
Using `bulkEncrypt` instead of calling `encrypt` in a loop is significantly faster. It batches key derivation requests to ZeroKMS.
Next steps [#next-steps]
* [Searchable encryption](https://cipherstash.com/docs/stack/cipherstash/encryption/searchable-encryption): query encrypted data without decrypting it
* [Drizzle ORM integration](https://cipherstash.com/docs/stack/cipherstash/encryption/drizzle): encrypted queries with Drizzle
* [Bulk operations](https://cipherstash.com/docs/stack/cipherstash/encryption/encrypt-decrypt): encrypt and decrypt multiple values efficiently
* [Identity-aware encryption](https://cipherstash.com/docs/stack/cipherstash/encryption/identity): bind operations to authenticated identities
# Supabase
Source: https://cipherstash.com/docs/stack/cipherstash/encryption/supabase
The `encryptedSupabase` wrapper makes encrypted queries look nearly identical to normal Supabase queries. It automatically handles encryption, decryption, `::jsonb` casts, and search term formatting.
Install [EQL](https://cipherstash.com/docs/stack/cipherstash/supabase#how-this-works) in your Supabase database using the [CipherStash CLI](https://cipherstash.com/docs/stack/cipherstash/cli) so encrypted columns can use the `eql_v2_encrypted` type.
```bash
npx stash db install --supabase
```
The `--supabase` flag installs a Supabase-compatible version of EQL and grants the required permissions on the `eql_v2` schema to `anon`, `authenticated`, and `service_role`.
Database schema [#database-schema]
Encrypted columns must be stored as `eql_v2_encrypted` or JSONB if you don't want searchable capabilities.
```sql filename="schema.sql"
CREATE TABLE users (
id SERIAL PRIMARY KEY,
email eql_v2_encrypted NOT NULL, -- encrypted column
name eql_v2_encrypted NOT NULL, -- encrypted column
age eql_v2_encrypted, -- encrypted column (numeric)
role VARCHAR(50), -- regular column (not encrypted)
created_at TIMESTAMPTZ DEFAULT NOW()
);
```
Setup [#setup]
```typescript filename="app/db.ts"
import { createClient } from "@supabase/supabase-js"
import { Encryption } from "@cipherstash/stack"
import { encryptedSupabase } from "@cipherstash/stack/supabase"
import { encryptedTable, encryptedColumn } from "@cipherstash/stack/schema"
const users = encryptedTable("users", {
email: encryptedColumn("email")
.equality()
.freeTextSearch(),
name: encryptedColumn("name")
.equality()
.freeTextSearch(),
age: encryptedColumn("age")
.dataType("number")
.equality()
.orderAndRange(),
})
const supabase = createClient(
process.env.SUPABASE_URL!,
process.env.SUPABASE_ANON_KEY!,
)
const encryptionClient = await Encryption({ schemas: [users] })
const eSupabase = encryptedSupabase({
encryptionClient,
supabaseClient: supabase,
})
```
All queries go through `eSupabase.from(tableName, schema)`:
```typescript filename="app/db.ts"
const { data, error } = await eSupabase
.from("users", users)
.select("id, email, name")
.eq("email", "alice@example.com")
```
Inserting data [#inserting-data]
The wrapper encrypts fields before insertion:
```typescript filename="app/actions.ts"
// Single insert
const { data, error } = await eSupabase
.from("users", users)
.insert({
email: "alice@example.com", // encrypted automatically
name: "Alice Smith", // encrypted automatically
age: 30, // encrypted automatically
role: "admin", // not in schema, passed through
})
.select("id")
// Bulk insert
const { data, error } = await eSupabase
.from("users", users)
.insert([
{ email: "alice@example.com", name: "Alice", age: 30, role: "admin" },
{ email: "bob@example.com", name: "Bob", age: 25, role: "user" },
])
.select("id")
```
Selecting data [#selecting-data]
The wrapper decrypts results automatically:
```typescript filename="app/queries.ts"
// List query — returns decrypted array
const { data, error } = await eSupabase
.from("users", users)
.select("id, email, name, role")
// data: [{ id: 1, email: "alice@example.com", name: "Alice Smith", role: "admin" }]
// Single result
const { data, error } = await eSupabase
.from("users", users)
.select("id, email, name")
.eq("id", 1)
.single()
// data: { id: 1, email: "alice@example.com", name: "Alice Smith" }
// Maybe single (returns null if no match)
const { data, error } = await eSupabase
.from("users", users)
.select("id, email")
.eq("email", "nobody@example.com")
.maybeSingle()
// data: null
```
You must list columns explicitly in `select()` — using `select('*')` will throw an error. The wrapper automatically adds `::jsonb` casts to encrypted columns so PostgreSQL parses them correctly.
`select()` also accepts an optional second parameter: `select(columns, { head?: boolean, count?: 'exact' | 'planned' | 'estimated' })`.
Query filters [#query-filters]
All filter values for encrypted columns are automatically encrypted before the query executes. Multiple filters are batch-encrypted in a single ZeroKMS call for efficiency.
Equality filters [#equality-filters]
```typescript filename="app/queries.ts"
// Exact match (requires .equality() on column)
const { data } = await eSupabase
.from("users", users)
.select("id, email, name")
.eq("email", "alice@example.com")
// Not equal
const { data } = await eSupabase
.from("users", users)
.select("id, email, name")
.neq("email", "alice@example.com")
// IN array (requires .equality())
const { data } = await eSupabase
.from("users", users)
.select("id, email, name")
.in("name", ["Alice Smith", "Bob Jones"])
// NULL check (no encryption needed)
const { data } = await eSupabase
.from("users", users)
.select("id, email, name")
.is("email", null)
```
Text search filters [#text-search-filters]
```typescript filename="app/queries.ts"
// LIKE — case sensitive (requires .freeTextSearch())
const { data } = await eSupabase
.from("users", users)
.select("id, email, name")
.like("name", "%alice%")
// ILIKE — case insensitive (requires .freeTextSearch())
const { data } = await eSupabase
.from("users", users)
.select("id, email, name")
.ilike("email", "%example.com%")
```
Range and comparison filters [#range-and-comparison-filters]
```typescript filename="app/queries.ts"
// Greater than (requires .orderAndRange())
const { data } = await eSupabase
.from("users", users)
.select("id, name, age")
.gt("age", 21)
// Greater than or equal
const { data } = await eSupabase
.from("users", users)
.select("id, name, age")
.gte("age", 18)
// Less than
const { data } = await eSupabase
.from("users", users)
.select("id, name, age")
.lt("age", 65)
// Less than or equal
const { data } = await eSupabase
.from("users", users)
.select("id, name, age")
.lte("age", 100)
```
Match (multi-column equality) [#match-multi-column-equality]
```typescript filename="app/queries.ts"
const { data } = await eSupabase
.from("users", users)
.select("id, email, name")
.match({ email: "alice@example.com", name: "Alice Smith" })
```
OR conditions [#or-conditions]
```typescript filename="app/queries.ts"
// String format
const { data } = await eSupabase
.from("users", users)
.select("id, email, name")
.or("email.eq.alice@example.com,email.eq.bob@example.com")
// Structured format (more type-safe)
const { data } = await eSupabase
.from("users", users)
.select("id, email, name")
.or([
{ column: "email", op: "eq", value: "alice@example.com" },
{ column: "email", op: "eq", value: "bob@example.com" },
])
```
Both forms encrypt values for encrypted columns automatically.
NOT filter [#not-filter]
```typescript filename="app/queries.ts"
const { data } = await eSupabase
.from("users", users)
.select("id, email, name")
.not("email", "eq", "alice@example.com")
```
Raw filter [#raw-filter]
```typescript filename="app/queries.ts"
const { data } = await eSupabase
.from("users", users)
.select("id, email, name")
.filter("email", "eq", "alice@example.com")
```
Combining encrypted and non-encrypted filters [#combining-encrypted-and-non-encrypted-filters]
```typescript filename="app/queries.ts"
const { data } = await eSupabase
.from("users", users)
.select("id, email, name")
.eq("email", "alice@example.com") // encrypted
.eq("role", "admin") // passed through as-is
```
Updating and deleting [#updating-and-deleting]
```typescript filename="app/actions.ts"
// Update
const { data } = await eSupabase
.from("users", users)
.update({ name: "Alice Johnson" }) // encrypted automatically
.eq("id", 1)
.select("id, name")
// Upsert
const { data } = await eSupabase
.from("users", users)
.upsert(
{ id: 1, email: "alice@example.com", name: "Alice", role: "admin" },
{ onConflict: "id" },
)
.select("id, email, name")
// Delete
const { error } = await eSupabase
.from("users", users)
.delete()
.eq("id", 1)
```
Transforms [#transforms]
These are passed through to Supabase directly:
```typescript filename="app/queries.ts"
const { data } = await eSupabase
.from("users", users)
.select("id, email, name")
.eq("name", "Alice")
.order("name", { ascending: true })
.limit(10)
.range(0, 9)
```
The following transform methods are also supported:
```typescript filename="app/queries.ts"
.csv()
.abortSignal(signal)
.throwOnError()
.returns()
```
Lock context and audit [#lock-context-and-audit]
Identity-aware encryption has two parts. Authenticate the encryption client as the signed-in user with `OidcFederationStrategy`, then chain `.withLockContext()` to bind values to a claim from that user's JWT.
Register your Supabase project as an OIDC provider on the [OIDC providers](https://dashboard.cipherstash.com/workspaces/_/oidc-providers) page in the Dashboard first. The `_` in that URL resolves to whichever workspace you have selected.
`OidcFederationStrategy` is the only strategy that supports lock contexts. `AccessKeyStrategy` authenticates as your service rather than as an end user, so there is no user identity for ZeroKMS to resolve the claim against.
```typescript filename="lib/encryption.ts"
import { Encryption, OidcFederationStrategy } from "@cipherstash/stack"
import { users } from "./schema"
// Every ZeroKMS request is authenticated as the signed-in Supabase user
export const encryptionClient = await Encryption({
schemas: [users],
config: {
authStrategy: OidcFederationStrategy.create(
process.env.CS_WORKSPACE_CRN,
async () => {
const { data } = await supabase.auth.getSession()
return data.session?.access_token
},
),
},
})
```
Pass a function that returns the **current** access token. The strategy calls it again whenever it re-federates, so a token captured once will go stale.
Build `eSupabase` from that `encryptionClient`. Without its `authStrategy`, `.withLockContext()` has no end-user identity to bind to.
```typescript filename="app/actions.ts"
import { LockContext } from "@cipherstash/stack/identity"
// Bind the data key to the user's `sub` claim
const lockContext = new LockContext({ context: { identityClaim: ["sub"] } })
const { data } = await eSupabase
.from("users", users)
.insert({ email: "alice@example.com", name: "Alice" })
.withLockContext(lockContext)
.select("id")
```
`lockContext.identify(jwt)` is **deprecated**. Per-operation CTS tokens were removed in `protect-ffi` 0.25, so calling it no longer affects encryption. Authenticate the client with `OidcFederationStrategy` instead.
Lock contexts work with all operations (insert, select, update, delete):
```typescript filename="app/queries.ts"
const { data } = await eSupabase
.from("users", users)
.select("id, email, name")
.eq("email", "alice@example.com")
.withLockContext(lockContext)
.audit({ metadata: { action: "user-lookup", requestId: "abc-123" } })
```
Error handling [#error-handling]
Encryption errors are surfaced with an additional `encryptionError` field:
```typescript filename="app/queries.ts"
const { data, error } = await eSupabase
.from("users", users)
.select("id, email")
if (error) {
if (error.encryptionError) {
console.error("Encryption error:", error.encryptionError)
}
}
```
Response type [#response-type]
```typescript filename="types.ts"
type EncryptedSupabaseResponse = {
data: T | null // Decrypted rows
error: EncryptedSupabaseError | null
count: number | null
status: number
statusText: string
}
```
Errors can come from Supabase (API errors) or from encryption operations. Check `error.encryptionError` for encryption-specific failures.
The full `EncryptedSupabaseError` type:
```typescript filename="types.ts"
type EncryptedSupabaseError = {
message: string
details?: string // Supabase error details
hint?: string // Supabase error hint
code?: string // Supabase/PostgreSQL error code
encryptionError?: EncryptionError // CipherStash encryption-specific error
}
```
Filter to index mapping [#filter-to-index-mapping]
| Filter Method | Required Index | Query Type |
| ------------------------ | ------------------- | ---------------------------------- |
| `eq`, `neq`, `in` | `.equality()` | `'equality'` |
| `like`, `ilike` | `.freeTextSearch()` | `'freeTextSearch'` |
| `gt`, `gte`, `lt`, `lte` | `.orderAndRange()` | `'orderAndRange'` |
| `is` | None | No encryption (NULL/boolean check) |
Exported types [#exported-types]
`@cipherstash/stack/supabase` also exports the following types:
* `EncryptedSupabaseConfig`
* `EncryptedSupabaseInstance`
* `EncryptedQueryBuilder`
* `PendingOrCondition`
* `SupabaseClientLike`
Exposing EQL schema for Supabase [#exposing-eql-schema-for-supabase]
If you installed EQL with `npx stash db install --supabase`, the role grants are already applied. You still need to expose the schema in the Supabase dashboard:
Go to [API settings](https://supabase.com/dashboard/project/_/settings/api) and add `eql_v2` to **Exposed schemas**.
If you installed EQL manually (without `--supabase`), you also need to grant permissions. See [CipherStash CLI — Supabase install](https://cipherstash.com/docs/stack/cipherstash/cli/install#supabase-install) for the required grants.
How it works [#how-it-works]
`encryptedSupabase` uses a deferred query builder pattern. All chained operations (`.select()`, `.eq()`, `.insert()`) are recorded synchronously. When you `await` the query, the builder:
1. **Encrypts mutation data** — calls `encryptModel` / `bulkEncryptModels` and converts to PG composites
2. **Adds `::jsonb` casts** — parses your select string and adds `::jsonb` to encrypted columns
3. **Batch-encrypts filter values** — collects all filter values for encrypted columns and encrypts them in a single `encryptQuery()` call (one round-trip to ZeroKMS)
4. **Executes the real Supabase query** — chains all operations on the underlying Supabase client
5. **Decrypts results** — calls `decryptModel` / `bulkDecryptModels` on the returned data
Complete example [#complete-example]
```typescript filename="app/example.ts"
import { createClient } from "@supabase/supabase-js"
import { Encryption } from "@cipherstash/stack"
import { encryptedSupabase } from "@cipherstash/stack/supabase"
import { encryptedTable, encryptedColumn } from "@cipherstash/stack/schema"
// Schema
const users = encryptedTable("users", {
email: encryptedColumn("email").equality().freeTextSearch(),
name: encryptedColumn("name").equality().freeTextSearch(),
age: encryptedColumn("age").dataType("number").equality().orderAndRange(),
})
// Clients
const supabase = createClient(process.env.SUPABASE_URL!, process.env.SUPABASE_ANON_KEY!)
const encryptionClient = await Encryption({ schemas: [users] })
const eSupabase = encryptedSupabase({ encryptionClient, supabaseClient: supabase })
// Insert
await eSupabase
.from("users", users)
.insert([
{ email: "alice@example.com", name: "Alice", age: 30 },
{ email: "bob@example.com", name: "Bob", age: 25 },
])
// Query with multiple filters
const { data } = await eSupabase
.from("users", users)
.select("id, email, name, age")
.gte("age", 18)
.lte("age", 35)
.ilike("name", "%ali%")
// data is fully decrypted:
// [{ id: 1, email: "alice@example.com", name: "Alice", age: 30 }]
```
# Audit features
Source: https://cipherstash.com/docs/stack/cipherstash/proxy/audit
CipherStash Proxy provides comprehensive data access auditing for PostgreSQL. These features work transparently. They require no changes to your SQL or application code.
Statement fingerprinting [#statement-fingerprinting]
Statement fingerprints identify unique SQL statements by examining the raw parse tree using [pg\_query](https://pganalyze.com/blog/pg-query-2-0-postgres-query-parser#fingerprints-in-pg_query-a-better-way-to-check-if-two-queries-are-identical). Fingerprints ignore query differences when they result in the same query intent. They are unique across environments and time, providing a useful mechanism for identifying query patterns.
**Example**
| SQL | Fingerprint |
| -------------------- | ------------------ |
| `SELECT a, b FROM c` | `fb1f305bea85c2f6` |
| `SELECT b, a FROM c` | `fb1f305bea85c2f6` |
Both queries produce the same fingerprint because they access the same columns from the same table. Column order doesn't affect the intent.
Statement redaction [#statement-redaction]
The statement SQL is redacted before being included in an event payload. All static values in the SQL string are stripped. Table names, column names, and function names are retained.
If parsing fails or another issue prevents redaction, Proxy does not transmit the statement.
Most PostgreSQL libraries and frameworks default to using parameterized statements and the PostgreSQL Extended Protocol, in which case values will not be included in the SQL.
**Example**
| Statement SQL | Redacted SQL |
| ----------------------------------- | ------------------------------------------ |
| `SELECT a, b FROM c` | `SELECT a, b FROM c` |
| `SELECT a, b FROM c WHERE id = '1'` | `SELECT a, b FROM c WHERE id = {REDACTED}` |
Primary key injection [#primary-key-injection]
Primary key injection connects SQL statements to record identifiers. It transparently ensures that any data access event includes the actual record identifiers. No need to instrument or change your SQL.
CipherStash Proxy uses the database schema to identify SQL statements that do not reference a primary key. It injects the missing primary keys into the SQL before execution. Primary keys of accessed records can then be tracked with the data access event.
The performance impact on the database is negligible as the primary key is by definition indexed, and the referenced tables are already present in the SQL statement.
When combined with [identity-aware encryption](https://cipherstash.com/docs/stack/cipherstash/encryption/identity), the events are also linked to client identity, providing an end-to-end view of data access.
Record reconciliation [#record-reconciliation]
Record reconciliation extracts the record identifiers, maps them to the appropriate tables, and includes them in the data access event payload sent to Audit.
Injected primary keys are always removed from the SQL results before being returned to the client. The process is internal to CipherStash Proxy. The format of the result set always matches the original query.
How it works together [#how-it-works-together]
These four features form a pipeline:
1. **Fingerprint**: identify the query pattern
2. **Redact**: strip sensitive values from the SQL statement
3. **Inject**: add primary key references to track which records are accessed
4. **Reconcile**: extract record identifiers and remove injected keys from results
The result is a complete data access event containing:
* **What query** was executed (fingerprint + redacted SQL)
* **Which records** were accessed (reconciled primary keys)
* **Who** executed it (when combined with identity-aware encryption)
* **When** it happened (timestamp)
All of this happens transparently within the proxy. Your application receives unmodified query results.
# Configuration
Source: https://cipherstash.com/docs/stack/cipherstash/proxy/configuration
Proxy configuration [#proxy-configuration]
CipherStash Proxy is available as a [container image](https://hub.docker.com/r/cipherstash/proxy) on Docker Hub. Deploy it locally, as a cloud sidecar, or as a standalone binary.
It speaks the PostgreSQL protocol (based on [pgcat](https://github.com/pgcat/pgcat)), meaning your application connects to Proxy exactly the same way it connects to PostgreSQL.
Installing Proxy [#installing-proxy]
The easiest way to start using CipherStash Proxy with your application is by adding a container to your application's `docker-compose.yml`:
```yaml
services:
app:
# Your app container config
db:
# Your Postgres container config
proxy:
image: cipherstash/proxy:latest
container_name: proxy
ports:
- 6432:6432
- 9930:9930
environment:
- CS_DATABASE__HOST=${CS_DATABASE__HOST}
- CS_DATABASE__PORT=${CS_DATABASE__PORT}
- CS_DATABASE__USERNAME=${CS_DATABASE__USERNAME}
- CS_DATABASE__PASSWORD=${CS_DATABASE__PASSWORD}
- CS_DATABASE__NAME=${CS_DATABASE__NAME}
- CS_WORKSPACE_CRN=${CS_WORKSPACE_CRN}
- CS_CLIENT_ACCESS_KEY=${CS_CLIENT_ACCESS_KEY}
- CS_DEFAULT_KEYSET_ID=${CS_DEFAULT_KEYSET_ID}
- CS_CLIENT_ID=${CS_CLIENT_ID}
- CS_CLIENT_KEY=${CS_CLIENT_KEY}
- CS_PROMETHEUS__ENABLED=${CS_PROMETHEUS__ENABLED:-true}
```
For a fully-working example, check out the [docker-compose.yml](https://github.com/cipherstash/proxy/blob/main/docker-compose.yml) in the Proxy repository.
Start the Proxy container:
```bash
docker compose up
```
Connect your PostgreSQL client to Proxy on TCP 6432.
Prometheus metrics are exposed on port 9930. Read more about them in the [reference documentation](https://cipherstash.com/docs/stack/reference/proxy-reference#prometheus-metrics).
Configuring Proxy [#configuring-proxy]
Unlike the Encryption SDK and Secrets SDK, CipherStash Proxy **always requires environment variables** because it runs as a separate process or container. It cannot use the host's device-based authentication.
For local development, create a client key and access key in the [Dashboard](https://dashboard.cipherstash.com) and set them in your `.env.proxy.docker` file.
For production, see [Going to production](https://cipherstash.com/docs/stack/deploy/going-to-production) to set up application client key credentials.
To run, CipherStash Proxy needs to know:
* What port to run on
* How to connect to the target PostgreSQL database
* Secrets to authenticate to CipherStash
There are two ways to configure Proxy:
* **Environment variables** that Proxy looks up on startup
* **TOML file** (`cipherstash-proxy.toml`) that Proxy reads on startup
Configuration loading order:
1. If `cipherstash-proxy.toml` is present in the current working directory, Proxy reads its config from that file
2. If `cipherstash-proxy.toml` is not present, Proxy looks up environment variables
3. If **both** are present, Proxy uses the TOML file as the base and overrides with any environment variables that are set
See the [Proxy config reference](https://cipherstash.com/docs/stack/reference/proxy-reference) for all available options.
Setting up the database schema [#setting-up-the-database-schema]
Proxy uses [EQL](https://cipherstash.com/docs/stack/reference/eql-guide) to index and search encrypted data.
When you start the Proxy container, you can install EQL by setting the `CS_DATABASE__INSTALL_EQL` environment variable:
```bash
CS_DATABASE__INSTALL_EQL=true
```
This installs the version of EQL bundled with the Proxy container.
Using `CS_DATABASE__INSTALL_EQL` is only recommended for development environments.
Install EQL by running [the installation script](https://github.com/cipherstash/encrypt-query-language/releases) as a database migration in production environments.
Check the installed EQL version:
```sql
SELECT eql_v2.version();
```
Creating encrypted columns [#creating-encrypted-columns]
When storing encrypted data in PostgreSQL with Proxy, you use the `eql_v2_encrypted` column type provided by EQL.
Create a table with an encrypted column:
```sql
CREATE TABLE users (
id SERIAL PRIMARY KEY,
email eql_v2_encrypted
);
```
Adding encrypted indexes [#adding-encrypted-indexes]
Encrypted columns cannot be searched without an encrypted index. The indexes you define determine what kind of searches you can perform.
Add a `unique` index for exact match queries:
```sql
SELECT eql_v2.add_search_config(
'users',
'email',
'unique',
'text'
);
```
Add `match` and `ore` indexes for pattern matching and ordering:
```sql
SELECT eql_v2.add_search_config(
'users',
'email',
'match',
'text'
);
SELECT eql_v2.add_search_config(
'users',
'email',
'ore',
'text'
);
```
Adding, updating, or deleting encrypted indexes on columns that already contain encrypted data will not re-index that data. To use the new indexes, you must `SELECT` the data out of the column and `UPDATE` it again.
To learn about encrypted indexes for other data types (`text`, `int`, `boolean`, `date`, `jsonb`), see the [EQL documentation](https://github.com/cipherstash/encrypt-query-language/tree/main/docs).
Encrypting existing data [#encrypting-existing-data]
CipherStash Proxy includes an `encrypt` CLI tool to encrypt existing data, or to apply index changes after changes to the encryption configuration.
See the [CLI reference](https://cipherstash.com/docs/stack/reference/proxy-reference#cli-reference) for usage details.
Reference [#reference]
See the [CipherStash Proxy reference](https://cipherstash.com/docs/stack/reference/proxy-reference) for all available options.
# Encrypt tool
Source: https://cipherstash.com/docs/stack/cipherstash/proxy/encrypt-tool
CipherStash Proxy includes an `encrypt` tool, a CLI application to encrypt existing plaintext data or apply index changes after updating the encryption configuration of a protected database.
Usage [#usage]
Encrypt data from a `source` column into a specified encrypted `target` column. The tool connects to CipherStash Proxy using the `cipherstash.toml` configuration or environment variables.
```bash
cipherstash-proxy encrypt [OPTIONS] --table --columns ...
```
How it works [#how-it-works]
The process for encrypting a column is:
1. Add a new encrypted destination column with the appropriate encryption configuration.
2. Use CipherStash Proxy to process the migration:
1. Select from the original plaintext column.
2. Update the encrypted column with the plaintext value.
3. Drop the original plaintext column.
4. Rename the encrypted column to the original plaintext column name.
The `encrypt` tool automates this process. Updates run in batches of 100 records (configurable via `--batch-size`). The process is idempotent and can be run repeatedly.
Configuration options [#configuration-options]
| Option | Description | Default |
| --------------------- | -------------------------------------------------------------- | -------- |
| `-t`, `--table` | Specifies the table to migrate | Required |
| `-c`, `--columns` | List of columns to migrate (space-delimited `key=value` pairs) | Required |
| `-k`, `--primary-key` | List of primary key columns (space-delimited) | `id` |
| `-b`, `--batch-size` | Number of records to process at once | `100` |
| `-d`, `--dry-run` | Loads data but does not perform updates | Optional |
| `-v`, `--verbose` | Turns on additional logging output | Optional |
| `-h`, `--help` | Displays help message | — |
Examples [#examples]
These examples assume a running CipherStash Proxy instance and a `users` table with:
* `id`: the primary key column
* `email`: the source plaintext column
* `encrypted_email`: the destination column configured for encrypted text
Encrypt a column [#encrypt-a-column]
```bash
cipherstash-proxy encrypt --table users --columns email=encrypted_email
```
Specify a primary key column [#specify-a-primary-key-column]
```bash
cipherstash-proxy encrypt --table users --columns email=encrypted_email --primary-key user_id
```
Compound primary key [#compound-primary-key]
```bash
cipherstash-proxy encrypt --table users --columns email=encrypted_email --primary-key user_id tenant_id
```
# Getting started with Proxy
Source: https://cipherstash.com/docs/stack/cipherstash/proxy/getting-started
Clone the repo [#clone-the-repo]
Start by cloning the [Proxy repo](https://github.com/cipherstash/proxy):
```bash
git clone https://github.com/cipherstash/proxy
cd proxy
```
Set up credentials [#set-up-credentials]
Complete the [Getting started](https://cipherstash.com/docs/stack/quickstart) guide first to initialize CipherStash on your device.
CipherStash Proxy runs inside a Docker container, so it cannot use the host's device-based authentication directly.
For local development, create a client key in the [CipherStash Dashboard](https://dashboard.cipherstash.com) and save the credentials to `.env.proxy.docker`:
```ini filename=".env.proxy.docker"
CS_WORKSPACE_CRN=
CS_CLIENT_ID=
CS_CLIENT_KEY=
CS_CLIENT_ACCESS_KEY=
```
You can find your workspace CRN in **Settings** for your workspace. Create a client key under **Clients** and an access key under **Access Keys**.
Do not commit `.env.proxy.docker` to version control. Add it to your `.gitignore`.
For production Proxy deployments, see [Going to production](https://cipherstash.com/docs/stack/deploy/going-to-production) to set up application client key credentials.
Start the containers [#start-the-containers]
```bash
docker compose up
```
This starts a PostgreSQL database on `localhost:5432` and CipherStash Proxy on `localhost:6432`.
The repo includes an example `users` table for inserting and querying encrypted data.
This example uses email, date of birth, and salary to represent sensitive data worth encrypting.
Insert and read some data [#insert-and-read-some-data]
Connect to the Proxy via `psql` and run some queries:
```bash
docker compose exec proxy psql postgres://cipherstash:3ncryp7@localhost:6432/cipherstash
```
This establishes an interactive session with the database, via CipherStash Proxy.
Insert and read some data via Proxy:
```sql
INSERT INTO users (encrypted_email, encrypted_dob, encrypted_salary)
VALUES ('alice@cipherstash.com', '1970-01-01', '100');
SELECT encrypted_email, encrypted_dob, encrypted_salary FROM users;
```
The `INSERT` inserts a record into the `users` table, and the `SELECT` reads the same record back.
Notice that it looks like nothing happened: the data in the `INSERT` was unencrypted, and the data in the `SELECT` is also unencrypted.
Now connect to the database directly via `psql` and see what the data actually looks like:
```bash
docker compose exec proxy psql postgres://cipherstash:3ncryp7@postgres:5432/cipherstash
```
Query the database directly:
```sql
SELECT encrypted_email, encrypted_dob, encrypted_salary FROM users;
```
The output is significantly larger because the `SELECT` returns the raw encrypted data.
The data is transparently encrypted and decrypted by Proxy.
Update data with a WHERE clause [#update-data-with-a-where-clause]
In your `psql` connection to Proxy, update the data and read it back:
```sql
UPDATE users SET encrypted_dob = '1978-02-01'
WHERE encrypted_email = 'alice@cipherstash.com';
SELECT encrypted_dob FROM users
WHERE encrypted_email = 'alice@cipherstash.com';
```
The `=` comparison operation in the `WHERE` clause is evaluated against **encrypted** data.
The `SELECT` returns `1978-02-01`.
Search encrypted data [#search-encrypted-data]
Insert more records via Proxy and search them:
```sql
INSERT INTO users (encrypted_email, encrypted_dob, encrypted_salary)
VALUES ('bob@cipherstash.com', '1991-03-06', '10');
INSERT INTO users (encrypted_email, encrypted_dob, encrypted_salary)
VALUES ('carol@cipherstash.com', '2005-12-30', '1000');
-- Range query on encrypted salary
SELECT encrypted_email, encrypted_dob, encrypted_salary
FROM users WHERE encrypted_salary <= 100;
-- Pattern match on encrypted email
SELECT encrypted_email, encrypted_dob, encrypted_salary
FROM users WHERE encrypted_email LIKE 'alice';
-- Range query on encrypted date
SELECT encrypted_email, encrypted_dob, encrypted_salary
FROM users WHERE encrypted_dob > '2000-01-01';
```
All comparison operations are evaluated against **encrypted** data. The literal values are transparently encrypted by Proxy before being compared in the database.
CipherStash Proxy provides:
* Completely transparent encryption of sensitive data in PostgreSQL
* All data remains searchable, protected with non-deterministic AES-256-GCM-SIV encryption
* Zero changes required to your application's database queries
# /PROXY
Source: https://cipherstash.com/docs/stack/cipherstash/proxy
Transparent, searchable encryption for your existing PostgreSQL database. No application code changes. Connect through the proxy. Your data is encrypted at the field level. Your queries still work.
What you get [#what-you-get]
1. **Zero code changes.** Configure encryption for specific tables and columns. Your SQL stays the same.
2. **Queries over ciphertext.** Equality, comparison, ordering, grouping over encrypted values.
3. **Written in Rust.** High performance, strongly-typed mapping of SQL statements.
4. **Backed by ZeroKMS.** Up to 14x the performance of AWS KMS.
5. **Prometheus built in.** Production monitoring out of the box.
6. **Runs in a container** or as a standalone CLI tool.
CipherStash Proxy uses the [Encrypt Query Language (EQL)](https://cipherstash.com/docs/stack/reference/eql-guide) to index and search encrypted data.
When to use Proxy vs SDK [#when-to-use-proxy-vs-sdk]
| | CipherStash Proxy | Encryption SDK |
| ---------------- | ---------------------------------------------------------- | ----------------------------------------------------- |
| **Best for** | DevOps teams adding encryption to existing PostgreSQL apps | Engineering teams building new applications |
| **Code changes** | Zero. Drop-in replacement for your database connection. | Application-level integration with schema definitions |
| **Setup** | Docker container, configure env vars | npm install, define schemas, integrate into app |
| **Control** | Automatic, table/column configuration | Fine-grained, per-field control |
Next steps [#next-steps]
# Message flow
Source: https://cipherstash.com/docs/stack/cipherstash/proxy/message-flow
This page explains the internal message handling flow for advanced users debugging unmappable statements or unexpected proxy behaviour. CipherStash Proxy sits between your application and PostgreSQL and intercepts the PostgreSQL extended query protocol. It encrypts parameters before they reach the database and decrypts values before they reach your application.
Extended query protocol overview [#extended-query-protocol-overview]
The PostgreSQL extended query protocol uses a sequence of messages to execute parameterised queries. The two most relevant messages for encryption are:
* **Parse**: the client sends a SQL statement with parameter placeholders (`$1`, `$2`, ...). Proxy inspects the statement and maps column references to their encryption config.
* **Bind**: the client sends parameter values to bind to a prepared statement. If Proxy recognised the statement during Parse, it encrypts the parameters here before forwarding them.
Parse flow [#parse-flow]
When Proxy receives a Parse message, it determines whether the SQL statement references encrypted columns.
1. Proxy checks whether the statement is encryptable (i.e., it references at least one column with an active encryption config).
2. If it is encryptable, Proxy maps the column references to their encryption configuration.
3. If the statement includes literal parameter values, Proxy rewrites them as encrypted values immediately.
4. Proxy adds the statement and its column config to the connection context for use during Bind.
5. Proxy forwards the (possibly rewritten) Parse message to PostgreSQL.
If the statement is not encryptable (no encrypted columns referenced), Proxy forwards it unchanged.
Bind flow [#bind-flow]
When Proxy receives a Bind message, it looks up the corresponding statement in the connection context.
1. Proxy checks whether the statement that this Bind message references is in the context (i.e., was processed during Parse).
2. If it is, Proxy encrypts each parameter value according to the column config mapped during Parse.
3. Proxy rewrites the parameter values in the Bind message with the encrypted payloads.
4. Proxy creates a portal for the bound statement and adds it to the context.
5. Proxy forwards the rewritten Bind message to PostgreSQL.
If the statement is not in context, Proxy creates a portal without encryption and forwards it unchanged.
Pipelining [#pipelining]
PostgreSQL supports pipelining: the client can send multiple messages without waiting for responses. Proxy must track Describe and Execute messages to correlate server responses with the right statements or portals, since responses arrive in order but may interleave.
```
Sequential Pipelined
| Client | Server | | Client | Server |
|----------------|-----------------| |----------------|-----------------|
| send query 1 | | | send query 1 | |
| | process query 1 | | send query 2 | process query 1 |
| receive rows 1 | | | send query 3 | process query 2 |
| send query 2 | | | receive rows 1 | process query 3 |
| | process query 2 | | receive rows 2 | |
| receive rows 2 | | | receive rows 3 | |
```
The PostgreSQL server always processes queries in sequential order, even when pipelined. Proxy preserves this ordering when encrypting parameters and decrypting results.
Unmappable statements [#unmappable-statements]
Some statements cannot be mapped to an encryption config. This happens when:
* The statement uses a function or expression that obscures the column reference (e.g., `CAST(email AS text)`)
* The column is referenced through a view, subquery, or CTE that Proxy cannot resolve
* The statement uses a SQL feature Proxy does not yet parse (e.g., certain `COPY` forms)
When a statement is unmappable, Proxy forwards it to PostgreSQL unmodified. No encryption or decryption occurs. The `cipherstash_proxy_statements_unmappable_total` Prometheus metric tracks how often this happens. Enable `CS_LOG__MAPPER_LEVEL=debug` to see which statements are unmappable and why.
Related reference [#related-reference]
* [Proxy configuration reference](https://cipherstash.com/docs/stack/reference/proxy-reference)
* [Proxy errors](https://cipherstash.com/docs/stack/reference/proxy-errors)
* [Prometheus metrics](https://cipherstash.com/docs/stack/reference/proxy-reference#prometheus-metrics)
# Multitenant operation
Source: https://cipherstash.com/docs/stack/cipherstash/proxy/multitenant
import { Callout } from "fumadocs-ui/components/callout";
Multitenant operation [#multitenant-operation]
CipherStash Proxy supports multitenant applications using ZeroKMS keysets to provide strong cryptographic separation between tenants.
In multitenant operation, each tenant is associated with a keyset. Data is protected by separate encryption keys. You can scope a proxy connection to a specific keyset at runtime using the `SET CIPHERSTASH.KEYSET` SQL commands:
* `SET CIPHERSTASH.KEYSET_ID`
* `SET CIPHERSTASH.KEYSET_NAME`
Once a keyset is set for a connection, all subsequent operations are scoped to that keyset. Data can only be decrypted by the same keyset that encrypted it.
A keyset `name` is unique to a workspace and functions as an alias. Using a keyset name lets you associate a keyset with an arbitrary identifier such as an internal `TenantId`.
The proxy must be configured without a `DEFAULT_KEYSET_ID` to enable multitenant operation and use of the `SET KEYSET` commands.
Keyset commands [#keyset-commands]
SET CIPHERSTASH.KEYSET_ID [#set-cipherstashkeyset_id]
Sets the active keyset for the current connection using a keyset UUID.
```sql
SET CIPHERSTASH.KEYSET_ID = '';
```
Example:
```sql
SET CIPHERSTASH.KEYSET_ID = '2cace9db-3a2a-4b46-a184-ba412b3e0730';
```
SET CIPHERSTASH.KEYSET_NAME [#set-cipherstashkeyset_name]
Sets the active keyset for the current connection using a keyset name.
```sql
SET CIPHERSTASH.KEYSET_NAME = '';
```
Example:
```sql
SET CIPHERSTASH.KEYSET_NAME = 'tenant-1';
```
Usage notes [#usage-notes]
* Execute `SET CIPHERSTASH.KEYSET` before performing any encryption operations.
* The keyset remains active for the duration of the connection, or until a subsequent `SET CIPHERSTASH.KEYSET` command.
* If a default keyset is configured in the proxy, these commands return an error.
* The active keyset is connection-scoped and does not affect other connections.
Do not use `SET CIPHERSTASH.KEYSET_ID` or `SET CIPHERSTASH.KEYSET_NAME` behind a transaction-mode connection pooler that sits in front of Proxy. The keyset belongs to the Proxy connection, not to your transaction. The pooler can run a later transaction on a Proxy connection with a different keyset. Run the pooler behind Proxy (PgBouncer 1.21 or later with `max_prepared_statements` set), or use session mode. A table of supported topologies is coming (CIP-4167).
***
Disabling encrypted mapping [#disabling-encrypted-mapping]
CipherStash Proxy transforms the plaintext SQL statements your application issues into statements on EQL columns. This process is called encrypted mapping.
In some circumstances you may need to disable encrypted mapping for one or more SQL statements. For example, performing a data transformation with complex logic directly in the database using `plpgsql`.
Use the `SET` command to change the `CIPHERSTASH.UNSAFE_DISABLE_MAPPING` configuration parameter. The parameter is always scoped to the connection session.
If mapping is disabled, sensitive data may not be encrypted and may appear in
logs.
CipherStash Proxy and EQL provide some protection against writing or reading plaintext from encrypted columns. Always use `eql_v2.add_encrypted_constraint(table, column)` when defining encrypted columns to prevent plaintext data from being written. Unmapped `SELECT` statements return the encrypted payload. If the constraint is applied, unmapped `INSERT` and `UPDATE` statements return a PostgreSQL type error.
Disable mapping [#disable-mapping]
```sql
SET CIPHERSTASH.UNSAFE_DISABLE_MAPPING = true;
```
Enable mapping [#enable-mapping]
```sql
SET CIPHERSTASH.UNSAFE_DISABLE_MAPPING = false;
```
Prepared statements and mapping [#prepared-statements-and-mapping]
CipherStash Proxy only decrypts data from SQL statements it has explicitly checked and mapped.
If mapping is disabled, any subsequent `PREPARE` skips the mapping process. If mapping is re-enabled later, returned data from those prepared statements is not decrypted.
To enable mapping, encryption, and decryption of prepared statements, either:
* Open a new connection, or
* Prepare the statement again after re-enabling mapping.
This behaviour is expected. When a client prepares a statement, it sends the SQL in a `parse` message. Once prepared, the client refers to the statement by name and skips the `parse` step. If mapping is disabled during `parse`, the proxy does not map the statement. Data returned from subsequent executions is never decrypted, even if mapping is re-enabled later.
# Searchable JSON functions and operators
Source: https://cipherstash.com/docs/stack/cipherstash/proxy/searchable-json
CipherStash Proxy supports a subset of PostgreSQL's JSONB functions and operators for use with encrypted columns. This page covers the supported operators, functions, and configuration required to enable searchable JSON.
Setup [#setup]
Schema [#schema]
Create a table with an `eql_v2_encrypted` column to store encrypted JSONB data:
```sql
CREATE TABLE cipherstash (
id SERIAL PRIMARY KEY,
encrypted_jsonb eql_v2_encrypted
);
```
Encrypted column configuration [#encrypted-column-configuration]
Add a `ste_vec` search index to the encrypted column:
```sql
SELECT eql_v2.add_search_config(
'cipherstash',
'encrypted_jsonb',
'ste_vec',
'jsonb',
'{"prefix": "cipherstash/encrypted_jsonb"}'
);
```
JSONB literals in `INSERT` and `UPDATE` statements work directly without explicit `::jsonb` type casts. The proxy infers the JSONB type from the target column.
Configuration options [#configuration-options]
The `ste_vec` index configuration accepts the following options:
| Option | Type | Default | Description |
| ------------------ | ---------------- | ---------- | ----------------------------------------------------------------- |
| `prefix` | string | (required) | Unique prefix for the index, typically `table/column` |
| `term_filters` | array | `[]` | Filters applied to indexed terms (e.g., `[{"kind": "downcase"}]`) |
| `array_index_mode` | string or object | `"all"` | Controls which array selectors are generated during indexing |
Array index mode [#array-index-mode]
The `array_index_mode` option controls which array selectors are generated during indexing.
Preset string values:
* `"all"` (default): Generates all selector types. Backwards compatible.
* `"none"`: Disables array indexing entirely.
Use the object form for fine-grained control:
```json
{
"item": true,
"wildcard": true,
"position": false
}
```
| Selector | JSONPath | Description |
| ---------- | ------------------ | ------------------------------------------------------------------ |
| `item` | `[@]` | EQL array element selector for functions like `jsonb_array_length` |
| `wildcard` | `[*]` | Standard JSONPath wildcard for iterating array elements |
| `position` | `[0]`, `[1]`, etc. | Positional access to specific array indices |
Enable all array selectors:
```sql
SELECT eql_v2.add_search_config(
'cipherstash',
'encrypted_jsonb',
'ste_vec',
'jsonb',
'{"prefix": "cipherstash/encrypted_jsonb", "array_index_mode": "all"}'
);
```
Disable positional indexing while keeping wildcard and item selectors:
```sql
SELECT eql_v2.add_search_config(
'events',
'payload',
'ste_vec',
'jsonb',
'{"prefix": "events/payload", "array_index_mode": {"item": true, "wildcard": true, "position": false}}'
);
```
Limitations [#limitations]
Encrypted literals cannot be passed as arguments to SQL functions. Encrypted columns can only be passed to SQL functions if the value has an encrypted search index that supports that specific function. For example, `AVG()` cannot be used on encrypted numeric values, `LOWER()` cannot be used on encrypted text, and `MIN()`/`MAX()` require an ORE index.
`CAST` operations cannot work on encrypted data. Casting requires decryption within the database, which the proxy does not support.
The `->` operator cannot be chained on `ste_vec` encrypted columns. Use `jsonb_path_query_first()` for deep nested access instead.
A selector path to an array field (`$.array`) returns the decrypted array as a JSON literal. To access an encrypted array as a set of encrypted values (for use with functions like `jsonb_array_length`), use the EQL array element selector `[@]`.
Operators [#operators]
-> (Field access) [#--field-access]
Extracts a JSON object field by key.
```sql
SELECT encrypted_jsonb -> 'number' FROM cipherstash;
-- Returns: 1
SELECT encrypted_jsonb -> 'object' FROM cipherstash;
-- Returns: { "string": "world", "number": 99 }
SELECT encrypted_jsonb -> 'string_array' FROM cipherstash;
-- Returns: ["hello","world"]
```
->> (Field access as text) [#--field-access-as-text]
Currently an alias for `->`. The data is returned as the decrypted JSON literal rather than a text string (unlike the standard PostgreSQL operator). The returned value can be cast to any valid type in the client.
```sql
SELECT encrypted_jsonb ->> 'number' FROM cipherstash;
-- Returns: 1
```
@> (Contains) [#-contains]
Tests whether the left value contains the right path/value entries at the top level. Supports string fields, numeric fields, complete arrays, and nested objects.
```sql
SELECT encrypted_jsonb @> '{"number": 1}' FROM cipherstash;
-- Returns: t
SELECT encrypted_jsonb @> '{"number": 99}' FROM cipherstash;
-- Returns: f
SELECT encrypted_jsonb @> '{"object": {"string": "world", "number": 99}}' FROM cipherstash;
-- Returns: t
```
<@ (Contained by) [#-contained-by]
Tests whether the left value is contained in the right value.
```sql
SELECT '{"number": 1}' <@ encrypted_jsonb FROM cipherstash;
-- Returns: t
```
Functions [#functions]
jsonb_path_query(target, path) [#jsonb_path_querytarget-path]
Returns all JSON items matched by the JSON path. Returns `setof eql_v2_encrypted` decrypted as `jsonb`.
```sql
SELECT jsonb_path_query(encrypted_jsonb, '$.number') FROM cipherstash;
-- Returns: 1
SELECT jsonb_path_query(encrypted_jsonb, '$.object') FROM cipherstash;
-- Returns: { "string": "world", "number": 99 }
SELECT jsonb_path_query(encrypted_jsonb, '$.object.string') FROM cipherstash;
-- Returns: "world"
SELECT jsonb_path_query(encrypted_jsonb, '$.string_array') FROM cipherstash;
-- Returns: ["hello","world"]
```
jsonb_path_query_first(target, path) [#jsonb_path_query_firsttarget-path]
Returns the first JSON item matched by the JSON path.
```sql
SELECT jsonb_path_query_first(encrypted_jsonb, '$.string_array[*]') FROM cipherstash;
-- Returns: "hello"
SELECT jsonb_path_query_first(encrypted_jsonb, '$.numeric_array[*]') FROM cipherstash;
-- Returns: 1
```
jsonb_path_exists(target, path) [#jsonb_path_existstarget-path]
Checks whether the JSON path returns any item. Returns a boolean.
```sql
SELECT jsonb_path_exists(encrypted_jsonb, '$.number') FROM cipherstash;
-- Returns: t
SELECT jsonb_path_exists(encrypted_jsonb, '$.unknown') FROM cipherstash;
-- Returns: f
```
jsonb_array_elements(target) [#jsonb_array_elementstarget]
Expands the top-level JSON array into a set of values. Requires the EQL array element selector `[@]`.
```sql
SELECT jsonb_array_elements(jsonb_path_query(encrypted_jsonb, '$.string_array[@]')) FROM cipherstash;
-- Returns: "hello", "world" (2 rows)
SELECT jsonb_array_elements(jsonb_path_query(encrypted_jsonb, '$.numeric_array[@]')) FROM cipherstash;
-- Returns: 1, 2, 3, 4 (4 rows)
```
jsonb_array_length(target) [#jsonb_array_lengthtarget]
Returns the number of elements in the top-level JSON array. Requires the EQL array element selector `[@]`.
```sql
SELECT jsonb_array_length(jsonb_path_query(encrypted_jsonb, '$.string_array[@]')) FROM cipherstash;
-- Returns: 2
SELECT jsonb_array_length(jsonb_path_query(encrypted_jsonb, '$.numeric_array[@]')) FROM cipherstash;
-- Returns: 4
```
Comparison operators in WHERE clauses [#comparison-operators-in-where-clauses]
All standard comparison operators work with JSON field extraction:
```sql
-- Equality
SELECT encrypted_jsonb FROM cipherstash WHERE encrypted_jsonb -> 'string' = 'B';
SELECT encrypted_jsonb FROM cipherstash WHERE jsonb_path_query_first(encrypted_jsonb, '$.string') = 'B';
-- Greater than
SELECT encrypted_jsonb FROM cipherstash WHERE encrypted_jsonb -> 'number' > 4;
-- Less than
SELECT encrypted_jsonb FROM cipherstash WHERE encrypted_jsonb -> 'number' < 3;
-- Greater than or equal
SELECT encrypted_jsonb FROM cipherstash WHERE encrypted_jsonb -> 'number' >= 4;
-- Less than or equal
SELECT encrypted_jsonb FROM cipherstash WHERE encrypted_jsonb -> 'number' <= 3;
```
JSONPath syntax [#jsonpath-syntax]
| Syntax | Description |
| ---------------- | ------------------------------------------------------------ |
| `$.field` | Access a top-level field |
| `$.nested.field` | Access a nested field |
| `$.array[*]` | Wildcard selector for all array elements |
| `$.array[@]` | EQL array element selector for use with processing functions |
Parameterized queries [#parameterized-queries]
All functions and operators support parameterized queries:
```sql
SELECT encrypted_jsonb -> $1 FROM cipherstash;
SELECT jsonb_path_query(encrypted_jsonb, $1) FROM cipherstash;
SELECT encrypted_jsonb @> $1 FROM cipherstash;
```
Supported data types [#supported-data-types]
The `ste_vec` index supports strings, numbers, booleans, arrays, objects, and nested structures.
# Troubleshooting
Source: https://cipherstash.com/docs/stack/cipherstash/proxy/troubleshooting
Troubleshooting ZeroKMS connections [#troubleshooting-zerokms-connections]
Recommended log settings [#recommended-log-settings]
For a quick check on ZeroKMS latency and connection issues, set:
```bash
CS_LOG__ZEROKMS_LEVEL=debug
CS_LOG__ENCRYPT_LEVEL=debug
```
For a deeper investigation, also enable slow statement detection:
```bash
CS_LOG__ZEROKMS_LEVEL=trace
CS_LOG__SLOW_STATEMENTS=true
CS_LOG__SLOW_STATEMENT_MIN_DURATION_MS=500
CS_LOG__SLOW_DB_RESPONSE_MIN_DURATION_MS=50
```
What to look for in logs [#what-to-look-for-in-logs]
| Signal | Meaning |
| --------------------------------------------------------- | ---------------------------------------------------------------------------------------- |
| `Initializing ZeroKMS ScopedCipher (cache miss)` | A network call to ZeroKMS is about to happen. Frequent occurrences indicate cache churn. |
| `Connected to ZeroKMS` with high `init_duration_ms` | Slow cipher init. Healthy values are under 200ms. Values over 1s trigger a warning. |
| `Use cached ScopedCipher` | Cache hit (fast path, no network call). |
| `ScopedCipher evicted from cache` with `cause: Size` | Cache too small for workload. Increase `cipher_cache_size`. |
| `Error initializing ZeroKMS` with high `init_duration_ms` | Network timeout to ZeroKMS. |
| `Error initializing ZeroKMS` with low `init_duration_ms` | Credential or configuration error. |
Key metrics [#key-metrics]
Enable Prometheus with `CS_PROMETHEUS__ENABLED=true` and watch these metrics:
| Metric | Why |
| ------------------------------------------------------------------------------------------ | ------------------------------------------------------------- |
| `cipherstash_proxy_keyset_cipher_init_duration_seconds` | Distribution of ZeroKMS init times including network latency. |
| `cipherstash_proxy_keyset_cipher_cache_hits_total` / `cache_miss_total` | Cache hit ratio. Should be above 95% in steady state. |
| `cipherstash_proxy_statements_session_duration_seconds` minus `execution_duration_seconds` | Encryption overhead per statement. |
| `cipherstash_proxy_encryption_error_total` / `decryption_error_total` | Spikes indicate ZeroKMS connectivity issues. |
Useful PromQL queries [#useful-promql-queries]
```txt
# P99 cipher init latency
histogram_quantile(0.99, rate(cipherstash_proxy_keyset_cipher_init_duration_seconds_bucket[5m]))
# Cache hit ratio
rate(cipherstash_proxy_keyset_cipher_cache_hits_total[5m])
/ (rate(cipherstash_proxy_keyset_cipher_cache_hits_total[5m])
+ rate(cipherstash_proxy_keyset_cipher_cache_miss_total[5m]))
```
Quick checklist [#quick-checklist]
1. **Cache hit ratio low?** Tune `CS_SERVER__CIPHER_CACHE_SIZE` (default: 64) and `CS_SERVER__CIPHER_CACHE_TTL_SECONDS` (default: 3600).
2. **`init_duration_ms` above 1s?** Network latency to ZeroKMS. Check DNS, firewall rules, and regional proximity.
3. **Large gap between session and execution duration?** Overhead is in encrypt/decrypt, not the database.
4. **Frequent evictions?** Increase `cipher_cache_size` to match your workload's keyset count.
***
Slow statement logging [#slow-statement-logging]
CipherStash Proxy includes built-in slow statement logging for diagnosing performance issues.
Configuration [#configuration]
Enable slow statement logging via environment variables:
```bash
# Enable slow statement logging (required)
CS_LOG__SLOW_STATEMENTS=true
# Optional: Set minimum duration threshold (default: 2000ms)
CS_LOG__SLOW_STATEMENT_MIN_DURATION_MS=500
# Optional: Set log level (default: warn when enabled)
CS_LOG__SLOW_STATEMENTS_LEVEL=warn
# Recommended: Use structured logging for parsing
CS_LOG__FORMAT=structured
```
Slow statement log format [#slow-statement-log-format]
When a statement exceeds the threshold, the proxy logs a detailed breakdown:
```json filename="slow statement log entry"
{
"client_id": 1,
"duration_ms": 10500,
"statement_type": "INSERT",
"protocol": "extended",
"encrypted": true,
"encrypted_values_count": 3,
"param_bytes": 1024,
"query_fingerprint": "a1b2c3d4",
"keyset_id": "uuid",
"mapping_disabled": false,
"breakdown": {
"parse_ms": 5,
"encrypt_ms": 450,
"server_write_ms": 12,
"server_wait_ms": 9800,
"server_response_ms": 233
}
}
```
Query fingerprints [#query-fingerprints]
Query fingerprints are ephemeral and instance-local. Each proxy instance generates a unique random key at startup to compute `query_fingerprint` values. Fingerprints change when the proxy restarts and cannot be correlated across different proxy instances. This is intentional for security. Use fingerprints for correlation within a single proxy instance's runtime only.
Prometheus histogram labels [#prometheus-histogram-labels]
Duration histograms include labels for filtering:
* `statement_type`: `insert`, `update`, `delete`, `select`, `other`
* `protocol`: `simple`, `extended`
* `mapped`: `true`, `false`
* `multi_statement`: `true`, `false`
Example PromQL queries:
```txt
# Average INSERT duration
histogram_quantile(0.5, rate(cipherstash_proxy_statements_session_duration_seconds_bucket{statement_type="insert"}[5m]))
# Compare encrypted vs passthrough
histogram_quantile(0.99, rate(cipherstash_proxy_statements_session_duration_seconds_bucket{mapped="true"}[5m]))
```
ZeroKMS cipher init metric [#zerokms-cipher-init-metric]
`cipherstash_proxy_keyset_cipher_init_duration_seconds` measures time for cipher initialization including the ZeroKMS network call. High values indicate ZeroKMS connectivity issues.
Interpreting results [#interpreting-results]
| Symptom | Likely Cause |
| --------------------------- | ------------------------------------- |
| High `encrypt_ms` | ZeroKMS latency or large payload. |
| High `server_wait_ms` | Database latency. |
| High `cipher_init_duration` | ZeroKMS cold start or network issues. |
| High `parse_ms` | Complex SQL or schema lookup. |
# CipherStash vs AWS KMS
Source: https://cipherstash.com/docs/stack/reference/comparisons/aws-kms
Encrypting data should not require managing binary buffers, base64 encoding, key ARNs, or building custom search solutions. CipherStash Encryption eliminates these complexities with a developer-friendly API.
The simple truth: Encrypting a value [#the-simple-truth-encrypting-a-value]
Start with the most basic operation: encrypting a single value.
AWS KMS: Manual work required [#aws-kms-manual-work-required]
```typescript
import { KMSClient, EncryptCommand } from '@aws-sdk/client-kms';
const client = new KMSClient({ region: 'us-west-2' });
const keyId = 'arn:aws:kms:us-west-2:123456789012:key/abcd1234-efgh-5678-ijkl-9012mnopqrst';
async function encryptWithKMS(plaintext: string): Promise {
try {
const command = new EncryptCommand({
KeyId: keyId,
Plaintext: Buffer.from(plaintext),
});
const response = await client.send(command);
const ciphertext = response.CiphertextBlob;
const base64Ciphertext = Buffer.from(ciphertext).toString('base64');
return base64Ciphertext;
} catch (error) {
console.error('Error encrypting data:', error);
throw error;
}
}
const encrypted = await encryptWithKMS('secret@squirrel.example');
```
**What you're managing:** Key ARNs, binary buffer conversions, base64 encoding/decoding, manual error handling, region configuration, AWS credential setup.
CipherStash Encryption: One simple call [#cipherstash-encryption-one-simple-call]
```typescript
import { Encryption } from '@cipherstash/stack';
import { encryptedTable, encryptedColumn } from '@cipherstash/stack/schema';
const users = encryptedTable('users', {
email: encryptedColumn('email'),
});
const client = await Encryption({
schemas: [users],
});
const encryptResult = await client.encrypt(
'secret@squirrel.example',
{ column: users.email, table: users }
);
if (encryptResult.failure) {
throw new Error(encryptResult.failure.message);
}
const ciphertext = encryptResult.data;
```
**What you get:** No key management (handled by ZeroKMS), no binary conversions, no base64 encoding, type-safe error handling, JSON payload ready for storage, zero-knowledge encryption by default.
Decryption [#decryption]
AWS KMS [#aws-kms]
```typescript
async function decryptWithKMS(base64Ciphertext: string): Promise {
try {
const ciphertextBlob = Buffer.from(base64Ciphertext, 'base64');
const command = new DecryptCommand({ CiphertextBlob: ciphertextBlob });
const response = await client.send(command);
return Buffer.from(response.Plaintext).toString('utf-8');
} catch (error) {
console.error('Error decrypting data:', error);
throw error;
}
}
```
CipherStash Encryption [#cipherstash-encryption]
```typescript
const decryptResult = await client.decrypt(ciphertext);
if (decryptResult.failure) {
throw new Error(decryptResult.failure.message);
}
const plaintext = decryptResult.data;
```
Features that AWS KMS can't do without major custom work [#features-that-aws-kms-cant-do-without-major-custom-work]
1. Searchable encryption: Built-in vs impossible [#1-searchable-encryption-built-in-vs-impossible]
**AWS KMS** requires decrypting everything and searching in memory, storing plaintext indexes, or building a custom searchable encryption solution.
**CipherStash Encryption** has searchable encryption built-in:
```typescript
const users = encryptedTable('users', {
email: encryptedColumn('email')
.freeTextSearch()
.equality()
.orderAndRange(),
});
const searchTerms = await client.encryptQuery('secret', {
column: users.email,
table: users,
});
```
2. Identity-aware encryption: Built-in vs custom implementation [#2-identity-aware-encryption-built-in-vs-custom-implementation]
**AWS KMS** has no built-in support. You must implement custom logic with encryption context as a workaround.
**CipherStash Encryption** has built-in identity-aware encryption:
```typescript
import { Encryption, OidcFederationStrategy } from '@cipherstash/stack';
// Authenticate every ZeroKMS request as the signed-in user
const client = await Encryption({
schemas: [users],
config: {
authStrategy: OidcFederationStrategy.create(workspaceCrn, () => getUserJwt()),
},
});
// Bind the data key to the user's `sub` claim
const encryptResult = await client.encrypt(
'secret@squirrel.example',
{ column: users.email, table: users }
).withLockContext({ identityClaim: ['sub'] });
const decryptResult = await client.decrypt(ciphertext)
.withLockContext({ identityClaim: ['sub'] });
```
3. Bulk operations: Native API vs manual batching [#3-bulk-operations-native-api-vs-manual-batching]
**AWS KMS** has no bulk API. You must manually batch operations and handle rate limits.
**CipherStash Encryption** has native bulk encryption:
```typescript
const bulkPlaintexts = [
{ id: '1', plaintext: 'Alice' },
{ id: '2', plaintext: 'Bob' },
{ id: '3', plaintext: 'Charlie' },
];
const bulkResult = await client.bulkEncrypt(bulkPlaintexts, {
column: users.name,
table: users,
});
const encryptedMap = bulkResult.data;
```
Feature comparison [#feature-comparison]
| Feature | AWS KMS | CipherStash Encryption |
| ----------------------------- | -------------------------------------- | -------------------------------- |
| **Basic Encryption** | Requires manual buffer/base64 handling | One-line API, JSON payload |
| **Key Management** | You manage key ARNs | Zero-knowledge, automatic |
| **Searchable Encryption** | Not possible | Built-in for PostgreSQL |
| **Identity-Aware Encryption** | Custom implementation | Built-in `LockContext` |
| **Bulk Operations** | Manual batching | Native bulk API |
| **Error Handling** | Try/catch, manual types | Type-safe Result pattern |
| **Type Safety** | Manual typing | Full TypeScript inference |
| **Storage Format** | Binary (needs encoding) | JSON (database-ready) |
| **ORM Integration** | Manual integration | Built-in Drizzle support |
| **Zero-Knowledge** | AWS has key access | True zero-knowledge |
| **Setup Complexity** | Medium (AWS credentials, regions) | Low (just environment variables) |
Developer experience comparison [#developer-experience-comparison]
Error handling [#error-handling]
**AWS KMS:** Try/catch with manual error type checking:
```typescript
try {
const response = await client.send(command)
} catch (error) {
if (error.name === "AccessDeniedException") {
// Handle access denied
} else if (error.name === "InvalidKeyUsageException") {
// Handle invalid key usage
}
}
```
**CipherStash Encryption:** Type-safe Result pattern:
```typescript
const result = await client.encrypt(plaintext, options)
if (result.failure) {
switch (result.failure.type) {
case "EncryptionError":
// TypeScript knows this is an EncryptionError
break
case "ClientInitError":
// TypeScript knows this is a ClientInitError
break
}
}
```
Type safety [#type-safety]
**AWS KMS:** Manual typing with binary data handling:
```typescript
const plaintext: string = Buffer.from(response.Plaintext).toString("utf-8")
```
**CipherStash Encryption:** Full TypeScript inference:
```typescript
const plaintext = decryptResult.data // Type: string
```
Storage format [#storage-format]
**AWS KMS:** Binary data that needs encoding:
```typescript
// Returns Uint8Array, must encode for storage
const base64 = Buffer.from(ciphertext).toString("base64")
```
**CipherStash Encryption:** JSON payload ready for database:
```typescript
// Returns JSON payload ready for JSONB storage
const ciphertext = encryptResult.data
```
Complete workflow comparison [#complete-workflow-comparison]
AWS KMS: Full implementation [#aws-kms-full-implementation]
```typescript
import { KMSClient, EncryptCommand, DecryptCommand } from "@aws-sdk/client-kms"
const client = new KMSClient({ region: "us-west-2" })
const keyId = "arn:aws:kms:us-west-2:123456789012:key/abcd1234-efgh-5678-ijkl-9012mnopqrst"
async function encrypt(plaintext: string): Promise {
const command = new EncryptCommand({
KeyId: keyId,
Plaintext: Buffer.from(plaintext),
})
const response = await client.send(command)
return Buffer.from(response.CiphertextBlob).toString("base64")
}
async function decrypt(base64Ciphertext: string): Promise {
const command = new DecryptCommand({
CiphertextBlob: Buffer.from(base64Ciphertext, "base64"),
})
const response = await client.send(command)
return Buffer.from(response.Plaintext).toString("utf-8")
}
const encrypted = await encrypt("secret@squirrel.example")
const decrypted = await decrypt(encrypted)
```
\~25 lines for basic encrypt/decrypt. You manage: key ARNs, binary conversions, base64 encoding, error handling, AWS credentials, regions.
CipherStash Encryption: Full implementation [#cipherstash-encryption-full-implementation]
```typescript
import { Encryption } from "@cipherstash/stack"
import { encryptedTable, encryptedColumn } from "@cipherstash/stack/schema"
const users = encryptedTable("users", {
email: encryptedColumn("email"),
})
const client = await Encryption({ schemas: [users] })
const encryptResult = await client.encrypt("secret@squirrel.example", {
column: users.email,
table: users,
})
if (encryptResult.failure) {
throw new Error(encryptResult.failure.message)
}
const decryptResult = await client.decrypt(encryptResult.data)
```
\~20 lines including setup. `@cipherstash/stack` handles everything.
When to use each [#when-to-use-each]
Use AWS KMS when: [#use-aws-kms-when]
* You need encryption for AWS services (S3, EBS, etc.)
* You're encrypting infrastructure-level resources
* You don't need to search encrypted data
* You're comfortable with manual buffer/base64 handling
Use CipherStash Encryption when: [#use-cipherstash-encryption-when]
* You're building applications with databases
* You need to search encrypted data
* You want a developer-friendly API
* You need identity-aware encryption
* You want zero-knowledge key management
* You value type safety and developer experience
References [#references]
* [AWS KMS Documentation](https://docs.aws.amazon.com/kms/)
* [CipherStash Encryption Getting Started](https://cipherstash.com/docs/stack/quickstart)
* [CipherStash Schema Reference](https://cipherstash.com/docs/stack/cipherstash/encryption/schema)
* [Searchable Encryption Concepts](https://cipherstash.com/docs/stack/cipherstash/encryption/searchable-encryption)
# CipherStash vs Homomorphic Encryption
Source: https://cipherstash.com/docs/stack/reference/comparisons/fhe
CipherStash is often described — incorrectly — as "homomorphic encryption for databases." It isn't. CipherStash uses a **portfolio of specialised searchable-encryption schemes**, exposed through PostgreSQL via [EQL](https://cipherstash.com/docs/stack/reference/eql-guide), that are 5–6 orders of magnitude faster than today's best Fully Homomorphic Encryption (FHE) at the operations a real database actually runs.
This page explains the difference, with numbers.
TL;DR [#tldr]
| | Fully Homomorphic Encryption (FHE) | CipherStash searchable encryption |
| --------------------------------- | ---------------------------------------------------- | -------------------------------------------------------------------------------------------------- |
| **Goal** | Run *arbitrary* computation on ciphertext | Make the database operations a real workload runs (equality, match, range) practical on ciphertext |
| **Approach** | One general-purpose primitive | A portfolio of specialised primitives, one per query type |
| **Per-operation cost (Apple M2)** | \~150 ms equality, \~165 ms compare, \~11 ms encrypt | \~755 ns equality, \~755 ns compare, \~375 µs encrypt |
| **Speed-up vs TFHE** | 1× | \~200,000× equality, \~215,000× greater-than, \~29× encrypt |
| **Where it runs** | Specialised libraries, custom hardware proposals | Standard PostgreSQL with [EQL](https://cipherstash.com/docs/stack/reference/eql-guide) |
| **Production-ready today** | No — orders of magnitude too slow for OLTP | Yes — sub-ms exact match, low-ms range on million-row tables |
Benchmarks: [`github.com/cipherstash/tfhe-ore-bench`](https://github.com/cipherstash/tfhe-ore-bench) (Apple M2, single-threaded; TFHE compared against CipherStash ORE).
Why the conflation happens [#why-the-conflation-happens]
Both FHE and searchable encryption answer the question *"Can I do something useful with encrypted data without decrypting it first?"* That question, framed at a whiteboard, sounds like a single problem. So when people first see CipherStash they reach for the most well-known answer — homomorphic encryption — and the comparison sticks.
It's the wrong frame. FHE and searchable encryption sit on opposite ends of a generality / performance trade-off:
* **FHE** keeps a single ciphertext format and lets you run *any* circuit over it. The price is that even simple operations cost tens to hundreds of milliseconds per ciphertext, and the ciphertext blows up in size as you compose operations. It is a remarkable theoretical achievement and an active area of research; it is not yet practical for production databases.
* **Searchable encryption** is a family of primitives, each *purpose-built* for one class of operation. Equality has its own scheme. Substring containment has its own scheme. Range and ordering have their own scheme. Each is dramatically cheaper than FHE because each does much less.
CipherStash is squarely in the second camp. The reason it can deliver microsecond-class encrypted predicates while TFHE takes 150 ms is not that we found a faster FHE — it's that we don't need FHE at all.
Two cryptographic philosophies [#two-cryptographic-philosophies]
**FHE** stakes everything on a single universal cipher and the ability to run any circuit over it. The cost is tens to hundreds of milliseconds per operation.
**CipherStash** keeps a portfolio of specialised ciphers and picks the right one per query type. The cost is sub-microsecond per operation.
For workloads that are essentially "find rows where X, sort by Y" — i.e. the workload of every line-of-business application on the planet — the second philosophy is dramatically more efficient and equally rigorous, *provided* each scheme has a published, formally-bounded leakage profile. CipherStash's schemes do (see [Security architecture](https://cipherstash.com/docs/stack/reference/security-architecture)).
Performance — measured per-operation cost [#performance--measured-per-operation-cost]
Numbers below are from the open-source benchmark harness at [`github.com/cipherstash/tfhe-ore-bench`](https://github.com/cipherstash/tfhe-ore-bench). Single-threaded, Apple M2, comparing TFHE — a leading FHE library — against CipherStash's Order-Revealing Encryption (ORE) on the primitive operations a database executes per row.
| Operation | TFHE (FHE) | CipherStash ORE | Speed-up |
| --------------------------- | ---------- | --------------- | -------------- |
| Encrypt one value | \~11 ms | \~375 µs | \~29× |
| Equality (`a == b`) | \~150 ms | \~755 ns | **\~200,000×** |
| Greater-than (`a > b`) | \~162 ms | \~755 ns | **\~215,000×** |
| Less-than (`a < b`) | \~166 ms | \~755 ns | **\~220,000×** |
| Greater-or-equal (`a >= b`) | \~25 ms | \~131 ns | **\~190,000×** |
| Less-or-equal (`a <= b`) | \~30 ms | \~131 ns | **\~225,000×** |
The implication is straightforward: a single equality check at \~150 ms is already untenable per row. Multiplied across a million-row `WHERE` clause, FHE is impossible; the same predicate in CipherStash runs in microseconds end-to-end and rides standard PostgreSQL B-tree, hash and GIN indexes.
> **Good to know**: FHE's selling point is that it can compute *anything*. CipherStash deliberately doesn't try to. We bet — correctly, for database workloads — that the long tail of "interesting" computation a database performs collapses to a small set of well-defined operations, and that specialised schemes for those operations beat a universal one by five or six orders of magnitude.
The CipherStash scheme portfolio [#the-cipherstash-scheme-portfolio]
In practice, only the 3–5 sensitive columns per table use these schemes. Foreign keys, timestamps, status flags and most other columns remain plaintext and behave exactly as they always have. That is what makes the portfolio approach tractable in real deployments.
| Scheme | Used for | Mechanism | Leakage profile |
| ------------------------------ | ---------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **HMAC-SHA-256** | Exact equality (`=`, joins, unique indexes) | Keyed hash — equal plaintexts produce equal tags; distinct plaintexts are indistinguishable. | Equality only. Pair with `UNIQUE` to eliminate frequency on repeated values. |
| **Encrypted Bloom filter** | Token / substring containment (`LIKE`, full-text) | Trigram tokens hashed into a fixed-size bit vector; queried via GIN containment with client-side false-positive filtering. | Tuneable false-positive rate doubles as a security knob — higher FPR obscures token-frequency patterns at the cost of more client-side filtering. |
| **Block ORE — Lewi-Wu (2016)** | Range and ordering (`<`, `>`, `BETWEEN`, `ORDER BY`) | Two-component ciphertexts (left / right). Right ciphertexts are stored; left ciphertexts are query-time only. Comparison is performed via the Postgres operator class. | Semantically-secure right-ciphertexts. Because left ciphertexts are not stored, **static order is not leaked** — only the order revealed by the queries you actually run. |
Underlying every encrypted value, AES-256-GCM-SIV provides the authenticated encryption used for retrieval. The schemes above are *searchable indexes* alongside the ciphertext, not replacements for it. The database stores `ciphertext + indexes`; the application receives plaintext only after key-bound decryption.
For full leakage definitions and parameter-selection guidance, see [Security architecture](https://cipherstash.com/docs/stack/reference/security-architecture).
What gets encrypted, and what doesn't [#what-gets-encrypted-and-what-doesnt]
A common misconception is that "encrypted database" means every column is opaque. In reality:
* **Sensitive columns are encrypted.** Names, emails, phone numbers, financial values, health attributes, free-text notes — typically 3–5 columns per sensitive table.
* **Everything else stays plaintext.** Surrogate primary keys, foreign keys, timestamps, enums, status flags, soft-delete markers, audit columns. They behave normally — indexed normally, joined normally, replicated normally.
* **Joins usually happen on plaintext.** Foreign keys are not normally sensitive; the join keys are plaintext, and join performance is unchanged. Where a join *does* need to happen on a sensitive value, an HMAC index makes it efficient.
This single fact reframes most operational concerns about encrypted databases. The encrypted columns are an addition to your schema, not a replacement for it.
Where plaintext actually lives [#where-plaintext-actually-lives]
With the [Encryption SDK](https://cipherstash.com/docs/stack/cipherstash/encryption), plaintext exists only inside your client application, edge worker, or browser. The PostgreSQL database, the network between you and it, any logical-replication consumer, and any Postgres-aware tooling (pgAdmin, query logs, backups, debug snapshots) see only ciphertext and searchable indexes.
This matters because most production data exposure happens *outside* the database — in proxies, replicas, BI tools, debug logs, error-reporting systems. With the SDK pattern, those surfaces never see plaintext to begin with.
> **Good to know**: CipherStash also offers a server-side [Proxy](https://cipherstash.com/docs/stack/cipherstash/proxy) for drop-in adoption with no code changes. Proxy and SDK are different deployment shapes of the same primitives; the SDK pattern gives you the strongest end-to-end guarantee.
EQL — open source, pluggable, extensible [#eql--open-source-pluggable-extensible]
All of this is implemented as **EQL — Encrypt Query Language**, an open-source set of PostgreSQL types, operators, and functions ([github.com/cipherstash/encrypt-query-language](https://github.com/cipherstash/encrypt-query-language)). EQL exposes the encrypted operators as standard SQL on the `eql_v2_encrypted` type:
* HMAC-backed equality for `=`, joins, and unique constraints
* Bloom-filter–backed substring match for `LIKE` / `ILIKE`
* ORE-backed comparisons for `<`, `>`, `BETWEEN`, and `ORDER BY`
Because every encrypted predicate is just standard SQL on an `eql_v2_encrypted` column, your application SQL stays standard SQL. Your ORM, your query builder, your DBA's `EXPLAIN ANALYZE` workflow, your migration tooling — all of it keeps working.
Two architectural consequences are worth calling out:
**Schemes are swappable.** A column's index can be re-keyed or migrated to a different scheme without changing application SQL. As stronger primitives mature — lattice-based searchable schemes, structured encryption variants, eventually practical FHE for specific operations — they slot in behind the same EQL surface.
**Quantum-resistant by construction.** The current primitives (AES-256-GCM-SIV, HMAC-SHA-256, BLAKE3) avoid the cryptographic assumptions known to fall to a sufficiently large quantum computer. No RSA, no elliptic curves. A column encrypted today is still secure on the day post-quantum migration becomes urgent.
What this looks like in SQL [#what-this-looks-like-in-sql]
Encrypted columns participate in standard SQL — the `eql_v2_encrypted` type and its operators do the heavy lifting:
```sql title="encrypted-queries.sql"
-- Exact equality (HMAC index)
SELECT id, name
FROM users
WHERE email = $1::eql_v2_encrypted;
-- Token / substring match (Bloom filter)
SELECT id, name
FROM users
WHERE name LIKE $1::eql_v2_encrypted
LIMIT 10;
-- Range query (ORE)
SELECT id, amount
FROM transactions
WHERE amount > $1::eql_v2_encrypted
ORDER BY amount
LIMIT 100;
-- Join on a plaintext foreign key (unchanged)
SELECT u.id, t.amount
FROM users u
JOIN transactions t ON t.user_id = u.id
WHERE u.email = $1::eql_v2_encrypted;
```
In each case, `$1` is a CipherCell produced by the SDK — the application encrypts the search value with the same key as the stored data, and PostgreSQL compares the searchable encrypted metadata without ever seeing plaintext. See the [EQL guide](https://cipherstash.com/docs/stack/reference/eql-guide) for the full operator and function surface.
Operational FAQ [#operational-faq]
The questions a senior engineer typically asks before approving an encrypted-database rollout — answered directly.
Joins across encrypted columns? [#joins-across-encrypted-columns]
Supported, and effectively the same performance as plaintext. In practice the join key itself is rarely sensitive — joins happen on surrogate IDs or foreign keys, which stay plaintext. When a join *does* need to happen on a sensitive value (e.g. email), the HMAC index makes equality joins efficient.
MIN, MAX, COUNT? [#min-max-count]
`COUNT` works without modification on encrypted columns. `MIN` and `MAX` work over ORE-indexed columns. `SUM` and `AVG` of encrypted numerics are not supported by the current scheme portfolio — decrypt application-side or aggregate over a plaintext bucket column.
GROUP BY? [#group-by]
Supported on equality-indexed columns. By definition, grouping by an encrypted column reveals the histogram of distinct values to the query — that is the result the application asked for. If the histogram itself is sensitive, group on a coarser plaintext bucket column instead, or restrict who can run the query at the application layer.
Foreign keys, cascading deletes? [#foreign-keys-cascading-deletes]
Unchanged. Foreign keys are not normally encrypted; cascading deletes, referential integrity, and `ON DELETE` semantics work as they always have.
NULL, empty strings, collation? [#null-empty-strings-collation]
Preserved. Encrypted strings carry UTF-8 collation and Unicode normalization metadata so that ordering and equality remain consistent under encryption. NULL handling matches standard PostgreSQL semantics.
Logical replication, pg_dump / restore, read replicas? [#logical-replication-pg_dump--restore-read-replicas]
All supported. Encrypted values and indexes are stored as standard PostgreSQL `JSONB` — they replicate, dump, restore and stream to read replicas like any other column.
Backups and key recovery? [#backups-and-key-recovery]
Key IDs are stored alongside the ciphertext. On restore, the SDK derives the same per-record keys via [ZeroKMS](https://cipherstash.com/docs/stack/cipherstash/kms) using those IDs. There is no separate "key restore" step that has to be choreographed with the data restore — the references travel with the data.
Supabase RLS and PostgREST? [#supabase-rls-and-postgrest]
Both work. RLS policies execute against plaintext columns (typically authentication-related: `user_id`, `tenant_id`) just as they do today. PostgREST exposes encrypted columns as opaque values to clients, and the SDK handles encryption/decryption at the application boundary.
Schema migrations and re-keying? [#schema-migrations-and-re-keying]
A column's index can be re-keyed or migrated to a different scheme without changing application SQL. Online re-keying is supported via dual-write during the migration window.
Security & threat model [#security--threat-model]
Each scheme has a published, formally-bounded leakage profile:
* **HMAC-SHA-256**: equality only. Frequency leaks on repeated values; eliminated by `UNIQUE` constraints or by encrypting only high-cardinality columns.
* **Encrypted Bloom filter**: false-positive rate is a deliberate parameter; raising it obscures token-frequency patterns at the cost of additional client-side filtering. Repeated query analysis is bounded by the FPR.
* **Block ORE — Lewi-Wu (2016)**: semantically-secure right-ciphertexts. Left ciphertexts are query-time only and not stored, so an attacker reading the database at rest does **not** see static order — only the order revealed by the queries you actually choose to run.
The trust boundary in the recommended SDK deployment is your client application, edge worker, or browser. The PostgreSQL instance, the network, ZeroKMS, the operator running your Postgres, and any Postgres-aware tooling are all *outside* that boundary and never see plaintext.
For deeper analysis — formal definitions of each scheme's leakage function, parameter-selection guidance, and attack-model walk-throughs — see [Security architecture](https://cipherstash.com/docs/stack/reference/security-architecture). Full analysis is available on request under NDA.
When CipherStash isn't the right fit [#when-cipherstash-isnt-the-right-fit]
In the spirit of an honest comparison page:
* **You need general-purpose computation on ciphertext.** If your workload is "run arbitrary user-defined functions over encrypted data" — for example, evaluating an opaque ML model on encrypted inputs — searchable encryption is not the right tool. That is genuinely the FHE problem, and you should track the FHE literature.
* **The query patterns you care about aren't equality, match or range.** Searchable encryption schemes exist for many other operations (graph traversal, geometric proximity, regex), but CipherStash's portfolio today is targeted at the operations a typical OLTP / line-of-business workload runs. If your central workload is something else, [talk to us](https://cipherstash.com/contact) about what's possible.
* **You want every column encrypted with no plaintext metadata at all.** That is achievable but expensive, and almost always unnecessary. The right design encrypts the sensitive columns and leaves the rest of the schema in plaintext.
Get started [#get-started]
* **Benchmarks**: [`github.com/cipherstash/tfhe-ore-bench`](https://github.com/cipherstash/tfhe-ore-bench)
* **EQL on GitHub**: [`github.com/cipherstash/encrypt-query-language`](https://github.com/cipherstash/encrypt-query-language)
* **Encryption SDK quickstart**: [`/stack/quickstart`](https://cipherstash.com/docs/stack/quickstart)
* **Talk to us** about a specific workload: [cipherstash.com/contact](https://cipherstash.com/contact)
***
> **Bottom line**: CipherStash is *not* FHE and does not need to be. It is a portfolio of specialised, well-understood searchable-encryption schemes — HMAC for equality, encrypted Bloom filters for token match, Lewi-Wu Block ORE for range — exposed through [EQL](https://cipherstash.com/docs/stack/reference/eql-guide) on standard PostgreSQL. That is what makes it 5–6 orders of magnitude faster than TFHE at the operations a real workload runs, while keeping data encrypted end-to-end.
# Overview
Source: https://cipherstash.com/docs/stack/reference/comparisons
Side-by-side breakdowns of CipherStash against the approaches teams most commonly weigh it against. Each page focuses on the same questions: what does each tool actually do, what are the per-operation trade-offs, and where is each one the right fit.
Related [#related]
* [Use cases](https://cipherstash.com/docs/stack/reference/use-cases) — including a comparison against data vaults like Skyflow and VGS.
* [Security architecture](https://cipherstash.com/docs/stack/reference/security-architecture) — the cryptographic primitives behind every comparison on this page.
# Access keys
Source: https://cipherstash.com/docs/stack/cipherstash/kms/access-keys
Access keys are used to authenticate programmatic access to CipherStash [CTS](https://cipherstash.com/docs/stack/cipherstash/kms/cts) and [ZeroKMS](https://cipherstash.com/docs/stack/cipherstash/kms).
Access keys are primarily needed for **production and CI/CD** environments.
For local development, device-based authentication handles access automatically — no access keys required.
See [Getting started](https://cipherstash.com/docs/stack/quickstart) to set up device auth.
Creating an access key [#creating-an-access-key]
In the [CipherStash Dashboard](https://dashboard.cipherstash.com), you can create an access key by clicking the **Create access key** button in the [Access Keys](https://dashboard.cipherstash.com/workspaces/_/access-keys) section for your workspace.
Roles [#roles]
Each access key is assigned a role that determines its permissions.
Use the role with the *least required privileges* and avoid higher privileges unless absolutely necessary.
Member [#member]
The member role is used for authenticating client keys for cryptographic operations.
These are the scopes that are available to the member role:
```text
keyset:list
data_key:generate
data_key:retrieve
```
Control [#control]
The control role is used for workspace automation tasks.
It has access to the CipherStash API endpoints for creating, listing, enabling, disabling, granting, modifying, and revoking keysets and client keys.
These are the scopes that are available to the control role:
```text
keyset:create
keyset:list
keyset:enable
keyset:disable
keyset:grant
keyset:modify
keyset:revoke
client:list
```
Admin [#admin]
In production environments, it is recommended to never use the admin role.
Use the member role for authenticating client keys, and the control role for workspace automation tasks.
The admin role is "god" mode.
It has access to all the CipherStash API endpoints and can authenticate client keys for cryptographic operations.
These are the scopes that are available to the admin role:
```text
keyset:create
keyset:list
keyset:enable
keyset:disable
keyset:grant
keyset:modify
keyset:revoke
data_key:generate
data_key:retrieve
client:create
client:list
client:delete
access_key:create
access_key:list
access_key:delete
```
# Client keys
Source: https://cipherstash.com/docs/stack/cipherstash/kms/clients
A client key is the cryptographic credential assigned to an instance of [CipherStash Proxy](https://cipherstash.com/docs/stack/cipherstash/proxy) or an application using an SDK like the [Encryption SDK](https://cipherstash.com/docs/stack/cipherstash/encryption). Each client key gets a unique ID and key pair, so you can revoke its access at any time.
Types of client keys [#types-of-client-keys]
CipherStash has two types of client keys:
Device-backed client keys [#device-backed-client-keys]
Device-backed client keys are created automatically when a developer runs `npx stash init`. They are tied to a specific developer's user account and device.
* Created automatically during initialization — no manual setup required
* Each developer gets their own unique client key
* Used for **local development only**
* Access can be revoked per developer without affecting other team members
Application client keys [#application-client-keys]
Application client keys are created manually in the Dashboard for production, CI/CD, and other non-interactive environments.
* No device attached — identified solely by `CS_CLIENT_ID` and `CS_CLIENT_KEY`
* Used for **production and CI/CD** where there is no interactive login
* Credentials are set via environment variables
See [Going to production](https://cipherstash.com/docs/stack/deploy/going-to-production) for a guide to creating application client keys.
Client keys and keysets [#client-keys-and-keysets]
When created, each client key is associated with a [keyset](https://cipherstash.com/docs/stack/cipherstash/kms/keysets). This allows the client key to perform encryption and decryption operations within the keyset.
Granting access to additional keysets [#granting-access-to-additional-keysets]
When creating a new client key, you can associate it with one or more keysets to grant access to the encrypted data in those keysets.
Revoking access to a client key [#revoking-access-to-a-client-key]
At any time, you can revoke access to a client key by removing the association with the keysets. This prohibits that client key from accessing the encrypted data in those keysets.
Creating a client key [#creating-a-client-key]
Automatic (local development) [#automatic-local-development]
Run `npx stash init` to create a device-backed client key automatically. See [Getting started](https://cipherstash.com/docs/stack/quickstart).
Manual (production) [#manual-production]
In the [CipherStash Dashboard](https://dashboard.cipherstash.com), you can create an application client key by clicking the **Create a new client** button in the [Clients](https://dashboard.cipherstash.com/workspaces/_/clients) page.
# Configuration
Source: https://cipherstash.com/docs/stack/cipherstash/kms/configuration
KMS configuration [#kms-configuration]
Local development [#local-development]
For local development, ZeroKMS credentials are handled automatically by device-based authentication.
Run `npx stash init` to set up your device — see [Getting started](https://cipherstash.com/docs/stack/quickstart).
Production credentials [#production-credentials]
In production and CI/CD environments, ZeroKMS is configured through the same credentials used by the Encryption SDK. The `CS_WORKSPACE_CRN` identifies your workspace in CRN format (e.g., `crn:ap-southeast-2.aws:your-workspace-id`).
For the full configuration reference (environment variables, programmatic config, and logging), see [Encryption SDK configuration](https://cipherstash.com/docs/stack/cipherstash/encryption/configuration).
The following credentials are required for production:
* **Workspace CRN:** identifies your workspace and region
* **Client ID:** identifies your application client key
* **Client key:** your half of the [dual-party key split](https://cipherstash.com/docs/stack/reference/security-architecture#key-hierarchy)
* **Access key:** API key for authenticating with CipherStash
See [Going to production](https://cipherstash.com/docs/stack/deploy/going-to-production) for a step-by-step guide to generating these credentials.
Keysets [#keysets]
To use a specific keyset for multi-tenant isolation, pass the `keyset` option:
```typescript filename="keyset-config.ts"
const client = await Encryption({
schemas: [users],
config: {
keyset: { name: "tenant-a" },
},
})
```
See [Keysets](https://cipherstash.com/docs/stack/cipherstash/kms/keysets) for more details on multi-tenant key isolation.
# CipherStash Token Service (CTS)
Source: https://cipherstash.com/docs/stack/cipherstash/kms/cts
CipherStash Token Service (CTS) is an authentication and identity federation service.
CTS issues tokens that grant client keys access to [ZeroKMS](https://cipherstash.com/docs/stack/cipherstash/kms).
That access is temporary, limited, and can be granularly scoped.
If you are familiar with the [AWS Security Token Service](https://docs.aws.amazon.com/STS/latest/APIReference/welcome.html) (AWS STS), CTS fulfills a similar role to that.
How it works [#how-it-works]
At a high level:
* Client keys authenticate to CTS
* CTS issues temporary tokens to those authenticated client keys
* Those temporary tokens can be used to make requests to ZeroKMS
A client key can be held by either [CipherStash Proxy](https://cipherstash.com/docs/stack/cipherstash/proxy) or an application using the [Encryption SDK](https://cipherstash.com/docs/stack/cipherstash/encryption).
Tokens [#tokens]
Client keys can authenticate to CTS via either:
* [Federating with an IDP](#federation)
* [Access keys](#access-keys)
Temporary tokens are valid for a maximum of 15 minutes.
Federation [#federation]
Federation allows you to use an existing source of identities to authenticate to CTS, and onwards to ZeroKMS.
This allows you to rapidly grant and revoke people's access based on your product or organisation's onboarding and offboarding processes.
By default, CTS federates with CipherStash Cloud's IDP.
Bringing your own Identity Provider (IDP) [#bringing-your-own-identity-provider-idp]
If you want to bring your own [IDP](https://cipherstash.com/docs/stack/reference/glossary#idp-identity-provider) to CTS, you can configure your workspace to use [Auth0](https://auth0.com/), [Okta](https://okta.com/), [Clerk](https://clerk.com/), or [Supabase](https://supabase.com/).
You can add and manage OIDC providers from your workspace settings in the [CipherStash Dashboard](https://dashboard.cipherstash.com).
Access keys [#access-keys]
[Access keys](https://cipherstash.com/docs/stack/cipherstash/kms/access-keys) are a persistent credential you can use for application-to-service access to CTS.
You can create access keys in the [CipherStash Dashboard](https://dashboard.cipherstash.com).
# Disaster recovery
Source: https://cipherstash.com/docs/stack/cipherstash/kms/disaster-recovery
ZeroKMS is designed to protect your encrypted data with robust disaster recovery capabilities. Your encrypted data remains recoverable even in the event of a complete service disruption.
Separation of keys and data [#separation-of-keys-and-data]
ZeroKMS uses a fundamental architectural principle: **your encrypted data stays in your database**. We only manage the key material needed to decrypt that data. This separation means:
* Your encrypted data is never stored in CipherStash infrastructure
* A CipherStash outage affects key access, not your data
* Recovery doesn't require migrating or restoring potentially terabytes of encrypted data
Key recovery process [#key-recovery-process]
ZeroKMS uses a hierarchical key structure that enables you to regenerate data keys on-demand without storing every individual key. This means:
* Key material is cryptographically reproducible
* No database of individual data keys needs to be restored
* Recovery time is measured in hours, not days
Zero data loss [#zero-data-loss]
In a disaster recovery scenario, no data loss occurs. All encrypted data remains intact and fully recoverable. The key material used to generate your data keys is preserved and can be regenerated.
Fast recovery in case of regional failure [#fast-recovery-in-case-of-regional-failure]
In the event of a complete regional failure, CipherStash can restore ZeroKMS service within a few hours. During this time:
* Your encrypted data remains safely stored in your database
* Applications cannot decrypt existing data or encrypt new data
* Once service is restored, all operations resume normally
What happens during a ZeroKMS outage? [#what-happens-during-a-zerokms-outage]
Data access during an outage [#data-access-during-an-outage]
**During a CipherStash outage, can we access our encrypted data?**
No. While ZeroKMS is unavailable, your applications cannot perform cryptographic operations (encrypt or decrypt). This is an intentional security design: cryptographic operations require active key management infrastructure.
**Is our encrypted data at risk?**
No. Your encrypted data remains safely stored in your own database. A CipherStash outage does not expose, corrupt, or delete your data.
After recovery [#after-recovery]
Once service is restored to a new region or infrastructure:
1. Your applications reconnect to the restored ZeroKMS endpoint
2. Key material is cryptographically regenerated
3. All encrypted data becomes accessible again
4. No data migration or reindexing is required
Architecture benefits [#architecture-benefits]
Compared to traditional approaches [#compared-to-traditional-approaches]
Many encryption and data protection solutions require storing both encrypted data and keys together in a "vault." During disaster recovery, these solutions must restore the entire vault, potentially terabytes of data, taking hours or days.
**ZeroKMS is different:**
* Only lightweight key material (megabytes) needs to be restored
* Your encrypted data never moves. It stays in your database.
* Recovery is based on cryptographic regeneration, not data restoration
Security during recovery [#security-during-recovery]
* Encrypted data in your database remains protected
* Key material is restored through cryptographically secure processes
* Access controls and audit logging resume immediately when service is restored
* No temporary "recovery windows" that might expose data
Questions? [#questions]
If you have specific disaster recovery requirements or need to discuss your resilience planning, please contact [support@cipherstash.com](mailto:support@cipherstash.com).
# ZeroKMS
Source: https://cipherstash.com/docs/stack/cipherstash/kms
ZeroKMS is the key management layer that powers [Encryption](https://cipherstash.com/docs/stack/cipherstash/encryption) and Secrets (coming soon). Every encrypted value gets its own unique key. Keys derived on demand, never stored. Identity and policy baked into every key.
100x faster than AWS KMS.
Zero-knowledge by design [#zero-knowledge-by-design]
Existing key management solutions reveal either data or keys to intermediaries. ZeroKMS uses proxy symmetric re-encryption (patent pending) on its authority key to produce a key seed, which it returns to the application. The application processes that seed with its own client key and derives the data key locally. Data keys are never seen by third parties, and never sent across the network. Neither is the client key.
How it works [#how-it-works]
* **Unique key per value:** Each encrypted field uses a distinct data encryption key, not a shared table-level key. The application requests a seed by key ID, which is what gives each data key its identity.
* **AWS KMS backed:** The authority key is encrypted at rest under an AWS KMS root key. No per-value data key is ever wrapped or stored.
* **Zero-knowledge:** CipherStash never sees your plaintext data, your client key, or an unwrapped data key. ZeroKMS returns a key seed; only your application can turn that seed into a data key, because only your application holds the client key.
* **Multi-tenant isolation:** Use keysets to isolate encryption keys per tenant, customer, or business unit.
* **Bulk operations:** ZeroKMS supports bulk encryption and decryption operations, enabling a unique data key per record without sacrificing performance.
* **Multi-region:** ZeroKMS is highly available and deployed in [multiple cloud regions globally](https://cipherstash.com/docs/stack/cipherstash/kms/regions). It can also be deployed within your own cloud account or on-prem.
Key Sets [#key-sets]
[Key Sets](https://cipherstash.com/docs/stack/cipherstash/kms/keysets) are ZeroKMS's core primitive for cryptographic isolation. A keyset is the unit of isolation. Data encrypted under one keyset cannot be decrypted with another.
Keysets are managed in the CipherStash Dashboard as a cloud primitive. How you use them is up to your architecture:
* **Tenant isolation**: one keyset per customer or business unit, giving per-tenant cryptographic boundaries with zero key management overhead. See [Encryption configuration](https://cipherstash.com/docs/stack/cipherstash/encryption/configuration#keysets).
* **Environment isolation**: separate keysets for production, staging, and development. Secrets (coming soon) maps its `environment` parameter to a keyset automatically.
* **Regional or compliance boundaries**: isolate data by jurisdiction or regulatory requirement.
* **Any boundary your application needs**: keysets are general-purpose. Combine them however your architecture requires.
Read the whitepaper [#read-the-whitepaper]
If you'd like to learn more about ZeroKMS, read the whitepaper on the [Trust Center](https://trust.cipherstash.com/resources).
Next steps [#next-steps]
# Keysets
Source: https://cipherstash.com/docs/stack/cipherstash/kms/keysets
Keysets are used, in combination with ZeroKMS key material, to derive unique data keys per record.
Each keyset maintains its own set of data encryption keys, so data encrypted under one keyset cannot be decrypted with another.
Key Sets are the foundational primitive that powers [multi-tenant encryption](https://cipherstash.com/docs/stack/cipherstash/encryption/configuration#keysets) in the Encryption SDK and environment isolation in Secrets (coming soon).
Default keyset [#default-keyset]
Each workspace has a default keyset, which is used to derive data keys for all records in the workspace and meets the needs for most use cases.
The default keyset is created automatically when you create a workspace.
You can create additional keysets to meet your specific needs.
When a developer runs `npx stash init`, their device-backed client key is automatically granted access to the default keyset. This means no additional configuration is needed for local development.
Create a client key with a keyset [#create-a-client-key-with-a-keyset]
By ID [#by-id]
```typescript
import { Encryption } from "@cipherstash/stack"
import { users } from "./schema"
const client = await Encryption({
schemas: [users],
config: {
keyset: { id: "123e4567-e89b-12d3-a456-426614174000" },
},
})
```
By name [#by-name]
```typescript
const client = await Encryption({
schemas: [users],
config: {
keyset: { name: "Company A" },
},
})
```
In Secrets (coming soon) [#in-secrets-coming-soon]
Secrets environments map directly to keysets. When you specify an `environment`, the Secrets SDK automatically uses the corresponding keyset for encryption and decryption.
How it works [#how-it-works]
When you specify a keyset, every key seed ZeroKMS returns is scoped to that keyset's authority key, so the data keys your application derives are scoped to it too.
This means:
* Data encrypted under keyset A cannot be decrypted with keyset B.
* You can rotate or revoke keys at the keyset level.
* Each tenant's data is cryptographically isolated from every other tenant.
Use cases [#use-cases]
* **Multi-tenant SaaS:** Give each customer their own keyset so their data is cryptographically separated. See [Encryption configuration](https://cipherstash.com/docs/stack/cipherstash/encryption/configuration#keysets).
* **Environment isolation:** Use different keysets for production, staging, and development. Secrets (coming soon) will manage these mappings automatically.
* **Compliance boundaries:** Isolate data by jurisdiction or regulatory requirement.
* **Custom isolation boundaries:** Key Sets are a general-purpose primitive. Use them for any cryptographic boundary your application needs: per-region, per-department, or per-feature.
Keysets and client keys [#keysets-and-client-keys]
Keysets can be associated with any number of client keys to grant each client key access to encryption and decryption operations on data in that keyset.
Granting access to a client key [#granting-access-to-a-client-key]
When creating a new keyset, you must choose which client keys will be granted access to the keyset.
You can manage this by clicking **Manage** on a particular keyset in the [Keysets](https://dashboard.cipherstash.com/workspaces/_/keysets) page of the [CipherStash Dashboard](https://dashboard.cipherstash.com).
Revoking access to a keyset [#revoking-access-to-a-keyset]
At any time, you can revoke access to a client key by removing the association with the keysets. This prohibits that client key from accessing the encrypted data in those keysets.
You can manage this by clicking **Manage** on a particular client key in the [Clients](https://dashboard.cipherstash.com/workspaces/_/clients) page of the [CipherStash Dashboard](https://dashboard.cipherstash.com).
Managing keysets [#managing-keysets]
Via the Dashboard [#via-the-dashboard]
In the [CipherStash Dashboard](https://dashboard.cipherstash.com), you can create a keyset by clicking the **Create Keyset** button in the [Keysets](https://dashboard.cipherstash.com/workspaces/_/keysets) page.
Via the API [#via-the-api]
To create a keyset via the API, follow these steps:
Step 1: Create an access key [#step-1-create-an-access-key]
First, create an access key in the [CipherStash Dashboard](https://dashboard.cipherstash.com) with the role of "Control".
Ensure you are using the access key with the "Control" role for workspace automation tasks.
These access keys only have access to the CipherStash API CRUD operations and are not able to authenticate cryptographic operations.
Step 2: Get a service token [#step-2-get-a-service-token]
Use your access key to get a service token:
```bash
curl https://ap-southeast-2.aws.auth.viturhosted.net/api/authorize \
-H "Content-Type: application/json" \
-d '{"accessKey": "your_access_key_set_with_control_role"}'
```
The response contains the access token and expiry information:
```json
{
"accessToken": "token_value",
"expiry": 1757529498
}
```
Step 3: Export the token [#step-3-export-the-token]
Export the access token as an environment variable:
```bash
export CTS_TOKEN="the_accessToken_from_previous_step"
```
Step 4: Create the keyset [#step-4-create-the-keyset]
Create a keyset using the service token (make sure your workspace is in ap-southeast-2 or update your endpoint):
```bash
curl https://ap-southeast-2.aws.viturhosted.net/create-keyset \
-H "Content-Type: application/json" \
-H "Authorization: Bearer $CTS_TOKEN" \
-d '{"name":"my_automated_keyset","description":"automated"}' -v
```
The response contains the ID of the created keyset:
```json
{
"id": "key_set_id",
"name": "my_key_set_name",
"description": "my_key_set_description"
}
```
Step 5: Grant access to a client key [#step-5-grant-access-to-a-client-key]
Grant access to a client key by granting access to the keyset.
You can find your client ID in the [CipherStash Dashboard](https://dashboard.cipherstash.com) on the [Clients](https://dashboard.cipherstash.com/workspaces/_/clients) page for your workspace.
```bash
curl https://ap-southeast-2.aws.viturhosted.net/grant-keyset \
-H "Content-Type: application/json" \
-H "Authorization: Bearer $CTS_TOKEN" \
-d '{"keyset_id":"key_set_id","client_id":"client_id_to_grant_access_to"}' -v
```
Returns HTTP 200 on success.
# OIDC Providers
Source: https://cipherstash.com/docs/stack/cipherstash/kms/oidc
OIDC Providers let you federate your existing identity provider (IdP) with CipherStash.
Once registered, end users can authenticate cryptographic operations using the identity tokens your IdP issues, not just application credentials.
This pairs with [identity-aware encryption](https://cipherstash.com/docs/reference/stack/api-reference) via `LockContext`, which binds encryption operations to a specific user identity.
If you are only encrypting data at rest with application credentials, you do not need an OIDC provider.
This feature is for workspaces where end-user identity should be bound to encryption operations.
Why this matters [#why-this-matters]
Without an OIDC provider, encryption operations are authenticated by [access keys](https://cipherstash.com/docs/stack/cipherstash/kms/access-keys) (long-lived, application-scoped) or PKCE device login (developer laptops).
With one, the identity token from your IdP can be bound to encryption and decryption operations — useful for per-user keys, audit trails, and identity-aware data access controls.
Supported providers [#supported-providers]
CipherStash supports the following identity providers:
* **Auth0**
* **Okta**
* **Clerk**
* **Supabase** — register from the dashboard setup hub or manually with the project issuer URL
Registering a provider [#registering-a-provider]
Go to your workspace in the [CipherStash Dashboard](https://dashboard.cipherstash.com/workspaces/_/oidc-providers) → **Authentication** → **OIDC Providers** → **Add OIDC Provider**.
Select your vendor and enter the **Issuer URL** — this is the OIDC discovery endpoint that issues identity tokens for your application. The URL format depends on your provider:
| Provider | Example issuer URL |
| -------- | ------------------------------------------ |
| Auth0 | `https://your-tenant.auth0.com/` |
| Okta | `https://your-org.okta.com/` |
| Clerk | `https://your-app.clerk.accounts.dev/` |
| Supabase | `https://{projectRef}.supabase.co/auth/v1` |
Submit the form. The provider is now registered for that workspace.
Supabase (from the dashboard) [#supabase-from-the-dashboard]
If you [connected Supabase in the dashboard](https://cipherstash.com/docs/stack/reference/dashboard-supabase-integration), open **Settings → Integrations → Supabase**, select your project, and click **Configure OIDC for this project**.
The dashboard registers vendor `supabase` with issuer `https://{projectRef}.supabase.co/auth/v1` for the selected project ref.
What gets stored [#what-gets-stored]
Each registered OIDC provider has three fields:
* **ID** — assigned by CipherStash on registration
* **Vendor** — one of `auth0`, `okta`, `clerk`, or `supabase`
* **Issuer** — the URL you provided
No client secret or shared key is stored. CipherStash validates tokens by fetching the JWKS from the issuer's discovery endpoint.
Using it from code [#using-it-from-code]
Once a provider is registered, use `LockContext` in the Encryption SDK to bind encryption operations to a user's identity token.
See the [Stack API reference](https://cipherstash.com/docs/reference/stack/api-reference) for the full `LockContext` API.
# Regions
Source: https://cipherstash.com/docs/stack/cipherstash/kms/regions
Each workspace is tied to a specific region and is deployed in that region's [ZeroKMS instance](https://cipherstash.com/docs/stack/cipherstash/kms).
Supported ZeroKMS regions [#supported-zerokms-regions]
ZeroKMS is deployed on AWS only. A region identifier forms part of your workspace CRN, for example `crn:ap-southeast-2.aws:your-workspace-id`.
Requesting a new region [#requesting-a-new-region]
If you need a region that is not listed above, please contact us at [support@cipherstash.com](mailto:support@cipherstash.com).
# EQL API Reference
Source: https://cipherstash.com/docs/stack/reference/eql
> **Latest Version:** 3.0.4
Complete API reference for the Encrypt Query Language (EQL) PostgreSQL extension.
Functions [#functions]
* [`>()`](#) - > operator for ORE block types
* [`ciphertext(jsonb)`](#ciphertextjsonb) - Extract ciphertext (c) from a raw jsonb encrypted value.
* [`eq(jsonb, eql_v3_integer_ord_ore)`](#eqjsonb-eql_v3_integer_ord_ore) - Operator wrapper for public.eql\_v3\_integer\_ord\_ore.
* [`eq(eql_v3_integer_ord_ore, jsonb)`](#eqeql_v3_integer_ord_ore-jsonb) - Operator wrapper for public.eql\_v3\_integer\_ord\_ore.
* [`eq(eql_v3_integer_ord_ore, eql_v3_integer_ord_ore)`](#eqeql_v3_integer_ord_ore-eql_v3_integer_ord_ore) - Operator wrapper for public.eql\_v3\_integer\_ord\_ore.
* [`eq(query_smallint_ord, eql_v3_smallint_ord)`](#eqquery_smallint_ord-eql_v3_smallint_ord) - Operator wrapper for eql\_v3.query\_smallint\_ord.
* [`eq(eql_v3_smallint_ord, query_smallint_ord)`](#eqeql_v3_smallint_ord-query_smallint_ord) - Operator wrapper for eql\_v3.query\_smallint\_ord.
* [`eq(jsonb, eql_v3_smallint_ord)`](#eqjsonb-eql_v3_smallint_ord) - Operator wrapper for public.eql\_v3\_smallint\_ord.
* [`eq(eql_v3_smallint_ord, jsonb)`](#eqeql_v3_smallint_ord-jsonb) - Operator wrapper for public.eql\_v3\_smallint\_ord.
* [`eq(eql_v3_smallint_ord, eql_v3_smallint_ord)`](#eqeql_v3_smallint_ord-eql_v3_smallint_ord) - Operator wrapper for public.eql\_v3\_smallint\_ord.
* [`eq(jsonb, eql_v3_date_ord)`](#eqjsonb-eql_v3_date_ord) - Operator wrapper for public.eql\_v3\_date\_ord.
* [`eq(eql_v3_date_ord, jsonb)`](#eqeql_v3_date_ord-jsonb) - Operator wrapper for public.eql\_v3\_date\_ord.
* [`eq(eql_v3_date_ord, eql_v3_date_ord)`](#eqeql_v3_date_ord-eql_v3_date_ord) - Operator wrapper for public.eql\_v3\_date\_ord.
* [`eq(query_real_ord, eql_v3_real_ord)`](#eqquery_real_ord-eql_v3_real_ord) - Operator wrapper for eql\_v3.query\_real\_ord.
* [`eq(eql_v3_real_ord, query_real_ord)`](#eqeql_v3_real_ord-query_real_ord) - Operator wrapper for eql\_v3.query\_real\_ord.
* [`eq(query_real_ord_ore, eql_v3_real_ord_ore)`](#eqquery_real_ord_ore-eql_v3_real_ord_ore) - Operator wrapper for eql\_v3.query\_real\_ord\_ore.
* [`eq(eql_v3_real_ord_ore, query_real_ord_ore)`](#eqeql_v3_real_ord_ore-query_real_ord_ore) - Operator wrapper for eql\_v3.query\_real\_ord\_ore.
* [`eq(jsonb, eql_v3_text_ord)`](#eqjsonb-eql_v3_text_ord) - Operator wrapper for public.eql\_v3\_text\_ord.
* [`eq(eql_v3_text_ord, jsonb)`](#eqeql_v3_text_ord-jsonb) - Operator wrapper for public.eql\_v3\_text\_ord.
* [`eq(eql_v3_text_ord, eql_v3_text_ord)`](#eqeql_v3_text_ord-eql_v3_text_ord) - Operator wrapper for public.eql\_v3\_text\_ord.
* [`eq(query_integer_ord_ope, eql_v3_integer_ord_ope)`](#eqquery_integer_ord_ope-eql_v3_integer_ord_ope) - Operator wrapper for eql\_v3.query\_integer\_ord\_ope.
* [`eq(eql_v3_integer_ord_ope, query_integer_ord_ope)`](#eqeql_v3_integer_ord_ope-query_integer_ord_ope) - Operator wrapper for eql\_v3.query\_integer\_ord\_ope.
* [`eq(query_text_ord, eql_v3_text_ord)`](#eqquery_text_ord-eql_v3_text_ord) - Operator wrapper for eql\_v3.query\_text\_ord.
* [`eq(eql_v3_text_ord, query_text_ord)`](#eqeql_v3_text_ord-query_text_ord) - Operator wrapper for eql\_v3.query\_text\_ord.
* [`eq(jsonb, eql_v3_timestamp_ord_ope)`](#eqjsonb-eql_v3_timestamp_ord_ope) - Operator wrapper for public.eql\_v3\_timestamp\_ord\_ope.
* [`eq(eql_v3_timestamp_ord_ope, jsonb)`](#eqeql_v3_timestamp_ord_ope-jsonb) - Operator wrapper for public.eql\_v3\_timestamp\_ord\_ope.
* [`eq(eql_v3_timestamp_ord_ope, eql_v3_timestamp_ord_ope)`](#eqeql_v3_timestamp_ord_ope-eql_v3_timestamp_ord_ope) - Operator wrapper for public.eql\_v3\_timestamp\_ord\_ope.
* [`eq(jsonb, eql_v3_integer_ord_ope)`](#eqjsonb-eql_v3_integer_ord_ope) - Operator wrapper for public.eql\_v3\_integer\_ord\_ope.
* [`eq(eql_v3_integer_ord_ope, jsonb)`](#eqeql_v3_integer_ord_ope-jsonb) - Operator wrapper for public.eql\_v3\_integer\_ord\_ope.
* [`eq(eql_v3_integer_ord_ope, eql_v3_integer_ord_ope)`](#eqeql_v3_integer_ord_ope-eql_v3_integer_ord_ope) - Operator wrapper for public.eql\_v3\_integer\_ord\_ope.
* [`eq(query_integer_ord, eql_v3_integer_ord)`](#eqquery_integer_ord-eql_v3_integer_ord) - Operator wrapper for eql\_v3.query\_integer\_ord.
* [`eq(eql_v3_integer_ord, query_integer_ord)`](#eqeql_v3_integer_ord-query_integer_ord) - Operator wrapper for eql\_v3.query\_integer\_ord.
* [`eq(query_text_search, eql_v3_text_search)`](#eqquery_text_search-eql_v3_text_search) - Operator wrapper for eql\_v3.query\_text\_search.
* [`eq(eql_v3_text_search, query_text_search)`](#eqeql_v3_text_search-query_text_search) - Operator wrapper for eql\_v3.query\_text\_search.
* [`eq(query_numeric_eq, eql_v3_numeric_eq)`](#eqquery_numeric_eq-eql_v3_numeric_eq) - Operator wrapper for eql\_v3.query\_numeric\_eq.
* [`eq(eql_v3_numeric_eq, query_numeric_eq)`](#eqeql_v3_numeric_eq-query_numeric_eq) - Operator wrapper for eql\_v3.query\_numeric\_eq.
* [`eq(jsonb, eql_v3_bigint_eq)`](#eqjsonb-eql_v3_bigint_eq) - Operator wrapper for public.eql\_v3\_bigint\_eq.
* [`eq(eql_v3_bigint_eq, jsonb)`](#eqeql_v3_bigint_eq-jsonb) - Operator wrapper for public.eql\_v3\_bigint\_eq.
* [`eq(eql_v3_bigint_eq, eql_v3_bigint_eq)`](#eqeql_v3_bigint_eq-eql_v3_bigint_eq) - Operator wrapper for public.eql\_v3\_bigint\_eq.
* [`eq(query_smallint_eq, eql_v3_smallint_eq)`](#eqquery_smallint_eq-eql_v3_smallint_eq) - Operator wrapper for eql\_v3.query\_smallint\_eq.
* [`eq(eql_v3_smallint_eq, query_smallint_eq)`](#eqeql_v3_smallint_eq-query_smallint_eq) - Operator wrapper for eql\_v3.query\_smallint\_eq.
* [`eq(jsonb, eql_v3_numeric_ord)`](#eqjsonb-eql_v3_numeric_ord) - Operator wrapper for public.eql\_v3\_numeric\_ord.
* [`eq(eql_v3_numeric_ord, jsonb)`](#eqeql_v3_numeric_ord-jsonb) - Operator wrapper for public.eql\_v3\_numeric\_ord.
* [`eq(eql_v3_numeric_ord, eql_v3_numeric_ord)`](#eqeql_v3_numeric_ord-eql_v3_numeric_ord) - Operator wrapper for public.eql\_v3\_numeric\_ord.
* [`eq(query_date_ord_ope, eql_v3_date_ord_ope)`](#eqquery_date_ord_ope-eql_v3_date_ord_ope) - Operator wrapper for eql\_v3.query\_date\_ord\_ope.
* [`eq(eql_v3_date_ord_ope, query_date_ord_ope)`](#eqeql_v3_date_ord_ope-query_date_ord_ope) - Operator wrapper for eql\_v3.query\_date\_ord\_ope.
* [`eq(query_timestamp_ord_ore, eql_v3_timestamp_ord_ore)`](#eqquery_timestamp_ord_ore-eql_v3_timestamp_ord_ore) - Operator wrapper for eql\_v3.query\_timestamp\_ord\_ore.
* [`eq(eql_v3_timestamp_ord_ore, query_timestamp_ord_ore)`](#eqeql_v3_timestamp_ord_ore-query_timestamp_ord_ore) - Operator wrapper for eql\_v3.query\_timestamp\_ord\_ore.
* [`eq(query_text_search_ore, eql_v3_text_search_ore)`](#eqquery_text_search_ore-eql_v3_text_search_ore) - Operator wrapper for eql\_v3.query\_text\_search\_ore.
* [`eq(eql_v3_text_search_ore, query_text_search_ore)`](#eqeql_v3_text_search_ore-query_text_search_ore) - Operator wrapper for eql\_v3.query\_text\_search\_ore.
* [`eq(query_text_ord_ore, eql_v3_text_ord_ore)`](#eqquery_text_ord_ore-eql_v3_text_ord_ore) - Operator wrapper for eql\_v3.query\_text\_ord\_ore.
* [`eq(eql_v3_text_ord_ore, query_text_ord_ore)`](#eqeql_v3_text_ord_ore-query_text_ord_ore) - Operator wrapper for eql\_v3.query\_text\_ord\_ore.
* [`eq(jsonb, eql_v3_timestamp_eq)`](#eqjsonb-eql_v3_timestamp_eq) - Operator wrapper for public.eql\_v3\_timestamp\_eq.
* [`eq(eql_v3_timestamp_eq, jsonb)`](#eqeql_v3_timestamp_eq-jsonb) - Operator wrapper for public.eql\_v3\_timestamp\_eq.
* [`eq(eql_v3_timestamp_eq, eql_v3_timestamp_eq)`](#eqeql_v3_timestamp_eq-eql_v3_timestamp_eq) - Operator wrapper for public.eql\_v3\_timestamp\_eq.
* [`eq(jsonb, eql_v3_real_ord_ope)`](#eqjsonb-eql_v3_real_ord_ope) - Operator wrapper for public.eql\_v3\_real\_ord\_ope.
* [`eq(eql_v3_real_ord_ope, jsonb)`](#eqeql_v3_real_ord_ope-jsonb) - Operator wrapper for public.eql\_v3\_real\_ord\_ope.
* [`eq(eql_v3_real_ord_ope, eql_v3_real_ord_ope)`](#eqeql_v3_real_ord_ope-eql_v3_real_ord_ope) - Operator wrapper for public.eql\_v3\_real\_ord\_ope.
* [`eq(jsonb, eql_v3_real_ord)`](#eqjsonb-eql_v3_real_ord) - Operator wrapper for public.eql\_v3\_real\_ord.
* [`eq(eql_v3_real_ord, jsonb)`](#eqeql_v3_real_ord-jsonb) - Operator wrapper for public.eql\_v3\_real\_ord.
* [`eq(eql_v3_real_ord, eql_v3_real_ord)`](#eqeql_v3_real_ord-eql_v3_real_ord) - Operator wrapper for public.eql\_v3\_real\_ord.
* [`eq(jsonb, eql_v3_integer_ord)`](#eqjsonb-eql_v3_integer_ord) - Operator wrapper for public.eql\_v3\_integer\_ord.
* [`eq(eql_v3_integer_ord, jsonb)`](#eqeql_v3_integer_ord-jsonb) - Operator wrapper for public.eql\_v3\_integer\_ord.
* [`eq(eql_v3_integer_ord, eql_v3_integer_ord)`](#eqeql_v3_integer_ord-eql_v3_integer_ord) - Operator wrapper for public.eql\_v3\_integer\_ord.
* [`eq(query_smallint_ord_ore, eql_v3_smallint_ord_ore)`](#eqquery_smallint_ord_ore-eql_v3_smallint_ord_ore) - Operator wrapper for eql\_v3.query\_smallint\_ord\_ore.
* [`eq(eql_v3_smallint_ord_ore, query_smallint_ord_ore)`](#eqeql_v3_smallint_ord_ore-query_smallint_ord_ore) - Operator wrapper for eql\_v3.query\_smallint\_ord\_ore.
* [`eq(jsonb, eql_v3_text_ord_ope)`](#eqjsonb-eql_v3_text_ord_ope) - Operator wrapper for public.eql\_v3\_text\_ord\_ope.
* [`eq(eql_v3_text_ord_ope, jsonb)`](#eqeql_v3_text_ord_ope-jsonb) - Operator wrapper for public.eql\_v3\_text\_ord\_ope.
* [`eq(eql_v3_text_ord_ope, eql_v3_text_ord_ope)`](#eqeql_v3_text_ord_ope-eql_v3_text_ord_ope) - Operator wrapper for public.eql\_v3\_text\_ord\_ope.
* [`eq(query_double_ord_ope, eql_v3_double_ord_ope)`](#eqquery_double_ord_ope-eql_v3_double_ord_ope) - Operator wrapper for eql\_v3.query\_double\_ord\_ope.
* [`eq(eql_v3_double_ord_ope, query_double_ord_ope)`](#eqeql_v3_double_ord_ope-query_double_ord_ope) - Operator wrapper for eql\_v3.query\_double\_ord\_ope.
* [`eq(query_integer_ord_ore, eql_v3_integer_ord_ore)`](#eqquery_integer_ord_ore-eql_v3_integer_ord_ore) - Operator wrapper for eql\_v3.query\_integer\_ord\_ore.
* [`eq(eql_v3_integer_ord_ore, query_integer_ord_ore)`](#eqeql_v3_integer_ord_ore-query_integer_ord_ore) - Operator wrapper for eql\_v3.query\_integer\_ord\_ore.
* [`eq(jsonb, eql_v3_real_eq)`](#eqjsonb-eql_v3_real_eq) - Operator wrapper for public.eql\_v3\_real\_eq.
* [`eq(eql_v3_real_eq, jsonb)`](#eqeql_v3_real_eq-jsonb) - Operator wrapper for public.eql\_v3\_real\_eq.
* [`eq(eql_v3_real_eq, eql_v3_real_eq)`](#eqeql_v3_real_eq-eql_v3_real_eq) - Operator wrapper for public.eql\_v3\_real\_eq.
* [`eq(query_text_eq, eql_v3_text_eq)`](#eqquery_text_eq-eql_v3_text_eq) - Operator wrapper for eql\_v3.query\_text\_eq.
* [`eq(eql_v3_text_eq, query_text_eq)`](#eqeql_v3_text_eq-query_text_eq) - Operator wrapper for eql\_v3.query\_text\_eq.
* [`eq(jsonb, eql_v3_bigint_ord_ore)`](#eqjsonb-eql_v3_bigint_ord_ore) - Operator wrapper for public.eql\_v3\_bigint\_ord\_ore.
* [`eq(eql_v3_bigint_ord_ore, jsonb)`](#eqeql_v3_bigint_ord_ore-jsonb) - Operator wrapper for public.eql\_v3\_bigint\_ord\_ore.
* [`eq(eql_v3_bigint_ord_ore, eql_v3_bigint_ord_ore)`](#eqeql_v3_bigint_ord_ore-eql_v3_bigint_ord_ore) - Operator wrapper for public.eql\_v3\_bigint\_ord\_ore.
* [`eq(query_date_ord, eql_v3_date_ord)`](#eqquery_date_ord-eql_v3_date_ord) - Operator wrapper for eql\_v3.query\_date\_ord.
* [`eq(eql_v3_date_ord, query_date_ord)`](#eqeql_v3_date_ord-query_date_ord) - Operator wrapper for eql\_v3.query\_date\_ord.
* [`eq(jsonb, eql_v3_double_eq)`](#eqjsonb-eql_v3_double_eq) - Operator wrapper for public.eql\_v3\_double\_eq.
* [`eq(eql_v3_double_eq, jsonb)`](#eqeql_v3_double_eq-jsonb) - Operator wrapper for public.eql\_v3\_double\_eq.
* [`eq(eql_v3_double_eq, eql_v3_double_eq)`](#eqeql_v3_double_eq-eql_v3_double_eq) - Operator wrapper for public.eql\_v3\_double\_eq.
* [`eq(jsonb, eql_v3_real_ord_ore)`](#eqjsonb-eql_v3_real_ord_ore) - Operator wrapper for public.eql\_v3\_real\_ord\_ore.
* [`eq(eql_v3_real_ord_ore, jsonb)`](#eqeql_v3_real_ord_ore-jsonb) - Operator wrapper for public.eql\_v3\_real\_ord\_ore.
* [`eq(eql_v3_real_ord_ore, eql_v3_real_ord_ore)`](#eqeql_v3_real_ord_ore-eql_v3_real_ord_ore) - Operator wrapper for public.eql\_v3\_real\_ord\_ore.
* [`eq(jsonb, eql_v3_numeric_ord_ore)`](#eqjsonb-eql_v3_numeric_ord_ore) - Operator wrapper for public.eql\_v3\_numeric\_ord\_ore.
* [`eq(eql_v3_numeric_ord_ore, jsonb)`](#eqeql_v3_numeric_ord_ore-jsonb) - Operator wrapper for public.eql\_v3\_numeric\_ord\_ore.
* [`eq(eql_v3_numeric_ord_ore, eql_v3_numeric_ord_ore)`](#eqeql_v3_numeric_ord_ore-eql_v3_numeric_ord_ore) - Operator wrapper for public.eql\_v3\_numeric\_ord\_ore.
* [`eq(query_double_eq, eql_v3_double_eq)`](#eqquery_double_eq-eql_v3_double_eq) - Operator wrapper for eql\_v3.query\_double\_eq.
* [`eq(eql_v3_double_eq, query_double_eq)`](#eqeql_v3_double_eq-query_double_eq) - Operator wrapper for eql\_v3.query\_double\_eq.
* [`eq(query_text_ord_ope, eql_v3_text_ord_ope)`](#eqquery_text_ord_ope-eql_v3_text_ord_ope) - Operator wrapper for eql\_v3.query\_text\_ord\_ope.
* [`eq(eql_v3_text_ord_ope, query_text_ord_ope)`](#eqeql_v3_text_ord_ope-query_text_ord_ope) - Operator wrapper for eql\_v3.query\_text\_ord\_ope.
* [`eq(jsonb, eql_v3_bigint_ord_ope)`](#eqjsonb-eql_v3_bigint_ord_ope) - Operator wrapper for public.eql\_v3\_bigint\_ord\_ope.
* [`eq(eql_v3_bigint_ord_ope, jsonb)`](#eqeql_v3_bigint_ord_ope-jsonb) - Operator wrapper for public.eql\_v3\_bigint\_ord\_ope.
* [`eq(eql_v3_bigint_ord_ope, eql_v3_bigint_ord_ope)`](#eqeql_v3_bigint_ord_ope-eql_v3_bigint_ord_ope) - Operator wrapper for public.eql\_v3\_bigint\_ord\_ope.
* [`eq(query_real_eq, eql_v3_real_eq)`](#eqquery_real_eq-eql_v3_real_eq) - Operator wrapper for eql\_v3.query\_real\_eq.
* [`eq(eql_v3_real_eq, query_real_eq)`](#eqeql_v3_real_eq-query_real_eq) - Operator wrapper for eql\_v3.query\_real\_eq.
* [`eq(jsonb, eql_v3_double_ord_ore)`](#eqjsonb-eql_v3_double_ord_ore) - Operator wrapper for public.eql\_v3\_double\_ord\_ore.
* [`eq(eql_v3_double_ord_ore, jsonb)`](#eqeql_v3_double_ord_ore-jsonb) - Operator wrapper for public.eql\_v3\_double\_ord\_ore.
* [`eq(eql_v3_double_ord_ore, eql_v3_double_ord_ore)`](#eqeql_v3_double_ord_ore-eql_v3_double_ord_ore) - Operator wrapper for public.eql\_v3\_double\_ord\_ore.
* [`eq(jsonb, eql_v3_bigint_ord)`](#eqjsonb-eql_v3_bigint_ord) - Operator wrapper for public.eql\_v3\_bigint\_ord.
* [`eq(eql_v3_bigint_ord, jsonb)`](#eqeql_v3_bigint_ord-jsonb) - Operator wrapper for public.eql\_v3\_bigint\_ord.
* [`eq(eql_v3_bigint_ord, eql_v3_bigint_ord)`](#eqeql_v3_bigint_ord-eql_v3_bigint_ord) - Operator wrapper for public.eql\_v3\_bigint\_ord.
* [`eq(query_timestamp_ord_ope, eql_v3_timestamp_ord_ope)`](#eqquery_timestamp_ord_ope-eql_v3_timestamp_ord_ope) - Operator wrapper for eql\_v3.query\_timestamp\_ord\_ope.
* [`eq(eql_v3_timestamp_ord_ope, query_timestamp_ord_ope)`](#eqeql_v3_timestamp_ord_ope-query_timestamp_ord_ope) - Operator wrapper for eql\_v3.query\_timestamp\_ord\_ope.
* [`eq(query_numeric_ord, eql_v3_numeric_ord)`](#eqquery_numeric_ord-eql_v3_numeric_ord) - Operator wrapper for eql\_v3.query\_numeric\_ord.
* [`eq(eql_v3_numeric_ord, query_numeric_ord)`](#eqeql_v3_numeric_ord-query_numeric_ord) - Operator wrapper for eql\_v3.query\_numeric\_ord.
* [`eq(jsonb, eql_v3_text_search_ore)`](#eqjsonb-eql_v3_text_search_ore) - Operator wrapper for public.eql\_v3\_text\_search\_ore.
* [`eq(eql_v3_text_search_ore, jsonb)`](#eqeql_v3_text_search_ore-jsonb) - Operator wrapper for public.eql\_v3\_text\_search\_ore.
* [`eq(eql_v3_text_search_ore, eql_v3_text_search_ore)`](#eqeql_v3_text_search_ore-eql_v3_text_search_ore) - Operator wrapper for public.eql\_v3\_text\_search\_ore.
* [`eq(query_bigint_eq, eql_v3_bigint_eq)`](#eqquery_bigint_eq-eql_v3_bigint_eq) - Operator wrapper for eql\_v3.query\_bigint\_eq.
* [`eq(eql_v3_bigint_eq, query_bigint_eq)`](#eqeql_v3_bigint_eq-query_bigint_eq) - Operator wrapper for eql\_v3.query\_bigint\_eq.
* [`eq(query_timestamp_eq, eql_v3_timestamp_eq)`](#eqquery_timestamp_eq-eql_v3_timestamp_eq) - Operator wrapper for eql\_v3.query\_timestamp\_eq.
* [`eq(eql_v3_timestamp_eq, query_timestamp_eq)`](#eqeql_v3_timestamp_eq-query_timestamp_eq) - Operator wrapper for eql\_v3.query\_timestamp\_eq.
* [`eq(query_real_ord_ope, eql_v3_real_ord_ope)`](#eqquery_real_ord_ope-eql_v3_real_ord_ope) - Operator wrapper for eql\_v3.query\_real\_ord\_ope.
* [`eq(eql_v3_real_ord_ope, query_real_ord_ope)`](#eqeql_v3_real_ord_ope-query_real_ord_ope) - Operator wrapper for eql\_v3.query\_real\_ord\_ope.
* [`eq(jsonb, eql_v3_numeric_eq)`](#eqjsonb-eql_v3_numeric_eq) - Operator wrapper for public.eql\_v3\_numeric\_eq.
* [`eq(eql_v3_numeric_eq, jsonb)`](#eqeql_v3_numeric_eq-jsonb) - Operator wrapper for public.eql\_v3\_numeric\_eq.
* [`eq(eql_v3_numeric_eq, eql_v3_numeric_eq)`](#eqeql_v3_numeric_eq-eql_v3_numeric_eq) - Operator wrapper for public.eql\_v3\_numeric\_eq.
* [`eq(jsonb, eql_v3_timestamp_ord)`](#eqjsonb-eql_v3_timestamp_ord) - Operator wrapper for public.eql\_v3\_timestamp\_ord.
* [`eq(eql_v3_timestamp_ord, jsonb)`](#eqeql_v3_timestamp_ord-jsonb) - Operator wrapper for public.eql\_v3\_timestamp\_ord.
* [`eq(eql_v3_timestamp_ord, eql_v3_timestamp_ord)`](#eqeql_v3_timestamp_ord-eql_v3_timestamp_ord) - Operator wrapper for public.eql\_v3\_timestamp\_ord.
* [`eq(jsonb, eql_v3_smallint_ord_ope)`](#eqjsonb-eql_v3_smallint_ord_ope) - Operator wrapper for public.eql\_v3\_smallint\_ord\_ope.
* [`eq(eql_v3_smallint_ord_ope, jsonb)`](#eqeql_v3_smallint_ord_ope-jsonb) - Operator wrapper for public.eql\_v3\_smallint\_ord\_ope.
* [`eq(eql_v3_smallint_ord_ope, eql_v3_smallint_ord_ope)`](#eqeql_v3_smallint_ord_ope-eql_v3_smallint_ord_ope) - Operator wrapper for public.eql\_v3\_smallint\_ord\_ope.
* [`eq(query_double_ord, eql_v3_double_ord)`](#eqquery_double_ord-eql_v3_double_ord) - Operator wrapper for eql\_v3.query\_double\_ord.
* [`eq(eql_v3_double_ord, query_double_ord)`](#eqeql_v3_double_ord-query_double_ord) - Operator wrapper for eql\_v3.query\_double\_ord.
* [`eq(query_date_eq, eql_v3_date_eq)`](#eqquery_date_eq-eql_v3_date_eq) - Operator wrapper for eql\_v3.query\_date\_eq.
* [`eq(eql_v3_date_eq, query_date_eq)`](#eqeql_v3_date_eq-query_date_eq) - Operator wrapper for eql\_v3.query\_date\_eq.
* [`eq(query_double_ord_ore, eql_v3_double_ord_ore)`](#eqquery_double_ord_ore-eql_v3_double_ord_ore) - Operator wrapper for eql\_v3.query\_double\_ord\_ore.
* [`eq(eql_v3_double_ord_ore, query_double_ord_ore)`](#eqeql_v3_double_ord_ore-query_double_ord_ore) - Operator wrapper for eql\_v3.query\_double\_ord\_ore.
* [`eq(jsonb, eql_v3_timestamp_ord_ore)`](#eqjsonb-eql_v3_timestamp_ord_ore) - Operator wrapper for public.eql\_v3\_timestamp\_ord\_ore.
* [`eq(eql_v3_timestamp_ord_ore, jsonb)`](#eqeql_v3_timestamp_ord_ore-jsonb) - Operator wrapper for public.eql\_v3\_timestamp\_ord\_ore.
* [`eq(eql_v3_timestamp_ord_ore, eql_v3_timestamp_ord_ore)`](#eqeql_v3_timestamp_ord_ore-eql_v3_timestamp_ord_ore) - Operator wrapper for public.eql\_v3\_timestamp\_ord\_ore.
* [`eq(jsonb, eql_v3_text_search)`](#eqjsonb-eql_v3_text_search) - Operator wrapper for public.eql\_v3\_text\_search.
* [`eq(eql_v3_text_search, jsonb)`](#eqeql_v3_text_search-jsonb) - Operator wrapper for public.eql\_v3\_text\_search.
* [`eq(eql_v3_text_search, eql_v3_text_search)`](#eqeql_v3_text_search-eql_v3_text_search) - Operator wrapper for public.eql\_v3\_text\_search.
* [`eq(query_numeric_ord_ore, eql_v3_numeric_ord_ore)`](#eqquery_numeric_ord_ore-eql_v3_numeric_ord_ore) - Operator wrapper for eql\_v3.query\_numeric\_ord\_ore.
* [`eq(eql_v3_numeric_ord_ore, query_numeric_ord_ore)`](#eqeql_v3_numeric_ord_ore-query_numeric_ord_ore) - Operator wrapper for eql\_v3.query\_numeric\_ord\_ore.
* [`eq(jsonb, eql_v3_smallint_eq)`](#eqjsonb-eql_v3_smallint_eq) - Operator wrapper for public.eql\_v3\_smallint\_eq.
* [`eq(eql_v3_smallint_eq, jsonb)`](#eqeql_v3_smallint_eq-jsonb) - Operator wrapper for public.eql\_v3\_smallint\_eq.
* [`eq(eql_v3_smallint_eq, eql_v3_smallint_eq)`](#eqeql_v3_smallint_eq-eql_v3_smallint_eq) - Operator wrapper for public.eql\_v3\_smallint\_eq.
* [`eq(query_bigint_ord_ore, eql_v3_bigint_ord_ore)`](#eqquery_bigint_ord_ore-eql_v3_bigint_ord_ore) - Operator wrapper for eql\_v3.query\_bigint\_ord\_ore.
* [`eq(eql_v3_bigint_ord_ore, query_bigint_ord_ore)`](#eqeql_v3_bigint_ord_ore-query_bigint_ord_ore) - Operator wrapper for eql\_v3.query\_bigint\_ord\_ore.
* [`eq(query_bigint_ord_ope, eql_v3_bigint_ord_ope)`](#eqquery_bigint_ord_ope-eql_v3_bigint_ord_ope) - Operator wrapper for eql\_v3.query\_bigint\_ord\_ope.
* [`eq(eql_v3_bigint_ord_ope, query_bigint_ord_ope)`](#eqeql_v3_bigint_ord_ope-query_bigint_ord_ope) - Operator wrapper for eql\_v3.query\_bigint\_ord\_ope.
* [`eq(query_date_ord_ore, eql_v3_date_ord_ore)`](#eqquery_date_ord_ore-eql_v3_date_ord_ore) - Operator wrapper for eql\_v3.query\_date\_ord\_ore.
* [`eq(eql_v3_date_ord_ore, query_date_ord_ore)`](#eqeql_v3_date_ord_ore-query_date_ord_ore) - Operator wrapper for eql\_v3.query\_date\_ord\_ore.
* [`eq(query_smallint_ord_ope, eql_v3_smallint_ord_ope)`](#eqquery_smallint_ord_ope-eql_v3_smallint_ord_ope) - Operator wrapper for eql\_v3.query\_smallint\_ord\_ope.
* [`eq(eql_v3_smallint_ord_ope, query_smallint_ord_ope)`](#eqeql_v3_smallint_ord_ope-query_smallint_ord_ope) - Operator wrapper for eql\_v3.query\_smallint\_ord\_ope.
* [`eq(jsonb, eql_v3_double_ord)`](#eqjsonb-eql_v3_double_ord) - Operator wrapper for public.eql\_v3\_double\_ord.
* [`eq(eql_v3_double_ord, jsonb)`](#eqeql_v3_double_ord-jsonb) - Operator wrapper for public.eql\_v3\_double\_ord.
* [`eq(eql_v3_double_ord, eql_v3_double_ord)`](#eqeql_v3_double_ord-eql_v3_double_ord) - Operator wrapper for public.eql\_v3\_double\_ord.
* [`eq(query_numeric_ord_ope, eql_v3_numeric_ord_ope)`](#eqquery_numeric_ord_ope-eql_v3_numeric_ord_ope) - Operator wrapper for eql\_v3.query\_numeric\_ord\_ope.
* [`eq(eql_v3_numeric_ord_ope, query_numeric_ord_ope)`](#eqeql_v3_numeric_ord_ope-query_numeric_ord_ope) - Operator wrapper for eql\_v3.query\_numeric\_ord\_ope.
* [`eq(jsonb, eql_v3_date_eq)`](#eqjsonb-eql_v3_date_eq) - Operator wrapper for public.eql\_v3\_date\_eq.
* [`eq(eql_v3_date_eq, jsonb)`](#eqeql_v3_date_eq-jsonb) - Operator wrapper for public.eql\_v3\_date\_eq.
* [`eq(eql_v3_date_eq, eql_v3_date_eq)`](#eqeql_v3_date_eq-eql_v3_date_eq) - Operator wrapper for public.eql\_v3\_date\_eq.
* [`eq(jsonb, eql_v3_double_ord_ope)`](#eqjsonb-eql_v3_double_ord_ope) - Operator wrapper for public.eql\_v3\_double\_ord\_ope.
* [`eq(eql_v3_double_ord_ope, jsonb)`](#eqeql_v3_double_ord_ope-jsonb) - Operator wrapper for public.eql\_v3\_double\_ord\_ope.
* [`eq(eql_v3_double_ord_ope, eql_v3_double_ord_ope)`](#eqeql_v3_double_ord_ope-eql_v3_double_ord_ope) - Operator wrapper for public.eql\_v3\_double\_ord\_ope.
* [`eq(jsonb, eql_v3_numeric_ord_ope)`](#eqjsonb-eql_v3_numeric_ord_ope) - Operator wrapper for public.eql\_v3\_numeric\_ord\_ope.
* [`eq(eql_v3_numeric_ord_ope, jsonb)`](#eqeql_v3_numeric_ord_ope-jsonb) - Operator wrapper for public.eql\_v3\_numeric\_ord\_ope.
* [`eq(eql_v3_numeric_ord_ope, eql_v3_numeric_ord_ope)`](#eqeql_v3_numeric_ord_ope-eql_v3_numeric_ord_ope) - Operator wrapper for public.eql\_v3\_numeric\_ord\_ope.
* [`eq(jsonb, eql_v3_date_ord_ore)`](#eqjsonb-eql_v3_date_ord_ore) - Operator wrapper for public.eql\_v3\_date\_ord\_ore.
* [`eq(eql_v3_date_ord_ore, jsonb)`](#eqeql_v3_date_ord_ore-jsonb) - Operator wrapper for public.eql\_v3\_date\_ord\_ore.
* [`eq(eql_v3_date_ord_ore, eql_v3_date_ord_ore)`](#eqeql_v3_date_ord_ore-eql_v3_date_ord_ore) - Operator wrapper for public.eql\_v3\_date\_ord\_ore.
* [`eq(query_timestamp_ord, eql_v3_timestamp_ord)`](#eqquery_timestamp_ord-eql_v3_timestamp_ord) - Operator wrapper for eql\_v3.query\_timestamp\_ord.
* [`eq(eql_v3_timestamp_ord, query_timestamp_ord)`](#eqeql_v3_timestamp_ord-query_timestamp_ord) - Operator wrapper for eql\_v3.query\_timestamp\_ord.
* [`eq(jsonb, eql_v3_text_eq)`](#eqjsonb-eql_v3_text_eq) - Operator wrapper for public.eql\_v3\_text\_eq.
* [`eq(eql_v3_text_eq, jsonb)`](#eqeql_v3_text_eq-jsonb) - Operator wrapper for public.eql\_v3\_text\_eq.
* [`eq(eql_v3_text_eq, eql_v3_text_eq)`](#eqeql_v3_text_eq-eql_v3_text_eq) - Operator wrapper for public.eql\_v3\_text\_eq.
* [`eq(jsonb, eql_v3_integer_eq)`](#eqjsonb-eql_v3_integer_eq) - Operator wrapper for public.eql\_v3\_integer\_eq.
* [`eq(eql_v3_integer_eq, jsonb)`](#eqeql_v3_integer_eq-jsonb) - Operator wrapper for public.eql\_v3\_integer\_eq.
* [`eq(eql_v3_integer_eq, eql_v3_integer_eq)`](#eqeql_v3_integer_eq-eql_v3_integer_eq) - Operator wrapper for public.eql\_v3\_integer\_eq.
* [`eq(query_integer_eq, eql_v3_integer_eq)`](#eqquery_integer_eq-eql_v3_integer_eq) - Operator wrapper for eql\_v3.query\_integer\_eq.
* [`eq(eql_v3_integer_eq, query_integer_eq)`](#eqeql_v3_integer_eq-query_integer_eq) - Operator wrapper for eql\_v3.query\_integer\_eq.
* [`eq(jsonb, eql_v3_smallint_ord_ore)`](#eqjsonb-eql_v3_smallint_ord_ore) - Operator wrapper for public.eql\_v3\_smallint\_ord\_ore.
* [`eq(eql_v3_smallint_ord_ore, jsonb)`](#eqeql_v3_smallint_ord_ore-jsonb) - Operator wrapper for public.eql\_v3\_smallint\_ord\_ore.
* [`eq(eql_v3_smallint_ord_ore, eql_v3_smallint_ord_ore)`](#eqeql_v3_smallint_ord_ore-eql_v3_smallint_ord_ore) - Operator wrapper for public.eql\_v3\_smallint\_ord\_ore.
* [`eq(jsonb, eql_v3_date_ord_ope)`](#eqjsonb-eql_v3_date_ord_ope) - Operator wrapper for public.eql\_v3\_date\_ord\_ope.
* [`eq(eql_v3_date_ord_ope, jsonb)`](#eqeql_v3_date_ord_ope-jsonb) - Operator wrapper for public.eql\_v3\_date\_ord\_ope.
* [`eq(eql_v3_date_ord_ope, eql_v3_date_ord_ope)`](#eqeql_v3_date_ord_ope-eql_v3_date_ord_ope) - Operator wrapper for public.eql\_v3\_date\_ord\_ope.
* [`eq(query_bigint_ord, eql_v3_bigint_ord)`](#eqquery_bigint_ord-eql_v3_bigint_ord) - Operator wrapper for eql\_v3.query\_bigint\_ord.
* [`eq(eql_v3_bigint_ord, query_bigint_ord)`](#eqeql_v3_bigint_ord-query_bigint_ord) - Operator wrapper for eql\_v3.query\_bigint\_ord.
* [`eq(jsonb, eql_v3_text_ord_ore)`](#eqjsonb-eql_v3_text_ord_ore) - Operator wrapper for public.eql\_v3\_text\_ord\_ore.
* [`eq(eql_v3_text_ord_ore, jsonb)`](#eqeql_v3_text_ord_ore-jsonb) - Operator wrapper for public.eql\_v3\_text\_ord\_ore.
* [`eq(eql_v3_text_ord_ore, eql_v3_text_ord_ore)`](#eqeql_v3_text_ord_ore-eql_v3_text_ord_ore) - Operator wrapper for public.eql\_v3\_text\_ord\_ore.
* [`eq_term(eql_v3_text_ord)`](#eq_termeql_v3_text_ord) - Index extractor for public.eql\_v3\_text\_ord.
* [`eq_term(query_text_ord)`](#eq_termquery_text_ord) - Index extractor for eql\_v3.query\_text\_ord.
* [`eq_term(query_text_search)`](#eq_termquery_text_search) - Index extractor for eql\_v3.query\_text\_search.
* [`eq_term(query_numeric_eq)`](#eq_termquery_numeric_eq) - Index extractor for eql\_v3.query\_numeric\_eq.
* [`eq_term(eql_v3_bigint_eq)`](#eq_termeql_v3_bigint_eq) - Index extractor for public.eql\_v3\_bigint\_eq.
* [`eq_term(query_smallint_eq)`](#eq_termquery_smallint_eq) - Index extractor for eql\_v3.query\_smallint\_eq.
* [`eq_term(query_text_search_ore)`](#eq_termquery_text_search_ore) - Index extractor for eql\_v3.query\_text\_search\_ore.
* [`eq_term(query_text_ord_ore)`](#eq_termquery_text_ord_ore) - Index extractor for eql\_v3.query\_text\_ord\_ore.
* [`eq_term(eql_v3_timestamp_eq)`](#eq_termeql_v3_timestamp_eq) - Index extractor for public.eql\_v3\_timestamp\_eq.
* [`eq_term(eql_v3_text_ord_ope)`](#eq_termeql_v3_text_ord_ope) - Index extractor for public.eql\_v3\_text\_ord\_ope.
* [`eq_term(eql_v3_real_eq)`](#eq_termeql_v3_real_eq) - Index extractor for public.eql\_v3\_real\_eq.
* [`eq_term(query_text_eq)`](#eq_termquery_text_eq) - Index extractor for eql\_v3.query\_text\_eq.
* [`eq_term(eql_v3_double_eq)`](#eq_termeql_v3_double_eq) - Index extractor for public.eql\_v3\_double\_eq.
* [`eq_term(query_double_eq)`](#eq_termquery_double_eq) - Index extractor for eql\_v3.query\_double\_eq.
* [`eq_term(eql_v3_json_entry)`](#eq_termeql_v3_json_entry) - Deprecated compatibility alias for eql\_v3.ope\_term(json\_entry).
* [`eq_term(query_text_ord_ope)`](#eq_termquery_text_ord_ope) - Index extractor for eql\_v3.query\_text\_ord\_ope.
* [`eq_term(query_real_eq)`](#eq_termquery_real_eq) - Index extractor for eql\_v3.query\_real\_eq.
* [`eq_term(eql_v3_text_search_ore)`](#eq_termeql_v3_text_search_ore) - Index extractor for public.eql\_v3\_text\_search\_ore.
* [`eq_term(query_bigint_eq)`](#eq_termquery_bigint_eq) - Index extractor for eql\_v3.query\_bigint\_eq.
* [`eq_term(query_timestamp_eq)`](#eq_termquery_timestamp_eq) - Index extractor for eql\_v3.query\_timestamp\_eq.
* [`eq_term(eql_v3_numeric_eq)`](#eq_termeql_v3_numeric_eq) - Index extractor for public.eql\_v3\_numeric\_eq.
* [`eq_term(query_date_eq)`](#eq_termquery_date_eq) - Index extractor for eql\_v3.query\_date\_eq.
* [`eq_term(eql_v3_text_search)`](#eq_termeql_v3_text_search) - Index extractor for public.eql\_v3\_text\_search.
* [`eq_term(eql_v3_smallint_eq)`](#eq_termeql_v3_smallint_eq) - Index extractor for public.eql\_v3\_smallint\_eq.
* [`eq_term(eql_v3_date_eq)`](#eq_termeql_v3_date_eq) - Index extractor for public.eql\_v3\_date\_eq.
* [`eq_term(eql_v3_text_eq)`](#eq_termeql_v3_text_eq) - Index extractor for public.eql\_v3\_text\_eq.
* [`eq_term(eql_v3_integer_eq)`](#eq_termeql_v3_integer_eq) - Index extractor for public.eql\_v3\_integer\_eq.
* [`eq_term(query_integer_eq)`](#eq_termquery_integer_eq) - Index extractor for eql\_v3.query\_integer\_eq.
* [`eq_term(eql_v3_text_ord_ore)`](#eq_termeql_v3_text_ord_ore) - Index extractor for public.eql\_v3\_text\_ord\_ore.
* [`eql_v3_is_valid_ste_vec_document_payload(jsonb)`](#eql_v3_is_valid_ste_vec_document_payloadjsonb) - Validate a root SteVec document payload.
* [`eql_v3_is_valid_ste_vec_entry_payload(jsonb)`](#eql_v3_is_valid_ste_vec_entry_payloadjsonb) - Validate a single SteVec entry payload.
* [`eql_v3_is_valid_ste_vec_query_payload(jsonb)`](#eql_v3_is_valid_ste_vec_query_payloadjsonb) - Validate a SteVec containment query payload.
* [`grouped_value(jsonb)`](#grouped_valuejsonb) - Return a representative (first non-null) encrypted value per group.
* [`gt(jsonb, eql_v3_integer_ord_ore)`](#gtjsonb-eql_v3_integer_ord_ore) - Operator wrapper for public.eql\_v3\_integer\_ord\_ore.
* [`gt(eql_v3_integer_ord_ore, jsonb)`](#gteql_v3_integer_ord_ore-jsonb) - Operator wrapper for public.eql\_v3\_integer\_ord\_ore.
* [`gt(eql_v3_integer_ord_ore, eql_v3_integer_ord_ore)`](#gteql_v3_integer_ord_ore-eql_v3_integer_ord_ore) - Operator wrapper for public.eql\_v3\_integer\_ord\_ore.
* [`gt(query_smallint_ord, eql_v3_smallint_ord)`](#gtquery_smallint_ord-eql_v3_smallint_ord) - Operator wrapper for eql\_v3.query\_smallint\_ord.
* [`gt(eql_v3_smallint_ord, query_smallint_ord)`](#gteql_v3_smallint_ord-query_smallint_ord) - Operator wrapper for eql\_v3.query\_smallint\_ord.
* [`gt(jsonb, eql_v3_smallint_ord)`](#gtjsonb-eql_v3_smallint_ord) - Operator wrapper for public.eql\_v3\_smallint\_ord.
* [`gt(eql_v3_smallint_ord, jsonb)`](#gteql_v3_smallint_ord-jsonb) - Operator wrapper for public.eql\_v3\_smallint\_ord.
* [`gt(eql_v3_smallint_ord, eql_v3_smallint_ord)`](#gteql_v3_smallint_ord-eql_v3_smallint_ord) - Operator wrapper for public.eql\_v3\_smallint\_ord.
* [`gt(jsonb, eql_v3_date_ord)`](#gtjsonb-eql_v3_date_ord) - Operator wrapper for public.eql\_v3\_date\_ord.
* [`gt(eql_v3_date_ord, jsonb)`](#gteql_v3_date_ord-jsonb) - Operator wrapper for public.eql\_v3\_date\_ord.
* [`gt(eql_v3_date_ord, eql_v3_date_ord)`](#gteql_v3_date_ord-eql_v3_date_ord) - Operator wrapper for public.eql\_v3\_date\_ord.
* [`gt(query_real_ord, eql_v3_real_ord)`](#gtquery_real_ord-eql_v3_real_ord) - Operator wrapper for eql\_v3.query\_real\_ord.
* [`gt(eql_v3_real_ord, query_real_ord)`](#gteql_v3_real_ord-query_real_ord) - Operator wrapper for eql\_v3.query\_real\_ord.
* [`gt(query_double_ord, eql_v3_json_entry)`](#gtquery_double_ord-eql_v3_json_entry) - Operator wrapper for public.eql\_v3\_json\_entry.
* [`gt(eql_v3_json_entry, query_double_ord)`](#gteql_v3_json_entry-query_double_ord) - Operator wrapper for public.eql\_v3\_json\_entry.
* [`gt(query_real_ord_ore, eql_v3_real_ord_ore)`](#gtquery_real_ord_ore-eql_v3_real_ord_ore) - Operator wrapper for eql\_v3.query\_real\_ord\_ore.
* [`gt(eql_v3_real_ord_ore, query_real_ord_ore)`](#gteql_v3_real_ord_ore-query_real_ord_ore) - Operator wrapper for eql\_v3.query\_real\_ord\_ore.
* [`gt(jsonb, eql_v3_text_ord)`](#gtjsonb-eql_v3_text_ord) - Operator wrapper for public.eql\_v3\_text\_ord.
* [`gt(eql_v3_text_ord, jsonb)`](#gteql_v3_text_ord-jsonb) - Operator wrapper for public.eql\_v3\_text\_ord.
* [`gt(eql_v3_text_ord, eql_v3_text_ord)`](#gteql_v3_text_ord-eql_v3_text_ord) - Operator wrapper for public.eql\_v3\_text\_ord.
* [`gt(query_integer_ord_ope, eql_v3_integer_ord_ope)`](#gtquery_integer_ord_ope-eql_v3_integer_ord_ope) - Operator wrapper for eql\_v3.query\_integer\_ord\_ope.
* [`gt(eql_v3_integer_ord_ope, query_integer_ord_ope)`](#gteql_v3_integer_ord_ope-query_integer_ord_ope) - Operator wrapper for eql\_v3.query\_integer\_ord\_ope.
* [`gt(query_text_ord, eql_v3_text_ord)`](#gtquery_text_ord-eql_v3_text_ord) - Operator wrapper for eql\_v3.query\_text\_ord.
* [`gt(eql_v3_text_ord, query_text_ord)`](#gteql_v3_text_ord-query_text_ord) - Operator wrapper for eql\_v3.query\_text\_ord.
* [`gt(jsonb, eql_v3_timestamp_ord_ope)`](#gtjsonb-eql_v3_timestamp_ord_ope) - Operator wrapper for public.eql\_v3\_timestamp\_ord\_ope.
* [`gt(eql_v3_timestamp_ord_ope, jsonb)`](#gteql_v3_timestamp_ord_ope-jsonb) - Operator wrapper for public.eql\_v3\_timestamp\_ord\_ope.
* [`gt(eql_v3_timestamp_ord_ope, eql_v3_timestamp_ord_ope)`](#gteql_v3_timestamp_ord_ope-eql_v3_timestamp_ord_ope) - Operator wrapper for public.eql\_v3\_timestamp\_ord\_ope.
* [`gt(jsonb, eql_v3_integer_ord_ope)`](#gtjsonb-eql_v3_integer_ord_ope) - Operator wrapper for public.eql\_v3\_integer\_ord\_ope.
* [`gt(eql_v3_integer_ord_ope, jsonb)`](#gteql_v3_integer_ord_ope-jsonb) - Operator wrapper for public.eql\_v3\_integer\_ord\_ope.
* [`gt(eql_v3_integer_ord_ope, eql_v3_integer_ord_ope)`](#gteql_v3_integer_ord_ope-eql_v3_integer_ord_ope) - Operator wrapper for public.eql\_v3\_integer\_ord\_ope.
* [`gt(query_integer_ord, eql_v3_integer_ord)`](#gtquery_integer_ord-eql_v3_integer_ord) - Operator wrapper for eql\_v3.query\_integer\_ord.
* [`gt(eql_v3_integer_ord, query_integer_ord)`](#gteql_v3_integer_ord-query_integer_ord) - Operator wrapper for eql\_v3.query\_integer\_ord.
* [`gt(query_text_search, eql_v3_text_search)`](#gtquery_text_search-eql_v3_text_search) - Operator wrapper for eql\_v3.query\_text\_search.
* [`gt(eql_v3_text_search, query_text_search)`](#gteql_v3_text_search-query_text_search) - Operator wrapper for eql\_v3.query\_text\_search.
* [`gt(jsonb, eql_v3_numeric_ord)`](#gtjsonb-eql_v3_numeric_ord) - Operator wrapper for public.eql\_v3\_numeric\_ord.
* [`gt(eql_v3_numeric_ord, jsonb)`](#gteql_v3_numeric_ord-jsonb) - Operator wrapper for public.eql\_v3\_numeric\_ord.
* [`gt(eql_v3_numeric_ord, eql_v3_numeric_ord)`](#gteql_v3_numeric_ord-eql_v3_numeric_ord) - Operator wrapper for public.eql\_v3\_numeric\_ord.
* [`gt(query_date_ord_ope, eql_v3_date_ord_ope)`](#gtquery_date_ord_ope-eql_v3_date_ord_ope) - Operator wrapper for eql\_v3.query\_date\_ord\_ope.
* [`gt(eql_v3_date_ord_ope, query_date_ord_ope)`](#gteql_v3_date_ord_ope-query_date_ord_ope) - Operator wrapper for eql\_v3.query\_date\_ord\_ope.
* [`gt(query_smallint_ord, eql_v3_json_entry)`](#gtquery_smallint_ord-eql_v3_json_entry) - Operator wrapper for public.eql\_v3\_json\_entry.
* [`gt(eql_v3_json_entry, query_smallint_ord)`](#gteql_v3_json_entry-query_smallint_ord) - Operator wrapper for public.eql\_v3\_json\_entry.
* [`gt(query_timestamp_ord_ore, eql_v3_timestamp_ord_ore)`](#gtquery_timestamp_ord_ore-eql_v3_timestamp_ord_ore) - Operator wrapper for eql\_v3.query\_timestamp\_ord\_ore.
* [`gt(eql_v3_timestamp_ord_ore, query_timestamp_ord_ore)`](#gteql_v3_timestamp_ord_ore-query_timestamp_ord_ore) - Operator wrapper for eql\_v3.query\_timestamp\_ord\_ore.
* [`gt(query_text_search_ore, eql_v3_text_search_ore)`](#gtquery_text_search_ore-eql_v3_text_search_ore) - Operator wrapper for eql\_v3.query\_text\_search\_ore.
* [`gt(eql_v3_text_search_ore, query_text_search_ore)`](#gteql_v3_text_search_ore-query_text_search_ore) - Operator wrapper for eql\_v3.query\_text\_search\_ore.
* [`gt(query_text_ord_ore, eql_v3_text_ord_ore)`](#gtquery_text_ord_ore-eql_v3_text_ord_ore) - Operator wrapper for eql\_v3.query\_text\_ord\_ore.
* [`gt(eql_v3_text_ord_ore, query_text_ord_ore)`](#gteql_v3_text_ord_ore-query_text_ord_ore) - Operator wrapper for eql\_v3.query\_text\_ord\_ore.
* [`gt(jsonb, eql_v3_real_ord_ope)`](#gtjsonb-eql_v3_real_ord_ope) - Operator wrapper for public.eql\_v3\_real\_ord\_ope.
* [`gt(eql_v3_real_ord_ope, jsonb)`](#gteql_v3_real_ord_ope-jsonb) - Operator wrapper for public.eql\_v3\_real\_ord\_ope.
* [`gt(eql_v3_real_ord_ope, eql_v3_real_ord_ope)`](#gteql_v3_real_ord_ope-eql_v3_real_ord_ope) - Operator wrapper for public.eql\_v3\_real\_ord\_ope.
* [`gt(jsonb, eql_v3_real_ord)`](#gtjsonb-eql_v3_real_ord) - Operator wrapper for public.eql\_v3\_real\_ord.
* [`gt(eql_v3_real_ord, jsonb)`](#gteql_v3_real_ord-jsonb) - Operator wrapper for public.eql\_v3\_real\_ord.
* [`gt(eql_v3_real_ord, eql_v3_real_ord)`](#gteql_v3_real_ord-eql_v3_real_ord) - Operator wrapper for public.eql\_v3\_real\_ord.
* [`gt(jsonb, eql_v3_integer_ord)`](#gtjsonb-eql_v3_integer_ord) - Operator wrapper for public.eql\_v3\_integer\_ord.
* [`gt(eql_v3_integer_ord, jsonb)`](#gteql_v3_integer_ord-jsonb) - Operator wrapper for public.eql\_v3\_integer\_ord.
* [`gt(eql_v3_integer_ord, eql_v3_integer_ord)`](#gteql_v3_integer_ord-eql_v3_integer_ord) - Operator wrapper for public.eql\_v3\_integer\_ord.
* [`gt(query_smallint_ord_ore, eql_v3_smallint_ord_ore)`](#gtquery_smallint_ord_ore-eql_v3_smallint_ord_ore) - Operator wrapper for eql\_v3.query\_smallint\_ord\_ore.
* [`gt(eql_v3_smallint_ord_ore, query_smallint_ord_ore)`](#gteql_v3_smallint_ord_ore-query_smallint_ord_ore) - Operator wrapper for eql\_v3.query\_smallint\_ord\_ore.
* [`gt(jsonb, eql_v3_text_ord_ope)`](#gtjsonb-eql_v3_text_ord_ope) - Operator wrapper for public.eql\_v3\_text\_ord\_ope.
* [`gt(eql_v3_text_ord_ope, jsonb)`](#gteql_v3_text_ord_ope-jsonb) - Operator wrapper for public.eql\_v3\_text\_ord\_ope.
* [`gt(eql_v3_text_ord_ope, eql_v3_text_ord_ope)`](#gteql_v3_text_ord_ope-eql_v3_text_ord_ope) - Operator wrapper for public.eql\_v3\_text\_ord\_ope.
* [`gt(query_double_ord_ope, eql_v3_double_ord_ope)`](#gtquery_double_ord_ope-eql_v3_double_ord_ope) - Operator wrapper for eql\_v3.query\_double\_ord\_ope.
* [`gt(eql_v3_double_ord_ope, query_double_ord_ope)`](#gteql_v3_double_ord_ope-query_double_ord_ope) - Operator wrapper for eql\_v3.query\_double\_ord\_ope.
* [`gt(query_integer_ord_ore, eql_v3_integer_ord_ore)`](#gtquery_integer_ord_ore-eql_v3_integer_ord_ore) - Operator wrapper for eql\_v3.query\_integer\_ord\_ore.
* [`gt(eql_v3_integer_ord_ore, query_integer_ord_ore)`](#gteql_v3_integer_ord_ore-query_integer_ord_ore) - Operator wrapper for eql\_v3.query\_integer\_ord\_ore.
* [`gt(jsonb, eql_v3_bigint_ord_ore)`](#gtjsonb-eql_v3_bigint_ord_ore) - Operator wrapper for public.eql\_v3\_bigint\_ord\_ore.
* [`gt(eql_v3_bigint_ord_ore, jsonb)`](#gteql_v3_bigint_ord_ore-jsonb) - Operator wrapper for public.eql\_v3\_bigint\_ord\_ore.
* [`gt(eql_v3_bigint_ord_ore, eql_v3_bigint_ord_ore)`](#gteql_v3_bigint_ord_ore-eql_v3_bigint_ord_ore) - Operator wrapper for public.eql\_v3\_bigint\_ord\_ore.
* [`gt(query_date_ord, eql_v3_date_ord)`](#gtquery_date_ord-eql_v3_date_ord) - Operator wrapper for eql\_v3.query\_date\_ord.
* [`gt(eql_v3_date_ord, query_date_ord)`](#gteql_v3_date_ord-query_date_ord) - Operator wrapper for eql\_v3.query\_date\_ord.
* [`gt(jsonb, eql_v3_real_ord_ore)`](#gtjsonb-eql_v3_real_ord_ore) - Operator wrapper for public.eql\_v3\_real\_ord\_ore.
* [`gt(eql_v3_real_ord_ore, jsonb)`](#gteql_v3_real_ord_ore-jsonb) - Operator wrapper for public.eql\_v3\_real\_ord\_ore.
* [`gt(eql_v3_real_ord_ore, eql_v3_real_ord_ore)`](#gteql_v3_real_ord_ore-eql_v3_real_ord_ore) - Operator wrapper for public.eql\_v3\_real\_ord\_ore.
* [`gt(jsonb, eql_v3_numeric_ord_ore)`](#gtjsonb-eql_v3_numeric_ord_ore) - Operator wrapper for public.eql\_v3\_numeric\_ord\_ore.
* [`gt(eql_v3_numeric_ord_ore, jsonb)`](#gteql_v3_numeric_ord_ore-jsonb) - Operator wrapper for public.eql\_v3\_numeric\_ord\_ore.
* [`gt(eql_v3_numeric_ord_ore, eql_v3_numeric_ord_ore)`](#gteql_v3_numeric_ord_ore-eql_v3_numeric_ord_ore) - Operator wrapper for public.eql\_v3\_numeric\_ord\_ore.
* [`gt(query_text_ord_ope, eql_v3_text_ord_ope)`](#gtquery_text_ord_ope-eql_v3_text_ord_ope) - Operator wrapper for eql\_v3.query\_text\_ord\_ope.
* [`gt(eql_v3_text_ord_ope, query_text_ord_ope)`](#gteql_v3_text_ord_ope-query_text_ord_ope) - Operator wrapper for eql\_v3.query\_text\_ord\_ope.
* [`gt(jsonb, eql_v3_bigint_ord_ope)`](#gtjsonb-eql_v3_bigint_ord_ope) - Operator wrapper for public.eql\_v3\_bigint\_ord\_ope.
* [`gt(eql_v3_bigint_ord_ope, jsonb)`](#gteql_v3_bigint_ord_ope-jsonb) - Operator wrapper for public.eql\_v3\_bigint\_ord\_ope.
* [`gt(eql_v3_bigint_ord_ope, eql_v3_bigint_ord_ope)`](#gteql_v3_bigint_ord_ope-eql_v3_bigint_ord_ope) - Operator wrapper for public.eql\_v3\_bigint\_ord\_ope.
* [`gt(query_numeric_ord, eql_v3_json_entry)`](#gtquery_numeric_ord-eql_v3_json_entry) - Operator wrapper for public.eql\_v3\_json\_entry.
* [`gt(eql_v3_json_entry, query_numeric_ord)`](#gteql_v3_json_entry-query_numeric_ord) - Operator wrapper for public.eql\_v3\_json\_entry.
* [`gt(jsonb, eql_v3_double_ord_ore)`](#gtjsonb-eql_v3_double_ord_ore) - Operator wrapper for public.eql\_v3\_double\_ord\_ore.
* [`gt(eql_v3_double_ord_ore, jsonb)`](#gteql_v3_double_ord_ore-jsonb) - Operator wrapper for public.eql\_v3\_double\_ord\_ore.
* [`gt(eql_v3_double_ord_ore, eql_v3_double_ord_ore)`](#gteql_v3_double_ord_ore-eql_v3_double_ord_ore) - Operator wrapper for public.eql\_v3\_double\_ord\_ore.
* [`gt(jsonb, eql_v3_bigint_ord)`](#gtjsonb-eql_v3_bigint_ord) - Operator wrapper for public.eql\_v3\_bigint\_ord.
* [`gt(eql_v3_bigint_ord, jsonb)`](#gteql_v3_bigint_ord-jsonb) - Operator wrapper for public.eql\_v3\_bigint\_ord.
* [`gt(eql_v3_bigint_ord, eql_v3_bigint_ord)`](#gteql_v3_bigint_ord-eql_v3_bigint_ord) - Operator wrapper for public.eql\_v3\_bigint\_ord.
* [`gt(query_text_ord, eql_v3_json_entry)`](#gtquery_text_ord-eql_v3_json_entry) - Operator wrapper for public.eql\_v3\_json\_entry.
* [`gt(eql_v3_json_entry, query_text_ord)`](#gteql_v3_json_entry-query_text_ord) - Operator wrapper for public.eql\_v3\_json\_entry.
* [`gt(query_timestamp_ord_ope, eql_v3_timestamp_ord_ope)`](#gtquery_timestamp_ord_ope-eql_v3_timestamp_ord_ope) - Operator wrapper for eql\_v3.query\_timestamp\_ord\_ope.
* [`gt(eql_v3_timestamp_ord_ope, query_timestamp_ord_ope)`](#gteql_v3_timestamp_ord_ope-query_timestamp_ord_ope) - Operator wrapper for eql\_v3.query\_timestamp\_ord\_ope.
* [`gt(query_numeric_ord, eql_v3_numeric_ord)`](#gtquery_numeric_ord-eql_v3_numeric_ord) - Operator wrapper for eql\_v3.query\_numeric\_ord.
* [`gt(eql_v3_numeric_ord, query_numeric_ord)`](#gteql_v3_numeric_ord-query_numeric_ord) - Operator wrapper for eql\_v3.query\_numeric\_ord.
* [`gt(jsonb, eql_v3_text_search_ore)`](#gtjsonb-eql_v3_text_search_ore) - Operator wrapper for public.eql\_v3\_text\_search\_ore.
* [`gt(eql_v3_text_search_ore, jsonb)`](#gteql_v3_text_search_ore-jsonb) - Operator wrapper for public.eql\_v3\_text\_search\_ore.
* [`gt(eql_v3_text_search_ore, eql_v3_text_search_ore)`](#gteql_v3_text_search_ore-eql_v3_text_search_ore) - Operator wrapper for public.eql\_v3\_text\_search\_ore.
* [`gt(query_real_ord_ope, eql_v3_real_ord_ope)`](#gtquery_real_ord_ope-eql_v3_real_ord_ope) - Operator wrapper for eql\_v3.query\_real\_ord\_ope.
* [`gt(eql_v3_real_ord_ope, query_real_ord_ope)`](#gteql_v3_real_ord_ope-query_real_ord_ope) - Operator wrapper for eql\_v3.query\_real\_ord\_ope.
* [`gt(jsonb, eql_v3_timestamp_ord)`](#gtjsonb-eql_v3_timestamp_ord) - Operator wrapper for public.eql\_v3\_timestamp\_ord.
* [`gt(eql_v3_timestamp_ord, jsonb)`](#gteql_v3_timestamp_ord-jsonb) - Operator wrapper for public.eql\_v3\_timestamp\_ord.
* [`gt(eql_v3_timestamp_ord, eql_v3_timestamp_ord)`](#gteql_v3_timestamp_ord-eql_v3_timestamp_ord) - Operator wrapper for public.eql\_v3\_timestamp\_ord.
* [`gt(jsonb, eql_v3_smallint_ord_ope)`](#gtjsonb-eql_v3_smallint_ord_ope) - Operator wrapper for public.eql\_v3\_smallint\_ord\_ope.
* [`gt(eql_v3_smallint_ord_ope, jsonb)`](#gteql_v3_smallint_ord_ope-jsonb) - Operator wrapper for public.eql\_v3\_smallint\_ord\_ope.
* [`gt(eql_v3_smallint_ord_ope, eql_v3_smallint_ord_ope)`](#gteql_v3_smallint_ord_ope-eql_v3_smallint_ord_ope) - Operator wrapper for public.eql\_v3\_smallint\_ord\_ope.
* [`gt(query_integer_ord, eql_v3_json_entry)`](#gtquery_integer_ord-eql_v3_json_entry) - Operator wrapper for public.eql\_v3\_json\_entry.
* [`gt(eql_v3_json_entry, query_integer_ord)`](#gteql_v3_json_entry-query_integer_ord) - Operator wrapper for public.eql\_v3\_json\_entry.
* [`gt(query_real_ord, eql_v3_json_entry)`](#gtquery_real_ord-eql_v3_json_entry) - Operator wrapper for public.eql\_v3\_json\_entry.
* [`gt(eql_v3_json_entry, query_real_ord)`](#gteql_v3_json_entry-query_real_ord) - Operator wrapper for public.eql\_v3\_json\_entry.
* [`gt(query_double_ord, eql_v3_double_ord)`](#gtquery_double_ord-eql_v3_double_ord) - Operator wrapper for eql\_v3.query\_double\_ord.
* [`gt(eql_v3_double_ord, query_double_ord)`](#gteql_v3_double_ord-query_double_ord) - Operator wrapper for eql\_v3.query\_double\_ord.
* [`gt(query_double_ord_ore, eql_v3_double_ord_ore)`](#gtquery_double_ord_ore-eql_v3_double_ord_ore) - Operator wrapper for eql\_v3.query\_double\_ord\_ore.
* [`gt(eql_v3_double_ord_ore, query_double_ord_ore)`](#gteql_v3_double_ord_ore-query_double_ord_ore) - Operator wrapper for eql\_v3.query\_double\_ord\_ore.
* [`gt(jsonb, eql_v3_timestamp_ord_ore)`](#gtjsonb-eql_v3_timestamp_ord_ore) - Operator wrapper for public.eql\_v3\_timestamp\_ord\_ore.
* [`gt(eql_v3_timestamp_ord_ore, jsonb)`](#gteql_v3_timestamp_ord_ore-jsonb) - Operator wrapper for public.eql\_v3\_timestamp\_ord\_ore.
* [`gt(eql_v3_timestamp_ord_ore, eql_v3_timestamp_ord_ore)`](#gteql_v3_timestamp_ord_ore-eql_v3_timestamp_ord_ore) - Operator wrapper for public.eql\_v3\_timestamp\_ord\_ore.
* [`gt(jsonb, eql_v3_text_search)`](#gtjsonb-eql_v3_text_search) - Operator wrapper for public.eql\_v3\_text\_search.
* [`gt(eql_v3_text_search, jsonb)`](#gteql_v3_text_search-jsonb) - Operator wrapper for public.eql\_v3\_text\_search.
* [`gt(eql_v3_text_search, eql_v3_text_search)`](#gteql_v3_text_search-eql_v3_text_search) - Operator wrapper for public.eql\_v3\_text\_search.
* [`gt(query_numeric_ord_ore, eql_v3_numeric_ord_ore)`](#gtquery_numeric_ord_ore-eql_v3_numeric_ord_ore) - Operator wrapper for eql\_v3.query\_numeric\_ord\_ore.
* [`gt(eql_v3_numeric_ord_ore, query_numeric_ord_ore)`](#gteql_v3_numeric_ord_ore-query_numeric_ord_ore) - Operator wrapper for eql\_v3.query\_numeric\_ord\_ore.
* [`gt(query_bigint_ord_ore, eql_v3_bigint_ord_ore)`](#gtquery_bigint_ord_ore-eql_v3_bigint_ord_ore) - Operator wrapper for eql\_v3.query\_bigint\_ord\_ore.
* [`gt(eql_v3_bigint_ord_ore, query_bigint_ord_ore)`](#gteql_v3_bigint_ord_ore-query_bigint_ord_ore) - Operator wrapper for eql\_v3.query\_bigint\_ord\_ore.
* [`gt(query_bigint_ord_ope, eql_v3_bigint_ord_ope)`](#gtquery_bigint_ord_ope-eql_v3_bigint_ord_ope) - Operator wrapper for eql\_v3.query\_bigint\_ord\_ope.
* [`gt(eql_v3_bigint_ord_ope, query_bigint_ord_ope)`](#gteql_v3_bigint_ord_ope-query_bigint_ord_ope) - Operator wrapper for eql\_v3.query\_bigint\_ord\_ope.
* [`gt(query_date_ord_ore, eql_v3_date_ord_ore)`](#gtquery_date_ord_ore-eql_v3_date_ord_ore) - Operator wrapper for eql\_v3.query\_date\_ord\_ore.
* [`gt(eql_v3_date_ord_ore, query_date_ord_ore)`](#gteql_v3_date_ord_ore-query_date_ord_ore) - Operator wrapper for eql\_v3.query\_date\_ord\_ore.
* [`gt(query_smallint_ord_ope, eql_v3_smallint_ord_ope)`](#gtquery_smallint_ord_ope-eql_v3_smallint_ord_ope) - Operator wrapper for eql\_v3.query\_smallint\_ord\_ope.
* [`gt(eql_v3_smallint_ord_ope, query_smallint_ord_ope)`](#gteql_v3_smallint_ord_ope-query_smallint_ord_ope) - Operator wrapper for eql\_v3.query\_smallint\_ord\_ope.
* [`gt(jsonb, eql_v3_double_ord)`](#gtjsonb-eql_v3_double_ord) - Operator wrapper for public.eql\_v3\_double\_ord.
* [`gt(eql_v3_double_ord, jsonb)`](#gteql_v3_double_ord-jsonb) - Operator wrapper for public.eql\_v3\_double\_ord.
* [`gt(eql_v3_double_ord, eql_v3_double_ord)`](#gteql_v3_double_ord-eql_v3_double_ord) - Operator wrapper for public.eql\_v3\_double\_ord.
* [`gt(query_numeric_ord_ope, eql_v3_numeric_ord_ope)`](#gtquery_numeric_ord_ope-eql_v3_numeric_ord_ope) - Operator wrapper for eql\_v3.query\_numeric\_ord\_ope.
* [`gt(eql_v3_numeric_ord_ope, query_numeric_ord_ope)`](#gteql_v3_numeric_ord_ope-query_numeric_ord_ope) - Operator wrapper for eql\_v3.query\_numeric\_ord\_ope.
* [`gt(jsonb, eql_v3_double_ord_ope)`](#gtjsonb-eql_v3_double_ord_ope) - Operator wrapper for public.eql\_v3\_double\_ord\_ope.
* [`gt(eql_v3_double_ord_ope, jsonb)`](#gteql_v3_double_ord_ope-jsonb) - Operator wrapper for public.eql\_v3\_double\_ord\_ope.
* [`gt(eql_v3_double_ord_ope, eql_v3_double_ord_ope)`](#gteql_v3_double_ord_ope-eql_v3_double_ord_ope) - Operator wrapper for public.eql\_v3\_double\_ord\_ope.
* [`gt(jsonb, eql_v3_numeric_ord_ope)`](#gtjsonb-eql_v3_numeric_ord_ope) - Operator wrapper for public.eql\_v3\_numeric\_ord\_ope.
* [`gt(eql_v3_numeric_ord_ope, jsonb)`](#gteql_v3_numeric_ord_ope-jsonb) - Operator wrapper for public.eql\_v3\_numeric\_ord\_ope.
* [`gt(eql_v3_numeric_ord_ope, eql_v3_numeric_ord_ope)`](#gteql_v3_numeric_ord_ope-eql_v3_numeric_ord_ope) - Operator wrapper for public.eql\_v3\_numeric\_ord\_ope.
* [`gt(jsonb, eql_v3_date_ord_ore)`](#gtjsonb-eql_v3_date_ord_ore) - Operator wrapper for public.eql\_v3\_date\_ord\_ore.
* [`gt(eql_v3_date_ord_ore, jsonb)`](#gteql_v3_date_ord_ore-jsonb) - Operator wrapper for public.eql\_v3\_date\_ord\_ore.
* [`gt(eql_v3_date_ord_ore, eql_v3_date_ord_ore)`](#gteql_v3_date_ord_ore-eql_v3_date_ord_ore) - Operator wrapper for public.eql\_v3\_date\_ord\_ore.
* [`gt(query_timestamp_ord, eql_v3_timestamp_ord)`](#gtquery_timestamp_ord-eql_v3_timestamp_ord) - Operator wrapper for eql\_v3.query\_timestamp\_ord.
* [`gt(eql_v3_timestamp_ord, query_timestamp_ord)`](#gteql_v3_timestamp_ord-query_timestamp_ord) - Operator wrapper for eql\_v3.query\_timestamp\_ord.
* [`gt(jsonb, eql_v3_smallint_ord_ore)`](#gtjsonb-eql_v3_smallint_ord_ore) - Operator wrapper for public.eql\_v3\_smallint\_ord\_ore.
* [`gt(eql_v3_smallint_ord_ore, jsonb)`](#gteql_v3_smallint_ord_ore-jsonb) - Operator wrapper for public.eql\_v3\_smallint\_ord\_ore.
* [`gt(eql_v3_smallint_ord_ore, eql_v3_smallint_ord_ore)`](#gteql_v3_smallint_ord_ore-eql_v3_smallint_ord_ore) - Operator wrapper for public.eql\_v3\_smallint\_ord\_ore.
* [`gt(jsonb, eql_v3_date_ord_ope)`](#gtjsonb-eql_v3_date_ord_ope) - Operator wrapper for public.eql\_v3\_date\_ord\_ope.
* [`gt(eql_v3_date_ord_ope, jsonb)`](#gteql_v3_date_ord_ope-jsonb) - Operator wrapper for public.eql\_v3\_date\_ord\_ope.
* [`gt(eql_v3_date_ord_ope, eql_v3_date_ord_ope)`](#gteql_v3_date_ord_ope-eql_v3_date_ord_ope) - Operator wrapper for public.eql\_v3\_date\_ord\_ope.
* [`gt(query_bigint_ord, eql_v3_bigint_ord)`](#gtquery_bigint_ord-eql_v3_bigint_ord) - Operator wrapper for eql\_v3.query\_bigint\_ord.
* [`gt(eql_v3_bigint_ord, query_bigint_ord)`](#gteql_v3_bigint_ord-query_bigint_ord) - Operator wrapper for eql\_v3.query\_bigint\_ord.
* [`gt(jsonb, eql_v3_text_ord_ore)`](#gtjsonb-eql_v3_text_ord_ore) - Operator wrapper for public.eql\_v3\_text\_ord\_ore.
* [`gt(eql_v3_text_ord_ore, jsonb)`](#gteql_v3_text_ord_ore-jsonb) - Operator wrapper for public.eql\_v3\_text\_ord\_ore.
* [`gt(eql_v3_text_ord_ore, eql_v3_text_ord_ore)`](#gteql_v3_text_ord_ore-eql_v3_text_ord_ore) - Operator wrapper for public.eql\_v3\_text\_ord\_ore.
* [`gt(query_bigint_ord, eql_v3_json_entry)`](#gtquery_bigint_ord-eql_v3_json_entry) - Operator wrapper for public.eql\_v3\_json\_entry.
* [`gt(eql_v3_json_entry, query_bigint_ord)`](#gteql_v3_json_entry-query_bigint_ord) - Operator wrapper for public.eql\_v3\_json\_entry.
* [`gte(jsonb, eql_v3_integer_ord_ore)`](#gtejsonb-eql_v3_integer_ord_ore) - Operator wrapper for public.eql\_v3\_integer\_ord\_ore.
* [`gte(eql_v3_integer_ord_ore, jsonb)`](#gteeql_v3_integer_ord_ore-jsonb) - Operator wrapper for public.eql\_v3\_integer\_ord\_ore.
* [`gte(eql_v3_integer_ord_ore, eql_v3_integer_ord_ore)`](#gteeql_v3_integer_ord_ore-eql_v3_integer_ord_ore) - Operator wrapper for public.eql\_v3\_integer\_ord\_ore.
* [`gte(query_smallint_ord, eql_v3_smallint_ord)`](#gtequery_smallint_ord-eql_v3_smallint_ord) - Operator wrapper for eql\_v3.query\_smallint\_ord.
* [`gte(eql_v3_smallint_ord, query_smallint_ord)`](#gteeql_v3_smallint_ord-query_smallint_ord) - Operator wrapper for eql\_v3.query\_smallint\_ord.
* [`gte(jsonb, eql_v3_smallint_ord)`](#gtejsonb-eql_v3_smallint_ord) - Operator wrapper for public.eql\_v3\_smallint\_ord.
* [`gte(eql_v3_smallint_ord, jsonb)`](#gteeql_v3_smallint_ord-jsonb) - Operator wrapper for public.eql\_v3\_smallint\_ord.
* [`gte(eql_v3_smallint_ord, eql_v3_smallint_ord)`](#gteeql_v3_smallint_ord-eql_v3_smallint_ord) - Operator wrapper for public.eql\_v3\_smallint\_ord.
* [`gte(jsonb, eql_v3_date_ord)`](#gtejsonb-eql_v3_date_ord) - Operator wrapper for public.eql\_v3\_date\_ord.
* [`gte(eql_v3_date_ord, jsonb)`](#gteeql_v3_date_ord-jsonb) - Operator wrapper for public.eql\_v3\_date\_ord.
* [`gte(eql_v3_date_ord, eql_v3_date_ord)`](#gteeql_v3_date_ord-eql_v3_date_ord) - Operator wrapper for public.eql\_v3\_date\_ord.
* [`gte(query_real_ord, eql_v3_real_ord)`](#gtequery_real_ord-eql_v3_real_ord) - Operator wrapper for eql\_v3.query\_real\_ord.
* [`gte(eql_v3_real_ord, query_real_ord)`](#gteeql_v3_real_ord-query_real_ord) - Operator wrapper for eql\_v3.query\_real\_ord.
* [`gte(query_double_ord, eql_v3_json_entry)`](#gtequery_double_ord-eql_v3_json_entry) - Operator wrapper for public.eql\_v3\_json\_entry.
* [`gte(eql_v3_json_entry, query_double_ord)`](#gteeql_v3_json_entry-query_double_ord) - Operator wrapper for public.eql\_v3\_json\_entry.
* [`gte(query_real_ord_ore, eql_v3_real_ord_ore)`](#gtequery_real_ord_ore-eql_v3_real_ord_ore) - Operator wrapper for eql\_v3.query\_real\_ord\_ore.
* [`gte(eql_v3_real_ord_ore, query_real_ord_ore)`](#gteeql_v3_real_ord_ore-query_real_ord_ore) - Operator wrapper for eql\_v3.query\_real\_ord\_ore.
* [`gte(jsonb, eql_v3_text_ord)`](#gtejsonb-eql_v3_text_ord) - Operator wrapper for public.eql\_v3\_text\_ord.
* [`gte(eql_v3_text_ord, jsonb)`](#gteeql_v3_text_ord-jsonb) - Operator wrapper for public.eql\_v3\_text\_ord.
* [`gte(eql_v3_text_ord, eql_v3_text_ord)`](#gteeql_v3_text_ord-eql_v3_text_ord) - Operator wrapper for public.eql\_v3\_text\_ord.
* [`gte(query_integer_ord_ope, eql_v3_integer_ord_ope)`](#gtequery_integer_ord_ope-eql_v3_integer_ord_ope) - Operator wrapper for eql\_v3.query\_integer\_ord\_ope.
* [`gte(eql_v3_integer_ord_ope, query_integer_ord_ope)`](#gteeql_v3_integer_ord_ope-query_integer_ord_ope) - Operator wrapper for eql\_v3.query\_integer\_ord\_ope.
* [`gte(query_text_ord, eql_v3_text_ord)`](#gtequery_text_ord-eql_v3_text_ord) - Operator wrapper for eql\_v3.query\_text\_ord.
* [`gte(eql_v3_text_ord, query_text_ord)`](#gteeql_v3_text_ord-query_text_ord) - Operator wrapper for eql\_v3.query\_text\_ord.
* [`gte(jsonb, eql_v3_timestamp_ord_ope)`](#gtejsonb-eql_v3_timestamp_ord_ope) - Operator wrapper for public.eql\_v3\_timestamp\_ord\_ope.
* [`gte(eql_v3_timestamp_ord_ope, jsonb)`](#gteeql_v3_timestamp_ord_ope-jsonb) - Operator wrapper for public.eql\_v3\_timestamp\_ord\_ope.
* [`gte(eql_v3_timestamp_ord_ope, eql_v3_timestamp_ord_ope)`](#gteeql_v3_timestamp_ord_ope-eql_v3_timestamp_ord_ope) - Operator wrapper for public.eql\_v3\_timestamp\_ord\_ope.
* [`gte(jsonb, eql_v3_integer_ord_ope)`](#gtejsonb-eql_v3_integer_ord_ope) - Operator wrapper for public.eql\_v3\_integer\_ord\_ope.
* [`gte(eql_v3_integer_ord_ope, jsonb)`](#gteeql_v3_integer_ord_ope-jsonb) - Operator wrapper for public.eql\_v3\_integer\_ord\_ope.
* [`gte(eql_v3_integer_ord_ope, eql_v3_integer_ord_ope)`](#gteeql_v3_integer_ord_ope-eql_v3_integer_ord_ope) - Operator wrapper for public.eql\_v3\_integer\_ord\_ope.
* [`gte(query_integer_ord, eql_v3_integer_ord)`](#gtequery_integer_ord-eql_v3_integer_ord) - Operator wrapper for eql\_v3.query\_integer\_ord.
* [`gte(eql_v3_integer_ord, query_integer_ord)`](#gteeql_v3_integer_ord-query_integer_ord) - Operator wrapper for eql\_v3.query\_integer\_ord.
* [`gte(query_text_search, eql_v3_text_search)`](#gtequery_text_search-eql_v3_text_search) - Operator wrapper for eql\_v3.query\_text\_search.
* [`gte(eql_v3_text_search, query_text_search)`](#gteeql_v3_text_search-query_text_search) - Operator wrapper for eql\_v3.query\_text\_search.
* [`gte(jsonb, eql_v3_numeric_ord)`](#gtejsonb-eql_v3_numeric_ord) - Operator wrapper for public.eql\_v3\_numeric\_ord.
* [`gte(eql_v3_numeric_ord, jsonb)`](#gteeql_v3_numeric_ord-jsonb) - Operator wrapper for public.eql\_v3\_numeric\_ord.
* [`gte(eql_v3_numeric_ord, eql_v3_numeric_ord)`](#gteeql_v3_numeric_ord-eql_v3_numeric_ord) - Operator wrapper for public.eql\_v3\_numeric\_ord.
* [`gte(query_date_ord_ope, eql_v3_date_ord_ope)`](#gtequery_date_ord_ope-eql_v3_date_ord_ope) - Operator wrapper for eql\_v3.query\_date\_ord\_ope.
* [`gte(eql_v3_date_ord_ope, query_date_ord_ope)`](#gteeql_v3_date_ord_ope-query_date_ord_ope) - Operator wrapper for eql\_v3.query\_date\_ord\_ope.
* [`gte(query_smallint_ord, eql_v3_json_entry)`](#gtequery_smallint_ord-eql_v3_json_entry) - Operator wrapper for public.eql\_v3\_json\_entry.
* [`gte(eql_v3_json_entry, query_smallint_ord)`](#gteeql_v3_json_entry-query_smallint_ord) - Operator wrapper for public.eql\_v3\_json\_entry.
* [`gte(query_timestamp_ord_ore, eql_v3_timestamp_ord_ore)`](#gtequery_timestamp_ord_ore-eql_v3_timestamp_ord_ore) - Operator wrapper for eql\_v3.query\_timestamp\_ord\_ore.
* [`gte(eql_v3_timestamp_ord_ore, query_timestamp_ord_ore)`](#gteeql_v3_timestamp_ord_ore-query_timestamp_ord_ore) - Operator wrapper for eql\_v3.query\_timestamp\_ord\_ore.
* [`gte(query_text_search_ore, eql_v3_text_search_ore)`](#gtequery_text_search_ore-eql_v3_text_search_ore) - Operator wrapper for eql\_v3.query\_text\_search\_ore.
* [`gte(eql_v3_text_search_ore, query_text_search_ore)`](#gteeql_v3_text_search_ore-query_text_search_ore) - Operator wrapper for eql\_v3.query\_text\_search\_ore.
* [`gte(query_text_ord_ore, eql_v3_text_ord_ore)`](#gtequery_text_ord_ore-eql_v3_text_ord_ore) - Operator wrapper for eql\_v3.query\_text\_ord\_ore.
* [`gte(eql_v3_text_ord_ore, query_text_ord_ore)`](#gteeql_v3_text_ord_ore-query_text_ord_ore) - Operator wrapper for eql\_v3.query\_text\_ord\_ore.
* [`gte(jsonb, eql_v3_real_ord_ope)`](#gtejsonb-eql_v3_real_ord_ope) - Operator wrapper for public.eql\_v3\_real\_ord\_ope.
* [`gte(eql_v3_real_ord_ope, jsonb)`](#gteeql_v3_real_ord_ope-jsonb) - Operator wrapper for public.eql\_v3\_real\_ord\_ope.
* [`gte(eql_v3_real_ord_ope, eql_v3_real_ord_ope)`](#gteeql_v3_real_ord_ope-eql_v3_real_ord_ope) - Operator wrapper for public.eql\_v3\_real\_ord\_ope.
* [`gte(jsonb, eql_v3_real_ord)`](#gtejsonb-eql_v3_real_ord) - Operator wrapper for public.eql\_v3\_real\_ord.
* [`gte(eql_v3_real_ord, jsonb)`](#gteeql_v3_real_ord-jsonb) - Operator wrapper for public.eql\_v3\_real\_ord.
* [`gte(eql_v3_real_ord, eql_v3_real_ord)`](#gteeql_v3_real_ord-eql_v3_real_ord) - Operator wrapper for public.eql\_v3\_real\_ord.
* [`gte(jsonb, eql_v3_integer_ord)`](#gtejsonb-eql_v3_integer_ord) - Operator wrapper for public.eql\_v3\_integer\_ord.
* [`gte(eql_v3_integer_ord, jsonb)`](#gteeql_v3_integer_ord-jsonb) - Operator wrapper for public.eql\_v3\_integer\_ord.
* [`gte(eql_v3_integer_ord, eql_v3_integer_ord)`](#gteeql_v3_integer_ord-eql_v3_integer_ord) - Operator wrapper for public.eql\_v3\_integer\_ord.
* [`gte(query_smallint_ord_ore, eql_v3_smallint_ord_ore)`](#gtequery_smallint_ord_ore-eql_v3_smallint_ord_ore) - Operator wrapper for eql\_v3.query\_smallint\_ord\_ore.
* [`gte(eql_v3_smallint_ord_ore, query_smallint_ord_ore)`](#gteeql_v3_smallint_ord_ore-query_smallint_ord_ore) - Operator wrapper for eql\_v3.query\_smallint\_ord\_ore.
* [`gte(jsonb, eql_v3_text_ord_ope)`](#gtejsonb-eql_v3_text_ord_ope) - Operator wrapper for public.eql\_v3\_text\_ord\_ope.
* [`gte(eql_v3_text_ord_ope, jsonb)`](#gteeql_v3_text_ord_ope-jsonb) - Operator wrapper for public.eql\_v3\_text\_ord\_ope.
* [`gte(eql_v3_text_ord_ope, eql_v3_text_ord_ope)`](#gteeql_v3_text_ord_ope-eql_v3_text_ord_ope) - Operator wrapper for public.eql\_v3\_text\_ord\_ope.
* [`gte(query_double_ord_ope, eql_v3_double_ord_ope)`](#gtequery_double_ord_ope-eql_v3_double_ord_ope) - Operator wrapper for eql\_v3.query\_double\_ord\_ope.
* [`gte(eql_v3_double_ord_ope, query_double_ord_ope)`](#gteeql_v3_double_ord_ope-query_double_ord_ope) - Operator wrapper for eql\_v3.query\_double\_ord\_ope.
* [`gte(query_integer_ord_ore, eql_v3_integer_ord_ore)`](#gtequery_integer_ord_ore-eql_v3_integer_ord_ore) - Operator wrapper for eql\_v3.query\_integer\_ord\_ore.
* [`gte(eql_v3_integer_ord_ore, query_integer_ord_ore)`](#gteeql_v3_integer_ord_ore-query_integer_ord_ore) - Operator wrapper for eql\_v3.query\_integer\_ord\_ore.
* [`gte(jsonb, eql_v3_bigint_ord_ore)`](#gtejsonb-eql_v3_bigint_ord_ore) - Operator wrapper for public.eql\_v3\_bigint\_ord\_ore.
* [`gte(eql_v3_bigint_ord_ore, jsonb)`](#gteeql_v3_bigint_ord_ore-jsonb) - Operator wrapper for public.eql\_v3\_bigint\_ord\_ore.
* [`gte(eql_v3_bigint_ord_ore, eql_v3_bigint_ord_ore)`](#gteeql_v3_bigint_ord_ore-eql_v3_bigint_ord_ore) - Operator wrapper for public.eql\_v3\_bigint\_ord\_ore.
* [`gte(query_date_ord, eql_v3_date_ord)`](#gtequery_date_ord-eql_v3_date_ord) - Operator wrapper for eql\_v3.query\_date\_ord.
* [`gte(eql_v3_date_ord, query_date_ord)`](#gteeql_v3_date_ord-query_date_ord) - Operator wrapper for eql\_v3.query\_date\_ord.
* [`gte(jsonb, eql_v3_real_ord_ore)`](#gtejsonb-eql_v3_real_ord_ore) - Operator wrapper for public.eql\_v3\_real\_ord\_ore.
* [`gte(eql_v3_real_ord_ore, jsonb)`](#gteeql_v3_real_ord_ore-jsonb) - Operator wrapper for public.eql\_v3\_real\_ord\_ore.
* [`gte(eql_v3_real_ord_ore, eql_v3_real_ord_ore)`](#gteeql_v3_real_ord_ore-eql_v3_real_ord_ore) - Operator wrapper for public.eql\_v3\_real\_ord\_ore.
* [`gte(jsonb, eql_v3_numeric_ord_ore)`](#gtejsonb-eql_v3_numeric_ord_ore) - Operator wrapper for public.eql\_v3\_numeric\_ord\_ore.
* [`gte(eql_v3_numeric_ord_ore, jsonb)`](#gteeql_v3_numeric_ord_ore-jsonb) - Operator wrapper for public.eql\_v3\_numeric\_ord\_ore.
* [`gte(eql_v3_numeric_ord_ore, eql_v3_numeric_ord_ore)`](#gteeql_v3_numeric_ord_ore-eql_v3_numeric_ord_ore) - Operator wrapper for public.eql\_v3\_numeric\_ord\_ore.
* [`gte(query_text_ord_ope, eql_v3_text_ord_ope)`](#gtequery_text_ord_ope-eql_v3_text_ord_ope) - Operator wrapper for eql\_v3.query\_text\_ord\_ope.
* [`gte(eql_v3_text_ord_ope, query_text_ord_ope)`](#gteeql_v3_text_ord_ope-query_text_ord_ope) - Operator wrapper for eql\_v3.query\_text\_ord\_ope.
* [`gte(jsonb, eql_v3_bigint_ord_ope)`](#gtejsonb-eql_v3_bigint_ord_ope) - Operator wrapper for public.eql\_v3\_bigint\_ord\_ope.
* [`gte(eql_v3_bigint_ord_ope, jsonb)`](#gteeql_v3_bigint_ord_ope-jsonb) - Operator wrapper for public.eql\_v3\_bigint\_ord\_ope.
* [`gte(eql_v3_bigint_ord_ope, eql_v3_bigint_ord_ope)`](#gteeql_v3_bigint_ord_ope-eql_v3_bigint_ord_ope) - Operator wrapper for public.eql\_v3\_bigint\_ord\_ope.
* [`gte(query_numeric_ord, eql_v3_json_entry)`](#gtequery_numeric_ord-eql_v3_json_entry) - Operator wrapper for public.eql\_v3\_json\_entry.
* [`gte(eql_v3_json_entry, query_numeric_ord)`](#gteeql_v3_json_entry-query_numeric_ord) - Operator wrapper for public.eql\_v3\_json\_entry.
* [`gte(jsonb, eql_v3_double_ord_ore)`](#gtejsonb-eql_v3_double_ord_ore) - Operator wrapper for public.eql\_v3\_double\_ord\_ore.
* [`gte(eql_v3_double_ord_ore, jsonb)`](#gteeql_v3_double_ord_ore-jsonb) - Operator wrapper for public.eql\_v3\_double\_ord\_ore.
* [`gte(eql_v3_double_ord_ore, eql_v3_double_ord_ore)`](#gteeql_v3_double_ord_ore-eql_v3_double_ord_ore) - Operator wrapper for public.eql\_v3\_double\_ord\_ore.
* [`gte(jsonb, eql_v3_bigint_ord)`](#gtejsonb-eql_v3_bigint_ord) - Operator wrapper for public.eql\_v3\_bigint\_ord.
* [`gte(eql_v3_bigint_ord, jsonb)`](#gteeql_v3_bigint_ord-jsonb) - Operator wrapper for public.eql\_v3\_bigint\_ord.
* [`gte(eql_v3_bigint_ord, eql_v3_bigint_ord)`](#gteeql_v3_bigint_ord-eql_v3_bigint_ord) - Operator wrapper for public.eql\_v3\_bigint\_ord.
* [`gte(query_text_ord, eql_v3_json_entry)`](#gtequery_text_ord-eql_v3_json_entry) - Operator wrapper for public.eql\_v3\_json\_entry.
* [`gte(eql_v3_json_entry, query_text_ord)`](#gteeql_v3_json_entry-query_text_ord) - Operator wrapper for public.eql\_v3\_json\_entry.
* [`gte(query_timestamp_ord_ope, eql_v3_timestamp_ord_ope)`](#gtequery_timestamp_ord_ope-eql_v3_timestamp_ord_ope) - Operator wrapper for eql\_v3.query\_timestamp\_ord\_ope.
* [`gte(eql_v3_timestamp_ord_ope, query_timestamp_ord_ope)`](#gteeql_v3_timestamp_ord_ope-query_timestamp_ord_ope) - Operator wrapper for eql\_v3.query\_timestamp\_ord\_ope.
* [`gte(query_numeric_ord, eql_v3_numeric_ord)`](#gtequery_numeric_ord-eql_v3_numeric_ord) - Operator wrapper for eql\_v3.query\_numeric\_ord.
* [`gte(eql_v3_numeric_ord, query_numeric_ord)`](#gteeql_v3_numeric_ord-query_numeric_ord) - Operator wrapper for eql\_v3.query\_numeric\_ord.
* [`gte(jsonb, eql_v3_text_search_ore)`](#gtejsonb-eql_v3_text_search_ore) - Operator wrapper for public.eql\_v3\_text\_search\_ore.
* [`gte(eql_v3_text_search_ore, jsonb)`](#gteeql_v3_text_search_ore-jsonb) - Operator wrapper for public.eql\_v3\_text\_search\_ore.
* [`gte(eql_v3_text_search_ore, eql_v3_text_search_ore)`](#gteeql_v3_text_search_ore-eql_v3_text_search_ore) - Operator wrapper for public.eql\_v3\_text\_search\_ore.
* [`gte(query_real_ord_ope, eql_v3_real_ord_ope)`](#gtequery_real_ord_ope-eql_v3_real_ord_ope) - Operator wrapper for eql\_v3.query\_real\_ord\_ope.
* [`gte(eql_v3_real_ord_ope, query_real_ord_ope)`](#gteeql_v3_real_ord_ope-query_real_ord_ope) - Operator wrapper for eql\_v3.query\_real\_ord\_ope.
* [`gte(jsonb, eql_v3_timestamp_ord)`](#gtejsonb-eql_v3_timestamp_ord) - Operator wrapper for public.eql\_v3\_timestamp\_ord.
* [`gte(eql_v3_timestamp_ord, jsonb)`](#gteeql_v3_timestamp_ord-jsonb) - Operator wrapper for public.eql\_v3\_timestamp\_ord.
* [`gte(eql_v3_timestamp_ord, eql_v3_timestamp_ord)`](#gteeql_v3_timestamp_ord-eql_v3_timestamp_ord) - Operator wrapper for public.eql\_v3\_timestamp\_ord.
* [`gte(jsonb, eql_v3_smallint_ord_ope)`](#gtejsonb-eql_v3_smallint_ord_ope) - Operator wrapper for public.eql\_v3\_smallint\_ord\_ope.
* [`gte(eql_v3_smallint_ord_ope, jsonb)`](#gteeql_v3_smallint_ord_ope-jsonb) - Operator wrapper for public.eql\_v3\_smallint\_ord\_ope.
* [`gte(eql_v3_smallint_ord_ope, eql_v3_smallint_ord_ope)`](#gteeql_v3_smallint_ord_ope-eql_v3_smallint_ord_ope) - Operator wrapper for public.eql\_v3\_smallint\_ord\_ope.
* [`gte(query_integer_ord, eql_v3_json_entry)`](#gtequery_integer_ord-eql_v3_json_entry) - Operator wrapper for public.eql\_v3\_json\_entry.
* [`gte(eql_v3_json_entry, query_integer_ord)`](#gteeql_v3_json_entry-query_integer_ord) - Operator wrapper for public.eql\_v3\_json\_entry.
* [`gte(query_real_ord, eql_v3_json_entry)`](#gtequery_real_ord-eql_v3_json_entry) - Operator wrapper for public.eql\_v3\_json\_entry.
* [`gte(eql_v3_json_entry, query_real_ord)`](#gteeql_v3_json_entry-query_real_ord) - Operator wrapper for public.eql\_v3\_json\_entry.
* [`gte(query_double_ord, eql_v3_double_ord)`](#gtequery_double_ord-eql_v3_double_ord) - Operator wrapper for eql\_v3.query\_double\_ord.
* [`gte(eql_v3_double_ord, query_double_ord)`](#gteeql_v3_double_ord-query_double_ord) - Operator wrapper for eql\_v3.query\_double\_ord.
* [`gte(query_double_ord_ore, eql_v3_double_ord_ore)`](#gtequery_double_ord_ore-eql_v3_double_ord_ore) - Operator wrapper for eql\_v3.query\_double\_ord\_ore.
* [`gte(eql_v3_double_ord_ore, query_double_ord_ore)`](#gteeql_v3_double_ord_ore-query_double_ord_ore) - Operator wrapper for eql\_v3.query\_double\_ord\_ore.
* [`gte(jsonb, eql_v3_timestamp_ord_ore)`](#gtejsonb-eql_v3_timestamp_ord_ore) - Operator wrapper for public.eql\_v3\_timestamp\_ord\_ore.
* [`gte(eql_v3_timestamp_ord_ore, jsonb)`](#gteeql_v3_timestamp_ord_ore-jsonb) - Operator wrapper for public.eql\_v3\_timestamp\_ord\_ore.
* [`gte(eql_v3_timestamp_ord_ore, eql_v3_timestamp_ord_ore)`](#gteeql_v3_timestamp_ord_ore-eql_v3_timestamp_ord_ore) - Operator wrapper for public.eql\_v3\_timestamp\_ord\_ore.
* [`gte(jsonb, eql_v3_text_search)`](#gtejsonb-eql_v3_text_search) - Operator wrapper for public.eql\_v3\_text\_search.
* [`gte(eql_v3_text_search, jsonb)`](#gteeql_v3_text_search-jsonb) - Operator wrapper for public.eql\_v3\_text\_search.
* [`gte(eql_v3_text_search, eql_v3_text_search)`](#gteeql_v3_text_search-eql_v3_text_search) - Operator wrapper for public.eql\_v3\_text\_search.
* [`gte(query_numeric_ord_ore, eql_v3_numeric_ord_ore)`](#gtequery_numeric_ord_ore-eql_v3_numeric_ord_ore) - Operator wrapper for eql\_v3.query\_numeric\_ord\_ore.
* [`gte(eql_v3_numeric_ord_ore, query_numeric_ord_ore)`](#gteeql_v3_numeric_ord_ore-query_numeric_ord_ore) - Operator wrapper for eql\_v3.query\_numeric\_ord\_ore.
* [`gte(query_bigint_ord_ore, eql_v3_bigint_ord_ore)`](#gtequery_bigint_ord_ore-eql_v3_bigint_ord_ore) - Operator wrapper for eql\_v3.query\_bigint\_ord\_ore.
* [`gte(eql_v3_bigint_ord_ore, query_bigint_ord_ore)`](#gteeql_v3_bigint_ord_ore-query_bigint_ord_ore) - Operator wrapper for eql\_v3.query\_bigint\_ord\_ore.
* [`gte(query_bigint_ord_ope, eql_v3_bigint_ord_ope)`](#gtequery_bigint_ord_ope-eql_v3_bigint_ord_ope) - Operator wrapper for eql\_v3.query\_bigint\_ord\_ope.
* [`gte(eql_v3_bigint_ord_ope, query_bigint_ord_ope)`](#gteeql_v3_bigint_ord_ope-query_bigint_ord_ope) - Operator wrapper for eql\_v3.query\_bigint\_ord\_ope.
* [`gte(query_date_ord_ore, eql_v3_date_ord_ore)`](#gtequery_date_ord_ore-eql_v3_date_ord_ore) - Operator wrapper for eql\_v3.query\_date\_ord\_ore.
* [`gte(eql_v3_date_ord_ore, query_date_ord_ore)`](#gteeql_v3_date_ord_ore-query_date_ord_ore) - Operator wrapper for eql\_v3.query\_date\_ord\_ore.
* [`gte(query_smallint_ord_ope, eql_v3_smallint_ord_ope)`](#gtequery_smallint_ord_ope-eql_v3_smallint_ord_ope) - Operator wrapper for eql\_v3.query\_smallint\_ord\_ope.
* [`gte(eql_v3_smallint_ord_ope, query_smallint_ord_ope)`](#gteeql_v3_smallint_ord_ope-query_smallint_ord_ope) - Operator wrapper for eql\_v3.query\_smallint\_ord\_ope.
* [`gte(jsonb, eql_v3_double_ord)`](#gtejsonb-eql_v3_double_ord) - Operator wrapper for public.eql\_v3\_double\_ord.
* [`gte(eql_v3_double_ord, jsonb)`](#gteeql_v3_double_ord-jsonb) - Operator wrapper for public.eql\_v3\_double\_ord.
* [`gte(eql_v3_double_ord, eql_v3_double_ord)`](#gteeql_v3_double_ord-eql_v3_double_ord) - Operator wrapper for public.eql\_v3\_double\_ord.
* [`gte(query_numeric_ord_ope, eql_v3_numeric_ord_ope)`](#gtequery_numeric_ord_ope-eql_v3_numeric_ord_ope) - Operator wrapper for eql\_v3.query\_numeric\_ord\_ope.
* [`gte(eql_v3_numeric_ord_ope, query_numeric_ord_ope)`](#gteeql_v3_numeric_ord_ope-query_numeric_ord_ope) - Operator wrapper for eql\_v3.query\_numeric\_ord\_ope.
* [`gte(jsonb, eql_v3_double_ord_ope)`](#gtejsonb-eql_v3_double_ord_ope) - Operator wrapper for public.eql\_v3\_double\_ord\_ope.
* [`gte(eql_v3_double_ord_ope, jsonb)`](#gteeql_v3_double_ord_ope-jsonb) - Operator wrapper for public.eql\_v3\_double\_ord\_ope.
* [`gte(eql_v3_double_ord_ope, eql_v3_double_ord_ope)`](#gteeql_v3_double_ord_ope-eql_v3_double_ord_ope) - Operator wrapper for public.eql\_v3\_double\_ord\_ope.
* [`gte(jsonb, eql_v3_numeric_ord_ope)`](#gtejsonb-eql_v3_numeric_ord_ope) - Operator wrapper for public.eql\_v3\_numeric\_ord\_ope.
* [`gte(eql_v3_numeric_ord_ope, jsonb)`](#gteeql_v3_numeric_ord_ope-jsonb) - Operator wrapper for public.eql\_v3\_numeric\_ord\_ope.
* [`gte(eql_v3_numeric_ord_ope, eql_v3_numeric_ord_ope)`](#gteeql_v3_numeric_ord_ope-eql_v3_numeric_ord_ope) - Operator wrapper for public.eql\_v3\_numeric\_ord\_ope.
* [`gte(jsonb, eql_v3_date_ord_ore)`](#gtejsonb-eql_v3_date_ord_ore) - Operator wrapper for public.eql\_v3\_date\_ord\_ore.
* [`gte(eql_v3_date_ord_ore, jsonb)`](#gteeql_v3_date_ord_ore-jsonb) - Operator wrapper for public.eql\_v3\_date\_ord\_ore.
* [`gte(eql_v3_date_ord_ore, eql_v3_date_ord_ore)`](#gteeql_v3_date_ord_ore-eql_v3_date_ord_ore) - Operator wrapper for public.eql\_v3\_date\_ord\_ore.
* [`gte(query_timestamp_ord, eql_v3_timestamp_ord)`](#gtequery_timestamp_ord-eql_v3_timestamp_ord) - Operator wrapper for eql\_v3.query\_timestamp\_ord.
* [`gte(eql_v3_timestamp_ord, query_timestamp_ord)`](#gteeql_v3_timestamp_ord-query_timestamp_ord) - Operator wrapper for eql\_v3.query\_timestamp\_ord.
* [`gte(jsonb, eql_v3_smallint_ord_ore)`](#gtejsonb-eql_v3_smallint_ord_ore) - Operator wrapper for public.eql\_v3\_smallint\_ord\_ore.
* [`gte(eql_v3_smallint_ord_ore, jsonb)`](#gteeql_v3_smallint_ord_ore-jsonb) - Operator wrapper for public.eql\_v3\_smallint\_ord\_ore.
* [`gte(eql_v3_smallint_ord_ore, eql_v3_smallint_ord_ore)`](#gteeql_v3_smallint_ord_ore-eql_v3_smallint_ord_ore) - Operator wrapper for public.eql\_v3\_smallint\_ord\_ore.
* [`gte(jsonb, eql_v3_date_ord_ope)`](#gtejsonb-eql_v3_date_ord_ope) - Operator wrapper for public.eql\_v3\_date\_ord\_ope.
* [`gte(eql_v3_date_ord_ope, jsonb)`](#gteeql_v3_date_ord_ope-jsonb) - Operator wrapper for public.eql\_v3\_date\_ord\_ope.
* [`gte(eql_v3_date_ord_ope, eql_v3_date_ord_ope)`](#gteeql_v3_date_ord_ope-eql_v3_date_ord_ope) - Operator wrapper for public.eql\_v3\_date\_ord\_ope.
* [`gte(query_bigint_ord, eql_v3_bigint_ord)`](#gtequery_bigint_ord-eql_v3_bigint_ord) - Operator wrapper for eql\_v3.query\_bigint\_ord.
* [`gte(eql_v3_bigint_ord, query_bigint_ord)`](#gteeql_v3_bigint_ord-query_bigint_ord) - Operator wrapper for eql\_v3.query\_bigint\_ord.
* [`gte(jsonb, eql_v3_text_ord_ore)`](#gtejsonb-eql_v3_text_ord_ore) - Operator wrapper for public.eql\_v3\_text\_ord\_ore.
* [`gte(eql_v3_text_ord_ore, jsonb)`](#gteeql_v3_text_ord_ore-jsonb) - Operator wrapper for public.eql\_v3\_text\_ord\_ore.
* [`gte(eql_v3_text_ord_ore, eql_v3_text_ord_ore)`](#gteeql_v3_text_ord_ore-eql_v3_text_ord_ore) - Operator wrapper for public.eql\_v3\_text\_ord\_ore.
* [`gte(query_bigint_ord, eql_v3_json_entry)`](#gtequery_bigint_ord-eql_v3_json_entry) - Operator wrapper for public.eql\_v3\_json\_entry.
* [`gte(eql_v3_json_entry, query_bigint_ord)`](#gteeql_v3_json_entry-query_bigint_ord) - Operator wrapper for public.eql\_v3\_json\_entry.
* [`jsonb_array(jsonb)`](#jsonb_arrayjsonb) - Extract deterministic containment fields (s) per sv element.
* [`jsonb_array_elements(jsonb)`](#jsonb_array_elementsjsonb) - Extract elements of an encrypted JSONB array as rows.
* [`jsonb_array_length(jsonb)`](#jsonb_array_lengthjsonb) - Get the length of an encrypted JSONB array.
* [`jsonb_contained_by(jsonb, jsonb)`](#jsonb_contained_byjsonb-jsonb) - GIN-indexable "is contained by" check.
* [`jsonb_contains(jsonb, jsonb)`](#jsonb_containsjsonb-jsonb) - GIN-indexable containment check: does a contain all of b?
* [`jsonb_path_exists(jsonb, text)`](#jsonb_path_existsjsonb-text) - Check if a selector path exists in encrypted JSONB.
* [`jsonb_path_query(jsonb, text)`](#jsonb_path_queryjsonb-text) - Query encrypted JSONB for sv elements matching selector.
* [`jsonb_path_query_first(jsonb, text)`](#jsonb_path_query_firstjsonb-text) - Get the first sv element matching selector, or NULL.
* [`lints()`](#lints) - EQL lint: detect non-inlinable operator implementation functions.
* [`lt(jsonb, eql_v3_integer_ord_ore)`](#ltjsonb-eql_v3_integer_ord_ore) - Operator wrapper for public.eql\_v3\_integer\_ord\_ore.
* [`lt(eql_v3_integer_ord_ore, jsonb)`](#lteql_v3_integer_ord_ore-jsonb) - Operator wrapper for public.eql\_v3\_integer\_ord\_ore.
* [`lt(eql_v3_integer_ord_ore, eql_v3_integer_ord_ore)`](#lteql_v3_integer_ord_ore-eql_v3_integer_ord_ore) - Operator wrapper for public.eql\_v3\_integer\_ord\_ore.
* [`lt(query_smallint_ord, eql_v3_smallint_ord)`](#ltquery_smallint_ord-eql_v3_smallint_ord) - Operator wrapper for eql\_v3.query\_smallint\_ord.
* [`lt(eql_v3_smallint_ord, query_smallint_ord)`](#lteql_v3_smallint_ord-query_smallint_ord) - Operator wrapper for eql\_v3.query\_smallint\_ord.
* [`lt(jsonb, eql_v3_smallint_ord)`](#ltjsonb-eql_v3_smallint_ord) - Operator wrapper for public.eql\_v3\_smallint\_ord.
* [`lt(eql_v3_smallint_ord, jsonb)`](#lteql_v3_smallint_ord-jsonb) - Operator wrapper for public.eql\_v3\_smallint\_ord.
* [`lt(eql_v3_smallint_ord, eql_v3_smallint_ord)`](#lteql_v3_smallint_ord-eql_v3_smallint_ord) - Operator wrapper for public.eql\_v3\_smallint\_ord.
* [`lt(jsonb, eql_v3_date_ord)`](#ltjsonb-eql_v3_date_ord) - Operator wrapper for public.eql\_v3\_date\_ord.
* [`lt(eql_v3_date_ord, jsonb)`](#lteql_v3_date_ord-jsonb) - Operator wrapper for public.eql\_v3\_date\_ord.
* [`lt(eql_v3_date_ord, eql_v3_date_ord)`](#lteql_v3_date_ord-eql_v3_date_ord) - Operator wrapper for public.eql\_v3\_date\_ord.
* [`lt(query_real_ord, eql_v3_real_ord)`](#ltquery_real_ord-eql_v3_real_ord) - Operator wrapper for eql\_v3.query\_real\_ord.
* [`lt(eql_v3_real_ord, query_real_ord)`](#lteql_v3_real_ord-query_real_ord) - Operator wrapper for eql\_v3.query\_real\_ord.
* [`lt(query_double_ord, eql_v3_json_entry)`](#ltquery_double_ord-eql_v3_json_entry) - Operator wrapper for public.eql\_v3\_json\_entry.
* [`lt(eql_v3_json_entry, query_double_ord)`](#lteql_v3_json_entry-query_double_ord) - Operator wrapper for public.eql\_v3\_json\_entry.
* [`lt(query_real_ord_ore, eql_v3_real_ord_ore)`](#ltquery_real_ord_ore-eql_v3_real_ord_ore) - Operator wrapper for eql\_v3.query\_real\_ord\_ore.
* [`lt(eql_v3_real_ord_ore, query_real_ord_ore)`](#lteql_v3_real_ord_ore-query_real_ord_ore) - Operator wrapper for eql\_v3.query\_real\_ord\_ore.
* [`lt(jsonb, eql_v3_text_ord)`](#ltjsonb-eql_v3_text_ord) - Operator wrapper for public.eql\_v3\_text\_ord.
* [`lt(eql_v3_text_ord, jsonb)`](#lteql_v3_text_ord-jsonb) - Operator wrapper for public.eql\_v3\_text\_ord.
* [`lt(eql_v3_text_ord, eql_v3_text_ord)`](#lteql_v3_text_ord-eql_v3_text_ord) - Operator wrapper for public.eql\_v3\_text\_ord.
* [`lt(query_integer_ord_ope, eql_v3_integer_ord_ope)`](#ltquery_integer_ord_ope-eql_v3_integer_ord_ope) - Operator wrapper for eql\_v3.query\_integer\_ord\_ope.
* [`lt(eql_v3_integer_ord_ope, query_integer_ord_ope)`](#lteql_v3_integer_ord_ope-query_integer_ord_ope) - Operator wrapper for eql\_v3.query\_integer\_ord\_ope.
* [`lt(query_text_ord, eql_v3_text_ord)`](#ltquery_text_ord-eql_v3_text_ord) - Operator wrapper for eql\_v3.query\_text\_ord.
* [`lt(eql_v3_text_ord, query_text_ord)`](#lteql_v3_text_ord-query_text_ord) - Operator wrapper for eql\_v3.query\_text\_ord.
* [`lt(jsonb, eql_v3_timestamp_ord_ope)`](#ltjsonb-eql_v3_timestamp_ord_ope) - Operator wrapper for public.eql\_v3\_timestamp\_ord\_ope.
* [`lt(eql_v3_timestamp_ord_ope, jsonb)`](#lteql_v3_timestamp_ord_ope-jsonb) - Operator wrapper for public.eql\_v3\_timestamp\_ord\_ope.
* [`lt(eql_v3_timestamp_ord_ope, eql_v3_timestamp_ord_ope)`](#lteql_v3_timestamp_ord_ope-eql_v3_timestamp_ord_ope) - Operator wrapper for public.eql\_v3\_timestamp\_ord\_ope.
* [`lt(jsonb, eql_v3_integer_ord_ope)`](#ltjsonb-eql_v3_integer_ord_ope) - Operator wrapper for public.eql\_v3\_integer\_ord\_ope.
* [`lt(eql_v3_integer_ord_ope, jsonb)`](#lteql_v3_integer_ord_ope-jsonb) - Operator wrapper for public.eql\_v3\_integer\_ord\_ope.
* [`lt(eql_v3_integer_ord_ope, eql_v3_integer_ord_ope)`](#lteql_v3_integer_ord_ope-eql_v3_integer_ord_ope) - Operator wrapper for public.eql\_v3\_integer\_ord\_ope.
* [`lt(query_integer_ord, eql_v3_integer_ord)`](#ltquery_integer_ord-eql_v3_integer_ord) - Operator wrapper for eql\_v3.query\_integer\_ord.
* [`lt(eql_v3_integer_ord, query_integer_ord)`](#lteql_v3_integer_ord-query_integer_ord) - Operator wrapper for eql\_v3.query\_integer\_ord.
* [`lt(query_text_search, eql_v3_text_search)`](#ltquery_text_search-eql_v3_text_search) - Operator wrapper for eql\_v3.query\_text\_search.
* [`lt(eql_v3_text_search, query_text_search)`](#lteql_v3_text_search-query_text_search) - Operator wrapper for eql\_v3.query\_text\_search.
* [`lt(jsonb, eql_v3_numeric_ord)`](#ltjsonb-eql_v3_numeric_ord) - Operator wrapper for public.eql\_v3\_numeric\_ord.
* [`lt(eql_v3_numeric_ord, jsonb)`](#lteql_v3_numeric_ord-jsonb) - Operator wrapper for public.eql\_v3\_numeric\_ord.
* [`lt(eql_v3_numeric_ord, eql_v3_numeric_ord)`](#lteql_v3_numeric_ord-eql_v3_numeric_ord) - Operator wrapper for public.eql\_v3\_numeric\_ord.
* [`lt(query_date_ord_ope, eql_v3_date_ord_ope)`](#ltquery_date_ord_ope-eql_v3_date_ord_ope) - Operator wrapper for eql\_v3.query\_date\_ord\_ope.
* [`lt(eql_v3_date_ord_ope, query_date_ord_ope)`](#lteql_v3_date_ord_ope-query_date_ord_ope) - Operator wrapper for eql\_v3.query\_date\_ord\_ope.
* [`lt(query_smallint_ord, eql_v3_json_entry)`](#ltquery_smallint_ord-eql_v3_json_entry) - Operator wrapper for public.eql\_v3\_json\_entry.
* [`lt(eql_v3_json_entry, query_smallint_ord)`](#lteql_v3_json_entry-query_smallint_ord) - Operator wrapper for public.eql\_v3\_json\_entry.
* [`lt(query_timestamp_ord_ore, eql_v3_timestamp_ord_ore)`](#ltquery_timestamp_ord_ore-eql_v3_timestamp_ord_ore) - Operator wrapper for eql\_v3.query\_timestamp\_ord\_ore.
* [`lt(eql_v3_timestamp_ord_ore, query_timestamp_ord_ore)`](#lteql_v3_timestamp_ord_ore-query_timestamp_ord_ore) - Operator wrapper for eql\_v3.query\_timestamp\_ord\_ore.
* [`lt(query_text_search_ore, eql_v3_text_search_ore)`](#ltquery_text_search_ore-eql_v3_text_search_ore) - Operator wrapper for eql\_v3.query\_text\_search\_ore.
* [`lt(eql_v3_text_search_ore, query_text_search_ore)`](#lteql_v3_text_search_ore-query_text_search_ore) - Operator wrapper for eql\_v3.query\_text\_search\_ore.
* [`lt(query_text_ord_ore, eql_v3_text_ord_ore)`](#ltquery_text_ord_ore-eql_v3_text_ord_ore) - Operator wrapper for eql\_v3.query\_text\_ord\_ore.
* [`lt(eql_v3_text_ord_ore, query_text_ord_ore)`](#lteql_v3_text_ord_ore-query_text_ord_ore) - Operator wrapper for eql\_v3.query\_text\_ord\_ore.
* [`lt(jsonb, eql_v3_real_ord_ope)`](#ltjsonb-eql_v3_real_ord_ope) - Operator wrapper for public.eql\_v3\_real\_ord\_ope.
* [`lt(eql_v3_real_ord_ope, jsonb)`](#lteql_v3_real_ord_ope-jsonb) - Operator wrapper for public.eql\_v3\_real\_ord\_ope.
* [`lt(eql_v3_real_ord_ope, eql_v3_real_ord_ope)`](#lteql_v3_real_ord_ope-eql_v3_real_ord_ope) - Operator wrapper for public.eql\_v3\_real\_ord\_ope.
* [`lt(jsonb, eql_v3_real_ord)`](#ltjsonb-eql_v3_real_ord) - Operator wrapper for public.eql\_v3\_real\_ord.
* [`lt(eql_v3_real_ord, jsonb)`](#lteql_v3_real_ord-jsonb) - Operator wrapper for public.eql\_v3\_real\_ord.
* [`lt(eql_v3_real_ord, eql_v3_real_ord)`](#lteql_v3_real_ord-eql_v3_real_ord) - Operator wrapper for public.eql\_v3\_real\_ord.
* [`lt(jsonb, eql_v3_integer_ord)`](#ltjsonb-eql_v3_integer_ord) - Operator wrapper for public.eql\_v3\_integer\_ord.
* [`lt(eql_v3_integer_ord, jsonb)`](#lteql_v3_integer_ord-jsonb) - Operator wrapper for public.eql\_v3\_integer\_ord.
* [`lt(eql_v3_integer_ord, eql_v3_integer_ord)`](#lteql_v3_integer_ord-eql_v3_integer_ord) - Operator wrapper for public.eql\_v3\_integer\_ord.
* [`lt(query_smallint_ord_ore, eql_v3_smallint_ord_ore)`](#ltquery_smallint_ord_ore-eql_v3_smallint_ord_ore) - Operator wrapper for eql\_v3.query\_smallint\_ord\_ore.
* [`lt(eql_v3_smallint_ord_ore, query_smallint_ord_ore)`](#lteql_v3_smallint_ord_ore-query_smallint_ord_ore) - Operator wrapper for eql\_v3.query\_smallint\_ord\_ore.
* [`lt(jsonb, eql_v3_text_ord_ope)`](#ltjsonb-eql_v3_text_ord_ope) - Operator wrapper for public.eql\_v3\_text\_ord\_ope.
* [`lt(eql_v3_text_ord_ope, jsonb)`](#lteql_v3_text_ord_ope-jsonb) - Operator wrapper for public.eql\_v3\_text\_ord\_ope.
* [`lt(eql_v3_text_ord_ope, eql_v3_text_ord_ope)`](#lteql_v3_text_ord_ope-eql_v3_text_ord_ope) - Operator wrapper for public.eql\_v3\_text\_ord\_ope.
* [`lt(query_double_ord_ope, eql_v3_double_ord_ope)`](#ltquery_double_ord_ope-eql_v3_double_ord_ope) - Operator wrapper for eql\_v3.query\_double\_ord\_ope.
* [`lt(eql_v3_double_ord_ope, query_double_ord_ope)`](#lteql_v3_double_ord_ope-query_double_ord_ope) - Operator wrapper for eql\_v3.query\_double\_ord\_ope.
* [`lt(query_integer_ord_ore, eql_v3_integer_ord_ore)`](#ltquery_integer_ord_ore-eql_v3_integer_ord_ore) - Operator wrapper for eql\_v3.query\_integer\_ord\_ore.
* [`lt(eql_v3_integer_ord_ore, query_integer_ord_ore)`](#lteql_v3_integer_ord_ore-query_integer_ord_ore) - Operator wrapper for eql\_v3.query\_integer\_ord\_ore.
* [`lt(jsonb, eql_v3_bigint_ord_ore)`](#ltjsonb-eql_v3_bigint_ord_ore) - Operator wrapper for public.eql\_v3\_bigint\_ord\_ore.
* [`lt(eql_v3_bigint_ord_ore, jsonb)`](#lteql_v3_bigint_ord_ore-jsonb) - Operator wrapper for public.eql\_v3\_bigint\_ord\_ore.
* [`lt(eql_v3_bigint_ord_ore, eql_v3_bigint_ord_ore)`](#lteql_v3_bigint_ord_ore-eql_v3_bigint_ord_ore) - Operator wrapper for public.eql\_v3\_bigint\_ord\_ore.
* [`lt(query_date_ord, eql_v3_date_ord)`](#ltquery_date_ord-eql_v3_date_ord) - Operator wrapper for eql\_v3.query\_date\_ord.
* [`lt(eql_v3_date_ord, query_date_ord)`](#lteql_v3_date_ord-query_date_ord) - Operator wrapper for eql\_v3.query\_date\_ord.
* [`lt(jsonb, eql_v3_real_ord_ore)`](#ltjsonb-eql_v3_real_ord_ore) - Operator wrapper for public.eql\_v3\_real\_ord\_ore.
* [`lt(eql_v3_real_ord_ore, jsonb)`](#lteql_v3_real_ord_ore-jsonb) - Operator wrapper for public.eql\_v3\_real\_ord\_ore.
* [`lt(eql_v3_real_ord_ore, eql_v3_real_ord_ore)`](#lteql_v3_real_ord_ore-eql_v3_real_ord_ore) - Operator wrapper for public.eql\_v3\_real\_ord\_ore.
* [`lt(jsonb, eql_v3_numeric_ord_ore)`](#ltjsonb-eql_v3_numeric_ord_ore) - Operator wrapper for public.eql\_v3\_numeric\_ord\_ore.
* [`lt(eql_v3_numeric_ord_ore, jsonb)`](#lteql_v3_numeric_ord_ore-jsonb) - Operator wrapper for public.eql\_v3\_numeric\_ord\_ore.
* [`lt(eql_v3_numeric_ord_ore, eql_v3_numeric_ord_ore)`](#lteql_v3_numeric_ord_ore-eql_v3_numeric_ord_ore) - Operator wrapper for public.eql\_v3\_numeric\_ord\_ore.
* [`lt(query_text_ord_ope, eql_v3_text_ord_ope)`](#ltquery_text_ord_ope-eql_v3_text_ord_ope) - Operator wrapper for eql\_v3.query\_text\_ord\_ope.
* [`lt(eql_v3_text_ord_ope, query_text_ord_ope)`](#lteql_v3_text_ord_ope-query_text_ord_ope) - Operator wrapper for eql\_v3.query\_text\_ord\_ope.
* [`lt(jsonb, eql_v3_bigint_ord_ope)`](#ltjsonb-eql_v3_bigint_ord_ope) - Operator wrapper for public.eql\_v3\_bigint\_ord\_ope.
* [`lt(eql_v3_bigint_ord_ope, jsonb)`](#lteql_v3_bigint_ord_ope-jsonb) - Operator wrapper for public.eql\_v3\_bigint\_ord\_ope.
* [`lt(eql_v3_bigint_ord_ope, eql_v3_bigint_ord_ope)`](#lteql_v3_bigint_ord_ope-eql_v3_bigint_ord_ope) - Operator wrapper for public.eql\_v3\_bigint\_ord\_ope.
* [`lt(query_numeric_ord, eql_v3_json_entry)`](#ltquery_numeric_ord-eql_v3_json_entry) - Operator wrapper for public.eql\_v3\_json\_entry.
* [`lt(eql_v3_json_entry, query_numeric_ord)`](#lteql_v3_json_entry-query_numeric_ord) - Operator wrapper for public.eql\_v3\_json\_entry.
* [`lt(jsonb, eql_v3_double_ord_ore)`](#ltjsonb-eql_v3_double_ord_ore) - Operator wrapper for public.eql\_v3\_double\_ord\_ore.
* [`lt(eql_v3_double_ord_ore, jsonb)`](#lteql_v3_double_ord_ore-jsonb) - Operator wrapper for public.eql\_v3\_double\_ord\_ore.
* [`lt(eql_v3_double_ord_ore, eql_v3_double_ord_ore)`](#lteql_v3_double_ord_ore-eql_v3_double_ord_ore) - Operator wrapper for public.eql\_v3\_double\_ord\_ore.
* [`lt(jsonb, eql_v3_bigint_ord)`](#ltjsonb-eql_v3_bigint_ord) - Operator wrapper for public.eql\_v3\_bigint\_ord.
* [`lt(eql_v3_bigint_ord, jsonb)`](#lteql_v3_bigint_ord-jsonb) - Operator wrapper for public.eql\_v3\_bigint\_ord.
* [`lt(eql_v3_bigint_ord, eql_v3_bigint_ord)`](#lteql_v3_bigint_ord-eql_v3_bigint_ord) - Operator wrapper for public.eql\_v3\_bigint\_ord.
* [`lt(query_text_ord, eql_v3_json_entry)`](#ltquery_text_ord-eql_v3_json_entry) - Operator wrapper for public.eql\_v3\_json\_entry.
* [`lt(eql_v3_json_entry, query_text_ord)`](#lteql_v3_json_entry-query_text_ord) - Operator wrapper for public.eql\_v3\_json\_entry.
* [`lt(query_timestamp_ord_ope, eql_v3_timestamp_ord_ope)`](#ltquery_timestamp_ord_ope-eql_v3_timestamp_ord_ope) - Operator wrapper for eql\_v3.query\_timestamp\_ord\_ope.
* [`lt(eql_v3_timestamp_ord_ope, query_timestamp_ord_ope)`](#lteql_v3_timestamp_ord_ope-query_timestamp_ord_ope) - Operator wrapper for eql\_v3.query\_timestamp\_ord\_ope.
* [`lt(query_numeric_ord, eql_v3_numeric_ord)`](#ltquery_numeric_ord-eql_v3_numeric_ord) - Operator wrapper for eql\_v3.query\_numeric\_ord.
* [`lt(eql_v3_numeric_ord, query_numeric_ord)`](#lteql_v3_numeric_ord-query_numeric_ord) - Operator wrapper for eql\_v3.query\_numeric\_ord.
* [`lt(jsonb, eql_v3_text_search_ore)`](#ltjsonb-eql_v3_text_search_ore) - Operator wrapper for public.eql\_v3\_text\_search\_ore.
* [`lt(eql_v3_text_search_ore, jsonb)`](#lteql_v3_text_search_ore-jsonb) - Operator wrapper for public.eql\_v3\_text\_search\_ore.
* [`lt(eql_v3_text_search_ore, eql_v3_text_search_ore)`](#lteql_v3_text_search_ore-eql_v3_text_search_ore) - Operator wrapper for public.eql\_v3\_text\_search\_ore.
* [`lt(query_real_ord_ope, eql_v3_real_ord_ope)`](#ltquery_real_ord_ope-eql_v3_real_ord_ope) - Operator wrapper for eql\_v3.query\_real\_ord\_ope.
* [`lt(eql_v3_real_ord_ope, query_real_ord_ope)`](#lteql_v3_real_ord_ope-query_real_ord_ope) - Operator wrapper for eql\_v3.query\_real\_ord\_ope.
* [`lt(jsonb, eql_v3_timestamp_ord)`](#ltjsonb-eql_v3_timestamp_ord) - Operator wrapper for public.eql\_v3\_timestamp\_ord.
* [`lt(eql_v3_timestamp_ord, jsonb)`](#lteql_v3_timestamp_ord-jsonb) - Operator wrapper for public.eql\_v3\_timestamp\_ord.
* [`lt(eql_v3_timestamp_ord, eql_v3_timestamp_ord)`](#lteql_v3_timestamp_ord-eql_v3_timestamp_ord) - Operator wrapper for public.eql\_v3\_timestamp\_ord.
* [`lt(jsonb, eql_v3_smallint_ord_ope)`](#ltjsonb-eql_v3_smallint_ord_ope) - Operator wrapper for public.eql\_v3\_smallint\_ord\_ope.
* [`lt(eql_v3_smallint_ord_ope, jsonb)`](#lteql_v3_smallint_ord_ope-jsonb) - Operator wrapper for public.eql\_v3\_smallint\_ord\_ope.
* [`lt(eql_v3_smallint_ord_ope, eql_v3_smallint_ord_ope)`](#lteql_v3_smallint_ord_ope-eql_v3_smallint_ord_ope) - Operator wrapper for public.eql\_v3\_smallint\_ord\_ope.
* [`lt(query_integer_ord, eql_v3_json_entry)`](#ltquery_integer_ord-eql_v3_json_entry) - Operator wrapper for public.eql\_v3\_json\_entry.
* [`lt(eql_v3_json_entry, query_integer_ord)`](#lteql_v3_json_entry-query_integer_ord) - Operator wrapper for public.eql\_v3\_json\_entry.
* [`lt(query_real_ord, eql_v3_json_entry)`](#ltquery_real_ord-eql_v3_json_entry) - Operator wrapper for public.eql\_v3\_json\_entry.
* [`lt(eql_v3_json_entry, query_real_ord)`](#lteql_v3_json_entry-query_real_ord) - Operator wrapper for public.eql\_v3\_json\_entry.
* [`lt(query_double_ord, eql_v3_double_ord)`](#ltquery_double_ord-eql_v3_double_ord) - Operator wrapper for eql\_v3.query\_double\_ord.
* [`lt(eql_v3_double_ord, query_double_ord)`](#lteql_v3_double_ord-query_double_ord) - Operator wrapper for eql\_v3.query\_double\_ord.
* [`lt(query_double_ord_ore, eql_v3_double_ord_ore)`](#ltquery_double_ord_ore-eql_v3_double_ord_ore) - Operator wrapper for eql\_v3.query\_double\_ord\_ore.
* [`lt(eql_v3_double_ord_ore, query_double_ord_ore)`](#lteql_v3_double_ord_ore-query_double_ord_ore) - Operator wrapper for eql\_v3.query\_double\_ord\_ore.
* [`lt(jsonb, eql_v3_timestamp_ord_ore)`](#ltjsonb-eql_v3_timestamp_ord_ore) - Operator wrapper for public.eql\_v3\_timestamp\_ord\_ore.
* [`lt(eql_v3_timestamp_ord_ore, jsonb)`](#lteql_v3_timestamp_ord_ore-jsonb) - Operator wrapper for public.eql\_v3\_timestamp\_ord\_ore.
* [`lt(eql_v3_timestamp_ord_ore, eql_v3_timestamp_ord_ore)`](#lteql_v3_timestamp_ord_ore-eql_v3_timestamp_ord_ore) - Operator wrapper for public.eql\_v3\_timestamp\_ord\_ore.
* [`lt(jsonb, eql_v3_text_search)`](#ltjsonb-eql_v3_text_search) - Operator wrapper for public.eql\_v3\_text\_search.
* [`lt(eql_v3_text_search, jsonb)`](#lteql_v3_text_search-jsonb) - Operator wrapper for public.eql\_v3\_text\_search.
* [`lt(eql_v3_text_search, eql_v3_text_search)`](#lteql_v3_text_search-eql_v3_text_search) - Operator wrapper for public.eql\_v3\_text\_search.
* [`lt(query_numeric_ord_ore, eql_v3_numeric_ord_ore)`](#ltquery_numeric_ord_ore-eql_v3_numeric_ord_ore) - Operator wrapper for eql\_v3.query\_numeric\_ord\_ore.
* [`lt(eql_v3_numeric_ord_ore, query_numeric_ord_ore)`](#lteql_v3_numeric_ord_ore-query_numeric_ord_ore) - Operator wrapper for eql\_v3.query\_numeric\_ord\_ore.
* [`lt(query_bigint_ord_ore, eql_v3_bigint_ord_ore)`](#ltquery_bigint_ord_ore-eql_v3_bigint_ord_ore) - Operator wrapper for eql\_v3.query\_bigint\_ord\_ore.
* [`lt(eql_v3_bigint_ord_ore, query_bigint_ord_ore)`](#lteql_v3_bigint_ord_ore-query_bigint_ord_ore) - Operator wrapper for eql\_v3.query\_bigint\_ord\_ore.
* [`lt(query_bigint_ord_ope, eql_v3_bigint_ord_ope)`](#ltquery_bigint_ord_ope-eql_v3_bigint_ord_ope) - Operator wrapper for eql\_v3.query\_bigint\_ord\_ope.
* [`lt(eql_v3_bigint_ord_ope, query_bigint_ord_ope)`](#lteql_v3_bigint_ord_ope-query_bigint_ord_ope) - Operator wrapper for eql\_v3.query\_bigint\_ord\_ope.
* [`lt(query_date_ord_ore, eql_v3_date_ord_ore)`](#ltquery_date_ord_ore-eql_v3_date_ord_ore) - Operator wrapper for eql\_v3.query\_date\_ord\_ore.
* [`lt(eql_v3_date_ord_ore, query_date_ord_ore)`](#lteql_v3_date_ord_ore-query_date_ord_ore) - Operator wrapper for eql\_v3.query\_date\_ord\_ore.
* [`lt(query_smallint_ord_ope, eql_v3_smallint_ord_ope)`](#ltquery_smallint_ord_ope-eql_v3_smallint_ord_ope) - Operator wrapper for eql\_v3.query\_smallint\_ord\_ope.
* [`lt(eql_v3_smallint_ord_ope, query_smallint_ord_ope)`](#lteql_v3_smallint_ord_ope-query_smallint_ord_ope) - Operator wrapper for eql\_v3.query\_smallint\_ord\_ope.
* [`lt(jsonb, eql_v3_double_ord)`](#ltjsonb-eql_v3_double_ord) - Operator wrapper for public.eql\_v3\_double\_ord.
* [`lt(eql_v3_double_ord, jsonb)`](#lteql_v3_double_ord-jsonb) - Operator wrapper for public.eql\_v3\_double\_ord.
* [`lt(eql_v3_double_ord, eql_v3_double_ord)`](#lteql_v3_double_ord-eql_v3_double_ord) - Operator wrapper for public.eql\_v3\_double\_ord.
* [`lt(query_numeric_ord_ope, eql_v3_numeric_ord_ope)`](#ltquery_numeric_ord_ope-eql_v3_numeric_ord_ope) - Operator wrapper for eql\_v3.query\_numeric\_ord\_ope.
* [`lt(eql_v3_numeric_ord_ope, query_numeric_ord_ope)`](#lteql_v3_numeric_ord_ope-query_numeric_ord_ope) - Operator wrapper for eql\_v3.query\_numeric\_ord\_ope.
* [`lt(jsonb, eql_v3_double_ord_ope)`](#ltjsonb-eql_v3_double_ord_ope) - Operator wrapper for public.eql\_v3\_double\_ord\_ope.
* [`lt(eql_v3_double_ord_ope, jsonb)`](#lteql_v3_double_ord_ope-jsonb) - Operator wrapper for public.eql\_v3\_double\_ord\_ope.
* [`lt(eql_v3_double_ord_ope, eql_v3_double_ord_ope)`](#lteql_v3_double_ord_ope-eql_v3_double_ord_ope) - Operator wrapper for public.eql\_v3\_double\_ord\_ope.
* [`lt(jsonb, eql_v3_numeric_ord_ope)`](#ltjsonb-eql_v3_numeric_ord_ope) - Operator wrapper for public.eql\_v3\_numeric\_ord\_ope.
* [`lt(eql_v3_numeric_ord_ope, jsonb)`](#lteql_v3_numeric_ord_ope-jsonb) - Operator wrapper for public.eql\_v3\_numeric\_ord\_ope.
* [`lt(eql_v3_numeric_ord_ope, eql_v3_numeric_ord_ope)`](#lteql_v3_numeric_ord_ope-eql_v3_numeric_ord_ope) - Operator wrapper for public.eql\_v3\_numeric\_ord\_ope.
* [`lt(jsonb, eql_v3_date_ord_ore)`](#ltjsonb-eql_v3_date_ord_ore) - Operator wrapper for public.eql\_v3\_date\_ord\_ore.
* [`lt(eql_v3_date_ord_ore, jsonb)`](#lteql_v3_date_ord_ore-jsonb) - Operator wrapper for public.eql\_v3\_date\_ord\_ore.
* [`lt(eql_v3_date_ord_ore, eql_v3_date_ord_ore)`](#lteql_v3_date_ord_ore-eql_v3_date_ord_ore) - Operator wrapper for public.eql\_v3\_date\_ord\_ore.
* [`lt(query_timestamp_ord, eql_v3_timestamp_ord)`](#ltquery_timestamp_ord-eql_v3_timestamp_ord) - Operator wrapper for eql\_v3.query\_timestamp\_ord.
* [`lt(eql_v3_timestamp_ord, query_timestamp_ord)`](#lteql_v3_timestamp_ord-query_timestamp_ord) - Operator wrapper for eql\_v3.query\_timestamp\_ord.
* [`lt(jsonb, eql_v3_smallint_ord_ore)`](#ltjsonb-eql_v3_smallint_ord_ore) - Operator wrapper for public.eql\_v3\_smallint\_ord\_ore.
* [`lt(eql_v3_smallint_ord_ore, jsonb)`](#lteql_v3_smallint_ord_ore-jsonb) - Operator wrapper for public.eql\_v3\_smallint\_ord\_ore.
* [`lt(eql_v3_smallint_ord_ore, eql_v3_smallint_ord_ore)`](#lteql_v3_smallint_ord_ore-eql_v3_smallint_ord_ore) - Operator wrapper for public.eql\_v3\_smallint\_ord\_ore.
* [`lt(jsonb, eql_v3_date_ord_ope)`](#ltjsonb-eql_v3_date_ord_ope) - Operator wrapper for public.eql\_v3\_date\_ord\_ope.
* [`lt(eql_v3_date_ord_ope, jsonb)`](#lteql_v3_date_ord_ope-jsonb) - Operator wrapper for public.eql\_v3\_date\_ord\_ope.
* [`lt(eql_v3_date_ord_ope, eql_v3_date_ord_ope)`](#lteql_v3_date_ord_ope-eql_v3_date_ord_ope) - Operator wrapper for public.eql\_v3\_date\_ord\_ope.
* [`lt(query_bigint_ord, eql_v3_bigint_ord)`](#ltquery_bigint_ord-eql_v3_bigint_ord) - Operator wrapper for eql\_v3.query\_bigint\_ord.
* [`lt(eql_v3_bigint_ord, query_bigint_ord)`](#lteql_v3_bigint_ord-query_bigint_ord) - Operator wrapper for eql\_v3.query\_bigint\_ord.
* [`lt(jsonb, eql_v3_text_ord_ore)`](#ltjsonb-eql_v3_text_ord_ore) - Operator wrapper for public.eql\_v3\_text\_ord\_ore.
* [`lt(eql_v3_text_ord_ore, jsonb)`](#lteql_v3_text_ord_ore-jsonb) - Operator wrapper for public.eql\_v3\_text\_ord\_ore.
* [`lt(eql_v3_text_ord_ore, eql_v3_text_ord_ore)`](#lteql_v3_text_ord_ore-eql_v3_text_ord_ore) - Operator wrapper for public.eql\_v3\_text\_ord\_ore.
* [`lt(query_bigint_ord, eql_v3_json_entry)`](#ltquery_bigint_ord-eql_v3_json_entry) - Operator wrapper for public.eql\_v3\_json\_entry.
* [`lt(eql_v3_json_entry, query_bigint_ord)`](#lteql_v3_json_entry-query_bigint_ord) - Operator wrapper for public.eql\_v3\_json\_entry.
* [`lte(jsonb, eql_v3_integer_ord_ore)`](#ltejsonb-eql_v3_integer_ord_ore) - Operator wrapper for public.eql\_v3\_integer\_ord\_ore.
* [`lte(eql_v3_integer_ord_ore, jsonb)`](#lteeql_v3_integer_ord_ore-jsonb) - Operator wrapper for public.eql\_v3\_integer\_ord\_ore.
* [`lte(eql_v3_integer_ord_ore, eql_v3_integer_ord_ore)`](#lteeql_v3_integer_ord_ore-eql_v3_integer_ord_ore) - Operator wrapper for public.eql\_v3\_integer\_ord\_ore.
* [`lte(query_smallint_ord, eql_v3_smallint_ord)`](#ltequery_smallint_ord-eql_v3_smallint_ord) - Operator wrapper for eql\_v3.query\_smallint\_ord.
* [`lte(eql_v3_smallint_ord, query_smallint_ord)`](#lteeql_v3_smallint_ord-query_smallint_ord) - Operator wrapper for eql\_v3.query\_smallint\_ord.
* [`lte(jsonb, eql_v3_smallint_ord)`](#ltejsonb-eql_v3_smallint_ord) - Operator wrapper for public.eql\_v3\_smallint\_ord.
* [`lte(eql_v3_smallint_ord, jsonb)`](#lteeql_v3_smallint_ord-jsonb) - Operator wrapper for public.eql\_v3\_smallint\_ord.
* [`lte(eql_v3_smallint_ord, eql_v3_smallint_ord)`](#lteeql_v3_smallint_ord-eql_v3_smallint_ord) - Operator wrapper for public.eql\_v3\_smallint\_ord.
* [`lte(jsonb, eql_v3_date_ord)`](#ltejsonb-eql_v3_date_ord) - Operator wrapper for public.eql\_v3\_date\_ord.
* [`lte(eql_v3_date_ord, jsonb)`](#lteeql_v3_date_ord-jsonb) - Operator wrapper for public.eql\_v3\_date\_ord.
* [`lte(eql_v3_date_ord, eql_v3_date_ord)`](#lteeql_v3_date_ord-eql_v3_date_ord) - Operator wrapper for public.eql\_v3\_date\_ord.
* [`lte(query_real_ord, eql_v3_real_ord)`](#ltequery_real_ord-eql_v3_real_ord) - Operator wrapper for eql\_v3.query\_real\_ord.
* [`lte(eql_v3_real_ord, query_real_ord)`](#lteeql_v3_real_ord-query_real_ord) - Operator wrapper for eql\_v3.query\_real\_ord.
* [`lte(query_double_ord, eql_v3_json_entry)`](#ltequery_double_ord-eql_v3_json_entry) - Operator wrapper for public.eql\_v3\_json\_entry.
* [`lte(eql_v3_json_entry, query_double_ord)`](#lteeql_v3_json_entry-query_double_ord) - Operator wrapper for public.eql\_v3\_json\_entry.
* [`lte(query_real_ord_ore, eql_v3_real_ord_ore)`](#ltequery_real_ord_ore-eql_v3_real_ord_ore) - Operator wrapper for eql\_v3.query\_real\_ord\_ore.
* [`lte(eql_v3_real_ord_ore, query_real_ord_ore)`](#lteeql_v3_real_ord_ore-query_real_ord_ore) - Operator wrapper for eql\_v3.query\_real\_ord\_ore.
* [`lte(jsonb, eql_v3_text_ord)`](#ltejsonb-eql_v3_text_ord) - Operator wrapper for public.eql\_v3\_text\_ord.
* [`lte(eql_v3_text_ord, jsonb)`](#lteeql_v3_text_ord-jsonb) - Operator wrapper for public.eql\_v3\_text\_ord.
* [`lte(eql_v3_text_ord, eql_v3_text_ord)`](#lteeql_v3_text_ord-eql_v3_text_ord) - Operator wrapper for public.eql\_v3\_text\_ord.
* [`lte(query_integer_ord_ope, eql_v3_integer_ord_ope)`](#ltequery_integer_ord_ope-eql_v3_integer_ord_ope) - Operator wrapper for eql\_v3.query\_integer\_ord\_ope.
* [`lte(eql_v3_integer_ord_ope, query_integer_ord_ope)`](#lteeql_v3_integer_ord_ope-query_integer_ord_ope) - Operator wrapper for eql\_v3.query\_integer\_ord\_ope.
* [`lte(query_text_ord, eql_v3_text_ord)`](#ltequery_text_ord-eql_v3_text_ord) - Operator wrapper for eql\_v3.query\_text\_ord.
* [`lte(eql_v3_text_ord, query_text_ord)`](#lteeql_v3_text_ord-query_text_ord) - Operator wrapper for eql\_v3.query\_text\_ord.
* [`lte(jsonb, eql_v3_timestamp_ord_ope)`](#ltejsonb-eql_v3_timestamp_ord_ope) - Operator wrapper for public.eql\_v3\_timestamp\_ord\_ope.
* [`lte(eql_v3_timestamp_ord_ope, jsonb)`](#lteeql_v3_timestamp_ord_ope-jsonb) - Operator wrapper for public.eql\_v3\_timestamp\_ord\_ope.
* [`lte(eql_v3_timestamp_ord_ope, eql_v3_timestamp_ord_ope)`](#lteeql_v3_timestamp_ord_ope-eql_v3_timestamp_ord_ope) - Operator wrapper for public.eql\_v3\_timestamp\_ord\_ope.
* [`lte(jsonb, eql_v3_integer_ord_ope)`](#ltejsonb-eql_v3_integer_ord_ope) - Operator wrapper for public.eql\_v3\_integer\_ord\_ope.
* [`lte(eql_v3_integer_ord_ope, jsonb)`](#lteeql_v3_integer_ord_ope-jsonb) - Operator wrapper for public.eql\_v3\_integer\_ord\_ope.
* [`lte(eql_v3_integer_ord_ope, eql_v3_integer_ord_ope)`](#lteeql_v3_integer_ord_ope-eql_v3_integer_ord_ope) - Operator wrapper for public.eql\_v3\_integer\_ord\_ope.
* [`lte(query_integer_ord, eql_v3_integer_ord)`](#ltequery_integer_ord-eql_v3_integer_ord) - Operator wrapper for eql\_v3.query\_integer\_ord.
* [`lte(eql_v3_integer_ord, query_integer_ord)`](#lteeql_v3_integer_ord-query_integer_ord) - Operator wrapper for eql\_v3.query\_integer\_ord.
* [`lte(query_text_search, eql_v3_text_search)`](#ltequery_text_search-eql_v3_text_search) - Operator wrapper for eql\_v3.query\_text\_search.
* [`lte(eql_v3_text_search, query_text_search)`](#lteeql_v3_text_search-query_text_search) - Operator wrapper for eql\_v3.query\_text\_search.
* [`lte(jsonb, eql_v3_numeric_ord)`](#ltejsonb-eql_v3_numeric_ord) - Operator wrapper for public.eql\_v3\_numeric\_ord.
* [`lte(eql_v3_numeric_ord, jsonb)`](#lteeql_v3_numeric_ord-jsonb) - Operator wrapper for public.eql\_v3\_numeric\_ord.
* [`lte(eql_v3_numeric_ord, eql_v3_numeric_ord)`](#lteeql_v3_numeric_ord-eql_v3_numeric_ord) - Operator wrapper for public.eql\_v3\_numeric\_ord.
* [`lte(query_date_ord_ope, eql_v3_date_ord_ope)`](#ltequery_date_ord_ope-eql_v3_date_ord_ope) - Operator wrapper for eql\_v3.query\_date\_ord\_ope.
* [`lte(eql_v3_date_ord_ope, query_date_ord_ope)`](#lteeql_v3_date_ord_ope-query_date_ord_ope) - Operator wrapper for eql\_v3.query\_date\_ord\_ope.
* [`lte(query_smallint_ord, eql_v3_json_entry)`](#ltequery_smallint_ord-eql_v3_json_entry) - Operator wrapper for public.eql\_v3\_json\_entry.
* [`lte(eql_v3_json_entry, query_smallint_ord)`](#lteeql_v3_json_entry-query_smallint_ord) - Operator wrapper for public.eql\_v3\_json\_entry.
* [`lte(query_timestamp_ord_ore, eql_v3_timestamp_ord_ore)`](#ltequery_timestamp_ord_ore-eql_v3_timestamp_ord_ore) - Operator wrapper for eql\_v3.query\_timestamp\_ord\_ore.
* [`lte(eql_v3_timestamp_ord_ore, query_timestamp_ord_ore)`](#lteeql_v3_timestamp_ord_ore-query_timestamp_ord_ore) - Operator wrapper for eql\_v3.query\_timestamp\_ord\_ore.
* [`lte(query_text_search_ore, eql_v3_text_search_ore)`](#ltequery_text_search_ore-eql_v3_text_search_ore) - Operator wrapper for eql\_v3.query\_text\_search\_ore.
* [`lte(eql_v3_text_search_ore, query_text_search_ore)`](#lteeql_v3_text_search_ore-query_text_search_ore) - Operator wrapper for eql\_v3.query\_text\_search\_ore.
* [`lte(query_text_ord_ore, eql_v3_text_ord_ore)`](#ltequery_text_ord_ore-eql_v3_text_ord_ore) - Operator wrapper for eql\_v3.query\_text\_ord\_ore.
* [`lte(eql_v3_text_ord_ore, query_text_ord_ore)`](#lteeql_v3_text_ord_ore-query_text_ord_ore) - Operator wrapper for eql\_v3.query\_text\_ord\_ore.
* [`lte(jsonb, eql_v3_real_ord_ope)`](#ltejsonb-eql_v3_real_ord_ope) - Operator wrapper for public.eql\_v3\_real\_ord\_ope.
* [`lte(eql_v3_real_ord_ope, jsonb)`](#lteeql_v3_real_ord_ope-jsonb) - Operator wrapper for public.eql\_v3\_real\_ord\_ope.
* [`lte(eql_v3_real_ord_ope, eql_v3_real_ord_ope)`](#lteeql_v3_real_ord_ope-eql_v3_real_ord_ope) - Operator wrapper for public.eql\_v3\_real\_ord\_ope.
* [`lte(jsonb, eql_v3_real_ord)`](#ltejsonb-eql_v3_real_ord) - Operator wrapper for public.eql\_v3\_real\_ord.
* [`lte(eql_v3_real_ord, jsonb)`](#lteeql_v3_real_ord-jsonb) - Operator wrapper for public.eql\_v3\_real\_ord.
* [`lte(eql_v3_real_ord, eql_v3_real_ord)`](#lteeql_v3_real_ord-eql_v3_real_ord) - Operator wrapper for public.eql\_v3\_real\_ord.
* [`lte(jsonb, eql_v3_integer_ord)`](#ltejsonb-eql_v3_integer_ord) - Operator wrapper for public.eql\_v3\_integer\_ord.
* [`lte(eql_v3_integer_ord, jsonb)`](#lteeql_v3_integer_ord-jsonb) - Operator wrapper for public.eql\_v3\_integer\_ord.
* [`lte(eql_v3_integer_ord, eql_v3_integer_ord)`](#lteeql_v3_integer_ord-eql_v3_integer_ord) - Operator wrapper for public.eql\_v3\_integer\_ord.
* [`lte(query_smallint_ord_ore, eql_v3_smallint_ord_ore)`](#ltequery_smallint_ord_ore-eql_v3_smallint_ord_ore) - Operator wrapper for eql\_v3.query\_smallint\_ord\_ore.
* [`lte(eql_v3_smallint_ord_ore, query_smallint_ord_ore)`](#lteeql_v3_smallint_ord_ore-query_smallint_ord_ore) - Operator wrapper for eql\_v3.query\_smallint\_ord\_ore.
* [`lte(jsonb, eql_v3_text_ord_ope)`](#ltejsonb-eql_v3_text_ord_ope) - Operator wrapper for public.eql\_v3\_text\_ord\_ope.
* [`lte(eql_v3_text_ord_ope, jsonb)`](#lteeql_v3_text_ord_ope-jsonb) - Operator wrapper for public.eql\_v3\_text\_ord\_ope.
* [`lte(eql_v3_text_ord_ope, eql_v3_text_ord_ope)`](#lteeql_v3_text_ord_ope-eql_v3_text_ord_ope) - Operator wrapper for public.eql\_v3\_text\_ord\_ope.
* [`lte(query_double_ord_ope, eql_v3_double_ord_ope)`](#ltequery_double_ord_ope-eql_v3_double_ord_ope) - Operator wrapper for eql\_v3.query\_double\_ord\_ope.
* [`lte(eql_v3_double_ord_ope, query_double_ord_ope)`](#lteeql_v3_double_ord_ope-query_double_ord_ope) - Operator wrapper for eql\_v3.query\_double\_ord\_ope.
* [`lte(query_integer_ord_ore, eql_v3_integer_ord_ore)`](#ltequery_integer_ord_ore-eql_v3_integer_ord_ore) - Operator wrapper for eql\_v3.query\_integer\_ord\_ore.
* [`lte(eql_v3_integer_ord_ore, query_integer_ord_ore)`](#lteeql_v3_integer_ord_ore-query_integer_ord_ore) - Operator wrapper for eql\_v3.query\_integer\_ord\_ore.
* [`lte(jsonb, eql_v3_bigint_ord_ore)`](#ltejsonb-eql_v3_bigint_ord_ore) - Operator wrapper for public.eql\_v3\_bigint\_ord\_ore.
* [`lte(eql_v3_bigint_ord_ore, jsonb)`](#lteeql_v3_bigint_ord_ore-jsonb) - Operator wrapper for public.eql\_v3\_bigint\_ord\_ore.
* [`lte(eql_v3_bigint_ord_ore, eql_v3_bigint_ord_ore)`](#lteeql_v3_bigint_ord_ore-eql_v3_bigint_ord_ore) - Operator wrapper for public.eql\_v3\_bigint\_ord\_ore.
* [`lte(query_date_ord, eql_v3_date_ord)`](#ltequery_date_ord-eql_v3_date_ord) - Operator wrapper for eql\_v3.query\_date\_ord.
* [`lte(eql_v3_date_ord, query_date_ord)`](#lteeql_v3_date_ord-query_date_ord) - Operator wrapper for eql\_v3.query\_date\_ord.
* [`lte(jsonb, eql_v3_real_ord_ore)`](#ltejsonb-eql_v3_real_ord_ore) - Operator wrapper for public.eql\_v3\_real\_ord\_ore.
* [`lte(eql_v3_real_ord_ore, jsonb)`](#lteeql_v3_real_ord_ore-jsonb) - Operator wrapper for public.eql\_v3\_real\_ord\_ore.
* [`lte(eql_v3_real_ord_ore, eql_v3_real_ord_ore)`](#lteeql_v3_real_ord_ore-eql_v3_real_ord_ore) - Operator wrapper for public.eql\_v3\_real\_ord\_ore.
* [`lte(jsonb, eql_v3_numeric_ord_ore)`](#ltejsonb-eql_v3_numeric_ord_ore) - Operator wrapper for public.eql\_v3\_numeric\_ord\_ore.
* [`lte(eql_v3_numeric_ord_ore, jsonb)`](#lteeql_v3_numeric_ord_ore-jsonb) - Operator wrapper for public.eql\_v3\_numeric\_ord\_ore.
* [`lte(eql_v3_numeric_ord_ore, eql_v3_numeric_ord_ore)`](#lteeql_v3_numeric_ord_ore-eql_v3_numeric_ord_ore) - Operator wrapper for public.eql\_v3\_numeric\_ord\_ore.
* [`lte(query_text_ord_ope, eql_v3_text_ord_ope)`](#ltequery_text_ord_ope-eql_v3_text_ord_ope) - Operator wrapper for eql\_v3.query\_text\_ord\_ope.
* [`lte(eql_v3_text_ord_ope, query_text_ord_ope)`](#lteeql_v3_text_ord_ope-query_text_ord_ope) - Operator wrapper for eql\_v3.query\_text\_ord\_ope.
* [`lte(jsonb, eql_v3_bigint_ord_ope)`](#ltejsonb-eql_v3_bigint_ord_ope) - Operator wrapper for public.eql\_v3\_bigint\_ord\_ope.
* [`lte(eql_v3_bigint_ord_ope, jsonb)`](#lteeql_v3_bigint_ord_ope-jsonb) - Operator wrapper for public.eql\_v3\_bigint\_ord\_ope.
* [`lte(eql_v3_bigint_ord_ope, eql_v3_bigint_ord_ope)`](#lteeql_v3_bigint_ord_ope-eql_v3_bigint_ord_ope) - Operator wrapper for public.eql\_v3\_bigint\_ord\_ope.
* [`lte(query_numeric_ord, eql_v3_json_entry)`](#ltequery_numeric_ord-eql_v3_json_entry) - Operator wrapper for public.eql\_v3\_json\_entry.
* [`lte(eql_v3_json_entry, query_numeric_ord)`](#lteeql_v3_json_entry-query_numeric_ord) - Operator wrapper for public.eql\_v3\_json\_entry.
* [`lte(jsonb, eql_v3_double_ord_ore)`](#ltejsonb-eql_v3_double_ord_ore) - Operator wrapper for public.eql\_v3\_double\_ord\_ore.
* [`lte(eql_v3_double_ord_ore, jsonb)`](#lteeql_v3_double_ord_ore-jsonb) - Operator wrapper for public.eql\_v3\_double\_ord\_ore.
* [`lte(eql_v3_double_ord_ore, eql_v3_double_ord_ore)`](#lteeql_v3_double_ord_ore-eql_v3_double_ord_ore) - Operator wrapper for public.eql\_v3\_double\_ord\_ore.
* [`lte(jsonb, eql_v3_bigint_ord)`](#ltejsonb-eql_v3_bigint_ord) - Operator wrapper for public.eql\_v3\_bigint\_ord.
* [`lte(eql_v3_bigint_ord, jsonb)`](#lteeql_v3_bigint_ord-jsonb) - Operator wrapper for public.eql\_v3\_bigint\_ord.
* [`lte(eql_v3_bigint_ord, eql_v3_bigint_ord)`](#lteeql_v3_bigint_ord-eql_v3_bigint_ord) - Operator wrapper for public.eql\_v3\_bigint\_ord.
* [`lte(query_text_ord, eql_v3_json_entry)`](#ltequery_text_ord-eql_v3_json_entry) - Operator wrapper for public.eql\_v3\_json\_entry.
* [`lte(eql_v3_json_entry, query_text_ord)`](#lteeql_v3_json_entry-query_text_ord) - Operator wrapper for public.eql\_v3\_json\_entry.
* [`lte(query_timestamp_ord_ope, eql_v3_timestamp_ord_ope)`](#ltequery_timestamp_ord_ope-eql_v3_timestamp_ord_ope) - Operator wrapper for eql\_v3.query\_timestamp\_ord\_ope.
* [`lte(eql_v3_timestamp_ord_ope, query_timestamp_ord_ope)`](#lteeql_v3_timestamp_ord_ope-query_timestamp_ord_ope) - Operator wrapper for eql\_v3.query\_timestamp\_ord\_ope.
* [`lte(query_numeric_ord, eql_v3_numeric_ord)`](#ltequery_numeric_ord-eql_v3_numeric_ord) - Operator wrapper for eql\_v3.query\_numeric\_ord.
* [`lte(eql_v3_numeric_ord, query_numeric_ord)`](#lteeql_v3_numeric_ord-query_numeric_ord) - Operator wrapper for eql\_v3.query\_numeric\_ord.
* [`lte(jsonb, eql_v3_text_search_ore)`](#ltejsonb-eql_v3_text_search_ore) - Operator wrapper for public.eql\_v3\_text\_search\_ore.
* [`lte(eql_v3_text_search_ore, jsonb)`](#lteeql_v3_text_search_ore-jsonb) - Operator wrapper for public.eql\_v3\_text\_search\_ore.
* [`lte(eql_v3_text_search_ore, eql_v3_text_search_ore)`](#lteeql_v3_text_search_ore-eql_v3_text_search_ore) - Operator wrapper for public.eql\_v3\_text\_search\_ore.
* [`lte(query_real_ord_ope, eql_v3_real_ord_ope)`](#ltequery_real_ord_ope-eql_v3_real_ord_ope) - Operator wrapper for eql\_v3.query\_real\_ord\_ope.
* [`lte(eql_v3_real_ord_ope, query_real_ord_ope)`](#lteeql_v3_real_ord_ope-query_real_ord_ope) - Operator wrapper for eql\_v3.query\_real\_ord\_ope.
* [`lte(jsonb, eql_v3_timestamp_ord)`](#ltejsonb-eql_v3_timestamp_ord) - Operator wrapper for public.eql\_v3\_timestamp\_ord.
* [`lte(eql_v3_timestamp_ord, jsonb)`](#lteeql_v3_timestamp_ord-jsonb) - Operator wrapper for public.eql\_v3\_timestamp\_ord.
* [`lte(eql_v3_timestamp_ord, eql_v3_timestamp_ord)`](#lteeql_v3_timestamp_ord-eql_v3_timestamp_ord) - Operator wrapper for public.eql\_v3\_timestamp\_ord.
* [`lte(jsonb, eql_v3_smallint_ord_ope)`](#ltejsonb-eql_v3_smallint_ord_ope) - Operator wrapper for public.eql\_v3\_smallint\_ord\_ope.
* [`lte(eql_v3_smallint_ord_ope, jsonb)`](#lteeql_v3_smallint_ord_ope-jsonb) - Operator wrapper for public.eql\_v3\_smallint\_ord\_ope.
* [`lte(eql_v3_smallint_ord_ope, eql_v3_smallint_ord_ope)`](#lteeql_v3_smallint_ord_ope-eql_v3_smallint_ord_ope) - Operator wrapper for public.eql\_v3\_smallint\_ord\_ope.
* [`lte(query_integer_ord, eql_v3_json_entry)`](#ltequery_integer_ord-eql_v3_json_entry) - Operator wrapper for public.eql\_v3\_json\_entry.
* [`lte(eql_v3_json_entry, query_integer_ord)`](#lteeql_v3_json_entry-query_integer_ord) - Operator wrapper for public.eql\_v3\_json\_entry.
* [`lte(query_real_ord, eql_v3_json_entry)`](#ltequery_real_ord-eql_v3_json_entry) - Operator wrapper for public.eql\_v3\_json\_entry.
* [`lte(eql_v3_json_entry, query_real_ord)`](#lteeql_v3_json_entry-query_real_ord) - Operator wrapper for public.eql\_v3\_json\_entry.
* [`lte(query_double_ord, eql_v3_double_ord)`](#ltequery_double_ord-eql_v3_double_ord) - Operator wrapper for eql\_v3.query\_double\_ord.
* [`lte(eql_v3_double_ord, query_double_ord)`](#lteeql_v3_double_ord-query_double_ord) - Operator wrapper for eql\_v3.query\_double\_ord.
* [`lte(query_double_ord_ore, eql_v3_double_ord_ore)`](#ltequery_double_ord_ore-eql_v3_double_ord_ore) - Operator wrapper for eql\_v3.query\_double\_ord\_ore.
* [`lte(eql_v3_double_ord_ore, query_double_ord_ore)`](#lteeql_v3_double_ord_ore-query_double_ord_ore) - Operator wrapper for eql\_v3.query\_double\_ord\_ore.
* [`lte(jsonb, eql_v3_timestamp_ord_ore)`](#ltejsonb-eql_v3_timestamp_ord_ore) - Operator wrapper for public.eql\_v3\_timestamp\_ord\_ore.
* [`lte(eql_v3_timestamp_ord_ore, jsonb)`](#lteeql_v3_timestamp_ord_ore-jsonb) - Operator wrapper for public.eql\_v3\_timestamp\_ord\_ore.
* [`lte(eql_v3_timestamp_ord_ore, eql_v3_timestamp_ord_ore)`](#lteeql_v3_timestamp_ord_ore-eql_v3_timestamp_ord_ore) - Operator wrapper for public.eql\_v3\_timestamp\_ord\_ore.
* [`lte(jsonb, eql_v3_text_search)`](#ltejsonb-eql_v3_text_search) - Operator wrapper for public.eql\_v3\_text\_search.
* [`lte(eql_v3_text_search, jsonb)`](#lteeql_v3_text_search-jsonb) - Operator wrapper for public.eql\_v3\_text\_search.
* [`lte(eql_v3_text_search, eql_v3_text_search)`](#lteeql_v3_text_search-eql_v3_text_search) - Operator wrapper for public.eql\_v3\_text\_search.
* [`lte(query_numeric_ord_ore, eql_v3_numeric_ord_ore)`](#ltequery_numeric_ord_ore-eql_v3_numeric_ord_ore) - Operator wrapper for eql\_v3.query\_numeric\_ord\_ore.
* [`lte(eql_v3_numeric_ord_ore, query_numeric_ord_ore)`](#lteeql_v3_numeric_ord_ore-query_numeric_ord_ore) - Operator wrapper for eql\_v3.query\_numeric\_ord\_ore.
* [`lte(query_bigint_ord_ore, eql_v3_bigint_ord_ore)`](#ltequery_bigint_ord_ore-eql_v3_bigint_ord_ore) - Operator wrapper for eql\_v3.query\_bigint\_ord\_ore.
* [`lte(eql_v3_bigint_ord_ore, query_bigint_ord_ore)`](#lteeql_v3_bigint_ord_ore-query_bigint_ord_ore) - Operator wrapper for eql\_v3.query\_bigint\_ord\_ore.
* [`lte(query_bigint_ord_ope, eql_v3_bigint_ord_ope)`](#ltequery_bigint_ord_ope-eql_v3_bigint_ord_ope) - Operator wrapper for eql\_v3.query\_bigint\_ord\_ope.
* [`lte(eql_v3_bigint_ord_ope, query_bigint_ord_ope)`](#lteeql_v3_bigint_ord_ope-query_bigint_ord_ope) - Operator wrapper for eql\_v3.query\_bigint\_ord\_ope.
* [`lte(query_date_ord_ore, eql_v3_date_ord_ore)`](#ltequery_date_ord_ore-eql_v3_date_ord_ore) - Operator wrapper for eql\_v3.query\_date\_ord\_ore.
* [`lte(eql_v3_date_ord_ore, query_date_ord_ore)`](#lteeql_v3_date_ord_ore-query_date_ord_ore) - Operator wrapper for eql\_v3.query\_date\_ord\_ore.
* [`lte(query_smallint_ord_ope, eql_v3_smallint_ord_ope)`](#ltequery_smallint_ord_ope-eql_v3_smallint_ord_ope) - Operator wrapper for eql\_v3.query\_smallint\_ord\_ope.
* [`lte(eql_v3_smallint_ord_ope, query_smallint_ord_ope)`](#lteeql_v3_smallint_ord_ope-query_smallint_ord_ope) - Operator wrapper for eql\_v3.query\_smallint\_ord\_ope.
* [`lte(jsonb, eql_v3_double_ord)`](#ltejsonb-eql_v3_double_ord) - Operator wrapper for public.eql\_v3\_double\_ord.
* [`lte(eql_v3_double_ord, jsonb)`](#lteeql_v3_double_ord-jsonb) - Operator wrapper for public.eql\_v3\_double\_ord.
* [`lte(eql_v3_double_ord, eql_v3_double_ord)`](#lteeql_v3_double_ord-eql_v3_double_ord) - Operator wrapper for public.eql\_v3\_double\_ord.
* [`lte(query_numeric_ord_ope, eql_v3_numeric_ord_ope)`](#ltequery_numeric_ord_ope-eql_v3_numeric_ord_ope) - Operator wrapper for eql\_v3.query\_numeric\_ord\_ope.
* [`lte(eql_v3_numeric_ord_ope, query_numeric_ord_ope)`](#lteeql_v3_numeric_ord_ope-query_numeric_ord_ope) - Operator wrapper for eql\_v3.query\_numeric\_ord\_ope.
* [`lte(jsonb, eql_v3_double_ord_ope)`](#ltejsonb-eql_v3_double_ord_ope) - Operator wrapper for public.eql\_v3\_double\_ord\_ope.
* [`lte(eql_v3_double_ord_ope, jsonb)`](#lteeql_v3_double_ord_ope-jsonb) - Operator wrapper for public.eql\_v3\_double\_ord\_ope.
* [`lte(eql_v3_double_ord_ope, eql_v3_double_ord_ope)`](#lteeql_v3_double_ord_ope-eql_v3_double_ord_ope) - Operator wrapper for public.eql\_v3\_double\_ord\_ope.
* [`lte(jsonb, eql_v3_numeric_ord_ope)`](#ltejsonb-eql_v3_numeric_ord_ope) - Operator wrapper for public.eql\_v3\_numeric\_ord\_ope.
* [`lte(eql_v3_numeric_ord_ope, jsonb)`](#lteeql_v3_numeric_ord_ope-jsonb) - Operator wrapper for public.eql\_v3\_numeric\_ord\_ope.
* [`lte(eql_v3_numeric_ord_ope, eql_v3_numeric_ord_ope)`](#lteeql_v3_numeric_ord_ope-eql_v3_numeric_ord_ope) - Operator wrapper for public.eql\_v3\_numeric\_ord\_ope.
* [`lte(jsonb, eql_v3_date_ord_ore)`](#ltejsonb-eql_v3_date_ord_ore) - Operator wrapper for public.eql\_v3\_date\_ord\_ore.
* [`lte(eql_v3_date_ord_ore, jsonb)`](#lteeql_v3_date_ord_ore-jsonb) - Operator wrapper for public.eql\_v3\_date\_ord\_ore.
* [`lte(eql_v3_date_ord_ore, eql_v3_date_ord_ore)`](#lteeql_v3_date_ord_ore-eql_v3_date_ord_ore) - Operator wrapper for public.eql\_v3\_date\_ord\_ore.
* [`lte(query_timestamp_ord, eql_v3_timestamp_ord)`](#ltequery_timestamp_ord-eql_v3_timestamp_ord) - Operator wrapper for eql\_v3.query\_timestamp\_ord.
* [`lte(eql_v3_timestamp_ord, query_timestamp_ord)`](#lteeql_v3_timestamp_ord-query_timestamp_ord) - Operator wrapper for eql\_v3.query\_timestamp\_ord.
* [`lte(jsonb, eql_v3_smallint_ord_ore)`](#ltejsonb-eql_v3_smallint_ord_ore) - Operator wrapper for public.eql\_v3\_smallint\_ord\_ore.
* [`lte(eql_v3_smallint_ord_ore, jsonb)`](#lteeql_v3_smallint_ord_ore-jsonb) - Operator wrapper for public.eql\_v3\_smallint\_ord\_ore.
* [`lte(eql_v3_smallint_ord_ore, eql_v3_smallint_ord_ore)`](#lteeql_v3_smallint_ord_ore-eql_v3_smallint_ord_ore) - Operator wrapper for public.eql\_v3\_smallint\_ord\_ore.
* [`lte(jsonb, eql_v3_date_ord_ope)`](#ltejsonb-eql_v3_date_ord_ope) - Operator wrapper for public.eql\_v3\_date\_ord\_ope.
* [`lte(eql_v3_date_ord_ope, jsonb)`](#lteeql_v3_date_ord_ope-jsonb) - Operator wrapper for public.eql\_v3\_date\_ord\_ope.
* [`lte(eql_v3_date_ord_ope, eql_v3_date_ord_ope)`](#lteeql_v3_date_ord_ope-eql_v3_date_ord_ope) - Operator wrapper for public.eql\_v3\_date\_ord\_ope.
* [`lte(query_bigint_ord, eql_v3_bigint_ord)`](#ltequery_bigint_ord-eql_v3_bigint_ord) - Operator wrapper for eql\_v3.query\_bigint\_ord.
* [`lte(eql_v3_bigint_ord, query_bigint_ord)`](#lteeql_v3_bigint_ord-query_bigint_ord) - Operator wrapper for eql\_v3.query\_bigint\_ord.
* [`lte(jsonb, eql_v3_text_ord_ore)`](#ltejsonb-eql_v3_text_ord_ore) - Operator wrapper for public.eql\_v3\_text\_ord\_ore.
* [`lte(eql_v3_text_ord_ore, jsonb)`](#lteeql_v3_text_ord_ore-jsonb) - Operator wrapper for public.eql\_v3\_text\_ord\_ore.
* [`lte(eql_v3_text_ord_ore, eql_v3_text_ord_ore)`](#lteeql_v3_text_ord_ore-eql_v3_text_ord_ore) - Operator wrapper for public.eql\_v3\_text\_ord\_ore.
* [`lte(query_bigint_ord, eql_v3_json_entry)`](#ltequery_bigint_ord-eql_v3_json_entry) - Operator wrapper for public.eql\_v3\_json\_entry.
* [`lte(eql_v3_json_entry, query_bigint_ord)`](#lteeql_v3_json_entry-query_bigint_ord) - Operator wrapper for public.eql\_v3\_json\_entry.
* [`match_term(query_text_search)`](#match_termquery_text_search) - Index extractor for eql\_v3.query\_text\_search.
* [`match_term(query_text_search_ore)`](#match_termquery_text_search_ore) - Index extractor for eql\_v3.query\_text\_search\_ore.
* [`match_term(query_text_match)`](#match_termquery_text_match) - Index extractor for eql\_v3.query\_text\_match.
* [`match_term(eql_v3_text_search_ore)`](#match_termeql_v3_text_search_ore) - Index extractor for public.eql\_v3\_text\_search\_ore.
* [`match_term(eql_v3_text_match)`](#match_termeql_v3_text_match) - Index extractor for public.eql\_v3\_text\_match.
* [`match_term(eql_v3_text_search)`](#match_termeql_v3_text_search) - Index extractor for public.eql\_v3\_text\_search.
* [`matches(query_text_search, eql_v3_text_search)`](#matchesquery_text_search-eql_v3_text_search) - Operator wrapper for eql\_v3.query\_text\_search.
* [`matches(eql_v3_text_search, query_text_search)`](#matcheseql_v3_text_search-query_text_search) - Operator wrapper for eql\_v3.query\_text\_search.
* [`matches(query_text_search_ore, eql_v3_text_search_ore)`](#matchesquery_text_search_ore-eql_v3_text_search_ore) - Operator wrapper for eql\_v3.query\_text\_search\_ore.
* [`matches(eql_v3_text_search_ore, query_text_search_ore)`](#matcheseql_v3_text_search_ore-query_text_search_ore) - Operator wrapper for eql\_v3.query\_text\_search\_ore.
* [`matches(query_text_match, eql_v3_text_match)`](#matchesquery_text_match-eql_v3_text_match) - Operator wrapper for eql\_v3.query\_text\_match.
* [`matches(eql_v3_text_match, query_text_match)`](#matcheseql_v3_text_match-query_text_match) - Operator wrapper for eql\_v3.query\_text\_match.
* [`matches(jsonb, eql_v3_text_search_ore)`](#matchesjsonb-eql_v3_text_search_ore) - Operator wrapper for public.eql\_v3\_text\_search\_ore.
* [`matches(eql_v3_text_search_ore, jsonb)`](#matcheseql_v3_text_search_ore-jsonb) - Operator wrapper for public.eql\_v3\_text\_search\_ore.
* [`matches(eql_v3_text_search_ore, eql_v3_text_search_ore)`](#matcheseql_v3_text_search_ore-eql_v3_text_search_ore) - Operator wrapper for public.eql\_v3\_text\_search\_ore.
* [`matches(jsonb, eql_v3_text_match)`](#matchesjsonb-eql_v3_text_match) - Operator wrapper for public.eql\_v3\_text\_match.
* [`matches(eql_v3_text_match, jsonb)`](#matcheseql_v3_text_match-jsonb) - Operator wrapper for public.eql\_v3\_text\_match.
* [`matches(eql_v3_text_match, eql_v3_text_match)`](#matcheseql_v3_text_match-eql_v3_text_match) - Operator wrapper for public.eql\_v3\_text\_match.
* [`matches(jsonb, eql_v3_text_search)`](#matchesjsonb-eql_v3_text_search) - Operator wrapper for public.eql\_v3\_text\_search.
* [`matches(eql_v3_text_search, jsonb)`](#matcheseql_v3_text_search-jsonb) - Operator wrapper for public.eql\_v3\_text\_search.
* [`matches(eql_v3_text_search, eql_v3_text_search)`](#matcheseql_v3_text_search-eql_v3_text_search) - Operator wrapper for public.eql\_v3\_text\_search.
* [`max(public.eql_v3_bigint_ord_ope)`](#maxpubliceql_v3_bigint_ord_ope) - max aggregate for public.eql\_v3\_bigint\_ord\_ope.
* [`max(public.eql_v3_smallint_ord_ope)`](#maxpubliceql_v3_smallint_ord_ope) - max aggregate for public.eql\_v3\_smallint\_ord\_ope.
* [`max(public.eql_v3_numeric_ord)`](#maxpubliceql_v3_numeric_ord) - max aggregate for public.eql\_v3\_numeric\_ord.
* [`max(public.eql_v3_real_ord_ore)`](#maxpubliceql_v3_real_ord_ore) - max aggregate for public.eql\_v3\_real\_ord\_ore.
* [`max(public.eql_v3_timestamp_ord_ore)`](#maxpubliceql_v3_timestamp_ord_ore) - max aggregate for public.eql\_v3\_timestamp\_ord\_ore.
* [`max(public.eql_v3_real_ord_ope)`](#maxpubliceql_v3_real_ord_ope) - max aggregate for public.eql\_v3\_real\_ord\_ope.
* [`max(public.eql_v3_text_ord_ope)`](#maxpubliceql_v3_text_ord_ope) - max aggregate for public.eql\_v3\_text\_ord\_ope.
* [`max(public.eql_v3_double_ord_ope)`](#maxpubliceql_v3_double_ord_ope) - max aggregate for public.eql\_v3\_double\_ord\_ope.
* [`max(public.eql_v3_date_ord_ore)`](#maxpubliceql_v3_date_ord_ore) - max aggregate for public.eql\_v3\_date\_ord\_ore.
* [`max(public.eql_v3_integer_ord_ore)`](#maxpubliceql_v3_integer_ord_ore) - max aggregate for public.eql\_v3\_integer\_ord\_ore.
* [`max(public.eql_v3_bigint_ord)`](#maxpubliceql_v3_bigint_ord) - max aggregate for public.eql\_v3\_bigint\_ord.
* [`max(public.eql_v3_numeric_ord_ope)`](#maxpubliceql_v3_numeric_ord_ope) - max aggregate for public.eql\_v3\_numeric\_ord\_ope.
* [`max(public.eql_v3_numeric_ord_ore)`](#maxpubliceql_v3_numeric_ord_ore) - max aggregate for public.eql\_v3\_numeric\_ord\_ore.
* [`max(public.eql_v3_real_ord)`](#maxpubliceql_v3_real_ord) - max aggregate for public.eql\_v3\_real\_ord.
* [`max(public.eql_v3_timestamp_ord_ope)`](#maxpubliceql_v3_timestamp_ord_ope) - max aggregate for public.eql\_v3\_timestamp\_ord\_ope.
* [`max(public.eql_v3_smallint_ord)`](#maxpubliceql_v3_smallint_ord) - max aggregate for public.eql\_v3\_smallint\_ord.
* [`max(public.eql_v3_text_search_ore)`](#maxpubliceql_v3_text_search_ore) - max aggregate for public.eql\_v3\_text\_search\_ore.
* [`max(public.eql_v3_integer_ord)`](#maxpubliceql_v3_integer_ord) - max aggregate for public.eql\_v3\_integer\_ord.
* [`max(public.eql_v3_integer_ord_ope)`](#maxpubliceql_v3_integer_ord_ope) - max aggregate for public.eql\_v3\_integer\_ord\_ope.
* [`max(public.eql_v3_smallint_ord_ore)`](#maxpubliceql_v3_smallint_ord_ore) - max aggregate for public.eql\_v3\_smallint\_ord\_ore.
* [`max(public.eql_v3_json_entry)`](#maxpubliceql_v3_json_entry) - max aggregate over public.eql\_v3\_json\_entry.
* [`max(public.eql_v3_date_ord)`](#maxpubliceql_v3_date_ord) - max aggregate for public.eql\_v3\_date\_ord.
* [`max(public.eql_v3_text_ord_ore)`](#maxpubliceql_v3_text_ord_ore) - max aggregate for public.eql\_v3\_text\_ord\_ore.
* [`max(public.eql_v3_double_ord_ore)`](#maxpubliceql_v3_double_ord_ore) - max aggregate for public.eql\_v3\_double\_ord\_ore.
* [`max(public.eql_v3_timestamp_ord)`](#maxpubliceql_v3_timestamp_ord) - max aggregate for public.eql\_v3\_timestamp\_ord.
* [`max(public.eql_v3_text_ord)`](#maxpubliceql_v3_text_ord) - max aggregate for public.eql\_v3\_text\_ord.
* [`max(public.eql_v3_bigint_ord_ore)`](#maxpubliceql_v3_bigint_ord_ore) - max aggregate for public.eql\_v3\_bigint\_ord\_ore.
* [`max(public.eql_v3_text_search)`](#maxpubliceql_v3_text_search) - max aggregate for public.eql\_v3\_text\_search.
* [`max(public.eql_v3_double_ord)`](#maxpubliceql_v3_double_ord) - max aggregate for public.eql\_v3\_double\_ord.
* [`max(public.eql_v3_date_ord_ope)`](#maxpubliceql_v3_date_ord_ope) - max aggregate for public.eql\_v3\_date\_ord\_ope.
* [`meta_data(jsonb)`](#meta_datajsonb) - Extract envelope metadata (i, v, h) from a raw jsonb encrypted value.
* [`min(public.eql_v3_bigint_ord_ope)`](#minpubliceql_v3_bigint_ord_ope) - min aggregate for public.eql\_v3\_bigint\_ord\_ope.
* [`min(public.eql_v3_smallint_ord_ope)`](#minpubliceql_v3_smallint_ord_ope) - min aggregate for public.eql\_v3\_smallint\_ord\_ope.
* [`min(public.eql_v3_numeric_ord)`](#minpubliceql_v3_numeric_ord) - min aggregate for public.eql\_v3\_numeric\_ord.
* [`min(public.eql_v3_real_ord_ore)`](#minpubliceql_v3_real_ord_ore) - min aggregate for public.eql\_v3\_real\_ord\_ore.
* [`min(public.eql_v3_timestamp_ord_ore)`](#minpubliceql_v3_timestamp_ord_ore) - min aggregate for public.eql\_v3\_timestamp\_ord\_ore.
* [`min(public.eql_v3_real_ord_ope)`](#minpubliceql_v3_real_ord_ope) - min aggregate for public.eql\_v3\_real\_ord\_ope.
* [`min(public.eql_v3_text_ord_ope)`](#minpubliceql_v3_text_ord_ope) - min aggregate for public.eql\_v3\_text\_ord\_ope.
* [`min(public.eql_v3_double_ord_ope)`](#minpubliceql_v3_double_ord_ope) - min aggregate for public.eql\_v3\_double\_ord\_ope.
* [`min(public.eql_v3_date_ord_ore)`](#minpubliceql_v3_date_ord_ore) - min aggregate for public.eql\_v3\_date\_ord\_ore.
* [`min(public.eql_v3_integer_ord_ore)`](#minpubliceql_v3_integer_ord_ore) - min aggregate for public.eql\_v3\_integer\_ord\_ore.
* [`min(public.eql_v3_bigint_ord)`](#minpubliceql_v3_bigint_ord) - min aggregate for public.eql\_v3\_bigint\_ord.
* [`min(public.eql_v3_numeric_ord_ope)`](#minpubliceql_v3_numeric_ord_ope) - min aggregate for public.eql\_v3\_numeric\_ord\_ope.
* [`min(public.eql_v3_numeric_ord_ore)`](#minpubliceql_v3_numeric_ord_ore) - min aggregate for public.eql\_v3\_numeric\_ord\_ore.
* [`min(public.eql_v3_real_ord)`](#minpubliceql_v3_real_ord) - min aggregate for public.eql\_v3\_real\_ord.
* [`min(public.eql_v3_timestamp_ord_ope)`](#minpubliceql_v3_timestamp_ord_ope) - min aggregate for public.eql\_v3\_timestamp\_ord\_ope.
* [`min(public.eql_v3_smallint_ord)`](#minpubliceql_v3_smallint_ord) - min aggregate for public.eql\_v3\_smallint\_ord.
* [`min(public.eql_v3_text_search_ore)`](#minpubliceql_v3_text_search_ore) - min aggregate for public.eql\_v3\_text\_search\_ore.
* [`min(public.eql_v3_integer_ord)`](#minpubliceql_v3_integer_ord) - min aggregate for public.eql\_v3\_integer\_ord.
* [`min(public.eql_v3_integer_ord_ope)`](#minpubliceql_v3_integer_ord_ope) - min aggregate for public.eql\_v3\_integer\_ord\_ope.
* [`min(public.eql_v3_smallint_ord_ore)`](#minpubliceql_v3_smallint_ord_ore) - min aggregate for public.eql\_v3\_smallint\_ord\_ore.
* [`min(public.eql_v3_json_entry)`](#minpubliceql_v3_json_entry) - min aggregate over public.eql\_v3\_json\_entry.
* [`min(public.eql_v3_date_ord)`](#minpubliceql_v3_date_ord) - min aggregate for public.eql\_v3\_date\_ord.
* [`min(public.eql_v3_text_ord_ore)`](#minpubliceql_v3_text_ord_ore) - min aggregate for public.eql\_v3\_text\_ord\_ore.
* [`min(public.eql_v3_double_ord_ore)`](#minpubliceql_v3_double_ord_ore) - min aggregate for public.eql\_v3\_double\_ord\_ore.
* [`min(public.eql_v3_timestamp_ord)`](#minpubliceql_v3_timestamp_ord) - min aggregate for public.eql\_v3\_timestamp\_ord.
* [`min(public.eql_v3_text_ord)`](#minpubliceql_v3_text_ord) - min aggregate for public.eql\_v3\_text\_ord.
* [`min(public.eql_v3_bigint_ord_ore)`](#minpubliceql_v3_bigint_ord_ore) - min aggregate for public.eql\_v3\_bigint\_ord\_ore.
* [`min(public.eql_v3_text_search)`](#minpubliceql_v3_text_search) - min aggregate for public.eql\_v3\_text\_search.
* [`min(public.eql_v3_double_ord)`](#minpubliceql_v3_double_ord) - min aggregate for public.eql\_v3\_double\_ord.
* [`min(public.eql_v3_date_ord_ope)`](#minpubliceql_v3_date_ord_ope) - min aggregate for public.eql\_v3\_date\_ord\_ope.
* [`neq(jsonb, eql_v3_integer_ord_ore)`](#neqjsonb-eql_v3_integer_ord_ore) - Operator wrapper for public.eql\_v3\_integer\_ord\_ore.
* [`neq(eql_v3_integer_ord_ore, jsonb)`](#neqeql_v3_integer_ord_ore-jsonb) - Operator wrapper for public.eql\_v3\_integer\_ord\_ore.
* [`neq(eql_v3_integer_ord_ore, eql_v3_integer_ord_ore)`](#neqeql_v3_integer_ord_ore-eql_v3_integer_ord_ore) - Operator wrapper for public.eql\_v3\_integer\_ord\_ore.
* [`neq(query_smallint_ord, eql_v3_smallint_ord)`](#neqquery_smallint_ord-eql_v3_smallint_ord) - Operator wrapper for eql\_v3.query\_smallint\_ord.
* [`neq(eql_v3_smallint_ord, query_smallint_ord)`](#neqeql_v3_smallint_ord-query_smallint_ord) - Operator wrapper for eql\_v3.query\_smallint\_ord.
* [`neq(jsonb, eql_v3_smallint_ord)`](#neqjsonb-eql_v3_smallint_ord) - Operator wrapper for public.eql\_v3\_smallint\_ord.
* [`neq(eql_v3_smallint_ord, jsonb)`](#neqeql_v3_smallint_ord-jsonb) - Operator wrapper for public.eql\_v3\_smallint\_ord.
* [`neq(eql_v3_smallint_ord, eql_v3_smallint_ord)`](#neqeql_v3_smallint_ord-eql_v3_smallint_ord) - Operator wrapper for public.eql\_v3\_smallint\_ord.
* [`neq(jsonb, eql_v3_date_ord)`](#neqjsonb-eql_v3_date_ord) - Operator wrapper for public.eql\_v3\_date\_ord.
* [`neq(eql_v3_date_ord, jsonb)`](#neqeql_v3_date_ord-jsonb) - Operator wrapper for public.eql\_v3\_date\_ord.
* [`neq(eql_v3_date_ord, eql_v3_date_ord)`](#neqeql_v3_date_ord-eql_v3_date_ord) - Operator wrapper for public.eql\_v3\_date\_ord.
* [`neq(query_real_ord, eql_v3_real_ord)`](#neqquery_real_ord-eql_v3_real_ord) - Operator wrapper for eql\_v3.query\_real\_ord.
* [`neq(eql_v3_real_ord, query_real_ord)`](#neqeql_v3_real_ord-query_real_ord) - Operator wrapper for eql\_v3.query\_real\_ord.
* [`neq(query_real_ord_ore, eql_v3_real_ord_ore)`](#neqquery_real_ord_ore-eql_v3_real_ord_ore) - Operator wrapper for eql\_v3.query\_real\_ord\_ore.
* [`neq(eql_v3_real_ord_ore, query_real_ord_ore)`](#neqeql_v3_real_ord_ore-query_real_ord_ore) - Operator wrapper for eql\_v3.query\_real\_ord\_ore.
* [`neq(jsonb, eql_v3_text_ord)`](#neqjsonb-eql_v3_text_ord) - Operator wrapper for public.eql\_v3\_text\_ord.
* [`neq(eql_v3_text_ord, jsonb)`](#neqeql_v3_text_ord-jsonb) - Operator wrapper for public.eql\_v3\_text\_ord.
* [`neq(eql_v3_text_ord, eql_v3_text_ord)`](#neqeql_v3_text_ord-eql_v3_text_ord) - Operator wrapper for public.eql\_v3\_text\_ord.
* [`neq(query_integer_ord_ope, eql_v3_integer_ord_ope)`](#neqquery_integer_ord_ope-eql_v3_integer_ord_ope) - Operator wrapper for eql\_v3.query\_integer\_ord\_ope.
* [`neq(eql_v3_integer_ord_ope, query_integer_ord_ope)`](#neqeql_v3_integer_ord_ope-query_integer_ord_ope) - Operator wrapper for eql\_v3.query\_integer\_ord\_ope.
* [`neq(query_text_ord, eql_v3_text_ord)`](#neqquery_text_ord-eql_v3_text_ord) - Operator wrapper for eql\_v3.query\_text\_ord.
* [`neq(eql_v3_text_ord, query_text_ord)`](#neqeql_v3_text_ord-query_text_ord) - Operator wrapper for eql\_v3.query\_text\_ord.
* [`neq(jsonb, eql_v3_timestamp_ord_ope)`](#neqjsonb-eql_v3_timestamp_ord_ope) - Operator wrapper for public.eql\_v3\_timestamp\_ord\_ope.
* [`neq(eql_v3_timestamp_ord_ope, jsonb)`](#neqeql_v3_timestamp_ord_ope-jsonb) - Operator wrapper for public.eql\_v3\_timestamp\_ord\_ope.
* [`neq(eql_v3_timestamp_ord_ope, eql_v3_timestamp_ord_ope)`](#neqeql_v3_timestamp_ord_ope-eql_v3_timestamp_ord_ope) - Operator wrapper for public.eql\_v3\_timestamp\_ord\_ope.
* [`neq(jsonb, eql_v3_integer_ord_ope)`](#neqjsonb-eql_v3_integer_ord_ope) - Operator wrapper for public.eql\_v3\_integer\_ord\_ope.
* [`neq(eql_v3_integer_ord_ope, jsonb)`](#neqeql_v3_integer_ord_ope-jsonb) - Operator wrapper for public.eql\_v3\_integer\_ord\_ope.
* [`neq(eql_v3_integer_ord_ope, eql_v3_integer_ord_ope)`](#neqeql_v3_integer_ord_ope-eql_v3_integer_ord_ope) - Operator wrapper for public.eql\_v3\_integer\_ord\_ope.
* [`neq(query_integer_ord, eql_v3_integer_ord)`](#neqquery_integer_ord-eql_v3_integer_ord) - Operator wrapper for eql\_v3.query\_integer\_ord.
* [`neq(eql_v3_integer_ord, query_integer_ord)`](#neqeql_v3_integer_ord-query_integer_ord) - Operator wrapper for eql\_v3.query\_integer\_ord.
* [`neq(query_text_search, eql_v3_text_search)`](#neqquery_text_search-eql_v3_text_search) - Operator wrapper for eql\_v3.query\_text\_search.
* [`neq(eql_v3_text_search, query_text_search)`](#neqeql_v3_text_search-query_text_search) - Operator wrapper for eql\_v3.query\_text\_search.
* [`neq(query_numeric_eq, eql_v3_numeric_eq)`](#neqquery_numeric_eq-eql_v3_numeric_eq) - Operator wrapper for eql\_v3.query\_numeric\_eq.
* [`neq(eql_v3_numeric_eq, query_numeric_eq)`](#neqeql_v3_numeric_eq-query_numeric_eq) - Operator wrapper for eql\_v3.query\_numeric\_eq.
* [`neq(jsonb, eql_v3_bigint_eq)`](#neqjsonb-eql_v3_bigint_eq) - Operator wrapper for public.eql\_v3\_bigint\_eq.
* [`neq(eql_v3_bigint_eq, jsonb)`](#neqeql_v3_bigint_eq-jsonb) - Operator wrapper for public.eql\_v3\_bigint\_eq.
* [`neq(eql_v3_bigint_eq, eql_v3_bigint_eq)`](#neqeql_v3_bigint_eq-eql_v3_bigint_eq) - Operator wrapper for public.eql\_v3\_bigint\_eq.
* [`neq(query_smallint_eq, eql_v3_smallint_eq)`](#neqquery_smallint_eq-eql_v3_smallint_eq) - Operator wrapper for eql\_v3.query\_smallint\_eq.
* [`neq(eql_v3_smallint_eq, query_smallint_eq)`](#neqeql_v3_smallint_eq-query_smallint_eq) - Operator wrapper for eql\_v3.query\_smallint\_eq.
* [`neq(jsonb, eql_v3_numeric_ord)`](#neqjsonb-eql_v3_numeric_ord) - Operator wrapper for public.eql\_v3\_numeric\_ord.
* [`neq(eql_v3_numeric_ord, jsonb)`](#neqeql_v3_numeric_ord-jsonb) - Operator wrapper for public.eql\_v3\_numeric\_ord.
* [`neq(eql_v3_numeric_ord, eql_v3_numeric_ord)`](#neqeql_v3_numeric_ord-eql_v3_numeric_ord) - Operator wrapper for public.eql\_v3\_numeric\_ord.
* [`neq(query_date_ord_ope, eql_v3_date_ord_ope)`](#neqquery_date_ord_ope-eql_v3_date_ord_ope) - Operator wrapper for eql\_v3.query\_date\_ord\_ope.
* [`neq(eql_v3_date_ord_ope, query_date_ord_ope)`](#neqeql_v3_date_ord_ope-query_date_ord_ope) - Operator wrapper for eql\_v3.query\_date\_ord\_ope.
* [`neq(query_timestamp_ord_ore, eql_v3_timestamp_ord_ore)`](#neqquery_timestamp_ord_ore-eql_v3_timestamp_ord_ore) - Operator wrapper for eql\_v3.query\_timestamp\_ord\_ore.
* [`neq(eql_v3_timestamp_ord_ore, query_timestamp_ord_ore)`](#neqeql_v3_timestamp_ord_ore-query_timestamp_ord_ore) - Operator wrapper for eql\_v3.query\_timestamp\_ord\_ore.
* [`neq(query_text_search_ore, eql_v3_text_search_ore)`](#neqquery_text_search_ore-eql_v3_text_search_ore) - Operator wrapper for eql\_v3.query\_text\_search\_ore.
* [`neq(eql_v3_text_search_ore, query_text_search_ore)`](#neqeql_v3_text_search_ore-query_text_search_ore) - Operator wrapper for eql\_v3.query\_text\_search\_ore.
* [`neq(query_text_ord_ore, eql_v3_text_ord_ore)`](#neqquery_text_ord_ore-eql_v3_text_ord_ore) - Operator wrapper for eql\_v3.query\_text\_ord\_ore.
* [`neq(eql_v3_text_ord_ore, query_text_ord_ore)`](#neqeql_v3_text_ord_ore-query_text_ord_ore) - Operator wrapper for eql\_v3.query\_text\_ord\_ore.
* [`neq(jsonb, eql_v3_timestamp_eq)`](#neqjsonb-eql_v3_timestamp_eq) - Operator wrapper for public.eql\_v3\_timestamp\_eq.
* [`neq(eql_v3_timestamp_eq, jsonb)`](#neqeql_v3_timestamp_eq-jsonb) - Operator wrapper for public.eql\_v3\_timestamp\_eq.
* [`neq(eql_v3_timestamp_eq, eql_v3_timestamp_eq)`](#neqeql_v3_timestamp_eq-eql_v3_timestamp_eq) - Operator wrapper for public.eql\_v3\_timestamp\_eq.
* [`neq(jsonb, eql_v3_real_ord_ope)`](#neqjsonb-eql_v3_real_ord_ope) - Operator wrapper for public.eql\_v3\_real\_ord\_ope.
* [`neq(eql_v3_real_ord_ope, jsonb)`](#neqeql_v3_real_ord_ope-jsonb) - Operator wrapper for public.eql\_v3\_real\_ord\_ope.
* [`neq(eql_v3_real_ord_ope, eql_v3_real_ord_ope)`](#neqeql_v3_real_ord_ope-eql_v3_real_ord_ope) - Operator wrapper for public.eql\_v3\_real\_ord\_ope.
* [`neq(jsonb, eql_v3_real_ord)`](#neqjsonb-eql_v3_real_ord) - Operator wrapper for public.eql\_v3\_real\_ord.
* [`neq(eql_v3_real_ord, jsonb)`](#neqeql_v3_real_ord-jsonb) - Operator wrapper for public.eql\_v3\_real\_ord.
* [`neq(eql_v3_real_ord, eql_v3_real_ord)`](#neqeql_v3_real_ord-eql_v3_real_ord) - Operator wrapper for public.eql\_v3\_real\_ord.
* [`neq(jsonb, eql_v3_integer_ord)`](#neqjsonb-eql_v3_integer_ord) - Operator wrapper for public.eql\_v3\_integer\_ord.
* [`neq(eql_v3_integer_ord, jsonb)`](#neqeql_v3_integer_ord-jsonb) - Operator wrapper for public.eql\_v3\_integer\_ord.
* [`neq(eql_v3_integer_ord, eql_v3_integer_ord)`](#neqeql_v3_integer_ord-eql_v3_integer_ord) - Operator wrapper for public.eql\_v3\_integer\_ord.
* [`neq(query_smallint_ord_ore, eql_v3_smallint_ord_ore)`](#neqquery_smallint_ord_ore-eql_v3_smallint_ord_ore) - Operator wrapper for eql\_v3.query\_smallint\_ord\_ore.
* [`neq(eql_v3_smallint_ord_ore, query_smallint_ord_ore)`](#neqeql_v3_smallint_ord_ore-query_smallint_ord_ore) - Operator wrapper for eql\_v3.query\_smallint\_ord\_ore.
* [`neq(jsonb, eql_v3_text_ord_ope)`](#neqjsonb-eql_v3_text_ord_ope) - Operator wrapper for public.eql\_v3\_text\_ord\_ope.
* [`neq(eql_v3_text_ord_ope, jsonb)`](#neqeql_v3_text_ord_ope-jsonb) - Operator wrapper for public.eql\_v3\_text\_ord\_ope.
* [`neq(eql_v3_text_ord_ope, eql_v3_text_ord_ope)`](#neqeql_v3_text_ord_ope-eql_v3_text_ord_ope) - Operator wrapper for public.eql\_v3\_text\_ord\_ope.
* [`neq(query_double_ord_ope, eql_v3_double_ord_ope)`](#neqquery_double_ord_ope-eql_v3_double_ord_ope) - Operator wrapper for eql\_v3.query\_double\_ord\_ope.
* [`neq(eql_v3_double_ord_ope, query_double_ord_ope)`](#neqeql_v3_double_ord_ope-query_double_ord_ope) - Operator wrapper for eql\_v3.query\_double\_ord\_ope.
* [`neq(query_integer_ord_ore, eql_v3_integer_ord_ore)`](#neqquery_integer_ord_ore-eql_v3_integer_ord_ore) - Operator wrapper for eql\_v3.query\_integer\_ord\_ore.
* [`neq(eql_v3_integer_ord_ore, query_integer_ord_ore)`](#neqeql_v3_integer_ord_ore-query_integer_ord_ore) - Operator wrapper for eql\_v3.query\_integer\_ord\_ore.
* [`neq(jsonb, eql_v3_real_eq)`](#neqjsonb-eql_v3_real_eq) - Operator wrapper for public.eql\_v3\_real\_eq.
* [`neq(eql_v3_real_eq, jsonb)`](#neqeql_v3_real_eq-jsonb) - Operator wrapper for public.eql\_v3\_real\_eq.
* [`neq(eql_v3_real_eq, eql_v3_real_eq)`](#neqeql_v3_real_eq-eql_v3_real_eq) - Operator wrapper for public.eql\_v3\_real\_eq.
* [`neq(query_text_eq, eql_v3_text_eq)`](#neqquery_text_eq-eql_v3_text_eq) - Operator wrapper for eql\_v3.query\_text\_eq.
* [`neq(eql_v3_text_eq, query_text_eq)`](#neqeql_v3_text_eq-query_text_eq) - Operator wrapper for eql\_v3.query\_text\_eq.
* [`neq(jsonb, eql_v3_bigint_ord_ore)`](#neqjsonb-eql_v3_bigint_ord_ore) - Operator wrapper for public.eql\_v3\_bigint\_ord\_ore.
* [`neq(eql_v3_bigint_ord_ore, jsonb)`](#neqeql_v3_bigint_ord_ore-jsonb) - Operator wrapper for public.eql\_v3\_bigint\_ord\_ore.
* [`neq(eql_v3_bigint_ord_ore, eql_v3_bigint_ord_ore)`](#neqeql_v3_bigint_ord_ore-eql_v3_bigint_ord_ore) - Operator wrapper for public.eql\_v3\_bigint\_ord\_ore.
* [`neq(query_date_ord, eql_v3_date_ord)`](#neqquery_date_ord-eql_v3_date_ord) - Operator wrapper for eql\_v3.query\_date\_ord.
* [`neq(eql_v3_date_ord, query_date_ord)`](#neqeql_v3_date_ord-query_date_ord) - Operator wrapper for eql\_v3.query\_date\_ord.
* [`neq(jsonb, eql_v3_double_eq)`](#neqjsonb-eql_v3_double_eq) - Operator wrapper for public.eql\_v3\_double\_eq.
* [`neq(eql_v3_double_eq, jsonb)`](#neqeql_v3_double_eq-jsonb) - Operator wrapper for public.eql\_v3\_double\_eq.
* [`neq(eql_v3_double_eq, eql_v3_double_eq)`](#neqeql_v3_double_eq-eql_v3_double_eq) - Operator wrapper for public.eql\_v3\_double\_eq.
* [`neq(jsonb, eql_v3_real_ord_ore)`](#neqjsonb-eql_v3_real_ord_ore) - Operator wrapper for public.eql\_v3\_real\_ord\_ore.
* [`neq(eql_v3_real_ord_ore, jsonb)`](#neqeql_v3_real_ord_ore-jsonb) - Operator wrapper for public.eql\_v3\_real\_ord\_ore.
* [`neq(eql_v3_real_ord_ore, eql_v3_real_ord_ore)`](#neqeql_v3_real_ord_ore-eql_v3_real_ord_ore) - Operator wrapper for public.eql\_v3\_real\_ord\_ore.
* [`neq(jsonb, eql_v3_numeric_ord_ore)`](#neqjsonb-eql_v3_numeric_ord_ore) - Operator wrapper for public.eql\_v3\_numeric\_ord\_ore.
* [`neq(eql_v3_numeric_ord_ore, jsonb)`](#neqeql_v3_numeric_ord_ore-jsonb) - Operator wrapper for public.eql\_v3\_numeric\_ord\_ore.
* [`neq(eql_v3_numeric_ord_ore, eql_v3_numeric_ord_ore)`](#neqeql_v3_numeric_ord_ore-eql_v3_numeric_ord_ore) - Operator wrapper for public.eql\_v3\_numeric\_ord\_ore.
* [`neq(query_double_eq, eql_v3_double_eq)`](#neqquery_double_eq-eql_v3_double_eq) - Operator wrapper for eql\_v3.query\_double\_eq.
* [`neq(eql_v3_double_eq, query_double_eq)`](#neqeql_v3_double_eq-query_double_eq) - Operator wrapper for eql\_v3.query\_double\_eq.
* [`neq(query_text_ord_ope, eql_v3_text_ord_ope)`](#neqquery_text_ord_ope-eql_v3_text_ord_ope) - Operator wrapper for eql\_v3.query\_text\_ord\_ope.
* [`neq(eql_v3_text_ord_ope, query_text_ord_ope)`](#neqeql_v3_text_ord_ope-query_text_ord_ope) - Operator wrapper for eql\_v3.query\_text\_ord\_ope.
* [`neq(jsonb, eql_v3_bigint_ord_ope)`](#neqjsonb-eql_v3_bigint_ord_ope) - Operator wrapper for public.eql\_v3\_bigint\_ord\_ope.
* [`neq(eql_v3_bigint_ord_ope, jsonb)`](#neqeql_v3_bigint_ord_ope-jsonb) - Operator wrapper for public.eql\_v3\_bigint\_ord\_ope.
* [`neq(eql_v3_bigint_ord_ope, eql_v3_bigint_ord_ope)`](#neqeql_v3_bigint_ord_ope-eql_v3_bigint_ord_ope) - Operator wrapper for public.eql\_v3\_bigint\_ord\_ope.
* [`neq(query_real_eq, eql_v3_real_eq)`](#neqquery_real_eq-eql_v3_real_eq) - Operator wrapper for eql\_v3.query\_real\_eq.
* [`neq(eql_v3_real_eq, query_real_eq)`](#neqeql_v3_real_eq-query_real_eq) - Operator wrapper for eql\_v3.query\_real\_eq.
* [`neq(jsonb, eql_v3_double_ord_ore)`](#neqjsonb-eql_v3_double_ord_ore) - Operator wrapper for public.eql\_v3\_double\_ord\_ore.
* [`neq(eql_v3_double_ord_ore, jsonb)`](#neqeql_v3_double_ord_ore-jsonb) - Operator wrapper for public.eql\_v3\_double\_ord\_ore.
* [`neq(eql_v3_double_ord_ore, eql_v3_double_ord_ore)`](#neqeql_v3_double_ord_ore-eql_v3_double_ord_ore) - Operator wrapper for public.eql\_v3\_double\_ord\_ore.
* [`neq(jsonb, eql_v3_bigint_ord)`](#neqjsonb-eql_v3_bigint_ord) - Operator wrapper for public.eql\_v3\_bigint\_ord.
* [`neq(eql_v3_bigint_ord, jsonb)`](#neqeql_v3_bigint_ord-jsonb) - Operator wrapper for public.eql\_v3\_bigint\_ord.
* [`neq(eql_v3_bigint_ord, eql_v3_bigint_ord)`](#neqeql_v3_bigint_ord-eql_v3_bigint_ord) - Operator wrapper for public.eql\_v3\_bigint\_ord.
* [`neq(query_timestamp_ord_ope, eql_v3_timestamp_ord_ope)`](#neqquery_timestamp_ord_ope-eql_v3_timestamp_ord_ope) - Operator wrapper for eql\_v3.query\_timestamp\_ord\_ope.
* [`neq(eql_v3_timestamp_ord_ope, query_timestamp_ord_ope)`](#neqeql_v3_timestamp_ord_ope-query_timestamp_ord_ope) - Operator wrapper for eql\_v3.query\_timestamp\_ord\_ope.
* [`neq(query_numeric_ord, eql_v3_numeric_ord)`](#neqquery_numeric_ord-eql_v3_numeric_ord) - Operator wrapper for eql\_v3.query\_numeric\_ord.
* [`neq(eql_v3_numeric_ord, query_numeric_ord)`](#neqeql_v3_numeric_ord-query_numeric_ord) - Operator wrapper for eql\_v3.query\_numeric\_ord.
* [`neq(jsonb, eql_v3_text_search_ore)`](#neqjsonb-eql_v3_text_search_ore) - Operator wrapper for public.eql\_v3\_text\_search\_ore.
* [`neq(eql_v3_text_search_ore, jsonb)`](#neqeql_v3_text_search_ore-jsonb) - Operator wrapper for public.eql\_v3\_text\_search\_ore.
* [`neq(eql_v3_text_search_ore, eql_v3_text_search_ore)`](#neqeql_v3_text_search_ore-eql_v3_text_search_ore) - Operator wrapper for public.eql\_v3\_text\_search\_ore.
* [`neq(query_bigint_eq, eql_v3_bigint_eq)`](#neqquery_bigint_eq-eql_v3_bigint_eq) - Operator wrapper for eql\_v3.query\_bigint\_eq.
* [`neq(eql_v3_bigint_eq, query_bigint_eq)`](#neqeql_v3_bigint_eq-query_bigint_eq) - Operator wrapper for eql\_v3.query\_bigint\_eq.
* [`neq(query_timestamp_eq, eql_v3_timestamp_eq)`](#neqquery_timestamp_eq-eql_v3_timestamp_eq) - Operator wrapper for eql\_v3.query\_timestamp\_eq.
* [`neq(eql_v3_timestamp_eq, query_timestamp_eq)`](#neqeql_v3_timestamp_eq-query_timestamp_eq) - Operator wrapper for eql\_v3.query\_timestamp\_eq.
* [`neq(query_real_ord_ope, eql_v3_real_ord_ope)`](#neqquery_real_ord_ope-eql_v3_real_ord_ope) - Operator wrapper for eql\_v3.query\_real\_ord\_ope.
* [`neq(eql_v3_real_ord_ope, query_real_ord_ope)`](#neqeql_v3_real_ord_ope-query_real_ord_ope) - Operator wrapper for eql\_v3.query\_real\_ord\_ope.
* [`neq(jsonb, eql_v3_numeric_eq)`](#neqjsonb-eql_v3_numeric_eq) - Operator wrapper for public.eql\_v3\_numeric\_eq.
* [`neq(eql_v3_numeric_eq, jsonb)`](#neqeql_v3_numeric_eq-jsonb) - Operator wrapper for public.eql\_v3\_numeric\_eq.
* [`neq(eql_v3_numeric_eq, eql_v3_numeric_eq)`](#neqeql_v3_numeric_eq-eql_v3_numeric_eq) - Operator wrapper for public.eql\_v3\_numeric\_eq.
* [`neq(jsonb, eql_v3_timestamp_ord)`](#neqjsonb-eql_v3_timestamp_ord) - Operator wrapper for public.eql\_v3\_timestamp\_ord.
* [`neq(eql_v3_timestamp_ord, jsonb)`](#neqeql_v3_timestamp_ord-jsonb) - Operator wrapper for public.eql\_v3\_timestamp\_ord.
* [`neq(eql_v3_timestamp_ord, eql_v3_timestamp_ord)`](#neqeql_v3_timestamp_ord-eql_v3_timestamp_ord) - Operator wrapper for public.eql\_v3\_timestamp\_ord.
* [`neq(jsonb, eql_v3_smallint_ord_ope)`](#neqjsonb-eql_v3_smallint_ord_ope) - Operator wrapper for public.eql\_v3\_smallint\_ord\_ope.
* [`neq(eql_v3_smallint_ord_ope, jsonb)`](#neqeql_v3_smallint_ord_ope-jsonb) - Operator wrapper for public.eql\_v3\_smallint\_ord\_ope.
* [`neq(eql_v3_smallint_ord_ope, eql_v3_smallint_ord_ope)`](#neqeql_v3_smallint_ord_ope-eql_v3_smallint_ord_ope) - Operator wrapper for public.eql\_v3\_smallint\_ord\_ope.
* [`neq(query_double_ord, eql_v3_double_ord)`](#neqquery_double_ord-eql_v3_double_ord) - Operator wrapper for eql\_v3.query\_double\_ord.
* [`neq(eql_v3_double_ord, query_double_ord)`](#neqeql_v3_double_ord-query_double_ord) - Operator wrapper for eql\_v3.query\_double\_ord.
* [`neq(query_date_eq, eql_v3_date_eq)`](#neqquery_date_eq-eql_v3_date_eq) - Operator wrapper for eql\_v3.query\_date\_eq.
* [`neq(eql_v3_date_eq, query_date_eq)`](#neqeql_v3_date_eq-query_date_eq) - Operator wrapper for eql\_v3.query\_date\_eq.
* [`neq(query_double_ord_ore, eql_v3_double_ord_ore)`](#neqquery_double_ord_ore-eql_v3_double_ord_ore) - Operator wrapper for eql\_v3.query\_double\_ord\_ore.
* [`neq(eql_v3_double_ord_ore, query_double_ord_ore)`](#neqeql_v3_double_ord_ore-query_double_ord_ore) - Operator wrapper for eql\_v3.query\_double\_ord\_ore.
* [`neq(jsonb, eql_v3_timestamp_ord_ore)`](#neqjsonb-eql_v3_timestamp_ord_ore) - Operator wrapper for public.eql\_v3\_timestamp\_ord\_ore.
* [`neq(eql_v3_timestamp_ord_ore, jsonb)`](#neqeql_v3_timestamp_ord_ore-jsonb) - Operator wrapper for public.eql\_v3\_timestamp\_ord\_ore.
* [`neq(eql_v3_timestamp_ord_ore, eql_v3_timestamp_ord_ore)`](#neqeql_v3_timestamp_ord_ore-eql_v3_timestamp_ord_ore) - Operator wrapper for public.eql\_v3\_timestamp\_ord\_ore.
* [`neq(jsonb, eql_v3_text_search)`](#neqjsonb-eql_v3_text_search) - Operator wrapper for public.eql\_v3\_text\_search.
* [`neq(eql_v3_text_search, jsonb)`](#neqeql_v3_text_search-jsonb) - Operator wrapper for public.eql\_v3\_text\_search.
* [`neq(eql_v3_text_search, eql_v3_text_search)`](#neqeql_v3_text_search-eql_v3_text_search) - Operator wrapper for public.eql\_v3\_text\_search.
* [`neq(query_numeric_ord_ore, eql_v3_numeric_ord_ore)`](#neqquery_numeric_ord_ore-eql_v3_numeric_ord_ore) - Operator wrapper for eql\_v3.query\_numeric\_ord\_ore.
* [`neq(eql_v3_numeric_ord_ore, query_numeric_ord_ore)`](#neqeql_v3_numeric_ord_ore-query_numeric_ord_ore) - Operator wrapper for eql\_v3.query\_numeric\_ord\_ore.
* [`neq(jsonb, eql_v3_smallint_eq)`](#neqjsonb-eql_v3_smallint_eq) - Operator wrapper for public.eql\_v3\_smallint\_eq.
* [`neq(eql_v3_smallint_eq, jsonb)`](#neqeql_v3_smallint_eq-jsonb) - Operator wrapper for public.eql\_v3\_smallint\_eq.
* [`neq(eql_v3_smallint_eq, eql_v3_smallint_eq)`](#neqeql_v3_smallint_eq-eql_v3_smallint_eq) - Operator wrapper for public.eql\_v3\_smallint\_eq.
* [`neq(query_bigint_ord_ore, eql_v3_bigint_ord_ore)`](#neqquery_bigint_ord_ore-eql_v3_bigint_ord_ore) - Operator wrapper for eql\_v3.query\_bigint\_ord\_ore.
* [`neq(eql_v3_bigint_ord_ore, query_bigint_ord_ore)`](#neqeql_v3_bigint_ord_ore-query_bigint_ord_ore) - Operator wrapper for eql\_v3.query\_bigint\_ord\_ore.
* [`neq(query_bigint_ord_ope, eql_v3_bigint_ord_ope)`](#neqquery_bigint_ord_ope-eql_v3_bigint_ord_ope) - Operator wrapper for eql\_v3.query\_bigint\_ord\_ope.
* [`neq(eql_v3_bigint_ord_ope, query_bigint_ord_ope)`](#neqeql_v3_bigint_ord_ope-query_bigint_ord_ope) - Operator wrapper for eql\_v3.query\_bigint\_ord\_ope.
* [`neq(query_date_ord_ore, eql_v3_date_ord_ore)`](#neqquery_date_ord_ore-eql_v3_date_ord_ore) - Operator wrapper for eql\_v3.query\_date\_ord\_ore.
* [`neq(eql_v3_date_ord_ore, query_date_ord_ore)`](#neqeql_v3_date_ord_ore-query_date_ord_ore) - Operator wrapper for eql\_v3.query\_date\_ord\_ore.
* [`neq(query_smallint_ord_ope, eql_v3_smallint_ord_ope)`](#neqquery_smallint_ord_ope-eql_v3_smallint_ord_ope) - Operator wrapper for eql\_v3.query\_smallint\_ord\_ope.
* [`neq(eql_v3_smallint_ord_ope, query_smallint_ord_ope)`](#neqeql_v3_smallint_ord_ope-query_smallint_ord_ope) - Operator wrapper for eql\_v3.query\_smallint\_ord\_ope.
* [`neq(jsonb, eql_v3_double_ord)`](#neqjsonb-eql_v3_double_ord) - Operator wrapper for public.eql\_v3\_double\_ord.
* [`neq(eql_v3_double_ord, jsonb)`](#neqeql_v3_double_ord-jsonb) - Operator wrapper for public.eql\_v3\_double\_ord.
* [`neq(eql_v3_double_ord, eql_v3_double_ord)`](#neqeql_v3_double_ord-eql_v3_double_ord) - Operator wrapper for public.eql\_v3\_double\_ord.
* [`neq(query_numeric_ord_ope, eql_v3_numeric_ord_ope)`](#neqquery_numeric_ord_ope-eql_v3_numeric_ord_ope) - Operator wrapper for eql\_v3.query\_numeric\_ord\_ope.
* [`neq(eql_v3_numeric_ord_ope, query_numeric_ord_ope)`](#neqeql_v3_numeric_ord_ope-query_numeric_ord_ope) - Operator wrapper for eql\_v3.query\_numeric\_ord\_ope.
* [`neq(jsonb, eql_v3_date_eq)`](#neqjsonb-eql_v3_date_eq) - Operator wrapper for public.eql\_v3\_date\_eq.
* [`neq(eql_v3_date_eq, jsonb)`](#neqeql_v3_date_eq-jsonb) - Operator wrapper for public.eql\_v3\_date\_eq.
* [`neq(eql_v3_date_eq, eql_v3_date_eq)`](#neqeql_v3_date_eq-eql_v3_date_eq) - Operator wrapper for public.eql\_v3\_date\_eq.
* [`neq(jsonb, eql_v3_double_ord_ope)`](#neqjsonb-eql_v3_double_ord_ope) - Operator wrapper for public.eql\_v3\_double\_ord\_ope.
* [`neq(eql_v3_double_ord_ope, jsonb)`](#neqeql_v3_double_ord_ope-jsonb) - Operator wrapper for public.eql\_v3\_double\_ord\_ope.
* [`neq(eql_v3_double_ord_ope, eql_v3_double_ord_ope)`](#neqeql_v3_double_ord_ope-eql_v3_double_ord_ope) - Operator wrapper for public.eql\_v3\_double\_ord\_ope.
* [`neq(jsonb, eql_v3_numeric_ord_ope)`](#neqjsonb-eql_v3_numeric_ord_ope) - Operator wrapper for public.eql\_v3\_numeric\_ord\_ope.
* [`neq(eql_v3_numeric_ord_ope, jsonb)`](#neqeql_v3_numeric_ord_ope-jsonb) - Operator wrapper for public.eql\_v3\_numeric\_ord\_ope.
* [`neq(eql_v3_numeric_ord_ope, eql_v3_numeric_ord_ope)`](#neqeql_v3_numeric_ord_ope-eql_v3_numeric_ord_ope) - Operator wrapper for public.eql\_v3\_numeric\_ord\_ope.
* [`neq(jsonb, eql_v3_date_ord_ore)`](#neqjsonb-eql_v3_date_ord_ore) - Operator wrapper for public.eql\_v3\_date\_ord\_ore.
* [`neq(eql_v3_date_ord_ore, jsonb)`](#neqeql_v3_date_ord_ore-jsonb) - Operator wrapper for public.eql\_v3\_date\_ord\_ore.
* [`neq(eql_v3_date_ord_ore, eql_v3_date_ord_ore)`](#neqeql_v3_date_ord_ore-eql_v3_date_ord_ore) - Operator wrapper for public.eql\_v3\_date\_ord\_ore.
* [`neq(query_timestamp_ord, eql_v3_timestamp_ord)`](#neqquery_timestamp_ord-eql_v3_timestamp_ord) - Operator wrapper for eql\_v3.query\_timestamp\_ord.
* [`neq(eql_v3_timestamp_ord, query_timestamp_ord)`](#neqeql_v3_timestamp_ord-query_timestamp_ord) - Operator wrapper for eql\_v3.query\_timestamp\_ord.
* [`neq(jsonb, eql_v3_text_eq)`](#neqjsonb-eql_v3_text_eq) - Operator wrapper for public.eql\_v3\_text\_eq.
* [`neq(eql_v3_text_eq, jsonb)`](#neqeql_v3_text_eq-jsonb) - Operator wrapper for public.eql\_v3\_text\_eq.
* [`neq(eql_v3_text_eq, eql_v3_text_eq)`](#neqeql_v3_text_eq-eql_v3_text_eq) - Operator wrapper for public.eql\_v3\_text\_eq.
* [`neq(jsonb, eql_v3_integer_eq)`](#neqjsonb-eql_v3_integer_eq) - Operator wrapper for public.eql\_v3\_integer\_eq.
* [`neq(eql_v3_integer_eq, jsonb)`](#neqeql_v3_integer_eq-jsonb) - Operator wrapper for public.eql\_v3\_integer\_eq.
* [`neq(eql_v3_integer_eq, eql_v3_integer_eq)`](#neqeql_v3_integer_eq-eql_v3_integer_eq) - Operator wrapper for public.eql\_v3\_integer\_eq.
* [`neq(query_integer_eq, eql_v3_integer_eq)`](#neqquery_integer_eq-eql_v3_integer_eq) - Operator wrapper for eql\_v3.query\_integer\_eq.
* [`neq(eql_v3_integer_eq, query_integer_eq)`](#neqeql_v3_integer_eq-query_integer_eq) - Operator wrapper for eql\_v3.query\_integer\_eq.
* [`neq(jsonb, eql_v3_smallint_ord_ore)`](#neqjsonb-eql_v3_smallint_ord_ore) - Operator wrapper for public.eql\_v3\_smallint\_ord\_ore.
* [`neq(eql_v3_smallint_ord_ore, jsonb)`](#neqeql_v3_smallint_ord_ore-jsonb) - Operator wrapper for public.eql\_v3\_smallint\_ord\_ore.
* [`neq(eql_v3_smallint_ord_ore, eql_v3_smallint_ord_ore)`](#neqeql_v3_smallint_ord_ore-eql_v3_smallint_ord_ore) - Operator wrapper for public.eql\_v3\_smallint\_ord\_ore.
* [`neq(jsonb, eql_v3_date_ord_ope)`](#neqjsonb-eql_v3_date_ord_ope) - Operator wrapper for public.eql\_v3\_date\_ord\_ope.
* [`neq(eql_v3_date_ord_ope, jsonb)`](#neqeql_v3_date_ord_ope-jsonb) - Operator wrapper for public.eql\_v3\_date\_ord\_ope.
* [`neq(eql_v3_date_ord_ope, eql_v3_date_ord_ope)`](#neqeql_v3_date_ord_ope-eql_v3_date_ord_ope) - Operator wrapper for public.eql\_v3\_date\_ord\_ope.
* [`neq(query_bigint_ord, eql_v3_bigint_ord)`](#neqquery_bigint_ord-eql_v3_bigint_ord) - Operator wrapper for eql\_v3.query\_bigint\_ord.
* [`neq(eql_v3_bigint_ord, query_bigint_ord)`](#neqeql_v3_bigint_ord-query_bigint_ord) - Operator wrapper for eql\_v3.query\_bigint\_ord.
* [`neq(jsonb, eql_v3_text_ord_ore)`](#neqjsonb-eql_v3_text_ord_ore) - Operator wrapper for public.eql\_v3\_text\_ord\_ore.
* [`neq(eql_v3_text_ord_ore, jsonb)`](#neqeql_v3_text_ord_ore-jsonb) - Operator wrapper for public.eql\_v3\_text\_ord\_ore.
* [`neq(eql_v3_text_ord_ore, eql_v3_text_ord_ore)`](#neqeql_v3_text_ord_ore-eql_v3_text_ord_ore) - Operator wrapper for public.eql\_v3\_text\_ord\_ore.
* [`ope_term(eql_v3_json_entry)`](#ope_termeql_v3_json_entry) - Low-level deterministic OPE byte extractor for a json entry.
* [`ord_term(query_smallint_ord)`](#ord_termquery_smallint_ord) - Index extractor for eql\_v3.query\_smallint\_ord.
* [`ord_term(eql_v3_smallint_ord)`](#ord_termeql_v3_smallint_ord) - Index extractor for public.eql\_v3\_smallint\_ord.
* [`ord_term(eql_v3_date_ord)`](#ord_termeql_v3_date_ord) - Index extractor for public.eql\_v3\_date\_ord.
* [`ord_term(query_real_ord)`](#ord_termquery_real_ord) - Index extractor for eql\_v3.query\_real\_ord.
* [`ord_term(eql_v3_text_ord)`](#ord_termeql_v3_text_ord) - Index extractor for public.eql\_v3\_text\_ord.
* [`ord_term(query_integer_ord_ope)`](#ord_termquery_integer_ord_ope) - Index extractor for eql\_v3.query\_integer\_ord\_ope.
* [`ord_term(query_text_ord)`](#ord_termquery_text_ord) - Index extractor for eql\_v3.query\_text\_ord.
* [`ord_term(eql_v3_timestamp_ord_ope)`](#ord_termeql_v3_timestamp_ord_ope) - Index extractor for public.eql\_v3\_timestamp\_ord\_ope.
* [`ord_term(eql_v3_integer_ord_ope)`](#ord_termeql_v3_integer_ord_ope) - Index extractor for public.eql\_v3\_integer\_ord\_ope.
* [`ord_term(query_integer_ord)`](#ord_termquery_integer_ord) - Index extractor for eql\_v3.query\_integer\_ord.
* [`ord_term(query_text_search)`](#ord_termquery_text_search) - Index extractor for eql\_v3.query\_text\_search.
* [`ord_term(eql_v3_numeric_ord)`](#ord_termeql_v3_numeric_ord) - Index extractor for public.eql\_v3\_numeric\_ord.
* [`ord_term(query_date_ord_ope)`](#ord_termquery_date_ord_ope) - Index extractor for eql\_v3.query\_date\_ord\_ope.
* [`ord_term(eql_v3_real_ord_ope)`](#ord_termeql_v3_real_ord_ope) - Index extractor for public.eql\_v3\_real\_ord\_ope.
* [`ord_term(eql_v3_real_ord)`](#ord_termeql_v3_real_ord) - Index extractor for public.eql\_v3\_real\_ord.
* [`ord_term(eql_v3_integer_ord)`](#ord_termeql_v3_integer_ord) - Index extractor for public.eql\_v3\_integer\_ord.
* [`ord_term(eql_v3_text_ord_ope)`](#ord_termeql_v3_text_ord_ope) - Index extractor for public.eql\_v3\_text\_ord\_ope.
* [`ord_term(query_double_ord_ope)`](#ord_termquery_double_ord_ope) - Index extractor for eql\_v3.query\_double\_ord\_ope.
* [`ord_term(query_date_ord)`](#ord_termquery_date_ord) - Index extractor for eql\_v3.query\_date\_ord.
* [`ord_term(eql_v3_json_entry)`](#ord_termeql_v3_json_entry) - Extract the CLLW OPE index term from a ste\_vec entry.
* [`ord_term(query_text_ord_ope)`](#ord_termquery_text_ord_ope) - Index extractor for eql\_v3.query\_text\_ord\_ope.
* [`ord_term(eql_v3_bigint_ord_ope)`](#ord_termeql_v3_bigint_ord_ope) - Index extractor for public.eql\_v3\_bigint\_ord\_ope.
* [`ord_term(eql_v3_bigint_ord)`](#ord_termeql_v3_bigint_ord) - Index extractor for public.eql\_v3\_bigint\_ord.
* [`ord_term(query_timestamp_ord_ope)`](#ord_termquery_timestamp_ord_ope) - Index extractor for eql\_v3.query\_timestamp\_ord\_ope.
* [`ord_term(query_numeric_ord)`](#ord_termquery_numeric_ord) - Index extractor for eql\_v3.query\_numeric\_ord.
* [`ord_term(query_real_ord_ope)`](#ord_termquery_real_ord_ope) - Index extractor for eql\_v3.query\_real\_ord\_ope.
* [`ord_term(eql_v3_timestamp_ord)`](#ord_termeql_v3_timestamp_ord) - Index extractor for public.eql\_v3\_timestamp\_ord.
* [`ord_term(eql_v3_smallint_ord_ope)`](#ord_termeql_v3_smallint_ord_ope) - Index extractor for public.eql\_v3\_smallint\_ord\_ope.
* [`ord_term(query_double_ord)`](#ord_termquery_double_ord) - Index extractor for eql\_v3.query\_double\_ord.
* [`ord_term(eql_v3_text_search)`](#ord_termeql_v3_text_search) - Index extractor for public.eql\_v3\_text\_search.
* [`ord_term(query_bigint_ord_ope)`](#ord_termquery_bigint_ord_ope) - Index extractor for eql\_v3.query\_bigint\_ord\_ope.
* [`ord_term(query_smallint_ord_ope)`](#ord_termquery_smallint_ord_ope) - Index extractor for eql\_v3.query\_smallint\_ord\_ope.
* [`ord_term(eql_v3_double_ord)`](#ord_termeql_v3_double_ord) - Index extractor for public.eql\_v3\_double\_ord.
* [`ord_term(query_numeric_ord_ope)`](#ord_termquery_numeric_ord_ope) - Index extractor for eql\_v3.query\_numeric\_ord\_ope.
* [`ord_term(eql_v3_double_ord_ope)`](#ord_termeql_v3_double_ord_ope) - Index extractor for public.eql\_v3\_double\_ord\_ope.
* [`ord_term(eql_v3_numeric_ord_ope)`](#ord_termeql_v3_numeric_ord_ope) - Index extractor for public.eql\_v3\_numeric\_ord\_ope.
* [`ord_term(query_timestamp_ord)`](#ord_termquery_timestamp_ord) - Index extractor for eql\_v3.query\_timestamp\_ord.
* [`ord_term(eql_v3_date_ord_ope)`](#ord_termeql_v3_date_ord_ope) - Index extractor for public.eql\_v3\_date\_ord\_ope.
* [`ord_term(query_bigint_ord)`](#ord_termquery_bigint_ord) - Index extractor for eql\_v3.query\_bigint\_ord.
* [`ord_term_ore(eql_v3_integer_ord_ore)`](#ord_term_oreeql_v3_integer_ord_ore) - Index extractor for public.eql\_v3\_integer\_ord\_ore.
* [`ord_term_ore(query_real_ord_ore)`](#ord_term_orequery_real_ord_ore) - Index extractor for eql\_v3.query\_real\_ord\_ore.
* [`ord_term_ore(query_timestamp_ord_ore)`](#ord_term_orequery_timestamp_ord_ore) - Index extractor for eql\_v3.query\_timestamp\_ord\_ore.
* [`ord_term_ore(query_text_search_ore)`](#ord_term_orequery_text_search_ore) - Index extractor for eql\_v3.query\_text\_search\_ore.
* [`ord_term_ore(query_text_ord_ore)`](#ord_term_orequery_text_ord_ore) - Index extractor for eql\_v3.query\_text\_ord\_ore.
* [`ord_term_ore(query_smallint_ord_ore)`](#ord_term_orequery_smallint_ord_ore) - Index extractor for eql\_v3.query\_smallint\_ord\_ore.
* [`ord_term_ore(query_integer_ord_ore)`](#ord_term_orequery_integer_ord_ore) - Index extractor for eql\_v3.query\_integer\_ord\_ore.
* [`ord_term_ore(eql_v3_bigint_ord_ore)`](#ord_term_oreeql_v3_bigint_ord_ore) - Index extractor for public.eql\_v3\_bigint\_ord\_ore.
* [`ord_term_ore(eql_v3_real_ord_ore)`](#ord_term_oreeql_v3_real_ord_ore) - Index extractor for public.eql\_v3\_real\_ord\_ore.
* [`ord_term_ore(eql_v3_numeric_ord_ore)`](#ord_term_oreeql_v3_numeric_ord_ore) - Index extractor for public.eql\_v3\_numeric\_ord\_ore.
* [`ord_term_ore(eql_v3_double_ord_ore)`](#ord_term_oreeql_v3_double_ord_ore) - Index extractor for public.eql\_v3\_double\_ord\_ore.
* [`ord_term_ore(eql_v3_text_search_ore)`](#ord_term_oreeql_v3_text_search_ore) - Index extractor for public.eql\_v3\_text\_search\_ore.
* [`ord_term_ore(query_double_ord_ore)`](#ord_term_orequery_double_ord_ore) - Index extractor for eql\_v3.query\_double\_ord\_ore.
* [`ord_term_ore(eql_v3_timestamp_ord_ore)`](#ord_term_oreeql_v3_timestamp_ord_ore) - Index extractor for public.eql\_v3\_timestamp\_ord\_ore.
* [`ord_term_ore(query_numeric_ord_ore)`](#ord_term_orequery_numeric_ord_ore) - Index extractor for eql\_v3.query\_numeric\_ord\_ore.
* [`ord_term_ore(query_bigint_ord_ore)`](#ord_term_orequery_bigint_ord_ore) - Index extractor for eql\_v3.query\_bigint\_ord\_ore.
* [`ord_term_ore(query_date_ord_ore)`](#ord_term_orequery_date_ord_ore) - Index extractor for eql\_v3.query\_date\_ord\_ore.
* [`ord_term_ore(eql_v3_date_ord_ore)`](#ord_term_oreeql_v3_date_ord_ore) - Index extractor for public.eql\_v3\_date\_ord\_ore.
* [`ord_term_ore(eql_v3_smallint_ord_ore)`](#ord_term_oreeql_v3_smallint_ord_ore) - Index extractor for public.eql\_v3\_smallint\_ord\_ore.
* [`ord_term_ore(eql_v3_text_ord_ore)`](#ord_term_oreeql_v3_text_ord_ore) - Index extractor for public.eql\_v3\_text\_ord\_ore.
* [`selector(eql_v3_json_entry)`](#selectoreql_v3_json_entry) - Extract selector (s) from a ste\_vec entry.
* [`selector(jsonb)`](#selectorjsonb) - Extract selector (s) from a raw jsonb encrypted value.
* [`ste_vec(jsonb)`](#ste_vecjsonb) - Extract the sv element array as raw jsonb\[].
* [`ste_vec_contains(jsonb, jsonb)`](#ste_vec_containsjsonb-jsonb) - Check if an sv array contains a specific sv element.
* [`ste_vec_contains(eql_v3_json_search, eql_v3_json_search)`](#ste_vec_containseql_v3_json_search-eql_v3_json_search) - Does encrypted value a contain all sv elements of b?
* [`to_ste_vec_query(query_json)`](#to_ste_vec_queryquery_json) - Normalise an already query-shaped needle to selector-only form.
* [`to_ste_vec_query(eql_v3_json_search)`](#to_ste_vec_queryeql_v3_json_search) - Convert a public.eql\_v3\_json\_search to a query\_json needle.
* [`version()`](#version) - Get the installed EQL version string.
Private Functions [#private-functions]
* [`bloom_filter(jsonb)`](#bloom_filterjsonb) - Extract the Bloom-filter index term from a jsonb payload.
* [`compare_ore_block_256_term(ore_block_256_term, ore_block_256_term)`](#compare_ore_block_256_termore_block_256_term-ore_block_256_term) - Compare two ORE block terms using cryptographic comparison.
* [`compare_ore_block_256_terms(ore_block_256, ore_block_256)`](#compare_ore_block_256_termsore_block_256-ore_block_256) - Compare ORE block composite types.
* [`compare_ore_block_256_terms(ore_block_256_term, ore_block_256_term)`](#compare_ore_block_256_termsore_block_256_term-ore_block_256_term) - Compare arrays of ORE block terms recursively.
* [`compare_ore_block_256_terms(ore_block_256, ore_block_256)`](#compare_ore_block_256_termsore_block_256-ore_block_256-1) - Compare ORE block composite types.
* [`contained_by(jsonb, eql_v3_integer_ord_ore)`](#contained_byjsonb-eql_v3_integer_ord_ore) - Unsupported operator blocker for public.eql\_v3\_integer\_ord\_ore.
* [`contained_by(eql_v3_integer_ord_ore, jsonb)`](#contained_byeql_v3_integer_ord_ore-jsonb) - Unsupported operator blocker for public.eql\_v3\_integer\_ord\_ore.
* [`contained_by(eql_v3_integer_ord_ore, eql_v3_integer_ord_ore)`](#contained_byeql_v3_integer_ord_ore-eql_v3_integer_ord_ore) - Unsupported operator blocker for public.eql\_v3\_integer\_ord\_ore.
* [`contained_by(jsonb, eql_v3_date)`](#contained_byjsonb-eql_v3_date) - Unsupported operator blocker for public.eql\_v3\_date.
* [`contained_by(eql_v3_date, jsonb)`](#contained_byeql_v3_date-jsonb) - Unsupported operator blocker for public.eql\_v3\_date.
* [`contained_by(eql_v3_date, eql_v3_date)`](#contained_byeql_v3_date-eql_v3_date) - Unsupported operator blocker for public.eql\_v3\_date.
* [`contained_by(jsonb, eql_v3_smallint_ord)`](#contained_byjsonb-eql_v3_smallint_ord) - Unsupported operator blocker for public.eql\_v3\_smallint\_ord.
* [`contained_by(eql_v3_smallint_ord, jsonb)`](#contained_byeql_v3_smallint_ord-jsonb) - Unsupported operator blocker for public.eql\_v3\_smallint\_ord.
* [`contained_by(eql_v3_smallint_ord, eql_v3_smallint_ord)`](#contained_byeql_v3_smallint_ord-eql_v3_smallint_ord) - Unsupported operator blocker for public.eql\_v3\_smallint\_ord.
* [`contained_by(jsonb, eql_v3_date_ord)`](#contained_byjsonb-eql_v3_date_ord) - Unsupported operator blocker for public.eql\_v3\_date\_ord.
* [`contained_by(eql_v3_date_ord, jsonb)`](#contained_byeql_v3_date_ord-jsonb) - Unsupported operator blocker for public.eql\_v3\_date\_ord.
* [`contained_by(eql_v3_date_ord, eql_v3_date_ord)`](#contained_byeql_v3_date_ord-eql_v3_date_ord) - Unsupported operator blocker for public.eql\_v3\_date\_ord.
* [`contained_by(jsonb, eql_v3_text_ord)`](#contained_byjsonb-eql_v3_text_ord) - Unsupported operator blocker for public.eql\_v3\_text\_ord.
* [`contained_by(eql_v3_text_ord, jsonb)`](#contained_byeql_v3_text_ord-jsonb) - Unsupported operator blocker for public.eql\_v3\_text\_ord.
* [`contained_by(eql_v3_text_ord, eql_v3_text_ord)`](#contained_byeql_v3_text_ord-eql_v3_text_ord) - Unsupported operator blocker for public.eql\_v3\_text\_ord.
* [`contained_by(jsonb, eql_v3_timestamp_ord_ope)`](#contained_byjsonb-eql_v3_timestamp_ord_ope) - Unsupported operator blocker for public.eql\_v3\_timestamp\_ord\_ope.
* [`contained_by(eql_v3_timestamp_ord_ope, jsonb)`](#contained_byeql_v3_timestamp_ord_ope-jsonb) - Unsupported operator blocker for public.eql\_v3\_timestamp\_ord\_ope.
* [`contained_by(eql_v3_timestamp_ord_ope, eql_v3_timestamp_ord_ope)`](#contained_byeql_v3_timestamp_ord_ope-eql_v3_timestamp_ord_ope) - Unsupported operator blocker for public.eql\_v3\_timestamp\_ord\_ope.
* [`contained_by(jsonb, eql_v3_integer_ord_ope)`](#contained_byjsonb-eql_v3_integer_ord_ope) - Unsupported operator blocker for public.eql\_v3\_integer\_ord\_ope.
* [`contained_by(eql_v3_integer_ord_ope, jsonb)`](#contained_byeql_v3_integer_ord_ope-jsonb) - Unsupported operator blocker for public.eql\_v3\_integer\_ord\_ope.
* [`contained_by(eql_v3_integer_ord_ope, eql_v3_integer_ord_ope)`](#contained_byeql_v3_integer_ord_ope-eql_v3_integer_ord_ope) - Unsupported operator blocker for public.eql\_v3\_integer\_ord\_ope.
* [`contained_by(jsonb, eql_v3_bigint_eq)`](#contained_byjsonb-eql_v3_bigint_eq) - Unsupported operator blocker for public.eql\_v3\_bigint\_eq.
* [`contained_by(eql_v3_bigint_eq, jsonb)`](#contained_byeql_v3_bigint_eq-jsonb) - Unsupported operator blocker for public.eql\_v3\_bigint\_eq.
* [`contained_by(eql_v3_bigint_eq, eql_v3_bigint_eq)`](#contained_byeql_v3_bigint_eq-eql_v3_bigint_eq) - Unsupported operator blocker for public.eql\_v3\_bigint\_eq.
* [`contained_by(jsonb, eql_v3_numeric_ord)`](#contained_byjsonb-eql_v3_numeric_ord) - Unsupported operator blocker for public.eql\_v3\_numeric\_ord.
* [`contained_by(eql_v3_numeric_ord, jsonb)`](#contained_byeql_v3_numeric_ord-jsonb) - Unsupported operator blocker for public.eql\_v3\_numeric\_ord.
* [`contained_by(eql_v3_numeric_ord, eql_v3_numeric_ord)`](#contained_byeql_v3_numeric_ord-eql_v3_numeric_ord) - Unsupported operator blocker for public.eql\_v3\_numeric\_ord.
* [`contained_by(jsonb, eql_v3_bigint)`](#contained_byjsonb-eql_v3_bigint) - Unsupported operator blocker for public.eql\_v3\_bigint.
* [`contained_by(eql_v3_bigint, jsonb)`](#contained_byeql_v3_bigint-jsonb) - Unsupported operator blocker for public.eql\_v3\_bigint.
* [`contained_by(eql_v3_bigint, eql_v3_bigint)`](#contained_byeql_v3_bigint-eql_v3_bigint) - Unsupported operator blocker for public.eql\_v3\_bigint.
* [`contained_by(jsonb, eql_v3_numeric)`](#contained_byjsonb-eql_v3_numeric) - Unsupported operator blocker for public.eql\_v3\_numeric.
* [`contained_by(eql_v3_numeric, jsonb)`](#contained_byeql_v3_numeric-jsonb) - Unsupported operator blocker for public.eql\_v3\_numeric.
* [`contained_by(eql_v3_numeric, eql_v3_numeric)`](#contained_byeql_v3_numeric-eql_v3_numeric) - Unsupported operator blocker for public.eql\_v3\_numeric.
* [`contained_by(jsonb, eql_v3_timestamp_eq)`](#contained_byjsonb-eql_v3_timestamp_eq) - Unsupported operator blocker for public.eql\_v3\_timestamp\_eq.
* [`contained_by(eql_v3_timestamp_eq, jsonb)`](#contained_byeql_v3_timestamp_eq-jsonb) - Unsupported operator blocker for public.eql\_v3\_timestamp\_eq.
* [`contained_by(eql_v3_timestamp_eq, eql_v3_timestamp_eq)`](#contained_byeql_v3_timestamp_eq-eql_v3_timestamp_eq) - Unsupported operator blocker for public.eql\_v3\_timestamp\_eq.
* [`contained_by(jsonb, eql_v3_real_ord_ope)`](#contained_byjsonb-eql_v3_real_ord_ope) - Unsupported operator blocker for public.eql\_v3\_real\_ord\_ope.
* [`contained_by(eql_v3_real_ord_ope, jsonb)`](#contained_byeql_v3_real_ord_ope-jsonb) - Unsupported operator blocker for public.eql\_v3\_real\_ord\_ope.
* [`contained_by(eql_v3_real_ord_ope, eql_v3_real_ord_ope)`](#contained_byeql_v3_real_ord_ope-eql_v3_real_ord_ope) - Unsupported operator blocker for public.eql\_v3\_real\_ord\_ope.
* [`contained_by(jsonb, eql_v3_real_ord)`](#contained_byjsonb-eql_v3_real_ord) - Unsupported operator blocker for public.eql\_v3\_real\_ord.
* [`contained_by(eql_v3_real_ord, jsonb)`](#contained_byeql_v3_real_ord-jsonb) - Unsupported operator blocker for public.eql\_v3\_real\_ord.
* [`contained_by(eql_v3_real_ord, eql_v3_real_ord)`](#contained_byeql_v3_real_ord-eql_v3_real_ord) - Unsupported operator blocker for public.eql\_v3\_real\_ord.
* [`contained_by(jsonb, eql_v3_integer_ord)`](#contained_byjsonb-eql_v3_integer_ord) - Unsupported operator blocker for public.eql\_v3\_integer\_ord.
* [`contained_by(eql_v3_integer_ord, jsonb)`](#contained_byeql_v3_integer_ord-jsonb) - Unsupported operator blocker for public.eql\_v3\_integer\_ord.
* [`contained_by(eql_v3_integer_ord, eql_v3_integer_ord)`](#contained_byeql_v3_integer_ord-eql_v3_integer_ord) - Unsupported operator blocker for public.eql\_v3\_integer\_ord.
* [`contained_by(jsonb, eql_v3_json)`](#contained_byjsonb-eql_v3_json) - Unsupported operator blocker for public.eql\_v3\_json.
* [`contained_by(eql_v3_json, jsonb)`](#contained_byeql_v3_json-jsonb) - Unsupported operator blocker for public.eql\_v3\_json.
* [`contained_by(eql_v3_json, eql_v3_json)`](#contained_byeql_v3_json-eql_v3_json) - Unsupported operator blocker for public.eql\_v3\_json.
* [`contained_by(jsonb, eql_v3_text_ord_ope)`](#contained_byjsonb-eql_v3_text_ord_ope) - Unsupported operator blocker for public.eql\_v3\_text\_ord\_ope.
* [`contained_by(eql_v3_text_ord_ope, jsonb)`](#contained_byeql_v3_text_ord_ope-jsonb) - Unsupported operator blocker for public.eql\_v3\_text\_ord\_ope.
* [`contained_by(eql_v3_text_ord_ope, eql_v3_text_ord_ope)`](#contained_byeql_v3_text_ord_ope-eql_v3_text_ord_ope) - Unsupported operator blocker for public.eql\_v3\_text\_ord\_ope.
* [`contained_by(jsonb, eql_v3_boolean)`](#contained_byjsonb-eql_v3_boolean) - Unsupported operator blocker for public.eql\_v3\_boolean.
* [`contained_by(eql_v3_boolean, jsonb)`](#contained_byeql_v3_boolean-jsonb) - Unsupported operator blocker for public.eql\_v3\_boolean.
* [`contained_by(eql_v3_boolean, eql_v3_boolean)`](#contained_byeql_v3_boolean-eql_v3_boolean) - Unsupported operator blocker for public.eql\_v3\_boolean.
* [`contained_by(jsonb, eql_v3_real)`](#contained_byjsonb-eql_v3_real) - Unsupported operator blocker for public.eql\_v3\_real.
* [`contained_by(eql_v3_real, jsonb)`](#contained_byeql_v3_real-jsonb) - Unsupported operator blocker for public.eql\_v3\_real.
* [`contained_by(eql_v3_real, eql_v3_real)`](#contained_byeql_v3_real-eql_v3_real) - Unsupported operator blocker for public.eql\_v3\_real.
* [`contained_by(jsonb, eql_v3_real_eq)`](#contained_byjsonb-eql_v3_real_eq) - Unsupported operator blocker for public.eql\_v3\_real\_eq.
* [`contained_by(eql_v3_real_eq, jsonb)`](#contained_byeql_v3_real_eq-jsonb) - Unsupported operator blocker for public.eql\_v3\_real\_eq.
* [`contained_by(eql_v3_real_eq, eql_v3_real_eq)`](#contained_byeql_v3_real_eq-eql_v3_real_eq) - Unsupported operator blocker for public.eql\_v3\_real\_eq.
* [`contained_by(jsonb, eql_v3_text)`](#contained_byjsonb-eql_v3_text) - Unsupported operator blocker for public.eql\_v3\_text.
* [`contained_by(eql_v3_text, jsonb)`](#contained_byeql_v3_text-jsonb) - Unsupported operator blocker for public.eql\_v3\_text.
* [`contained_by(eql_v3_text, eql_v3_text)`](#contained_byeql_v3_text-eql_v3_text) - Unsupported operator blocker for public.eql\_v3\_text.
* [`contained_by(jsonb, eql_v3_bigint_ord_ore)`](#contained_byjsonb-eql_v3_bigint_ord_ore) - Unsupported operator blocker for public.eql\_v3\_bigint\_ord\_ore.
* [`contained_by(eql_v3_bigint_ord_ore, jsonb)`](#contained_byeql_v3_bigint_ord_ore-jsonb) - Unsupported operator blocker for public.eql\_v3\_bigint\_ord\_ore.
* [`contained_by(eql_v3_bigint_ord_ore, eql_v3_bigint_ord_ore)`](#contained_byeql_v3_bigint_ord_ore-eql_v3_bigint_ord_ore) - Unsupported operator blocker for public.eql\_v3\_bigint\_ord\_ore.
* [`contained_by(jsonb, eql_v3_double_eq)`](#contained_byjsonb-eql_v3_double_eq) - Unsupported operator blocker for public.eql\_v3\_double\_eq.
* [`contained_by(eql_v3_double_eq, jsonb)`](#contained_byeql_v3_double_eq-jsonb) - Unsupported operator blocker for public.eql\_v3\_double\_eq.
* [`contained_by(eql_v3_double_eq, eql_v3_double_eq)`](#contained_byeql_v3_double_eq-eql_v3_double_eq) - Unsupported operator blocker for public.eql\_v3\_double\_eq.
* [`contained_by(jsonb, eql_v3_real_ord_ore)`](#contained_byjsonb-eql_v3_real_ord_ore) - Unsupported operator blocker for public.eql\_v3\_real\_ord\_ore.
* [`contained_by(eql_v3_real_ord_ore, jsonb)`](#contained_byeql_v3_real_ord_ore-jsonb) - Unsupported operator blocker for public.eql\_v3\_real\_ord\_ore.
* [`contained_by(eql_v3_real_ord_ore, eql_v3_real_ord_ore)`](#contained_byeql_v3_real_ord_ore-eql_v3_real_ord_ore) - Unsupported operator blocker for public.eql\_v3\_real\_ord\_ore.
* [`contained_by(jsonb, eql_v3_numeric_ord_ore)`](#contained_byjsonb-eql_v3_numeric_ord_ore) - Unsupported operator blocker for public.eql\_v3\_numeric\_ord\_ore.
* [`contained_by(eql_v3_numeric_ord_ore, jsonb)`](#contained_byeql_v3_numeric_ord_ore-jsonb) - Unsupported operator blocker for public.eql\_v3\_numeric\_ord\_ore.
* [`contained_by(eql_v3_numeric_ord_ore, eql_v3_numeric_ord_ore)`](#contained_byeql_v3_numeric_ord_ore-eql_v3_numeric_ord_ore) - Unsupported operator blocker for public.eql\_v3\_numeric\_ord\_ore.
* [`contained_by(jsonb, eql_v3_bigint_ord_ope)`](#contained_byjsonb-eql_v3_bigint_ord_ope) - Unsupported operator blocker for public.eql\_v3\_bigint\_ord\_ope.
* [`contained_by(eql_v3_bigint_ord_ope, jsonb)`](#contained_byeql_v3_bigint_ord_ope-jsonb) - Unsupported operator blocker for public.eql\_v3\_bigint\_ord\_ope.
* [`contained_by(eql_v3_bigint_ord_ope, eql_v3_bigint_ord_ope)`](#contained_byeql_v3_bigint_ord_ope-eql_v3_bigint_ord_ope) - Unsupported operator blocker for public.eql\_v3\_bigint\_ord\_ope.
* [`contained_by(jsonb, eql_v3_timestamp)`](#contained_byjsonb-eql_v3_timestamp) - Unsupported operator blocker for public.eql\_v3\_timestamp.
* [`contained_by(eql_v3_timestamp, jsonb)`](#contained_byeql_v3_timestamp-jsonb) - Unsupported operator blocker for public.eql\_v3\_timestamp.
* [`contained_by(eql_v3_timestamp, eql_v3_timestamp)`](#contained_byeql_v3_timestamp-eql_v3_timestamp) - Unsupported operator blocker for public.eql\_v3\_timestamp.
* [`contained_by(jsonb, eql_v3_double_ord_ore)`](#contained_byjsonb-eql_v3_double_ord_ore) - Unsupported operator blocker for public.eql\_v3\_double\_ord\_ore.
* [`contained_by(eql_v3_double_ord_ore, jsonb)`](#contained_byeql_v3_double_ord_ore-jsonb) - Unsupported operator blocker for public.eql\_v3\_double\_ord\_ore.
* [`contained_by(eql_v3_double_ord_ore, eql_v3_double_ord_ore)`](#contained_byeql_v3_double_ord_ore-eql_v3_double_ord_ore) - Unsupported operator blocker for public.eql\_v3\_double\_ord\_ore.
* [`contained_by(jsonb, eql_v3_bigint_ord)`](#contained_byjsonb-eql_v3_bigint_ord) - Unsupported operator blocker for public.eql\_v3\_bigint\_ord.
* [`contained_by(eql_v3_bigint_ord, jsonb)`](#contained_byeql_v3_bigint_ord-jsonb) - Unsupported operator blocker for public.eql\_v3\_bigint\_ord.
* [`contained_by(eql_v3_bigint_ord, eql_v3_bigint_ord)`](#contained_byeql_v3_bigint_ord-eql_v3_bigint_ord) - Unsupported operator blocker for public.eql\_v3\_bigint\_ord.
* [`contained_by(jsonb, eql_v3_text_search_ore)`](#contained_byjsonb-eql_v3_text_search_ore) - Unsupported operator blocker for public.eql\_v3\_text\_search\_ore.
* [`contained_by(eql_v3_text_search_ore, jsonb)`](#contained_byeql_v3_text_search_ore-jsonb) - Unsupported operator blocker for public.eql\_v3\_text\_search\_ore.
* [`contained_by(eql_v3_text_search_ore, eql_v3_text_search_ore)`](#contained_byeql_v3_text_search_ore-eql_v3_text_search_ore) - Unsupported operator blocker for public.eql\_v3\_text\_search\_ore.
* [`contained_by(jsonb, eql_v3_numeric_eq)`](#contained_byjsonb-eql_v3_numeric_eq) - Unsupported operator blocker for public.eql\_v3\_numeric\_eq.
* [`contained_by(eql_v3_numeric_eq, jsonb)`](#contained_byeql_v3_numeric_eq-jsonb) - Unsupported operator blocker for public.eql\_v3\_numeric\_eq.
* [`contained_by(eql_v3_numeric_eq, eql_v3_numeric_eq)`](#contained_byeql_v3_numeric_eq-eql_v3_numeric_eq) - Unsupported operator blocker for public.eql\_v3\_numeric\_eq.
* [`contained_by(jsonb, eql_v3_timestamp_ord)`](#contained_byjsonb-eql_v3_timestamp_ord) - Unsupported operator blocker for public.eql\_v3\_timestamp\_ord.
* [`contained_by(eql_v3_timestamp_ord, jsonb)`](#contained_byeql_v3_timestamp_ord-jsonb) - Unsupported operator blocker for public.eql\_v3\_timestamp\_ord.
* [`contained_by(eql_v3_timestamp_ord, eql_v3_timestamp_ord)`](#contained_byeql_v3_timestamp_ord-eql_v3_timestamp_ord) - Unsupported operator blocker for public.eql\_v3\_timestamp\_ord.
* [`contained_by(jsonb, eql_v3_text_match)`](#contained_byjsonb-eql_v3_text_match) - Unsupported operator blocker for public.eql\_v3\_text\_match.
* [`contained_by(eql_v3_text_match, jsonb)`](#contained_byeql_v3_text_match-jsonb) - Unsupported operator blocker for public.eql\_v3\_text\_match.
* [`contained_by(eql_v3_text_match, eql_v3_text_match)`](#contained_byeql_v3_text_match-eql_v3_text_match) - Unsupported operator blocker for public.eql\_v3\_text\_match.
* [`contained_by(jsonb, eql_v3_smallint_ord_ope)`](#contained_byjsonb-eql_v3_smallint_ord_ope) - Unsupported operator blocker for public.eql\_v3\_smallint\_ord\_ope.
* [`contained_by(eql_v3_smallint_ord_ope, jsonb)`](#contained_byeql_v3_smallint_ord_ope-jsonb) - Unsupported operator blocker for public.eql\_v3\_smallint\_ord\_ope.
* [`contained_by(eql_v3_smallint_ord_ope, eql_v3_smallint_ord_ope)`](#contained_byeql_v3_smallint_ord_ope-eql_v3_smallint_ord_ope) - Unsupported operator blocker for public.eql\_v3\_smallint\_ord\_ope.
* [`contained_by(jsonb, eql_v3_integer)`](#contained_byjsonb-eql_v3_integer) - Unsupported operator blocker for public.eql\_v3\_integer.
* [`contained_by(eql_v3_integer, jsonb)`](#contained_byeql_v3_integer-jsonb) - Unsupported operator blocker for public.eql\_v3\_integer.
* [`contained_by(eql_v3_integer, eql_v3_integer)`](#contained_byeql_v3_integer-eql_v3_integer) - Unsupported operator blocker for public.eql\_v3\_integer.
* [`contained_by(jsonb, eql_v3_double)`](#contained_byjsonb-eql_v3_double) - Unsupported operator blocker for public.eql\_v3\_double.
* [`contained_by(eql_v3_double, jsonb)`](#contained_byeql_v3_double-jsonb) - Unsupported operator blocker for public.eql\_v3\_double.
* [`contained_by(eql_v3_double, eql_v3_double)`](#contained_byeql_v3_double-eql_v3_double) - Unsupported operator blocker for public.eql\_v3\_double.
* [`contained_by(jsonb, eql_v3_timestamp_ord_ore)`](#contained_byjsonb-eql_v3_timestamp_ord_ore) - Unsupported operator blocker for public.eql\_v3\_timestamp\_ord\_ore.
* [`contained_by(eql_v3_timestamp_ord_ore, jsonb)`](#contained_byeql_v3_timestamp_ord_ore-jsonb) - Unsupported operator blocker for public.eql\_v3\_timestamp\_ord\_ore.
* [`contained_by(eql_v3_timestamp_ord_ore, eql_v3_timestamp_ord_ore)`](#contained_byeql_v3_timestamp_ord_ore-eql_v3_timestamp_ord_ore) - Unsupported operator blocker for public.eql\_v3\_timestamp\_ord\_ore.
* [`contained_by(jsonb, eql_v3_text_search)`](#contained_byjsonb-eql_v3_text_search) - Unsupported operator blocker for public.eql\_v3\_text\_search.
* [`contained_by(eql_v3_text_search, jsonb)`](#contained_byeql_v3_text_search-jsonb) - Unsupported operator blocker for public.eql\_v3\_text\_search.
* [`contained_by(eql_v3_text_search, eql_v3_text_search)`](#contained_byeql_v3_text_search-eql_v3_text_search) - Unsupported operator blocker for public.eql\_v3\_text\_search.
* [`contained_by(jsonb, eql_v3_smallint_eq)`](#contained_byjsonb-eql_v3_smallint_eq) - Unsupported operator blocker for public.eql\_v3\_smallint\_eq.
* [`contained_by(eql_v3_smallint_eq, jsonb)`](#contained_byeql_v3_smallint_eq-jsonb) - Unsupported operator blocker for public.eql\_v3\_smallint\_eq.
* [`contained_by(eql_v3_smallint_eq, eql_v3_smallint_eq)`](#contained_byeql_v3_smallint_eq-eql_v3_smallint_eq) - Unsupported operator blocker for public.eql\_v3\_smallint\_eq.
* [`contained_by(jsonb, eql_v3_double_ord)`](#contained_byjsonb-eql_v3_double_ord) - Unsupported operator blocker for public.eql\_v3\_double\_ord.
* [`contained_by(eql_v3_double_ord, jsonb)`](#contained_byeql_v3_double_ord-jsonb) - Unsupported operator blocker for public.eql\_v3\_double\_ord.
* [`contained_by(eql_v3_double_ord, eql_v3_double_ord)`](#contained_byeql_v3_double_ord-eql_v3_double_ord) - Unsupported operator blocker for public.eql\_v3\_double\_ord.
* [`contained_by(jsonb, eql_v3_date_eq)`](#contained_byjsonb-eql_v3_date_eq) - Unsupported operator blocker for public.eql\_v3\_date\_eq.
* [`contained_by(eql_v3_date_eq, jsonb)`](#contained_byeql_v3_date_eq-jsonb) - Unsupported operator blocker for public.eql\_v3\_date\_eq.
* [`contained_by(eql_v3_date_eq, eql_v3_date_eq)`](#contained_byeql_v3_date_eq-eql_v3_date_eq) - Unsupported operator blocker for public.eql\_v3\_date\_eq.
* [`contained_by(jsonb, eql_v3_double_ord_ope)`](#contained_byjsonb-eql_v3_double_ord_ope) - Unsupported operator blocker for public.eql\_v3\_double\_ord\_ope.
* [`contained_by(eql_v3_double_ord_ope, jsonb)`](#contained_byeql_v3_double_ord_ope-jsonb) - Unsupported operator blocker for public.eql\_v3\_double\_ord\_ope.
* [`contained_by(eql_v3_double_ord_ope, eql_v3_double_ord_ope)`](#contained_byeql_v3_double_ord_ope-eql_v3_double_ord_ope) - Unsupported operator blocker for public.eql\_v3\_double\_ord\_ope.
* [`contained_by(jsonb, eql_v3_numeric_ord_ope)`](#contained_byjsonb-eql_v3_numeric_ord_ope) - Unsupported operator blocker for public.eql\_v3\_numeric\_ord\_ope.
* [`contained_by(eql_v3_numeric_ord_ope, jsonb)`](#contained_byeql_v3_numeric_ord_ope-jsonb) - Unsupported operator blocker for public.eql\_v3\_numeric\_ord\_ope.
* [`contained_by(eql_v3_numeric_ord_ope, eql_v3_numeric_ord_ope)`](#contained_byeql_v3_numeric_ord_ope-eql_v3_numeric_ord_ope) - Unsupported operator blocker for public.eql\_v3\_numeric\_ord\_ope.
* [`contained_by(jsonb, eql_v3_date_ord_ore)`](#contained_byjsonb-eql_v3_date_ord_ore) - Unsupported operator blocker for public.eql\_v3\_date\_ord\_ore.
* [`contained_by(eql_v3_date_ord_ore, jsonb)`](#contained_byeql_v3_date_ord_ore-jsonb) - Unsupported operator blocker for public.eql\_v3\_date\_ord\_ore.
* [`contained_by(eql_v3_date_ord_ore, eql_v3_date_ord_ore)`](#contained_byeql_v3_date_ord_ore-eql_v3_date_ord_ore) - Unsupported operator blocker for public.eql\_v3\_date\_ord\_ore.
* [`contained_by(jsonb, eql_v3_text_eq)`](#contained_byjsonb-eql_v3_text_eq) - Unsupported operator blocker for public.eql\_v3\_text\_eq.
* [`contained_by(eql_v3_text_eq, jsonb)`](#contained_byeql_v3_text_eq-jsonb) - Unsupported operator blocker for public.eql\_v3\_text\_eq.
* [`contained_by(eql_v3_text_eq, eql_v3_text_eq)`](#contained_byeql_v3_text_eq-eql_v3_text_eq) - Unsupported operator blocker for public.eql\_v3\_text\_eq.
* [`contained_by(jsonb, eql_v3_integer_eq)`](#contained_byjsonb-eql_v3_integer_eq) - Unsupported operator blocker for public.eql\_v3\_integer\_eq.
* [`contained_by(eql_v3_integer_eq, jsonb)`](#contained_byeql_v3_integer_eq-jsonb) - Unsupported operator blocker for public.eql\_v3\_integer\_eq.
* [`contained_by(eql_v3_integer_eq, eql_v3_integer_eq)`](#contained_byeql_v3_integer_eq-eql_v3_integer_eq) - Unsupported operator blocker for public.eql\_v3\_integer\_eq.
* [`contained_by(jsonb, eql_v3_smallint_ord_ore)`](#contained_byjsonb-eql_v3_smallint_ord_ore) - Unsupported operator blocker for public.eql\_v3\_smallint\_ord\_ore.
* [`contained_by(eql_v3_smallint_ord_ore, jsonb)`](#contained_byeql_v3_smallint_ord_ore-jsonb) - Unsupported operator blocker for public.eql\_v3\_smallint\_ord\_ore.
* [`contained_by(eql_v3_smallint_ord_ore, eql_v3_smallint_ord_ore)`](#contained_byeql_v3_smallint_ord_ore-eql_v3_smallint_ord_ore) - Unsupported operator blocker for public.eql\_v3\_smallint\_ord\_ore.
* [`contained_by(jsonb, eql_v3_date_ord_ope)`](#contained_byjsonb-eql_v3_date_ord_ope) - Unsupported operator blocker for public.eql\_v3\_date\_ord\_ope.
* [`contained_by(eql_v3_date_ord_ope, jsonb)`](#contained_byeql_v3_date_ord_ope-jsonb) - Unsupported operator blocker for public.eql\_v3\_date\_ord\_ope.
* [`contained_by(eql_v3_date_ord_ope, eql_v3_date_ord_ope)`](#contained_byeql_v3_date_ord_ope-eql_v3_date_ord_ope) - Unsupported operator blocker for public.eql\_v3\_date\_ord\_ope.
* [`contained_by(jsonb, eql_v3_text_ord_ore)`](#contained_byjsonb-eql_v3_text_ord_ore) - Unsupported operator blocker for public.eql\_v3\_text\_ord\_ore.
* [`contained_by(eql_v3_text_ord_ore, jsonb)`](#contained_byeql_v3_text_ord_ore-jsonb) - Unsupported operator blocker for public.eql\_v3\_text\_ord\_ore.
* [`contained_by(eql_v3_text_ord_ore, eql_v3_text_ord_ore)`](#contained_byeql_v3_text_ord_ore-eql_v3_text_ord_ore) - Unsupported operator blocker for public.eql\_v3\_text\_ord\_ore.
* [`contained_by(jsonb, eql_v3_smallint)`](#contained_byjsonb-eql_v3_smallint) - Unsupported operator blocker for public.eql\_v3\_smallint.
* [`contained_by(eql_v3_smallint, jsonb)`](#contained_byeql_v3_smallint-jsonb) - Unsupported operator blocker for public.eql\_v3\_smallint.
* [`contained_by(eql_v3_smallint, eql_v3_smallint)`](#contained_byeql_v3_smallint-eql_v3_smallint) - Unsupported operator blocker for public.eql\_v3\_smallint.
* [`contains(jsonb, eql_v3_integer_ord_ore)`](#containsjsonb-eql_v3_integer_ord_ore) - Unsupported operator blocker for public.eql\_v3\_integer\_ord\_ore.
* [`contains(eql_v3_integer_ord_ore, jsonb)`](#containseql_v3_integer_ord_ore-jsonb) - Unsupported operator blocker for public.eql\_v3\_integer\_ord\_ore.
* [`contains(eql_v3_integer_ord_ore, eql_v3_integer_ord_ore)`](#containseql_v3_integer_ord_ore-eql_v3_integer_ord_ore) - Unsupported operator blocker for public.eql\_v3\_integer\_ord\_ore.
* [`contains(jsonb, eql_v3_date)`](#containsjsonb-eql_v3_date) - Unsupported operator blocker for public.eql\_v3\_date.
* [`contains(eql_v3_date, jsonb)`](#containseql_v3_date-jsonb) - Unsupported operator blocker for public.eql\_v3\_date.
* [`contains(eql_v3_date, eql_v3_date)`](#containseql_v3_date-eql_v3_date) - Unsupported operator blocker for public.eql\_v3\_date.
* [`contains(jsonb, eql_v3_smallint_ord)`](#containsjsonb-eql_v3_smallint_ord) - Unsupported operator blocker for public.eql\_v3\_smallint\_ord.
* [`contains(eql_v3_smallint_ord, jsonb)`](#containseql_v3_smallint_ord-jsonb) - Unsupported operator blocker for public.eql\_v3\_smallint\_ord.
* [`contains(eql_v3_smallint_ord, eql_v3_smallint_ord)`](#containseql_v3_smallint_ord-eql_v3_smallint_ord) - Unsupported operator blocker for public.eql\_v3\_smallint\_ord.
* [`contains(jsonb, eql_v3_date_ord)`](#containsjsonb-eql_v3_date_ord) - Unsupported operator blocker for public.eql\_v3\_date\_ord.
* [`contains(eql_v3_date_ord, jsonb)`](#containseql_v3_date_ord-jsonb) - Unsupported operator blocker for public.eql\_v3\_date\_ord.
* [`contains(eql_v3_date_ord, eql_v3_date_ord)`](#containseql_v3_date_ord-eql_v3_date_ord) - Unsupported operator blocker for public.eql\_v3\_date\_ord.
* [`contains(jsonb, eql_v3_text_ord)`](#containsjsonb-eql_v3_text_ord) - Unsupported operator blocker for public.eql\_v3\_text\_ord.
* [`contains(eql_v3_text_ord, jsonb)`](#containseql_v3_text_ord-jsonb) - Unsupported operator blocker for public.eql\_v3\_text\_ord.
* [`contains(eql_v3_text_ord, eql_v3_text_ord)`](#containseql_v3_text_ord-eql_v3_text_ord) - Unsupported operator blocker for public.eql\_v3\_text\_ord.
* [`contains(jsonb, eql_v3_timestamp_ord_ope)`](#containsjsonb-eql_v3_timestamp_ord_ope) - Unsupported operator blocker for public.eql\_v3\_timestamp\_ord\_ope.
* [`contains(eql_v3_timestamp_ord_ope, jsonb)`](#containseql_v3_timestamp_ord_ope-jsonb) - Unsupported operator blocker for public.eql\_v3\_timestamp\_ord\_ope.
* [`contains(eql_v3_timestamp_ord_ope, eql_v3_timestamp_ord_ope)`](#containseql_v3_timestamp_ord_ope-eql_v3_timestamp_ord_ope) - Unsupported operator blocker for public.eql\_v3\_timestamp\_ord\_ope.
* [`contains(jsonb, eql_v3_integer_ord_ope)`](#containsjsonb-eql_v3_integer_ord_ope) - Unsupported operator blocker for public.eql\_v3\_integer\_ord\_ope.
* [`contains(eql_v3_integer_ord_ope, jsonb)`](#containseql_v3_integer_ord_ope-jsonb) - Unsupported operator blocker for public.eql\_v3\_integer\_ord\_ope.
* [`contains(eql_v3_integer_ord_ope, eql_v3_integer_ord_ope)`](#containseql_v3_integer_ord_ope-eql_v3_integer_ord_ope) - Unsupported operator blocker for public.eql\_v3\_integer\_ord\_ope.
* [`contains(jsonb, eql_v3_bigint_eq)`](#containsjsonb-eql_v3_bigint_eq) - Unsupported operator blocker for public.eql\_v3\_bigint\_eq.
* [`contains(eql_v3_bigint_eq, jsonb)`](#containseql_v3_bigint_eq-jsonb) - Unsupported operator blocker for public.eql\_v3\_bigint\_eq.
* [`contains(eql_v3_bigint_eq, eql_v3_bigint_eq)`](#containseql_v3_bigint_eq-eql_v3_bigint_eq) - Unsupported operator blocker for public.eql\_v3\_bigint\_eq.
* [`contains(jsonb, eql_v3_numeric_ord)`](#containsjsonb-eql_v3_numeric_ord) - Unsupported operator blocker for public.eql\_v3\_numeric\_ord.
* [`contains(eql_v3_numeric_ord, jsonb)`](#containseql_v3_numeric_ord-jsonb) - Unsupported operator blocker for public.eql\_v3\_numeric\_ord.
* [`contains(eql_v3_numeric_ord, eql_v3_numeric_ord)`](#containseql_v3_numeric_ord-eql_v3_numeric_ord) - Unsupported operator blocker for public.eql\_v3\_numeric\_ord.
* [`contains(jsonb, eql_v3_bigint)`](#containsjsonb-eql_v3_bigint) - Unsupported operator blocker for public.eql\_v3\_bigint.
* [`contains(eql_v3_bigint, jsonb)`](#containseql_v3_bigint-jsonb) - Unsupported operator blocker for public.eql\_v3\_bigint.
* [`contains(eql_v3_bigint, eql_v3_bigint)`](#containseql_v3_bigint-eql_v3_bigint) - Unsupported operator blocker for public.eql\_v3\_bigint.
* [`contains(jsonb, eql_v3_numeric)`](#containsjsonb-eql_v3_numeric) - Unsupported operator blocker for public.eql\_v3\_numeric.
* [`contains(eql_v3_numeric, jsonb)`](#containseql_v3_numeric-jsonb) - Unsupported operator blocker for public.eql\_v3\_numeric.
* [`contains(eql_v3_numeric, eql_v3_numeric)`](#containseql_v3_numeric-eql_v3_numeric) - Unsupported operator blocker for public.eql\_v3\_numeric.
* [`contains(jsonb, eql_v3_timestamp_eq)`](#containsjsonb-eql_v3_timestamp_eq) - Unsupported operator blocker for public.eql\_v3\_timestamp\_eq.
* [`contains(eql_v3_timestamp_eq, jsonb)`](#containseql_v3_timestamp_eq-jsonb) - Unsupported operator blocker for public.eql\_v3\_timestamp\_eq.
* [`contains(eql_v3_timestamp_eq, eql_v3_timestamp_eq)`](#containseql_v3_timestamp_eq-eql_v3_timestamp_eq) - Unsupported operator blocker for public.eql\_v3\_timestamp\_eq.
* [`contains(jsonb, eql_v3_real_ord_ope)`](#containsjsonb-eql_v3_real_ord_ope) - Unsupported operator blocker for public.eql\_v3\_real\_ord\_ope.
* [`contains(eql_v3_real_ord_ope, jsonb)`](#containseql_v3_real_ord_ope-jsonb) - Unsupported operator blocker for public.eql\_v3\_real\_ord\_ope.
* [`contains(eql_v3_real_ord_ope, eql_v3_real_ord_ope)`](#containseql_v3_real_ord_ope-eql_v3_real_ord_ope) - Unsupported operator blocker for public.eql\_v3\_real\_ord\_ope.
* [`contains(jsonb, eql_v3_real_ord)`](#containsjsonb-eql_v3_real_ord) - Unsupported operator blocker for public.eql\_v3\_real\_ord.
* [`contains(eql_v3_real_ord, jsonb)`](#containseql_v3_real_ord-jsonb) - Unsupported operator blocker for public.eql\_v3\_real\_ord.
* [`contains(eql_v3_real_ord, eql_v3_real_ord)`](#containseql_v3_real_ord-eql_v3_real_ord) - Unsupported operator blocker for public.eql\_v3\_real\_ord.
* [`contains(jsonb, eql_v3_integer_ord)`](#containsjsonb-eql_v3_integer_ord) - Unsupported operator blocker for public.eql\_v3\_integer\_ord.
* [`contains(eql_v3_integer_ord, jsonb)`](#containseql_v3_integer_ord-jsonb) - Unsupported operator blocker for public.eql\_v3\_integer\_ord.
* [`contains(eql_v3_integer_ord, eql_v3_integer_ord)`](#containseql_v3_integer_ord-eql_v3_integer_ord) - Unsupported operator blocker for public.eql\_v3\_integer\_ord.
* [`contains(jsonb, eql_v3_json)`](#containsjsonb-eql_v3_json) - Unsupported operator blocker for public.eql\_v3\_json.
* [`contains(eql_v3_json, jsonb)`](#containseql_v3_json-jsonb) - Unsupported operator blocker for public.eql\_v3\_json.
* [`contains(eql_v3_json, eql_v3_json)`](#containseql_v3_json-eql_v3_json) - Unsupported operator blocker for public.eql\_v3\_json.
* [`contains(jsonb, eql_v3_text_ord_ope)`](#containsjsonb-eql_v3_text_ord_ope) - Unsupported operator blocker for public.eql\_v3\_text\_ord\_ope.
* [`contains(eql_v3_text_ord_ope, jsonb)`](#containseql_v3_text_ord_ope-jsonb) - Unsupported operator blocker for public.eql\_v3\_text\_ord\_ope.
* [`contains(eql_v3_text_ord_ope, eql_v3_text_ord_ope)`](#containseql_v3_text_ord_ope-eql_v3_text_ord_ope) - Unsupported operator blocker for public.eql\_v3\_text\_ord\_ope.
* [`contains(jsonb, eql_v3_boolean)`](#containsjsonb-eql_v3_boolean) - Unsupported operator blocker for public.eql\_v3\_boolean.
* [`contains(eql_v3_boolean, jsonb)`](#containseql_v3_boolean-jsonb) - Unsupported operator blocker for public.eql\_v3\_boolean.
* [`contains(eql_v3_boolean, eql_v3_boolean)`](#containseql_v3_boolean-eql_v3_boolean) - Unsupported operator blocker for public.eql\_v3\_boolean.
* [`contains(jsonb, eql_v3_real)`](#containsjsonb-eql_v3_real) - Unsupported operator blocker for public.eql\_v3\_real.
* [`contains(eql_v3_real, jsonb)`](#containseql_v3_real-jsonb) - Unsupported operator blocker for public.eql\_v3\_real.
* [`contains(eql_v3_real, eql_v3_real)`](#containseql_v3_real-eql_v3_real) - Unsupported operator blocker for public.eql\_v3\_real.
* [`contains(jsonb, eql_v3_real_eq)`](#containsjsonb-eql_v3_real_eq) - Unsupported operator blocker for public.eql\_v3\_real\_eq.
* [`contains(eql_v3_real_eq, jsonb)`](#containseql_v3_real_eq-jsonb) - Unsupported operator blocker for public.eql\_v3\_real\_eq.
* [`contains(eql_v3_real_eq, eql_v3_real_eq)`](#containseql_v3_real_eq-eql_v3_real_eq) - Unsupported operator blocker for public.eql\_v3\_real\_eq.
* [`contains(jsonb, eql_v3_text)`](#containsjsonb-eql_v3_text) - Unsupported operator blocker for public.eql\_v3\_text.
* [`contains(eql_v3_text, jsonb)`](#containseql_v3_text-jsonb) - Unsupported operator blocker for public.eql\_v3\_text.
* [`contains(eql_v3_text, eql_v3_text)`](#containseql_v3_text-eql_v3_text) - Unsupported operator blocker for public.eql\_v3\_text.
* [`contains(jsonb, eql_v3_bigint_ord_ore)`](#containsjsonb-eql_v3_bigint_ord_ore) - Unsupported operator blocker for public.eql\_v3\_bigint\_ord\_ore.
* [`contains(eql_v3_bigint_ord_ore, jsonb)`](#containseql_v3_bigint_ord_ore-jsonb) - Unsupported operator blocker for public.eql\_v3\_bigint\_ord\_ore.
* [`contains(eql_v3_bigint_ord_ore, eql_v3_bigint_ord_ore)`](#containseql_v3_bigint_ord_ore-eql_v3_bigint_ord_ore) - Unsupported operator blocker for public.eql\_v3\_bigint\_ord\_ore.
* [`contains(jsonb, eql_v3_double_eq)`](#containsjsonb-eql_v3_double_eq) - Unsupported operator blocker for public.eql\_v3\_double\_eq.
* [`contains(eql_v3_double_eq, jsonb)`](#containseql_v3_double_eq-jsonb) - Unsupported operator blocker for public.eql\_v3\_double\_eq.
* [`contains(eql_v3_double_eq, eql_v3_double_eq)`](#containseql_v3_double_eq-eql_v3_double_eq) - Unsupported operator blocker for public.eql\_v3\_double\_eq.
* [`contains(jsonb, eql_v3_real_ord_ore)`](#containsjsonb-eql_v3_real_ord_ore) - Unsupported operator blocker for public.eql\_v3\_real\_ord\_ore.
* [`contains(eql_v3_real_ord_ore, jsonb)`](#containseql_v3_real_ord_ore-jsonb) - Unsupported operator blocker for public.eql\_v3\_real\_ord\_ore.
* [`contains(eql_v3_real_ord_ore, eql_v3_real_ord_ore)`](#containseql_v3_real_ord_ore-eql_v3_real_ord_ore) - Unsupported operator blocker for public.eql\_v3\_real\_ord\_ore.
* [`contains(jsonb, eql_v3_numeric_ord_ore)`](#containsjsonb-eql_v3_numeric_ord_ore) - Unsupported operator blocker for public.eql\_v3\_numeric\_ord\_ore.
* [`contains(eql_v3_numeric_ord_ore, jsonb)`](#containseql_v3_numeric_ord_ore-jsonb) - Unsupported operator blocker for public.eql\_v3\_numeric\_ord\_ore.
* [`contains(eql_v3_numeric_ord_ore, eql_v3_numeric_ord_ore)`](#containseql_v3_numeric_ord_ore-eql_v3_numeric_ord_ore) - Unsupported operator blocker for public.eql\_v3\_numeric\_ord\_ore.
* [`contains(jsonb, eql_v3_bigint_ord_ope)`](#containsjsonb-eql_v3_bigint_ord_ope) - Unsupported operator blocker for public.eql\_v3\_bigint\_ord\_ope.
* [`contains(eql_v3_bigint_ord_ope, jsonb)`](#containseql_v3_bigint_ord_ope-jsonb) - Unsupported operator blocker for public.eql\_v3\_bigint\_ord\_ope.
* [`contains(eql_v3_bigint_ord_ope, eql_v3_bigint_ord_ope)`](#containseql_v3_bigint_ord_ope-eql_v3_bigint_ord_ope) - Unsupported operator blocker for public.eql\_v3\_bigint\_ord\_ope.
* [`contains(jsonb, eql_v3_timestamp)`](#containsjsonb-eql_v3_timestamp) - Unsupported operator blocker for public.eql\_v3\_timestamp.
* [`contains(eql_v3_timestamp, jsonb)`](#containseql_v3_timestamp-jsonb) - Unsupported operator blocker for public.eql\_v3\_timestamp.
* [`contains(eql_v3_timestamp, eql_v3_timestamp)`](#containseql_v3_timestamp-eql_v3_timestamp) - Unsupported operator blocker for public.eql\_v3\_timestamp.
* [`contains(jsonb, eql_v3_double_ord_ore)`](#containsjsonb-eql_v3_double_ord_ore) - Unsupported operator blocker for public.eql\_v3\_double\_ord\_ore.
* [`contains(eql_v3_double_ord_ore, jsonb)`](#containseql_v3_double_ord_ore-jsonb) - Unsupported operator blocker for public.eql\_v3\_double\_ord\_ore.
* [`contains(eql_v3_double_ord_ore, eql_v3_double_ord_ore)`](#containseql_v3_double_ord_ore-eql_v3_double_ord_ore) - Unsupported operator blocker for public.eql\_v3\_double\_ord\_ore.
* [`contains(jsonb, eql_v3_bigint_ord)`](#containsjsonb-eql_v3_bigint_ord) - Unsupported operator blocker for public.eql\_v3\_bigint\_ord.
* [`contains(eql_v3_bigint_ord, jsonb)`](#containseql_v3_bigint_ord-jsonb) - Unsupported operator blocker for public.eql\_v3\_bigint\_ord.
* [`contains(eql_v3_bigint_ord, eql_v3_bigint_ord)`](#containseql_v3_bigint_ord-eql_v3_bigint_ord) - Unsupported operator blocker for public.eql\_v3\_bigint\_ord.
* [`contains(jsonb, eql_v3_text_search_ore)`](#containsjsonb-eql_v3_text_search_ore) - Unsupported operator blocker for public.eql\_v3\_text\_search\_ore.
* [`contains(eql_v3_text_search_ore, jsonb)`](#containseql_v3_text_search_ore-jsonb) - Unsupported operator blocker for public.eql\_v3\_text\_search\_ore.
* [`contains(eql_v3_text_search_ore, eql_v3_text_search_ore)`](#containseql_v3_text_search_ore-eql_v3_text_search_ore) - Unsupported operator blocker for public.eql\_v3\_text\_search\_ore.
* [`contains(jsonb, eql_v3_numeric_eq)`](#containsjsonb-eql_v3_numeric_eq) - Unsupported operator blocker for public.eql\_v3\_numeric\_eq.
* [`contains(eql_v3_numeric_eq, jsonb)`](#containseql_v3_numeric_eq-jsonb) - Unsupported operator blocker for public.eql\_v3\_numeric\_eq.
* [`contains(eql_v3_numeric_eq, eql_v3_numeric_eq)`](#containseql_v3_numeric_eq-eql_v3_numeric_eq) - Unsupported operator blocker for public.eql\_v3\_numeric\_eq.
* [`contains(jsonb, eql_v3_timestamp_ord)`](#containsjsonb-eql_v3_timestamp_ord) - Unsupported operator blocker for public.eql\_v3\_timestamp\_ord.
* [`contains(eql_v3_timestamp_ord, jsonb)`](#containseql_v3_timestamp_ord-jsonb) - Unsupported operator blocker for public.eql\_v3\_timestamp\_ord.
* [`contains(eql_v3_timestamp_ord, eql_v3_timestamp_ord)`](#containseql_v3_timestamp_ord-eql_v3_timestamp_ord) - Unsupported operator blocker for public.eql\_v3\_timestamp\_ord.
* [`contains(jsonb, eql_v3_text_match)`](#containsjsonb-eql_v3_text_match) - Unsupported operator blocker for public.eql\_v3\_text\_match.
* [`contains(eql_v3_text_match, jsonb)`](#containseql_v3_text_match-jsonb) - Unsupported operator blocker for public.eql\_v3\_text\_match.
* [`contains(eql_v3_text_match, eql_v3_text_match)`](#containseql_v3_text_match-eql_v3_text_match) - Unsupported operator blocker for public.eql\_v3\_text\_match.
* [`contains(jsonb, eql_v3_smallint_ord_ope)`](#containsjsonb-eql_v3_smallint_ord_ope) - Unsupported operator blocker for public.eql\_v3\_smallint\_ord\_ope.
* [`contains(eql_v3_smallint_ord_ope, jsonb)`](#containseql_v3_smallint_ord_ope-jsonb) - Unsupported operator blocker for public.eql\_v3\_smallint\_ord\_ope.
* [`contains(eql_v3_smallint_ord_ope, eql_v3_smallint_ord_ope)`](#containseql_v3_smallint_ord_ope-eql_v3_smallint_ord_ope) - Unsupported operator blocker for public.eql\_v3\_smallint\_ord\_ope.
* [`contains(jsonb, eql_v3_integer)`](#containsjsonb-eql_v3_integer) - Unsupported operator blocker for public.eql\_v3\_integer.
* [`contains(eql_v3_integer, jsonb)`](#containseql_v3_integer-jsonb) - Unsupported operator blocker for public.eql\_v3\_integer.
* [`contains(eql_v3_integer, eql_v3_integer)`](#containseql_v3_integer-eql_v3_integer) - Unsupported operator blocker for public.eql\_v3\_integer.
* [`contains(jsonb, eql_v3_double)`](#containsjsonb-eql_v3_double) - Unsupported operator blocker for public.eql\_v3\_double.
* [`contains(eql_v3_double, jsonb)`](#containseql_v3_double-jsonb) - Unsupported operator blocker for public.eql\_v3\_double.
* [`contains(eql_v3_double, eql_v3_double)`](#containseql_v3_double-eql_v3_double) - Unsupported operator blocker for public.eql\_v3\_double.
* [`contains(jsonb, eql_v3_timestamp_ord_ore)`](#containsjsonb-eql_v3_timestamp_ord_ore) - Unsupported operator blocker for public.eql\_v3\_timestamp\_ord\_ore.
* [`contains(eql_v3_timestamp_ord_ore, jsonb)`](#containseql_v3_timestamp_ord_ore-jsonb) - Unsupported operator blocker for public.eql\_v3\_timestamp\_ord\_ore.
* [`contains(eql_v3_timestamp_ord_ore, eql_v3_timestamp_ord_ore)`](#containseql_v3_timestamp_ord_ore-eql_v3_timestamp_ord_ore) - Unsupported operator blocker for public.eql\_v3\_timestamp\_ord\_ore.
* [`contains(jsonb, eql_v3_text_search)`](#containsjsonb-eql_v3_text_search) - Unsupported operator blocker for public.eql\_v3\_text\_search.
* [`contains(eql_v3_text_search, jsonb)`](#containseql_v3_text_search-jsonb) - Unsupported operator blocker for public.eql\_v3\_text\_search.
* [`contains(eql_v3_text_search, eql_v3_text_search)`](#containseql_v3_text_search-eql_v3_text_search) - Unsupported operator blocker for public.eql\_v3\_text\_search.
* [`contains(jsonb, eql_v3_smallint_eq)`](#containsjsonb-eql_v3_smallint_eq) - Unsupported operator blocker for public.eql\_v3\_smallint\_eq.
* [`contains(eql_v3_smallint_eq, jsonb)`](#containseql_v3_smallint_eq-jsonb) - Unsupported operator blocker for public.eql\_v3\_smallint\_eq.
* [`contains(eql_v3_smallint_eq, eql_v3_smallint_eq)`](#containseql_v3_smallint_eq-eql_v3_smallint_eq) - Unsupported operator blocker for public.eql\_v3\_smallint\_eq.
* [`contains(jsonb, eql_v3_double_ord)`](#containsjsonb-eql_v3_double_ord) - Unsupported operator blocker for public.eql\_v3\_double\_ord.
* [`contains(eql_v3_double_ord, jsonb)`](#containseql_v3_double_ord-jsonb) - Unsupported operator blocker for public.eql\_v3\_double\_ord.
* [`contains(eql_v3_double_ord, eql_v3_double_ord)`](#containseql_v3_double_ord-eql_v3_double_ord) - Unsupported operator blocker for public.eql\_v3\_double\_ord.
* [`contains(jsonb, eql_v3_date_eq)`](#containsjsonb-eql_v3_date_eq) - Unsupported operator blocker for public.eql\_v3\_date\_eq.
* [`contains(eql_v3_date_eq, jsonb)`](#containseql_v3_date_eq-jsonb) - Unsupported operator blocker for public.eql\_v3\_date\_eq.
* [`contains(eql_v3_date_eq, eql_v3_date_eq)`](#containseql_v3_date_eq-eql_v3_date_eq) - Unsupported operator blocker for public.eql\_v3\_date\_eq.
* [`contains(jsonb, eql_v3_double_ord_ope)`](#containsjsonb-eql_v3_double_ord_ope) - Unsupported operator blocker for public.eql\_v3\_double\_ord\_ope.
* [`contains(eql_v3_double_ord_ope, jsonb)`](#containseql_v3_double_ord_ope-jsonb) - Unsupported operator blocker for public.eql\_v3\_double\_ord\_ope.
* [`contains(eql_v3_double_ord_ope, eql_v3_double_ord_ope)`](#containseql_v3_double_ord_ope-eql_v3_double_ord_ope) - Unsupported operator blocker for public.eql\_v3\_double\_ord\_ope.
* [`contains(jsonb, eql_v3_numeric_ord_ope)`](#containsjsonb-eql_v3_numeric_ord_ope) - Unsupported operator blocker for public.eql\_v3\_numeric\_ord\_ope.
* [`contains(eql_v3_numeric_ord_ope, jsonb)`](#containseql_v3_numeric_ord_ope-jsonb) - Unsupported operator blocker for public.eql\_v3\_numeric\_ord\_ope.
* [`contains(eql_v3_numeric_ord_ope, eql_v3_numeric_ord_ope)`](#containseql_v3_numeric_ord_ope-eql_v3_numeric_ord_ope) - Unsupported operator blocker for public.eql\_v3\_numeric\_ord\_ope.
* [`contains(jsonb, eql_v3_date_ord_ore)`](#containsjsonb-eql_v3_date_ord_ore) - Unsupported operator blocker for public.eql\_v3\_date\_ord\_ore.
* [`contains(eql_v3_date_ord_ore, jsonb)`](#containseql_v3_date_ord_ore-jsonb) - Unsupported operator blocker for public.eql\_v3\_date\_ord\_ore.
* [`contains(eql_v3_date_ord_ore, eql_v3_date_ord_ore)`](#containseql_v3_date_ord_ore-eql_v3_date_ord_ore) - Unsupported operator blocker for public.eql\_v3\_date\_ord\_ore.
* [`contains(jsonb, eql_v3_text_eq)`](#containsjsonb-eql_v3_text_eq) - Unsupported operator blocker for public.eql\_v3\_text\_eq.
* [`contains(eql_v3_text_eq, jsonb)`](#containseql_v3_text_eq-jsonb) - Unsupported operator blocker for public.eql\_v3\_text\_eq.
* [`contains(eql_v3_text_eq, eql_v3_text_eq)`](#containseql_v3_text_eq-eql_v3_text_eq) - Unsupported operator blocker for public.eql\_v3\_text\_eq.
* [`contains(jsonb, eql_v3_integer_eq)`](#containsjsonb-eql_v3_integer_eq) - Unsupported operator blocker for public.eql\_v3\_integer\_eq.
* [`contains(eql_v3_integer_eq, jsonb)`](#containseql_v3_integer_eq-jsonb) - Unsupported operator blocker for public.eql\_v3\_integer\_eq.
* [`contains(eql_v3_integer_eq, eql_v3_integer_eq)`](#containseql_v3_integer_eq-eql_v3_integer_eq) - Unsupported operator blocker for public.eql\_v3\_integer\_eq.
* [`contains(jsonb, eql_v3_smallint_ord_ore)`](#containsjsonb-eql_v3_smallint_ord_ore) - Unsupported operator blocker for public.eql\_v3\_smallint\_ord\_ore.
* [`contains(eql_v3_smallint_ord_ore, jsonb)`](#containseql_v3_smallint_ord_ore-jsonb) - Unsupported operator blocker for public.eql\_v3\_smallint\_ord\_ore.
* [`contains(eql_v3_smallint_ord_ore, eql_v3_smallint_ord_ore)`](#containseql_v3_smallint_ord_ore-eql_v3_smallint_ord_ore) - Unsupported operator blocker for public.eql\_v3\_smallint\_ord\_ore.
* [`contains(jsonb, eql_v3_date_ord_ope)`](#containsjsonb-eql_v3_date_ord_ope) - Unsupported operator blocker for public.eql\_v3\_date\_ord\_ope.
* [`contains(eql_v3_date_ord_ope, jsonb)`](#containseql_v3_date_ord_ope-jsonb) - Unsupported operator blocker for public.eql\_v3\_date\_ord\_ope.
* [`contains(eql_v3_date_ord_ope, eql_v3_date_ord_ope)`](#containseql_v3_date_ord_ope-eql_v3_date_ord_ope) - Unsupported operator blocker for public.eql\_v3\_date\_ord\_ope.
* [`contains(jsonb, eql_v3_text_ord_ore)`](#containsjsonb-eql_v3_text_ord_ore) - Unsupported operator blocker for public.eql\_v3\_text\_ord\_ore.
* [`contains(eql_v3_text_ord_ore, jsonb)`](#containseql_v3_text_ord_ore-jsonb) - Unsupported operator blocker for public.eql\_v3\_text\_ord\_ore.
* [`contains(eql_v3_text_ord_ore, eql_v3_text_ord_ore)`](#containseql_v3_text_ord_ore-eql_v3_text_ord_ore) - Unsupported operator blocker for public.eql\_v3\_text\_ord\_ore.
* [`contains(jsonb, eql_v3_smallint)`](#containsjsonb-eql_v3_smallint) - Unsupported operator blocker for public.eql\_v3\_smallint.
* [`contains(eql_v3_smallint, jsonb)`](#containseql_v3_smallint-jsonb) - Unsupported operator blocker for public.eql\_v3\_smallint.
* [`contains(eql_v3_smallint, eql_v3_smallint)`](#containseql_v3_smallint-eql_v3_smallint) - Unsupported operator blocker for public.eql\_v3\_smallint.
* [`encrypted_domain_unsupported_bool(text, text)`](#encrypted_domain_unsupported_booltext-text) - Shared blocker helper.
* [`encrypted_domain_unsupported_jsonb(text, text)`](#encrypted_domain_unsupported_jsonbtext-text) - Shared blocker helper returning jsonb.
* [`encrypted_domain_unsupported_text(text, text)`](#encrypted_domain_unsupported_texttext-text) - Shared blocker helper returning text.
* [`eq(jsonb, eql_v3_date)`](#eqjsonb-eql_v3_date) - Unsupported operator blocker for public.eql\_v3\_date.
* [`eq(eql_v3_date, jsonb)`](#eqeql_v3_date-jsonb) - Unsupported operator blocker for public.eql\_v3\_date.
* [`eq(eql_v3_date, eql_v3_date)`](#eqeql_v3_date-eql_v3_date) - Unsupported operator blocker for public.eql\_v3\_date.
* [`eq(query_double_ord, eql_v3_json_entry)`](#eqquery_double_ord-eql_v3_json_entry) - Unsupported operator blocker for public.eql\_v3\_json\_entry.
* [`eq(eql_v3_json_entry, query_double_ord)`](#eqeql_v3_json_entry-query_double_ord) - Unsupported operator blocker for public.eql\_v3\_json\_entry.
* [`eq(query_smallint_ord, eql_v3_json_entry)`](#eqquery_smallint_ord-eql_v3_json_entry) - Unsupported operator blocker for public.eql\_v3\_json\_entry.
* [`eq(eql_v3_json_entry, query_smallint_ord)`](#eqeql_v3_json_entry-query_smallint_ord) - Unsupported operator blocker for public.eql\_v3\_json\_entry.
* [`eq(jsonb, eql_v3_bigint)`](#eqjsonb-eql_v3_bigint) - Unsupported operator blocker for public.eql\_v3\_bigint.
* [`eq(eql_v3_bigint, jsonb)`](#eqeql_v3_bigint-jsonb) - Unsupported operator blocker for public.eql\_v3\_bigint.
* [`eq(eql_v3_bigint, eql_v3_bigint)`](#eqeql_v3_bigint-eql_v3_bigint) - Unsupported operator blocker for public.eql\_v3\_bigint.
* [`eq(jsonb, eql_v3_numeric)`](#eqjsonb-eql_v3_numeric) - Unsupported operator blocker for public.eql\_v3\_numeric.
* [`eq(eql_v3_numeric, jsonb)`](#eqeql_v3_numeric-jsonb) - Unsupported operator blocker for public.eql\_v3\_numeric.
* [`eq(eql_v3_numeric, eql_v3_numeric)`](#eqeql_v3_numeric-eql_v3_numeric) - Unsupported operator blocker for public.eql\_v3\_numeric.
* [`eq(jsonb, eql_v3_json)`](#eqjsonb-eql_v3_json) - Unsupported operator blocker for public.eql\_v3\_json.
* [`eq(eql_v3_json, jsonb)`](#eqeql_v3_json-jsonb) - Unsupported operator blocker for public.eql\_v3\_json.
* [`eq(eql_v3_json, eql_v3_json)`](#eqeql_v3_json-eql_v3_json) - Unsupported operator blocker for public.eql\_v3\_json.
* [`eq(jsonb, eql_v3_boolean)`](#eqjsonb-eql_v3_boolean) - Unsupported operator blocker for public.eql\_v3\_boolean.
* [`eq(eql_v3_boolean, jsonb)`](#eqeql_v3_boolean-jsonb) - Unsupported operator blocker for public.eql\_v3\_boolean.
* [`eq(eql_v3_boolean, eql_v3_boolean)`](#eqeql_v3_boolean-eql_v3_boolean) - Unsupported operator blocker for public.eql\_v3\_boolean.
* [`eq(query_date_ord, eql_v3_json_entry)`](#eqquery_date_ord-eql_v3_json_entry) - Unsupported operator blocker for public.eql\_v3\_json\_entry.
* [`eq(eql_v3_json_entry, query_date_ord)`](#eqeql_v3_json_entry-query_date_ord) - Unsupported operator blocker for public.eql\_v3\_json\_entry.
* [`eq(jsonb, eql_v3_real)`](#eqjsonb-eql_v3_real) - Unsupported operator blocker for public.eql\_v3\_real.
* [`eq(eql_v3_real, jsonb)`](#eqeql_v3_real-jsonb) - Unsupported operator blocker for public.eql\_v3\_real.
* [`eq(eql_v3_real, eql_v3_real)`](#eqeql_v3_real-eql_v3_real) - Unsupported operator blocker for public.eql\_v3\_real.
* [`eq(query_timestamp_ord, eql_v3_json_entry)`](#eqquery_timestamp_ord-eql_v3_json_entry) - Unsupported operator blocker for public.eql\_v3\_json\_entry.
* [`eq(eql_v3_json_entry, query_timestamp_ord)`](#eqeql_v3_json_entry-query_timestamp_ord) - Unsupported operator blocker for public.eql\_v3\_json\_entry.
* [`eq(jsonb, eql_v3_text)`](#eqjsonb-eql_v3_text) - Unsupported operator blocker for public.eql\_v3\_text.
* [`eq(eql_v3_text, jsonb)`](#eqeql_v3_text-jsonb) - Unsupported operator blocker for public.eql\_v3\_text.
* [`eq(eql_v3_text, eql_v3_text)`](#eqeql_v3_text-eql_v3_text) - Unsupported operator blocker for public.eql\_v3\_text.
* [`eq(query_numeric_ord, eql_v3_json_entry)`](#eqquery_numeric_ord-eql_v3_json_entry) - Unsupported operator blocker for public.eql\_v3\_json\_entry.
* [`eq(eql_v3_json_entry, query_numeric_ord)`](#eqeql_v3_json_entry-query_numeric_ord) - Unsupported operator blocker for public.eql\_v3\_json\_entry.
* [`eq(jsonb, eql_v3_timestamp)`](#eqjsonb-eql_v3_timestamp) - Unsupported operator blocker for public.eql\_v3\_timestamp.
* [`eq(eql_v3_timestamp, jsonb)`](#eqeql_v3_timestamp-jsonb) - Unsupported operator blocker for public.eql\_v3\_timestamp.
* [`eq(eql_v3_timestamp, eql_v3_timestamp)`](#eqeql_v3_timestamp-eql_v3_timestamp) - Unsupported operator blocker for public.eql\_v3\_timestamp.
* [`eq(query_text_ord, eql_v3_json_entry)`](#eqquery_text_ord-eql_v3_json_entry) - Unsupported operator blocker for public.eql\_v3\_json\_entry.
* [`eq(eql_v3_json_entry, query_text_ord)`](#eqeql_v3_json_entry-query_text_ord) - Unsupported operator blocker for public.eql\_v3\_json\_entry.
* [`eq(jsonb, eql_v3_text_match)`](#eqjsonb-eql_v3_text_match) - Unsupported operator blocker for public.eql\_v3\_text\_match.
* [`eq(eql_v3_text_match, jsonb)`](#eqeql_v3_text_match-jsonb) - Unsupported operator blocker for public.eql\_v3\_text\_match.
* [`eq(eql_v3_text_match, eql_v3_text_match)`](#eqeql_v3_text_match-eql_v3_text_match) - Unsupported operator blocker for public.eql\_v3\_text\_match.
* [`eq(query_integer_ord, eql_v3_json_entry)`](#eqquery_integer_ord-eql_v3_json_entry) - Unsupported operator blocker for public.eql\_v3\_json\_entry.
* [`eq(eql_v3_json_entry, query_integer_ord)`](#eqeql_v3_json_entry-query_integer_ord) - Unsupported operator blocker for public.eql\_v3\_json\_entry.
* [`eq(jsonb, eql_v3_integer)`](#eqjsonb-eql_v3_integer) - Unsupported operator blocker for public.eql\_v3\_integer.
* [`eq(eql_v3_integer, jsonb)`](#eqeql_v3_integer-jsonb) - Unsupported operator blocker for public.eql\_v3\_integer.
* [`eq(eql_v3_integer, eql_v3_integer)`](#eqeql_v3_integer-eql_v3_integer) - Unsupported operator blocker for public.eql\_v3\_integer.
* [`eq(query_real_ord, eql_v3_json_entry)`](#eqquery_real_ord-eql_v3_json_entry) - Unsupported operator blocker for public.eql\_v3\_json\_entry.
* [`eq(eql_v3_json_entry, query_real_ord)`](#eqeql_v3_json_entry-query_real_ord) - Unsupported operator blocker for public.eql\_v3\_json\_entry.
* [`eq(jsonb, eql_v3_double)`](#eqjsonb-eql_v3_double) - Unsupported operator blocker for public.eql\_v3\_double.
* [`eq(eql_v3_double, jsonb)`](#eqeql_v3_double-jsonb) - Unsupported operator blocker for public.eql\_v3\_double.
* [`eq(eql_v3_double, eql_v3_double)`](#eqeql_v3_double-eql_v3_double) - Unsupported operator blocker for public.eql\_v3\_double.
* [`eq(jsonb, eql_v3_smallint)`](#eqjsonb-eql_v3_smallint) - Unsupported operator blocker for public.eql\_v3\_smallint.
* [`eq(eql_v3_smallint, jsonb)`](#eqeql_v3_smallint-jsonb) - Unsupported operator blocker for public.eql\_v3\_smallint.
* [`eq(eql_v3_smallint, eql_v3_smallint)`](#eqeql_v3_smallint-eql_v3_smallint) - Unsupported operator blocker for public.eql\_v3\_smallint.
* [`eq(query_bigint_ord, eql_v3_json_entry)`](#eqquery_bigint_ord-eql_v3_json_entry) - Unsupported operator blocker for public.eql\_v3\_json\_entry.
* [`eq(eql_v3_json_entry, query_bigint_ord)`](#eqeql_v3_json_entry-query_bigint_ord) - Unsupported operator blocker for public.eql\_v3\_json\_entry.
* [`grouped_value_sfunc(jsonb, jsonb)`](#grouped_value_sfuncjsonb-jsonb) - State transition function for the grouped\_value aggregate.
* [`gt(jsonb, eql_v3_date)`](#gtjsonb-eql_v3_date) - Unsupported operator blocker for public.eql\_v3\_date.
* [`gt(eql_v3_date, jsonb)`](#gteql_v3_date-jsonb) - Unsupported operator blocker for public.eql\_v3\_date.
* [`gt(eql_v3_date, eql_v3_date)`](#gteql_v3_date-eql_v3_date) - Unsupported operator blocker for public.eql\_v3\_date.
* [`gt(jsonb, eql_v3_bigint_eq)`](#gtjsonb-eql_v3_bigint_eq) - Unsupported operator blocker for public.eql\_v3\_bigint\_eq.
* [`gt(eql_v3_bigint_eq, jsonb)`](#gteql_v3_bigint_eq-jsonb) - Unsupported operator blocker for public.eql\_v3\_bigint\_eq.
* [`gt(eql_v3_bigint_eq, eql_v3_bigint_eq)`](#gteql_v3_bigint_eq-eql_v3_bigint_eq) - Unsupported operator blocker for public.eql\_v3\_bigint\_eq.
* [`gt(jsonb, eql_v3_bigint)`](#gtjsonb-eql_v3_bigint) - Unsupported operator blocker for public.eql\_v3\_bigint.
* [`gt(eql_v3_bigint, jsonb)`](#gteql_v3_bigint-jsonb) - Unsupported operator blocker for public.eql\_v3\_bigint.
* [`gt(eql_v3_bigint, eql_v3_bigint)`](#gteql_v3_bigint-eql_v3_bigint) - Unsupported operator blocker for public.eql\_v3\_bigint.
* [`gt(jsonb, eql_v3_numeric)`](#gtjsonb-eql_v3_numeric) - Unsupported operator blocker for public.eql\_v3\_numeric.
* [`gt(eql_v3_numeric, jsonb)`](#gteql_v3_numeric-jsonb) - Unsupported operator blocker for public.eql\_v3\_numeric.
* [`gt(eql_v3_numeric, eql_v3_numeric)`](#gteql_v3_numeric-eql_v3_numeric) - Unsupported operator blocker for public.eql\_v3\_numeric.
* [`gt(jsonb, eql_v3_timestamp_eq)`](#gtjsonb-eql_v3_timestamp_eq) - Unsupported operator blocker for public.eql\_v3\_timestamp\_eq.
* [`gt(eql_v3_timestamp_eq, jsonb)`](#gteql_v3_timestamp_eq-jsonb) - Unsupported operator blocker for public.eql\_v3\_timestamp\_eq.
* [`gt(eql_v3_timestamp_eq, eql_v3_timestamp_eq)`](#gteql_v3_timestamp_eq-eql_v3_timestamp_eq) - Unsupported operator blocker for public.eql\_v3\_timestamp\_eq.
* [`gt(jsonb, eql_v3_json)`](#gtjsonb-eql_v3_json) - Unsupported operator blocker for public.eql\_v3\_json.
* [`gt(eql_v3_json, jsonb)`](#gteql_v3_json-jsonb) - Unsupported operator blocker for public.eql\_v3\_json.
* [`gt(eql_v3_json, eql_v3_json)`](#gteql_v3_json-eql_v3_json) - Unsupported operator blocker for public.eql\_v3\_json.
* [`gt(jsonb, eql_v3_boolean)`](#gtjsonb-eql_v3_boolean) - Unsupported operator blocker for public.eql\_v3\_boolean.
* [`gt(eql_v3_boolean, jsonb)`](#gteql_v3_boolean-jsonb) - Unsupported operator blocker for public.eql\_v3\_boolean.
* [`gt(eql_v3_boolean, eql_v3_boolean)`](#gteql_v3_boolean-eql_v3_boolean) - Unsupported operator blocker for public.eql\_v3\_boolean.
* [`gt(query_date_ord, eql_v3_json_entry)`](#gtquery_date_ord-eql_v3_json_entry) - Unsupported operator blocker for public.eql\_v3\_json\_entry.
* [`gt(eql_v3_json_entry, query_date_ord)`](#gteql_v3_json_entry-query_date_ord) - Unsupported operator blocker for public.eql\_v3\_json\_entry.
* [`gt(jsonb, eql_v3_real)`](#gtjsonb-eql_v3_real) - Unsupported operator blocker for public.eql\_v3\_real.
* [`gt(eql_v3_real, jsonb)`](#gteql_v3_real-jsonb) - Unsupported operator blocker for public.eql\_v3\_real.
* [`gt(eql_v3_real, eql_v3_real)`](#gteql_v3_real-eql_v3_real) - Unsupported operator blocker for public.eql\_v3\_real.
* [`gt(jsonb, eql_v3_real_eq)`](#gtjsonb-eql_v3_real_eq) - Unsupported operator blocker for public.eql\_v3\_real\_eq.
* [`gt(eql_v3_real_eq, jsonb)`](#gteql_v3_real_eq-jsonb) - Unsupported operator blocker for public.eql\_v3\_real\_eq.
* [`gt(eql_v3_real_eq, eql_v3_real_eq)`](#gteql_v3_real_eq-eql_v3_real_eq) - Unsupported operator blocker for public.eql\_v3\_real\_eq.
* [`gt(query_timestamp_ord, eql_v3_json_entry)`](#gtquery_timestamp_ord-eql_v3_json_entry) - Unsupported operator blocker for public.eql\_v3\_json\_entry.
* [`gt(eql_v3_json_entry, query_timestamp_ord)`](#gteql_v3_json_entry-query_timestamp_ord) - Unsupported operator blocker for public.eql\_v3\_json\_entry.
* [`gt(jsonb, eql_v3_text)`](#gtjsonb-eql_v3_text) - Unsupported operator blocker for public.eql\_v3\_text.
* [`gt(eql_v3_text, jsonb)`](#gteql_v3_text-jsonb) - Unsupported operator blocker for public.eql\_v3\_text.
* [`gt(eql_v3_text, eql_v3_text)`](#gteql_v3_text-eql_v3_text) - Unsupported operator blocker for public.eql\_v3\_text.
* [`gt(jsonb, eql_v3_double_eq)`](#gtjsonb-eql_v3_double_eq) - Unsupported operator blocker for public.eql\_v3\_double\_eq.
* [`gt(eql_v3_double_eq, jsonb)`](#gteql_v3_double_eq-jsonb) - Unsupported operator blocker for public.eql\_v3\_double\_eq.
* [`gt(eql_v3_double_eq, eql_v3_double_eq)`](#gteql_v3_double_eq-eql_v3_double_eq) - Unsupported operator blocker for public.eql\_v3\_double\_eq.
* [`gt(jsonb, eql_v3_timestamp)`](#gtjsonb-eql_v3_timestamp) - Unsupported operator blocker for public.eql\_v3\_timestamp.
* [`gt(eql_v3_timestamp, jsonb)`](#gteql_v3_timestamp-jsonb) - Unsupported operator blocker for public.eql\_v3\_timestamp.
* [`gt(eql_v3_timestamp, eql_v3_timestamp)`](#gteql_v3_timestamp-eql_v3_timestamp) - Unsupported operator blocker for public.eql\_v3\_timestamp.
* [`gt(jsonb, eql_v3_numeric_eq)`](#gtjsonb-eql_v3_numeric_eq) - Unsupported operator blocker for public.eql\_v3\_numeric\_eq.
* [`gt(eql_v3_numeric_eq, jsonb)`](#gteql_v3_numeric_eq-jsonb) - Unsupported operator blocker for public.eql\_v3\_numeric\_eq.
* [`gt(eql_v3_numeric_eq, eql_v3_numeric_eq)`](#gteql_v3_numeric_eq-eql_v3_numeric_eq) - Unsupported operator blocker for public.eql\_v3\_numeric\_eq.
* [`gt(jsonb, eql_v3_text_match)`](#gtjsonb-eql_v3_text_match) - Unsupported operator blocker for public.eql\_v3\_text\_match.
* [`gt(eql_v3_text_match, jsonb)`](#gteql_v3_text_match-jsonb) - Unsupported operator blocker for public.eql\_v3\_text\_match.
* [`gt(eql_v3_text_match, eql_v3_text_match)`](#gteql_v3_text_match-eql_v3_text_match) - Unsupported operator blocker for public.eql\_v3\_text\_match.
* [`gt(jsonb, eql_v3_integer)`](#gtjsonb-eql_v3_integer) - Unsupported operator blocker for public.eql\_v3\_integer.
* [`gt(eql_v3_integer, jsonb)`](#gteql_v3_integer-jsonb) - Unsupported operator blocker for public.eql\_v3\_integer.
* [`gt(eql_v3_integer, eql_v3_integer)`](#gteql_v3_integer-eql_v3_integer) - Unsupported operator blocker for public.eql\_v3\_integer.
* [`gt(jsonb, eql_v3_double)`](#gtjsonb-eql_v3_double) - Unsupported operator blocker for public.eql\_v3\_double.
* [`gt(eql_v3_double, jsonb)`](#gteql_v3_double-jsonb) - Unsupported operator blocker for public.eql\_v3\_double.
* [`gt(eql_v3_double, eql_v3_double)`](#gteql_v3_double-eql_v3_double) - Unsupported operator blocker for public.eql\_v3\_double.
* [`gt(jsonb, eql_v3_smallint_eq)`](#gtjsonb-eql_v3_smallint_eq) - Unsupported operator blocker for public.eql\_v3\_smallint\_eq.
* [`gt(eql_v3_smallint_eq, jsonb)`](#gteql_v3_smallint_eq-jsonb) - Unsupported operator blocker for public.eql\_v3\_smallint\_eq.
* [`gt(eql_v3_smallint_eq, eql_v3_smallint_eq)`](#gteql_v3_smallint_eq-eql_v3_smallint_eq) - Unsupported operator blocker for public.eql\_v3\_smallint\_eq.
* [`gt(jsonb, eql_v3_date_eq)`](#gtjsonb-eql_v3_date_eq) - Unsupported operator blocker for public.eql\_v3\_date\_eq.
* [`gt(eql_v3_date_eq, jsonb)`](#gteql_v3_date_eq-jsonb) - Unsupported operator blocker for public.eql\_v3\_date\_eq.
* [`gt(eql_v3_date_eq, eql_v3_date_eq)`](#gteql_v3_date_eq-eql_v3_date_eq) - Unsupported operator blocker for public.eql\_v3\_date\_eq.
* [`gt(jsonb, eql_v3_text_eq)`](#gtjsonb-eql_v3_text_eq) - Unsupported operator blocker for public.eql\_v3\_text\_eq.
* [`gt(eql_v3_text_eq, jsonb)`](#gteql_v3_text_eq-jsonb) - Unsupported operator blocker for public.eql\_v3\_text\_eq.
* [`gt(eql_v3_text_eq, eql_v3_text_eq)`](#gteql_v3_text_eq-eql_v3_text_eq) - Unsupported operator blocker for public.eql\_v3\_text\_eq.
* [`gt(jsonb, eql_v3_integer_eq)`](#gtjsonb-eql_v3_integer_eq) - Unsupported operator blocker for public.eql\_v3\_integer\_eq.
* [`gt(eql_v3_integer_eq, jsonb)`](#gteql_v3_integer_eq-jsonb) - Unsupported operator blocker for public.eql\_v3\_integer\_eq.
* [`gt(eql_v3_integer_eq, eql_v3_integer_eq)`](#gteql_v3_integer_eq-eql_v3_integer_eq) - Unsupported operator blocker for public.eql\_v3\_integer\_eq.
* [`gt(jsonb, eql_v3_smallint)`](#gtjsonb-eql_v3_smallint) - Unsupported operator blocker for public.eql\_v3\_smallint.
* [`gt(eql_v3_smallint, jsonb)`](#gteql_v3_smallint-jsonb) - Unsupported operator blocker for public.eql\_v3\_smallint.
* [`gt(eql_v3_smallint, eql_v3_smallint)`](#gteql_v3_smallint-eql_v3_smallint) - Unsupported operator blocker for public.eql\_v3\_smallint.
* [`gte(jsonb, eql_v3_date)`](#gtejsonb-eql_v3_date) - Unsupported operator blocker for public.eql\_v3\_date.
* [`gte(eql_v3_date, jsonb)`](#gteeql_v3_date-jsonb) - Unsupported operator blocker for public.eql\_v3\_date.
* [`gte(eql_v3_date, eql_v3_date)`](#gteeql_v3_date-eql_v3_date) - Unsupported operator blocker for public.eql\_v3\_date.
* [`gte(jsonb, eql_v3_bigint_eq)`](#gtejsonb-eql_v3_bigint_eq) - Unsupported operator blocker for public.eql\_v3\_bigint\_eq.
* [`gte(eql_v3_bigint_eq, jsonb)`](#gteeql_v3_bigint_eq-jsonb) - Unsupported operator blocker for public.eql\_v3\_bigint\_eq.
* [`gte(eql_v3_bigint_eq, eql_v3_bigint_eq)`](#gteeql_v3_bigint_eq-eql_v3_bigint_eq) - Unsupported operator blocker for public.eql\_v3\_bigint\_eq.
* [`gte(jsonb, eql_v3_bigint)`](#gtejsonb-eql_v3_bigint) - Unsupported operator blocker for public.eql\_v3\_bigint.
* [`gte(eql_v3_bigint, jsonb)`](#gteeql_v3_bigint-jsonb) - Unsupported operator blocker for public.eql\_v3\_bigint.
* [`gte(eql_v3_bigint, eql_v3_bigint)`](#gteeql_v3_bigint-eql_v3_bigint) - Unsupported operator blocker for public.eql\_v3\_bigint.
* [`gte(jsonb, eql_v3_numeric)`](#gtejsonb-eql_v3_numeric) - Unsupported operator blocker for public.eql\_v3\_numeric.
* [`gte(eql_v3_numeric, jsonb)`](#gteeql_v3_numeric-jsonb) - Unsupported operator blocker for public.eql\_v3\_numeric.
* [`gte(eql_v3_numeric, eql_v3_numeric)`](#gteeql_v3_numeric-eql_v3_numeric) - Unsupported operator blocker for public.eql\_v3\_numeric.
* [`gte(jsonb, eql_v3_timestamp_eq)`](#gtejsonb-eql_v3_timestamp_eq) - Unsupported operator blocker for public.eql\_v3\_timestamp\_eq.
* [`gte(eql_v3_timestamp_eq, jsonb)`](#gteeql_v3_timestamp_eq-jsonb) - Unsupported operator blocker for public.eql\_v3\_timestamp\_eq.
* [`gte(eql_v3_timestamp_eq, eql_v3_timestamp_eq)`](#gteeql_v3_timestamp_eq-eql_v3_timestamp_eq) - Unsupported operator blocker for public.eql\_v3\_timestamp\_eq.
* [`gte(jsonb, eql_v3_json)`](#gtejsonb-eql_v3_json) - Unsupported operator blocker for public.eql\_v3\_json.
* [`gte(eql_v3_json, jsonb)`](#gteeql_v3_json-jsonb) - Unsupported operator blocker for public.eql\_v3\_json.
* [`gte(eql_v3_json, eql_v3_json)`](#gteeql_v3_json-eql_v3_json) - Unsupported operator blocker for public.eql\_v3\_json.
* [`gte(jsonb, eql_v3_boolean)`](#gtejsonb-eql_v3_boolean) - Unsupported operator blocker for public.eql\_v3\_boolean.
* [`gte(eql_v3_boolean, jsonb)`](#gteeql_v3_boolean-jsonb) - Unsupported operator blocker for public.eql\_v3\_boolean.
* [`gte(eql_v3_boolean, eql_v3_boolean)`](#gteeql_v3_boolean-eql_v3_boolean) - Unsupported operator blocker for public.eql\_v3\_boolean.
* [`gte(query_date_ord, eql_v3_json_entry)`](#gtequery_date_ord-eql_v3_json_entry) - Unsupported operator blocker for public.eql\_v3\_json\_entry.
* [`gte(eql_v3_json_entry, query_date_ord)`](#gteeql_v3_json_entry-query_date_ord) - Unsupported operator blocker for public.eql\_v3\_json\_entry.
* [`gte(jsonb, eql_v3_real)`](#gtejsonb-eql_v3_real) - Unsupported operator blocker for public.eql\_v3\_real.
* [`gte(eql_v3_real, jsonb)`](#gteeql_v3_real-jsonb) - Unsupported operator blocker for public.eql\_v3\_real.
* [`gte(eql_v3_real, eql_v3_real)`](#gteeql_v3_real-eql_v3_real) - Unsupported operator blocker for public.eql\_v3\_real.
* [`gte(jsonb, eql_v3_real_eq)`](#gtejsonb-eql_v3_real_eq) - Unsupported operator blocker for public.eql\_v3\_real\_eq.
* [`gte(eql_v3_real_eq, jsonb)`](#gteeql_v3_real_eq-jsonb) - Unsupported operator blocker for public.eql\_v3\_real\_eq.
* [`gte(eql_v3_real_eq, eql_v3_real_eq)`](#gteeql_v3_real_eq-eql_v3_real_eq) - Unsupported operator blocker for public.eql\_v3\_real\_eq.
* [`gte(query_timestamp_ord, eql_v3_json_entry)`](#gtequery_timestamp_ord-eql_v3_json_entry) - Unsupported operator blocker for public.eql\_v3\_json\_entry.
* [`gte(eql_v3_json_entry, query_timestamp_ord)`](#gteeql_v3_json_entry-query_timestamp_ord) - Unsupported operator blocker for public.eql\_v3\_json\_entry.
* [`gte(jsonb, eql_v3_text)`](#gtejsonb-eql_v3_text) - Unsupported operator blocker for public.eql\_v3\_text.
* [`gte(eql_v3_text, jsonb)`](#gteeql_v3_text-jsonb) - Unsupported operator blocker for public.eql\_v3\_text.
* [`gte(eql_v3_text, eql_v3_text)`](#gteeql_v3_text-eql_v3_text) - Unsupported operator blocker for public.eql\_v3\_text.
* [`gte(jsonb, eql_v3_double_eq)`](#gtejsonb-eql_v3_double_eq) - Unsupported operator blocker for public.eql\_v3\_double\_eq.
* [`gte(eql_v3_double_eq, jsonb)`](#gteeql_v3_double_eq-jsonb) - Unsupported operator blocker for public.eql\_v3\_double\_eq.
* [`gte(eql_v3_double_eq, eql_v3_double_eq)`](#gteeql_v3_double_eq-eql_v3_double_eq) - Unsupported operator blocker for public.eql\_v3\_double\_eq.
* [`gte(jsonb, eql_v3_timestamp)`](#gtejsonb-eql_v3_timestamp) - Unsupported operator blocker for public.eql\_v3\_timestamp.
* [`gte(eql_v3_timestamp, jsonb)`](#gteeql_v3_timestamp-jsonb) - Unsupported operator blocker for public.eql\_v3\_timestamp.
* [`gte(eql_v3_timestamp, eql_v3_timestamp)`](#gteeql_v3_timestamp-eql_v3_timestamp) - Unsupported operator blocker for public.eql\_v3\_timestamp.
* [`gte(jsonb, eql_v3_numeric_eq)`](#gtejsonb-eql_v3_numeric_eq) - Unsupported operator blocker for public.eql\_v3\_numeric\_eq.
* [`gte(eql_v3_numeric_eq, jsonb)`](#gteeql_v3_numeric_eq-jsonb) - Unsupported operator blocker for public.eql\_v3\_numeric\_eq.
* [`gte(eql_v3_numeric_eq, eql_v3_numeric_eq)`](#gteeql_v3_numeric_eq-eql_v3_numeric_eq) - Unsupported operator blocker for public.eql\_v3\_numeric\_eq.
* [`gte(jsonb, eql_v3_text_match)`](#gtejsonb-eql_v3_text_match) - Unsupported operator blocker for public.eql\_v3\_text\_match.
* [`gte(eql_v3_text_match, jsonb)`](#gteeql_v3_text_match-jsonb) - Unsupported operator blocker for public.eql\_v3\_text\_match.
* [`gte(eql_v3_text_match, eql_v3_text_match)`](#gteeql_v3_text_match-eql_v3_text_match) - Unsupported operator blocker for public.eql\_v3\_text\_match.
* [`gte(jsonb, eql_v3_integer)`](#gtejsonb-eql_v3_integer) - Unsupported operator blocker for public.eql\_v3\_integer.
* [`gte(eql_v3_integer, jsonb)`](#gteeql_v3_integer-jsonb) - Unsupported operator blocker for public.eql\_v3\_integer.
* [`gte(eql_v3_integer, eql_v3_integer)`](#gteeql_v3_integer-eql_v3_integer) - Unsupported operator blocker for public.eql\_v3\_integer.
* [`gte(jsonb, eql_v3_double)`](#gtejsonb-eql_v3_double) - Unsupported operator blocker for public.eql\_v3\_double.
* [`gte(eql_v3_double, jsonb)`](#gteeql_v3_double-jsonb) - Unsupported operator blocker for public.eql\_v3\_double.
* [`gte(eql_v3_double, eql_v3_double)`](#gteeql_v3_double-eql_v3_double) - Unsupported operator blocker for public.eql\_v3\_double.
* [`gte(jsonb, eql_v3_smallint_eq)`](#gtejsonb-eql_v3_smallint_eq) - Unsupported operator blocker for public.eql\_v3\_smallint\_eq.
* [`gte(eql_v3_smallint_eq, jsonb)`](#gteeql_v3_smallint_eq-jsonb) - Unsupported operator blocker for public.eql\_v3\_smallint\_eq.
* [`gte(eql_v3_smallint_eq, eql_v3_smallint_eq)`](#gteeql_v3_smallint_eq-eql_v3_smallint_eq) - Unsupported operator blocker for public.eql\_v3\_smallint\_eq.
* [`gte(jsonb, eql_v3_date_eq)`](#gtejsonb-eql_v3_date_eq) - Unsupported operator blocker for public.eql\_v3\_date\_eq.
* [`gte(eql_v3_date_eq, jsonb)`](#gteeql_v3_date_eq-jsonb) - Unsupported operator blocker for public.eql\_v3\_date\_eq.
* [`gte(eql_v3_date_eq, eql_v3_date_eq)`](#gteeql_v3_date_eq-eql_v3_date_eq) - Unsupported operator blocker for public.eql\_v3\_date\_eq.
* [`gte(jsonb, eql_v3_text_eq)`](#gtejsonb-eql_v3_text_eq) - Unsupported operator blocker for public.eql\_v3\_text\_eq.
* [`gte(eql_v3_text_eq, jsonb)`](#gteeql_v3_text_eq-jsonb) - Unsupported operator blocker for public.eql\_v3\_text\_eq.
* [`gte(eql_v3_text_eq, eql_v3_text_eq)`](#gteeql_v3_text_eq-eql_v3_text_eq) - Unsupported operator blocker for public.eql\_v3\_text\_eq.
* [`gte(jsonb, eql_v3_integer_eq)`](#gtejsonb-eql_v3_integer_eq) - Unsupported operator blocker for public.eql\_v3\_integer\_eq.
* [`gte(eql_v3_integer_eq, jsonb)`](#gteeql_v3_integer_eq-jsonb) - Unsupported operator blocker for public.eql\_v3\_integer\_eq.
* [`gte(eql_v3_integer_eq, eql_v3_integer_eq)`](#gteeql_v3_integer_eq-eql_v3_integer_eq) - Unsupported operator blocker for public.eql\_v3\_integer\_eq.
* [`gte(jsonb, eql_v3_smallint)`](#gtejsonb-eql_v3_smallint) - Unsupported operator blocker for public.eql\_v3\_smallint.
* [`gte(eql_v3_smallint, jsonb)`](#gteeql_v3_smallint-jsonb) - Unsupported operator blocker for public.eql\_v3\_smallint.
* [`gte(eql_v3_smallint, eql_v3_smallint)`](#gteeql_v3_smallint-eql_v3_smallint) - Unsupported operator blocker for public.eql\_v3\_smallint.
* [`has_bloom_filter(jsonb)`](#has_bloom_filterjsonb) - Test whether a jsonb payload carries a Bloom-filter (bf) term.
* [`has_hmac_256(jsonb)`](#has_hmac_256jsonb) - Check if JSONB payload contains HMAC-SHA256 index term.
* [`has_ore_block_256(jsonb)`](#has_ore_block_256jsonb) - Check if JSONB payload contains an ORE block index term.
* [`hmac_256(jsonb)`](#hmac_256jsonb) - Extract HMAC-SHA256 index term from JSONB payload.
* [`is_ste_vec_array(jsonb)`](#is_ste_vec_arrayjsonb) - Check if a jsonb payload is marked as an sv array (a flag true).
* [`jsonb_array_to_bytea_array(jsonb)`](#jsonb_array_to_bytea_arrayjsonb) - Convert JSONB hex array to bytea array.
* [`jsonb_array_to_ore_block_256(jsonb)`](#jsonb_array_to_ore_block_256jsonb) - Convert JSONB array to ORE block composite type.
* [`jsonb_blocked_compare_json_json(eql_v3_json_search, eql_v3_json_search)`](#jsonb_blocked_compare_json_jsoneql_v3_json_search-eql_v3_json_search) - Blocker: root public.eql\_v3\_json\_search document comparisons.
* [`jsonb_blocked_compare_json_jsonb(eql_v3_json_search, jsonb)`](#jsonb_blocked_compare_json_jsonbeql_v3_json_search-jsonb) - Blocker: root public.eql\_v3\_json\_search-to-jsonb comparisons.
* [`jsonb_blocked_compare_jsonb_json(jsonb, eql_v3_json_search)`](#jsonb_blocked_compare_jsonb_jsonjsonb-eql_v3_json_search) - Blocker: root jsonb-to-public.eql\_v3\_json\_search comparisons.
* [`jsonb_blocked_concat(eql_v3_json_search, jsonb)`](#jsonb_blocked_concateql_v3_json_search-jsonb) - Blocker: || (concatenate, encrypted on the left).
* [`jsonb_blocked_concat_rhs(jsonb, eql_v3_json_search)`](#jsonb_blocked_concat_rhsjsonb-eql_v3_json_search) - Blocker: || (concatenate, encrypted on the right).
* [`jsonb_blocked_contains_entry(eql_v3_json_search, eql_v3_json_entry)`](#jsonb_blocked_contains_entryeql_v3_json_search-eql_v3_json_entry) - Block document containment against an extracted path entry.
* [`jsonb_blocked_delete_array(eql_v3_json_search, text)`](#jsonb_blocked_delete_arrayeql_v3_json_search-text) - Blocker: - (delete keys, text\[] RHS).
* [`jsonb_blocked_delete_int(eql_v3_json_search, integer)`](#jsonb_blocked_delete_inteql_v3_json_search-integer) - Blocker: - (delete index, integer RHS).
* [`jsonb_blocked_delete_path(eql_v3_json_search, text)`](#jsonb_blocked_delete_patheql_v3_json_search-text) - Blocker: #- (delete at path).
* [`jsonb_blocked_delete_text(eql_v3_json_search, text)`](#jsonb_blocked_delete_texteql_v3_json_search-text) - Blocker: - (delete key, text RHS; native returns jsonb).
* [`jsonb_blocked_entry_contained(eql_v3_json_entry, eql_v3_json_search)`](#jsonb_blocked_entry_containedeql_v3_json_entry-eql_v3_json_search) - Block reverse containment from an extracted path entry.
* [`jsonb_blocked_exists(eql_v3_json_search, text)`](#jsonb_blocked_existseql_v3_json_search-text) - Blocker: ? (key/element exists).
* [`jsonb_blocked_exists_all(eql_v3_json_search, text)`](#jsonb_blocked_exists_alleql_v3_json_search-text) - Blocker: ?& (all keys exist).
* [`jsonb_blocked_exists_any(eql_v3_json_search, text)`](#jsonb_blocked_exists_anyeql_v3_json_search-text) - Blocker: ?| (any key exists).
* [`jsonb_blocked_jsonpath_exists(eql_v3_json_search, jsonpath)`](#jsonb_blocked_jsonpath_existseql_v3_json_search-jsonpath) - Blocker: @? (jsonpath exists).
* [`jsonb_blocked_jsonpath_match(eql_v3_json_search, jsonpath)`](#jsonb_blocked_jsonpath_matcheql_v3_json_search-jsonpath) - Blocker: @ (jsonpath predicate).
* [`jsonb_blocked_path_extract(eql_v3_json_search, text)`](#jsonb_blocked_path_extracteql_v3_json_search-text) - Blocker: #> (path extract, native returns jsonb).
* [`jsonb_blocked_path_extract_text(eql_v3_json_search, text)`](#jsonb_blocked_path_extract_texteql_v3_json_search-text) - Blocker: #>> (path extract as text).
* [`jsonb_entry_max_sfunc(eql_v3_json_entry, eql_v3_json_entry)`](#jsonb_entry_max_sfunceql_v3_json_entry-eql_v3_json_entry) - State function for max on public.eql\_v3\_json\_entry.
* [`jsonb_entry_min_sfunc(eql_v3_json_entry, eql_v3_json_entry)`](#jsonb_entry_min_sfunceql_v3_json_entry-eql_v3_json_entry) - State function for min on public.eql\_v3\_json\_entry.
* [`lt(jsonb, eql_v3_date)`](#ltjsonb-eql_v3_date) - Unsupported operator blocker for public.eql\_v3\_date.
* [`lt(eql_v3_date, jsonb)`](#lteql_v3_date-jsonb) - Unsupported operator blocker for public.eql\_v3\_date.
* [`lt(eql_v3_date, eql_v3_date)`](#lteql_v3_date-eql_v3_date) - Unsupported operator blocker for public.eql\_v3\_date.
* [`lt(jsonb, eql_v3_bigint_eq)`](#ltjsonb-eql_v3_bigint_eq) - Unsupported operator blocker for public.eql\_v3\_bigint\_eq.
* [`lt(eql_v3_bigint_eq, jsonb)`](#lteql_v3_bigint_eq-jsonb) - Unsupported operator blocker for public.eql\_v3\_bigint\_eq.
* [`lt(eql_v3_bigint_eq, eql_v3_bigint_eq)`](#lteql_v3_bigint_eq-eql_v3_bigint_eq) - Unsupported operator blocker for public.eql\_v3\_bigint\_eq.
* [`lt(jsonb, eql_v3_bigint)`](#ltjsonb-eql_v3_bigint) - Unsupported operator blocker for public.eql\_v3\_bigint.
* [`lt(eql_v3_bigint, jsonb)`](#lteql_v3_bigint-jsonb) - Unsupported operator blocker for public.eql\_v3\_bigint.
* [`lt(eql_v3_bigint, eql_v3_bigint)`](#lteql_v3_bigint-eql_v3_bigint) - Unsupported operator blocker for public.eql\_v3\_bigint.
* [`lt(jsonb, eql_v3_numeric)`](#ltjsonb-eql_v3_numeric) - Unsupported operator blocker for public.eql\_v3\_numeric.
* [`lt(eql_v3_numeric, jsonb)`](#lteql_v3_numeric-jsonb) - Unsupported operator blocker for public.eql\_v3\_numeric.
* [`lt(eql_v3_numeric, eql_v3_numeric)`](#lteql_v3_numeric-eql_v3_numeric) - Unsupported operator blocker for public.eql\_v3\_numeric.
* [`lt(jsonb, eql_v3_timestamp_eq)`](#ltjsonb-eql_v3_timestamp_eq) - Unsupported operator blocker for public.eql\_v3\_timestamp\_eq.
* [`lt(eql_v3_timestamp_eq, jsonb)`](#lteql_v3_timestamp_eq-jsonb) - Unsupported operator blocker for public.eql\_v3\_timestamp\_eq.
* [`lt(eql_v3_timestamp_eq, eql_v3_timestamp_eq)`](#lteql_v3_timestamp_eq-eql_v3_timestamp_eq) - Unsupported operator blocker for public.eql\_v3\_timestamp\_eq.
* [`lt(jsonb, eql_v3_json)`](#ltjsonb-eql_v3_json) - Unsupported operator blocker for public.eql\_v3\_json.
* [`lt(eql_v3_json, jsonb)`](#lteql_v3_json-jsonb) - Unsupported operator blocker for public.eql\_v3\_json.
* [`lt(eql_v3_json, eql_v3_json)`](#lteql_v3_json-eql_v3_json) - Unsupported operator blocker for public.eql\_v3\_json.
* [`lt(jsonb, eql_v3_boolean)`](#ltjsonb-eql_v3_boolean) - Unsupported operator blocker for public.eql\_v3\_boolean.
* [`lt(eql_v3_boolean, jsonb)`](#lteql_v3_boolean-jsonb) - Unsupported operator blocker for public.eql\_v3\_boolean.
* [`lt(eql_v3_boolean, eql_v3_boolean)`](#lteql_v3_boolean-eql_v3_boolean) - Unsupported operator blocker for public.eql\_v3\_boolean.
* [`lt(query_date_ord, eql_v3_json_entry)`](#ltquery_date_ord-eql_v3_json_entry) - Unsupported operator blocker for public.eql\_v3\_json\_entry.
* [`lt(eql_v3_json_entry, query_date_ord)`](#lteql_v3_json_entry-query_date_ord) - Unsupported operator blocker for public.eql\_v3\_json\_entry.
* [`lt(jsonb, eql_v3_real)`](#ltjsonb-eql_v3_real) - Unsupported operator blocker for public.eql\_v3\_real.
* [`lt(eql_v3_real, jsonb)`](#lteql_v3_real-jsonb) - Unsupported operator blocker for public.eql\_v3\_real.
* [`lt(eql_v3_real, eql_v3_real)`](#lteql_v3_real-eql_v3_real) - Unsupported operator blocker for public.eql\_v3\_real.
* [`lt(jsonb, eql_v3_real_eq)`](#ltjsonb-eql_v3_real_eq) - Unsupported operator blocker for public.eql\_v3\_real\_eq.
* [`lt(eql_v3_real_eq, jsonb)`](#lteql_v3_real_eq-jsonb) - Unsupported operator blocker for public.eql\_v3\_real\_eq.
* [`lt(eql_v3_real_eq, eql_v3_real_eq)`](#lteql_v3_real_eq-eql_v3_real_eq) - Unsupported operator blocker for public.eql\_v3\_real\_eq.
* [`lt(query_timestamp_ord, eql_v3_json_entry)`](#ltquery_timestamp_ord-eql_v3_json_entry) - Unsupported operator blocker for public.eql\_v3\_json\_entry.
* [`lt(eql_v3_json_entry, query_timestamp_ord)`](#lteql_v3_json_entry-query_timestamp_ord) - Unsupported operator blocker for public.eql\_v3\_json\_entry.
* [`lt(jsonb, eql_v3_text)`](#ltjsonb-eql_v3_text) - Unsupported operator blocker for public.eql\_v3\_text.
* [`lt(eql_v3_text, jsonb)`](#lteql_v3_text-jsonb) - Unsupported operator blocker for public.eql\_v3\_text.
* [`lt(eql_v3_text, eql_v3_text)`](#lteql_v3_text-eql_v3_text) - Unsupported operator blocker for public.eql\_v3\_text.
* [`lt(jsonb, eql_v3_double_eq)`](#ltjsonb-eql_v3_double_eq) - Unsupported operator blocker for public.eql\_v3\_double\_eq.
* [`lt(eql_v3_double_eq, jsonb)`](#lteql_v3_double_eq-jsonb) - Unsupported operator blocker for public.eql\_v3\_double\_eq.
* [`lt(eql_v3_double_eq, eql_v3_double_eq)`](#lteql_v3_double_eq-eql_v3_double_eq) - Unsupported operator blocker for public.eql\_v3\_double\_eq.
* [`lt(jsonb, eql_v3_timestamp)`](#ltjsonb-eql_v3_timestamp) - Unsupported operator blocker for public.eql\_v3\_timestamp.
* [`lt(eql_v3_timestamp, jsonb)`](#lteql_v3_timestamp-jsonb) - Unsupported operator blocker for public.eql\_v3\_timestamp.
* [`lt(eql_v3_timestamp, eql_v3_timestamp)`](#lteql_v3_timestamp-eql_v3_timestamp) - Unsupported operator blocker for public.eql\_v3\_timestamp.
* [`lt(jsonb, eql_v3_numeric_eq)`](#ltjsonb-eql_v3_numeric_eq) - Unsupported operator blocker for public.eql\_v3\_numeric\_eq.
* [`lt(eql_v3_numeric_eq, jsonb)`](#lteql_v3_numeric_eq-jsonb) - Unsupported operator blocker for public.eql\_v3\_numeric\_eq.
* [`lt(eql_v3_numeric_eq, eql_v3_numeric_eq)`](#lteql_v3_numeric_eq-eql_v3_numeric_eq) - Unsupported operator blocker for public.eql\_v3\_numeric\_eq.
* [`lt(jsonb, eql_v3_text_match)`](#ltjsonb-eql_v3_text_match) - Unsupported operator blocker for public.eql\_v3\_text\_match.
* [`lt(eql_v3_text_match, jsonb)`](#lteql_v3_text_match-jsonb) - Unsupported operator blocker for public.eql\_v3\_text\_match.
* [`lt(eql_v3_text_match, eql_v3_text_match)`](#lteql_v3_text_match-eql_v3_text_match) - Unsupported operator blocker for public.eql\_v3\_text\_match.
* [`lt(jsonb, eql_v3_integer)`](#ltjsonb-eql_v3_integer) - Unsupported operator blocker for public.eql\_v3\_integer.
* [`lt(eql_v3_integer, jsonb)`](#lteql_v3_integer-jsonb) - Unsupported operator blocker for public.eql\_v3\_integer.
* [`lt(eql_v3_integer, eql_v3_integer)`](#lteql_v3_integer-eql_v3_integer) - Unsupported operator blocker for public.eql\_v3\_integer.
* [`lt(jsonb, eql_v3_double)`](#ltjsonb-eql_v3_double) - Unsupported operator blocker for public.eql\_v3\_double.
* [`lt(eql_v3_double, jsonb)`](#lteql_v3_double-jsonb) - Unsupported operator blocker for public.eql\_v3\_double.
* [`lt(eql_v3_double, eql_v3_double)`](#lteql_v3_double-eql_v3_double) - Unsupported operator blocker for public.eql\_v3\_double.
* [`lt(jsonb, eql_v3_smallint_eq)`](#ltjsonb-eql_v3_smallint_eq) - Unsupported operator blocker for public.eql\_v3\_smallint\_eq.
* [`lt(eql_v3_smallint_eq, jsonb)`](#lteql_v3_smallint_eq-jsonb) - Unsupported operator blocker for public.eql\_v3\_smallint\_eq.
* [`lt(eql_v3_smallint_eq, eql_v3_smallint_eq)`](#lteql_v3_smallint_eq-eql_v3_smallint_eq) - Unsupported operator blocker for public.eql\_v3\_smallint\_eq.
* [`lt(jsonb, eql_v3_date_eq)`](#ltjsonb-eql_v3_date_eq) - Unsupported operator blocker for public.eql\_v3\_date\_eq.
* [`lt(eql_v3_date_eq, jsonb)`](#lteql_v3_date_eq-jsonb) - Unsupported operator blocker for public.eql\_v3\_date\_eq.
* [`lt(eql_v3_date_eq, eql_v3_date_eq)`](#lteql_v3_date_eq-eql_v3_date_eq) - Unsupported operator blocker for public.eql\_v3\_date\_eq.
* [`lt(jsonb, eql_v3_text_eq)`](#ltjsonb-eql_v3_text_eq) - Unsupported operator blocker for public.eql\_v3\_text\_eq.
* [`lt(eql_v3_text_eq, jsonb)`](#lteql_v3_text_eq-jsonb) - Unsupported operator blocker for public.eql\_v3\_text\_eq.
* [`lt(eql_v3_text_eq, eql_v3_text_eq)`](#lteql_v3_text_eq-eql_v3_text_eq) - Unsupported operator blocker for public.eql\_v3\_text\_eq.
* [`lt(jsonb, eql_v3_integer_eq)`](#ltjsonb-eql_v3_integer_eq) - Unsupported operator blocker for public.eql\_v3\_integer\_eq.
* [`lt(eql_v3_integer_eq, jsonb)`](#lteql_v3_integer_eq-jsonb) - Unsupported operator blocker for public.eql\_v3\_integer\_eq.
* [`lt(eql_v3_integer_eq, eql_v3_integer_eq)`](#lteql_v3_integer_eq-eql_v3_integer_eq) - Unsupported operator blocker for public.eql\_v3\_integer\_eq.
* [`lt(jsonb, eql_v3_smallint)`](#ltjsonb-eql_v3_smallint) - Unsupported operator blocker for public.eql\_v3\_smallint.
* [`lt(eql_v3_smallint, jsonb)`](#lteql_v3_smallint-jsonb) - Unsupported operator blocker for public.eql\_v3\_smallint.
* [`lt(eql_v3_smallint, eql_v3_smallint)`](#lteql_v3_smallint-eql_v3_smallint) - Unsupported operator blocker for public.eql\_v3\_smallint.
* [`lte(jsonb, eql_v3_date)`](#ltejsonb-eql_v3_date) - Unsupported operator blocker for public.eql\_v3\_date.
* [`lte(eql_v3_date, jsonb)`](#lteeql_v3_date-jsonb) - Unsupported operator blocker for public.eql\_v3\_date.
* [`lte(eql_v3_date, eql_v3_date)`](#lteeql_v3_date-eql_v3_date) - Unsupported operator blocker for public.eql\_v3\_date.
* [`lte(jsonb, eql_v3_bigint_eq)`](#ltejsonb-eql_v3_bigint_eq) - Unsupported operator blocker for public.eql\_v3\_bigint\_eq.
* [`lte(eql_v3_bigint_eq, jsonb)`](#lteeql_v3_bigint_eq-jsonb) - Unsupported operator blocker for public.eql\_v3\_bigint\_eq.
* [`lte(eql_v3_bigint_eq, eql_v3_bigint_eq)`](#lteeql_v3_bigint_eq-eql_v3_bigint_eq) - Unsupported operator blocker for public.eql\_v3\_bigint\_eq.
* [`lte(jsonb, eql_v3_bigint)`](#ltejsonb-eql_v3_bigint) - Unsupported operator blocker for public.eql\_v3\_bigint.
* [`lte(eql_v3_bigint, jsonb)`](#lteeql_v3_bigint-jsonb) - Unsupported operator blocker for public.eql\_v3\_bigint.
* [`lte(eql_v3_bigint, eql_v3_bigint)`](#lteeql_v3_bigint-eql_v3_bigint) - Unsupported operator blocker for public.eql\_v3\_bigint.
* [`lte(jsonb, eql_v3_numeric)`](#ltejsonb-eql_v3_numeric) - Unsupported operator blocker for public.eql\_v3\_numeric.
* [`lte(eql_v3_numeric, jsonb)`](#lteeql_v3_numeric-jsonb) - Unsupported operator blocker for public.eql\_v3\_numeric.
* [`lte(eql_v3_numeric, eql_v3_numeric)`](#lteeql_v3_numeric-eql_v3_numeric) - Unsupported operator blocker for public.eql\_v3\_numeric.
* [`lte(jsonb, eql_v3_timestamp_eq)`](#ltejsonb-eql_v3_timestamp_eq) - Unsupported operator blocker for public.eql\_v3\_timestamp\_eq.
* [`lte(eql_v3_timestamp_eq, jsonb)`](#lteeql_v3_timestamp_eq-jsonb) - Unsupported operator blocker for public.eql\_v3\_timestamp\_eq.
* [`lte(eql_v3_timestamp_eq, eql_v3_timestamp_eq)`](#lteeql_v3_timestamp_eq-eql_v3_timestamp_eq) - Unsupported operator blocker for public.eql\_v3\_timestamp\_eq.
* [`lte(jsonb, eql_v3_json)`](#ltejsonb-eql_v3_json) - Unsupported operator blocker for public.eql\_v3\_json.
* [`lte(eql_v3_json, jsonb)`](#lteeql_v3_json-jsonb) - Unsupported operator blocker for public.eql\_v3\_json.
* [`lte(eql_v3_json, eql_v3_json)`](#lteeql_v3_json-eql_v3_json) - Unsupported operator blocker for public.eql\_v3\_json.
* [`lte(jsonb, eql_v3_boolean)`](#ltejsonb-eql_v3_boolean) - Unsupported operator blocker for public.eql\_v3\_boolean.
* [`lte(eql_v3_boolean, jsonb)`](#lteeql_v3_boolean-jsonb) - Unsupported operator blocker for public.eql\_v3\_boolean.
* [`lte(eql_v3_boolean, eql_v3_boolean)`](#lteeql_v3_boolean-eql_v3_boolean) - Unsupported operator blocker for public.eql\_v3\_boolean.
* [`lte(query_date_ord, eql_v3_json_entry)`](#ltequery_date_ord-eql_v3_json_entry) - Unsupported operator blocker for public.eql\_v3\_json\_entry.
* [`lte(eql_v3_json_entry, query_date_ord)`](#lteeql_v3_json_entry-query_date_ord) - Unsupported operator blocker for public.eql\_v3\_json\_entry.
* [`lte(jsonb, eql_v3_real)`](#ltejsonb-eql_v3_real) - Unsupported operator blocker for public.eql\_v3\_real.
* [`lte(eql_v3_real, jsonb)`](#lteeql_v3_real-jsonb) - Unsupported operator blocker for public.eql\_v3\_real.
* [`lte(eql_v3_real, eql_v3_real)`](#lteeql_v3_real-eql_v3_real) - Unsupported operator blocker for public.eql\_v3\_real.
* [`lte(jsonb, eql_v3_real_eq)`](#ltejsonb-eql_v3_real_eq) - Unsupported operator blocker for public.eql\_v3\_real\_eq.
* [`lte(eql_v3_real_eq, jsonb)`](#lteeql_v3_real_eq-jsonb) - Unsupported operator blocker for public.eql\_v3\_real\_eq.
* [`lte(eql_v3_real_eq, eql_v3_real_eq)`](#lteeql_v3_real_eq-eql_v3_real_eq) - Unsupported operator blocker for public.eql\_v3\_real\_eq.
* [`lte(query_timestamp_ord, eql_v3_json_entry)`](#ltequery_timestamp_ord-eql_v3_json_entry) - Unsupported operator blocker for public.eql\_v3\_json\_entry.
* [`lte(eql_v3_json_entry, query_timestamp_ord)`](#lteeql_v3_json_entry-query_timestamp_ord) - Unsupported operator blocker for public.eql\_v3\_json\_entry.
* [`lte(jsonb, eql_v3_text)`](#ltejsonb-eql_v3_text) - Unsupported operator blocker for public.eql\_v3\_text.
* [`lte(eql_v3_text, jsonb)`](#lteeql_v3_text-jsonb) - Unsupported operator blocker for public.eql\_v3\_text.
* [`lte(eql_v3_text, eql_v3_text)`](#lteeql_v3_text-eql_v3_text) - Unsupported operator blocker for public.eql\_v3\_text.
* [`lte(jsonb, eql_v3_double_eq)`](#ltejsonb-eql_v3_double_eq) - Unsupported operator blocker for public.eql\_v3\_double\_eq.
* [`lte(eql_v3_double_eq, jsonb)`](#lteeql_v3_double_eq-jsonb) - Unsupported operator blocker for public.eql\_v3\_double\_eq.
* [`lte(eql_v3_double_eq, eql_v3_double_eq)`](#lteeql_v3_double_eq-eql_v3_double_eq) - Unsupported operator blocker for public.eql\_v3\_double\_eq.
* [`lte(jsonb, eql_v3_timestamp)`](#ltejsonb-eql_v3_timestamp) - Unsupported operator blocker for public.eql\_v3\_timestamp.
* [`lte(eql_v3_timestamp, jsonb)`](#lteeql_v3_timestamp-jsonb) - Unsupported operator blocker for public.eql\_v3\_timestamp.
* [`lte(eql_v3_timestamp, eql_v3_timestamp)`](#lteeql_v3_timestamp-eql_v3_timestamp) - Unsupported operator blocker for public.eql\_v3\_timestamp.
* [`lte(jsonb, eql_v3_numeric_eq)`](#ltejsonb-eql_v3_numeric_eq) - Unsupported operator blocker for public.eql\_v3\_numeric\_eq.
* [`lte(eql_v3_numeric_eq, jsonb)`](#lteeql_v3_numeric_eq-jsonb) - Unsupported operator blocker for public.eql\_v3\_numeric\_eq.
* [`lte(eql_v3_numeric_eq, eql_v3_numeric_eq)`](#lteeql_v3_numeric_eq-eql_v3_numeric_eq) - Unsupported operator blocker for public.eql\_v3\_numeric\_eq.
* [`lte(jsonb, eql_v3_text_match)`](#ltejsonb-eql_v3_text_match) - Unsupported operator blocker for public.eql\_v3\_text\_match.
* [`lte(eql_v3_text_match, jsonb)`](#lteeql_v3_text_match-jsonb) - Unsupported operator blocker for public.eql\_v3\_text\_match.
* [`lte(eql_v3_text_match, eql_v3_text_match)`](#lteeql_v3_text_match-eql_v3_text_match) - Unsupported operator blocker for public.eql\_v3\_text\_match.
* [`lte(jsonb, eql_v3_integer)`](#ltejsonb-eql_v3_integer) - Unsupported operator blocker for public.eql\_v3\_integer.
* [`lte(eql_v3_integer, jsonb)`](#lteeql_v3_integer-jsonb) - Unsupported operator blocker for public.eql\_v3\_integer.
* [`lte(eql_v3_integer, eql_v3_integer)`](#lteeql_v3_integer-eql_v3_integer) - Unsupported operator blocker for public.eql\_v3\_integer.
* [`lte(jsonb, eql_v3_double)`](#ltejsonb-eql_v3_double) - Unsupported operator blocker for public.eql\_v3\_double.
* [`lte(eql_v3_double, jsonb)`](#lteeql_v3_double-jsonb) - Unsupported operator blocker for public.eql\_v3\_double.
* [`lte(eql_v3_double, eql_v3_double)`](#lteeql_v3_double-eql_v3_double) - Unsupported operator blocker for public.eql\_v3\_double.
* [`lte(jsonb, eql_v3_smallint_eq)`](#ltejsonb-eql_v3_smallint_eq) - Unsupported operator blocker for public.eql\_v3\_smallint\_eq.
* [`lte(eql_v3_smallint_eq, jsonb)`](#lteeql_v3_smallint_eq-jsonb) - Unsupported operator blocker for public.eql\_v3\_smallint\_eq.
* [`lte(eql_v3_smallint_eq, eql_v3_smallint_eq)`](#lteeql_v3_smallint_eq-eql_v3_smallint_eq) - Unsupported operator blocker for public.eql\_v3\_smallint\_eq.
* [`lte(jsonb, eql_v3_date_eq)`](#ltejsonb-eql_v3_date_eq) - Unsupported operator blocker for public.eql\_v3\_date\_eq.
* [`lte(eql_v3_date_eq, jsonb)`](#lteeql_v3_date_eq-jsonb) - Unsupported operator blocker for public.eql\_v3\_date\_eq.
* [`lte(eql_v3_date_eq, eql_v3_date_eq)`](#lteeql_v3_date_eq-eql_v3_date_eq) - Unsupported operator blocker for public.eql\_v3\_date\_eq.
* [`lte(jsonb, eql_v3_text_eq)`](#ltejsonb-eql_v3_text_eq) - Unsupported operator blocker for public.eql\_v3\_text\_eq.
* [`lte(eql_v3_text_eq, jsonb)`](#lteeql_v3_text_eq-jsonb) - Unsupported operator blocker for public.eql\_v3\_text\_eq.
* [`lte(eql_v3_text_eq, eql_v3_text_eq)`](#lteeql_v3_text_eq-eql_v3_text_eq) - Unsupported operator blocker for public.eql\_v3\_text\_eq.
* [`lte(jsonb, eql_v3_integer_eq)`](#ltejsonb-eql_v3_integer_eq) - Unsupported operator blocker for public.eql\_v3\_integer\_eq.
* [`lte(eql_v3_integer_eq, jsonb)`](#lteeql_v3_integer_eq-jsonb) - Unsupported operator blocker for public.eql\_v3\_integer\_eq.
* [`lte(eql_v3_integer_eq, eql_v3_integer_eq)`](#lteeql_v3_integer_eq-eql_v3_integer_eq) - Unsupported operator blocker for public.eql\_v3\_integer\_eq.
* [`lte(jsonb, eql_v3_smallint)`](#ltejsonb-eql_v3_smallint) - Unsupported operator blocker for public.eql\_v3\_smallint.
* [`lte(eql_v3_smallint, jsonb)`](#lteeql_v3_smallint-jsonb) - Unsupported operator blocker for public.eql\_v3\_smallint.
* [`lte(eql_v3_smallint, eql_v3_smallint)`](#lteeql_v3_smallint-eql_v3_smallint) - Unsupported operator blocker for public.eql\_v3\_smallint.
* [`max_sfunc(eql_v3_bigint_ord_ope, eql_v3_bigint_ord_ope)`](#max_sfunceql_v3_bigint_ord_ope-eql_v3_bigint_ord_ope) - State function for max on public.eql\_v3\_bigint\_ord\_ope.
* [`max_sfunc(eql_v3_smallint_ord_ope, eql_v3_smallint_ord_ope)`](#max_sfunceql_v3_smallint_ord_ope-eql_v3_smallint_ord_ope) - State function for max on public.eql\_v3\_smallint\_ord\_ope.
* [`max_sfunc(eql_v3_numeric_ord, eql_v3_numeric_ord)`](#max_sfunceql_v3_numeric_ord-eql_v3_numeric_ord) - State function for max on public.eql\_v3\_numeric\_ord.
* [`max_sfunc(eql_v3_real_ord_ore, eql_v3_real_ord_ore)`](#max_sfunceql_v3_real_ord_ore-eql_v3_real_ord_ore) - State function for max on public.eql\_v3\_real\_ord\_ore.
* [`max_sfunc(eql_v3_timestamp_ord_ore, eql_v3_timestamp_ord_ore)`](#max_sfunceql_v3_timestamp_ord_ore-eql_v3_timestamp_ord_ore) - State function for max on public.eql\_v3\_timestamp\_ord\_ore.
* [`max_sfunc(eql_v3_real_ord_ope, eql_v3_real_ord_ope)`](#max_sfunceql_v3_real_ord_ope-eql_v3_real_ord_ope) - State function for max on public.eql\_v3\_real\_ord\_ope.
* [`max_sfunc(eql_v3_text_ord_ope, eql_v3_text_ord_ope)`](#max_sfunceql_v3_text_ord_ope-eql_v3_text_ord_ope) - State function for max on public.eql\_v3\_text\_ord\_ope.
* [`max_sfunc(eql_v3_double_ord_ope, eql_v3_double_ord_ope)`](#max_sfunceql_v3_double_ord_ope-eql_v3_double_ord_ope) - State function for max on public.eql\_v3\_double\_ord\_ope.
* [`max_sfunc(eql_v3_date_ord_ore, eql_v3_date_ord_ore)`](#max_sfunceql_v3_date_ord_ore-eql_v3_date_ord_ore) - State function for max on public.eql\_v3\_date\_ord\_ore.
* [`max_sfunc(eql_v3_integer_ord_ore, eql_v3_integer_ord_ore)`](#max_sfunceql_v3_integer_ord_ore-eql_v3_integer_ord_ore) - State function for max on public.eql\_v3\_integer\_ord\_ore.
* [`max_sfunc(eql_v3_bigint_ord, eql_v3_bigint_ord)`](#max_sfunceql_v3_bigint_ord-eql_v3_bigint_ord) - State function for max on public.eql\_v3\_bigint\_ord.
* [`max_sfunc(eql_v3_numeric_ord_ope, eql_v3_numeric_ord_ope)`](#max_sfunceql_v3_numeric_ord_ope-eql_v3_numeric_ord_ope) - State function for max on public.eql\_v3\_numeric\_ord\_ope.
* [`max_sfunc(eql_v3_numeric_ord_ore, eql_v3_numeric_ord_ore)`](#max_sfunceql_v3_numeric_ord_ore-eql_v3_numeric_ord_ore) - State function for max on public.eql\_v3\_numeric\_ord\_ore.
* [`max_sfunc(eql_v3_real_ord, eql_v3_real_ord)`](#max_sfunceql_v3_real_ord-eql_v3_real_ord) - State function for max on public.eql\_v3\_real\_ord.
* [`max_sfunc(eql_v3_timestamp_ord_ope, eql_v3_timestamp_ord_ope)`](#max_sfunceql_v3_timestamp_ord_ope-eql_v3_timestamp_ord_ope) - State function for max on public.eql\_v3\_timestamp\_ord\_ope.
* [`max_sfunc(eql_v3_smallint_ord, eql_v3_smallint_ord)`](#max_sfunceql_v3_smallint_ord-eql_v3_smallint_ord) - State function for max on public.eql\_v3\_smallint\_ord.
* [`max_sfunc(eql_v3_text_search_ore, eql_v3_text_search_ore)`](#max_sfunceql_v3_text_search_ore-eql_v3_text_search_ore) - State function for max on public.eql\_v3\_text\_search\_ore.
* [`max_sfunc(eql_v3_integer_ord, eql_v3_integer_ord)`](#max_sfunceql_v3_integer_ord-eql_v3_integer_ord) - State function for max on public.eql\_v3\_integer\_ord.
* [`max_sfunc(eql_v3_integer_ord_ope, eql_v3_integer_ord_ope)`](#max_sfunceql_v3_integer_ord_ope-eql_v3_integer_ord_ope) - State function for max on public.eql\_v3\_integer\_ord\_ope.
* [`max_sfunc(eql_v3_smallint_ord_ore, eql_v3_smallint_ord_ore)`](#max_sfunceql_v3_smallint_ord_ore-eql_v3_smallint_ord_ore) - State function for max on public.eql\_v3\_smallint\_ord\_ore.
* [`max_sfunc(eql_v3_date_ord, eql_v3_date_ord)`](#max_sfunceql_v3_date_ord-eql_v3_date_ord) - State function for max on public.eql\_v3\_date\_ord.
* [`max_sfunc(eql_v3_text_ord_ore, eql_v3_text_ord_ore)`](#max_sfunceql_v3_text_ord_ore-eql_v3_text_ord_ore) - State function for max on public.eql\_v3\_text\_ord\_ore.
* [`max_sfunc(eql_v3_double_ord_ore, eql_v3_double_ord_ore)`](#max_sfunceql_v3_double_ord_ore-eql_v3_double_ord_ore) - State function for max on public.eql\_v3\_double\_ord\_ore.
* [`max_sfunc(eql_v3_timestamp_ord, eql_v3_timestamp_ord)`](#max_sfunceql_v3_timestamp_ord-eql_v3_timestamp_ord) - State function for max on public.eql\_v3\_timestamp\_ord.
* [`max_sfunc(eql_v3_text_ord, eql_v3_text_ord)`](#max_sfunceql_v3_text_ord-eql_v3_text_ord) - State function for max on public.eql\_v3\_text\_ord.
* [`max_sfunc(eql_v3_bigint_ord_ore, eql_v3_bigint_ord_ore)`](#max_sfunceql_v3_bigint_ord_ore-eql_v3_bigint_ord_ore) - State function for max on public.eql\_v3\_bigint\_ord\_ore.
* [`max_sfunc(eql_v3_text_search, eql_v3_text_search)`](#max_sfunceql_v3_text_search-eql_v3_text_search) - State function for max on public.eql\_v3\_text\_search.
* [`max_sfunc(eql_v3_double_ord, eql_v3_double_ord)`](#max_sfunceql_v3_double_ord-eql_v3_double_ord) - State function for max on public.eql\_v3\_double\_ord.
* [`max_sfunc(eql_v3_date_ord_ope, eql_v3_date_ord_ope)`](#max_sfunceql_v3_date_ord_ope-eql_v3_date_ord_ope) - State function for max on public.eql\_v3\_date\_ord\_ope.
* [`min_sfunc(eql_v3_bigint_ord_ope, eql_v3_bigint_ord_ope)`](#min_sfunceql_v3_bigint_ord_ope-eql_v3_bigint_ord_ope) - State function for min on public.eql\_v3\_bigint\_ord\_ope.
* [`min_sfunc(eql_v3_smallint_ord_ope, eql_v3_smallint_ord_ope)`](#min_sfunceql_v3_smallint_ord_ope-eql_v3_smallint_ord_ope) - State function for min on public.eql\_v3\_smallint\_ord\_ope.
* [`min_sfunc(eql_v3_numeric_ord, eql_v3_numeric_ord)`](#min_sfunceql_v3_numeric_ord-eql_v3_numeric_ord) - State function for min on public.eql\_v3\_numeric\_ord.
* [`min_sfunc(eql_v3_real_ord_ore, eql_v3_real_ord_ore)`](#min_sfunceql_v3_real_ord_ore-eql_v3_real_ord_ore) - State function for min on public.eql\_v3\_real\_ord\_ore.
* [`min_sfunc(eql_v3_timestamp_ord_ore, eql_v3_timestamp_ord_ore)`](#min_sfunceql_v3_timestamp_ord_ore-eql_v3_timestamp_ord_ore) - State function for min on public.eql\_v3\_timestamp\_ord\_ore.
* [`min_sfunc(eql_v3_real_ord_ope, eql_v3_real_ord_ope)`](#min_sfunceql_v3_real_ord_ope-eql_v3_real_ord_ope) - State function for min on public.eql\_v3\_real\_ord\_ope.
* [`min_sfunc(eql_v3_text_ord_ope, eql_v3_text_ord_ope)`](#min_sfunceql_v3_text_ord_ope-eql_v3_text_ord_ope) - State function for min on public.eql\_v3\_text\_ord\_ope.
* [`min_sfunc(eql_v3_double_ord_ope, eql_v3_double_ord_ope)`](#min_sfunceql_v3_double_ord_ope-eql_v3_double_ord_ope) - State function for min on public.eql\_v3\_double\_ord\_ope.
* [`min_sfunc(eql_v3_date_ord_ore, eql_v3_date_ord_ore)`](#min_sfunceql_v3_date_ord_ore-eql_v3_date_ord_ore) - State function for min on public.eql\_v3\_date\_ord\_ore.
* [`min_sfunc(eql_v3_integer_ord_ore, eql_v3_integer_ord_ore)`](#min_sfunceql_v3_integer_ord_ore-eql_v3_integer_ord_ore) - State function for min on public.eql\_v3\_integer\_ord\_ore.
* [`min_sfunc(eql_v3_bigint_ord, eql_v3_bigint_ord)`](#min_sfunceql_v3_bigint_ord-eql_v3_bigint_ord) - State function for min on public.eql\_v3\_bigint\_ord.
* [`min_sfunc(eql_v3_numeric_ord_ope, eql_v3_numeric_ord_ope)`](#min_sfunceql_v3_numeric_ord_ope-eql_v3_numeric_ord_ope) - State function for min on public.eql\_v3\_numeric\_ord\_ope.
* [`min_sfunc(eql_v3_numeric_ord_ore, eql_v3_numeric_ord_ore)`](#min_sfunceql_v3_numeric_ord_ore-eql_v3_numeric_ord_ore) - State function for min on public.eql\_v3\_numeric\_ord\_ore.
* [`min_sfunc(eql_v3_real_ord, eql_v3_real_ord)`](#min_sfunceql_v3_real_ord-eql_v3_real_ord) - State function for min on public.eql\_v3\_real\_ord.
* [`min_sfunc(eql_v3_timestamp_ord_ope, eql_v3_timestamp_ord_ope)`](#min_sfunceql_v3_timestamp_ord_ope-eql_v3_timestamp_ord_ope) - State function for min on public.eql\_v3\_timestamp\_ord\_ope.
* [`min_sfunc(eql_v3_smallint_ord, eql_v3_smallint_ord)`](#min_sfunceql_v3_smallint_ord-eql_v3_smallint_ord) - State function for min on public.eql\_v3\_smallint\_ord.
* [`min_sfunc(eql_v3_text_search_ore, eql_v3_text_search_ore)`](#min_sfunceql_v3_text_search_ore-eql_v3_text_search_ore) - State function for min on public.eql\_v3\_text\_search\_ore.
* [`min_sfunc(eql_v3_integer_ord, eql_v3_integer_ord)`](#min_sfunceql_v3_integer_ord-eql_v3_integer_ord) - State function for min on public.eql\_v3\_integer\_ord.
* [`min_sfunc(eql_v3_integer_ord_ope, eql_v3_integer_ord_ope)`](#min_sfunceql_v3_integer_ord_ope-eql_v3_integer_ord_ope) - State function for min on public.eql\_v3\_integer\_ord\_ope.
* [`min_sfunc(eql_v3_smallint_ord_ore, eql_v3_smallint_ord_ore)`](#min_sfunceql_v3_smallint_ord_ore-eql_v3_smallint_ord_ore) - State function for min on public.eql\_v3\_smallint\_ord\_ore.
* [`min_sfunc(eql_v3_date_ord, eql_v3_date_ord)`](#min_sfunceql_v3_date_ord-eql_v3_date_ord) - State function for min on public.eql\_v3\_date\_ord.
* [`min_sfunc(eql_v3_text_ord_ore, eql_v3_text_ord_ore)`](#min_sfunceql_v3_text_ord_ore-eql_v3_text_ord_ore) - State function for min on public.eql\_v3\_text\_ord\_ore.
* [`min_sfunc(eql_v3_double_ord_ore, eql_v3_double_ord_ore)`](#min_sfunceql_v3_double_ord_ore-eql_v3_double_ord_ore) - State function for min on public.eql\_v3\_double\_ord\_ore.
* [`min_sfunc(eql_v3_timestamp_ord, eql_v3_timestamp_ord)`](#min_sfunceql_v3_timestamp_ord-eql_v3_timestamp_ord) - State function for min on public.eql\_v3\_timestamp\_ord.
* [`min_sfunc(eql_v3_text_ord, eql_v3_text_ord)`](#min_sfunceql_v3_text_ord-eql_v3_text_ord) - State function for min on public.eql\_v3\_text\_ord.
* [`min_sfunc(eql_v3_bigint_ord_ore, eql_v3_bigint_ord_ore)`](#min_sfunceql_v3_bigint_ord_ore-eql_v3_bigint_ord_ore) - State function for min on public.eql\_v3\_bigint\_ord\_ore.
* [`min_sfunc(eql_v3_text_search, eql_v3_text_search)`](#min_sfunceql_v3_text_search-eql_v3_text_search) - State function for min on public.eql\_v3\_text\_search.
* [`min_sfunc(eql_v3_double_ord, eql_v3_double_ord)`](#min_sfunceql_v3_double_ord-eql_v3_double_ord) - State function for min on public.eql\_v3\_double\_ord.
* [`min_sfunc(eql_v3_date_ord_ope, eql_v3_date_ord_ope)`](#min_sfunceql_v3_date_ord_ope-eql_v3_date_ord_ope) - State function for min on public.eql\_v3\_date\_ord\_ope.
* [`neq(jsonb, eql_v3_date)`](#neqjsonb-eql_v3_date) - Unsupported operator blocker for public.eql\_v3\_date.
* [`neq(eql_v3_date, jsonb)`](#neqeql_v3_date-jsonb) - Unsupported operator blocker for public.eql\_v3\_date.
* [`neq(eql_v3_date, eql_v3_date)`](#neqeql_v3_date-eql_v3_date) - Unsupported operator blocker for public.eql\_v3\_date.
* [`neq(query_double_ord, eql_v3_json_entry)`](#neqquery_double_ord-eql_v3_json_entry) - Unsupported operator blocker for public.eql\_v3\_json\_entry.
* [`neq(eql_v3_json_entry, query_double_ord)`](#neqeql_v3_json_entry-query_double_ord) - Unsupported operator blocker for public.eql\_v3\_json\_entry.
* [`neq(query_smallint_ord, eql_v3_json_entry)`](#neqquery_smallint_ord-eql_v3_json_entry) - Unsupported operator blocker for public.eql\_v3\_json\_entry.
* [`neq(eql_v3_json_entry, query_smallint_ord)`](#neqeql_v3_json_entry-query_smallint_ord) - Unsupported operator blocker for public.eql\_v3\_json\_entry.
* [`neq(jsonb, eql_v3_bigint)`](#neqjsonb-eql_v3_bigint) - Unsupported operator blocker for public.eql\_v3\_bigint.
* [`neq(eql_v3_bigint, jsonb)`](#neqeql_v3_bigint-jsonb) - Unsupported operator blocker for public.eql\_v3\_bigint.
* [`neq(eql_v3_bigint, eql_v3_bigint)`](#neqeql_v3_bigint-eql_v3_bigint) - Unsupported operator blocker for public.eql\_v3\_bigint.
* [`neq(jsonb, eql_v3_numeric)`](#neqjsonb-eql_v3_numeric) - Unsupported operator blocker for public.eql\_v3\_numeric.
* [`neq(eql_v3_numeric, jsonb)`](#neqeql_v3_numeric-jsonb) - Unsupported operator blocker for public.eql\_v3\_numeric.
* [`neq(eql_v3_numeric, eql_v3_numeric)`](#neqeql_v3_numeric-eql_v3_numeric) - Unsupported operator blocker for public.eql\_v3\_numeric.
* [`neq(jsonb, eql_v3_json)`](#neqjsonb-eql_v3_json) - Unsupported operator blocker for public.eql\_v3\_json.
* [`neq(eql_v3_json, jsonb)`](#neqeql_v3_json-jsonb) - Unsupported operator blocker for public.eql\_v3\_json.
* [`neq(eql_v3_json, eql_v3_json)`](#neqeql_v3_json-eql_v3_json) - Unsupported operator blocker for public.eql\_v3\_json.
* [`neq(jsonb, eql_v3_boolean)`](#neqjsonb-eql_v3_boolean) - Unsupported operator blocker for public.eql\_v3\_boolean.
* [`neq(eql_v3_boolean, jsonb)`](#neqeql_v3_boolean-jsonb) - Unsupported operator blocker for public.eql\_v3\_boolean.
* [`neq(eql_v3_boolean, eql_v3_boolean)`](#neqeql_v3_boolean-eql_v3_boolean) - Unsupported operator blocker for public.eql\_v3\_boolean.
* [`neq(query_date_ord, eql_v3_json_entry)`](#neqquery_date_ord-eql_v3_json_entry) - Unsupported operator blocker for public.eql\_v3\_json\_entry.
* [`neq(eql_v3_json_entry, query_date_ord)`](#neqeql_v3_json_entry-query_date_ord) - Unsupported operator blocker for public.eql\_v3\_json\_entry.
* [`neq(jsonb, eql_v3_real)`](#neqjsonb-eql_v3_real) - Unsupported operator blocker for public.eql\_v3\_real.
* [`neq(eql_v3_real, jsonb)`](#neqeql_v3_real-jsonb) - Unsupported operator blocker for public.eql\_v3\_real.
* [`neq(eql_v3_real, eql_v3_real)`](#neqeql_v3_real-eql_v3_real) - Unsupported operator blocker for public.eql\_v3\_real.
* [`neq(query_timestamp_ord, eql_v3_json_entry)`](#neqquery_timestamp_ord-eql_v3_json_entry) - Unsupported operator blocker for public.eql\_v3\_json\_entry.
* [`neq(eql_v3_json_entry, query_timestamp_ord)`](#neqeql_v3_json_entry-query_timestamp_ord) - Unsupported operator blocker for public.eql\_v3\_json\_entry.
* [`neq(jsonb, eql_v3_text)`](#neqjsonb-eql_v3_text) - Unsupported operator blocker for public.eql\_v3\_text.
* [`neq(eql_v3_text, jsonb)`](#neqeql_v3_text-jsonb) - Unsupported operator blocker for public.eql\_v3\_text.
* [`neq(eql_v3_text, eql_v3_text)`](#neqeql_v3_text-eql_v3_text) - Unsupported operator blocker for public.eql\_v3\_text.
* [`neq(query_numeric_ord, eql_v3_json_entry)`](#neqquery_numeric_ord-eql_v3_json_entry) - Unsupported operator blocker for public.eql\_v3\_json\_entry.
* [`neq(eql_v3_json_entry, query_numeric_ord)`](#neqeql_v3_json_entry-query_numeric_ord) - Unsupported operator blocker for public.eql\_v3\_json\_entry.
* [`neq(jsonb, eql_v3_timestamp)`](#neqjsonb-eql_v3_timestamp) - Unsupported operator blocker for public.eql\_v3\_timestamp.
* [`neq(eql_v3_timestamp, jsonb)`](#neqeql_v3_timestamp-jsonb) - Unsupported operator blocker for public.eql\_v3\_timestamp.
* [`neq(eql_v3_timestamp, eql_v3_timestamp)`](#neqeql_v3_timestamp-eql_v3_timestamp) - Unsupported operator blocker for public.eql\_v3\_timestamp.
* [`neq(query_text_ord, eql_v3_json_entry)`](#neqquery_text_ord-eql_v3_json_entry) - Unsupported operator blocker for public.eql\_v3\_json\_entry.
* [`neq(eql_v3_json_entry, query_text_ord)`](#neqeql_v3_json_entry-query_text_ord) - Unsupported operator blocker for public.eql\_v3\_json\_entry.
* [`neq(jsonb, eql_v3_text_match)`](#neqjsonb-eql_v3_text_match) - Unsupported operator blocker for public.eql\_v3\_text\_match.
* [`neq(eql_v3_text_match, jsonb)`](#neqeql_v3_text_match-jsonb) - Unsupported operator blocker for public.eql\_v3\_text\_match.
* [`neq(eql_v3_text_match, eql_v3_text_match)`](#neqeql_v3_text_match-eql_v3_text_match) - Unsupported operator blocker for public.eql\_v3\_text\_match.
* [`neq(query_integer_ord, eql_v3_json_entry)`](#neqquery_integer_ord-eql_v3_json_entry) - Unsupported operator blocker for public.eql\_v3\_json\_entry.
* [`neq(eql_v3_json_entry, query_integer_ord)`](#neqeql_v3_json_entry-query_integer_ord) - Unsupported operator blocker for public.eql\_v3\_json\_entry.
* [`neq(jsonb, eql_v3_integer)`](#neqjsonb-eql_v3_integer) - Unsupported operator blocker for public.eql\_v3\_integer.
* [`neq(eql_v3_integer, jsonb)`](#neqeql_v3_integer-jsonb) - Unsupported operator blocker for public.eql\_v3\_integer.
* [`neq(eql_v3_integer, eql_v3_integer)`](#neqeql_v3_integer-eql_v3_integer) - Unsupported operator blocker for public.eql\_v3\_integer.
* [`neq(query_real_ord, eql_v3_json_entry)`](#neqquery_real_ord-eql_v3_json_entry) - Unsupported operator blocker for public.eql\_v3\_json\_entry.
* [`neq(eql_v3_json_entry, query_real_ord)`](#neqeql_v3_json_entry-query_real_ord) - Unsupported operator blocker for public.eql\_v3\_json\_entry.
* [`neq(jsonb, eql_v3_double)`](#neqjsonb-eql_v3_double) - Unsupported operator blocker for public.eql\_v3\_double.
* [`neq(eql_v3_double, jsonb)`](#neqeql_v3_double-jsonb) - Unsupported operator blocker for public.eql\_v3\_double.
* [`neq(eql_v3_double, eql_v3_double)`](#neqeql_v3_double-eql_v3_double) - Unsupported operator blocker for public.eql\_v3\_double.
* [`neq(jsonb, eql_v3_smallint)`](#neqjsonb-eql_v3_smallint) - Unsupported operator blocker for public.eql\_v3\_smallint.
* [`neq(eql_v3_smallint, jsonb)`](#neqeql_v3_smallint-jsonb) - Unsupported operator blocker for public.eql\_v3\_smallint.
* [`neq(eql_v3_smallint, eql_v3_smallint)`](#neqeql_v3_smallint-eql_v3_smallint) - Unsupported operator blocker for public.eql\_v3\_smallint.
* [`neq(query_bigint_ord, eql_v3_json_entry)`](#neqquery_bigint_ord-eql_v3_json_entry) - Unsupported operator blocker for public.eql\_v3\_json\_entry.
* [`neq(eql_v3_json_entry, query_bigint_ord)`](#neqeql_v3_json_entry-query_bigint_ord) - Unsupported operator blocker for public.eql\_v3\_json\_entry.
* [`ope_cllw(jsonb)`](#ope_cllwjsonb) - Extract CLLW OPE index term from JSONB payload.
* [`ore_block_256(jsonb)`](#ore_block_256jsonb) - Extract ORE block index term from JSONB payload.
* [`ore_block_256_eq(ore_block_256, ore_block_256)`](#ore_block_256_eqore_block_256-ore_block_256) - Equality backing function for ORE block types.
* [`ore_block_256_gt(ore_block_256, ore_block_256)`](#ore_block_256_gtore_block_256-ore_block_256) - Greater-than backing function for ORE block types.
* [`ore_block_256_gte(ore_block_256, ore_block_256)`](#ore_block_256_gteore_block_256-ore_block_256) - Greater-than-or-equal backing function for ORE block types.
* [`ore_block_256_lt(ore_block_256, ore_block_256)`](#ore_block_256_ltore_block_256-ore_block_256) - Less-than backing function for ORE block types.
* [`ore_block_256_lte(ore_block_256, ore_block_256)`](#ore_block_256_lteore_block_256-ore_block_256) - Less-than-or-equal backing function for ORE block types.
* [`ore_block_256_neq(ore_block_256, ore_block_256)`](#ore_block_256_neqore_block_256-ore_block_256) - Not-equal backing function for ORE block types.
* [`ore_domain_unavailable(jsonb, text, text)`](#ore_domain_unavailablejsonb-text-text) - Poison CHECK backing for the ORE-carrying domains on platforms without the ORE operator class.
* [`owned_schemas()`](#owned_schemas) - Schemas owned by the eql\_v3 surface.
***
Functions [#functions-1]
>()
> operator for ORE block types
Parameters [#parameters]
| Name | Type | Description |
| ------------ | ---- | ----------- |
| `FUNCTION` | | |
| `LEFTARG` | | |
| `RIGHTARG` | | |
| `COMMUTATOR` | | |
| `NEGATOR` | | |
| `RESTRICT` | | |
| `JOIN` | | |
***
ciphertext(jsonb) [#ciphertextjsonb]
Extract ciphertext (c) from a raw jsonb encrypted value.
Parameters [#parameters-1]
| Name | Type | Description |
| ----- | ------- | --------------------- |
| `val` | `jsonb` | encrypted EQL payload |
Returns [#returns]
**Type:** `text`
text The c field verbatim (base85 text).
Note [#note]
On the SteVec surface an entry's c is raw AEAD output and is NOT decryptable on its own: the decryption unit is the entry — its s (nonce source), c, and the document key header h (grafted onto extracted entries by ->; see eql\_v3.meta\_data). Scalar payloads' c remains a self-describing encrypted record.
Exceptions [#exceptions]
* if c is absent.
***
eq(jsonb, eql_v3_integer_ord_ore) [#eqjsonb-eql_v3_integer_ord_ore]
Operator wrapper for public.eql\_v3\_integer\_ord\_ore.
Parameters [#parameters-2]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_integer_ord_ore` | |
Returns [#returns-1]
**Type:** `boolean`
boolean
***
eq(eql_v3_integer_ord_ore, jsonb) [#eqeql_v3_integer_ord_ore-jsonb]
Operator wrapper for public.eql\_v3\_integer\_ord\_ore.
Parameters [#parameters-3]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a public.` | `eql_v3_integer_ord_ore` | |
| `b` | `jsonb` | |
Returns [#returns-2]
**Type:** `boolean`
boolean
***
eq(eql_v3_integer_ord_ore, eql_v3_integer_ord_ore) [#eqeql_v3_integer_ord_ore-eql_v3_integer_ord_ore]
Operator wrapper for public.eql\_v3\_integer\_ord\_ore.
Parameters [#parameters-4]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a public.` | `eql_v3_integer_ord_ore` | |
| `b public.` | `eql_v3_integer_ord_ore` | |
Returns [#returns-3]
**Type:** `boolean`
boolean
***
eq(query_smallint_ord, eql_v3_smallint_ord) [#eqquery_smallint_ord-eql_v3_smallint_ord]
Operator wrapper for eql\_v3.query\_smallint\_ord.
Parameters [#parameters-5]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a eql_v3.` | `query_smallint_ord` | |
| `b public.` | `eql_v3_smallint_ord` | |
Returns [#returns-4]
**Type:** `boolean`
boolean
***
eq(eql_v3_smallint_ord, query_smallint_ord) [#eqeql_v3_smallint_ord-query_smallint_ord]
Operator wrapper for eql\_v3.query\_smallint\_ord.
Parameters [#parameters-6]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_smallint_ord` | |
| `b eql_v3.` | `query_smallint_ord` | |
Returns [#returns-5]
**Type:** `boolean`
boolean
***
eq(jsonb, eql_v3_smallint_ord) [#eqjsonb-eql_v3_smallint_ord]
Operator wrapper for public.eql\_v3\_smallint\_ord.
Parameters [#parameters-7]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_smallint_ord` | |
Returns [#returns-6]
**Type:** `boolean`
boolean
***
eq(eql_v3_smallint_ord, jsonb) [#eqeql_v3_smallint_ord-jsonb]
Operator wrapper for public.eql\_v3\_smallint\_ord.
Parameters [#parameters-8]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_smallint_ord` | |
| `b` | `jsonb` | |
Returns [#returns-7]
**Type:** `boolean`
boolean
***
eq(eql_v3_smallint_ord, eql_v3_smallint_ord) [#eqeql_v3_smallint_ord-eql_v3_smallint_ord]
Operator wrapper for public.eql\_v3\_smallint\_ord.
Parameters [#parameters-9]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_smallint_ord` | |
| `b public.` | `eql_v3_smallint_ord` | |
Returns [#returns-8]
**Type:** `boolean`
boolean
***
eq(jsonb, eql_v3_date_ord) [#eqjsonb-eql_v3_date_ord]
Operator wrapper for public.eql\_v3\_date\_ord.
Parameters [#parameters-10]
| Name | Type | Description |
| ----------- | ----------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_date_ord` | |
Returns [#returns-9]
**Type:** `boolean`
boolean
***
eq(eql_v3_date_ord, jsonb) [#eqeql_v3_date_ord-jsonb]
Operator wrapper for public.eql\_v3\_date\_ord.
Parameters [#parameters-11]
| Name | Type | Description |
| ----------- | ----------------- | ----------- |
| `a public.` | `eql_v3_date_ord` | |
| `b` | `jsonb` | |
Returns [#returns-10]
**Type:** `boolean`
boolean
***
eq(eql_v3_date_ord, eql_v3_date_ord) [#eqeql_v3_date_ord-eql_v3_date_ord]
Operator wrapper for public.eql\_v3\_date\_ord.
Parameters [#parameters-12]
| Name | Type | Description |
| ----------- | ----------------- | ----------- |
| `a public.` | `eql_v3_date_ord` | |
| `b public.` | `eql_v3_date_ord` | |
Returns [#returns-11]
**Type:** `boolean`
boolean
***
eq(query_real_ord, eql_v3_real_ord) [#eqquery_real_ord-eql_v3_real_ord]
Operator wrapper for eql\_v3.query\_real\_ord.
Parameters [#parameters-13]
| Name | Type | Description |
| ----------- | ----------------- | ----------- |
| `a eql_v3.` | `query_real_ord` | |
| `b public.` | `eql_v3_real_ord` | |
Returns [#returns-12]
**Type:** `boolean`
boolean
***
eq(eql_v3_real_ord, query_real_ord) [#eqeql_v3_real_ord-query_real_ord]
Operator wrapper for eql\_v3.query\_real\_ord.
Parameters [#parameters-14]
| Name | Type | Description |
| ----------- | ----------------- | ----------- |
| `a public.` | `eql_v3_real_ord` | |
| `b eql_v3.` | `query_real_ord` | |
Returns [#returns-13]
**Type:** `boolean`
boolean
***
eq(query_real_ord_ore, eql_v3_real_ord_ore) [#eqquery_real_ord_ore-eql_v3_real_ord_ore]
Operator wrapper for eql\_v3.query\_real\_ord\_ore.
Parameters [#parameters-15]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a eql_v3.` | `query_real_ord_ore` | |
| `b public.` | `eql_v3_real_ord_ore` | |
Returns [#returns-14]
**Type:** `boolean`
boolean
***
eq(eql_v3_real_ord_ore, query_real_ord_ore) [#eqeql_v3_real_ord_ore-query_real_ord_ore]
Operator wrapper for eql\_v3.query\_real\_ord\_ore.
Parameters [#parameters-16]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_real_ord_ore` | |
| `b eql_v3.` | `query_real_ord_ore` | |
Returns [#returns-15]
**Type:** `boolean`
boolean
***
eq(jsonb, eql_v3_text_ord) [#eqjsonb-eql_v3_text_ord]
Operator wrapper for public.eql\_v3\_text\_ord.
Parameters [#parameters-17]
| Name | Type | Description |
| ----------- | ----------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_text_ord` | |
Returns [#returns-16]
**Type:** `boolean`
boolean
***
eq(eql_v3_text_ord, jsonb) [#eqeql_v3_text_ord-jsonb]
Operator wrapper for public.eql\_v3\_text\_ord.
Parameters [#parameters-18]
| Name | Type | Description |
| ----------- | ----------------- | ----------- |
| `a public.` | `eql_v3_text_ord` | |
| `b` | `jsonb` | |
Returns [#returns-17]
**Type:** `boolean`
boolean
***
eq(eql_v3_text_ord, eql_v3_text_ord) [#eqeql_v3_text_ord-eql_v3_text_ord]
Operator wrapper for public.eql\_v3\_text\_ord.
Parameters [#parameters-19]
| Name | Type | Description |
| ----------- | ----------------- | ----------- |
| `a public.` | `eql_v3_text_ord` | |
| `b public.` | `eql_v3_text_ord` | |
Returns [#returns-18]
**Type:** `boolean`
boolean
***
eq(query_integer_ord_ope, eql_v3_integer_ord_ope) [#eqquery_integer_ord_ope-eql_v3_integer_ord_ope]
Operator wrapper for eql\_v3.query\_integer\_ord\_ope.
Parameters [#parameters-20]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a eql_v3.` | `query_integer_ord_ope` | |
| `b public.` | `eql_v3_integer_ord_ope` | |
Returns [#returns-19]
**Type:** `boolean`
boolean
***
eq(eql_v3_integer_ord_ope, query_integer_ord_ope) [#eqeql_v3_integer_ord_ope-query_integer_ord_ope]
Operator wrapper for eql\_v3.query\_integer\_ord\_ope.
Parameters [#parameters-21]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a public.` | `eql_v3_integer_ord_ope` | |
| `b eql_v3.` | `query_integer_ord_ope` | |
Returns [#returns-20]
**Type:** `boolean`
boolean
***
eq(query_text_ord, eql_v3_text_ord) [#eqquery_text_ord-eql_v3_text_ord]
Operator wrapper for eql\_v3.query\_text\_ord.
Parameters [#parameters-22]
| Name | Type | Description |
| ----------- | ----------------- | ----------- |
| `a eql_v3.` | `query_text_ord` | |
| `b public.` | `eql_v3_text_ord` | |
Returns [#returns-21]
**Type:** `boolean`
boolean
***
eq(eql_v3_text_ord, query_text_ord) [#eqeql_v3_text_ord-query_text_ord]
Operator wrapper for eql\_v3.query\_text\_ord.
Parameters [#parameters-23]
| Name | Type | Description |
| ----------- | ----------------- | ----------- |
| `a public.` | `eql_v3_text_ord` | |
| `b eql_v3.` | `query_text_ord` | |
Returns [#returns-22]
**Type:** `boolean`
boolean
***
eq(jsonb, eql_v3_timestamp_ord_ope) [#eqjsonb-eql_v3_timestamp_ord_ope]
Operator wrapper for public.eql\_v3\_timestamp\_ord\_ope.
Parameters [#parameters-24]
| Name | Type | Description |
| ----------- | -------------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_timestamp_ord_ope` | |
Returns [#returns-23]
**Type:** `boolean`
boolean
***
eq(eql_v3_timestamp_ord_ope, jsonb) [#eqeql_v3_timestamp_ord_ope-jsonb]
Operator wrapper for public.eql\_v3\_timestamp\_ord\_ope.
Parameters [#parameters-25]
| Name | Type | Description |
| ----------- | -------------------------- | ----------- |
| `a public.` | `eql_v3_timestamp_ord_ope` | |
| `b` | `jsonb` | |
Returns [#returns-24]
**Type:** `boolean`
boolean
***
eq(eql_v3_timestamp_ord_ope, eql_v3_timestamp_ord_ope) [#eqeql_v3_timestamp_ord_ope-eql_v3_timestamp_ord_ope]
Operator wrapper for public.eql\_v3\_timestamp\_ord\_ope.
Parameters [#parameters-26]
| Name | Type | Description |
| ----------- | -------------------------- | ----------- |
| `a public.` | `eql_v3_timestamp_ord_ope` | |
| `b public.` | `eql_v3_timestamp_ord_ope` | |
Returns [#returns-25]
**Type:** `boolean`
boolean
***
eq(jsonb, eql_v3_integer_ord_ope) [#eqjsonb-eql_v3_integer_ord_ope]
Operator wrapper for public.eql\_v3\_integer\_ord\_ope.
Parameters [#parameters-27]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_integer_ord_ope` | |
Returns [#returns-26]
**Type:** `boolean`
boolean
***
eq(eql_v3_integer_ord_ope, jsonb) [#eqeql_v3_integer_ord_ope-jsonb]
Operator wrapper for public.eql\_v3\_integer\_ord\_ope.
Parameters [#parameters-28]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a public.` | `eql_v3_integer_ord_ope` | |
| `b` | `jsonb` | |
Returns [#returns-27]
**Type:** `boolean`
boolean
***
eq(eql_v3_integer_ord_ope, eql_v3_integer_ord_ope) [#eqeql_v3_integer_ord_ope-eql_v3_integer_ord_ope]
Operator wrapper for public.eql\_v3\_integer\_ord\_ope.
Parameters [#parameters-29]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a public.` | `eql_v3_integer_ord_ope` | |
| `b public.` | `eql_v3_integer_ord_ope` | |
Returns [#returns-28]
**Type:** `boolean`
boolean
***
eq(query_integer_ord, eql_v3_integer_ord) [#eqquery_integer_ord-eql_v3_integer_ord]
Operator wrapper for eql\_v3.query\_integer\_ord.
Parameters [#parameters-30]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a eql_v3.` | `query_integer_ord` | |
| `b public.` | `eql_v3_integer_ord` | |
Returns [#returns-29]
**Type:** `boolean`
boolean
***
eq(eql_v3_integer_ord, query_integer_ord) [#eqeql_v3_integer_ord-query_integer_ord]
Operator wrapper for eql\_v3.query\_integer\_ord.
Parameters [#parameters-31]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a public.` | `eql_v3_integer_ord` | |
| `b eql_v3.` | `query_integer_ord` | |
Returns [#returns-30]
**Type:** `boolean`
boolean
***
eq(query_text_search, eql_v3_text_search) [#eqquery_text_search-eql_v3_text_search]
Operator wrapper for eql\_v3.query\_text\_search.
Parameters [#parameters-32]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a eql_v3.` | `query_text_search` | |
| `b public.` | `eql_v3_text_search` | |
Returns [#returns-31]
**Type:** `boolean`
boolean
***
eq(eql_v3_text_search, query_text_search) [#eqeql_v3_text_search-query_text_search]
Operator wrapper for eql\_v3.query\_text\_search.
Parameters [#parameters-33]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a public.` | `eql_v3_text_search` | |
| `b eql_v3.` | `query_text_search` | |
Returns [#returns-32]
**Type:** `boolean`
boolean
***
eq(query_numeric_eq, eql_v3_numeric_eq) [#eqquery_numeric_eq-eql_v3_numeric_eq]
Operator wrapper for eql\_v3.query\_numeric\_eq.
Parameters [#parameters-34]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a eql_v3.` | `query_numeric_eq` | |
| `b public.` | `eql_v3_numeric_eq` | |
Returns [#returns-33]
**Type:** `boolean`
boolean
***
eq(eql_v3_numeric_eq, query_numeric_eq) [#eqeql_v3_numeric_eq-query_numeric_eq]
Operator wrapper for eql\_v3.query\_numeric\_eq.
Parameters [#parameters-35]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a public.` | `eql_v3_numeric_eq` | |
| `b eql_v3.` | `query_numeric_eq` | |
Returns [#returns-34]
**Type:** `boolean`
boolean
***
eq(jsonb, eql_v3_bigint_eq) [#eqjsonb-eql_v3_bigint_eq]
Operator wrapper for public.eql\_v3\_bigint\_eq.
Parameters [#parameters-36]
| Name | Type | Description |
| ----------- | ------------------ | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_bigint_eq` | |
Returns [#returns-35]
**Type:** `boolean`
boolean
***
eq(eql_v3_bigint_eq, jsonb) [#eqeql_v3_bigint_eq-jsonb]
Operator wrapper for public.eql\_v3\_bigint\_eq.
Parameters [#parameters-37]
| Name | Type | Description |
| ----------- | ------------------ | ----------- |
| `a public.` | `eql_v3_bigint_eq` | |
| `b` | `jsonb` | |
Returns [#returns-36]
**Type:** `boolean`
boolean
***
eq(eql_v3_bigint_eq, eql_v3_bigint_eq) [#eqeql_v3_bigint_eq-eql_v3_bigint_eq]
Operator wrapper for public.eql\_v3\_bigint\_eq.
Parameters [#parameters-38]
| Name | Type | Description |
| ----------- | ------------------ | ----------- |
| `a public.` | `eql_v3_bigint_eq` | |
| `b public.` | `eql_v3_bigint_eq` | |
Returns [#returns-37]
**Type:** `boolean`
boolean
***
eq(query_smallint_eq, eql_v3_smallint_eq) [#eqquery_smallint_eq-eql_v3_smallint_eq]
Operator wrapper for eql\_v3.query\_smallint\_eq.
Parameters [#parameters-39]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a eql_v3.` | `query_smallint_eq` | |
| `b public.` | `eql_v3_smallint_eq` | |
Returns [#returns-38]
**Type:** `boolean`
boolean
***
eq(eql_v3_smallint_eq, query_smallint_eq) [#eqeql_v3_smallint_eq-query_smallint_eq]
Operator wrapper for eql\_v3.query\_smallint\_eq.
Parameters [#parameters-40]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a public.` | `eql_v3_smallint_eq` | |
| `b eql_v3.` | `query_smallint_eq` | |
Returns [#returns-39]
**Type:** `boolean`
boolean
***
eq(jsonb, eql_v3_numeric_ord) [#eqjsonb-eql_v3_numeric_ord]
Operator wrapper for public.eql\_v3\_numeric\_ord.
Parameters [#parameters-41]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_numeric_ord` | |
Returns [#returns-40]
**Type:** `boolean`
boolean
***
eq(eql_v3_numeric_ord, jsonb) [#eqeql_v3_numeric_ord-jsonb]
Operator wrapper for public.eql\_v3\_numeric\_ord.
Parameters [#parameters-42]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a public.` | `eql_v3_numeric_ord` | |
| `b` | `jsonb` | |
Returns [#returns-41]
**Type:** `boolean`
boolean
***
eq(eql_v3_numeric_ord, eql_v3_numeric_ord) [#eqeql_v3_numeric_ord-eql_v3_numeric_ord]
Operator wrapper for public.eql\_v3\_numeric\_ord.
Parameters [#parameters-43]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a public.` | `eql_v3_numeric_ord` | |
| `b public.` | `eql_v3_numeric_ord` | |
Returns [#returns-42]
**Type:** `boolean`
boolean
***
eq(query_date_ord_ope, eql_v3_date_ord_ope) [#eqquery_date_ord_ope-eql_v3_date_ord_ope]
Operator wrapper for eql\_v3.query\_date\_ord\_ope.
Parameters [#parameters-44]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a eql_v3.` | `query_date_ord_ope` | |
| `b public.` | `eql_v3_date_ord_ope` | |
Returns [#returns-43]
**Type:** `boolean`
boolean
***
eq(eql_v3_date_ord_ope, query_date_ord_ope) [#eqeql_v3_date_ord_ope-query_date_ord_ope]
Operator wrapper for eql\_v3.query\_date\_ord\_ope.
Parameters [#parameters-45]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_date_ord_ope` | |
| `b eql_v3.` | `query_date_ord_ope` | |
Returns [#returns-44]
**Type:** `boolean`
boolean
***
eq(query_timestamp_ord_ore, eql_v3_timestamp_ord_ore) [#eqquery_timestamp_ord_ore-eql_v3_timestamp_ord_ore]
Operator wrapper for eql\_v3.query\_timestamp\_ord\_ore.
Parameters [#parameters-46]
| Name | Type | Description |
| ----------- | -------------------------- | ----------- |
| `a eql_v3.` | `query_timestamp_ord_ore` | |
| `b public.` | `eql_v3_timestamp_ord_ore` | |
Returns [#returns-45]
**Type:** `boolean`
boolean
***
eq(eql_v3_timestamp_ord_ore, query_timestamp_ord_ore) [#eqeql_v3_timestamp_ord_ore-query_timestamp_ord_ore]
Operator wrapper for eql\_v3.query\_timestamp\_ord\_ore.
Parameters [#parameters-47]
| Name | Type | Description |
| ----------- | -------------------------- | ----------- |
| `a public.` | `eql_v3_timestamp_ord_ore` | |
| `b eql_v3.` | `query_timestamp_ord_ore` | |
Returns [#returns-46]
**Type:** `boolean`
boolean
***
eq(query_text_search_ore, eql_v3_text_search_ore) [#eqquery_text_search_ore-eql_v3_text_search_ore]
Operator wrapper for eql\_v3.query\_text\_search\_ore.
Parameters [#parameters-48]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a eql_v3.` | `query_text_search_ore` | |
| `b public.` | `eql_v3_text_search_ore` | |
Returns [#returns-47]
**Type:** `boolean`
boolean
***
eq(eql_v3_text_search_ore, query_text_search_ore) [#eqeql_v3_text_search_ore-query_text_search_ore]
Operator wrapper for eql\_v3.query\_text\_search\_ore.
Parameters [#parameters-49]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a public.` | `eql_v3_text_search_ore` | |
| `b eql_v3.` | `query_text_search_ore` | |
Returns [#returns-48]
**Type:** `boolean`
boolean
***
eq(query_text_ord_ore, eql_v3_text_ord_ore) [#eqquery_text_ord_ore-eql_v3_text_ord_ore]
Operator wrapper for eql\_v3.query\_text\_ord\_ore.
Parameters [#parameters-50]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a eql_v3.` | `query_text_ord_ore` | |
| `b public.` | `eql_v3_text_ord_ore` | |
Returns [#returns-49]
**Type:** `boolean`
boolean
***
eq(eql_v3_text_ord_ore, query_text_ord_ore) [#eqeql_v3_text_ord_ore-query_text_ord_ore]
Operator wrapper for eql\_v3.query\_text\_ord\_ore.
Parameters [#parameters-51]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_text_ord_ore` | |
| `b eql_v3.` | `query_text_ord_ore` | |
Returns [#returns-50]
**Type:** `boolean`
boolean
***
eq(jsonb, eql_v3_timestamp_eq) [#eqjsonb-eql_v3_timestamp_eq]
Operator wrapper for public.eql\_v3\_timestamp\_eq.
Parameters [#parameters-52]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_timestamp_eq` | |
Returns [#returns-51]
**Type:** `boolean`
boolean
***
eq(eql_v3_timestamp_eq, jsonb) [#eqeql_v3_timestamp_eq-jsonb]
Operator wrapper for public.eql\_v3\_timestamp\_eq.
Parameters [#parameters-53]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_timestamp_eq` | |
| `b` | `jsonb` | |
Returns [#returns-52]
**Type:** `boolean`
boolean
***
eq(eql_v3_timestamp_eq, eql_v3_timestamp_eq) [#eqeql_v3_timestamp_eq-eql_v3_timestamp_eq]
Operator wrapper for public.eql\_v3\_timestamp\_eq.
Parameters [#parameters-54]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_timestamp_eq` | |
| `b public.` | `eql_v3_timestamp_eq` | |
Returns [#returns-53]
**Type:** `boolean`
boolean
***
eq(jsonb, eql_v3_real_ord_ope) [#eqjsonb-eql_v3_real_ord_ope]
Operator wrapper for public.eql\_v3\_real\_ord\_ope.
Parameters [#parameters-55]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_real_ord_ope` | |
Returns [#returns-54]
**Type:** `boolean`
boolean
***
eq(eql_v3_real_ord_ope, jsonb) [#eqeql_v3_real_ord_ope-jsonb]
Operator wrapper for public.eql\_v3\_real\_ord\_ope.
Parameters [#parameters-56]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_real_ord_ope` | |
| `b` | `jsonb` | |
Returns [#returns-55]
**Type:** `boolean`
boolean
***
eq(eql_v3_real_ord_ope, eql_v3_real_ord_ope) [#eqeql_v3_real_ord_ope-eql_v3_real_ord_ope]
Operator wrapper for public.eql\_v3\_real\_ord\_ope.
Parameters [#parameters-57]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_real_ord_ope` | |
| `b public.` | `eql_v3_real_ord_ope` | |
Returns [#returns-56]
**Type:** `boolean`
boolean
***
eq(jsonb, eql_v3_real_ord) [#eqjsonb-eql_v3_real_ord]
Operator wrapper for public.eql\_v3\_real\_ord.
Parameters [#parameters-58]
| Name | Type | Description |
| ----------- | ----------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_real_ord` | |
Returns [#returns-57]
**Type:** `boolean`
boolean
***
eq(eql_v3_real_ord, jsonb) [#eqeql_v3_real_ord-jsonb]
Operator wrapper for public.eql\_v3\_real\_ord.
Parameters [#parameters-59]
| Name | Type | Description |
| ----------- | ----------------- | ----------- |
| `a public.` | `eql_v3_real_ord` | |
| `b` | `jsonb` | |
Returns [#returns-58]
**Type:** `boolean`
boolean
***
eq(eql_v3_real_ord, eql_v3_real_ord) [#eqeql_v3_real_ord-eql_v3_real_ord]
Operator wrapper for public.eql\_v3\_real\_ord.
Parameters [#parameters-60]
| Name | Type | Description |
| ----------- | ----------------- | ----------- |
| `a public.` | `eql_v3_real_ord` | |
| `b public.` | `eql_v3_real_ord` | |
Returns [#returns-59]
**Type:** `boolean`
boolean
***
eq(jsonb, eql_v3_integer_ord) [#eqjsonb-eql_v3_integer_ord]
Operator wrapper for public.eql\_v3\_integer\_ord.
Parameters [#parameters-61]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_integer_ord` | |
Returns [#returns-60]
**Type:** `boolean`
boolean
***
eq(eql_v3_integer_ord, jsonb) [#eqeql_v3_integer_ord-jsonb]
Operator wrapper for public.eql\_v3\_integer\_ord.
Parameters [#parameters-62]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a public.` | `eql_v3_integer_ord` | |
| `b` | `jsonb` | |
Returns [#returns-61]
**Type:** `boolean`
boolean
***
eq(eql_v3_integer_ord, eql_v3_integer_ord) [#eqeql_v3_integer_ord-eql_v3_integer_ord]
Operator wrapper for public.eql\_v3\_integer\_ord.
Parameters [#parameters-63]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a public.` | `eql_v3_integer_ord` | |
| `b public.` | `eql_v3_integer_ord` | |
Returns [#returns-62]
**Type:** `boolean`
boolean
***
eq(query_smallint_ord_ore, eql_v3_smallint_ord_ore) [#eqquery_smallint_ord_ore-eql_v3_smallint_ord_ore]
Operator wrapper for eql\_v3.query\_smallint\_ord\_ore.
Parameters [#parameters-64]
| Name | Type | Description |
| ----------- | ------------------------- | ----------- |
| `a eql_v3.` | `query_smallint_ord_ore` | |
| `b public.` | `eql_v3_smallint_ord_ore` | |
Returns [#returns-63]
**Type:** `boolean`
boolean
***
eq(eql_v3_smallint_ord_ore, query_smallint_ord_ore) [#eqeql_v3_smallint_ord_ore-query_smallint_ord_ore]
Operator wrapper for eql\_v3.query\_smallint\_ord\_ore.
Parameters [#parameters-65]
| Name | Type | Description |
| ----------- | ------------------------- | ----------- |
| `a public.` | `eql_v3_smallint_ord_ore` | |
| `b eql_v3.` | `query_smallint_ord_ore` | |
Returns [#returns-64]
**Type:** `boolean`
boolean
***
eq(jsonb, eql_v3_text_ord_ope) [#eqjsonb-eql_v3_text_ord_ope]
Operator wrapper for public.eql\_v3\_text\_ord\_ope.
Parameters [#parameters-66]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_text_ord_ope` | |
Returns [#returns-65]
**Type:** `boolean`
boolean
***
eq(eql_v3_text_ord_ope, jsonb) [#eqeql_v3_text_ord_ope-jsonb]
Operator wrapper for public.eql\_v3\_text\_ord\_ope.
Parameters [#parameters-67]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_text_ord_ope` | |
| `b` | `jsonb` | |
Returns [#returns-66]
**Type:** `boolean`
boolean
***
eq(eql_v3_text_ord_ope, eql_v3_text_ord_ope) [#eqeql_v3_text_ord_ope-eql_v3_text_ord_ope]
Operator wrapper for public.eql\_v3\_text\_ord\_ope.
Parameters [#parameters-68]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_text_ord_ope` | |
| `b public.` | `eql_v3_text_ord_ope` | |
Returns [#returns-67]
**Type:** `boolean`
boolean
***
eq(query_double_ord_ope, eql_v3_double_ord_ope) [#eqquery_double_ord_ope-eql_v3_double_ord_ope]
Operator wrapper for eql\_v3.query\_double\_ord\_ope.
Parameters [#parameters-69]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a eql_v3.` | `query_double_ord_ope` | |
| `b public.` | `eql_v3_double_ord_ope` | |
Returns [#returns-68]
**Type:** `boolean`
boolean
***
eq(eql_v3_double_ord_ope, query_double_ord_ope) [#eqeql_v3_double_ord_ope-query_double_ord_ope]
Operator wrapper for eql\_v3.query\_double\_ord\_ope.
Parameters [#parameters-70]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a public.` | `eql_v3_double_ord_ope` | |
| `b eql_v3.` | `query_double_ord_ope` | |
Returns [#returns-69]
**Type:** `boolean`
boolean
***
eq(query_integer_ord_ore, eql_v3_integer_ord_ore) [#eqquery_integer_ord_ore-eql_v3_integer_ord_ore]
Operator wrapper for eql\_v3.query\_integer\_ord\_ore.
Parameters [#parameters-71]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a eql_v3.` | `query_integer_ord_ore` | |
| `b public.` | `eql_v3_integer_ord_ore` | |
Returns [#returns-70]
**Type:** `boolean`
boolean
***
eq(eql_v3_integer_ord_ore, query_integer_ord_ore) [#eqeql_v3_integer_ord_ore-query_integer_ord_ore]
Operator wrapper for eql\_v3.query\_integer\_ord\_ore.
Parameters [#parameters-72]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a public.` | `eql_v3_integer_ord_ore` | |
| `b eql_v3.` | `query_integer_ord_ore` | |
Returns [#returns-71]
**Type:** `boolean`
boolean
***
eq(jsonb, eql_v3_real_eq) [#eqjsonb-eql_v3_real_eq]
Operator wrapper for public.eql\_v3\_real\_eq.
Parameters [#parameters-73]
| Name | Type | Description |
| ----------- | ---------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_real_eq` | |
Returns [#returns-72]
**Type:** `boolean`
boolean
***
eq(eql_v3_real_eq, jsonb) [#eqeql_v3_real_eq-jsonb]
Operator wrapper for public.eql\_v3\_real\_eq.
Parameters [#parameters-74]
| Name | Type | Description |
| ----------- | ---------------- | ----------- |
| `a public.` | `eql_v3_real_eq` | |
| `b` | `jsonb` | |
Returns [#returns-73]
**Type:** `boolean`
boolean
***
eq(eql_v3_real_eq, eql_v3_real_eq) [#eqeql_v3_real_eq-eql_v3_real_eq]
Operator wrapper for public.eql\_v3\_real\_eq.
Parameters [#parameters-75]
| Name | Type | Description |
| ----------- | ---------------- | ----------- |
| `a public.` | `eql_v3_real_eq` | |
| `b public.` | `eql_v3_real_eq` | |
Returns [#returns-74]
**Type:** `boolean`
boolean
***
eq(query_text_eq, eql_v3_text_eq) [#eqquery_text_eq-eql_v3_text_eq]
Operator wrapper for eql\_v3.query\_text\_eq.
Parameters [#parameters-76]
| Name | Type | Description |
| ----------- | ---------------- | ----------- |
| `a eql_v3.` | `query_text_eq` | |
| `b public.` | `eql_v3_text_eq` | |
Returns [#returns-75]
**Type:** `boolean`
boolean
***
eq(eql_v3_text_eq, query_text_eq) [#eqeql_v3_text_eq-query_text_eq]
Operator wrapper for eql\_v3.query\_text\_eq.
Parameters [#parameters-77]
| Name | Type | Description |
| ----------- | ---------------- | ----------- |
| `a public.` | `eql_v3_text_eq` | |
| `b eql_v3.` | `query_text_eq` | |
Returns [#returns-76]
**Type:** `boolean`
boolean
***
eq(jsonb, eql_v3_bigint_ord_ore) [#eqjsonb-eql_v3_bigint_ord_ore]
Operator wrapper for public.eql\_v3\_bigint\_ord\_ore.
Parameters [#parameters-78]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_bigint_ord_ore` | |
Returns [#returns-77]
**Type:** `boolean`
boolean
***
eq(eql_v3_bigint_ord_ore, jsonb) [#eqeql_v3_bigint_ord_ore-jsonb]
Operator wrapper for public.eql\_v3\_bigint\_ord\_ore.
Parameters [#parameters-79]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a public.` | `eql_v3_bigint_ord_ore` | |
| `b` | `jsonb` | |
Returns [#returns-78]
**Type:** `boolean`
boolean
***
eq(eql_v3_bigint_ord_ore, eql_v3_bigint_ord_ore) [#eqeql_v3_bigint_ord_ore-eql_v3_bigint_ord_ore]
Operator wrapper for public.eql\_v3\_bigint\_ord\_ore.
Parameters [#parameters-80]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a public.` | `eql_v3_bigint_ord_ore` | |
| `b public.` | `eql_v3_bigint_ord_ore` | |
Returns [#returns-79]
**Type:** `boolean`
boolean
***
eq(query_date_ord, eql_v3_date_ord) [#eqquery_date_ord-eql_v3_date_ord]
Operator wrapper for eql\_v3.query\_date\_ord.
Parameters [#parameters-81]
| Name | Type | Description |
| ----------- | ----------------- | ----------- |
| `a eql_v3.` | `query_date_ord` | |
| `b public.` | `eql_v3_date_ord` | |
Returns [#returns-80]
**Type:** `boolean`
boolean
***
eq(eql_v3_date_ord, query_date_ord) [#eqeql_v3_date_ord-query_date_ord]
Operator wrapper for eql\_v3.query\_date\_ord.
Parameters [#parameters-82]
| Name | Type | Description |
| ----------- | ----------------- | ----------- |
| `a public.` | `eql_v3_date_ord` | |
| `b eql_v3.` | `query_date_ord` | |
Returns [#returns-81]
**Type:** `boolean`
boolean
***
eq(jsonb, eql_v3_double_eq) [#eqjsonb-eql_v3_double_eq]
Operator wrapper for public.eql\_v3\_double\_eq.
Parameters [#parameters-83]
| Name | Type | Description |
| ----------- | ------------------ | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_double_eq` | |
Returns [#returns-82]
**Type:** `boolean`
boolean
***
eq(eql_v3_double_eq, jsonb) [#eqeql_v3_double_eq-jsonb]
Operator wrapper for public.eql\_v3\_double\_eq.
Parameters [#parameters-84]
| Name | Type | Description |
| ----------- | ------------------ | ----------- |
| `a public.` | `eql_v3_double_eq` | |
| `b` | `jsonb` | |
Returns [#returns-83]
**Type:** `boolean`
boolean
***
eq(eql_v3_double_eq, eql_v3_double_eq) [#eqeql_v3_double_eq-eql_v3_double_eq]
Operator wrapper for public.eql\_v3\_double\_eq.
Parameters [#parameters-85]
| Name | Type | Description |
| ----------- | ------------------ | ----------- |
| `a public.` | `eql_v3_double_eq` | |
| `b public.` | `eql_v3_double_eq` | |
Returns [#returns-84]
**Type:** `boolean`
boolean
***
eq(jsonb, eql_v3_real_ord_ore) [#eqjsonb-eql_v3_real_ord_ore]
Operator wrapper for public.eql\_v3\_real\_ord\_ore.
Parameters [#parameters-86]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_real_ord_ore` | |
Returns [#returns-85]
**Type:** `boolean`
boolean
***
eq(eql_v3_real_ord_ore, jsonb) [#eqeql_v3_real_ord_ore-jsonb]
Operator wrapper for public.eql\_v3\_real\_ord\_ore.
Parameters [#parameters-87]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_real_ord_ore` | |
| `b` | `jsonb` | |
Returns [#returns-86]
**Type:** `boolean`
boolean
***
eq(eql_v3_real_ord_ore, eql_v3_real_ord_ore) [#eqeql_v3_real_ord_ore-eql_v3_real_ord_ore]
Operator wrapper for public.eql\_v3\_real\_ord\_ore.
Parameters [#parameters-88]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_real_ord_ore` | |
| `b public.` | `eql_v3_real_ord_ore` | |
Returns [#returns-87]
**Type:** `boolean`
boolean
***
eq(jsonb, eql_v3_numeric_ord_ore) [#eqjsonb-eql_v3_numeric_ord_ore]
Operator wrapper for public.eql\_v3\_numeric\_ord\_ore.
Parameters [#parameters-89]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_numeric_ord_ore` | |
Returns [#returns-88]
**Type:** `boolean`
boolean
***
eq(eql_v3_numeric_ord_ore, jsonb) [#eqeql_v3_numeric_ord_ore-jsonb]
Operator wrapper for public.eql\_v3\_numeric\_ord\_ore.
Parameters [#parameters-90]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a public.` | `eql_v3_numeric_ord_ore` | |
| `b` | `jsonb` | |
Returns [#returns-89]
**Type:** `boolean`
boolean
***
eq(eql_v3_numeric_ord_ore, eql_v3_numeric_ord_ore) [#eqeql_v3_numeric_ord_ore-eql_v3_numeric_ord_ore]
Operator wrapper for public.eql\_v3\_numeric\_ord\_ore.
Parameters [#parameters-91]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a public.` | `eql_v3_numeric_ord_ore` | |
| `b public.` | `eql_v3_numeric_ord_ore` | |
Returns [#returns-90]
**Type:** `boolean`
boolean
***
eq(query_double_eq, eql_v3_double_eq) [#eqquery_double_eq-eql_v3_double_eq]
Operator wrapper for eql\_v3.query\_double\_eq.
Parameters [#parameters-92]
| Name | Type | Description |
| ----------- | ------------------ | ----------- |
| `a eql_v3.` | `query_double_eq` | |
| `b public.` | `eql_v3_double_eq` | |
Returns [#returns-91]
**Type:** `boolean`
boolean
***
eq(eql_v3_double_eq, query_double_eq) [#eqeql_v3_double_eq-query_double_eq]
Operator wrapper for eql\_v3.query\_double\_eq.
Parameters [#parameters-93]
| Name | Type | Description |
| ----------- | ------------------ | ----------- |
| `a public.` | `eql_v3_double_eq` | |
| `b eql_v3.` | `query_double_eq` | |
Returns [#returns-92]
**Type:** `boolean`
boolean
***
eq(query_text_ord_ope, eql_v3_text_ord_ope) [#eqquery_text_ord_ope-eql_v3_text_ord_ope]
Operator wrapper for eql\_v3.query\_text\_ord\_ope.
Parameters [#parameters-94]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a eql_v3.` | `query_text_ord_ope` | |
| `b public.` | `eql_v3_text_ord_ope` | |
Returns [#returns-93]
**Type:** `boolean`
boolean
***
eq(eql_v3_text_ord_ope, query_text_ord_ope) [#eqeql_v3_text_ord_ope-query_text_ord_ope]
Operator wrapper for eql\_v3.query\_text\_ord\_ope.
Parameters [#parameters-95]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_text_ord_ope` | |
| `b eql_v3.` | `query_text_ord_ope` | |
Returns [#returns-94]
**Type:** `boolean`
boolean
***
eq(jsonb, eql_v3_bigint_ord_ope) [#eqjsonb-eql_v3_bigint_ord_ope]
Operator wrapper for public.eql\_v3\_bigint\_ord\_ope.
Parameters [#parameters-96]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_bigint_ord_ope` | |
Returns [#returns-95]
**Type:** `boolean`
boolean
***
eq(eql_v3_bigint_ord_ope, jsonb) [#eqeql_v3_bigint_ord_ope-jsonb]
Operator wrapper for public.eql\_v3\_bigint\_ord\_ope.
Parameters [#parameters-97]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a public.` | `eql_v3_bigint_ord_ope` | |
| `b` | `jsonb` | |
Returns [#returns-96]
**Type:** `boolean`
boolean
***
eq(eql_v3_bigint_ord_ope, eql_v3_bigint_ord_ope) [#eqeql_v3_bigint_ord_ope-eql_v3_bigint_ord_ope]
Operator wrapper for public.eql\_v3\_bigint\_ord\_ope.
Parameters [#parameters-98]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a public.` | `eql_v3_bigint_ord_ope` | |
| `b public.` | `eql_v3_bigint_ord_ope` | |
Returns [#returns-97]
**Type:** `boolean`
boolean
***
eq(query_real_eq, eql_v3_real_eq) [#eqquery_real_eq-eql_v3_real_eq]
Operator wrapper for eql\_v3.query\_real\_eq.
Parameters [#parameters-99]
| Name | Type | Description |
| ----------- | ---------------- | ----------- |
| `a eql_v3.` | `query_real_eq` | |
| `b public.` | `eql_v3_real_eq` | |
Returns [#returns-98]
**Type:** `boolean`
boolean
***
eq(eql_v3_real_eq, query_real_eq) [#eqeql_v3_real_eq-query_real_eq]
Operator wrapper for eql\_v3.query\_real\_eq.
Parameters [#parameters-100]
| Name | Type | Description |
| ----------- | ---------------- | ----------- |
| `a public.` | `eql_v3_real_eq` | |
| `b eql_v3.` | `query_real_eq` | |
Returns [#returns-99]
**Type:** `boolean`
boolean
***
eq(jsonb, eql_v3_double_ord_ore) [#eqjsonb-eql_v3_double_ord_ore]
Operator wrapper for public.eql\_v3\_double\_ord\_ore.
Parameters [#parameters-101]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_double_ord_ore` | |
Returns [#returns-100]
**Type:** `boolean`
boolean
***
eq(eql_v3_double_ord_ore, jsonb) [#eqeql_v3_double_ord_ore-jsonb]
Operator wrapper for public.eql\_v3\_double\_ord\_ore.
Parameters [#parameters-102]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a public.` | `eql_v3_double_ord_ore` | |
| `b` | `jsonb` | |
Returns [#returns-101]
**Type:** `boolean`
boolean
***
eq(eql_v3_double_ord_ore, eql_v3_double_ord_ore) [#eqeql_v3_double_ord_ore-eql_v3_double_ord_ore]
Operator wrapper for public.eql\_v3\_double\_ord\_ore.
Parameters [#parameters-103]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a public.` | `eql_v3_double_ord_ore` | |
| `b public.` | `eql_v3_double_ord_ore` | |
Returns [#returns-102]
**Type:** `boolean`
boolean
***
eq(jsonb, eql_v3_bigint_ord) [#eqjsonb-eql_v3_bigint_ord]
Operator wrapper for public.eql\_v3\_bigint\_ord.
Parameters [#parameters-104]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_bigint_ord` | |
Returns [#returns-103]
**Type:** `boolean`
boolean
***
eq(eql_v3_bigint_ord, jsonb) [#eqeql_v3_bigint_ord-jsonb]
Operator wrapper for public.eql\_v3\_bigint\_ord.
Parameters [#parameters-105]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a public.` | `eql_v3_bigint_ord` | |
| `b` | `jsonb` | |
Returns [#returns-104]
**Type:** `boolean`
boolean
***
eq(eql_v3_bigint_ord, eql_v3_bigint_ord) [#eqeql_v3_bigint_ord-eql_v3_bigint_ord]
Operator wrapper for public.eql\_v3\_bigint\_ord.
Parameters [#parameters-106]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a public.` | `eql_v3_bigint_ord` | |
| `b public.` | `eql_v3_bigint_ord` | |
Returns [#returns-105]
**Type:** `boolean`
boolean
***
eq(query_timestamp_ord_ope, eql_v3_timestamp_ord_ope) [#eqquery_timestamp_ord_ope-eql_v3_timestamp_ord_ope]
Operator wrapper for eql\_v3.query\_timestamp\_ord\_ope.
Parameters [#parameters-107]
| Name | Type | Description |
| ----------- | -------------------------- | ----------- |
| `a eql_v3.` | `query_timestamp_ord_ope` | |
| `b public.` | `eql_v3_timestamp_ord_ope` | |
Returns [#returns-106]
**Type:** `boolean`
boolean
***
eq(eql_v3_timestamp_ord_ope, query_timestamp_ord_ope) [#eqeql_v3_timestamp_ord_ope-query_timestamp_ord_ope]
Operator wrapper for eql\_v3.query\_timestamp\_ord\_ope.
Parameters [#parameters-108]
| Name | Type | Description |
| ----------- | -------------------------- | ----------- |
| `a public.` | `eql_v3_timestamp_ord_ope` | |
| `b eql_v3.` | `query_timestamp_ord_ope` | |
Returns [#returns-107]
**Type:** `boolean`
boolean
***
eq(query_numeric_ord, eql_v3_numeric_ord) [#eqquery_numeric_ord-eql_v3_numeric_ord]
Operator wrapper for eql\_v3.query\_numeric\_ord.
Parameters [#parameters-109]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a eql_v3.` | `query_numeric_ord` | |
| `b public.` | `eql_v3_numeric_ord` | |
Returns [#returns-108]
**Type:** `boolean`
boolean
***
eq(eql_v3_numeric_ord, query_numeric_ord) [#eqeql_v3_numeric_ord-query_numeric_ord]
Operator wrapper for eql\_v3.query\_numeric\_ord.
Parameters [#parameters-110]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a public.` | `eql_v3_numeric_ord` | |
| `b eql_v3.` | `query_numeric_ord` | |
Returns [#returns-109]
**Type:** `boolean`
boolean
***
eq(jsonb, eql_v3_text_search_ore) [#eqjsonb-eql_v3_text_search_ore]
Operator wrapper for public.eql\_v3\_text\_search\_ore.
Parameters [#parameters-111]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_text_search_ore` | |
Returns [#returns-110]
**Type:** `boolean`
boolean
***
eq(eql_v3_text_search_ore, jsonb) [#eqeql_v3_text_search_ore-jsonb]
Operator wrapper for public.eql\_v3\_text\_search\_ore.
Parameters [#parameters-112]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a public.` | `eql_v3_text_search_ore` | |
| `b` | `jsonb` | |
Returns [#returns-111]
**Type:** `boolean`
boolean
***
eq(eql_v3_text_search_ore, eql_v3_text_search_ore) [#eqeql_v3_text_search_ore-eql_v3_text_search_ore]
Operator wrapper for public.eql\_v3\_text\_search\_ore.
Parameters [#parameters-113]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a public.` | `eql_v3_text_search_ore` | |
| `b public.` | `eql_v3_text_search_ore` | |
Returns [#returns-112]
**Type:** `boolean`
boolean
***
eq(query_bigint_eq, eql_v3_bigint_eq) [#eqquery_bigint_eq-eql_v3_bigint_eq]
Operator wrapper for eql\_v3.query\_bigint\_eq.
Parameters [#parameters-114]
| Name | Type | Description |
| ----------- | ------------------ | ----------- |
| `a eql_v3.` | `query_bigint_eq` | |
| `b public.` | `eql_v3_bigint_eq` | |
Returns [#returns-113]
**Type:** `boolean`
boolean
***
eq(eql_v3_bigint_eq, query_bigint_eq) [#eqeql_v3_bigint_eq-query_bigint_eq]
Operator wrapper for eql\_v3.query\_bigint\_eq.
Parameters [#parameters-115]
| Name | Type | Description |
| ----------- | ------------------ | ----------- |
| `a public.` | `eql_v3_bigint_eq` | |
| `b eql_v3.` | `query_bigint_eq` | |
Returns [#returns-114]
**Type:** `boolean`
boolean
***
eq(query_timestamp_eq, eql_v3_timestamp_eq) [#eqquery_timestamp_eq-eql_v3_timestamp_eq]
Operator wrapper for eql\_v3.query\_timestamp\_eq.
Parameters [#parameters-116]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a eql_v3.` | `query_timestamp_eq` | |
| `b public.` | `eql_v3_timestamp_eq` | |
Returns [#returns-115]
**Type:** `boolean`
boolean
***
eq(eql_v3_timestamp_eq, query_timestamp_eq) [#eqeql_v3_timestamp_eq-query_timestamp_eq]
Operator wrapper for eql\_v3.query\_timestamp\_eq.
Parameters [#parameters-117]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_timestamp_eq` | |
| `b eql_v3.` | `query_timestamp_eq` | |
Returns [#returns-116]
**Type:** `boolean`
boolean
***
eq(query_real_ord_ope, eql_v3_real_ord_ope) [#eqquery_real_ord_ope-eql_v3_real_ord_ope]
Operator wrapper for eql\_v3.query\_real\_ord\_ope.
Parameters [#parameters-118]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a eql_v3.` | `query_real_ord_ope` | |
| `b public.` | `eql_v3_real_ord_ope` | |
Returns [#returns-117]
**Type:** `boolean`
boolean
***
eq(eql_v3_real_ord_ope, query_real_ord_ope) [#eqeql_v3_real_ord_ope-query_real_ord_ope]
Operator wrapper for eql\_v3.query\_real\_ord\_ope.
Parameters [#parameters-119]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_real_ord_ope` | |
| `b eql_v3.` | `query_real_ord_ope` | |
Returns [#returns-118]
**Type:** `boolean`
boolean
***
eq(jsonb, eql_v3_numeric_eq) [#eqjsonb-eql_v3_numeric_eq]
Operator wrapper for public.eql\_v3\_numeric\_eq.
Parameters [#parameters-120]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_numeric_eq` | |
Returns [#returns-119]
**Type:** `boolean`
boolean
***
eq(eql_v3_numeric_eq, jsonb) [#eqeql_v3_numeric_eq-jsonb]
Operator wrapper for public.eql\_v3\_numeric\_eq.
Parameters [#parameters-121]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a public.` | `eql_v3_numeric_eq` | |
| `b` | `jsonb` | |
Returns [#returns-120]
**Type:** `boolean`
boolean
***
eq(eql_v3_numeric_eq, eql_v3_numeric_eq) [#eqeql_v3_numeric_eq-eql_v3_numeric_eq]
Operator wrapper for public.eql\_v3\_numeric\_eq.
Parameters [#parameters-122]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a public.` | `eql_v3_numeric_eq` | |
| `b public.` | `eql_v3_numeric_eq` | |
Returns [#returns-121]
**Type:** `boolean`
boolean
***
eq(jsonb, eql_v3_timestamp_ord) [#eqjsonb-eql_v3_timestamp_ord]
Operator wrapper for public.eql\_v3\_timestamp\_ord.
Parameters [#parameters-123]
| Name | Type | Description |
| ----------- | ---------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_timestamp_ord` | |
Returns [#returns-122]
**Type:** `boolean`
boolean
***
eq(eql_v3_timestamp_ord, jsonb) [#eqeql_v3_timestamp_ord-jsonb]
Operator wrapper for public.eql\_v3\_timestamp\_ord.
Parameters [#parameters-124]
| Name | Type | Description |
| ----------- | ---------------------- | ----------- |
| `a public.` | `eql_v3_timestamp_ord` | |
| `b` | `jsonb` | |
Returns [#returns-123]
**Type:** `boolean`
boolean
***
eq(eql_v3_timestamp_ord, eql_v3_timestamp_ord) [#eqeql_v3_timestamp_ord-eql_v3_timestamp_ord]
Operator wrapper for public.eql\_v3\_timestamp\_ord.
Parameters [#parameters-125]
| Name | Type | Description |
| ----------- | ---------------------- | ----------- |
| `a public.` | `eql_v3_timestamp_ord` | |
| `b public.` | `eql_v3_timestamp_ord` | |
Returns [#returns-124]
**Type:** `boolean`
boolean
***
eq(jsonb, eql_v3_smallint_ord_ope) [#eqjsonb-eql_v3_smallint_ord_ope]
Operator wrapper for public.eql\_v3\_smallint\_ord\_ope.
Parameters [#parameters-126]
| Name | Type | Description |
| ----------- | ------------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_smallint_ord_ope` | |
Returns [#returns-125]
**Type:** `boolean`
boolean
***
eq(eql_v3_smallint_ord_ope, jsonb) [#eqeql_v3_smallint_ord_ope-jsonb]
Operator wrapper for public.eql\_v3\_smallint\_ord\_ope.
Parameters [#parameters-127]
| Name | Type | Description |
| ----------- | ------------------------- | ----------- |
| `a public.` | `eql_v3_smallint_ord_ope` | |
| `b` | `jsonb` | |
Returns [#returns-126]
**Type:** `boolean`
boolean
***
eq(eql_v3_smallint_ord_ope, eql_v3_smallint_ord_ope) [#eqeql_v3_smallint_ord_ope-eql_v3_smallint_ord_ope]
Operator wrapper for public.eql\_v3\_smallint\_ord\_ope.
Parameters [#parameters-128]
| Name | Type | Description |
| ----------- | ------------------------- | ----------- |
| `a public.` | `eql_v3_smallint_ord_ope` | |
| `b public.` | `eql_v3_smallint_ord_ope` | |
Returns [#returns-127]
**Type:** `boolean`
boolean
***
eq(query_double_ord, eql_v3_double_ord) [#eqquery_double_ord-eql_v3_double_ord]
Operator wrapper for eql\_v3.query\_double\_ord.
Parameters [#parameters-129]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a eql_v3.` | `query_double_ord` | |
| `b public.` | `eql_v3_double_ord` | |
Returns [#returns-128]
**Type:** `boolean`
boolean
***
eq(eql_v3_double_ord, query_double_ord) [#eqeql_v3_double_ord-query_double_ord]
Operator wrapper for eql\_v3.query\_double\_ord.
Parameters [#parameters-130]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a public.` | `eql_v3_double_ord` | |
| `b eql_v3.` | `query_double_ord` | |
Returns [#returns-129]
**Type:** `boolean`
boolean
***
eq(query_date_eq, eql_v3_date_eq) [#eqquery_date_eq-eql_v3_date_eq]
Operator wrapper for eql\_v3.query\_date\_eq.
Parameters [#parameters-131]
| Name | Type | Description |
| ----------- | ---------------- | ----------- |
| `a eql_v3.` | `query_date_eq` | |
| `b public.` | `eql_v3_date_eq` | |
Returns [#returns-130]
**Type:** `boolean`
boolean
***
eq(eql_v3_date_eq, query_date_eq) [#eqeql_v3_date_eq-query_date_eq]
Operator wrapper for eql\_v3.query\_date\_eq.
Parameters [#parameters-132]
| Name | Type | Description |
| ----------- | ---------------- | ----------- |
| `a public.` | `eql_v3_date_eq` | |
| `b eql_v3.` | `query_date_eq` | |
Returns [#returns-131]
**Type:** `boolean`
boolean
***
eq(query_double_ord_ore, eql_v3_double_ord_ore) [#eqquery_double_ord_ore-eql_v3_double_ord_ore]
Operator wrapper for eql\_v3.query\_double\_ord\_ore.
Parameters [#parameters-133]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a eql_v3.` | `query_double_ord_ore` | |
| `b public.` | `eql_v3_double_ord_ore` | |
Returns [#returns-132]
**Type:** `boolean`
boolean
***
eq(eql_v3_double_ord_ore, query_double_ord_ore) [#eqeql_v3_double_ord_ore-query_double_ord_ore]
Operator wrapper for eql\_v3.query\_double\_ord\_ore.
Parameters [#parameters-134]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a public.` | `eql_v3_double_ord_ore` | |
| `b eql_v3.` | `query_double_ord_ore` | |
Returns [#returns-133]
**Type:** `boolean`
boolean
***
eq(jsonb, eql_v3_timestamp_ord_ore) [#eqjsonb-eql_v3_timestamp_ord_ore]
Operator wrapper for public.eql\_v3\_timestamp\_ord\_ore.
Parameters [#parameters-135]
| Name | Type | Description |
| ----------- | -------------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_timestamp_ord_ore` | |
Returns [#returns-134]
**Type:** `boolean`
boolean
***
eq(eql_v3_timestamp_ord_ore, jsonb) [#eqeql_v3_timestamp_ord_ore-jsonb]
Operator wrapper for public.eql\_v3\_timestamp\_ord\_ore.
Parameters [#parameters-136]
| Name | Type | Description |
| ----------- | -------------------------- | ----------- |
| `a public.` | `eql_v3_timestamp_ord_ore` | |
| `b` | `jsonb` | |
Returns [#returns-135]
**Type:** `boolean`
boolean
***
eq(eql_v3_timestamp_ord_ore, eql_v3_timestamp_ord_ore) [#eqeql_v3_timestamp_ord_ore-eql_v3_timestamp_ord_ore]
Operator wrapper for public.eql\_v3\_timestamp\_ord\_ore.
Parameters [#parameters-137]
| Name | Type | Description |
| ----------- | -------------------------- | ----------- |
| `a public.` | `eql_v3_timestamp_ord_ore` | |
| `b public.` | `eql_v3_timestamp_ord_ore` | |
Returns [#returns-136]
**Type:** `boolean`
boolean
***
eq(jsonb, eql_v3_text_search) [#eqjsonb-eql_v3_text_search]
Operator wrapper for public.eql\_v3\_text\_search.
Parameters [#parameters-138]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_text_search` | |
Returns [#returns-137]
**Type:** `boolean`
boolean
***
eq(eql_v3_text_search, jsonb) [#eqeql_v3_text_search-jsonb]
Operator wrapper for public.eql\_v3\_text\_search.
Parameters [#parameters-139]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a public.` | `eql_v3_text_search` | |
| `b` | `jsonb` | |
Returns [#returns-138]
**Type:** `boolean`
boolean
***
eq(eql_v3_text_search, eql_v3_text_search) [#eqeql_v3_text_search-eql_v3_text_search]
Operator wrapper for public.eql\_v3\_text\_search.
Parameters [#parameters-140]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a public.` | `eql_v3_text_search` | |
| `b public.` | `eql_v3_text_search` | |
Returns [#returns-139]
**Type:** `boolean`
boolean
***
eq(query_numeric_ord_ore, eql_v3_numeric_ord_ore) [#eqquery_numeric_ord_ore-eql_v3_numeric_ord_ore]
Operator wrapper for eql\_v3.query\_numeric\_ord\_ore.
Parameters [#parameters-141]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a eql_v3.` | `query_numeric_ord_ore` | |
| `b public.` | `eql_v3_numeric_ord_ore` | |
Returns [#returns-140]
**Type:** `boolean`
boolean
***
eq(eql_v3_numeric_ord_ore, query_numeric_ord_ore) [#eqeql_v3_numeric_ord_ore-query_numeric_ord_ore]
Operator wrapper for eql\_v3.query\_numeric\_ord\_ore.
Parameters [#parameters-142]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a public.` | `eql_v3_numeric_ord_ore` | |
| `b eql_v3.` | `query_numeric_ord_ore` | |
Returns [#returns-141]
**Type:** `boolean`
boolean
***
eq(jsonb, eql_v3_smallint_eq) [#eqjsonb-eql_v3_smallint_eq]
Operator wrapper for public.eql\_v3\_smallint\_eq.
Parameters [#parameters-143]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_smallint_eq` | |
Returns [#returns-142]
**Type:** `boolean`
boolean
***
eq(eql_v3_smallint_eq, jsonb) [#eqeql_v3_smallint_eq-jsonb]
Operator wrapper for public.eql\_v3\_smallint\_eq.
Parameters [#parameters-144]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a public.` | `eql_v3_smallint_eq` | |
| `b` | `jsonb` | |
Returns [#returns-143]
**Type:** `boolean`
boolean
***
eq(eql_v3_smallint_eq, eql_v3_smallint_eq) [#eqeql_v3_smallint_eq-eql_v3_smallint_eq]
Operator wrapper for public.eql\_v3\_smallint\_eq.
Parameters [#parameters-145]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a public.` | `eql_v3_smallint_eq` | |
| `b public.` | `eql_v3_smallint_eq` | |
Returns [#returns-144]
**Type:** `boolean`
boolean
***
eq(query_bigint_ord_ore, eql_v3_bigint_ord_ore) [#eqquery_bigint_ord_ore-eql_v3_bigint_ord_ore]
Operator wrapper for eql\_v3.query\_bigint\_ord\_ore.
Parameters [#parameters-146]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a eql_v3.` | `query_bigint_ord_ore` | |
| `b public.` | `eql_v3_bigint_ord_ore` | |
Returns [#returns-145]
**Type:** `boolean`
boolean
***
eq(eql_v3_bigint_ord_ore, query_bigint_ord_ore) [#eqeql_v3_bigint_ord_ore-query_bigint_ord_ore]
Operator wrapper for eql\_v3.query\_bigint\_ord\_ore.
Parameters [#parameters-147]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a public.` | `eql_v3_bigint_ord_ore` | |
| `b eql_v3.` | `query_bigint_ord_ore` | |
Returns [#returns-146]
**Type:** `boolean`
boolean
***
eq(query_bigint_ord_ope, eql_v3_bigint_ord_ope) [#eqquery_bigint_ord_ope-eql_v3_bigint_ord_ope]
Operator wrapper for eql\_v3.query\_bigint\_ord\_ope.
Parameters [#parameters-148]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a eql_v3.` | `query_bigint_ord_ope` | |
| `b public.` | `eql_v3_bigint_ord_ope` | |
Returns [#returns-147]
**Type:** `boolean`
boolean
***
eq(eql_v3_bigint_ord_ope, query_bigint_ord_ope) [#eqeql_v3_bigint_ord_ope-query_bigint_ord_ope]
Operator wrapper for eql\_v3.query\_bigint\_ord\_ope.
Parameters [#parameters-149]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a public.` | `eql_v3_bigint_ord_ope` | |
| `b eql_v3.` | `query_bigint_ord_ope` | |
Returns [#returns-148]
**Type:** `boolean`
boolean
***
eq(query_date_ord_ore, eql_v3_date_ord_ore) [#eqquery_date_ord_ore-eql_v3_date_ord_ore]
Operator wrapper for eql\_v3.query\_date\_ord\_ore.
Parameters [#parameters-150]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a eql_v3.` | `query_date_ord_ore` | |
| `b public.` | `eql_v3_date_ord_ore` | |
Returns [#returns-149]
**Type:** `boolean`
boolean
***
eq(eql_v3_date_ord_ore, query_date_ord_ore) [#eqeql_v3_date_ord_ore-query_date_ord_ore]
Operator wrapper for eql\_v3.query\_date\_ord\_ore.
Parameters [#parameters-151]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_date_ord_ore` | |
| `b eql_v3.` | `query_date_ord_ore` | |
Returns [#returns-150]
**Type:** `boolean`
boolean
***
eq(query_smallint_ord_ope, eql_v3_smallint_ord_ope) [#eqquery_smallint_ord_ope-eql_v3_smallint_ord_ope]
Operator wrapper for eql\_v3.query\_smallint\_ord\_ope.
Parameters [#parameters-152]
| Name | Type | Description |
| ----------- | ------------------------- | ----------- |
| `a eql_v3.` | `query_smallint_ord_ope` | |
| `b public.` | `eql_v3_smallint_ord_ope` | |
Returns [#returns-151]
**Type:** `boolean`
boolean
***
eq(eql_v3_smallint_ord_ope, query_smallint_ord_ope) [#eqeql_v3_smallint_ord_ope-query_smallint_ord_ope]
Operator wrapper for eql\_v3.query\_smallint\_ord\_ope.
Parameters [#parameters-153]
| Name | Type | Description |
| ----------- | ------------------------- | ----------- |
| `a public.` | `eql_v3_smallint_ord_ope` | |
| `b eql_v3.` | `query_smallint_ord_ope` | |
Returns [#returns-152]
**Type:** `boolean`
boolean
***
eq(jsonb, eql_v3_double_ord) [#eqjsonb-eql_v3_double_ord]
Operator wrapper for public.eql\_v3\_double\_ord.
Parameters [#parameters-154]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_double_ord` | |
Returns [#returns-153]
**Type:** `boolean`
boolean
***
eq(eql_v3_double_ord, jsonb) [#eqeql_v3_double_ord-jsonb]
Operator wrapper for public.eql\_v3\_double\_ord.
Parameters [#parameters-155]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a public.` | `eql_v3_double_ord` | |
| `b` | `jsonb` | |
Returns [#returns-154]
**Type:** `boolean`
boolean
***
eq(eql_v3_double_ord, eql_v3_double_ord) [#eqeql_v3_double_ord-eql_v3_double_ord]
Operator wrapper for public.eql\_v3\_double\_ord.
Parameters [#parameters-156]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a public.` | `eql_v3_double_ord` | |
| `b public.` | `eql_v3_double_ord` | |
Returns [#returns-155]
**Type:** `boolean`
boolean
***
eq(query_numeric_ord_ope, eql_v3_numeric_ord_ope) [#eqquery_numeric_ord_ope-eql_v3_numeric_ord_ope]
Operator wrapper for eql\_v3.query\_numeric\_ord\_ope.
Parameters [#parameters-157]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a eql_v3.` | `query_numeric_ord_ope` | |
| `b public.` | `eql_v3_numeric_ord_ope` | |
Returns [#returns-156]
**Type:** `boolean`
boolean
***
eq(eql_v3_numeric_ord_ope, query_numeric_ord_ope) [#eqeql_v3_numeric_ord_ope-query_numeric_ord_ope]
Operator wrapper for eql\_v3.query\_numeric\_ord\_ope.
Parameters [#parameters-158]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a public.` | `eql_v3_numeric_ord_ope` | |
| `b eql_v3.` | `query_numeric_ord_ope` | |
Returns [#returns-157]
**Type:** `boolean`
boolean
***
eq(jsonb, eql_v3_date_eq) [#eqjsonb-eql_v3_date_eq]
Operator wrapper for public.eql\_v3\_date\_eq.
Parameters [#parameters-159]
| Name | Type | Description |
| ----------- | ---------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_date_eq` | |
Returns [#returns-158]
**Type:** `boolean`
boolean
***
eq(eql_v3_date_eq, jsonb) [#eqeql_v3_date_eq-jsonb]
Operator wrapper for public.eql\_v3\_date\_eq.
Parameters [#parameters-160]
| Name | Type | Description |
| ----------- | ---------------- | ----------- |
| `a public.` | `eql_v3_date_eq` | |
| `b` | `jsonb` | |
Returns [#returns-159]
**Type:** `boolean`
boolean
***
eq(eql_v3_date_eq, eql_v3_date_eq) [#eqeql_v3_date_eq-eql_v3_date_eq]
Operator wrapper for public.eql\_v3\_date\_eq.
Parameters [#parameters-161]
| Name | Type | Description |
| ----------- | ---------------- | ----------- |
| `a public.` | `eql_v3_date_eq` | |
| `b public.` | `eql_v3_date_eq` | |
Returns [#returns-160]
**Type:** `boolean`
boolean
***
eq(jsonb, eql_v3_double_ord_ope) [#eqjsonb-eql_v3_double_ord_ope]
Operator wrapper for public.eql\_v3\_double\_ord\_ope.
Parameters [#parameters-162]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_double_ord_ope` | |
Returns [#returns-161]
**Type:** `boolean`
boolean
***
eq(eql_v3_double_ord_ope, jsonb) [#eqeql_v3_double_ord_ope-jsonb]
Operator wrapper for public.eql\_v3\_double\_ord\_ope.
Parameters [#parameters-163]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a public.` | `eql_v3_double_ord_ope` | |
| `b` | `jsonb` | |
Returns [#returns-162]
**Type:** `boolean`
boolean
***
eq(eql_v3_double_ord_ope, eql_v3_double_ord_ope) [#eqeql_v3_double_ord_ope-eql_v3_double_ord_ope]
Operator wrapper for public.eql\_v3\_double\_ord\_ope.
Parameters [#parameters-164]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a public.` | `eql_v3_double_ord_ope` | |
| `b public.` | `eql_v3_double_ord_ope` | |
Returns [#returns-163]
**Type:** `boolean`
boolean
***
eq(jsonb, eql_v3_numeric_ord_ope) [#eqjsonb-eql_v3_numeric_ord_ope]
Operator wrapper for public.eql\_v3\_numeric\_ord\_ope.
Parameters [#parameters-165]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_numeric_ord_ope` | |
Returns [#returns-164]
**Type:** `boolean`
boolean
***
eq(eql_v3_numeric_ord_ope, jsonb) [#eqeql_v3_numeric_ord_ope-jsonb]
Operator wrapper for public.eql\_v3\_numeric\_ord\_ope.
Parameters [#parameters-166]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a public.` | `eql_v3_numeric_ord_ope` | |
| `b` | `jsonb` | |
Returns [#returns-165]
**Type:** `boolean`
boolean
***
eq(eql_v3_numeric_ord_ope, eql_v3_numeric_ord_ope) [#eqeql_v3_numeric_ord_ope-eql_v3_numeric_ord_ope]
Operator wrapper for public.eql\_v3\_numeric\_ord\_ope.
Parameters [#parameters-167]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a public.` | `eql_v3_numeric_ord_ope` | |
| `b public.` | `eql_v3_numeric_ord_ope` | |
Returns [#returns-166]
**Type:** `boolean`
boolean
***
eq(jsonb, eql_v3_date_ord_ore) [#eqjsonb-eql_v3_date_ord_ore]
Operator wrapper for public.eql\_v3\_date\_ord\_ore.
Parameters [#parameters-168]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_date_ord_ore` | |
Returns [#returns-167]
**Type:** `boolean`
boolean
***
eq(eql_v3_date_ord_ore, jsonb) [#eqeql_v3_date_ord_ore-jsonb]
Operator wrapper for public.eql\_v3\_date\_ord\_ore.
Parameters [#parameters-169]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_date_ord_ore` | |
| `b` | `jsonb` | |
Returns [#returns-168]
**Type:** `boolean`
boolean
***
eq(eql_v3_date_ord_ore, eql_v3_date_ord_ore) [#eqeql_v3_date_ord_ore-eql_v3_date_ord_ore]
Operator wrapper for public.eql\_v3\_date\_ord\_ore.
Parameters [#parameters-170]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_date_ord_ore` | |
| `b public.` | `eql_v3_date_ord_ore` | |
Returns [#returns-169]
**Type:** `boolean`
boolean
***
eq(query_timestamp_ord, eql_v3_timestamp_ord) [#eqquery_timestamp_ord-eql_v3_timestamp_ord]
Operator wrapper for eql\_v3.query\_timestamp\_ord.
Parameters [#parameters-171]
| Name | Type | Description |
| ----------- | ---------------------- | ----------- |
| `a eql_v3.` | `query_timestamp_ord` | |
| `b public.` | `eql_v3_timestamp_ord` | |
Returns [#returns-170]
**Type:** `boolean`
boolean
***
eq(eql_v3_timestamp_ord, query_timestamp_ord) [#eqeql_v3_timestamp_ord-query_timestamp_ord]
Operator wrapper for eql\_v3.query\_timestamp\_ord.
Parameters [#parameters-172]
| Name | Type | Description |
| ----------- | ---------------------- | ----------- |
| `a public.` | `eql_v3_timestamp_ord` | |
| `b eql_v3.` | `query_timestamp_ord` | |
Returns [#returns-171]
**Type:** `boolean`
boolean
***
eq(jsonb, eql_v3_text_eq) [#eqjsonb-eql_v3_text_eq]
Operator wrapper for public.eql\_v3\_text\_eq.
Parameters [#parameters-173]
| Name | Type | Description |
| ----------- | ---------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_text_eq` | |
Returns [#returns-172]
**Type:** `boolean`
boolean
***
eq(eql_v3_text_eq, jsonb) [#eqeql_v3_text_eq-jsonb]
Operator wrapper for public.eql\_v3\_text\_eq.
Parameters [#parameters-174]
| Name | Type | Description |
| ----------- | ---------------- | ----------- |
| `a public.` | `eql_v3_text_eq` | |
| `b` | `jsonb` | |
Returns [#returns-173]
**Type:** `boolean`
boolean
***
eq(eql_v3_text_eq, eql_v3_text_eq) [#eqeql_v3_text_eq-eql_v3_text_eq]
Operator wrapper for public.eql\_v3\_text\_eq.
Parameters [#parameters-175]
| Name | Type | Description |
| ----------- | ---------------- | ----------- |
| `a public.` | `eql_v3_text_eq` | |
| `b public.` | `eql_v3_text_eq` | |
Returns [#returns-174]
**Type:** `boolean`
boolean
***
eq(jsonb, eql_v3_integer_eq) [#eqjsonb-eql_v3_integer_eq]
Operator wrapper for public.eql\_v3\_integer\_eq.
Parameters [#parameters-176]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_integer_eq` | |
Returns [#returns-175]
**Type:** `boolean`
boolean
***
eq(eql_v3_integer_eq, jsonb) [#eqeql_v3_integer_eq-jsonb]
Operator wrapper for public.eql\_v3\_integer\_eq.
Parameters [#parameters-177]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a public.` | `eql_v3_integer_eq` | |
| `b` | `jsonb` | |
Returns [#returns-176]
**Type:** `boolean`
boolean
***
eq(eql_v3_integer_eq, eql_v3_integer_eq) [#eqeql_v3_integer_eq-eql_v3_integer_eq]
Operator wrapper for public.eql\_v3\_integer\_eq.
Parameters [#parameters-178]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a public.` | `eql_v3_integer_eq` | |
| `b public.` | `eql_v3_integer_eq` | |
Returns [#returns-177]
**Type:** `boolean`
boolean
***
eq(query_integer_eq, eql_v3_integer_eq) [#eqquery_integer_eq-eql_v3_integer_eq]
Operator wrapper for eql\_v3.query\_integer\_eq.
Parameters [#parameters-179]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a eql_v3.` | `query_integer_eq` | |
| `b public.` | `eql_v3_integer_eq` | |
Returns [#returns-178]
**Type:** `boolean`
boolean
***
eq(eql_v3_integer_eq, query_integer_eq) [#eqeql_v3_integer_eq-query_integer_eq]
Operator wrapper for eql\_v3.query\_integer\_eq.
Parameters [#parameters-180]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a public.` | `eql_v3_integer_eq` | |
| `b eql_v3.` | `query_integer_eq` | |
Returns [#returns-179]
**Type:** `boolean`
boolean
***
eq(jsonb, eql_v3_smallint_ord_ore) [#eqjsonb-eql_v3_smallint_ord_ore]
Operator wrapper for public.eql\_v3\_smallint\_ord\_ore.
Parameters [#parameters-181]
| Name | Type | Description |
| ----------- | ------------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_smallint_ord_ore` | |
Returns [#returns-180]
**Type:** `boolean`
boolean
***
eq(eql_v3_smallint_ord_ore, jsonb) [#eqeql_v3_smallint_ord_ore-jsonb]
Operator wrapper for public.eql\_v3\_smallint\_ord\_ore.
Parameters [#parameters-182]
| Name | Type | Description |
| ----------- | ------------------------- | ----------- |
| `a public.` | `eql_v3_smallint_ord_ore` | |
| `b` | `jsonb` | |
Returns [#returns-181]
**Type:** `boolean`
boolean
***
eq(eql_v3_smallint_ord_ore, eql_v3_smallint_ord_ore) [#eqeql_v3_smallint_ord_ore-eql_v3_smallint_ord_ore]
Operator wrapper for public.eql\_v3\_smallint\_ord\_ore.
Parameters [#parameters-183]
| Name | Type | Description |
| ----------- | ------------------------- | ----------- |
| `a public.` | `eql_v3_smallint_ord_ore` | |
| `b public.` | `eql_v3_smallint_ord_ore` | |
Returns [#returns-182]
**Type:** `boolean`
boolean
***
eq(jsonb, eql_v3_date_ord_ope) [#eqjsonb-eql_v3_date_ord_ope]
Operator wrapper for public.eql\_v3\_date\_ord\_ope.
Parameters [#parameters-184]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_date_ord_ope` | |
Returns [#returns-183]
**Type:** `boolean`
boolean
***
eq(eql_v3_date_ord_ope, jsonb) [#eqeql_v3_date_ord_ope-jsonb]
Operator wrapper for public.eql\_v3\_date\_ord\_ope.
Parameters [#parameters-185]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_date_ord_ope` | |
| `b` | `jsonb` | |
Returns [#returns-184]
**Type:** `boolean`
boolean
***
eq(eql_v3_date_ord_ope, eql_v3_date_ord_ope) [#eqeql_v3_date_ord_ope-eql_v3_date_ord_ope]
Operator wrapper for public.eql\_v3\_date\_ord\_ope.
Parameters [#parameters-186]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_date_ord_ope` | |
| `b public.` | `eql_v3_date_ord_ope` | |
Returns [#returns-185]
**Type:** `boolean`
boolean
***
eq(query_bigint_ord, eql_v3_bigint_ord) [#eqquery_bigint_ord-eql_v3_bigint_ord]
Operator wrapper for eql\_v3.query\_bigint\_ord.
Parameters [#parameters-187]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a eql_v3.` | `query_bigint_ord` | |
| `b public.` | `eql_v3_bigint_ord` | |
Returns [#returns-186]
**Type:** `boolean`
boolean
***
eq(eql_v3_bigint_ord, query_bigint_ord) [#eqeql_v3_bigint_ord-query_bigint_ord]
Operator wrapper for eql\_v3.query\_bigint\_ord.
Parameters [#parameters-188]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a public.` | `eql_v3_bigint_ord` | |
| `b eql_v3.` | `query_bigint_ord` | |
Returns [#returns-187]
**Type:** `boolean`
boolean
***
eq(jsonb, eql_v3_text_ord_ore) [#eqjsonb-eql_v3_text_ord_ore]
Operator wrapper for public.eql\_v3\_text\_ord\_ore.
Parameters [#parameters-189]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_text_ord_ore` | |
Returns [#returns-188]
**Type:** `boolean`
boolean
***
eq(eql_v3_text_ord_ore, jsonb) [#eqeql_v3_text_ord_ore-jsonb]
Operator wrapper for public.eql\_v3\_text\_ord\_ore.
Parameters [#parameters-190]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_text_ord_ore` | |
| `b` | `jsonb` | |
Returns [#returns-189]
**Type:** `boolean`
boolean
***
eq(eql_v3_text_ord_ore, eql_v3_text_ord_ore) [#eqeql_v3_text_ord_ore-eql_v3_text_ord_ore]
Operator wrapper for public.eql\_v3\_text\_ord\_ore.
Parameters [#parameters-191]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_text_ord_ore` | |
| `b public.` | `eql_v3_text_ord_ore` | |
Returns [#returns-190]
**Type:** `boolean`
boolean
***
eq_term(eql_v3_text_ord) [#eq_termeql_v3_text_ord]
Index extractor for public.eql\_v3\_text\_ord.
Parameters [#parameters-192]
| Name | Type | Description |
| ----------- | ----------------- | ----------- |
| `a public.` | `eql_v3_text_ord` | |
Returns [#returns-191]
**Type:** `eql_v3_internal.hmac_256`
eql\_v3\_internal.hmac\_256
***
eq_term(query_text_ord) [#eq_termquery_text_ord]
Index extractor for eql\_v3.query\_text\_ord.
Parameters [#parameters-193]
| Name | Type | Description |
| ----------- | ---------------- | ----------- |
| `a eql_v3.` | `query_text_ord` | |
Returns [#returns-192]
**Type:** `eql_v3_internal.hmac_256`
eql\_v3\_internal.hmac\_256
***
eq_term(query_text_search) [#eq_termquery_text_search]
Index extractor for eql\_v3.query\_text\_search.
Parameters [#parameters-194]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a eql_v3.` | `query_text_search` | |
Returns [#returns-193]
**Type:** `eql_v3_internal.hmac_256`
eql\_v3\_internal.hmac\_256
***
eq_term(query_numeric_eq) [#eq_termquery_numeric_eq]
Index extractor for eql\_v3.query\_numeric\_eq.
Parameters [#parameters-195]
| Name | Type | Description |
| ----------- | ------------------ | ----------- |
| `a eql_v3.` | `query_numeric_eq` | |
Returns [#returns-194]
**Type:** `eql_v3_internal.hmac_256`
eql\_v3\_internal.hmac\_256
***
eq_term(eql_v3_bigint_eq) [#eq_termeql_v3_bigint_eq]
Index extractor for public.eql\_v3\_bigint\_eq.
Parameters [#parameters-196]
| Name | Type | Description |
| ----------- | ------------------ | ----------- |
| `a public.` | `eql_v3_bigint_eq` | |
Returns [#returns-195]
**Type:** `eql_v3_internal.hmac_256`
eql\_v3\_internal.hmac\_256
***
eq_term(query_smallint_eq) [#eq_termquery_smallint_eq]
Index extractor for eql\_v3.query\_smallint\_eq.
Parameters [#parameters-197]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a eql_v3.` | `query_smallint_eq` | |
Returns [#returns-196]
**Type:** `eql_v3_internal.hmac_256`
eql\_v3\_internal.hmac\_256
***
eq_term(query_text_search_ore) [#eq_termquery_text_search_ore]
Index extractor for eql\_v3.query\_text\_search\_ore.
Parameters [#parameters-198]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a eql_v3.` | `query_text_search_ore` | |
Returns [#returns-197]
**Type:** `eql_v3_internal.hmac_256`
eql\_v3\_internal.hmac\_256
***
eq_term(query_text_ord_ore) [#eq_termquery_text_ord_ore]
Index extractor for eql\_v3.query\_text\_ord\_ore.
Parameters [#parameters-199]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a eql_v3.` | `query_text_ord_ore` | |
Returns [#returns-198]
**Type:** `eql_v3_internal.hmac_256`
eql\_v3\_internal.hmac\_256
***
eq_term(eql_v3_timestamp_eq) [#eq_termeql_v3_timestamp_eq]
Index extractor for public.eql\_v3\_timestamp\_eq.
Parameters [#parameters-200]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_timestamp_eq` | |
Returns [#returns-199]
**Type:** `eql_v3_internal.hmac_256`
eql\_v3\_internal.hmac\_256
***
eq_term(eql_v3_text_ord_ope) [#eq_termeql_v3_text_ord_ope]
Index extractor for public.eql\_v3\_text\_ord\_ope.
Parameters [#parameters-201]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_text_ord_ope` | |
Returns [#returns-200]
**Type:** `eql_v3_internal.hmac_256`
eql\_v3\_internal.hmac\_256
***
eq_term(eql_v3_real_eq) [#eq_termeql_v3_real_eq]
Index extractor for public.eql\_v3\_real\_eq.
Parameters [#parameters-202]
| Name | Type | Description |
| ----------- | ---------------- | ----------- |
| `a public.` | `eql_v3_real_eq` | |
Returns [#returns-201]
**Type:** `eql_v3_internal.hmac_256`
eql\_v3\_internal.hmac\_256
***
eq_term(query_text_eq) [#eq_termquery_text_eq]
Index extractor for eql\_v3.query\_text\_eq.
Parameters [#parameters-203]
| Name | Type | Description |
| ----------- | --------------- | ----------- |
| `a eql_v3.` | `query_text_eq` | |
Returns [#returns-202]
**Type:** `eql_v3_internal.hmac_256`
eql\_v3\_internal.hmac\_256
***
eq_term(eql_v3_double_eq) [#eq_termeql_v3_double_eq]
Index extractor for public.eql\_v3\_double\_eq.
Parameters [#parameters-204]
| Name | Type | Description |
| ----------- | ------------------ | ----------- |
| `a public.` | `eql_v3_double_eq` | |
Returns [#returns-203]
**Type:** `eql_v3_internal.hmac_256`
eql\_v3\_internal.hmac\_256
***
eq_term(query_double_eq) [#eq_termquery_double_eq]
Index extractor for eql\_v3.query\_double\_eq.
Parameters [#parameters-205]
| Name | Type | Description |
| ----------- | ----------------- | ----------- |
| `a eql_v3.` | `query_double_eq` | |
Returns [#returns-204]
**Type:** `eql_v3_internal.hmac_256`
eql\_v3\_internal.hmac\_256
***
eq_term(eql_v3_json_entry) [#eq_termeql_v3_json_entry]
Deprecated compatibility alias for eql\_v3.ope\_term(json\_entry).
Parameters [#parameters-206]
| Name | Type | Description |
| --------------- | ------------------- | ----------- |
| `entry public.` | `eql_v3_json_entry` | |
Returns [#returns-205]
**Type:** `bytea`
bytea Decoded op bytes (NULL when the entry has no op).
***
eq_term(query_text_ord_ope) [#eq_termquery_text_ord_ope]
Index extractor for eql\_v3.query\_text\_ord\_ope.
Parameters [#parameters-207]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a eql_v3.` | `query_text_ord_ope` | |
Returns [#returns-206]
**Type:** `eql_v3_internal.hmac_256`
eql\_v3\_internal.hmac\_256
***
eq_term(query_real_eq) [#eq_termquery_real_eq]
Index extractor for eql\_v3.query\_real\_eq.
Parameters [#parameters-208]
| Name | Type | Description |
| ----------- | --------------- | ----------- |
| `a eql_v3.` | `query_real_eq` | |
Returns [#returns-207]
**Type:** `eql_v3_internal.hmac_256`
eql\_v3\_internal.hmac\_256
***
eq_term(eql_v3_text_search_ore) [#eq_termeql_v3_text_search_ore]
Index extractor for public.eql\_v3\_text\_search\_ore.
Parameters [#parameters-209]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a public.` | `eql_v3_text_search_ore` | |
Returns [#returns-208]
**Type:** `eql_v3_internal.hmac_256`
eql\_v3\_internal.hmac\_256
***
eq_term(query_bigint_eq) [#eq_termquery_bigint_eq]
Index extractor for eql\_v3.query\_bigint\_eq.
Parameters [#parameters-210]
| Name | Type | Description |
| ----------- | ----------------- | ----------- |
| `a eql_v3.` | `query_bigint_eq` | |
Returns [#returns-209]
**Type:** `eql_v3_internal.hmac_256`
eql\_v3\_internal.hmac\_256
***
eq_term(query_timestamp_eq) [#eq_termquery_timestamp_eq]
Index extractor for eql\_v3.query\_timestamp\_eq.
Parameters [#parameters-211]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a eql_v3.` | `query_timestamp_eq` | |
Returns [#returns-210]
**Type:** `eql_v3_internal.hmac_256`
eql\_v3\_internal.hmac\_256
***
eq_term(eql_v3_numeric_eq) [#eq_termeql_v3_numeric_eq]
Index extractor for public.eql\_v3\_numeric\_eq.
Parameters [#parameters-212]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a public.` | `eql_v3_numeric_eq` | |
Returns [#returns-211]
**Type:** `eql_v3_internal.hmac_256`
eql\_v3\_internal.hmac\_256
***
eq_term(query_date_eq) [#eq_termquery_date_eq]
Index extractor for eql\_v3.query\_date\_eq.
Parameters [#parameters-213]
| Name | Type | Description |
| ----------- | --------------- | ----------- |
| `a eql_v3.` | `query_date_eq` | |
Returns [#returns-212]
**Type:** `eql_v3_internal.hmac_256`
eql\_v3\_internal.hmac\_256
***
eq_term(eql_v3_text_search) [#eq_termeql_v3_text_search]
Index extractor for public.eql\_v3\_text\_search.
Parameters [#parameters-214]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a public.` | `eql_v3_text_search` | |
Returns [#returns-213]
**Type:** `eql_v3_internal.hmac_256`
eql\_v3\_internal.hmac\_256
***
eq_term(eql_v3_smallint_eq) [#eq_termeql_v3_smallint_eq]
Index extractor for public.eql\_v3\_smallint\_eq.
Parameters [#parameters-215]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a public.` | `eql_v3_smallint_eq` | |
Returns [#returns-214]
**Type:** `eql_v3_internal.hmac_256`
eql\_v3\_internal.hmac\_256
***
eq_term(eql_v3_date_eq) [#eq_termeql_v3_date_eq]
Index extractor for public.eql\_v3\_date\_eq.
Parameters [#parameters-216]
| Name | Type | Description |
| ----------- | ---------------- | ----------- |
| `a public.` | `eql_v3_date_eq` | |
Returns [#returns-215]
**Type:** `eql_v3_internal.hmac_256`
eql\_v3\_internal.hmac\_256
***
eq_term(eql_v3_text_eq) [#eq_termeql_v3_text_eq]
Index extractor for public.eql\_v3\_text\_eq.
Parameters [#parameters-217]
| Name | Type | Description |
| ----------- | ---------------- | ----------- |
| `a public.` | `eql_v3_text_eq` | |
Returns [#returns-216]
**Type:** `eql_v3_internal.hmac_256`
eql\_v3\_internal.hmac\_256
***
eq_term(eql_v3_integer_eq) [#eq_termeql_v3_integer_eq]
Index extractor for public.eql\_v3\_integer\_eq.
Parameters [#parameters-218]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a public.` | `eql_v3_integer_eq` | |
Returns [#returns-217]
**Type:** `eql_v3_internal.hmac_256`
eql\_v3\_internal.hmac\_256
***
eq_term(query_integer_eq) [#eq_termquery_integer_eq]
Index extractor for eql\_v3.query\_integer\_eq.
Parameters [#parameters-219]
| Name | Type | Description |
| ----------- | ------------------ | ----------- |
| `a eql_v3.` | `query_integer_eq` | |
Returns [#returns-218]
**Type:** `eql_v3_internal.hmac_256`
eql\_v3\_internal.hmac\_256
***
eq_term(eql_v3_text_ord_ore) [#eq_termeql_v3_text_ord_ore]
Index extractor for public.eql\_v3\_text\_ord\_ore.
Parameters [#parameters-220]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_text_ord_ore` | |
Returns [#returns-219]
**Type:** `eql_v3_internal.hmac_256`
eql\_v3\_internal.hmac\_256
***
eql_v3_is_valid_ste_vec_document_payload(jsonb) [#eql_v3_is_valid_ste_vec_document_payloadjsonb]
Validate a root SteVec document payload.
Parameters [#parameters-221]
| Name | Type | Description |
| ----- | ------- | ----------- |
| `val` | `jsonb` | |
***
eql_v3_is_valid_ste_vec_entry_payload(jsonb) [#eql_v3_is_valid_ste_vec_entry_payloadjsonb]
Validate a single SteVec entry payload.
Parameters [#parameters-222]
| Name | Type | Description |
| ----- | ------- | ----------- |
| `val` | `jsonb` | |
***
eql_v3_is_valid_ste_vec_query_payload(jsonb) [#eql_v3_is_valid_ste_vec_query_payloadjsonb]
Validate a SteVec containment query payload.
Parameters [#parameters-223]
| Name | Type | Description |
| ----- | ------- | ----------- |
| `val` | `jsonb` | |
***
grouped_value(jsonb) [#grouped_valuejsonb]
Return a representative (first non-null) encrypted value per group.
Returns the first non-null value encountered within a GROUP BY group. Its primary use is projecting an encrypted column while grouping by that column's equality term (GROUP BY eql\_v3.eq\_term(col)), where PostgreSQL will not let you SELECT col directly — see the file header for the worked example. Accepts any eql\_v3 encrypted-domain value (each is a jsonb-backed domain) and returns it unchanged, performing no decryption or comparison. PARALLEL SAFE with a combine function, so it works under partial/parallel aggregation on large GROUP BY workloads.
SELECT eql\_v3.grouped\_value(encrypted\_foo) AS encrypted\_foo, count(\*) FROM some\_table GROUP BY eql\_v3.eq\_term(encrypted\_foo);
Parameters [#parameters-224]
| Name | Type | Description |
| ------- | ------- | ------------------------------ |
| `input` | `jsonb` | Encrypted values to aggregate. |
Returns [#returns-220]
**Type:** `jsonb`
jsonb The first non-null value in the group.
Note [#note-1]
Which value is "first" is arbitrary in the absence of an ordering, and is not deterministic under parallel aggregation. That is exactly what is wanted for the group-by-eq\_term case (every value in a group is an encryption of the same plaintext, so any one represents the group) and it matches the eql\_v2 original.
Variants [#variants]
* eql\_v3.eq\_term
***
gt(jsonb, eql_v3_integer_ord_ore) [#gtjsonb-eql_v3_integer_ord_ore]
Operator wrapper for public.eql\_v3\_integer\_ord\_ore.
Parameters [#parameters-225]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_integer_ord_ore` | |
Returns [#returns-221]
**Type:** `boolean`
boolean
***
gt(eql_v3_integer_ord_ore, jsonb) [#gteql_v3_integer_ord_ore-jsonb]
Operator wrapper for public.eql\_v3\_integer\_ord\_ore.
Parameters [#parameters-226]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a public.` | `eql_v3_integer_ord_ore` | |
| `b` | `jsonb` | |
Returns [#returns-222]
**Type:** `boolean`
boolean
***
gt(eql_v3_integer_ord_ore, eql_v3_integer_ord_ore) [#gteql_v3_integer_ord_ore-eql_v3_integer_ord_ore]
Operator wrapper for public.eql\_v3\_integer\_ord\_ore.
Parameters [#parameters-227]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a public.` | `eql_v3_integer_ord_ore` | |
| `b public.` | `eql_v3_integer_ord_ore` | |
Returns [#returns-223]
**Type:** `boolean`
boolean
***
gt(query_smallint_ord, eql_v3_smallint_ord) [#gtquery_smallint_ord-eql_v3_smallint_ord]
Operator wrapper for eql\_v3.query\_smallint\_ord.
Parameters [#parameters-228]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a eql_v3.` | `query_smallint_ord` | |
| `b public.` | `eql_v3_smallint_ord` | |
Returns [#returns-224]
**Type:** `boolean`
boolean
***
gt(eql_v3_smallint_ord, query_smallint_ord) [#gteql_v3_smallint_ord-query_smallint_ord]
Operator wrapper for eql\_v3.query\_smallint\_ord.
Parameters [#parameters-229]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_smallint_ord` | |
| `b eql_v3.` | `query_smallint_ord` | |
Returns [#returns-225]
**Type:** `boolean`
boolean
***
gt(jsonb, eql_v3_smallint_ord) [#gtjsonb-eql_v3_smallint_ord]
Operator wrapper for public.eql\_v3\_smallint\_ord.
Parameters [#parameters-230]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_smallint_ord` | |
Returns [#returns-226]
**Type:** `boolean`
boolean
***
gt(eql_v3_smallint_ord, jsonb) [#gteql_v3_smallint_ord-jsonb]
Operator wrapper for public.eql\_v3\_smallint\_ord.
Parameters [#parameters-231]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_smallint_ord` | |
| `b` | `jsonb` | |
Returns [#returns-227]
**Type:** `boolean`
boolean
***
gt(eql_v3_smallint_ord, eql_v3_smallint_ord) [#gteql_v3_smallint_ord-eql_v3_smallint_ord]
Operator wrapper for public.eql\_v3\_smallint\_ord.
Parameters [#parameters-232]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_smallint_ord` | |
| `b public.` | `eql_v3_smallint_ord` | |
Returns [#returns-228]
**Type:** `boolean`
boolean
***
gt(jsonb, eql_v3_date_ord) [#gtjsonb-eql_v3_date_ord]
Operator wrapper for public.eql\_v3\_date\_ord.
Parameters [#parameters-233]
| Name | Type | Description |
| ----------- | ----------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_date_ord` | |
Returns [#returns-229]
**Type:** `boolean`
boolean
***
gt(eql_v3_date_ord, jsonb) [#gteql_v3_date_ord-jsonb]
Operator wrapper for public.eql\_v3\_date\_ord.
Parameters [#parameters-234]
| Name | Type | Description |
| ----------- | ----------------- | ----------- |
| `a public.` | `eql_v3_date_ord` | |
| `b` | `jsonb` | |
Returns [#returns-230]
**Type:** `boolean`
boolean
***
gt(eql_v3_date_ord, eql_v3_date_ord) [#gteql_v3_date_ord-eql_v3_date_ord]
Operator wrapper for public.eql\_v3\_date\_ord.
Parameters [#parameters-235]
| Name | Type | Description |
| ----------- | ----------------- | ----------- |
| `a public.` | `eql_v3_date_ord` | |
| `b public.` | `eql_v3_date_ord` | |
Returns [#returns-231]
**Type:** `boolean`
boolean
***
gt(query_real_ord, eql_v3_real_ord) [#gtquery_real_ord-eql_v3_real_ord]
Operator wrapper for eql\_v3.query\_real\_ord.
Parameters [#parameters-236]
| Name | Type | Description |
| ----------- | ----------------- | ----------- |
| `a eql_v3.` | `query_real_ord` | |
| `b public.` | `eql_v3_real_ord` | |
Returns [#returns-232]
**Type:** `boolean`
boolean
***
gt(eql_v3_real_ord, query_real_ord) [#gteql_v3_real_ord-query_real_ord]
Operator wrapper for eql\_v3.query\_real\_ord.
Parameters [#parameters-237]
| Name | Type | Description |
| ----------- | ----------------- | ----------- |
| `a public.` | `eql_v3_real_ord` | |
| `b eql_v3.` | `query_real_ord` | |
Returns [#returns-233]
**Type:** `boolean`
boolean
***
gt(query_double_ord, eql_v3_json_entry) [#gtquery_double_ord-eql_v3_json_entry]
Operator wrapper for public.eql\_v3\_json\_entry.
Parameters [#parameters-238]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a eql_v3.` | `query_double_ord` | |
| `b public.` | `eql_v3_json_entry` | |
Returns [#returns-234]
**Type:** `boolean`
boolean
***
gt(eql_v3_json_entry, query_double_ord) [#gteql_v3_json_entry-query_double_ord]
Operator wrapper for public.eql\_v3\_json\_entry.
Parameters [#parameters-239]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a public.` | `eql_v3_json_entry` | |
| `b eql_v3.` | `query_double_ord` | |
Returns [#returns-235]
**Type:** `boolean`
boolean
***
gt(query_real_ord_ore, eql_v3_real_ord_ore) [#gtquery_real_ord_ore-eql_v3_real_ord_ore]
Operator wrapper for eql\_v3.query\_real\_ord\_ore.
Parameters [#parameters-240]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a eql_v3.` | `query_real_ord_ore` | |
| `b public.` | `eql_v3_real_ord_ore` | |
Returns [#returns-236]
**Type:** `boolean`
boolean
***
gt(eql_v3_real_ord_ore, query_real_ord_ore) [#gteql_v3_real_ord_ore-query_real_ord_ore]
Operator wrapper for eql\_v3.query\_real\_ord\_ore.
Parameters [#parameters-241]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_real_ord_ore` | |
| `b eql_v3.` | `query_real_ord_ore` | |
Returns [#returns-237]
**Type:** `boolean`
boolean
***
gt(jsonb, eql_v3_text_ord) [#gtjsonb-eql_v3_text_ord]
Operator wrapper for public.eql\_v3\_text\_ord.
Parameters [#parameters-242]
| Name | Type | Description |
| ----------- | ----------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_text_ord` | |
Returns [#returns-238]
**Type:** `boolean`
boolean
***
gt(eql_v3_text_ord, jsonb) [#gteql_v3_text_ord-jsonb]
Operator wrapper for public.eql\_v3\_text\_ord.
Parameters [#parameters-243]
| Name | Type | Description |
| ----------- | ----------------- | ----------- |
| `a public.` | `eql_v3_text_ord` | |
| `b` | `jsonb` | |
Returns [#returns-239]
**Type:** `boolean`
boolean
***
gt(eql_v3_text_ord, eql_v3_text_ord) [#gteql_v3_text_ord-eql_v3_text_ord]
Operator wrapper for public.eql\_v3\_text\_ord.
Parameters [#parameters-244]
| Name | Type | Description |
| ----------- | ----------------- | ----------- |
| `a public.` | `eql_v3_text_ord` | |
| `b public.` | `eql_v3_text_ord` | |
Returns [#returns-240]
**Type:** `boolean`
boolean
***
gt(query_integer_ord_ope, eql_v3_integer_ord_ope) [#gtquery_integer_ord_ope-eql_v3_integer_ord_ope]
Operator wrapper for eql\_v3.query\_integer\_ord\_ope.
Parameters [#parameters-245]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a eql_v3.` | `query_integer_ord_ope` | |
| `b public.` | `eql_v3_integer_ord_ope` | |
Returns [#returns-241]
**Type:** `boolean`
boolean
***
gt(eql_v3_integer_ord_ope, query_integer_ord_ope) [#gteql_v3_integer_ord_ope-query_integer_ord_ope]
Operator wrapper for eql\_v3.query\_integer\_ord\_ope.
Parameters [#parameters-246]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a public.` | `eql_v3_integer_ord_ope` | |
| `b eql_v3.` | `query_integer_ord_ope` | |
Returns [#returns-242]
**Type:** `boolean`
boolean
***
gt(query_text_ord, eql_v3_text_ord) [#gtquery_text_ord-eql_v3_text_ord]
Operator wrapper for eql\_v3.query\_text\_ord.
Parameters [#parameters-247]
| Name | Type | Description |
| ----------- | ----------------- | ----------- |
| `a eql_v3.` | `query_text_ord` | |
| `b public.` | `eql_v3_text_ord` | |
Returns [#returns-243]
**Type:** `boolean`
boolean
***
gt(eql_v3_text_ord, query_text_ord) [#gteql_v3_text_ord-query_text_ord]
Operator wrapper for eql\_v3.query\_text\_ord.
Parameters [#parameters-248]
| Name | Type | Description |
| ----------- | ----------------- | ----------- |
| `a public.` | `eql_v3_text_ord` | |
| `b eql_v3.` | `query_text_ord` | |
Returns [#returns-244]
**Type:** `boolean`
boolean
***
gt(jsonb, eql_v3_timestamp_ord_ope) [#gtjsonb-eql_v3_timestamp_ord_ope]
Operator wrapper for public.eql\_v3\_timestamp\_ord\_ope.
Parameters [#parameters-249]
| Name | Type | Description |
| ----------- | -------------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_timestamp_ord_ope` | |
Returns [#returns-245]
**Type:** `boolean`
boolean
***
gt(eql_v3_timestamp_ord_ope, jsonb) [#gteql_v3_timestamp_ord_ope-jsonb]
Operator wrapper for public.eql\_v3\_timestamp\_ord\_ope.
Parameters [#parameters-250]
| Name | Type | Description |
| ----------- | -------------------------- | ----------- |
| `a public.` | `eql_v3_timestamp_ord_ope` | |
| `b` | `jsonb` | |
Returns [#returns-246]
**Type:** `boolean`
boolean
***
gt(eql_v3_timestamp_ord_ope, eql_v3_timestamp_ord_ope) [#gteql_v3_timestamp_ord_ope-eql_v3_timestamp_ord_ope]
Operator wrapper for public.eql\_v3\_timestamp\_ord\_ope.
Parameters [#parameters-251]
| Name | Type | Description |
| ----------- | -------------------------- | ----------- |
| `a public.` | `eql_v3_timestamp_ord_ope` | |
| `b public.` | `eql_v3_timestamp_ord_ope` | |
Returns [#returns-247]
**Type:** `boolean`
boolean
***
gt(jsonb, eql_v3_integer_ord_ope) [#gtjsonb-eql_v3_integer_ord_ope]
Operator wrapper for public.eql\_v3\_integer\_ord\_ope.
Parameters [#parameters-252]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_integer_ord_ope` | |
Returns [#returns-248]
**Type:** `boolean`
boolean
***
gt(eql_v3_integer_ord_ope, jsonb) [#gteql_v3_integer_ord_ope-jsonb]
Operator wrapper for public.eql\_v3\_integer\_ord\_ope.
Parameters [#parameters-253]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a public.` | `eql_v3_integer_ord_ope` | |
| `b` | `jsonb` | |
Returns [#returns-249]
**Type:** `boolean`
boolean
***
gt(eql_v3_integer_ord_ope, eql_v3_integer_ord_ope) [#gteql_v3_integer_ord_ope-eql_v3_integer_ord_ope]
Operator wrapper for public.eql\_v3\_integer\_ord\_ope.
Parameters [#parameters-254]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a public.` | `eql_v3_integer_ord_ope` | |
| `b public.` | `eql_v3_integer_ord_ope` | |
Returns [#returns-250]
**Type:** `boolean`
boolean
***
gt(query_integer_ord, eql_v3_integer_ord) [#gtquery_integer_ord-eql_v3_integer_ord]
Operator wrapper for eql\_v3.query\_integer\_ord.
Parameters [#parameters-255]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a eql_v3.` | `query_integer_ord` | |
| `b public.` | `eql_v3_integer_ord` | |
Returns [#returns-251]
**Type:** `boolean`
boolean
***
gt(eql_v3_integer_ord, query_integer_ord) [#gteql_v3_integer_ord-query_integer_ord]
Operator wrapper for eql\_v3.query\_integer\_ord.
Parameters [#parameters-256]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a public.` | `eql_v3_integer_ord` | |
| `b eql_v3.` | `query_integer_ord` | |
Returns [#returns-252]
**Type:** `boolean`
boolean
***
gt(query_text_search, eql_v3_text_search) [#gtquery_text_search-eql_v3_text_search]
Operator wrapper for eql\_v3.query\_text\_search.
Parameters [#parameters-257]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a eql_v3.` | `query_text_search` | |
| `b public.` | `eql_v3_text_search` | |
Returns [#returns-253]
**Type:** `boolean`
boolean
***
gt(eql_v3_text_search, query_text_search) [#gteql_v3_text_search-query_text_search]
Operator wrapper for eql\_v3.query\_text\_search.
Parameters [#parameters-258]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a public.` | `eql_v3_text_search` | |
| `b eql_v3.` | `query_text_search` | |
Returns [#returns-254]
**Type:** `boolean`
boolean
***
gt(jsonb, eql_v3_numeric_ord) [#gtjsonb-eql_v3_numeric_ord]
Operator wrapper for public.eql\_v3\_numeric\_ord.
Parameters [#parameters-259]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_numeric_ord` | |
Returns [#returns-255]
**Type:** `boolean`
boolean
***
gt(eql_v3_numeric_ord, jsonb) [#gteql_v3_numeric_ord-jsonb]
Operator wrapper for public.eql\_v3\_numeric\_ord.
Parameters [#parameters-260]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a public.` | `eql_v3_numeric_ord` | |
| `b` | `jsonb` | |
Returns [#returns-256]
**Type:** `boolean`
boolean
***
gt(eql_v3_numeric_ord, eql_v3_numeric_ord) [#gteql_v3_numeric_ord-eql_v3_numeric_ord]
Operator wrapper for public.eql\_v3\_numeric\_ord.
Parameters [#parameters-261]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a public.` | `eql_v3_numeric_ord` | |
| `b public.` | `eql_v3_numeric_ord` | |
Returns [#returns-257]
**Type:** `boolean`
boolean
***
gt(query_date_ord_ope, eql_v3_date_ord_ope) [#gtquery_date_ord_ope-eql_v3_date_ord_ope]
Operator wrapper for eql\_v3.query\_date\_ord\_ope.
Parameters [#parameters-262]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a eql_v3.` | `query_date_ord_ope` | |
| `b public.` | `eql_v3_date_ord_ope` | |
Returns [#returns-258]
**Type:** `boolean`
boolean
***
gt(eql_v3_date_ord_ope, query_date_ord_ope) [#gteql_v3_date_ord_ope-query_date_ord_ope]
Operator wrapper for eql\_v3.query\_date\_ord\_ope.
Parameters [#parameters-263]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_date_ord_ope` | |
| `b eql_v3.` | `query_date_ord_ope` | |
Returns [#returns-259]
**Type:** `boolean`
boolean
***
gt(query_smallint_ord, eql_v3_json_entry) [#gtquery_smallint_ord-eql_v3_json_entry]
Operator wrapper for public.eql\_v3\_json\_entry.
Parameters [#parameters-264]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a eql_v3.` | `query_smallint_ord` | |
| `b public.` | `eql_v3_json_entry` | |
Returns [#returns-260]
**Type:** `boolean`
boolean
***
gt(eql_v3_json_entry, query_smallint_ord) [#gteql_v3_json_entry-query_smallint_ord]
Operator wrapper for public.eql\_v3\_json\_entry.
Parameters [#parameters-265]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a public.` | `eql_v3_json_entry` | |
| `b eql_v3.` | `query_smallint_ord` | |
Returns [#returns-261]
**Type:** `boolean`
boolean
***
gt(query_timestamp_ord_ore, eql_v3_timestamp_ord_ore) [#gtquery_timestamp_ord_ore-eql_v3_timestamp_ord_ore]
Operator wrapper for eql\_v3.query\_timestamp\_ord\_ore.
Parameters [#parameters-266]
| Name | Type | Description |
| ----------- | -------------------------- | ----------- |
| `a eql_v3.` | `query_timestamp_ord_ore` | |
| `b public.` | `eql_v3_timestamp_ord_ore` | |
Returns [#returns-262]
**Type:** `boolean`
boolean
***
gt(eql_v3_timestamp_ord_ore, query_timestamp_ord_ore) [#gteql_v3_timestamp_ord_ore-query_timestamp_ord_ore]
Operator wrapper for eql\_v3.query\_timestamp\_ord\_ore.
Parameters [#parameters-267]
| Name | Type | Description |
| ----------- | -------------------------- | ----------- |
| `a public.` | `eql_v3_timestamp_ord_ore` | |
| `b eql_v3.` | `query_timestamp_ord_ore` | |
Returns [#returns-263]
**Type:** `boolean`
boolean
***
gt(query_text_search_ore, eql_v3_text_search_ore) [#gtquery_text_search_ore-eql_v3_text_search_ore]
Operator wrapper for eql\_v3.query\_text\_search\_ore.
Parameters [#parameters-268]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a eql_v3.` | `query_text_search_ore` | |
| `b public.` | `eql_v3_text_search_ore` | |
Returns [#returns-264]
**Type:** `boolean`
boolean
***
gt(eql_v3_text_search_ore, query_text_search_ore) [#gteql_v3_text_search_ore-query_text_search_ore]
Operator wrapper for eql\_v3.query\_text\_search\_ore.
Parameters [#parameters-269]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a public.` | `eql_v3_text_search_ore` | |
| `b eql_v3.` | `query_text_search_ore` | |
Returns [#returns-265]
**Type:** `boolean`
boolean
***
gt(query_text_ord_ore, eql_v3_text_ord_ore) [#gtquery_text_ord_ore-eql_v3_text_ord_ore]
Operator wrapper for eql\_v3.query\_text\_ord\_ore.
Parameters [#parameters-270]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a eql_v3.` | `query_text_ord_ore` | |
| `b public.` | `eql_v3_text_ord_ore` | |
Returns [#returns-266]
**Type:** `boolean`
boolean
***
gt(eql_v3_text_ord_ore, query_text_ord_ore) [#gteql_v3_text_ord_ore-query_text_ord_ore]
Operator wrapper for eql\_v3.query\_text\_ord\_ore.
Parameters [#parameters-271]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_text_ord_ore` | |
| `b eql_v3.` | `query_text_ord_ore` | |
Returns [#returns-267]
**Type:** `boolean`
boolean
***
gt(jsonb, eql_v3_real_ord_ope) [#gtjsonb-eql_v3_real_ord_ope]
Operator wrapper for public.eql\_v3\_real\_ord\_ope.
Parameters [#parameters-272]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_real_ord_ope` | |
Returns [#returns-268]
**Type:** `boolean`
boolean
***
gt(eql_v3_real_ord_ope, jsonb) [#gteql_v3_real_ord_ope-jsonb]
Operator wrapper for public.eql\_v3\_real\_ord\_ope.
Parameters [#parameters-273]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_real_ord_ope` | |
| `b` | `jsonb` | |
Returns [#returns-269]
**Type:** `boolean`
boolean
***
gt(eql_v3_real_ord_ope, eql_v3_real_ord_ope) [#gteql_v3_real_ord_ope-eql_v3_real_ord_ope]
Operator wrapper for public.eql\_v3\_real\_ord\_ope.
Parameters [#parameters-274]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_real_ord_ope` | |
| `b public.` | `eql_v3_real_ord_ope` | |
Returns [#returns-270]
**Type:** `boolean`
boolean
***
gt(jsonb, eql_v3_real_ord) [#gtjsonb-eql_v3_real_ord]
Operator wrapper for public.eql\_v3\_real\_ord.
Parameters [#parameters-275]
| Name | Type | Description |
| ----------- | ----------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_real_ord` | |
Returns [#returns-271]
**Type:** `boolean`
boolean
***
gt(eql_v3_real_ord, jsonb) [#gteql_v3_real_ord-jsonb]
Operator wrapper for public.eql\_v3\_real\_ord.
Parameters [#parameters-276]
| Name | Type | Description |
| ----------- | ----------------- | ----------- |
| `a public.` | `eql_v3_real_ord` | |
| `b` | `jsonb` | |
Returns [#returns-272]
**Type:** `boolean`
boolean
***
gt(eql_v3_real_ord, eql_v3_real_ord) [#gteql_v3_real_ord-eql_v3_real_ord]
Operator wrapper for public.eql\_v3\_real\_ord.
Parameters [#parameters-277]
| Name | Type | Description |
| ----------- | ----------------- | ----------- |
| `a public.` | `eql_v3_real_ord` | |
| `b public.` | `eql_v3_real_ord` | |
Returns [#returns-273]
**Type:** `boolean`
boolean
***
gt(jsonb, eql_v3_integer_ord) [#gtjsonb-eql_v3_integer_ord]
Operator wrapper for public.eql\_v3\_integer\_ord.
Parameters [#parameters-278]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_integer_ord` | |
Returns [#returns-274]
**Type:** `boolean`
boolean
***
gt(eql_v3_integer_ord, jsonb) [#gteql_v3_integer_ord-jsonb]
Operator wrapper for public.eql\_v3\_integer\_ord.
Parameters [#parameters-279]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a public.` | `eql_v3_integer_ord` | |
| `b` | `jsonb` | |
Returns [#returns-275]
**Type:** `boolean`
boolean
***
gt(eql_v3_integer_ord, eql_v3_integer_ord) [#gteql_v3_integer_ord-eql_v3_integer_ord]
Operator wrapper for public.eql\_v3\_integer\_ord.
Parameters [#parameters-280]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a public.` | `eql_v3_integer_ord` | |
| `b public.` | `eql_v3_integer_ord` | |
Returns [#returns-276]
**Type:** `boolean`
boolean
***
gt(query_smallint_ord_ore, eql_v3_smallint_ord_ore) [#gtquery_smallint_ord_ore-eql_v3_smallint_ord_ore]
Operator wrapper for eql\_v3.query\_smallint\_ord\_ore.
Parameters [#parameters-281]
| Name | Type | Description |
| ----------- | ------------------------- | ----------- |
| `a eql_v3.` | `query_smallint_ord_ore` | |
| `b public.` | `eql_v3_smallint_ord_ore` | |
Returns [#returns-277]
**Type:** `boolean`
boolean
***
gt(eql_v3_smallint_ord_ore, query_smallint_ord_ore) [#gteql_v3_smallint_ord_ore-query_smallint_ord_ore]
Operator wrapper for eql\_v3.query\_smallint\_ord\_ore.
Parameters [#parameters-282]
| Name | Type | Description |
| ----------- | ------------------------- | ----------- |
| `a public.` | `eql_v3_smallint_ord_ore` | |
| `b eql_v3.` | `query_smallint_ord_ore` | |
Returns [#returns-278]
**Type:** `boolean`
boolean
***
gt(jsonb, eql_v3_text_ord_ope) [#gtjsonb-eql_v3_text_ord_ope]
Operator wrapper for public.eql\_v3\_text\_ord\_ope.
Parameters [#parameters-283]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_text_ord_ope` | |
Returns [#returns-279]
**Type:** `boolean`
boolean
***
gt(eql_v3_text_ord_ope, jsonb) [#gteql_v3_text_ord_ope-jsonb]
Operator wrapper for public.eql\_v3\_text\_ord\_ope.
Parameters [#parameters-284]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_text_ord_ope` | |
| `b` | `jsonb` | |
Returns [#returns-280]
**Type:** `boolean`
boolean
***
gt(eql_v3_text_ord_ope, eql_v3_text_ord_ope) [#gteql_v3_text_ord_ope-eql_v3_text_ord_ope]
Operator wrapper for public.eql\_v3\_text\_ord\_ope.
Parameters [#parameters-285]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_text_ord_ope` | |
| `b public.` | `eql_v3_text_ord_ope` | |
Returns [#returns-281]
**Type:** `boolean`
boolean
***
gt(query_double_ord_ope, eql_v3_double_ord_ope) [#gtquery_double_ord_ope-eql_v3_double_ord_ope]
Operator wrapper for eql\_v3.query\_double\_ord\_ope.
Parameters [#parameters-286]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a eql_v3.` | `query_double_ord_ope` | |
| `b public.` | `eql_v3_double_ord_ope` | |
Returns [#returns-282]
**Type:** `boolean`
boolean
***
gt(eql_v3_double_ord_ope, query_double_ord_ope) [#gteql_v3_double_ord_ope-query_double_ord_ope]
Operator wrapper for eql\_v3.query\_double\_ord\_ope.
Parameters [#parameters-287]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a public.` | `eql_v3_double_ord_ope` | |
| `b eql_v3.` | `query_double_ord_ope` | |
Returns [#returns-283]
**Type:** `boolean`
boolean
***
gt(query_integer_ord_ore, eql_v3_integer_ord_ore) [#gtquery_integer_ord_ore-eql_v3_integer_ord_ore]
Operator wrapper for eql\_v3.query\_integer\_ord\_ore.
Parameters [#parameters-288]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a eql_v3.` | `query_integer_ord_ore` | |
| `b public.` | `eql_v3_integer_ord_ore` | |
Returns [#returns-284]
**Type:** `boolean`
boolean
***
gt(eql_v3_integer_ord_ore, query_integer_ord_ore) [#gteql_v3_integer_ord_ore-query_integer_ord_ore]
Operator wrapper for eql\_v3.query\_integer\_ord\_ore.
Parameters [#parameters-289]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a public.` | `eql_v3_integer_ord_ore` | |
| `b eql_v3.` | `query_integer_ord_ore` | |
Returns [#returns-285]
**Type:** `boolean`
boolean
***
gt(jsonb, eql_v3_bigint_ord_ore) [#gtjsonb-eql_v3_bigint_ord_ore]
Operator wrapper for public.eql\_v3\_bigint\_ord\_ore.
Parameters [#parameters-290]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_bigint_ord_ore` | |
Returns [#returns-286]
**Type:** `boolean`
boolean
***
gt(eql_v3_bigint_ord_ore, jsonb) [#gteql_v3_bigint_ord_ore-jsonb]
Operator wrapper for public.eql\_v3\_bigint\_ord\_ore.
Parameters [#parameters-291]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a public.` | `eql_v3_bigint_ord_ore` | |
| `b` | `jsonb` | |
Returns [#returns-287]
**Type:** `boolean`
boolean
***
gt(eql_v3_bigint_ord_ore, eql_v3_bigint_ord_ore) [#gteql_v3_bigint_ord_ore-eql_v3_bigint_ord_ore]
Operator wrapper for public.eql\_v3\_bigint\_ord\_ore.
Parameters [#parameters-292]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a public.` | `eql_v3_bigint_ord_ore` | |
| `b public.` | `eql_v3_bigint_ord_ore` | |
Returns [#returns-288]
**Type:** `boolean`
boolean
***
gt(query_date_ord, eql_v3_date_ord) [#gtquery_date_ord-eql_v3_date_ord]
Operator wrapper for eql\_v3.query\_date\_ord.
Parameters [#parameters-293]
| Name | Type | Description |
| ----------- | ----------------- | ----------- |
| `a eql_v3.` | `query_date_ord` | |
| `b public.` | `eql_v3_date_ord` | |
Returns [#returns-289]
**Type:** `boolean`
boolean
***
gt(eql_v3_date_ord, query_date_ord) [#gteql_v3_date_ord-query_date_ord]
Operator wrapper for eql\_v3.query\_date\_ord.
Parameters [#parameters-294]
| Name | Type | Description |
| ----------- | ----------------- | ----------- |
| `a public.` | `eql_v3_date_ord` | |
| `b eql_v3.` | `query_date_ord` | |
Returns [#returns-290]
**Type:** `boolean`
boolean
***
gt(jsonb, eql_v3_real_ord_ore) [#gtjsonb-eql_v3_real_ord_ore]
Operator wrapper for public.eql\_v3\_real\_ord\_ore.
Parameters [#parameters-295]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_real_ord_ore` | |
Returns [#returns-291]
**Type:** `boolean`
boolean
***
gt(eql_v3_real_ord_ore, jsonb) [#gteql_v3_real_ord_ore-jsonb]
Operator wrapper for public.eql\_v3\_real\_ord\_ore.
Parameters [#parameters-296]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_real_ord_ore` | |
| `b` | `jsonb` | |
Returns [#returns-292]
**Type:** `boolean`
boolean
***
gt(eql_v3_real_ord_ore, eql_v3_real_ord_ore) [#gteql_v3_real_ord_ore-eql_v3_real_ord_ore]
Operator wrapper for public.eql\_v3\_real\_ord\_ore.
Parameters [#parameters-297]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_real_ord_ore` | |
| `b public.` | `eql_v3_real_ord_ore` | |
Returns [#returns-293]
**Type:** `boolean`
boolean
***
gt(jsonb, eql_v3_numeric_ord_ore) [#gtjsonb-eql_v3_numeric_ord_ore]
Operator wrapper for public.eql\_v3\_numeric\_ord\_ore.
Parameters [#parameters-298]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_numeric_ord_ore` | |
Returns [#returns-294]
**Type:** `boolean`
boolean
***
gt(eql_v3_numeric_ord_ore, jsonb) [#gteql_v3_numeric_ord_ore-jsonb]
Operator wrapper for public.eql\_v3\_numeric\_ord\_ore.
Parameters [#parameters-299]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a public.` | `eql_v3_numeric_ord_ore` | |
| `b` | `jsonb` | |
Returns [#returns-295]
**Type:** `boolean`
boolean
***
gt(eql_v3_numeric_ord_ore, eql_v3_numeric_ord_ore) [#gteql_v3_numeric_ord_ore-eql_v3_numeric_ord_ore]
Operator wrapper for public.eql\_v3\_numeric\_ord\_ore.
Parameters [#parameters-300]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a public.` | `eql_v3_numeric_ord_ore` | |
| `b public.` | `eql_v3_numeric_ord_ore` | |
Returns [#returns-296]
**Type:** `boolean`
boolean
***
gt(query_text_ord_ope, eql_v3_text_ord_ope) [#gtquery_text_ord_ope-eql_v3_text_ord_ope]
Operator wrapper for eql\_v3.query\_text\_ord\_ope.
Parameters [#parameters-301]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a eql_v3.` | `query_text_ord_ope` | |
| `b public.` | `eql_v3_text_ord_ope` | |
Returns [#returns-297]
**Type:** `boolean`
boolean
***
gt(eql_v3_text_ord_ope, query_text_ord_ope) [#gteql_v3_text_ord_ope-query_text_ord_ope]
Operator wrapper for eql\_v3.query\_text\_ord\_ope.
Parameters [#parameters-302]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_text_ord_ope` | |
| `b eql_v3.` | `query_text_ord_ope` | |
Returns [#returns-298]
**Type:** `boolean`
boolean
***
gt(jsonb, eql_v3_bigint_ord_ope) [#gtjsonb-eql_v3_bigint_ord_ope]
Operator wrapper for public.eql\_v3\_bigint\_ord\_ope.
Parameters [#parameters-303]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_bigint_ord_ope` | |
Returns [#returns-299]
**Type:** `boolean`
boolean
***
gt(eql_v3_bigint_ord_ope, jsonb) [#gteql_v3_bigint_ord_ope-jsonb]
Operator wrapper for public.eql\_v3\_bigint\_ord\_ope.
Parameters [#parameters-304]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a public.` | `eql_v3_bigint_ord_ope` | |
| `b` | `jsonb` | |
Returns [#returns-300]
**Type:** `boolean`
boolean
***
gt(eql_v3_bigint_ord_ope, eql_v3_bigint_ord_ope) [#gteql_v3_bigint_ord_ope-eql_v3_bigint_ord_ope]
Operator wrapper for public.eql\_v3\_bigint\_ord\_ope.
Parameters [#parameters-305]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a public.` | `eql_v3_bigint_ord_ope` | |
| `b public.` | `eql_v3_bigint_ord_ope` | |
Returns [#returns-301]
**Type:** `boolean`
boolean
***
gt(query_numeric_ord, eql_v3_json_entry) [#gtquery_numeric_ord-eql_v3_json_entry]
Operator wrapper for public.eql\_v3\_json\_entry.
Parameters [#parameters-306]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a eql_v3.` | `query_numeric_ord` | |
| `b public.` | `eql_v3_json_entry` | |
Returns [#returns-302]
**Type:** `boolean`
boolean
***
gt(eql_v3_json_entry, query_numeric_ord) [#gteql_v3_json_entry-query_numeric_ord]
Operator wrapper for public.eql\_v3\_json\_entry.
Parameters [#parameters-307]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a public.` | `eql_v3_json_entry` | |
| `b eql_v3.` | `query_numeric_ord` | |
Returns [#returns-303]
**Type:** `boolean`
boolean
***
gt(jsonb, eql_v3_double_ord_ore) [#gtjsonb-eql_v3_double_ord_ore]
Operator wrapper for public.eql\_v3\_double\_ord\_ore.
Parameters [#parameters-308]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_double_ord_ore` | |
Returns [#returns-304]
**Type:** `boolean`
boolean
***
gt(eql_v3_double_ord_ore, jsonb) [#gteql_v3_double_ord_ore-jsonb]
Operator wrapper for public.eql\_v3\_double\_ord\_ore.
Parameters [#parameters-309]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a public.` | `eql_v3_double_ord_ore` | |
| `b` | `jsonb` | |
Returns [#returns-305]
**Type:** `boolean`
boolean
***
gt(eql_v3_double_ord_ore, eql_v3_double_ord_ore) [#gteql_v3_double_ord_ore-eql_v3_double_ord_ore]
Operator wrapper for public.eql\_v3\_double\_ord\_ore.
Parameters [#parameters-310]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a public.` | `eql_v3_double_ord_ore` | |
| `b public.` | `eql_v3_double_ord_ore` | |
Returns [#returns-306]
**Type:** `boolean`
boolean
***
gt(jsonb, eql_v3_bigint_ord) [#gtjsonb-eql_v3_bigint_ord]
Operator wrapper for public.eql\_v3\_bigint\_ord.
Parameters [#parameters-311]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_bigint_ord` | |
Returns [#returns-307]
**Type:** `boolean`
boolean
***
gt(eql_v3_bigint_ord, jsonb) [#gteql_v3_bigint_ord-jsonb]
Operator wrapper for public.eql\_v3\_bigint\_ord.
Parameters [#parameters-312]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a public.` | `eql_v3_bigint_ord` | |
| `b` | `jsonb` | |
Returns [#returns-308]
**Type:** `boolean`
boolean
***
gt(eql_v3_bigint_ord, eql_v3_bigint_ord) [#gteql_v3_bigint_ord-eql_v3_bigint_ord]
Operator wrapper for public.eql\_v3\_bigint\_ord.
Parameters [#parameters-313]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a public.` | `eql_v3_bigint_ord` | |
| `b public.` | `eql_v3_bigint_ord` | |
Returns [#returns-309]
**Type:** `boolean`
boolean
***
gt(query_text_ord, eql_v3_json_entry) [#gtquery_text_ord-eql_v3_json_entry]
Operator wrapper for public.eql\_v3\_json\_entry.
Unsupported operator blocker for public.eql\_v3\_json\_entry.
Parameters [#parameters-314]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a eql_v3.` | `query_text_ord` | |
| `b public.` | `eql_v3_json_entry` | |
Returns [#returns-310]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gt(eql_v3_json_entry, query_text_ord) [#gteql_v3_json_entry-query_text_ord]
Operator wrapper for public.eql\_v3\_json\_entry.
Unsupported operator blocker for public.eql\_v3\_json\_entry.
Parameters [#parameters-315]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a public.` | `eql_v3_json_entry` | |
| `b eql_v3.` | `query_text_ord` | |
Returns [#returns-311]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gt(query_timestamp_ord_ope, eql_v3_timestamp_ord_ope) [#gtquery_timestamp_ord_ope-eql_v3_timestamp_ord_ope]
Operator wrapper for eql\_v3.query\_timestamp\_ord\_ope.
Parameters [#parameters-316]
| Name | Type | Description |
| ----------- | -------------------------- | ----------- |
| `a eql_v3.` | `query_timestamp_ord_ope` | |
| `b public.` | `eql_v3_timestamp_ord_ope` | |
Returns [#returns-312]
**Type:** `boolean`
boolean
***
gt(eql_v3_timestamp_ord_ope, query_timestamp_ord_ope) [#gteql_v3_timestamp_ord_ope-query_timestamp_ord_ope]
Operator wrapper for eql\_v3.query\_timestamp\_ord\_ope.
Parameters [#parameters-317]
| Name | Type | Description |
| ----------- | -------------------------- | ----------- |
| `a public.` | `eql_v3_timestamp_ord_ope` | |
| `b eql_v3.` | `query_timestamp_ord_ope` | |
Returns [#returns-313]
**Type:** `boolean`
boolean
***
gt(query_numeric_ord, eql_v3_numeric_ord) [#gtquery_numeric_ord-eql_v3_numeric_ord]
Operator wrapper for eql\_v3.query\_numeric\_ord.
Parameters [#parameters-318]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a eql_v3.` | `query_numeric_ord` | |
| `b public.` | `eql_v3_numeric_ord` | |
Returns [#returns-314]
**Type:** `boolean`
boolean
***
gt(eql_v3_numeric_ord, query_numeric_ord) [#gteql_v3_numeric_ord-query_numeric_ord]
Operator wrapper for eql\_v3.query\_numeric\_ord.
Parameters [#parameters-319]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a public.` | `eql_v3_numeric_ord` | |
| `b eql_v3.` | `query_numeric_ord` | |
Returns [#returns-315]
**Type:** `boolean`
boolean
***
gt(jsonb, eql_v3_text_search_ore) [#gtjsonb-eql_v3_text_search_ore]
Operator wrapper for public.eql\_v3\_text\_search\_ore.
Parameters [#parameters-320]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_text_search_ore` | |
Returns [#returns-316]
**Type:** `boolean`
boolean
***
gt(eql_v3_text_search_ore, jsonb) [#gteql_v3_text_search_ore-jsonb]
Operator wrapper for public.eql\_v3\_text\_search\_ore.
Parameters [#parameters-321]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a public.` | `eql_v3_text_search_ore` | |
| `b` | `jsonb` | |
Returns [#returns-317]
**Type:** `boolean`
boolean
***
gt(eql_v3_text_search_ore, eql_v3_text_search_ore) [#gteql_v3_text_search_ore-eql_v3_text_search_ore]
Operator wrapper for public.eql\_v3\_text\_search\_ore.
Parameters [#parameters-322]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a public.` | `eql_v3_text_search_ore` | |
| `b public.` | `eql_v3_text_search_ore` | |
Returns [#returns-318]
**Type:** `boolean`
boolean
***
gt(query_real_ord_ope, eql_v3_real_ord_ope) [#gtquery_real_ord_ope-eql_v3_real_ord_ope]
Operator wrapper for eql\_v3.query\_real\_ord\_ope.
Parameters [#parameters-323]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a eql_v3.` | `query_real_ord_ope` | |
| `b public.` | `eql_v3_real_ord_ope` | |
Returns [#returns-319]
**Type:** `boolean`
boolean
***
gt(eql_v3_real_ord_ope, query_real_ord_ope) [#gteql_v3_real_ord_ope-query_real_ord_ope]
Operator wrapper for eql\_v3.query\_real\_ord\_ope.
Parameters [#parameters-324]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_real_ord_ope` | |
| `b eql_v3.` | `query_real_ord_ope` | |
Returns [#returns-320]
**Type:** `boolean`
boolean
***
gt(jsonb, eql_v3_timestamp_ord) [#gtjsonb-eql_v3_timestamp_ord]
Operator wrapper for public.eql\_v3\_timestamp\_ord.
Parameters [#parameters-325]
| Name | Type | Description |
| ----------- | ---------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_timestamp_ord` | |
Returns [#returns-321]
**Type:** `boolean`
boolean
***
gt(eql_v3_timestamp_ord, jsonb) [#gteql_v3_timestamp_ord-jsonb]
Operator wrapper for public.eql\_v3\_timestamp\_ord.
Parameters [#parameters-326]
| Name | Type | Description |
| ----------- | ---------------------- | ----------- |
| `a public.` | `eql_v3_timestamp_ord` | |
| `b` | `jsonb` | |
Returns [#returns-322]
**Type:** `boolean`
boolean
***
gt(eql_v3_timestamp_ord, eql_v3_timestamp_ord) [#gteql_v3_timestamp_ord-eql_v3_timestamp_ord]
Operator wrapper for public.eql\_v3\_timestamp\_ord.
Parameters [#parameters-327]
| Name | Type | Description |
| ----------- | ---------------------- | ----------- |
| `a public.` | `eql_v3_timestamp_ord` | |
| `b public.` | `eql_v3_timestamp_ord` | |
Returns [#returns-323]
**Type:** `boolean`
boolean
***
gt(jsonb, eql_v3_smallint_ord_ope) [#gtjsonb-eql_v3_smallint_ord_ope]
Operator wrapper for public.eql\_v3\_smallint\_ord\_ope.
Parameters [#parameters-328]
| Name | Type | Description |
| ----------- | ------------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_smallint_ord_ope` | |
Returns [#returns-324]
**Type:** `boolean`
boolean
***
gt(eql_v3_smallint_ord_ope, jsonb) [#gteql_v3_smallint_ord_ope-jsonb]
Operator wrapper for public.eql\_v3\_smallint\_ord\_ope.
Parameters [#parameters-329]
| Name | Type | Description |
| ----------- | ------------------------- | ----------- |
| `a public.` | `eql_v3_smallint_ord_ope` | |
| `b` | `jsonb` | |
Returns [#returns-325]
**Type:** `boolean`
boolean
***
gt(eql_v3_smallint_ord_ope, eql_v3_smallint_ord_ope) [#gteql_v3_smallint_ord_ope-eql_v3_smallint_ord_ope]
Operator wrapper for public.eql\_v3\_smallint\_ord\_ope.
Parameters [#parameters-330]
| Name | Type | Description |
| ----------- | ------------------------- | ----------- |
| `a public.` | `eql_v3_smallint_ord_ope` | |
| `b public.` | `eql_v3_smallint_ord_ope` | |
Returns [#returns-326]
**Type:** `boolean`
boolean
***
gt(query_integer_ord, eql_v3_json_entry) [#gtquery_integer_ord-eql_v3_json_entry]
Operator wrapper for public.eql\_v3\_json\_entry.
Parameters [#parameters-331]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a eql_v3.` | `query_integer_ord` | |
| `b public.` | `eql_v3_json_entry` | |
Returns [#returns-327]
**Type:** `boolean`
boolean
***
gt(eql_v3_json_entry, query_integer_ord) [#gteql_v3_json_entry-query_integer_ord]
Operator wrapper for public.eql\_v3\_json\_entry.
Parameters [#parameters-332]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a public.` | `eql_v3_json_entry` | |
| `b eql_v3.` | `query_integer_ord` | |
Returns [#returns-328]
**Type:** `boolean`
boolean
***
gt(query_real_ord, eql_v3_json_entry) [#gtquery_real_ord-eql_v3_json_entry]
Operator wrapper for public.eql\_v3\_json\_entry.
Parameters [#parameters-333]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a eql_v3.` | `query_real_ord` | |
| `b public.` | `eql_v3_json_entry` | |
Returns [#returns-329]
**Type:** `boolean`
boolean
***
gt(eql_v3_json_entry, query_real_ord) [#gteql_v3_json_entry-query_real_ord]
Operator wrapper for public.eql\_v3\_json\_entry.
Parameters [#parameters-334]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a public.` | `eql_v3_json_entry` | |
| `b eql_v3.` | `query_real_ord` | |
Returns [#returns-330]
**Type:** `boolean`
boolean
***
gt(query_double_ord, eql_v3_double_ord) [#gtquery_double_ord-eql_v3_double_ord]
Operator wrapper for eql\_v3.query\_double\_ord.
Parameters [#parameters-335]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a eql_v3.` | `query_double_ord` | |
| `b public.` | `eql_v3_double_ord` | |
Returns [#returns-331]
**Type:** `boolean`
boolean
***
gt(eql_v3_double_ord, query_double_ord) [#gteql_v3_double_ord-query_double_ord]
Operator wrapper for eql\_v3.query\_double\_ord.
Parameters [#parameters-336]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a public.` | `eql_v3_double_ord` | |
| `b eql_v3.` | `query_double_ord` | |
Returns [#returns-332]
**Type:** `boolean`
boolean
***
gt(query_double_ord_ore, eql_v3_double_ord_ore) [#gtquery_double_ord_ore-eql_v3_double_ord_ore]
Operator wrapper for eql\_v3.query\_double\_ord\_ore.
Parameters [#parameters-337]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a eql_v3.` | `query_double_ord_ore` | |
| `b public.` | `eql_v3_double_ord_ore` | |
Returns [#returns-333]
**Type:** `boolean`
boolean
***
gt(eql_v3_double_ord_ore, query_double_ord_ore) [#gteql_v3_double_ord_ore-query_double_ord_ore]
Operator wrapper for eql\_v3.query\_double\_ord\_ore.
Parameters [#parameters-338]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a public.` | `eql_v3_double_ord_ore` | |
| `b eql_v3.` | `query_double_ord_ore` | |
Returns [#returns-334]
**Type:** `boolean`
boolean
***
gt(jsonb, eql_v3_timestamp_ord_ore) [#gtjsonb-eql_v3_timestamp_ord_ore]
Operator wrapper for public.eql\_v3\_timestamp\_ord\_ore.
Parameters [#parameters-339]
| Name | Type | Description |
| ----------- | -------------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_timestamp_ord_ore` | |
Returns [#returns-335]
**Type:** `boolean`
boolean
***
gt(eql_v3_timestamp_ord_ore, jsonb) [#gteql_v3_timestamp_ord_ore-jsonb]
Operator wrapper for public.eql\_v3\_timestamp\_ord\_ore.
Parameters [#parameters-340]
| Name | Type | Description |
| ----------- | -------------------------- | ----------- |
| `a public.` | `eql_v3_timestamp_ord_ore` | |
| `b` | `jsonb` | |
Returns [#returns-336]
**Type:** `boolean`
boolean
***
gt(eql_v3_timestamp_ord_ore, eql_v3_timestamp_ord_ore) [#gteql_v3_timestamp_ord_ore-eql_v3_timestamp_ord_ore]
Operator wrapper for public.eql\_v3\_timestamp\_ord\_ore.
Parameters [#parameters-341]
| Name | Type | Description |
| ----------- | -------------------------- | ----------- |
| `a public.` | `eql_v3_timestamp_ord_ore` | |
| `b public.` | `eql_v3_timestamp_ord_ore` | |
Returns [#returns-337]
**Type:** `boolean`
boolean
***
gt(jsonb, eql_v3_text_search) [#gtjsonb-eql_v3_text_search]
Operator wrapper for public.eql\_v3\_text\_search.
Parameters [#parameters-342]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_text_search` | |
Returns [#returns-338]
**Type:** `boolean`
boolean
***
gt(eql_v3_text_search, jsonb) [#gteql_v3_text_search-jsonb]
Operator wrapper for public.eql\_v3\_text\_search.
Parameters [#parameters-343]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a public.` | `eql_v3_text_search` | |
| `b` | `jsonb` | |
Returns [#returns-339]
**Type:** `boolean`
boolean
***
gt(eql_v3_text_search, eql_v3_text_search) [#gteql_v3_text_search-eql_v3_text_search]
Operator wrapper for public.eql\_v3\_text\_search.
Parameters [#parameters-344]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a public.` | `eql_v3_text_search` | |
| `b public.` | `eql_v3_text_search` | |
Returns [#returns-340]
**Type:** `boolean`
boolean
***
gt(query_numeric_ord_ore, eql_v3_numeric_ord_ore) [#gtquery_numeric_ord_ore-eql_v3_numeric_ord_ore]
Operator wrapper for eql\_v3.query\_numeric\_ord\_ore.
Parameters [#parameters-345]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a eql_v3.` | `query_numeric_ord_ore` | |
| `b public.` | `eql_v3_numeric_ord_ore` | |
Returns [#returns-341]
**Type:** `boolean`
boolean
***
gt(eql_v3_numeric_ord_ore, query_numeric_ord_ore) [#gteql_v3_numeric_ord_ore-query_numeric_ord_ore]
Operator wrapper for eql\_v3.query\_numeric\_ord\_ore.
Parameters [#parameters-346]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a public.` | `eql_v3_numeric_ord_ore` | |
| `b eql_v3.` | `query_numeric_ord_ore` | |
Returns [#returns-342]
**Type:** `boolean`
boolean
***
gt(query_bigint_ord_ore, eql_v3_bigint_ord_ore) [#gtquery_bigint_ord_ore-eql_v3_bigint_ord_ore]
Operator wrapper for eql\_v3.query\_bigint\_ord\_ore.
Parameters [#parameters-347]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a eql_v3.` | `query_bigint_ord_ore` | |
| `b public.` | `eql_v3_bigint_ord_ore` | |
Returns [#returns-343]
**Type:** `boolean`
boolean
***
gt(eql_v3_bigint_ord_ore, query_bigint_ord_ore) [#gteql_v3_bigint_ord_ore-query_bigint_ord_ore]
Operator wrapper for eql\_v3.query\_bigint\_ord\_ore.
Parameters [#parameters-348]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a public.` | `eql_v3_bigint_ord_ore` | |
| `b eql_v3.` | `query_bigint_ord_ore` | |
Returns [#returns-344]
**Type:** `boolean`
boolean
***
gt(query_bigint_ord_ope, eql_v3_bigint_ord_ope) [#gtquery_bigint_ord_ope-eql_v3_bigint_ord_ope]
Operator wrapper for eql\_v3.query\_bigint\_ord\_ope.
Parameters [#parameters-349]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a eql_v3.` | `query_bigint_ord_ope` | |
| `b public.` | `eql_v3_bigint_ord_ope` | |
Returns [#returns-345]
**Type:** `boolean`
boolean
***
gt(eql_v3_bigint_ord_ope, query_bigint_ord_ope) [#gteql_v3_bigint_ord_ope-query_bigint_ord_ope]
Operator wrapper for eql\_v3.query\_bigint\_ord\_ope.
Parameters [#parameters-350]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a public.` | `eql_v3_bigint_ord_ope` | |
| `b eql_v3.` | `query_bigint_ord_ope` | |
Returns [#returns-346]
**Type:** `boolean`
boolean
***
gt(query_date_ord_ore, eql_v3_date_ord_ore) [#gtquery_date_ord_ore-eql_v3_date_ord_ore]
Operator wrapper for eql\_v3.query\_date\_ord\_ore.
Parameters [#parameters-351]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a eql_v3.` | `query_date_ord_ore` | |
| `b public.` | `eql_v3_date_ord_ore` | |
Returns [#returns-347]
**Type:** `boolean`
boolean
***
gt(eql_v3_date_ord_ore, query_date_ord_ore) [#gteql_v3_date_ord_ore-query_date_ord_ore]
Operator wrapper for eql\_v3.query\_date\_ord\_ore.
Parameters [#parameters-352]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_date_ord_ore` | |
| `b eql_v3.` | `query_date_ord_ore` | |
Returns [#returns-348]
**Type:** `boolean`
boolean
***
gt(query_smallint_ord_ope, eql_v3_smallint_ord_ope) [#gtquery_smallint_ord_ope-eql_v3_smallint_ord_ope]
Operator wrapper for eql\_v3.query\_smallint\_ord\_ope.
Parameters [#parameters-353]
| Name | Type | Description |
| ----------- | ------------------------- | ----------- |
| `a eql_v3.` | `query_smallint_ord_ope` | |
| `b public.` | `eql_v3_smallint_ord_ope` | |
Returns [#returns-349]
**Type:** `boolean`
boolean
***
gt(eql_v3_smallint_ord_ope, query_smallint_ord_ope) [#gteql_v3_smallint_ord_ope-query_smallint_ord_ope]
Operator wrapper for eql\_v3.query\_smallint\_ord\_ope.
Parameters [#parameters-354]
| Name | Type | Description |
| ----------- | ------------------------- | ----------- |
| `a public.` | `eql_v3_smallint_ord_ope` | |
| `b eql_v3.` | `query_smallint_ord_ope` | |
Returns [#returns-350]
**Type:** `boolean`
boolean
***
gt(jsonb, eql_v3_double_ord) [#gtjsonb-eql_v3_double_ord]
Operator wrapper for public.eql\_v3\_double\_ord.
Parameters [#parameters-355]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_double_ord` | |
Returns [#returns-351]
**Type:** `boolean`
boolean
***
gt(eql_v3_double_ord, jsonb) [#gteql_v3_double_ord-jsonb]
Operator wrapper for public.eql\_v3\_double\_ord.
Parameters [#parameters-356]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a public.` | `eql_v3_double_ord` | |
| `b` | `jsonb` | |
Returns [#returns-352]
**Type:** `boolean`
boolean
***
gt(eql_v3_double_ord, eql_v3_double_ord) [#gteql_v3_double_ord-eql_v3_double_ord]
Operator wrapper for public.eql\_v3\_double\_ord.
Parameters [#parameters-357]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a public.` | `eql_v3_double_ord` | |
| `b public.` | `eql_v3_double_ord` | |
Returns [#returns-353]
**Type:** `boolean`
boolean
***
gt(query_numeric_ord_ope, eql_v3_numeric_ord_ope) [#gtquery_numeric_ord_ope-eql_v3_numeric_ord_ope]
Operator wrapper for eql\_v3.query\_numeric\_ord\_ope.
Parameters [#parameters-358]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a eql_v3.` | `query_numeric_ord_ope` | |
| `b public.` | `eql_v3_numeric_ord_ope` | |
Returns [#returns-354]
**Type:** `boolean`
boolean
***
gt(eql_v3_numeric_ord_ope, query_numeric_ord_ope) [#gteql_v3_numeric_ord_ope-query_numeric_ord_ope]
Operator wrapper for eql\_v3.query\_numeric\_ord\_ope.
Parameters [#parameters-359]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a public.` | `eql_v3_numeric_ord_ope` | |
| `b eql_v3.` | `query_numeric_ord_ope` | |
Returns [#returns-355]
**Type:** `boolean`
boolean
***
gt(jsonb, eql_v3_double_ord_ope) [#gtjsonb-eql_v3_double_ord_ope]
Operator wrapper for public.eql\_v3\_double\_ord\_ope.
Parameters [#parameters-360]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_double_ord_ope` | |
Returns [#returns-356]
**Type:** `boolean`
boolean
***
gt(eql_v3_double_ord_ope, jsonb) [#gteql_v3_double_ord_ope-jsonb]
Operator wrapper for public.eql\_v3\_double\_ord\_ope.
Parameters [#parameters-361]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a public.` | `eql_v3_double_ord_ope` | |
| `b` | `jsonb` | |
Returns [#returns-357]
**Type:** `boolean`
boolean
***
gt(eql_v3_double_ord_ope, eql_v3_double_ord_ope) [#gteql_v3_double_ord_ope-eql_v3_double_ord_ope]
Operator wrapper for public.eql\_v3\_double\_ord\_ope.
Parameters [#parameters-362]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a public.` | `eql_v3_double_ord_ope` | |
| `b public.` | `eql_v3_double_ord_ope` | |
Returns [#returns-358]
**Type:** `boolean`
boolean
***
gt(jsonb, eql_v3_numeric_ord_ope) [#gtjsonb-eql_v3_numeric_ord_ope]
Operator wrapper for public.eql\_v3\_numeric\_ord\_ope.
Parameters [#parameters-363]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_numeric_ord_ope` | |
Returns [#returns-359]
**Type:** `boolean`
boolean
***
gt(eql_v3_numeric_ord_ope, jsonb) [#gteql_v3_numeric_ord_ope-jsonb]
Operator wrapper for public.eql\_v3\_numeric\_ord\_ope.
Parameters [#parameters-364]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a public.` | `eql_v3_numeric_ord_ope` | |
| `b` | `jsonb` | |
Returns [#returns-360]
**Type:** `boolean`
boolean
***
gt(eql_v3_numeric_ord_ope, eql_v3_numeric_ord_ope) [#gteql_v3_numeric_ord_ope-eql_v3_numeric_ord_ope]
Operator wrapper for public.eql\_v3\_numeric\_ord\_ope.
Parameters [#parameters-365]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a public.` | `eql_v3_numeric_ord_ope` | |
| `b public.` | `eql_v3_numeric_ord_ope` | |
Returns [#returns-361]
**Type:** `boolean`
boolean
***
gt(jsonb, eql_v3_date_ord_ore) [#gtjsonb-eql_v3_date_ord_ore]
Operator wrapper for public.eql\_v3\_date\_ord\_ore.
Parameters [#parameters-366]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_date_ord_ore` | |
Returns [#returns-362]
**Type:** `boolean`
boolean
***
gt(eql_v3_date_ord_ore, jsonb) [#gteql_v3_date_ord_ore-jsonb]
Operator wrapper for public.eql\_v3\_date\_ord\_ore.
Parameters [#parameters-367]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_date_ord_ore` | |
| `b` | `jsonb` | |
Returns [#returns-363]
**Type:** `boolean`
boolean
***
gt(eql_v3_date_ord_ore, eql_v3_date_ord_ore) [#gteql_v3_date_ord_ore-eql_v3_date_ord_ore]
Operator wrapper for public.eql\_v3\_date\_ord\_ore.
Parameters [#parameters-368]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_date_ord_ore` | |
| `b public.` | `eql_v3_date_ord_ore` | |
Returns [#returns-364]
**Type:** `boolean`
boolean
***
gt(query_timestamp_ord, eql_v3_timestamp_ord) [#gtquery_timestamp_ord-eql_v3_timestamp_ord]
Operator wrapper for eql\_v3.query\_timestamp\_ord.
Parameters [#parameters-369]
| Name | Type | Description |
| ----------- | ---------------------- | ----------- |
| `a eql_v3.` | `query_timestamp_ord` | |
| `b public.` | `eql_v3_timestamp_ord` | |
Returns [#returns-365]
**Type:** `boolean`
boolean
***
gt(eql_v3_timestamp_ord, query_timestamp_ord) [#gteql_v3_timestamp_ord-query_timestamp_ord]
Operator wrapper for eql\_v3.query\_timestamp\_ord.
Parameters [#parameters-370]
| Name | Type | Description |
| ----------- | ---------------------- | ----------- |
| `a public.` | `eql_v3_timestamp_ord` | |
| `b eql_v3.` | `query_timestamp_ord` | |
Returns [#returns-366]
**Type:** `boolean`
boolean
***
gt(jsonb, eql_v3_smallint_ord_ore) [#gtjsonb-eql_v3_smallint_ord_ore]
Operator wrapper for public.eql\_v3\_smallint\_ord\_ore.
Parameters [#parameters-371]
| Name | Type | Description |
| ----------- | ------------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_smallint_ord_ore` | |
Returns [#returns-367]
**Type:** `boolean`
boolean
***
gt(eql_v3_smallint_ord_ore, jsonb) [#gteql_v3_smallint_ord_ore-jsonb]
Operator wrapper for public.eql\_v3\_smallint\_ord\_ore.
Parameters [#parameters-372]
| Name | Type | Description |
| ----------- | ------------------------- | ----------- |
| `a public.` | `eql_v3_smallint_ord_ore` | |
| `b` | `jsonb` | |
Returns [#returns-368]
**Type:** `boolean`
boolean
***
gt(eql_v3_smallint_ord_ore, eql_v3_smallint_ord_ore) [#gteql_v3_smallint_ord_ore-eql_v3_smallint_ord_ore]
Operator wrapper for public.eql\_v3\_smallint\_ord\_ore.
Parameters [#parameters-373]
| Name | Type | Description |
| ----------- | ------------------------- | ----------- |
| `a public.` | `eql_v3_smallint_ord_ore` | |
| `b public.` | `eql_v3_smallint_ord_ore` | |
Returns [#returns-369]
**Type:** `boolean`
boolean
***
gt(jsonb, eql_v3_date_ord_ope) [#gtjsonb-eql_v3_date_ord_ope]
Operator wrapper for public.eql\_v3\_date\_ord\_ope.
Parameters [#parameters-374]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_date_ord_ope` | |
Returns [#returns-370]
**Type:** `boolean`
boolean
***
gt(eql_v3_date_ord_ope, jsonb) [#gteql_v3_date_ord_ope-jsonb]
Operator wrapper for public.eql\_v3\_date\_ord\_ope.
Parameters [#parameters-375]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_date_ord_ope` | |
| `b` | `jsonb` | |
Returns [#returns-371]
**Type:** `boolean`
boolean
***
gt(eql_v3_date_ord_ope, eql_v3_date_ord_ope) [#gteql_v3_date_ord_ope-eql_v3_date_ord_ope]
Operator wrapper for public.eql\_v3\_date\_ord\_ope.
Parameters [#parameters-376]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_date_ord_ope` | |
| `b public.` | `eql_v3_date_ord_ope` | |
Returns [#returns-372]
**Type:** `boolean`
boolean
***
gt(query_bigint_ord, eql_v3_bigint_ord) [#gtquery_bigint_ord-eql_v3_bigint_ord]
Operator wrapper for eql\_v3.query\_bigint\_ord.
Parameters [#parameters-377]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a eql_v3.` | `query_bigint_ord` | |
| `b public.` | `eql_v3_bigint_ord` | |
Returns [#returns-373]
**Type:** `boolean`
boolean
***
gt(eql_v3_bigint_ord, query_bigint_ord) [#gteql_v3_bigint_ord-query_bigint_ord]
Operator wrapper for eql\_v3.query\_bigint\_ord.
Parameters [#parameters-378]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a public.` | `eql_v3_bigint_ord` | |
| `b eql_v3.` | `query_bigint_ord` | |
Returns [#returns-374]
**Type:** `boolean`
boolean
***
gt(jsonb, eql_v3_text_ord_ore) [#gtjsonb-eql_v3_text_ord_ore]
Operator wrapper for public.eql\_v3\_text\_ord\_ore.
Parameters [#parameters-379]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_text_ord_ore` | |
Returns [#returns-375]
**Type:** `boolean`
boolean
***
gt(eql_v3_text_ord_ore, jsonb) [#gteql_v3_text_ord_ore-jsonb]
Operator wrapper for public.eql\_v3\_text\_ord\_ore.
Parameters [#parameters-380]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_text_ord_ore` | |
| `b` | `jsonb` | |
Returns [#returns-376]
**Type:** `boolean`
boolean
***
gt(eql_v3_text_ord_ore, eql_v3_text_ord_ore) [#gteql_v3_text_ord_ore-eql_v3_text_ord_ore]
Operator wrapper for public.eql\_v3\_text\_ord\_ore.
Parameters [#parameters-381]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_text_ord_ore` | |
| `b public.` | `eql_v3_text_ord_ore` | |
Returns [#returns-377]
**Type:** `boolean`
boolean
***
gt(query_bigint_ord, eql_v3_json_entry) [#gtquery_bigint_ord-eql_v3_json_entry]
Operator wrapper for public.eql\_v3\_json\_entry.
Unsupported operator blocker for public.eql\_v3\_json\_entry.
Parameters [#parameters-382]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a eql_v3.` | `query_bigint_ord` | |
| `b public.` | `eql_v3_json_entry` | |
Returns [#returns-378]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gt(eql_v3_json_entry, query_bigint_ord) [#gteql_v3_json_entry-query_bigint_ord]
Operator wrapper for public.eql\_v3\_json\_entry.
Unsupported operator blocker for public.eql\_v3\_json\_entry.
Parameters [#parameters-383]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a public.` | `eql_v3_json_entry` | |
| `b eql_v3.` | `query_bigint_ord` | |
Returns [#returns-379]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gte(jsonb, eql_v3_integer_ord_ore) [#gtejsonb-eql_v3_integer_ord_ore]
Operator wrapper for public.eql\_v3\_integer\_ord\_ore.
Parameters [#parameters-384]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_integer_ord_ore` | |
Returns [#returns-380]
**Type:** `boolean`
boolean
***
gte(eql_v3_integer_ord_ore, jsonb) [#gteeql_v3_integer_ord_ore-jsonb]
Operator wrapper for public.eql\_v3\_integer\_ord\_ore.
Parameters [#parameters-385]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a public.` | `eql_v3_integer_ord_ore` | |
| `b` | `jsonb` | |
Returns [#returns-381]
**Type:** `boolean`
boolean
***
gte(eql_v3_integer_ord_ore, eql_v3_integer_ord_ore) [#gteeql_v3_integer_ord_ore-eql_v3_integer_ord_ore]
Operator wrapper for public.eql\_v3\_integer\_ord\_ore.
Parameters [#parameters-386]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a public.` | `eql_v3_integer_ord_ore` | |
| `b public.` | `eql_v3_integer_ord_ore` | |
Returns [#returns-382]
**Type:** `boolean`
boolean
***
gte(query_smallint_ord, eql_v3_smallint_ord) [#gtequery_smallint_ord-eql_v3_smallint_ord]
Operator wrapper for eql\_v3.query\_smallint\_ord.
Parameters [#parameters-387]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a eql_v3.` | `query_smallint_ord` | |
| `b public.` | `eql_v3_smallint_ord` | |
Returns [#returns-383]
**Type:** `boolean`
boolean
***
gte(eql_v3_smallint_ord, query_smallint_ord) [#gteeql_v3_smallint_ord-query_smallint_ord]
Operator wrapper for eql\_v3.query\_smallint\_ord.
Parameters [#parameters-388]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_smallint_ord` | |
| `b eql_v3.` | `query_smallint_ord` | |
Returns [#returns-384]
**Type:** `boolean`
boolean
***
gte(jsonb, eql_v3_smallint_ord) [#gtejsonb-eql_v3_smallint_ord]
Operator wrapper for public.eql\_v3\_smallint\_ord.
Parameters [#parameters-389]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_smallint_ord` | |
Returns [#returns-385]
**Type:** `boolean`
boolean
***
gte(eql_v3_smallint_ord, jsonb) [#gteeql_v3_smallint_ord-jsonb]
Operator wrapper for public.eql\_v3\_smallint\_ord.
Parameters [#parameters-390]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_smallint_ord` | |
| `b` | `jsonb` | |
Returns [#returns-386]
**Type:** `boolean`
boolean
***
gte(eql_v3_smallint_ord, eql_v3_smallint_ord) [#gteeql_v3_smallint_ord-eql_v3_smallint_ord]
Operator wrapper for public.eql\_v3\_smallint\_ord.
Parameters [#parameters-391]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_smallint_ord` | |
| `b public.` | `eql_v3_smallint_ord` | |
Returns [#returns-387]
**Type:** `boolean`
boolean
***
gte(jsonb, eql_v3_date_ord) [#gtejsonb-eql_v3_date_ord]
Operator wrapper for public.eql\_v3\_date\_ord.
Parameters [#parameters-392]
| Name | Type | Description |
| ----------- | ----------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_date_ord` | |
Returns [#returns-388]
**Type:** `boolean`
boolean
***
gte(eql_v3_date_ord, jsonb) [#gteeql_v3_date_ord-jsonb]
Operator wrapper for public.eql\_v3\_date\_ord.
Parameters [#parameters-393]
| Name | Type | Description |
| ----------- | ----------------- | ----------- |
| `a public.` | `eql_v3_date_ord` | |
| `b` | `jsonb` | |
Returns [#returns-389]
**Type:** `boolean`
boolean
***
gte(eql_v3_date_ord, eql_v3_date_ord) [#gteeql_v3_date_ord-eql_v3_date_ord]
Operator wrapper for public.eql\_v3\_date\_ord.
Parameters [#parameters-394]
| Name | Type | Description |
| ----------- | ----------------- | ----------- |
| `a public.` | `eql_v3_date_ord` | |
| `b public.` | `eql_v3_date_ord` | |
Returns [#returns-390]
**Type:** `boolean`
boolean
***
gte(query_real_ord, eql_v3_real_ord) [#gtequery_real_ord-eql_v3_real_ord]
Operator wrapper for eql\_v3.query\_real\_ord.
Parameters [#parameters-395]
| Name | Type | Description |
| ----------- | ----------------- | ----------- |
| `a eql_v3.` | `query_real_ord` | |
| `b public.` | `eql_v3_real_ord` | |
Returns [#returns-391]
**Type:** `boolean`
boolean
***
gte(eql_v3_real_ord, query_real_ord) [#gteeql_v3_real_ord-query_real_ord]
Operator wrapper for eql\_v3.query\_real\_ord.
Parameters [#parameters-396]
| Name | Type | Description |
| ----------- | ----------------- | ----------- |
| `a public.` | `eql_v3_real_ord` | |
| `b eql_v3.` | `query_real_ord` | |
Returns [#returns-392]
**Type:** `boolean`
boolean
***
gte(query_double_ord, eql_v3_json_entry) [#gtequery_double_ord-eql_v3_json_entry]
Operator wrapper for public.eql\_v3\_json\_entry.
Parameters [#parameters-397]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a eql_v3.` | `query_double_ord` | |
| `b public.` | `eql_v3_json_entry` | |
Returns [#returns-393]
**Type:** `boolean`
boolean
***
gte(eql_v3_json_entry, query_double_ord) [#gteeql_v3_json_entry-query_double_ord]
Operator wrapper for public.eql\_v3\_json\_entry.
Parameters [#parameters-398]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a public.` | `eql_v3_json_entry` | |
| `b eql_v3.` | `query_double_ord` | |
Returns [#returns-394]
**Type:** `boolean`
boolean
***
gte(query_real_ord_ore, eql_v3_real_ord_ore) [#gtequery_real_ord_ore-eql_v3_real_ord_ore]
Operator wrapper for eql\_v3.query\_real\_ord\_ore.
Parameters [#parameters-399]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a eql_v3.` | `query_real_ord_ore` | |
| `b public.` | `eql_v3_real_ord_ore` | |
Returns [#returns-395]
**Type:** `boolean`
boolean
***
gte(eql_v3_real_ord_ore, query_real_ord_ore) [#gteeql_v3_real_ord_ore-query_real_ord_ore]
Operator wrapper for eql\_v3.query\_real\_ord\_ore.
Parameters [#parameters-400]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_real_ord_ore` | |
| `b eql_v3.` | `query_real_ord_ore` | |
Returns [#returns-396]
**Type:** `boolean`
boolean
***
gte(jsonb, eql_v3_text_ord) [#gtejsonb-eql_v3_text_ord]
Operator wrapper for public.eql\_v3\_text\_ord.
Parameters [#parameters-401]
| Name | Type | Description |
| ----------- | ----------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_text_ord` | |
Returns [#returns-397]
**Type:** `boolean`
boolean
***
gte(eql_v3_text_ord, jsonb) [#gteeql_v3_text_ord-jsonb]
Operator wrapper for public.eql\_v3\_text\_ord.
Parameters [#parameters-402]
| Name | Type | Description |
| ----------- | ----------------- | ----------- |
| `a public.` | `eql_v3_text_ord` | |
| `b` | `jsonb` | |
Returns [#returns-398]
**Type:** `boolean`
boolean
***
gte(eql_v3_text_ord, eql_v3_text_ord) [#gteeql_v3_text_ord-eql_v3_text_ord]
Operator wrapper for public.eql\_v3\_text\_ord.
Parameters [#parameters-403]
| Name | Type | Description |
| ----------- | ----------------- | ----------- |
| `a public.` | `eql_v3_text_ord` | |
| `b public.` | `eql_v3_text_ord` | |
Returns [#returns-399]
**Type:** `boolean`
boolean
***
gte(query_integer_ord_ope, eql_v3_integer_ord_ope) [#gtequery_integer_ord_ope-eql_v3_integer_ord_ope]
Operator wrapper for eql\_v3.query\_integer\_ord\_ope.
Parameters [#parameters-404]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a eql_v3.` | `query_integer_ord_ope` | |
| `b public.` | `eql_v3_integer_ord_ope` | |
Returns [#returns-400]
**Type:** `boolean`
boolean
***
gte(eql_v3_integer_ord_ope, query_integer_ord_ope) [#gteeql_v3_integer_ord_ope-query_integer_ord_ope]
Operator wrapper for eql\_v3.query\_integer\_ord\_ope.
Parameters [#parameters-405]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a public.` | `eql_v3_integer_ord_ope` | |
| `b eql_v3.` | `query_integer_ord_ope` | |
Returns [#returns-401]
**Type:** `boolean`
boolean
***
gte(query_text_ord, eql_v3_text_ord) [#gtequery_text_ord-eql_v3_text_ord]
Operator wrapper for eql\_v3.query\_text\_ord.
Parameters [#parameters-406]
| Name | Type | Description |
| ----------- | ----------------- | ----------- |
| `a eql_v3.` | `query_text_ord` | |
| `b public.` | `eql_v3_text_ord` | |
Returns [#returns-402]
**Type:** `boolean`
boolean
***
gte(eql_v3_text_ord, query_text_ord) [#gteeql_v3_text_ord-query_text_ord]
Operator wrapper for eql\_v3.query\_text\_ord.
Parameters [#parameters-407]
| Name | Type | Description |
| ----------- | ----------------- | ----------- |
| `a public.` | `eql_v3_text_ord` | |
| `b eql_v3.` | `query_text_ord` | |
Returns [#returns-403]
**Type:** `boolean`
boolean
***
gte(jsonb, eql_v3_timestamp_ord_ope) [#gtejsonb-eql_v3_timestamp_ord_ope]
Operator wrapper for public.eql\_v3\_timestamp\_ord\_ope.
Parameters [#parameters-408]
| Name | Type | Description |
| ----------- | -------------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_timestamp_ord_ope` | |
Returns [#returns-404]
**Type:** `boolean`
boolean
***
gte(eql_v3_timestamp_ord_ope, jsonb) [#gteeql_v3_timestamp_ord_ope-jsonb]
Operator wrapper for public.eql\_v3\_timestamp\_ord\_ope.
Parameters [#parameters-409]
| Name | Type | Description |
| ----------- | -------------------------- | ----------- |
| `a public.` | `eql_v3_timestamp_ord_ope` | |
| `b` | `jsonb` | |
Returns [#returns-405]
**Type:** `boolean`
boolean
***
gte(eql_v3_timestamp_ord_ope, eql_v3_timestamp_ord_ope) [#gteeql_v3_timestamp_ord_ope-eql_v3_timestamp_ord_ope]
Operator wrapper for public.eql\_v3\_timestamp\_ord\_ope.
Parameters [#parameters-410]
| Name | Type | Description |
| ----------- | -------------------------- | ----------- |
| `a public.` | `eql_v3_timestamp_ord_ope` | |
| `b public.` | `eql_v3_timestamp_ord_ope` | |
Returns [#returns-406]
**Type:** `boolean`
boolean
***
gte(jsonb, eql_v3_integer_ord_ope) [#gtejsonb-eql_v3_integer_ord_ope]
Operator wrapper for public.eql\_v3\_integer\_ord\_ope.
Parameters [#parameters-411]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_integer_ord_ope` | |
Returns [#returns-407]
**Type:** `boolean`
boolean
***
gte(eql_v3_integer_ord_ope, jsonb) [#gteeql_v3_integer_ord_ope-jsonb]
Operator wrapper for public.eql\_v3\_integer\_ord\_ope.
Parameters [#parameters-412]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a public.` | `eql_v3_integer_ord_ope` | |
| `b` | `jsonb` | |
Returns [#returns-408]
**Type:** `boolean`
boolean
***
gte(eql_v3_integer_ord_ope, eql_v3_integer_ord_ope) [#gteeql_v3_integer_ord_ope-eql_v3_integer_ord_ope]
Operator wrapper for public.eql\_v3\_integer\_ord\_ope.
Parameters [#parameters-413]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a public.` | `eql_v3_integer_ord_ope` | |
| `b public.` | `eql_v3_integer_ord_ope` | |
Returns [#returns-409]
**Type:** `boolean`
boolean
***
gte(query_integer_ord, eql_v3_integer_ord) [#gtequery_integer_ord-eql_v3_integer_ord]
Operator wrapper for eql\_v3.query\_integer\_ord.
Parameters [#parameters-414]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a eql_v3.` | `query_integer_ord` | |
| `b public.` | `eql_v3_integer_ord` | |
Returns [#returns-410]
**Type:** `boolean`
boolean
***
gte(eql_v3_integer_ord, query_integer_ord) [#gteeql_v3_integer_ord-query_integer_ord]
Operator wrapper for eql\_v3.query\_integer\_ord.
Parameters [#parameters-415]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a public.` | `eql_v3_integer_ord` | |
| `b eql_v3.` | `query_integer_ord` | |
Returns [#returns-411]
**Type:** `boolean`
boolean
***
gte(query_text_search, eql_v3_text_search) [#gtequery_text_search-eql_v3_text_search]
Operator wrapper for eql\_v3.query\_text\_search.
Parameters [#parameters-416]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a eql_v3.` | `query_text_search` | |
| `b public.` | `eql_v3_text_search` | |
Returns [#returns-412]
**Type:** `boolean`
boolean
***
gte(eql_v3_text_search, query_text_search) [#gteeql_v3_text_search-query_text_search]
Operator wrapper for eql\_v3.query\_text\_search.
Parameters [#parameters-417]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a public.` | `eql_v3_text_search` | |
| `b eql_v3.` | `query_text_search` | |
Returns [#returns-413]
**Type:** `boolean`
boolean
***
gte(jsonb, eql_v3_numeric_ord) [#gtejsonb-eql_v3_numeric_ord]
Operator wrapper for public.eql\_v3\_numeric\_ord.
Parameters [#parameters-418]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_numeric_ord` | |
Returns [#returns-414]
**Type:** `boolean`
boolean
***
gte(eql_v3_numeric_ord, jsonb) [#gteeql_v3_numeric_ord-jsonb]
Operator wrapper for public.eql\_v3\_numeric\_ord.
Parameters [#parameters-419]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a public.` | `eql_v3_numeric_ord` | |
| `b` | `jsonb` | |
Returns [#returns-415]
**Type:** `boolean`
boolean
***
gte(eql_v3_numeric_ord, eql_v3_numeric_ord) [#gteeql_v3_numeric_ord-eql_v3_numeric_ord]
Operator wrapper for public.eql\_v3\_numeric\_ord.
Parameters [#parameters-420]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a public.` | `eql_v3_numeric_ord` | |
| `b public.` | `eql_v3_numeric_ord` | |
Returns [#returns-416]
**Type:** `boolean`
boolean
***
gte(query_date_ord_ope, eql_v3_date_ord_ope) [#gtequery_date_ord_ope-eql_v3_date_ord_ope]
Operator wrapper for eql\_v3.query\_date\_ord\_ope.
Parameters [#parameters-421]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a eql_v3.` | `query_date_ord_ope` | |
| `b public.` | `eql_v3_date_ord_ope` | |
Returns [#returns-417]
**Type:** `boolean`
boolean
***
gte(eql_v3_date_ord_ope, query_date_ord_ope) [#gteeql_v3_date_ord_ope-query_date_ord_ope]
Operator wrapper for eql\_v3.query\_date\_ord\_ope.
Parameters [#parameters-422]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_date_ord_ope` | |
| `b eql_v3.` | `query_date_ord_ope` | |
Returns [#returns-418]
**Type:** `boolean`
boolean
***
gte(query_smallint_ord, eql_v3_json_entry) [#gtequery_smallint_ord-eql_v3_json_entry]
Operator wrapper for public.eql\_v3\_json\_entry.
Parameters [#parameters-423]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a eql_v3.` | `query_smallint_ord` | |
| `b public.` | `eql_v3_json_entry` | |
Returns [#returns-419]
**Type:** `boolean`
boolean
***
gte(eql_v3_json_entry, query_smallint_ord) [#gteeql_v3_json_entry-query_smallint_ord]
Operator wrapper for public.eql\_v3\_json\_entry.
Parameters [#parameters-424]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a public.` | `eql_v3_json_entry` | |
| `b eql_v3.` | `query_smallint_ord` | |
Returns [#returns-420]
**Type:** `boolean`
boolean
***
gte(query_timestamp_ord_ore, eql_v3_timestamp_ord_ore) [#gtequery_timestamp_ord_ore-eql_v3_timestamp_ord_ore]
Operator wrapper for eql\_v3.query\_timestamp\_ord\_ore.
Parameters [#parameters-425]
| Name | Type | Description |
| ----------- | -------------------------- | ----------- |
| `a eql_v3.` | `query_timestamp_ord_ore` | |
| `b public.` | `eql_v3_timestamp_ord_ore` | |
Returns [#returns-421]
**Type:** `boolean`
boolean
***
gte(eql_v3_timestamp_ord_ore, query_timestamp_ord_ore) [#gteeql_v3_timestamp_ord_ore-query_timestamp_ord_ore]
Operator wrapper for eql\_v3.query\_timestamp\_ord\_ore.
Parameters [#parameters-426]
| Name | Type | Description |
| ----------- | -------------------------- | ----------- |
| `a public.` | `eql_v3_timestamp_ord_ore` | |
| `b eql_v3.` | `query_timestamp_ord_ore` | |
Returns [#returns-422]
**Type:** `boolean`
boolean
***
gte(query_text_search_ore, eql_v3_text_search_ore) [#gtequery_text_search_ore-eql_v3_text_search_ore]
Operator wrapper for eql\_v3.query\_text\_search\_ore.
Parameters [#parameters-427]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a eql_v3.` | `query_text_search_ore` | |
| `b public.` | `eql_v3_text_search_ore` | |
Returns [#returns-423]
**Type:** `boolean`
boolean
***
gte(eql_v3_text_search_ore, query_text_search_ore) [#gteeql_v3_text_search_ore-query_text_search_ore]
Operator wrapper for eql\_v3.query\_text\_search\_ore.
Parameters [#parameters-428]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a public.` | `eql_v3_text_search_ore` | |
| `b eql_v3.` | `query_text_search_ore` | |
Returns [#returns-424]
**Type:** `boolean`
boolean
***
gte(query_text_ord_ore, eql_v3_text_ord_ore) [#gtequery_text_ord_ore-eql_v3_text_ord_ore]
Operator wrapper for eql\_v3.query\_text\_ord\_ore.
Parameters [#parameters-429]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a eql_v3.` | `query_text_ord_ore` | |
| `b public.` | `eql_v3_text_ord_ore` | |
Returns [#returns-425]
**Type:** `boolean`
boolean
***
gte(eql_v3_text_ord_ore, query_text_ord_ore) [#gteeql_v3_text_ord_ore-query_text_ord_ore]
Operator wrapper for eql\_v3.query\_text\_ord\_ore.
Parameters [#parameters-430]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_text_ord_ore` | |
| `b eql_v3.` | `query_text_ord_ore` | |
Returns [#returns-426]
**Type:** `boolean`
boolean
***
gte(jsonb, eql_v3_real_ord_ope) [#gtejsonb-eql_v3_real_ord_ope]
Operator wrapper for public.eql\_v3\_real\_ord\_ope.
Parameters [#parameters-431]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_real_ord_ope` | |
Returns [#returns-427]
**Type:** `boolean`
boolean
***
gte(eql_v3_real_ord_ope, jsonb) [#gteeql_v3_real_ord_ope-jsonb]
Operator wrapper for public.eql\_v3\_real\_ord\_ope.
Parameters [#parameters-432]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_real_ord_ope` | |
| `b` | `jsonb` | |
Returns [#returns-428]
**Type:** `boolean`
boolean
***
gte(eql_v3_real_ord_ope, eql_v3_real_ord_ope) [#gteeql_v3_real_ord_ope-eql_v3_real_ord_ope]
Operator wrapper for public.eql\_v3\_real\_ord\_ope.
Parameters [#parameters-433]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_real_ord_ope` | |
| `b public.` | `eql_v3_real_ord_ope` | |
Returns [#returns-429]
**Type:** `boolean`
boolean
***
gte(jsonb, eql_v3_real_ord) [#gtejsonb-eql_v3_real_ord]
Operator wrapper for public.eql\_v3\_real\_ord.
Parameters [#parameters-434]
| Name | Type | Description |
| ----------- | ----------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_real_ord` | |
Returns [#returns-430]
**Type:** `boolean`
boolean
***
gte(eql_v3_real_ord, jsonb) [#gteeql_v3_real_ord-jsonb]
Operator wrapper for public.eql\_v3\_real\_ord.
Parameters [#parameters-435]
| Name | Type | Description |
| ----------- | ----------------- | ----------- |
| `a public.` | `eql_v3_real_ord` | |
| `b` | `jsonb` | |
Returns [#returns-431]
**Type:** `boolean`
boolean
***
gte(eql_v3_real_ord, eql_v3_real_ord) [#gteeql_v3_real_ord-eql_v3_real_ord]
Operator wrapper for public.eql\_v3\_real\_ord.
Parameters [#parameters-436]
| Name | Type | Description |
| ----------- | ----------------- | ----------- |
| `a public.` | `eql_v3_real_ord` | |
| `b public.` | `eql_v3_real_ord` | |
Returns [#returns-432]
**Type:** `boolean`
boolean
***
gte(jsonb, eql_v3_integer_ord) [#gtejsonb-eql_v3_integer_ord]
Operator wrapper for public.eql\_v3\_integer\_ord.
Parameters [#parameters-437]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_integer_ord` | |
Returns [#returns-433]
**Type:** `boolean`
boolean
***
gte(eql_v3_integer_ord, jsonb) [#gteeql_v3_integer_ord-jsonb]
Operator wrapper for public.eql\_v3\_integer\_ord.
Parameters [#parameters-438]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a public.` | `eql_v3_integer_ord` | |
| `b` | `jsonb` | |
Returns [#returns-434]
**Type:** `boolean`
boolean
***
gte(eql_v3_integer_ord, eql_v3_integer_ord) [#gteeql_v3_integer_ord-eql_v3_integer_ord]
Operator wrapper for public.eql\_v3\_integer\_ord.
Parameters [#parameters-439]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a public.` | `eql_v3_integer_ord` | |
| `b public.` | `eql_v3_integer_ord` | |
Returns [#returns-435]
**Type:** `boolean`
boolean
***
gte(query_smallint_ord_ore, eql_v3_smallint_ord_ore) [#gtequery_smallint_ord_ore-eql_v3_smallint_ord_ore]
Operator wrapper for eql\_v3.query\_smallint\_ord\_ore.
Parameters [#parameters-440]
| Name | Type | Description |
| ----------- | ------------------------- | ----------- |
| `a eql_v3.` | `query_smallint_ord_ore` | |
| `b public.` | `eql_v3_smallint_ord_ore` | |
Returns [#returns-436]
**Type:** `boolean`
boolean
***
gte(eql_v3_smallint_ord_ore, query_smallint_ord_ore) [#gteeql_v3_smallint_ord_ore-query_smallint_ord_ore]
Operator wrapper for eql\_v3.query\_smallint\_ord\_ore.
Parameters [#parameters-441]
| Name | Type | Description |
| ----------- | ------------------------- | ----------- |
| `a public.` | `eql_v3_smallint_ord_ore` | |
| `b eql_v3.` | `query_smallint_ord_ore` | |
Returns [#returns-437]
**Type:** `boolean`
boolean
***
gte(jsonb, eql_v3_text_ord_ope) [#gtejsonb-eql_v3_text_ord_ope]
Operator wrapper for public.eql\_v3\_text\_ord\_ope.
Parameters [#parameters-442]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_text_ord_ope` | |
Returns [#returns-438]
**Type:** `boolean`
boolean
***
gte(eql_v3_text_ord_ope, jsonb) [#gteeql_v3_text_ord_ope-jsonb]
Operator wrapper for public.eql\_v3\_text\_ord\_ope.
Parameters [#parameters-443]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_text_ord_ope` | |
| `b` | `jsonb` | |
Returns [#returns-439]
**Type:** `boolean`
boolean
***
gte(eql_v3_text_ord_ope, eql_v3_text_ord_ope) [#gteeql_v3_text_ord_ope-eql_v3_text_ord_ope]
Operator wrapper for public.eql\_v3\_text\_ord\_ope.
Parameters [#parameters-444]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_text_ord_ope` | |
| `b public.` | `eql_v3_text_ord_ope` | |
Returns [#returns-440]
**Type:** `boolean`
boolean
***
gte(query_double_ord_ope, eql_v3_double_ord_ope) [#gtequery_double_ord_ope-eql_v3_double_ord_ope]
Operator wrapper for eql\_v3.query\_double\_ord\_ope.
Parameters [#parameters-445]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a eql_v3.` | `query_double_ord_ope` | |
| `b public.` | `eql_v3_double_ord_ope` | |
Returns [#returns-441]
**Type:** `boolean`
boolean
***
gte(eql_v3_double_ord_ope, query_double_ord_ope) [#gteeql_v3_double_ord_ope-query_double_ord_ope]
Operator wrapper for eql\_v3.query\_double\_ord\_ope.
Parameters [#parameters-446]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a public.` | `eql_v3_double_ord_ope` | |
| `b eql_v3.` | `query_double_ord_ope` | |
Returns [#returns-442]
**Type:** `boolean`
boolean
***
gte(query_integer_ord_ore, eql_v3_integer_ord_ore) [#gtequery_integer_ord_ore-eql_v3_integer_ord_ore]
Operator wrapper for eql\_v3.query\_integer\_ord\_ore.
Parameters [#parameters-447]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a eql_v3.` | `query_integer_ord_ore` | |
| `b public.` | `eql_v3_integer_ord_ore` | |
Returns [#returns-443]
**Type:** `boolean`
boolean
***
gte(eql_v3_integer_ord_ore, query_integer_ord_ore) [#gteeql_v3_integer_ord_ore-query_integer_ord_ore]
Operator wrapper for eql\_v3.query\_integer\_ord\_ore.
Parameters [#parameters-448]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a public.` | `eql_v3_integer_ord_ore` | |
| `b eql_v3.` | `query_integer_ord_ore` | |
Returns [#returns-444]
**Type:** `boolean`
boolean
***
gte(jsonb, eql_v3_bigint_ord_ore) [#gtejsonb-eql_v3_bigint_ord_ore]
Operator wrapper for public.eql\_v3\_bigint\_ord\_ore.
Parameters [#parameters-449]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_bigint_ord_ore` | |
Returns [#returns-445]
**Type:** `boolean`
boolean
***
gte(eql_v3_bigint_ord_ore, jsonb) [#gteeql_v3_bigint_ord_ore-jsonb]
Operator wrapper for public.eql\_v3\_bigint\_ord\_ore.
Parameters [#parameters-450]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a public.` | `eql_v3_bigint_ord_ore` | |
| `b` | `jsonb` | |
Returns [#returns-446]
**Type:** `boolean`
boolean
***
gte(eql_v3_bigint_ord_ore, eql_v3_bigint_ord_ore) [#gteeql_v3_bigint_ord_ore-eql_v3_bigint_ord_ore]
Operator wrapper for public.eql\_v3\_bigint\_ord\_ore.
Parameters [#parameters-451]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a public.` | `eql_v3_bigint_ord_ore` | |
| `b public.` | `eql_v3_bigint_ord_ore` | |
Returns [#returns-447]
**Type:** `boolean`
boolean
***
gte(query_date_ord, eql_v3_date_ord) [#gtequery_date_ord-eql_v3_date_ord]
Operator wrapper for eql\_v3.query\_date\_ord.
Parameters [#parameters-452]
| Name | Type | Description |
| ----------- | ----------------- | ----------- |
| `a eql_v3.` | `query_date_ord` | |
| `b public.` | `eql_v3_date_ord` | |
Returns [#returns-448]
**Type:** `boolean`
boolean
***
gte(eql_v3_date_ord, query_date_ord) [#gteeql_v3_date_ord-query_date_ord]
Operator wrapper for eql\_v3.query\_date\_ord.
Parameters [#parameters-453]
| Name | Type | Description |
| ----------- | ----------------- | ----------- |
| `a public.` | `eql_v3_date_ord` | |
| `b eql_v3.` | `query_date_ord` | |
Returns [#returns-449]
**Type:** `boolean`
boolean
***
gte(jsonb, eql_v3_real_ord_ore) [#gtejsonb-eql_v3_real_ord_ore]
Operator wrapper for public.eql\_v3\_real\_ord\_ore.
Parameters [#parameters-454]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_real_ord_ore` | |
Returns [#returns-450]
**Type:** `boolean`
boolean
***
gte(eql_v3_real_ord_ore, jsonb) [#gteeql_v3_real_ord_ore-jsonb]
Operator wrapper for public.eql\_v3\_real\_ord\_ore.
Parameters [#parameters-455]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_real_ord_ore` | |
| `b` | `jsonb` | |
Returns [#returns-451]
**Type:** `boolean`
boolean
***
gte(eql_v3_real_ord_ore, eql_v3_real_ord_ore) [#gteeql_v3_real_ord_ore-eql_v3_real_ord_ore]
Operator wrapper for public.eql\_v3\_real\_ord\_ore.
Parameters [#parameters-456]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_real_ord_ore` | |
| `b public.` | `eql_v3_real_ord_ore` | |
Returns [#returns-452]
**Type:** `boolean`
boolean
***
gte(jsonb, eql_v3_numeric_ord_ore) [#gtejsonb-eql_v3_numeric_ord_ore]
Operator wrapper for public.eql\_v3\_numeric\_ord\_ore.
Parameters [#parameters-457]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_numeric_ord_ore` | |
Returns [#returns-453]
**Type:** `boolean`
boolean
***
gte(eql_v3_numeric_ord_ore, jsonb) [#gteeql_v3_numeric_ord_ore-jsonb]
Operator wrapper for public.eql\_v3\_numeric\_ord\_ore.
Parameters [#parameters-458]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a public.` | `eql_v3_numeric_ord_ore` | |
| `b` | `jsonb` | |
Returns [#returns-454]
**Type:** `boolean`
boolean
***
gte(eql_v3_numeric_ord_ore, eql_v3_numeric_ord_ore) [#gteeql_v3_numeric_ord_ore-eql_v3_numeric_ord_ore]
Operator wrapper for public.eql\_v3\_numeric\_ord\_ore.
Parameters [#parameters-459]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a public.` | `eql_v3_numeric_ord_ore` | |
| `b public.` | `eql_v3_numeric_ord_ore` | |
Returns [#returns-455]
**Type:** `boolean`
boolean
***
gte(query_text_ord_ope, eql_v3_text_ord_ope) [#gtequery_text_ord_ope-eql_v3_text_ord_ope]
Operator wrapper for eql\_v3.query\_text\_ord\_ope.
Parameters [#parameters-460]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a eql_v3.` | `query_text_ord_ope` | |
| `b public.` | `eql_v3_text_ord_ope` | |
Returns [#returns-456]
**Type:** `boolean`
boolean
***
gte(eql_v3_text_ord_ope, query_text_ord_ope) [#gteeql_v3_text_ord_ope-query_text_ord_ope]
Operator wrapper for eql\_v3.query\_text\_ord\_ope.
Parameters [#parameters-461]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_text_ord_ope` | |
| `b eql_v3.` | `query_text_ord_ope` | |
Returns [#returns-457]
**Type:** `boolean`
boolean
***
gte(jsonb, eql_v3_bigint_ord_ope) [#gtejsonb-eql_v3_bigint_ord_ope]
Operator wrapper for public.eql\_v3\_bigint\_ord\_ope.
Parameters [#parameters-462]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_bigint_ord_ope` | |
Returns [#returns-458]
**Type:** `boolean`
boolean
***
gte(eql_v3_bigint_ord_ope, jsonb) [#gteeql_v3_bigint_ord_ope-jsonb]
Operator wrapper for public.eql\_v3\_bigint\_ord\_ope.
Parameters [#parameters-463]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a public.` | `eql_v3_bigint_ord_ope` | |
| `b` | `jsonb` | |
Returns [#returns-459]
**Type:** `boolean`
boolean
***
gte(eql_v3_bigint_ord_ope, eql_v3_bigint_ord_ope) [#gteeql_v3_bigint_ord_ope-eql_v3_bigint_ord_ope]
Operator wrapper for public.eql\_v3\_bigint\_ord\_ope.
Parameters [#parameters-464]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a public.` | `eql_v3_bigint_ord_ope` | |
| `b public.` | `eql_v3_bigint_ord_ope` | |
Returns [#returns-460]
**Type:** `boolean`
boolean
***
gte(query_numeric_ord, eql_v3_json_entry) [#gtequery_numeric_ord-eql_v3_json_entry]
Operator wrapper for public.eql\_v3\_json\_entry.
Parameters [#parameters-465]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a eql_v3.` | `query_numeric_ord` | |
| `b public.` | `eql_v3_json_entry` | |
Returns [#returns-461]
**Type:** `boolean`
boolean
***
gte(eql_v3_json_entry, query_numeric_ord) [#gteeql_v3_json_entry-query_numeric_ord]
Operator wrapper for public.eql\_v3\_json\_entry.
Parameters [#parameters-466]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a public.` | `eql_v3_json_entry` | |
| `b eql_v3.` | `query_numeric_ord` | |
Returns [#returns-462]
**Type:** `boolean`
boolean
***
gte(jsonb, eql_v3_double_ord_ore) [#gtejsonb-eql_v3_double_ord_ore]
Operator wrapper for public.eql\_v3\_double\_ord\_ore.
Parameters [#parameters-467]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_double_ord_ore` | |
Returns [#returns-463]
**Type:** `boolean`
boolean
***
gte(eql_v3_double_ord_ore, jsonb) [#gteeql_v3_double_ord_ore-jsonb]
Operator wrapper for public.eql\_v3\_double\_ord\_ore.
Parameters [#parameters-468]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a public.` | `eql_v3_double_ord_ore` | |
| `b` | `jsonb` | |
Returns [#returns-464]
**Type:** `boolean`
boolean
***
gte(eql_v3_double_ord_ore, eql_v3_double_ord_ore) [#gteeql_v3_double_ord_ore-eql_v3_double_ord_ore]
Operator wrapper for public.eql\_v3\_double\_ord\_ore.
Parameters [#parameters-469]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a public.` | `eql_v3_double_ord_ore` | |
| `b public.` | `eql_v3_double_ord_ore` | |
Returns [#returns-465]
**Type:** `boolean`
boolean
***
gte(jsonb, eql_v3_bigint_ord) [#gtejsonb-eql_v3_bigint_ord]
Operator wrapper for public.eql\_v3\_bigint\_ord.
Parameters [#parameters-470]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_bigint_ord` | |
Returns [#returns-466]
**Type:** `boolean`
boolean
***
gte(eql_v3_bigint_ord, jsonb) [#gteeql_v3_bigint_ord-jsonb]
Operator wrapper for public.eql\_v3\_bigint\_ord.
Parameters [#parameters-471]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a public.` | `eql_v3_bigint_ord` | |
| `b` | `jsonb` | |
Returns [#returns-467]
**Type:** `boolean`
boolean
***
gte(eql_v3_bigint_ord, eql_v3_bigint_ord) [#gteeql_v3_bigint_ord-eql_v3_bigint_ord]
Operator wrapper for public.eql\_v3\_bigint\_ord.
Parameters [#parameters-472]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a public.` | `eql_v3_bigint_ord` | |
| `b public.` | `eql_v3_bigint_ord` | |
Returns [#returns-468]
**Type:** `boolean`
boolean
***
gte(query_text_ord, eql_v3_json_entry) [#gtequery_text_ord-eql_v3_json_entry]
Operator wrapper for public.eql\_v3\_json\_entry.
Unsupported operator blocker for public.eql\_v3\_json\_entry.
Parameters [#parameters-473]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a eql_v3.` | `query_text_ord` | |
| `b public.` | `eql_v3_json_entry` | |
Returns [#returns-469]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gte(eql_v3_json_entry, query_text_ord) [#gteeql_v3_json_entry-query_text_ord]
Operator wrapper for public.eql\_v3\_json\_entry.
Unsupported operator blocker for public.eql\_v3\_json\_entry.
Parameters [#parameters-474]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a public.` | `eql_v3_json_entry` | |
| `b eql_v3.` | `query_text_ord` | |
Returns [#returns-470]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gte(query_timestamp_ord_ope, eql_v3_timestamp_ord_ope) [#gtequery_timestamp_ord_ope-eql_v3_timestamp_ord_ope]
Operator wrapper for eql\_v3.query\_timestamp\_ord\_ope.
Parameters [#parameters-475]
| Name | Type | Description |
| ----------- | -------------------------- | ----------- |
| `a eql_v3.` | `query_timestamp_ord_ope` | |
| `b public.` | `eql_v3_timestamp_ord_ope` | |
Returns [#returns-471]
**Type:** `boolean`
boolean
***
gte(eql_v3_timestamp_ord_ope, query_timestamp_ord_ope) [#gteeql_v3_timestamp_ord_ope-query_timestamp_ord_ope]
Operator wrapper for eql\_v3.query\_timestamp\_ord\_ope.
Parameters [#parameters-476]
| Name | Type | Description |
| ----------- | -------------------------- | ----------- |
| `a public.` | `eql_v3_timestamp_ord_ope` | |
| `b eql_v3.` | `query_timestamp_ord_ope` | |
Returns [#returns-472]
**Type:** `boolean`
boolean
***
gte(query_numeric_ord, eql_v3_numeric_ord) [#gtequery_numeric_ord-eql_v3_numeric_ord]
Operator wrapper for eql\_v3.query\_numeric\_ord.
Parameters [#parameters-477]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a eql_v3.` | `query_numeric_ord` | |
| `b public.` | `eql_v3_numeric_ord` | |
Returns [#returns-473]
**Type:** `boolean`
boolean
***
gte(eql_v3_numeric_ord, query_numeric_ord) [#gteeql_v3_numeric_ord-query_numeric_ord]
Operator wrapper for eql\_v3.query\_numeric\_ord.
Parameters [#parameters-478]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a public.` | `eql_v3_numeric_ord` | |
| `b eql_v3.` | `query_numeric_ord` | |
Returns [#returns-474]
**Type:** `boolean`
boolean
***
gte(jsonb, eql_v3_text_search_ore) [#gtejsonb-eql_v3_text_search_ore]
Operator wrapper for public.eql\_v3\_text\_search\_ore.
Parameters [#parameters-479]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_text_search_ore` | |
Returns [#returns-475]
**Type:** `boolean`
boolean
***
gte(eql_v3_text_search_ore, jsonb) [#gteeql_v3_text_search_ore-jsonb]
Operator wrapper for public.eql\_v3\_text\_search\_ore.
Parameters [#parameters-480]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a public.` | `eql_v3_text_search_ore` | |
| `b` | `jsonb` | |
Returns [#returns-476]
**Type:** `boolean`
boolean
***
gte(eql_v3_text_search_ore, eql_v3_text_search_ore) [#gteeql_v3_text_search_ore-eql_v3_text_search_ore]
Operator wrapper for public.eql\_v3\_text\_search\_ore.
Parameters [#parameters-481]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a public.` | `eql_v3_text_search_ore` | |
| `b public.` | `eql_v3_text_search_ore` | |
Returns [#returns-477]
**Type:** `boolean`
boolean
***
gte(query_real_ord_ope, eql_v3_real_ord_ope) [#gtequery_real_ord_ope-eql_v3_real_ord_ope]
Operator wrapper for eql\_v3.query\_real\_ord\_ope.
Parameters [#parameters-482]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a eql_v3.` | `query_real_ord_ope` | |
| `b public.` | `eql_v3_real_ord_ope` | |
Returns [#returns-478]
**Type:** `boolean`
boolean
***
gte(eql_v3_real_ord_ope, query_real_ord_ope) [#gteeql_v3_real_ord_ope-query_real_ord_ope]
Operator wrapper for eql\_v3.query\_real\_ord\_ope.
Parameters [#parameters-483]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_real_ord_ope` | |
| `b eql_v3.` | `query_real_ord_ope` | |
Returns [#returns-479]
**Type:** `boolean`
boolean
***
gte(jsonb, eql_v3_timestamp_ord) [#gtejsonb-eql_v3_timestamp_ord]
Operator wrapper for public.eql\_v3\_timestamp\_ord.
Parameters [#parameters-484]
| Name | Type | Description |
| ----------- | ---------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_timestamp_ord` | |
Returns [#returns-480]
**Type:** `boolean`
boolean
***
gte(eql_v3_timestamp_ord, jsonb) [#gteeql_v3_timestamp_ord-jsonb]
Operator wrapper for public.eql\_v3\_timestamp\_ord.
Parameters [#parameters-485]
| Name | Type | Description |
| ----------- | ---------------------- | ----------- |
| `a public.` | `eql_v3_timestamp_ord` | |
| `b` | `jsonb` | |
Returns [#returns-481]
**Type:** `boolean`
boolean
***
gte(eql_v3_timestamp_ord, eql_v3_timestamp_ord) [#gteeql_v3_timestamp_ord-eql_v3_timestamp_ord]
Operator wrapper for public.eql\_v3\_timestamp\_ord.
Parameters [#parameters-486]
| Name | Type | Description |
| ----------- | ---------------------- | ----------- |
| `a public.` | `eql_v3_timestamp_ord` | |
| `b public.` | `eql_v3_timestamp_ord` | |
Returns [#returns-482]
**Type:** `boolean`
boolean
***
gte(jsonb, eql_v3_smallint_ord_ope) [#gtejsonb-eql_v3_smallint_ord_ope]
Operator wrapper for public.eql\_v3\_smallint\_ord\_ope.
Parameters [#parameters-487]
| Name | Type | Description |
| ----------- | ------------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_smallint_ord_ope` | |
Returns [#returns-483]
**Type:** `boolean`
boolean
***
gte(eql_v3_smallint_ord_ope, jsonb) [#gteeql_v3_smallint_ord_ope-jsonb]
Operator wrapper for public.eql\_v3\_smallint\_ord\_ope.
Parameters [#parameters-488]
| Name | Type | Description |
| ----------- | ------------------------- | ----------- |
| `a public.` | `eql_v3_smallint_ord_ope` | |
| `b` | `jsonb` | |
Returns [#returns-484]
**Type:** `boolean`
boolean
***
gte(eql_v3_smallint_ord_ope, eql_v3_smallint_ord_ope) [#gteeql_v3_smallint_ord_ope-eql_v3_smallint_ord_ope]
Operator wrapper for public.eql\_v3\_smallint\_ord\_ope.
Parameters [#parameters-489]
| Name | Type | Description |
| ----------- | ------------------------- | ----------- |
| `a public.` | `eql_v3_smallint_ord_ope` | |
| `b public.` | `eql_v3_smallint_ord_ope` | |
Returns [#returns-485]
**Type:** `boolean`
boolean
***
gte(query_integer_ord, eql_v3_json_entry) [#gtequery_integer_ord-eql_v3_json_entry]
Operator wrapper for public.eql\_v3\_json\_entry.
Parameters [#parameters-490]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a eql_v3.` | `query_integer_ord` | |
| `b public.` | `eql_v3_json_entry` | |
Returns [#returns-486]
**Type:** `boolean`
boolean
***
gte(eql_v3_json_entry, query_integer_ord) [#gteeql_v3_json_entry-query_integer_ord]
Operator wrapper for public.eql\_v3\_json\_entry.
Parameters [#parameters-491]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a public.` | `eql_v3_json_entry` | |
| `b eql_v3.` | `query_integer_ord` | |
Returns [#returns-487]
**Type:** `boolean`
boolean
***
gte(query_real_ord, eql_v3_json_entry) [#gtequery_real_ord-eql_v3_json_entry]
Operator wrapper for public.eql\_v3\_json\_entry.
Parameters [#parameters-492]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a eql_v3.` | `query_real_ord` | |
| `b public.` | `eql_v3_json_entry` | |
Returns [#returns-488]
**Type:** `boolean`
boolean
***
gte(eql_v3_json_entry, query_real_ord) [#gteeql_v3_json_entry-query_real_ord]
Operator wrapper for public.eql\_v3\_json\_entry.
Parameters [#parameters-493]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a public.` | `eql_v3_json_entry` | |
| `b eql_v3.` | `query_real_ord` | |
Returns [#returns-489]
**Type:** `boolean`
boolean
***
gte(query_double_ord, eql_v3_double_ord) [#gtequery_double_ord-eql_v3_double_ord]
Operator wrapper for eql\_v3.query\_double\_ord.
Parameters [#parameters-494]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a eql_v3.` | `query_double_ord` | |
| `b public.` | `eql_v3_double_ord` | |
Returns [#returns-490]
**Type:** `boolean`
boolean
***
gte(eql_v3_double_ord, query_double_ord) [#gteeql_v3_double_ord-query_double_ord]
Operator wrapper for eql\_v3.query\_double\_ord.
Parameters [#parameters-495]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a public.` | `eql_v3_double_ord` | |
| `b eql_v3.` | `query_double_ord` | |
Returns [#returns-491]
**Type:** `boolean`
boolean
***
gte(query_double_ord_ore, eql_v3_double_ord_ore) [#gtequery_double_ord_ore-eql_v3_double_ord_ore]
Operator wrapper for eql\_v3.query\_double\_ord\_ore.
Parameters [#parameters-496]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a eql_v3.` | `query_double_ord_ore` | |
| `b public.` | `eql_v3_double_ord_ore` | |
Returns [#returns-492]
**Type:** `boolean`
boolean
***
gte(eql_v3_double_ord_ore, query_double_ord_ore) [#gteeql_v3_double_ord_ore-query_double_ord_ore]
Operator wrapper for eql\_v3.query\_double\_ord\_ore.
Parameters [#parameters-497]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a public.` | `eql_v3_double_ord_ore` | |
| `b eql_v3.` | `query_double_ord_ore` | |
Returns [#returns-493]
**Type:** `boolean`
boolean
***
gte(jsonb, eql_v3_timestamp_ord_ore) [#gtejsonb-eql_v3_timestamp_ord_ore]
Operator wrapper for public.eql\_v3\_timestamp\_ord\_ore.
Parameters [#parameters-498]
| Name | Type | Description |
| ----------- | -------------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_timestamp_ord_ore` | |
Returns [#returns-494]
**Type:** `boolean`
boolean
***
gte(eql_v3_timestamp_ord_ore, jsonb) [#gteeql_v3_timestamp_ord_ore-jsonb]
Operator wrapper for public.eql\_v3\_timestamp\_ord\_ore.
Parameters [#parameters-499]
| Name | Type | Description |
| ----------- | -------------------------- | ----------- |
| `a public.` | `eql_v3_timestamp_ord_ore` | |
| `b` | `jsonb` | |
Returns [#returns-495]
**Type:** `boolean`
boolean
***
gte(eql_v3_timestamp_ord_ore, eql_v3_timestamp_ord_ore) [#gteeql_v3_timestamp_ord_ore-eql_v3_timestamp_ord_ore]
Operator wrapper for public.eql\_v3\_timestamp\_ord\_ore.
Parameters [#parameters-500]
| Name | Type | Description |
| ----------- | -------------------------- | ----------- |
| `a public.` | `eql_v3_timestamp_ord_ore` | |
| `b public.` | `eql_v3_timestamp_ord_ore` | |
Returns [#returns-496]
**Type:** `boolean`
boolean
***
gte(jsonb, eql_v3_text_search) [#gtejsonb-eql_v3_text_search]
Operator wrapper for public.eql\_v3\_text\_search.
Parameters [#parameters-501]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_text_search` | |
Returns [#returns-497]
**Type:** `boolean`
boolean
***
gte(eql_v3_text_search, jsonb) [#gteeql_v3_text_search-jsonb]
Operator wrapper for public.eql\_v3\_text\_search.
Parameters [#parameters-502]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a public.` | `eql_v3_text_search` | |
| `b` | `jsonb` | |
Returns [#returns-498]
**Type:** `boolean`
boolean
***
gte(eql_v3_text_search, eql_v3_text_search) [#gteeql_v3_text_search-eql_v3_text_search]
Operator wrapper for public.eql\_v3\_text\_search.
Parameters [#parameters-503]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a public.` | `eql_v3_text_search` | |
| `b public.` | `eql_v3_text_search` | |
Returns [#returns-499]
**Type:** `boolean`
boolean
***
gte(query_numeric_ord_ore, eql_v3_numeric_ord_ore) [#gtequery_numeric_ord_ore-eql_v3_numeric_ord_ore]
Operator wrapper for eql\_v3.query\_numeric\_ord\_ore.
Parameters [#parameters-504]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a eql_v3.` | `query_numeric_ord_ore` | |
| `b public.` | `eql_v3_numeric_ord_ore` | |
Returns [#returns-500]
**Type:** `boolean`
boolean
***
gte(eql_v3_numeric_ord_ore, query_numeric_ord_ore) [#gteeql_v3_numeric_ord_ore-query_numeric_ord_ore]
Operator wrapper for eql\_v3.query\_numeric\_ord\_ore.
Parameters [#parameters-505]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a public.` | `eql_v3_numeric_ord_ore` | |
| `b eql_v3.` | `query_numeric_ord_ore` | |
Returns [#returns-501]
**Type:** `boolean`
boolean
***
gte(query_bigint_ord_ore, eql_v3_bigint_ord_ore) [#gtequery_bigint_ord_ore-eql_v3_bigint_ord_ore]
Operator wrapper for eql\_v3.query\_bigint\_ord\_ore.
Parameters [#parameters-506]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a eql_v3.` | `query_bigint_ord_ore` | |
| `b public.` | `eql_v3_bigint_ord_ore` | |
Returns [#returns-502]
**Type:** `boolean`
boolean
***
gte(eql_v3_bigint_ord_ore, query_bigint_ord_ore) [#gteeql_v3_bigint_ord_ore-query_bigint_ord_ore]
Operator wrapper for eql\_v3.query\_bigint\_ord\_ore.
Parameters [#parameters-507]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a public.` | `eql_v3_bigint_ord_ore` | |
| `b eql_v3.` | `query_bigint_ord_ore` | |
Returns [#returns-503]
**Type:** `boolean`
boolean
***
gte(query_bigint_ord_ope, eql_v3_bigint_ord_ope) [#gtequery_bigint_ord_ope-eql_v3_bigint_ord_ope]
Operator wrapper for eql\_v3.query\_bigint\_ord\_ope.
Parameters [#parameters-508]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a eql_v3.` | `query_bigint_ord_ope` | |
| `b public.` | `eql_v3_bigint_ord_ope` | |
Returns [#returns-504]
**Type:** `boolean`
boolean
***
gte(eql_v3_bigint_ord_ope, query_bigint_ord_ope) [#gteeql_v3_bigint_ord_ope-query_bigint_ord_ope]
Operator wrapper for eql\_v3.query\_bigint\_ord\_ope.
Parameters [#parameters-509]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a public.` | `eql_v3_bigint_ord_ope` | |
| `b eql_v3.` | `query_bigint_ord_ope` | |
Returns [#returns-505]
**Type:** `boolean`
boolean
***
gte(query_date_ord_ore, eql_v3_date_ord_ore) [#gtequery_date_ord_ore-eql_v3_date_ord_ore]
Operator wrapper for eql\_v3.query\_date\_ord\_ore.
Parameters [#parameters-510]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a eql_v3.` | `query_date_ord_ore` | |
| `b public.` | `eql_v3_date_ord_ore` | |
Returns [#returns-506]
**Type:** `boolean`
boolean
***
gte(eql_v3_date_ord_ore, query_date_ord_ore) [#gteeql_v3_date_ord_ore-query_date_ord_ore]
Operator wrapper for eql\_v3.query\_date\_ord\_ore.
Parameters [#parameters-511]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_date_ord_ore` | |
| `b eql_v3.` | `query_date_ord_ore` | |
Returns [#returns-507]
**Type:** `boolean`
boolean
***
gte(query_smallint_ord_ope, eql_v3_smallint_ord_ope) [#gtequery_smallint_ord_ope-eql_v3_smallint_ord_ope]
Operator wrapper for eql\_v3.query\_smallint\_ord\_ope.
Parameters [#parameters-512]
| Name | Type | Description |
| ----------- | ------------------------- | ----------- |
| `a eql_v3.` | `query_smallint_ord_ope` | |
| `b public.` | `eql_v3_smallint_ord_ope` | |
Returns [#returns-508]
**Type:** `boolean`
boolean
***
gte(eql_v3_smallint_ord_ope, query_smallint_ord_ope) [#gteeql_v3_smallint_ord_ope-query_smallint_ord_ope]
Operator wrapper for eql\_v3.query\_smallint\_ord\_ope.
Parameters [#parameters-513]
| Name | Type | Description |
| ----------- | ------------------------- | ----------- |
| `a public.` | `eql_v3_smallint_ord_ope` | |
| `b eql_v3.` | `query_smallint_ord_ope` | |
Returns [#returns-509]
**Type:** `boolean`
boolean
***
gte(jsonb, eql_v3_double_ord) [#gtejsonb-eql_v3_double_ord]
Operator wrapper for public.eql\_v3\_double\_ord.
Parameters [#parameters-514]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_double_ord` | |
Returns [#returns-510]
**Type:** `boolean`
boolean
***
gte(eql_v3_double_ord, jsonb) [#gteeql_v3_double_ord-jsonb]
Operator wrapper for public.eql\_v3\_double\_ord.
Parameters [#parameters-515]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a public.` | `eql_v3_double_ord` | |
| `b` | `jsonb` | |
Returns [#returns-511]
**Type:** `boolean`
boolean
***
gte(eql_v3_double_ord, eql_v3_double_ord) [#gteeql_v3_double_ord-eql_v3_double_ord]
Operator wrapper for public.eql\_v3\_double\_ord.
Parameters [#parameters-516]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a public.` | `eql_v3_double_ord` | |
| `b public.` | `eql_v3_double_ord` | |
Returns [#returns-512]
**Type:** `boolean`
boolean
***
gte(query_numeric_ord_ope, eql_v3_numeric_ord_ope) [#gtequery_numeric_ord_ope-eql_v3_numeric_ord_ope]
Operator wrapper for eql\_v3.query\_numeric\_ord\_ope.
Parameters [#parameters-517]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a eql_v3.` | `query_numeric_ord_ope` | |
| `b public.` | `eql_v3_numeric_ord_ope` | |
Returns [#returns-513]
**Type:** `boolean`
boolean
***
gte(eql_v3_numeric_ord_ope, query_numeric_ord_ope) [#gteeql_v3_numeric_ord_ope-query_numeric_ord_ope]
Operator wrapper for eql\_v3.query\_numeric\_ord\_ope.
Parameters [#parameters-518]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a public.` | `eql_v3_numeric_ord_ope` | |
| `b eql_v3.` | `query_numeric_ord_ope` | |
Returns [#returns-514]
**Type:** `boolean`
boolean
***
gte(jsonb, eql_v3_double_ord_ope) [#gtejsonb-eql_v3_double_ord_ope]
Operator wrapper for public.eql\_v3\_double\_ord\_ope.
Parameters [#parameters-519]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_double_ord_ope` | |
Returns [#returns-515]
**Type:** `boolean`
boolean
***
gte(eql_v3_double_ord_ope, jsonb) [#gteeql_v3_double_ord_ope-jsonb]
Operator wrapper for public.eql\_v3\_double\_ord\_ope.
Parameters [#parameters-520]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a public.` | `eql_v3_double_ord_ope` | |
| `b` | `jsonb` | |
Returns [#returns-516]
**Type:** `boolean`
boolean
***
gte(eql_v3_double_ord_ope, eql_v3_double_ord_ope) [#gteeql_v3_double_ord_ope-eql_v3_double_ord_ope]
Operator wrapper for public.eql\_v3\_double\_ord\_ope.
Parameters [#parameters-521]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a public.` | `eql_v3_double_ord_ope` | |
| `b public.` | `eql_v3_double_ord_ope` | |
Returns [#returns-517]
**Type:** `boolean`
boolean
***
gte(jsonb, eql_v3_numeric_ord_ope) [#gtejsonb-eql_v3_numeric_ord_ope]
Operator wrapper for public.eql\_v3\_numeric\_ord\_ope.
Parameters [#parameters-522]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_numeric_ord_ope` | |
Returns [#returns-518]
**Type:** `boolean`
boolean
***
gte(eql_v3_numeric_ord_ope, jsonb) [#gteeql_v3_numeric_ord_ope-jsonb]
Operator wrapper for public.eql\_v3\_numeric\_ord\_ope.
Parameters [#parameters-523]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a public.` | `eql_v3_numeric_ord_ope` | |
| `b` | `jsonb` | |
Returns [#returns-519]
**Type:** `boolean`
boolean
***
gte(eql_v3_numeric_ord_ope, eql_v3_numeric_ord_ope) [#gteeql_v3_numeric_ord_ope-eql_v3_numeric_ord_ope]
Operator wrapper for public.eql\_v3\_numeric\_ord\_ope.
Parameters [#parameters-524]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a public.` | `eql_v3_numeric_ord_ope` | |
| `b public.` | `eql_v3_numeric_ord_ope` | |
Returns [#returns-520]
**Type:** `boolean`
boolean
***
gte(jsonb, eql_v3_date_ord_ore) [#gtejsonb-eql_v3_date_ord_ore]
Operator wrapper for public.eql\_v3\_date\_ord\_ore.
Parameters [#parameters-525]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_date_ord_ore` | |
Returns [#returns-521]
**Type:** `boolean`
boolean
***
gte(eql_v3_date_ord_ore, jsonb) [#gteeql_v3_date_ord_ore-jsonb]
Operator wrapper for public.eql\_v3\_date\_ord\_ore.
Parameters [#parameters-526]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_date_ord_ore` | |
| `b` | `jsonb` | |
Returns [#returns-522]
**Type:** `boolean`
boolean
***
gte(eql_v3_date_ord_ore, eql_v3_date_ord_ore) [#gteeql_v3_date_ord_ore-eql_v3_date_ord_ore]
Operator wrapper for public.eql\_v3\_date\_ord\_ore.
Parameters [#parameters-527]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_date_ord_ore` | |
| `b public.` | `eql_v3_date_ord_ore` | |
Returns [#returns-523]
**Type:** `boolean`
boolean
***
gte(query_timestamp_ord, eql_v3_timestamp_ord) [#gtequery_timestamp_ord-eql_v3_timestamp_ord]
Operator wrapper for eql\_v3.query\_timestamp\_ord.
Parameters [#parameters-528]
| Name | Type | Description |
| ----------- | ---------------------- | ----------- |
| `a eql_v3.` | `query_timestamp_ord` | |
| `b public.` | `eql_v3_timestamp_ord` | |
Returns [#returns-524]
**Type:** `boolean`
boolean
***
gte(eql_v3_timestamp_ord, query_timestamp_ord) [#gteeql_v3_timestamp_ord-query_timestamp_ord]
Operator wrapper for eql\_v3.query\_timestamp\_ord.
Parameters [#parameters-529]
| Name | Type | Description |
| ----------- | ---------------------- | ----------- |
| `a public.` | `eql_v3_timestamp_ord` | |
| `b eql_v3.` | `query_timestamp_ord` | |
Returns [#returns-525]
**Type:** `boolean`
boolean
***
gte(jsonb, eql_v3_smallint_ord_ore) [#gtejsonb-eql_v3_smallint_ord_ore]
Operator wrapper for public.eql\_v3\_smallint\_ord\_ore.
Parameters [#parameters-530]
| Name | Type | Description |
| ----------- | ------------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_smallint_ord_ore` | |
Returns [#returns-526]
**Type:** `boolean`
boolean
***
gte(eql_v3_smallint_ord_ore, jsonb) [#gteeql_v3_smallint_ord_ore-jsonb]
Operator wrapper for public.eql\_v3\_smallint\_ord\_ore.
Parameters [#parameters-531]
| Name | Type | Description |
| ----------- | ------------------------- | ----------- |
| `a public.` | `eql_v3_smallint_ord_ore` | |
| `b` | `jsonb` | |
Returns [#returns-527]
**Type:** `boolean`
boolean
***
gte(eql_v3_smallint_ord_ore, eql_v3_smallint_ord_ore) [#gteeql_v3_smallint_ord_ore-eql_v3_smallint_ord_ore]
Operator wrapper for public.eql\_v3\_smallint\_ord\_ore.
Parameters [#parameters-532]
| Name | Type | Description |
| ----------- | ------------------------- | ----------- |
| `a public.` | `eql_v3_smallint_ord_ore` | |
| `b public.` | `eql_v3_smallint_ord_ore` | |
Returns [#returns-528]
**Type:** `boolean`
boolean
***
gte(jsonb, eql_v3_date_ord_ope) [#gtejsonb-eql_v3_date_ord_ope]
Operator wrapper for public.eql\_v3\_date\_ord\_ope.
Parameters [#parameters-533]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_date_ord_ope` | |
Returns [#returns-529]
**Type:** `boolean`
boolean
***
gte(eql_v3_date_ord_ope, jsonb) [#gteeql_v3_date_ord_ope-jsonb]
Operator wrapper for public.eql\_v3\_date\_ord\_ope.
Parameters [#parameters-534]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_date_ord_ope` | |
| `b` | `jsonb` | |
Returns [#returns-530]
**Type:** `boolean`
boolean
***
gte(eql_v3_date_ord_ope, eql_v3_date_ord_ope) [#gteeql_v3_date_ord_ope-eql_v3_date_ord_ope]
Operator wrapper for public.eql\_v3\_date\_ord\_ope.
Parameters [#parameters-535]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_date_ord_ope` | |
| `b public.` | `eql_v3_date_ord_ope` | |
Returns [#returns-531]
**Type:** `boolean`
boolean
***
gte(query_bigint_ord, eql_v3_bigint_ord) [#gtequery_bigint_ord-eql_v3_bigint_ord]
Operator wrapper for eql\_v3.query\_bigint\_ord.
Parameters [#parameters-536]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a eql_v3.` | `query_bigint_ord` | |
| `b public.` | `eql_v3_bigint_ord` | |
Returns [#returns-532]
**Type:** `boolean`
boolean
***
gte(eql_v3_bigint_ord, query_bigint_ord) [#gteeql_v3_bigint_ord-query_bigint_ord]
Operator wrapper for eql\_v3.query\_bigint\_ord.
Parameters [#parameters-537]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a public.` | `eql_v3_bigint_ord` | |
| `b eql_v3.` | `query_bigint_ord` | |
Returns [#returns-533]
**Type:** `boolean`
boolean
***
gte(jsonb, eql_v3_text_ord_ore) [#gtejsonb-eql_v3_text_ord_ore]
Operator wrapper for public.eql\_v3\_text\_ord\_ore.
Parameters [#parameters-538]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_text_ord_ore` | |
Returns [#returns-534]
**Type:** `boolean`
boolean
***
gte(eql_v3_text_ord_ore, jsonb) [#gteeql_v3_text_ord_ore-jsonb]
Operator wrapper for public.eql\_v3\_text\_ord\_ore.
Parameters [#parameters-539]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_text_ord_ore` | |
| `b` | `jsonb` | |
Returns [#returns-535]
**Type:** `boolean`
boolean
***
gte(eql_v3_text_ord_ore, eql_v3_text_ord_ore) [#gteeql_v3_text_ord_ore-eql_v3_text_ord_ore]
Operator wrapper for public.eql\_v3\_text\_ord\_ore.
Parameters [#parameters-540]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_text_ord_ore` | |
| `b public.` | `eql_v3_text_ord_ore` | |
Returns [#returns-536]
**Type:** `boolean`
boolean
***
gte(query_bigint_ord, eql_v3_json_entry) [#gtequery_bigint_ord-eql_v3_json_entry]
Operator wrapper for public.eql\_v3\_json\_entry.
Unsupported operator blocker for public.eql\_v3\_json\_entry.
Parameters [#parameters-541]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a eql_v3.` | `query_bigint_ord` | |
| `b public.` | `eql_v3_json_entry` | |
Returns [#returns-537]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gte(eql_v3_json_entry, query_bigint_ord) [#gteeql_v3_json_entry-query_bigint_ord]
Operator wrapper for public.eql\_v3\_json\_entry.
Unsupported operator blocker for public.eql\_v3\_json\_entry.
Parameters [#parameters-542]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a public.` | `eql_v3_json_entry` | |
| `b eql_v3.` | `query_bigint_ord` | |
Returns [#returns-538]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
jsonb_array(jsonb) [#jsonb_arrayjsonb]
Extract deterministic containment fields (s) per sv element.
Excludes non-deterministic ciphertext so PostgreSQL's native jsonb @> can compare for containment. Use for GIN indexes and containment queries. Exact and structural containment are selector-set containment, so ordering terms are deliberately excluded.
Parameters [#parameters-543]
| Name | Type | Description |
| ----- | ------- | --------------------- |
| `val` | `jsonb` | encrypted EQL payload |
Returns [#returns-539]
**Type:** `jsonb[]`
jsonb\[] Array of objects with only deterministic fields.
***
jsonb_array_elements(jsonb) [#jsonb_array_elementsjsonb]
Extract elements of an encrypted JSONB array as rows.
Parameters [#parameters-544]
| Name | Type | Description |
| ----- | ------- | ---------------------------------------------- |
| `val` | `jsonb` | encrypted EQL payload (must have a flag true). |
Returns [#returns-540]
**Type:** `SETOF`
SETOF public.eql\_v3\_json\_entry One row per element (metadata preserved).
Exceptions [#exceptions-1]
* 'cannot extract elements from non-array' if not an array.
***
jsonb_array_length(jsonb) [#jsonb_array_lengthjsonb]
Get the length of an encrypted JSONB array.
Parameters [#parameters-545]
| Name | Type | Description |
| ----- | ------- | ---------------------------------------------- |
| `val` | `jsonb` | encrypted EQL payload (must have a flag true). |
Returns [#returns-541]
**Type:** `integer`
integer Number of elements.
Exceptions [#exceptions-2]
* 'cannot get array length of a non-array' if not an array.
***
jsonb_contained_by(jsonb, jsonb) [#jsonb_contained_byjsonb-jsonb]
GIN-indexable "is contained by" check.
Parameters [#parameters-546]
| Name | Type | Description |
| ---- | ------- | ------------------ |
| `a` | `jsonb` | Payload to check. |
| `b` | `jsonb` | Container payload. |
Returns [#returns-542]
**Type:** `boolean`
boolean True if all elements of a are contained in b.
Note [#note-2]
Public raw-jsonb\[] reverse-containment helper — the function-form entrypoint for \<@ on platforms without operator support. The typed public.eql\_v3\_json\_search \<@ operator binds to eql\_v3.ste\_vec\_contains instead, but both agree on the result.
***
jsonb_contains(jsonb, jsonb) [#jsonb_containsjsonb-jsonb]
GIN-indexable containment check: does a contain all of b?
Parameters [#parameters-547]
| Name | Type | Description |
| ---- | ------- | ------------------ |
| `a` | `jsonb` | Container payload. |
| `b` | `jsonb` | Search payload. |
Returns [#returns-543]
**Type:** `boolean`
boolean True if a contains all deterministic elements of b.
Note [#note-3]
Public raw-jsonb\[] containment helper over the extracted deterministic fields — the function-form entrypoint for containment on platforms without operator support (Supabase/PostgREST). The typed public.eql\_v3\_json\_search @> operator does NOT call this function — it binds to eql\_v3.ste\_vec\_contains instead — but both agree on the result (a parity test pins this). Also the documented GIN index expression (eql\_v3.jsonb\_array(col)); see docs/reference/database-indexes.md.
***
jsonb_path_exists(jsonb, text) [#jsonb_path_existsjsonb-text]
Check if a selector path exists in encrypted JSONB.
Parameters [#parameters-548]
| Name | Type | Description |
| ---------- | ------- | ---------------------- |
| `val` | `jsonb` | encrypted EQL payload. |
| `selector` | `text` | Selector hash to test. |
Returns [#returns-544]
**Type:** `boolean`
boolean True if a matching element exists.
***
jsonb_path_query(jsonb, text) [#jsonb_path_queryjsonb-text]
Query encrypted JSONB for sv elements matching selector.
Returns one jsonb\_entry row per matching encrypted element. Returns empty set on no match. It deliberately does not wrap multiple matches as an public.eql\_v3\_json\_search document, because the root document domain requires an sv array and single leaves belong to public.eql\_v3\_json\_entry.
Parameters [#parameters-549]
| Name | Type | Description |
| ---------- | ------- | ------------------------------ |
| `val` | `jsonb` | encrypted EQL payload with sv. |
| `selector` | `text` | Selector hash (s value). |
Returns [#returns-545]
**Type:** `SETOF`
SETOF public.eql\_v3\_json\_entry Matching encrypted entries.
Variants [#variants-1]
* eql\_v3.jsonb\_path\_query\_first
***
jsonb_path_query_first(jsonb, text) [#jsonb_path_query_firstjsonb-text]
Get the first sv element matching selector, or NULL.
Parameters [#parameters-550]
| Name | Type | Description |
| ---------- | ------- | ----------------------- |
| `val` | `jsonb` | encrypted EQL payload. |
| `selector` | `text` | Selector hash to match. |
Returns [#returns-546]
**Type:** `public.eql_v3_json_entry`
public.eql\_v3\_json\_entry First matching element or NULL.
***
lints() [#lints]
EQL lint: detect non-inlinable operator implementation functions.
Returns one row per violation found in the installed eql\_v3 surface. The Postgres planner can only inline a function during index matching when:
LANGUAGE sql (plpgsql / C / etc. cannot be inlined)IMMUTABLE or STABLE volatility (VOLATILE cannot be inlined into index expressions)No SET clauses (e.g. SET search\_path = ...)Not SECURITY DEFINERSingle-statement SELECT body
Severity: error — fixable, blocks index matching, ship-blocking. warning — likely-fixable, may not block matching but signals intent. info — observational; useful for review, not a defect on its own.
Categories: inlinability\_language — implementation function isn't LANGUAGE sql. inlinability\_volatility — implementation function is VOLATILE. inlinability\_set\_clause — implementation function has a SET clause. inlinability\_secdef — implementation function is SECURITY DEFINER. inlinability\_transitive — implementation function is itself inlinable but its body invokes a non-inlinable function (depth 1; the planner can't peek through that boundary). blocker\_language — encrypted-domain blocker is not LANGUAGE plpgsql. The planner can inline / elide a LANGUAGE sql body when the result is provably unused, silently bypassing the RAISE that the blocker exists to perform. blocker\_strict — encrypted-domain blocker is STRICT. PostgreSQL skips the body and returns NULL on NULL arguments, silently bypassing the RAISE. domain\_over\_domain — an eql\_v3 encrypted domain is derived from another encrypted domain rather than jsonb. Operators resolve against the ultimate base type, so the derived domain does not inherit the base domain's blocker surface. domain\_opclass — an operator class is declared FOR TYPE on an eql\_v3 encrypted domain. Opclasses on domains bypass operator resolution; use a functional index on the extractor instead. schema\_placement — a naked composite or enum TYPE lives in the public eql\_v3 schema. Internal index-term types (e.g. ore\_block\_256\_term) belong in eql\_v3\_internal; a composite/enum in eql\_v3 clutters the Supabase Table Builder type picker, which the schema split exists to prevent. Move it to eql\_v3\_internal.
SELECT severity, category, object\_name, message FROM eql\_v3.lints() WHERE severity = 'error' ORDER BY category, object\_name;
Returns [#returns-547]
**Type:** `TABLE`
SETOF record (severity text, category text, object\_name text, message text)
Note [#note-4]
The single-statement SELECT body condition is not yet checked by this lint. A LANGUAGE sql function with a multi-statement body, a CTE, or any pre-SELECT statement will pass all four implemented checks while remaining non-inlinable. Implementing the check requires walking prosrc (or pg\_get\_functiondef); tracked as a follow-up.
***
lt(jsonb, eql_v3_integer_ord_ore) [#ltjsonb-eql_v3_integer_ord_ore]
Operator wrapper for public.eql\_v3\_integer\_ord\_ore.
Parameters [#parameters-551]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_integer_ord_ore` | |
Returns [#returns-548]
**Type:** `boolean`
boolean
***
lt(eql_v3_integer_ord_ore, jsonb) [#lteql_v3_integer_ord_ore-jsonb]
Operator wrapper for public.eql\_v3\_integer\_ord\_ore.
Parameters [#parameters-552]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a public.` | `eql_v3_integer_ord_ore` | |
| `b` | `jsonb` | |
Returns [#returns-549]
**Type:** `boolean`
boolean
***
lt(eql_v3_integer_ord_ore, eql_v3_integer_ord_ore) [#lteql_v3_integer_ord_ore-eql_v3_integer_ord_ore]
Operator wrapper for public.eql\_v3\_integer\_ord\_ore.
Parameters [#parameters-553]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a public.` | `eql_v3_integer_ord_ore` | |
| `b public.` | `eql_v3_integer_ord_ore` | |
Returns [#returns-550]
**Type:** `boolean`
boolean
***
lt(query_smallint_ord, eql_v3_smallint_ord) [#ltquery_smallint_ord-eql_v3_smallint_ord]
Operator wrapper for eql\_v3.query\_smallint\_ord.
Parameters [#parameters-554]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a eql_v3.` | `query_smallint_ord` | |
| `b public.` | `eql_v3_smallint_ord` | |
Returns [#returns-551]
**Type:** `boolean`
boolean
***
lt(eql_v3_smallint_ord, query_smallint_ord) [#lteql_v3_smallint_ord-query_smallint_ord]
Operator wrapper for eql\_v3.query\_smallint\_ord.
Parameters [#parameters-555]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_smallint_ord` | |
| `b eql_v3.` | `query_smallint_ord` | |
Returns [#returns-552]
**Type:** `boolean`
boolean
***
lt(jsonb, eql_v3_smallint_ord) [#ltjsonb-eql_v3_smallint_ord]
Operator wrapper for public.eql\_v3\_smallint\_ord.
Parameters [#parameters-556]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_smallint_ord` | |
Returns [#returns-553]
**Type:** `boolean`
boolean
***
lt(eql_v3_smallint_ord, jsonb) [#lteql_v3_smallint_ord-jsonb]
Operator wrapper for public.eql\_v3\_smallint\_ord.
Parameters [#parameters-557]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_smallint_ord` | |
| `b` | `jsonb` | |
Returns [#returns-554]
**Type:** `boolean`
boolean
***
lt(eql_v3_smallint_ord, eql_v3_smallint_ord) [#lteql_v3_smallint_ord-eql_v3_smallint_ord]
Operator wrapper for public.eql\_v3\_smallint\_ord.
Parameters [#parameters-558]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_smallint_ord` | |
| `b public.` | `eql_v3_smallint_ord` | |
Returns [#returns-555]
**Type:** `boolean`
boolean
***
lt(jsonb, eql_v3_date_ord) [#ltjsonb-eql_v3_date_ord]
Operator wrapper for public.eql\_v3\_date\_ord.
Parameters [#parameters-559]
| Name | Type | Description |
| ----------- | ----------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_date_ord` | |
Returns [#returns-556]
**Type:** `boolean`
boolean
***
lt(eql_v3_date_ord, jsonb) [#lteql_v3_date_ord-jsonb]
Operator wrapper for public.eql\_v3\_date\_ord.
Parameters [#parameters-560]
| Name | Type | Description |
| ----------- | ----------------- | ----------- |
| `a public.` | `eql_v3_date_ord` | |
| `b` | `jsonb` | |
Returns [#returns-557]
**Type:** `boolean`
boolean
***
lt(eql_v3_date_ord, eql_v3_date_ord) [#lteql_v3_date_ord-eql_v3_date_ord]
Operator wrapper for public.eql\_v3\_date\_ord.
Parameters [#parameters-561]
| Name | Type | Description |
| ----------- | ----------------- | ----------- |
| `a public.` | `eql_v3_date_ord` | |
| `b public.` | `eql_v3_date_ord` | |
Returns [#returns-558]
**Type:** `boolean`
boolean
***
lt(query_real_ord, eql_v3_real_ord) [#ltquery_real_ord-eql_v3_real_ord]
Operator wrapper for eql\_v3.query\_real\_ord.
Parameters [#parameters-562]
| Name | Type | Description |
| ----------- | ----------------- | ----------- |
| `a eql_v3.` | `query_real_ord` | |
| `b public.` | `eql_v3_real_ord` | |
Returns [#returns-559]
**Type:** `boolean`
boolean
***
lt(eql_v3_real_ord, query_real_ord) [#lteql_v3_real_ord-query_real_ord]
Operator wrapper for eql\_v3.query\_real\_ord.
Parameters [#parameters-563]
| Name | Type | Description |
| ----------- | ----------------- | ----------- |
| `a public.` | `eql_v3_real_ord` | |
| `b eql_v3.` | `query_real_ord` | |
Returns [#returns-560]
**Type:** `boolean`
boolean
***
lt(query_double_ord, eql_v3_json_entry) [#ltquery_double_ord-eql_v3_json_entry]
Operator wrapper for public.eql\_v3\_json\_entry.
Parameters [#parameters-564]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a eql_v3.` | `query_double_ord` | |
| `b public.` | `eql_v3_json_entry` | |
Returns [#returns-561]
**Type:** `boolean`
boolean
***
lt(eql_v3_json_entry, query_double_ord) [#lteql_v3_json_entry-query_double_ord]
Operator wrapper for public.eql\_v3\_json\_entry.
Parameters [#parameters-565]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a public.` | `eql_v3_json_entry` | |
| `b eql_v3.` | `query_double_ord` | |
Returns [#returns-562]
**Type:** `boolean`
boolean
***
lt(query_real_ord_ore, eql_v3_real_ord_ore) [#ltquery_real_ord_ore-eql_v3_real_ord_ore]
Operator wrapper for eql\_v3.query\_real\_ord\_ore.
Parameters [#parameters-566]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a eql_v3.` | `query_real_ord_ore` | |
| `b public.` | `eql_v3_real_ord_ore` | |
Returns [#returns-563]
**Type:** `boolean`
boolean
***
lt(eql_v3_real_ord_ore, query_real_ord_ore) [#lteql_v3_real_ord_ore-query_real_ord_ore]
Operator wrapper for eql\_v3.query\_real\_ord\_ore.
Parameters [#parameters-567]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_real_ord_ore` | |
| `b eql_v3.` | `query_real_ord_ore` | |
Returns [#returns-564]
**Type:** `boolean`
boolean
***
lt(jsonb, eql_v3_text_ord) [#ltjsonb-eql_v3_text_ord]
Operator wrapper for public.eql\_v3\_text\_ord.
Parameters [#parameters-568]
| Name | Type | Description |
| ----------- | ----------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_text_ord` | |
Returns [#returns-565]
**Type:** `boolean`
boolean
***
lt(eql_v3_text_ord, jsonb) [#lteql_v3_text_ord-jsonb]
Operator wrapper for public.eql\_v3\_text\_ord.
Parameters [#parameters-569]
| Name | Type | Description |
| ----------- | ----------------- | ----------- |
| `a public.` | `eql_v3_text_ord` | |
| `b` | `jsonb` | |
Returns [#returns-566]
**Type:** `boolean`
boolean
***
lt(eql_v3_text_ord, eql_v3_text_ord) [#lteql_v3_text_ord-eql_v3_text_ord]
Operator wrapper for public.eql\_v3\_text\_ord.
Parameters [#parameters-570]
| Name | Type | Description |
| ----------- | ----------------- | ----------- |
| `a public.` | `eql_v3_text_ord` | |
| `b public.` | `eql_v3_text_ord` | |
Returns [#returns-567]
**Type:** `boolean`
boolean
***
lt(query_integer_ord_ope, eql_v3_integer_ord_ope) [#ltquery_integer_ord_ope-eql_v3_integer_ord_ope]
Operator wrapper for eql\_v3.query\_integer\_ord\_ope.
Parameters [#parameters-571]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a eql_v3.` | `query_integer_ord_ope` | |
| `b public.` | `eql_v3_integer_ord_ope` | |
Returns [#returns-568]
**Type:** `boolean`
boolean
***
lt(eql_v3_integer_ord_ope, query_integer_ord_ope) [#lteql_v3_integer_ord_ope-query_integer_ord_ope]
Operator wrapper for eql\_v3.query\_integer\_ord\_ope.
Parameters [#parameters-572]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a public.` | `eql_v3_integer_ord_ope` | |
| `b eql_v3.` | `query_integer_ord_ope` | |
Returns [#returns-569]
**Type:** `boolean`
boolean
***
lt(query_text_ord, eql_v3_text_ord) [#ltquery_text_ord-eql_v3_text_ord]
Operator wrapper for eql\_v3.query\_text\_ord.
Parameters [#parameters-573]
| Name | Type | Description |
| ----------- | ----------------- | ----------- |
| `a eql_v3.` | `query_text_ord` | |
| `b public.` | `eql_v3_text_ord` | |
Returns [#returns-570]
**Type:** `boolean`
boolean
***
lt(eql_v3_text_ord, query_text_ord) [#lteql_v3_text_ord-query_text_ord]
Operator wrapper for eql\_v3.query\_text\_ord.
Parameters [#parameters-574]
| Name | Type | Description |
| ----------- | ----------------- | ----------- |
| `a public.` | `eql_v3_text_ord` | |
| `b eql_v3.` | `query_text_ord` | |
Returns [#returns-571]
**Type:** `boolean`
boolean
***
lt(jsonb, eql_v3_timestamp_ord_ope) [#ltjsonb-eql_v3_timestamp_ord_ope]
Operator wrapper for public.eql\_v3\_timestamp\_ord\_ope.
Parameters [#parameters-575]
| Name | Type | Description |
| ----------- | -------------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_timestamp_ord_ope` | |
Returns [#returns-572]
**Type:** `boolean`
boolean
***
lt(eql_v3_timestamp_ord_ope, jsonb) [#lteql_v3_timestamp_ord_ope-jsonb]
Operator wrapper for public.eql\_v3\_timestamp\_ord\_ope.
Parameters [#parameters-576]
| Name | Type | Description |
| ----------- | -------------------------- | ----------- |
| `a public.` | `eql_v3_timestamp_ord_ope` | |
| `b` | `jsonb` | |
Returns [#returns-573]
**Type:** `boolean`
boolean
***
lt(eql_v3_timestamp_ord_ope, eql_v3_timestamp_ord_ope) [#lteql_v3_timestamp_ord_ope-eql_v3_timestamp_ord_ope]
Operator wrapper for public.eql\_v3\_timestamp\_ord\_ope.
Parameters [#parameters-577]
| Name | Type | Description |
| ----------- | -------------------------- | ----------- |
| `a public.` | `eql_v3_timestamp_ord_ope` | |
| `b public.` | `eql_v3_timestamp_ord_ope` | |
Returns [#returns-574]
**Type:** `boolean`
boolean
***
lt(jsonb, eql_v3_integer_ord_ope) [#ltjsonb-eql_v3_integer_ord_ope]
Operator wrapper for public.eql\_v3\_integer\_ord\_ope.
Parameters [#parameters-578]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_integer_ord_ope` | |
Returns [#returns-575]
**Type:** `boolean`
boolean
***
lt(eql_v3_integer_ord_ope, jsonb) [#lteql_v3_integer_ord_ope-jsonb]
Operator wrapper for public.eql\_v3\_integer\_ord\_ope.
Parameters [#parameters-579]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a public.` | `eql_v3_integer_ord_ope` | |
| `b` | `jsonb` | |
Returns [#returns-576]
**Type:** `boolean`
boolean
***
lt(eql_v3_integer_ord_ope, eql_v3_integer_ord_ope) [#lteql_v3_integer_ord_ope-eql_v3_integer_ord_ope]
Operator wrapper for public.eql\_v3\_integer\_ord\_ope.
Parameters [#parameters-580]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a public.` | `eql_v3_integer_ord_ope` | |
| `b public.` | `eql_v3_integer_ord_ope` | |
Returns [#returns-577]
**Type:** `boolean`
boolean
***
lt(query_integer_ord, eql_v3_integer_ord) [#ltquery_integer_ord-eql_v3_integer_ord]
Operator wrapper for eql\_v3.query\_integer\_ord.
Parameters [#parameters-581]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a eql_v3.` | `query_integer_ord` | |
| `b public.` | `eql_v3_integer_ord` | |
Returns [#returns-578]
**Type:** `boolean`
boolean
***
lt(eql_v3_integer_ord, query_integer_ord) [#lteql_v3_integer_ord-query_integer_ord]
Operator wrapper for eql\_v3.query\_integer\_ord.
Parameters [#parameters-582]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a public.` | `eql_v3_integer_ord` | |
| `b eql_v3.` | `query_integer_ord` | |
Returns [#returns-579]
**Type:** `boolean`
boolean
***
lt(query_text_search, eql_v3_text_search) [#ltquery_text_search-eql_v3_text_search]
Operator wrapper for eql\_v3.query\_text\_search.
Parameters [#parameters-583]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a eql_v3.` | `query_text_search` | |
| `b public.` | `eql_v3_text_search` | |
Returns [#returns-580]
**Type:** `boolean`
boolean
***
lt(eql_v3_text_search, query_text_search) [#lteql_v3_text_search-query_text_search]
Operator wrapper for eql\_v3.query\_text\_search.
Parameters [#parameters-584]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a public.` | `eql_v3_text_search` | |
| `b eql_v3.` | `query_text_search` | |
Returns [#returns-581]
**Type:** `boolean`
boolean
***
lt(jsonb, eql_v3_numeric_ord) [#ltjsonb-eql_v3_numeric_ord]
Operator wrapper for public.eql\_v3\_numeric\_ord.
Parameters [#parameters-585]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_numeric_ord` | |
Returns [#returns-582]
**Type:** `boolean`
boolean
***
lt(eql_v3_numeric_ord, jsonb) [#lteql_v3_numeric_ord-jsonb]
Operator wrapper for public.eql\_v3\_numeric\_ord.
Parameters [#parameters-586]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a public.` | `eql_v3_numeric_ord` | |
| `b` | `jsonb` | |
Returns [#returns-583]
**Type:** `boolean`
boolean
***
lt(eql_v3_numeric_ord, eql_v3_numeric_ord) [#lteql_v3_numeric_ord-eql_v3_numeric_ord]
Operator wrapper for public.eql\_v3\_numeric\_ord.
Parameters [#parameters-587]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a public.` | `eql_v3_numeric_ord` | |
| `b public.` | `eql_v3_numeric_ord` | |
Returns [#returns-584]
**Type:** `boolean`
boolean
***
lt(query_date_ord_ope, eql_v3_date_ord_ope) [#ltquery_date_ord_ope-eql_v3_date_ord_ope]
Operator wrapper for eql\_v3.query\_date\_ord\_ope.
Parameters [#parameters-588]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a eql_v3.` | `query_date_ord_ope` | |
| `b public.` | `eql_v3_date_ord_ope` | |
Returns [#returns-585]
**Type:** `boolean`
boolean
***
lt(eql_v3_date_ord_ope, query_date_ord_ope) [#lteql_v3_date_ord_ope-query_date_ord_ope]
Operator wrapper for eql\_v3.query\_date\_ord\_ope.
Parameters [#parameters-589]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_date_ord_ope` | |
| `b eql_v3.` | `query_date_ord_ope` | |
Returns [#returns-586]
**Type:** `boolean`
boolean
***
lt(query_smallint_ord, eql_v3_json_entry) [#ltquery_smallint_ord-eql_v3_json_entry]
Operator wrapper for public.eql\_v3\_json\_entry.
Parameters [#parameters-590]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a eql_v3.` | `query_smallint_ord` | |
| `b public.` | `eql_v3_json_entry` | |
Returns [#returns-587]
**Type:** `boolean`
boolean
***
lt(eql_v3_json_entry, query_smallint_ord) [#lteql_v3_json_entry-query_smallint_ord]
Operator wrapper for public.eql\_v3\_json\_entry.
Parameters [#parameters-591]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a public.` | `eql_v3_json_entry` | |
| `b eql_v3.` | `query_smallint_ord` | |
Returns [#returns-588]
**Type:** `boolean`
boolean
***
lt(query_timestamp_ord_ore, eql_v3_timestamp_ord_ore) [#ltquery_timestamp_ord_ore-eql_v3_timestamp_ord_ore]
Operator wrapper for eql\_v3.query\_timestamp\_ord\_ore.
Parameters [#parameters-592]
| Name | Type | Description |
| ----------- | -------------------------- | ----------- |
| `a eql_v3.` | `query_timestamp_ord_ore` | |
| `b public.` | `eql_v3_timestamp_ord_ore` | |
Returns [#returns-589]
**Type:** `boolean`
boolean
***
lt(eql_v3_timestamp_ord_ore, query_timestamp_ord_ore) [#lteql_v3_timestamp_ord_ore-query_timestamp_ord_ore]
Operator wrapper for eql\_v3.query\_timestamp\_ord\_ore.
Parameters [#parameters-593]
| Name | Type | Description |
| ----------- | -------------------------- | ----------- |
| `a public.` | `eql_v3_timestamp_ord_ore` | |
| `b eql_v3.` | `query_timestamp_ord_ore` | |
Returns [#returns-590]
**Type:** `boolean`
boolean
***
lt(query_text_search_ore, eql_v3_text_search_ore) [#ltquery_text_search_ore-eql_v3_text_search_ore]
Operator wrapper for eql\_v3.query\_text\_search\_ore.
Parameters [#parameters-594]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a eql_v3.` | `query_text_search_ore` | |
| `b public.` | `eql_v3_text_search_ore` | |
Returns [#returns-591]
**Type:** `boolean`
boolean
***
lt(eql_v3_text_search_ore, query_text_search_ore) [#lteql_v3_text_search_ore-query_text_search_ore]
Operator wrapper for eql\_v3.query\_text\_search\_ore.
Parameters [#parameters-595]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a public.` | `eql_v3_text_search_ore` | |
| `b eql_v3.` | `query_text_search_ore` | |
Returns [#returns-592]
**Type:** `boolean`
boolean
***
lt(query_text_ord_ore, eql_v3_text_ord_ore) [#ltquery_text_ord_ore-eql_v3_text_ord_ore]
Operator wrapper for eql\_v3.query\_text\_ord\_ore.
Parameters [#parameters-596]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a eql_v3.` | `query_text_ord_ore` | |
| `b public.` | `eql_v3_text_ord_ore` | |
Returns [#returns-593]
**Type:** `boolean`
boolean
***
lt(eql_v3_text_ord_ore, query_text_ord_ore) [#lteql_v3_text_ord_ore-query_text_ord_ore]
Operator wrapper for eql\_v3.query\_text\_ord\_ore.
Parameters [#parameters-597]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_text_ord_ore` | |
| `b eql_v3.` | `query_text_ord_ore` | |
Returns [#returns-594]
**Type:** `boolean`
boolean
***
lt(jsonb, eql_v3_real_ord_ope) [#ltjsonb-eql_v3_real_ord_ope]
Operator wrapper for public.eql\_v3\_real\_ord\_ope.
Parameters [#parameters-598]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_real_ord_ope` | |
Returns [#returns-595]
**Type:** `boolean`
boolean
***
lt(eql_v3_real_ord_ope, jsonb) [#lteql_v3_real_ord_ope-jsonb]
Operator wrapper for public.eql\_v3\_real\_ord\_ope.
Parameters [#parameters-599]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_real_ord_ope` | |
| `b` | `jsonb` | |
Returns [#returns-596]
**Type:** `boolean`
boolean
***
lt(eql_v3_real_ord_ope, eql_v3_real_ord_ope) [#lteql_v3_real_ord_ope-eql_v3_real_ord_ope]
Operator wrapper for public.eql\_v3\_real\_ord\_ope.
Parameters [#parameters-600]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_real_ord_ope` | |
| `b public.` | `eql_v3_real_ord_ope` | |
Returns [#returns-597]
**Type:** `boolean`
boolean
***
lt(jsonb, eql_v3_real_ord) [#ltjsonb-eql_v3_real_ord]
Operator wrapper for public.eql\_v3\_real\_ord.
Parameters [#parameters-601]
| Name | Type | Description |
| ----------- | ----------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_real_ord` | |
Returns [#returns-598]
**Type:** `boolean`
boolean
***
lt(eql_v3_real_ord, jsonb) [#lteql_v3_real_ord-jsonb]
Operator wrapper for public.eql\_v3\_real\_ord.
Parameters [#parameters-602]
| Name | Type | Description |
| ----------- | ----------------- | ----------- |
| `a public.` | `eql_v3_real_ord` | |
| `b` | `jsonb` | |
Returns [#returns-599]
**Type:** `boolean`
boolean
***
lt(eql_v3_real_ord, eql_v3_real_ord) [#lteql_v3_real_ord-eql_v3_real_ord]
Operator wrapper for public.eql\_v3\_real\_ord.
Parameters [#parameters-603]
| Name | Type | Description |
| ----------- | ----------------- | ----------- |
| `a public.` | `eql_v3_real_ord` | |
| `b public.` | `eql_v3_real_ord` | |
Returns [#returns-600]
**Type:** `boolean`
boolean
***
lt(jsonb, eql_v3_integer_ord) [#ltjsonb-eql_v3_integer_ord]
Operator wrapper for public.eql\_v3\_integer\_ord.
Parameters [#parameters-604]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_integer_ord` | |
Returns [#returns-601]
**Type:** `boolean`
boolean
***
lt(eql_v3_integer_ord, jsonb) [#lteql_v3_integer_ord-jsonb]
Operator wrapper for public.eql\_v3\_integer\_ord.
Parameters [#parameters-605]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a public.` | `eql_v3_integer_ord` | |
| `b` | `jsonb` | |
Returns [#returns-602]
**Type:** `boolean`
boolean
***
lt(eql_v3_integer_ord, eql_v3_integer_ord) [#lteql_v3_integer_ord-eql_v3_integer_ord]
Operator wrapper for public.eql\_v3\_integer\_ord.
Parameters [#parameters-606]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a public.` | `eql_v3_integer_ord` | |
| `b public.` | `eql_v3_integer_ord` | |
Returns [#returns-603]
**Type:** `boolean`
boolean
***
lt(query_smallint_ord_ore, eql_v3_smallint_ord_ore) [#ltquery_smallint_ord_ore-eql_v3_smallint_ord_ore]
Operator wrapper for eql\_v3.query\_smallint\_ord\_ore.
Parameters [#parameters-607]
| Name | Type | Description |
| ----------- | ------------------------- | ----------- |
| `a eql_v3.` | `query_smallint_ord_ore` | |
| `b public.` | `eql_v3_smallint_ord_ore` | |
Returns [#returns-604]
**Type:** `boolean`
boolean
***
lt(eql_v3_smallint_ord_ore, query_smallint_ord_ore) [#lteql_v3_smallint_ord_ore-query_smallint_ord_ore]
Operator wrapper for eql\_v3.query\_smallint\_ord\_ore.
Parameters [#parameters-608]
| Name | Type | Description |
| ----------- | ------------------------- | ----------- |
| `a public.` | `eql_v3_smallint_ord_ore` | |
| `b eql_v3.` | `query_smallint_ord_ore` | |
Returns [#returns-605]
**Type:** `boolean`
boolean
***
lt(jsonb, eql_v3_text_ord_ope) [#ltjsonb-eql_v3_text_ord_ope]
Operator wrapper for public.eql\_v3\_text\_ord\_ope.
Parameters [#parameters-609]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_text_ord_ope` | |
Returns [#returns-606]
**Type:** `boolean`
boolean
***
lt(eql_v3_text_ord_ope, jsonb) [#lteql_v3_text_ord_ope-jsonb]
Operator wrapper for public.eql\_v3\_text\_ord\_ope.
Parameters [#parameters-610]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_text_ord_ope` | |
| `b` | `jsonb` | |
Returns [#returns-607]
**Type:** `boolean`
boolean
***
lt(eql_v3_text_ord_ope, eql_v3_text_ord_ope) [#lteql_v3_text_ord_ope-eql_v3_text_ord_ope]
Operator wrapper for public.eql\_v3\_text\_ord\_ope.
Parameters [#parameters-611]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_text_ord_ope` | |
| `b public.` | `eql_v3_text_ord_ope` | |
Returns [#returns-608]
**Type:** `boolean`
boolean
***
lt(query_double_ord_ope, eql_v3_double_ord_ope) [#ltquery_double_ord_ope-eql_v3_double_ord_ope]
Operator wrapper for eql\_v3.query\_double\_ord\_ope.
Parameters [#parameters-612]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a eql_v3.` | `query_double_ord_ope` | |
| `b public.` | `eql_v3_double_ord_ope` | |
Returns [#returns-609]
**Type:** `boolean`
boolean
***
lt(eql_v3_double_ord_ope, query_double_ord_ope) [#lteql_v3_double_ord_ope-query_double_ord_ope]
Operator wrapper for eql\_v3.query\_double\_ord\_ope.
Parameters [#parameters-613]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a public.` | `eql_v3_double_ord_ope` | |
| `b eql_v3.` | `query_double_ord_ope` | |
Returns [#returns-610]
**Type:** `boolean`
boolean
***
lt(query_integer_ord_ore, eql_v3_integer_ord_ore) [#ltquery_integer_ord_ore-eql_v3_integer_ord_ore]
Operator wrapper for eql\_v3.query\_integer\_ord\_ore.
Parameters [#parameters-614]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a eql_v3.` | `query_integer_ord_ore` | |
| `b public.` | `eql_v3_integer_ord_ore` | |
Returns [#returns-611]
**Type:** `boolean`
boolean
***
lt(eql_v3_integer_ord_ore, query_integer_ord_ore) [#lteql_v3_integer_ord_ore-query_integer_ord_ore]
Operator wrapper for eql\_v3.query\_integer\_ord\_ore.
Parameters [#parameters-615]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a public.` | `eql_v3_integer_ord_ore` | |
| `b eql_v3.` | `query_integer_ord_ore` | |
Returns [#returns-612]
**Type:** `boolean`
boolean
***
lt(jsonb, eql_v3_bigint_ord_ore) [#ltjsonb-eql_v3_bigint_ord_ore]
Operator wrapper for public.eql\_v3\_bigint\_ord\_ore.
Parameters [#parameters-616]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_bigint_ord_ore` | |
Returns [#returns-613]
**Type:** `boolean`
boolean
***
lt(eql_v3_bigint_ord_ore, jsonb) [#lteql_v3_bigint_ord_ore-jsonb]
Operator wrapper for public.eql\_v3\_bigint\_ord\_ore.
Parameters [#parameters-617]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a public.` | `eql_v3_bigint_ord_ore` | |
| `b` | `jsonb` | |
Returns [#returns-614]
**Type:** `boolean`
boolean
***
lt(eql_v3_bigint_ord_ore, eql_v3_bigint_ord_ore) [#lteql_v3_bigint_ord_ore-eql_v3_bigint_ord_ore]
Operator wrapper for public.eql\_v3\_bigint\_ord\_ore.
Parameters [#parameters-618]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a public.` | `eql_v3_bigint_ord_ore` | |
| `b public.` | `eql_v3_bigint_ord_ore` | |
Returns [#returns-615]
**Type:** `boolean`
boolean
***
lt(query_date_ord, eql_v3_date_ord) [#ltquery_date_ord-eql_v3_date_ord]
Operator wrapper for eql\_v3.query\_date\_ord.
Parameters [#parameters-619]
| Name | Type | Description |
| ----------- | ----------------- | ----------- |
| `a eql_v3.` | `query_date_ord` | |
| `b public.` | `eql_v3_date_ord` | |
Returns [#returns-616]
**Type:** `boolean`
boolean
***
lt(eql_v3_date_ord, query_date_ord) [#lteql_v3_date_ord-query_date_ord]
Operator wrapper for eql\_v3.query\_date\_ord.
Parameters [#parameters-620]
| Name | Type | Description |
| ----------- | ----------------- | ----------- |
| `a public.` | `eql_v3_date_ord` | |
| `b eql_v3.` | `query_date_ord` | |
Returns [#returns-617]
**Type:** `boolean`
boolean
***
lt(jsonb, eql_v3_real_ord_ore) [#ltjsonb-eql_v3_real_ord_ore]
Operator wrapper for public.eql\_v3\_real\_ord\_ore.
Parameters [#parameters-621]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_real_ord_ore` | |
Returns [#returns-618]
**Type:** `boolean`
boolean
***
lt(eql_v3_real_ord_ore, jsonb) [#lteql_v3_real_ord_ore-jsonb]
Operator wrapper for public.eql\_v3\_real\_ord\_ore.
Parameters [#parameters-622]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_real_ord_ore` | |
| `b` | `jsonb` | |
Returns [#returns-619]
**Type:** `boolean`
boolean
***
lt(eql_v3_real_ord_ore, eql_v3_real_ord_ore) [#lteql_v3_real_ord_ore-eql_v3_real_ord_ore]
Operator wrapper for public.eql\_v3\_real\_ord\_ore.
Parameters [#parameters-623]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_real_ord_ore` | |
| `b public.` | `eql_v3_real_ord_ore` | |
Returns [#returns-620]
**Type:** `boolean`
boolean
***
lt(jsonb, eql_v3_numeric_ord_ore) [#ltjsonb-eql_v3_numeric_ord_ore]
Operator wrapper for public.eql\_v3\_numeric\_ord\_ore.
Parameters [#parameters-624]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_numeric_ord_ore` | |
Returns [#returns-621]
**Type:** `boolean`
boolean
***
lt(eql_v3_numeric_ord_ore, jsonb) [#lteql_v3_numeric_ord_ore-jsonb]
Operator wrapper for public.eql\_v3\_numeric\_ord\_ore.
Parameters [#parameters-625]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a public.` | `eql_v3_numeric_ord_ore` | |
| `b` | `jsonb` | |
Returns [#returns-622]
**Type:** `boolean`
boolean
***
lt(eql_v3_numeric_ord_ore, eql_v3_numeric_ord_ore) [#lteql_v3_numeric_ord_ore-eql_v3_numeric_ord_ore]
Operator wrapper for public.eql\_v3\_numeric\_ord\_ore.
Parameters [#parameters-626]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a public.` | `eql_v3_numeric_ord_ore` | |
| `b public.` | `eql_v3_numeric_ord_ore` | |
Returns [#returns-623]
**Type:** `boolean`
boolean
***
lt(query_text_ord_ope, eql_v3_text_ord_ope) [#ltquery_text_ord_ope-eql_v3_text_ord_ope]
Operator wrapper for eql\_v3.query\_text\_ord\_ope.
Parameters [#parameters-627]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a eql_v3.` | `query_text_ord_ope` | |
| `b public.` | `eql_v3_text_ord_ope` | |
Returns [#returns-624]
**Type:** `boolean`
boolean
***
lt(eql_v3_text_ord_ope, query_text_ord_ope) [#lteql_v3_text_ord_ope-query_text_ord_ope]
Operator wrapper for eql\_v3.query\_text\_ord\_ope.
Parameters [#parameters-628]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_text_ord_ope` | |
| `b eql_v3.` | `query_text_ord_ope` | |
Returns [#returns-625]
**Type:** `boolean`
boolean
***
lt(jsonb, eql_v3_bigint_ord_ope) [#ltjsonb-eql_v3_bigint_ord_ope]
Operator wrapper for public.eql\_v3\_bigint\_ord\_ope.
Parameters [#parameters-629]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_bigint_ord_ope` | |
Returns [#returns-626]
**Type:** `boolean`
boolean
***
lt(eql_v3_bigint_ord_ope, jsonb) [#lteql_v3_bigint_ord_ope-jsonb]
Operator wrapper for public.eql\_v3\_bigint\_ord\_ope.
Parameters [#parameters-630]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a public.` | `eql_v3_bigint_ord_ope` | |
| `b` | `jsonb` | |
Returns [#returns-627]
**Type:** `boolean`
boolean
***
lt(eql_v3_bigint_ord_ope, eql_v3_bigint_ord_ope) [#lteql_v3_bigint_ord_ope-eql_v3_bigint_ord_ope]
Operator wrapper for public.eql\_v3\_bigint\_ord\_ope.
Parameters [#parameters-631]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a public.` | `eql_v3_bigint_ord_ope` | |
| `b public.` | `eql_v3_bigint_ord_ope` | |
Returns [#returns-628]
**Type:** `boolean`
boolean
***
lt(query_numeric_ord, eql_v3_json_entry) [#ltquery_numeric_ord-eql_v3_json_entry]
Operator wrapper for public.eql\_v3\_json\_entry.
Parameters [#parameters-632]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a eql_v3.` | `query_numeric_ord` | |
| `b public.` | `eql_v3_json_entry` | |
Returns [#returns-629]
**Type:** `boolean`
boolean
***
lt(eql_v3_json_entry, query_numeric_ord) [#lteql_v3_json_entry-query_numeric_ord]
Operator wrapper for public.eql\_v3\_json\_entry.
Parameters [#parameters-633]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a public.` | `eql_v3_json_entry` | |
| `b eql_v3.` | `query_numeric_ord` | |
Returns [#returns-630]
**Type:** `boolean`
boolean
***
lt(jsonb, eql_v3_double_ord_ore) [#ltjsonb-eql_v3_double_ord_ore]
Operator wrapper for public.eql\_v3\_double\_ord\_ore.
Parameters [#parameters-634]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_double_ord_ore` | |
Returns [#returns-631]
**Type:** `boolean`
boolean
***
lt(eql_v3_double_ord_ore, jsonb) [#lteql_v3_double_ord_ore-jsonb]
Operator wrapper for public.eql\_v3\_double\_ord\_ore.
Parameters [#parameters-635]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a public.` | `eql_v3_double_ord_ore` | |
| `b` | `jsonb` | |
Returns [#returns-632]
**Type:** `boolean`
boolean
***
lt(eql_v3_double_ord_ore, eql_v3_double_ord_ore) [#lteql_v3_double_ord_ore-eql_v3_double_ord_ore]
Operator wrapper for public.eql\_v3\_double\_ord\_ore.
Parameters [#parameters-636]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a public.` | `eql_v3_double_ord_ore` | |
| `b public.` | `eql_v3_double_ord_ore` | |
Returns [#returns-633]
**Type:** `boolean`
boolean
***
lt(jsonb, eql_v3_bigint_ord) [#ltjsonb-eql_v3_bigint_ord]
Operator wrapper for public.eql\_v3\_bigint\_ord.
Parameters [#parameters-637]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_bigint_ord` | |
Returns [#returns-634]
**Type:** `boolean`
boolean
***
lt(eql_v3_bigint_ord, jsonb) [#lteql_v3_bigint_ord-jsonb]
Operator wrapper for public.eql\_v3\_bigint\_ord.
Parameters [#parameters-638]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a public.` | `eql_v3_bigint_ord` | |
| `b` | `jsonb` | |
Returns [#returns-635]
**Type:** `boolean`
boolean
***
lt(eql_v3_bigint_ord, eql_v3_bigint_ord) [#lteql_v3_bigint_ord-eql_v3_bigint_ord]
Operator wrapper for public.eql\_v3\_bigint\_ord.
Parameters [#parameters-639]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a public.` | `eql_v3_bigint_ord` | |
| `b public.` | `eql_v3_bigint_ord` | |
Returns [#returns-636]
**Type:** `boolean`
boolean
***
lt(query_text_ord, eql_v3_json_entry) [#ltquery_text_ord-eql_v3_json_entry]
Operator wrapper for public.eql\_v3\_json\_entry.
Unsupported operator blocker for public.eql\_v3\_json\_entry.
Parameters [#parameters-640]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a eql_v3.` | `query_text_ord` | |
| `b public.` | `eql_v3_json_entry` | |
Returns [#returns-637]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lt(eql_v3_json_entry, query_text_ord) [#lteql_v3_json_entry-query_text_ord]
Operator wrapper for public.eql\_v3\_json\_entry.
Unsupported operator blocker for public.eql\_v3\_json\_entry.
Parameters [#parameters-641]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a public.` | `eql_v3_json_entry` | |
| `b eql_v3.` | `query_text_ord` | |
Returns [#returns-638]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lt(query_timestamp_ord_ope, eql_v3_timestamp_ord_ope) [#ltquery_timestamp_ord_ope-eql_v3_timestamp_ord_ope]
Operator wrapper for eql\_v3.query\_timestamp\_ord\_ope.
Parameters [#parameters-642]
| Name | Type | Description |
| ----------- | -------------------------- | ----------- |
| `a eql_v3.` | `query_timestamp_ord_ope` | |
| `b public.` | `eql_v3_timestamp_ord_ope` | |
Returns [#returns-639]
**Type:** `boolean`
boolean
***
lt(eql_v3_timestamp_ord_ope, query_timestamp_ord_ope) [#lteql_v3_timestamp_ord_ope-query_timestamp_ord_ope]
Operator wrapper for eql\_v3.query\_timestamp\_ord\_ope.
Parameters [#parameters-643]
| Name | Type | Description |
| ----------- | -------------------------- | ----------- |
| `a public.` | `eql_v3_timestamp_ord_ope` | |
| `b eql_v3.` | `query_timestamp_ord_ope` | |
Returns [#returns-640]
**Type:** `boolean`
boolean
***
lt(query_numeric_ord, eql_v3_numeric_ord) [#ltquery_numeric_ord-eql_v3_numeric_ord]
Operator wrapper for eql\_v3.query\_numeric\_ord.
Parameters [#parameters-644]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a eql_v3.` | `query_numeric_ord` | |
| `b public.` | `eql_v3_numeric_ord` | |
Returns [#returns-641]
**Type:** `boolean`
boolean
***
lt(eql_v3_numeric_ord, query_numeric_ord) [#lteql_v3_numeric_ord-query_numeric_ord]
Operator wrapper for eql\_v3.query\_numeric\_ord.
Parameters [#parameters-645]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a public.` | `eql_v3_numeric_ord` | |
| `b eql_v3.` | `query_numeric_ord` | |
Returns [#returns-642]
**Type:** `boolean`
boolean
***
lt(jsonb, eql_v3_text_search_ore) [#ltjsonb-eql_v3_text_search_ore]
Operator wrapper for public.eql\_v3\_text\_search\_ore.
Parameters [#parameters-646]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_text_search_ore` | |
Returns [#returns-643]
**Type:** `boolean`
boolean
***
lt(eql_v3_text_search_ore, jsonb) [#lteql_v3_text_search_ore-jsonb]
Operator wrapper for public.eql\_v3\_text\_search\_ore.
Parameters [#parameters-647]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a public.` | `eql_v3_text_search_ore` | |
| `b` | `jsonb` | |
Returns [#returns-644]
**Type:** `boolean`
boolean
***
lt(eql_v3_text_search_ore, eql_v3_text_search_ore) [#lteql_v3_text_search_ore-eql_v3_text_search_ore]
Operator wrapper for public.eql\_v3\_text\_search\_ore.
Parameters [#parameters-648]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a public.` | `eql_v3_text_search_ore` | |
| `b public.` | `eql_v3_text_search_ore` | |
Returns [#returns-645]
**Type:** `boolean`
boolean
***
lt(query_real_ord_ope, eql_v3_real_ord_ope) [#ltquery_real_ord_ope-eql_v3_real_ord_ope]
Operator wrapper for eql\_v3.query\_real\_ord\_ope.
Parameters [#parameters-649]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a eql_v3.` | `query_real_ord_ope` | |
| `b public.` | `eql_v3_real_ord_ope` | |
Returns [#returns-646]
**Type:** `boolean`
boolean
***
lt(eql_v3_real_ord_ope, query_real_ord_ope) [#lteql_v3_real_ord_ope-query_real_ord_ope]
Operator wrapper for eql\_v3.query\_real\_ord\_ope.
Parameters [#parameters-650]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_real_ord_ope` | |
| `b eql_v3.` | `query_real_ord_ope` | |
Returns [#returns-647]
**Type:** `boolean`
boolean
***
lt(jsonb, eql_v3_timestamp_ord) [#ltjsonb-eql_v3_timestamp_ord]
Operator wrapper for public.eql\_v3\_timestamp\_ord.
Parameters [#parameters-651]
| Name | Type | Description |
| ----------- | ---------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_timestamp_ord` | |
Returns [#returns-648]
**Type:** `boolean`
boolean
***
lt(eql_v3_timestamp_ord, jsonb) [#lteql_v3_timestamp_ord-jsonb]
Operator wrapper for public.eql\_v3\_timestamp\_ord.
Parameters [#parameters-652]
| Name | Type | Description |
| ----------- | ---------------------- | ----------- |
| `a public.` | `eql_v3_timestamp_ord` | |
| `b` | `jsonb` | |
Returns [#returns-649]
**Type:** `boolean`
boolean
***
lt(eql_v3_timestamp_ord, eql_v3_timestamp_ord) [#lteql_v3_timestamp_ord-eql_v3_timestamp_ord]
Operator wrapper for public.eql\_v3\_timestamp\_ord.
Parameters [#parameters-653]
| Name | Type | Description |
| ----------- | ---------------------- | ----------- |
| `a public.` | `eql_v3_timestamp_ord` | |
| `b public.` | `eql_v3_timestamp_ord` | |
Returns [#returns-650]
**Type:** `boolean`
boolean
***
lt(jsonb, eql_v3_smallint_ord_ope) [#ltjsonb-eql_v3_smallint_ord_ope]
Operator wrapper for public.eql\_v3\_smallint\_ord\_ope.
Parameters [#parameters-654]
| Name | Type | Description |
| ----------- | ------------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_smallint_ord_ope` | |
Returns [#returns-651]
**Type:** `boolean`
boolean
***
lt(eql_v3_smallint_ord_ope, jsonb) [#lteql_v3_smallint_ord_ope-jsonb]
Operator wrapper for public.eql\_v3\_smallint\_ord\_ope.
Parameters [#parameters-655]
| Name | Type | Description |
| ----------- | ------------------------- | ----------- |
| `a public.` | `eql_v3_smallint_ord_ope` | |
| `b` | `jsonb` | |
Returns [#returns-652]
**Type:** `boolean`
boolean
***
lt(eql_v3_smallint_ord_ope, eql_v3_smallint_ord_ope) [#lteql_v3_smallint_ord_ope-eql_v3_smallint_ord_ope]
Operator wrapper for public.eql\_v3\_smallint\_ord\_ope.
Parameters [#parameters-656]
| Name | Type | Description |
| ----------- | ------------------------- | ----------- |
| `a public.` | `eql_v3_smallint_ord_ope` | |
| `b public.` | `eql_v3_smallint_ord_ope` | |
Returns [#returns-653]
**Type:** `boolean`
boolean
***
lt(query_integer_ord, eql_v3_json_entry) [#ltquery_integer_ord-eql_v3_json_entry]
Operator wrapper for public.eql\_v3\_json\_entry.
Parameters [#parameters-657]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a eql_v3.` | `query_integer_ord` | |
| `b public.` | `eql_v3_json_entry` | |
Returns [#returns-654]
**Type:** `boolean`
boolean
***
lt(eql_v3_json_entry, query_integer_ord) [#lteql_v3_json_entry-query_integer_ord]
Operator wrapper for public.eql\_v3\_json\_entry.
Parameters [#parameters-658]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a public.` | `eql_v3_json_entry` | |
| `b eql_v3.` | `query_integer_ord` | |
Returns [#returns-655]
**Type:** `boolean`
boolean
***
lt(query_real_ord, eql_v3_json_entry) [#ltquery_real_ord-eql_v3_json_entry]
Operator wrapper for public.eql\_v3\_json\_entry.
Parameters [#parameters-659]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a eql_v3.` | `query_real_ord` | |
| `b public.` | `eql_v3_json_entry` | |
Returns [#returns-656]
**Type:** `boolean`
boolean
***
lt(eql_v3_json_entry, query_real_ord) [#lteql_v3_json_entry-query_real_ord]
Operator wrapper for public.eql\_v3\_json\_entry.
Parameters [#parameters-660]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a public.` | `eql_v3_json_entry` | |
| `b eql_v3.` | `query_real_ord` | |
Returns [#returns-657]
**Type:** `boolean`
boolean
***
lt(query_double_ord, eql_v3_double_ord) [#ltquery_double_ord-eql_v3_double_ord]
Operator wrapper for eql\_v3.query\_double\_ord.
Parameters [#parameters-661]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a eql_v3.` | `query_double_ord` | |
| `b public.` | `eql_v3_double_ord` | |
Returns [#returns-658]
**Type:** `boolean`
boolean
***
lt(eql_v3_double_ord, query_double_ord) [#lteql_v3_double_ord-query_double_ord]
Operator wrapper for eql\_v3.query\_double\_ord.
Parameters [#parameters-662]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a public.` | `eql_v3_double_ord` | |
| `b eql_v3.` | `query_double_ord` | |
Returns [#returns-659]
**Type:** `boolean`
boolean
***
lt(query_double_ord_ore, eql_v3_double_ord_ore) [#ltquery_double_ord_ore-eql_v3_double_ord_ore]
Operator wrapper for eql\_v3.query\_double\_ord\_ore.
Parameters [#parameters-663]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a eql_v3.` | `query_double_ord_ore` | |
| `b public.` | `eql_v3_double_ord_ore` | |
Returns [#returns-660]
**Type:** `boolean`
boolean
***
lt(eql_v3_double_ord_ore, query_double_ord_ore) [#lteql_v3_double_ord_ore-query_double_ord_ore]
Operator wrapper for eql\_v3.query\_double\_ord\_ore.
Parameters [#parameters-664]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a public.` | `eql_v3_double_ord_ore` | |
| `b eql_v3.` | `query_double_ord_ore` | |
Returns [#returns-661]
**Type:** `boolean`
boolean
***
lt(jsonb, eql_v3_timestamp_ord_ore) [#ltjsonb-eql_v3_timestamp_ord_ore]
Operator wrapper for public.eql\_v3\_timestamp\_ord\_ore.
Parameters [#parameters-665]
| Name | Type | Description |
| ----------- | -------------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_timestamp_ord_ore` | |
Returns [#returns-662]
**Type:** `boolean`
boolean
***
lt(eql_v3_timestamp_ord_ore, jsonb) [#lteql_v3_timestamp_ord_ore-jsonb]
Operator wrapper for public.eql\_v3\_timestamp\_ord\_ore.
Parameters [#parameters-666]
| Name | Type | Description |
| ----------- | -------------------------- | ----------- |
| `a public.` | `eql_v3_timestamp_ord_ore` | |
| `b` | `jsonb` | |
Returns [#returns-663]
**Type:** `boolean`
boolean
***
lt(eql_v3_timestamp_ord_ore, eql_v3_timestamp_ord_ore) [#lteql_v3_timestamp_ord_ore-eql_v3_timestamp_ord_ore]
Operator wrapper for public.eql\_v3\_timestamp\_ord\_ore.
Parameters [#parameters-667]
| Name | Type | Description |
| ----------- | -------------------------- | ----------- |
| `a public.` | `eql_v3_timestamp_ord_ore` | |
| `b public.` | `eql_v3_timestamp_ord_ore` | |
Returns [#returns-664]
**Type:** `boolean`
boolean
***
lt(jsonb, eql_v3_text_search) [#ltjsonb-eql_v3_text_search]
Operator wrapper for public.eql\_v3\_text\_search.
Parameters [#parameters-668]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_text_search` | |
Returns [#returns-665]
**Type:** `boolean`
boolean
***
lt(eql_v3_text_search, jsonb) [#lteql_v3_text_search-jsonb]
Operator wrapper for public.eql\_v3\_text\_search.
Parameters [#parameters-669]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a public.` | `eql_v3_text_search` | |
| `b` | `jsonb` | |
Returns [#returns-666]
**Type:** `boolean`
boolean
***
lt(eql_v3_text_search, eql_v3_text_search) [#lteql_v3_text_search-eql_v3_text_search]
Operator wrapper for public.eql\_v3\_text\_search.
Parameters [#parameters-670]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a public.` | `eql_v3_text_search` | |
| `b public.` | `eql_v3_text_search` | |
Returns [#returns-667]
**Type:** `boolean`
boolean
***
lt(query_numeric_ord_ore, eql_v3_numeric_ord_ore) [#ltquery_numeric_ord_ore-eql_v3_numeric_ord_ore]
Operator wrapper for eql\_v3.query\_numeric\_ord\_ore.
Parameters [#parameters-671]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a eql_v3.` | `query_numeric_ord_ore` | |
| `b public.` | `eql_v3_numeric_ord_ore` | |
Returns [#returns-668]
**Type:** `boolean`
boolean
***
lt(eql_v3_numeric_ord_ore, query_numeric_ord_ore) [#lteql_v3_numeric_ord_ore-query_numeric_ord_ore]
Operator wrapper for eql\_v3.query\_numeric\_ord\_ore.
Parameters [#parameters-672]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a public.` | `eql_v3_numeric_ord_ore` | |
| `b eql_v3.` | `query_numeric_ord_ore` | |
Returns [#returns-669]
**Type:** `boolean`
boolean
***
lt(query_bigint_ord_ore, eql_v3_bigint_ord_ore) [#ltquery_bigint_ord_ore-eql_v3_bigint_ord_ore]
Operator wrapper for eql\_v3.query\_bigint\_ord\_ore.
Parameters [#parameters-673]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a eql_v3.` | `query_bigint_ord_ore` | |
| `b public.` | `eql_v3_bigint_ord_ore` | |
Returns [#returns-670]
**Type:** `boolean`
boolean
***
lt(eql_v3_bigint_ord_ore, query_bigint_ord_ore) [#lteql_v3_bigint_ord_ore-query_bigint_ord_ore]
Operator wrapper for eql\_v3.query\_bigint\_ord\_ore.
Parameters [#parameters-674]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a public.` | `eql_v3_bigint_ord_ore` | |
| `b eql_v3.` | `query_bigint_ord_ore` | |
Returns [#returns-671]
**Type:** `boolean`
boolean
***
lt(query_bigint_ord_ope, eql_v3_bigint_ord_ope) [#ltquery_bigint_ord_ope-eql_v3_bigint_ord_ope]
Operator wrapper for eql\_v3.query\_bigint\_ord\_ope.
Parameters [#parameters-675]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a eql_v3.` | `query_bigint_ord_ope` | |
| `b public.` | `eql_v3_bigint_ord_ope` | |
Returns [#returns-672]
**Type:** `boolean`
boolean
***
lt(eql_v3_bigint_ord_ope, query_bigint_ord_ope) [#lteql_v3_bigint_ord_ope-query_bigint_ord_ope]
Operator wrapper for eql\_v3.query\_bigint\_ord\_ope.
Parameters [#parameters-676]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a public.` | `eql_v3_bigint_ord_ope` | |
| `b eql_v3.` | `query_bigint_ord_ope` | |
Returns [#returns-673]
**Type:** `boolean`
boolean
***
lt(query_date_ord_ore, eql_v3_date_ord_ore) [#ltquery_date_ord_ore-eql_v3_date_ord_ore]
Operator wrapper for eql\_v3.query\_date\_ord\_ore.
Parameters [#parameters-677]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a eql_v3.` | `query_date_ord_ore` | |
| `b public.` | `eql_v3_date_ord_ore` | |
Returns [#returns-674]
**Type:** `boolean`
boolean
***
lt(eql_v3_date_ord_ore, query_date_ord_ore) [#lteql_v3_date_ord_ore-query_date_ord_ore]
Operator wrapper for eql\_v3.query\_date\_ord\_ore.
Parameters [#parameters-678]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_date_ord_ore` | |
| `b eql_v3.` | `query_date_ord_ore` | |
Returns [#returns-675]
**Type:** `boolean`
boolean
***
lt(query_smallint_ord_ope, eql_v3_smallint_ord_ope) [#ltquery_smallint_ord_ope-eql_v3_smallint_ord_ope]
Operator wrapper for eql\_v3.query\_smallint\_ord\_ope.
Parameters [#parameters-679]
| Name | Type | Description |
| ----------- | ------------------------- | ----------- |
| `a eql_v3.` | `query_smallint_ord_ope` | |
| `b public.` | `eql_v3_smallint_ord_ope` | |
Returns [#returns-676]
**Type:** `boolean`
boolean
***
lt(eql_v3_smallint_ord_ope, query_smallint_ord_ope) [#lteql_v3_smallint_ord_ope-query_smallint_ord_ope]
Operator wrapper for eql\_v3.query\_smallint\_ord\_ope.
Parameters [#parameters-680]
| Name | Type | Description |
| ----------- | ------------------------- | ----------- |
| `a public.` | `eql_v3_smallint_ord_ope` | |
| `b eql_v3.` | `query_smallint_ord_ope` | |
Returns [#returns-677]
**Type:** `boolean`
boolean
***
lt(jsonb, eql_v3_double_ord) [#ltjsonb-eql_v3_double_ord]
Operator wrapper for public.eql\_v3\_double\_ord.
Parameters [#parameters-681]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_double_ord` | |
Returns [#returns-678]
**Type:** `boolean`
boolean
***
lt(eql_v3_double_ord, jsonb) [#lteql_v3_double_ord-jsonb]
Operator wrapper for public.eql\_v3\_double\_ord.
Parameters [#parameters-682]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a public.` | `eql_v3_double_ord` | |
| `b` | `jsonb` | |
Returns [#returns-679]
**Type:** `boolean`
boolean
***
lt(eql_v3_double_ord, eql_v3_double_ord) [#lteql_v3_double_ord-eql_v3_double_ord]
Operator wrapper for public.eql\_v3\_double\_ord.
Parameters [#parameters-683]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a public.` | `eql_v3_double_ord` | |
| `b public.` | `eql_v3_double_ord` | |
Returns [#returns-680]
**Type:** `boolean`
boolean
***
lt(query_numeric_ord_ope, eql_v3_numeric_ord_ope) [#ltquery_numeric_ord_ope-eql_v3_numeric_ord_ope]
Operator wrapper for eql\_v3.query\_numeric\_ord\_ope.
Parameters [#parameters-684]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a eql_v3.` | `query_numeric_ord_ope` | |
| `b public.` | `eql_v3_numeric_ord_ope` | |
Returns [#returns-681]
**Type:** `boolean`
boolean
***
lt(eql_v3_numeric_ord_ope, query_numeric_ord_ope) [#lteql_v3_numeric_ord_ope-query_numeric_ord_ope]
Operator wrapper for eql\_v3.query\_numeric\_ord\_ope.
Parameters [#parameters-685]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a public.` | `eql_v3_numeric_ord_ope` | |
| `b eql_v3.` | `query_numeric_ord_ope` | |
Returns [#returns-682]
**Type:** `boolean`
boolean
***
lt(jsonb, eql_v3_double_ord_ope) [#ltjsonb-eql_v3_double_ord_ope]
Operator wrapper for public.eql\_v3\_double\_ord\_ope.
Parameters [#parameters-686]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_double_ord_ope` | |
Returns [#returns-683]
**Type:** `boolean`
boolean
***
lt(eql_v3_double_ord_ope, jsonb) [#lteql_v3_double_ord_ope-jsonb]
Operator wrapper for public.eql\_v3\_double\_ord\_ope.
Parameters [#parameters-687]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a public.` | `eql_v3_double_ord_ope` | |
| `b` | `jsonb` | |
Returns [#returns-684]
**Type:** `boolean`
boolean
***
lt(eql_v3_double_ord_ope, eql_v3_double_ord_ope) [#lteql_v3_double_ord_ope-eql_v3_double_ord_ope]
Operator wrapper for public.eql\_v3\_double\_ord\_ope.
Parameters [#parameters-688]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a public.` | `eql_v3_double_ord_ope` | |
| `b public.` | `eql_v3_double_ord_ope` | |
Returns [#returns-685]
**Type:** `boolean`
boolean
***
lt(jsonb, eql_v3_numeric_ord_ope) [#ltjsonb-eql_v3_numeric_ord_ope]
Operator wrapper for public.eql\_v3\_numeric\_ord\_ope.
Parameters [#parameters-689]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_numeric_ord_ope` | |
Returns [#returns-686]
**Type:** `boolean`
boolean
***
lt(eql_v3_numeric_ord_ope, jsonb) [#lteql_v3_numeric_ord_ope-jsonb]
Operator wrapper for public.eql\_v3\_numeric\_ord\_ope.
Parameters [#parameters-690]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a public.` | `eql_v3_numeric_ord_ope` | |
| `b` | `jsonb` | |
Returns [#returns-687]
**Type:** `boolean`
boolean
***
lt(eql_v3_numeric_ord_ope, eql_v3_numeric_ord_ope) [#lteql_v3_numeric_ord_ope-eql_v3_numeric_ord_ope]
Operator wrapper for public.eql\_v3\_numeric\_ord\_ope.
Parameters [#parameters-691]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a public.` | `eql_v3_numeric_ord_ope` | |
| `b public.` | `eql_v3_numeric_ord_ope` | |
Returns [#returns-688]
**Type:** `boolean`
boolean
***
lt(jsonb, eql_v3_date_ord_ore) [#ltjsonb-eql_v3_date_ord_ore]
Operator wrapper for public.eql\_v3\_date\_ord\_ore.
Parameters [#parameters-692]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_date_ord_ore` | |
Returns [#returns-689]
**Type:** `boolean`
boolean
***
lt(eql_v3_date_ord_ore, jsonb) [#lteql_v3_date_ord_ore-jsonb]
Operator wrapper for public.eql\_v3\_date\_ord\_ore.
Parameters [#parameters-693]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_date_ord_ore` | |
| `b` | `jsonb` | |
Returns [#returns-690]
**Type:** `boolean`
boolean
***
lt(eql_v3_date_ord_ore, eql_v3_date_ord_ore) [#lteql_v3_date_ord_ore-eql_v3_date_ord_ore]
Operator wrapper for public.eql\_v3\_date\_ord\_ore.
Parameters [#parameters-694]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_date_ord_ore` | |
| `b public.` | `eql_v3_date_ord_ore` | |
Returns [#returns-691]
**Type:** `boolean`
boolean
***
lt(query_timestamp_ord, eql_v3_timestamp_ord) [#ltquery_timestamp_ord-eql_v3_timestamp_ord]
Operator wrapper for eql\_v3.query\_timestamp\_ord.
Parameters [#parameters-695]
| Name | Type | Description |
| ----------- | ---------------------- | ----------- |
| `a eql_v3.` | `query_timestamp_ord` | |
| `b public.` | `eql_v3_timestamp_ord` | |
Returns [#returns-692]
**Type:** `boolean`
boolean
***
lt(eql_v3_timestamp_ord, query_timestamp_ord) [#lteql_v3_timestamp_ord-query_timestamp_ord]
Operator wrapper for eql\_v3.query\_timestamp\_ord.
Parameters [#parameters-696]
| Name | Type | Description |
| ----------- | ---------------------- | ----------- |
| `a public.` | `eql_v3_timestamp_ord` | |
| `b eql_v3.` | `query_timestamp_ord` | |
Returns [#returns-693]
**Type:** `boolean`
boolean
***
lt(jsonb, eql_v3_smallint_ord_ore) [#ltjsonb-eql_v3_smallint_ord_ore]
Operator wrapper for public.eql\_v3\_smallint\_ord\_ore.
Parameters [#parameters-697]
| Name | Type | Description |
| ----------- | ------------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_smallint_ord_ore` | |
Returns [#returns-694]
**Type:** `boolean`
boolean
***
lt(eql_v3_smallint_ord_ore, jsonb) [#lteql_v3_smallint_ord_ore-jsonb]
Operator wrapper for public.eql\_v3\_smallint\_ord\_ore.
Parameters [#parameters-698]
| Name | Type | Description |
| ----------- | ------------------------- | ----------- |
| `a public.` | `eql_v3_smallint_ord_ore` | |
| `b` | `jsonb` | |
Returns [#returns-695]
**Type:** `boolean`
boolean
***
lt(eql_v3_smallint_ord_ore, eql_v3_smallint_ord_ore) [#lteql_v3_smallint_ord_ore-eql_v3_smallint_ord_ore]
Operator wrapper for public.eql\_v3\_smallint\_ord\_ore.
Parameters [#parameters-699]
| Name | Type | Description |
| ----------- | ------------------------- | ----------- |
| `a public.` | `eql_v3_smallint_ord_ore` | |
| `b public.` | `eql_v3_smallint_ord_ore` | |
Returns [#returns-696]
**Type:** `boolean`
boolean
***
lt(jsonb, eql_v3_date_ord_ope) [#ltjsonb-eql_v3_date_ord_ope]
Operator wrapper for public.eql\_v3\_date\_ord\_ope.
Parameters [#parameters-700]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_date_ord_ope` | |
Returns [#returns-697]
**Type:** `boolean`
boolean
***
lt(eql_v3_date_ord_ope, jsonb) [#lteql_v3_date_ord_ope-jsonb]
Operator wrapper for public.eql\_v3\_date\_ord\_ope.
Parameters [#parameters-701]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_date_ord_ope` | |
| `b` | `jsonb` | |
Returns [#returns-698]
**Type:** `boolean`
boolean
***
lt(eql_v3_date_ord_ope, eql_v3_date_ord_ope) [#lteql_v3_date_ord_ope-eql_v3_date_ord_ope]
Operator wrapper for public.eql\_v3\_date\_ord\_ope.
Parameters [#parameters-702]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_date_ord_ope` | |
| `b public.` | `eql_v3_date_ord_ope` | |
Returns [#returns-699]
**Type:** `boolean`
boolean
***
lt(query_bigint_ord, eql_v3_bigint_ord) [#ltquery_bigint_ord-eql_v3_bigint_ord]
Operator wrapper for eql\_v3.query\_bigint\_ord.
Parameters [#parameters-703]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a eql_v3.` | `query_bigint_ord` | |
| `b public.` | `eql_v3_bigint_ord` | |
Returns [#returns-700]
**Type:** `boolean`
boolean
***
lt(eql_v3_bigint_ord, query_bigint_ord) [#lteql_v3_bigint_ord-query_bigint_ord]
Operator wrapper for eql\_v3.query\_bigint\_ord.
Parameters [#parameters-704]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a public.` | `eql_v3_bigint_ord` | |
| `b eql_v3.` | `query_bigint_ord` | |
Returns [#returns-701]
**Type:** `boolean`
boolean
***
lt(jsonb, eql_v3_text_ord_ore) [#ltjsonb-eql_v3_text_ord_ore]
Operator wrapper for public.eql\_v3\_text\_ord\_ore.
Parameters [#parameters-705]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_text_ord_ore` | |
Returns [#returns-702]
**Type:** `boolean`
boolean
***
lt(eql_v3_text_ord_ore, jsonb) [#lteql_v3_text_ord_ore-jsonb]
Operator wrapper for public.eql\_v3\_text\_ord\_ore.
Parameters [#parameters-706]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_text_ord_ore` | |
| `b` | `jsonb` | |
Returns [#returns-703]
**Type:** `boolean`
boolean
***
lt(eql_v3_text_ord_ore, eql_v3_text_ord_ore) [#lteql_v3_text_ord_ore-eql_v3_text_ord_ore]
Operator wrapper for public.eql\_v3\_text\_ord\_ore.
Parameters [#parameters-707]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_text_ord_ore` | |
| `b public.` | `eql_v3_text_ord_ore` | |
Returns [#returns-704]
**Type:** `boolean`
boolean
***
lt(query_bigint_ord, eql_v3_json_entry) [#ltquery_bigint_ord-eql_v3_json_entry]
Operator wrapper for public.eql\_v3\_json\_entry.
Unsupported operator blocker for public.eql\_v3\_json\_entry.
Parameters [#parameters-708]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a eql_v3.` | `query_bigint_ord` | |
| `b public.` | `eql_v3_json_entry` | |
Returns [#returns-705]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lt(eql_v3_json_entry, query_bigint_ord) [#lteql_v3_json_entry-query_bigint_ord]
Operator wrapper for public.eql\_v3\_json\_entry.
Unsupported operator blocker for public.eql\_v3\_json\_entry.
Parameters [#parameters-709]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a public.` | `eql_v3_json_entry` | |
| `b eql_v3.` | `query_bigint_ord` | |
Returns [#returns-706]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lte(jsonb, eql_v3_integer_ord_ore) [#ltejsonb-eql_v3_integer_ord_ore]
Operator wrapper for public.eql\_v3\_integer\_ord\_ore.
Parameters [#parameters-710]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_integer_ord_ore` | |
Returns [#returns-707]
**Type:** `boolean`
boolean
***
lte(eql_v3_integer_ord_ore, jsonb) [#lteeql_v3_integer_ord_ore-jsonb]
Operator wrapper for public.eql\_v3\_integer\_ord\_ore.
Parameters [#parameters-711]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a public.` | `eql_v3_integer_ord_ore` | |
| `b` | `jsonb` | |
Returns [#returns-708]
**Type:** `boolean`
boolean
***
lte(eql_v3_integer_ord_ore, eql_v3_integer_ord_ore) [#lteeql_v3_integer_ord_ore-eql_v3_integer_ord_ore]
Operator wrapper for public.eql\_v3\_integer\_ord\_ore.
Parameters [#parameters-712]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a public.` | `eql_v3_integer_ord_ore` | |
| `b public.` | `eql_v3_integer_ord_ore` | |
Returns [#returns-709]
**Type:** `boolean`
boolean
***
lte(query_smallint_ord, eql_v3_smallint_ord) [#ltequery_smallint_ord-eql_v3_smallint_ord]
Operator wrapper for eql\_v3.query\_smallint\_ord.
Parameters [#parameters-713]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a eql_v3.` | `query_smallint_ord` | |
| `b public.` | `eql_v3_smallint_ord` | |
Returns [#returns-710]
**Type:** `boolean`
boolean
***
lte(eql_v3_smallint_ord, query_smallint_ord) [#lteeql_v3_smallint_ord-query_smallint_ord]
Operator wrapper for eql\_v3.query\_smallint\_ord.
Parameters [#parameters-714]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_smallint_ord` | |
| `b eql_v3.` | `query_smallint_ord` | |
Returns [#returns-711]
**Type:** `boolean`
boolean
***
lte(jsonb, eql_v3_smallint_ord) [#ltejsonb-eql_v3_smallint_ord]
Operator wrapper for public.eql\_v3\_smallint\_ord.
Parameters [#parameters-715]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_smallint_ord` | |
Returns [#returns-712]
**Type:** `boolean`
boolean
***
lte(eql_v3_smallint_ord, jsonb) [#lteeql_v3_smallint_ord-jsonb]
Operator wrapper for public.eql\_v3\_smallint\_ord.
Parameters [#parameters-716]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_smallint_ord` | |
| `b` | `jsonb` | |
Returns [#returns-713]
**Type:** `boolean`
boolean
***
lte(eql_v3_smallint_ord, eql_v3_smallint_ord) [#lteeql_v3_smallint_ord-eql_v3_smallint_ord]
Operator wrapper for public.eql\_v3\_smallint\_ord.
Parameters [#parameters-717]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_smallint_ord` | |
| `b public.` | `eql_v3_smallint_ord` | |
Returns [#returns-714]
**Type:** `boolean`
boolean
***
lte(jsonb, eql_v3_date_ord) [#ltejsonb-eql_v3_date_ord]
Operator wrapper for public.eql\_v3\_date\_ord.
Parameters [#parameters-718]
| Name | Type | Description |
| ----------- | ----------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_date_ord` | |
Returns [#returns-715]
**Type:** `boolean`
boolean
***
lte(eql_v3_date_ord, jsonb) [#lteeql_v3_date_ord-jsonb]
Operator wrapper for public.eql\_v3\_date\_ord.
Parameters [#parameters-719]
| Name | Type | Description |
| ----------- | ----------------- | ----------- |
| `a public.` | `eql_v3_date_ord` | |
| `b` | `jsonb` | |
Returns [#returns-716]
**Type:** `boolean`
boolean
***
lte(eql_v3_date_ord, eql_v3_date_ord) [#lteeql_v3_date_ord-eql_v3_date_ord]
Operator wrapper for public.eql\_v3\_date\_ord.
Parameters [#parameters-720]
| Name | Type | Description |
| ----------- | ----------------- | ----------- |
| `a public.` | `eql_v3_date_ord` | |
| `b public.` | `eql_v3_date_ord` | |
Returns [#returns-717]
**Type:** `boolean`
boolean
***
lte(query_real_ord, eql_v3_real_ord) [#ltequery_real_ord-eql_v3_real_ord]
Operator wrapper for eql\_v3.query\_real\_ord.
Parameters [#parameters-721]
| Name | Type | Description |
| ----------- | ----------------- | ----------- |
| `a eql_v3.` | `query_real_ord` | |
| `b public.` | `eql_v3_real_ord` | |
Returns [#returns-718]
**Type:** `boolean`
boolean
***
lte(eql_v3_real_ord, query_real_ord) [#lteeql_v3_real_ord-query_real_ord]
Operator wrapper for eql\_v3.query\_real\_ord.
Parameters [#parameters-722]
| Name | Type | Description |
| ----------- | ----------------- | ----------- |
| `a public.` | `eql_v3_real_ord` | |
| `b eql_v3.` | `query_real_ord` | |
Returns [#returns-719]
**Type:** `boolean`
boolean
***
lte(query_double_ord, eql_v3_json_entry) [#ltequery_double_ord-eql_v3_json_entry]
Operator wrapper for public.eql\_v3\_json\_entry.
Parameters [#parameters-723]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a eql_v3.` | `query_double_ord` | |
| `b public.` | `eql_v3_json_entry` | |
Returns [#returns-720]
**Type:** `boolean`
boolean
***
lte(eql_v3_json_entry, query_double_ord) [#lteeql_v3_json_entry-query_double_ord]
Operator wrapper for public.eql\_v3\_json\_entry.
Parameters [#parameters-724]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a public.` | `eql_v3_json_entry` | |
| `b eql_v3.` | `query_double_ord` | |
Returns [#returns-721]
**Type:** `boolean`
boolean
***
lte(query_real_ord_ore, eql_v3_real_ord_ore) [#ltequery_real_ord_ore-eql_v3_real_ord_ore]
Operator wrapper for eql\_v3.query\_real\_ord\_ore.
Parameters [#parameters-725]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a eql_v3.` | `query_real_ord_ore` | |
| `b public.` | `eql_v3_real_ord_ore` | |
Returns [#returns-722]
**Type:** `boolean`
boolean
***
lte(eql_v3_real_ord_ore, query_real_ord_ore) [#lteeql_v3_real_ord_ore-query_real_ord_ore]
Operator wrapper for eql\_v3.query\_real\_ord\_ore.
Parameters [#parameters-726]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_real_ord_ore` | |
| `b eql_v3.` | `query_real_ord_ore` | |
Returns [#returns-723]
**Type:** `boolean`
boolean
***
lte(jsonb, eql_v3_text_ord) [#ltejsonb-eql_v3_text_ord]
Operator wrapper for public.eql\_v3\_text\_ord.
Parameters [#parameters-727]
| Name | Type | Description |
| ----------- | ----------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_text_ord` | |
Returns [#returns-724]
**Type:** `boolean`
boolean
***
lte(eql_v3_text_ord, jsonb) [#lteeql_v3_text_ord-jsonb]
Operator wrapper for public.eql\_v3\_text\_ord.
Parameters [#parameters-728]
| Name | Type | Description |
| ----------- | ----------------- | ----------- |
| `a public.` | `eql_v3_text_ord` | |
| `b` | `jsonb` | |
Returns [#returns-725]
**Type:** `boolean`
boolean
***
lte(eql_v3_text_ord, eql_v3_text_ord) [#lteeql_v3_text_ord-eql_v3_text_ord]
Operator wrapper for public.eql\_v3\_text\_ord.
Parameters [#parameters-729]
| Name | Type | Description |
| ----------- | ----------------- | ----------- |
| `a public.` | `eql_v3_text_ord` | |
| `b public.` | `eql_v3_text_ord` | |
Returns [#returns-726]
**Type:** `boolean`
boolean
***
lte(query_integer_ord_ope, eql_v3_integer_ord_ope) [#ltequery_integer_ord_ope-eql_v3_integer_ord_ope]
Operator wrapper for eql\_v3.query\_integer\_ord\_ope.
Parameters [#parameters-730]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a eql_v3.` | `query_integer_ord_ope` | |
| `b public.` | `eql_v3_integer_ord_ope` | |
Returns [#returns-727]
**Type:** `boolean`
boolean
***
lte(eql_v3_integer_ord_ope, query_integer_ord_ope) [#lteeql_v3_integer_ord_ope-query_integer_ord_ope]
Operator wrapper for eql\_v3.query\_integer\_ord\_ope.
Parameters [#parameters-731]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a public.` | `eql_v3_integer_ord_ope` | |
| `b eql_v3.` | `query_integer_ord_ope` | |
Returns [#returns-728]
**Type:** `boolean`
boolean
***
lte(query_text_ord, eql_v3_text_ord) [#ltequery_text_ord-eql_v3_text_ord]
Operator wrapper for eql\_v3.query\_text\_ord.
Parameters [#parameters-732]
| Name | Type | Description |
| ----------- | ----------------- | ----------- |
| `a eql_v3.` | `query_text_ord` | |
| `b public.` | `eql_v3_text_ord` | |
Returns [#returns-729]
**Type:** `boolean`
boolean
***
lte(eql_v3_text_ord, query_text_ord) [#lteeql_v3_text_ord-query_text_ord]
Operator wrapper for eql\_v3.query\_text\_ord.
Parameters [#parameters-733]
| Name | Type | Description |
| ----------- | ----------------- | ----------- |
| `a public.` | `eql_v3_text_ord` | |
| `b eql_v3.` | `query_text_ord` | |
Returns [#returns-730]
**Type:** `boolean`
boolean
***
lte(jsonb, eql_v3_timestamp_ord_ope) [#ltejsonb-eql_v3_timestamp_ord_ope]
Operator wrapper for public.eql\_v3\_timestamp\_ord\_ope.
Parameters [#parameters-734]
| Name | Type | Description |
| ----------- | -------------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_timestamp_ord_ope` | |
Returns [#returns-731]
**Type:** `boolean`
boolean
***
lte(eql_v3_timestamp_ord_ope, jsonb) [#lteeql_v3_timestamp_ord_ope-jsonb]
Operator wrapper for public.eql\_v3\_timestamp\_ord\_ope.
Parameters [#parameters-735]
| Name | Type | Description |
| ----------- | -------------------------- | ----------- |
| `a public.` | `eql_v3_timestamp_ord_ope` | |
| `b` | `jsonb` | |
Returns [#returns-732]
**Type:** `boolean`
boolean
***
lte(eql_v3_timestamp_ord_ope, eql_v3_timestamp_ord_ope) [#lteeql_v3_timestamp_ord_ope-eql_v3_timestamp_ord_ope]
Operator wrapper for public.eql\_v3\_timestamp\_ord\_ope.
Parameters [#parameters-736]
| Name | Type | Description |
| ----------- | -------------------------- | ----------- |
| `a public.` | `eql_v3_timestamp_ord_ope` | |
| `b public.` | `eql_v3_timestamp_ord_ope` | |
Returns [#returns-733]
**Type:** `boolean`
boolean
***
lte(jsonb, eql_v3_integer_ord_ope) [#ltejsonb-eql_v3_integer_ord_ope]
Operator wrapper for public.eql\_v3\_integer\_ord\_ope.
Parameters [#parameters-737]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_integer_ord_ope` | |
Returns [#returns-734]
**Type:** `boolean`
boolean
***
lte(eql_v3_integer_ord_ope, jsonb) [#lteeql_v3_integer_ord_ope-jsonb]
Operator wrapper for public.eql\_v3\_integer\_ord\_ope.
Parameters [#parameters-738]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a public.` | `eql_v3_integer_ord_ope` | |
| `b` | `jsonb` | |
Returns [#returns-735]
**Type:** `boolean`
boolean
***
lte(eql_v3_integer_ord_ope, eql_v3_integer_ord_ope) [#lteeql_v3_integer_ord_ope-eql_v3_integer_ord_ope]
Operator wrapper for public.eql\_v3\_integer\_ord\_ope.
Parameters [#parameters-739]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a public.` | `eql_v3_integer_ord_ope` | |
| `b public.` | `eql_v3_integer_ord_ope` | |
Returns [#returns-736]
**Type:** `boolean`
boolean
***
lte(query_integer_ord, eql_v3_integer_ord) [#ltequery_integer_ord-eql_v3_integer_ord]
Operator wrapper for eql\_v3.query\_integer\_ord.
Parameters [#parameters-740]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a eql_v3.` | `query_integer_ord` | |
| `b public.` | `eql_v3_integer_ord` | |
Returns [#returns-737]
**Type:** `boolean`
boolean
***
lte(eql_v3_integer_ord, query_integer_ord) [#lteeql_v3_integer_ord-query_integer_ord]
Operator wrapper for eql\_v3.query\_integer\_ord.
Parameters [#parameters-741]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a public.` | `eql_v3_integer_ord` | |
| `b eql_v3.` | `query_integer_ord` | |
Returns [#returns-738]
**Type:** `boolean`
boolean
***
lte(query_text_search, eql_v3_text_search) [#ltequery_text_search-eql_v3_text_search]
Operator wrapper for eql\_v3.query\_text\_search.
Parameters [#parameters-742]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a eql_v3.` | `query_text_search` | |
| `b public.` | `eql_v3_text_search` | |
Returns [#returns-739]
**Type:** `boolean`
boolean
***
lte(eql_v3_text_search, query_text_search) [#lteeql_v3_text_search-query_text_search]
Operator wrapper for eql\_v3.query\_text\_search.
Parameters [#parameters-743]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a public.` | `eql_v3_text_search` | |
| `b eql_v3.` | `query_text_search` | |
Returns [#returns-740]
**Type:** `boolean`
boolean
***
lte(jsonb, eql_v3_numeric_ord) [#ltejsonb-eql_v3_numeric_ord]
Operator wrapper for public.eql\_v3\_numeric\_ord.
Parameters [#parameters-744]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_numeric_ord` | |
Returns [#returns-741]
**Type:** `boolean`
boolean
***
lte(eql_v3_numeric_ord, jsonb) [#lteeql_v3_numeric_ord-jsonb]
Operator wrapper for public.eql\_v3\_numeric\_ord.
Parameters [#parameters-745]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a public.` | `eql_v3_numeric_ord` | |
| `b` | `jsonb` | |
Returns [#returns-742]
**Type:** `boolean`
boolean
***
lte(eql_v3_numeric_ord, eql_v3_numeric_ord) [#lteeql_v3_numeric_ord-eql_v3_numeric_ord]
Operator wrapper for public.eql\_v3\_numeric\_ord.
Parameters [#parameters-746]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a public.` | `eql_v3_numeric_ord` | |
| `b public.` | `eql_v3_numeric_ord` | |
Returns [#returns-743]
**Type:** `boolean`
boolean
***
lte(query_date_ord_ope, eql_v3_date_ord_ope) [#ltequery_date_ord_ope-eql_v3_date_ord_ope]
Operator wrapper for eql\_v3.query\_date\_ord\_ope.
Parameters [#parameters-747]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a eql_v3.` | `query_date_ord_ope` | |
| `b public.` | `eql_v3_date_ord_ope` | |
Returns [#returns-744]
**Type:** `boolean`
boolean
***
lte(eql_v3_date_ord_ope, query_date_ord_ope) [#lteeql_v3_date_ord_ope-query_date_ord_ope]
Operator wrapper for eql\_v3.query\_date\_ord\_ope.
Parameters [#parameters-748]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_date_ord_ope` | |
| `b eql_v3.` | `query_date_ord_ope` | |
Returns [#returns-745]
**Type:** `boolean`
boolean
***
lte(query_smallint_ord, eql_v3_json_entry) [#ltequery_smallint_ord-eql_v3_json_entry]
Operator wrapper for public.eql\_v3\_json\_entry.
Parameters [#parameters-749]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a eql_v3.` | `query_smallint_ord` | |
| `b public.` | `eql_v3_json_entry` | |
Returns [#returns-746]
**Type:** `boolean`
boolean
***
lte(eql_v3_json_entry, query_smallint_ord) [#lteeql_v3_json_entry-query_smallint_ord]
Operator wrapper for public.eql\_v3\_json\_entry.
Parameters [#parameters-750]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a public.` | `eql_v3_json_entry` | |
| `b eql_v3.` | `query_smallint_ord` | |
Returns [#returns-747]
**Type:** `boolean`
boolean
***
lte(query_timestamp_ord_ore, eql_v3_timestamp_ord_ore) [#ltequery_timestamp_ord_ore-eql_v3_timestamp_ord_ore]
Operator wrapper for eql\_v3.query\_timestamp\_ord\_ore.
Parameters [#parameters-751]
| Name | Type | Description |
| ----------- | -------------------------- | ----------- |
| `a eql_v3.` | `query_timestamp_ord_ore` | |
| `b public.` | `eql_v3_timestamp_ord_ore` | |
Returns [#returns-748]
**Type:** `boolean`
boolean
***
lte(eql_v3_timestamp_ord_ore, query_timestamp_ord_ore) [#lteeql_v3_timestamp_ord_ore-query_timestamp_ord_ore]
Operator wrapper for eql\_v3.query\_timestamp\_ord\_ore.
Parameters [#parameters-752]
| Name | Type | Description |
| ----------- | -------------------------- | ----------- |
| `a public.` | `eql_v3_timestamp_ord_ore` | |
| `b eql_v3.` | `query_timestamp_ord_ore` | |
Returns [#returns-749]
**Type:** `boolean`
boolean
***
lte(query_text_search_ore, eql_v3_text_search_ore) [#ltequery_text_search_ore-eql_v3_text_search_ore]
Operator wrapper for eql\_v3.query\_text\_search\_ore.
Parameters [#parameters-753]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a eql_v3.` | `query_text_search_ore` | |
| `b public.` | `eql_v3_text_search_ore` | |
Returns [#returns-750]
**Type:** `boolean`
boolean
***
lte(eql_v3_text_search_ore, query_text_search_ore) [#lteeql_v3_text_search_ore-query_text_search_ore]
Operator wrapper for eql\_v3.query\_text\_search\_ore.
Parameters [#parameters-754]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a public.` | `eql_v3_text_search_ore` | |
| `b eql_v3.` | `query_text_search_ore` | |
Returns [#returns-751]
**Type:** `boolean`
boolean
***
lte(query_text_ord_ore, eql_v3_text_ord_ore) [#ltequery_text_ord_ore-eql_v3_text_ord_ore]
Operator wrapper for eql\_v3.query\_text\_ord\_ore.
Parameters [#parameters-755]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a eql_v3.` | `query_text_ord_ore` | |
| `b public.` | `eql_v3_text_ord_ore` | |
Returns [#returns-752]
**Type:** `boolean`
boolean
***
lte(eql_v3_text_ord_ore, query_text_ord_ore) [#lteeql_v3_text_ord_ore-query_text_ord_ore]
Operator wrapper for eql\_v3.query\_text\_ord\_ore.
Parameters [#parameters-756]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_text_ord_ore` | |
| `b eql_v3.` | `query_text_ord_ore` | |
Returns [#returns-753]
**Type:** `boolean`
boolean
***
lte(jsonb, eql_v3_real_ord_ope) [#ltejsonb-eql_v3_real_ord_ope]
Operator wrapper for public.eql\_v3\_real\_ord\_ope.
Parameters [#parameters-757]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_real_ord_ope` | |
Returns [#returns-754]
**Type:** `boolean`
boolean
***
lte(eql_v3_real_ord_ope, jsonb) [#lteeql_v3_real_ord_ope-jsonb]
Operator wrapper for public.eql\_v3\_real\_ord\_ope.
Parameters [#parameters-758]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_real_ord_ope` | |
| `b` | `jsonb` | |
Returns [#returns-755]
**Type:** `boolean`
boolean
***
lte(eql_v3_real_ord_ope, eql_v3_real_ord_ope) [#lteeql_v3_real_ord_ope-eql_v3_real_ord_ope]
Operator wrapper for public.eql\_v3\_real\_ord\_ope.
Parameters [#parameters-759]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_real_ord_ope` | |
| `b public.` | `eql_v3_real_ord_ope` | |
Returns [#returns-756]
**Type:** `boolean`
boolean
***
lte(jsonb, eql_v3_real_ord) [#ltejsonb-eql_v3_real_ord]
Operator wrapper for public.eql\_v3\_real\_ord.
Parameters [#parameters-760]
| Name | Type | Description |
| ----------- | ----------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_real_ord` | |
Returns [#returns-757]
**Type:** `boolean`
boolean
***
lte(eql_v3_real_ord, jsonb) [#lteeql_v3_real_ord-jsonb]
Operator wrapper for public.eql\_v3\_real\_ord.
Parameters [#parameters-761]
| Name | Type | Description |
| ----------- | ----------------- | ----------- |
| `a public.` | `eql_v3_real_ord` | |
| `b` | `jsonb` | |
Returns [#returns-758]
**Type:** `boolean`
boolean
***
lte(eql_v3_real_ord, eql_v3_real_ord) [#lteeql_v3_real_ord-eql_v3_real_ord]
Operator wrapper for public.eql\_v3\_real\_ord.
Parameters [#parameters-762]
| Name | Type | Description |
| ----------- | ----------------- | ----------- |
| `a public.` | `eql_v3_real_ord` | |
| `b public.` | `eql_v3_real_ord` | |
Returns [#returns-759]
**Type:** `boolean`
boolean
***
lte(jsonb, eql_v3_integer_ord) [#ltejsonb-eql_v3_integer_ord]
Operator wrapper for public.eql\_v3\_integer\_ord.
Parameters [#parameters-763]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_integer_ord` | |
Returns [#returns-760]
**Type:** `boolean`
boolean
***
lte(eql_v3_integer_ord, jsonb) [#lteeql_v3_integer_ord-jsonb]
Operator wrapper for public.eql\_v3\_integer\_ord.
Parameters [#parameters-764]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a public.` | `eql_v3_integer_ord` | |
| `b` | `jsonb` | |
Returns [#returns-761]
**Type:** `boolean`
boolean
***
lte(eql_v3_integer_ord, eql_v3_integer_ord) [#lteeql_v3_integer_ord-eql_v3_integer_ord]
Operator wrapper for public.eql\_v3\_integer\_ord.
Parameters [#parameters-765]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a public.` | `eql_v3_integer_ord` | |
| `b public.` | `eql_v3_integer_ord` | |
Returns [#returns-762]
**Type:** `boolean`
boolean
***
lte(query_smallint_ord_ore, eql_v3_smallint_ord_ore) [#ltequery_smallint_ord_ore-eql_v3_smallint_ord_ore]
Operator wrapper for eql\_v3.query\_smallint\_ord\_ore.
Parameters [#parameters-766]
| Name | Type | Description |
| ----------- | ------------------------- | ----------- |
| `a eql_v3.` | `query_smallint_ord_ore` | |
| `b public.` | `eql_v3_smallint_ord_ore` | |
Returns [#returns-763]
**Type:** `boolean`
boolean
***
lte(eql_v3_smallint_ord_ore, query_smallint_ord_ore) [#lteeql_v3_smallint_ord_ore-query_smallint_ord_ore]
Operator wrapper for eql\_v3.query\_smallint\_ord\_ore.
Parameters [#parameters-767]
| Name | Type | Description |
| ----------- | ------------------------- | ----------- |
| `a public.` | `eql_v3_smallint_ord_ore` | |
| `b eql_v3.` | `query_smallint_ord_ore` | |
Returns [#returns-764]
**Type:** `boolean`
boolean
***
lte(jsonb, eql_v3_text_ord_ope) [#ltejsonb-eql_v3_text_ord_ope]
Operator wrapper for public.eql\_v3\_text\_ord\_ope.
Parameters [#parameters-768]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_text_ord_ope` | |
Returns [#returns-765]
**Type:** `boolean`
boolean
***
lte(eql_v3_text_ord_ope, jsonb) [#lteeql_v3_text_ord_ope-jsonb]
Operator wrapper for public.eql\_v3\_text\_ord\_ope.
Parameters [#parameters-769]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_text_ord_ope` | |
| `b` | `jsonb` | |
Returns [#returns-766]
**Type:** `boolean`
boolean
***
lte(eql_v3_text_ord_ope, eql_v3_text_ord_ope) [#lteeql_v3_text_ord_ope-eql_v3_text_ord_ope]
Operator wrapper for public.eql\_v3\_text\_ord\_ope.
Parameters [#parameters-770]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_text_ord_ope` | |
| `b public.` | `eql_v3_text_ord_ope` | |
Returns [#returns-767]
**Type:** `boolean`
boolean
***
lte(query_double_ord_ope, eql_v3_double_ord_ope) [#ltequery_double_ord_ope-eql_v3_double_ord_ope]
Operator wrapper for eql\_v3.query\_double\_ord\_ope.
Parameters [#parameters-771]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a eql_v3.` | `query_double_ord_ope` | |
| `b public.` | `eql_v3_double_ord_ope` | |
Returns [#returns-768]
**Type:** `boolean`
boolean
***
lte(eql_v3_double_ord_ope, query_double_ord_ope) [#lteeql_v3_double_ord_ope-query_double_ord_ope]
Operator wrapper for eql\_v3.query\_double\_ord\_ope.
Parameters [#parameters-772]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a public.` | `eql_v3_double_ord_ope` | |
| `b eql_v3.` | `query_double_ord_ope` | |
Returns [#returns-769]
**Type:** `boolean`
boolean
***
lte(query_integer_ord_ore, eql_v3_integer_ord_ore) [#ltequery_integer_ord_ore-eql_v3_integer_ord_ore]
Operator wrapper for eql\_v3.query\_integer\_ord\_ore.
Parameters [#parameters-773]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a eql_v3.` | `query_integer_ord_ore` | |
| `b public.` | `eql_v3_integer_ord_ore` | |
Returns [#returns-770]
**Type:** `boolean`
boolean
***
lte(eql_v3_integer_ord_ore, query_integer_ord_ore) [#lteeql_v3_integer_ord_ore-query_integer_ord_ore]
Operator wrapper for eql\_v3.query\_integer\_ord\_ore.
Parameters [#parameters-774]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a public.` | `eql_v3_integer_ord_ore` | |
| `b eql_v3.` | `query_integer_ord_ore` | |
Returns [#returns-771]
**Type:** `boolean`
boolean
***
lte(jsonb, eql_v3_bigint_ord_ore) [#ltejsonb-eql_v3_bigint_ord_ore]
Operator wrapper for public.eql\_v3\_bigint\_ord\_ore.
Parameters [#parameters-775]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_bigint_ord_ore` | |
Returns [#returns-772]
**Type:** `boolean`
boolean
***
lte(eql_v3_bigint_ord_ore, jsonb) [#lteeql_v3_bigint_ord_ore-jsonb]
Operator wrapper for public.eql\_v3\_bigint\_ord\_ore.
Parameters [#parameters-776]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a public.` | `eql_v3_bigint_ord_ore` | |
| `b` | `jsonb` | |
Returns [#returns-773]
**Type:** `boolean`
boolean
***
lte(eql_v3_bigint_ord_ore, eql_v3_bigint_ord_ore) [#lteeql_v3_bigint_ord_ore-eql_v3_bigint_ord_ore]
Operator wrapper for public.eql\_v3\_bigint\_ord\_ore.
Parameters [#parameters-777]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a public.` | `eql_v3_bigint_ord_ore` | |
| `b public.` | `eql_v3_bigint_ord_ore` | |
Returns [#returns-774]
**Type:** `boolean`
boolean
***
lte(query_date_ord, eql_v3_date_ord) [#ltequery_date_ord-eql_v3_date_ord]
Operator wrapper for eql\_v3.query\_date\_ord.
Parameters [#parameters-778]
| Name | Type | Description |
| ----------- | ----------------- | ----------- |
| `a eql_v3.` | `query_date_ord` | |
| `b public.` | `eql_v3_date_ord` | |
Returns [#returns-775]
**Type:** `boolean`
boolean
***
lte(eql_v3_date_ord, query_date_ord) [#lteeql_v3_date_ord-query_date_ord]
Operator wrapper for eql\_v3.query\_date\_ord.
Parameters [#parameters-779]
| Name | Type | Description |
| ----------- | ----------------- | ----------- |
| `a public.` | `eql_v3_date_ord` | |
| `b eql_v3.` | `query_date_ord` | |
Returns [#returns-776]
**Type:** `boolean`
boolean
***
lte(jsonb, eql_v3_real_ord_ore) [#ltejsonb-eql_v3_real_ord_ore]
Operator wrapper for public.eql\_v3\_real\_ord\_ore.
Parameters [#parameters-780]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_real_ord_ore` | |
Returns [#returns-777]
**Type:** `boolean`
boolean
***
lte(eql_v3_real_ord_ore, jsonb) [#lteeql_v3_real_ord_ore-jsonb]
Operator wrapper for public.eql\_v3\_real\_ord\_ore.
Parameters [#parameters-781]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_real_ord_ore` | |
| `b` | `jsonb` | |
Returns [#returns-778]
**Type:** `boolean`
boolean
***
lte(eql_v3_real_ord_ore, eql_v3_real_ord_ore) [#lteeql_v3_real_ord_ore-eql_v3_real_ord_ore]
Operator wrapper for public.eql\_v3\_real\_ord\_ore.
Parameters [#parameters-782]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_real_ord_ore` | |
| `b public.` | `eql_v3_real_ord_ore` | |
Returns [#returns-779]
**Type:** `boolean`
boolean
***
lte(jsonb, eql_v3_numeric_ord_ore) [#ltejsonb-eql_v3_numeric_ord_ore]
Operator wrapper for public.eql\_v3\_numeric\_ord\_ore.
Parameters [#parameters-783]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_numeric_ord_ore` | |
Returns [#returns-780]
**Type:** `boolean`
boolean
***
lte(eql_v3_numeric_ord_ore, jsonb) [#lteeql_v3_numeric_ord_ore-jsonb]
Operator wrapper for public.eql\_v3\_numeric\_ord\_ore.
Parameters [#parameters-784]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a public.` | `eql_v3_numeric_ord_ore` | |
| `b` | `jsonb` | |
Returns [#returns-781]
**Type:** `boolean`
boolean
***
lte(eql_v3_numeric_ord_ore, eql_v3_numeric_ord_ore) [#lteeql_v3_numeric_ord_ore-eql_v3_numeric_ord_ore]
Operator wrapper for public.eql\_v3\_numeric\_ord\_ore.
Parameters [#parameters-785]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a public.` | `eql_v3_numeric_ord_ore` | |
| `b public.` | `eql_v3_numeric_ord_ore` | |
Returns [#returns-782]
**Type:** `boolean`
boolean
***
lte(query_text_ord_ope, eql_v3_text_ord_ope) [#ltequery_text_ord_ope-eql_v3_text_ord_ope]
Operator wrapper for eql\_v3.query\_text\_ord\_ope.
Parameters [#parameters-786]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a eql_v3.` | `query_text_ord_ope` | |
| `b public.` | `eql_v3_text_ord_ope` | |
Returns [#returns-783]
**Type:** `boolean`
boolean
***
lte(eql_v3_text_ord_ope, query_text_ord_ope) [#lteeql_v3_text_ord_ope-query_text_ord_ope]
Operator wrapper for eql\_v3.query\_text\_ord\_ope.
Parameters [#parameters-787]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_text_ord_ope` | |
| `b eql_v3.` | `query_text_ord_ope` | |
Returns [#returns-784]
**Type:** `boolean`
boolean
***
lte(jsonb, eql_v3_bigint_ord_ope) [#ltejsonb-eql_v3_bigint_ord_ope]
Operator wrapper for public.eql\_v3\_bigint\_ord\_ope.
Parameters [#parameters-788]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_bigint_ord_ope` | |
Returns [#returns-785]
**Type:** `boolean`
boolean
***
lte(eql_v3_bigint_ord_ope, jsonb) [#lteeql_v3_bigint_ord_ope-jsonb]
Operator wrapper for public.eql\_v3\_bigint\_ord\_ope.
Parameters [#parameters-789]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a public.` | `eql_v3_bigint_ord_ope` | |
| `b` | `jsonb` | |
Returns [#returns-786]
**Type:** `boolean`
boolean
***
lte(eql_v3_bigint_ord_ope, eql_v3_bigint_ord_ope) [#lteeql_v3_bigint_ord_ope-eql_v3_bigint_ord_ope]
Operator wrapper for public.eql\_v3\_bigint\_ord\_ope.
Parameters [#parameters-790]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a public.` | `eql_v3_bigint_ord_ope` | |
| `b public.` | `eql_v3_bigint_ord_ope` | |
Returns [#returns-787]
**Type:** `boolean`
boolean
***
lte(query_numeric_ord, eql_v3_json_entry) [#ltequery_numeric_ord-eql_v3_json_entry]
Operator wrapper for public.eql\_v3\_json\_entry.
Parameters [#parameters-791]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a eql_v3.` | `query_numeric_ord` | |
| `b public.` | `eql_v3_json_entry` | |
Returns [#returns-788]
**Type:** `boolean`
boolean
***
lte(eql_v3_json_entry, query_numeric_ord) [#lteeql_v3_json_entry-query_numeric_ord]
Operator wrapper for public.eql\_v3\_json\_entry.
Parameters [#parameters-792]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a public.` | `eql_v3_json_entry` | |
| `b eql_v3.` | `query_numeric_ord` | |
Returns [#returns-789]
**Type:** `boolean`
boolean
***
lte(jsonb, eql_v3_double_ord_ore) [#ltejsonb-eql_v3_double_ord_ore]
Operator wrapper for public.eql\_v3\_double\_ord\_ore.
Parameters [#parameters-793]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_double_ord_ore` | |
Returns [#returns-790]
**Type:** `boolean`
boolean
***
lte(eql_v3_double_ord_ore, jsonb) [#lteeql_v3_double_ord_ore-jsonb]
Operator wrapper for public.eql\_v3\_double\_ord\_ore.
Parameters [#parameters-794]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a public.` | `eql_v3_double_ord_ore` | |
| `b` | `jsonb` | |
Returns [#returns-791]
**Type:** `boolean`
boolean
***
lte(eql_v3_double_ord_ore, eql_v3_double_ord_ore) [#lteeql_v3_double_ord_ore-eql_v3_double_ord_ore]
Operator wrapper for public.eql\_v3\_double\_ord\_ore.
Parameters [#parameters-795]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a public.` | `eql_v3_double_ord_ore` | |
| `b public.` | `eql_v3_double_ord_ore` | |
Returns [#returns-792]
**Type:** `boolean`
boolean
***
lte(jsonb, eql_v3_bigint_ord) [#ltejsonb-eql_v3_bigint_ord]
Operator wrapper for public.eql\_v3\_bigint\_ord.
Parameters [#parameters-796]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_bigint_ord` | |
Returns [#returns-793]
**Type:** `boolean`
boolean
***
lte(eql_v3_bigint_ord, jsonb) [#lteeql_v3_bigint_ord-jsonb]
Operator wrapper for public.eql\_v3\_bigint\_ord.
Parameters [#parameters-797]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a public.` | `eql_v3_bigint_ord` | |
| `b` | `jsonb` | |
Returns [#returns-794]
**Type:** `boolean`
boolean
***
lte(eql_v3_bigint_ord, eql_v3_bigint_ord) [#lteeql_v3_bigint_ord-eql_v3_bigint_ord]
Operator wrapper for public.eql\_v3\_bigint\_ord.
Parameters [#parameters-798]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a public.` | `eql_v3_bigint_ord` | |
| `b public.` | `eql_v3_bigint_ord` | |
Returns [#returns-795]
**Type:** `boolean`
boolean
***
lte(query_text_ord, eql_v3_json_entry) [#ltequery_text_ord-eql_v3_json_entry]
Operator wrapper for public.eql\_v3\_json\_entry.
Unsupported operator blocker for public.eql\_v3\_json\_entry.
Parameters [#parameters-799]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a eql_v3.` | `query_text_ord` | |
| `b public.` | `eql_v3_json_entry` | |
Returns [#returns-796]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lte(eql_v3_json_entry, query_text_ord) [#lteeql_v3_json_entry-query_text_ord]
Operator wrapper for public.eql\_v3\_json\_entry.
Unsupported operator blocker for public.eql\_v3\_json\_entry.
Parameters [#parameters-800]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a public.` | `eql_v3_json_entry` | |
| `b eql_v3.` | `query_text_ord` | |
Returns [#returns-797]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lte(query_timestamp_ord_ope, eql_v3_timestamp_ord_ope) [#ltequery_timestamp_ord_ope-eql_v3_timestamp_ord_ope]
Operator wrapper for eql\_v3.query\_timestamp\_ord\_ope.
Parameters [#parameters-801]
| Name | Type | Description |
| ----------- | -------------------------- | ----------- |
| `a eql_v3.` | `query_timestamp_ord_ope` | |
| `b public.` | `eql_v3_timestamp_ord_ope` | |
Returns [#returns-798]
**Type:** `boolean`
boolean
***
lte(eql_v3_timestamp_ord_ope, query_timestamp_ord_ope) [#lteeql_v3_timestamp_ord_ope-query_timestamp_ord_ope]
Operator wrapper for eql\_v3.query\_timestamp\_ord\_ope.
Parameters [#parameters-802]
| Name | Type | Description |
| ----------- | -------------------------- | ----------- |
| `a public.` | `eql_v3_timestamp_ord_ope` | |
| `b eql_v3.` | `query_timestamp_ord_ope` | |
Returns [#returns-799]
**Type:** `boolean`
boolean
***
lte(query_numeric_ord, eql_v3_numeric_ord) [#ltequery_numeric_ord-eql_v3_numeric_ord]
Operator wrapper for eql\_v3.query\_numeric\_ord.
Parameters [#parameters-803]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a eql_v3.` | `query_numeric_ord` | |
| `b public.` | `eql_v3_numeric_ord` | |
Returns [#returns-800]
**Type:** `boolean`
boolean
***
lte(eql_v3_numeric_ord, query_numeric_ord) [#lteeql_v3_numeric_ord-query_numeric_ord]
Operator wrapper for eql\_v3.query\_numeric\_ord.
Parameters [#parameters-804]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a public.` | `eql_v3_numeric_ord` | |
| `b eql_v3.` | `query_numeric_ord` | |
Returns [#returns-801]
**Type:** `boolean`
boolean
***
lte(jsonb, eql_v3_text_search_ore) [#ltejsonb-eql_v3_text_search_ore]
Operator wrapper for public.eql\_v3\_text\_search\_ore.
Parameters [#parameters-805]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_text_search_ore` | |
Returns [#returns-802]
**Type:** `boolean`
boolean
***
lte(eql_v3_text_search_ore, jsonb) [#lteeql_v3_text_search_ore-jsonb]
Operator wrapper for public.eql\_v3\_text\_search\_ore.
Parameters [#parameters-806]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a public.` | `eql_v3_text_search_ore` | |
| `b` | `jsonb` | |
Returns [#returns-803]
**Type:** `boolean`
boolean
***
lte(eql_v3_text_search_ore, eql_v3_text_search_ore) [#lteeql_v3_text_search_ore-eql_v3_text_search_ore]
Operator wrapper for public.eql\_v3\_text\_search\_ore.
Parameters [#parameters-807]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a public.` | `eql_v3_text_search_ore` | |
| `b public.` | `eql_v3_text_search_ore` | |
Returns [#returns-804]
**Type:** `boolean`
boolean
***
lte(query_real_ord_ope, eql_v3_real_ord_ope) [#ltequery_real_ord_ope-eql_v3_real_ord_ope]
Operator wrapper for eql\_v3.query\_real\_ord\_ope.
Parameters [#parameters-808]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a eql_v3.` | `query_real_ord_ope` | |
| `b public.` | `eql_v3_real_ord_ope` | |
Returns [#returns-805]
**Type:** `boolean`
boolean
***
lte(eql_v3_real_ord_ope, query_real_ord_ope) [#lteeql_v3_real_ord_ope-query_real_ord_ope]
Operator wrapper for eql\_v3.query\_real\_ord\_ope.
Parameters [#parameters-809]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_real_ord_ope` | |
| `b eql_v3.` | `query_real_ord_ope` | |
Returns [#returns-806]
**Type:** `boolean`
boolean
***
lte(jsonb, eql_v3_timestamp_ord) [#ltejsonb-eql_v3_timestamp_ord]
Operator wrapper for public.eql\_v3\_timestamp\_ord.
Parameters [#parameters-810]
| Name | Type | Description |
| ----------- | ---------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_timestamp_ord` | |
Returns [#returns-807]
**Type:** `boolean`
boolean
***
lte(eql_v3_timestamp_ord, jsonb) [#lteeql_v3_timestamp_ord-jsonb]
Operator wrapper for public.eql\_v3\_timestamp\_ord.
Parameters [#parameters-811]
| Name | Type | Description |
| ----------- | ---------------------- | ----------- |
| `a public.` | `eql_v3_timestamp_ord` | |
| `b` | `jsonb` | |
Returns [#returns-808]
**Type:** `boolean`
boolean
***
lte(eql_v3_timestamp_ord, eql_v3_timestamp_ord) [#lteeql_v3_timestamp_ord-eql_v3_timestamp_ord]
Operator wrapper for public.eql\_v3\_timestamp\_ord.
Parameters [#parameters-812]
| Name | Type | Description |
| ----------- | ---------------------- | ----------- |
| `a public.` | `eql_v3_timestamp_ord` | |
| `b public.` | `eql_v3_timestamp_ord` | |
Returns [#returns-809]
**Type:** `boolean`
boolean
***
lte(jsonb, eql_v3_smallint_ord_ope) [#ltejsonb-eql_v3_smallint_ord_ope]
Operator wrapper for public.eql\_v3\_smallint\_ord\_ope.
Parameters [#parameters-813]
| Name | Type | Description |
| ----------- | ------------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_smallint_ord_ope` | |
Returns [#returns-810]
**Type:** `boolean`
boolean
***
lte(eql_v3_smallint_ord_ope, jsonb) [#lteeql_v3_smallint_ord_ope-jsonb]
Operator wrapper for public.eql\_v3\_smallint\_ord\_ope.
Parameters [#parameters-814]
| Name | Type | Description |
| ----------- | ------------------------- | ----------- |
| `a public.` | `eql_v3_smallint_ord_ope` | |
| `b` | `jsonb` | |
Returns [#returns-811]
**Type:** `boolean`
boolean
***
lte(eql_v3_smallint_ord_ope, eql_v3_smallint_ord_ope) [#lteeql_v3_smallint_ord_ope-eql_v3_smallint_ord_ope]
Operator wrapper for public.eql\_v3\_smallint\_ord\_ope.
Parameters [#parameters-815]
| Name | Type | Description |
| ----------- | ------------------------- | ----------- |
| `a public.` | `eql_v3_smallint_ord_ope` | |
| `b public.` | `eql_v3_smallint_ord_ope` | |
Returns [#returns-812]
**Type:** `boolean`
boolean
***
lte(query_integer_ord, eql_v3_json_entry) [#ltequery_integer_ord-eql_v3_json_entry]
Operator wrapper for public.eql\_v3\_json\_entry.
Parameters [#parameters-816]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a eql_v3.` | `query_integer_ord` | |
| `b public.` | `eql_v3_json_entry` | |
Returns [#returns-813]
**Type:** `boolean`
boolean
***
lte(eql_v3_json_entry, query_integer_ord) [#lteeql_v3_json_entry-query_integer_ord]
Operator wrapper for public.eql\_v3\_json\_entry.
Parameters [#parameters-817]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a public.` | `eql_v3_json_entry` | |
| `b eql_v3.` | `query_integer_ord` | |
Returns [#returns-814]
**Type:** `boolean`
boolean
***
lte(query_real_ord, eql_v3_json_entry) [#ltequery_real_ord-eql_v3_json_entry]
Operator wrapper for public.eql\_v3\_json\_entry.
Parameters [#parameters-818]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a eql_v3.` | `query_real_ord` | |
| `b public.` | `eql_v3_json_entry` | |
Returns [#returns-815]
**Type:** `boolean`
boolean
***
lte(eql_v3_json_entry, query_real_ord) [#lteeql_v3_json_entry-query_real_ord]
Operator wrapper for public.eql\_v3\_json\_entry.
Parameters [#parameters-819]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a public.` | `eql_v3_json_entry` | |
| `b eql_v3.` | `query_real_ord` | |
Returns [#returns-816]
**Type:** `boolean`
boolean
***
lte(query_double_ord, eql_v3_double_ord) [#ltequery_double_ord-eql_v3_double_ord]
Operator wrapper for eql\_v3.query\_double\_ord.
Parameters [#parameters-820]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a eql_v3.` | `query_double_ord` | |
| `b public.` | `eql_v3_double_ord` | |
Returns [#returns-817]
**Type:** `boolean`
boolean
***
lte(eql_v3_double_ord, query_double_ord) [#lteeql_v3_double_ord-query_double_ord]
Operator wrapper for eql\_v3.query\_double\_ord.
Parameters [#parameters-821]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a public.` | `eql_v3_double_ord` | |
| `b eql_v3.` | `query_double_ord` | |
Returns [#returns-818]
**Type:** `boolean`
boolean
***
lte(query_double_ord_ore, eql_v3_double_ord_ore) [#ltequery_double_ord_ore-eql_v3_double_ord_ore]
Operator wrapper for eql\_v3.query\_double\_ord\_ore.
Parameters [#parameters-822]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a eql_v3.` | `query_double_ord_ore` | |
| `b public.` | `eql_v3_double_ord_ore` | |
Returns [#returns-819]
**Type:** `boolean`
boolean
***
lte(eql_v3_double_ord_ore, query_double_ord_ore) [#lteeql_v3_double_ord_ore-query_double_ord_ore]
Operator wrapper for eql\_v3.query\_double\_ord\_ore.
Parameters [#parameters-823]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a public.` | `eql_v3_double_ord_ore` | |
| `b eql_v3.` | `query_double_ord_ore` | |
Returns [#returns-820]
**Type:** `boolean`
boolean
***
lte(jsonb, eql_v3_timestamp_ord_ore) [#ltejsonb-eql_v3_timestamp_ord_ore]
Operator wrapper for public.eql\_v3\_timestamp\_ord\_ore.
Parameters [#parameters-824]
| Name | Type | Description |
| ----------- | -------------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_timestamp_ord_ore` | |
Returns [#returns-821]
**Type:** `boolean`
boolean
***
lte(eql_v3_timestamp_ord_ore, jsonb) [#lteeql_v3_timestamp_ord_ore-jsonb]
Operator wrapper for public.eql\_v3\_timestamp\_ord\_ore.
Parameters [#parameters-825]
| Name | Type | Description |
| ----------- | -------------------------- | ----------- |
| `a public.` | `eql_v3_timestamp_ord_ore` | |
| `b` | `jsonb` | |
Returns [#returns-822]
**Type:** `boolean`
boolean
***
lte(eql_v3_timestamp_ord_ore, eql_v3_timestamp_ord_ore) [#lteeql_v3_timestamp_ord_ore-eql_v3_timestamp_ord_ore]
Operator wrapper for public.eql\_v3\_timestamp\_ord\_ore.
Parameters [#parameters-826]
| Name | Type | Description |
| ----------- | -------------------------- | ----------- |
| `a public.` | `eql_v3_timestamp_ord_ore` | |
| `b public.` | `eql_v3_timestamp_ord_ore` | |
Returns [#returns-823]
**Type:** `boolean`
boolean
***
lte(jsonb, eql_v3_text_search) [#ltejsonb-eql_v3_text_search]
Operator wrapper for public.eql\_v3\_text\_search.
Parameters [#parameters-827]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_text_search` | |
Returns [#returns-824]
**Type:** `boolean`
boolean
***
lte(eql_v3_text_search, jsonb) [#lteeql_v3_text_search-jsonb]
Operator wrapper for public.eql\_v3\_text\_search.
Parameters [#parameters-828]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a public.` | `eql_v3_text_search` | |
| `b` | `jsonb` | |
Returns [#returns-825]
**Type:** `boolean`
boolean
***
lte(eql_v3_text_search, eql_v3_text_search) [#lteeql_v3_text_search-eql_v3_text_search]
Operator wrapper for public.eql\_v3\_text\_search.
Parameters [#parameters-829]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a public.` | `eql_v3_text_search` | |
| `b public.` | `eql_v3_text_search` | |
Returns [#returns-826]
**Type:** `boolean`
boolean
***
lte(query_numeric_ord_ore, eql_v3_numeric_ord_ore) [#ltequery_numeric_ord_ore-eql_v3_numeric_ord_ore]
Operator wrapper for eql\_v3.query\_numeric\_ord\_ore.
Parameters [#parameters-830]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a eql_v3.` | `query_numeric_ord_ore` | |
| `b public.` | `eql_v3_numeric_ord_ore` | |
Returns [#returns-827]
**Type:** `boolean`
boolean
***
lte(eql_v3_numeric_ord_ore, query_numeric_ord_ore) [#lteeql_v3_numeric_ord_ore-query_numeric_ord_ore]
Operator wrapper for eql\_v3.query\_numeric\_ord\_ore.
Parameters [#parameters-831]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a public.` | `eql_v3_numeric_ord_ore` | |
| `b eql_v3.` | `query_numeric_ord_ore` | |
Returns [#returns-828]
**Type:** `boolean`
boolean
***
lte(query_bigint_ord_ore, eql_v3_bigint_ord_ore) [#ltequery_bigint_ord_ore-eql_v3_bigint_ord_ore]
Operator wrapper for eql\_v3.query\_bigint\_ord\_ore.
Parameters [#parameters-832]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a eql_v3.` | `query_bigint_ord_ore` | |
| `b public.` | `eql_v3_bigint_ord_ore` | |
Returns [#returns-829]
**Type:** `boolean`
boolean
***
lte(eql_v3_bigint_ord_ore, query_bigint_ord_ore) [#lteeql_v3_bigint_ord_ore-query_bigint_ord_ore]
Operator wrapper for eql\_v3.query\_bigint\_ord\_ore.
Parameters [#parameters-833]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a public.` | `eql_v3_bigint_ord_ore` | |
| `b eql_v3.` | `query_bigint_ord_ore` | |
Returns [#returns-830]
**Type:** `boolean`
boolean
***
lte(query_bigint_ord_ope, eql_v3_bigint_ord_ope) [#ltequery_bigint_ord_ope-eql_v3_bigint_ord_ope]
Operator wrapper for eql\_v3.query\_bigint\_ord\_ope.
Parameters [#parameters-834]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a eql_v3.` | `query_bigint_ord_ope` | |
| `b public.` | `eql_v3_bigint_ord_ope` | |
Returns [#returns-831]
**Type:** `boolean`
boolean
***
lte(eql_v3_bigint_ord_ope, query_bigint_ord_ope) [#lteeql_v3_bigint_ord_ope-query_bigint_ord_ope]
Operator wrapper for eql\_v3.query\_bigint\_ord\_ope.
Parameters [#parameters-835]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a public.` | `eql_v3_bigint_ord_ope` | |
| `b eql_v3.` | `query_bigint_ord_ope` | |
Returns [#returns-832]
**Type:** `boolean`
boolean
***
lte(query_date_ord_ore, eql_v3_date_ord_ore) [#ltequery_date_ord_ore-eql_v3_date_ord_ore]
Operator wrapper for eql\_v3.query\_date\_ord\_ore.
Parameters [#parameters-836]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a eql_v3.` | `query_date_ord_ore` | |
| `b public.` | `eql_v3_date_ord_ore` | |
Returns [#returns-833]
**Type:** `boolean`
boolean
***
lte(eql_v3_date_ord_ore, query_date_ord_ore) [#lteeql_v3_date_ord_ore-query_date_ord_ore]
Operator wrapper for eql\_v3.query\_date\_ord\_ore.
Parameters [#parameters-837]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_date_ord_ore` | |
| `b eql_v3.` | `query_date_ord_ore` | |
Returns [#returns-834]
**Type:** `boolean`
boolean
***
lte(query_smallint_ord_ope, eql_v3_smallint_ord_ope) [#ltequery_smallint_ord_ope-eql_v3_smallint_ord_ope]
Operator wrapper for eql\_v3.query\_smallint\_ord\_ope.
Parameters [#parameters-838]
| Name | Type | Description |
| ----------- | ------------------------- | ----------- |
| `a eql_v3.` | `query_smallint_ord_ope` | |
| `b public.` | `eql_v3_smallint_ord_ope` | |
Returns [#returns-835]
**Type:** `boolean`
boolean
***
lte(eql_v3_smallint_ord_ope, query_smallint_ord_ope) [#lteeql_v3_smallint_ord_ope-query_smallint_ord_ope]
Operator wrapper for eql\_v3.query\_smallint\_ord\_ope.
Parameters [#parameters-839]
| Name | Type | Description |
| ----------- | ------------------------- | ----------- |
| `a public.` | `eql_v3_smallint_ord_ope` | |
| `b eql_v3.` | `query_smallint_ord_ope` | |
Returns [#returns-836]
**Type:** `boolean`
boolean
***
lte(jsonb, eql_v3_double_ord) [#ltejsonb-eql_v3_double_ord]
Operator wrapper for public.eql\_v3\_double\_ord.
Parameters [#parameters-840]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_double_ord` | |
Returns [#returns-837]
**Type:** `boolean`
boolean
***
lte(eql_v3_double_ord, jsonb) [#lteeql_v3_double_ord-jsonb]
Operator wrapper for public.eql\_v3\_double\_ord.
Parameters [#parameters-841]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a public.` | `eql_v3_double_ord` | |
| `b` | `jsonb` | |
Returns [#returns-838]
**Type:** `boolean`
boolean
***
lte(eql_v3_double_ord, eql_v3_double_ord) [#lteeql_v3_double_ord-eql_v3_double_ord]
Operator wrapper for public.eql\_v3\_double\_ord.
Parameters [#parameters-842]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a public.` | `eql_v3_double_ord` | |
| `b public.` | `eql_v3_double_ord` | |
Returns [#returns-839]
**Type:** `boolean`
boolean
***
lte(query_numeric_ord_ope, eql_v3_numeric_ord_ope) [#ltequery_numeric_ord_ope-eql_v3_numeric_ord_ope]
Operator wrapper for eql\_v3.query\_numeric\_ord\_ope.
Parameters [#parameters-843]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a eql_v3.` | `query_numeric_ord_ope` | |
| `b public.` | `eql_v3_numeric_ord_ope` | |
Returns [#returns-840]
**Type:** `boolean`
boolean
***
lte(eql_v3_numeric_ord_ope, query_numeric_ord_ope) [#lteeql_v3_numeric_ord_ope-query_numeric_ord_ope]
Operator wrapper for eql\_v3.query\_numeric\_ord\_ope.
Parameters [#parameters-844]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a public.` | `eql_v3_numeric_ord_ope` | |
| `b eql_v3.` | `query_numeric_ord_ope` | |
Returns [#returns-841]
**Type:** `boolean`
boolean
***
lte(jsonb, eql_v3_double_ord_ope) [#ltejsonb-eql_v3_double_ord_ope]
Operator wrapper for public.eql\_v3\_double\_ord\_ope.
Parameters [#parameters-845]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_double_ord_ope` | |
Returns [#returns-842]
**Type:** `boolean`
boolean
***
lte(eql_v3_double_ord_ope, jsonb) [#lteeql_v3_double_ord_ope-jsonb]
Operator wrapper for public.eql\_v3\_double\_ord\_ope.
Parameters [#parameters-846]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a public.` | `eql_v3_double_ord_ope` | |
| `b` | `jsonb` | |
Returns [#returns-843]
**Type:** `boolean`
boolean
***
lte(eql_v3_double_ord_ope, eql_v3_double_ord_ope) [#lteeql_v3_double_ord_ope-eql_v3_double_ord_ope]
Operator wrapper for public.eql\_v3\_double\_ord\_ope.
Parameters [#parameters-847]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a public.` | `eql_v3_double_ord_ope` | |
| `b public.` | `eql_v3_double_ord_ope` | |
Returns [#returns-844]
**Type:** `boolean`
boolean
***
lte(jsonb, eql_v3_numeric_ord_ope) [#ltejsonb-eql_v3_numeric_ord_ope]
Operator wrapper for public.eql\_v3\_numeric\_ord\_ope.
Parameters [#parameters-848]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_numeric_ord_ope` | |
Returns [#returns-845]
**Type:** `boolean`
boolean
***
lte(eql_v3_numeric_ord_ope, jsonb) [#lteeql_v3_numeric_ord_ope-jsonb]
Operator wrapper for public.eql\_v3\_numeric\_ord\_ope.
Parameters [#parameters-849]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a public.` | `eql_v3_numeric_ord_ope` | |
| `b` | `jsonb` | |
Returns [#returns-846]
**Type:** `boolean`
boolean
***
lte(eql_v3_numeric_ord_ope, eql_v3_numeric_ord_ope) [#lteeql_v3_numeric_ord_ope-eql_v3_numeric_ord_ope]
Operator wrapper for public.eql\_v3\_numeric\_ord\_ope.
Parameters [#parameters-850]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a public.` | `eql_v3_numeric_ord_ope` | |
| `b public.` | `eql_v3_numeric_ord_ope` | |
Returns [#returns-847]
**Type:** `boolean`
boolean
***
lte(jsonb, eql_v3_date_ord_ore) [#ltejsonb-eql_v3_date_ord_ore]
Operator wrapper for public.eql\_v3\_date\_ord\_ore.
Parameters [#parameters-851]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_date_ord_ore` | |
Returns [#returns-848]
**Type:** `boolean`
boolean
***
lte(eql_v3_date_ord_ore, jsonb) [#lteeql_v3_date_ord_ore-jsonb]
Operator wrapper for public.eql\_v3\_date\_ord\_ore.
Parameters [#parameters-852]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_date_ord_ore` | |
| `b` | `jsonb` | |
Returns [#returns-849]
**Type:** `boolean`
boolean
***
lte(eql_v3_date_ord_ore, eql_v3_date_ord_ore) [#lteeql_v3_date_ord_ore-eql_v3_date_ord_ore]
Operator wrapper for public.eql\_v3\_date\_ord\_ore.
Parameters [#parameters-853]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_date_ord_ore` | |
| `b public.` | `eql_v3_date_ord_ore` | |
Returns [#returns-850]
**Type:** `boolean`
boolean
***
lte(query_timestamp_ord, eql_v3_timestamp_ord) [#ltequery_timestamp_ord-eql_v3_timestamp_ord]
Operator wrapper for eql\_v3.query\_timestamp\_ord.
Parameters [#parameters-854]
| Name | Type | Description |
| ----------- | ---------------------- | ----------- |
| `a eql_v3.` | `query_timestamp_ord` | |
| `b public.` | `eql_v3_timestamp_ord` | |
Returns [#returns-851]
**Type:** `boolean`
boolean
***
lte(eql_v3_timestamp_ord, query_timestamp_ord) [#lteeql_v3_timestamp_ord-query_timestamp_ord]
Operator wrapper for eql\_v3.query\_timestamp\_ord.
Parameters [#parameters-855]
| Name | Type | Description |
| ----------- | ---------------------- | ----------- |
| `a public.` | `eql_v3_timestamp_ord` | |
| `b eql_v3.` | `query_timestamp_ord` | |
Returns [#returns-852]
**Type:** `boolean`
boolean
***
lte(jsonb, eql_v3_smallint_ord_ore) [#ltejsonb-eql_v3_smallint_ord_ore]
Operator wrapper for public.eql\_v3\_smallint\_ord\_ore.
Parameters [#parameters-856]
| Name | Type | Description |
| ----------- | ------------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_smallint_ord_ore` | |
Returns [#returns-853]
**Type:** `boolean`
boolean
***
lte(eql_v3_smallint_ord_ore, jsonb) [#lteeql_v3_smallint_ord_ore-jsonb]
Operator wrapper for public.eql\_v3\_smallint\_ord\_ore.
Parameters [#parameters-857]
| Name | Type | Description |
| ----------- | ------------------------- | ----------- |
| `a public.` | `eql_v3_smallint_ord_ore` | |
| `b` | `jsonb` | |
Returns [#returns-854]
**Type:** `boolean`
boolean
***
lte(eql_v3_smallint_ord_ore, eql_v3_smallint_ord_ore) [#lteeql_v3_smallint_ord_ore-eql_v3_smallint_ord_ore]
Operator wrapper for public.eql\_v3\_smallint\_ord\_ore.
Parameters [#parameters-858]
| Name | Type | Description |
| ----------- | ------------------------- | ----------- |
| `a public.` | `eql_v3_smallint_ord_ore` | |
| `b public.` | `eql_v3_smallint_ord_ore` | |
Returns [#returns-855]
**Type:** `boolean`
boolean
***
lte(jsonb, eql_v3_date_ord_ope) [#ltejsonb-eql_v3_date_ord_ope]
Operator wrapper for public.eql\_v3\_date\_ord\_ope.
Parameters [#parameters-859]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_date_ord_ope` | |
Returns [#returns-856]
**Type:** `boolean`
boolean
***
lte(eql_v3_date_ord_ope, jsonb) [#lteeql_v3_date_ord_ope-jsonb]
Operator wrapper for public.eql\_v3\_date\_ord\_ope.
Parameters [#parameters-860]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_date_ord_ope` | |
| `b` | `jsonb` | |
Returns [#returns-857]
**Type:** `boolean`
boolean
***
lte(eql_v3_date_ord_ope, eql_v3_date_ord_ope) [#lteeql_v3_date_ord_ope-eql_v3_date_ord_ope]
Operator wrapper for public.eql\_v3\_date\_ord\_ope.
Parameters [#parameters-861]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_date_ord_ope` | |
| `b public.` | `eql_v3_date_ord_ope` | |
Returns [#returns-858]
**Type:** `boolean`
boolean
***
lte(query_bigint_ord, eql_v3_bigint_ord) [#ltequery_bigint_ord-eql_v3_bigint_ord]
Operator wrapper for eql\_v3.query\_bigint\_ord.
Parameters [#parameters-862]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a eql_v3.` | `query_bigint_ord` | |
| `b public.` | `eql_v3_bigint_ord` | |
Returns [#returns-859]
**Type:** `boolean`
boolean
***
lte(eql_v3_bigint_ord, query_bigint_ord) [#lteeql_v3_bigint_ord-query_bigint_ord]
Operator wrapper for eql\_v3.query\_bigint\_ord.
Parameters [#parameters-863]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a public.` | `eql_v3_bigint_ord` | |
| `b eql_v3.` | `query_bigint_ord` | |
Returns [#returns-860]
**Type:** `boolean`
boolean
***
lte(jsonb, eql_v3_text_ord_ore) [#ltejsonb-eql_v3_text_ord_ore]
Operator wrapper for public.eql\_v3\_text\_ord\_ore.
Parameters [#parameters-864]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_text_ord_ore` | |
Returns [#returns-861]
**Type:** `boolean`
boolean
***
lte(eql_v3_text_ord_ore, jsonb) [#lteeql_v3_text_ord_ore-jsonb]
Operator wrapper for public.eql\_v3\_text\_ord\_ore.
Parameters [#parameters-865]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_text_ord_ore` | |
| `b` | `jsonb` | |
Returns [#returns-862]
**Type:** `boolean`
boolean
***
lte(eql_v3_text_ord_ore, eql_v3_text_ord_ore) [#lteeql_v3_text_ord_ore-eql_v3_text_ord_ore]
Operator wrapper for public.eql\_v3\_text\_ord\_ore.
Parameters [#parameters-866]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_text_ord_ore` | |
| `b public.` | `eql_v3_text_ord_ore` | |
Returns [#returns-863]
**Type:** `boolean`
boolean
***
lte(query_bigint_ord, eql_v3_json_entry) [#ltequery_bigint_ord-eql_v3_json_entry]
Operator wrapper for public.eql\_v3\_json\_entry.
Unsupported operator blocker for public.eql\_v3\_json\_entry.
Parameters [#parameters-867]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a eql_v3.` | `query_bigint_ord` | |
| `b public.` | `eql_v3_json_entry` | |
Returns [#returns-864]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lte(eql_v3_json_entry, query_bigint_ord) [#lteeql_v3_json_entry-query_bigint_ord]
Operator wrapper for public.eql\_v3\_json\_entry.
Unsupported operator blocker for public.eql\_v3\_json\_entry.
Parameters [#parameters-868]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a public.` | `eql_v3_json_entry` | |
| `b eql_v3.` | `query_bigint_ord` | |
Returns [#returns-865]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
match_term(query_text_search) [#match_termquery_text_search]
Index extractor for eql\_v3.query\_text\_search.
Parameters [#parameters-869]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a eql_v3.` | `query_text_search` | |
Returns [#returns-866]
**Type:** `eql_v3_internal.bloom_filter`
eql\_v3\_internal.bloom\_filter
***
match_term(query_text_search_ore) [#match_termquery_text_search_ore]
Index extractor for eql\_v3.query\_text\_search\_ore.
Parameters [#parameters-870]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a eql_v3.` | `query_text_search_ore` | |
Returns [#returns-867]
**Type:** `eql_v3_internal.bloom_filter`
eql\_v3\_internal.bloom\_filter
***
match_term(query_text_match) [#match_termquery_text_match]
Index extractor for eql\_v3.query\_text\_match.
Parameters [#parameters-871]
| Name | Type | Description |
| ----------- | ------------------ | ----------- |
| `a eql_v3.` | `query_text_match` | |
Returns [#returns-868]
**Type:** `eql_v3_internal.bloom_filter`
eql\_v3\_internal.bloom\_filter
***
match_term(eql_v3_text_search_ore) [#match_termeql_v3_text_search_ore]
Index extractor for public.eql\_v3\_text\_search\_ore.
Parameters [#parameters-872]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a public.` | `eql_v3_text_search_ore` | |
Returns [#returns-869]
**Type:** `eql_v3_internal.bloom_filter`
eql\_v3\_internal.bloom\_filter
***
match_term(eql_v3_text_match) [#match_termeql_v3_text_match]
Index extractor for public.eql\_v3\_text\_match.
Parameters [#parameters-873]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a public.` | `eql_v3_text_match` | |
Returns [#returns-870]
**Type:** `eql_v3_internal.bloom_filter`
eql\_v3\_internal.bloom\_filter
***
match_term(eql_v3_text_search) [#match_termeql_v3_text_search]
Index extractor for public.eql\_v3\_text\_search.
Parameters [#parameters-874]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a public.` | `eql_v3_text_search` | |
Returns [#returns-871]
**Type:** `eql_v3_internal.bloom_filter`
eql\_v3\_internal.bloom\_filter
***
matches(query_text_search, eql_v3_text_search) [#matchesquery_text_search-eql_v3_text_search]
Operator wrapper for eql\_v3.query\_text\_search.
Parameters [#parameters-875]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a eql_v3.` | `query_text_search` | |
| `b public.` | `eql_v3_text_search` | |
Returns [#returns-872]
**Type:** `boolean`
boolean
***
matches(eql_v3_text_search, query_text_search) [#matcheseql_v3_text_search-query_text_search]
Operator wrapper for eql\_v3.query\_text\_search.
Parameters [#parameters-876]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a public.` | `eql_v3_text_search` | |
| `b eql_v3.` | `query_text_search` | |
Returns [#returns-873]
**Type:** `boolean`
boolean
***
matches(query_text_search_ore, eql_v3_text_search_ore) [#matchesquery_text_search_ore-eql_v3_text_search_ore]
Operator wrapper for eql\_v3.query\_text\_search\_ore.
Parameters [#parameters-877]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a eql_v3.` | `query_text_search_ore` | |
| `b public.` | `eql_v3_text_search_ore` | |
Returns [#returns-874]
**Type:** `boolean`
boolean
***
matches(eql_v3_text_search_ore, query_text_search_ore) [#matcheseql_v3_text_search_ore-query_text_search_ore]
Operator wrapper for eql\_v3.query\_text\_search\_ore.
Parameters [#parameters-878]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a public.` | `eql_v3_text_search_ore` | |
| `b eql_v3.` | `query_text_search_ore` | |
Returns [#returns-875]
**Type:** `boolean`
boolean
***
matches(query_text_match, eql_v3_text_match) [#matchesquery_text_match-eql_v3_text_match]
Operator wrapper for eql\_v3.query\_text\_match.
Parameters [#parameters-879]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a eql_v3.` | `query_text_match` | |
| `b public.` | `eql_v3_text_match` | |
Returns [#returns-876]
**Type:** `boolean`
boolean
***
matches(eql_v3_text_match, query_text_match) [#matcheseql_v3_text_match-query_text_match]
Operator wrapper for eql\_v3.query\_text\_match.
Parameters [#parameters-880]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a public.` | `eql_v3_text_match` | |
| `b eql_v3.` | `query_text_match` | |
Returns [#returns-877]
**Type:** `boolean`
boolean
***
matches(jsonb, eql_v3_text_search_ore) [#matchesjsonb-eql_v3_text_search_ore]
Operator wrapper for public.eql\_v3\_text\_search\_ore.
Parameters [#parameters-881]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_text_search_ore` | |
Returns [#returns-878]
**Type:** `boolean`
boolean
***
matches(eql_v3_text_search_ore, jsonb) [#matcheseql_v3_text_search_ore-jsonb]
Operator wrapper for public.eql\_v3\_text\_search\_ore.
Parameters [#parameters-882]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a public.` | `eql_v3_text_search_ore` | |
| `b` | `jsonb` | |
Returns [#returns-879]
**Type:** `boolean`
boolean
***
matches(eql_v3_text_search_ore, eql_v3_text_search_ore) [#matcheseql_v3_text_search_ore-eql_v3_text_search_ore]
Operator wrapper for public.eql\_v3\_text\_search\_ore.
Parameters [#parameters-883]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a public.` | `eql_v3_text_search_ore` | |
| `b public.` | `eql_v3_text_search_ore` | |
Returns [#returns-880]
**Type:** `boolean`
boolean
***
matches(jsonb, eql_v3_text_match) [#matchesjsonb-eql_v3_text_match]
Operator wrapper for public.eql\_v3\_text\_match.
Parameters [#parameters-884]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_text_match` | |
Returns [#returns-881]
**Type:** `boolean`
boolean
***
matches(eql_v3_text_match, jsonb) [#matcheseql_v3_text_match-jsonb]
Operator wrapper for public.eql\_v3\_text\_match.
Parameters [#parameters-885]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a public.` | `eql_v3_text_match` | |
| `b` | `jsonb` | |
Returns [#returns-882]
**Type:** `boolean`
boolean
***
matches(eql_v3_text_match, eql_v3_text_match) [#matcheseql_v3_text_match-eql_v3_text_match]
Operator wrapper for public.eql\_v3\_text\_match.
Parameters [#parameters-886]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a public.` | `eql_v3_text_match` | |
| `b public.` | `eql_v3_text_match` | |
Returns [#returns-883]
**Type:** `boolean`
boolean
***
matches(jsonb, eql_v3_text_search) [#matchesjsonb-eql_v3_text_search]
Operator wrapper for public.eql\_v3\_text\_search.
Parameters [#parameters-887]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_text_search` | |
Returns [#returns-884]
**Type:** `boolean`
boolean
***
matches(eql_v3_text_search, jsonb) [#matcheseql_v3_text_search-jsonb]
Operator wrapper for public.eql\_v3\_text\_search.
Parameters [#parameters-888]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a public.` | `eql_v3_text_search` | |
| `b` | `jsonb` | |
Returns [#returns-885]
**Type:** `boolean`
boolean
***
matches(eql_v3_text_search, eql_v3_text_search) [#matcheseql_v3_text_search-eql_v3_text_search]
Operator wrapper for public.eql\_v3\_text\_search.
Parameters [#parameters-889]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a public.` | `eql_v3_text_search` | |
| `b public.` | `eql_v3_text_search` | |
Returns [#returns-886]
**Type:** `boolean`
boolean
***
max(public.eql_v3_bigint_ord_ope) [#maxpubliceql_v3_bigint_ord_ope]
max aggregate for public.eql\_v3\_bigint\_ord\_ope.
Parameters [#parameters-890]
| Name | Type | Description |
| ------- | ------------------------------ | ----------- |
| `input` | `public.eql_v3_bigint_ord_ope` | |
Returns [#returns-887]
**Type:** `public.eql_v3_bigint_ord_ope`
public.eql\_v3\_bigint\_ord\_ope
***
max(public.eql_v3_smallint_ord_ope) [#maxpubliceql_v3_smallint_ord_ope]
max aggregate for public.eql\_v3\_smallint\_ord\_ope.
Parameters [#parameters-891]
| Name | Type | Description |
| ------- | -------------------------------- | ----------- |
| `input` | `public.eql_v3_smallint_ord_ope` | |
Returns [#returns-888]
**Type:** `public.eql_v3_smallint_ord_ope`
public.eql\_v3\_smallint\_ord\_ope
***
max(public.eql_v3_numeric_ord) [#maxpubliceql_v3_numeric_ord]
max aggregate for public.eql\_v3\_numeric\_ord.
Parameters [#parameters-892]
| Name | Type | Description |
| ------- | --------------------------- | ----------- |
| `input` | `public.eql_v3_numeric_ord` | |
Returns [#returns-889]
**Type:** `public.eql_v3_numeric_ord`
public.eql\_v3\_numeric\_ord
***
max(public.eql_v3_real_ord_ore) [#maxpubliceql_v3_real_ord_ore]
max aggregate for public.eql\_v3\_real\_ord\_ore.
Parameters [#parameters-893]
| Name | Type | Description |
| ------- | ---------------------------- | ----------- |
| `input` | `public.eql_v3_real_ord_ore` | |
Returns [#returns-890]
**Type:** `public.eql_v3_real_ord_ore`
public.eql\_v3\_real\_ord\_ore
***
max(public.eql_v3_timestamp_ord_ore) [#maxpubliceql_v3_timestamp_ord_ore]
max aggregate for public.eql\_v3\_timestamp\_ord\_ore.
Parameters [#parameters-894]
| Name | Type | Description |
| ------- | --------------------------------- | ----------- |
| `input` | `public.eql_v3_timestamp_ord_ore` | |
Returns [#returns-891]
**Type:** `public.eql_v3_timestamp_ord_ore`
public.eql\_v3\_timestamp\_ord\_ore
***
max(public.eql_v3_real_ord_ope) [#maxpubliceql_v3_real_ord_ope]
max aggregate for public.eql\_v3\_real\_ord\_ope.
Parameters [#parameters-895]
| Name | Type | Description |
| ------- | ---------------------------- | ----------- |
| `input` | `public.eql_v3_real_ord_ope` | |
Returns [#returns-892]
**Type:** `public.eql_v3_real_ord_ope`
public.eql\_v3\_real\_ord\_ope
***
max(public.eql_v3_text_ord_ope) [#maxpubliceql_v3_text_ord_ope]
max aggregate for public.eql\_v3\_text\_ord\_ope.
Parameters [#parameters-896]
| Name | Type | Description |
| ------- | ---------------------------- | ----------- |
| `input` | `public.eql_v3_text_ord_ope` | |
Returns [#returns-893]
**Type:** `public.eql_v3_text_ord_ope`
public.eql\_v3\_text\_ord\_ope
***
max(public.eql_v3_double_ord_ope) [#maxpubliceql_v3_double_ord_ope]
max aggregate for public.eql\_v3\_double\_ord\_ope.
Parameters [#parameters-897]
| Name | Type | Description |
| ------- | ------------------------------ | ----------- |
| `input` | `public.eql_v3_double_ord_ope` | |
Returns [#returns-894]
**Type:** `public.eql_v3_double_ord_ope`
public.eql\_v3\_double\_ord\_ope
***
max(public.eql_v3_date_ord_ore) [#maxpubliceql_v3_date_ord_ore]
max aggregate for public.eql\_v3\_date\_ord\_ore.
Parameters [#parameters-898]
| Name | Type | Description |
| ------- | ---------------------------- | ----------- |
| `input` | `public.eql_v3_date_ord_ore` | |
Returns [#returns-895]
**Type:** `public.eql_v3_date_ord_ore`
public.eql\_v3\_date\_ord\_ore
***
max(public.eql_v3_integer_ord_ore) [#maxpubliceql_v3_integer_ord_ore]
max aggregate for public.eql\_v3\_integer\_ord\_ore.
Parameters [#parameters-899]
| Name | Type | Description |
| ------- | ------------------------------- | ----------- |
| `input` | `public.eql_v3_integer_ord_ore` | |
Returns [#returns-896]
**Type:** `public.eql_v3_integer_ord_ore`
public.eql\_v3\_integer\_ord\_ore
***
max(public.eql_v3_bigint_ord) [#maxpubliceql_v3_bigint_ord]
max aggregate for public.eql\_v3\_bigint\_ord.
Parameters [#parameters-900]
| Name | Type | Description |
| ------- | -------------------------- | ----------- |
| `input` | `public.eql_v3_bigint_ord` | |
Returns [#returns-897]
**Type:** `public.eql_v3_bigint_ord`
public.eql\_v3\_bigint\_ord
***
max(public.eql_v3_numeric_ord_ope) [#maxpubliceql_v3_numeric_ord_ope]
max aggregate for public.eql\_v3\_numeric\_ord\_ope.
Parameters [#parameters-901]
| Name | Type | Description |
| ------- | ------------------------------- | ----------- |
| `input` | `public.eql_v3_numeric_ord_ope` | |
Returns [#returns-898]
**Type:** `public.eql_v3_numeric_ord_ope`
public.eql\_v3\_numeric\_ord\_ope
***
max(public.eql_v3_numeric_ord_ore) [#maxpubliceql_v3_numeric_ord_ore]
max aggregate for public.eql\_v3\_numeric\_ord\_ore.
Parameters [#parameters-902]
| Name | Type | Description |
| ------- | ------------------------------- | ----------- |
| `input` | `public.eql_v3_numeric_ord_ore` | |
Returns [#returns-899]
**Type:** `public.eql_v3_numeric_ord_ore`
public.eql\_v3\_numeric\_ord\_ore
***
max(public.eql_v3_real_ord) [#maxpubliceql_v3_real_ord]
max aggregate for public.eql\_v3\_real\_ord.
Parameters [#parameters-903]
| Name | Type | Description |
| ------- | ------------------------ | ----------- |
| `input` | `public.eql_v3_real_ord` | |
Returns [#returns-900]
**Type:** `public.eql_v3_real_ord`
public.eql\_v3\_real\_ord
***
max(public.eql_v3_timestamp_ord_ope) [#maxpubliceql_v3_timestamp_ord_ope]
max aggregate for public.eql\_v3\_timestamp\_ord\_ope.
Parameters [#parameters-904]
| Name | Type | Description |
| ------- | --------------------------------- | ----------- |
| `input` | `public.eql_v3_timestamp_ord_ope` | |
Returns [#returns-901]
**Type:** `public.eql_v3_timestamp_ord_ope`
public.eql\_v3\_timestamp\_ord\_ope
***
max(public.eql_v3_smallint_ord) [#maxpubliceql_v3_smallint_ord]
max aggregate for public.eql\_v3\_smallint\_ord.
Parameters [#parameters-905]
| Name | Type | Description |
| ------- | ---------------------------- | ----------- |
| `input` | `public.eql_v3_smallint_ord` | |
Returns [#returns-902]
**Type:** `public.eql_v3_smallint_ord`
public.eql\_v3\_smallint\_ord
***
max(public.eql_v3_text_search_ore) [#maxpubliceql_v3_text_search_ore]
max aggregate for public.eql\_v3\_text\_search\_ore.
Parameters [#parameters-906]
| Name | Type | Description |
| ------- | ------------------------------- | ----------- |
| `input` | `public.eql_v3_text_search_ore` | |
Returns [#returns-903]
**Type:** `public.eql_v3_text_search_ore`
public.eql\_v3\_text\_search\_ore
***
max(public.eql_v3_integer_ord) [#maxpubliceql_v3_integer_ord]
max aggregate for public.eql\_v3\_integer\_ord.
Parameters [#parameters-907]
| Name | Type | Description |
| ------- | --------------------------- | ----------- |
| `input` | `public.eql_v3_integer_ord` | |
Returns [#returns-904]
**Type:** `public.eql_v3_integer_ord`
public.eql\_v3\_integer\_ord
***
max(public.eql_v3_integer_ord_ope) [#maxpubliceql_v3_integer_ord_ope]
max aggregate for public.eql\_v3\_integer\_ord\_ope.
Parameters [#parameters-908]
| Name | Type | Description |
| ------- | ------------------------------- | ----------- |
| `input` | `public.eql_v3_integer_ord_ope` | |
Returns [#returns-905]
**Type:** `public.eql_v3_integer_ord_ope`
public.eql\_v3\_integer\_ord\_ope
***
max(public.eql_v3_smallint_ord_ore) [#maxpubliceql_v3_smallint_ord_ore]
max aggregate for public.eql\_v3\_smallint\_ord\_ore.
Parameters [#parameters-909]
| Name | Type | Description |
| ------- | -------------------------------- | ----------- |
| `input` | `public.eql_v3_smallint_ord_ore` | |
Returns [#returns-906]
**Type:** `public.eql_v3_smallint_ord_ore`
public.eql\_v3\_smallint\_ord\_ore
***
max(public.eql_v3_json_entry) [#maxpubliceql_v3_json_entry]
max aggregate over public.eql\_v3\_json\_entry.
Parameters [#parameters-910]
| Name | Type | Description |
| ------- | -------------------------- | ----------- |
| `input` | `public.eql_v3_json_entry` | |
Returns [#returns-907]
**Type:** `public.eql_v3_json_entry`
public.eql\_v3\_json\_entry The entry with the largest CLLW OPE term.
***
max(public.eql_v3_date_ord) [#maxpubliceql_v3_date_ord]
max aggregate for public.eql\_v3\_date\_ord.
Parameters [#parameters-911]
| Name | Type | Description |
| ------- | ------------------------ | ----------- |
| `input` | `public.eql_v3_date_ord` | |
Returns [#returns-908]
**Type:** `public.eql_v3_date_ord`
public.eql\_v3\_date\_ord
***
max(public.eql_v3_text_ord_ore) [#maxpubliceql_v3_text_ord_ore]
max aggregate for public.eql\_v3\_text\_ord\_ore.
Parameters [#parameters-912]
| Name | Type | Description |
| ------- | ---------------------------- | ----------- |
| `input` | `public.eql_v3_text_ord_ore` | |
Returns [#returns-909]
**Type:** `public.eql_v3_text_ord_ore`
public.eql\_v3\_text\_ord\_ore
***
max(public.eql_v3_double_ord_ore) [#maxpubliceql_v3_double_ord_ore]
max aggregate for public.eql\_v3\_double\_ord\_ore.
Parameters [#parameters-913]
| Name | Type | Description |
| ------- | ------------------------------ | ----------- |
| `input` | `public.eql_v3_double_ord_ore` | |
Returns [#returns-910]
**Type:** `public.eql_v3_double_ord_ore`
public.eql\_v3\_double\_ord\_ore
***
max(public.eql_v3_timestamp_ord) [#maxpubliceql_v3_timestamp_ord]
max aggregate for public.eql\_v3\_timestamp\_ord.
Parameters [#parameters-914]
| Name | Type | Description |
| ------- | ----------------------------- | ----------- |
| `input` | `public.eql_v3_timestamp_ord` | |
Returns [#returns-911]
**Type:** `public.eql_v3_timestamp_ord`
public.eql\_v3\_timestamp\_ord
***
max(public.eql_v3_text_ord) [#maxpubliceql_v3_text_ord]
max aggregate for public.eql\_v3\_text\_ord.
Parameters [#parameters-915]
| Name | Type | Description |
| ------- | ------------------------ | ----------- |
| `input` | `public.eql_v3_text_ord` | |
Returns [#returns-912]
**Type:** `public.eql_v3_text_ord`
public.eql\_v3\_text\_ord
***
max(public.eql_v3_bigint_ord_ore) [#maxpubliceql_v3_bigint_ord_ore]
max aggregate for public.eql\_v3\_bigint\_ord\_ore.
Parameters [#parameters-916]
| Name | Type | Description |
| ------- | ------------------------------ | ----------- |
| `input` | `public.eql_v3_bigint_ord_ore` | |
Returns [#returns-913]
**Type:** `public.eql_v3_bigint_ord_ore`
public.eql\_v3\_bigint\_ord\_ore
***
max(public.eql_v3_text_search) [#maxpubliceql_v3_text_search]
max aggregate for public.eql\_v3\_text\_search.
Parameters [#parameters-917]
| Name | Type | Description |
| ------- | --------------------------- | ----------- |
| `input` | `public.eql_v3_text_search` | |
Returns [#returns-914]
**Type:** `public.eql_v3_text_search`
public.eql\_v3\_text\_search
***
max(public.eql_v3_double_ord) [#maxpubliceql_v3_double_ord]
max aggregate for public.eql\_v3\_double\_ord.
Parameters [#parameters-918]
| Name | Type | Description |
| ------- | -------------------------- | ----------- |
| `input` | `public.eql_v3_double_ord` | |
Returns [#returns-915]
**Type:** `public.eql_v3_double_ord`
public.eql\_v3\_double\_ord
***
max(public.eql_v3_date_ord_ope) [#maxpubliceql_v3_date_ord_ope]
max aggregate for public.eql\_v3\_date\_ord\_ope.
Parameters [#parameters-919]
| Name | Type | Description |
| ------- | ---------------------------- | ----------- |
| `input` | `public.eql_v3_date_ord_ope` | |
Returns [#returns-916]
**Type:** `public.eql_v3_date_ord_ope`
public.eql\_v3\_date\_ord\_ope
***
meta_data(jsonb) [#meta_datajsonb]
Extract envelope metadata (i, v, h) from a raw jsonb encrypted value.
h is the document's key header — hoisted once to the envelope because every sv entry encrypts under the document's single data key. Grafting it here (the same concat that already grafts i/v) is what keeps an extracted public.eql\_v3\_json\_entry self-contained decryptable: decryption needs the header plus the entry's own s (the nonce source) and c (the raw AEAD output). jsonb\_strip\_nulls drops the keys entirely on payloads that lack them (e.g. a raw scalar envelope has no h), rather than grafting JSON nulls.
Parameters [#parameters-920]
| Name | Type | Description |
| ----- | ------- | --------------------- |
| `val` | `jsonb` | encrypted EQL payload |
Returns [#returns-917]
**Type:** `jsonb`
jsonb Metadata object with i, v, and (for documents) h.
***
min(public.eql_v3_bigint_ord_ope) [#minpubliceql_v3_bigint_ord_ope]
min aggregate for public.eql\_v3\_bigint\_ord\_ope.
Parameters [#parameters-921]
| Name | Type | Description |
| ------- | ------------------------------ | ----------- |
| `input` | `public.eql_v3_bigint_ord_ope` | |
Returns [#returns-918]
**Type:** `public.eql_v3_bigint_ord_ope`
public.eql\_v3\_bigint\_ord\_ope
***
min(public.eql_v3_smallint_ord_ope) [#minpubliceql_v3_smallint_ord_ope]
min aggregate for public.eql\_v3\_smallint\_ord\_ope.
Parameters [#parameters-922]
| Name | Type | Description |
| ------- | -------------------------------- | ----------- |
| `input` | `public.eql_v3_smallint_ord_ope` | |
Returns [#returns-919]
**Type:** `public.eql_v3_smallint_ord_ope`
public.eql\_v3\_smallint\_ord\_ope
***
min(public.eql_v3_numeric_ord) [#minpubliceql_v3_numeric_ord]
min aggregate for public.eql\_v3\_numeric\_ord.
Parameters [#parameters-923]
| Name | Type | Description |
| ------- | --------------------------- | ----------- |
| `input` | `public.eql_v3_numeric_ord` | |
Returns [#returns-920]
**Type:** `public.eql_v3_numeric_ord`
public.eql\_v3\_numeric\_ord
***
min(public.eql_v3_real_ord_ore) [#minpubliceql_v3_real_ord_ore]
min aggregate for public.eql\_v3\_real\_ord\_ore.
Parameters [#parameters-924]
| Name | Type | Description |
| ------- | ---------------------------- | ----------- |
| `input` | `public.eql_v3_real_ord_ore` | |
Returns [#returns-921]
**Type:** `public.eql_v3_real_ord_ore`
public.eql\_v3\_real\_ord\_ore
***
min(public.eql_v3_timestamp_ord_ore) [#minpubliceql_v3_timestamp_ord_ore]
min aggregate for public.eql\_v3\_timestamp\_ord\_ore.
Parameters [#parameters-925]
| Name | Type | Description |
| ------- | --------------------------------- | ----------- |
| `input` | `public.eql_v3_timestamp_ord_ore` | |
Returns [#returns-922]
**Type:** `public.eql_v3_timestamp_ord_ore`
public.eql\_v3\_timestamp\_ord\_ore
***
min(public.eql_v3_real_ord_ope) [#minpubliceql_v3_real_ord_ope]
min aggregate for public.eql\_v3\_real\_ord\_ope.
Parameters [#parameters-926]
| Name | Type | Description |
| ------- | ---------------------------- | ----------- |
| `input` | `public.eql_v3_real_ord_ope` | |
Returns [#returns-923]
**Type:** `public.eql_v3_real_ord_ope`
public.eql\_v3\_real\_ord\_ope
***
min(public.eql_v3_text_ord_ope) [#minpubliceql_v3_text_ord_ope]
min aggregate for public.eql\_v3\_text\_ord\_ope.
Parameters [#parameters-927]
| Name | Type | Description |
| ------- | ---------------------------- | ----------- |
| `input` | `public.eql_v3_text_ord_ope` | |
Returns [#returns-924]
**Type:** `public.eql_v3_text_ord_ope`
public.eql\_v3\_text\_ord\_ope
***
min(public.eql_v3_double_ord_ope) [#minpubliceql_v3_double_ord_ope]
min aggregate for public.eql\_v3\_double\_ord\_ope.
Parameters [#parameters-928]
| Name | Type | Description |
| ------- | ------------------------------ | ----------- |
| `input` | `public.eql_v3_double_ord_ope` | |
Returns [#returns-925]
**Type:** `public.eql_v3_double_ord_ope`
public.eql\_v3\_double\_ord\_ope
***
min(public.eql_v3_date_ord_ore) [#minpubliceql_v3_date_ord_ore]
min aggregate for public.eql\_v3\_date\_ord\_ore.
Parameters [#parameters-929]
| Name | Type | Description |
| ------- | ---------------------------- | ----------- |
| `input` | `public.eql_v3_date_ord_ore` | |
Returns [#returns-926]
**Type:** `public.eql_v3_date_ord_ore`
public.eql\_v3\_date\_ord\_ore
***
min(public.eql_v3_integer_ord_ore) [#minpubliceql_v3_integer_ord_ore]
min aggregate for public.eql\_v3\_integer\_ord\_ore.
Parameters [#parameters-930]
| Name | Type | Description |
| ------- | ------------------------------- | ----------- |
| `input` | `public.eql_v3_integer_ord_ore` | |
Returns [#returns-927]
**Type:** `public.eql_v3_integer_ord_ore`
public.eql\_v3\_integer\_ord\_ore
***
min(public.eql_v3_bigint_ord) [#minpubliceql_v3_bigint_ord]
min aggregate for public.eql\_v3\_bigint\_ord.
Parameters [#parameters-931]
| Name | Type | Description |
| ------- | -------------------------- | ----------- |
| `input` | `public.eql_v3_bigint_ord` | |
Returns [#returns-928]
**Type:** `public.eql_v3_bigint_ord`
public.eql\_v3\_bigint\_ord
***
min(public.eql_v3_numeric_ord_ope) [#minpubliceql_v3_numeric_ord_ope]
min aggregate for public.eql\_v3\_numeric\_ord\_ope.
Parameters [#parameters-932]
| Name | Type | Description |
| ------- | ------------------------------- | ----------- |
| `input` | `public.eql_v3_numeric_ord_ope` | |
Returns [#returns-929]
**Type:** `public.eql_v3_numeric_ord_ope`
public.eql\_v3\_numeric\_ord\_ope
***
min(public.eql_v3_numeric_ord_ore) [#minpubliceql_v3_numeric_ord_ore]
min aggregate for public.eql\_v3\_numeric\_ord\_ore.
Parameters [#parameters-933]
| Name | Type | Description |
| ------- | ------------------------------- | ----------- |
| `input` | `public.eql_v3_numeric_ord_ore` | |
Returns [#returns-930]
**Type:** `public.eql_v3_numeric_ord_ore`
public.eql\_v3\_numeric\_ord\_ore
***
min(public.eql_v3_real_ord) [#minpubliceql_v3_real_ord]
min aggregate for public.eql\_v3\_real\_ord.
Parameters [#parameters-934]
| Name | Type | Description |
| ------- | ------------------------ | ----------- |
| `input` | `public.eql_v3_real_ord` | |
Returns [#returns-931]
**Type:** `public.eql_v3_real_ord`
public.eql\_v3\_real\_ord
***
min(public.eql_v3_timestamp_ord_ope) [#minpubliceql_v3_timestamp_ord_ope]
min aggregate for public.eql\_v3\_timestamp\_ord\_ope.
Parameters [#parameters-935]
| Name | Type | Description |
| ------- | --------------------------------- | ----------- |
| `input` | `public.eql_v3_timestamp_ord_ope` | |
Returns [#returns-932]
**Type:** `public.eql_v3_timestamp_ord_ope`
public.eql\_v3\_timestamp\_ord\_ope
***
min(public.eql_v3_smallint_ord) [#minpubliceql_v3_smallint_ord]
min aggregate for public.eql\_v3\_smallint\_ord.
Parameters [#parameters-936]
| Name | Type | Description |
| ------- | ---------------------------- | ----------- |
| `input` | `public.eql_v3_smallint_ord` | |
Returns [#returns-933]
**Type:** `public.eql_v3_smallint_ord`
public.eql\_v3\_smallint\_ord
***
min(public.eql_v3_text_search_ore) [#minpubliceql_v3_text_search_ore]
min aggregate for public.eql\_v3\_text\_search\_ore.
Parameters [#parameters-937]
| Name | Type | Description |
| ------- | ------------------------------- | ----------- |
| `input` | `public.eql_v3_text_search_ore` | |
Returns [#returns-934]
**Type:** `public.eql_v3_text_search_ore`
public.eql\_v3\_text\_search\_ore
***
min(public.eql_v3_integer_ord) [#minpubliceql_v3_integer_ord]
min aggregate for public.eql\_v3\_integer\_ord.
Parameters [#parameters-938]
| Name | Type | Description |
| ------- | --------------------------- | ----------- |
| `input` | `public.eql_v3_integer_ord` | |
Returns [#returns-935]
**Type:** `public.eql_v3_integer_ord`
public.eql\_v3\_integer\_ord
***
min(public.eql_v3_integer_ord_ope) [#minpubliceql_v3_integer_ord_ope]
min aggregate for public.eql\_v3\_integer\_ord\_ope.
Parameters [#parameters-939]
| Name | Type | Description |
| ------- | ------------------------------- | ----------- |
| `input` | `public.eql_v3_integer_ord_ope` | |
Returns [#returns-936]
**Type:** `public.eql_v3_integer_ord_ope`
public.eql\_v3\_integer\_ord\_ope
***
min(public.eql_v3_smallint_ord_ore) [#minpubliceql_v3_smallint_ord_ore]
min aggregate for public.eql\_v3\_smallint\_ord\_ore.
Parameters [#parameters-940]
| Name | Type | Description |
| ------- | -------------------------------- | ----------- |
| `input` | `public.eql_v3_smallint_ord_ore` | |
Returns [#returns-937]
**Type:** `public.eql_v3_smallint_ord_ore`
public.eql\_v3\_smallint\_ord\_ore
***
min(public.eql_v3_json_entry) [#minpubliceql_v3_json_entry]
min aggregate over public.eql\_v3\_json\_entry.
Parameters [#parameters-941]
| Name | Type | Description |
| ------- | -------------------------- | ----------- |
| `input` | `public.eql_v3_json_entry` | |
Returns [#returns-938]
**Type:** `public.eql_v3_json_entry`
public.eql\_v3\_json\_entry The entry with the smallest CLLW OPE term.
***
min(public.eql_v3_date_ord) [#minpubliceql_v3_date_ord]
min aggregate for public.eql\_v3\_date\_ord.
Parameters [#parameters-942]
| Name | Type | Description |
| ------- | ------------------------ | ----------- |
| `input` | `public.eql_v3_date_ord` | |
Returns [#returns-939]
**Type:** `public.eql_v3_date_ord`
public.eql\_v3\_date\_ord
***
min(public.eql_v3_text_ord_ore) [#minpubliceql_v3_text_ord_ore]
min aggregate for public.eql\_v3\_text\_ord\_ore.
Parameters [#parameters-943]
| Name | Type | Description |
| ------- | ---------------------------- | ----------- |
| `input` | `public.eql_v3_text_ord_ore` | |
Returns [#returns-940]
**Type:** `public.eql_v3_text_ord_ore`
public.eql\_v3\_text\_ord\_ore
***
min(public.eql_v3_double_ord_ore) [#minpubliceql_v3_double_ord_ore]
min aggregate for public.eql\_v3\_double\_ord\_ore.
Parameters [#parameters-944]
| Name | Type | Description |
| ------- | ------------------------------ | ----------- |
| `input` | `public.eql_v3_double_ord_ore` | |
Returns [#returns-941]
**Type:** `public.eql_v3_double_ord_ore`
public.eql\_v3\_double\_ord\_ore
***
min(public.eql_v3_timestamp_ord) [#minpubliceql_v3_timestamp_ord]
min aggregate for public.eql\_v3\_timestamp\_ord.
Parameters [#parameters-945]
| Name | Type | Description |
| ------- | ----------------------------- | ----------- |
| `input` | `public.eql_v3_timestamp_ord` | |
Returns [#returns-942]
**Type:** `public.eql_v3_timestamp_ord`
public.eql\_v3\_timestamp\_ord
***
min(public.eql_v3_text_ord) [#minpubliceql_v3_text_ord]
min aggregate for public.eql\_v3\_text\_ord.
Parameters [#parameters-946]
| Name | Type | Description |
| ------- | ------------------------ | ----------- |
| `input` | `public.eql_v3_text_ord` | |
Returns [#returns-943]
**Type:** `public.eql_v3_text_ord`
public.eql\_v3\_text\_ord
***
min(public.eql_v3_bigint_ord_ore) [#minpubliceql_v3_bigint_ord_ore]
min aggregate for public.eql\_v3\_bigint\_ord\_ore.
Parameters [#parameters-947]
| Name | Type | Description |
| ------- | ------------------------------ | ----------- |
| `input` | `public.eql_v3_bigint_ord_ore` | |
Returns [#returns-944]
**Type:** `public.eql_v3_bigint_ord_ore`
public.eql\_v3\_bigint\_ord\_ore
***
min(public.eql_v3_text_search) [#minpubliceql_v3_text_search]
min aggregate for public.eql\_v3\_text\_search.
Parameters [#parameters-948]
| Name | Type | Description |
| ------- | --------------------------- | ----------- |
| `input` | `public.eql_v3_text_search` | |
Returns [#returns-945]
**Type:** `public.eql_v3_text_search`
public.eql\_v3\_text\_search
***
min(public.eql_v3_double_ord) [#minpubliceql_v3_double_ord]
min aggregate for public.eql\_v3\_double\_ord.
Parameters [#parameters-949]
| Name | Type | Description |
| ------- | -------------------------- | ----------- |
| `input` | `public.eql_v3_double_ord` | |
Returns [#returns-946]
**Type:** `public.eql_v3_double_ord`
public.eql\_v3\_double\_ord
***
min(public.eql_v3_date_ord_ope) [#minpubliceql_v3_date_ord_ope]
min aggregate for public.eql\_v3\_date\_ord\_ope.
Parameters [#parameters-950]
| Name | Type | Description |
| ------- | ---------------------------- | ----------- |
| `input` | `public.eql_v3_date_ord_ope` | |
Returns [#returns-947]
**Type:** `public.eql_v3_date_ord_ope`
public.eql\_v3\_date\_ord\_ope
***
neq(jsonb, eql_v3_integer_ord_ore) [#neqjsonb-eql_v3_integer_ord_ore]
Operator wrapper for public.eql\_v3\_integer\_ord\_ore.
Parameters [#parameters-951]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_integer_ord_ore` | |
Returns [#returns-948]
**Type:** `boolean`
boolean
***
neq(eql_v3_integer_ord_ore, jsonb) [#neqeql_v3_integer_ord_ore-jsonb]
Operator wrapper for public.eql\_v3\_integer\_ord\_ore.
Parameters [#parameters-952]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a public.` | `eql_v3_integer_ord_ore` | |
| `b` | `jsonb` | |
Returns [#returns-949]
**Type:** `boolean`
boolean
***
neq(eql_v3_integer_ord_ore, eql_v3_integer_ord_ore) [#neqeql_v3_integer_ord_ore-eql_v3_integer_ord_ore]
Operator wrapper for public.eql\_v3\_integer\_ord\_ore.
Parameters [#parameters-953]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a public.` | `eql_v3_integer_ord_ore` | |
| `b public.` | `eql_v3_integer_ord_ore` | |
Returns [#returns-950]
**Type:** `boolean`
boolean
***
neq(query_smallint_ord, eql_v3_smallint_ord) [#neqquery_smallint_ord-eql_v3_smallint_ord]
Operator wrapper for eql\_v3.query\_smallint\_ord.
Parameters [#parameters-954]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a eql_v3.` | `query_smallint_ord` | |
| `b public.` | `eql_v3_smallint_ord` | |
Returns [#returns-951]
**Type:** `boolean`
boolean
***
neq(eql_v3_smallint_ord, query_smallint_ord) [#neqeql_v3_smallint_ord-query_smallint_ord]
Operator wrapper for eql\_v3.query\_smallint\_ord.
Parameters [#parameters-955]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_smallint_ord` | |
| `b eql_v3.` | `query_smallint_ord` | |
Returns [#returns-952]
**Type:** `boolean`
boolean
***
neq(jsonb, eql_v3_smallint_ord) [#neqjsonb-eql_v3_smallint_ord]
Operator wrapper for public.eql\_v3\_smallint\_ord.
Parameters [#parameters-956]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_smallint_ord` | |
Returns [#returns-953]
**Type:** `boolean`
boolean
***
neq(eql_v3_smallint_ord, jsonb) [#neqeql_v3_smallint_ord-jsonb]
Operator wrapper for public.eql\_v3\_smallint\_ord.
Parameters [#parameters-957]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_smallint_ord` | |
| `b` | `jsonb` | |
Returns [#returns-954]
**Type:** `boolean`
boolean
***
neq(eql_v3_smallint_ord, eql_v3_smallint_ord) [#neqeql_v3_smallint_ord-eql_v3_smallint_ord]
Operator wrapper for public.eql\_v3\_smallint\_ord.
Parameters [#parameters-958]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_smallint_ord` | |
| `b public.` | `eql_v3_smallint_ord` | |
Returns [#returns-955]
**Type:** `boolean`
boolean
***
neq(jsonb, eql_v3_date_ord) [#neqjsonb-eql_v3_date_ord]
Operator wrapper for public.eql\_v3\_date\_ord.
Parameters [#parameters-959]
| Name | Type | Description |
| ----------- | ----------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_date_ord` | |
Returns [#returns-956]
**Type:** `boolean`
boolean
***
neq(eql_v3_date_ord, jsonb) [#neqeql_v3_date_ord-jsonb]
Operator wrapper for public.eql\_v3\_date\_ord.
Parameters [#parameters-960]
| Name | Type | Description |
| ----------- | ----------------- | ----------- |
| `a public.` | `eql_v3_date_ord` | |
| `b` | `jsonb` | |
Returns [#returns-957]
**Type:** `boolean`
boolean
***
neq(eql_v3_date_ord, eql_v3_date_ord) [#neqeql_v3_date_ord-eql_v3_date_ord]
Operator wrapper for public.eql\_v3\_date\_ord.
Parameters [#parameters-961]
| Name | Type | Description |
| ----------- | ----------------- | ----------- |
| `a public.` | `eql_v3_date_ord` | |
| `b public.` | `eql_v3_date_ord` | |
Returns [#returns-958]
**Type:** `boolean`
boolean
***
neq(query_real_ord, eql_v3_real_ord) [#neqquery_real_ord-eql_v3_real_ord]
Operator wrapper for eql\_v3.query\_real\_ord.
Parameters [#parameters-962]
| Name | Type | Description |
| ----------- | ----------------- | ----------- |
| `a eql_v3.` | `query_real_ord` | |
| `b public.` | `eql_v3_real_ord` | |
Returns [#returns-959]
**Type:** `boolean`
boolean
***
neq(eql_v3_real_ord, query_real_ord) [#neqeql_v3_real_ord-query_real_ord]
Operator wrapper for eql\_v3.query\_real\_ord.
Parameters [#parameters-963]
| Name | Type | Description |
| ----------- | ----------------- | ----------- |
| `a public.` | `eql_v3_real_ord` | |
| `b eql_v3.` | `query_real_ord` | |
Returns [#returns-960]
**Type:** `boolean`
boolean
***
neq(query_real_ord_ore, eql_v3_real_ord_ore) [#neqquery_real_ord_ore-eql_v3_real_ord_ore]
Operator wrapper for eql\_v3.query\_real\_ord\_ore.
Parameters [#parameters-964]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a eql_v3.` | `query_real_ord_ore` | |
| `b public.` | `eql_v3_real_ord_ore` | |
Returns [#returns-961]
**Type:** `boolean`
boolean
***
neq(eql_v3_real_ord_ore, query_real_ord_ore) [#neqeql_v3_real_ord_ore-query_real_ord_ore]
Operator wrapper for eql\_v3.query\_real\_ord\_ore.
Parameters [#parameters-965]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_real_ord_ore` | |
| `b eql_v3.` | `query_real_ord_ore` | |
Returns [#returns-962]
**Type:** `boolean`
boolean
***
neq(jsonb, eql_v3_text_ord) [#neqjsonb-eql_v3_text_ord]
Operator wrapper for public.eql\_v3\_text\_ord.
Parameters [#parameters-966]
| Name | Type | Description |
| ----------- | ----------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_text_ord` | |
Returns [#returns-963]
**Type:** `boolean`
boolean
***
neq(eql_v3_text_ord, jsonb) [#neqeql_v3_text_ord-jsonb]
Operator wrapper for public.eql\_v3\_text\_ord.
Parameters [#parameters-967]
| Name | Type | Description |
| ----------- | ----------------- | ----------- |
| `a public.` | `eql_v3_text_ord` | |
| `b` | `jsonb` | |
Returns [#returns-964]
**Type:** `boolean`
boolean
***
neq(eql_v3_text_ord, eql_v3_text_ord) [#neqeql_v3_text_ord-eql_v3_text_ord]
Operator wrapper for public.eql\_v3\_text\_ord.
Parameters [#parameters-968]
| Name | Type | Description |
| ----------- | ----------------- | ----------- |
| `a public.` | `eql_v3_text_ord` | |
| `b public.` | `eql_v3_text_ord` | |
Returns [#returns-965]
**Type:** `boolean`
boolean
***
neq(query_integer_ord_ope, eql_v3_integer_ord_ope) [#neqquery_integer_ord_ope-eql_v3_integer_ord_ope]
Operator wrapper for eql\_v3.query\_integer\_ord\_ope.
Parameters [#parameters-969]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a eql_v3.` | `query_integer_ord_ope` | |
| `b public.` | `eql_v3_integer_ord_ope` | |
Returns [#returns-966]
**Type:** `boolean`
boolean
***
neq(eql_v3_integer_ord_ope, query_integer_ord_ope) [#neqeql_v3_integer_ord_ope-query_integer_ord_ope]
Operator wrapper for eql\_v3.query\_integer\_ord\_ope.
Parameters [#parameters-970]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a public.` | `eql_v3_integer_ord_ope` | |
| `b eql_v3.` | `query_integer_ord_ope` | |
Returns [#returns-967]
**Type:** `boolean`
boolean
***
neq(query_text_ord, eql_v3_text_ord) [#neqquery_text_ord-eql_v3_text_ord]
Operator wrapper for eql\_v3.query\_text\_ord.
Parameters [#parameters-971]
| Name | Type | Description |
| ----------- | ----------------- | ----------- |
| `a eql_v3.` | `query_text_ord` | |
| `b public.` | `eql_v3_text_ord` | |
Returns [#returns-968]
**Type:** `boolean`
boolean
***
neq(eql_v3_text_ord, query_text_ord) [#neqeql_v3_text_ord-query_text_ord]
Operator wrapper for eql\_v3.query\_text\_ord.
Parameters [#parameters-972]
| Name | Type | Description |
| ----------- | ----------------- | ----------- |
| `a public.` | `eql_v3_text_ord` | |
| `b eql_v3.` | `query_text_ord` | |
Returns [#returns-969]
**Type:** `boolean`
boolean
***
neq(jsonb, eql_v3_timestamp_ord_ope) [#neqjsonb-eql_v3_timestamp_ord_ope]
Operator wrapper for public.eql\_v3\_timestamp\_ord\_ope.
Parameters [#parameters-973]
| Name | Type | Description |
| ----------- | -------------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_timestamp_ord_ope` | |
Returns [#returns-970]
**Type:** `boolean`
boolean
***
neq(eql_v3_timestamp_ord_ope, jsonb) [#neqeql_v3_timestamp_ord_ope-jsonb]
Operator wrapper for public.eql\_v3\_timestamp\_ord\_ope.
Parameters [#parameters-974]
| Name | Type | Description |
| ----------- | -------------------------- | ----------- |
| `a public.` | `eql_v3_timestamp_ord_ope` | |
| `b` | `jsonb` | |
Returns [#returns-971]
**Type:** `boolean`
boolean
***
neq(eql_v3_timestamp_ord_ope, eql_v3_timestamp_ord_ope) [#neqeql_v3_timestamp_ord_ope-eql_v3_timestamp_ord_ope]
Operator wrapper for public.eql\_v3\_timestamp\_ord\_ope.
Parameters [#parameters-975]
| Name | Type | Description |
| ----------- | -------------------------- | ----------- |
| `a public.` | `eql_v3_timestamp_ord_ope` | |
| `b public.` | `eql_v3_timestamp_ord_ope` | |
Returns [#returns-972]
**Type:** `boolean`
boolean
***
neq(jsonb, eql_v3_integer_ord_ope) [#neqjsonb-eql_v3_integer_ord_ope]
Operator wrapper for public.eql\_v3\_integer\_ord\_ope.
Parameters [#parameters-976]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_integer_ord_ope` | |
Returns [#returns-973]
**Type:** `boolean`
boolean
***
neq(eql_v3_integer_ord_ope, jsonb) [#neqeql_v3_integer_ord_ope-jsonb]
Operator wrapper for public.eql\_v3\_integer\_ord\_ope.
Parameters [#parameters-977]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a public.` | `eql_v3_integer_ord_ope` | |
| `b` | `jsonb` | |
Returns [#returns-974]
**Type:** `boolean`
boolean
***
neq(eql_v3_integer_ord_ope, eql_v3_integer_ord_ope) [#neqeql_v3_integer_ord_ope-eql_v3_integer_ord_ope]
Operator wrapper for public.eql\_v3\_integer\_ord\_ope.
Parameters [#parameters-978]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a public.` | `eql_v3_integer_ord_ope` | |
| `b public.` | `eql_v3_integer_ord_ope` | |
Returns [#returns-975]
**Type:** `boolean`
boolean
***
neq(query_integer_ord, eql_v3_integer_ord) [#neqquery_integer_ord-eql_v3_integer_ord]
Operator wrapper for eql\_v3.query\_integer\_ord.
Parameters [#parameters-979]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a eql_v3.` | `query_integer_ord` | |
| `b public.` | `eql_v3_integer_ord` | |
Returns [#returns-976]
**Type:** `boolean`
boolean
***
neq(eql_v3_integer_ord, query_integer_ord) [#neqeql_v3_integer_ord-query_integer_ord]
Operator wrapper for eql\_v3.query\_integer\_ord.
Parameters [#parameters-980]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a public.` | `eql_v3_integer_ord` | |
| `b eql_v3.` | `query_integer_ord` | |
Returns [#returns-977]
**Type:** `boolean`
boolean
***
neq(query_text_search, eql_v3_text_search) [#neqquery_text_search-eql_v3_text_search]
Operator wrapper for eql\_v3.query\_text\_search.
Parameters [#parameters-981]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a eql_v3.` | `query_text_search` | |
| `b public.` | `eql_v3_text_search` | |
Returns [#returns-978]
**Type:** `boolean`
boolean
***
neq(eql_v3_text_search, query_text_search) [#neqeql_v3_text_search-query_text_search]
Operator wrapper for eql\_v3.query\_text\_search.
Parameters [#parameters-982]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a public.` | `eql_v3_text_search` | |
| `b eql_v3.` | `query_text_search` | |
Returns [#returns-979]
**Type:** `boolean`
boolean
***
neq(query_numeric_eq, eql_v3_numeric_eq) [#neqquery_numeric_eq-eql_v3_numeric_eq]
Operator wrapper for eql\_v3.query\_numeric\_eq.
Parameters [#parameters-983]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a eql_v3.` | `query_numeric_eq` | |
| `b public.` | `eql_v3_numeric_eq` | |
Returns [#returns-980]
**Type:** `boolean`
boolean
***
neq(eql_v3_numeric_eq, query_numeric_eq) [#neqeql_v3_numeric_eq-query_numeric_eq]
Operator wrapper for eql\_v3.query\_numeric\_eq.
Parameters [#parameters-984]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a public.` | `eql_v3_numeric_eq` | |
| `b eql_v3.` | `query_numeric_eq` | |
Returns [#returns-981]
**Type:** `boolean`
boolean
***
neq(jsonb, eql_v3_bigint_eq) [#neqjsonb-eql_v3_bigint_eq]
Operator wrapper for public.eql\_v3\_bigint\_eq.
Parameters [#parameters-985]
| Name | Type | Description |
| ----------- | ------------------ | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_bigint_eq` | |
Returns [#returns-982]
**Type:** `boolean`
boolean
***
neq(eql_v3_bigint_eq, jsonb) [#neqeql_v3_bigint_eq-jsonb]
Operator wrapper for public.eql\_v3\_bigint\_eq.
Parameters [#parameters-986]
| Name | Type | Description |
| ----------- | ------------------ | ----------- |
| `a public.` | `eql_v3_bigint_eq` | |
| `b` | `jsonb` | |
Returns [#returns-983]
**Type:** `boolean`
boolean
***
neq(eql_v3_bigint_eq, eql_v3_bigint_eq) [#neqeql_v3_bigint_eq-eql_v3_bigint_eq]
Operator wrapper for public.eql\_v3\_bigint\_eq.
Parameters [#parameters-987]
| Name | Type | Description |
| ----------- | ------------------ | ----------- |
| `a public.` | `eql_v3_bigint_eq` | |
| `b public.` | `eql_v3_bigint_eq` | |
Returns [#returns-984]
**Type:** `boolean`
boolean
***
neq(query_smallint_eq, eql_v3_smallint_eq) [#neqquery_smallint_eq-eql_v3_smallint_eq]
Operator wrapper for eql\_v3.query\_smallint\_eq.
Parameters [#parameters-988]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a eql_v3.` | `query_smallint_eq` | |
| `b public.` | `eql_v3_smallint_eq` | |
Returns [#returns-985]
**Type:** `boolean`
boolean
***
neq(eql_v3_smallint_eq, query_smallint_eq) [#neqeql_v3_smallint_eq-query_smallint_eq]
Operator wrapper for eql\_v3.query\_smallint\_eq.
Parameters [#parameters-989]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a public.` | `eql_v3_smallint_eq` | |
| `b eql_v3.` | `query_smallint_eq` | |
Returns [#returns-986]
**Type:** `boolean`
boolean
***
neq(jsonb, eql_v3_numeric_ord) [#neqjsonb-eql_v3_numeric_ord]
Operator wrapper for public.eql\_v3\_numeric\_ord.
Parameters [#parameters-990]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_numeric_ord` | |
Returns [#returns-987]
**Type:** `boolean`
boolean
***
neq(eql_v3_numeric_ord, jsonb) [#neqeql_v3_numeric_ord-jsonb]
Operator wrapper for public.eql\_v3\_numeric\_ord.
Parameters [#parameters-991]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a public.` | `eql_v3_numeric_ord` | |
| `b` | `jsonb` | |
Returns [#returns-988]
**Type:** `boolean`
boolean
***
neq(eql_v3_numeric_ord, eql_v3_numeric_ord) [#neqeql_v3_numeric_ord-eql_v3_numeric_ord]
Operator wrapper for public.eql\_v3\_numeric\_ord.
Parameters [#parameters-992]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a public.` | `eql_v3_numeric_ord` | |
| `b public.` | `eql_v3_numeric_ord` | |
Returns [#returns-989]
**Type:** `boolean`
boolean
***
neq(query_date_ord_ope, eql_v3_date_ord_ope) [#neqquery_date_ord_ope-eql_v3_date_ord_ope]
Operator wrapper for eql\_v3.query\_date\_ord\_ope.
Parameters [#parameters-993]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a eql_v3.` | `query_date_ord_ope` | |
| `b public.` | `eql_v3_date_ord_ope` | |
Returns [#returns-990]
**Type:** `boolean`
boolean
***
neq(eql_v3_date_ord_ope, query_date_ord_ope) [#neqeql_v3_date_ord_ope-query_date_ord_ope]
Operator wrapper for eql\_v3.query\_date\_ord\_ope.
Parameters [#parameters-994]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_date_ord_ope` | |
| `b eql_v3.` | `query_date_ord_ope` | |
Returns [#returns-991]
**Type:** `boolean`
boolean
***
neq(query_timestamp_ord_ore, eql_v3_timestamp_ord_ore) [#neqquery_timestamp_ord_ore-eql_v3_timestamp_ord_ore]
Operator wrapper for eql\_v3.query\_timestamp\_ord\_ore.
Parameters [#parameters-995]
| Name | Type | Description |
| ----------- | -------------------------- | ----------- |
| `a eql_v3.` | `query_timestamp_ord_ore` | |
| `b public.` | `eql_v3_timestamp_ord_ore` | |
Returns [#returns-992]
**Type:** `boolean`
boolean
***
neq(eql_v3_timestamp_ord_ore, query_timestamp_ord_ore) [#neqeql_v3_timestamp_ord_ore-query_timestamp_ord_ore]
Operator wrapper for eql\_v3.query\_timestamp\_ord\_ore.
Parameters [#parameters-996]
| Name | Type | Description |
| ----------- | -------------------------- | ----------- |
| `a public.` | `eql_v3_timestamp_ord_ore` | |
| `b eql_v3.` | `query_timestamp_ord_ore` | |
Returns [#returns-993]
**Type:** `boolean`
boolean
***
neq(query_text_search_ore, eql_v3_text_search_ore) [#neqquery_text_search_ore-eql_v3_text_search_ore]
Operator wrapper for eql\_v3.query\_text\_search\_ore.
Parameters [#parameters-997]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a eql_v3.` | `query_text_search_ore` | |
| `b public.` | `eql_v3_text_search_ore` | |
Returns [#returns-994]
**Type:** `boolean`
boolean
***
neq(eql_v3_text_search_ore, query_text_search_ore) [#neqeql_v3_text_search_ore-query_text_search_ore]
Operator wrapper for eql\_v3.query\_text\_search\_ore.
Parameters [#parameters-998]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a public.` | `eql_v3_text_search_ore` | |
| `b eql_v3.` | `query_text_search_ore` | |
Returns [#returns-995]
**Type:** `boolean`
boolean
***
neq(query_text_ord_ore, eql_v3_text_ord_ore) [#neqquery_text_ord_ore-eql_v3_text_ord_ore]
Operator wrapper for eql\_v3.query\_text\_ord\_ore.
Parameters [#parameters-999]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a eql_v3.` | `query_text_ord_ore` | |
| `b public.` | `eql_v3_text_ord_ore` | |
Returns [#returns-996]
**Type:** `boolean`
boolean
***
neq(eql_v3_text_ord_ore, query_text_ord_ore) [#neqeql_v3_text_ord_ore-query_text_ord_ore]
Operator wrapper for eql\_v3.query\_text\_ord\_ore.
Parameters [#parameters-1000]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_text_ord_ore` | |
| `b eql_v3.` | `query_text_ord_ore` | |
Returns [#returns-997]
**Type:** `boolean`
boolean
***
neq(jsonb, eql_v3_timestamp_eq) [#neqjsonb-eql_v3_timestamp_eq]
Operator wrapper for public.eql\_v3\_timestamp\_eq.
Parameters [#parameters-1001]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_timestamp_eq` | |
Returns [#returns-998]
**Type:** `boolean`
boolean
***
neq(eql_v3_timestamp_eq, jsonb) [#neqeql_v3_timestamp_eq-jsonb]
Operator wrapper for public.eql\_v3\_timestamp\_eq.
Parameters [#parameters-1002]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_timestamp_eq` | |
| `b` | `jsonb` | |
Returns [#returns-999]
**Type:** `boolean`
boolean
***
neq(eql_v3_timestamp_eq, eql_v3_timestamp_eq) [#neqeql_v3_timestamp_eq-eql_v3_timestamp_eq]
Operator wrapper for public.eql\_v3\_timestamp\_eq.
Parameters [#parameters-1003]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_timestamp_eq` | |
| `b public.` | `eql_v3_timestamp_eq` | |
Returns [#returns-1000]
**Type:** `boolean`
boolean
***
neq(jsonb, eql_v3_real_ord_ope) [#neqjsonb-eql_v3_real_ord_ope]
Operator wrapper for public.eql\_v3\_real\_ord\_ope.
Parameters [#parameters-1004]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_real_ord_ope` | |
Returns [#returns-1001]
**Type:** `boolean`
boolean
***
neq(eql_v3_real_ord_ope, jsonb) [#neqeql_v3_real_ord_ope-jsonb]
Operator wrapper for public.eql\_v3\_real\_ord\_ope.
Parameters [#parameters-1005]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_real_ord_ope` | |
| `b` | `jsonb` | |
Returns [#returns-1002]
**Type:** `boolean`
boolean
***
neq(eql_v3_real_ord_ope, eql_v3_real_ord_ope) [#neqeql_v3_real_ord_ope-eql_v3_real_ord_ope]
Operator wrapper for public.eql\_v3\_real\_ord\_ope.
Parameters [#parameters-1006]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_real_ord_ope` | |
| `b public.` | `eql_v3_real_ord_ope` | |
Returns [#returns-1003]
**Type:** `boolean`
boolean
***
neq(jsonb, eql_v3_real_ord) [#neqjsonb-eql_v3_real_ord]
Operator wrapper for public.eql\_v3\_real\_ord.
Parameters [#parameters-1007]
| Name | Type | Description |
| ----------- | ----------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_real_ord` | |
Returns [#returns-1004]
**Type:** `boolean`
boolean
***
neq(eql_v3_real_ord, jsonb) [#neqeql_v3_real_ord-jsonb]
Operator wrapper for public.eql\_v3\_real\_ord.
Parameters [#parameters-1008]
| Name | Type | Description |
| ----------- | ----------------- | ----------- |
| `a public.` | `eql_v3_real_ord` | |
| `b` | `jsonb` | |
Returns [#returns-1005]
**Type:** `boolean`
boolean
***
neq(eql_v3_real_ord, eql_v3_real_ord) [#neqeql_v3_real_ord-eql_v3_real_ord]
Operator wrapper for public.eql\_v3\_real\_ord.
Parameters [#parameters-1009]
| Name | Type | Description |
| ----------- | ----------------- | ----------- |
| `a public.` | `eql_v3_real_ord` | |
| `b public.` | `eql_v3_real_ord` | |
Returns [#returns-1006]
**Type:** `boolean`
boolean
***
neq(jsonb, eql_v3_integer_ord) [#neqjsonb-eql_v3_integer_ord]
Operator wrapper for public.eql\_v3\_integer\_ord.
Parameters [#parameters-1010]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_integer_ord` | |
Returns [#returns-1007]
**Type:** `boolean`
boolean
***
neq(eql_v3_integer_ord, jsonb) [#neqeql_v3_integer_ord-jsonb]
Operator wrapper for public.eql\_v3\_integer\_ord.
Parameters [#parameters-1011]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a public.` | `eql_v3_integer_ord` | |
| `b` | `jsonb` | |
Returns [#returns-1008]
**Type:** `boolean`
boolean
***
neq(eql_v3_integer_ord, eql_v3_integer_ord) [#neqeql_v3_integer_ord-eql_v3_integer_ord]
Operator wrapper for public.eql\_v3\_integer\_ord.
Parameters [#parameters-1012]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a public.` | `eql_v3_integer_ord` | |
| `b public.` | `eql_v3_integer_ord` | |
Returns [#returns-1009]
**Type:** `boolean`
boolean
***
neq(query_smallint_ord_ore, eql_v3_smallint_ord_ore) [#neqquery_smallint_ord_ore-eql_v3_smallint_ord_ore]
Operator wrapper for eql\_v3.query\_smallint\_ord\_ore.
Parameters [#parameters-1013]
| Name | Type | Description |
| ----------- | ------------------------- | ----------- |
| `a eql_v3.` | `query_smallint_ord_ore` | |
| `b public.` | `eql_v3_smallint_ord_ore` | |
Returns [#returns-1010]
**Type:** `boolean`
boolean
***
neq(eql_v3_smallint_ord_ore, query_smallint_ord_ore) [#neqeql_v3_smallint_ord_ore-query_smallint_ord_ore]
Operator wrapper for eql\_v3.query\_smallint\_ord\_ore.
Parameters [#parameters-1014]
| Name | Type | Description |
| ----------- | ------------------------- | ----------- |
| `a public.` | `eql_v3_smallint_ord_ore` | |
| `b eql_v3.` | `query_smallint_ord_ore` | |
Returns [#returns-1011]
**Type:** `boolean`
boolean
***
neq(jsonb, eql_v3_text_ord_ope) [#neqjsonb-eql_v3_text_ord_ope]
Operator wrapper for public.eql\_v3\_text\_ord\_ope.
Parameters [#parameters-1015]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_text_ord_ope` | |
Returns [#returns-1012]
**Type:** `boolean`
boolean
***
neq(eql_v3_text_ord_ope, jsonb) [#neqeql_v3_text_ord_ope-jsonb]
Operator wrapper for public.eql\_v3\_text\_ord\_ope.
Parameters [#parameters-1016]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_text_ord_ope` | |
| `b` | `jsonb` | |
Returns [#returns-1013]
**Type:** `boolean`
boolean
***
neq(eql_v3_text_ord_ope, eql_v3_text_ord_ope) [#neqeql_v3_text_ord_ope-eql_v3_text_ord_ope]
Operator wrapper for public.eql\_v3\_text\_ord\_ope.
Parameters [#parameters-1017]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_text_ord_ope` | |
| `b public.` | `eql_v3_text_ord_ope` | |
Returns [#returns-1014]
**Type:** `boolean`
boolean
***
neq(query_double_ord_ope, eql_v3_double_ord_ope) [#neqquery_double_ord_ope-eql_v3_double_ord_ope]
Operator wrapper for eql\_v3.query\_double\_ord\_ope.
Parameters [#parameters-1018]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a eql_v3.` | `query_double_ord_ope` | |
| `b public.` | `eql_v3_double_ord_ope` | |
Returns [#returns-1015]
**Type:** `boolean`
boolean
***
neq(eql_v3_double_ord_ope, query_double_ord_ope) [#neqeql_v3_double_ord_ope-query_double_ord_ope]
Operator wrapper for eql\_v3.query\_double\_ord\_ope.
Parameters [#parameters-1019]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a public.` | `eql_v3_double_ord_ope` | |
| `b eql_v3.` | `query_double_ord_ope` | |
Returns [#returns-1016]
**Type:** `boolean`
boolean
***
neq(query_integer_ord_ore, eql_v3_integer_ord_ore) [#neqquery_integer_ord_ore-eql_v3_integer_ord_ore]
Operator wrapper for eql\_v3.query\_integer\_ord\_ore.
Parameters [#parameters-1020]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a eql_v3.` | `query_integer_ord_ore` | |
| `b public.` | `eql_v3_integer_ord_ore` | |
Returns [#returns-1017]
**Type:** `boolean`
boolean
***
neq(eql_v3_integer_ord_ore, query_integer_ord_ore) [#neqeql_v3_integer_ord_ore-query_integer_ord_ore]
Operator wrapper for eql\_v3.query\_integer\_ord\_ore.
Parameters [#parameters-1021]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a public.` | `eql_v3_integer_ord_ore` | |
| `b eql_v3.` | `query_integer_ord_ore` | |
Returns [#returns-1018]
**Type:** `boolean`
boolean
***
neq(jsonb, eql_v3_real_eq) [#neqjsonb-eql_v3_real_eq]
Operator wrapper for public.eql\_v3\_real\_eq.
Parameters [#parameters-1022]
| Name | Type | Description |
| ----------- | ---------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_real_eq` | |
Returns [#returns-1019]
**Type:** `boolean`
boolean
***
neq(eql_v3_real_eq, jsonb) [#neqeql_v3_real_eq-jsonb]
Operator wrapper for public.eql\_v3\_real\_eq.
Parameters [#parameters-1023]
| Name | Type | Description |
| ----------- | ---------------- | ----------- |
| `a public.` | `eql_v3_real_eq` | |
| `b` | `jsonb` | |
Returns [#returns-1020]
**Type:** `boolean`
boolean
***
neq(eql_v3_real_eq, eql_v3_real_eq) [#neqeql_v3_real_eq-eql_v3_real_eq]
Operator wrapper for public.eql\_v3\_real\_eq.
Parameters [#parameters-1024]
| Name | Type | Description |
| ----------- | ---------------- | ----------- |
| `a public.` | `eql_v3_real_eq` | |
| `b public.` | `eql_v3_real_eq` | |
Returns [#returns-1021]
**Type:** `boolean`
boolean
***
neq(query_text_eq, eql_v3_text_eq) [#neqquery_text_eq-eql_v3_text_eq]
Operator wrapper for eql\_v3.query\_text\_eq.
Parameters [#parameters-1025]
| Name | Type | Description |
| ----------- | ---------------- | ----------- |
| `a eql_v3.` | `query_text_eq` | |
| `b public.` | `eql_v3_text_eq` | |
Returns [#returns-1022]
**Type:** `boolean`
boolean
***
neq(eql_v3_text_eq, query_text_eq) [#neqeql_v3_text_eq-query_text_eq]
Operator wrapper for eql\_v3.query\_text\_eq.
Parameters [#parameters-1026]
| Name | Type | Description |
| ----------- | ---------------- | ----------- |
| `a public.` | `eql_v3_text_eq` | |
| `b eql_v3.` | `query_text_eq` | |
Returns [#returns-1023]
**Type:** `boolean`
boolean
***
neq(jsonb, eql_v3_bigint_ord_ore) [#neqjsonb-eql_v3_bigint_ord_ore]
Operator wrapper for public.eql\_v3\_bigint\_ord\_ore.
Parameters [#parameters-1027]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_bigint_ord_ore` | |
Returns [#returns-1024]
**Type:** `boolean`
boolean
***
neq(eql_v3_bigint_ord_ore, jsonb) [#neqeql_v3_bigint_ord_ore-jsonb]
Operator wrapper for public.eql\_v3\_bigint\_ord\_ore.
Parameters [#parameters-1028]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a public.` | `eql_v3_bigint_ord_ore` | |
| `b` | `jsonb` | |
Returns [#returns-1025]
**Type:** `boolean`
boolean
***
neq(eql_v3_bigint_ord_ore, eql_v3_bigint_ord_ore) [#neqeql_v3_bigint_ord_ore-eql_v3_bigint_ord_ore]
Operator wrapper for public.eql\_v3\_bigint\_ord\_ore.
Parameters [#parameters-1029]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a public.` | `eql_v3_bigint_ord_ore` | |
| `b public.` | `eql_v3_bigint_ord_ore` | |
Returns [#returns-1026]
**Type:** `boolean`
boolean
***
neq(query_date_ord, eql_v3_date_ord) [#neqquery_date_ord-eql_v3_date_ord]
Operator wrapper for eql\_v3.query\_date\_ord.
Parameters [#parameters-1030]
| Name | Type | Description |
| ----------- | ----------------- | ----------- |
| `a eql_v3.` | `query_date_ord` | |
| `b public.` | `eql_v3_date_ord` | |
Returns [#returns-1027]
**Type:** `boolean`
boolean
***
neq(eql_v3_date_ord, query_date_ord) [#neqeql_v3_date_ord-query_date_ord]
Operator wrapper for eql\_v3.query\_date\_ord.
Parameters [#parameters-1031]
| Name | Type | Description |
| ----------- | ----------------- | ----------- |
| `a public.` | `eql_v3_date_ord` | |
| `b eql_v3.` | `query_date_ord` | |
Returns [#returns-1028]
**Type:** `boolean`
boolean
***
neq(jsonb, eql_v3_double_eq) [#neqjsonb-eql_v3_double_eq]
Operator wrapper for public.eql\_v3\_double\_eq.
Parameters [#parameters-1032]
| Name | Type | Description |
| ----------- | ------------------ | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_double_eq` | |
Returns [#returns-1029]
**Type:** `boolean`
boolean
***
neq(eql_v3_double_eq, jsonb) [#neqeql_v3_double_eq-jsonb]
Operator wrapper for public.eql\_v3\_double\_eq.
Parameters [#parameters-1033]
| Name | Type | Description |
| ----------- | ------------------ | ----------- |
| `a public.` | `eql_v3_double_eq` | |
| `b` | `jsonb` | |
Returns [#returns-1030]
**Type:** `boolean`
boolean
***
neq(eql_v3_double_eq, eql_v3_double_eq) [#neqeql_v3_double_eq-eql_v3_double_eq]
Operator wrapper for public.eql\_v3\_double\_eq.
Parameters [#parameters-1034]
| Name | Type | Description |
| ----------- | ------------------ | ----------- |
| `a public.` | `eql_v3_double_eq` | |
| `b public.` | `eql_v3_double_eq` | |
Returns [#returns-1031]
**Type:** `boolean`
boolean
***
neq(jsonb, eql_v3_real_ord_ore) [#neqjsonb-eql_v3_real_ord_ore]
Operator wrapper for public.eql\_v3\_real\_ord\_ore.
Parameters [#parameters-1035]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_real_ord_ore` | |
Returns [#returns-1032]
**Type:** `boolean`
boolean
***
neq(eql_v3_real_ord_ore, jsonb) [#neqeql_v3_real_ord_ore-jsonb]
Operator wrapper for public.eql\_v3\_real\_ord\_ore.
Parameters [#parameters-1036]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_real_ord_ore` | |
| `b` | `jsonb` | |
Returns [#returns-1033]
**Type:** `boolean`
boolean
***
neq(eql_v3_real_ord_ore, eql_v3_real_ord_ore) [#neqeql_v3_real_ord_ore-eql_v3_real_ord_ore]
Operator wrapper for public.eql\_v3\_real\_ord\_ore.
Parameters [#parameters-1037]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_real_ord_ore` | |
| `b public.` | `eql_v3_real_ord_ore` | |
Returns [#returns-1034]
**Type:** `boolean`
boolean
***
neq(jsonb, eql_v3_numeric_ord_ore) [#neqjsonb-eql_v3_numeric_ord_ore]
Operator wrapper for public.eql\_v3\_numeric\_ord\_ore.
Parameters [#parameters-1038]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_numeric_ord_ore` | |
Returns [#returns-1035]
**Type:** `boolean`
boolean
***
neq(eql_v3_numeric_ord_ore, jsonb) [#neqeql_v3_numeric_ord_ore-jsonb]
Operator wrapper for public.eql\_v3\_numeric\_ord\_ore.
Parameters [#parameters-1039]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a public.` | `eql_v3_numeric_ord_ore` | |
| `b` | `jsonb` | |
Returns [#returns-1036]
**Type:** `boolean`
boolean
***
neq(eql_v3_numeric_ord_ore, eql_v3_numeric_ord_ore) [#neqeql_v3_numeric_ord_ore-eql_v3_numeric_ord_ore]
Operator wrapper for public.eql\_v3\_numeric\_ord\_ore.
Parameters [#parameters-1040]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a public.` | `eql_v3_numeric_ord_ore` | |
| `b public.` | `eql_v3_numeric_ord_ore` | |
Returns [#returns-1037]
**Type:** `boolean`
boolean
***
neq(query_double_eq, eql_v3_double_eq) [#neqquery_double_eq-eql_v3_double_eq]
Operator wrapper for eql\_v3.query\_double\_eq.
Parameters [#parameters-1041]
| Name | Type | Description |
| ----------- | ------------------ | ----------- |
| `a eql_v3.` | `query_double_eq` | |
| `b public.` | `eql_v3_double_eq` | |
Returns [#returns-1038]
**Type:** `boolean`
boolean
***
neq(eql_v3_double_eq, query_double_eq) [#neqeql_v3_double_eq-query_double_eq]
Operator wrapper for eql\_v3.query\_double\_eq.
Parameters [#parameters-1042]
| Name | Type | Description |
| ----------- | ------------------ | ----------- |
| `a public.` | `eql_v3_double_eq` | |
| `b eql_v3.` | `query_double_eq` | |
Returns [#returns-1039]
**Type:** `boolean`
boolean
***
neq(query_text_ord_ope, eql_v3_text_ord_ope) [#neqquery_text_ord_ope-eql_v3_text_ord_ope]
Operator wrapper for eql\_v3.query\_text\_ord\_ope.
Parameters [#parameters-1043]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a eql_v3.` | `query_text_ord_ope` | |
| `b public.` | `eql_v3_text_ord_ope` | |
Returns [#returns-1040]
**Type:** `boolean`
boolean
***
neq(eql_v3_text_ord_ope, query_text_ord_ope) [#neqeql_v3_text_ord_ope-query_text_ord_ope]
Operator wrapper for eql\_v3.query\_text\_ord\_ope.
Parameters [#parameters-1044]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_text_ord_ope` | |
| `b eql_v3.` | `query_text_ord_ope` | |
Returns [#returns-1041]
**Type:** `boolean`
boolean
***
neq(jsonb, eql_v3_bigint_ord_ope) [#neqjsonb-eql_v3_bigint_ord_ope]
Operator wrapper for public.eql\_v3\_bigint\_ord\_ope.
Parameters [#parameters-1045]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_bigint_ord_ope` | |
Returns [#returns-1042]
**Type:** `boolean`
boolean
***
neq(eql_v3_bigint_ord_ope, jsonb) [#neqeql_v3_bigint_ord_ope-jsonb]
Operator wrapper for public.eql\_v3\_bigint\_ord\_ope.
Parameters [#parameters-1046]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a public.` | `eql_v3_bigint_ord_ope` | |
| `b` | `jsonb` | |
Returns [#returns-1043]
**Type:** `boolean`
boolean
***
neq(eql_v3_bigint_ord_ope, eql_v3_bigint_ord_ope) [#neqeql_v3_bigint_ord_ope-eql_v3_bigint_ord_ope]
Operator wrapper for public.eql\_v3\_bigint\_ord\_ope.
Parameters [#parameters-1047]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a public.` | `eql_v3_bigint_ord_ope` | |
| `b public.` | `eql_v3_bigint_ord_ope` | |
Returns [#returns-1044]
**Type:** `boolean`
boolean
***
neq(query_real_eq, eql_v3_real_eq) [#neqquery_real_eq-eql_v3_real_eq]
Operator wrapper for eql\_v3.query\_real\_eq.
Parameters [#parameters-1048]
| Name | Type | Description |
| ----------- | ---------------- | ----------- |
| `a eql_v3.` | `query_real_eq` | |
| `b public.` | `eql_v3_real_eq` | |
Returns [#returns-1045]
**Type:** `boolean`
boolean
***
neq(eql_v3_real_eq, query_real_eq) [#neqeql_v3_real_eq-query_real_eq]
Operator wrapper for eql\_v3.query\_real\_eq.
Parameters [#parameters-1049]
| Name | Type | Description |
| ----------- | ---------------- | ----------- |
| `a public.` | `eql_v3_real_eq` | |
| `b eql_v3.` | `query_real_eq` | |
Returns [#returns-1046]
**Type:** `boolean`
boolean
***
neq(jsonb, eql_v3_double_ord_ore) [#neqjsonb-eql_v3_double_ord_ore]
Operator wrapper for public.eql\_v3\_double\_ord\_ore.
Parameters [#parameters-1050]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_double_ord_ore` | |
Returns [#returns-1047]
**Type:** `boolean`
boolean
***
neq(eql_v3_double_ord_ore, jsonb) [#neqeql_v3_double_ord_ore-jsonb]
Operator wrapper for public.eql\_v3\_double\_ord\_ore.
Parameters [#parameters-1051]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a public.` | `eql_v3_double_ord_ore` | |
| `b` | `jsonb` | |
Returns [#returns-1048]
**Type:** `boolean`
boolean
***
neq(eql_v3_double_ord_ore, eql_v3_double_ord_ore) [#neqeql_v3_double_ord_ore-eql_v3_double_ord_ore]
Operator wrapper for public.eql\_v3\_double\_ord\_ore.
Parameters [#parameters-1052]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a public.` | `eql_v3_double_ord_ore` | |
| `b public.` | `eql_v3_double_ord_ore` | |
Returns [#returns-1049]
**Type:** `boolean`
boolean
***
neq(jsonb, eql_v3_bigint_ord) [#neqjsonb-eql_v3_bigint_ord]
Operator wrapper for public.eql\_v3\_bigint\_ord.
Parameters [#parameters-1053]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_bigint_ord` | |
Returns [#returns-1050]
**Type:** `boolean`
boolean
***
neq(eql_v3_bigint_ord, jsonb) [#neqeql_v3_bigint_ord-jsonb]
Operator wrapper for public.eql\_v3\_bigint\_ord.
Parameters [#parameters-1054]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a public.` | `eql_v3_bigint_ord` | |
| `b` | `jsonb` | |
Returns [#returns-1051]
**Type:** `boolean`
boolean
***
neq(eql_v3_bigint_ord, eql_v3_bigint_ord) [#neqeql_v3_bigint_ord-eql_v3_bigint_ord]
Operator wrapper for public.eql\_v3\_bigint\_ord.
Parameters [#parameters-1055]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a public.` | `eql_v3_bigint_ord` | |
| `b public.` | `eql_v3_bigint_ord` | |
Returns [#returns-1052]
**Type:** `boolean`
boolean
***
neq(query_timestamp_ord_ope, eql_v3_timestamp_ord_ope) [#neqquery_timestamp_ord_ope-eql_v3_timestamp_ord_ope]
Operator wrapper for eql\_v3.query\_timestamp\_ord\_ope.
Parameters [#parameters-1056]
| Name | Type | Description |
| ----------- | -------------------------- | ----------- |
| `a eql_v3.` | `query_timestamp_ord_ope` | |
| `b public.` | `eql_v3_timestamp_ord_ope` | |
Returns [#returns-1053]
**Type:** `boolean`
boolean
***
neq(eql_v3_timestamp_ord_ope, query_timestamp_ord_ope) [#neqeql_v3_timestamp_ord_ope-query_timestamp_ord_ope]
Operator wrapper for eql\_v3.query\_timestamp\_ord\_ope.
Parameters [#parameters-1057]
| Name | Type | Description |
| ----------- | -------------------------- | ----------- |
| `a public.` | `eql_v3_timestamp_ord_ope` | |
| `b eql_v3.` | `query_timestamp_ord_ope` | |
Returns [#returns-1054]
**Type:** `boolean`
boolean
***
neq(query_numeric_ord, eql_v3_numeric_ord) [#neqquery_numeric_ord-eql_v3_numeric_ord]
Operator wrapper for eql\_v3.query\_numeric\_ord.
Parameters [#parameters-1058]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a eql_v3.` | `query_numeric_ord` | |
| `b public.` | `eql_v3_numeric_ord` | |
Returns [#returns-1055]
**Type:** `boolean`
boolean
***
neq(eql_v3_numeric_ord, query_numeric_ord) [#neqeql_v3_numeric_ord-query_numeric_ord]
Operator wrapper for eql\_v3.query\_numeric\_ord.
Parameters [#parameters-1059]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a public.` | `eql_v3_numeric_ord` | |
| `b eql_v3.` | `query_numeric_ord` | |
Returns [#returns-1056]
**Type:** `boolean`
boolean
***
neq(jsonb, eql_v3_text_search_ore) [#neqjsonb-eql_v3_text_search_ore]
Operator wrapper for public.eql\_v3\_text\_search\_ore.
Parameters [#parameters-1060]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_text_search_ore` | |
Returns [#returns-1057]
**Type:** `boolean`
boolean
***
neq(eql_v3_text_search_ore, jsonb) [#neqeql_v3_text_search_ore-jsonb]
Operator wrapper for public.eql\_v3\_text\_search\_ore.
Parameters [#parameters-1061]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a public.` | `eql_v3_text_search_ore` | |
| `b` | `jsonb` | |
Returns [#returns-1058]
**Type:** `boolean`
boolean
***
neq(eql_v3_text_search_ore, eql_v3_text_search_ore) [#neqeql_v3_text_search_ore-eql_v3_text_search_ore]
Operator wrapper for public.eql\_v3\_text\_search\_ore.
Parameters [#parameters-1062]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a public.` | `eql_v3_text_search_ore` | |
| `b public.` | `eql_v3_text_search_ore` | |
Returns [#returns-1059]
**Type:** `boolean`
boolean
***
neq(query_bigint_eq, eql_v3_bigint_eq) [#neqquery_bigint_eq-eql_v3_bigint_eq]
Operator wrapper for eql\_v3.query\_bigint\_eq.
Parameters [#parameters-1063]
| Name | Type | Description |
| ----------- | ------------------ | ----------- |
| `a eql_v3.` | `query_bigint_eq` | |
| `b public.` | `eql_v3_bigint_eq` | |
Returns [#returns-1060]
**Type:** `boolean`
boolean
***
neq(eql_v3_bigint_eq, query_bigint_eq) [#neqeql_v3_bigint_eq-query_bigint_eq]
Operator wrapper for eql\_v3.query\_bigint\_eq.
Parameters [#parameters-1064]
| Name | Type | Description |
| ----------- | ------------------ | ----------- |
| `a public.` | `eql_v3_bigint_eq` | |
| `b eql_v3.` | `query_bigint_eq` | |
Returns [#returns-1061]
**Type:** `boolean`
boolean
***
neq(query_timestamp_eq, eql_v3_timestamp_eq) [#neqquery_timestamp_eq-eql_v3_timestamp_eq]
Operator wrapper for eql\_v3.query\_timestamp\_eq.
Parameters [#parameters-1065]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a eql_v3.` | `query_timestamp_eq` | |
| `b public.` | `eql_v3_timestamp_eq` | |
Returns [#returns-1062]
**Type:** `boolean`
boolean
***
neq(eql_v3_timestamp_eq, query_timestamp_eq) [#neqeql_v3_timestamp_eq-query_timestamp_eq]
Operator wrapper for eql\_v3.query\_timestamp\_eq.
Parameters [#parameters-1066]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_timestamp_eq` | |
| `b eql_v3.` | `query_timestamp_eq` | |
Returns [#returns-1063]
**Type:** `boolean`
boolean
***
neq(query_real_ord_ope, eql_v3_real_ord_ope) [#neqquery_real_ord_ope-eql_v3_real_ord_ope]
Operator wrapper for eql\_v3.query\_real\_ord\_ope.
Parameters [#parameters-1067]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a eql_v3.` | `query_real_ord_ope` | |
| `b public.` | `eql_v3_real_ord_ope` | |
Returns [#returns-1064]
**Type:** `boolean`
boolean
***
neq(eql_v3_real_ord_ope, query_real_ord_ope) [#neqeql_v3_real_ord_ope-query_real_ord_ope]
Operator wrapper for eql\_v3.query\_real\_ord\_ope.
Parameters [#parameters-1068]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_real_ord_ope` | |
| `b eql_v3.` | `query_real_ord_ope` | |
Returns [#returns-1065]
**Type:** `boolean`
boolean
***
neq(jsonb, eql_v3_numeric_eq) [#neqjsonb-eql_v3_numeric_eq]
Operator wrapper for public.eql\_v3\_numeric\_eq.
Parameters [#parameters-1069]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_numeric_eq` | |
Returns [#returns-1066]
**Type:** `boolean`
boolean
***
neq(eql_v3_numeric_eq, jsonb) [#neqeql_v3_numeric_eq-jsonb]
Operator wrapper for public.eql\_v3\_numeric\_eq.
Parameters [#parameters-1070]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a public.` | `eql_v3_numeric_eq` | |
| `b` | `jsonb` | |
Returns [#returns-1067]
**Type:** `boolean`
boolean
***
neq(eql_v3_numeric_eq, eql_v3_numeric_eq) [#neqeql_v3_numeric_eq-eql_v3_numeric_eq]
Operator wrapper for public.eql\_v3\_numeric\_eq.
Parameters [#parameters-1071]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a public.` | `eql_v3_numeric_eq` | |
| `b public.` | `eql_v3_numeric_eq` | |
Returns [#returns-1068]
**Type:** `boolean`
boolean
***
neq(jsonb, eql_v3_timestamp_ord) [#neqjsonb-eql_v3_timestamp_ord]
Operator wrapper for public.eql\_v3\_timestamp\_ord.
Parameters [#parameters-1072]
| Name | Type | Description |
| ----------- | ---------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_timestamp_ord` | |
Returns [#returns-1069]
**Type:** `boolean`
boolean
***
neq(eql_v3_timestamp_ord, jsonb) [#neqeql_v3_timestamp_ord-jsonb]
Operator wrapper for public.eql\_v3\_timestamp\_ord.
Parameters [#parameters-1073]
| Name | Type | Description |
| ----------- | ---------------------- | ----------- |
| `a public.` | `eql_v3_timestamp_ord` | |
| `b` | `jsonb` | |
Returns [#returns-1070]
**Type:** `boolean`
boolean
***
neq(eql_v3_timestamp_ord, eql_v3_timestamp_ord) [#neqeql_v3_timestamp_ord-eql_v3_timestamp_ord]
Operator wrapper for public.eql\_v3\_timestamp\_ord.
Parameters [#parameters-1074]
| Name | Type | Description |
| ----------- | ---------------------- | ----------- |
| `a public.` | `eql_v3_timestamp_ord` | |
| `b public.` | `eql_v3_timestamp_ord` | |
Returns [#returns-1071]
**Type:** `boolean`
boolean
***
neq(jsonb, eql_v3_smallint_ord_ope) [#neqjsonb-eql_v3_smallint_ord_ope]
Operator wrapper for public.eql\_v3\_smallint\_ord\_ope.
Parameters [#parameters-1075]
| Name | Type | Description |
| ----------- | ------------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_smallint_ord_ope` | |
Returns [#returns-1072]
**Type:** `boolean`
boolean
***
neq(eql_v3_smallint_ord_ope, jsonb) [#neqeql_v3_smallint_ord_ope-jsonb]
Operator wrapper for public.eql\_v3\_smallint\_ord\_ope.
Parameters [#parameters-1076]
| Name | Type | Description |
| ----------- | ------------------------- | ----------- |
| `a public.` | `eql_v3_smallint_ord_ope` | |
| `b` | `jsonb` | |
Returns [#returns-1073]
**Type:** `boolean`
boolean
***
neq(eql_v3_smallint_ord_ope, eql_v3_smallint_ord_ope) [#neqeql_v3_smallint_ord_ope-eql_v3_smallint_ord_ope]
Operator wrapper for public.eql\_v3\_smallint\_ord\_ope.
Parameters [#parameters-1077]
| Name | Type | Description |
| ----------- | ------------------------- | ----------- |
| `a public.` | `eql_v3_smallint_ord_ope` | |
| `b public.` | `eql_v3_smallint_ord_ope` | |
Returns [#returns-1074]
**Type:** `boolean`
boolean
***
neq(query_double_ord, eql_v3_double_ord) [#neqquery_double_ord-eql_v3_double_ord]
Operator wrapper for eql\_v3.query\_double\_ord.
Parameters [#parameters-1078]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a eql_v3.` | `query_double_ord` | |
| `b public.` | `eql_v3_double_ord` | |
Returns [#returns-1075]
**Type:** `boolean`
boolean
***
neq(eql_v3_double_ord, query_double_ord) [#neqeql_v3_double_ord-query_double_ord]
Operator wrapper for eql\_v3.query\_double\_ord.
Parameters [#parameters-1079]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a public.` | `eql_v3_double_ord` | |
| `b eql_v3.` | `query_double_ord` | |
Returns [#returns-1076]
**Type:** `boolean`
boolean
***
neq(query_date_eq, eql_v3_date_eq) [#neqquery_date_eq-eql_v3_date_eq]
Operator wrapper for eql\_v3.query\_date\_eq.
Parameters [#parameters-1080]
| Name | Type | Description |
| ----------- | ---------------- | ----------- |
| `a eql_v3.` | `query_date_eq` | |
| `b public.` | `eql_v3_date_eq` | |
Returns [#returns-1077]
**Type:** `boolean`
boolean
***
neq(eql_v3_date_eq, query_date_eq) [#neqeql_v3_date_eq-query_date_eq]
Operator wrapper for eql\_v3.query\_date\_eq.
Parameters [#parameters-1081]
| Name | Type | Description |
| ----------- | ---------------- | ----------- |
| `a public.` | `eql_v3_date_eq` | |
| `b eql_v3.` | `query_date_eq` | |
Returns [#returns-1078]
**Type:** `boolean`
boolean
***
neq(query_double_ord_ore, eql_v3_double_ord_ore) [#neqquery_double_ord_ore-eql_v3_double_ord_ore]
Operator wrapper for eql\_v3.query\_double\_ord\_ore.
Parameters [#parameters-1082]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a eql_v3.` | `query_double_ord_ore` | |
| `b public.` | `eql_v3_double_ord_ore` | |
Returns [#returns-1079]
**Type:** `boolean`
boolean
***
neq(eql_v3_double_ord_ore, query_double_ord_ore) [#neqeql_v3_double_ord_ore-query_double_ord_ore]
Operator wrapper for eql\_v3.query\_double\_ord\_ore.
Parameters [#parameters-1083]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a public.` | `eql_v3_double_ord_ore` | |
| `b eql_v3.` | `query_double_ord_ore` | |
Returns [#returns-1080]
**Type:** `boolean`
boolean
***
neq(jsonb, eql_v3_timestamp_ord_ore) [#neqjsonb-eql_v3_timestamp_ord_ore]
Operator wrapper for public.eql\_v3\_timestamp\_ord\_ore.
Parameters [#parameters-1084]
| Name | Type | Description |
| ----------- | -------------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_timestamp_ord_ore` | |
Returns [#returns-1081]
**Type:** `boolean`
boolean
***
neq(eql_v3_timestamp_ord_ore, jsonb) [#neqeql_v3_timestamp_ord_ore-jsonb]
Operator wrapper for public.eql\_v3\_timestamp\_ord\_ore.
Parameters [#parameters-1085]
| Name | Type | Description |
| ----------- | -------------------------- | ----------- |
| `a public.` | `eql_v3_timestamp_ord_ore` | |
| `b` | `jsonb` | |
Returns [#returns-1082]
**Type:** `boolean`
boolean
***
neq(eql_v3_timestamp_ord_ore, eql_v3_timestamp_ord_ore) [#neqeql_v3_timestamp_ord_ore-eql_v3_timestamp_ord_ore]
Operator wrapper for public.eql\_v3\_timestamp\_ord\_ore.
Parameters [#parameters-1086]
| Name | Type | Description |
| ----------- | -------------------------- | ----------- |
| `a public.` | `eql_v3_timestamp_ord_ore` | |
| `b public.` | `eql_v3_timestamp_ord_ore` | |
Returns [#returns-1083]
**Type:** `boolean`
boolean
***
neq(jsonb, eql_v3_text_search) [#neqjsonb-eql_v3_text_search]
Operator wrapper for public.eql\_v3\_text\_search.
Parameters [#parameters-1087]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_text_search` | |
Returns [#returns-1084]
**Type:** `boolean`
boolean
***
neq(eql_v3_text_search, jsonb) [#neqeql_v3_text_search-jsonb]
Operator wrapper for public.eql\_v3\_text\_search.
Parameters [#parameters-1088]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a public.` | `eql_v3_text_search` | |
| `b` | `jsonb` | |
Returns [#returns-1085]
**Type:** `boolean`
boolean
***
neq(eql_v3_text_search, eql_v3_text_search) [#neqeql_v3_text_search-eql_v3_text_search]
Operator wrapper for public.eql\_v3\_text\_search.
Parameters [#parameters-1089]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a public.` | `eql_v3_text_search` | |
| `b public.` | `eql_v3_text_search` | |
Returns [#returns-1086]
**Type:** `boolean`
boolean
***
neq(query_numeric_ord_ore, eql_v3_numeric_ord_ore) [#neqquery_numeric_ord_ore-eql_v3_numeric_ord_ore]
Operator wrapper for eql\_v3.query\_numeric\_ord\_ore.
Parameters [#parameters-1090]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a eql_v3.` | `query_numeric_ord_ore` | |
| `b public.` | `eql_v3_numeric_ord_ore` | |
Returns [#returns-1087]
**Type:** `boolean`
boolean
***
neq(eql_v3_numeric_ord_ore, query_numeric_ord_ore) [#neqeql_v3_numeric_ord_ore-query_numeric_ord_ore]
Operator wrapper for eql\_v3.query\_numeric\_ord\_ore.
Parameters [#parameters-1091]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a public.` | `eql_v3_numeric_ord_ore` | |
| `b eql_v3.` | `query_numeric_ord_ore` | |
Returns [#returns-1088]
**Type:** `boolean`
boolean
***
neq(jsonb, eql_v3_smallint_eq) [#neqjsonb-eql_v3_smallint_eq]
Operator wrapper for public.eql\_v3\_smallint\_eq.
Parameters [#parameters-1092]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_smallint_eq` | |
Returns [#returns-1089]
**Type:** `boolean`
boolean
***
neq(eql_v3_smallint_eq, jsonb) [#neqeql_v3_smallint_eq-jsonb]
Operator wrapper for public.eql\_v3\_smallint\_eq.
Parameters [#parameters-1093]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a public.` | `eql_v3_smallint_eq` | |
| `b` | `jsonb` | |
Returns [#returns-1090]
**Type:** `boolean`
boolean
***
neq(eql_v3_smallint_eq, eql_v3_smallint_eq) [#neqeql_v3_smallint_eq-eql_v3_smallint_eq]
Operator wrapper for public.eql\_v3\_smallint\_eq.
Parameters [#parameters-1094]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a public.` | `eql_v3_smallint_eq` | |
| `b public.` | `eql_v3_smallint_eq` | |
Returns [#returns-1091]
**Type:** `boolean`
boolean
***
neq(query_bigint_ord_ore, eql_v3_bigint_ord_ore) [#neqquery_bigint_ord_ore-eql_v3_bigint_ord_ore]
Operator wrapper for eql\_v3.query\_bigint\_ord\_ore.
Parameters [#parameters-1095]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a eql_v3.` | `query_bigint_ord_ore` | |
| `b public.` | `eql_v3_bigint_ord_ore` | |
Returns [#returns-1092]
**Type:** `boolean`
boolean
***
neq(eql_v3_bigint_ord_ore, query_bigint_ord_ore) [#neqeql_v3_bigint_ord_ore-query_bigint_ord_ore]
Operator wrapper for eql\_v3.query\_bigint\_ord\_ore.
Parameters [#parameters-1096]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a public.` | `eql_v3_bigint_ord_ore` | |
| `b eql_v3.` | `query_bigint_ord_ore` | |
Returns [#returns-1093]
**Type:** `boolean`
boolean
***
neq(query_bigint_ord_ope, eql_v3_bigint_ord_ope) [#neqquery_bigint_ord_ope-eql_v3_bigint_ord_ope]
Operator wrapper for eql\_v3.query\_bigint\_ord\_ope.
Parameters [#parameters-1097]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a eql_v3.` | `query_bigint_ord_ope` | |
| `b public.` | `eql_v3_bigint_ord_ope` | |
Returns [#returns-1094]
**Type:** `boolean`
boolean
***
neq(eql_v3_bigint_ord_ope, query_bigint_ord_ope) [#neqeql_v3_bigint_ord_ope-query_bigint_ord_ope]
Operator wrapper for eql\_v3.query\_bigint\_ord\_ope.
Parameters [#parameters-1098]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a public.` | `eql_v3_bigint_ord_ope` | |
| `b eql_v3.` | `query_bigint_ord_ope` | |
Returns [#returns-1095]
**Type:** `boolean`
boolean
***
neq(query_date_ord_ore, eql_v3_date_ord_ore) [#neqquery_date_ord_ore-eql_v3_date_ord_ore]
Operator wrapper for eql\_v3.query\_date\_ord\_ore.
Parameters [#parameters-1099]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a eql_v3.` | `query_date_ord_ore` | |
| `b public.` | `eql_v3_date_ord_ore` | |
Returns [#returns-1096]
**Type:** `boolean`
boolean
***
neq(eql_v3_date_ord_ore, query_date_ord_ore) [#neqeql_v3_date_ord_ore-query_date_ord_ore]
Operator wrapper for eql\_v3.query\_date\_ord\_ore.
Parameters [#parameters-1100]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_date_ord_ore` | |
| `b eql_v3.` | `query_date_ord_ore` | |
Returns [#returns-1097]
**Type:** `boolean`
boolean
***
neq(query_smallint_ord_ope, eql_v3_smallint_ord_ope) [#neqquery_smallint_ord_ope-eql_v3_smallint_ord_ope]
Operator wrapper for eql\_v3.query\_smallint\_ord\_ope.
Parameters [#parameters-1101]
| Name | Type | Description |
| ----------- | ------------------------- | ----------- |
| `a eql_v3.` | `query_smallint_ord_ope` | |
| `b public.` | `eql_v3_smallint_ord_ope` | |
Returns [#returns-1098]
**Type:** `boolean`
boolean
***
neq(eql_v3_smallint_ord_ope, query_smallint_ord_ope) [#neqeql_v3_smallint_ord_ope-query_smallint_ord_ope]
Operator wrapper for eql\_v3.query\_smallint\_ord\_ope.
Parameters [#parameters-1102]
| Name | Type | Description |
| ----------- | ------------------------- | ----------- |
| `a public.` | `eql_v3_smallint_ord_ope` | |
| `b eql_v3.` | `query_smallint_ord_ope` | |
Returns [#returns-1099]
**Type:** `boolean`
boolean
***
neq(jsonb, eql_v3_double_ord) [#neqjsonb-eql_v3_double_ord]
Operator wrapper for public.eql\_v3\_double\_ord.
Parameters [#parameters-1103]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_double_ord` | |
Returns [#returns-1100]
**Type:** `boolean`
boolean
***
neq(eql_v3_double_ord, jsonb) [#neqeql_v3_double_ord-jsonb]
Operator wrapper for public.eql\_v3\_double\_ord.
Parameters [#parameters-1104]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a public.` | `eql_v3_double_ord` | |
| `b` | `jsonb` | |
Returns [#returns-1101]
**Type:** `boolean`
boolean
***
neq(eql_v3_double_ord, eql_v3_double_ord) [#neqeql_v3_double_ord-eql_v3_double_ord]
Operator wrapper for public.eql\_v3\_double\_ord.
Parameters [#parameters-1105]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a public.` | `eql_v3_double_ord` | |
| `b public.` | `eql_v3_double_ord` | |
Returns [#returns-1102]
**Type:** `boolean`
boolean
***
neq(query_numeric_ord_ope, eql_v3_numeric_ord_ope) [#neqquery_numeric_ord_ope-eql_v3_numeric_ord_ope]
Operator wrapper for eql\_v3.query\_numeric\_ord\_ope.
Parameters [#parameters-1106]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a eql_v3.` | `query_numeric_ord_ope` | |
| `b public.` | `eql_v3_numeric_ord_ope` | |
Returns [#returns-1103]
**Type:** `boolean`
boolean
***
neq(eql_v3_numeric_ord_ope, query_numeric_ord_ope) [#neqeql_v3_numeric_ord_ope-query_numeric_ord_ope]
Operator wrapper for eql\_v3.query\_numeric\_ord\_ope.
Parameters [#parameters-1107]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a public.` | `eql_v3_numeric_ord_ope` | |
| `b eql_v3.` | `query_numeric_ord_ope` | |
Returns [#returns-1104]
**Type:** `boolean`
boolean
***
neq(jsonb, eql_v3_date_eq) [#neqjsonb-eql_v3_date_eq]
Operator wrapper for public.eql\_v3\_date\_eq.
Parameters [#parameters-1108]
| Name | Type | Description |
| ----------- | ---------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_date_eq` | |
Returns [#returns-1105]
**Type:** `boolean`
boolean
***
neq(eql_v3_date_eq, jsonb) [#neqeql_v3_date_eq-jsonb]
Operator wrapper for public.eql\_v3\_date\_eq.
Parameters [#parameters-1109]
| Name | Type | Description |
| ----------- | ---------------- | ----------- |
| `a public.` | `eql_v3_date_eq` | |
| `b` | `jsonb` | |
Returns [#returns-1106]
**Type:** `boolean`
boolean
***
neq(eql_v3_date_eq, eql_v3_date_eq) [#neqeql_v3_date_eq-eql_v3_date_eq]
Operator wrapper for public.eql\_v3\_date\_eq.
Parameters [#parameters-1110]
| Name | Type | Description |
| ----------- | ---------------- | ----------- |
| `a public.` | `eql_v3_date_eq` | |
| `b public.` | `eql_v3_date_eq` | |
Returns [#returns-1107]
**Type:** `boolean`
boolean
***
neq(jsonb, eql_v3_double_ord_ope) [#neqjsonb-eql_v3_double_ord_ope]
Operator wrapper for public.eql\_v3\_double\_ord\_ope.
Parameters [#parameters-1111]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_double_ord_ope` | |
Returns [#returns-1108]
**Type:** `boolean`
boolean
***
neq(eql_v3_double_ord_ope, jsonb) [#neqeql_v3_double_ord_ope-jsonb]
Operator wrapper for public.eql\_v3\_double\_ord\_ope.
Parameters [#parameters-1112]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a public.` | `eql_v3_double_ord_ope` | |
| `b` | `jsonb` | |
Returns [#returns-1109]
**Type:** `boolean`
boolean
***
neq(eql_v3_double_ord_ope, eql_v3_double_ord_ope) [#neqeql_v3_double_ord_ope-eql_v3_double_ord_ope]
Operator wrapper for public.eql\_v3\_double\_ord\_ope.
Parameters [#parameters-1113]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a public.` | `eql_v3_double_ord_ope` | |
| `b public.` | `eql_v3_double_ord_ope` | |
Returns [#returns-1110]
**Type:** `boolean`
boolean
***
neq(jsonb, eql_v3_numeric_ord_ope) [#neqjsonb-eql_v3_numeric_ord_ope]
Operator wrapper for public.eql\_v3\_numeric\_ord\_ope.
Parameters [#parameters-1114]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_numeric_ord_ope` | |
Returns [#returns-1111]
**Type:** `boolean`
boolean
***
neq(eql_v3_numeric_ord_ope, jsonb) [#neqeql_v3_numeric_ord_ope-jsonb]
Operator wrapper for public.eql\_v3\_numeric\_ord\_ope.
Parameters [#parameters-1115]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a public.` | `eql_v3_numeric_ord_ope` | |
| `b` | `jsonb` | |
Returns [#returns-1112]
**Type:** `boolean`
boolean
***
neq(eql_v3_numeric_ord_ope, eql_v3_numeric_ord_ope) [#neqeql_v3_numeric_ord_ope-eql_v3_numeric_ord_ope]
Operator wrapper for public.eql\_v3\_numeric\_ord\_ope.
Parameters [#parameters-1116]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a public.` | `eql_v3_numeric_ord_ope` | |
| `b public.` | `eql_v3_numeric_ord_ope` | |
Returns [#returns-1113]
**Type:** `boolean`
boolean
***
neq(jsonb, eql_v3_date_ord_ore) [#neqjsonb-eql_v3_date_ord_ore]
Operator wrapper for public.eql\_v3\_date\_ord\_ore.
Parameters [#parameters-1117]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_date_ord_ore` | |
Returns [#returns-1114]
**Type:** `boolean`
boolean
***
neq(eql_v3_date_ord_ore, jsonb) [#neqeql_v3_date_ord_ore-jsonb]
Operator wrapper for public.eql\_v3\_date\_ord\_ore.
Parameters [#parameters-1118]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_date_ord_ore` | |
| `b` | `jsonb` | |
Returns [#returns-1115]
**Type:** `boolean`
boolean
***
neq(eql_v3_date_ord_ore, eql_v3_date_ord_ore) [#neqeql_v3_date_ord_ore-eql_v3_date_ord_ore]
Operator wrapper for public.eql\_v3\_date\_ord\_ore.
Parameters [#parameters-1119]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_date_ord_ore` | |
| `b public.` | `eql_v3_date_ord_ore` | |
Returns [#returns-1116]
**Type:** `boolean`
boolean
***
neq(query_timestamp_ord, eql_v3_timestamp_ord) [#neqquery_timestamp_ord-eql_v3_timestamp_ord]
Operator wrapper for eql\_v3.query\_timestamp\_ord.
Parameters [#parameters-1120]
| Name | Type | Description |
| ----------- | ---------------------- | ----------- |
| `a eql_v3.` | `query_timestamp_ord` | |
| `b public.` | `eql_v3_timestamp_ord` | |
Returns [#returns-1117]
**Type:** `boolean`
boolean
***
neq(eql_v3_timestamp_ord, query_timestamp_ord) [#neqeql_v3_timestamp_ord-query_timestamp_ord]
Operator wrapper for eql\_v3.query\_timestamp\_ord.
Parameters [#parameters-1121]
| Name | Type | Description |
| ----------- | ---------------------- | ----------- |
| `a public.` | `eql_v3_timestamp_ord` | |
| `b eql_v3.` | `query_timestamp_ord` | |
Returns [#returns-1118]
**Type:** `boolean`
boolean
***
neq(jsonb, eql_v3_text_eq) [#neqjsonb-eql_v3_text_eq]
Operator wrapper for public.eql\_v3\_text\_eq.
Parameters [#parameters-1122]
| Name | Type | Description |
| ----------- | ---------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_text_eq` | |
Returns [#returns-1119]
**Type:** `boolean`
boolean
***
neq(eql_v3_text_eq, jsonb) [#neqeql_v3_text_eq-jsonb]
Operator wrapper for public.eql\_v3\_text\_eq.
Parameters [#parameters-1123]
| Name | Type | Description |
| ----------- | ---------------- | ----------- |
| `a public.` | `eql_v3_text_eq` | |
| `b` | `jsonb` | |
Returns [#returns-1120]
**Type:** `boolean`
boolean
***
neq(eql_v3_text_eq, eql_v3_text_eq) [#neqeql_v3_text_eq-eql_v3_text_eq]
Operator wrapper for public.eql\_v3\_text\_eq.
Parameters [#parameters-1124]
| Name | Type | Description |
| ----------- | ---------------- | ----------- |
| `a public.` | `eql_v3_text_eq` | |
| `b public.` | `eql_v3_text_eq` | |
Returns [#returns-1121]
**Type:** `boolean`
boolean
***
neq(jsonb, eql_v3_integer_eq) [#neqjsonb-eql_v3_integer_eq]
Operator wrapper for public.eql\_v3\_integer\_eq.
Parameters [#parameters-1125]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_integer_eq` | |
Returns [#returns-1122]
**Type:** `boolean`
boolean
***
neq(eql_v3_integer_eq, jsonb) [#neqeql_v3_integer_eq-jsonb]
Operator wrapper for public.eql\_v3\_integer\_eq.
Parameters [#parameters-1126]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a public.` | `eql_v3_integer_eq` | |
| `b` | `jsonb` | |
Returns [#returns-1123]
**Type:** `boolean`
boolean
***
neq(eql_v3_integer_eq, eql_v3_integer_eq) [#neqeql_v3_integer_eq-eql_v3_integer_eq]
Operator wrapper for public.eql\_v3\_integer\_eq.
Parameters [#parameters-1127]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a public.` | `eql_v3_integer_eq` | |
| `b public.` | `eql_v3_integer_eq` | |
Returns [#returns-1124]
**Type:** `boolean`
boolean
***
neq(query_integer_eq, eql_v3_integer_eq) [#neqquery_integer_eq-eql_v3_integer_eq]
Operator wrapper for eql\_v3.query\_integer\_eq.
Parameters [#parameters-1128]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a eql_v3.` | `query_integer_eq` | |
| `b public.` | `eql_v3_integer_eq` | |
Returns [#returns-1125]
**Type:** `boolean`
boolean
***
neq(eql_v3_integer_eq, query_integer_eq) [#neqeql_v3_integer_eq-query_integer_eq]
Operator wrapper for eql\_v3.query\_integer\_eq.
Parameters [#parameters-1129]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a public.` | `eql_v3_integer_eq` | |
| `b eql_v3.` | `query_integer_eq` | |
Returns [#returns-1126]
**Type:** `boolean`
boolean
***
neq(jsonb, eql_v3_smallint_ord_ore) [#neqjsonb-eql_v3_smallint_ord_ore]
Operator wrapper for public.eql\_v3\_smallint\_ord\_ore.
Parameters [#parameters-1130]
| Name | Type | Description |
| ----------- | ------------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_smallint_ord_ore` | |
Returns [#returns-1127]
**Type:** `boolean`
boolean
***
neq(eql_v3_smallint_ord_ore, jsonb) [#neqeql_v3_smallint_ord_ore-jsonb]
Operator wrapper for public.eql\_v3\_smallint\_ord\_ore.
Parameters [#parameters-1131]
| Name | Type | Description |
| ----------- | ------------------------- | ----------- |
| `a public.` | `eql_v3_smallint_ord_ore` | |
| `b` | `jsonb` | |
Returns [#returns-1128]
**Type:** `boolean`
boolean
***
neq(eql_v3_smallint_ord_ore, eql_v3_smallint_ord_ore) [#neqeql_v3_smallint_ord_ore-eql_v3_smallint_ord_ore]
Operator wrapper for public.eql\_v3\_smallint\_ord\_ore.
Parameters [#parameters-1132]
| Name | Type | Description |
| ----------- | ------------------------- | ----------- |
| `a public.` | `eql_v3_smallint_ord_ore` | |
| `b public.` | `eql_v3_smallint_ord_ore` | |
Returns [#returns-1129]
**Type:** `boolean`
boolean
***
neq(jsonb, eql_v3_date_ord_ope) [#neqjsonb-eql_v3_date_ord_ope]
Operator wrapper for public.eql\_v3\_date\_ord\_ope.
Parameters [#parameters-1133]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_date_ord_ope` | |
Returns [#returns-1130]
**Type:** `boolean`
boolean
***
neq(eql_v3_date_ord_ope, jsonb) [#neqeql_v3_date_ord_ope-jsonb]
Operator wrapper for public.eql\_v3\_date\_ord\_ope.
Parameters [#parameters-1134]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_date_ord_ope` | |
| `b` | `jsonb` | |
Returns [#returns-1131]
**Type:** `boolean`
boolean
***
neq(eql_v3_date_ord_ope, eql_v3_date_ord_ope) [#neqeql_v3_date_ord_ope-eql_v3_date_ord_ope]
Operator wrapper for public.eql\_v3\_date\_ord\_ope.
Parameters [#parameters-1135]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_date_ord_ope` | |
| `b public.` | `eql_v3_date_ord_ope` | |
Returns [#returns-1132]
**Type:** `boolean`
boolean
***
neq(query_bigint_ord, eql_v3_bigint_ord) [#neqquery_bigint_ord-eql_v3_bigint_ord]
Operator wrapper for eql\_v3.query\_bigint\_ord.
Parameters [#parameters-1136]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a eql_v3.` | `query_bigint_ord` | |
| `b public.` | `eql_v3_bigint_ord` | |
Returns [#returns-1133]
**Type:** `boolean`
boolean
***
neq(eql_v3_bigint_ord, query_bigint_ord) [#neqeql_v3_bigint_ord-query_bigint_ord]
Operator wrapper for eql\_v3.query\_bigint\_ord.
Parameters [#parameters-1137]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a public.` | `eql_v3_bigint_ord` | |
| `b eql_v3.` | `query_bigint_ord` | |
Returns [#returns-1134]
**Type:** `boolean`
boolean
***
neq(jsonb, eql_v3_text_ord_ore) [#neqjsonb-eql_v3_text_ord_ore]
Operator wrapper for public.eql\_v3\_text\_ord\_ore.
Parameters [#parameters-1138]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a` | `jsonb` | |
| `b public.` | `eql_v3_text_ord_ore` | |
Returns [#returns-1135]
**Type:** `boolean`
boolean
***
neq(eql_v3_text_ord_ore, jsonb) [#neqeql_v3_text_ord_ore-jsonb]
Operator wrapper for public.eql\_v3\_text\_ord\_ore.
Parameters [#parameters-1139]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_text_ord_ore` | |
| `b` | `jsonb` | |
Returns [#returns-1136]
**Type:** `boolean`
boolean
***
neq(eql_v3_text_ord_ore, eql_v3_text_ord_ore) [#neqeql_v3_text_ord_ore-eql_v3_text_ord_ore]
Operator wrapper for public.eql\_v3\_text\_ord\_ore.
Parameters [#parameters-1140]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_text_ord_ore` | |
| `b public.` | `eql_v3_text_ord_ore` | |
Returns [#returns-1137]
**Type:** `boolean`
boolean
***
ope_term(eql_v3_json_entry) [#ope_termeql_v3_json_entry]
Low-level deterministic OPE byte extractor for a json entry.
Returns the bytea of the entry's deterministic op (CLLW OPE) term, or NULL for a term-less entry (a value entry, or a bool/null/structural path entry — which carry no term because exact matching there is selector presence, not a per-entry term). Entry-to-entry = / \<> are blocked: these bytes are an ordering encoding, not an exact equality representation.
op is deterministic (equal plaintext at a fixed selector ⇒ equal bytes), so byte equality on it is a sound equality for number/string leaves — with the same encoding caveat as the scalar \_ord surface (f64 rounding, string collation make it lossy for bigint/numeric/text). Exact, loss-free equality on a JSON field is selector presence (containment / the value selector), not this term. This extractor remains available only for callers that deliberately need encoded OPE-equivalence buckets. hm is retired — entries no longer carry it.
Parameters [#parameters-1141]
| Name | Type | Description |
| --------------- | ------------------- | ----------- |
| `entry public.` | `eql_v3_json_entry` | |
Returns [#returns-1138]
**Type:** `bytea`
bytea Decoded op bytes (NULL if the entry has no op, or is NULL).
***
ord_term(query_smallint_ord) [#ord_termquery_smallint_ord]
Index extractor for eql\_v3.query\_smallint\_ord.
Parameters [#parameters-1142]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a eql_v3.` | `query_smallint_ord` | |
Returns [#returns-1139]
**Type:** `eql_v3_internal.ope_cllw`
eql\_v3\_internal.ope\_cllw
***
ord_term(eql_v3_smallint_ord) [#ord_termeql_v3_smallint_ord]
Index extractor for public.eql\_v3\_smallint\_ord.
Parameters [#parameters-1143]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_smallint_ord` | |
Returns [#returns-1140]
**Type:** `eql_v3_internal.ope_cllw`
eql\_v3\_internal.ope\_cllw
***
ord_term(eql_v3_date_ord) [#ord_termeql_v3_date_ord]
Index extractor for public.eql\_v3\_date\_ord.
Parameters [#parameters-1144]
| Name | Type | Description |
| ----------- | ----------------- | ----------- |
| `a public.` | `eql_v3_date_ord` | |
Returns [#returns-1141]
**Type:** `eql_v3_internal.ope_cllw`
eql\_v3\_internal.ope\_cllw
***
ord_term(query_real_ord) [#ord_termquery_real_ord]
Index extractor for eql\_v3.query\_real\_ord.
Parameters [#parameters-1145]
| Name | Type | Description |
| ----------- | ---------------- | ----------- |
| `a eql_v3.` | `query_real_ord` | |
Returns [#returns-1142]
**Type:** `eql_v3_internal.ope_cllw`
eql\_v3\_internal.ope\_cllw
***
ord_term(eql_v3_text_ord) [#ord_termeql_v3_text_ord]
Index extractor for public.eql\_v3\_text\_ord.
Parameters [#parameters-1146]
| Name | Type | Description |
| ----------- | ----------------- | ----------- |
| `a public.` | `eql_v3_text_ord` | |
Returns [#returns-1143]
**Type:** `eql_v3_internal.ope_cllw`
eql\_v3\_internal.ope\_cllw
***
ord_term(query_integer_ord_ope) [#ord_termquery_integer_ord_ope]
Index extractor for eql\_v3.query\_integer\_ord\_ope.
Parameters [#parameters-1147]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a eql_v3.` | `query_integer_ord_ope` | |
Returns [#returns-1144]
**Type:** `eql_v3_internal.ope_cllw`
eql\_v3\_internal.ope\_cllw
***
ord_term(query_text_ord) [#ord_termquery_text_ord]
Index extractor for eql\_v3.query\_text\_ord.
Parameters [#parameters-1148]
| Name | Type | Description |
| ----------- | ---------------- | ----------- |
| `a eql_v3.` | `query_text_ord` | |
Returns [#returns-1145]
**Type:** `eql_v3_internal.ope_cllw`
eql\_v3\_internal.ope\_cllw
***
ord_term(eql_v3_timestamp_ord_ope) [#ord_termeql_v3_timestamp_ord_ope]
Index extractor for public.eql\_v3\_timestamp\_ord\_ope.
Parameters [#parameters-1149]
| Name | Type | Description |
| ----------- | -------------------------- | ----------- |
| `a public.` | `eql_v3_timestamp_ord_ope` | |
Returns [#returns-1146]
**Type:** `eql_v3_internal.ope_cllw`
eql\_v3\_internal.ope\_cllw
***
ord_term(eql_v3_integer_ord_ope) [#ord_termeql_v3_integer_ord_ope]
Index extractor for public.eql\_v3\_integer\_ord\_ope.
Parameters [#parameters-1150]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a public.` | `eql_v3_integer_ord_ope` | |
Returns [#returns-1147]
**Type:** `eql_v3_internal.ope_cllw`
eql\_v3\_internal.ope\_cllw
***
ord_term(query_integer_ord) [#ord_termquery_integer_ord]
Index extractor for eql\_v3.query\_integer\_ord.
Parameters [#parameters-1151]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a eql_v3.` | `query_integer_ord` | |
Returns [#returns-1148]
**Type:** `eql_v3_internal.ope_cllw`
eql\_v3\_internal.ope\_cllw
***
ord_term(query_text_search) [#ord_termquery_text_search]
Index extractor for eql\_v3.query\_text\_search.
Parameters [#parameters-1152]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a eql_v3.` | `query_text_search` | |
Returns [#returns-1149]
**Type:** `eql_v3_internal.ope_cllw`
eql\_v3\_internal.ope\_cllw
***
ord_term(eql_v3_numeric_ord) [#ord_termeql_v3_numeric_ord]
Index extractor for public.eql\_v3\_numeric\_ord.
Parameters [#parameters-1153]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a public.` | `eql_v3_numeric_ord` | |
Returns [#returns-1150]
**Type:** `eql_v3_internal.ope_cllw`
eql\_v3\_internal.ope\_cllw
***
ord_term(query_date_ord_ope) [#ord_termquery_date_ord_ope]
Index extractor for eql\_v3.query\_date\_ord\_ope.
Parameters [#parameters-1154]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a eql_v3.` | `query_date_ord_ope` | |
Returns [#returns-1151]
**Type:** `eql_v3_internal.ope_cllw`
eql\_v3\_internal.ope\_cllw
***
ord_term(eql_v3_real_ord_ope) [#ord_termeql_v3_real_ord_ope]
Index extractor for public.eql\_v3\_real\_ord\_ope.
Parameters [#parameters-1155]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_real_ord_ope` | |
Returns [#returns-1152]
**Type:** `eql_v3_internal.ope_cllw`
eql\_v3\_internal.ope\_cllw
***
ord_term(eql_v3_real_ord) [#ord_termeql_v3_real_ord]
Index extractor for public.eql\_v3\_real\_ord.
Parameters [#parameters-1156]
| Name | Type | Description |
| ----------- | ----------------- | ----------- |
| `a public.` | `eql_v3_real_ord` | |
Returns [#returns-1153]
**Type:** `eql_v3_internal.ope_cllw`
eql\_v3\_internal.ope\_cllw
***
ord_term(eql_v3_integer_ord) [#ord_termeql_v3_integer_ord]
Index extractor for public.eql\_v3\_integer\_ord.
Parameters [#parameters-1157]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a public.` | `eql_v3_integer_ord` | |
Returns [#returns-1154]
**Type:** `eql_v3_internal.ope_cllw`
eql\_v3\_internal.ope\_cllw
***
ord_term(eql_v3_text_ord_ope) [#ord_termeql_v3_text_ord_ope]
Index extractor for public.eql\_v3\_text\_ord\_ope.
Parameters [#parameters-1158]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_text_ord_ope` | |
Returns [#returns-1155]
**Type:** `eql_v3_internal.ope_cllw`
eql\_v3\_internal.ope\_cllw
***
ord_term(query_double_ord_ope) [#ord_termquery_double_ord_ope]
Index extractor for eql\_v3.query\_double\_ord\_ope.
Parameters [#parameters-1159]
| Name | Type | Description |
| ----------- | ---------------------- | ----------- |
| `a eql_v3.` | `query_double_ord_ope` | |
Returns [#returns-1156]
**Type:** `eql_v3_internal.ope_cllw`
eql\_v3\_internal.ope\_cllw
***
ord_term(query_date_ord) [#ord_termquery_date_ord]
Index extractor for eql\_v3.query\_date\_ord.
Parameters [#parameters-1160]
| Name | Type | Description |
| ----------- | ---------------- | ----------- |
| `a eql_v3.` | `query_date_ord` | |
Returns [#returns-1157]
**Type:** `eql_v3_internal.ope_cllw`
eql\_v3\_internal.ope\_cllw
***
ord_term(eql_v3_json_entry) [#ord_termeql_v3_json_entry]
Extract the CLLW OPE index term from a ste\_vec entry.
An sv-element op term is only ever present on an sv element, never at a root encrypted value, so the typed overload accepts public.eql\_v3\_json\_entry — the jsonb\_entry twin of the generated scalar eql\_v3.ord\_term extractors. Returns SQL NULL when op is absent (the strict ->> / decode chain propagates it), so btree NULL-filters such rows from range queries. The returned eql\_v3\_internal.ope\_cllw is a bytea domain: it orders under native byte comparison with the DEFAULT btree opclass, so a functional index on eql\_v3.ord\_term(col -> 'selector)\` engages structurally with no custom operator class (Supabase/managed-Postgres safe).
Parameters [#parameters-1161]
| Name | Type | Description |
| --------------- | ------------------- | ----------- |
| `entry public.` | `eql_v3_json_entry` | |
Returns [#returns-1158]
**Type:** `eql_v3_internal.ope_cllw`
eql\_v3\_internal.ope\_cllw Hex-decoded CLLW OPE term, or NULL when op is absent.
***
ord_term(query_text_ord_ope) [#ord_termquery_text_ord_ope]
Index extractor for eql\_v3.query\_text\_ord\_ope.
Parameters [#parameters-1162]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a eql_v3.` | `query_text_ord_ope` | |
Returns [#returns-1159]
**Type:** `eql_v3_internal.ope_cllw`
eql\_v3\_internal.ope\_cllw
***
ord_term(eql_v3_bigint_ord_ope) [#ord_termeql_v3_bigint_ord_ope]
Index extractor for public.eql\_v3\_bigint\_ord\_ope.
Parameters [#parameters-1163]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a public.` | `eql_v3_bigint_ord_ope` | |
Returns [#returns-1160]
**Type:** `eql_v3_internal.ope_cllw`
eql\_v3\_internal.ope\_cllw
***
ord_term(eql_v3_bigint_ord) [#ord_termeql_v3_bigint_ord]
Index extractor for public.eql\_v3\_bigint\_ord.
Parameters [#parameters-1164]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a public.` | `eql_v3_bigint_ord` | |
Returns [#returns-1161]
**Type:** `eql_v3_internal.ope_cllw`
eql\_v3\_internal.ope\_cllw
***
ord_term(query_timestamp_ord_ope) [#ord_termquery_timestamp_ord_ope]
Index extractor for eql\_v3.query\_timestamp\_ord\_ope.
Parameters [#parameters-1165]
| Name | Type | Description |
| ----------- | ------------------------- | ----------- |
| `a eql_v3.` | `query_timestamp_ord_ope` | |
Returns [#returns-1162]
**Type:** `eql_v3_internal.ope_cllw`
eql\_v3\_internal.ope\_cllw
***
ord_term(query_numeric_ord) [#ord_termquery_numeric_ord]
Index extractor for eql\_v3.query\_numeric\_ord.
Parameters [#parameters-1166]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a eql_v3.` | `query_numeric_ord` | |
Returns [#returns-1163]
**Type:** `eql_v3_internal.ope_cllw`
eql\_v3\_internal.ope\_cllw
***
ord_term(query_real_ord_ope) [#ord_termquery_real_ord_ope]
Index extractor for eql\_v3.query\_real\_ord\_ope.
Parameters [#parameters-1167]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a eql_v3.` | `query_real_ord_ope` | |
Returns [#returns-1164]
**Type:** `eql_v3_internal.ope_cllw`
eql\_v3\_internal.ope\_cllw
***
ord_term(eql_v3_timestamp_ord) [#ord_termeql_v3_timestamp_ord]
Index extractor for public.eql\_v3\_timestamp\_ord.
Parameters [#parameters-1168]
| Name | Type | Description |
| ----------- | ---------------------- | ----------- |
| `a public.` | `eql_v3_timestamp_ord` | |
Returns [#returns-1165]
**Type:** `eql_v3_internal.ope_cllw`
eql\_v3\_internal.ope\_cllw
***
ord_term(eql_v3_smallint_ord_ope) [#ord_termeql_v3_smallint_ord_ope]
Index extractor for public.eql\_v3\_smallint\_ord\_ope.
Parameters [#parameters-1169]
| Name | Type | Description |
| ----------- | ------------------------- | ----------- |
| `a public.` | `eql_v3_smallint_ord_ope` | |
Returns [#returns-1166]
**Type:** `eql_v3_internal.ope_cllw`
eql\_v3\_internal.ope\_cllw
***
ord_term(query_double_ord) [#ord_termquery_double_ord]
Index extractor for eql\_v3.query\_double\_ord.
Parameters [#parameters-1170]
| Name | Type | Description |
| ----------- | ------------------ | ----------- |
| `a eql_v3.` | `query_double_ord` | |
Returns [#returns-1167]
**Type:** `eql_v3_internal.ope_cllw`
eql\_v3\_internal.ope\_cllw
***
ord_term(eql_v3_text_search) [#ord_termeql_v3_text_search]
Index extractor for public.eql\_v3\_text\_search.
Parameters [#parameters-1171]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a public.` | `eql_v3_text_search` | |
Returns [#returns-1168]
**Type:** `eql_v3_internal.ope_cllw`
eql\_v3\_internal.ope\_cllw
***
ord_term(query_bigint_ord_ope) [#ord_termquery_bigint_ord_ope]
Index extractor for eql\_v3.query\_bigint\_ord\_ope.
Parameters [#parameters-1172]
| Name | Type | Description |
| ----------- | ---------------------- | ----------- |
| `a eql_v3.` | `query_bigint_ord_ope` | |
Returns [#returns-1169]
**Type:** `eql_v3_internal.ope_cllw`
eql\_v3\_internal.ope\_cllw
***
ord_term(query_smallint_ord_ope) [#ord_termquery_smallint_ord_ope]
Index extractor for eql\_v3.query\_smallint\_ord\_ope.
Parameters [#parameters-1173]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a eql_v3.` | `query_smallint_ord_ope` | |
Returns [#returns-1170]
**Type:** `eql_v3_internal.ope_cllw`
eql\_v3\_internal.ope\_cllw
***
ord_term(eql_v3_double_ord) [#ord_termeql_v3_double_ord]
Index extractor for public.eql\_v3\_double\_ord.
Parameters [#parameters-1174]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a public.` | `eql_v3_double_ord` | |
Returns [#returns-1171]
**Type:** `eql_v3_internal.ope_cllw`
eql\_v3\_internal.ope\_cllw
***
ord_term(query_numeric_ord_ope) [#ord_termquery_numeric_ord_ope]
Index extractor for eql\_v3.query\_numeric\_ord\_ope.
Parameters [#parameters-1175]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a eql_v3.` | `query_numeric_ord_ope` | |
Returns [#returns-1172]
**Type:** `eql_v3_internal.ope_cllw`
eql\_v3\_internal.ope\_cllw
***
ord_term(eql_v3_double_ord_ope) [#ord_termeql_v3_double_ord_ope]
Index extractor for public.eql\_v3\_double\_ord\_ope.
Parameters [#parameters-1176]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a public.` | `eql_v3_double_ord_ope` | |
Returns [#returns-1173]
**Type:** `eql_v3_internal.ope_cllw`
eql\_v3\_internal.ope\_cllw
***
ord_term(eql_v3_numeric_ord_ope) [#ord_termeql_v3_numeric_ord_ope]
Index extractor for public.eql\_v3\_numeric\_ord\_ope.
Parameters [#parameters-1177]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a public.` | `eql_v3_numeric_ord_ope` | |
Returns [#returns-1174]
**Type:** `eql_v3_internal.ope_cllw`
eql\_v3\_internal.ope\_cllw
***
ord_term(query_timestamp_ord) [#ord_termquery_timestamp_ord]
Index extractor for eql\_v3.query\_timestamp\_ord.
Parameters [#parameters-1178]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a eql_v3.` | `query_timestamp_ord` | |
Returns [#returns-1175]
**Type:** `eql_v3_internal.ope_cllw`
eql\_v3\_internal.ope\_cllw
***
ord_term(eql_v3_date_ord_ope) [#ord_termeql_v3_date_ord_ope]
Index extractor for public.eql\_v3\_date\_ord\_ope.
Parameters [#parameters-1179]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_date_ord_ope` | |
Returns [#returns-1176]
**Type:** `eql_v3_internal.ope_cllw`
eql\_v3\_internal.ope\_cllw
***
ord_term(query_bigint_ord) [#ord_termquery_bigint_ord]
Index extractor for eql\_v3.query\_bigint\_ord.
Parameters [#parameters-1180]
| Name | Type | Description |
| ----------- | ------------------ | ----------- |
| `a eql_v3.` | `query_bigint_ord` | |
Returns [#returns-1177]
**Type:** `eql_v3_internal.ope_cllw`
eql\_v3\_internal.ope\_cllw
***
ord_term_ore(eql_v3_integer_ord_ore) [#ord_term_oreeql_v3_integer_ord_ore]
Index extractor for public.eql\_v3\_integer\_ord\_ore.
Parameters [#parameters-1181]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a public.` | `eql_v3_integer_ord_ore` | |
Returns [#returns-1178]
**Type:** `eql_v3_internal.ore_block_256`
eql\_v3\_internal.ore\_block\_256
***
ord_term_ore(query_real_ord_ore) [#ord_term_orequery_real_ord_ore]
Index extractor for eql\_v3.query\_real\_ord\_ore.
Parameters [#parameters-1182]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a eql_v3.` | `query_real_ord_ore` | |
Returns [#returns-1179]
**Type:** `eql_v3_internal.ore_block_256`
eql\_v3\_internal.ore\_block\_256
***
ord_term_ore(query_timestamp_ord_ore) [#ord_term_orequery_timestamp_ord_ore]
Index extractor for eql\_v3.query\_timestamp\_ord\_ore.
Parameters [#parameters-1183]
| Name | Type | Description |
| ----------- | ------------------------- | ----------- |
| `a eql_v3.` | `query_timestamp_ord_ore` | |
Returns [#returns-1180]
**Type:** `eql_v3_internal.ore_block_256`
eql\_v3\_internal.ore\_block\_256
***
ord_term_ore(query_text_search_ore) [#ord_term_orequery_text_search_ore]
Index extractor for eql\_v3.query\_text\_search\_ore.
Parameters [#parameters-1184]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a eql_v3.` | `query_text_search_ore` | |
Returns [#returns-1181]
**Type:** `eql_v3_internal.ore_block_256`
eql\_v3\_internal.ore\_block\_256
***
ord_term_ore(query_text_ord_ore) [#ord_term_orequery_text_ord_ore]
Index extractor for eql\_v3.query\_text\_ord\_ore.
Parameters [#parameters-1185]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a eql_v3.` | `query_text_ord_ore` | |
Returns [#returns-1182]
**Type:** `eql_v3_internal.ore_block_256`
eql\_v3\_internal.ore\_block\_256
***
ord_term_ore(query_smallint_ord_ore) [#ord_term_orequery_smallint_ord_ore]
Index extractor for eql\_v3.query\_smallint\_ord\_ore.
Parameters [#parameters-1186]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a eql_v3.` | `query_smallint_ord_ore` | |
Returns [#returns-1183]
**Type:** `eql_v3_internal.ore_block_256`
eql\_v3\_internal.ore\_block\_256
***
ord_term_ore(query_integer_ord_ore) [#ord_term_orequery_integer_ord_ore]
Index extractor for eql\_v3.query\_integer\_ord\_ore.
Parameters [#parameters-1187]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a eql_v3.` | `query_integer_ord_ore` | |
Returns [#returns-1184]
**Type:** `eql_v3_internal.ore_block_256`
eql\_v3\_internal.ore\_block\_256
***
ord_term_ore(eql_v3_bigint_ord_ore) [#ord_term_oreeql_v3_bigint_ord_ore]
Index extractor for public.eql\_v3\_bigint\_ord\_ore.
Parameters [#parameters-1188]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a public.` | `eql_v3_bigint_ord_ore` | |
Returns [#returns-1185]
**Type:** `eql_v3_internal.ore_block_256`
eql\_v3\_internal.ore\_block\_256
***
ord_term_ore(eql_v3_real_ord_ore) [#ord_term_oreeql_v3_real_ord_ore]
Index extractor for public.eql\_v3\_real\_ord\_ore.
Parameters [#parameters-1189]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_real_ord_ore` | |
Returns [#returns-1186]
**Type:** `eql_v3_internal.ore_block_256`
eql\_v3\_internal.ore\_block\_256
***
ord_term_ore(eql_v3_numeric_ord_ore) [#ord_term_oreeql_v3_numeric_ord_ore]
Index extractor for public.eql\_v3\_numeric\_ord\_ore.
Parameters [#parameters-1190]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a public.` | `eql_v3_numeric_ord_ore` | |
Returns [#returns-1187]
**Type:** `eql_v3_internal.ore_block_256`
eql\_v3\_internal.ore\_block\_256
***
ord_term_ore(eql_v3_double_ord_ore) [#ord_term_oreeql_v3_double_ord_ore]
Index extractor for public.eql\_v3\_double\_ord\_ore.
Parameters [#parameters-1191]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a public.` | `eql_v3_double_ord_ore` | |
Returns [#returns-1188]
**Type:** `eql_v3_internal.ore_block_256`
eql\_v3\_internal.ore\_block\_256
***
ord_term_ore(eql_v3_text_search_ore) [#ord_term_oreeql_v3_text_search_ore]
Index extractor for public.eql\_v3\_text\_search\_ore.
Parameters [#parameters-1192]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a public.` | `eql_v3_text_search_ore` | |
Returns [#returns-1189]
**Type:** `eql_v3_internal.ore_block_256`
eql\_v3\_internal.ore\_block\_256
***
ord_term_ore(query_double_ord_ore) [#ord_term_orequery_double_ord_ore]
Index extractor for eql\_v3.query\_double\_ord\_ore.
Parameters [#parameters-1193]
| Name | Type | Description |
| ----------- | ---------------------- | ----------- |
| `a eql_v3.` | `query_double_ord_ore` | |
Returns [#returns-1190]
**Type:** `eql_v3_internal.ore_block_256`
eql\_v3\_internal.ore\_block\_256
***
ord_term_ore(eql_v3_timestamp_ord_ore) [#ord_term_oreeql_v3_timestamp_ord_ore]
Index extractor for public.eql\_v3\_timestamp\_ord\_ore.
Parameters [#parameters-1194]
| Name | Type | Description |
| ----------- | -------------------------- | ----------- |
| `a public.` | `eql_v3_timestamp_ord_ore` | |
Returns [#returns-1191]
**Type:** `eql_v3_internal.ore_block_256`
eql\_v3\_internal.ore\_block\_256
***
ord_term_ore(query_numeric_ord_ore) [#ord_term_orequery_numeric_ord_ore]
Index extractor for eql\_v3.query\_numeric\_ord\_ore.
Parameters [#parameters-1195]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a eql_v3.` | `query_numeric_ord_ore` | |
Returns [#returns-1192]
**Type:** `eql_v3_internal.ore_block_256`
eql\_v3\_internal.ore\_block\_256
***
ord_term_ore(query_bigint_ord_ore) [#ord_term_orequery_bigint_ord_ore]
Index extractor for eql\_v3.query\_bigint\_ord\_ore.
Parameters [#parameters-1196]
| Name | Type | Description |
| ----------- | ---------------------- | ----------- |
| `a eql_v3.` | `query_bigint_ord_ore` | |
Returns [#returns-1193]
**Type:** `eql_v3_internal.ore_block_256`
eql\_v3\_internal.ore\_block\_256
***
ord_term_ore(query_date_ord_ore) [#ord_term_orequery_date_ord_ore]
Index extractor for eql\_v3.query\_date\_ord\_ore.
Parameters [#parameters-1197]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a eql_v3.` | `query_date_ord_ore` | |
Returns [#returns-1194]
**Type:** `eql_v3_internal.ore_block_256`
eql\_v3\_internal.ore\_block\_256
***
ord_term_ore(eql_v3_date_ord_ore) [#ord_term_oreeql_v3_date_ord_ore]
Index extractor for public.eql\_v3\_date\_ord\_ore.
Parameters [#parameters-1198]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_date_ord_ore` | |
Returns [#returns-1195]
**Type:** `eql_v3_internal.ore_block_256`
eql\_v3\_internal.ore\_block\_256
***
ord_term_ore(eql_v3_smallint_ord_ore) [#ord_term_oreeql_v3_smallint_ord_ore]
Index extractor for public.eql\_v3\_smallint\_ord\_ore.
Parameters [#parameters-1199]
| Name | Type | Description |
| ----------- | ------------------------- | ----------- |
| `a public.` | `eql_v3_smallint_ord_ore` | |
Returns [#returns-1196]
**Type:** `eql_v3_internal.ore_block_256`
eql\_v3\_internal.ore\_block\_256
***
ord_term_ore(eql_v3_text_ord_ore) [#ord_term_oreeql_v3_text_ord_ore]
Index extractor for public.eql\_v3\_text\_ord\_ore.
Parameters [#parameters-1200]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_text_ord_ore` | |
Returns [#returns-1197]
**Type:** `eql_v3_internal.ore_block_256`
eql\_v3\_internal.ore\_block\_256
***
selector(eql_v3_json_entry) [#selectoreql_v3_json_entry]
Extract selector (s) from a ste\_vec entry.
The DOMAIN CHECK guarantees is present, so this is a simple field access.
Parameters [#parameters-1201]
| Name | Type | Description |
| --------------- | ------------------- | ----------- |
| `entry public.` | `eql_v3_json_entry` | |
Returns [#returns-1198]
**Type:** `text`
text The selector value.
***
selector(jsonb) [#selectorjsonb]
Extract selector (s) from a raw jsonb encrypted value.
Parameters [#parameters-1202]
| Name | Type | Description |
| ----- | ------- | --------------------- |
| `val` | `jsonb` | encrypted EQL payload |
Returns [#returns-1199]
**Type:** `text`
text The selector value.
Exceptions [#exceptions-3]
* if s is absent.
***
ste_vec(jsonb) [#ste_vecjsonb]
Extract the sv element array as raw jsonb\[].
Returns the elements of sv (or a single-element array wrapping the value when there is no sv). No envelope re-wrapping — raw jsonb elements.
Parameters [#parameters-1203]
| Name | Type | Description |
| ----- | ------- | --------------------- |
| `val` | `jsonb` | encrypted EQL payload |
Returns [#returns-1200]
**Type:** `jsonb[]`
jsonb\[] Array of sv elements.
***
ste_vec_contains(jsonb, jsonb) [#ste_vec_containsjsonb-jsonb]
Check if an sv array contains a specific sv element.
Match = selector equal. Containment reduces to selector-set subset testing: a leaf's value is tokenized into its value selector (SEL(tag ‖ path ‖ value)), so the presence of a needle's value selector in the stored sv IS the exact value match — a keyed-MAC comparison, injective per (path, value), immune to the ordering encoding's losses (f64 rounding, string collation). Structural containment rides the same test: a needle's path selector (SEL(path), value-independent) matches any stored node at that path, and the needle's value selectors constrain the values. No per-entry term comparison is involved — the value is in the selector, not in a term.
Parameters [#parameters-1204]
| Name | Type | Description |
| ---- | ------- | -------------------------- |
| `a` | `jsonb` | sv array to search within. |
| `b` | `jsonb` | sv element to search for. |
Returns [#returns-1201]
**Type:** `boolean`
boolean True if b's selector is present in any element of a.
***
ste_vec_contains(eql_v3_json_search, eql_v3_json_search) [#ste_vec_containseql_v3_json_search-eql_v3_json_search]
Does encrypted value a contain all sv elements of b?
Empty b is always contained. Each element of b must have its selector present in some element of a (selector-subset containment).
Parameters [#parameters-1205]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a public.` | `eql_v3_json_search` | |
| `b public.` | `eql_v3_json_search` | |
Returns [#returns-1202]
**Type:** `boolean`
boolean True if all elements of b are contained in a.
Variants [#variants-2]
* `ste_vec_contains(jsonb[], jsonb)`
***
to_ste_vec_query(query_json) [#to_ste_vec_queryquery_json]
Normalise an already query-shaped needle to selector-only form.
Some producers derive a query from a complete encrypted document and may therefore carry the path entry's op. Containment is selector-set containment, so this overload strips op before comparison and keeps every public containment entry point semantically identical.
Parameters [#parameters-1206]
| Name | Type | Description |
| ----------- | ------------ | ----------- |
| `e eql_v3.` | `query_json` | |
***
to_ste_vec_query(eql_v3_json_search) [#to_ste_vec_queryeql_v3_json_search]
Convert a public.eql\_v3\_json\_search to a query\_json needle.
Normalises each sv element down to its selector s. Exact and structural containment are both selector-set containment; an op carried by a legacy or document-derived needle is accepted at the boundary for compatibility but is not part of the containment predicate. Other fields are stripped. This is the canonical needle shape for @> containment and the functional GIN index expression: GIN (eql\_v3.to\_ste\_vec\_query(col)::jsonb jsonb\_path\_ops).
Parameters [#parameters-1207]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `e public.` | `eql_v3_json_search` | |
Returns [#returns-1203]
**Type:** `eql_v3.query_json`
eql\_v3.query\_json Query-shaped needle, sv elements normalised.
Variants [#variants-3]
* eql\_v3.query\_json
***
version() [#version]
Get the installed EQL version string.
Returns the version string for the installed EQL library. This value is baked in at build time from the release tag.
Returns [#returns-1204]
**Type:** `text`
text Version string (e.g. "3.0.0" or "DEV" for development builds)
Note [#note-5]
Auto-generated during build from src/v3/version.template
***
Private Functions [#private-functions-1]
bloom_filter(jsonb) [#bloom_filterjsonb]
Extract the Bloom-filter index term from a jsonb payload.
Inlinable single-statement SQL — the planner can fold this into the calling query so the functional GIN index built on eql\_v3\_internal.match\_term(col) (which calls this) engages structurally. Mirrors eql\_v3\_internal.hmac\_256(jsonb): no RAISE and no pinned search\_path. Returns NULL when bf is absent or present but not a json array, rather than raising. The text\_match domain CHECK guarantees the bf key is present but not that it is an array, so a non-array bf (e.g. \{"bf": null}) can reach here even on a typed value; gating on jsonb\_typeof(...) = 'array\` returns NULL for that case — and for raw jsonb outside the domain — instead of erroring inside jsonb\_array\_elements. NULL, like the HMAC extractor, is the right answer. An empty bf array yields an empty filter (contains nothing, contained by everything), matching set-containment semantics.
Parameters [#parameters-1208]
| Name | Type | Description |
| ----- | ------- | ---------------------- |
| `val` | `jsonb` | The encrypted payload. |
Returns [#returns-1205]
**Type:** `eql_v3_internal.bloom_filter`
eql\_v3\_internal.bloom\_filter The bf array as a smallint\[] domain value, or NULL when bf is absent or not a json array.
***
compare_ore_block_256_term(ore_block_256_term, ore_block_256_term) [#compare_ore_block_256_termore_block_256_term-ore_block_256_term]
Compare two ORE block terms using cryptographic comparison.
Parameters [#parameters-1209]
| Name | Type | Description |
| -------------------- | -------------------- | ----------- |
| `a eql_v3_internal.` | `ore_block_256_term` | |
| `b eql_v3_internal.` | `ore_block_256_term` | |
***
compare_ore_block_256_terms(ore_block_256, ore_block_256) [#compare_ore_block_256_termsore_block_256-ore_block_256]
Compare ORE block composite types.
Parameters [#parameters-1210]
| Name | Type | Description |
| -------------------- | -------------------------------------- | ----------- |
| `a eql_v3_internal.` | [`ore_block_256`](#ore-block-256jsonb) | |
| `b eql_v3_internal.` | [`ore_block_256`](#ore-block-256jsonb) | |
***
compare_ore_block_256_terms(ore_block_256_term, ore_block_256_term) [#compare_ore_block_256_termsore_block_256_term-ore_block_256_term]
Compare arrays of ORE block terms recursively.
Parameters [#parameters-1211]
| Name | Type | Description |
| -------------------- | -------------------- | ----------- |
| `a eql_v3_internal.` | `ore_block_256_term` | |
| `b eql_v3_internal.` | `ore_block_256_term` | |
***
compare_ore_block_256_terms(ore_block_256, ore_block_256) [#compare_ore_block_256_termsore_block_256-ore_block_256-1]
Compare ORE block composite types.
Parameters [#parameters-1212]
| Name | Type | Description |
| -------------------- | -------------------------------------- | ----------- |
| `a eql_v3_internal.` | [`ore_block_256`](#ore-block-256jsonb) | |
| `b eql_v3_internal.` | [`ore_block_256`](#ore-block-256jsonb) | |
***
contained_by(jsonb, eql_v3_integer_ord_ore) [#contained_byjsonb-eql_v3_integer_ord_ore]
Unsupported operator blocker for public.eql\_v3\_integer\_ord\_ore.
Intercepts an operator that is not supported on public.eql\_v3\_integer\_ord\_ore and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1213]
| Name | Type | Description |
| ----------- | ------------------------ | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_integer_ord_ore` | |
Returns [#returns-1206]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(eql_v3_integer_ord_ore, jsonb) [#contained_byeql_v3_integer_ord_ore-jsonb]
Unsupported operator blocker for public.eql\_v3\_integer\_ord\_ore.
Intercepts an operator that is not supported on public.eql\_v3\_integer\_ord\_ore and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1214]
| Name | Type | Description |
| ----------- | ------------------------ | ------------------------------------- |
| `a public.` | `eql_v3_integer_ord_ore` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1207]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(eql_v3_integer_ord_ore, eql_v3_integer_ord_ore) [#contained_byeql_v3_integer_ord_ore-eql_v3_integer_ord_ore]
Unsupported operator blocker for public.eql\_v3\_integer\_ord\_ore.
Intercepts an operator that is not supported on public.eql\_v3\_integer\_ord\_ore and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1215]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a public.` | `eql_v3_integer_ord_ore` | |
| `b public.` | `eql_v3_integer_ord_ore` | |
Returns [#returns-1208]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(jsonb, eql_v3_date) [#contained_byjsonb-eql_v3_date]
Unsupported operator blocker for public.eql\_v3\_date.
Intercepts an operator that is not supported on public.eql\_v3\_date and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1216]
| Name | Type | Description |
| ----------- | ------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_date` | |
Returns [#returns-1209]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(eql_v3_date, jsonb) [#contained_byeql_v3_date-jsonb]
Unsupported operator blocker for public.eql\_v3\_date.
Intercepts an operator that is not supported on public.eql\_v3\_date and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1217]
| Name | Type | Description |
| ----------- | ------------- | ------------------------------------- |
| `a public.` | `eql_v3_date` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1210]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(eql_v3_date, eql_v3_date) [#contained_byeql_v3_date-eql_v3_date]
Unsupported operator blocker for public.eql\_v3\_date.
Intercepts an operator that is not supported on public.eql\_v3\_date and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1218]
| Name | Type | Description |
| ----------- | ------------- | ----------- |
| `a public.` | `eql_v3_date` | |
| `b public.` | `eql_v3_date` | |
Returns [#returns-1211]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(jsonb, eql_v3_smallint_ord) [#contained_byjsonb-eql_v3_smallint_ord]
Unsupported operator blocker for public.eql\_v3\_smallint\_ord.
Intercepts an operator that is not supported on public.eql\_v3\_smallint\_ord and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1219]
| Name | Type | Description |
| ----------- | --------------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_smallint_ord` | |
Returns [#returns-1212]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(eql_v3_smallint_ord, jsonb) [#contained_byeql_v3_smallint_ord-jsonb]
Unsupported operator blocker for public.eql\_v3\_smallint\_ord.
Intercepts an operator that is not supported on public.eql\_v3\_smallint\_ord and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1220]
| Name | Type | Description |
| ----------- | --------------------- | ------------------------------------- |
| `a public.` | `eql_v3_smallint_ord` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1213]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(eql_v3_smallint_ord, eql_v3_smallint_ord) [#contained_byeql_v3_smallint_ord-eql_v3_smallint_ord]
Unsupported operator blocker for public.eql\_v3\_smallint\_ord.
Intercepts an operator that is not supported on public.eql\_v3\_smallint\_ord and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1221]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_smallint_ord` | |
| `b public.` | `eql_v3_smallint_ord` | |
Returns [#returns-1214]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(jsonb, eql_v3_date_ord) [#contained_byjsonb-eql_v3_date_ord]
Unsupported operator blocker for public.eql\_v3\_date\_ord.
Intercepts an operator that is not supported on public.eql\_v3\_date\_ord and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1222]
| Name | Type | Description |
| ----------- | ----------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_date_ord` | |
Returns [#returns-1215]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(eql_v3_date_ord, jsonb) [#contained_byeql_v3_date_ord-jsonb]
Unsupported operator blocker for public.eql\_v3\_date\_ord.
Intercepts an operator that is not supported on public.eql\_v3\_date\_ord and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1223]
| Name | Type | Description |
| ----------- | ----------------- | ------------------------------------- |
| `a public.` | `eql_v3_date_ord` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1216]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(eql_v3_date_ord, eql_v3_date_ord) [#contained_byeql_v3_date_ord-eql_v3_date_ord]
Unsupported operator blocker for public.eql\_v3\_date\_ord.
Intercepts an operator that is not supported on public.eql\_v3\_date\_ord and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1224]
| Name | Type | Description |
| ----------- | ----------------- | ----------- |
| `a public.` | `eql_v3_date_ord` | |
| `b public.` | `eql_v3_date_ord` | |
Returns [#returns-1217]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(jsonb, eql_v3_text_ord) [#contained_byjsonb-eql_v3_text_ord]
Unsupported operator blocker for public.eql\_v3\_text\_ord.
Intercepts an operator that is not supported on public.eql\_v3\_text\_ord and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1225]
| Name | Type | Description |
| ----------- | ----------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_text_ord` | |
Returns [#returns-1218]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(eql_v3_text_ord, jsonb) [#contained_byeql_v3_text_ord-jsonb]
Unsupported operator blocker for public.eql\_v3\_text\_ord.
Intercepts an operator that is not supported on public.eql\_v3\_text\_ord and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1226]
| Name | Type | Description |
| ----------- | ----------------- | ------------------------------------- |
| `a public.` | `eql_v3_text_ord` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1219]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(eql_v3_text_ord, eql_v3_text_ord) [#contained_byeql_v3_text_ord-eql_v3_text_ord]
Unsupported operator blocker for public.eql\_v3\_text\_ord.
Intercepts an operator that is not supported on public.eql\_v3\_text\_ord and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1227]
| Name | Type | Description |
| ----------- | ----------------- | ----------- |
| `a public.` | `eql_v3_text_ord` | |
| `b public.` | `eql_v3_text_ord` | |
Returns [#returns-1220]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(jsonb, eql_v3_timestamp_ord_ope) [#contained_byjsonb-eql_v3_timestamp_ord_ope]
Unsupported operator blocker for public.eql\_v3\_timestamp\_ord\_ope.
Intercepts an operator that is not supported on public.eql\_v3\_timestamp\_ord\_ope and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1228]
| Name | Type | Description |
| ----------- | -------------------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_timestamp_ord_ope` | |
Returns [#returns-1221]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(eql_v3_timestamp_ord_ope, jsonb) [#contained_byeql_v3_timestamp_ord_ope-jsonb]
Unsupported operator blocker for public.eql\_v3\_timestamp\_ord\_ope.
Intercepts an operator that is not supported on public.eql\_v3\_timestamp\_ord\_ope and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1229]
| Name | Type | Description |
| ----------- | -------------------------- | ------------------------------------- |
| `a public.` | `eql_v3_timestamp_ord_ope` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1222]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(eql_v3_timestamp_ord_ope, eql_v3_timestamp_ord_ope) [#contained_byeql_v3_timestamp_ord_ope-eql_v3_timestamp_ord_ope]
Unsupported operator blocker for public.eql\_v3\_timestamp\_ord\_ope.
Intercepts an operator that is not supported on public.eql\_v3\_timestamp\_ord\_ope and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1230]
| Name | Type | Description |
| ----------- | -------------------------- | ----------- |
| `a public.` | `eql_v3_timestamp_ord_ope` | |
| `b public.` | `eql_v3_timestamp_ord_ope` | |
Returns [#returns-1223]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(jsonb, eql_v3_integer_ord_ope) [#contained_byjsonb-eql_v3_integer_ord_ope]
Unsupported operator blocker for public.eql\_v3\_integer\_ord\_ope.
Intercepts an operator that is not supported on public.eql\_v3\_integer\_ord\_ope and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1231]
| Name | Type | Description |
| ----------- | ------------------------ | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_integer_ord_ope` | |
Returns [#returns-1224]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(eql_v3_integer_ord_ope, jsonb) [#contained_byeql_v3_integer_ord_ope-jsonb]
Unsupported operator blocker for public.eql\_v3\_integer\_ord\_ope.
Intercepts an operator that is not supported on public.eql\_v3\_integer\_ord\_ope and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1232]
| Name | Type | Description |
| ----------- | ------------------------ | ------------------------------------- |
| `a public.` | `eql_v3_integer_ord_ope` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1225]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(eql_v3_integer_ord_ope, eql_v3_integer_ord_ope) [#contained_byeql_v3_integer_ord_ope-eql_v3_integer_ord_ope]
Unsupported operator blocker for public.eql\_v3\_integer\_ord\_ope.
Intercepts an operator that is not supported on public.eql\_v3\_integer\_ord\_ope and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1233]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a public.` | `eql_v3_integer_ord_ope` | |
| `b public.` | `eql_v3_integer_ord_ope` | |
Returns [#returns-1226]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(jsonb, eql_v3_bigint_eq) [#contained_byjsonb-eql_v3_bigint_eq]
Unsupported operator blocker for public.eql\_v3\_bigint\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_bigint\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1234]
| Name | Type | Description |
| ----------- | ------------------ | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_bigint_eq` | |
Returns [#returns-1227]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(eql_v3_bigint_eq, jsonb) [#contained_byeql_v3_bigint_eq-jsonb]
Unsupported operator blocker for public.eql\_v3\_bigint\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_bigint\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1235]
| Name | Type | Description |
| ----------- | ------------------ | ------------------------------------- |
| `a public.` | `eql_v3_bigint_eq` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1228]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(eql_v3_bigint_eq, eql_v3_bigint_eq) [#contained_byeql_v3_bigint_eq-eql_v3_bigint_eq]
Unsupported operator blocker for public.eql\_v3\_bigint\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_bigint\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1236]
| Name | Type | Description |
| ----------- | ------------------ | ----------- |
| `a public.` | `eql_v3_bigint_eq` | |
| `b public.` | `eql_v3_bigint_eq` | |
Returns [#returns-1229]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(jsonb, eql_v3_numeric_ord) [#contained_byjsonb-eql_v3_numeric_ord]
Unsupported operator blocker for public.eql\_v3\_numeric\_ord.
Intercepts an operator that is not supported on public.eql\_v3\_numeric\_ord and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1237]
| Name | Type | Description |
| ----------- | -------------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_numeric_ord` | |
Returns [#returns-1230]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(eql_v3_numeric_ord, jsonb) [#contained_byeql_v3_numeric_ord-jsonb]
Unsupported operator blocker for public.eql\_v3\_numeric\_ord.
Intercepts an operator that is not supported on public.eql\_v3\_numeric\_ord and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1238]
| Name | Type | Description |
| ----------- | -------------------- | ------------------------------------- |
| `a public.` | `eql_v3_numeric_ord` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1231]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(eql_v3_numeric_ord, eql_v3_numeric_ord) [#contained_byeql_v3_numeric_ord-eql_v3_numeric_ord]
Unsupported operator blocker for public.eql\_v3\_numeric\_ord.
Intercepts an operator that is not supported on public.eql\_v3\_numeric\_ord and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1239]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a public.` | `eql_v3_numeric_ord` | |
| `b public.` | `eql_v3_numeric_ord` | |
Returns [#returns-1232]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(jsonb, eql_v3_bigint) [#contained_byjsonb-eql_v3_bigint]
Unsupported operator blocker for public.eql\_v3\_bigint.
Intercepts an operator that is not supported on public.eql\_v3\_bigint and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1240]
| Name | Type | Description |
| ----------- | --------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_bigint` | |
Returns [#returns-1233]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(eql_v3_bigint, jsonb) [#contained_byeql_v3_bigint-jsonb]
Unsupported operator blocker for public.eql\_v3\_bigint.
Intercepts an operator that is not supported on public.eql\_v3\_bigint and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1241]
| Name | Type | Description |
| ----------- | --------------- | ------------------------------------- |
| `a public.` | `eql_v3_bigint` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1234]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(eql_v3_bigint, eql_v3_bigint) [#contained_byeql_v3_bigint-eql_v3_bigint]
Unsupported operator blocker for public.eql\_v3\_bigint.
Intercepts an operator that is not supported on public.eql\_v3\_bigint and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1242]
| Name | Type | Description |
| ----------- | --------------- | ----------- |
| `a public.` | `eql_v3_bigint` | |
| `b public.` | `eql_v3_bigint` | |
Returns [#returns-1235]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(jsonb, eql_v3_numeric) [#contained_byjsonb-eql_v3_numeric]
Unsupported operator blocker for public.eql\_v3\_numeric.
Intercepts an operator that is not supported on public.eql\_v3\_numeric and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1243]
| Name | Type | Description |
| ----------- | ---------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_numeric` | |
Returns [#returns-1236]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(eql_v3_numeric, jsonb) [#contained_byeql_v3_numeric-jsonb]
Unsupported operator blocker for public.eql\_v3\_numeric.
Intercepts an operator that is not supported on public.eql\_v3\_numeric and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1244]
| Name | Type | Description |
| ----------- | ---------------- | ------------------------------------- |
| `a public.` | `eql_v3_numeric` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1237]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(eql_v3_numeric, eql_v3_numeric) [#contained_byeql_v3_numeric-eql_v3_numeric]
Unsupported operator blocker for public.eql\_v3\_numeric.
Intercepts an operator that is not supported on public.eql\_v3\_numeric and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1245]
| Name | Type | Description |
| ----------- | ---------------- | ----------- |
| `a public.` | `eql_v3_numeric` | |
| `b public.` | `eql_v3_numeric` | |
Returns [#returns-1238]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(jsonb, eql_v3_timestamp_eq) [#contained_byjsonb-eql_v3_timestamp_eq]
Unsupported operator blocker for public.eql\_v3\_timestamp\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_timestamp\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1246]
| Name | Type | Description |
| ----------- | --------------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_timestamp_eq` | |
Returns [#returns-1239]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(eql_v3_timestamp_eq, jsonb) [#contained_byeql_v3_timestamp_eq-jsonb]
Unsupported operator blocker for public.eql\_v3\_timestamp\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_timestamp\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1247]
| Name | Type | Description |
| ----------- | --------------------- | ------------------------------------- |
| `a public.` | `eql_v3_timestamp_eq` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1240]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(eql_v3_timestamp_eq, eql_v3_timestamp_eq) [#contained_byeql_v3_timestamp_eq-eql_v3_timestamp_eq]
Unsupported operator blocker for public.eql\_v3\_timestamp\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_timestamp\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1248]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_timestamp_eq` | |
| `b public.` | `eql_v3_timestamp_eq` | |
Returns [#returns-1241]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(jsonb, eql_v3_real_ord_ope) [#contained_byjsonb-eql_v3_real_ord_ope]
Unsupported operator blocker for public.eql\_v3\_real\_ord\_ope.
Intercepts an operator that is not supported on public.eql\_v3\_real\_ord\_ope and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1249]
| Name | Type | Description |
| ----------- | --------------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_real_ord_ope` | |
Returns [#returns-1242]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(eql_v3_real_ord_ope, jsonb) [#contained_byeql_v3_real_ord_ope-jsonb]
Unsupported operator blocker for public.eql\_v3\_real\_ord\_ope.
Intercepts an operator that is not supported on public.eql\_v3\_real\_ord\_ope and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1250]
| Name | Type | Description |
| ----------- | --------------------- | ------------------------------------- |
| `a public.` | `eql_v3_real_ord_ope` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1243]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(eql_v3_real_ord_ope, eql_v3_real_ord_ope) [#contained_byeql_v3_real_ord_ope-eql_v3_real_ord_ope]
Unsupported operator blocker for public.eql\_v3\_real\_ord\_ope.
Intercepts an operator that is not supported on public.eql\_v3\_real\_ord\_ope and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1251]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_real_ord_ope` | |
| `b public.` | `eql_v3_real_ord_ope` | |
Returns [#returns-1244]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(jsonb, eql_v3_real_ord) [#contained_byjsonb-eql_v3_real_ord]
Unsupported operator blocker for public.eql\_v3\_real\_ord.
Intercepts an operator that is not supported on public.eql\_v3\_real\_ord and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1252]
| Name | Type | Description |
| ----------- | ----------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_real_ord` | |
Returns [#returns-1245]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(eql_v3_real_ord, jsonb) [#contained_byeql_v3_real_ord-jsonb]
Unsupported operator blocker for public.eql\_v3\_real\_ord.
Intercepts an operator that is not supported on public.eql\_v3\_real\_ord and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1253]
| Name | Type | Description |
| ----------- | ----------------- | ------------------------------------- |
| `a public.` | `eql_v3_real_ord` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1246]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(eql_v3_real_ord, eql_v3_real_ord) [#contained_byeql_v3_real_ord-eql_v3_real_ord]
Unsupported operator blocker for public.eql\_v3\_real\_ord.
Intercepts an operator that is not supported on public.eql\_v3\_real\_ord and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1254]
| Name | Type | Description |
| ----------- | ----------------- | ----------- |
| `a public.` | `eql_v3_real_ord` | |
| `b public.` | `eql_v3_real_ord` | |
Returns [#returns-1247]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(jsonb, eql_v3_integer_ord) [#contained_byjsonb-eql_v3_integer_ord]
Unsupported operator blocker for public.eql\_v3\_integer\_ord.
Intercepts an operator that is not supported on public.eql\_v3\_integer\_ord and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1255]
| Name | Type | Description |
| ----------- | -------------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_integer_ord` | |
Returns [#returns-1248]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(eql_v3_integer_ord, jsonb) [#contained_byeql_v3_integer_ord-jsonb]
Unsupported operator blocker for public.eql\_v3\_integer\_ord.
Intercepts an operator that is not supported on public.eql\_v3\_integer\_ord and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1256]
| Name | Type | Description |
| ----------- | -------------------- | ------------------------------------- |
| `a public.` | `eql_v3_integer_ord` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1249]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(eql_v3_integer_ord, eql_v3_integer_ord) [#contained_byeql_v3_integer_ord-eql_v3_integer_ord]
Unsupported operator blocker for public.eql\_v3\_integer\_ord.
Intercepts an operator that is not supported on public.eql\_v3\_integer\_ord and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1257]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a public.` | `eql_v3_integer_ord` | |
| `b public.` | `eql_v3_integer_ord` | |
Returns [#returns-1250]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(jsonb, eql_v3_json) [#contained_byjsonb-eql_v3_json]
Unsupported operator blocker for public.eql\_v3\_json.
Intercepts an operator that is not supported on public.eql\_v3\_json and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1258]
| Name | Type | Description |
| ----------- | ------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_json` | |
Returns [#returns-1251]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(eql_v3_json, jsonb) [#contained_byeql_v3_json-jsonb]
Unsupported operator blocker for public.eql\_v3\_json.
Intercepts an operator that is not supported on public.eql\_v3\_json and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1259]
| Name | Type | Description |
| ----------- | ------------- | ------------------------------------- |
| `a public.` | `eql_v3_json` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1252]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(eql_v3_json, eql_v3_json) [#contained_byeql_v3_json-eql_v3_json]
Unsupported operator blocker for public.eql\_v3\_json.
Intercepts an operator that is not supported on public.eql\_v3\_json and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1260]
| Name | Type | Description |
| ----------- | ------------- | ----------- |
| `a public.` | `eql_v3_json` | |
| `b public.` | `eql_v3_json` | |
Returns [#returns-1253]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(jsonb, eql_v3_text_ord_ope) [#contained_byjsonb-eql_v3_text_ord_ope]
Unsupported operator blocker for public.eql\_v3\_text\_ord\_ope.
Intercepts an operator that is not supported on public.eql\_v3\_text\_ord\_ope and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1261]
| Name | Type | Description |
| ----------- | --------------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_text_ord_ope` | |
Returns [#returns-1254]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(eql_v3_text_ord_ope, jsonb) [#contained_byeql_v3_text_ord_ope-jsonb]
Unsupported operator blocker for public.eql\_v3\_text\_ord\_ope.
Intercepts an operator that is not supported on public.eql\_v3\_text\_ord\_ope and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1262]
| Name | Type | Description |
| ----------- | --------------------- | ------------------------------------- |
| `a public.` | `eql_v3_text_ord_ope` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1255]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(eql_v3_text_ord_ope, eql_v3_text_ord_ope) [#contained_byeql_v3_text_ord_ope-eql_v3_text_ord_ope]
Unsupported operator blocker for public.eql\_v3\_text\_ord\_ope.
Intercepts an operator that is not supported on public.eql\_v3\_text\_ord\_ope and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1263]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_text_ord_ope` | |
| `b public.` | `eql_v3_text_ord_ope` | |
Returns [#returns-1256]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(jsonb, eql_v3_boolean) [#contained_byjsonb-eql_v3_boolean]
Unsupported operator blocker for public.eql\_v3\_boolean.
Intercepts an operator that is not supported on public.eql\_v3\_boolean and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1264]
| Name | Type | Description |
| ----------- | ---------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_boolean` | |
Returns [#returns-1257]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(eql_v3_boolean, jsonb) [#contained_byeql_v3_boolean-jsonb]
Unsupported operator blocker for public.eql\_v3\_boolean.
Intercepts an operator that is not supported on public.eql\_v3\_boolean and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1265]
| Name | Type | Description |
| ----------- | ---------------- | ------------------------------------- |
| `a public.` | `eql_v3_boolean` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1258]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(eql_v3_boolean, eql_v3_boolean) [#contained_byeql_v3_boolean-eql_v3_boolean]
Unsupported operator blocker for public.eql\_v3\_boolean.
Intercepts an operator that is not supported on public.eql\_v3\_boolean and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1266]
| Name | Type | Description |
| ----------- | ---------------- | ----------- |
| `a public.` | `eql_v3_boolean` | |
| `b public.` | `eql_v3_boolean` | |
Returns [#returns-1259]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(jsonb, eql_v3_real) [#contained_byjsonb-eql_v3_real]
Unsupported operator blocker for public.eql\_v3\_real.
Intercepts an operator that is not supported on public.eql\_v3\_real and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1267]
| Name | Type | Description |
| ----------- | ------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_real` | |
Returns [#returns-1260]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(eql_v3_real, jsonb) [#contained_byeql_v3_real-jsonb]
Unsupported operator blocker for public.eql\_v3\_real.
Intercepts an operator that is not supported on public.eql\_v3\_real and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1268]
| Name | Type | Description |
| ----------- | ------------- | ------------------------------------- |
| `a public.` | `eql_v3_real` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1261]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(eql_v3_real, eql_v3_real) [#contained_byeql_v3_real-eql_v3_real]
Unsupported operator blocker for public.eql\_v3\_real.
Intercepts an operator that is not supported on public.eql\_v3\_real and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1269]
| Name | Type | Description |
| ----------- | ------------- | ----------- |
| `a public.` | `eql_v3_real` | |
| `b public.` | `eql_v3_real` | |
Returns [#returns-1262]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(jsonb, eql_v3_real_eq) [#contained_byjsonb-eql_v3_real_eq]
Unsupported operator blocker for public.eql\_v3\_real\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_real\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1270]
| Name | Type | Description |
| ----------- | ---------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_real_eq` | |
Returns [#returns-1263]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(eql_v3_real_eq, jsonb) [#contained_byeql_v3_real_eq-jsonb]
Unsupported operator blocker for public.eql\_v3\_real\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_real\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1271]
| Name | Type | Description |
| ----------- | ---------------- | ------------------------------------- |
| `a public.` | `eql_v3_real_eq` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1264]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(eql_v3_real_eq, eql_v3_real_eq) [#contained_byeql_v3_real_eq-eql_v3_real_eq]
Unsupported operator blocker for public.eql\_v3\_real\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_real\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1272]
| Name | Type | Description |
| ----------- | ---------------- | ----------- |
| `a public.` | `eql_v3_real_eq` | |
| `b public.` | `eql_v3_real_eq` | |
Returns [#returns-1265]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(jsonb, eql_v3_text) [#contained_byjsonb-eql_v3_text]
Unsupported operator blocker for public.eql\_v3\_text.
Intercepts an operator that is not supported on public.eql\_v3\_text and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1273]
| Name | Type | Description |
| ----------- | ------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_text` | |
Returns [#returns-1266]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(eql_v3_text, jsonb) [#contained_byeql_v3_text-jsonb]
Unsupported operator blocker for public.eql\_v3\_text.
Intercepts an operator that is not supported on public.eql\_v3\_text and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1274]
| Name | Type | Description |
| ----------- | ------------- | ------------------------------------- |
| `a public.` | `eql_v3_text` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1267]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(eql_v3_text, eql_v3_text) [#contained_byeql_v3_text-eql_v3_text]
Unsupported operator blocker for public.eql\_v3\_text.
Intercepts an operator that is not supported on public.eql\_v3\_text and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1275]
| Name | Type | Description |
| ----------- | ------------- | ----------- |
| `a public.` | `eql_v3_text` | |
| `b public.` | `eql_v3_text` | |
Returns [#returns-1268]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(jsonb, eql_v3_bigint_ord_ore) [#contained_byjsonb-eql_v3_bigint_ord_ore]
Unsupported operator blocker for public.eql\_v3\_bigint\_ord\_ore.
Intercepts an operator that is not supported on public.eql\_v3\_bigint\_ord\_ore and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1276]
| Name | Type | Description |
| ----------- | ----------------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_bigint_ord_ore` | |
Returns [#returns-1269]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(eql_v3_bigint_ord_ore, jsonb) [#contained_byeql_v3_bigint_ord_ore-jsonb]
Unsupported operator blocker for public.eql\_v3\_bigint\_ord\_ore.
Intercepts an operator that is not supported on public.eql\_v3\_bigint\_ord\_ore and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1277]
| Name | Type | Description |
| ----------- | ----------------------- | ------------------------------------- |
| `a public.` | `eql_v3_bigint_ord_ore` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1270]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(eql_v3_bigint_ord_ore, eql_v3_bigint_ord_ore) [#contained_byeql_v3_bigint_ord_ore-eql_v3_bigint_ord_ore]
Unsupported operator blocker for public.eql\_v3\_bigint\_ord\_ore.
Intercepts an operator that is not supported on public.eql\_v3\_bigint\_ord\_ore and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1278]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a public.` | `eql_v3_bigint_ord_ore` | |
| `b public.` | `eql_v3_bigint_ord_ore` | |
Returns [#returns-1271]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(jsonb, eql_v3_double_eq) [#contained_byjsonb-eql_v3_double_eq]
Unsupported operator blocker for public.eql\_v3\_double\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_double\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1279]
| Name | Type | Description |
| ----------- | ------------------ | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_double_eq` | |
Returns [#returns-1272]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(eql_v3_double_eq, jsonb) [#contained_byeql_v3_double_eq-jsonb]
Unsupported operator blocker for public.eql\_v3\_double\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_double\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1280]
| Name | Type | Description |
| ----------- | ------------------ | ------------------------------------- |
| `a public.` | `eql_v3_double_eq` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1273]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(eql_v3_double_eq, eql_v3_double_eq) [#contained_byeql_v3_double_eq-eql_v3_double_eq]
Unsupported operator blocker for public.eql\_v3\_double\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_double\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1281]
| Name | Type | Description |
| ----------- | ------------------ | ----------- |
| `a public.` | `eql_v3_double_eq` | |
| `b public.` | `eql_v3_double_eq` | |
Returns [#returns-1274]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(jsonb, eql_v3_real_ord_ore) [#contained_byjsonb-eql_v3_real_ord_ore]
Unsupported operator blocker for public.eql\_v3\_real\_ord\_ore.
Intercepts an operator that is not supported on public.eql\_v3\_real\_ord\_ore and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1282]
| Name | Type | Description |
| ----------- | --------------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_real_ord_ore` | |
Returns [#returns-1275]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(eql_v3_real_ord_ore, jsonb) [#contained_byeql_v3_real_ord_ore-jsonb]
Unsupported operator blocker for public.eql\_v3\_real\_ord\_ore.
Intercepts an operator that is not supported on public.eql\_v3\_real\_ord\_ore and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1283]
| Name | Type | Description |
| ----------- | --------------------- | ------------------------------------- |
| `a public.` | `eql_v3_real_ord_ore` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1276]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(eql_v3_real_ord_ore, eql_v3_real_ord_ore) [#contained_byeql_v3_real_ord_ore-eql_v3_real_ord_ore]
Unsupported operator blocker for public.eql\_v3\_real\_ord\_ore.
Intercepts an operator that is not supported on public.eql\_v3\_real\_ord\_ore and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1284]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_real_ord_ore` | |
| `b public.` | `eql_v3_real_ord_ore` | |
Returns [#returns-1277]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(jsonb, eql_v3_numeric_ord_ore) [#contained_byjsonb-eql_v3_numeric_ord_ore]
Unsupported operator blocker for public.eql\_v3\_numeric\_ord\_ore.
Intercepts an operator that is not supported on public.eql\_v3\_numeric\_ord\_ore and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1285]
| Name | Type | Description |
| ----------- | ------------------------ | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_numeric_ord_ore` | |
Returns [#returns-1278]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(eql_v3_numeric_ord_ore, jsonb) [#contained_byeql_v3_numeric_ord_ore-jsonb]
Unsupported operator blocker for public.eql\_v3\_numeric\_ord\_ore.
Intercepts an operator that is not supported on public.eql\_v3\_numeric\_ord\_ore and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1286]
| Name | Type | Description |
| ----------- | ------------------------ | ------------------------------------- |
| `a public.` | `eql_v3_numeric_ord_ore` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1279]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(eql_v3_numeric_ord_ore, eql_v3_numeric_ord_ore) [#contained_byeql_v3_numeric_ord_ore-eql_v3_numeric_ord_ore]
Unsupported operator blocker for public.eql\_v3\_numeric\_ord\_ore.
Intercepts an operator that is not supported on public.eql\_v3\_numeric\_ord\_ore and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1287]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a public.` | `eql_v3_numeric_ord_ore` | |
| `b public.` | `eql_v3_numeric_ord_ore` | |
Returns [#returns-1280]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(jsonb, eql_v3_bigint_ord_ope) [#contained_byjsonb-eql_v3_bigint_ord_ope]
Unsupported operator blocker for public.eql\_v3\_bigint\_ord\_ope.
Intercepts an operator that is not supported on public.eql\_v3\_bigint\_ord\_ope and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1288]
| Name | Type | Description |
| ----------- | ----------------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_bigint_ord_ope` | |
Returns [#returns-1281]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(eql_v3_bigint_ord_ope, jsonb) [#contained_byeql_v3_bigint_ord_ope-jsonb]
Unsupported operator blocker for public.eql\_v3\_bigint\_ord\_ope.
Intercepts an operator that is not supported on public.eql\_v3\_bigint\_ord\_ope and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1289]
| Name | Type | Description |
| ----------- | ----------------------- | ------------------------------------- |
| `a public.` | `eql_v3_bigint_ord_ope` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1282]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(eql_v3_bigint_ord_ope, eql_v3_bigint_ord_ope) [#contained_byeql_v3_bigint_ord_ope-eql_v3_bigint_ord_ope]
Unsupported operator blocker for public.eql\_v3\_bigint\_ord\_ope.
Intercepts an operator that is not supported on public.eql\_v3\_bigint\_ord\_ope and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1290]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a public.` | `eql_v3_bigint_ord_ope` | |
| `b public.` | `eql_v3_bigint_ord_ope` | |
Returns [#returns-1283]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(jsonb, eql_v3_timestamp) [#contained_byjsonb-eql_v3_timestamp]
Unsupported operator blocker for public.eql\_v3\_timestamp.
Intercepts an operator that is not supported on public.eql\_v3\_timestamp and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1291]
| Name | Type | Description |
| ----------- | ------------------ | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_timestamp` | |
Returns [#returns-1284]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(eql_v3_timestamp, jsonb) [#contained_byeql_v3_timestamp-jsonb]
Unsupported operator blocker for public.eql\_v3\_timestamp.
Intercepts an operator that is not supported on public.eql\_v3\_timestamp and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1292]
| Name | Type | Description |
| ----------- | ------------------ | ------------------------------------- |
| `a public.` | `eql_v3_timestamp` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1285]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(eql_v3_timestamp, eql_v3_timestamp) [#contained_byeql_v3_timestamp-eql_v3_timestamp]
Unsupported operator blocker for public.eql\_v3\_timestamp.
Intercepts an operator that is not supported on public.eql\_v3\_timestamp and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1293]
| Name | Type | Description |
| ----------- | ------------------ | ----------- |
| `a public.` | `eql_v3_timestamp` | |
| `b public.` | `eql_v3_timestamp` | |
Returns [#returns-1286]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(jsonb, eql_v3_double_ord_ore) [#contained_byjsonb-eql_v3_double_ord_ore]
Unsupported operator blocker for public.eql\_v3\_double\_ord\_ore.
Intercepts an operator that is not supported on public.eql\_v3\_double\_ord\_ore and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1294]
| Name | Type | Description |
| ----------- | ----------------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_double_ord_ore` | |
Returns [#returns-1287]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(eql_v3_double_ord_ore, jsonb) [#contained_byeql_v3_double_ord_ore-jsonb]
Unsupported operator blocker for public.eql\_v3\_double\_ord\_ore.
Intercepts an operator that is not supported on public.eql\_v3\_double\_ord\_ore and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1295]
| Name | Type | Description |
| ----------- | ----------------------- | ------------------------------------- |
| `a public.` | `eql_v3_double_ord_ore` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1288]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(eql_v3_double_ord_ore, eql_v3_double_ord_ore) [#contained_byeql_v3_double_ord_ore-eql_v3_double_ord_ore]
Unsupported operator blocker for public.eql\_v3\_double\_ord\_ore.
Intercepts an operator that is not supported on public.eql\_v3\_double\_ord\_ore and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1296]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a public.` | `eql_v3_double_ord_ore` | |
| `b public.` | `eql_v3_double_ord_ore` | |
Returns [#returns-1289]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(jsonb, eql_v3_bigint_ord) [#contained_byjsonb-eql_v3_bigint_ord]
Unsupported operator blocker for public.eql\_v3\_bigint\_ord.
Intercepts an operator that is not supported on public.eql\_v3\_bigint\_ord and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1297]
| Name | Type | Description |
| ----------- | ------------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_bigint_ord` | |
Returns [#returns-1290]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(eql_v3_bigint_ord, jsonb) [#contained_byeql_v3_bigint_ord-jsonb]
Unsupported operator blocker for public.eql\_v3\_bigint\_ord.
Intercepts an operator that is not supported on public.eql\_v3\_bigint\_ord and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1298]
| Name | Type | Description |
| ----------- | ------------------- | ------------------------------------- |
| `a public.` | `eql_v3_bigint_ord` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1291]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(eql_v3_bigint_ord, eql_v3_bigint_ord) [#contained_byeql_v3_bigint_ord-eql_v3_bigint_ord]
Unsupported operator blocker for public.eql\_v3\_bigint\_ord.
Intercepts an operator that is not supported on public.eql\_v3\_bigint\_ord and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1299]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a public.` | `eql_v3_bigint_ord` | |
| `b public.` | `eql_v3_bigint_ord` | |
Returns [#returns-1292]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(jsonb, eql_v3_text_search_ore) [#contained_byjsonb-eql_v3_text_search_ore]
Unsupported operator blocker for public.eql\_v3\_text\_search\_ore.
Intercepts an operator that is not supported on public.eql\_v3\_text\_search\_ore and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1300]
| Name | Type | Description |
| ----------- | ------------------------ | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_text_search_ore` | |
Returns [#returns-1293]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(eql_v3_text_search_ore, jsonb) [#contained_byeql_v3_text_search_ore-jsonb]
Unsupported operator blocker for public.eql\_v3\_text\_search\_ore.
Intercepts an operator that is not supported on public.eql\_v3\_text\_search\_ore and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1301]
| Name | Type | Description |
| ----------- | ------------------------ | ------------------------------------- |
| `a public.` | `eql_v3_text_search_ore` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1294]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(eql_v3_text_search_ore, eql_v3_text_search_ore) [#contained_byeql_v3_text_search_ore-eql_v3_text_search_ore]
Unsupported operator blocker for public.eql\_v3\_text\_search\_ore.
Intercepts an operator that is not supported on public.eql\_v3\_text\_search\_ore and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1302]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a public.` | `eql_v3_text_search_ore` | |
| `b public.` | `eql_v3_text_search_ore` | |
Returns [#returns-1295]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(jsonb, eql_v3_numeric_eq) [#contained_byjsonb-eql_v3_numeric_eq]
Unsupported operator blocker for public.eql\_v3\_numeric\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_numeric\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1303]
| Name | Type | Description |
| ----------- | ------------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_numeric_eq` | |
Returns [#returns-1296]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(eql_v3_numeric_eq, jsonb) [#contained_byeql_v3_numeric_eq-jsonb]
Unsupported operator blocker for public.eql\_v3\_numeric\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_numeric\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1304]
| Name | Type | Description |
| ----------- | ------------------- | ------------------------------------- |
| `a public.` | `eql_v3_numeric_eq` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1297]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(eql_v3_numeric_eq, eql_v3_numeric_eq) [#contained_byeql_v3_numeric_eq-eql_v3_numeric_eq]
Unsupported operator blocker for public.eql\_v3\_numeric\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_numeric\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1305]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a public.` | `eql_v3_numeric_eq` | |
| `b public.` | `eql_v3_numeric_eq` | |
Returns [#returns-1298]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(jsonb, eql_v3_timestamp_ord) [#contained_byjsonb-eql_v3_timestamp_ord]
Unsupported operator blocker for public.eql\_v3\_timestamp\_ord.
Intercepts an operator that is not supported on public.eql\_v3\_timestamp\_ord and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1306]
| Name | Type | Description |
| ----------- | ---------------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_timestamp_ord` | |
Returns [#returns-1299]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(eql_v3_timestamp_ord, jsonb) [#contained_byeql_v3_timestamp_ord-jsonb]
Unsupported operator blocker for public.eql\_v3\_timestamp\_ord.
Intercepts an operator that is not supported on public.eql\_v3\_timestamp\_ord and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1307]
| Name | Type | Description |
| ----------- | ---------------------- | ------------------------------------- |
| `a public.` | `eql_v3_timestamp_ord` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1300]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(eql_v3_timestamp_ord, eql_v3_timestamp_ord) [#contained_byeql_v3_timestamp_ord-eql_v3_timestamp_ord]
Unsupported operator blocker for public.eql\_v3\_timestamp\_ord.
Intercepts an operator that is not supported on public.eql\_v3\_timestamp\_ord and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1308]
| Name | Type | Description |
| ----------- | ---------------------- | ----------- |
| `a public.` | `eql_v3_timestamp_ord` | |
| `b public.` | `eql_v3_timestamp_ord` | |
Returns [#returns-1301]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(jsonb, eql_v3_text_match) [#contained_byjsonb-eql_v3_text_match]
Unsupported operator blocker for public.eql\_v3\_text\_match.
Intercepts an operator that is not supported on public.eql\_v3\_text\_match and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1309]
| Name | Type | Description |
| ----------- | ------------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_text_match` | |
Returns [#returns-1302]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(eql_v3_text_match, jsonb) [#contained_byeql_v3_text_match-jsonb]
Unsupported operator blocker for public.eql\_v3\_text\_match.
Intercepts an operator that is not supported on public.eql\_v3\_text\_match and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1310]
| Name | Type | Description |
| ----------- | ------------------- | ------------------------------------- |
| `a public.` | `eql_v3_text_match` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1303]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(eql_v3_text_match, eql_v3_text_match) [#contained_byeql_v3_text_match-eql_v3_text_match]
Unsupported operator blocker for public.eql\_v3\_text\_match.
Intercepts an operator that is not supported on public.eql\_v3\_text\_match and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1311]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a public.` | `eql_v3_text_match` | |
| `b public.` | `eql_v3_text_match` | |
Returns [#returns-1304]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(jsonb, eql_v3_smallint_ord_ope) [#contained_byjsonb-eql_v3_smallint_ord_ope]
Unsupported operator blocker for public.eql\_v3\_smallint\_ord\_ope.
Intercepts an operator that is not supported on public.eql\_v3\_smallint\_ord\_ope and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1312]
| Name | Type | Description |
| ----------- | ------------------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_smallint_ord_ope` | |
Returns [#returns-1305]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(eql_v3_smallint_ord_ope, jsonb) [#contained_byeql_v3_smallint_ord_ope-jsonb]
Unsupported operator blocker for public.eql\_v3\_smallint\_ord\_ope.
Intercepts an operator that is not supported on public.eql\_v3\_smallint\_ord\_ope and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1313]
| Name | Type | Description |
| ----------- | ------------------------- | ------------------------------------- |
| `a public.` | `eql_v3_smallint_ord_ope` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1306]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(eql_v3_smallint_ord_ope, eql_v3_smallint_ord_ope) [#contained_byeql_v3_smallint_ord_ope-eql_v3_smallint_ord_ope]
Unsupported operator blocker for public.eql\_v3\_smallint\_ord\_ope.
Intercepts an operator that is not supported on public.eql\_v3\_smallint\_ord\_ope and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1314]
| Name | Type | Description |
| ----------- | ------------------------- | ----------- |
| `a public.` | `eql_v3_smallint_ord_ope` | |
| `b public.` | `eql_v3_smallint_ord_ope` | |
Returns [#returns-1307]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(jsonb, eql_v3_integer) [#contained_byjsonb-eql_v3_integer]
Unsupported operator blocker for public.eql\_v3\_integer.
Intercepts an operator that is not supported on public.eql\_v3\_integer and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1315]
| Name | Type | Description |
| ----------- | ---------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_integer` | |
Returns [#returns-1308]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(eql_v3_integer, jsonb) [#contained_byeql_v3_integer-jsonb]
Unsupported operator blocker for public.eql\_v3\_integer.
Intercepts an operator that is not supported on public.eql\_v3\_integer and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1316]
| Name | Type | Description |
| ----------- | ---------------- | ------------------------------------- |
| `a public.` | `eql_v3_integer` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1309]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(eql_v3_integer, eql_v3_integer) [#contained_byeql_v3_integer-eql_v3_integer]
Unsupported operator blocker for public.eql\_v3\_integer.
Intercepts an operator that is not supported on public.eql\_v3\_integer and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1317]
| Name | Type | Description |
| ----------- | ---------------- | ----------- |
| `a public.` | `eql_v3_integer` | |
| `b public.` | `eql_v3_integer` | |
Returns [#returns-1310]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(jsonb, eql_v3_double) [#contained_byjsonb-eql_v3_double]
Unsupported operator blocker for public.eql\_v3\_double.
Intercepts an operator that is not supported on public.eql\_v3\_double and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1318]
| Name | Type | Description |
| ----------- | --------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_double` | |
Returns [#returns-1311]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(eql_v3_double, jsonb) [#contained_byeql_v3_double-jsonb]
Unsupported operator blocker for public.eql\_v3\_double.
Intercepts an operator that is not supported on public.eql\_v3\_double and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1319]
| Name | Type | Description |
| ----------- | --------------- | ------------------------------------- |
| `a public.` | `eql_v3_double` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1312]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(eql_v3_double, eql_v3_double) [#contained_byeql_v3_double-eql_v3_double]
Unsupported operator blocker for public.eql\_v3\_double.
Intercepts an operator that is not supported on public.eql\_v3\_double and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1320]
| Name | Type | Description |
| ----------- | --------------- | ----------- |
| `a public.` | `eql_v3_double` | |
| `b public.` | `eql_v3_double` | |
Returns [#returns-1313]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(jsonb, eql_v3_timestamp_ord_ore) [#contained_byjsonb-eql_v3_timestamp_ord_ore]
Unsupported operator blocker for public.eql\_v3\_timestamp\_ord\_ore.
Intercepts an operator that is not supported on public.eql\_v3\_timestamp\_ord\_ore and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1321]
| Name | Type | Description |
| ----------- | -------------------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_timestamp_ord_ore` | |
Returns [#returns-1314]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(eql_v3_timestamp_ord_ore, jsonb) [#contained_byeql_v3_timestamp_ord_ore-jsonb]
Unsupported operator blocker for public.eql\_v3\_timestamp\_ord\_ore.
Intercepts an operator that is not supported on public.eql\_v3\_timestamp\_ord\_ore and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1322]
| Name | Type | Description |
| ----------- | -------------------------- | ------------------------------------- |
| `a public.` | `eql_v3_timestamp_ord_ore` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1315]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(eql_v3_timestamp_ord_ore, eql_v3_timestamp_ord_ore) [#contained_byeql_v3_timestamp_ord_ore-eql_v3_timestamp_ord_ore]
Unsupported operator blocker for public.eql\_v3\_timestamp\_ord\_ore.
Intercepts an operator that is not supported on public.eql\_v3\_timestamp\_ord\_ore and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1323]
| Name | Type | Description |
| ----------- | -------------------------- | ----------- |
| `a public.` | `eql_v3_timestamp_ord_ore` | |
| `b public.` | `eql_v3_timestamp_ord_ore` | |
Returns [#returns-1316]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(jsonb, eql_v3_text_search) [#contained_byjsonb-eql_v3_text_search]
Unsupported operator blocker for public.eql\_v3\_text\_search.
Intercepts an operator that is not supported on public.eql\_v3\_text\_search and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1324]
| Name | Type | Description |
| ----------- | -------------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_text_search` | |
Returns [#returns-1317]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(eql_v3_text_search, jsonb) [#contained_byeql_v3_text_search-jsonb]
Unsupported operator blocker for public.eql\_v3\_text\_search.
Intercepts an operator that is not supported on public.eql\_v3\_text\_search and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1325]
| Name | Type | Description |
| ----------- | -------------------- | ------------------------------------- |
| `a public.` | `eql_v3_text_search` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1318]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(eql_v3_text_search, eql_v3_text_search) [#contained_byeql_v3_text_search-eql_v3_text_search]
Unsupported operator blocker for public.eql\_v3\_text\_search.
Intercepts an operator that is not supported on public.eql\_v3\_text\_search and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1326]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a public.` | `eql_v3_text_search` | |
| `b public.` | `eql_v3_text_search` | |
Returns [#returns-1319]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(jsonb, eql_v3_smallint_eq) [#contained_byjsonb-eql_v3_smallint_eq]
Unsupported operator blocker for public.eql\_v3\_smallint\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_smallint\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1327]
| Name | Type | Description |
| ----------- | -------------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_smallint_eq` | |
Returns [#returns-1320]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(eql_v3_smallint_eq, jsonb) [#contained_byeql_v3_smallint_eq-jsonb]
Unsupported operator blocker for public.eql\_v3\_smallint\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_smallint\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1328]
| Name | Type | Description |
| ----------- | -------------------- | ------------------------------------- |
| `a public.` | `eql_v3_smallint_eq` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1321]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(eql_v3_smallint_eq, eql_v3_smallint_eq) [#contained_byeql_v3_smallint_eq-eql_v3_smallint_eq]
Unsupported operator blocker for public.eql\_v3\_smallint\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_smallint\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1329]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a public.` | `eql_v3_smallint_eq` | |
| `b public.` | `eql_v3_smallint_eq` | |
Returns [#returns-1322]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(jsonb, eql_v3_double_ord) [#contained_byjsonb-eql_v3_double_ord]
Unsupported operator blocker for public.eql\_v3\_double\_ord.
Intercepts an operator that is not supported on public.eql\_v3\_double\_ord and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1330]
| Name | Type | Description |
| ----------- | ------------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_double_ord` | |
Returns [#returns-1323]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(eql_v3_double_ord, jsonb) [#contained_byeql_v3_double_ord-jsonb]
Unsupported operator blocker for public.eql\_v3\_double\_ord.
Intercepts an operator that is not supported on public.eql\_v3\_double\_ord and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1331]
| Name | Type | Description |
| ----------- | ------------------- | ------------------------------------- |
| `a public.` | `eql_v3_double_ord` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1324]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(eql_v3_double_ord, eql_v3_double_ord) [#contained_byeql_v3_double_ord-eql_v3_double_ord]
Unsupported operator blocker for public.eql\_v3\_double\_ord.
Intercepts an operator that is not supported on public.eql\_v3\_double\_ord and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1332]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a public.` | `eql_v3_double_ord` | |
| `b public.` | `eql_v3_double_ord` | |
Returns [#returns-1325]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(jsonb, eql_v3_date_eq) [#contained_byjsonb-eql_v3_date_eq]
Unsupported operator blocker for public.eql\_v3\_date\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_date\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1333]
| Name | Type | Description |
| ----------- | ---------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_date_eq` | |
Returns [#returns-1326]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(eql_v3_date_eq, jsonb) [#contained_byeql_v3_date_eq-jsonb]
Unsupported operator blocker for public.eql\_v3\_date\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_date\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1334]
| Name | Type | Description |
| ----------- | ---------------- | ------------------------------------- |
| `a public.` | `eql_v3_date_eq` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1327]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(eql_v3_date_eq, eql_v3_date_eq) [#contained_byeql_v3_date_eq-eql_v3_date_eq]
Unsupported operator blocker for public.eql\_v3\_date\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_date\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1335]
| Name | Type | Description |
| ----------- | ---------------- | ----------- |
| `a public.` | `eql_v3_date_eq` | |
| `b public.` | `eql_v3_date_eq` | |
Returns [#returns-1328]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(jsonb, eql_v3_double_ord_ope) [#contained_byjsonb-eql_v3_double_ord_ope]
Unsupported operator blocker for public.eql\_v3\_double\_ord\_ope.
Intercepts an operator that is not supported on public.eql\_v3\_double\_ord\_ope and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1336]
| Name | Type | Description |
| ----------- | ----------------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_double_ord_ope` | |
Returns [#returns-1329]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(eql_v3_double_ord_ope, jsonb) [#contained_byeql_v3_double_ord_ope-jsonb]
Unsupported operator blocker for public.eql\_v3\_double\_ord\_ope.
Intercepts an operator that is not supported on public.eql\_v3\_double\_ord\_ope and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1337]
| Name | Type | Description |
| ----------- | ----------------------- | ------------------------------------- |
| `a public.` | `eql_v3_double_ord_ope` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1330]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(eql_v3_double_ord_ope, eql_v3_double_ord_ope) [#contained_byeql_v3_double_ord_ope-eql_v3_double_ord_ope]
Unsupported operator blocker for public.eql\_v3\_double\_ord\_ope.
Intercepts an operator that is not supported on public.eql\_v3\_double\_ord\_ope and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1338]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a public.` | `eql_v3_double_ord_ope` | |
| `b public.` | `eql_v3_double_ord_ope` | |
Returns [#returns-1331]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(jsonb, eql_v3_numeric_ord_ope) [#contained_byjsonb-eql_v3_numeric_ord_ope]
Unsupported operator blocker for public.eql\_v3\_numeric\_ord\_ope.
Intercepts an operator that is not supported on public.eql\_v3\_numeric\_ord\_ope and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1339]
| Name | Type | Description |
| ----------- | ------------------------ | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_numeric_ord_ope` | |
Returns [#returns-1332]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(eql_v3_numeric_ord_ope, jsonb) [#contained_byeql_v3_numeric_ord_ope-jsonb]
Unsupported operator blocker for public.eql\_v3\_numeric\_ord\_ope.
Intercepts an operator that is not supported on public.eql\_v3\_numeric\_ord\_ope and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1340]
| Name | Type | Description |
| ----------- | ------------------------ | ------------------------------------- |
| `a public.` | `eql_v3_numeric_ord_ope` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1333]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(eql_v3_numeric_ord_ope, eql_v3_numeric_ord_ope) [#contained_byeql_v3_numeric_ord_ope-eql_v3_numeric_ord_ope]
Unsupported operator blocker for public.eql\_v3\_numeric\_ord\_ope.
Intercepts an operator that is not supported on public.eql\_v3\_numeric\_ord\_ope and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1341]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a public.` | `eql_v3_numeric_ord_ope` | |
| `b public.` | `eql_v3_numeric_ord_ope` | |
Returns [#returns-1334]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(jsonb, eql_v3_date_ord_ore) [#contained_byjsonb-eql_v3_date_ord_ore]
Unsupported operator blocker for public.eql\_v3\_date\_ord\_ore.
Intercepts an operator that is not supported on public.eql\_v3\_date\_ord\_ore and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1342]
| Name | Type | Description |
| ----------- | --------------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_date_ord_ore` | |
Returns [#returns-1335]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(eql_v3_date_ord_ore, jsonb) [#contained_byeql_v3_date_ord_ore-jsonb]
Unsupported operator blocker for public.eql\_v3\_date\_ord\_ore.
Intercepts an operator that is not supported on public.eql\_v3\_date\_ord\_ore and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1343]
| Name | Type | Description |
| ----------- | --------------------- | ------------------------------------- |
| `a public.` | `eql_v3_date_ord_ore` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1336]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(eql_v3_date_ord_ore, eql_v3_date_ord_ore) [#contained_byeql_v3_date_ord_ore-eql_v3_date_ord_ore]
Unsupported operator blocker for public.eql\_v3\_date\_ord\_ore.
Intercepts an operator that is not supported on public.eql\_v3\_date\_ord\_ore and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1344]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_date_ord_ore` | |
| `b public.` | `eql_v3_date_ord_ore` | |
Returns [#returns-1337]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(jsonb, eql_v3_text_eq) [#contained_byjsonb-eql_v3_text_eq]
Unsupported operator blocker for public.eql\_v3\_text\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_text\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1345]
| Name | Type | Description |
| ----------- | ---------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_text_eq` | |
Returns [#returns-1338]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(eql_v3_text_eq, jsonb) [#contained_byeql_v3_text_eq-jsonb]
Unsupported operator blocker for public.eql\_v3\_text\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_text\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1346]
| Name | Type | Description |
| ----------- | ---------------- | ------------------------------------- |
| `a public.` | `eql_v3_text_eq` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1339]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(eql_v3_text_eq, eql_v3_text_eq) [#contained_byeql_v3_text_eq-eql_v3_text_eq]
Unsupported operator blocker for public.eql\_v3\_text\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_text\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1347]
| Name | Type | Description |
| ----------- | ---------------- | ----------- |
| `a public.` | `eql_v3_text_eq` | |
| `b public.` | `eql_v3_text_eq` | |
Returns [#returns-1340]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(jsonb, eql_v3_integer_eq) [#contained_byjsonb-eql_v3_integer_eq]
Unsupported operator blocker for public.eql\_v3\_integer\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_integer\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1348]
| Name | Type | Description |
| ----------- | ------------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_integer_eq` | |
Returns [#returns-1341]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(eql_v3_integer_eq, jsonb) [#contained_byeql_v3_integer_eq-jsonb]
Unsupported operator blocker for public.eql\_v3\_integer\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_integer\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1349]
| Name | Type | Description |
| ----------- | ------------------- | ------------------------------------- |
| `a public.` | `eql_v3_integer_eq` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1342]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(eql_v3_integer_eq, eql_v3_integer_eq) [#contained_byeql_v3_integer_eq-eql_v3_integer_eq]
Unsupported operator blocker for public.eql\_v3\_integer\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_integer\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1350]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a public.` | `eql_v3_integer_eq` | |
| `b public.` | `eql_v3_integer_eq` | |
Returns [#returns-1343]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(jsonb, eql_v3_smallint_ord_ore) [#contained_byjsonb-eql_v3_smallint_ord_ore]
Unsupported operator blocker for public.eql\_v3\_smallint\_ord\_ore.
Intercepts an operator that is not supported on public.eql\_v3\_smallint\_ord\_ore and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1351]
| Name | Type | Description |
| ----------- | ------------------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_smallint_ord_ore` | |
Returns [#returns-1344]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(eql_v3_smallint_ord_ore, jsonb) [#contained_byeql_v3_smallint_ord_ore-jsonb]
Unsupported operator blocker for public.eql\_v3\_smallint\_ord\_ore.
Intercepts an operator that is not supported on public.eql\_v3\_smallint\_ord\_ore and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1352]
| Name | Type | Description |
| ----------- | ------------------------- | ------------------------------------- |
| `a public.` | `eql_v3_smallint_ord_ore` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1345]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(eql_v3_smallint_ord_ore, eql_v3_smallint_ord_ore) [#contained_byeql_v3_smallint_ord_ore-eql_v3_smallint_ord_ore]
Unsupported operator blocker for public.eql\_v3\_smallint\_ord\_ore.
Intercepts an operator that is not supported on public.eql\_v3\_smallint\_ord\_ore and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1353]
| Name | Type | Description |
| ----------- | ------------------------- | ----------- |
| `a public.` | `eql_v3_smallint_ord_ore` | |
| `b public.` | `eql_v3_smallint_ord_ore` | |
Returns [#returns-1346]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(jsonb, eql_v3_date_ord_ope) [#contained_byjsonb-eql_v3_date_ord_ope]
Unsupported operator blocker for public.eql\_v3\_date\_ord\_ope.
Intercepts an operator that is not supported on public.eql\_v3\_date\_ord\_ope and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1354]
| Name | Type | Description |
| ----------- | --------------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_date_ord_ope` | |
Returns [#returns-1347]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(eql_v3_date_ord_ope, jsonb) [#contained_byeql_v3_date_ord_ope-jsonb]
Unsupported operator blocker for public.eql\_v3\_date\_ord\_ope.
Intercepts an operator that is not supported on public.eql\_v3\_date\_ord\_ope and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1355]
| Name | Type | Description |
| ----------- | --------------------- | ------------------------------------- |
| `a public.` | `eql_v3_date_ord_ope` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1348]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(eql_v3_date_ord_ope, eql_v3_date_ord_ope) [#contained_byeql_v3_date_ord_ope-eql_v3_date_ord_ope]
Unsupported operator blocker for public.eql\_v3\_date\_ord\_ope.
Intercepts an operator that is not supported on public.eql\_v3\_date\_ord\_ope and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1356]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_date_ord_ope` | |
| `b public.` | `eql_v3_date_ord_ope` | |
Returns [#returns-1349]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(jsonb, eql_v3_text_ord_ore) [#contained_byjsonb-eql_v3_text_ord_ore]
Unsupported operator blocker for public.eql\_v3\_text\_ord\_ore.
Intercepts an operator that is not supported on public.eql\_v3\_text\_ord\_ore and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1357]
| Name | Type | Description |
| ----------- | --------------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_text_ord_ore` | |
Returns [#returns-1350]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(eql_v3_text_ord_ore, jsonb) [#contained_byeql_v3_text_ord_ore-jsonb]
Unsupported operator blocker for public.eql\_v3\_text\_ord\_ore.
Intercepts an operator that is not supported on public.eql\_v3\_text\_ord\_ore and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1358]
| Name | Type | Description |
| ----------- | --------------------- | ------------------------------------- |
| `a public.` | `eql_v3_text_ord_ore` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1351]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(eql_v3_text_ord_ore, eql_v3_text_ord_ore) [#contained_byeql_v3_text_ord_ore-eql_v3_text_ord_ore]
Unsupported operator blocker for public.eql\_v3\_text\_ord\_ore.
Intercepts an operator that is not supported on public.eql\_v3\_text\_ord\_ore and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1359]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_text_ord_ore` | |
| `b public.` | `eql_v3_text_ord_ore` | |
Returns [#returns-1352]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(jsonb, eql_v3_smallint) [#contained_byjsonb-eql_v3_smallint]
Unsupported operator blocker for public.eql\_v3\_smallint.
Intercepts an operator that is not supported on public.eql\_v3\_smallint and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1360]
| Name | Type | Description |
| ----------- | ----------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_smallint` | |
Returns [#returns-1353]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(eql_v3_smallint, jsonb) [#contained_byeql_v3_smallint-jsonb]
Unsupported operator blocker for public.eql\_v3\_smallint.
Intercepts an operator that is not supported on public.eql\_v3\_smallint and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1361]
| Name | Type | Description |
| ----------- | ----------------- | ------------------------------------- |
| `a public.` | `eql_v3_smallint` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1354]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contained_by(eql_v3_smallint, eql_v3_smallint) [#contained_byeql_v3_smallint-eql_v3_smallint]
Unsupported operator blocker for public.eql\_v3\_smallint.
Intercepts an operator that is not supported on public.eql\_v3\_smallint and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1362]
| Name | Type | Description |
| ----------- | ----------------- | ----------- |
| `a public.` | `eql_v3_smallint` | |
| `b public.` | `eql_v3_smallint` | |
Returns [#returns-1355]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(jsonb, eql_v3_integer_ord_ore) [#containsjsonb-eql_v3_integer_ord_ore]
Unsupported operator blocker for public.eql\_v3\_integer\_ord\_ore.
Intercepts an operator that is not supported on public.eql\_v3\_integer\_ord\_ore and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1363]
| Name | Type | Description |
| ----------- | ------------------------ | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_integer_ord_ore` | |
Returns [#returns-1356]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(eql_v3_integer_ord_ore, jsonb) [#containseql_v3_integer_ord_ore-jsonb]
Unsupported operator blocker for public.eql\_v3\_integer\_ord\_ore.
Intercepts an operator that is not supported on public.eql\_v3\_integer\_ord\_ore and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1364]
| Name | Type | Description |
| ----------- | ------------------------ | ------------------------------------- |
| `a public.` | `eql_v3_integer_ord_ore` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1357]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(eql_v3_integer_ord_ore, eql_v3_integer_ord_ore) [#containseql_v3_integer_ord_ore-eql_v3_integer_ord_ore]
Unsupported operator blocker for public.eql\_v3\_integer\_ord\_ore.
Intercepts an operator that is not supported on public.eql\_v3\_integer\_ord\_ore and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1365]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a public.` | `eql_v3_integer_ord_ore` | |
| `b public.` | `eql_v3_integer_ord_ore` | |
Returns [#returns-1358]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(jsonb, eql_v3_date) [#containsjsonb-eql_v3_date]
Unsupported operator blocker for public.eql\_v3\_date.
Intercepts an operator that is not supported on public.eql\_v3\_date and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1366]
| Name | Type | Description |
| ----------- | ------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_date` | |
Returns [#returns-1359]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(eql_v3_date, jsonb) [#containseql_v3_date-jsonb]
Unsupported operator blocker for public.eql\_v3\_date.
Intercepts an operator that is not supported on public.eql\_v3\_date and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1367]
| Name | Type | Description |
| ----------- | ------------- | ------------------------------------- |
| `a public.` | `eql_v3_date` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1360]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(eql_v3_date, eql_v3_date) [#containseql_v3_date-eql_v3_date]
Unsupported operator blocker for public.eql\_v3\_date.
Intercepts an operator that is not supported on public.eql\_v3\_date and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1368]
| Name | Type | Description |
| ----------- | ------------- | ----------- |
| `a public.` | `eql_v3_date` | |
| `b public.` | `eql_v3_date` | |
Returns [#returns-1361]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(jsonb, eql_v3_smallint_ord) [#containsjsonb-eql_v3_smallint_ord]
Unsupported operator blocker for public.eql\_v3\_smallint\_ord.
Intercepts an operator that is not supported on public.eql\_v3\_smallint\_ord and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1369]
| Name | Type | Description |
| ----------- | --------------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_smallint_ord` | |
Returns [#returns-1362]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(eql_v3_smallint_ord, jsonb) [#containseql_v3_smallint_ord-jsonb]
Unsupported operator blocker for public.eql\_v3\_smallint\_ord.
Intercepts an operator that is not supported on public.eql\_v3\_smallint\_ord and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1370]
| Name | Type | Description |
| ----------- | --------------------- | ------------------------------------- |
| `a public.` | `eql_v3_smallint_ord` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1363]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(eql_v3_smallint_ord, eql_v3_smallint_ord) [#containseql_v3_smallint_ord-eql_v3_smallint_ord]
Unsupported operator blocker for public.eql\_v3\_smallint\_ord.
Intercepts an operator that is not supported on public.eql\_v3\_smallint\_ord and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1371]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_smallint_ord` | |
| `b public.` | `eql_v3_smallint_ord` | |
Returns [#returns-1364]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(jsonb, eql_v3_date_ord) [#containsjsonb-eql_v3_date_ord]
Unsupported operator blocker for public.eql\_v3\_date\_ord.
Intercepts an operator that is not supported on public.eql\_v3\_date\_ord and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1372]
| Name | Type | Description |
| ----------- | ----------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_date_ord` | |
Returns [#returns-1365]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(eql_v3_date_ord, jsonb) [#containseql_v3_date_ord-jsonb]
Unsupported operator blocker for public.eql\_v3\_date\_ord.
Intercepts an operator that is not supported on public.eql\_v3\_date\_ord and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1373]
| Name | Type | Description |
| ----------- | ----------------- | ------------------------------------- |
| `a public.` | `eql_v3_date_ord` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1366]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(eql_v3_date_ord, eql_v3_date_ord) [#containseql_v3_date_ord-eql_v3_date_ord]
Unsupported operator blocker for public.eql\_v3\_date\_ord.
Intercepts an operator that is not supported on public.eql\_v3\_date\_ord and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1374]
| Name | Type | Description |
| ----------- | ----------------- | ----------- |
| `a public.` | `eql_v3_date_ord` | |
| `b public.` | `eql_v3_date_ord` | |
Returns [#returns-1367]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(jsonb, eql_v3_text_ord) [#containsjsonb-eql_v3_text_ord]
Unsupported operator blocker for public.eql\_v3\_text\_ord.
Intercepts an operator that is not supported on public.eql\_v3\_text\_ord and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1375]
| Name | Type | Description |
| ----------- | ----------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_text_ord` | |
Returns [#returns-1368]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(eql_v3_text_ord, jsonb) [#containseql_v3_text_ord-jsonb]
Unsupported operator blocker for public.eql\_v3\_text\_ord.
Intercepts an operator that is not supported on public.eql\_v3\_text\_ord and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1376]
| Name | Type | Description |
| ----------- | ----------------- | ------------------------------------- |
| `a public.` | `eql_v3_text_ord` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1369]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(eql_v3_text_ord, eql_v3_text_ord) [#containseql_v3_text_ord-eql_v3_text_ord]
Unsupported operator blocker for public.eql\_v3\_text\_ord.
Intercepts an operator that is not supported on public.eql\_v3\_text\_ord and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1377]
| Name | Type | Description |
| ----------- | ----------------- | ----------- |
| `a public.` | `eql_v3_text_ord` | |
| `b public.` | `eql_v3_text_ord` | |
Returns [#returns-1370]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(jsonb, eql_v3_timestamp_ord_ope) [#containsjsonb-eql_v3_timestamp_ord_ope]
Unsupported operator blocker for public.eql\_v3\_timestamp\_ord\_ope.
Intercepts an operator that is not supported on public.eql\_v3\_timestamp\_ord\_ope and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1378]
| Name | Type | Description |
| ----------- | -------------------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_timestamp_ord_ope` | |
Returns [#returns-1371]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(eql_v3_timestamp_ord_ope, jsonb) [#containseql_v3_timestamp_ord_ope-jsonb]
Unsupported operator blocker for public.eql\_v3\_timestamp\_ord\_ope.
Intercepts an operator that is not supported on public.eql\_v3\_timestamp\_ord\_ope and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1379]
| Name | Type | Description |
| ----------- | -------------------------- | ------------------------------------- |
| `a public.` | `eql_v3_timestamp_ord_ope` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1372]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(eql_v3_timestamp_ord_ope, eql_v3_timestamp_ord_ope) [#containseql_v3_timestamp_ord_ope-eql_v3_timestamp_ord_ope]
Unsupported operator blocker for public.eql\_v3\_timestamp\_ord\_ope.
Intercepts an operator that is not supported on public.eql\_v3\_timestamp\_ord\_ope and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1380]
| Name | Type | Description |
| ----------- | -------------------------- | ----------- |
| `a public.` | `eql_v3_timestamp_ord_ope` | |
| `b public.` | `eql_v3_timestamp_ord_ope` | |
Returns [#returns-1373]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(jsonb, eql_v3_integer_ord_ope) [#containsjsonb-eql_v3_integer_ord_ope]
Unsupported operator blocker for public.eql\_v3\_integer\_ord\_ope.
Intercepts an operator that is not supported on public.eql\_v3\_integer\_ord\_ope and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1381]
| Name | Type | Description |
| ----------- | ------------------------ | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_integer_ord_ope` | |
Returns [#returns-1374]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(eql_v3_integer_ord_ope, jsonb) [#containseql_v3_integer_ord_ope-jsonb]
Unsupported operator blocker for public.eql\_v3\_integer\_ord\_ope.
Intercepts an operator that is not supported on public.eql\_v3\_integer\_ord\_ope and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1382]
| Name | Type | Description |
| ----------- | ------------------------ | ------------------------------------- |
| `a public.` | `eql_v3_integer_ord_ope` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1375]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(eql_v3_integer_ord_ope, eql_v3_integer_ord_ope) [#containseql_v3_integer_ord_ope-eql_v3_integer_ord_ope]
Unsupported operator blocker for public.eql\_v3\_integer\_ord\_ope.
Intercepts an operator that is not supported on public.eql\_v3\_integer\_ord\_ope and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1383]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a public.` | `eql_v3_integer_ord_ope` | |
| `b public.` | `eql_v3_integer_ord_ope` | |
Returns [#returns-1376]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(jsonb, eql_v3_bigint_eq) [#containsjsonb-eql_v3_bigint_eq]
Unsupported operator blocker for public.eql\_v3\_bigint\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_bigint\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1384]
| Name | Type | Description |
| ----------- | ------------------ | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_bigint_eq` | |
Returns [#returns-1377]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(eql_v3_bigint_eq, jsonb) [#containseql_v3_bigint_eq-jsonb]
Unsupported operator blocker for public.eql\_v3\_bigint\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_bigint\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1385]
| Name | Type | Description |
| ----------- | ------------------ | ------------------------------------- |
| `a public.` | `eql_v3_bigint_eq` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1378]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(eql_v3_bigint_eq, eql_v3_bigint_eq) [#containseql_v3_bigint_eq-eql_v3_bigint_eq]
Unsupported operator blocker for public.eql\_v3\_bigint\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_bigint\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1386]
| Name | Type | Description |
| ----------- | ------------------ | ----------- |
| `a public.` | `eql_v3_bigint_eq` | |
| `b public.` | `eql_v3_bigint_eq` | |
Returns [#returns-1379]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(jsonb, eql_v3_numeric_ord) [#containsjsonb-eql_v3_numeric_ord]
Unsupported operator blocker for public.eql\_v3\_numeric\_ord.
Intercepts an operator that is not supported on public.eql\_v3\_numeric\_ord and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1387]
| Name | Type | Description |
| ----------- | -------------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_numeric_ord` | |
Returns [#returns-1380]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(eql_v3_numeric_ord, jsonb) [#containseql_v3_numeric_ord-jsonb]
Unsupported operator blocker for public.eql\_v3\_numeric\_ord.
Intercepts an operator that is not supported on public.eql\_v3\_numeric\_ord and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1388]
| Name | Type | Description |
| ----------- | -------------------- | ------------------------------------- |
| `a public.` | `eql_v3_numeric_ord` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1381]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(eql_v3_numeric_ord, eql_v3_numeric_ord) [#containseql_v3_numeric_ord-eql_v3_numeric_ord]
Unsupported operator blocker for public.eql\_v3\_numeric\_ord.
Intercepts an operator that is not supported on public.eql\_v3\_numeric\_ord and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1389]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a public.` | `eql_v3_numeric_ord` | |
| `b public.` | `eql_v3_numeric_ord` | |
Returns [#returns-1382]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(jsonb, eql_v3_bigint) [#containsjsonb-eql_v3_bigint]
Unsupported operator blocker for public.eql\_v3\_bigint.
Intercepts an operator that is not supported on public.eql\_v3\_bigint and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1390]
| Name | Type | Description |
| ----------- | --------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_bigint` | |
Returns [#returns-1383]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(eql_v3_bigint, jsonb) [#containseql_v3_bigint-jsonb]
Unsupported operator blocker for public.eql\_v3\_bigint.
Intercepts an operator that is not supported on public.eql\_v3\_bigint and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1391]
| Name | Type | Description |
| ----------- | --------------- | ------------------------------------- |
| `a public.` | `eql_v3_bigint` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1384]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(eql_v3_bigint, eql_v3_bigint) [#containseql_v3_bigint-eql_v3_bigint]
Unsupported operator blocker for public.eql\_v3\_bigint.
Intercepts an operator that is not supported on public.eql\_v3\_bigint and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1392]
| Name | Type | Description |
| ----------- | --------------- | ----------- |
| `a public.` | `eql_v3_bigint` | |
| `b public.` | `eql_v3_bigint` | |
Returns [#returns-1385]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(jsonb, eql_v3_numeric) [#containsjsonb-eql_v3_numeric]
Unsupported operator blocker for public.eql\_v3\_numeric.
Intercepts an operator that is not supported on public.eql\_v3\_numeric and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1393]
| Name | Type | Description |
| ----------- | ---------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_numeric` | |
Returns [#returns-1386]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(eql_v3_numeric, jsonb) [#containseql_v3_numeric-jsonb]
Unsupported operator blocker for public.eql\_v3\_numeric.
Intercepts an operator that is not supported on public.eql\_v3\_numeric and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1394]
| Name | Type | Description |
| ----------- | ---------------- | ------------------------------------- |
| `a public.` | `eql_v3_numeric` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1387]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(eql_v3_numeric, eql_v3_numeric) [#containseql_v3_numeric-eql_v3_numeric]
Unsupported operator blocker for public.eql\_v3\_numeric.
Intercepts an operator that is not supported on public.eql\_v3\_numeric and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1395]
| Name | Type | Description |
| ----------- | ---------------- | ----------- |
| `a public.` | `eql_v3_numeric` | |
| `b public.` | `eql_v3_numeric` | |
Returns [#returns-1388]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(jsonb, eql_v3_timestamp_eq) [#containsjsonb-eql_v3_timestamp_eq]
Unsupported operator blocker for public.eql\_v3\_timestamp\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_timestamp\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1396]
| Name | Type | Description |
| ----------- | --------------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_timestamp_eq` | |
Returns [#returns-1389]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(eql_v3_timestamp_eq, jsonb) [#containseql_v3_timestamp_eq-jsonb]
Unsupported operator blocker for public.eql\_v3\_timestamp\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_timestamp\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1397]
| Name | Type | Description |
| ----------- | --------------------- | ------------------------------------- |
| `a public.` | `eql_v3_timestamp_eq` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1390]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(eql_v3_timestamp_eq, eql_v3_timestamp_eq) [#containseql_v3_timestamp_eq-eql_v3_timestamp_eq]
Unsupported operator blocker for public.eql\_v3\_timestamp\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_timestamp\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1398]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_timestamp_eq` | |
| `b public.` | `eql_v3_timestamp_eq` | |
Returns [#returns-1391]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(jsonb, eql_v3_real_ord_ope) [#containsjsonb-eql_v3_real_ord_ope]
Unsupported operator blocker for public.eql\_v3\_real\_ord\_ope.
Intercepts an operator that is not supported on public.eql\_v3\_real\_ord\_ope and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1399]
| Name | Type | Description |
| ----------- | --------------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_real_ord_ope` | |
Returns [#returns-1392]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(eql_v3_real_ord_ope, jsonb) [#containseql_v3_real_ord_ope-jsonb]
Unsupported operator blocker for public.eql\_v3\_real\_ord\_ope.
Intercepts an operator that is not supported on public.eql\_v3\_real\_ord\_ope and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1400]
| Name | Type | Description |
| ----------- | --------------------- | ------------------------------------- |
| `a public.` | `eql_v3_real_ord_ope` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1393]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(eql_v3_real_ord_ope, eql_v3_real_ord_ope) [#containseql_v3_real_ord_ope-eql_v3_real_ord_ope]
Unsupported operator blocker for public.eql\_v3\_real\_ord\_ope.
Intercepts an operator that is not supported on public.eql\_v3\_real\_ord\_ope and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1401]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_real_ord_ope` | |
| `b public.` | `eql_v3_real_ord_ope` | |
Returns [#returns-1394]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(jsonb, eql_v3_real_ord) [#containsjsonb-eql_v3_real_ord]
Unsupported operator blocker for public.eql\_v3\_real\_ord.
Intercepts an operator that is not supported on public.eql\_v3\_real\_ord and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1402]
| Name | Type | Description |
| ----------- | ----------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_real_ord` | |
Returns [#returns-1395]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(eql_v3_real_ord, jsonb) [#containseql_v3_real_ord-jsonb]
Unsupported operator blocker for public.eql\_v3\_real\_ord.
Intercepts an operator that is not supported on public.eql\_v3\_real\_ord and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1403]
| Name | Type | Description |
| ----------- | ----------------- | ------------------------------------- |
| `a public.` | `eql_v3_real_ord` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1396]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(eql_v3_real_ord, eql_v3_real_ord) [#containseql_v3_real_ord-eql_v3_real_ord]
Unsupported operator blocker for public.eql\_v3\_real\_ord.
Intercepts an operator that is not supported on public.eql\_v3\_real\_ord and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1404]
| Name | Type | Description |
| ----------- | ----------------- | ----------- |
| `a public.` | `eql_v3_real_ord` | |
| `b public.` | `eql_v3_real_ord` | |
Returns [#returns-1397]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(jsonb, eql_v3_integer_ord) [#containsjsonb-eql_v3_integer_ord]
Unsupported operator blocker for public.eql\_v3\_integer\_ord.
Intercepts an operator that is not supported on public.eql\_v3\_integer\_ord and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1405]
| Name | Type | Description |
| ----------- | -------------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_integer_ord` | |
Returns [#returns-1398]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(eql_v3_integer_ord, jsonb) [#containseql_v3_integer_ord-jsonb]
Unsupported operator blocker for public.eql\_v3\_integer\_ord.
Intercepts an operator that is not supported on public.eql\_v3\_integer\_ord and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1406]
| Name | Type | Description |
| ----------- | -------------------- | ------------------------------------- |
| `a public.` | `eql_v3_integer_ord` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1399]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(eql_v3_integer_ord, eql_v3_integer_ord) [#containseql_v3_integer_ord-eql_v3_integer_ord]
Unsupported operator blocker for public.eql\_v3\_integer\_ord.
Intercepts an operator that is not supported on public.eql\_v3\_integer\_ord and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1407]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a public.` | `eql_v3_integer_ord` | |
| `b public.` | `eql_v3_integer_ord` | |
Returns [#returns-1400]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(jsonb, eql_v3_json) [#containsjsonb-eql_v3_json]
Unsupported operator blocker for public.eql\_v3\_json.
Intercepts an operator that is not supported on public.eql\_v3\_json and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1408]
| Name | Type | Description |
| ----------- | ------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_json` | |
Returns [#returns-1401]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(eql_v3_json, jsonb) [#containseql_v3_json-jsonb]
Unsupported operator blocker for public.eql\_v3\_json.
Intercepts an operator that is not supported on public.eql\_v3\_json and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1409]
| Name | Type | Description |
| ----------- | ------------- | ------------------------------------- |
| `a public.` | `eql_v3_json` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1402]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(eql_v3_json, eql_v3_json) [#containseql_v3_json-eql_v3_json]
Unsupported operator blocker for public.eql\_v3\_json.
Intercepts an operator that is not supported on public.eql\_v3\_json and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1410]
| Name | Type | Description |
| ----------- | ------------- | ----------- |
| `a public.` | `eql_v3_json` | |
| `b public.` | `eql_v3_json` | |
Returns [#returns-1403]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(jsonb, eql_v3_text_ord_ope) [#containsjsonb-eql_v3_text_ord_ope]
Unsupported operator blocker for public.eql\_v3\_text\_ord\_ope.
Intercepts an operator that is not supported on public.eql\_v3\_text\_ord\_ope and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1411]
| Name | Type | Description |
| ----------- | --------------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_text_ord_ope` | |
Returns [#returns-1404]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(eql_v3_text_ord_ope, jsonb) [#containseql_v3_text_ord_ope-jsonb]
Unsupported operator blocker for public.eql\_v3\_text\_ord\_ope.
Intercepts an operator that is not supported on public.eql\_v3\_text\_ord\_ope and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1412]
| Name | Type | Description |
| ----------- | --------------------- | ------------------------------------- |
| `a public.` | `eql_v3_text_ord_ope` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1405]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(eql_v3_text_ord_ope, eql_v3_text_ord_ope) [#containseql_v3_text_ord_ope-eql_v3_text_ord_ope]
Unsupported operator blocker for public.eql\_v3\_text\_ord\_ope.
Intercepts an operator that is not supported on public.eql\_v3\_text\_ord\_ope and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1413]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_text_ord_ope` | |
| `b public.` | `eql_v3_text_ord_ope` | |
Returns [#returns-1406]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(jsonb, eql_v3_boolean) [#containsjsonb-eql_v3_boolean]
Unsupported operator blocker for public.eql\_v3\_boolean.
Intercepts an operator that is not supported on public.eql\_v3\_boolean and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1414]
| Name | Type | Description |
| ----------- | ---------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_boolean` | |
Returns [#returns-1407]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(eql_v3_boolean, jsonb) [#containseql_v3_boolean-jsonb]
Unsupported operator blocker for public.eql\_v3\_boolean.
Intercepts an operator that is not supported on public.eql\_v3\_boolean and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1415]
| Name | Type | Description |
| ----------- | ---------------- | ------------------------------------- |
| `a public.` | `eql_v3_boolean` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1408]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(eql_v3_boolean, eql_v3_boolean) [#containseql_v3_boolean-eql_v3_boolean]
Unsupported operator blocker for public.eql\_v3\_boolean.
Intercepts an operator that is not supported on public.eql\_v3\_boolean and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1416]
| Name | Type | Description |
| ----------- | ---------------- | ----------- |
| `a public.` | `eql_v3_boolean` | |
| `b public.` | `eql_v3_boolean` | |
Returns [#returns-1409]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(jsonb, eql_v3_real) [#containsjsonb-eql_v3_real]
Unsupported operator blocker for public.eql\_v3\_real.
Intercepts an operator that is not supported on public.eql\_v3\_real and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1417]
| Name | Type | Description |
| ----------- | ------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_real` | |
Returns [#returns-1410]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(eql_v3_real, jsonb) [#containseql_v3_real-jsonb]
Unsupported operator blocker for public.eql\_v3\_real.
Intercepts an operator that is not supported on public.eql\_v3\_real and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1418]
| Name | Type | Description |
| ----------- | ------------- | ------------------------------------- |
| `a public.` | `eql_v3_real` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1411]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(eql_v3_real, eql_v3_real) [#containseql_v3_real-eql_v3_real]
Unsupported operator blocker for public.eql\_v3\_real.
Intercepts an operator that is not supported on public.eql\_v3\_real and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1419]
| Name | Type | Description |
| ----------- | ------------- | ----------- |
| `a public.` | `eql_v3_real` | |
| `b public.` | `eql_v3_real` | |
Returns [#returns-1412]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(jsonb, eql_v3_real_eq) [#containsjsonb-eql_v3_real_eq]
Unsupported operator blocker for public.eql\_v3\_real\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_real\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1420]
| Name | Type | Description |
| ----------- | ---------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_real_eq` | |
Returns [#returns-1413]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(eql_v3_real_eq, jsonb) [#containseql_v3_real_eq-jsonb]
Unsupported operator blocker for public.eql\_v3\_real\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_real\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1421]
| Name | Type | Description |
| ----------- | ---------------- | ------------------------------------- |
| `a public.` | `eql_v3_real_eq` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1414]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(eql_v3_real_eq, eql_v3_real_eq) [#containseql_v3_real_eq-eql_v3_real_eq]
Unsupported operator blocker for public.eql\_v3\_real\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_real\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1422]
| Name | Type | Description |
| ----------- | ---------------- | ----------- |
| `a public.` | `eql_v3_real_eq` | |
| `b public.` | `eql_v3_real_eq` | |
Returns [#returns-1415]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(jsonb, eql_v3_text) [#containsjsonb-eql_v3_text]
Unsupported operator blocker for public.eql\_v3\_text.
Intercepts an operator that is not supported on public.eql\_v3\_text and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1423]
| Name | Type | Description |
| ----------- | ------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_text` | |
Returns [#returns-1416]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(eql_v3_text, jsonb) [#containseql_v3_text-jsonb]
Unsupported operator blocker for public.eql\_v3\_text.
Intercepts an operator that is not supported on public.eql\_v3\_text and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1424]
| Name | Type | Description |
| ----------- | ------------- | ------------------------------------- |
| `a public.` | `eql_v3_text` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1417]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(eql_v3_text, eql_v3_text) [#containseql_v3_text-eql_v3_text]
Unsupported operator blocker for public.eql\_v3\_text.
Intercepts an operator that is not supported on public.eql\_v3\_text and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1425]
| Name | Type | Description |
| ----------- | ------------- | ----------- |
| `a public.` | `eql_v3_text` | |
| `b public.` | `eql_v3_text` | |
Returns [#returns-1418]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(jsonb, eql_v3_bigint_ord_ore) [#containsjsonb-eql_v3_bigint_ord_ore]
Unsupported operator blocker for public.eql\_v3\_bigint\_ord\_ore.
Intercepts an operator that is not supported on public.eql\_v3\_bigint\_ord\_ore and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1426]
| Name | Type | Description |
| ----------- | ----------------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_bigint_ord_ore` | |
Returns [#returns-1419]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(eql_v3_bigint_ord_ore, jsonb) [#containseql_v3_bigint_ord_ore-jsonb]
Unsupported operator blocker for public.eql\_v3\_bigint\_ord\_ore.
Intercepts an operator that is not supported on public.eql\_v3\_bigint\_ord\_ore and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1427]
| Name | Type | Description |
| ----------- | ----------------------- | ------------------------------------- |
| `a public.` | `eql_v3_bigint_ord_ore` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1420]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(eql_v3_bigint_ord_ore, eql_v3_bigint_ord_ore) [#containseql_v3_bigint_ord_ore-eql_v3_bigint_ord_ore]
Unsupported operator blocker for public.eql\_v3\_bigint\_ord\_ore.
Intercepts an operator that is not supported on public.eql\_v3\_bigint\_ord\_ore and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1428]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a public.` | `eql_v3_bigint_ord_ore` | |
| `b public.` | `eql_v3_bigint_ord_ore` | |
Returns [#returns-1421]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(jsonb, eql_v3_double_eq) [#containsjsonb-eql_v3_double_eq]
Unsupported operator blocker for public.eql\_v3\_double\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_double\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1429]
| Name | Type | Description |
| ----------- | ------------------ | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_double_eq` | |
Returns [#returns-1422]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(eql_v3_double_eq, jsonb) [#containseql_v3_double_eq-jsonb]
Unsupported operator blocker for public.eql\_v3\_double\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_double\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1430]
| Name | Type | Description |
| ----------- | ------------------ | ------------------------------------- |
| `a public.` | `eql_v3_double_eq` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1423]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(eql_v3_double_eq, eql_v3_double_eq) [#containseql_v3_double_eq-eql_v3_double_eq]
Unsupported operator blocker for public.eql\_v3\_double\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_double\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1431]
| Name | Type | Description |
| ----------- | ------------------ | ----------- |
| `a public.` | `eql_v3_double_eq` | |
| `b public.` | `eql_v3_double_eq` | |
Returns [#returns-1424]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(jsonb, eql_v3_real_ord_ore) [#containsjsonb-eql_v3_real_ord_ore]
Unsupported operator blocker for public.eql\_v3\_real\_ord\_ore.
Intercepts an operator that is not supported on public.eql\_v3\_real\_ord\_ore and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1432]
| Name | Type | Description |
| ----------- | --------------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_real_ord_ore` | |
Returns [#returns-1425]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(eql_v3_real_ord_ore, jsonb) [#containseql_v3_real_ord_ore-jsonb]
Unsupported operator blocker for public.eql\_v3\_real\_ord\_ore.
Intercepts an operator that is not supported on public.eql\_v3\_real\_ord\_ore and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1433]
| Name | Type | Description |
| ----------- | --------------------- | ------------------------------------- |
| `a public.` | `eql_v3_real_ord_ore` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1426]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(eql_v3_real_ord_ore, eql_v3_real_ord_ore) [#containseql_v3_real_ord_ore-eql_v3_real_ord_ore]
Unsupported operator blocker for public.eql\_v3\_real\_ord\_ore.
Intercepts an operator that is not supported on public.eql\_v3\_real\_ord\_ore and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1434]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_real_ord_ore` | |
| `b public.` | `eql_v3_real_ord_ore` | |
Returns [#returns-1427]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(jsonb, eql_v3_numeric_ord_ore) [#containsjsonb-eql_v3_numeric_ord_ore]
Unsupported operator blocker for public.eql\_v3\_numeric\_ord\_ore.
Intercepts an operator that is not supported on public.eql\_v3\_numeric\_ord\_ore and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1435]
| Name | Type | Description |
| ----------- | ------------------------ | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_numeric_ord_ore` | |
Returns [#returns-1428]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(eql_v3_numeric_ord_ore, jsonb) [#containseql_v3_numeric_ord_ore-jsonb]
Unsupported operator blocker for public.eql\_v3\_numeric\_ord\_ore.
Intercepts an operator that is not supported on public.eql\_v3\_numeric\_ord\_ore and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1436]
| Name | Type | Description |
| ----------- | ------------------------ | ------------------------------------- |
| `a public.` | `eql_v3_numeric_ord_ore` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1429]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(eql_v3_numeric_ord_ore, eql_v3_numeric_ord_ore) [#containseql_v3_numeric_ord_ore-eql_v3_numeric_ord_ore]
Unsupported operator blocker for public.eql\_v3\_numeric\_ord\_ore.
Intercepts an operator that is not supported on public.eql\_v3\_numeric\_ord\_ore and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1437]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a public.` | `eql_v3_numeric_ord_ore` | |
| `b public.` | `eql_v3_numeric_ord_ore` | |
Returns [#returns-1430]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(jsonb, eql_v3_bigint_ord_ope) [#containsjsonb-eql_v3_bigint_ord_ope]
Unsupported operator blocker for public.eql\_v3\_bigint\_ord\_ope.
Intercepts an operator that is not supported on public.eql\_v3\_bigint\_ord\_ope and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1438]
| Name | Type | Description |
| ----------- | ----------------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_bigint_ord_ope` | |
Returns [#returns-1431]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(eql_v3_bigint_ord_ope, jsonb) [#containseql_v3_bigint_ord_ope-jsonb]
Unsupported operator blocker for public.eql\_v3\_bigint\_ord\_ope.
Intercepts an operator that is not supported on public.eql\_v3\_bigint\_ord\_ope and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1439]
| Name | Type | Description |
| ----------- | ----------------------- | ------------------------------------- |
| `a public.` | `eql_v3_bigint_ord_ope` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1432]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(eql_v3_bigint_ord_ope, eql_v3_bigint_ord_ope) [#containseql_v3_bigint_ord_ope-eql_v3_bigint_ord_ope]
Unsupported operator blocker for public.eql\_v3\_bigint\_ord\_ope.
Intercepts an operator that is not supported on public.eql\_v3\_bigint\_ord\_ope and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1440]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a public.` | `eql_v3_bigint_ord_ope` | |
| `b public.` | `eql_v3_bigint_ord_ope` | |
Returns [#returns-1433]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(jsonb, eql_v3_timestamp) [#containsjsonb-eql_v3_timestamp]
Unsupported operator blocker for public.eql\_v3\_timestamp.
Intercepts an operator that is not supported on public.eql\_v3\_timestamp and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1441]
| Name | Type | Description |
| ----------- | ------------------ | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_timestamp` | |
Returns [#returns-1434]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(eql_v3_timestamp, jsonb) [#containseql_v3_timestamp-jsonb]
Unsupported operator blocker for public.eql\_v3\_timestamp.
Intercepts an operator that is not supported on public.eql\_v3\_timestamp and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1442]
| Name | Type | Description |
| ----------- | ------------------ | ------------------------------------- |
| `a public.` | `eql_v3_timestamp` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1435]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(eql_v3_timestamp, eql_v3_timestamp) [#containseql_v3_timestamp-eql_v3_timestamp]
Unsupported operator blocker for public.eql\_v3\_timestamp.
Intercepts an operator that is not supported on public.eql\_v3\_timestamp and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1443]
| Name | Type | Description |
| ----------- | ------------------ | ----------- |
| `a public.` | `eql_v3_timestamp` | |
| `b public.` | `eql_v3_timestamp` | |
Returns [#returns-1436]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(jsonb, eql_v3_double_ord_ore) [#containsjsonb-eql_v3_double_ord_ore]
Unsupported operator blocker for public.eql\_v3\_double\_ord\_ore.
Intercepts an operator that is not supported on public.eql\_v3\_double\_ord\_ore and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1444]
| Name | Type | Description |
| ----------- | ----------------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_double_ord_ore` | |
Returns [#returns-1437]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(eql_v3_double_ord_ore, jsonb) [#containseql_v3_double_ord_ore-jsonb]
Unsupported operator blocker for public.eql\_v3\_double\_ord\_ore.
Intercepts an operator that is not supported on public.eql\_v3\_double\_ord\_ore and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1445]
| Name | Type | Description |
| ----------- | ----------------------- | ------------------------------------- |
| `a public.` | `eql_v3_double_ord_ore` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1438]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(eql_v3_double_ord_ore, eql_v3_double_ord_ore) [#containseql_v3_double_ord_ore-eql_v3_double_ord_ore]
Unsupported operator blocker for public.eql\_v3\_double\_ord\_ore.
Intercepts an operator that is not supported on public.eql\_v3\_double\_ord\_ore and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1446]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a public.` | `eql_v3_double_ord_ore` | |
| `b public.` | `eql_v3_double_ord_ore` | |
Returns [#returns-1439]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(jsonb, eql_v3_bigint_ord) [#containsjsonb-eql_v3_bigint_ord]
Unsupported operator blocker for public.eql\_v3\_bigint\_ord.
Intercepts an operator that is not supported on public.eql\_v3\_bigint\_ord and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1447]
| Name | Type | Description |
| ----------- | ------------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_bigint_ord` | |
Returns [#returns-1440]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(eql_v3_bigint_ord, jsonb) [#containseql_v3_bigint_ord-jsonb]
Unsupported operator blocker for public.eql\_v3\_bigint\_ord.
Intercepts an operator that is not supported on public.eql\_v3\_bigint\_ord and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1448]
| Name | Type | Description |
| ----------- | ------------------- | ------------------------------------- |
| `a public.` | `eql_v3_bigint_ord` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1441]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(eql_v3_bigint_ord, eql_v3_bigint_ord) [#containseql_v3_bigint_ord-eql_v3_bigint_ord]
Unsupported operator blocker for public.eql\_v3\_bigint\_ord.
Intercepts an operator that is not supported on public.eql\_v3\_bigint\_ord and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1449]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a public.` | `eql_v3_bigint_ord` | |
| `b public.` | `eql_v3_bigint_ord` | |
Returns [#returns-1442]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(jsonb, eql_v3_text_search_ore) [#containsjsonb-eql_v3_text_search_ore]
Unsupported operator blocker for public.eql\_v3\_text\_search\_ore.
Intercepts an operator that is not supported on public.eql\_v3\_text\_search\_ore and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1450]
| Name | Type | Description |
| ----------- | ------------------------ | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_text_search_ore` | |
Returns [#returns-1443]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(eql_v3_text_search_ore, jsonb) [#containseql_v3_text_search_ore-jsonb]
Unsupported operator blocker for public.eql\_v3\_text\_search\_ore.
Intercepts an operator that is not supported on public.eql\_v3\_text\_search\_ore and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1451]
| Name | Type | Description |
| ----------- | ------------------------ | ------------------------------------- |
| `a public.` | `eql_v3_text_search_ore` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1444]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(eql_v3_text_search_ore, eql_v3_text_search_ore) [#containseql_v3_text_search_ore-eql_v3_text_search_ore]
Unsupported operator blocker for public.eql\_v3\_text\_search\_ore.
Intercepts an operator that is not supported on public.eql\_v3\_text\_search\_ore and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1452]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a public.` | `eql_v3_text_search_ore` | |
| `b public.` | `eql_v3_text_search_ore` | |
Returns [#returns-1445]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(jsonb, eql_v3_numeric_eq) [#containsjsonb-eql_v3_numeric_eq]
Unsupported operator blocker for public.eql\_v3\_numeric\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_numeric\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1453]
| Name | Type | Description |
| ----------- | ------------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_numeric_eq` | |
Returns [#returns-1446]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(eql_v3_numeric_eq, jsonb) [#containseql_v3_numeric_eq-jsonb]
Unsupported operator blocker for public.eql\_v3\_numeric\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_numeric\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1454]
| Name | Type | Description |
| ----------- | ------------------- | ------------------------------------- |
| `a public.` | `eql_v3_numeric_eq` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1447]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(eql_v3_numeric_eq, eql_v3_numeric_eq) [#containseql_v3_numeric_eq-eql_v3_numeric_eq]
Unsupported operator blocker for public.eql\_v3\_numeric\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_numeric\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1455]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a public.` | `eql_v3_numeric_eq` | |
| `b public.` | `eql_v3_numeric_eq` | |
Returns [#returns-1448]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(jsonb, eql_v3_timestamp_ord) [#containsjsonb-eql_v3_timestamp_ord]
Unsupported operator blocker for public.eql\_v3\_timestamp\_ord.
Intercepts an operator that is not supported on public.eql\_v3\_timestamp\_ord and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1456]
| Name | Type | Description |
| ----------- | ---------------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_timestamp_ord` | |
Returns [#returns-1449]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(eql_v3_timestamp_ord, jsonb) [#containseql_v3_timestamp_ord-jsonb]
Unsupported operator blocker for public.eql\_v3\_timestamp\_ord.
Intercepts an operator that is not supported on public.eql\_v3\_timestamp\_ord and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1457]
| Name | Type | Description |
| ----------- | ---------------------- | ------------------------------------- |
| `a public.` | `eql_v3_timestamp_ord` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1450]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(eql_v3_timestamp_ord, eql_v3_timestamp_ord) [#containseql_v3_timestamp_ord-eql_v3_timestamp_ord]
Unsupported operator blocker for public.eql\_v3\_timestamp\_ord.
Intercepts an operator that is not supported on public.eql\_v3\_timestamp\_ord and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1458]
| Name | Type | Description |
| ----------- | ---------------------- | ----------- |
| `a public.` | `eql_v3_timestamp_ord` | |
| `b public.` | `eql_v3_timestamp_ord` | |
Returns [#returns-1451]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(jsonb, eql_v3_text_match) [#containsjsonb-eql_v3_text_match]
Unsupported operator blocker for public.eql\_v3\_text\_match.
Intercepts an operator that is not supported on public.eql\_v3\_text\_match and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1459]
| Name | Type | Description |
| ----------- | ------------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_text_match` | |
Returns [#returns-1452]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(eql_v3_text_match, jsonb) [#containseql_v3_text_match-jsonb]
Unsupported operator blocker for public.eql\_v3\_text\_match.
Intercepts an operator that is not supported on public.eql\_v3\_text\_match and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1460]
| Name | Type | Description |
| ----------- | ------------------- | ------------------------------------- |
| `a public.` | `eql_v3_text_match` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1453]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(eql_v3_text_match, eql_v3_text_match) [#containseql_v3_text_match-eql_v3_text_match]
Unsupported operator blocker for public.eql\_v3\_text\_match.
Intercepts an operator that is not supported on public.eql\_v3\_text\_match and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1461]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a public.` | `eql_v3_text_match` | |
| `b public.` | `eql_v3_text_match` | |
Returns [#returns-1454]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(jsonb, eql_v3_smallint_ord_ope) [#containsjsonb-eql_v3_smallint_ord_ope]
Unsupported operator blocker for public.eql\_v3\_smallint\_ord\_ope.
Intercepts an operator that is not supported on public.eql\_v3\_smallint\_ord\_ope and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1462]
| Name | Type | Description |
| ----------- | ------------------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_smallint_ord_ope` | |
Returns [#returns-1455]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(eql_v3_smallint_ord_ope, jsonb) [#containseql_v3_smallint_ord_ope-jsonb]
Unsupported operator blocker for public.eql\_v3\_smallint\_ord\_ope.
Intercepts an operator that is not supported on public.eql\_v3\_smallint\_ord\_ope and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1463]
| Name | Type | Description |
| ----------- | ------------------------- | ------------------------------------- |
| `a public.` | `eql_v3_smallint_ord_ope` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1456]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(eql_v3_smallint_ord_ope, eql_v3_smallint_ord_ope) [#containseql_v3_smallint_ord_ope-eql_v3_smallint_ord_ope]
Unsupported operator blocker for public.eql\_v3\_smallint\_ord\_ope.
Intercepts an operator that is not supported on public.eql\_v3\_smallint\_ord\_ope and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1464]
| Name | Type | Description |
| ----------- | ------------------------- | ----------- |
| `a public.` | `eql_v3_smallint_ord_ope` | |
| `b public.` | `eql_v3_smallint_ord_ope` | |
Returns [#returns-1457]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(jsonb, eql_v3_integer) [#containsjsonb-eql_v3_integer]
Unsupported operator blocker for public.eql\_v3\_integer.
Intercepts an operator that is not supported on public.eql\_v3\_integer and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1465]
| Name | Type | Description |
| ----------- | ---------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_integer` | |
Returns [#returns-1458]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(eql_v3_integer, jsonb) [#containseql_v3_integer-jsonb]
Unsupported operator blocker for public.eql\_v3\_integer.
Intercepts an operator that is not supported on public.eql\_v3\_integer and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1466]
| Name | Type | Description |
| ----------- | ---------------- | ------------------------------------- |
| `a public.` | `eql_v3_integer` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1459]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(eql_v3_integer, eql_v3_integer) [#containseql_v3_integer-eql_v3_integer]
Unsupported operator blocker for public.eql\_v3\_integer.
Intercepts an operator that is not supported on public.eql\_v3\_integer and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1467]
| Name | Type | Description |
| ----------- | ---------------- | ----------- |
| `a public.` | `eql_v3_integer` | |
| `b public.` | `eql_v3_integer` | |
Returns [#returns-1460]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(jsonb, eql_v3_double) [#containsjsonb-eql_v3_double]
Unsupported operator blocker for public.eql\_v3\_double.
Intercepts an operator that is not supported on public.eql\_v3\_double and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1468]
| Name | Type | Description |
| ----------- | --------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_double` | |
Returns [#returns-1461]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(eql_v3_double, jsonb) [#containseql_v3_double-jsonb]
Unsupported operator blocker for public.eql\_v3\_double.
Intercepts an operator that is not supported on public.eql\_v3\_double and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1469]
| Name | Type | Description |
| ----------- | --------------- | ------------------------------------- |
| `a public.` | `eql_v3_double` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1462]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(eql_v3_double, eql_v3_double) [#containseql_v3_double-eql_v3_double]
Unsupported operator blocker for public.eql\_v3\_double.
Intercepts an operator that is not supported on public.eql\_v3\_double and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1470]
| Name | Type | Description |
| ----------- | --------------- | ----------- |
| `a public.` | `eql_v3_double` | |
| `b public.` | `eql_v3_double` | |
Returns [#returns-1463]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(jsonb, eql_v3_timestamp_ord_ore) [#containsjsonb-eql_v3_timestamp_ord_ore]
Unsupported operator blocker for public.eql\_v3\_timestamp\_ord\_ore.
Intercepts an operator that is not supported on public.eql\_v3\_timestamp\_ord\_ore and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1471]
| Name | Type | Description |
| ----------- | -------------------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_timestamp_ord_ore` | |
Returns [#returns-1464]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(eql_v3_timestamp_ord_ore, jsonb) [#containseql_v3_timestamp_ord_ore-jsonb]
Unsupported operator blocker for public.eql\_v3\_timestamp\_ord\_ore.
Intercepts an operator that is not supported on public.eql\_v3\_timestamp\_ord\_ore and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1472]
| Name | Type | Description |
| ----------- | -------------------------- | ------------------------------------- |
| `a public.` | `eql_v3_timestamp_ord_ore` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1465]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(eql_v3_timestamp_ord_ore, eql_v3_timestamp_ord_ore) [#containseql_v3_timestamp_ord_ore-eql_v3_timestamp_ord_ore]
Unsupported operator blocker for public.eql\_v3\_timestamp\_ord\_ore.
Intercepts an operator that is not supported on public.eql\_v3\_timestamp\_ord\_ore and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1473]
| Name | Type | Description |
| ----------- | -------------------------- | ----------- |
| `a public.` | `eql_v3_timestamp_ord_ore` | |
| `b public.` | `eql_v3_timestamp_ord_ore` | |
Returns [#returns-1466]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(jsonb, eql_v3_text_search) [#containsjsonb-eql_v3_text_search]
Unsupported operator blocker for public.eql\_v3\_text\_search.
Intercepts an operator that is not supported on public.eql\_v3\_text\_search and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1474]
| Name | Type | Description |
| ----------- | -------------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_text_search` | |
Returns [#returns-1467]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(eql_v3_text_search, jsonb) [#containseql_v3_text_search-jsonb]
Unsupported operator blocker for public.eql\_v3\_text\_search.
Intercepts an operator that is not supported on public.eql\_v3\_text\_search and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1475]
| Name | Type | Description |
| ----------- | -------------------- | ------------------------------------- |
| `a public.` | `eql_v3_text_search` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1468]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(eql_v3_text_search, eql_v3_text_search) [#containseql_v3_text_search-eql_v3_text_search]
Unsupported operator blocker for public.eql\_v3\_text\_search.
Intercepts an operator that is not supported on public.eql\_v3\_text\_search and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1476]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a public.` | `eql_v3_text_search` | |
| `b public.` | `eql_v3_text_search` | |
Returns [#returns-1469]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(jsonb, eql_v3_smallint_eq) [#containsjsonb-eql_v3_smallint_eq]
Unsupported operator blocker for public.eql\_v3\_smallint\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_smallint\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1477]
| Name | Type | Description |
| ----------- | -------------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_smallint_eq` | |
Returns [#returns-1470]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(eql_v3_smallint_eq, jsonb) [#containseql_v3_smallint_eq-jsonb]
Unsupported operator blocker for public.eql\_v3\_smallint\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_smallint\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1478]
| Name | Type | Description |
| ----------- | -------------------- | ------------------------------------- |
| `a public.` | `eql_v3_smallint_eq` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1471]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(eql_v3_smallint_eq, eql_v3_smallint_eq) [#containseql_v3_smallint_eq-eql_v3_smallint_eq]
Unsupported operator blocker for public.eql\_v3\_smallint\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_smallint\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1479]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a public.` | `eql_v3_smallint_eq` | |
| `b public.` | `eql_v3_smallint_eq` | |
Returns [#returns-1472]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(jsonb, eql_v3_double_ord) [#containsjsonb-eql_v3_double_ord]
Unsupported operator blocker for public.eql\_v3\_double\_ord.
Intercepts an operator that is not supported on public.eql\_v3\_double\_ord and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1480]
| Name | Type | Description |
| ----------- | ------------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_double_ord` | |
Returns [#returns-1473]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(eql_v3_double_ord, jsonb) [#containseql_v3_double_ord-jsonb]
Unsupported operator blocker for public.eql\_v3\_double\_ord.
Intercepts an operator that is not supported on public.eql\_v3\_double\_ord and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1481]
| Name | Type | Description |
| ----------- | ------------------- | ------------------------------------- |
| `a public.` | `eql_v3_double_ord` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1474]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(eql_v3_double_ord, eql_v3_double_ord) [#containseql_v3_double_ord-eql_v3_double_ord]
Unsupported operator blocker for public.eql\_v3\_double\_ord.
Intercepts an operator that is not supported on public.eql\_v3\_double\_ord and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1482]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a public.` | `eql_v3_double_ord` | |
| `b public.` | `eql_v3_double_ord` | |
Returns [#returns-1475]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(jsonb, eql_v3_date_eq) [#containsjsonb-eql_v3_date_eq]
Unsupported operator blocker for public.eql\_v3\_date\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_date\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1483]
| Name | Type | Description |
| ----------- | ---------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_date_eq` | |
Returns [#returns-1476]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(eql_v3_date_eq, jsonb) [#containseql_v3_date_eq-jsonb]
Unsupported operator blocker for public.eql\_v3\_date\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_date\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1484]
| Name | Type | Description |
| ----------- | ---------------- | ------------------------------------- |
| `a public.` | `eql_v3_date_eq` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1477]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(eql_v3_date_eq, eql_v3_date_eq) [#containseql_v3_date_eq-eql_v3_date_eq]
Unsupported operator blocker for public.eql\_v3\_date\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_date\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1485]
| Name | Type | Description |
| ----------- | ---------------- | ----------- |
| `a public.` | `eql_v3_date_eq` | |
| `b public.` | `eql_v3_date_eq` | |
Returns [#returns-1478]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(jsonb, eql_v3_double_ord_ope) [#containsjsonb-eql_v3_double_ord_ope]
Unsupported operator blocker for public.eql\_v3\_double\_ord\_ope.
Intercepts an operator that is not supported on public.eql\_v3\_double\_ord\_ope and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1486]
| Name | Type | Description |
| ----------- | ----------------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_double_ord_ope` | |
Returns [#returns-1479]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(eql_v3_double_ord_ope, jsonb) [#containseql_v3_double_ord_ope-jsonb]
Unsupported operator blocker for public.eql\_v3\_double\_ord\_ope.
Intercepts an operator that is not supported on public.eql\_v3\_double\_ord\_ope and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1487]
| Name | Type | Description |
| ----------- | ----------------------- | ------------------------------------- |
| `a public.` | `eql_v3_double_ord_ope` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1480]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(eql_v3_double_ord_ope, eql_v3_double_ord_ope) [#containseql_v3_double_ord_ope-eql_v3_double_ord_ope]
Unsupported operator blocker for public.eql\_v3\_double\_ord\_ope.
Intercepts an operator that is not supported on public.eql\_v3\_double\_ord\_ope and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1488]
| Name | Type | Description |
| ----------- | ----------------------- | ----------- |
| `a public.` | `eql_v3_double_ord_ope` | |
| `b public.` | `eql_v3_double_ord_ope` | |
Returns [#returns-1481]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(jsonb, eql_v3_numeric_ord_ope) [#containsjsonb-eql_v3_numeric_ord_ope]
Unsupported operator blocker for public.eql\_v3\_numeric\_ord\_ope.
Intercepts an operator that is not supported on public.eql\_v3\_numeric\_ord\_ope and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1489]
| Name | Type | Description |
| ----------- | ------------------------ | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_numeric_ord_ope` | |
Returns [#returns-1482]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(eql_v3_numeric_ord_ope, jsonb) [#containseql_v3_numeric_ord_ope-jsonb]
Unsupported operator blocker for public.eql\_v3\_numeric\_ord\_ope.
Intercepts an operator that is not supported on public.eql\_v3\_numeric\_ord\_ope and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1490]
| Name | Type | Description |
| ----------- | ------------------------ | ------------------------------------- |
| `a public.` | `eql_v3_numeric_ord_ope` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1483]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(eql_v3_numeric_ord_ope, eql_v3_numeric_ord_ope) [#containseql_v3_numeric_ord_ope-eql_v3_numeric_ord_ope]
Unsupported operator blocker for public.eql\_v3\_numeric\_ord\_ope.
Intercepts an operator that is not supported on public.eql\_v3\_numeric\_ord\_ope and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1491]
| Name | Type | Description |
| ----------- | ------------------------ | ----------- |
| `a public.` | `eql_v3_numeric_ord_ope` | |
| `b public.` | `eql_v3_numeric_ord_ope` | |
Returns [#returns-1484]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(jsonb, eql_v3_date_ord_ore) [#containsjsonb-eql_v3_date_ord_ore]
Unsupported operator blocker for public.eql\_v3\_date\_ord\_ore.
Intercepts an operator that is not supported on public.eql\_v3\_date\_ord\_ore and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1492]
| Name | Type | Description |
| ----------- | --------------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_date_ord_ore` | |
Returns [#returns-1485]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(eql_v3_date_ord_ore, jsonb) [#containseql_v3_date_ord_ore-jsonb]
Unsupported operator blocker for public.eql\_v3\_date\_ord\_ore.
Intercepts an operator that is not supported on public.eql\_v3\_date\_ord\_ore and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1493]
| Name | Type | Description |
| ----------- | --------------------- | ------------------------------------- |
| `a public.` | `eql_v3_date_ord_ore` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1486]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(eql_v3_date_ord_ore, eql_v3_date_ord_ore) [#containseql_v3_date_ord_ore-eql_v3_date_ord_ore]
Unsupported operator blocker for public.eql\_v3\_date\_ord\_ore.
Intercepts an operator that is not supported on public.eql\_v3\_date\_ord\_ore and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1494]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_date_ord_ore` | |
| `b public.` | `eql_v3_date_ord_ore` | |
Returns [#returns-1487]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(jsonb, eql_v3_text_eq) [#containsjsonb-eql_v3_text_eq]
Unsupported operator blocker for public.eql\_v3\_text\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_text\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1495]
| Name | Type | Description |
| ----------- | ---------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_text_eq` | |
Returns [#returns-1488]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(eql_v3_text_eq, jsonb) [#containseql_v3_text_eq-jsonb]
Unsupported operator blocker for public.eql\_v3\_text\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_text\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1496]
| Name | Type | Description |
| ----------- | ---------------- | ------------------------------------- |
| `a public.` | `eql_v3_text_eq` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1489]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(eql_v3_text_eq, eql_v3_text_eq) [#containseql_v3_text_eq-eql_v3_text_eq]
Unsupported operator blocker for public.eql\_v3\_text\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_text\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1497]
| Name | Type | Description |
| ----------- | ---------------- | ----------- |
| `a public.` | `eql_v3_text_eq` | |
| `b public.` | `eql_v3_text_eq` | |
Returns [#returns-1490]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(jsonb, eql_v3_integer_eq) [#containsjsonb-eql_v3_integer_eq]
Unsupported operator blocker for public.eql\_v3\_integer\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_integer\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1498]
| Name | Type | Description |
| ----------- | ------------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_integer_eq` | |
Returns [#returns-1491]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(eql_v3_integer_eq, jsonb) [#containseql_v3_integer_eq-jsonb]
Unsupported operator blocker for public.eql\_v3\_integer\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_integer\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1499]
| Name | Type | Description |
| ----------- | ------------------- | ------------------------------------- |
| `a public.` | `eql_v3_integer_eq` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1492]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(eql_v3_integer_eq, eql_v3_integer_eq) [#containseql_v3_integer_eq-eql_v3_integer_eq]
Unsupported operator blocker for public.eql\_v3\_integer\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_integer\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1500]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a public.` | `eql_v3_integer_eq` | |
| `b public.` | `eql_v3_integer_eq` | |
Returns [#returns-1493]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(jsonb, eql_v3_smallint_ord_ore) [#containsjsonb-eql_v3_smallint_ord_ore]
Unsupported operator blocker for public.eql\_v3\_smallint\_ord\_ore.
Intercepts an operator that is not supported on public.eql\_v3\_smallint\_ord\_ore and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1501]
| Name | Type | Description |
| ----------- | ------------------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_smallint_ord_ore` | |
Returns [#returns-1494]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(eql_v3_smallint_ord_ore, jsonb) [#containseql_v3_smallint_ord_ore-jsonb]
Unsupported operator blocker for public.eql\_v3\_smallint\_ord\_ore.
Intercepts an operator that is not supported on public.eql\_v3\_smallint\_ord\_ore and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1502]
| Name | Type | Description |
| ----------- | ------------------------- | ------------------------------------- |
| `a public.` | `eql_v3_smallint_ord_ore` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1495]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(eql_v3_smallint_ord_ore, eql_v3_smallint_ord_ore) [#containseql_v3_smallint_ord_ore-eql_v3_smallint_ord_ore]
Unsupported operator blocker for public.eql\_v3\_smallint\_ord\_ore.
Intercepts an operator that is not supported on public.eql\_v3\_smallint\_ord\_ore and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1503]
| Name | Type | Description |
| ----------- | ------------------------- | ----------- |
| `a public.` | `eql_v3_smallint_ord_ore` | |
| `b public.` | `eql_v3_smallint_ord_ore` | |
Returns [#returns-1496]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(jsonb, eql_v3_date_ord_ope) [#containsjsonb-eql_v3_date_ord_ope]
Unsupported operator blocker for public.eql\_v3\_date\_ord\_ope.
Intercepts an operator that is not supported on public.eql\_v3\_date\_ord\_ope and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1504]
| Name | Type | Description |
| ----------- | --------------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_date_ord_ope` | |
Returns [#returns-1497]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(eql_v3_date_ord_ope, jsonb) [#containseql_v3_date_ord_ope-jsonb]
Unsupported operator blocker for public.eql\_v3\_date\_ord\_ope.
Intercepts an operator that is not supported on public.eql\_v3\_date\_ord\_ope and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1505]
| Name | Type | Description |
| ----------- | --------------------- | ------------------------------------- |
| `a public.` | `eql_v3_date_ord_ope` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1498]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(eql_v3_date_ord_ope, eql_v3_date_ord_ope) [#containseql_v3_date_ord_ope-eql_v3_date_ord_ope]
Unsupported operator blocker for public.eql\_v3\_date\_ord\_ope.
Intercepts an operator that is not supported on public.eql\_v3\_date\_ord\_ope and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1506]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_date_ord_ope` | |
| `b public.` | `eql_v3_date_ord_ope` | |
Returns [#returns-1499]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(jsonb, eql_v3_text_ord_ore) [#containsjsonb-eql_v3_text_ord_ore]
Unsupported operator blocker for public.eql\_v3\_text\_ord\_ore.
Intercepts an operator that is not supported on public.eql\_v3\_text\_ord\_ore and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1507]
| Name | Type | Description |
| ----------- | --------------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_text_ord_ore` | |
Returns [#returns-1500]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(eql_v3_text_ord_ore, jsonb) [#containseql_v3_text_ord_ore-jsonb]
Unsupported operator blocker for public.eql\_v3\_text\_ord\_ore.
Intercepts an operator that is not supported on public.eql\_v3\_text\_ord\_ore and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1508]
| Name | Type | Description |
| ----------- | --------------------- | ------------------------------------- |
| `a public.` | `eql_v3_text_ord_ore` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1501]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(eql_v3_text_ord_ore, eql_v3_text_ord_ore) [#containseql_v3_text_ord_ore-eql_v3_text_ord_ore]
Unsupported operator blocker for public.eql\_v3\_text\_ord\_ore.
Intercepts an operator that is not supported on public.eql\_v3\_text\_ord\_ore and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1509]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_text_ord_ore` | |
| `b public.` | `eql_v3_text_ord_ore` | |
Returns [#returns-1502]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(jsonb, eql_v3_smallint) [#containsjsonb-eql_v3_smallint]
Unsupported operator blocker for public.eql\_v3\_smallint.
Intercepts an operator that is not supported on public.eql\_v3\_smallint and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1510]
| Name | Type | Description |
| ----------- | ----------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_smallint` | |
Returns [#returns-1503]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(eql_v3_smallint, jsonb) [#containseql_v3_smallint-jsonb]
Unsupported operator blocker for public.eql\_v3\_smallint.
Intercepts an operator that is not supported on public.eql\_v3\_smallint and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1511]
| Name | Type | Description |
| ----------- | ----------------- | ------------------------------------- |
| `a public.` | `eql_v3_smallint` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1504]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
contains(eql_v3_smallint, eql_v3_smallint) [#containseql_v3_smallint-eql_v3_smallint]
Unsupported operator blocker for public.eql\_v3\_smallint.
Intercepts an operator that is not supported on public.eql\_v3\_smallint and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1512]
| Name | Type | Description |
| ----------- | ----------------- | ----------- |
| `a public.` | `eql_v3_smallint` | |
| `b public.` | `eql_v3_smallint` | |
Returns [#returns-1505]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
encrypted_domain_unsupported_bool(text, text) [#encrypted_domain_unsupported_booltext-text]
Shared blocker helper.
Raises 'operator X is not supported for TYPE' so unsupported domain operators surface a clear error rather than fall through to native jsonb behaviour.
Parameters [#parameters-1513]
| Name | Type | Description |
| --------------- | ------ | --------------------------- |
| `type_name` | `text` | type name (eql\_v3.\\*) |
| `operator_name` | `text` | symbol (=, \<, >, ->, etc.) |
Returns [#returns-1506]
**Type:** `boolean`
boolean (never returns; always raises)
***
encrypted_domain_unsupported_jsonb(text, text) [#encrypted_domain_unsupported_jsonbtext-text]
Shared blocker helper returning jsonb.
Identical to encrypted\_domain\_unsupported\_bool but typed for blockers shadowing native operators whose result is jsonb (#>, -, #-, ||), so composed expressions resolve and the body raises rather than failing earlier with a misleading 'operator does not exist' on a boolean result.
Parameters [#parameters-1514]
| Name | Type | Description | | |
| --------------- | ------ | -------------------------- | - | ------- |
| `type_name` | `text` | type name (eql\_v3.\\*) | | |
| `operator_name` | `text` | symbol (#>, -, #-, | | , etc.) |
Returns [#returns-1507]
**Type:** `jsonb`
jsonb (never returns; always raises)
***
encrypted_domain_unsupported_text(text, text) [#encrypted_domain_unsupported_texttext-text]
Shared blocker helper returning text.
Identical to encrypted\_domain\_unsupported\_bool but typed for blockers shadowing the native #>> operator whose result is text.
Parameters [#parameters-1515]
| Name | Type | Description |
| --------------- | ------ | -------------------------- |
| `type_name` | `text` | type name (eql\_v3.\\*) |
| `operator_name` | `text` | symbol (#>>) |
Returns [#returns-1508]
**Type:** `text`
text (never returns; always raises)
***
eq(jsonb, eql_v3_date) [#eqjsonb-eql_v3_date]
Unsupported operator blocker for public.eql\_v3\_date.
Intercepts an operator that is not supported on public.eql\_v3\_date and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1516]
| Name | Type | Description |
| ----------- | ------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_date` | |
Returns [#returns-1509]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
eq(eql_v3_date, jsonb) [#eqeql_v3_date-jsonb]
Unsupported operator blocker for public.eql\_v3\_date.
Intercepts an operator that is not supported on public.eql\_v3\_date and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1517]
| Name | Type | Description |
| ----------- | ------------- | ------------------------------------- |
| `a public.` | `eql_v3_date` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1510]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
eq(eql_v3_date, eql_v3_date) [#eqeql_v3_date-eql_v3_date]
Unsupported operator blocker for public.eql\_v3\_date.
Intercepts an operator that is not supported on public.eql\_v3\_date and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1518]
| Name | Type | Description |
| ----------- | ------------- | ----------- |
| `a public.` | `eql_v3_date` | |
| `b public.` | `eql_v3_date` | |
Returns [#returns-1511]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
eq(query_double_ord, eql_v3_json_entry) [#eqquery_double_ord-eql_v3_json_entry]
Unsupported operator blocker for public.eql\_v3\_json\_entry.
Intercepts an operator that is not supported on public.eql\_v3\_json\_entry and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1519]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a eql_v3.` | `query_double_ord` | |
| `b public.` | `eql_v3_json_entry` | |
Returns [#returns-1512]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
eq(eql_v3_json_entry, query_double_ord) [#eqeql_v3_json_entry-query_double_ord]
Unsupported operator blocker for public.eql\_v3\_json\_entry.
Intercepts an operator that is not supported on public.eql\_v3\_json\_entry and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1520]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a public.` | `eql_v3_json_entry` | |
| `b eql_v3.` | `query_double_ord` | |
Returns [#returns-1513]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
eq(query_smallint_ord, eql_v3_json_entry) [#eqquery_smallint_ord-eql_v3_json_entry]
Unsupported operator blocker for public.eql\_v3\_json\_entry.
Intercepts an operator that is not supported on public.eql\_v3\_json\_entry and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1521]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a eql_v3.` | `query_smallint_ord` | |
| `b public.` | `eql_v3_json_entry` | |
Returns [#returns-1514]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
eq(eql_v3_json_entry, query_smallint_ord) [#eqeql_v3_json_entry-query_smallint_ord]
Unsupported operator blocker for public.eql\_v3\_json\_entry.
Intercepts an operator that is not supported on public.eql\_v3\_json\_entry and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1522]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a public.` | `eql_v3_json_entry` | |
| `b eql_v3.` | `query_smallint_ord` | |
Returns [#returns-1515]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
eq(jsonb, eql_v3_bigint) [#eqjsonb-eql_v3_bigint]
Unsupported operator blocker for public.eql\_v3\_bigint.
Intercepts an operator that is not supported on public.eql\_v3\_bigint and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1523]
| Name | Type | Description |
| ----------- | --------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_bigint` | |
Returns [#returns-1516]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
eq(eql_v3_bigint, jsonb) [#eqeql_v3_bigint-jsonb]
Unsupported operator blocker for public.eql\_v3\_bigint.
Intercepts an operator that is not supported on public.eql\_v3\_bigint and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1524]
| Name | Type | Description |
| ----------- | --------------- | ------------------------------------- |
| `a public.` | `eql_v3_bigint` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1517]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
eq(eql_v3_bigint, eql_v3_bigint) [#eqeql_v3_bigint-eql_v3_bigint]
Unsupported operator blocker for public.eql\_v3\_bigint.
Intercepts an operator that is not supported on public.eql\_v3\_bigint and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1525]
| Name | Type | Description |
| ----------- | --------------- | ----------- |
| `a public.` | `eql_v3_bigint` | |
| `b public.` | `eql_v3_bigint` | |
Returns [#returns-1518]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
eq(jsonb, eql_v3_numeric) [#eqjsonb-eql_v3_numeric]
Unsupported operator blocker for public.eql\_v3\_numeric.
Intercepts an operator that is not supported on public.eql\_v3\_numeric and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1526]
| Name | Type | Description |
| ----------- | ---------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_numeric` | |
Returns [#returns-1519]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
eq(eql_v3_numeric, jsonb) [#eqeql_v3_numeric-jsonb]
Unsupported operator blocker for public.eql\_v3\_numeric.
Intercepts an operator that is not supported on public.eql\_v3\_numeric and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1527]
| Name | Type | Description |
| ----------- | ---------------- | ------------------------------------- |
| `a public.` | `eql_v3_numeric` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1520]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
eq(eql_v3_numeric, eql_v3_numeric) [#eqeql_v3_numeric-eql_v3_numeric]
Unsupported operator blocker for public.eql\_v3\_numeric.
Intercepts an operator that is not supported on public.eql\_v3\_numeric and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1528]
| Name | Type | Description |
| ----------- | ---------------- | ----------- |
| `a public.` | `eql_v3_numeric` | |
| `b public.` | `eql_v3_numeric` | |
Returns [#returns-1521]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
eq(jsonb, eql_v3_json) [#eqjsonb-eql_v3_json]
Unsupported operator blocker for public.eql\_v3\_json.
Intercepts an operator that is not supported on public.eql\_v3\_json and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1529]
| Name | Type | Description |
| ----------- | ------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_json` | |
Returns [#returns-1522]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
eq(eql_v3_json, jsonb) [#eqeql_v3_json-jsonb]
Unsupported operator blocker for public.eql\_v3\_json.
Intercepts an operator that is not supported on public.eql\_v3\_json and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1530]
| Name | Type | Description |
| ----------- | ------------- | ------------------------------------- |
| `a public.` | `eql_v3_json` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1523]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
eq(eql_v3_json, eql_v3_json) [#eqeql_v3_json-eql_v3_json]
Unsupported operator blocker for public.eql\_v3\_json.
Intercepts an operator that is not supported on public.eql\_v3\_json and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1531]
| Name | Type | Description |
| ----------- | ------------- | ----------- |
| `a public.` | `eql_v3_json` | |
| `b public.` | `eql_v3_json` | |
Returns [#returns-1524]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
eq(jsonb, eql_v3_boolean) [#eqjsonb-eql_v3_boolean]
Unsupported operator blocker for public.eql\_v3\_boolean.
Intercepts an operator that is not supported on public.eql\_v3\_boolean and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1532]
| Name | Type | Description |
| ----------- | ---------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_boolean` | |
Returns [#returns-1525]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
eq(eql_v3_boolean, jsonb) [#eqeql_v3_boolean-jsonb]
Unsupported operator blocker for public.eql\_v3\_boolean.
Intercepts an operator that is not supported on public.eql\_v3\_boolean and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1533]
| Name | Type | Description |
| ----------- | ---------------- | ------------------------------------- |
| `a public.` | `eql_v3_boolean` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1526]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
eq(eql_v3_boolean, eql_v3_boolean) [#eqeql_v3_boolean-eql_v3_boolean]
Unsupported operator blocker for public.eql\_v3\_boolean.
Intercepts an operator that is not supported on public.eql\_v3\_boolean and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1534]
| Name | Type | Description |
| ----------- | ---------------- | ----------- |
| `a public.` | `eql_v3_boolean` | |
| `b public.` | `eql_v3_boolean` | |
Returns [#returns-1527]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
eq(query_date_ord, eql_v3_json_entry) [#eqquery_date_ord-eql_v3_json_entry]
Unsupported operator blocker for public.eql\_v3\_json\_entry.
Intercepts an operator that is not supported on public.eql\_v3\_json\_entry and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1535]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a eql_v3.` | `query_date_ord` | |
| `b public.` | `eql_v3_json_entry` | |
Returns [#returns-1528]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
eq(eql_v3_json_entry, query_date_ord) [#eqeql_v3_json_entry-query_date_ord]
Unsupported operator blocker for public.eql\_v3\_json\_entry.
Intercepts an operator that is not supported on public.eql\_v3\_json\_entry and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1536]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a public.` | `eql_v3_json_entry` | |
| `b eql_v3.` | `query_date_ord` | |
Returns [#returns-1529]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
eq(jsonb, eql_v3_real) [#eqjsonb-eql_v3_real]
Unsupported operator blocker for public.eql\_v3\_real.
Intercepts an operator that is not supported on public.eql\_v3\_real and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1537]
| Name | Type | Description |
| ----------- | ------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_real` | |
Returns [#returns-1530]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
eq(eql_v3_real, jsonb) [#eqeql_v3_real-jsonb]
Unsupported operator blocker for public.eql\_v3\_real.
Intercepts an operator that is not supported on public.eql\_v3\_real and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1538]
| Name | Type | Description |
| ----------- | ------------- | ------------------------------------- |
| `a public.` | `eql_v3_real` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1531]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
eq(eql_v3_real, eql_v3_real) [#eqeql_v3_real-eql_v3_real]
Unsupported operator blocker for public.eql\_v3\_real.
Intercepts an operator that is not supported on public.eql\_v3\_real and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1539]
| Name | Type | Description |
| ----------- | ------------- | ----------- |
| `a public.` | `eql_v3_real` | |
| `b public.` | `eql_v3_real` | |
Returns [#returns-1532]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
eq(query_timestamp_ord, eql_v3_json_entry) [#eqquery_timestamp_ord-eql_v3_json_entry]
Unsupported operator blocker for public.eql\_v3\_json\_entry.
Intercepts an operator that is not supported on public.eql\_v3\_json\_entry and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1540]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a eql_v3.` | `query_timestamp_ord` | |
| `b public.` | `eql_v3_json_entry` | |
Returns [#returns-1533]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
eq(eql_v3_json_entry, query_timestamp_ord) [#eqeql_v3_json_entry-query_timestamp_ord]
Unsupported operator blocker for public.eql\_v3\_json\_entry.
Intercepts an operator that is not supported on public.eql\_v3\_json\_entry and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1541]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_json_entry` | |
| `b eql_v3.` | `query_timestamp_ord` | |
Returns [#returns-1534]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
eq(jsonb, eql_v3_text) [#eqjsonb-eql_v3_text]
Unsupported operator blocker for public.eql\_v3\_text.
Intercepts an operator that is not supported on public.eql\_v3\_text and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1542]
| Name | Type | Description |
| ----------- | ------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_text` | |
Returns [#returns-1535]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
eq(eql_v3_text, jsonb) [#eqeql_v3_text-jsonb]
Unsupported operator blocker for public.eql\_v3\_text.
Intercepts an operator that is not supported on public.eql\_v3\_text and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1543]
| Name | Type | Description |
| ----------- | ------------- | ------------------------------------- |
| `a public.` | `eql_v3_text` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1536]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
eq(eql_v3_text, eql_v3_text) [#eqeql_v3_text-eql_v3_text]
Unsupported operator blocker for public.eql\_v3\_text.
Intercepts an operator that is not supported on public.eql\_v3\_text and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1544]
| Name | Type | Description |
| ----------- | ------------- | ----------- |
| `a public.` | `eql_v3_text` | |
| `b public.` | `eql_v3_text` | |
Returns [#returns-1537]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
eq(query_numeric_ord, eql_v3_json_entry) [#eqquery_numeric_ord-eql_v3_json_entry]
Unsupported operator blocker for public.eql\_v3\_json\_entry.
Intercepts an operator that is not supported on public.eql\_v3\_json\_entry and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1545]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a eql_v3.` | `query_numeric_ord` | |
| `b public.` | `eql_v3_json_entry` | |
Returns [#returns-1538]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
eq(eql_v3_json_entry, query_numeric_ord) [#eqeql_v3_json_entry-query_numeric_ord]
Unsupported operator blocker for public.eql\_v3\_json\_entry.
Intercepts an operator that is not supported on public.eql\_v3\_json\_entry and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1546]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a public.` | `eql_v3_json_entry` | |
| `b eql_v3.` | `query_numeric_ord` | |
Returns [#returns-1539]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
eq(jsonb, eql_v3_timestamp) [#eqjsonb-eql_v3_timestamp]
Unsupported operator blocker for public.eql\_v3\_timestamp.
Intercepts an operator that is not supported on public.eql\_v3\_timestamp and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1547]
| Name | Type | Description |
| ----------- | ------------------ | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_timestamp` | |
Returns [#returns-1540]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
eq(eql_v3_timestamp, jsonb) [#eqeql_v3_timestamp-jsonb]
Unsupported operator blocker for public.eql\_v3\_timestamp.
Intercepts an operator that is not supported on public.eql\_v3\_timestamp and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1548]
| Name | Type | Description |
| ----------- | ------------------ | ------------------------------------- |
| `a public.` | `eql_v3_timestamp` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1541]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
eq(eql_v3_timestamp, eql_v3_timestamp) [#eqeql_v3_timestamp-eql_v3_timestamp]
Unsupported operator blocker for public.eql\_v3\_timestamp.
Intercepts an operator that is not supported on public.eql\_v3\_timestamp and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1549]
| Name | Type | Description |
| ----------- | ------------------ | ----------- |
| `a public.` | `eql_v3_timestamp` | |
| `b public.` | `eql_v3_timestamp` | |
Returns [#returns-1542]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
eq(query_text_ord, eql_v3_json_entry) [#eqquery_text_ord-eql_v3_json_entry]
Unsupported operator blocker for public.eql\_v3\_json\_entry.
Intercepts an operator that is not supported on public.eql\_v3\_json\_entry and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1550]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a eql_v3.` | `query_text_ord` | |
| `b public.` | `eql_v3_json_entry` | |
Returns [#returns-1543]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
eq(eql_v3_json_entry, query_text_ord) [#eqeql_v3_json_entry-query_text_ord]
Unsupported operator blocker for public.eql\_v3\_json\_entry.
Intercepts an operator that is not supported on public.eql\_v3\_json\_entry and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1551]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a public.` | `eql_v3_json_entry` | |
| `b eql_v3.` | `query_text_ord` | |
Returns [#returns-1544]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
eq(jsonb, eql_v3_text_match) [#eqjsonb-eql_v3_text_match]
Unsupported operator blocker for public.eql\_v3\_text\_match.
Intercepts an operator that is not supported on public.eql\_v3\_text\_match and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1552]
| Name | Type | Description |
| ----------- | ------------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_text_match` | |
Returns [#returns-1545]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
eq(eql_v3_text_match, jsonb) [#eqeql_v3_text_match-jsonb]
Unsupported operator blocker for public.eql\_v3\_text\_match.
Intercepts an operator that is not supported on public.eql\_v3\_text\_match and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1553]
| Name | Type | Description |
| ----------- | ------------------- | ------------------------------------- |
| `a public.` | `eql_v3_text_match` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1546]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
eq(eql_v3_text_match, eql_v3_text_match) [#eqeql_v3_text_match-eql_v3_text_match]
Unsupported operator blocker for public.eql\_v3\_text\_match.
Intercepts an operator that is not supported on public.eql\_v3\_text\_match and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1554]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a public.` | `eql_v3_text_match` | |
| `b public.` | `eql_v3_text_match` | |
Returns [#returns-1547]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
eq(query_integer_ord, eql_v3_json_entry) [#eqquery_integer_ord-eql_v3_json_entry]
Unsupported operator blocker for public.eql\_v3\_json\_entry.
Intercepts an operator that is not supported on public.eql\_v3\_json\_entry and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1555]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a eql_v3.` | `query_integer_ord` | |
| `b public.` | `eql_v3_json_entry` | |
Returns [#returns-1548]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
eq(eql_v3_json_entry, query_integer_ord) [#eqeql_v3_json_entry-query_integer_ord]
Unsupported operator blocker for public.eql\_v3\_json\_entry.
Intercepts an operator that is not supported on public.eql\_v3\_json\_entry and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1556]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a public.` | `eql_v3_json_entry` | |
| `b eql_v3.` | `query_integer_ord` | |
Returns [#returns-1549]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
eq(jsonb, eql_v3_integer) [#eqjsonb-eql_v3_integer]
Unsupported operator blocker for public.eql\_v3\_integer.
Intercepts an operator that is not supported on public.eql\_v3\_integer and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1557]
| Name | Type | Description |
| ----------- | ---------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_integer` | |
Returns [#returns-1550]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
eq(eql_v3_integer, jsonb) [#eqeql_v3_integer-jsonb]
Unsupported operator blocker for public.eql\_v3\_integer.
Intercepts an operator that is not supported on public.eql\_v3\_integer and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1558]
| Name | Type | Description |
| ----------- | ---------------- | ------------------------------------- |
| `a public.` | `eql_v3_integer` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1551]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
eq(eql_v3_integer, eql_v3_integer) [#eqeql_v3_integer-eql_v3_integer]
Unsupported operator blocker for public.eql\_v3\_integer.
Intercepts an operator that is not supported on public.eql\_v3\_integer and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1559]
| Name | Type | Description |
| ----------- | ---------------- | ----------- |
| `a public.` | `eql_v3_integer` | |
| `b public.` | `eql_v3_integer` | |
Returns [#returns-1552]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
eq(query_real_ord, eql_v3_json_entry) [#eqquery_real_ord-eql_v3_json_entry]
Unsupported operator blocker for public.eql\_v3\_json\_entry.
Intercepts an operator that is not supported on public.eql\_v3\_json\_entry and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1560]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a eql_v3.` | `query_real_ord` | |
| `b public.` | `eql_v3_json_entry` | |
Returns [#returns-1553]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
eq(eql_v3_json_entry, query_real_ord) [#eqeql_v3_json_entry-query_real_ord]
Unsupported operator blocker for public.eql\_v3\_json\_entry.
Intercepts an operator that is not supported on public.eql\_v3\_json\_entry and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1561]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a public.` | `eql_v3_json_entry` | |
| `b eql_v3.` | `query_real_ord` | |
Returns [#returns-1554]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
eq(jsonb, eql_v3_double) [#eqjsonb-eql_v3_double]
Unsupported operator blocker for public.eql\_v3\_double.
Intercepts an operator that is not supported on public.eql\_v3\_double and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1562]
| Name | Type | Description |
| ----------- | --------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_double` | |
Returns [#returns-1555]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
eq(eql_v3_double, jsonb) [#eqeql_v3_double-jsonb]
Unsupported operator blocker for public.eql\_v3\_double.
Intercepts an operator that is not supported on public.eql\_v3\_double and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1563]
| Name | Type | Description |
| ----------- | --------------- | ------------------------------------- |
| `a public.` | `eql_v3_double` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1556]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
eq(eql_v3_double, eql_v3_double) [#eqeql_v3_double-eql_v3_double]
Unsupported operator blocker for public.eql\_v3\_double.
Intercepts an operator that is not supported on public.eql\_v3\_double and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1564]
| Name | Type | Description |
| ----------- | --------------- | ----------- |
| `a public.` | `eql_v3_double` | |
| `b public.` | `eql_v3_double` | |
Returns [#returns-1557]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
eq(jsonb, eql_v3_smallint) [#eqjsonb-eql_v3_smallint]
Unsupported operator blocker for public.eql\_v3\_smallint.
Intercepts an operator that is not supported on public.eql\_v3\_smallint and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1565]
| Name | Type | Description |
| ----------- | ----------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_smallint` | |
Returns [#returns-1558]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
eq(eql_v3_smallint, jsonb) [#eqeql_v3_smallint-jsonb]
Unsupported operator blocker for public.eql\_v3\_smallint.
Intercepts an operator that is not supported on public.eql\_v3\_smallint and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1566]
| Name | Type | Description |
| ----------- | ----------------- | ------------------------------------- |
| `a public.` | `eql_v3_smallint` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1559]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
eq(eql_v3_smallint, eql_v3_smallint) [#eqeql_v3_smallint-eql_v3_smallint]
Unsupported operator blocker for public.eql\_v3\_smallint.
Intercepts an operator that is not supported on public.eql\_v3\_smallint and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1567]
| Name | Type | Description |
| ----------- | ----------------- | ----------- |
| `a public.` | `eql_v3_smallint` | |
| `b public.` | `eql_v3_smallint` | |
Returns [#returns-1560]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
eq(query_bigint_ord, eql_v3_json_entry) [#eqquery_bigint_ord-eql_v3_json_entry]
Unsupported operator blocker for public.eql\_v3\_json\_entry.
Intercepts an operator that is not supported on public.eql\_v3\_json\_entry and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1568]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a eql_v3.` | `query_bigint_ord` | |
| `b public.` | `eql_v3_json_entry` | |
Returns [#returns-1561]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
eq(eql_v3_json_entry, query_bigint_ord) [#eqeql_v3_json_entry-query_bigint_ord]
Unsupported operator blocker for public.eql\_v3\_json\_entry.
Intercepts an operator that is not supported on public.eql\_v3\_json\_entry and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1569]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a public.` | `eql_v3_json_entry` | |
| `b eql_v3.` | `query_bigint_ord` | |
Returns [#returns-1562]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
grouped_value_sfunc(jsonb, jsonb) [#grouped_value_sfuncjsonb-jsonb]
State transition function for the grouped\_value aggregate.
Parameters [#parameters-1570]
| Name | Type | Description |
| ------- | ------- | ----------- |
| `state` | `jsonb` | |
| `value` | `jsonb` | |
***
gt(jsonb, eql_v3_date) [#gtjsonb-eql_v3_date]
Unsupported operator blocker for public.eql\_v3\_date.
Intercepts an operator that is not supported on public.eql\_v3\_date and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1571]
| Name | Type | Description |
| ----------- | ------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_date` | |
Returns [#returns-1563]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gt(eql_v3_date, jsonb) [#gteql_v3_date-jsonb]
Unsupported operator blocker for public.eql\_v3\_date.
Intercepts an operator that is not supported on public.eql\_v3\_date and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1572]
| Name | Type | Description |
| ----------- | ------------- | ------------------------------------- |
| `a public.` | `eql_v3_date` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1564]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gt(eql_v3_date, eql_v3_date) [#gteql_v3_date-eql_v3_date]
Unsupported operator blocker for public.eql\_v3\_date.
Intercepts an operator that is not supported on public.eql\_v3\_date and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1573]
| Name | Type | Description |
| ----------- | ------------- | ----------- |
| `a public.` | `eql_v3_date` | |
| `b public.` | `eql_v3_date` | |
Returns [#returns-1565]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gt(jsonb, eql_v3_bigint_eq) [#gtjsonb-eql_v3_bigint_eq]
Unsupported operator blocker for public.eql\_v3\_bigint\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_bigint\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1574]
| Name | Type | Description |
| ----------- | ------------------ | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_bigint_eq` | |
Returns [#returns-1566]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gt(eql_v3_bigint_eq, jsonb) [#gteql_v3_bigint_eq-jsonb]
Unsupported operator blocker for public.eql\_v3\_bigint\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_bigint\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1575]
| Name | Type | Description |
| ----------- | ------------------ | ------------------------------------- |
| `a public.` | `eql_v3_bigint_eq` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1567]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gt(eql_v3_bigint_eq, eql_v3_bigint_eq) [#gteql_v3_bigint_eq-eql_v3_bigint_eq]
Unsupported operator blocker for public.eql\_v3\_bigint\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_bigint\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1576]
| Name | Type | Description |
| ----------- | ------------------ | ----------- |
| `a public.` | `eql_v3_bigint_eq` | |
| `b public.` | `eql_v3_bigint_eq` | |
Returns [#returns-1568]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gt(jsonb, eql_v3_bigint) [#gtjsonb-eql_v3_bigint]
Unsupported operator blocker for public.eql\_v3\_bigint.
Intercepts an operator that is not supported on public.eql\_v3\_bigint and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1577]
| Name | Type | Description |
| ----------- | --------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_bigint` | |
Returns [#returns-1569]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gt(eql_v3_bigint, jsonb) [#gteql_v3_bigint-jsonb]
Unsupported operator blocker for public.eql\_v3\_bigint.
Intercepts an operator that is not supported on public.eql\_v3\_bigint and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1578]
| Name | Type | Description |
| ----------- | --------------- | ------------------------------------- |
| `a public.` | `eql_v3_bigint` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1570]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gt(eql_v3_bigint, eql_v3_bigint) [#gteql_v3_bigint-eql_v3_bigint]
Unsupported operator blocker for public.eql\_v3\_bigint.
Intercepts an operator that is not supported on public.eql\_v3\_bigint and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1579]
| Name | Type | Description |
| ----------- | --------------- | ----------- |
| `a public.` | `eql_v3_bigint` | |
| `b public.` | `eql_v3_bigint` | |
Returns [#returns-1571]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gt(jsonb, eql_v3_numeric) [#gtjsonb-eql_v3_numeric]
Unsupported operator blocker for public.eql\_v3\_numeric.
Intercepts an operator that is not supported on public.eql\_v3\_numeric and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1580]
| Name | Type | Description |
| ----------- | ---------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_numeric` | |
Returns [#returns-1572]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gt(eql_v3_numeric, jsonb) [#gteql_v3_numeric-jsonb]
Unsupported operator blocker for public.eql\_v3\_numeric.
Intercepts an operator that is not supported on public.eql\_v3\_numeric and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1581]
| Name | Type | Description |
| ----------- | ---------------- | ------------------------------------- |
| `a public.` | `eql_v3_numeric` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1573]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gt(eql_v3_numeric, eql_v3_numeric) [#gteql_v3_numeric-eql_v3_numeric]
Unsupported operator blocker for public.eql\_v3\_numeric.
Intercepts an operator that is not supported on public.eql\_v3\_numeric and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1582]
| Name | Type | Description |
| ----------- | ---------------- | ----------- |
| `a public.` | `eql_v3_numeric` | |
| `b public.` | `eql_v3_numeric` | |
Returns [#returns-1574]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gt(jsonb, eql_v3_timestamp_eq) [#gtjsonb-eql_v3_timestamp_eq]
Unsupported operator blocker for public.eql\_v3\_timestamp\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_timestamp\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1583]
| Name | Type | Description |
| ----------- | --------------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_timestamp_eq` | |
Returns [#returns-1575]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gt(eql_v3_timestamp_eq, jsonb) [#gteql_v3_timestamp_eq-jsonb]
Unsupported operator blocker for public.eql\_v3\_timestamp\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_timestamp\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1584]
| Name | Type | Description |
| ----------- | --------------------- | ------------------------------------- |
| `a public.` | `eql_v3_timestamp_eq` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1576]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gt(eql_v3_timestamp_eq, eql_v3_timestamp_eq) [#gteql_v3_timestamp_eq-eql_v3_timestamp_eq]
Unsupported operator blocker for public.eql\_v3\_timestamp\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_timestamp\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1585]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_timestamp_eq` | |
| `b public.` | `eql_v3_timestamp_eq` | |
Returns [#returns-1577]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gt(jsonb, eql_v3_json) [#gtjsonb-eql_v3_json]
Unsupported operator blocker for public.eql\_v3\_json.
Intercepts an operator that is not supported on public.eql\_v3\_json and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1586]
| Name | Type | Description |
| ----------- | ------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_json` | |
Returns [#returns-1578]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gt(eql_v3_json, jsonb) [#gteql_v3_json-jsonb]
Unsupported operator blocker for public.eql\_v3\_json.
Intercepts an operator that is not supported on public.eql\_v3\_json and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1587]
| Name | Type | Description |
| ----------- | ------------- | ------------------------------------- |
| `a public.` | `eql_v3_json` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1579]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gt(eql_v3_json, eql_v3_json) [#gteql_v3_json-eql_v3_json]
Unsupported operator blocker for public.eql\_v3\_json.
Intercepts an operator that is not supported on public.eql\_v3\_json and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1588]
| Name | Type | Description |
| ----------- | ------------- | ----------- |
| `a public.` | `eql_v3_json` | |
| `b public.` | `eql_v3_json` | |
Returns [#returns-1580]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gt(jsonb, eql_v3_boolean) [#gtjsonb-eql_v3_boolean]
Unsupported operator blocker for public.eql\_v3\_boolean.
Intercepts an operator that is not supported on public.eql\_v3\_boolean and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1589]
| Name | Type | Description |
| ----------- | ---------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_boolean` | |
Returns [#returns-1581]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gt(eql_v3_boolean, jsonb) [#gteql_v3_boolean-jsonb]
Unsupported operator blocker for public.eql\_v3\_boolean.
Intercepts an operator that is not supported on public.eql\_v3\_boolean and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1590]
| Name | Type | Description |
| ----------- | ---------------- | ------------------------------------- |
| `a public.` | `eql_v3_boolean` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1582]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gt(eql_v3_boolean, eql_v3_boolean) [#gteql_v3_boolean-eql_v3_boolean]
Unsupported operator blocker for public.eql\_v3\_boolean.
Intercepts an operator that is not supported on public.eql\_v3\_boolean and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1591]
| Name | Type | Description |
| ----------- | ---------------- | ----------- |
| `a public.` | `eql_v3_boolean` | |
| `b public.` | `eql_v3_boolean` | |
Returns [#returns-1583]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gt(query_date_ord, eql_v3_json_entry) [#gtquery_date_ord-eql_v3_json_entry]
Unsupported operator blocker for public.eql\_v3\_json\_entry.
Intercepts an operator that is not supported on public.eql\_v3\_json\_entry and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1592]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a eql_v3.` | `query_date_ord` | |
| `b public.` | `eql_v3_json_entry` | |
Returns [#returns-1584]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gt(eql_v3_json_entry, query_date_ord) [#gteql_v3_json_entry-query_date_ord]
Unsupported operator blocker for public.eql\_v3\_json\_entry.
Intercepts an operator that is not supported on public.eql\_v3\_json\_entry and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1593]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a public.` | `eql_v3_json_entry` | |
| `b eql_v3.` | `query_date_ord` | |
Returns [#returns-1585]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gt(jsonb, eql_v3_real) [#gtjsonb-eql_v3_real]
Unsupported operator blocker for public.eql\_v3\_real.
Intercepts an operator that is not supported on public.eql\_v3\_real and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1594]
| Name | Type | Description |
| ----------- | ------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_real` | |
Returns [#returns-1586]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gt(eql_v3_real, jsonb) [#gteql_v3_real-jsonb]
Unsupported operator blocker for public.eql\_v3\_real.
Intercepts an operator that is not supported on public.eql\_v3\_real and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1595]
| Name | Type | Description |
| ----------- | ------------- | ------------------------------------- |
| `a public.` | `eql_v3_real` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1587]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gt(eql_v3_real, eql_v3_real) [#gteql_v3_real-eql_v3_real]
Unsupported operator blocker for public.eql\_v3\_real.
Intercepts an operator that is not supported on public.eql\_v3\_real and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1596]
| Name | Type | Description |
| ----------- | ------------- | ----------- |
| `a public.` | `eql_v3_real` | |
| `b public.` | `eql_v3_real` | |
Returns [#returns-1588]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gt(jsonb, eql_v3_real_eq) [#gtjsonb-eql_v3_real_eq]
Unsupported operator blocker for public.eql\_v3\_real\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_real\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1597]
| Name | Type | Description |
| ----------- | ---------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_real_eq` | |
Returns [#returns-1589]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gt(eql_v3_real_eq, jsonb) [#gteql_v3_real_eq-jsonb]
Unsupported operator blocker for public.eql\_v3\_real\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_real\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1598]
| Name | Type | Description |
| ----------- | ---------------- | ------------------------------------- |
| `a public.` | `eql_v3_real_eq` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1590]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gt(eql_v3_real_eq, eql_v3_real_eq) [#gteql_v3_real_eq-eql_v3_real_eq]
Unsupported operator blocker for public.eql\_v3\_real\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_real\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1599]
| Name | Type | Description |
| ----------- | ---------------- | ----------- |
| `a public.` | `eql_v3_real_eq` | |
| `b public.` | `eql_v3_real_eq` | |
Returns [#returns-1591]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gt(query_timestamp_ord, eql_v3_json_entry) [#gtquery_timestamp_ord-eql_v3_json_entry]
Unsupported operator blocker for public.eql\_v3\_json\_entry.
Intercepts an operator that is not supported on public.eql\_v3\_json\_entry and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1600]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a eql_v3.` | `query_timestamp_ord` | |
| `b public.` | `eql_v3_json_entry` | |
Returns [#returns-1592]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gt(eql_v3_json_entry, query_timestamp_ord) [#gteql_v3_json_entry-query_timestamp_ord]
Unsupported operator blocker for public.eql\_v3\_json\_entry.
Intercepts an operator that is not supported on public.eql\_v3\_json\_entry and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1601]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_json_entry` | |
| `b eql_v3.` | `query_timestamp_ord` | |
Returns [#returns-1593]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gt(jsonb, eql_v3_text) [#gtjsonb-eql_v3_text]
Unsupported operator blocker for public.eql\_v3\_text.
Intercepts an operator that is not supported on public.eql\_v3\_text and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1602]
| Name | Type | Description |
| ----------- | ------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_text` | |
Returns [#returns-1594]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gt(eql_v3_text, jsonb) [#gteql_v3_text-jsonb]
Unsupported operator blocker for public.eql\_v3\_text.
Intercepts an operator that is not supported on public.eql\_v3\_text and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1603]
| Name | Type | Description |
| ----------- | ------------- | ------------------------------------- |
| `a public.` | `eql_v3_text` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1595]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gt(eql_v3_text, eql_v3_text) [#gteql_v3_text-eql_v3_text]
Unsupported operator blocker for public.eql\_v3\_text.
Intercepts an operator that is not supported on public.eql\_v3\_text and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1604]
| Name | Type | Description |
| ----------- | ------------- | ----------- |
| `a public.` | `eql_v3_text` | |
| `b public.` | `eql_v3_text` | |
Returns [#returns-1596]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gt(jsonb, eql_v3_double_eq) [#gtjsonb-eql_v3_double_eq]
Unsupported operator blocker for public.eql\_v3\_double\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_double\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1605]
| Name | Type | Description |
| ----------- | ------------------ | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_double_eq` | |
Returns [#returns-1597]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gt(eql_v3_double_eq, jsonb) [#gteql_v3_double_eq-jsonb]
Unsupported operator blocker for public.eql\_v3\_double\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_double\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1606]
| Name | Type | Description |
| ----------- | ------------------ | ------------------------------------- |
| `a public.` | `eql_v3_double_eq` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1598]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gt(eql_v3_double_eq, eql_v3_double_eq) [#gteql_v3_double_eq-eql_v3_double_eq]
Unsupported operator blocker for public.eql\_v3\_double\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_double\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1607]
| Name | Type | Description |
| ----------- | ------------------ | ----------- |
| `a public.` | `eql_v3_double_eq` | |
| `b public.` | `eql_v3_double_eq` | |
Returns [#returns-1599]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gt(jsonb, eql_v3_timestamp) [#gtjsonb-eql_v3_timestamp]
Unsupported operator blocker for public.eql\_v3\_timestamp.
Intercepts an operator that is not supported on public.eql\_v3\_timestamp and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1608]
| Name | Type | Description |
| ----------- | ------------------ | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_timestamp` | |
Returns [#returns-1600]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gt(eql_v3_timestamp, jsonb) [#gteql_v3_timestamp-jsonb]
Unsupported operator blocker for public.eql\_v3\_timestamp.
Intercepts an operator that is not supported on public.eql\_v3\_timestamp and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1609]
| Name | Type | Description |
| ----------- | ------------------ | ------------------------------------- |
| `a public.` | `eql_v3_timestamp` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1601]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gt(eql_v3_timestamp, eql_v3_timestamp) [#gteql_v3_timestamp-eql_v3_timestamp]
Unsupported operator blocker for public.eql\_v3\_timestamp.
Intercepts an operator that is not supported on public.eql\_v3\_timestamp and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1610]
| Name | Type | Description |
| ----------- | ------------------ | ----------- |
| `a public.` | `eql_v3_timestamp` | |
| `b public.` | `eql_v3_timestamp` | |
Returns [#returns-1602]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gt(jsonb, eql_v3_numeric_eq) [#gtjsonb-eql_v3_numeric_eq]
Unsupported operator blocker for public.eql\_v3\_numeric\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_numeric\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1611]
| Name | Type | Description |
| ----------- | ------------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_numeric_eq` | |
Returns [#returns-1603]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gt(eql_v3_numeric_eq, jsonb) [#gteql_v3_numeric_eq-jsonb]
Unsupported operator blocker for public.eql\_v3\_numeric\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_numeric\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1612]
| Name | Type | Description |
| ----------- | ------------------- | ------------------------------------- |
| `a public.` | `eql_v3_numeric_eq` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1604]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gt(eql_v3_numeric_eq, eql_v3_numeric_eq) [#gteql_v3_numeric_eq-eql_v3_numeric_eq]
Unsupported operator blocker for public.eql\_v3\_numeric\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_numeric\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1613]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a public.` | `eql_v3_numeric_eq` | |
| `b public.` | `eql_v3_numeric_eq` | |
Returns [#returns-1605]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gt(jsonb, eql_v3_text_match) [#gtjsonb-eql_v3_text_match]
Unsupported operator blocker for public.eql\_v3\_text\_match.
Intercepts an operator that is not supported on public.eql\_v3\_text\_match and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1614]
| Name | Type | Description |
| ----------- | ------------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_text_match` | |
Returns [#returns-1606]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gt(eql_v3_text_match, jsonb) [#gteql_v3_text_match-jsonb]
Unsupported operator blocker for public.eql\_v3\_text\_match.
Intercepts an operator that is not supported on public.eql\_v3\_text\_match and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1615]
| Name | Type | Description |
| ----------- | ------------------- | ------------------------------------- |
| `a public.` | `eql_v3_text_match` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1607]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gt(eql_v3_text_match, eql_v3_text_match) [#gteql_v3_text_match-eql_v3_text_match]
Unsupported operator blocker for public.eql\_v3\_text\_match.
Intercepts an operator that is not supported on public.eql\_v3\_text\_match and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1616]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a public.` | `eql_v3_text_match` | |
| `b public.` | `eql_v3_text_match` | |
Returns [#returns-1608]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gt(jsonb, eql_v3_integer) [#gtjsonb-eql_v3_integer]
Unsupported operator blocker for public.eql\_v3\_integer.
Intercepts an operator that is not supported on public.eql\_v3\_integer and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1617]
| Name | Type | Description |
| ----------- | ---------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_integer` | |
Returns [#returns-1609]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gt(eql_v3_integer, jsonb) [#gteql_v3_integer-jsonb]
Unsupported operator blocker for public.eql\_v3\_integer.
Intercepts an operator that is not supported on public.eql\_v3\_integer and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1618]
| Name | Type | Description |
| ----------- | ---------------- | ------------------------------------- |
| `a public.` | `eql_v3_integer` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1610]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gt(eql_v3_integer, eql_v3_integer) [#gteql_v3_integer-eql_v3_integer]
Unsupported operator blocker for public.eql\_v3\_integer.
Intercepts an operator that is not supported on public.eql\_v3\_integer and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1619]
| Name | Type | Description |
| ----------- | ---------------- | ----------- |
| `a public.` | `eql_v3_integer` | |
| `b public.` | `eql_v3_integer` | |
Returns [#returns-1611]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gt(jsonb, eql_v3_double) [#gtjsonb-eql_v3_double]
Unsupported operator blocker for public.eql\_v3\_double.
Intercepts an operator that is not supported on public.eql\_v3\_double and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1620]
| Name | Type | Description |
| ----------- | --------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_double` | |
Returns [#returns-1612]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gt(eql_v3_double, jsonb) [#gteql_v3_double-jsonb]
Unsupported operator blocker for public.eql\_v3\_double.
Intercepts an operator that is not supported on public.eql\_v3\_double and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1621]
| Name | Type | Description |
| ----------- | --------------- | ------------------------------------- |
| `a public.` | `eql_v3_double` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1613]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gt(eql_v3_double, eql_v3_double) [#gteql_v3_double-eql_v3_double]
Unsupported operator blocker for public.eql\_v3\_double.
Intercepts an operator that is not supported on public.eql\_v3\_double and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1622]
| Name | Type | Description |
| ----------- | --------------- | ----------- |
| `a public.` | `eql_v3_double` | |
| `b public.` | `eql_v3_double` | |
Returns [#returns-1614]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gt(jsonb, eql_v3_smallint_eq) [#gtjsonb-eql_v3_smallint_eq]
Unsupported operator blocker for public.eql\_v3\_smallint\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_smallint\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1623]
| Name | Type | Description |
| ----------- | -------------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_smallint_eq` | |
Returns [#returns-1615]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gt(eql_v3_smallint_eq, jsonb) [#gteql_v3_smallint_eq-jsonb]
Unsupported operator blocker for public.eql\_v3\_smallint\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_smallint\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1624]
| Name | Type | Description |
| ----------- | -------------------- | ------------------------------------- |
| `a public.` | `eql_v3_smallint_eq` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1616]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gt(eql_v3_smallint_eq, eql_v3_smallint_eq) [#gteql_v3_smallint_eq-eql_v3_smallint_eq]
Unsupported operator blocker for public.eql\_v3\_smallint\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_smallint\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1625]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a public.` | `eql_v3_smallint_eq` | |
| `b public.` | `eql_v3_smallint_eq` | |
Returns [#returns-1617]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gt(jsonb, eql_v3_date_eq) [#gtjsonb-eql_v3_date_eq]
Unsupported operator blocker for public.eql\_v3\_date\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_date\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1626]
| Name | Type | Description |
| ----------- | ---------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_date_eq` | |
Returns [#returns-1618]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gt(eql_v3_date_eq, jsonb) [#gteql_v3_date_eq-jsonb]
Unsupported operator blocker for public.eql\_v3\_date\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_date\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1627]
| Name | Type | Description |
| ----------- | ---------------- | ------------------------------------- |
| `a public.` | `eql_v3_date_eq` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1619]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gt(eql_v3_date_eq, eql_v3_date_eq) [#gteql_v3_date_eq-eql_v3_date_eq]
Unsupported operator blocker for public.eql\_v3\_date\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_date\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1628]
| Name | Type | Description |
| ----------- | ---------------- | ----------- |
| `a public.` | `eql_v3_date_eq` | |
| `b public.` | `eql_v3_date_eq` | |
Returns [#returns-1620]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gt(jsonb, eql_v3_text_eq) [#gtjsonb-eql_v3_text_eq]
Unsupported operator blocker for public.eql\_v3\_text\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_text\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1629]
| Name | Type | Description |
| ----------- | ---------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_text_eq` | |
Returns [#returns-1621]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gt(eql_v3_text_eq, jsonb) [#gteql_v3_text_eq-jsonb]
Unsupported operator blocker for public.eql\_v3\_text\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_text\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1630]
| Name | Type | Description |
| ----------- | ---------------- | ------------------------------------- |
| `a public.` | `eql_v3_text_eq` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1622]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gt(eql_v3_text_eq, eql_v3_text_eq) [#gteql_v3_text_eq-eql_v3_text_eq]
Unsupported operator blocker for public.eql\_v3\_text\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_text\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1631]
| Name | Type | Description |
| ----------- | ---------------- | ----------- |
| `a public.` | `eql_v3_text_eq` | |
| `b public.` | `eql_v3_text_eq` | |
Returns [#returns-1623]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gt(jsonb, eql_v3_integer_eq) [#gtjsonb-eql_v3_integer_eq]
Unsupported operator blocker for public.eql\_v3\_integer\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_integer\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1632]
| Name | Type | Description |
| ----------- | ------------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_integer_eq` | |
Returns [#returns-1624]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gt(eql_v3_integer_eq, jsonb) [#gteql_v3_integer_eq-jsonb]
Unsupported operator blocker for public.eql\_v3\_integer\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_integer\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1633]
| Name | Type | Description |
| ----------- | ------------------- | ------------------------------------- |
| `a public.` | `eql_v3_integer_eq` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1625]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gt(eql_v3_integer_eq, eql_v3_integer_eq) [#gteql_v3_integer_eq-eql_v3_integer_eq]
Unsupported operator blocker for public.eql\_v3\_integer\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_integer\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1634]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a public.` | `eql_v3_integer_eq` | |
| `b public.` | `eql_v3_integer_eq` | |
Returns [#returns-1626]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gt(jsonb, eql_v3_smallint) [#gtjsonb-eql_v3_smallint]
Unsupported operator blocker for public.eql\_v3\_smallint.
Intercepts an operator that is not supported on public.eql\_v3\_smallint and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1635]
| Name | Type | Description |
| ----------- | ----------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_smallint` | |
Returns [#returns-1627]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gt(eql_v3_smallint, jsonb) [#gteql_v3_smallint-jsonb]
Unsupported operator blocker for public.eql\_v3\_smallint.
Intercepts an operator that is not supported on public.eql\_v3\_smallint and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1636]
| Name | Type | Description |
| ----------- | ----------------- | ------------------------------------- |
| `a public.` | `eql_v3_smallint` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1628]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gt(eql_v3_smallint, eql_v3_smallint) [#gteql_v3_smallint-eql_v3_smallint]
Unsupported operator blocker for public.eql\_v3\_smallint.
Intercepts an operator that is not supported on public.eql\_v3\_smallint and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1637]
| Name | Type | Description |
| ----------- | ----------------- | ----------- |
| `a public.` | `eql_v3_smallint` | |
| `b public.` | `eql_v3_smallint` | |
Returns [#returns-1629]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gte(jsonb, eql_v3_date) [#gtejsonb-eql_v3_date]
Unsupported operator blocker for public.eql\_v3\_date.
Intercepts an operator that is not supported on public.eql\_v3\_date and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1638]
| Name | Type | Description |
| ----------- | ------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_date` | |
Returns [#returns-1630]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gte(eql_v3_date, jsonb) [#gteeql_v3_date-jsonb]
Unsupported operator blocker for public.eql\_v3\_date.
Intercepts an operator that is not supported on public.eql\_v3\_date and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1639]
| Name | Type | Description |
| ----------- | ------------- | ------------------------------------- |
| `a public.` | `eql_v3_date` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1631]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gte(eql_v3_date, eql_v3_date) [#gteeql_v3_date-eql_v3_date]
Unsupported operator blocker for public.eql\_v3\_date.
Intercepts an operator that is not supported on public.eql\_v3\_date and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1640]
| Name | Type | Description |
| ----------- | ------------- | ----------- |
| `a public.` | `eql_v3_date` | |
| `b public.` | `eql_v3_date` | |
Returns [#returns-1632]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gte(jsonb, eql_v3_bigint_eq) [#gtejsonb-eql_v3_bigint_eq]
Unsupported operator blocker for public.eql\_v3\_bigint\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_bigint\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1641]
| Name | Type | Description |
| ----------- | ------------------ | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_bigint_eq` | |
Returns [#returns-1633]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gte(eql_v3_bigint_eq, jsonb) [#gteeql_v3_bigint_eq-jsonb]
Unsupported operator blocker for public.eql\_v3\_bigint\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_bigint\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1642]
| Name | Type | Description |
| ----------- | ------------------ | ------------------------------------- |
| `a public.` | `eql_v3_bigint_eq` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1634]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gte(eql_v3_bigint_eq, eql_v3_bigint_eq) [#gteeql_v3_bigint_eq-eql_v3_bigint_eq]
Unsupported operator blocker for public.eql\_v3\_bigint\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_bigint\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1643]
| Name | Type | Description |
| ----------- | ------------------ | ----------- |
| `a public.` | `eql_v3_bigint_eq` | |
| `b public.` | `eql_v3_bigint_eq` | |
Returns [#returns-1635]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gte(jsonb, eql_v3_bigint) [#gtejsonb-eql_v3_bigint]
Unsupported operator blocker for public.eql\_v3\_bigint.
Intercepts an operator that is not supported on public.eql\_v3\_bigint and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1644]
| Name | Type | Description |
| ----------- | --------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_bigint` | |
Returns [#returns-1636]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gte(eql_v3_bigint, jsonb) [#gteeql_v3_bigint-jsonb]
Unsupported operator blocker for public.eql\_v3\_bigint.
Intercepts an operator that is not supported on public.eql\_v3\_bigint and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1645]
| Name | Type | Description |
| ----------- | --------------- | ------------------------------------- |
| `a public.` | `eql_v3_bigint` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1637]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gte(eql_v3_bigint, eql_v3_bigint) [#gteeql_v3_bigint-eql_v3_bigint]
Unsupported operator blocker for public.eql\_v3\_bigint.
Intercepts an operator that is not supported on public.eql\_v3\_bigint and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1646]
| Name | Type | Description |
| ----------- | --------------- | ----------- |
| `a public.` | `eql_v3_bigint` | |
| `b public.` | `eql_v3_bigint` | |
Returns [#returns-1638]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gte(jsonb, eql_v3_numeric) [#gtejsonb-eql_v3_numeric]
Unsupported operator blocker for public.eql\_v3\_numeric.
Intercepts an operator that is not supported on public.eql\_v3\_numeric and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1647]
| Name | Type | Description |
| ----------- | ---------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_numeric` | |
Returns [#returns-1639]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gte(eql_v3_numeric, jsonb) [#gteeql_v3_numeric-jsonb]
Unsupported operator blocker for public.eql\_v3\_numeric.
Intercepts an operator that is not supported on public.eql\_v3\_numeric and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1648]
| Name | Type | Description |
| ----------- | ---------------- | ------------------------------------- |
| `a public.` | `eql_v3_numeric` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1640]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gte(eql_v3_numeric, eql_v3_numeric) [#gteeql_v3_numeric-eql_v3_numeric]
Unsupported operator blocker for public.eql\_v3\_numeric.
Intercepts an operator that is not supported on public.eql\_v3\_numeric and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1649]
| Name | Type | Description |
| ----------- | ---------------- | ----------- |
| `a public.` | `eql_v3_numeric` | |
| `b public.` | `eql_v3_numeric` | |
Returns [#returns-1641]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gte(jsonb, eql_v3_timestamp_eq) [#gtejsonb-eql_v3_timestamp_eq]
Unsupported operator blocker for public.eql\_v3\_timestamp\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_timestamp\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1650]
| Name | Type | Description |
| ----------- | --------------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_timestamp_eq` | |
Returns [#returns-1642]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gte(eql_v3_timestamp_eq, jsonb) [#gteeql_v3_timestamp_eq-jsonb]
Unsupported operator blocker for public.eql\_v3\_timestamp\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_timestamp\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1651]
| Name | Type | Description |
| ----------- | --------------------- | ------------------------------------- |
| `a public.` | `eql_v3_timestamp_eq` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1643]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gte(eql_v3_timestamp_eq, eql_v3_timestamp_eq) [#gteeql_v3_timestamp_eq-eql_v3_timestamp_eq]
Unsupported operator blocker for public.eql\_v3\_timestamp\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_timestamp\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1652]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_timestamp_eq` | |
| `b public.` | `eql_v3_timestamp_eq` | |
Returns [#returns-1644]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gte(jsonb, eql_v3_json) [#gtejsonb-eql_v3_json]
Unsupported operator blocker for public.eql\_v3\_json.
Intercepts an operator that is not supported on public.eql\_v3\_json and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1653]
| Name | Type | Description |
| ----------- | ------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_json` | |
Returns [#returns-1645]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gte(eql_v3_json, jsonb) [#gteeql_v3_json-jsonb]
Unsupported operator blocker for public.eql\_v3\_json.
Intercepts an operator that is not supported on public.eql\_v3\_json and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1654]
| Name | Type | Description |
| ----------- | ------------- | ------------------------------------- |
| `a public.` | `eql_v3_json` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1646]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gte(eql_v3_json, eql_v3_json) [#gteeql_v3_json-eql_v3_json]
Unsupported operator blocker for public.eql\_v3\_json.
Intercepts an operator that is not supported on public.eql\_v3\_json and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1655]
| Name | Type | Description |
| ----------- | ------------- | ----------- |
| `a public.` | `eql_v3_json` | |
| `b public.` | `eql_v3_json` | |
Returns [#returns-1647]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gte(jsonb, eql_v3_boolean) [#gtejsonb-eql_v3_boolean]
Unsupported operator blocker for public.eql\_v3\_boolean.
Intercepts an operator that is not supported on public.eql\_v3\_boolean and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1656]
| Name | Type | Description |
| ----------- | ---------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_boolean` | |
Returns [#returns-1648]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gte(eql_v3_boolean, jsonb) [#gteeql_v3_boolean-jsonb]
Unsupported operator blocker for public.eql\_v3\_boolean.
Intercepts an operator that is not supported on public.eql\_v3\_boolean and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1657]
| Name | Type | Description |
| ----------- | ---------------- | ------------------------------------- |
| `a public.` | `eql_v3_boolean` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1649]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gte(eql_v3_boolean, eql_v3_boolean) [#gteeql_v3_boolean-eql_v3_boolean]
Unsupported operator blocker for public.eql\_v3\_boolean.
Intercepts an operator that is not supported on public.eql\_v3\_boolean and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1658]
| Name | Type | Description |
| ----------- | ---------------- | ----------- |
| `a public.` | `eql_v3_boolean` | |
| `b public.` | `eql_v3_boolean` | |
Returns [#returns-1650]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gte(query_date_ord, eql_v3_json_entry) [#gtequery_date_ord-eql_v3_json_entry]
Unsupported operator blocker for public.eql\_v3\_json\_entry.
Intercepts an operator that is not supported on public.eql\_v3\_json\_entry and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1659]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a eql_v3.` | `query_date_ord` | |
| `b public.` | `eql_v3_json_entry` | |
Returns [#returns-1651]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gte(eql_v3_json_entry, query_date_ord) [#gteeql_v3_json_entry-query_date_ord]
Unsupported operator blocker for public.eql\_v3\_json\_entry.
Intercepts an operator that is not supported on public.eql\_v3\_json\_entry and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1660]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a public.` | `eql_v3_json_entry` | |
| `b eql_v3.` | `query_date_ord` | |
Returns [#returns-1652]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gte(jsonb, eql_v3_real) [#gtejsonb-eql_v3_real]
Unsupported operator blocker for public.eql\_v3\_real.
Intercepts an operator that is not supported on public.eql\_v3\_real and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1661]
| Name | Type | Description |
| ----------- | ------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_real` | |
Returns [#returns-1653]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gte(eql_v3_real, jsonb) [#gteeql_v3_real-jsonb]
Unsupported operator blocker for public.eql\_v3\_real.
Intercepts an operator that is not supported on public.eql\_v3\_real and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1662]
| Name | Type | Description |
| ----------- | ------------- | ------------------------------------- |
| `a public.` | `eql_v3_real` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1654]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gte(eql_v3_real, eql_v3_real) [#gteeql_v3_real-eql_v3_real]
Unsupported operator blocker for public.eql\_v3\_real.
Intercepts an operator that is not supported on public.eql\_v3\_real and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1663]
| Name | Type | Description |
| ----------- | ------------- | ----------- |
| `a public.` | `eql_v3_real` | |
| `b public.` | `eql_v3_real` | |
Returns [#returns-1655]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gte(jsonb, eql_v3_real_eq) [#gtejsonb-eql_v3_real_eq]
Unsupported operator blocker for public.eql\_v3\_real\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_real\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1664]
| Name | Type | Description |
| ----------- | ---------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_real_eq` | |
Returns [#returns-1656]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gte(eql_v3_real_eq, jsonb) [#gteeql_v3_real_eq-jsonb]
Unsupported operator blocker for public.eql\_v3\_real\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_real\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1665]
| Name | Type | Description |
| ----------- | ---------------- | ------------------------------------- |
| `a public.` | `eql_v3_real_eq` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1657]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gte(eql_v3_real_eq, eql_v3_real_eq) [#gteeql_v3_real_eq-eql_v3_real_eq]
Unsupported operator blocker for public.eql\_v3\_real\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_real\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1666]
| Name | Type | Description |
| ----------- | ---------------- | ----------- |
| `a public.` | `eql_v3_real_eq` | |
| `b public.` | `eql_v3_real_eq` | |
Returns [#returns-1658]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gte(query_timestamp_ord, eql_v3_json_entry) [#gtequery_timestamp_ord-eql_v3_json_entry]
Unsupported operator blocker for public.eql\_v3\_json\_entry.
Intercepts an operator that is not supported on public.eql\_v3\_json\_entry and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1667]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a eql_v3.` | `query_timestamp_ord` | |
| `b public.` | `eql_v3_json_entry` | |
Returns [#returns-1659]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gte(eql_v3_json_entry, query_timestamp_ord) [#gteeql_v3_json_entry-query_timestamp_ord]
Unsupported operator blocker for public.eql\_v3\_json\_entry.
Intercepts an operator that is not supported on public.eql\_v3\_json\_entry and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1668]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_json_entry` | |
| `b eql_v3.` | `query_timestamp_ord` | |
Returns [#returns-1660]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gte(jsonb, eql_v3_text) [#gtejsonb-eql_v3_text]
Unsupported operator blocker for public.eql\_v3\_text.
Intercepts an operator that is not supported on public.eql\_v3\_text and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1669]
| Name | Type | Description |
| ----------- | ------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_text` | |
Returns [#returns-1661]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gte(eql_v3_text, jsonb) [#gteeql_v3_text-jsonb]
Unsupported operator blocker for public.eql\_v3\_text.
Intercepts an operator that is not supported on public.eql\_v3\_text and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1670]
| Name | Type | Description |
| ----------- | ------------- | ------------------------------------- |
| `a public.` | `eql_v3_text` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1662]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gte(eql_v3_text, eql_v3_text) [#gteeql_v3_text-eql_v3_text]
Unsupported operator blocker for public.eql\_v3\_text.
Intercepts an operator that is not supported on public.eql\_v3\_text and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1671]
| Name | Type | Description |
| ----------- | ------------- | ----------- |
| `a public.` | `eql_v3_text` | |
| `b public.` | `eql_v3_text` | |
Returns [#returns-1663]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gte(jsonb, eql_v3_double_eq) [#gtejsonb-eql_v3_double_eq]
Unsupported operator blocker for public.eql\_v3\_double\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_double\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1672]
| Name | Type | Description |
| ----------- | ------------------ | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_double_eq` | |
Returns [#returns-1664]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gte(eql_v3_double_eq, jsonb) [#gteeql_v3_double_eq-jsonb]
Unsupported operator blocker for public.eql\_v3\_double\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_double\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1673]
| Name | Type | Description |
| ----------- | ------------------ | ------------------------------------- |
| `a public.` | `eql_v3_double_eq` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1665]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gte(eql_v3_double_eq, eql_v3_double_eq) [#gteeql_v3_double_eq-eql_v3_double_eq]
Unsupported operator blocker for public.eql\_v3\_double\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_double\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1674]
| Name | Type | Description |
| ----------- | ------------------ | ----------- |
| `a public.` | `eql_v3_double_eq` | |
| `b public.` | `eql_v3_double_eq` | |
Returns [#returns-1666]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gte(jsonb, eql_v3_timestamp) [#gtejsonb-eql_v3_timestamp]
Unsupported operator blocker for public.eql\_v3\_timestamp.
Intercepts an operator that is not supported on public.eql\_v3\_timestamp and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1675]
| Name | Type | Description |
| ----------- | ------------------ | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_timestamp` | |
Returns [#returns-1667]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gte(eql_v3_timestamp, jsonb) [#gteeql_v3_timestamp-jsonb]
Unsupported operator blocker for public.eql\_v3\_timestamp.
Intercepts an operator that is not supported on public.eql\_v3\_timestamp and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1676]
| Name | Type | Description |
| ----------- | ------------------ | ------------------------------------- |
| `a public.` | `eql_v3_timestamp` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1668]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gte(eql_v3_timestamp, eql_v3_timestamp) [#gteeql_v3_timestamp-eql_v3_timestamp]
Unsupported operator blocker for public.eql\_v3\_timestamp.
Intercepts an operator that is not supported on public.eql\_v3\_timestamp and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1677]
| Name | Type | Description |
| ----------- | ------------------ | ----------- |
| `a public.` | `eql_v3_timestamp` | |
| `b public.` | `eql_v3_timestamp` | |
Returns [#returns-1669]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gte(jsonb, eql_v3_numeric_eq) [#gtejsonb-eql_v3_numeric_eq]
Unsupported operator blocker for public.eql\_v3\_numeric\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_numeric\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1678]
| Name | Type | Description |
| ----------- | ------------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_numeric_eq` | |
Returns [#returns-1670]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gte(eql_v3_numeric_eq, jsonb) [#gteeql_v3_numeric_eq-jsonb]
Unsupported operator blocker for public.eql\_v3\_numeric\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_numeric\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1679]
| Name | Type | Description |
| ----------- | ------------------- | ------------------------------------- |
| `a public.` | `eql_v3_numeric_eq` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1671]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gte(eql_v3_numeric_eq, eql_v3_numeric_eq) [#gteeql_v3_numeric_eq-eql_v3_numeric_eq]
Unsupported operator blocker for public.eql\_v3\_numeric\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_numeric\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1680]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a public.` | `eql_v3_numeric_eq` | |
| `b public.` | `eql_v3_numeric_eq` | |
Returns [#returns-1672]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gte(jsonb, eql_v3_text_match) [#gtejsonb-eql_v3_text_match]
Unsupported operator blocker for public.eql\_v3\_text\_match.
Intercepts an operator that is not supported on public.eql\_v3\_text\_match and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1681]
| Name | Type | Description |
| ----------- | ------------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_text_match` | |
Returns [#returns-1673]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gte(eql_v3_text_match, jsonb) [#gteeql_v3_text_match-jsonb]
Unsupported operator blocker for public.eql\_v3\_text\_match.
Intercepts an operator that is not supported on public.eql\_v3\_text\_match and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1682]
| Name | Type | Description |
| ----------- | ------------------- | ------------------------------------- |
| `a public.` | `eql_v3_text_match` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1674]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gte(eql_v3_text_match, eql_v3_text_match) [#gteeql_v3_text_match-eql_v3_text_match]
Unsupported operator blocker for public.eql\_v3\_text\_match.
Intercepts an operator that is not supported on public.eql\_v3\_text\_match and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1683]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a public.` | `eql_v3_text_match` | |
| `b public.` | `eql_v3_text_match` | |
Returns [#returns-1675]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gte(jsonb, eql_v3_integer) [#gtejsonb-eql_v3_integer]
Unsupported operator blocker for public.eql\_v3\_integer.
Intercepts an operator that is not supported on public.eql\_v3\_integer and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1684]
| Name | Type | Description |
| ----------- | ---------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_integer` | |
Returns [#returns-1676]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gte(eql_v3_integer, jsonb) [#gteeql_v3_integer-jsonb]
Unsupported operator blocker for public.eql\_v3\_integer.
Intercepts an operator that is not supported on public.eql\_v3\_integer and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1685]
| Name | Type | Description |
| ----------- | ---------------- | ------------------------------------- |
| `a public.` | `eql_v3_integer` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1677]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gte(eql_v3_integer, eql_v3_integer) [#gteeql_v3_integer-eql_v3_integer]
Unsupported operator blocker for public.eql\_v3\_integer.
Intercepts an operator that is not supported on public.eql\_v3\_integer and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1686]
| Name | Type | Description |
| ----------- | ---------------- | ----------- |
| `a public.` | `eql_v3_integer` | |
| `b public.` | `eql_v3_integer` | |
Returns [#returns-1678]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gte(jsonb, eql_v3_double) [#gtejsonb-eql_v3_double]
Unsupported operator blocker for public.eql\_v3\_double.
Intercepts an operator that is not supported on public.eql\_v3\_double and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1687]
| Name | Type | Description |
| ----------- | --------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_double` | |
Returns [#returns-1679]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gte(eql_v3_double, jsonb) [#gteeql_v3_double-jsonb]
Unsupported operator blocker for public.eql\_v3\_double.
Intercepts an operator that is not supported on public.eql\_v3\_double and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1688]
| Name | Type | Description |
| ----------- | --------------- | ------------------------------------- |
| `a public.` | `eql_v3_double` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1680]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gte(eql_v3_double, eql_v3_double) [#gteeql_v3_double-eql_v3_double]
Unsupported operator blocker for public.eql\_v3\_double.
Intercepts an operator that is not supported on public.eql\_v3\_double and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1689]
| Name | Type | Description |
| ----------- | --------------- | ----------- |
| `a public.` | `eql_v3_double` | |
| `b public.` | `eql_v3_double` | |
Returns [#returns-1681]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gte(jsonb, eql_v3_smallint_eq) [#gtejsonb-eql_v3_smallint_eq]
Unsupported operator blocker for public.eql\_v3\_smallint\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_smallint\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1690]
| Name | Type | Description |
| ----------- | -------------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_smallint_eq` | |
Returns [#returns-1682]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gte(eql_v3_smallint_eq, jsonb) [#gteeql_v3_smallint_eq-jsonb]
Unsupported operator blocker for public.eql\_v3\_smallint\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_smallint\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1691]
| Name | Type | Description |
| ----------- | -------------------- | ------------------------------------- |
| `a public.` | `eql_v3_smallint_eq` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1683]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gte(eql_v3_smallint_eq, eql_v3_smallint_eq) [#gteeql_v3_smallint_eq-eql_v3_smallint_eq]
Unsupported operator blocker for public.eql\_v3\_smallint\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_smallint\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1692]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a public.` | `eql_v3_smallint_eq` | |
| `b public.` | `eql_v3_smallint_eq` | |
Returns [#returns-1684]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gte(jsonb, eql_v3_date_eq) [#gtejsonb-eql_v3_date_eq]
Unsupported operator blocker for public.eql\_v3\_date\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_date\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1693]
| Name | Type | Description |
| ----------- | ---------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_date_eq` | |
Returns [#returns-1685]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gte(eql_v3_date_eq, jsonb) [#gteeql_v3_date_eq-jsonb]
Unsupported operator blocker for public.eql\_v3\_date\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_date\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1694]
| Name | Type | Description |
| ----------- | ---------------- | ------------------------------------- |
| `a public.` | `eql_v3_date_eq` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1686]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gte(eql_v3_date_eq, eql_v3_date_eq) [#gteeql_v3_date_eq-eql_v3_date_eq]
Unsupported operator blocker for public.eql\_v3\_date\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_date\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1695]
| Name | Type | Description |
| ----------- | ---------------- | ----------- |
| `a public.` | `eql_v3_date_eq` | |
| `b public.` | `eql_v3_date_eq` | |
Returns [#returns-1687]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gte(jsonb, eql_v3_text_eq) [#gtejsonb-eql_v3_text_eq]
Unsupported operator blocker for public.eql\_v3\_text\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_text\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1696]
| Name | Type | Description |
| ----------- | ---------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_text_eq` | |
Returns [#returns-1688]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gte(eql_v3_text_eq, jsonb) [#gteeql_v3_text_eq-jsonb]
Unsupported operator blocker for public.eql\_v3\_text\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_text\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1697]
| Name | Type | Description |
| ----------- | ---------------- | ------------------------------------- |
| `a public.` | `eql_v3_text_eq` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1689]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gte(eql_v3_text_eq, eql_v3_text_eq) [#gteeql_v3_text_eq-eql_v3_text_eq]
Unsupported operator blocker for public.eql\_v3\_text\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_text\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1698]
| Name | Type | Description |
| ----------- | ---------------- | ----------- |
| `a public.` | `eql_v3_text_eq` | |
| `b public.` | `eql_v3_text_eq` | |
Returns [#returns-1690]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gte(jsonb, eql_v3_integer_eq) [#gtejsonb-eql_v3_integer_eq]
Unsupported operator blocker for public.eql\_v3\_integer\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_integer\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1699]
| Name | Type | Description |
| ----------- | ------------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_integer_eq` | |
Returns [#returns-1691]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gte(eql_v3_integer_eq, jsonb) [#gteeql_v3_integer_eq-jsonb]
Unsupported operator blocker for public.eql\_v3\_integer\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_integer\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1700]
| Name | Type | Description |
| ----------- | ------------------- | ------------------------------------- |
| `a public.` | `eql_v3_integer_eq` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1692]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gte(eql_v3_integer_eq, eql_v3_integer_eq) [#gteeql_v3_integer_eq-eql_v3_integer_eq]
Unsupported operator blocker for public.eql\_v3\_integer\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_integer\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1701]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a public.` | `eql_v3_integer_eq` | |
| `b public.` | `eql_v3_integer_eq` | |
Returns [#returns-1693]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gte(jsonb, eql_v3_smallint) [#gtejsonb-eql_v3_smallint]
Unsupported operator blocker for public.eql\_v3\_smallint.
Intercepts an operator that is not supported on public.eql\_v3\_smallint and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1702]
| Name | Type | Description |
| ----------- | ----------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_smallint` | |
Returns [#returns-1694]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gte(eql_v3_smallint, jsonb) [#gteeql_v3_smallint-jsonb]
Unsupported operator blocker for public.eql\_v3\_smallint.
Intercepts an operator that is not supported on public.eql\_v3\_smallint and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1703]
| Name | Type | Description |
| ----------- | ----------------- | ------------------------------------- |
| `a public.` | `eql_v3_smallint` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1695]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
gte(eql_v3_smallint, eql_v3_smallint) [#gteeql_v3_smallint-eql_v3_smallint]
Unsupported operator blocker for public.eql\_v3\_smallint.
Intercepts an operator that is not supported on public.eql\_v3\_smallint and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1704]
| Name | Type | Description |
| ----------- | ----------------- | ----------- |
| `a public.` | `eql_v3_smallint` | |
| `b public.` | `eql_v3_smallint` | |
Returns [#returns-1696]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
has_bloom_filter(jsonb) [#has_bloom_filterjsonb]
Test whether a jsonb payload carries a Bloom-filter (bf) term.
Parameters [#parameters-1705]
| Name | Type | Description |
| ----- | ------- | ---------------------- |
| `val` | `jsonb` | The encrypted payload. |
Returns [#returns-1697]
**Type:** `boolean`
boolean True when the bf key is present and non-null.
***
has_hmac_256(jsonb) [#has_hmac_256jsonb]
Check if JSONB payload contains HMAC-SHA256 index term.
Parameters [#parameters-1706]
| Name | Type | Description |
| ----- | ------- | -------------------------------- |
| `val` | `jsonb` | containing encrypted EQL payload |
Returns [#returns-1698]
**Type:** `boolean`
boolean True if 'hm' field is present and non-null
***
has_ore_block_256(jsonb) [#has_ore_block_256jsonb]
Check if JSONB payload contains an ORE block index term.
Parameters [#parameters-1707]
| Name | Type | Description |
| ----- | ------- | -------------------------------- |
| `val` | `jsonb` | containing encrypted EQL payload |
Returns [#returns-1699]
**Type:** `boolean`
boolean True only if the 'ob' field is present and is a JSON array
Note [#note-6]
A well-formed ORE index term is always a JSON array of block terms, so this guard treats a present-but-non-array ob (a scalar or object) as absent. That makes the extractor RAISE on a structurally invalid ob payload at the boundary instead of silently degrading it to a NULL index term in jsonb\_array\_to\_ore\_block\_256. The previous val ->> 'ob IS NOT NULLform stringified scalars/objects and so reported them as present.\{}(absentob) and\{"ob": null}(JSON null) both remainfalse\`.
***
hmac_256(jsonb) [#hmac_256jsonb]
Extract HMAC-SHA256 index term from JSONB payload.
Inlinable single-statement SQL — the planner can fold this into the calling query so functional hash/btree indexes built on eql\_v3\_internal.eq\_term(col) (which calls this) engage structurally.
Parameters [#parameters-1708]
| Name | Type | Description |
| ----- | ------- | -------------------------------- |
| `val` | `jsonb` | containing encrypted EQL payload |
Returns [#returns-1700]
**Type:** `eql_v3_internal.hmac_256`
eql\_v3\_internal.hmac\_256 HMAC-SHA256 hash value, or NULL when hm is absent
***
is_ste_vec_array(jsonb) [#is_ste_vec_arrayjsonb]
Check if a jsonb payload is marked as an sv array (a flag true).
Parameters [#parameters-1709]
| Name | Type | Description |
| ----- | ------- | --------------------- |
| `val` | `jsonb` | encrypted EQL payload |
Returns [#returns-1701]
**Type:** `boolean`
boolean True if a is present and true.
***
jsonb_array_to_bytea_array(jsonb) [#jsonb_array_to_bytea_arrayjsonb]
Convert JSONB hex array to bytea array.
Parameters [#parameters-1710]
| Name | Type | Description |
| ----- | ------- | ----------- |
| `val` | `jsonb` | |
***
jsonb_array_to_ore_block_256(jsonb) [#jsonb_array_to_ore_block_256jsonb]
Convert JSONB array to ORE block composite type.
Parameters [#parameters-1711]
| Name | Type | Description |
| ----- | ------- | ----------- |
| `val` | `jsonb` | |
***
jsonb_blocked_compare_json_json(eql_v3_json_search, eql_v3_json_search) [#jsonb_blocked_compare_json_jsoneql_v3_json_search-eql_v3_json_search]
Blocker: root public.eql\_v3\_json\_search document comparisons.
Parameters [#parameters-1712]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a public.` | `eql_v3_json_search` | |
| `b public.` | `eql_v3_json_search` | |
Returns [#returns-1702]
**Type:** `boolean`
boolean Never returns; always raises 'operator not supported'.
***
jsonb_blocked_compare_json_jsonb(eql_v3_json_search, jsonb) [#jsonb_blocked_compare_json_jsonbeql_v3_json_search-jsonb]
Blocker: root public.eql\_v3\_json\_search-to-jsonb comparisons.
Parameters [#parameters-1713]
| Name | Type | Description |
| ----------- | -------------------- | ------------------- |
| `a public.` | `eql_v3_json_search` | |
| `b` | `jsonb` | Native RHS operand. |
Returns [#returns-1703]
**Type:** `boolean`
boolean Never returns; always raises 'operator not supported'.
***
jsonb_blocked_compare_jsonb_json(jsonb, eql_v3_json_search) [#jsonb_blocked_compare_jsonb_jsonjsonb-eql_v3_json_search]
Blocker: root jsonb-to-public.eql\_v3\_json\_search comparisons.
Parameters [#parameters-1714]
| Name | Type | Description |
| ----------- | -------------------- | ------------------- |
| `a` | `jsonb` | Native LHS operand. |
| `b public.` | `eql_v3_json_search` | |
Returns [#returns-1704]
**Type:** `boolean`
boolean Never returns; always raises 'operator not supported'.
***
jsonb_blocked_concat(eql_v3_json_search, jsonb) [#jsonb_blocked_concateql_v3_json_search-jsonb]
Blocker: || (concatenate, encrypted on the left).
Parameters [#parameters-1715]
| Name | Type | Description |
| ----------- | -------------------- | ------------------- |
| `a public.` | `eql_v3_json_search` | |
| `b` | `jsonb` | Native RHS operand. |
Returns [#returns-1705]
**Type:** `jsonb`
jsonb Never returns; always raises 'operator not supported'.
***
jsonb_blocked_concat_rhs(jsonb, eql_v3_json_search) [#jsonb_blocked_concat_rhsjsonb-eql_v3_json_search]
Blocker: || (concatenate, encrypted on the right).
Parameters [#parameters-1716]
| Name | Type | Description |
| ----------- | -------------------- | ------------------- |
| `a` | `jsonb` | Native LHS operand. |
| `b public.` | `eql_v3_json_search` | |
Returns [#returns-1706]
**Type:** `jsonb`
jsonb Never returns; always raises 'operator not supported'.
***
jsonb_blocked_contains_entry(eql_v3_json_search, eql_v3_json_entry) [#jsonb_blocked_contains_entryeql_v3_json_search-eql_v3_json_entry]
Block document containment against an extracted path entry.
Parameters [#parameters-1717]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a public.` | `eql_v3_json_search` | |
| `b public.` | `eql_v3_json_entry` | |
Returns [#returns-1707]
**Type:** `boolean`
boolean Never returns; always raises 'operator not supported'.
Note [#note-7]
An extracted path entry carries no value selector, so this signature cannot express exact equality. It is explicitly claimed to prevent PostgreSQL flattening both domains to native jsonb containment.
***
jsonb_blocked_delete_array(eql_v3_json_search, text) [#jsonb_blocked_delete_arrayeql_v3_json_search-text]
Blocker: - (delete keys, text\[] RHS).
Parameters [#parameters-1718]
| Name | Type | Description |
| ----------- | -------------------- | ------------------- |
| `a public.` | `eql_v3_json_search` | |
| `b` | `text` | Native RHS operand. |
Returns [#returns-1708]
**Type:** `jsonb`
jsonb Never returns; always raises 'operator not supported'.
***
jsonb_blocked_delete_int(eql_v3_json_search, integer) [#jsonb_blocked_delete_inteql_v3_json_search-integer]
Blocker: - (delete index, integer RHS).
Parameters [#parameters-1719]
| Name | Type | Description |
| ----------- | -------------------- | ------------------- |
| `a public.` | `eql_v3_json_search` | |
| `b` | `integer` | Native RHS operand. |
Returns [#returns-1709]
**Type:** `jsonb`
jsonb Never returns; always raises 'operator not supported'.
***
jsonb_blocked_delete_path(eql_v3_json_search, text) [#jsonb_blocked_delete_patheql_v3_json_search-text]
Blocker: #- (delete at path).
Parameters [#parameters-1720]
| Name | Type | Description |
| ----------- | -------------------- | ------------------- |
| `a public.` | `eql_v3_json_search` | |
| `b` | `text` | Native RHS operand. |
Returns [#returns-1710]
**Type:** `jsonb`
jsonb Never returns; always raises 'operator not supported'.
***
jsonb_blocked_delete_text(eql_v3_json_search, text) [#jsonb_blocked_delete_texteql_v3_json_search-text]
Blocker: - (delete key, text RHS; native returns jsonb).
Parameters [#parameters-1721]
| Name | Type | Description |
| ----------- | -------------------- | ------------------- |
| `a public.` | `eql_v3_json_search` | |
| `b` | `text` | Native RHS operand. |
Returns [#returns-1711]
**Type:** `jsonb`
jsonb Never returns; always raises 'operator not supported'.
***
jsonb_blocked_entry_contained(eql_v3_json_entry, eql_v3_json_search) [#jsonb_blocked_entry_containedeql_v3_json_entry-eql_v3_json_search]
Block reverse containment from an extracted path entry.
Parameters [#parameters-1722]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a public.` | `eql_v3_json_entry` | |
| `b public.` | `eql_v3_json_search` | |
Returns [#returns-1712]
**Type:** `boolean`
boolean Never returns; always raises 'operator not supported'.
***
jsonb_blocked_exists(eql_v3_json_search, text) [#jsonb_blocked_existseql_v3_json_search-text]
Blocker: ? (key/element exists).
Parameters [#parameters-1723]
| Name | Type | Description |
| ----------- | -------------------- | ------------------- |
| `a public.` | `eql_v3_json_search` | |
| `b` | `text` | Native RHS operand. |
Returns [#returns-1713]
**Type:** `boolean`
boolean Never returns; always raises 'operator not supported'.
***
jsonb_blocked_exists_all(eql_v3_json_search, text) [#jsonb_blocked_exists_alleql_v3_json_search-text]
Blocker: ?& (all keys exist).
Parameters [#parameters-1724]
| Name | Type | Description |
| ----------- | -------------------- | ------------------- |
| `a public.` | `eql_v3_json_search` | |
| `b` | `text` | Native RHS operand. |
Returns [#returns-1714]
**Type:** `boolean`
boolean Never returns; always raises 'operator not supported'.
***
jsonb_blocked_exists_any(eql_v3_json_search, text) [#jsonb_blocked_exists_anyeql_v3_json_search-text]
Blocker: ?| (any key exists).
Parameters [#parameters-1725]
| Name | Type | Description |
| ----------- | -------------------- | ------------------- |
| `a public.` | `eql_v3_json_search` | |
| `b` | `text` | Native RHS operand. |
Returns [#returns-1715]
**Type:** `boolean`
boolean Never returns; always raises 'operator not supported'.
***
jsonb_blocked_jsonpath_exists(eql_v3_json_search, jsonpath) [#jsonb_blocked_jsonpath_existseql_v3_json_search-jsonpath]
Blocker: @? (jsonpath exists).
Parameters [#parameters-1726]
| Name | Type | Description |
| ----------- | -------------------- | ------------------- |
| `a public.` | `eql_v3_json_search` | |
| `b` | `jsonpath` | Native RHS operand. |
Returns [#returns-1716]
**Type:** `boolean`
boolean Never returns; always raises 'operator not supported'.
***
jsonb_blocked_jsonpath_match(eql_v3_json_search, jsonpath) [#jsonb_blocked_jsonpath_matcheql_v3_json_search-jsonpath]
Blocker: @ (jsonpath predicate).
Parameters [#parameters-1727]
| Name | Type | Description |
| ----------- | -------------------- | ------------------- |
| `a public.` | `eql_v3_json_search` | |
| `b` | `jsonpath` | Native RHS operand. |
Returns [#returns-1717]
**Type:** `boolean`
boolean Never returns; always raises 'operator not supported'.
***
jsonb_blocked_path_extract(eql_v3_json_search, text) [#jsonb_blocked_path_extracteql_v3_json_search-text]
Blocker: #> (path extract, native returns jsonb).
Parameters [#parameters-1728]
| Name | Type | Description |
| ----------- | -------------------- | ------------------- |
| `a public.` | `eql_v3_json_search` | |
| `b` | `text` | Native RHS operand. |
Returns [#returns-1718]
**Type:** `jsonb`
jsonb Never returns; always raises 'operator not supported'.
***
jsonb_blocked_path_extract_text(eql_v3_json_search, text) [#jsonb_blocked_path_extract_texteql_v3_json_search-text]
Blocker: #>> (path extract as text).
Parameters [#parameters-1729]
| Name | Type | Description |
| ----------- | -------------------- | ------------------- |
| `a public.` | `eql_v3_json_search` | |
| `b` | `text` | Native RHS operand. |
Returns [#returns-1719]
**Type:** `text`
text Never returns; always raises 'operator not supported'.
***
jsonb_entry_max_sfunc(eql_v3_json_entry, eql_v3_json_entry) [#jsonb_entry_max_sfunceql_v3_json_entry-eql_v3_json_entry]
State function for max on public.eql\_v3\_json\_entry.
Keeps whichever orderable entry has the greater CLLW OPE term. -less entries are skipped, mirroring (see the file
Parameters [#parameters-1730]
| Name | Type | Description |
| --------------- | ------------------- | ----------- |
| `state public.` | `eql_v3_json_entry` | |
| `value public.` | `eql_v3_json_entry` | |
Returns [#returns-1720]
**Type:** `public.eql_v3_json_entry`
public.eql\_v3\_json\_entry The greater orderable entry by ord\_term.
Note [#note-8]
).
***
jsonb_entry_min_sfunc(eql_v3_json_entry, eql_v3_json_entry) [#jsonb_entry_min_sfunceql_v3_json_entry-eql_v3_json_entry]
State function for min on public.eql\_v3\_json\_entry.
Keeps whichever orderable entry has the lesser CLLW OPE term. STRICT, so SQL NULL entries are skipped by the aggregate machinery; -less (non-orderable) entries are skipped explicitly (see the
Parameters [#parameters-1731]
| Name | Type | Description |
| --------------- | ------------------- | ----------- |
| `state public.` | `eql_v3_json_entry` | |
| `value public.` | `eql_v3_json_entry` | |
Returns [#returns-1721]
**Type:** `public.eql_v3_json_entry`
public.eql\_v3\_json\_entry The lesser orderable entry by ord\_term.
Note [#note-9]
on this file).
***
lt(jsonb, eql_v3_date) [#ltjsonb-eql_v3_date]
Unsupported operator blocker for public.eql\_v3\_date.
Intercepts an operator that is not supported on public.eql\_v3\_date and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1732]
| Name | Type | Description |
| ----------- | ------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_date` | |
Returns [#returns-1722]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lt(eql_v3_date, jsonb) [#lteql_v3_date-jsonb]
Unsupported operator blocker for public.eql\_v3\_date.
Intercepts an operator that is not supported on public.eql\_v3\_date and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1733]
| Name | Type | Description |
| ----------- | ------------- | ------------------------------------- |
| `a public.` | `eql_v3_date` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1723]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lt(eql_v3_date, eql_v3_date) [#lteql_v3_date-eql_v3_date]
Unsupported operator blocker for public.eql\_v3\_date.
Intercepts an operator that is not supported on public.eql\_v3\_date and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1734]
| Name | Type | Description |
| ----------- | ------------- | ----------- |
| `a public.` | `eql_v3_date` | |
| `b public.` | `eql_v3_date` | |
Returns [#returns-1724]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lt(jsonb, eql_v3_bigint_eq) [#ltjsonb-eql_v3_bigint_eq]
Unsupported operator blocker for public.eql\_v3\_bigint\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_bigint\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1735]
| Name | Type | Description |
| ----------- | ------------------ | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_bigint_eq` | |
Returns [#returns-1725]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lt(eql_v3_bigint_eq, jsonb) [#lteql_v3_bigint_eq-jsonb]
Unsupported operator blocker for public.eql\_v3\_bigint\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_bigint\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1736]
| Name | Type | Description |
| ----------- | ------------------ | ------------------------------------- |
| `a public.` | `eql_v3_bigint_eq` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1726]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lt(eql_v3_bigint_eq, eql_v3_bigint_eq) [#lteql_v3_bigint_eq-eql_v3_bigint_eq]
Unsupported operator blocker for public.eql\_v3\_bigint\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_bigint\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1737]
| Name | Type | Description |
| ----------- | ------------------ | ----------- |
| `a public.` | `eql_v3_bigint_eq` | |
| `b public.` | `eql_v3_bigint_eq` | |
Returns [#returns-1727]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lt(jsonb, eql_v3_bigint) [#ltjsonb-eql_v3_bigint]
Unsupported operator blocker for public.eql\_v3\_bigint.
Intercepts an operator that is not supported on public.eql\_v3\_bigint and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1738]
| Name | Type | Description |
| ----------- | --------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_bigint` | |
Returns [#returns-1728]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lt(eql_v3_bigint, jsonb) [#lteql_v3_bigint-jsonb]
Unsupported operator blocker for public.eql\_v3\_bigint.
Intercepts an operator that is not supported on public.eql\_v3\_bigint and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1739]
| Name | Type | Description |
| ----------- | --------------- | ------------------------------------- |
| `a public.` | `eql_v3_bigint` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1729]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lt(eql_v3_bigint, eql_v3_bigint) [#lteql_v3_bigint-eql_v3_bigint]
Unsupported operator blocker for public.eql\_v3\_bigint.
Intercepts an operator that is not supported on public.eql\_v3\_bigint and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1740]
| Name | Type | Description |
| ----------- | --------------- | ----------- |
| `a public.` | `eql_v3_bigint` | |
| `b public.` | `eql_v3_bigint` | |
Returns [#returns-1730]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lt(jsonb, eql_v3_numeric) [#ltjsonb-eql_v3_numeric]
Unsupported operator blocker for public.eql\_v3\_numeric.
Intercepts an operator that is not supported on public.eql\_v3\_numeric and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1741]
| Name | Type | Description |
| ----------- | ---------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_numeric` | |
Returns [#returns-1731]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lt(eql_v3_numeric, jsonb) [#lteql_v3_numeric-jsonb]
Unsupported operator blocker for public.eql\_v3\_numeric.
Intercepts an operator that is not supported on public.eql\_v3\_numeric and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1742]
| Name | Type | Description |
| ----------- | ---------------- | ------------------------------------- |
| `a public.` | `eql_v3_numeric` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1732]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lt(eql_v3_numeric, eql_v3_numeric) [#lteql_v3_numeric-eql_v3_numeric]
Unsupported operator blocker for public.eql\_v3\_numeric.
Intercepts an operator that is not supported on public.eql\_v3\_numeric and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1743]
| Name | Type | Description |
| ----------- | ---------------- | ----------- |
| `a public.` | `eql_v3_numeric` | |
| `b public.` | `eql_v3_numeric` | |
Returns [#returns-1733]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lt(jsonb, eql_v3_timestamp_eq) [#ltjsonb-eql_v3_timestamp_eq]
Unsupported operator blocker for public.eql\_v3\_timestamp\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_timestamp\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1744]
| Name | Type | Description |
| ----------- | --------------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_timestamp_eq` | |
Returns [#returns-1734]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lt(eql_v3_timestamp_eq, jsonb) [#lteql_v3_timestamp_eq-jsonb]
Unsupported operator blocker for public.eql\_v3\_timestamp\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_timestamp\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1745]
| Name | Type | Description |
| ----------- | --------------------- | ------------------------------------- |
| `a public.` | `eql_v3_timestamp_eq` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1735]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lt(eql_v3_timestamp_eq, eql_v3_timestamp_eq) [#lteql_v3_timestamp_eq-eql_v3_timestamp_eq]
Unsupported operator blocker for public.eql\_v3\_timestamp\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_timestamp\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1746]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_timestamp_eq` | |
| `b public.` | `eql_v3_timestamp_eq` | |
Returns [#returns-1736]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lt(jsonb, eql_v3_json) [#ltjsonb-eql_v3_json]
Unsupported operator blocker for public.eql\_v3\_json.
Intercepts an operator that is not supported on public.eql\_v3\_json and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1747]
| Name | Type | Description |
| ----------- | ------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_json` | |
Returns [#returns-1737]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lt(eql_v3_json, jsonb) [#lteql_v3_json-jsonb]
Unsupported operator blocker for public.eql\_v3\_json.
Intercepts an operator that is not supported on public.eql\_v3\_json and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1748]
| Name | Type | Description |
| ----------- | ------------- | ------------------------------------- |
| `a public.` | `eql_v3_json` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1738]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lt(eql_v3_json, eql_v3_json) [#lteql_v3_json-eql_v3_json]
Unsupported operator blocker for public.eql\_v3\_json.
Intercepts an operator that is not supported on public.eql\_v3\_json and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1749]
| Name | Type | Description |
| ----------- | ------------- | ----------- |
| `a public.` | `eql_v3_json` | |
| `b public.` | `eql_v3_json` | |
Returns [#returns-1739]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lt(jsonb, eql_v3_boolean) [#ltjsonb-eql_v3_boolean]
Unsupported operator blocker for public.eql\_v3\_boolean.
Intercepts an operator that is not supported on public.eql\_v3\_boolean and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1750]
| Name | Type | Description |
| ----------- | ---------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_boolean` | |
Returns [#returns-1740]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lt(eql_v3_boolean, jsonb) [#lteql_v3_boolean-jsonb]
Unsupported operator blocker for public.eql\_v3\_boolean.
Intercepts an operator that is not supported on public.eql\_v3\_boolean and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1751]
| Name | Type | Description |
| ----------- | ---------------- | ------------------------------------- |
| `a public.` | `eql_v3_boolean` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1741]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lt(eql_v3_boolean, eql_v3_boolean) [#lteql_v3_boolean-eql_v3_boolean]
Unsupported operator blocker for public.eql\_v3\_boolean.
Intercepts an operator that is not supported on public.eql\_v3\_boolean and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1752]
| Name | Type | Description |
| ----------- | ---------------- | ----------- |
| `a public.` | `eql_v3_boolean` | |
| `b public.` | `eql_v3_boolean` | |
Returns [#returns-1742]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lt(query_date_ord, eql_v3_json_entry) [#ltquery_date_ord-eql_v3_json_entry]
Unsupported operator blocker for public.eql\_v3\_json\_entry.
Intercepts an operator that is not supported on public.eql\_v3\_json\_entry and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1753]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a eql_v3.` | `query_date_ord` | |
| `b public.` | `eql_v3_json_entry` | |
Returns [#returns-1743]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lt(eql_v3_json_entry, query_date_ord) [#lteql_v3_json_entry-query_date_ord]
Unsupported operator blocker for public.eql\_v3\_json\_entry.
Intercepts an operator that is not supported on public.eql\_v3\_json\_entry and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1754]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a public.` | `eql_v3_json_entry` | |
| `b eql_v3.` | `query_date_ord` | |
Returns [#returns-1744]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lt(jsonb, eql_v3_real) [#ltjsonb-eql_v3_real]
Unsupported operator blocker for public.eql\_v3\_real.
Intercepts an operator that is not supported on public.eql\_v3\_real and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1755]
| Name | Type | Description |
| ----------- | ------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_real` | |
Returns [#returns-1745]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lt(eql_v3_real, jsonb) [#lteql_v3_real-jsonb]
Unsupported operator blocker for public.eql\_v3\_real.
Intercepts an operator that is not supported on public.eql\_v3\_real and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1756]
| Name | Type | Description |
| ----------- | ------------- | ------------------------------------- |
| `a public.` | `eql_v3_real` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1746]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lt(eql_v3_real, eql_v3_real) [#lteql_v3_real-eql_v3_real]
Unsupported operator blocker for public.eql\_v3\_real.
Intercepts an operator that is not supported on public.eql\_v3\_real and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1757]
| Name | Type | Description |
| ----------- | ------------- | ----------- |
| `a public.` | `eql_v3_real` | |
| `b public.` | `eql_v3_real` | |
Returns [#returns-1747]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lt(jsonb, eql_v3_real_eq) [#ltjsonb-eql_v3_real_eq]
Unsupported operator blocker for public.eql\_v3\_real\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_real\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1758]
| Name | Type | Description |
| ----------- | ---------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_real_eq` | |
Returns [#returns-1748]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lt(eql_v3_real_eq, jsonb) [#lteql_v3_real_eq-jsonb]
Unsupported operator blocker for public.eql\_v3\_real\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_real\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1759]
| Name | Type | Description |
| ----------- | ---------------- | ------------------------------------- |
| `a public.` | `eql_v3_real_eq` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1749]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lt(eql_v3_real_eq, eql_v3_real_eq) [#lteql_v3_real_eq-eql_v3_real_eq]
Unsupported operator blocker for public.eql\_v3\_real\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_real\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1760]
| Name | Type | Description |
| ----------- | ---------------- | ----------- |
| `a public.` | `eql_v3_real_eq` | |
| `b public.` | `eql_v3_real_eq` | |
Returns [#returns-1750]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lt(query_timestamp_ord, eql_v3_json_entry) [#ltquery_timestamp_ord-eql_v3_json_entry]
Unsupported operator blocker for public.eql\_v3\_json\_entry.
Intercepts an operator that is not supported on public.eql\_v3\_json\_entry and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1761]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a eql_v3.` | `query_timestamp_ord` | |
| `b public.` | `eql_v3_json_entry` | |
Returns [#returns-1751]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lt(eql_v3_json_entry, query_timestamp_ord) [#lteql_v3_json_entry-query_timestamp_ord]
Unsupported operator blocker for public.eql\_v3\_json\_entry.
Intercepts an operator that is not supported on public.eql\_v3\_json\_entry and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1762]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_json_entry` | |
| `b eql_v3.` | `query_timestamp_ord` | |
Returns [#returns-1752]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lt(jsonb, eql_v3_text) [#ltjsonb-eql_v3_text]
Unsupported operator blocker for public.eql\_v3\_text.
Intercepts an operator that is not supported on public.eql\_v3\_text and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1763]
| Name | Type | Description |
| ----------- | ------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_text` | |
Returns [#returns-1753]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lt(eql_v3_text, jsonb) [#lteql_v3_text-jsonb]
Unsupported operator blocker for public.eql\_v3\_text.
Intercepts an operator that is not supported on public.eql\_v3\_text and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1764]
| Name | Type | Description |
| ----------- | ------------- | ------------------------------------- |
| `a public.` | `eql_v3_text` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1754]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lt(eql_v3_text, eql_v3_text) [#lteql_v3_text-eql_v3_text]
Unsupported operator blocker for public.eql\_v3\_text.
Intercepts an operator that is not supported on public.eql\_v3\_text and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1765]
| Name | Type | Description |
| ----------- | ------------- | ----------- |
| `a public.` | `eql_v3_text` | |
| `b public.` | `eql_v3_text` | |
Returns [#returns-1755]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lt(jsonb, eql_v3_double_eq) [#ltjsonb-eql_v3_double_eq]
Unsupported operator blocker for public.eql\_v3\_double\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_double\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1766]
| Name | Type | Description |
| ----------- | ------------------ | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_double_eq` | |
Returns [#returns-1756]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lt(eql_v3_double_eq, jsonb) [#lteql_v3_double_eq-jsonb]
Unsupported operator blocker for public.eql\_v3\_double\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_double\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1767]
| Name | Type | Description |
| ----------- | ------------------ | ------------------------------------- |
| `a public.` | `eql_v3_double_eq` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1757]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lt(eql_v3_double_eq, eql_v3_double_eq) [#lteql_v3_double_eq-eql_v3_double_eq]
Unsupported operator blocker for public.eql\_v3\_double\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_double\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1768]
| Name | Type | Description |
| ----------- | ------------------ | ----------- |
| `a public.` | `eql_v3_double_eq` | |
| `b public.` | `eql_v3_double_eq` | |
Returns [#returns-1758]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lt(jsonb, eql_v3_timestamp) [#ltjsonb-eql_v3_timestamp]
Unsupported operator blocker for public.eql\_v3\_timestamp.
Intercepts an operator that is not supported on public.eql\_v3\_timestamp and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1769]
| Name | Type | Description |
| ----------- | ------------------ | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_timestamp` | |
Returns [#returns-1759]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lt(eql_v3_timestamp, jsonb) [#lteql_v3_timestamp-jsonb]
Unsupported operator blocker for public.eql\_v3\_timestamp.
Intercepts an operator that is not supported on public.eql\_v3\_timestamp and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1770]
| Name | Type | Description |
| ----------- | ------------------ | ------------------------------------- |
| `a public.` | `eql_v3_timestamp` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1760]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lt(eql_v3_timestamp, eql_v3_timestamp) [#lteql_v3_timestamp-eql_v3_timestamp]
Unsupported operator blocker for public.eql\_v3\_timestamp.
Intercepts an operator that is not supported on public.eql\_v3\_timestamp and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1771]
| Name | Type | Description |
| ----------- | ------------------ | ----------- |
| `a public.` | `eql_v3_timestamp` | |
| `b public.` | `eql_v3_timestamp` | |
Returns [#returns-1761]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lt(jsonb, eql_v3_numeric_eq) [#ltjsonb-eql_v3_numeric_eq]
Unsupported operator blocker for public.eql\_v3\_numeric\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_numeric\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1772]
| Name | Type | Description |
| ----------- | ------------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_numeric_eq` | |
Returns [#returns-1762]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lt(eql_v3_numeric_eq, jsonb) [#lteql_v3_numeric_eq-jsonb]
Unsupported operator blocker for public.eql\_v3\_numeric\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_numeric\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1773]
| Name | Type | Description |
| ----------- | ------------------- | ------------------------------------- |
| `a public.` | `eql_v3_numeric_eq` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1763]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lt(eql_v3_numeric_eq, eql_v3_numeric_eq) [#lteql_v3_numeric_eq-eql_v3_numeric_eq]
Unsupported operator blocker for public.eql\_v3\_numeric\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_numeric\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1774]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a public.` | `eql_v3_numeric_eq` | |
| `b public.` | `eql_v3_numeric_eq` | |
Returns [#returns-1764]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lt(jsonb, eql_v3_text_match) [#ltjsonb-eql_v3_text_match]
Unsupported operator blocker for public.eql\_v3\_text\_match.
Intercepts an operator that is not supported on public.eql\_v3\_text\_match and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1775]
| Name | Type | Description |
| ----------- | ------------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_text_match` | |
Returns [#returns-1765]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lt(eql_v3_text_match, jsonb) [#lteql_v3_text_match-jsonb]
Unsupported operator blocker for public.eql\_v3\_text\_match.
Intercepts an operator that is not supported on public.eql\_v3\_text\_match and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1776]
| Name | Type | Description |
| ----------- | ------------------- | ------------------------------------- |
| `a public.` | `eql_v3_text_match` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1766]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lt(eql_v3_text_match, eql_v3_text_match) [#lteql_v3_text_match-eql_v3_text_match]
Unsupported operator blocker for public.eql\_v3\_text\_match.
Intercepts an operator that is not supported on public.eql\_v3\_text\_match and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1777]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a public.` | `eql_v3_text_match` | |
| `b public.` | `eql_v3_text_match` | |
Returns [#returns-1767]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lt(jsonb, eql_v3_integer) [#ltjsonb-eql_v3_integer]
Unsupported operator blocker for public.eql\_v3\_integer.
Intercepts an operator that is not supported on public.eql\_v3\_integer and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1778]
| Name | Type | Description |
| ----------- | ---------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_integer` | |
Returns [#returns-1768]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lt(eql_v3_integer, jsonb) [#lteql_v3_integer-jsonb]
Unsupported operator blocker for public.eql\_v3\_integer.
Intercepts an operator that is not supported on public.eql\_v3\_integer and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1779]
| Name | Type | Description |
| ----------- | ---------------- | ------------------------------------- |
| `a public.` | `eql_v3_integer` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1769]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lt(eql_v3_integer, eql_v3_integer) [#lteql_v3_integer-eql_v3_integer]
Unsupported operator blocker for public.eql\_v3\_integer.
Intercepts an operator that is not supported on public.eql\_v3\_integer and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1780]
| Name | Type | Description |
| ----------- | ---------------- | ----------- |
| `a public.` | `eql_v3_integer` | |
| `b public.` | `eql_v3_integer` | |
Returns [#returns-1770]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lt(jsonb, eql_v3_double) [#ltjsonb-eql_v3_double]
Unsupported operator blocker for public.eql\_v3\_double.
Intercepts an operator that is not supported on public.eql\_v3\_double and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1781]
| Name | Type | Description |
| ----------- | --------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_double` | |
Returns [#returns-1771]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lt(eql_v3_double, jsonb) [#lteql_v3_double-jsonb]
Unsupported operator blocker for public.eql\_v3\_double.
Intercepts an operator that is not supported on public.eql\_v3\_double and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1782]
| Name | Type | Description |
| ----------- | --------------- | ------------------------------------- |
| `a public.` | `eql_v3_double` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1772]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lt(eql_v3_double, eql_v3_double) [#lteql_v3_double-eql_v3_double]
Unsupported operator blocker for public.eql\_v3\_double.
Intercepts an operator that is not supported on public.eql\_v3\_double and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1783]
| Name | Type | Description |
| ----------- | --------------- | ----------- |
| `a public.` | `eql_v3_double` | |
| `b public.` | `eql_v3_double` | |
Returns [#returns-1773]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lt(jsonb, eql_v3_smallint_eq) [#ltjsonb-eql_v3_smallint_eq]
Unsupported operator blocker for public.eql\_v3\_smallint\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_smallint\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1784]
| Name | Type | Description |
| ----------- | -------------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_smallint_eq` | |
Returns [#returns-1774]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lt(eql_v3_smallint_eq, jsonb) [#lteql_v3_smallint_eq-jsonb]
Unsupported operator blocker for public.eql\_v3\_smallint\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_smallint\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1785]
| Name | Type | Description |
| ----------- | -------------------- | ------------------------------------- |
| `a public.` | `eql_v3_smallint_eq` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1775]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lt(eql_v3_smallint_eq, eql_v3_smallint_eq) [#lteql_v3_smallint_eq-eql_v3_smallint_eq]
Unsupported operator blocker for public.eql\_v3\_smallint\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_smallint\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1786]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a public.` | `eql_v3_smallint_eq` | |
| `b public.` | `eql_v3_smallint_eq` | |
Returns [#returns-1776]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lt(jsonb, eql_v3_date_eq) [#ltjsonb-eql_v3_date_eq]
Unsupported operator blocker for public.eql\_v3\_date\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_date\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1787]
| Name | Type | Description |
| ----------- | ---------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_date_eq` | |
Returns [#returns-1777]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lt(eql_v3_date_eq, jsonb) [#lteql_v3_date_eq-jsonb]
Unsupported operator blocker for public.eql\_v3\_date\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_date\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1788]
| Name | Type | Description |
| ----------- | ---------------- | ------------------------------------- |
| `a public.` | `eql_v3_date_eq` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1778]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lt(eql_v3_date_eq, eql_v3_date_eq) [#lteql_v3_date_eq-eql_v3_date_eq]
Unsupported operator blocker for public.eql\_v3\_date\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_date\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1789]
| Name | Type | Description |
| ----------- | ---------------- | ----------- |
| `a public.` | `eql_v3_date_eq` | |
| `b public.` | `eql_v3_date_eq` | |
Returns [#returns-1779]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lt(jsonb, eql_v3_text_eq) [#ltjsonb-eql_v3_text_eq]
Unsupported operator blocker for public.eql\_v3\_text\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_text\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1790]
| Name | Type | Description |
| ----------- | ---------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_text_eq` | |
Returns [#returns-1780]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lt(eql_v3_text_eq, jsonb) [#lteql_v3_text_eq-jsonb]
Unsupported operator blocker for public.eql\_v3\_text\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_text\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1791]
| Name | Type | Description |
| ----------- | ---------------- | ------------------------------------- |
| `a public.` | `eql_v3_text_eq` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1781]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lt(eql_v3_text_eq, eql_v3_text_eq) [#lteql_v3_text_eq-eql_v3_text_eq]
Unsupported operator blocker for public.eql\_v3\_text\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_text\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1792]
| Name | Type | Description |
| ----------- | ---------------- | ----------- |
| `a public.` | `eql_v3_text_eq` | |
| `b public.` | `eql_v3_text_eq` | |
Returns [#returns-1782]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lt(jsonb, eql_v3_integer_eq) [#ltjsonb-eql_v3_integer_eq]
Unsupported operator blocker for public.eql\_v3\_integer\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_integer\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1793]
| Name | Type | Description |
| ----------- | ------------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_integer_eq` | |
Returns [#returns-1783]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lt(eql_v3_integer_eq, jsonb) [#lteql_v3_integer_eq-jsonb]
Unsupported operator blocker for public.eql\_v3\_integer\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_integer\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1794]
| Name | Type | Description |
| ----------- | ------------------- | ------------------------------------- |
| `a public.` | `eql_v3_integer_eq` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1784]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lt(eql_v3_integer_eq, eql_v3_integer_eq) [#lteql_v3_integer_eq-eql_v3_integer_eq]
Unsupported operator blocker for public.eql\_v3\_integer\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_integer\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1795]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a public.` | `eql_v3_integer_eq` | |
| `b public.` | `eql_v3_integer_eq` | |
Returns [#returns-1785]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lt(jsonb, eql_v3_smallint) [#ltjsonb-eql_v3_smallint]
Unsupported operator blocker for public.eql\_v3\_smallint.
Intercepts an operator that is not supported on public.eql\_v3\_smallint and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1796]
| Name | Type | Description |
| ----------- | ----------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_smallint` | |
Returns [#returns-1786]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lt(eql_v3_smallint, jsonb) [#lteql_v3_smallint-jsonb]
Unsupported operator blocker for public.eql\_v3\_smallint.
Intercepts an operator that is not supported on public.eql\_v3\_smallint and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1797]
| Name | Type | Description |
| ----------- | ----------------- | ------------------------------------- |
| `a public.` | `eql_v3_smallint` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1787]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lt(eql_v3_smallint, eql_v3_smallint) [#lteql_v3_smallint-eql_v3_smallint]
Unsupported operator blocker for public.eql\_v3\_smallint.
Intercepts an operator that is not supported on public.eql\_v3\_smallint and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1798]
| Name | Type | Description |
| ----------- | ----------------- | ----------- |
| `a public.` | `eql_v3_smallint` | |
| `b public.` | `eql_v3_smallint` | |
Returns [#returns-1788]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lte(jsonb, eql_v3_date) [#ltejsonb-eql_v3_date]
Unsupported operator blocker for public.eql\_v3\_date.
Intercepts an operator that is not supported on public.eql\_v3\_date and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1799]
| Name | Type | Description |
| ----------- | ------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_date` | |
Returns [#returns-1789]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lte(eql_v3_date, jsonb) [#lteeql_v3_date-jsonb]
Unsupported operator blocker for public.eql\_v3\_date.
Intercepts an operator that is not supported on public.eql\_v3\_date and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1800]
| Name | Type | Description |
| ----------- | ------------- | ------------------------------------- |
| `a public.` | `eql_v3_date` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1790]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lte(eql_v3_date, eql_v3_date) [#lteeql_v3_date-eql_v3_date]
Unsupported operator blocker for public.eql\_v3\_date.
Intercepts an operator that is not supported on public.eql\_v3\_date and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1801]
| Name | Type | Description |
| ----------- | ------------- | ----------- |
| `a public.` | `eql_v3_date` | |
| `b public.` | `eql_v3_date` | |
Returns [#returns-1791]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lte(jsonb, eql_v3_bigint_eq) [#ltejsonb-eql_v3_bigint_eq]
Unsupported operator blocker for public.eql\_v3\_bigint\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_bigint\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1802]
| Name | Type | Description |
| ----------- | ------------------ | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_bigint_eq` | |
Returns [#returns-1792]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lte(eql_v3_bigint_eq, jsonb) [#lteeql_v3_bigint_eq-jsonb]
Unsupported operator blocker for public.eql\_v3\_bigint\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_bigint\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1803]
| Name | Type | Description |
| ----------- | ------------------ | ------------------------------------- |
| `a public.` | `eql_v3_bigint_eq` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1793]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lte(eql_v3_bigint_eq, eql_v3_bigint_eq) [#lteeql_v3_bigint_eq-eql_v3_bigint_eq]
Unsupported operator blocker for public.eql\_v3\_bigint\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_bigint\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1804]
| Name | Type | Description |
| ----------- | ------------------ | ----------- |
| `a public.` | `eql_v3_bigint_eq` | |
| `b public.` | `eql_v3_bigint_eq` | |
Returns [#returns-1794]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lte(jsonb, eql_v3_bigint) [#ltejsonb-eql_v3_bigint]
Unsupported operator blocker for public.eql\_v3\_bigint.
Intercepts an operator that is not supported on public.eql\_v3\_bigint and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1805]
| Name | Type | Description |
| ----------- | --------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_bigint` | |
Returns [#returns-1795]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lte(eql_v3_bigint, jsonb) [#lteeql_v3_bigint-jsonb]
Unsupported operator blocker for public.eql\_v3\_bigint.
Intercepts an operator that is not supported on public.eql\_v3\_bigint and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1806]
| Name | Type | Description |
| ----------- | --------------- | ------------------------------------- |
| `a public.` | `eql_v3_bigint` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1796]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lte(eql_v3_bigint, eql_v3_bigint) [#lteeql_v3_bigint-eql_v3_bigint]
Unsupported operator blocker for public.eql\_v3\_bigint.
Intercepts an operator that is not supported on public.eql\_v3\_bigint and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1807]
| Name | Type | Description |
| ----------- | --------------- | ----------- |
| `a public.` | `eql_v3_bigint` | |
| `b public.` | `eql_v3_bigint` | |
Returns [#returns-1797]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lte(jsonb, eql_v3_numeric) [#ltejsonb-eql_v3_numeric]
Unsupported operator blocker for public.eql\_v3\_numeric.
Intercepts an operator that is not supported on public.eql\_v3\_numeric and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1808]
| Name | Type | Description |
| ----------- | ---------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_numeric` | |
Returns [#returns-1798]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lte(eql_v3_numeric, jsonb) [#lteeql_v3_numeric-jsonb]
Unsupported operator blocker for public.eql\_v3\_numeric.
Intercepts an operator that is not supported on public.eql\_v3\_numeric and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1809]
| Name | Type | Description |
| ----------- | ---------------- | ------------------------------------- |
| `a public.` | `eql_v3_numeric` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1799]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lte(eql_v3_numeric, eql_v3_numeric) [#lteeql_v3_numeric-eql_v3_numeric]
Unsupported operator blocker for public.eql\_v3\_numeric.
Intercepts an operator that is not supported on public.eql\_v3\_numeric and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1810]
| Name | Type | Description |
| ----------- | ---------------- | ----------- |
| `a public.` | `eql_v3_numeric` | |
| `b public.` | `eql_v3_numeric` | |
Returns [#returns-1800]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lte(jsonb, eql_v3_timestamp_eq) [#ltejsonb-eql_v3_timestamp_eq]
Unsupported operator blocker for public.eql\_v3\_timestamp\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_timestamp\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1811]
| Name | Type | Description |
| ----------- | --------------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_timestamp_eq` | |
Returns [#returns-1801]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lte(eql_v3_timestamp_eq, jsonb) [#lteeql_v3_timestamp_eq-jsonb]
Unsupported operator blocker for public.eql\_v3\_timestamp\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_timestamp\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1812]
| Name | Type | Description |
| ----------- | --------------------- | ------------------------------------- |
| `a public.` | `eql_v3_timestamp_eq` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1802]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lte(eql_v3_timestamp_eq, eql_v3_timestamp_eq) [#lteeql_v3_timestamp_eq-eql_v3_timestamp_eq]
Unsupported operator blocker for public.eql\_v3\_timestamp\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_timestamp\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1813]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_timestamp_eq` | |
| `b public.` | `eql_v3_timestamp_eq` | |
Returns [#returns-1803]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lte(jsonb, eql_v3_json) [#ltejsonb-eql_v3_json]
Unsupported operator blocker for public.eql\_v3\_json.
Intercepts an operator that is not supported on public.eql\_v3\_json and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1814]
| Name | Type | Description |
| ----------- | ------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_json` | |
Returns [#returns-1804]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lte(eql_v3_json, jsonb) [#lteeql_v3_json-jsonb]
Unsupported operator blocker for public.eql\_v3\_json.
Intercepts an operator that is not supported on public.eql\_v3\_json and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1815]
| Name | Type | Description |
| ----------- | ------------- | ------------------------------------- |
| `a public.` | `eql_v3_json` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1805]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lte(eql_v3_json, eql_v3_json) [#lteeql_v3_json-eql_v3_json]
Unsupported operator blocker for public.eql\_v3\_json.
Intercepts an operator that is not supported on public.eql\_v3\_json and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1816]
| Name | Type | Description |
| ----------- | ------------- | ----------- |
| `a public.` | `eql_v3_json` | |
| `b public.` | `eql_v3_json` | |
Returns [#returns-1806]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lte(jsonb, eql_v3_boolean) [#ltejsonb-eql_v3_boolean]
Unsupported operator blocker for public.eql\_v3\_boolean.
Intercepts an operator that is not supported on public.eql\_v3\_boolean and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1817]
| Name | Type | Description |
| ----------- | ---------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_boolean` | |
Returns [#returns-1807]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lte(eql_v3_boolean, jsonb) [#lteeql_v3_boolean-jsonb]
Unsupported operator blocker for public.eql\_v3\_boolean.
Intercepts an operator that is not supported on public.eql\_v3\_boolean and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1818]
| Name | Type | Description |
| ----------- | ---------------- | ------------------------------------- |
| `a public.` | `eql_v3_boolean` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1808]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lte(eql_v3_boolean, eql_v3_boolean) [#lteeql_v3_boolean-eql_v3_boolean]
Unsupported operator blocker for public.eql\_v3\_boolean.
Intercepts an operator that is not supported on public.eql\_v3\_boolean and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1819]
| Name | Type | Description |
| ----------- | ---------------- | ----------- |
| `a public.` | `eql_v3_boolean` | |
| `b public.` | `eql_v3_boolean` | |
Returns [#returns-1809]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lte(query_date_ord, eql_v3_json_entry) [#ltequery_date_ord-eql_v3_json_entry]
Unsupported operator blocker for public.eql\_v3\_json\_entry.
Intercepts an operator that is not supported on public.eql\_v3\_json\_entry and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1820]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a eql_v3.` | `query_date_ord` | |
| `b public.` | `eql_v3_json_entry` | |
Returns [#returns-1810]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lte(eql_v3_json_entry, query_date_ord) [#lteeql_v3_json_entry-query_date_ord]
Unsupported operator blocker for public.eql\_v3\_json\_entry.
Intercepts an operator that is not supported on public.eql\_v3\_json\_entry and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1821]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a public.` | `eql_v3_json_entry` | |
| `b eql_v3.` | `query_date_ord` | |
Returns [#returns-1811]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lte(jsonb, eql_v3_real) [#ltejsonb-eql_v3_real]
Unsupported operator blocker for public.eql\_v3\_real.
Intercepts an operator that is not supported on public.eql\_v3\_real and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1822]
| Name | Type | Description |
| ----------- | ------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_real` | |
Returns [#returns-1812]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lte(eql_v3_real, jsonb) [#lteeql_v3_real-jsonb]
Unsupported operator blocker for public.eql\_v3\_real.
Intercepts an operator that is not supported on public.eql\_v3\_real and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1823]
| Name | Type | Description |
| ----------- | ------------- | ------------------------------------- |
| `a public.` | `eql_v3_real` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1813]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lte(eql_v3_real, eql_v3_real) [#lteeql_v3_real-eql_v3_real]
Unsupported operator blocker for public.eql\_v3\_real.
Intercepts an operator that is not supported on public.eql\_v3\_real and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1824]
| Name | Type | Description |
| ----------- | ------------- | ----------- |
| `a public.` | `eql_v3_real` | |
| `b public.` | `eql_v3_real` | |
Returns [#returns-1814]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lte(jsonb, eql_v3_real_eq) [#ltejsonb-eql_v3_real_eq]
Unsupported operator blocker for public.eql\_v3\_real\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_real\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1825]
| Name | Type | Description |
| ----------- | ---------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_real_eq` | |
Returns [#returns-1815]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lte(eql_v3_real_eq, jsonb) [#lteeql_v3_real_eq-jsonb]
Unsupported operator blocker for public.eql\_v3\_real\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_real\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1826]
| Name | Type | Description |
| ----------- | ---------------- | ------------------------------------- |
| `a public.` | `eql_v3_real_eq` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1816]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lte(eql_v3_real_eq, eql_v3_real_eq) [#lteeql_v3_real_eq-eql_v3_real_eq]
Unsupported operator blocker for public.eql\_v3\_real\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_real\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1827]
| Name | Type | Description |
| ----------- | ---------------- | ----------- |
| `a public.` | `eql_v3_real_eq` | |
| `b public.` | `eql_v3_real_eq` | |
Returns [#returns-1817]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lte(query_timestamp_ord, eql_v3_json_entry) [#ltequery_timestamp_ord-eql_v3_json_entry]
Unsupported operator blocker for public.eql\_v3\_json\_entry.
Intercepts an operator that is not supported on public.eql\_v3\_json\_entry and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1828]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a eql_v3.` | `query_timestamp_ord` | |
| `b public.` | `eql_v3_json_entry` | |
Returns [#returns-1818]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lte(eql_v3_json_entry, query_timestamp_ord) [#lteeql_v3_json_entry-query_timestamp_ord]
Unsupported operator blocker for public.eql\_v3\_json\_entry.
Intercepts an operator that is not supported on public.eql\_v3\_json\_entry and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1829]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_json_entry` | |
| `b eql_v3.` | `query_timestamp_ord` | |
Returns [#returns-1819]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lte(jsonb, eql_v3_text) [#ltejsonb-eql_v3_text]
Unsupported operator blocker for public.eql\_v3\_text.
Intercepts an operator that is not supported on public.eql\_v3\_text and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1830]
| Name | Type | Description |
| ----------- | ------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_text` | |
Returns [#returns-1820]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lte(eql_v3_text, jsonb) [#lteeql_v3_text-jsonb]
Unsupported operator blocker for public.eql\_v3\_text.
Intercepts an operator that is not supported on public.eql\_v3\_text and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1831]
| Name | Type | Description |
| ----------- | ------------- | ------------------------------------- |
| `a public.` | `eql_v3_text` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1821]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lte(eql_v3_text, eql_v3_text) [#lteeql_v3_text-eql_v3_text]
Unsupported operator blocker for public.eql\_v3\_text.
Intercepts an operator that is not supported on public.eql\_v3\_text and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1832]
| Name | Type | Description |
| ----------- | ------------- | ----------- |
| `a public.` | `eql_v3_text` | |
| `b public.` | `eql_v3_text` | |
Returns [#returns-1822]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lte(jsonb, eql_v3_double_eq) [#ltejsonb-eql_v3_double_eq]
Unsupported operator blocker for public.eql\_v3\_double\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_double\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1833]
| Name | Type | Description |
| ----------- | ------------------ | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_double_eq` | |
Returns [#returns-1823]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lte(eql_v3_double_eq, jsonb) [#lteeql_v3_double_eq-jsonb]
Unsupported operator blocker for public.eql\_v3\_double\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_double\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1834]
| Name | Type | Description |
| ----------- | ------------------ | ------------------------------------- |
| `a public.` | `eql_v3_double_eq` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1824]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lte(eql_v3_double_eq, eql_v3_double_eq) [#lteeql_v3_double_eq-eql_v3_double_eq]
Unsupported operator blocker for public.eql\_v3\_double\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_double\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1835]
| Name | Type | Description |
| ----------- | ------------------ | ----------- |
| `a public.` | `eql_v3_double_eq` | |
| `b public.` | `eql_v3_double_eq` | |
Returns [#returns-1825]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lte(jsonb, eql_v3_timestamp) [#ltejsonb-eql_v3_timestamp]
Unsupported operator blocker for public.eql\_v3\_timestamp.
Intercepts an operator that is not supported on public.eql\_v3\_timestamp and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1836]
| Name | Type | Description |
| ----------- | ------------------ | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_timestamp` | |
Returns [#returns-1826]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lte(eql_v3_timestamp, jsonb) [#lteeql_v3_timestamp-jsonb]
Unsupported operator blocker for public.eql\_v3\_timestamp.
Intercepts an operator that is not supported on public.eql\_v3\_timestamp and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1837]
| Name | Type | Description |
| ----------- | ------------------ | ------------------------------------- |
| `a public.` | `eql_v3_timestamp` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1827]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lte(eql_v3_timestamp, eql_v3_timestamp) [#lteeql_v3_timestamp-eql_v3_timestamp]
Unsupported operator blocker for public.eql\_v3\_timestamp.
Intercepts an operator that is not supported on public.eql\_v3\_timestamp and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1838]
| Name | Type | Description |
| ----------- | ------------------ | ----------- |
| `a public.` | `eql_v3_timestamp` | |
| `b public.` | `eql_v3_timestamp` | |
Returns [#returns-1828]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lte(jsonb, eql_v3_numeric_eq) [#ltejsonb-eql_v3_numeric_eq]
Unsupported operator blocker for public.eql\_v3\_numeric\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_numeric\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1839]
| Name | Type | Description |
| ----------- | ------------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_numeric_eq` | |
Returns [#returns-1829]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lte(eql_v3_numeric_eq, jsonb) [#lteeql_v3_numeric_eq-jsonb]
Unsupported operator blocker for public.eql\_v3\_numeric\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_numeric\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1840]
| Name | Type | Description |
| ----------- | ------------------- | ------------------------------------- |
| `a public.` | `eql_v3_numeric_eq` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1830]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lte(eql_v3_numeric_eq, eql_v3_numeric_eq) [#lteeql_v3_numeric_eq-eql_v3_numeric_eq]
Unsupported operator blocker for public.eql\_v3\_numeric\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_numeric\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1841]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a public.` | `eql_v3_numeric_eq` | |
| `b public.` | `eql_v3_numeric_eq` | |
Returns [#returns-1831]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lte(jsonb, eql_v3_text_match) [#ltejsonb-eql_v3_text_match]
Unsupported operator blocker for public.eql\_v3\_text\_match.
Intercepts an operator that is not supported on public.eql\_v3\_text\_match and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1842]
| Name | Type | Description |
| ----------- | ------------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_text_match` | |
Returns [#returns-1832]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lte(eql_v3_text_match, jsonb) [#lteeql_v3_text_match-jsonb]
Unsupported operator blocker for public.eql\_v3\_text\_match.
Intercepts an operator that is not supported on public.eql\_v3\_text\_match and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1843]
| Name | Type | Description |
| ----------- | ------------------- | ------------------------------------- |
| `a public.` | `eql_v3_text_match` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1833]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lte(eql_v3_text_match, eql_v3_text_match) [#lteeql_v3_text_match-eql_v3_text_match]
Unsupported operator blocker for public.eql\_v3\_text\_match.
Intercepts an operator that is not supported on public.eql\_v3\_text\_match and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1844]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a public.` | `eql_v3_text_match` | |
| `b public.` | `eql_v3_text_match` | |
Returns [#returns-1834]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lte(jsonb, eql_v3_integer) [#ltejsonb-eql_v3_integer]
Unsupported operator blocker for public.eql\_v3\_integer.
Intercepts an operator that is not supported on public.eql\_v3\_integer and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1845]
| Name | Type | Description |
| ----------- | ---------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_integer` | |
Returns [#returns-1835]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lte(eql_v3_integer, jsonb) [#lteeql_v3_integer-jsonb]
Unsupported operator blocker for public.eql\_v3\_integer.
Intercepts an operator that is not supported on public.eql\_v3\_integer and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1846]
| Name | Type | Description |
| ----------- | ---------------- | ------------------------------------- |
| `a public.` | `eql_v3_integer` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1836]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lte(eql_v3_integer, eql_v3_integer) [#lteeql_v3_integer-eql_v3_integer]
Unsupported operator blocker for public.eql\_v3\_integer.
Intercepts an operator that is not supported on public.eql\_v3\_integer and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1847]
| Name | Type | Description |
| ----------- | ---------------- | ----------- |
| `a public.` | `eql_v3_integer` | |
| `b public.` | `eql_v3_integer` | |
Returns [#returns-1837]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lte(jsonb, eql_v3_double) [#ltejsonb-eql_v3_double]
Unsupported operator blocker for public.eql\_v3\_double.
Intercepts an operator that is not supported on public.eql\_v3\_double and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1848]
| Name | Type | Description |
| ----------- | --------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_double` | |
Returns [#returns-1838]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lte(eql_v3_double, jsonb) [#lteeql_v3_double-jsonb]
Unsupported operator blocker for public.eql\_v3\_double.
Intercepts an operator that is not supported on public.eql\_v3\_double and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1849]
| Name | Type | Description |
| ----------- | --------------- | ------------------------------------- |
| `a public.` | `eql_v3_double` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1839]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lte(eql_v3_double, eql_v3_double) [#lteeql_v3_double-eql_v3_double]
Unsupported operator blocker for public.eql\_v3\_double.
Intercepts an operator that is not supported on public.eql\_v3\_double and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1850]
| Name | Type | Description |
| ----------- | --------------- | ----------- |
| `a public.` | `eql_v3_double` | |
| `b public.` | `eql_v3_double` | |
Returns [#returns-1840]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lte(jsonb, eql_v3_smallint_eq) [#ltejsonb-eql_v3_smallint_eq]
Unsupported operator blocker for public.eql\_v3\_smallint\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_smallint\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1851]
| Name | Type | Description |
| ----------- | -------------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_smallint_eq` | |
Returns [#returns-1841]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lte(eql_v3_smallint_eq, jsonb) [#lteeql_v3_smallint_eq-jsonb]
Unsupported operator blocker for public.eql\_v3\_smallint\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_smallint\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1852]
| Name | Type | Description |
| ----------- | -------------------- | ------------------------------------- |
| `a public.` | `eql_v3_smallint_eq` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1842]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lte(eql_v3_smallint_eq, eql_v3_smallint_eq) [#lteeql_v3_smallint_eq-eql_v3_smallint_eq]
Unsupported operator blocker for public.eql\_v3\_smallint\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_smallint\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1853]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a public.` | `eql_v3_smallint_eq` | |
| `b public.` | `eql_v3_smallint_eq` | |
Returns [#returns-1843]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lte(jsonb, eql_v3_date_eq) [#ltejsonb-eql_v3_date_eq]
Unsupported operator blocker for public.eql\_v3\_date\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_date\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1854]
| Name | Type | Description |
| ----------- | ---------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_date_eq` | |
Returns [#returns-1844]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lte(eql_v3_date_eq, jsonb) [#lteeql_v3_date_eq-jsonb]
Unsupported operator blocker for public.eql\_v3\_date\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_date\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1855]
| Name | Type | Description |
| ----------- | ---------------- | ------------------------------------- |
| `a public.` | `eql_v3_date_eq` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1845]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lte(eql_v3_date_eq, eql_v3_date_eq) [#lteeql_v3_date_eq-eql_v3_date_eq]
Unsupported operator blocker for public.eql\_v3\_date\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_date\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1856]
| Name | Type | Description |
| ----------- | ---------------- | ----------- |
| `a public.` | `eql_v3_date_eq` | |
| `b public.` | `eql_v3_date_eq` | |
Returns [#returns-1846]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lte(jsonb, eql_v3_text_eq) [#ltejsonb-eql_v3_text_eq]
Unsupported operator blocker for public.eql\_v3\_text\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_text\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1857]
| Name | Type | Description |
| ----------- | ---------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_text_eq` | |
Returns [#returns-1847]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lte(eql_v3_text_eq, jsonb) [#lteeql_v3_text_eq-jsonb]
Unsupported operator blocker for public.eql\_v3\_text\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_text\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1858]
| Name | Type | Description |
| ----------- | ---------------- | ------------------------------------- |
| `a public.` | `eql_v3_text_eq` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1848]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lte(eql_v3_text_eq, eql_v3_text_eq) [#lteeql_v3_text_eq-eql_v3_text_eq]
Unsupported operator blocker for public.eql\_v3\_text\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_text\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1859]
| Name | Type | Description |
| ----------- | ---------------- | ----------- |
| `a public.` | `eql_v3_text_eq` | |
| `b public.` | `eql_v3_text_eq` | |
Returns [#returns-1849]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lte(jsonb, eql_v3_integer_eq) [#ltejsonb-eql_v3_integer_eq]
Unsupported operator blocker for public.eql\_v3\_integer\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_integer\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1860]
| Name | Type | Description |
| ----------- | ------------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_integer_eq` | |
Returns [#returns-1850]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lte(eql_v3_integer_eq, jsonb) [#lteeql_v3_integer_eq-jsonb]
Unsupported operator blocker for public.eql\_v3\_integer\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_integer\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1861]
| Name | Type | Description |
| ----------- | ------------------- | ------------------------------------- |
| `a public.` | `eql_v3_integer_eq` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1851]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lte(eql_v3_integer_eq, eql_v3_integer_eq) [#lteeql_v3_integer_eq-eql_v3_integer_eq]
Unsupported operator blocker for public.eql\_v3\_integer\_eq.
Intercepts an operator that is not supported on public.eql\_v3\_integer\_eq and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1862]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a public.` | `eql_v3_integer_eq` | |
| `b public.` | `eql_v3_integer_eq` | |
Returns [#returns-1852]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lte(jsonb, eql_v3_smallint) [#ltejsonb-eql_v3_smallint]
Unsupported operator blocker for public.eql\_v3\_smallint.
Intercepts an operator that is not supported on public.eql\_v3\_smallint and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1863]
| Name | Type | Description |
| ----------- | ----------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_smallint` | |
Returns [#returns-1853]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lte(eql_v3_smallint, jsonb) [#lteeql_v3_smallint-jsonb]
Unsupported operator blocker for public.eql\_v3\_smallint.
Intercepts an operator that is not supported on public.eql\_v3\_smallint and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1864]
| Name | Type | Description |
| ----------- | ----------------- | ------------------------------------- |
| `a public.` | `eql_v3_smallint` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1854]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
lte(eql_v3_smallint, eql_v3_smallint) [#lteeql_v3_smallint-eql_v3_smallint]
Unsupported operator blocker for public.eql\_v3\_smallint.
Intercepts an operator that is not supported on public.eql\_v3\_smallint and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1865]
| Name | Type | Description |
| ----------- | ----------------- | ----------- |
| `a public.` | `eql_v3_smallint` | |
| `b public.` | `eql_v3_smallint` | |
Returns [#returns-1855]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
max_sfunc(eql_v3_bigint_ord_ope, eql_v3_bigint_ord_ope) [#max_sfunceql_v3_bigint_ord_ope-eql_v3_bigint_ord_ope]
State function for max on public.eql\_v3\_bigint\_ord\_ope.
Parameters [#parameters-1866]
| Name | Type | Description |
| --------------- | ----------------------- | ----------- |
| `state public.` | `eql_v3_bigint_ord_ope` | |
| `value public.` | `eql_v3_bigint_ord_ope` | |
Returns [#returns-1856]
**Type:** `public.eql_v3_bigint_ord_ope`
public.eql\_v3\_bigint\_ord\_ope
***
max_sfunc(eql_v3_smallint_ord_ope, eql_v3_smallint_ord_ope) [#max_sfunceql_v3_smallint_ord_ope-eql_v3_smallint_ord_ope]
State function for max on public.eql\_v3\_smallint\_ord\_ope.
Parameters [#parameters-1867]
| Name | Type | Description |
| --------------- | ------------------------- | ----------- |
| `state public.` | `eql_v3_smallint_ord_ope` | |
| `value public.` | `eql_v3_smallint_ord_ope` | |
Returns [#returns-1857]
**Type:** `public.eql_v3_smallint_ord_ope`
public.eql\_v3\_smallint\_ord\_ope
***
max_sfunc(eql_v3_numeric_ord, eql_v3_numeric_ord) [#max_sfunceql_v3_numeric_ord-eql_v3_numeric_ord]
State function for max on public.eql\_v3\_numeric\_ord.
Parameters [#parameters-1868]
| Name | Type | Description |
| --------------- | -------------------- | ----------- |
| `state public.` | `eql_v3_numeric_ord` | |
| `value public.` | `eql_v3_numeric_ord` | |
Returns [#returns-1858]
**Type:** `public.eql_v3_numeric_ord`
public.eql\_v3\_numeric\_ord
***
max_sfunc(eql_v3_real_ord_ore, eql_v3_real_ord_ore) [#max_sfunceql_v3_real_ord_ore-eql_v3_real_ord_ore]
State function for max on public.eql\_v3\_real\_ord\_ore.
Parameters [#parameters-1869]
| Name | Type | Description |
| --------------- | --------------------- | ----------- |
| `state public.` | `eql_v3_real_ord_ore` | |
| `value public.` | `eql_v3_real_ord_ore` | |
Returns [#returns-1859]
**Type:** `public.eql_v3_real_ord_ore`
public.eql\_v3\_real\_ord\_ore
***
max_sfunc(eql_v3_timestamp_ord_ore, eql_v3_timestamp_ord_ore) [#max_sfunceql_v3_timestamp_ord_ore-eql_v3_timestamp_ord_ore]
State function for max on public.eql\_v3\_timestamp\_ord\_ore.
Parameters [#parameters-1870]
| Name | Type | Description |
| --------------- | -------------------------- | ----------- |
| `state public.` | `eql_v3_timestamp_ord_ore` | |
| `value public.` | `eql_v3_timestamp_ord_ore` | |
Returns [#returns-1860]
**Type:** `public.eql_v3_timestamp_ord_ore`
public.eql\_v3\_timestamp\_ord\_ore
***
max_sfunc(eql_v3_real_ord_ope, eql_v3_real_ord_ope) [#max_sfunceql_v3_real_ord_ope-eql_v3_real_ord_ope]
State function for max on public.eql\_v3\_real\_ord\_ope.
Parameters [#parameters-1871]
| Name | Type | Description |
| --------------- | --------------------- | ----------- |
| `state public.` | `eql_v3_real_ord_ope` | |
| `value public.` | `eql_v3_real_ord_ope` | |
Returns [#returns-1861]
**Type:** `public.eql_v3_real_ord_ope`
public.eql\_v3\_real\_ord\_ope
***
max_sfunc(eql_v3_text_ord_ope, eql_v3_text_ord_ope) [#max_sfunceql_v3_text_ord_ope-eql_v3_text_ord_ope]
State function for max on public.eql\_v3\_text\_ord\_ope.
Parameters [#parameters-1872]
| Name | Type | Description |
| --------------- | --------------------- | ----------- |
| `state public.` | `eql_v3_text_ord_ope` | |
| `value public.` | `eql_v3_text_ord_ope` | |
Returns [#returns-1862]
**Type:** `public.eql_v3_text_ord_ope`
public.eql\_v3\_text\_ord\_ope
***
max_sfunc(eql_v3_double_ord_ope, eql_v3_double_ord_ope) [#max_sfunceql_v3_double_ord_ope-eql_v3_double_ord_ope]
State function for max on public.eql\_v3\_double\_ord\_ope.
Parameters [#parameters-1873]
| Name | Type | Description |
| --------------- | ----------------------- | ----------- |
| `state public.` | `eql_v3_double_ord_ope` | |
| `value public.` | `eql_v3_double_ord_ope` | |
Returns [#returns-1863]
**Type:** `public.eql_v3_double_ord_ope`
public.eql\_v3\_double\_ord\_ope
***
max_sfunc(eql_v3_date_ord_ore, eql_v3_date_ord_ore) [#max_sfunceql_v3_date_ord_ore-eql_v3_date_ord_ore]
State function for max on public.eql\_v3\_date\_ord\_ore.
Parameters [#parameters-1874]
| Name | Type | Description |
| --------------- | --------------------- | ----------- |
| `state public.` | `eql_v3_date_ord_ore` | |
| `value public.` | `eql_v3_date_ord_ore` | |
Returns [#returns-1864]
**Type:** `public.eql_v3_date_ord_ore`
public.eql\_v3\_date\_ord\_ore
***
max_sfunc(eql_v3_integer_ord_ore, eql_v3_integer_ord_ore) [#max_sfunceql_v3_integer_ord_ore-eql_v3_integer_ord_ore]
State function for max on public.eql\_v3\_integer\_ord\_ore.
Parameters [#parameters-1875]
| Name | Type | Description |
| --------------- | ------------------------ | ----------- |
| `state public.` | `eql_v3_integer_ord_ore` | |
| `value public.` | `eql_v3_integer_ord_ore` | |
Returns [#returns-1865]
**Type:** `public.eql_v3_integer_ord_ore`
public.eql\_v3\_integer\_ord\_ore
***
max_sfunc(eql_v3_bigint_ord, eql_v3_bigint_ord) [#max_sfunceql_v3_bigint_ord-eql_v3_bigint_ord]
State function for max on public.eql\_v3\_bigint\_ord.
Parameters [#parameters-1876]
| Name | Type | Description |
| --------------- | ------------------- | ----------- |
| `state public.` | `eql_v3_bigint_ord` | |
| `value public.` | `eql_v3_bigint_ord` | |
Returns [#returns-1866]
**Type:** `public.eql_v3_bigint_ord`
public.eql\_v3\_bigint\_ord
***
max_sfunc(eql_v3_numeric_ord_ope, eql_v3_numeric_ord_ope) [#max_sfunceql_v3_numeric_ord_ope-eql_v3_numeric_ord_ope]
State function for max on public.eql\_v3\_numeric\_ord\_ope.
Parameters [#parameters-1877]
| Name | Type | Description |
| --------------- | ------------------------ | ----------- |
| `state public.` | `eql_v3_numeric_ord_ope` | |
| `value public.` | `eql_v3_numeric_ord_ope` | |
Returns [#returns-1867]
**Type:** `public.eql_v3_numeric_ord_ope`
public.eql\_v3\_numeric\_ord\_ope
***
max_sfunc(eql_v3_numeric_ord_ore, eql_v3_numeric_ord_ore) [#max_sfunceql_v3_numeric_ord_ore-eql_v3_numeric_ord_ore]
State function for max on public.eql\_v3\_numeric\_ord\_ore.
Parameters [#parameters-1878]
| Name | Type | Description |
| --------------- | ------------------------ | ----------- |
| `state public.` | `eql_v3_numeric_ord_ore` | |
| `value public.` | `eql_v3_numeric_ord_ore` | |
Returns [#returns-1868]
**Type:** `public.eql_v3_numeric_ord_ore`
public.eql\_v3\_numeric\_ord\_ore
***
max_sfunc(eql_v3_real_ord, eql_v3_real_ord) [#max_sfunceql_v3_real_ord-eql_v3_real_ord]
State function for max on public.eql\_v3\_real\_ord.
Parameters [#parameters-1879]
| Name | Type | Description |
| --------------- | ----------------- | ----------- |
| `state public.` | `eql_v3_real_ord` | |
| `value public.` | `eql_v3_real_ord` | |
Returns [#returns-1869]
**Type:** `public.eql_v3_real_ord`
public.eql\_v3\_real\_ord
***
max_sfunc(eql_v3_timestamp_ord_ope, eql_v3_timestamp_ord_ope) [#max_sfunceql_v3_timestamp_ord_ope-eql_v3_timestamp_ord_ope]
State function for max on public.eql\_v3\_timestamp\_ord\_ope.
Parameters [#parameters-1880]
| Name | Type | Description |
| --------------- | -------------------------- | ----------- |
| `state public.` | `eql_v3_timestamp_ord_ope` | |
| `value public.` | `eql_v3_timestamp_ord_ope` | |
Returns [#returns-1870]
**Type:** `public.eql_v3_timestamp_ord_ope`
public.eql\_v3\_timestamp\_ord\_ope
***
max_sfunc(eql_v3_smallint_ord, eql_v3_smallint_ord) [#max_sfunceql_v3_smallint_ord-eql_v3_smallint_ord]
State function for max on public.eql\_v3\_smallint\_ord.
Parameters [#parameters-1881]
| Name | Type | Description |
| --------------- | --------------------- | ----------- |
| `state public.` | `eql_v3_smallint_ord` | |
| `value public.` | `eql_v3_smallint_ord` | |
Returns [#returns-1871]
**Type:** `public.eql_v3_smallint_ord`
public.eql\_v3\_smallint\_ord
***
max_sfunc(eql_v3_text_search_ore, eql_v3_text_search_ore) [#max_sfunceql_v3_text_search_ore-eql_v3_text_search_ore]
State function for max on public.eql\_v3\_text\_search\_ore.
Parameters [#parameters-1882]
| Name | Type | Description |
| --------------- | ------------------------ | ----------- |
| `state public.` | `eql_v3_text_search_ore` | |
| `value public.` | `eql_v3_text_search_ore` | |
Returns [#returns-1872]
**Type:** `public.eql_v3_text_search_ore`
public.eql\_v3\_text\_search\_ore
***
max_sfunc(eql_v3_integer_ord, eql_v3_integer_ord) [#max_sfunceql_v3_integer_ord-eql_v3_integer_ord]
State function for max on public.eql\_v3\_integer\_ord.
Parameters [#parameters-1883]
| Name | Type | Description |
| --------------- | -------------------- | ----------- |
| `state public.` | `eql_v3_integer_ord` | |
| `value public.` | `eql_v3_integer_ord` | |
Returns [#returns-1873]
**Type:** `public.eql_v3_integer_ord`
public.eql\_v3\_integer\_ord
***
max_sfunc(eql_v3_integer_ord_ope, eql_v3_integer_ord_ope) [#max_sfunceql_v3_integer_ord_ope-eql_v3_integer_ord_ope]
State function for max on public.eql\_v3\_integer\_ord\_ope.
Parameters [#parameters-1884]
| Name | Type | Description |
| --------------- | ------------------------ | ----------- |
| `state public.` | `eql_v3_integer_ord_ope` | |
| `value public.` | `eql_v3_integer_ord_ope` | |
Returns [#returns-1874]
**Type:** `public.eql_v3_integer_ord_ope`
public.eql\_v3\_integer\_ord\_ope
***
max_sfunc(eql_v3_smallint_ord_ore, eql_v3_smallint_ord_ore) [#max_sfunceql_v3_smallint_ord_ore-eql_v3_smallint_ord_ore]
State function for max on public.eql\_v3\_smallint\_ord\_ore.
Parameters [#parameters-1885]
| Name | Type | Description |
| --------------- | ------------------------- | ----------- |
| `state public.` | `eql_v3_smallint_ord_ore` | |
| `value public.` | `eql_v3_smallint_ord_ore` | |
Returns [#returns-1875]
**Type:** `public.eql_v3_smallint_ord_ore`
public.eql\_v3\_smallint\_ord\_ore
***
max_sfunc(eql_v3_date_ord, eql_v3_date_ord) [#max_sfunceql_v3_date_ord-eql_v3_date_ord]
State function for max on public.eql\_v3\_date\_ord.
Parameters [#parameters-1886]
| Name | Type | Description |
| --------------- | ----------------- | ----------- |
| `state public.` | `eql_v3_date_ord` | |
| `value public.` | `eql_v3_date_ord` | |
Returns [#returns-1876]
**Type:** `public.eql_v3_date_ord`
public.eql\_v3\_date\_ord
***
max_sfunc(eql_v3_text_ord_ore, eql_v3_text_ord_ore) [#max_sfunceql_v3_text_ord_ore-eql_v3_text_ord_ore]
State function for max on public.eql\_v3\_text\_ord\_ore.
Parameters [#parameters-1887]
| Name | Type | Description |
| --------------- | --------------------- | ----------- |
| `state public.` | `eql_v3_text_ord_ore` | |
| `value public.` | `eql_v3_text_ord_ore` | |
Returns [#returns-1877]
**Type:** `public.eql_v3_text_ord_ore`
public.eql\_v3\_text\_ord\_ore
***
max_sfunc(eql_v3_double_ord_ore, eql_v3_double_ord_ore) [#max_sfunceql_v3_double_ord_ore-eql_v3_double_ord_ore]
State function for max on public.eql\_v3\_double\_ord\_ore.
Parameters [#parameters-1888]
| Name | Type | Description |
| --------------- | ----------------------- | ----------- |
| `state public.` | `eql_v3_double_ord_ore` | |
| `value public.` | `eql_v3_double_ord_ore` | |
Returns [#returns-1878]
**Type:** `public.eql_v3_double_ord_ore`
public.eql\_v3\_double\_ord\_ore
***
max_sfunc(eql_v3_timestamp_ord, eql_v3_timestamp_ord) [#max_sfunceql_v3_timestamp_ord-eql_v3_timestamp_ord]
State function for max on public.eql\_v3\_timestamp\_ord.
Parameters [#parameters-1889]
| Name | Type | Description |
| --------------- | ---------------------- | ----------- |
| `state public.` | `eql_v3_timestamp_ord` | |
| `value public.` | `eql_v3_timestamp_ord` | |
Returns [#returns-1879]
**Type:** `public.eql_v3_timestamp_ord`
public.eql\_v3\_timestamp\_ord
***
max_sfunc(eql_v3_text_ord, eql_v3_text_ord) [#max_sfunceql_v3_text_ord-eql_v3_text_ord]
State function for max on public.eql\_v3\_text\_ord.
Parameters [#parameters-1890]
| Name | Type | Description |
| --------------- | ----------------- | ----------- |
| `state public.` | `eql_v3_text_ord` | |
| `value public.` | `eql_v3_text_ord` | |
Returns [#returns-1880]
**Type:** `public.eql_v3_text_ord`
public.eql\_v3\_text\_ord
***
max_sfunc(eql_v3_bigint_ord_ore, eql_v3_bigint_ord_ore) [#max_sfunceql_v3_bigint_ord_ore-eql_v3_bigint_ord_ore]
State function for max on public.eql\_v3\_bigint\_ord\_ore.
Parameters [#parameters-1891]
| Name | Type | Description |
| --------------- | ----------------------- | ----------- |
| `state public.` | `eql_v3_bigint_ord_ore` | |
| `value public.` | `eql_v3_bigint_ord_ore` | |
Returns [#returns-1881]
**Type:** `public.eql_v3_bigint_ord_ore`
public.eql\_v3\_bigint\_ord\_ore
***
max_sfunc(eql_v3_text_search, eql_v3_text_search) [#max_sfunceql_v3_text_search-eql_v3_text_search]
State function for max on public.eql\_v3\_text\_search.
Parameters [#parameters-1892]
| Name | Type | Description |
| --------------- | -------------------- | ----------- |
| `state public.` | `eql_v3_text_search` | |
| `value public.` | `eql_v3_text_search` | |
Returns [#returns-1882]
**Type:** `public.eql_v3_text_search`
public.eql\_v3\_text\_search
***
max_sfunc(eql_v3_double_ord, eql_v3_double_ord) [#max_sfunceql_v3_double_ord-eql_v3_double_ord]
State function for max on public.eql\_v3\_double\_ord.
Parameters [#parameters-1893]
| Name | Type | Description |
| --------------- | ------------------- | ----------- |
| `state public.` | `eql_v3_double_ord` | |
| `value public.` | `eql_v3_double_ord` | |
Returns [#returns-1883]
**Type:** `public.eql_v3_double_ord`
public.eql\_v3\_double\_ord
***
max_sfunc(eql_v3_date_ord_ope, eql_v3_date_ord_ope) [#max_sfunceql_v3_date_ord_ope-eql_v3_date_ord_ope]
State function for max on public.eql\_v3\_date\_ord\_ope.
Parameters [#parameters-1894]
| Name | Type | Description |
| --------------- | --------------------- | ----------- |
| `state public.` | `eql_v3_date_ord_ope` | |
| `value public.` | `eql_v3_date_ord_ope` | |
Returns [#returns-1884]
**Type:** `public.eql_v3_date_ord_ope`
public.eql\_v3\_date\_ord\_ope
***
min_sfunc(eql_v3_bigint_ord_ope, eql_v3_bigint_ord_ope) [#min_sfunceql_v3_bigint_ord_ope-eql_v3_bigint_ord_ope]
State function for min on public.eql\_v3\_bigint\_ord\_ope.
Parameters [#parameters-1895]
| Name | Type | Description |
| --------------- | ----------------------- | ----------- |
| `state public.` | `eql_v3_bigint_ord_ope` | |
| `value public.` | `eql_v3_bigint_ord_ope` | |
Returns [#returns-1885]
**Type:** `public.eql_v3_bigint_ord_ope`
public.eql\_v3\_bigint\_ord\_ope
***
min_sfunc(eql_v3_smallint_ord_ope, eql_v3_smallint_ord_ope) [#min_sfunceql_v3_smallint_ord_ope-eql_v3_smallint_ord_ope]
State function for min on public.eql\_v3\_smallint\_ord\_ope.
Parameters [#parameters-1896]
| Name | Type | Description |
| --------------- | ------------------------- | ----------- |
| `state public.` | `eql_v3_smallint_ord_ope` | |
| `value public.` | `eql_v3_smallint_ord_ope` | |
Returns [#returns-1886]
**Type:** `public.eql_v3_smallint_ord_ope`
public.eql\_v3\_smallint\_ord\_ope
***
min_sfunc(eql_v3_numeric_ord, eql_v3_numeric_ord) [#min_sfunceql_v3_numeric_ord-eql_v3_numeric_ord]
State function for min on public.eql\_v3\_numeric\_ord.
Parameters [#parameters-1897]
| Name | Type | Description |
| --------------- | -------------------- | ----------- |
| `state public.` | `eql_v3_numeric_ord` | |
| `value public.` | `eql_v3_numeric_ord` | |
Returns [#returns-1887]
**Type:** `public.eql_v3_numeric_ord`
public.eql\_v3\_numeric\_ord
***
min_sfunc(eql_v3_real_ord_ore, eql_v3_real_ord_ore) [#min_sfunceql_v3_real_ord_ore-eql_v3_real_ord_ore]
State function for min on public.eql\_v3\_real\_ord\_ore.
Parameters [#parameters-1898]
| Name | Type | Description |
| --------------- | --------------------- | ----------- |
| `state public.` | `eql_v3_real_ord_ore` | |
| `value public.` | `eql_v3_real_ord_ore` | |
Returns [#returns-1888]
**Type:** `public.eql_v3_real_ord_ore`
public.eql\_v3\_real\_ord\_ore
***
min_sfunc(eql_v3_timestamp_ord_ore, eql_v3_timestamp_ord_ore) [#min_sfunceql_v3_timestamp_ord_ore-eql_v3_timestamp_ord_ore]
State function for min on public.eql\_v3\_timestamp\_ord\_ore.
Parameters [#parameters-1899]
| Name | Type | Description |
| --------------- | -------------------------- | ----------- |
| `state public.` | `eql_v3_timestamp_ord_ore` | |
| `value public.` | `eql_v3_timestamp_ord_ore` | |
Returns [#returns-1889]
**Type:** `public.eql_v3_timestamp_ord_ore`
public.eql\_v3\_timestamp\_ord\_ore
***
min_sfunc(eql_v3_real_ord_ope, eql_v3_real_ord_ope) [#min_sfunceql_v3_real_ord_ope-eql_v3_real_ord_ope]
State function for min on public.eql\_v3\_real\_ord\_ope.
Parameters [#parameters-1900]
| Name | Type | Description |
| --------------- | --------------------- | ----------- |
| `state public.` | `eql_v3_real_ord_ope` | |
| `value public.` | `eql_v3_real_ord_ope` | |
Returns [#returns-1890]
**Type:** `public.eql_v3_real_ord_ope`
public.eql\_v3\_real\_ord\_ope
***
min_sfunc(eql_v3_text_ord_ope, eql_v3_text_ord_ope) [#min_sfunceql_v3_text_ord_ope-eql_v3_text_ord_ope]
State function for min on public.eql\_v3\_text\_ord\_ope.
Parameters [#parameters-1901]
| Name | Type | Description |
| --------------- | --------------------- | ----------- |
| `state public.` | `eql_v3_text_ord_ope` | |
| `value public.` | `eql_v3_text_ord_ope` | |
Returns [#returns-1891]
**Type:** `public.eql_v3_text_ord_ope`
public.eql\_v3\_text\_ord\_ope
***
min_sfunc(eql_v3_double_ord_ope, eql_v3_double_ord_ope) [#min_sfunceql_v3_double_ord_ope-eql_v3_double_ord_ope]
State function for min on public.eql\_v3\_double\_ord\_ope.
Parameters [#parameters-1902]
| Name | Type | Description |
| --------------- | ----------------------- | ----------- |
| `state public.` | `eql_v3_double_ord_ope` | |
| `value public.` | `eql_v3_double_ord_ope` | |
Returns [#returns-1892]
**Type:** `public.eql_v3_double_ord_ope`
public.eql\_v3\_double\_ord\_ope
***
min_sfunc(eql_v3_date_ord_ore, eql_v3_date_ord_ore) [#min_sfunceql_v3_date_ord_ore-eql_v3_date_ord_ore]
State function for min on public.eql\_v3\_date\_ord\_ore.
Parameters [#parameters-1903]
| Name | Type | Description |
| --------------- | --------------------- | ----------- |
| `state public.` | `eql_v3_date_ord_ore` | |
| `value public.` | `eql_v3_date_ord_ore` | |
Returns [#returns-1893]
**Type:** `public.eql_v3_date_ord_ore`
public.eql\_v3\_date\_ord\_ore
***
min_sfunc(eql_v3_integer_ord_ore, eql_v3_integer_ord_ore) [#min_sfunceql_v3_integer_ord_ore-eql_v3_integer_ord_ore]
State function for min on public.eql\_v3\_integer\_ord\_ore.
Parameters [#parameters-1904]
| Name | Type | Description |
| --------------- | ------------------------ | ----------- |
| `state public.` | `eql_v3_integer_ord_ore` | |
| `value public.` | `eql_v3_integer_ord_ore` | |
Returns [#returns-1894]
**Type:** `public.eql_v3_integer_ord_ore`
public.eql\_v3\_integer\_ord\_ore
***
min_sfunc(eql_v3_bigint_ord, eql_v3_bigint_ord) [#min_sfunceql_v3_bigint_ord-eql_v3_bigint_ord]
State function for min on public.eql\_v3\_bigint\_ord.
Parameters [#parameters-1905]
| Name | Type | Description |
| --------------- | ------------------- | ----------- |
| `state public.` | `eql_v3_bigint_ord` | |
| `value public.` | `eql_v3_bigint_ord` | |
Returns [#returns-1895]
**Type:** `public.eql_v3_bigint_ord`
public.eql\_v3\_bigint\_ord
***
min_sfunc(eql_v3_numeric_ord_ope, eql_v3_numeric_ord_ope) [#min_sfunceql_v3_numeric_ord_ope-eql_v3_numeric_ord_ope]
State function for min on public.eql\_v3\_numeric\_ord\_ope.
Parameters [#parameters-1906]
| Name | Type | Description |
| --------------- | ------------------------ | ----------- |
| `state public.` | `eql_v3_numeric_ord_ope` | |
| `value public.` | `eql_v3_numeric_ord_ope` | |
Returns [#returns-1896]
**Type:** `public.eql_v3_numeric_ord_ope`
public.eql\_v3\_numeric\_ord\_ope
***
min_sfunc(eql_v3_numeric_ord_ore, eql_v3_numeric_ord_ore) [#min_sfunceql_v3_numeric_ord_ore-eql_v3_numeric_ord_ore]
State function for min on public.eql\_v3\_numeric\_ord\_ore.
Parameters [#parameters-1907]
| Name | Type | Description |
| --------------- | ------------------------ | ----------- |
| `state public.` | `eql_v3_numeric_ord_ore` | |
| `value public.` | `eql_v3_numeric_ord_ore` | |
Returns [#returns-1897]
**Type:** `public.eql_v3_numeric_ord_ore`
public.eql\_v3\_numeric\_ord\_ore
***
min_sfunc(eql_v3_real_ord, eql_v3_real_ord) [#min_sfunceql_v3_real_ord-eql_v3_real_ord]
State function for min on public.eql\_v3\_real\_ord.
Parameters [#parameters-1908]
| Name | Type | Description |
| --------------- | ----------------- | ----------- |
| `state public.` | `eql_v3_real_ord` | |
| `value public.` | `eql_v3_real_ord` | |
Returns [#returns-1898]
**Type:** `public.eql_v3_real_ord`
public.eql\_v3\_real\_ord
***
min_sfunc(eql_v3_timestamp_ord_ope, eql_v3_timestamp_ord_ope) [#min_sfunceql_v3_timestamp_ord_ope-eql_v3_timestamp_ord_ope]
State function for min on public.eql\_v3\_timestamp\_ord\_ope.
Parameters [#parameters-1909]
| Name | Type | Description |
| --------------- | -------------------------- | ----------- |
| `state public.` | `eql_v3_timestamp_ord_ope` | |
| `value public.` | `eql_v3_timestamp_ord_ope` | |
Returns [#returns-1899]
**Type:** `public.eql_v3_timestamp_ord_ope`
public.eql\_v3\_timestamp\_ord\_ope
***
min_sfunc(eql_v3_smallint_ord, eql_v3_smallint_ord) [#min_sfunceql_v3_smallint_ord-eql_v3_smallint_ord]
State function for min on public.eql\_v3\_smallint\_ord.
Parameters [#parameters-1910]
| Name | Type | Description |
| --------------- | --------------------- | ----------- |
| `state public.` | `eql_v3_smallint_ord` | |
| `value public.` | `eql_v3_smallint_ord` | |
Returns [#returns-1900]
**Type:** `public.eql_v3_smallint_ord`
public.eql\_v3\_smallint\_ord
***
min_sfunc(eql_v3_text_search_ore, eql_v3_text_search_ore) [#min_sfunceql_v3_text_search_ore-eql_v3_text_search_ore]
State function for min on public.eql\_v3\_text\_search\_ore.
Parameters [#parameters-1911]
| Name | Type | Description |
| --------------- | ------------------------ | ----------- |
| `state public.` | `eql_v3_text_search_ore` | |
| `value public.` | `eql_v3_text_search_ore` | |
Returns [#returns-1901]
**Type:** `public.eql_v3_text_search_ore`
public.eql\_v3\_text\_search\_ore
***
min_sfunc(eql_v3_integer_ord, eql_v3_integer_ord) [#min_sfunceql_v3_integer_ord-eql_v3_integer_ord]
State function for min on public.eql\_v3\_integer\_ord.
Parameters [#parameters-1912]
| Name | Type | Description |
| --------------- | -------------------- | ----------- |
| `state public.` | `eql_v3_integer_ord` | |
| `value public.` | `eql_v3_integer_ord` | |
Returns [#returns-1902]
**Type:** `public.eql_v3_integer_ord`
public.eql\_v3\_integer\_ord
***
min_sfunc(eql_v3_integer_ord_ope, eql_v3_integer_ord_ope) [#min_sfunceql_v3_integer_ord_ope-eql_v3_integer_ord_ope]
State function for min on public.eql\_v3\_integer\_ord\_ope.
Parameters [#parameters-1913]
| Name | Type | Description |
| --------------- | ------------------------ | ----------- |
| `state public.` | `eql_v3_integer_ord_ope` | |
| `value public.` | `eql_v3_integer_ord_ope` | |
Returns [#returns-1903]
**Type:** `public.eql_v3_integer_ord_ope`
public.eql\_v3\_integer\_ord\_ope
***
min_sfunc(eql_v3_smallint_ord_ore, eql_v3_smallint_ord_ore) [#min_sfunceql_v3_smallint_ord_ore-eql_v3_smallint_ord_ore]
State function for min on public.eql\_v3\_smallint\_ord\_ore.
Parameters [#parameters-1914]
| Name | Type | Description |
| --------------- | ------------------------- | ----------- |
| `state public.` | `eql_v3_smallint_ord_ore` | |
| `value public.` | `eql_v3_smallint_ord_ore` | |
Returns [#returns-1904]
**Type:** `public.eql_v3_smallint_ord_ore`
public.eql\_v3\_smallint\_ord\_ore
***
min_sfunc(eql_v3_date_ord, eql_v3_date_ord) [#min_sfunceql_v3_date_ord-eql_v3_date_ord]
State function for min on public.eql\_v3\_date\_ord.
Parameters [#parameters-1915]
| Name | Type | Description |
| --------------- | ----------------- | ----------- |
| `state public.` | `eql_v3_date_ord` | |
| `value public.` | `eql_v3_date_ord` | |
Returns [#returns-1905]
**Type:** `public.eql_v3_date_ord`
public.eql\_v3\_date\_ord
***
min_sfunc(eql_v3_text_ord_ore, eql_v3_text_ord_ore) [#min_sfunceql_v3_text_ord_ore-eql_v3_text_ord_ore]
State function for min on public.eql\_v3\_text\_ord\_ore.
Parameters [#parameters-1916]
| Name | Type | Description |
| --------------- | --------------------- | ----------- |
| `state public.` | `eql_v3_text_ord_ore` | |
| `value public.` | `eql_v3_text_ord_ore` | |
Returns [#returns-1906]
**Type:** `public.eql_v3_text_ord_ore`
public.eql\_v3\_text\_ord\_ore
***
min_sfunc(eql_v3_double_ord_ore, eql_v3_double_ord_ore) [#min_sfunceql_v3_double_ord_ore-eql_v3_double_ord_ore]
State function for min on public.eql\_v3\_double\_ord\_ore.
Parameters [#parameters-1917]
| Name | Type | Description |
| --------------- | ----------------------- | ----------- |
| `state public.` | `eql_v3_double_ord_ore` | |
| `value public.` | `eql_v3_double_ord_ore` | |
Returns [#returns-1907]
**Type:** `public.eql_v3_double_ord_ore`
public.eql\_v3\_double\_ord\_ore
***
min_sfunc(eql_v3_timestamp_ord, eql_v3_timestamp_ord) [#min_sfunceql_v3_timestamp_ord-eql_v3_timestamp_ord]
State function for min on public.eql\_v3\_timestamp\_ord.
Parameters [#parameters-1918]
| Name | Type | Description |
| --------------- | ---------------------- | ----------- |
| `state public.` | `eql_v3_timestamp_ord` | |
| `value public.` | `eql_v3_timestamp_ord` | |
Returns [#returns-1908]
**Type:** `public.eql_v3_timestamp_ord`
public.eql\_v3\_timestamp\_ord
***
min_sfunc(eql_v3_text_ord, eql_v3_text_ord) [#min_sfunceql_v3_text_ord-eql_v3_text_ord]
State function for min on public.eql\_v3\_text\_ord.
Parameters [#parameters-1919]
| Name | Type | Description |
| --------------- | ----------------- | ----------- |
| `state public.` | `eql_v3_text_ord` | |
| `value public.` | `eql_v3_text_ord` | |
Returns [#returns-1909]
**Type:** `public.eql_v3_text_ord`
public.eql\_v3\_text\_ord
***
min_sfunc(eql_v3_bigint_ord_ore, eql_v3_bigint_ord_ore) [#min_sfunceql_v3_bigint_ord_ore-eql_v3_bigint_ord_ore]
State function for min on public.eql\_v3\_bigint\_ord\_ore.
Parameters [#parameters-1920]
| Name | Type | Description |
| --------------- | ----------------------- | ----------- |
| `state public.` | `eql_v3_bigint_ord_ore` | |
| `value public.` | `eql_v3_bigint_ord_ore` | |
Returns [#returns-1910]
**Type:** `public.eql_v3_bigint_ord_ore`
public.eql\_v3\_bigint\_ord\_ore
***
min_sfunc(eql_v3_text_search, eql_v3_text_search) [#min_sfunceql_v3_text_search-eql_v3_text_search]
State function for min on public.eql\_v3\_text\_search.
Parameters [#parameters-1921]
| Name | Type | Description |
| --------------- | -------------------- | ----------- |
| `state public.` | `eql_v3_text_search` | |
| `value public.` | `eql_v3_text_search` | |
Returns [#returns-1911]
**Type:** `public.eql_v3_text_search`
public.eql\_v3\_text\_search
***
min_sfunc(eql_v3_double_ord, eql_v3_double_ord) [#min_sfunceql_v3_double_ord-eql_v3_double_ord]
State function for min on public.eql\_v3\_double\_ord.
Parameters [#parameters-1922]
| Name | Type | Description |
| --------------- | ------------------- | ----------- |
| `state public.` | `eql_v3_double_ord` | |
| `value public.` | `eql_v3_double_ord` | |
Returns [#returns-1912]
**Type:** `public.eql_v3_double_ord`
public.eql\_v3\_double\_ord
***
min_sfunc(eql_v3_date_ord_ope, eql_v3_date_ord_ope) [#min_sfunceql_v3_date_ord_ope-eql_v3_date_ord_ope]
State function for min on public.eql\_v3\_date\_ord\_ope.
Parameters [#parameters-1923]
| Name | Type | Description |
| --------------- | --------------------- | ----------- |
| `state public.` | `eql_v3_date_ord_ope` | |
| `value public.` | `eql_v3_date_ord_ope` | |
Returns [#returns-1913]
**Type:** `public.eql_v3_date_ord_ope`
public.eql\_v3\_date\_ord\_ope
***
neq(jsonb, eql_v3_date) [#neqjsonb-eql_v3_date]
Unsupported operator blocker for public.eql\_v3\_date.
Intercepts an operator that is not supported on public.eql\_v3\_date and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1924]
| Name | Type | Description |
| ----------- | ------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_date` | |
Returns [#returns-1914]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
neq(eql_v3_date, jsonb) [#neqeql_v3_date-jsonb]
Unsupported operator blocker for public.eql\_v3\_date.
Intercepts an operator that is not supported on public.eql\_v3\_date and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1925]
| Name | Type | Description |
| ----------- | ------------- | ------------------------------------- |
| `a public.` | `eql_v3_date` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1915]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
neq(eql_v3_date, eql_v3_date) [#neqeql_v3_date-eql_v3_date]
Unsupported operator blocker for public.eql\_v3\_date.
Intercepts an operator that is not supported on public.eql\_v3\_date and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1926]
| Name | Type | Description |
| ----------- | ------------- | ----------- |
| `a public.` | `eql_v3_date` | |
| `b public.` | `eql_v3_date` | |
Returns [#returns-1916]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
neq(query_double_ord, eql_v3_json_entry) [#neqquery_double_ord-eql_v3_json_entry]
Unsupported operator blocker for public.eql\_v3\_json\_entry.
Intercepts an operator that is not supported on public.eql\_v3\_json\_entry and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1927]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a eql_v3.` | `query_double_ord` | |
| `b public.` | `eql_v3_json_entry` | |
Returns [#returns-1917]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
neq(eql_v3_json_entry, query_double_ord) [#neqeql_v3_json_entry-query_double_ord]
Unsupported operator blocker for public.eql\_v3\_json\_entry.
Intercepts an operator that is not supported on public.eql\_v3\_json\_entry and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1928]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a public.` | `eql_v3_json_entry` | |
| `b eql_v3.` | `query_double_ord` | |
Returns [#returns-1918]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
neq(query_smallint_ord, eql_v3_json_entry) [#neqquery_smallint_ord-eql_v3_json_entry]
Unsupported operator blocker for public.eql\_v3\_json\_entry.
Intercepts an operator that is not supported on public.eql\_v3\_json\_entry and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1929]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a eql_v3.` | `query_smallint_ord` | |
| `b public.` | `eql_v3_json_entry` | |
Returns [#returns-1919]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
neq(eql_v3_json_entry, query_smallint_ord) [#neqeql_v3_json_entry-query_smallint_ord]
Unsupported operator blocker for public.eql\_v3\_json\_entry.
Intercepts an operator that is not supported on public.eql\_v3\_json\_entry and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1930]
| Name | Type | Description |
| ----------- | -------------------- | ----------- |
| `a public.` | `eql_v3_json_entry` | |
| `b eql_v3.` | `query_smallint_ord` | |
Returns [#returns-1920]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
neq(jsonb, eql_v3_bigint) [#neqjsonb-eql_v3_bigint]
Unsupported operator blocker for public.eql\_v3\_bigint.
Intercepts an operator that is not supported on public.eql\_v3\_bigint and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1931]
| Name | Type | Description |
| ----------- | --------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_bigint` | |
Returns [#returns-1921]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
neq(eql_v3_bigint, jsonb) [#neqeql_v3_bigint-jsonb]
Unsupported operator blocker for public.eql\_v3\_bigint.
Intercepts an operator that is not supported on public.eql\_v3\_bigint and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1932]
| Name | Type | Description |
| ----------- | --------------- | ------------------------------------- |
| `a public.` | `eql_v3_bigint` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1922]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
neq(eql_v3_bigint, eql_v3_bigint) [#neqeql_v3_bigint-eql_v3_bigint]
Unsupported operator blocker for public.eql\_v3\_bigint.
Intercepts an operator that is not supported on public.eql\_v3\_bigint and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1933]
| Name | Type | Description |
| ----------- | --------------- | ----------- |
| `a public.` | `eql_v3_bigint` | |
| `b public.` | `eql_v3_bigint` | |
Returns [#returns-1923]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
neq(jsonb, eql_v3_numeric) [#neqjsonb-eql_v3_numeric]
Unsupported operator blocker for public.eql\_v3\_numeric.
Intercepts an operator that is not supported on public.eql\_v3\_numeric and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1934]
| Name | Type | Description |
| ----------- | ---------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_numeric` | |
Returns [#returns-1924]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
neq(eql_v3_numeric, jsonb) [#neqeql_v3_numeric-jsonb]
Unsupported operator blocker for public.eql\_v3\_numeric.
Intercepts an operator that is not supported on public.eql\_v3\_numeric and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1935]
| Name | Type | Description |
| ----------- | ---------------- | ------------------------------------- |
| `a public.` | `eql_v3_numeric` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1925]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
neq(eql_v3_numeric, eql_v3_numeric) [#neqeql_v3_numeric-eql_v3_numeric]
Unsupported operator blocker for public.eql\_v3\_numeric.
Intercepts an operator that is not supported on public.eql\_v3\_numeric and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1936]
| Name | Type | Description |
| ----------- | ---------------- | ----------- |
| `a public.` | `eql_v3_numeric` | |
| `b public.` | `eql_v3_numeric` | |
Returns [#returns-1926]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
neq(jsonb, eql_v3_json) [#neqjsonb-eql_v3_json]
Unsupported operator blocker for public.eql\_v3\_json.
Intercepts an operator that is not supported on public.eql\_v3\_json and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1937]
| Name | Type | Description |
| ----------- | ------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_json` | |
Returns [#returns-1927]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
neq(eql_v3_json, jsonb) [#neqeql_v3_json-jsonb]
Unsupported operator blocker for public.eql\_v3\_json.
Intercepts an operator that is not supported on public.eql\_v3\_json and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1938]
| Name | Type | Description |
| ----------- | ------------- | ------------------------------------- |
| `a public.` | `eql_v3_json` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1928]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
neq(eql_v3_json, eql_v3_json) [#neqeql_v3_json-eql_v3_json]
Unsupported operator blocker for public.eql\_v3\_json.
Intercepts an operator that is not supported on public.eql\_v3\_json and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1939]
| Name | Type | Description |
| ----------- | ------------- | ----------- |
| `a public.` | `eql_v3_json` | |
| `b public.` | `eql_v3_json` | |
Returns [#returns-1929]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
neq(jsonb, eql_v3_boolean) [#neqjsonb-eql_v3_boolean]
Unsupported operator blocker for public.eql\_v3\_boolean.
Intercepts an operator that is not supported on public.eql\_v3\_boolean and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1940]
| Name | Type | Description |
| ----------- | ---------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_boolean` | |
Returns [#returns-1930]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
neq(eql_v3_boolean, jsonb) [#neqeql_v3_boolean-jsonb]
Unsupported operator blocker for public.eql\_v3\_boolean.
Intercepts an operator that is not supported on public.eql\_v3\_boolean and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1941]
| Name | Type | Description |
| ----------- | ---------------- | ------------------------------------- |
| `a public.` | `eql_v3_boolean` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1931]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
neq(eql_v3_boolean, eql_v3_boolean) [#neqeql_v3_boolean-eql_v3_boolean]
Unsupported operator blocker for public.eql\_v3\_boolean.
Intercepts an operator that is not supported on public.eql\_v3\_boolean and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1942]
| Name | Type | Description |
| ----------- | ---------------- | ----------- |
| `a public.` | `eql_v3_boolean` | |
| `b public.` | `eql_v3_boolean` | |
Returns [#returns-1932]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
neq(query_date_ord, eql_v3_json_entry) [#neqquery_date_ord-eql_v3_json_entry]
Unsupported operator blocker for public.eql\_v3\_json\_entry.
Intercepts an operator that is not supported on public.eql\_v3\_json\_entry and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1943]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a eql_v3.` | `query_date_ord` | |
| `b public.` | `eql_v3_json_entry` | |
Returns [#returns-1933]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
neq(eql_v3_json_entry, query_date_ord) [#neqeql_v3_json_entry-query_date_ord]
Unsupported operator blocker for public.eql\_v3\_json\_entry.
Intercepts an operator that is not supported on public.eql\_v3\_json\_entry and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1944]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a public.` | `eql_v3_json_entry` | |
| `b eql_v3.` | `query_date_ord` | |
Returns [#returns-1934]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
neq(jsonb, eql_v3_real) [#neqjsonb-eql_v3_real]
Unsupported operator blocker for public.eql\_v3\_real.
Intercepts an operator that is not supported on public.eql\_v3\_real and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1945]
| Name | Type | Description |
| ----------- | ------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_real` | |
Returns [#returns-1935]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
neq(eql_v3_real, jsonb) [#neqeql_v3_real-jsonb]
Unsupported operator blocker for public.eql\_v3\_real.
Intercepts an operator that is not supported on public.eql\_v3\_real and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1946]
| Name | Type | Description |
| ----------- | ------------- | ------------------------------------- |
| `a public.` | `eql_v3_real` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1936]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
neq(eql_v3_real, eql_v3_real) [#neqeql_v3_real-eql_v3_real]
Unsupported operator blocker for public.eql\_v3\_real.
Intercepts an operator that is not supported on public.eql\_v3\_real and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1947]
| Name | Type | Description |
| ----------- | ------------- | ----------- |
| `a public.` | `eql_v3_real` | |
| `b public.` | `eql_v3_real` | |
Returns [#returns-1937]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
neq(query_timestamp_ord, eql_v3_json_entry) [#neqquery_timestamp_ord-eql_v3_json_entry]
Unsupported operator blocker for public.eql\_v3\_json\_entry.
Intercepts an operator that is not supported on public.eql\_v3\_json\_entry and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1948]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a eql_v3.` | `query_timestamp_ord` | |
| `b public.` | `eql_v3_json_entry` | |
Returns [#returns-1938]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
neq(eql_v3_json_entry, query_timestamp_ord) [#neqeql_v3_json_entry-query_timestamp_ord]
Unsupported operator blocker for public.eql\_v3\_json\_entry.
Intercepts an operator that is not supported on public.eql\_v3\_json\_entry and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1949]
| Name | Type | Description |
| ----------- | --------------------- | ----------- |
| `a public.` | `eql_v3_json_entry` | |
| `b eql_v3.` | `query_timestamp_ord` | |
Returns [#returns-1939]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
neq(jsonb, eql_v3_text) [#neqjsonb-eql_v3_text]
Unsupported operator blocker for public.eql\_v3\_text.
Intercepts an operator that is not supported on public.eql\_v3\_text and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1950]
| Name | Type | Description |
| ----------- | ------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_text` | |
Returns [#returns-1940]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
neq(eql_v3_text, jsonb) [#neqeql_v3_text-jsonb]
Unsupported operator blocker for public.eql\_v3\_text.
Intercepts an operator that is not supported on public.eql\_v3\_text and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1951]
| Name | Type | Description |
| ----------- | ------------- | ------------------------------------- |
| `a public.` | `eql_v3_text` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1941]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
neq(eql_v3_text, eql_v3_text) [#neqeql_v3_text-eql_v3_text]
Unsupported operator blocker for public.eql\_v3\_text.
Intercepts an operator that is not supported on public.eql\_v3\_text and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1952]
| Name | Type | Description |
| ----------- | ------------- | ----------- |
| `a public.` | `eql_v3_text` | |
| `b public.` | `eql_v3_text` | |
Returns [#returns-1942]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
neq(query_numeric_ord, eql_v3_json_entry) [#neqquery_numeric_ord-eql_v3_json_entry]
Unsupported operator blocker for public.eql\_v3\_json\_entry.
Intercepts an operator that is not supported on public.eql\_v3\_json\_entry and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1953]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a eql_v3.` | `query_numeric_ord` | |
| `b public.` | `eql_v3_json_entry` | |
Returns [#returns-1943]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
neq(eql_v3_json_entry, query_numeric_ord) [#neqeql_v3_json_entry-query_numeric_ord]
Unsupported operator blocker for public.eql\_v3\_json\_entry.
Intercepts an operator that is not supported on public.eql\_v3\_json\_entry and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1954]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a public.` | `eql_v3_json_entry` | |
| `b eql_v3.` | `query_numeric_ord` | |
Returns [#returns-1944]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
neq(jsonb, eql_v3_timestamp) [#neqjsonb-eql_v3_timestamp]
Unsupported operator blocker for public.eql\_v3\_timestamp.
Intercepts an operator that is not supported on public.eql\_v3\_timestamp and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1955]
| Name | Type | Description |
| ----------- | ------------------ | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_timestamp` | |
Returns [#returns-1945]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
neq(eql_v3_timestamp, jsonb) [#neqeql_v3_timestamp-jsonb]
Unsupported operator blocker for public.eql\_v3\_timestamp.
Intercepts an operator that is not supported on public.eql\_v3\_timestamp and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1956]
| Name | Type | Description |
| ----------- | ------------------ | ------------------------------------- |
| `a public.` | `eql_v3_timestamp` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1946]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
neq(eql_v3_timestamp, eql_v3_timestamp) [#neqeql_v3_timestamp-eql_v3_timestamp]
Unsupported operator blocker for public.eql\_v3\_timestamp.
Intercepts an operator that is not supported on public.eql\_v3\_timestamp and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1957]
| Name | Type | Description |
| ----------- | ------------------ | ----------- |
| `a public.` | `eql_v3_timestamp` | |
| `b public.` | `eql_v3_timestamp` | |
Returns [#returns-1947]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
neq(query_text_ord, eql_v3_json_entry) [#neqquery_text_ord-eql_v3_json_entry]
Unsupported operator blocker for public.eql\_v3\_json\_entry.
Intercepts an operator that is not supported on public.eql\_v3\_json\_entry and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1958]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a eql_v3.` | `query_text_ord` | |
| `b public.` | `eql_v3_json_entry` | |
Returns [#returns-1948]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
neq(eql_v3_json_entry, query_text_ord) [#neqeql_v3_json_entry-query_text_ord]
Unsupported operator blocker for public.eql\_v3\_json\_entry.
Intercepts an operator that is not supported on public.eql\_v3\_json\_entry and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1959]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a public.` | `eql_v3_json_entry` | |
| `b eql_v3.` | `query_text_ord` | |
Returns [#returns-1949]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
neq(jsonb, eql_v3_text_match) [#neqjsonb-eql_v3_text_match]
Unsupported operator blocker for public.eql\_v3\_text\_match.
Intercepts an operator that is not supported on public.eql\_v3\_text\_match and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1960]
| Name | Type | Description |
| ----------- | ------------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_text_match` | |
Returns [#returns-1950]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
neq(eql_v3_text_match, jsonb) [#neqeql_v3_text_match-jsonb]
Unsupported operator blocker for public.eql\_v3\_text\_match.
Intercepts an operator that is not supported on public.eql\_v3\_text\_match and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1961]
| Name | Type | Description |
| ----------- | ------------------- | ------------------------------------- |
| `a public.` | `eql_v3_text_match` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1951]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
neq(eql_v3_text_match, eql_v3_text_match) [#neqeql_v3_text_match-eql_v3_text_match]
Unsupported operator blocker for public.eql\_v3\_text\_match.
Intercepts an operator that is not supported on public.eql\_v3\_text\_match and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1962]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a public.` | `eql_v3_text_match` | |
| `b public.` | `eql_v3_text_match` | |
Returns [#returns-1952]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
neq(query_integer_ord, eql_v3_json_entry) [#neqquery_integer_ord-eql_v3_json_entry]
Unsupported operator blocker for public.eql\_v3\_json\_entry.
Intercepts an operator that is not supported on public.eql\_v3\_json\_entry and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1963]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a eql_v3.` | `query_integer_ord` | |
| `b public.` | `eql_v3_json_entry` | |
Returns [#returns-1953]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
neq(eql_v3_json_entry, query_integer_ord) [#neqeql_v3_json_entry-query_integer_ord]
Unsupported operator blocker for public.eql\_v3\_json\_entry.
Intercepts an operator that is not supported on public.eql\_v3\_json\_entry and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1964]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a public.` | `eql_v3_json_entry` | |
| `b eql_v3.` | `query_integer_ord` | |
Returns [#returns-1954]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
neq(jsonb, eql_v3_integer) [#neqjsonb-eql_v3_integer]
Unsupported operator blocker for public.eql\_v3\_integer.
Intercepts an operator that is not supported on public.eql\_v3\_integer and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1965]
| Name | Type | Description |
| ----------- | ---------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_integer` | |
Returns [#returns-1955]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
neq(eql_v3_integer, jsonb) [#neqeql_v3_integer-jsonb]
Unsupported operator blocker for public.eql\_v3\_integer.
Intercepts an operator that is not supported on public.eql\_v3\_integer and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1966]
| Name | Type | Description |
| ----------- | ---------------- | ------------------------------------- |
| `a public.` | `eql_v3_integer` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1956]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
neq(eql_v3_integer, eql_v3_integer) [#neqeql_v3_integer-eql_v3_integer]
Unsupported operator blocker for public.eql\_v3\_integer.
Intercepts an operator that is not supported on public.eql\_v3\_integer and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1967]
| Name | Type | Description |
| ----------- | ---------------- | ----------- |
| `a public.` | `eql_v3_integer` | |
| `b public.` | `eql_v3_integer` | |
Returns [#returns-1957]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
neq(query_real_ord, eql_v3_json_entry) [#neqquery_real_ord-eql_v3_json_entry]
Unsupported operator blocker for public.eql\_v3\_json\_entry.
Intercepts an operator that is not supported on public.eql\_v3\_json\_entry and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1968]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a eql_v3.` | `query_real_ord` | |
| `b public.` | `eql_v3_json_entry` | |
Returns [#returns-1958]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
neq(eql_v3_json_entry, query_real_ord) [#neqeql_v3_json_entry-query_real_ord]
Unsupported operator blocker for public.eql\_v3\_json\_entry.
Intercepts an operator that is not supported on public.eql\_v3\_json\_entry and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1969]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a public.` | `eql_v3_json_entry` | |
| `b eql_v3.` | `query_real_ord` | |
Returns [#returns-1959]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
neq(jsonb, eql_v3_double) [#neqjsonb-eql_v3_double]
Unsupported operator blocker for public.eql\_v3\_double.
Intercepts an operator that is not supported on public.eql\_v3\_double and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1970]
| Name | Type | Description |
| ----------- | --------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_double` | |
Returns [#returns-1960]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
neq(eql_v3_double, jsonb) [#neqeql_v3_double-jsonb]
Unsupported operator blocker for public.eql\_v3\_double.
Intercepts an operator that is not supported on public.eql\_v3\_double and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1971]
| Name | Type | Description |
| ----------- | --------------- | ------------------------------------- |
| `a public.` | `eql_v3_double` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1961]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
neq(eql_v3_double, eql_v3_double) [#neqeql_v3_double-eql_v3_double]
Unsupported operator blocker for public.eql\_v3\_double.
Intercepts an operator that is not supported on public.eql\_v3\_double and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1972]
| Name | Type | Description |
| ----------- | --------------- | ----------- |
| `a public.` | `eql_v3_double` | |
| `b public.` | `eql_v3_double` | |
Returns [#returns-1962]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
neq(jsonb, eql_v3_smallint) [#neqjsonb-eql_v3_smallint]
Unsupported operator blocker for public.eql\_v3\_smallint.
Intercepts an operator that is not supported on public.eql\_v3\_smallint and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1973]
| Name | Type | Description |
| ----------- | ----------------- | ------------------------------------ |
| `a` | `jsonb` | left operand of the blocked operator |
| `b public.` | `eql_v3_smallint` | |
Returns [#returns-1963]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
neq(eql_v3_smallint, jsonb) [#neqeql_v3_smallint-jsonb]
Unsupported operator blocker for public.eql\_v3\_smallint.
Intercepts an operator that is not supported on public.eql\_v3\_smallint and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1974]
| Name | Type | Description |
| ----------- | ----------------- | ------------------------------------- |
| `a public.` | `eql_v3_smallint` | |
| `b` | `jsonb` | right operand of the blocked operator |
Returns [#returns-1964]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
neq(eql_v3_smallint, eql_v3_smallint) [#neqeql_v3_smallint-eql_v3_smallint]
Unsupported operator blocker for public.eql\_v3\_smallint.
Intercepts an operator that is not supported on public.eql\_v3\_smallint and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1975]
| Name | Type | Description |
| ----------- | ----------------- | ----------- |
| `a public.` | `eql_v3_smallint` | |
| `b public.` | `eql_v3_smallint` | |
Returns [#returns-1965]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
neq(query_bigint_ord, eql_v3_json_entry) [#neqquery_bigint_ord-eql_v3_json_entry]
Unsupported operator blocker for public.eql\_v3\_json\_entry.
Intercepts an operator that is not supported on public.eql\_v3\_json\_entry and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1976]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a eql_v3.` | `query_bigint_ord` | |
| `b public.` | `eql_v3_json_entry` | |
Returns [#returns-1966]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
neq(eql_v3_json_entry, query_bigint_ord) [#neqeql_v3_json_entry-query_bigint_ord]
Unsupported operator blocker for public.eql\_v3\_json\_entry.
Intercepts an operator that is not supported on public.eql\_v3\_json\_entry and always raises; it never returns a value. The declared signature exists only so the operator resolves to this blocker instead of a base-type fallback.
Parameters [#parameters-1977]
| Name | Type | Description |
| ----------- | ------------------- | ----------- |
| `a public.` | `eql_v3_json_entry` | |
| `b eql_v3.` | `query_bigint_ord` | |
Returns [#returns-1967]
**Type:** `boolean`
boolean never returned — the function always raises "operator not supported"
***
ope_cllw(jsonb) [#ope_cllwjsonb]
Extract CLLW OPE index term from JSONB payload.
Returns the CLLW OPE ciphertext from the op field of an encrypted scalar payload, hex-decoded to the bytea-backed eql\_v3\_internal.ope\_cllw domain.
Inlinable single-statement SQL — the body is a strict expression of the argument (->> and decode are both STRICT), so the planner folds this into the calling query and functional btree indexes built on eql\_v3.ord\_term(col) (which calls this) engage structurally, the same way the hmac\_256 equality chain does.
Missing-op semantics: val ->> 'opis NULL whenop\` is absent and the strict chain propagates it, so the extractor returns SQL NULL and btree's NULL handling filters those rows from range queries.
Parameters [#parameters-1978]
| Name | Type | Description |
| ----- | ------- | -------------------------------- |
| `val` | `jsonb` | containing encrypted EQL payload |
Returns [#returns-1968]
**Type:** `eql_v3_internal.ope_cllw`
eql\_v3\_internal.ope\_cllw Hex-decoded CLLW OPE term, or NULL when op is absent
***
ore_block_256(jsonb) [#ore_block_256jsonb]
Extract ORE block index term from JSONB payload.
Parameters [#parameters-1979]
| Name | Type | Description |
| ----- | ------- | -------------------------------- |
| `val` | `jsonb` | containing encrypted EQL payload |
Returns [#returns-1969]
**Type:** `eql_v3_internal.ore_block_256`
eql\_v3\_internal.ore\_block\_256 ORE block index term
Exceptions [#exceptions-4]
* if 'ob' field is missing
***
ore_block_256_eq(ore_block_256, ore_block_256) [#ore_block_256_eqore_block_256-ore_block_256]
Equality backing function for ORE block types.
Parameters [#parameters-1980]
| Name | Type | Description |
| -------------------- | -------------------------------------- | ----------- |
| `a eql_v3_internal.` | [`ore_block_256`](#ore-block-256jsonb) | |
| `b eql_v3_internal.` | [`ore_block_256`](#ore-block-256jsonb) | |
***
ore_block_256_gt(ore_block_256, ore_block_256) [#ore_block_256_gtore_block_256-ore_block_256]
Greater-than backing function for ORE block types.
Parameters [#parameters-1981]
| Name | Type | Description |
| -------------------- | -------------------------------------- | ----------- |
| `a eql_v3_internal.` | [`ore_block_256`](#ore-block-256jsonb) | |
| `b eql_v3_internal.` | [`ore_block_256`](#ore-block-256jsonb) | |
***
ore_block_256_gte(ore_block_256, ore_block_256) [#ore_block_256_gteore_block_256-ore_block_256]
Greater-than-or-equal backing function for ORE block types.
Parameters [#parameters-1982]
| Name | Type | Description |
| -------------------- | -------------------------------------- | ----------- |
| `a eql_v3_internal.` | [`ore_block_256`](#ore-block-256jsonb) | |
| `b eql_v3_internal.` | [`ore_block_256`](#ore-block-256jsonb) | |
***
ore_block_256_lt(ore_block_256, ore_block_256) [#ore_block_256_ltore_block_256-ore_block_256]
Less-than backing function for ORE block types.
Parameters [#parameters-1983]
| Name | Type | Description |
| -------------------- | -------------------------------------- | ----------- |
| `a eql_v3_internal.` | [`ore_block_256`](#ore-block-256jsonb) | |
| `b eql_v3_internal.` | [`ore_block_256`](#ore-block-256jsonb) | |
***
ore_block_256_lte(ore_block_256, ore_block_256) [#ore_block_256_lteore_block_256-ore_block_256]
Less-than-or-equal backing function for ORE block types.
Parameters [#parameters-1984]
| Name | Type | Description |
| -------------------- | -------------------------------------- | ----------- |
| `a eql_v3_internal.` | [`ore_block_256`](#ore-block-256jsonb) | |
| `b eql_v3_internal.` | [`ore_block_256`](#ore-block-256jsonb) | |
***
ore_block_256_neq(ore_block_256, ore_block_256) [#ore_block_256_neqore_block_256-ore_block_256]
Not-equal backing function for ORE block types.
Parameters [#parameters-1985]
| Name | Type | Description |
| -------------------- | -------------------------------------- | ----------- |
| `a eql_v3_internal.` | [`ore_block_256`](#ore-block-256jsonb) | |
| `b eql_v3_internal.` | [`ore_block_256`](#ore-block-256jsonb) | |
***
ore_domain_unavailable(jsonb, text, text) [#ore_domain_unavailablejsonb-text-text]
Poison CHECK backing for the ORE-carrying domains on platforms without the ORE operator class.
Always raises; never returns.
Parameters [#parameters-1986]
| Name | Type | Description |
| -------------- | ------- | ----------- |
| `val` | `jsonb` | |
| `domain_name` | `text` | |
| `alternatives` | `text` | |
***
owned_schemas() [#owned_schemas]
Schemas owned by the eql\_v3 surface.
Single source of truth for tooling that must enumerate every schema this installer owns (eql\_v3.lints(), tasks/pin\_search\_path\_v3.sql), so a future third eql\_v3-family schema is one array literal to edit instead of a hardcoded schema-name predicate repeated at every call site. Keep in sync with the SCHEMA / INTERNAL\_SCHEMA constants in crates/eql-codegen/src/consts.rs — those drive what codegen emits into each schema; this drives what tooling scans across both.
Returns [#returns-1970]
**Type:** `name[]`
name\[] The schema names eql\_v3 owns (public + internal).
***
# Securing AI and RAG pipelines
Source: https://cipherstash.com/docs/stack/reference/use-cases/ai-rag
Retrieval-Augmented Generation (RAG) pipelines commonly store sensitive documents alongside vector embeddings. Without encryption, this data is exposed at rest and during retrieval, creating a significant attack surface. CipherStash lets you encrypt sensitive content while preserving the ability to search and retrieve it.
The problem [#the-problem]
RAG architectures typically store:
* **Document chunks**: the original text, often containing PII, financial data, or confidential business information
* **Metadata**: source references, user associations, access tags
* **Vector embeddings**: numeric representations used for similarity search
If any of this data is exfiltrated from the database, the plaintext content is immediately exposed. Encryption-at-rest does not help because the data is decrypted as soon as it is queried.
Encrypting RAG context data [#encrypting-rag-context-data]
Use the Encryption SDK to encrypt sensitive fields before storing them alongside your embeddings.
Define a schema for your documents [#define-a-schema-for-your-documents]
```typescript filename="schema.ts"
import { encryptedTable, encryptedColumn } from "@cipherstash/stack/schema"
export const documents = encryptedTable("documents", {
content: encryptedColumn("content")
.freeTextSearch(),
source: encryptedColumn("source")
.equality(),
userId: encryptedColumn("user_id")
.equality(),
})
```
Encrypt before storage [#encrypt-before-storage]
```typescript filename="ingest.ts"
import { Encryption } from "@cipherstash/stack"
import { documents } from "./schema"
const client = await Encryption({ schemas: [documents] })
async function ingestDocument(doc: { content: string; source: string; userId: string; embedding: number[] }) {
const encryptedContent = await client.encrypt(doc.content, {
column: documents.content,
table: documents,
})
const encryptedSource = await client.encrypt(doc.source, {
column: documents.source,
table: documents,
})
const encryptedUserId = await client.encrypt(doc.userId, {
column: documents.userId,
table: documents,
})
if (encryptedContent.failure || encryptedSource.failure || encryptedUserId.failure) {
throw new Error("Encryption failed")
}
// Store encrypted fields alongside the vector embedding
await db.query(
`INSERT INTO documents (content, source, user_id, embedding)
VALUES ($1::jsonb, $2::jsonb, $3::jsonb, $4)`,
[encryptedContent.data, encryptedSource.data, encryptedUserId.data, JSON.stringify(doc.embedding)]
)
}
```
Decrypt retrieved context [#decrypt-retrieved-context]
After vector similarity search retrieves relevant documents, decrypt the content before passing it to the LLM:
```typescript filename="retrieve.ts"
async function retrieveContext(queryEmbedding: number[], topK: number = 5) {
// Vector similarity search returns encrypted rows
const results = await db.query(
`SELECT content, source FROM documents
ORDER BY embedding <-> $1
LIMIT $2`,
[JSON.stringify(queryEmbedding), topK]
)
// Decrypt the content for each result
const decryptedDocs = await Promise.all(
results.rows.map(async (row) => {
const content = await client.decrypt(row.content)
const source = await client.decrypt(row.source)
return {
content: content.failure ? null : content.data,
source: source.failure ? null : source.data,
}
})
)
return decryptedDocs.filter((doc) => doc.content !== null)
}
```
Searchable encrypted retrieval [#searchable-encrypted-retrieval]
When you need to filter documents by metadata before or alongside vector search, use [searchable encryption](https://cipherstash.com/docs/stack/cipherstash/encryption/searchable-encryption) with EQL:
```sql
-- Find documents for a specific user using encrypted equality search
SELECT content, source, embedding
FROM documents
WHERE eql_v2.eq(user_id, $1)
ORDER BY embedding <-> $2
LIMIT 10;
```
This combines encrypted metadata filtering with vector similarity, without ever decrypting the metadata in the database.
Benefits for AI pipelines [#benefits-for-ai-pipelines]
* **Sensitive context stays encrypted**: document chunks containing PII or confidential data are never stored in plaintext
* **Compliance-ready**: encrypted storage meets GDPR, HIPAA, and SOC2 requirements for data protection
* **Selective decryption**: only decrypt what the LLM needs, reducing exposure surface
* **Audit trail**: track who retrieved which documents and when using [identity-aware encryption](https://cipherstash.com/docs/stack/cipherstash/encryption/identity)
# Regulatory compliance
Source: https://cipherstash.com/docs/stack/reference/use-cases/compliance
CipherStash's searchable encryption provides the technical controls needed to satisfy regulatory requirements while maintaining full query capabilities. This page covers common compliance patterns using the Encryption SDK and EQL.
Encrypted uniqueness constraints [#encrypted-uniqueness-constraints]
Many compliance frameworks require that sensitive identifiers (email, SSN, tax ID) are unique across your dataset. With CipherStash, you can enforce uniqueness on encrypted data using HMAC-based indexes.
Create a unique index on encrypted data [#create-a-unique-index-on-encrypted-data]
When you define an `equality()` index on a column, CipherStash generates a deterministic HMAC that can be used for unique constraints:
```typescript filename="schema.ts"
import { encryptedTable, encryptedColumn } from "@cipherstash/stack/schema"
export const patients = encryptedTable("patients", {
ssn: encryptedColumn("ssn")
.equality(),
email: encryptedColumn("email")
.equality(),
})
```
In PostgreSQL with EQL, create a unique index on the HMAC component:
```sql
-- Create the table with encrypted columns
CREATE TABLE patients (
id SERIAL PRIMARY KEY,
ssn eql_v2_encrypted NOT NULL,
email eql_v2_encrypted NOT NULL
);
-- Add unique index on the HMAC (equality) index term
CREATE UNIQUE INDEX patients_ssn_unique
ON patients (eql_v2.hmac_256(ssn));
CREATE UNIQUE INDEX patients_email_unique
ON patients (eql_v2.hmac_256(email));
```
This ensures no two patients can have the same SSN or email, enforced at the database level, while the actual values remain encrypted.
GDPR compliance patterns [#gdpr-compliance-patterns]
Right to erasure (Article 17) [#right-to-erasure-article-17]
Encrypted data with CipherStash supports crypto-shredding: revoke the keyset or client key, and all data encrypted under that key becomes permanently unreadable.
Data minimization (Article 5) [#data-minimization-article-5]
Encrypt all personal data fields and use [Lock Contexts](https://cipherstash.com/docs/stack/cipherstash/encryption/identity) to restrict which application components can decrypt specific records:
```typescript filename="minimize-access.ts"
// The client is authenticated as the signed-in user via OidcFederationStrategy;
// the data key is bound to their `sub` claim
const result = await client
.decrypt(encryptedPaymentData)
.withLockContext({ identityClaim: ["sub"] })
```
Data portability (Article 20) [#data-portability-article-20]
Encrypted values are stored as standard JSON objects ([CipherCells](https://cipherstash.com/docs/stack/reference/cipher-cell)). They can be exported, transferred between systems, and decrypted at the destination, provided the recipient has the appropriate key material.
HIPAA compliance patterns [#hipaa-compliance-patterns]
Access controls (§ 164.312(a)) [#access-controls--164312a]
Use identity-aware encryption to bind decryption to authenticated healthcare providers:
```typescript filename="hipaa-access.ts"
// Encrypt patient records, bound to the authenticated provider's identity
const encrypted = await client
.encrypt(patientRecord.diagnosis, {
column: patients.diagnosis,
table: patients,
})
.withLockContext({ identityClaim: ["sub"] })
```
Audit controls (§ 164.312(b)) [#audit-controls--164312b]
Every encryption and decryption operation through ZeroKMS produces an audit event. Combine with [CipherStash Proxy audit features](https://cipherstash.com/docs/stack/cipherstash/proxy/audit) for comprehensive data access logging including statement fingerprints and record reconciliation.
Integrity controls (§ 164.312(c)) [#integrity-controls--164312c]
CipherStash's authenticated encryption (AES-256-GCM-SIV) detects any tampering with encrypted data during decryption. The operation fails if the ciphertext has been modified.
PCI-DSS compliance patterns [#pci-dss-compliance-patterns]
Requirement 3: Protect stored cardholder data [#requirement-3-protect-stored-cardholder-data]
Encrypt cardholder data at the application layer before it reaches the database:
```typescript filename="pci-store.ts"
import { encryptedTable, encryptedColumn } from "@cipherstash/stack/schema"
export const cards = encryptedTable("cards", {
cardNumber: encryptedColumn("card_number")
.equality(),
cardholderName: encryptedColumn("cardholder_name"),
})
```
Requirement 10: Track and monitor access [#requirement-10-track-and-monitor-access]
CipherStash's audit logging provides cryptographic proof of data access. Every decryption request is logged with:
* **Who**: the authenticated identity (via Lock Context)
* **What**: which encrypted column was accessed
* **When**: timestamp of the operation
Supported regulations [#supported-regulations]
| Regulation | Key requirements | CipherStash features |
| ------------- | ----------------------------------------------- | -------------------------------------------------------------- |
| **GDPR** | Encryption, data minimization, right to erasure | Searchable encryption, Lock Contexts, crypto-shredding |
| **HIPAA** | Access controls, audit trails, integrity | Identity-aware encryption, ZeroKMS audit logs, AES-256-GCM-SIV |
| **PCI-DSS** | Protect cardholder data, access monitoring | Application-layer encryption, audit logging |
| **SOC2** | Encryption at rest and in use, access controls | Encryption-in-use, role-based key access |
| **ISO 27001** | Information security management | End-to-end encryption, key management, audit trails |
| **CCPA** | Consumer data protection | Encrypted storage, access controls |
# Data residency
Source: https://cipherstash.com/docs/stack/reference/use-cases/data-residency
CipherStash's architecture provides strong data residency guarantees through regional key management, zero-knowledge encryption, and cryptographic key splitting. This guide covers deployment patterns for organizations with cross-border data requirements.
Regional ZeroKMS deployment [#regional-zerokms-deployment]
ZeroKMS is available in [multiple regions](https://cipherstash.com/docs/stack/cipherstash/kms/regions) globally:
* **Asia Pacific**: Sydney (ap-southeast-2)
* **Europe**: Frankfurt (eu-central-1), Ireland (eu-west-1)
* **US East**: N. Virginia (us-east-1)
* **US West**: Oregon (us-west-2)
By selecting a ZeroKMS region, you control where authority keys are managed. Combined with your application's deployment region, this gives you full control over where key material exists.
Dual-party key split for sovereignty [#dual-party-key-split-for-sovereignty]
CipherStash uses a dual-party key split architecture that provides a strong sovereignty guarantee:
1. **Authority key**: managed by ZeroKMS in your chosen region
2. **Client key**: managed by your application in your infrastructure
Neither key alone is sufficient to derive data keys. Both must cooperate to encrypt or decrypt data. This means:
* **ZeroKMS alone cannot access your data**: it only holds half of the key material
* **Your application alone cannot access data**: it needs ZeroKMS to derive data keys
* **Data keys are never transmitted**: they are derived locally in your infrastructure
Deployment patterns [#deployment-patterns]
Single-region deployment [#single-region-deployment]
The simplest pattern: deploy your application and ZeroKMS in the same region.
```
┌─────────────────────────────────┐
│ Region: eu-central-1 │
│ │
│ ┌───────────┐ ┌────────────┐ │
│ │ Your App │──│ ZeroKMS │ │
│ │ + Client │ │ + Authority│ │
│ │ Key │ │ Key │ │
│ └─────┬─────┘ └────────────┘ │
│ │ │
│ ┌─────┴─────┐ │
│ │ PostgreSQL │ │
│ │ (encrypted)│ │
│ └───────────┘ │
└─────────────────────────────────┘
```
All key material and data remain within the single region. This satisfies most data residency requirements including GDPR and regional data protection laws.
Multi-region with regional key isolation [#multi-region-with-regional-key-isolation]
For organizations operating across regions with different data residency requirements, deploy separate workspaces per region:
```
┌─────────────────────┐ ┌─────────────────────┐
│ Region: eu-central-1│ │ Region: ap-southeast-2│
│ │ │ │
│ App + Client Key │ │ App + Client Key │
│ ZeroKMS (EU) │ │ ZeroKMS (APAC) │
│ PostgreSQL (EU) │ │ PostgreSQL (APAC) │
└─────────────────────┘ └─────────────────────┘
```
Each region has its own:
* ZeroKMS workspace with independent authority keys
* Client keys that never leave the region
* Database with encrypted data
Data encrypted in one region cannot be decrypted in another, providing cryptographic enforcement of data residency boundaries.
Cross-border access with centralized control [#cross-border-access-with-centralized-control]
When you need to access encrypted data across regions (e.g., a global support team), use the Encryption SDK with region-specific client keys:
```typescript filename="regional-access.ts"
import { Encryption } from "@cipherstash/stack"
import { customers } from "./schema"
// Configure client for the EU workspace
const euClient = await Encryption({
schemas: [customers],
workspaceCrn: process.env.CS_EU_WORKSPACE_CRN,
clientId: process.env.CS_EU_CLIENT_ID,
clientKey: process.env.CS_EU_CLIENT_KEY,
accessKey: process.env.CS_EU_ACCESS_KEY,
})
// Decrypt EU customer data (requires EU credentials)
const result = await euClient.decrypt(encryptedEuRecord)
```
Access to each region's data requires that region's credentials. This provides an auditable, revocable access model. To revoke a team member's access to a region, delete their client credentials for that region's workspace.
Compliance alignment [#compliance-alignment]
| Requirement | How CipherStash addresses it |
| --------------------------------------- | ----------------------------------------------------------------------------------------------------- |
| **Data must not leave the region** | Encryption and decryption happen locally; plaintext never leaves your infrastructure |
| **Key material must stay in-region** | ZeroKMS authority keys are region-bound; client keys deploy with your app |
| **Audit trail for cross-border access** | ZeroKMS logs all key derivation requests with identity context |
| **Ability to revoke access** | Delete client credentials or revoke [Lock Context](https://cipherstash.com/docs/stack/cipherstash/encryption/identity) identities |
| **Cryptographic enforcement** | Dual-party key split makes unauthorized access mathematically impossible |
Next steps [#next-steps]
* [Configure ZeroKMS regions](https://cipherstash.com/docs/stack/cipherstash/kms/regions) for your workspaces
* [Set up identity-aware encryption](https://cipherstash.com/docs/stack/cipherstash/encryption/identity) for access control
* [Review disaster recovery](https://cipherstash.com/docs/stack/cipherstash/kms/disaster-recovery) for multi-region key backup
# Overview
Source: https://cipherstash.com/docs/stack/reference/use-cases
CipherStash vs data vaults [#cipherstash-vs-data-vaults]
Compare CipherStash's proof-based security architecture with traditional data vault solutions like Skyflow and VGS.
Security architecture [#security-architecture]
CipherStash: Proof-based security [#cipherstash-proof-based-security]
Access is cryptographically provable. You do not need to fully trust CipherStash because we never see the data.
CipherStash is actually multiple separate components: a cloud-based key service (ZeroKMS) and encryption services (either Proxy or the Encryption SDK) that always run in your infrastructure. Neither plaintext nor data keys are ever visible to the cloud service. Even the encrypted values always remain within your systems.
CipherStash ZeroKMS employs an encryption key hierarchy to provide true zero-trust capabilities. For a given keyset, ZeroKMS manages an "authority key" which is not sufficient to generate data encryption keys. The application (Proxy or Encryption SDK) manages an independent client key. Data keys can only be generated by the application and so are never visible to ZeroKMS.
Skyflow and VGS: Trust-based security [#skyflow-and-vgs-trust-based-security]
There is no way to prove if data was accessed by an unauthorized user. You must trust that the vendor does the right thing.
In contrast, Skyflow and VGS both process and store plaintext data. There is no strict trust boundary between your systems and the data vault which means you must trust that the company's processes, practices and personnel are appropriate.
Searchable encryption [#searchable-encryption]
CipherStash encryption is searchable and supports simple lookups, range queries, ordering, and free-text search. Data does not need to be decrypted to be queried and can remain encrypted in a broader range of systems. CipherStash searchable encryption is fast: even the slowest mechanism takes less than 1ms to filter records in a PostgreSQL table containing 120 million rows.
Skyflow supports only exact lookups. VGS does not support searchable encryption at all.
Protection beyond the vault [#protection-beyond-the-vault]
If any encrypted data unexpectedly leaves your PostgreSQL database it remains safe. This provides strong protection against accidental leaks as well as insider threats. Encrypted data can also be transferred between systems without ever needing to decrypt it.
A vault offers no or limited protection for data outside the vault. If original values are retrieved and stored then no protection is provided.
Example: Query customer records [#example-query-customer-records]
**Scenario**: You have customer data including SSN, date of birth, email address and home address. You want to retrieve all records where the customer was born in 1990.
| Vendor | How DOB is stored | Query capability | Avoids N+1 | Performance |
| --------------- | --------------------------------- | -------------------------------- | ---------- | ----------------------------------------------- |
| **CipherStash** | Encrypted per-value in your DB | Range queries via ORE | Yes | Efficient (runs in PostgreSQL) |
| **Skyflow** | Plaintext in vault, token outside | Exact match only; range limited | No | Extra 50–200 ms per vault query |
| **VGS** | Plaintext in vault, alias outside | Equality only (no range queries) | No | Requires fetching all and filtering client-side |
***
Data sovereignty [#data-sovereignty]
CipherStash provides comprehensive solutions for data sovereignty requirements. The architecture gives you complete control over where your data and key material reside.
Zero-knowledge architecture [#zero-knowledge-architecture]
* **Data keys are never transmitted across networks**: keys are derived locally in your infrastructure
* **Plaintext data never leaves your systems**: encryption and decryption occur entirely within your environment
* **Even encrypted values remain in your infrastructure**: CipherStash Proxy and Encryption SDK run in your systems
* **No single point of compromise**: cryptographic proofs ensure unauthorized access is mathematically impossible
Cryptographic control [#cryptographic-control]
CipherStash uses a **dual-party key split** architecture:
* ZeroKMS manages an "authority key" (required but not sufficient)
* Your application (Proxy or Encryption SDK) manages an independent "client key"
* Data keys can only be generated when both components cooperate
* Data keys are never visible to ZeroKMS or transmitted over networks
Regional deployment [#regional-deployment]
ZeroKMS is available in [multiple regions globally](https://cipherstash.com/docs/stack/cipherstash/kms/regions), including Asia Pacific (Sydney), Europe (Frankfurt, Ireland), US East, and US West.
Compliance alignment [#compliance-alignment]
CipherStash's data sovereignty architecture supports compliance with GDPR, regional data protection laws, government regulations, and industry-specific requirements for healthcare, financial services, and other regulated sectors.
***
What data should I protect? [#what-data-should-i-protect]
When improving your data security practices, it can be difficult to know what data is important enough to protect. Here are the common types of sensitive data you should encrypt.
Personally Identifiable Information (PII) [#personally-identifiable-information-pii]
Any data that could identify a specific individual: names, phone numbers, dates of birth, addresses, emails, IP addresses, social security numbers, license numbers, passport numbers.
**Applicable regulations**: GDPR, CCPA, HIPAA, APP (Australia), PCI-DSS, SOC2, ISO27001
Protected Health Information (PHI) [#protected-health-information-phi]
Any information about health status, provision of health care, or payment for health care that can be linked to an individual: medical record numbers, health insurance beneficiary numbers, biometric identifiers, medical conditions, medication histories, payment histories.
**Applicable regulations**: HIPAA, CMIA, GDPR, APP
Financial Information [#financial-information]
Data about money, accounts, and transactions: account numbers and balances, transaction data, TFNs/ITINs, saved payees.
**Applicable regulations**: GDPR, CCPA, PCI-DSS, CDR (Australia), SOC2, ISO27001
Authentication Information [#authentication-information]
Credentials used to gain access to accounts and services: usernames, passwords (plaintext and hashed), OAuth tokens, session cookies.
**Applicable regulations**: SOC2, ISO27001, PCI-DSS
# Provable access control
Source: https://cipherstash.com/docs/stack/reference/use-cases/provable-access
Traditional access control relies on application logic. If a bug or misconfiguration exposes data, there is no way to prove access was unauthorized. CipherStash provides **cryptographic proof-based access control** through Lock Contexts, where access to data is mathematically bound to authenticated identities.
How it works [#how-it-works]
CipherStash [Lock Contexts](https://cipherstash.com/docs/stack/cipherstash/encryption/identity) bind encryption and decryption operations to an authenticated identity (typically a JWT from your identity provider). The identity token becomes part of the key derivation process. Without a valid token, the data keys cannot be derived and the data cannot be decrypted.
This creates a provable access boundary:
* If data was decrypted, the identity token **must** have been present
* ZeroKMS logs the identity associated with every key derivation
* The audit trail is cryptographically verifiable; it cannot be falsified
Identity-aware encryption [#identity-aware-encryption]
Bind encryption to an identity [#bind-encryption-to-an-identity]
Authenticate the client as the signed-in provider, then bind values to a claim from their JWT.
```typescript filename="identity-encrypt.ts"
import { Encryption, OidcFederationStrategy } from "@cipherstash/stack"
import { patients } from "./schema"
// Every ZeroKMS request is made as the signed-in healthcare provider
const client = await Encryption({
schemas: [patients],
config: {
authStrategy: OidcFederationStrategy.create(
process.env.CS_WORKSPACE_CRN,
() => getProviderJwt(),
),
},
})
async function encryptPatientRecord(record: { diagnosis: string }) {
const result = await client
.encrypt(record.diagnosis, {
column: patients.diagnosis,
table: patients,
})
.withLockContext({ identityClaim: ["sub"] })
if (result.failure) {
throw new Error(`Encryption failed: ${result.failure.message}`)
}
return result.data
}
```
Decrypt with identity verification [#decrypt-with-identity-verification]
```typescript filename="identity-decrypt.ts"
async function decryptPatientRecord(encryptedDiagnosis: unknown) {
const result = await client
.decrypt(encryptedDiagnosis)
.withLockContext({ identityClaim: ["sub"] })
if (result.failure) {
// Decryption fails if the identity doesn't have access
throw new Error(`Access denied: ${result.failure.message}`)
}
return result.data
}
```
Audit logging [#audit-logging]
Every encryption and decryption operation through ZeroKMS produces an audit event containing:
| Field | Description |
| --------------- | ------------------------------------------------------------- |
| **Identity** | The authenticated user or service (from the Lock Context JWT) |
| **Operation** | Encrypt or decrypt |
| **Timestamp** | When the operation occurred |
| **Keyset** | Which keyset was used |
| **Application** | Which application performed the operation |
Combining with Proxy audit [#combining-with-proxy-audit]
When using [CipherStash Proxy](https://cipherstash.com/docs/stack/cipherstash/proxy), additional audit capabilities are available:
* **[Statement fingerprinting](https://cipherstash.com/docs/stack/cipherstash/proxy/audit)**: identify unique SQL query patterns accessing encrypted data
* **[SQL redaction](https://cipherstash.com/docs/stack/cipherstash/proxy/audit)**: strip sensitive values from logged queries
* **[Primary key injection](https://cipherstash.com/docs/stack/cipherstash/proxy/audit)**: track which specific records were accessed
* **[Record reconciliation](https://cipherstash.com/docs/stack/cipherstash/proxy/audit)**: map data access events to specific table records
Together, these provide an end-to-end audit trail: **who** accessed **what data**, **when**, and using **which query**.
Use cases [#use-cases]
Healthcare: HIPAA audit requirements [#healthcare-hipaa-audit-requirements]
HIPAA requires audit controls that record who accessed Protected Health Information (PHI). With Lock Contexts, every access to patient data is cryptographically tied to the authenticated provider:
```typescript filename="hipaa-audit.ts"
// The client is authenticated as Dr Smith, so each access is provably tied to her
const diagnosis = await client
.decrypt(patient.encryptedDiagnosis)
.withLockContext({ identityClaim: ["sub"] })
// ZeroKMS audit log shows:
// - Identity: dr.smith@hospital.example (from JWT)
// - Operation: decrypt
// - Keyset: patients-production
// - Timestamp: 2025-01-15T09:30:00Z
```
Financial services: Segregation of duties [#financial-services-segregation-of-duties]
Ensure that only authorized roles can access specific data categories:
```typescript filename="segregation.ts"
// A client authenticated as a compliance-team member can decrypt audit records
const auditData = await client
.decrypt(encryptedAuditRecord)
.withLockContext({ identityClaim: ["sub"] })
// Someone on the trading desk, authenticated as themselves, resolves a different
// claim value, so key derivation fails and the records do not decrypt
```
Multi-tenant SaaS: Tenant isolation [#multi-tenant-saas-tenant-isolation]
Bind encryption to tenant identity to provide cryptographic tenant isolation:
```typescript filename="tenant-isolation.ts"
// Encrypt data bound to the signed-in tenant user's identity
const encrypted = await client
.encrypt(sensitiveData, {
column: tenants.data,
table: tenants,
})
.withLockContext({ identityClaim: ["sub"] })
// Only Tenant A's identity can decrypt this data
// Tenant B's JWT will fail key derivation
```
Benefits over traditional access control [#benefits-over-traditional-access-control]
| Aspect | Traditional (application logic) | Provable (CipherStash Lock Contexts) |
| ------------------------ | ---------------------------------------- | -------------------------------------------------------- |
| **Enforcement** | Software checks that can be bypassed | Cryptographic: mathematically impossible to bypass |
| **Audit trail** | Application logs that can be modified | ZeroKMS audit logs that are cryptographically verifiable |
| **Proof of access** | Circumstantial (log entries) | Deterministic (key derivation requires identity) |
| **Blast radius of bugs** | Data exposed if access check is bypassed | Data remains encrypted even if application logic fails |
Next steps [#next-steps]
* [Set up identity-aware encryption](https://cipherstash.com/docs/stack/cipherstash/encryption/identity) with Lock Contexts
* [Configure audit logging](https://cipherstash.com/docs/stack/cipherstash/proxy/audit) with CipherStash Proxy
* [Review compliance patterns](https://cipherstash.com/docs/stack/reference/use-cases/compliance) for GDPR, HIPAA, and PCI-DSS