Skip to main content
Filter operations allow you to query entities based on specific conditions. ChameleonDB supports a rich set of comparison operators.

​
Current API (v0.1)

v0.1 uses string-based filters. The target API will use generated typed accessors for better type safety.
Current syntax: 
db.Users().Filter("email", "eq", "ana@mail.com")
Target API (with code generation): 
db.Users().Filter(User.Email.Eq("ana@mail.com"))

​
Filter by Equality

Match records where a field equals a specific value: 
users, err := db.Users().
    Filter("email", "eq", "ana@mail.com").
    Execute()

​
Comparison Operators

ChameleonDB supports these comparison operators:
OperatorMeaningExample
eqEqualFilter("age", "eq", 25)
neqNot equalFilter("status", "neq", "deleted")
gtGreater thanFilter("age", "gt", 18)
gteGreater than or equalFilter("age", "gte", 18)
ltLess thanFilter("total", "lt", 100)
lteLess than or equalFilter("total", "lte", 100)
likeContains (pattern)Filter("name", "like", "ana")
inIn listFilter("status", "in", [...])

​
Greater Than or Equal

users, err := db.Users().
    Filter("age", "gte", 18).
    Execute()

​
Multiple Filters (AND)

Multiple .Filter() calls are combined with AND: 
users, err := db.Users().
    Filter("age", "gte", 18).
    Filter("age", "lte", 65).
    Execute()
You can chain as many filters as needed. They will all be combined with AND logic.

​
Like (Pattern Matching)

Match strings using like. Wildcards (%) are added automatically: 
users, err := db.Users().
    Filter("name", "like", "ana").
    Execute()
ChameleonDB automatically wraps the search term with % wildcards for convenient substring matching.

​
In (Multiple Values)

Match against a list of values: 
users, err := db.Users().
    Filter("status", "in", []string{"active", "pending"}).
    Execute()
Filter the main entity based on a condition on a related entity: 
users, err := db.Users().
    Filter("orders.total", "gt", 100).
    Execute()
Important: When filtering on a relation, ChameleonDB uses a JOIN automatically. DISTINCT is added to avoid duplicates when a user has multiple matching orders.

​
Filter on Relation + Include

You can filter on a relation and also include it. The filter affects which users are returned; the include loads all their orders (not just matching ones): 
users, err := db.Users().
    Filter("orders.total", "gt", 100).
    Include("orders").
    Execute()
The filter determines which users match. The include loads all related data for those users, not just the filtered subset.

​
Not Equal

users, err := db.Users().
    Filter("status", "neq", "deleted").
    Execute()

​
Less Than

orders, err := db.Orders().
    Filter("total", "lt", 100).
    Execute()

​
Type Safety

Filters are validated against your schema. Type mismatches will be caught:
// ❌ This will fail - age is an integer
db.Users().Filter("age", "eq", "not a number")

// ✅ Correct
db.Users().Filter("age", "eq", 25)

​
What’s Next?

Relations

Learn about eager loading with Include()

Advanced Queries

OrderBy, Limit, Offset, and complex queries