sqlutil

A powerful and flexible collection of Go helpers for database operations. sqlutil simplifies common database tasks with a clean, chainable API that works with PostgreSQL, MySQL, and SQLite.

Features

Clean, intuitive API for CRUD operations
Support for multiple SQL flavors (PostgreSQL, MySQL, SQLite)
Flexible filtering with comparison operators (=, <>, >, <, >=, <=, LIKE, IN, NOT IN)
Pagination and ordering support
Field selection to retrieve only needed columns
Row locking support (FOR UPDATE)
Works with *sql.DB, *sql.Conn, and *sql.Tx
Built on top of sqlquery and scany

Installation

go get github.com/allisson/sqlutil

Quick Start

package main

import (
	"context"
	"database/sql"
	"fmt"
	"log"

	"github.com/allisson/sqlutil"
	_ "github.com/lib/pq"
)

type User struct {
	ID    int    `db:"id"`
	Name  string `db:"name" fieldtag:"insert,update"`
	Email string `db:"email" fieldtag:"insert,update"`
	Age   int    `db:"age" fieldtag:"insert,update"`
}

func main() {
	// Connect to database
	db, err := sql.Open("postgres", "postgres://user:password@localhost/mydb?sslmode=disable")
	if err != nil {
		log.Fatal(err)
	}
	defer db.Close()

	ctx := context.Background()
	flavor := sqlutil.PostgreSQLFlavor

	// Insert a user
	user := User{Name: "Alice", Email: "alice@example.com", Age: 30}
	if err := sqlutil.Insert(ctx, db, flavor, "insert", "users", &user); err != nil {
		log.Fatal(err)
	}

	// Get a user
	var alice User
	opts := sqlutil.NewFindOptions(flavor).WithFilter("email", "alice@example.com")
	if err := sqlutil.Get(ctx, db, "users", opts, &alice); err != nil {
		log.Fatal(err)
	}
	fmt.Printf("Found user: %+v\n", alice)

	// Update the user
	alice.Age = 31
	if err := sqlutil.Update(ctx, db, flavor, "update", "users", alice.ID, &alice); err != nil {
		log.Fatal(err)
	}

	// Delete the user
	if err := sqlutil.Delete(ctx, db, flavor, "users", alice.ID); err != nil {
		log.Fatal(err)
	}
}

Database Setup

For the examples below, we'll use this table structure:

CREATE TABLE users (
	id SERIAL PRIMARY KEY,
	name VARCHAR(255) NOT NULL,
	email VARCHAR(255) UNIQUE NOT NULL,
	age INTEGER NOT NULL,
	country VARCHAR(100),
	active BOOLEAN DEFAULT true,
	created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

Run a PostgreSQL database with Docker:

docker run --name sqlutil-postgres \
	-e POSTGRES_USER=user \
	-e POSTGRES_PASSWORD=password \
	-e POSTGRES_DB=sqlutil \
	-p 5432:5432 \
	-d postgres:14-alpine

Basic CRUD Operations

Insert

Insert a single record into the database:

package main

import (
	"context"
	"database/sql"
	"log"

	"github.com/allisson/sqlutil"
	_ "github.com/lib/pq"
)

type User struct {
	ID        int    `db:"id"`
	Name      string `db:"name" fieldtag:"insert,update"`
	Email     string `db:"email" fieldtag:"insert,update"`
	Age       int    `db:"age" fieldtag:"insert,update"`
	Country   string `db:"country" fieldtag:"insert,update"`
	Active    bool   `db:"active" fieldtag:"insert,update"`
}

func main() {
	db, _ := sql.Open("postgres", "postgres://user:password@localhost/sqlutil?sslmode=disable")
	defer db.Close()

	ctx := context.Background()
	flavor := sqlutil.PostgreSQLFlavor

	// Insert a new user
	newUser := User{
		Name:    "Bob Smith",
		Email:   "bob@example.com",
		Age:     28,
		Country: "USA",
		Active:  true,
	}

	// The "insert" tag tells sqlutil to use fields marked with fieldtag:"insert"
	if err := sqlutil.Insert(ctx, db, flavor, "insert", "users", &newUser); err != nil {
		log.Fatal(err)
	}

	log.Println("User inserted successfully")
}

Get (Single Record)

Retrieve a single record from the database:

// Get user by ID
var user User
opts := sqlutil.NewFindOptions(flavor).WithFilter("id", 1)
if err := sqlutil.Get(ctx, db, "users", opts, &user); err != nil {
	log.Fatal(err)
}
fmt.Printf("User: %+v\n", user)

// Get user by email
var userByEmail User
opts = sqlutil.NewFindOptions(flavor).WithFilter("email", "bob@example.com")
if err := sqlutil.Get(ctx, db, "users", opts, &userByEmail); err != nil {
	log.Fatal(err)
}

// Get user with specific fields only
var partialUser struct {
	ID    int    `db:"id"`
	Name  string `db:"name"`
	Email string `db:"email"`
}
opts = sqlutil.NewFindOptions(flavor).
	WithFields([]string{"id", "name", "email"}).
	WithFilter("id", 1)
if err := sqlutil.Get(ctx, db, "users", opts, &partialUser); err != nil {
	log.Fatal(err)
}

Select (Multiple Records)

Retrieve multiple records from the database:

// Get all users
var users []User
opts := sqlutil.NewFindAllOptions(flavor)
if err := sqlutil.Select(ctx, db, "users", opts, &users); err != nil {
	log.Fatal(err)
}
fmt.Printf("Found %d users\n", len(users))

// Get active users only
var activeUsers []User
opts = sqlutil.NewFindAllOptions(flavor).WithFilter("active", true)
if err := sqlutil.Select(ctx, db, "users", opts, &activeUsers); err != nil {
	log.Fatal(err)
}

// Get users with pagination
var pagedUsers []User
opts = sqlutil.NewFindAllOptions(flavor).
	WithLimit(10).
	WithOffset(0).
	WithOrderBy("created_at DESC")
if err := sqlutil.Select(ctx, db, "users", opts, &pagedUsers); err != nil {
	log.Fatal(err)
}

Update

Update existing records:

// Update user by ID
user := User{
	ID:      1,
	Name:    "Bob Smith Jr.",
	Email:   "bob.jr@example.com",
	Age:     29,
	Country: "USA",
	Active:  true,
}

// The "update" tag tells sqlutil to use fields marked with fieldtag:"update"
if err := sqlutil.Update(ctx, db, flavor, "update", "users", user.ID, &user); err != nil {
	log.Fatal(err)
}

// Update with custom options (more flexible)
updateOpts := sqlutil.NewUpdateOptions(flavor).
	WithSet("age", 30).
	WithSet("country", "Canada").
	WithFilter("id", 1)

if err := sqlutil.UpdateWithOptions(ctx, db, flavor, "users", updateOpts); err != nil {
	log.Fatal(err)
}

// Bulk update - update all inactive users
updateOpts = sqlutil.NewUpdateOptions(flavor).
	WithSet("active", false).
	WithFilter("age.lt", 18)

if err := sqlutil.UpdateWithOptions(ctx, db, flavor, "users", updateOpts); err != nil {
	log.Fatal(err)
}

Delete

Delete records from the database:

// Delete user by ID
if err := sqlutil.Delete(ctx, db, flavor, "users", 1); err != nil {
	log.Fatal(err)
}

// Delete with custom options (more flexible)
deleteOpts := sqlutil.NewDeleteOptions(flavor).WithFilter("active", false)
if err := sqlutil.DeleteWithOptions(ctx, db, flavor, "users", deleteOpts); err != nil {
	log.Fatal(err)
}

// Delete users older than 65
deleteOpts = sqlutil.NewDeleteOptions(flavor).WithFilter("age.gt", 65)
if err := sqlutil.DeleteWithOptions(ctx, db, flavor, "users", deleteOpts); err != nil {
	log.Fatal(err)
}

// Delete users from specific country
deleteOpts = sqlutil.NewDeleteOptions(flavor).WithFilter("country", "USA")
if err := sqlutil.DeleteWithOptions(ctx, db, flavor, "users", deleteOpts); err != nil {
	log.Fatal(err)
}

Advanced Queries

Filtering

sqlutil supports a wide range of filter operators:

ctx := context.Background()
flavor := sqlutil.PostgreSQLFlavor

// Equality
opts := sqlutil.NewFindAllOptions(flavor).WithFilter("age", 30)
// WHERE age = 30

// Not equal
opts = sqlutil.NewFindAllOptions(flavor).WithFilter("age.not", 30)
// WHERE age <> 30

// Greater than
opts = sqlutil.NewFindAllOptions(flavor).WithFilter("age.gt", 18)
// WHERE age > 18

// Greater than or equal
opts = sqlutil.NewFindAllOptions(flavor).WithFilter("age.gte", 18)
// WHERE age >= 18

// Less than
opts = sqlutil.NewFindAllOptions(flavor).WithFilter("age.lt", 65)
// WHERE age < 65

// Less than or equal
opts = sqlutil.NewFindAllOptions(flavor).WithFilter("age.lte", 65)
// WHERE age <= 65

// LIKE operator
opts = sqlutil.NewFindAllOptions(flavor).WithFilter("name.like", "%Smith%")
// WHERE name LIKE '%Smith%'

// IN operator
opts = sqlutil.NewFindAllOptions(flavor).WithFilter("country.in", "USA,Canada,Mexico")
// WHERE country IN ('USA', 'Canada', 'Mexico')

// NOT IN operator
opts = sqlutil.NewFindAllOptions(flavor).WithFilter("country.notin", "USA,Canada")
// WHERE country NOT IN ('USA', 'Canada')

// IS NULL
opts = sqlutil.NewFindAllOptions(flavor).WithFilter("country.null", true)
// WHERE country IS NULL

// IS NOT NULL
opts = sqlutil.NewFindAllOptions(flavor).WithFilter("country.null", false)
// WHERE country IS NOT NULL

// Multiple filters (AND condition)
opts = sqlutil.NewFindAllOptions(flavor).
	WithFilter("age.gte", 18).
	WithFilter("age.lte", 65).
	WithFilter("active", true).
	WithFilter("country", "USA")
// WHERE age >= 18 AND age <= 65 AND active = true AND country = 'USA'

// Complex example: Find active users aged 25-40 from specific countries
var users []User
opts = sqlutil.NewFindAllOptions(flavor).
	WithFilter("active", true).
	WithFilter("age.gte", 25).
	WithFilter("age.lte", 40).
	WithFilter("country.in", "USA,Canada,UK")

if err := sqlutil.Select(ctx, db, "users", opts, &users); err != nil {
	log.Fatal(err)
}

Field Selection

Retrieve only the fields you need:

// Define a struct with only the fields you need
type UserBasic struct {
	ID    int    `db:"id"`
	Name  string `db:"name"`
	Email string `db:"email"`
}

// Select only specific fields
var users []UserBasic
opts := sqlutil.NewFindAllOptions(flavor).
	WithFields([]string{"id", "name", "email"}).
	WithFilter("active", true)

if err := sqlutil.Select(ctx, db, "users", opts, &users); err != nil {
	log.Fatal(err)
}
// SELECT id, name, email FROM users WHERE active = true

// Get single user with limited fields
var userBasic UserBasic
opts := sqlutil.NewFindOptions(flavor).
	WithFields([]string{"id", "name", "email"}).
	WithFilter("id", 1)

if err := sqlutil.Get(ctx, db, "users", opts, &userBasic); err != nil {
	log.Fatal(err)
}

Pagination

Implement pagination for large result sets:

// Page 1: First 10 users
var page1 []User
opts := sqlutil.NewFindAllOptions(flavor).
	WithLimit(10).
	WithOffset(0).
	WithOrderBy("id ASC")

if err := sqlutil.Select(ctx, db, "users", opts, &page1); err != nil {
	log.Fatal(err)
}

// Page 2: Next 10 users
var page2 []User
opts = sqlutil.NewFindAllOptions(flavor).
	WithLimit(10).
	WithOffset(10).
	WithOrderBy("id ASC")

if err := sqlutil.Select(ctx, db, "users", opts, &page2); err != nil {
	log.Fatal(err)
}

// Pagination helper function
func GetUserPage(ctx context.Context, db *sql.DB, page, pageSize int) ([]User, error) {
	var users []User
	offset := (page - 1) * pageSize
	
	opts := sqlutil.NewFindAllOptions(flavor).
		WithLimit(pageSize).
		WithOffset(offset).
		WithOrderBy("id ASC")
	
	err := sqlutil.Select(ctx, db, "users", opts, &users)
	return users, err
}

// Usage
page1Users, err := GetUserPage(ctx, db, 1, 20) // First page, 20 items
page2Users, err := GetUserPage(ctx, db, 2, 20) // Second page, 20 items

Ordering

Sort results by one or multiple columns:

// Order by single column ascending
opts := sqlutil.NewFindAllOptions(flavor).WithOrderBy("name ASC")

// Order by single column descending
opts = sqlutil.NewFindAllOptions(flavor).WithOrderBy("created_at DESC")

// Order by multiple columns
opts = sqlutil.NewFindAllOptions(flavor).WithOrderBy("country ASC, age DESC")

// Complex example: Get top 10 youngest active users from USA
var youngUsers []User
opts = sqlutil.NewFindAllOptions(flavor).
	WithFilter("active", true).
	WithFilter("country", "USA").
	WithOrderBy("age ASC").
	WithLimit(10)

if err := sqlutil.Select(ctx, db, "users", opts, &youngUsers); err != nil {
	log.Fatal(err)
}

Row Locking

Use row locking for concurrent operations:

// FOR UPDATE - locks rows for update
opts := sqlutil.NewFindAllOptions(flavor).
	WithFilter("active", true).
	WithForUpdate("")

// FOR UPDATE SKIP LOCKED - skip rows that are already locked
opts = sqlutil.NewFindAllOptions(flavor).
	WithFilter("active", true).
	WithForUpdate("SKIP LOCKED")

// FOR UPDATE NOWAIT - return immediately if rows are locked
opts = sqlutil.NewFindAllOptions(flavor).
	WithFilter("active", true).
	WithForUpdate("NOWAIT")

// Example: Process queue items with row locking
tx, err := db.BeginTx(ctx, nil)
if err != nil {
	log.Fatal(err)
}
defer tx.Rollback()

var queueItems []QueueItem
opts := sqlutil.NewFindAllOptions(flavor).
	WithFilter("status", "pending").
	WithOrderBy("created_at ASC").
	WithLimit(10).
	WithForUpdate("SKIP LOCKED")

if err := sqlutil.Select(ctx, tx, "queue", opts, &queueItems); err != nil {
	log.Fatal(err)
}

// Process items...
for _, item := range queueItems {
	// Process item
	updateOpts := sqlutil.NewUpdateOptions(flavor).
		WithSet("status", "processed").
		WithFilter("id", item.ID)
	
	if err := sqlutil.UpdateWithOptions(ctx, tx, flavor, "queue", updateOpts); err != nil {
		log.Fatal(err)
	}
}

tx.Commit()

Bulk Operations

Efficiently handle multiple operations:

// Insert multiple users
users := []User{
	{Name: "Alice", Email: "alice@example.com", Age: 30, Country: "USA"},
	{Name: "Bob", Email: "bob@example.com", Age: 25, Country: "Canada"},
	{Name: "Charlie", Email: "charlie@example.com", Age: 35, Country: "UK"},
}

for _, user := range users {
	if err := sqlutil.Insert(ctx, db, flavor, "insert", "users", &user); err != nil {
		log.Fatal(err)
	}
}

// Bulk update with filter
updateOpts := sqlutil.NewUpdateOptions(flavor).
	WithSet("active", false).
	WithFilter("country.in", "USA,Canada,Mexico")

if err := sqlutil.UpdateWithOptions(ctx, db, flavor, "users", updateOpts); err != nil {
	log.Fatal(err)
}

// Bulk delete with filter
deleteOpts := sqlutil.NewDeleteOptions(flavor).
	WithFilter("active", false).
	WithFilter("age.lt", 18)

if err := sqlutil.DeleteWithOptions(ctx, db, flavor, "users", deleteOpts); err != nil {
	log.Fatal(err)
}

Using with Transactions

sqlutil works seamlessly with database transactions:

// Start a transaction
tx, err := db.BeginTx(ctx, nil)
if err != nil {
	log.Fatal(err)
}
defer tx.Rollback() // Rollback if not committed

// Insert user
user := User{Name: "David", Email: "david@example.com", Age: 40, Country: "France"}
if err := sqlutil.Insert(ctx, tx, flavor, "insert", "users", &user); err != nil {
	log.Fatal(err)
}

// Get the inserted user
var insertedUser User
opts := sqlutil.NewFindOptions(flavor).WithFilter("email", "david@example.com")
if err := sqlutil.Get(ctx, tx, "users", opts, &insertedUser); err != nil {
	log.Fatal(err)
}

// Update the user
insertedUser.Age = 41
if err := sqlutil.Update(ctx, tx, flavor, "update", "users", insertedUser.ID, &insertedUser); err != nil {
	log.Fatal(err)
}

// Commit the transaction
if err := tx.Commit(); err != nil {
	log.Fatal(err)
}

// Example: Transfer operation with rollback
func TransferUser(ctx context.Context, db *sql.DB, userID int, newCountry string) error {
	tx, err := db.BeginTx(ctx, nil)
	if err != nil {
		return err
	}
	defer tx.Rollback()

	// Get user
	var user User
	opts := sqlutil.NewFindOptions(flavor).WithFilter("id", userID)
	if err := sqlutil.Get(ctx, tx, "users", opts, &user); err != nil {
		return err
	}

	// Update country
	updateOpts := sqlutil.NewUpdateOptions(flavor).
		WithSet("country", newCountry).
		WithFilter("id", userID)
	
	if err := sqlutil.UpdateWithOptions(ctx, tx, flavor, "users", updateOpts); err != nil {
		return err
	}

	// Commit transaction
	return tx.Commit()
}

Multiple SQL Flavors

sqlutil supports PostgreSQL, MySQL, and SQLite:

PostgreSQL

import (
	"github.com/allisson/sqlutil"
	_ "github.com/lib/pq"
)

db, _ := sql.Open("postgres", "postgres://user:password@localhost/mydb?sslmode=disable")
flavor := sqlutil.PostgreSQLFlavor

opts := sqlutil.NewFindOptions(flavor).WithFilter("id", 1)

MySQL

import (
	"github.com/allisson/sqlutil"
	_ "github.com/go-sql-driver/mysql"
)

db, _ := sql.Open("mysql", "user:password@tcp(localhost:3306)/mydb")
flavor := sqlutil.MySQLFlavor

opts := sqlutil.NewFindOptions(flavor).WithFilter("id", 1)

SQLite

import (
	"github.com/allisson/sqlutil"
	_ "github.com/mattn/go-sqlite3"
)

db, _ := sql.Open("sqlite3", "./mydb.db")
flavor := sqlutil.SQLiteFlavor

opts := sqlutil.NewFindOptions(flavor).WithFilter("id", 1)

Cross-Database Compatibility

Write database-agnostic code by passing the flavor as a parameter:

type UserRepository struct {
	db     *sql.DB
	flavor sqlutil.Flavor
}

func NewUserRepository(db *sql.DB, flavor sqlutil.Flavor) *UserRepository {
	return &UserRepository{db: db, flavor: flavor}
}

func (r *UserRepository) GetByID(ctx context.Context, id int) (*User, error) {
	var user User
	opts := sqlutil.NewFindOptions(r.flavor).WithFilter("id", id)
	err := sqlutil.Get(ctx, r.db, "users", opts, &user)
	return &user, err
}

func (r *UserRepository) GetActiveUsers(ctx context.Context) ([]User, error) {
	var users []User
	opts := sqlutil.NewFindAllOptions(r.flavor).
		WithFilter("active", true).
		WithOrderBy("name ASC")
	err := sqlutil.Select(ctx, r.db, "users", opts, &users)
	return users, err
}

// Works with any database flavor
pgRepo := NewUserRepository(pgDB, sqlutil.PostgreSQLFlavor)
mysqlRepo := NewUserRepository(mysqlDB, sqlutil.MySQLFlavor)
sqliteRepo := NewUserRepository(sqliteDB, sqlutil.SQLiteFlavor)

Complete Example

Here's a complete example demonstrating various features:

package main

import (
	"context"
	"database/sql"
	"fmt"
	"log"

	"github.com/allisson/sqlutil"
	_ "github.com/lib/pq"
)

type User struct {
	ID        int    `db:"id"`
	Name      string `db:"name" fieldtag:"insert,update"`
	Email     string `db:"email" fieldtag:"insert,update"`
	Age       int    `db:"age" fieldtag:"insert,update"`
	Country   string `db:"country" fieldtag:"insert,update"`
	Active    bool   `db:"active" fieldtag:"insert,update"`
}

func main() {
	// Connect to database
	db, err := sql.Open("postgres", "postgres://user:password@localhost/sqlutil?sslmode=disable")
	if err != nil {
		log.Fatal(err)
	}
	defer db.Close()

	ctx := context.Background()
	flavor := sqlutil.PostgreSQLFlavor

	// Create table
	_, err = db.ExecContext(ctx, `
		CREATE TABLE IF NOT EXISTS users (
			id SERIAL PRIMARY KEY,
			name VARCHAR(255) NOT NULL,
			email VARCHAR(255) UNIQUE NOT NULL,
			age INTEGER NOT NULL,
			country VARCHAR(100),
			active BOOLEAN DEFAULT true
		)
	`)
	if err != nil {
		log.Fatal(err)
	}

	// Insert users
	users := []User{
		{Name: "Alice Johnson", Email: "alice@example.com", Age: 30, Country: "USA", Active: true},
		{Name: "Bob Smith", Email: "bob@example.com", Age: 25, Country: "Canada", Active: true},
		{Name: "Charlie Brown", Email: "charlie@example.com", Age: 35, Country: "UK", Active: true},
		{Name: "David Lee", Email: "david@example.com", Age: 28, Country: "USA", Active: false},
	}

	for _, user := range users {
		if err := sqlutil.Insert(ctx, db, flavor, "insert", "users", &user); err != nil {
			log.Printf("Error inserting user: %v", err)
		}
	}

	// Get single user by email
	var alice User
	opts := sqlutil.NewFindOptions(flavor).WithFilter("email", "alice@example.com")
	if err := sqlutil.Get(ctx, db, "users", opts, &alice); err != nil {
		log.Fatal(err)
	}
	fmt.Printf("Found user: %+v\n", alice)

	// Get all active users from USA
	var activeUSAUsers []User
	opts2 := sqlutil.NewFindAllOptions(flavor).
		WithFilter("active", true).
		WithFilter("country", "USA").
		WithOrderBy("name ASC")
	
	if err := sqlutil.Select(ctx, db, "users", opts2, &activeUSAUsers); err != nil {
		log.Fatal(err)
	}
	fmt.Printf("Active USA users: %d\n", len(activeUSAUsers))

	// Get users with age between 25 and 30
	var youngUsers []User
	opts3 := sqlutil.NewFindAllOptions(flavor).
		WithFilter("age.gte", 25).
		WithFilter("age.lte", 30).
		WithOrderBy("age ASC")
	
	if err := sqlutil.Select(ctx, db, "users", opts3, &youngUsers); err != nil {
		log.Fatal(err)
	}
	fmt.Printf("Users aged 25-30: %d\n", len(youngUsers))

	// Update user
	alice.Age = 31
	alice.Country = "Canada"
	if err := sqlutil.Update(ctx, db, flavor, "update", "users", alice.ID, &alice); err != nil {
		log.Fatal(err)
	}

	// Bulk update: deactivate all users older than 30
	updateOpts := sqlutil.NewUpdateOptions(flavor).
		WithSet("active", false).
		WithFilter("age.gt", 30)
	
	if err := sqlutil.UpdateWithOptions(ctx, db, flavor, "users", updateOpts); err != nil {
		log.Fatal(err)
	}

	// Get users with pagination
	page1 := []User{}
	paginationOpts := sqlutil.NewFindAllOptions(flavor).
		WithLimit(2).
		WithOffset(0).
		WithOrderBy("name ASC")
	
	if err := sqlutil.Select(ctx, db, "users", paginationOpts, &page1); err != nil {
		log.Fatal(err)
	}
	fmt.Printf("Page 1: %d users\n", len(page1))

	// Delete inactive users
	deleteOpts := sqlutil.NewDeleteOptions(flavor).WithFilter("active", false)
	if err := sqlutil.DeleteWithOptions(ctx, db, flavor, "users", deleteOpts); err != nil {
		log.Fatal(err)
	}
	fmt.Println("Inactive users deleted")
}

License

This project is licensed under the MIT License - see the LICENSE file for details.

Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

Related Projects

sqlquery - SQL query builder for Go
scany - Library for scanning data from a database into Go structs

Name		Name	Last commit message	Last commit date
Latest commit History 30 Commits
.github/workflows		.github/workflows
script		script
.gitignore		.gitignore
.golangci.yml		.golangci.yml
CHANGELOG.md		CHANGELOG.md
LICENSE		LICENSE
README.md		README.md
go.mod		go.mod
go.sum		go.sum
helper.go		helper.go
helper_test.go		helper_test.go
version.txt		version.txt

License

allisson/sqlutil

Folders and files

Latest commit

History

Repository files navigation

sqlutil

Features

Installation

Table of Contents

Quick Start

Database Setup

Basic CRUD Operations

Insert

Get (Single Record)

Select (Multiple Records)

Update

Delete

Advanced Queries

Filtering

Field Selection

Pagination

Ordering

Row Locking

Bulk Operations

Using with Transactions

Multiple SQL Flavors

PostgreSQL

MySQL

SQLite

Cross-Database Compatibility

Complete Example

License

Contributing

Related Projects

About

Resources

License

Uh oh!

Stars

Watchers

Forks

Releases 14

Packages 0

Uh oh!

Contributors 2

Uh oh!

Languages

Packages