3.operators.md

title	Operators Reference
description	All filter operators in vecna
author	zoobzio
published	2025-01-14
updated	2025-01-14
tags	vecna operators reference

Operators Reference

Complete reference for all filter operators.

Comparison Operators

Eq (Equal)

filter := builder.Where("field").Eq(value)

Property	Value
Op constant	vecna.Eq
Spec string	"eq"
SQL equivalent	field = value
Valid field types	All

Example:

builder.Where("category").Eq("tech")
builder.Where("active").Eq(true)
builder.Where("count").Eq(10)

---

Ne (Not Equal)

filter := builder.Where("field").Ne(value)

Property	Value
Op constant	vecna.Ne
Spec string	"ne"
SQL equivalent	field != value
Valid field types	All

Example:

builder.Where("status").Ne("deleted")

---

Gt (Greater Than)

filter := builder.Where("field").Gt(value)

Property	Value
Op constant	vecna.Gt
Spec string	"gt"
SQL equivalent	field > value
Valid field types	Numeric only (KindInt, KindFloat)

Example:

builder.Where("score").Gt(0.5)
builder.Where("count").Gt(100)

Error: Returns filter with ErrInvalidFilter if field is not numeric.

---

Gte (Greater Than or Equal)

filter := builder.Where("field").Gte(value)

Property	Value
Op constant	vecna.Gte
Spec string	"gte"
SQL equivalent	field >= value
Valid field types	Numeric only

Example:

builder.Where("score").Gte(0.8)

---

Lt (Less Than)

filter := builder.Where("field").Lt(value)

Property	Value
Op constant	vecna.Lt
Spec string	"lt"
SQL equivalent	field < value
Valid field types	Numeric only

Example:

builder.Where("age").Lt(30)

---

Lte (Less Than or Equal)

filter := builder.Where("field").Lte(value)

Property	Value
Op constant	vecna.Lte
Spec string	"lte"
SQL equivalent	field <= value
Valid field types	Numeric only

Example:

builder.Where("price").Lte(99.99)

---

In (Set Membership)

filter := builder.Where("field").In(values...)

Property	Value
Op constant	vecna.In
Spec string	"in"
SQL equivalent	field IN (value1, value2, ...)
Valid field types	All

Example:

builder.Where("category").In("tech", "science", "art")
builder.Where("status").In("active", "pending")

FilterSpec format:

{"op": "in", "field": "category", "value": ["tech", "science", "art"]}

---

Nin (Not In Set)

filter := builder.Where("field").Nin(values...)

Property	Value
Op constant	vecna.Nin
Spec string	"nin"
SQL equivalent	field NOT IN (value1, value2, ...)
Valid field types	All

Example:

builder.Where("category").Nin("spam", "junk", "deleted")
builder.Where("status").Nin("archived", "banned")

FilterSpec format:

{"op": "nin", "field": "category", "value": ["spam", "junk", "deleted"]}

---

Like (Pattern Match)

filter := builder.Where("field").Like(pattern)

Property	Value
Op constant	vecna.Like
Spec string	"like"
SQL equivalent	field LIKE pattern
Valid field types	String only (KindString)

Pattern syntax is provider-dependent but typically supports:

• % — matches any sequence of characters
• _ — matches any single character

Example:

builder.Where("name").Like("%widget%")
builder.Where("email").Like("%@example.com")

FilterSpec format:

{"op": "like", "field": "name", "value": "%widget%"}

Error: Returns filter with ErrInvalidFilter if field is not a string.

Provider Support: Not supported by Pinecone. Will error at query time.

---

Contains (Array Membership)

filter := builder.Where("field").Contains(value)

Property	Value
Op constant	vecna.Contains
Spec string	"contains"
SQL equivalent	value = ANY(field)
Valid field types	Slice only (KindSlice)

Checks if an array field contains a specific value.

Example:

builder.Where("tags").Contains("featured")
builder.Where("categories").Contains("electronics")

FilterSpec format:

{"op": "contains", "field": "tags", "value": "featured"}

Error: Returns filter with ErrInvalidFilter if field is not a slice.

Provider Support: Not supported by Pinecone. Will error at query time.

---

Logical Operators

And

filter := builder.And(filter1, filter2, ...)

Property	Value
Op constant	vecna.And
Spec string	"and"
SQL equivalent	(condition1 AND condition2 AND ...)

Matches when all child filters match.

Example:

builder.And(
    builder.Where("category").Eq("tech"),
    builder.Where("active").Eq(true),
)

FilterSpec format:

{
    "op": "and",
    "children": [
        {"op": "eq", "field": "category", "value": "tech"},
        {"op": "eq", "field": "active", "value": true}
    ]
}

---

Or

filter := builder.Or(filter1, filter2, ...)

Property	Value
Op constant	vecna.Or
Spec string	"or"
SQL equivalent	(condition1 OR condition2 OR ...)

Matches when any child filter matches.

Example:

builder.Or(
    builder.Where("category").Eq("tech"),
    builder.Where("category").Eq("science"),
)

FilterSpec format:

{
    "op": "or",
    "children": [
        {"op": "eq", "field": "category", "value": "tech"},
        {"op": "eq", "field": "category", "value": "science"}
    ]
}

---

Not

filter := builder.Not(filter)

Property	Value
Op constant	vecna.Not
Spec string	"not"
SQL equivalent	NOT (condition)

Negates a filter. Matches when the child filter does not match.

Important: Not requires exactly one child filter.

Example:

// Simple negation
builder.Not(builder.Where("status").Eq("deleted"))

// Negating a compound filter
builder.Not(
    builder.Or(
        builder.Where("category").Eq("spam"),
        builder.Where("category").Eq("junk"),
    ),
)

FilterSpec format:

{
    "op": "not",
    "children": [
        {"op": "eq", "field": "status", "value": "deleted"}
    ]
}

Error: Returns filter with ErrInvalidFilter if not exactly one child is provided.

---

Summary Table

Operator	Method	Spec	Type Restriction	Description
Eq	Eq(v)	"eq"	None	Equal
Ne	Ne(v)	"ne"	None	Not equal
Gt	Gt(v)	"gt"	Numeric only	Greater than
Gte	Gte(v)	"gte"	Numeric only	Greater than or equal
Lt	Lt(v)	"lt"	Numeric only	Less than
Lte	Lte(v)	"lte"	Numeric only	Less than or equal
In	In(v...)	"in"	None	Set membership
Nin	Nin(v...)	"nin"	None	Not in set
Like	Like(p)	"like"	String only	Pattern match
Contains	Contains(v)	"contains"	Slice only	Array membership
And	And(...)	"and"	—	Logical AND
Or	Or(...)	"or"	—	Logical OR
Not	Not(f)	"not"	—	Logical NOT

---

Field Type Compatibility

Field Kind	Eq	Ne	Gt	Gte	Lt	Lte	In	Nin	Like	Contains
KindString	Yes	Yes	No	No	No	No	Yes	Yes	Yes	No
KindInt	Yes	Yes	Yes	Yes	Yes	Yes	Yes	Yes	No	No
KindFloat	Yes	Yes	Yes	Yes	Yes	Yes	Yes	Yes	No	No
KindBool	Yes	Yes	No	No	No	No	Yes	Yes	No	No
KindSlice	Yes	Yes	No	No	No	No	Yes	Yes	No	Yes

---

Provider Support

Not all operators are supported by all vector database providers.

Operator	Qdrant	Pinecone	Weaviate	Milvus	PgVector
Eq	Yes	Yes	Yes	Yes	Yes
Ne	Yes	Yes	Yes	Yes	Yes
Gt/Gte/Lt/Lte	Yes	No	Yes	Yes	Yes
In	Yes	Yes	Yes	Yes	Yes
Nin	Yes	Yes	Yes	Yes	Yes
Like	Yes	No	Yes	Yes	Yes
Contains	Yes	No	Yes	Yes	Yes
And/Or	Yes	Yes	Yes	Yes	Yes
Not	Yes	Yes	Yes	Yes	Yes

Unsupported operators will return an error at query time.