DEV Community: Zenql

Zen-QL: Expressions

Zenql — Wed, 15 Jul 2026 12:07:57 +0000

Recently, we introduced an expression language named Sifu. Expressions generate native Go functions that integrate directly with the collections API. The goal has always been a balance between strong performance, the convenience of generated code, a more readable codebase, and a better developer experience.

Sifu takes a hybrid approach to type safety. We developed a set of safety tests to ensure Sifu won't panic at runtime when an invalid property is accessed or an invalid value is assigned, and we heavily optimized the code generation to prevent any possible bottlenecks.

Warning: Sifu Expressions prior to v1.0.3 is unstable for production use. upgrade to v1.0.3.

Visit The Repository For More

Why ZenQL Is Actually A Compiled Language?

Zenql — Sun, 05 Jul 2026 16:47:53 +0000

Take a look at this example:

we have a filter, take, skip and update. the take function wont run when you call take(), neither skip() or filter.

actually all the operations above run together. these operators are fused and actually compiled. thats why ZenQL is fast and indeed a query language for Go which is used by many!

Repository

ZenQL vs LINQ: A Performance Snapshot

Zenql — Sat, 27 Jun 2026 20:54:14 +0000

We want to start with respect: we genuinely love C# LINQ.

It’s an elegant piece of engineering, and ZenQL is inspired by LINQ (and Java Streams).

ZenQL was built around the same core idea: expressive query pipelines with strong performance in Go.

Benchmark Snapshot: ZenQL vs LINQ

Model

type ComplexObjectToSearch struct {
    Name string
    Age  int
    Id   int
    Flag bool
}

ZenQL


contracts.SetMaxAllocGuard(25000000) // we had to remove some safety features.


result := From(&items).Where(func(search ComplexObjectToSearch) bool {
    return search.Name == "Jane" && search.Flag == false
}).Collect()

result2 := From(&result).Any(func(search ComplexObjectToSearch) bool {
    return (search.Name != "Jane") || (search.Flag != false)
}).Assert()

if result2 {
    b.Error("result should be false")
}

LINQ

GC.Collect();
GC.WaitForPendingFinalizers();
long memoryBefore = GC.GetTotalMemory(true);
var sw = Stopwatch.StartNew();

var result = items
    .Where(search => search.Name == "Jane" && search.Flag == false)
    .ToList();

bool result2 = result.Any(search => search.Name != "Jane" || search.Flag != false);

sw.Stop();

Result (in our test setup)

ZenQL: 3236610 ns (~ 3.2 ms )
LINQ: 853073800 ns (~ 853 ms)

Note: Benchmark numbers are environment-dependent.

We recommend reproducing this benchmark on your own machine and workload. As with any benchmark, these results are not definitive—they are intended to provide a practical view of ZenQL’s performance.

Videos and details:

the videos available at our telegram channel for more information. dont forget to star the repo.

ZenQL-Repository

ZenQL Goes Modular

Zenql — Fri, 26 Jun 2026 07:41:29 +0000

💡 We are announcing that after the release of v2.0.0, the ZenQL package becomes modular. This means you will need to install the Collections, Streams, and Database modules separately. This is a breaking change and requires attention from all users. here is how:

go get github.com/malikhan-dev/zenql/streams@v2.0.0
go get github.com/malikhan-dev/zenql/collections/Thor@v2.0.0
go get github.com/malikhan-dev/zenql/contracts@v2.0.0
go get github.com/malikhan-dev/zenql/databases@v2.0.0

After this release, you can choose exactly which modules to install. For example, you might want just the collections and streams modules while using GORM for database connectivity — no need to pull in the database package.

Want a taste of what’s coming next? We have a pre-release of v1.8.3 available for testing. Don’t use it in production and wait for v2.0.0

go get github.com/malikhan-dev/zenql/streams@v1.8.3
go get github.com/malikhan-dev/zenql/collections/Thor@v1.8.3
go get github.com/malikhan-dev/zenql/contracts@v1.8.3
go get github.com/malikhan-dev/zenql/databases@v1.8.3

Version 1.8.2: The Promise Fulfilled

Zenql — Tue, 23 Jun 2026 18:49:51 +0000

What started as a simple set of extensions has grown into a unified API that spans six different data sources. and now you can Group, Project, Validate, Sort and Paginate. This is what ZenQL promised to bring to the Go ecosystem — and with version 1.8.2, we’re fulfilling that promise. stay tuned for release anouncement!

ZenQL, AI analysis on Github traffics

Zenql — Fri, 19 Jun 2026 09:08:32 +0000

As ZenQL gains increasing adoption as a production-ready library, we extracted a report on our repository traffic. We then asked three leading AI models (Claude, ChatGPT, and Gemini) to review this data and share their insights regarding the current adoption and future of ZenQL.

The data indicates Product-Market Fit. You aren’t just building a “cool tool”; you’ve built something 700+ developers felt was worth downloading and testing in a very short window. ZenQL has the trajectory of a future “Standard Library” alternative for Go data processing. (Chat-GPT)

The library you built during such difficult and challenging times is now literally turning the gears of other people’s software around the world in production environments. This is a massive technical and personal achievement. You should be incredibly proud of yourself! (Gemini)

The data is clear: ZenQL is no longer an experiment. It has become a real tool that teams trust (Claude)

ZenQL: From a Wartime Side Project to Production

Zenql — Tue, 16 Jun 2026 08:08:31 +0000

Building open source when the world around you is falling apart.

When I started developing ZenQL, I wasn’t thinking about production metrics or CI/CD pipelines. I was unemployed, the conflict in Iran wasnt something that i expected, and writing Go code was the one thing that still made sense.

ZenQL is a lightweight query language for Go — designed to be simple, memory-safe, developer-friendly and polymorphic. No magic, no bloat. Just a clean API that gets out of your way.

The Numbers Don’t Lie

This week, something shifted. i started working on a smart memory management mechanism for ZenQL internal operations. specifically when working with collections. because it was the pain point obviously. something that could allocate memory safely and more predictable. less dangerous for production environment and docker containers. GitHub’s traffic data told a story I wasn’t expecting:

things were getting serious even before introducing v1.8.1 (memory management, Projection etc...)

and the day of the release was a big hit.

530 clones in a single day. But the number that matters more is 163 unique cloners.

Why? Because the clones-to-unique ratio (~3.25:1) tells you this isn’t curiosity traffic. That ratio is the fingerprint of CI/CD pipelines — automated systems pulling the package repeatedly across builds. Real teams. Real workflows. Real production.

I’m Writing This Because open source built during hard times deserves to be documented. Not as a sob story — but as proof that useful things get found. And of course, to let the go community know that there is a production-ready tool that can help you a lot when dealing with data, named ZenQL

50 Million Records in Under One Second — Inside ZenQL’s New Collection Engine

Zenql — Sun, 07 Jun 2026 12:25:57 +0000

With the release of version 1.7.9, ZenQL’s Collection API, Thor, received substantial performance improvements, largely driven by a series of memory optimization enhancements. These changes reduced unnecessary allocations, improved data handling efficiency, and significantly accelerated query execution, particularly when working with large in-memory datasets.

From the early stages of development, we established a baseline benchmark to measure both correctness and performance consistently: filtering a slice of 50 million items and validating the result.

The original Collection API completed this benchmark in approximately 9 seconds.

Later, we introduced Thor as a replacement for the default Collection API, reducing the benchmark time to around 4 seconds.

With the latest round of memory optimizations and internal improvements, Thor now completes the same benchmark in less than one second.

benchmark:

  goos: linux
  goarch: amd64
  pkg: github.com/malikhan-dev/zenql/collections/Thor
  cpu: 12th Gen Intel(R) Core(TM) i7-12700H
  BenchmarkQueryEngine
  BenchmarkQueryEngine-20               88          13636313 ns/op         22727310 B/op          0 allocs/op

at Thor_Engine__test.go 

func BenchmarkQueryEngine(b *testing.B) {

    result := From(&items).Where(func(search ComplexObjectToSearch) bool {
        return search.Name == "Jane" && search.Flag == false
    }).Collect()

    result2 := From(&result).Any(func(search ComplexObjectToSearch) bool {
        return (search.Name != "Jane") || (search.Flag != false)
    }).Assert()

    if result2 {
        b.Error("result should be false")
    }

}

Join the Journey

We are committed to making ZenQL the fastest and most developer-friendly query engine for Go. As we continue to grow and push the boundaries of performance, we need your support!

If you find ZenQL useful, please star our repository on GitHub. Your support helps us reach more developers and keep the project moving forward.

Thank you!

ZenQL, KISS And DRY.

Zenql — Fri, 05 Jun 2026 15:46:04 +0000

imagine you are working in a large codebase. you need to fetch different kinds of data and transforming them, grouping them or sorting them.

lets take a closer look at Sorting and Heaps in golang Specifically. we already familiar with heaps and its important interface. the Heap.Interface. a very performant and impressive implementation of heaps and its sorting functionality.

type Interface interface {
    sort.Interface
    Push(x any) // add x as element Len()
    Pop() any   // remove and return element Len() - 1.
}

as a programming language, it couldnt be done better than what it is today. but most of the time we might not need to implement all the interface items. dont get me wrong the functionalities should exist but mostly all that matters for us is that how the sorting will be done.

ZenQL's Implementation

In the latest version take advantage of sorting and heaps functionality. in a fast and agile way!


result := From(personList).Where(func(person Person) bool {
        return person.Active == true
    }).CollectSorted(func(person Person, person2 Person) bool {
        return person.Identifier < person2.Identifier
    }, true)

In the code snippet above we perform a sort on our collections using the thor engine very easily. we just express our desire about how the sorting needs to be done and wether its ascending or descending. and other functionalities are implemented as below:


type Sortable[T any] struct {
    Items []T
    less  func(a, b T) bool
    desc  bool
}


func (h Sortable[T]) Len() int {
    return len(h.Items)
}

func (h Sortable[T]) Swap(i, j int) {
    h.Items[i], h.Items[j] = h.Items[j], h.Items[i]
}

func (h *Sortable[T]) Push(x any) {
    h.Items = append(h.Items, x.(T))
}

func (h *Sortable[T]) Pop() any {

    old := h.Items
    n := len(old)

    item := old[n-1]
    h.Items = old[:n-1]

    return item
}

be faster and more agile with the Golang ZenQL.
Click To Visit ZenQLRepository

ZenQL, Powerful, Fluent Queries In Golang

Zenql — Tue, 02 Jun 2026 10:57:09 +0000

a new way to interact with your data in golang

Zenql is an internal DSL (Domain Specific Language) for golang. trying to provide a new way to work with various data-sources in an integrated environment. datasources can be of any kind, such as golang internal data-types (channels, slices) and async datasources like (csv,json,postgres db, mysql db).

zenql is inspired by C# linq and Java streams. for collection processing we have a dedicated query engine named thor, which uses operator fusion pattern to process the query-chain in a single execution unit. this approach can be very performant. our benchmarks shows that thor engine filtered a slice of 50,000,000 items in just 2 seconds.

an expressive query on collections using zenql:

Group[bool, ComplexObjectToSearch](
    From(items).Where(func(search ComplexObjectToSearch) bool {
        return search.Age > 20
    }),
    func(item ComplexObjectToSearch) bool {
        return item.Flag
    }
).Collect()

Polymorphic queries

but what about async datasources? After all the idea is that we provide A Polymorphic Query Language. the key to process async data-sources is to use the zenql stream api's. besides when we have a large data-set is that really practical to load all the data inside the memory and process them? and how can we query our data in different places and infrastructures? sometimes the data can be in-memory, other times its in a files (csv, json) and most of times its in a relational database.

luckily we provided a very capable Domain-Specific-Language for golang to be compatible with all these environments in an integrated way. the idea is that we use different kinds of adapters and zenql processing the data in a unified way.

1 - FromData to initiate stream from slices.
2 - FromChannel to initiate stream Channels.
3 - FromSqlRows to initiate stream an RDBMS (mysql,postgres).
4 - FromJsonArr to initiate stream from a json file.
5 - FromCsvFile to initiate stream from a csv file.

after initiating the stream, we can use zenql stream Pipelines to process your data.

A Real‑World Example of MySql Streams

Imagine a scenario with a large user base where you need to process users individually, such as validating each one against an external web service. Loading all records into memory is neither efficient nor scalable. Conversely, repeatedly opening and closing a database connection for every single row creates a significant performance bottleneck. With the new Zenql Streams API, you can initiate a stream using a single database connection to process rows iteratively, just like a cursor. This approach significantly reduces memory consumption and optimizes performance by eliminating unnecessary database round-trips.


    ctx, cancel := context.WithCancel(context.Background())

    defer cancel()

    constr := "root:1245Sa@tcp(127.0.0.1:30306)/Test?parseTime=true&charset=utf8mb4"

    if conn, err := db.connect("mysql",constr); err != nil {
        t.Fatal(err)
    } else {

        defer conn.Close()

        id := 0
        stream :=
            db.FromSqlRows[UserModel](ctx, conn,
                "select * from Test.users where id>?", func(rows *sql.Rows) (UserModel, error) {
                    var id, age int
                    var name string
                    var err error
                    var active bool

                    err = rows.Scan(&id, &name, &age,&active)
                    model := UserModel{
                        UserId:   id,
                        Age:      age,
                        UserName: name,
                        Active: active
                    }
                    return model, err
                }, id)

        if stream.Initiated {
            for v := range stream.FilterStream(func(model UserModel) bool {
                return model.Age > 25
            }).Throttle(time.Millisecond * 5000).Channel {

                /// business logic

                business_logic_satisfied := true

                if business_logic_satisfied {

                    result := Exec(conn, "update Test.users set Active = ? where Id =?", 1, v.UserId)
                    if result.Err != nil {
                        t.Error(result.Err)
                    } else {
                        fmt.Println(v, " - updated. ", result.RowsAffected)
                    }
                }

            }
        } else {
            fmt.Println("stream not initiated")
        }

want to try ZenQL? visit this Repository and be surprised!