DEV Community: Kirill Scherba

Why I Built a Go SQL Helper

Kirill Scherba — Fri, 12 Jun 2026 10:41:50 +0000

Zero-boilerplate SQL for Go. Define a struct with tags. That's it.

If you write Go and talk to SQL databases, you know the pain. Every CRUD operation requires writing a raw SQL string, carefully mapping columns to struct fields with rows.Scan, manually wrapping writes in Begin/Commit/Rollback, and keeping your schema definitions in sync with your code. It's tedious, error-prone, and the boilerplate never ends.

This is the story of sqlh — a library I built to eliminate all of that, while staying in the "sweet spot" between raw SQL (too much work) and heavy ORMs (too much magic).

The Problem: Go + SQL = Death by a Thousand `rows.Scan`s

Go's database/sql package is excellent. It gives you a solid, portable foundation for talking to any SQL database. But it intentionally leaves the hard work to you.

Here's what a simple CRUD workflow looks like with raw database/sql:

// 1. Create table — raw DDL string
_, err := db.Exec(`CREATE TABLE IF NOT EXISTS user (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    name TEXT UNIQUE,
    email TEXT,
    age INTEGER
)`)

// 2. Insert — explicit placeholders and args
_, err = db.Exec(
    "INSERT INTO user (name, email, age) VALUES (?, ?, ?)",
    "Alice", "alice@example.com", 30,
)

// 3. Get by ID — QueryRow + manual Scan
var u User
err = db.QueryRow("SELECT id, name, email, age FROM user WHERE id = ?", 1).
    Scan(&u.ID, &u.Name, &u.Email, &u.Age)

// 4. List all — Query + rows.Next + rows.Scan loop
rows, err := db.Query("SELECT id, name, email, age FROM user ORDER BY name ASC")
var users []User
for rows.Next() {
    var u User
    if err := rows.Scan(&u.ID, &u.Name, &u.Email, &u.Age); err != nil {
        log.Fatal(err)
    }
    users = append(users, u)
}
rows.Close()

// 5. Update — raw SQL with placeholders
_, err = db.Exec(
    "UPDATE user SET email = ?, age = ? WHERE id = ?",
    "alice.new@example.com", 31, 1,
)

// 6. Delete — raw SQL
_, err = db.Exec("DELETE FROM user WHERE id = ?", 1)

That is ~115 lines of code for six basic operations. And every time you add a column, you must update the CREATE TABLE string, the INSERT columns, the SELECT columns, and the rows.Scan call. One typo in any of those, and you get a runtime error — no compile-time safety.

The Pain Points

Pain	Why it hurts
Manual SQL writing	Every CRUD operation needs a raw SQL string — no compile-time check
`rows.Scan` verbosity	4–5 lines per query result just to map columns to struct fields
Transaction boilerplate	`db.Begin()` + `defer tx.Rollback()` + `tx.Commit()` — repeated everywhere
No schema traceability	Table DDL lives in migration files, structs in Go — they drift
Error-prone column ordering	Adding a column means updating SQL strings and `Scan` calls

Existing Solutions: sqlx, GORM, and the Missing Middle

The Go ecosystem offers two well-known paths to reduce this pain. Both have trade-offs.

sqlx: Better, But Still Manual

sqlx is a popular enhancement over database/sql. It adds StructScan, Get, Select, and named query parameters. You still write raw SQL, but rows.Scan is automated.

// sqlx: still manual SQL, but StructScan eliminates Scan
var u User
dbx.Get(&u, "SELECT id, name, email, age FROM user WHERE id = ?", 1)

sqlx saves about 30% of the boilerplate (down to ~80 lines). But you still write every CREATE TABLE, INSERT, SELECT, UPDATE, and DELETE by hand. SQL generation is not its job.

GORM: Full ORM, Full Magic

GORM is the heavyweight champion. It generates everything — schema, queries, migrations — and provides a rich chainable API. But it comes with a cost:

Heavy reflection overhead at runtime
Steep learning curve — tags, hooks, scopes, associations
~4 MB binary size increase just for the ORM
Magic that hides complexity — until it doesn't, and you spend hours debugging

For large teams with dedicated DBAs and complex domain models, GORM is a solid choice. For CLI tools, startups, and small-to-medium services, it's overkill.

sqlh: The Sweet Spot

Feature	`database/sql`	sqlx	GORM	sqlh
SQL generation	❌ Manual	❌ Manual	✅ Full	✅ Full
`rows.Scan` needed	✅ Yes	❌ `StructScan`	❌ Auto	❌ Auto
Type-safe (generics)	❌	❌	❌	✅
Auto-transactions	❌	❌	✅	✅
Lock retry	❌	❌	❌	✅
Learning curve	Medium	Medium	High	Low
Binary size overhead	0	~200 KB	~4 MB	~200 KB

sqlh lives between sqlx and GORM:

Zero-boilerplate CRUD — struct tags generate all SQL
Type-safe via Go generics — Get[User]() returns *User, not interface{}
No magic — what you see in the struct is what you get in the database
Lightweight — minimal reflection, cached metadata, no hidden complexity

How sqlh Works: Struct Tags as Single Source of Truth

The core idea is simple: your Go struct is your schema.

type User struct {
    ID    int64  `db:"id" db_key:"not null primary key autoincrement"`
    Name  string `db:"name" db_key:"unique"`
    Email string `db:"email"`
    Age   int    `db:"age"`
}

Three struct tags control everything:

Tag	Purpose	Example
`db`	Column name	`db:"user_name"`
`db_key`	Constraints, indexes	`db_key:"primary key autoincrement"`
`db_type`	SQL type override	`db_type:"TEXT"`

From this single struct definition, sqlh generates:

CREATE TABLE — sqlh.Create[User](db) generates and executes CREATE TABLE IF NOT EXISTS user (id INTEGER PRIMARY KEY AUTOINCREMENT, name TEXT UNIQUE, email TEXT, age INTEGER)
INSERT — sqlh.Insert(db, User{Name: "Alice"}) generates INSERT INTO user (name, email, age) VALUES (?, ?, ?)
SELECT — sqlh.Get[User](db, ...) generates SELECT id, name, email, age FROM user WHERE ... LIMIT 2
UPDATE — sqlh.Update(db, ...) generates UPDATE user SET name=?, email=?, age=? WHERE ...
DELETE — sqlh.Delete[User](db, ...) generates DELETE FROM user WHERE ...

Architecture

┌─────────────────────────────────────────────┐
│  sqlh package                               │
│  Insert, Get, List, Update, Delete, Set,    │
│  Create — with auto-transactions            │
├─────────────────────────────────────────────┤
│  query package                              │
│  SQL generation, metadata cache, JOINs      │
├─────────────────────────────────────────────┤
│  database/sql (stdlib)                      │
│  Connection pool, raw query execution       │
└─────────────────────────────────────────────┘

Key Design Decisions

Generics-first (Go 1.25+) — Get[User]() returns *User with compile-time type safety. No interface{}, no type assertions.
Reflection at call-time — Struct metadata is parsed once and cached in a sync.Map keyed by reflect.Type. Subsequent calls reuse table names, field lists, and scan metadata.
Auto-transactions on writes — Every Insert, Update, Delete, and Set is automatically wrapped in BEGIN...COMMIT with ROLLBACK on error. You never forget a transaction again.
Database lock retry — SQLite "database is locked" errors are automatically retried up to 20 times with 100ms backoff. Production-grade resilience out of the box.
Multi-database support — SQLite (primary), MySQL, PostgreSQL (both CI-tested), and SQL Server (experimental).

CRUD in 50 Lines: The Quick Start

Here's the complete CRUD workflow with sqlh. Same operations as the raw SQL example above — ~57% less code:

package main

import (
    "database/sql"
    "fmt"

    "github.com/kirill-scherba/sqlh"
    _ "github.com/mattn/go-sqlite3"
)

type User struct {
    ID    int64  `db:"id" db_key:"not null primary key autoincrement"`
    Name  string `db:"name" db_key:"unique"`
    Email string `db:"email"`
    Age   int    `db:"age"`
}

func main() {
    db, _ := sql.Open("sqlite3", "file::memory:?cache=shared")
    defer db.Close()

    // 1. Create table from struct
    sqlh.Create[User](db)

    // 2. Insert
    sqlh.Insert(db, User{Name: "Alice", Email: "alice@example.com", Age: 30})
    bobID, _ := sqlh.InsertId(db, User{Name: "Bob", Email: "bob@example.com", Age: 25})

    // 3. Get by ID — returns *User, not interface{}
    u, _ := sqlh.Get[User](db, sqlh.Eq("id", bobID))
    fmt.Println(u.Name) // "Bob"

    // 4. List all — returns []User + next offset
    users, _, _ := sqlh.List[User](db, 0, "", "name ASC")
    fmt.Println(len(users)) // 2

    // 5. Update — pass full struct to avoid zeroing other columns
    sqlh.Update(db, sqlh.UpdateAttr[User]{
        Row:    User{Name: "Alice", Email: "alice.new@example.com", Age: 31},
        Wheres: []sqlh.Where{sqlh.Eq("id", 1)},
    })

    // 6. Delete
    sqlh.Delete[User](db, sqlh.Eq("id", bobID))
}

~50 lines. No raw SQL. No rows.Scan. No transaction management. No column ordering errors.

Side-by-Side Comparison

Operation	Raw `database/sql`	sqlx	sqlh
CREATE TABLE	Raw SQL string	Raw SQL string	`sqlh.Create[User](db)`
INSERT	`Exec(?,?,?)`	`NamedExec`	`Insert(T)`
GET	`QueryRow + Scan`	`Get(&T)`	`Get[T](where)`
LIST	`rows.Next + Scan`	`Select`	`List[T](...)`
UPDATE	`Exec(?,?,?,?)`	`NamedExec`	`Update(attr)`
DELETE	`Exec(?)`	`Exec(?)`	`Delete[T](where)`
COUNT	`QueryRow + Scan`	`Get(&int)`	`Count[T]()`

	Lines of code	Reduction
Raw `database/sql`	~115	baseline
sqlx	~80	−30%
sqlh	~50	−57%

Benchmarks: The Numbers

How fast is sqlh in practice? I created a standalone bench/ module comparing raw database/sql, sqlx, GORM, and sqlh on the same CRUD workload. All benchmarks use in-memory SQLite — zero external setup.

Reproduce on your machine:

cd bench && go test -bench=. -benchmem -benchtime=1s

CRUD Throughput (ops/sec)

Operation	raw sql	sqlx	GORM	sqlh
Insert	158,856	131,337	35,288	85,631
Get by PK	169,090	150,082	77,489	73,601
List all	11,857	9,076	6,775	7,607
List limit 10	51,000	43,381	37,666	44,204
Update	226,963	177,242	65,828	84,083
Delete	170,503	163,185	41,375	60,503

Memory Allocations (bytes/op, allocs/op)

Operation	raw sql	sqlx	GORM	sqlh
Insert	328 B, 12	721 B, 20	5,536 B, 82	1,274 B, 39
Get by PK	792 B, 27	976 B, 31	3,952 B, 66	2,593 B, 78
List all	23,744 B, 528	26,376 B, 632	27,669 B, 946	26,394 B, 745
List limit	3,120 B, 76	3,624 B, 91	6,145 B, 141	3,958 B, 115
Update	296 B, 10	680 B, 19	5,079 B, 68	1,393 B, 43
Delete	216 B, 7	216 B, 7	5,483 B, 67	1,139 B, 37

What the Numbers Tell Us

GORM has the highest latency and allocation footprint across all operations, reflecting its rich feature set and internal reflection overhead.
sqlh sits between raw sql/sqlx and GORM. The moderate overhead comes from auto-generated SQL, struct tag parsing, and built-in transaction wrapping for writes.
sqlh trades raw speed for correctness: every write is auto-transacted with rollback on error, eliminating an entire class of bugs at the cost of ~2–6x latency versus raw sql for single-row mutations.
ListAll is dominated by the cost of scanning 100 rows. All libraries show similar performance here.

Environment: Linux AMD Ryzen 9 3900, Go 1.26.3, SQLite in-memory.
Run cd bench && go test -bench=. -benchmem -benchtime=1s on your own hardware for an apples-to-apples comparison.

When to Use sqlh

sqlh is not a silver bullet. Here's where it shines and where you might want something else:

Use case	Recommendation
CLI tools & utilities	✅ Perfect — zero migration files, single binary
Startups & MVPs	✅ Ship faster, refactor later
Microservices with simple schemas	✅ Low overhead, type-safe
High-throughput OLTP (>100K writes/sec)	⚠️ Test first — raw sql may be needed
Complex multi-table analytics	⚠️ Prefer raw SQL or a query builder
Large teams with dedicated DBAs	⚠️ GORM or sqlx may fit better
Learning Go + SQL	✅ Great teaching tool — low cognitive load

Getting Started

go get github.com/kirill-scherba/sqlh

What’s Next

sqlh is actively developed. As of v0.8.0 (June 2026), the library supports:

✅ Full CRUD with auto-transactions
✅ Native UPSERT (PostgreSQL, SQLite, MySQL)
✅ JOIN queries with composite struct scanning
✅ Go 1.25 iterators (ListRange) for lazy streaming
✅ Type-safe WHERE helpers (Eq, Ne, Gt, Like, In, etc.)
✅ Database lock retry for SQLite
✅ Multi-database support (SQLite, MySQL, PostgreSQL)

On the roadmap: aggregate functions (SUM, AVG), schema migrations, batch operations, and transactional reads. The API is stabilizing toward v1.0.0.

If you’re building a Go project that talks to SQL and you’re tired of writing the same boilerplate over and over — give sqlh a try. Define your struct. That’s it.

Written by Kirill Scherba. sqlh is open source under the BSD license. Contributions welcome.

Ordered map

Kirill Scherba — Sat, 15 Feb 2025 11:51:43 +0000

Omap is Golang package for working with thread safe ordered maps. The ordered map contains the golang map, list and mutex to execute Ordered Map functions.

The Ordered Map is a map that remembers the order of items. The map can be iterated over to retrieve the items in the order they were added.

Introduction to the omap Go Package

The omap Go package is a lightweight and efficient library for working with ordered maps in Go. An ordered map is a data structure that combines the benefits of a map and a list, allowing you to store key-value pairs in a specific order.

What is omap?

Omap is a Go package that provides an implementation of an ordered map. It is designed to be fast, efficient, and easy to use. Omap is particularly useful when you need to store data in a specific order, such as when working with configuration files, caching, or data processing pipelines.

Key Features of omap

Ordered: omap preserves the order in which key-value pairs are inserted, allowing you to iterate over the map in a specific order.
Fast lookups: omap uses a hash table to store key-value pairs, making lookups fast and efficient.
Efficient insertion and deletion: omap uses a linked list to store the order of key-value pairs, making insertion and deletion operations efficient.

Using omap

To use omap, you can install it using the following command:

go get github.com/kirill-scherba/omap

Here is an example of how to use omap:

package main

import (
    "fmt"
    "log"

    "github.com/kirill-scherba/omap"
)

func main() {
    // Create a new ordered map
    m, err := omap.New[string, string]()
    if err != nil {
        log.Fatal(err)
    }

    // Insert some key-value pairs
    m.Set("key1", "value1")
    m.Set("key2", "value2")
    m.Set("key3", "value3")

    // Iterate over the omap in order
    for _, pair := range m.Pairs() {
        fmt.Printf("%s: %s\n", pair.Key, pair.Value)
    }
}

This code creates a new omap, inserts some key-value pairs, and then iterates over the omap in order, printing out each key-value pair.

Conclusion

The omap Go package is a useful library for working with ordered maps in Go. Its fast lookups, efficient insertion and deletion, and ordered iteration make it a great choice for a variety of use cases. Whether you're working with configuration files, caching, or data processing pipelines, omap is definitely worth considering.

Example Use Cases

Configuration files: Use omap to store configuration data in a specific order, making it easy to iterate over the configuration and apply settings in the correct order.
Caching: Use omap to store cached data in a specific order, making it easy to iterate over the cache and evict items in the correct order.
Data processing pipelines: Use omap to store data in a specific order, making it easy to iterate over the data and process it in the correct order.

See more description and examples on omap projects github page:
https://github.com/kirill-scherba/omap/

Teonet messages queue

Kirill Scherba — Thu, 21 Mar 2024 07:29:45 +0000

The Teonet messages queue is a part of the Teonet network.

A message queue is a form of asynchronous service-to-service communication used in serverless and microservices architectures. Messages are stored on the queue until they are processed and deleted. Each message is processed only once, by a single consumer. Message queues can be used to decouple heavyweight processing, to buffer or batch work, and to smooth spiky workloads.

Basic teomq scheme

The Teonet messages queue contains three basic parts:

Teonet messages broker
Teonet messages consumer
Teonet messages producer

See more at: https://github.com/teonet-go/teomq

Teonet messages queue

Kirill Scherba — Thu, 21 Mar 2024 07:29:41 +0000

The Teonet messages queue is a part of the Teonet network.

Basic teomq scheme

The Teonet messages queue contains three basic parts:

Teonet messages broker
Teonet messages consumer
Teonet messages producer

See more at: https://github.com/teonet-go/teomq

Golang multinode tree with parallel search

Kirill Scherba — Wed, 06 Sep 2023 09:10:26 +0000

Golang package tree is pure golang implementation of tree with any direction nodes. Each node in the tree can be connected to many children and has many parents.

In the implementation of this tree, parents are no different from children. The tree element contains references to branches without specifying whether it is a parent or a child.

Each node reference in an element contains a path cost that is taken into account when calculating the path from point A to point B. The path between points A and B calculates using threads (parallel) to minimize time of find all paths.

This tree has no root. Paths in a tree can be looped.

The tree elements can store any data structure. This structure is defined when the tree is created.

See the part of code to create Tree and it Elements:



t := tree.New[TreeData]("My first element")

// Create new tree elements (first element and end point element)
e := t.New("My first element")
ep := t.New("End point")

// Create children of e (first element) element
ch1, _ := e.Add(t.New("My first child"))
ch2, _ := e.Add(t.New("My second child"), tree.WayOptions{Cost: 3.0})
ch4, _ := e.Add(t.New("My fourth child"), tree.WayOptions{Cost: 3.0})

// Create sub children elements
ch3, _ := ch2.Add(t.New("Some third child"))
ch3.Add(ch4)

// Add children to ep (end point) element
ch1.Add(ch4)
ch2.Add(ep)
ch4.Add(ep)

// Set oneway path from ep (end point) to e (first element) element
ep.Add(e, tree.WayOptions{Cost: 5.0, Oneway: true})

// Print tree started from e (first element) element
fmt.Printf("\nPrint tree:\n%v\n\n", e)

The result of last printf:



. My first element
├── My first child, cost: 1.00
│   ├── My fourth child, cost: 1.00
│   │   ├── My first element, cost: 3.00 🡡
│   │   ├── Some third child, cost: 1.00
│   │   │   ├── My second child, cost: 1.00
│   │   │   │   ├── My first element, cost: 3.00 🡡
│   │   │   │   ├── Some third child, cost: 1.00 🡡
│   │   │   │   └── End point, cost: 1.00
│   │   │   │       ├── My second child, cost: 1.00 🡡
│   │   │   │       ├── My fourth child, cost: 1.00 🡡
│   │   │   │       └── My first element, cost: 5.00 (one way road) 🡡
│   │   │   └── My fourth child, cost: 1.00 🡡
│   │   ├── My first child, cost: 1.00 🡡
│   │   └── End point, cost: 1.00 🡡
│   └── My first element, cost: 1.00 🡡
├── My second child, cost: 3.00 🡡
├── My fourth child, cost: 3.00 🡡
└── End point, cost: 5.00 (way not allowed) 🡡

See the code and more descriptions and example at: https://github.com/kirill-scherba/tree

Connect to Tru peers using unix socket

Kirill Scherba — Tue, 22 Aug 2023 12:01:38 +0000

If you can't link the Tru package to your application than use this standalone unix socket server to communicate with any Tru peers.

The Unix socket Server created on golang and can run under Linux or Windows.

The Unix socket Cliens examples created on Go, C, C++ and build-in sample Visual Studio project.

See the part of C++ code to connect to the Unix socket Server:

int main(int argc, char *argv[]) {

  // Get unix socket path
  std::string socket_path = std::string("/tmp/trugw.sock");

  // Get tru peer address
  std::string tru_addr = ":7070";
  if (argc >= 2) {
    tru_addr = std::string(argv[1]);
  }

  std::cout << "Trugw C++ client, "
            << "sock path: " << socket_path << "tru peer: " << socket_path
            << std::endl;

  // Connect to teogw server
  std::cout << "trying to connect...\n";
  Trugw tgw(socket_path, tru_addr);
  if (!tgw.connected()) {
    std::cout << "can't connect\n";
    return 1;
  }
  std::cout << "connected \n";

  // Send messages
  for (int i = 0; i < 50000; i++) {
    std::string msg = "Hello " + std::to_string(i);
    std::cout << "send " << msg << std::endl;
    tgw.send(msg);

    uint8_t buf[1024];
    auto n = tgw.recv((const char *)buf, sizeof(buf), 0);
    std::string s((const char *)buf, n);
    std::cout << "receive " << s << std::endl;
  }

  return 0;
}

See the code and more descriptions and example at: https://github.com/teonet-go/trugw

Tru go net example

Kirill Scherba — Sun, 30 Apr 2023 11:35:17 +0000

New version of Tru (Teonet reliable UDP) golang package was releaset.

The Tru golang net module and example was added. This example is Client/Server application which transfer data using golang net standard functions.

https://github.com/teonet-go/tru

TeoS3 package and s3cp utility

Kirill Scherba — Fri, 04 Nov 2022 21:34:51 +0000

The TeoS3 package contains Golang features that make it easy to use S3 storage as a key-value database.

This project contain also the s3cp utility which copy files from disk to s3 storage and back.

https://github.com/teonet-go/teos3

There is a part of code with connect, set and get key value:

// Connect to S3 storage
con, err := teos3.Connect(accessKey, secretKey, endpoint, secure)
if err != nil {
    log.Fatalln(err)
}

// Set key to teos3 Map
err = con.Map.Set(key, data)
if err != nil {
    log.Fatalln(err)
}

// Get key from TeoS3 Map
data, err := con.Map.Get(key)
if err != nil {
    log.Fatalln(err)
}

See the code and more descriptions and example at: https://github.com/teonet-go/teos3

Teonet C library

Kirill Scherba — Wed, 08 Jun 2022 15:47:49 +0000

Teonet news.

Today we published Teonet v5 C library and examples project.

Teonet is designed to create client-server systems and build networks for server applications operating within a microservice architecture.

Main Teonet v5 code was created on Golang. This project make c/c++ dynamic library to use it in any C/C++ and C compatible applications.

The description of Teonet you can find at main Teonet-go page.

The examples of this project copy Teonet-go examples functional. So look this project examples to get started with teonet-c library: examples

See the project code and description on Github:
https://github.com/teonet-go/teonet-c

We are waiting your support! Please give stars to our Teonet-c and Teonet projects in Github.

Best regards,
Kirill Scherba
https://github.com/kirill-scherba

Tunnel between hosts without public IPs

Kirill Scherba — Sun, 05 Jun 2022 17:26:28 +0000

There is Teonet news.

The Teotun packet and application was published today by Teonet.

The Teotun creates secret tunnel between hosts without public IPs using Teonet. The connection based on TRU transport and create reliable, low latency, encrypted P2P channels between connected peers.

See the project code and description on Github:

https://github.com/teonet-go/teotun

We are waiting your support! Please give stars to our Teotun and Teonet projects in Github.

Best regards,
Kirill Scherba
https://github.com/kirill-scherba

Create secret tunnel using Go

Kirill Scherba — Mon, 30 May 2022 13:25:14 +0000

Trutun

Look at my new application Trutun.

It creates secret tunnel by IP address using Teonet TRU transport. TRU create reliable, low latency and encrypted channel between connected peers.

Star

The repository is available on Github:
https://github.com/teonet-go/trutun

Using a neural network in Go

Kirill Scherba — Wed, 25 May 2022 20:37:47 +0000

NNHelper is a Go package for creating and using a neural network

Summary

This article describes the work of the nnhelper package, designed to create and use neural networks in Go programs.

If you are already familiar with machine learning and use it in your work, then this article and the examples described in it may seem too simple for you. If you are at the beginning of your journey and want to get acquainted with this topic or would like to learn how to use the neural network in your Go programs, then you have come to the right place.

The nnhelper Go package is designed to quickly create a neural network and use it in the applications written in the Go language. To use nnhelper, you don't need anything else other than Go. The nnhelper package is an add-on to the gonn package. And this is the only one external dependency.

Neural network (neural matrix)

Let me try to explain in my own words what a neural network or neural matrix is, in order not to copy here complex and, perhaps, incomprehensible explanations from the initial reading.

A neural matrix is an array of floating point values that allows you to give the desired output values depending on the input values. The values known to us are fed to the input of the neural matrix, and the results we expect are given at the output.

Let's use the neural matrix to solve the problem "Two Minuses Make a Plus." To do this, we will make two tables: one with the input data, the other with the results.

We have two input parameters and two output parameters. The input is two numbers with a plus or minus sign. At the output we get two numbers with values from 0 to 1. If the first value is close to 1, then the result is Plus, if the second value is close to 1, then the result is Minus. That is, we give real values as input, and we get an array of results as output. Than we select the largest value from the array and consider it the answer.

Input data:              Results(plus, minus):
 1, 1  – plus * plus     1, 0 – plus
 1,-1  – plus * minus    0, 1 – minus
-1, 1  – minus* plus     0, 1 – minus
-1,-1  – minus* minus    1, 0 – plus

From the prepared tables with input and output data, a neural matrix is created by its training: The input data is fed to the inputs of the matrix. The matrix produces an output that is compared with the result from our results table. Based on these answers, the coefficients in the matrix change. The input data is looped through hundreds, thousands and even hundreds of thousands of iterations until the matrix answers are accurate enough.

Let's move on to programming

Enough words and theory. Let's see how it looks in practice.

Let's create a folder for the project. And create three files in it:

main.go 
sam03_inp.csv 
sam03_tar.csv

Let's place our input and output data in the *.csv files:

sam03_inp.csv

1,1
1,-1
-1,1
-1,-1

sam03_tar.csv

1,0
0,1
0,1
1,0

In the main.go file, create the main function and write the following code:

// Constants with filenames of our matrix and data
const (
    SAM03_NN  = "sam03.nn"
    SAM03_INP = "sam03_inp.csv"
    SAM03_TAR = "sam03_tar.csv"
)

// Human answers string array
humanAnswers := []string{"Plus", "Minus"}

// Create NN if it file does not exists
if _, err := os.Stat(SAM03_NN); errors.Is(err, os.ErrNotExist) {
        log.Println("Create", SAM03_NN, "neural network")
        nnhelper.Create(2, 4, 2, false, SAM03_INP, SAM03_TAR, SAM03_NN, true)
}

// Load neural matrix from file
nn := nnhelper.Load(SAM03_NN)

// Using / testing our neural network
const (
        PLUS  = 1.0
        MINUS = -1.0
    )

    // Intput array for testing
    in := [][]float64{
        {PLUS, PLUS},   // Plus * Plus = Plus
        {PLUS, MINUS},  // Plus * Minus = Minus
        {MINUS, PLUS},  // Minus * Plus = Minus
        {MINUS, MINUS}, // Minus * Minus = Plus
        {3000, -0.001}, // Minus * Plus = Minus
    }
    for i := range in {
        out := nn.Answer(in[i]...)
        answer, _ := nn.AnswerToHuman(out, humanAnswers)
        fmt.Println(in[i], answer, out)
    }
}

The full text of this example and the data files are located in examples/sam03

Let's run the example:

go run .

And we get the results:

[1 1] Plus [0.9944239772210877 0.005449692189449571]
[1 -1] Minus [0.006860785779850435 0.9935960167863507]
[-1 1] Minus [0.005651009980489101 0.994384581174021]
[-1 -1] Plus [0.9944591181959666 0.005221796400203198]
[3000 -0.001] Minus [0.005445102841471242 0.9960123783099599]

In the results we see (see the first line):

our original data: [1,1]
result translated into understandable form: Plus
result obtained from matrix outputs: [0.9944239772210877 0.005449692189449571]

Pay attention to the last line of the results. Our matrix was able to give the correct answer to the "unknown" inputs. This is the whole taste of neural networks. The matrix gives answers not only to the input data that it was trained on, but also to other input parameters unknown to it.

To see the training process of the neural network, you need to delete the sam03.nn file and run the example again.

Well, I guess I'll wrap it up here. For a long time I dreamed of writing a clear and simple explanation of how neural networks can be used in programming. I hope I succeeded.

There are two more examples in the package:

sam02: Input the time in 24-hour format and get the answer: Morning, Evening, Day or Night;
sam01: An example of a matrix for getting the reaction of a game bot. The input is the amount of health, the presence of weapons, the number of enemies, and at the output we get the answer to the question “what to do”: attack, sneak, run away or do nothing.

The package is hosted on Github:
https://github.com/kirill-scherba/nnhelper

Best regards,
Kirill Scherba

DEV Community: Kirill Scherba

Why I Built a Go SQL Helper

The Problem: Go + SQL = Death by a Thousand rows.Scans

The Pain Points

Existing Solutions: sqlx, GORM, and the Missing Middle

sqlx: Better, But Still Manual

GORM: Full ORM, Full Magic

sqlh: The Sweet Spot

How sqlh Works: Struct Tags as Single Source of Truth

Architecture

Key Design Decisions

CRUD in 50 Lines: The Quick Start

Side-by-Side Comparison

Benchmarks: The Numbers

CRUD Throughput (ops/sec)

Memory Allocations (bytes/op, allocs/op)

What the Numbers Tell Us

When to Use sqlh

Getting Started

What’s Next

Ordered map

Introduction to the omap Go Package

What is omap?

Key Features of omap

Using omap

Conclusion

Example Use Cases

Teonet messages queue

Basic teomq scheme

Teonet messages queue

Basic teomq scheme

Golang multinode tree with parallel search

Connect to Tru peers using unix socket

Tru go net example

TeoS3 package and s3cp utility

Teonet C library

Tunnel between hosts without public IPs

Create secret tunnel using Go

Trutun

Using a neural network in Go

NNHelper is a Go package for creating and using a neural network

Summary

Neural network (neural matrix)

Let's move on to programming

The Problem: Go + SQL = Death by a Thousand `rows.Scan`s