Querying with Filters

All ekoDB client libraries provide a QueryBuilder for constructing complex queries with filters, sorting, and pagination using a fluent API.

Simple Query

🦀 Rust

use ekodb_client::{Client, QueryBuilder};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = Client::new("https://your-db.ekodb.net", "YOUR_API_KEY")?;

    // Find active users
    let query = QueryBuilder::new()
        .eq("status", "active")
        .build();

    let result = client.find("users", query).await?;
    println!("{:?}", result);
    Ok(())
}

📘 TypeScript

import { EkoDBClient, QueryBuilder } from 'ekodb-client';

const client = new EkoDBClient({
  baseURL: "https://your-db.ekodb.net",
  apiKey: "YOUR_API_KEY"
});

// Find active users
const query = new QueryBuilder()
  .eq("status", "active")
  .build();

const result = await client.find("users", query);
console.log(result);

🔷 Go

package main

import (
    "fmt"
    "github.com/ekoDB/ekodb-client-go"
)

func main() {
    client := ekodb.NewClient(
        "https://your-db.ekodb.net",
        "YOUR_API_KEY",
    )

    // Find active users
    query := ekodb.NewQueryBuilder().
        Eq("status", "active").
        Build()

    result, err := client.Find("users", query)
    if err != nil {
        panic(err)
    }
    fmt.Println(result)
}

🐍 Python

from ekodb_client import Client, QueryBuilder

client = Client.new(
    "https://your-db.ekodb.net",
    "YOUR_API_KEY"
)

# Find active users
query = QueryBuilder() \
    .eq("status", "active") \
    .build()

result = client.find("users", query)
print(result)

🟣 Kotlin

import io.ekodb.client.EkoDBClient
import io.ekodb.client.QueryBuilder

suspend fun main() {
    val client = EkoDBClient(
        baseUrl = "https://your-db.ekodb.net",
        apiKey = "YOUR_API_KEY"
    )

    // Find active users
    val query = QueryBuilder()
        .eq("status", "active")
        .build()

    val result = client.find("users", query)
    println(result)
}

---

Complex Query

Find active users aged 18-65 with gmail addresses, sorted by creation date:

🦀 Rust

let query = QueryBuilder::new()
    .eq("status", "active")
    .gte("age", 18)
    .lte("age", 65)
    .contains("email", "@gmail.com")
    .sort_desc("created_at")
    .limit(20)
    .build();

let result = client.find("users", query).await?;

📘 TypeScript

const query = new QueryBuilder()
  .eq("status", "active")
  .gte("age", 18)
  .lte("age", 65)
  .contains("email", "@gmail.com")
  .sortDesc("created_at")
  .limit(20)
  .build();

const result = await client.find("users", query);

🔷 Go

query := ekodb.NewQueryBuilder().
    Eq("status", "active").
    Gte("age", 18).
    Lte("age", 65).
    Contains("email", "@gmail.com").
    SortDescending("created_at").
    Limit(20).
    Build()

result, err := client.Find("users", query)

🐍 Python

query = QueryBuilder() \
    .eq("status", "active") \
    .gte("age", 18) \
    .lte("age", 65) \
    .contains("email", "@gmail.com") \
    .sort_desc("created_at") \
    .limit(20) \
    .build()

result = client.find("users", query)

🟣 Kotlin

val query = QueryBuilder()
    .eq("status", "active")
    .gte("age", 18)
    .lte("age", 65)
    .contains("email", "@gmail.com")
    .sortDesc("created_at")
    .limit(20)
    .build()

val result = client.find("users", query)

---

Logical Operators

OR Query

Find users who are either admins or moderators:

🦀 Rust

use serde_json::json;

let query = QueryBuilder::new()
    .or(vec![
        json!({
            "type": "Condition",
            "content": {
                "field": "role",
                "operator": "Eq",
                "value": "admin"
            }
        }),
        json!({
            "type": "Condition",
            "content": {
                "field": "role",
                "operator": "Eq",
                "value": "moderator"
            }
        }),
    ])
    .build();

📘 TypeScript

const query = new QueryBuilder()
  .or([
    {
      type: "Condition",
      content: {
        field: "role",
        operator: "Eq",
        value: "admin"
      }
    },
    {
      type: "Condition",
      content: {
        field: "role",
        operator: "Eq",
        value: "moderator"
      }
    }
  ])
  .build();

🔷 Go

query := ekodb.NewQueryBuilder().
    Or([]map[string]interface{}{
        {
            "type": "Condition",
            "content": map[string]interface{}{
                "field":    "role",
                "operator": "Eq",
                "value":    "admin",
            },
        },
        {
            "type": "Condition",
            "content": map[string]interface{}{
                "field":    "role",
                "operator": "Eq",
                "value":    "moderator",
            },
        },
    }).
    Build()

🐍 Python

query = QueryBuilder() \
    .or_([
        {
            "type": "Condition",
            "content": {
                "field": "role",
                "operator": "Eq",
                "value": "admin"
            }
        },
        {
            "type": "Condition",
            "content": {
                "field": "role",
                "operator": "Eq",
                "value": "moderator"
            }
        }
    ]) \
    .build()

🟣 Kotlin

val query = QueryBuilder()
    .or(listOf(
        mapOf(
            "type" to "Condition",
            "content" to mapOf(
                "field" to "role",
                "operator" to "Eq",
                "value" to "admin"
            )
        ),
        mapOf(
            "type" to "Condition",
            "content" to mapOf(
                "field" to "role",
                "operator" to "Eq",
                "value" to "moderator"
            )
        )
    ))
    .build()

---

String Operators

StartsWith

🦀 Rust

let query = QueryBuilder::new()
    .starts_with("name", "Dr. ")
    .build();

📘 TypeScript

const query = new QueryBuilder()
  .startsWith("name", "Dr. ")
  .build();

🔷 Go

query := ekodb.NewQueryBuilder().
    StartsWith("name", "Dr. ").
    Build()

🐍 Python

query = QueryBuilder() \
    .starts_with("name", "Dr. ") \
    .build()

🟣 Kotlin

val query = QueryBuilder()
    .startsWith("name", "Dr. ")
    .build()

EndsWith

🦀 Rust

let query = QueryBuilder::new()
    .ends_with("email", ".edu")
    .build();

📘 TypeScript

const query = new QueryBuilder()
  .endsWith("email", ".edu")
  .build();

🔷 Go

query := ekodb.NewQueryBuilder().
    EndsWith("email", ".edu").
    Build()

🐍 Python

query = QueryBuilder() \
    .ends_with("email", ".edu") \
    .build()

🟣 Kotlin

val query = QueryBuilder()
    .endsWith("email", ".edu")
    .build()

Contains

🦀 Rust

let query = QueryBuilder::new()
    .contains("description", "urgent")
    .build();

📘 TypeScript

const query = new QueryBuilder()
  .contains("description", "urgent")
  .build();

🔷 Go

query := ekodb.NewQueryBuilder().
    Contains("description", "urgent").
    Build()

🐍 Python

query = QueryBuilder() \
    .contains("description", "urgent") \
    .build()

🟣 Kotlin

val query = QueryBuilder()
    .contains("description", "urgent")
    .build()

---

Pagination

Page through results with skip and limit:

🦀 Rust

// Page 2 with 20 items per page
let query = QueryBuilder::new()
    .eq("status", "active")
    .page(2, 20)  // skip: 40, limit: 20
    .sort_desc("created_at")
    .build();

📘 TypeScript

// Page 2 with 20 items per page
const query = new QueryBuilder()
  .eq("status", "active")
  .page(2, 20)  // skip: 40, limit: 20
  .sortDesc("created_at")
  .build();

🔷 Go

// Page 2 with 20 items per page
query := ekodb.NewQueryBuilder().
    Eq("status", "active").
    Page(2, 20). // skip: 40, limit: 20
    SortDescending("created_at").
    Build()

🐍 Python

# Page 2 with 20 items per page
query = QueryBuilder() \
    .eq("status", "active") \
    .page(2, 20) \  # skip: 40, limit: 20
    .sort_desc("created_at") \
    .build()

🟣 Kotlin

// Page 2 with 20 items per page
val query = QueryBuilder()
    .eq("status", "active")
    .page(2, 20)  // skip: 40, limit: 20
    .sortDesc("created_at")
    .build()

---

Available Operators

Comparison Operators

Method	Operator	Description
.eq(field, value)	Eq	Equals
.ne(field, value)	Ne	Not equals
.gt(field, value)	Gt	Greater than
.gte(field, value)	Gte	Greater than or equal
.lt(field, value)	Lt	Less than
.lte(field, value)	Lte	Less than or equal
.in(field, array)	In	Value in array
.nin(field, array)	NotIn	Value not in array

String Operators

Method	Operator	Description
.contains(field, substring)	Contains	Substring match
.startsWith(field, prefix)	StartsWith	Prefix match
.endsWith(field, suffix)	EndsWith	Suffix match

Logical Operators

Method	Description
.and(conditions)	All conditions must match
.or(conditions)	At least one condition must match
.not(condition)	Negate a condition

Sorting & Pagination

Method	Description
.sortAsc(field)	Sort ascending
.sortDesc(field)	Sort descending
.limit(n)	Max results to return
.skip(n)	Results to skip
.page(page, size)	Convenience method for pagination

---

Query Expression Reference

For the complete reference including all operators, JSON structure, and advanced patterns, see:

Query Expressions Reference

Complete QueryBuilder Examples

QueryBuilder examples - Complex queries with filtering, sorting, and pagination:

• Rust: client_query_builder.rs
• Python: client_query_builder.py
• TypeScript: client_query_builder.ts
• JavaScript: client_query_builder.js
• Go: client_query_builder.go
• Kotlin: ClientQueryBuilder.kt

---

Next Steps

• Query Expressions - Complete operator reference
• Advanced Operations - Joins, transactions, and batch operations
• Examples Repository - Client library & direct HTTP examples

Need Help?

• 🐛 Issues: GitHub Issues
• 💬 Support: app.ekodb.io/support
• 📧 Email: support@ekodb.io