fluentsql

package module
v0.0.0-...-67d1e51 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Dec 1, 2025 License: MIT Imports: 9 Imported by: 0

README

go-fluent-sql

Go Version License Go Report Card codecov GoDoc

A fluent, type-safe SQL query builder for Go with Laravel-inspired syntax.

Features

  • 🔗 Fluent API - Chain methods for readable queries
  • 🛡️ SQL Injection Protection - Prepared statements & identifier validation
  • 🎯 Type Safety - Compile-time checks where possible
  • 🚀 High Performance - Minimal allocations, cached reflection
  • 🔌 Multi-Database - MySQL, PostgreSQL (coming soon)
  • 📦 Zero Config - Works out of the box
  • 🧪 Well Tested - Comprehensive test coverage

Installation

go get github.com/biyonik/go-fluent-sql

Quick Start

package main

import (
    "context"
    "log"
    
    fluentsql "github.com/biyonik/go-fluent-sql"
)

func main() {
    // Connect to database
    db, err := fluentsql.Connect("user:password@tcp(localhost:3306)/dbname")
    if err != nil {
        log.Fatal(err)
    }
    defer db.Close()

    // Create query builder
    qb := fluentsql.New(db)

    // Select query
    var users []User
    err = qb.Table("users").
        Select("id", "name", "email").
        Where("status", "=", "active").
        WhereIn("role", []interface{}{"admin", "moderator"}).
        OrderBy("created_at", "DESC").
        Limit(10).
        Get(&users)

    // Insert
    result, err := qb.Table("users").Insert(map[string]interface{}{
        "name":  "John Doe",
        "email": "john@example.com",
    })

    // Update
    result, err = qb.Table("users").
        Where("id", "=", 1).
        Update(map[string]interface{}{
            "status": "inactive",
        })

    // Delete
    result, err = qb.Table("users").
        Where("status", "=", "banned").
        Delete()
}

type User struct {
    ID    int    `db:"id"`
    Name  string `db:"name"`
    Email string `db:"email"`
}

Documentation

📚 Full Documentation

Query Building
// Basic WHERE
qb.Where("column", "=", value)
qb.OrWhere("column", "!=", value)

// WHERE IN
qb.WhereIn("status", []interface{}{"active", "pending"})
qb.WhereNotIn("role", []interface{}{"banned"})

// WHERE BETWEEN
qb.WhereBetween("age", 18, 65)
qb.WhereNotBetween("score", 0, 50)

// WHERE NULL
qb.WhereNull("deleted_at")
qb.WhereNotNull("email_verified_at")

// Date queries
qb.WhereDate("created_at", "2024-01-15")
qb.WhereYear("created_at", 2024)
qb.WhereMonth("created_at", 12)

// Ordering
qb.OrderBy("created_at", "DESC")

// Pagination
qb.Limit(10).Offset(20)
Transactions
tx, err := fluentsql.BeginTransaction(db)
if err != nil {
    return err
}

// Use transaction
err = tx.Table("users").Where("id", "=", 1).Update(data)
if err != nil {
    tx.Rollback()
    return err
}

err = tx.Table("logs").Insert(logData)
if err != nil {
    tx.Rollback()
    return err
}

return tx.Commit()
Migrations
migrator := migration.NewMigrator(db, migration.NewMySQLGrammar())

err := migrator.CreateTable("users", func(t *migration.Blueprint) {
    t.ID()
    t.String("name", 255)
    t.String("email", 255).Unique()
    t.String("password", 255)
    t.Timestamps()
    t.SoftDeletes()
})

Benchmarks

BenchmarkSelect-8         500000    2340 ns/op    1024 B/op    15 allocs/op
BenchmarkWhere-8          800000    1456 ns/op     512 B/op     8 allocs/op
BenchmarkInsert-8         600000    1892 ns/op     768 B/op    12 allocs/op

Contributing

Contributions are welcome! Please read our Contributing Guide first.

# Clone the repo
git clone https://github.com/biyonik/go-fluent-sql.git

# Install dependencies
make deps

# Run tests
make test

# Run linter
make lint

License

MIT License - see LICENSE for details.

Acknowledgments

Inspired by Laravel's Eloquent and Query Builder.

Documentation

Overview

Package fluentsql provides a fluent SQL query builder for Go.

go-fluent-sql offers a Laravel-inspired API for building SQL queries with built-in protection against SQL injection attacks.

Quick Start

Connect to a database and start building queries: 

db, err := fluentsql.Connect("user:pass@tcp(localhost:3306)/dbname")
if err != nil {
    log.Fatal(err)
}
defer db.Close()

qb := fluentsql.New(db)

Select Queries

Build SELECT queries using the fluent API: 

var users []User
err := qb.Table("users").
    Select("id", "name", "email").
    Where("status", "=", "active").
    OrderBy("created_at", "DESC").
    Limit(10).
    Get(&users)

Where Clauses

Multiple WHERE methods are available: 

qb.Where("age", ">", 18)
qb.OrWhere("role", "=", "admin")
qb.WhereIn("status", []interface{}{"active", "pending"})
qb.WhereBetween("created_at", startDate, endDate)
qb.WhereNull("deleted_at")

Insert, Update, Delete

Execute write operations: 

// Insert
result, err := qb.Table("users").Insert(map[string]interface{}{
    "name": "John",
    "email": "john@example.com",
})

// Update
result, err := qb.Table("users").
    Where("id", "=", 1).
    Update(map[string]interface{}{"status": "inactive"})

// Delete
result, err := qb.Table("users").
    Where("status", "=", "banned").
    Delete()

Transactions

Use transactions for atomic operations: 

tx, err := fluentsql.BeginTransaction(db)
if err != nil {
    return err
}

if err := tx.Table("accounts").Where("id", "=", 1).Update(debit); err != nil {
    tx.Rollback()
    return err
}

if err := tx.Table("accounts").Where("id", "=", 2).Update(credit); err != nil {
    tx.Rollback()
    return err
}

return tx.Commit()

Security

go-fluent-sql protects against SQL injection through:

  • Prepared statements for all values
  • Identifier validation (table/column names)
  • Operator whitelisting

Thread Safety

QueryBuilder instances are NOT thread-safe. Create a new instance for each goroutine or query.

Supported Databases

  • MySQL / MariaDB
  • PostgreSQL (coming soon)
  • SQLite (coming soon)

Package fluentsql, Go dilinde akıcı SQL sorguları oluşturmayı ve yönetmeyi sağlayan bir kütüphanedir. Bu paket, hem bağlantılı hem de bağlantısız sorgu oluşturmayı destekler, raw SQL ifadelerini güvenli biçimde kullanmayı sağlar ve çeşitli konfigürasyon seçenekleri sunar.

Yazar: Ahmet ALTUN Github: github.com/biyonik LinkedIn: linkedin.com/in/biyonik Email: ahmet.altun60@gmail.com

Index

Constants

View Source 
const Version = "0.1.0-alpha"

Version, go-fluent-sql kütüphanesinin mevcut sürümünü belirtir.

Variables

View Source 
var (
	// ErrNoRows is returned when a query returns no rows.
	ErrNoRows = errors.New("fluentsql: no rows in result set")

	// ErrNoTable is returned when no table is specified.
	ErrNoTable = errors.New("fluentsql: no table specified")

	// ErrNoColumns is returned when no columns are specified for insert/update.
	ErrNoColumns = errors.New("fluentsql: no columns specified")

	// ErrNoExecutor is returned when no database executor is set.
	ErrNoExecutor = errors.New("fluentsql: no database executor")

	// ErrInvalidIdentifier is returned for invalid SQL identifiers.
	ErrInvalidIdentifier = errors.New("fluentsql: invalid identifier")

	// ErrInvalidOperator is returned for disallowed operators.
	ErrInvalidOperator = errors.New("fluentsql: invalid operator")

	// ErrInvalidValue is returned for invalid values.
	ErrInvalidValue = errors.New("fluentsql: invalid value")

	// ErrNotAPointer is returned when dest is not a pointer.
	ErrNotAPointer = errors.New("fluentsql: destination must be a pointer")

	// ErrNotASlice is returned when dest is not a slice.
	ErrNotASlice = errors.New("fluentsql: destination must be a slice")

	// ErrNotAStruct is returned when dest element is not a struct.
	ErrNotAStruct = errors.New("fluentsql: destination element must be a struct")

	// ErrTxAlreadyClosed is returned when transaction is already committed/rolled back.
	ErrTxAlreadyClosed = errors.New("fluentsql: transaction already closed")

	// ErrEmptyBatch is returned when inserting empty batch.
	ErrEmptyBatch = errors.New("fluentsql: cannot insert empty batch")

	// ErrInconsistentBatch is returned when batch rows have different columns.
	ErrInconsistentBatch = errors.New("fluentsql: inconsistent columns in batch")

	// ErrEmptyWhereIn is returned when WhereIn is called with an empty slice.
	ErrEmptyWhereIn = errors.New("fluentsql: empty slice passed to WhereIn")

	// ErrInvalidBetweenValues is returned when WhereBetween doesn't receive exactly 2 values.
	ErrInvalidBetweenValues = errors.New("fluentsql: BETWEEN requires exactly 2 values")

	// ErrConnectionClosed is returned when trying to use a closed connection.
	ErrConnectionClosed = errors.New("fluentsql: connection closed")

	// ErrQueryTimeout is returned when a query exceeds the context deadline.
	ErrQueryTimeout = errors.New("fluentsql: query timeout exceeded")
)

Sentinel errors for go-fluent-sql. These errors can be checked using errors.Is().

Functions

func WrapError 

func WrapError(op string, err error) error

------------------------------------------------------------------------------- 🔄 WrapError ------------------------------------------------------------------------------- Amaç: Operasyon ismiyle birlikte hata zinciri oluşturmak. Kullanım: return WrapError("insert", err) Sonuç: `fluentsql: insert: <wrapped error>` şeklinde takip edilebilir output üretir. ------------------------------------------------------------------------------

Types

type Builder 

type Builder struct {
	// contains filtered or unexported fields
}

Builder, SQL sorgularını akıcı bir arayüz (fluent interface) ile oluşturmak için kullanılan ana sınıftır.

Bu sınıf, Laravel ve Symfony'nin Query Builder mantığından esinlenmiştir. Sorguların neyi, nasıl ve neden yaptığına dair okunabilir ve bakımı kolay bir yapı sunar. Builder örnekleri **concurrent-safe** değildir; paralel kullanımlar için Clone() ile çoğaltılmalıdır.

Genel kullanım örneği: 

var users []User
err := db.Table("users").
    Select("id", "name", "email").
    Where("status", "=", "active").
    OrderByDesc("created_at").
    Limit(10).
    GetContext(ctx, &users)

Bu sınıf, SELECT, INSERT, UPDATE, DELETE işlemlerini destekler ve sorgu bileşenlerini kolayca birleştirmeyi sağlar.

@author Ahmet ALTUN @github github.com/biyonik @linkedin linkedin.com/in/biyonik @email ahmet.altun60@gmail.com

func New 

func New(opts ...Option) *Builder

New, veritabanı bağlantısı olmadan yeni bir Builder oluşturur. SQL stringleri oluşturmak ve sorgu yürütmeden hazırlık yapmak için kullanılır.

Örnek: 

qb := fluentsql.New()
sql, args, err := qb.Table("users").
    Select("id", "name").
    Where("status", "=", "active").
    ToSQL()

func NewBuilder 

func NewBuilder(executor QueryExecutor, grammar dialect.Grammar, scanner Scanner) *Builder

NewBuilder, belirtilen executor, grammar ve scanner ile yeni bir Builder oluşturur.

func Table 

func Table(name string) *Builder

Table, yeni bir Builder oluşturup tablo adını ayarlamak için kısayoldur.

Örnek: 

sql, args, err := fluentsql.Table("users").
    Where("status", "=", "active").
    ToSQL()

func (*Builder) Clone 

func (b *Builder) Clone() *Builder

Clone, Builder'ın derin kopyasını oluşturur.

func (*Builder) Count 

func (b *Builder) Count() (int64, error)

Count, CountContext’in context.Background() versiyonudur.

func (*Builder) CountContext 

func (b *Builder) CountContext(ctx context.Context) (int64, error)

CountContext, sorgu için toplam satır sayısını döndürür.

func (*Builder) CrossJoin 

func (b *Builder) CrossJoin(table string) *Builder

CrossJoin, CROSS JOIN ekler.

func (*Builder) Delete 

func (b *Builder) Delete() (*QueryResult, error)

Delete, DeleteContext’in context.Background() versiyonudur.

func (*Builder) DeleteContext 

func (b *Builder) DeleteContext(ctx context.Context) (*QueryResult, error)

DeleteContext, DELETE sorgusu çalıştırır.

func (*Builder) Distinct 

func (b *Builder) Distinct() *Builder

Distinct, sorguyu DISTINCT olarak işaretler.

func (*Builder) DoesntExist 

func (b *Builder) DoesntExist() (bool, error)

DoesntExist, DoesntExistContext’in context.Background() versiyonudur.

func (*Builder) DoesntExistContext 

func (b *Builder) DoesntExistContext(ctx context.Context) (bool, error)

DoesntExistContext, sorguda hiçbir satır yoksa true döner.

func (*Builder) Err 

func (b *Builder) Err() error

Err, birikmiş hatayı döndürür.

func (*Builder) Exists 

func (b *Builder) Exists() (bool, error)

Exists, ExistsContext’in context.Background() versiyonudur.

func (*Builder) ExistsContext 

func (b *Builder) ExistsContext(ctx context.Context) (bool, error)

ExistsContext, sorguda herhangi bir satır var mı kontrol eder.

func (*Builder) First 

func (b *Builder) First(dest any) error

First, FirstContext’in context.Background() versiyonudur.

func (*Builder) FirstContext 

func (b *Builder) FirstContext(ctx context.Context, dest any) error

FirstContext, LIMIT 1 ile sorguyu çalıştırır.

func (*Builder) ForPage 

func (b *Builder) ForPage(page, perPage int) *Builder

ForPage, sayfa bazlı limit ve offset belirler.

func (*Builder) From 

func (b *Builder) From(name string) *Builder

From, Table için okunabilir alias sağlar.

func (*Builder) Get 

func (b *Builder) Get(dest any) error

Get, GetContext’in context.Background() versiyonudur.

func (*Builder) GetColumns 

func (b *Builder) GetColumns() []string

GetColumns, seçilen kolonları döndürür.

func (*Builder) GetContext 

func (b *Builder) GetContext(ctx context.Context, dest any) error

GetContext, sorguyu çalıştırır ve sonuçları dest içine tarar.

func (*Builder) GetGroupBy 

func (b *Builder) GetGroupBy() []string

GetGroupBy, GROUP BY kolonlarını döndürür.

func (*Builder) GetHaving 

func (b *Builder) GetHaving() []dialect.WhereClause

GetHaving, HAVING koşullarını döndürür.

func (*Builder) GetJoins 

func (b *Builder) GetJoins() []dialect.JoinClause

GetJoins, JOIN koşullarını döndürür.

func (*Builder) GetLimit 

func (b *Builder) GetLimit() *int

GetLimit, LIMIT değerini döndürür.

func (*Builder) GetOffset 

func (b *Builder) GetOffset() *int

GetOffset, OFFSET değerini döndürür.

func (*Builder) GetOrders 

func (b *Builder) GetOrders() []dialect.OrderClause

GetOrders, ORDER BY koşullarını döndürür.

func (*Builder) GetTable 

func (b *Builder) GetTable() string

GetTable, tablo adını döndürür.

func (*Builder) GetTableAlias 

func (b *Builder) GetTableAlias() string

GetTableAlias, tablo aliasını döndürür.

func (*Builder) GetWheres 

func (b *Builder) GetWheres() []dialect.WhereClause

GetWheres, WHERE koşullarını döndürür.

func (*Builder) GroupBy 

func (b *Builder) GroupBy(columns ...string) *Builder

GroupBy, GROUP BY ekler.

func (*Builder) Having 

func (b *Builder) Having(column, operator string, value any) *Builder

Having, HAVING ekler.

func (*Builder) HavingRaw 

func (b *Builder) HavingRaw(sqlExpr string, bindings ...any) *Builder

HavingRaw, ham HAVING ifadesi ekler.

func (*Builder) Insert 

func (b *Builder) Insert(data map[string]any) (*QueryResult, error)

Insert, InsertContext’in context.Background() versiyonudur.

func (*Builder) InsertContext 

func (b *Builder) InsertContext(ctx context.Context, data map[string]any) (*QueryResult, error)

InsertContext, INSERT sorgusu çalıştırır.

func (*Builder) IsDistinct 

func (b *Builder) IsDistinct() bool

IsDistinct, DISTINCT kullanılıp kullanılmadığını döndürür.

func (*Builder) Join 

func (b *Builder) Join(table, first, operator, second string) *Builder

Join, INNER JOIN ekler.

func (*Builder) Latest 

func (b *Builder) Latest() *Builder

Latest, created_at DESC ile sıralar.

func (*Builder) LeftJoin 

func (b *Builder) LeftJoin(table, first, operator, second string) *Builder

LeftJoin, LEFT JOIN ekler.

func (*Builder) Limit 

func (b *Builder) Limit(n int) *Builder

Limit, LIMIT ekler.

func (*Builder) Offset 

func (b *Builder) Offset(n int) *Builder

Offset, OFFSET ekler.

func (*Builder) Oldest 

func (b *Builder) Oldest() *Builder

Oldest, created_at ASC ile sıralar.

func (*Builder) OrWhere 

func (b *Builder) OrWhere(column, operator string, value any) *Builder

OrWhere, OR WHERE koşulu ekler.

func (*Builder) OrWhereIn 

func (b *Builder) OrWhereIn(column string, values []any) *Builder

OrWhereIn, OR WHERE IN koşulu ekler.

func (*Builder) OrWhereNested 

func (b *Builder) OrWhereNested(fn func(*Builder)) *Builder

OrWhereNested, OR iç içe WHERE bloğu ekler.

func (*Builder) OrWhereNotIn 

func (b *Builder) OrWhereNotIn(column string, values []any) *Builder

OrWhereNotIn, OR WHERE NOT IN koşulu ekler.

func (*Builder) OrWhereNotNull 

func (b *Builder) OrWhereNotNull(column string) *Builder

OrWhereNotNull, OR WHERE IS NOT NULL koşulu ekler.

func (*Builder) OrWhereNull 

func (b *Builder) OrWhereNull(column string) *Builder

OrWhereNull, OR WHERE IS NULL koşulu ekler.

func (*Builder) OrWhereRaw 

func (b *Builder) OrWhereRaw(sqlExpr string, bindings ...any) *Builder

OrWhereRaw, ham SQL OR WHERE ifadesi ekler.

func (*Builder) OrderBy 

func (b *Builder) OrderBy(column string, direction dialect.OrderDirection) *Builder

OrderBy, ORDER BY ekler.

func (*Builder) OrderByAsc 

func (b *Builder) OrderByAsc(column string) *Builder

OrderByAsc, artan sırada ORDER BY ekler.

func (*Builder) OrderByDesc 

func (b *Builder) OrderByDesc(column string) *Builder

OrderByDesc, azalan sırada ORDER BY ekler.

func (*Builder) OrderByRaw 

func (b *Builder) OrderByRaw(expr string) *Builder

OrderByRaw, ham ORDER BY ifadesi ekler.

func (*Builder) Reset 

func (b *Builder) Reset() *Builder

Reset, tüm sorgu durumunu temizler (connection ve grammar hariç).

func (*Builder) RightJoin 

func (b *Builder) RightJoin(table, first, operator, second string) *Builder

RightJoin, RIGHT JOIN ekler.

func (*Builder) Select 

func (b *Builder) Select(columns ...string) *Builder

Select, sorguda seçilecek kolonları ayarlar.

func (*Builder) SelectRaw 

func (b *Builder) SelectRaw(expr string) *Builder

SelectRaw, ham SQL select ifadesi ekler. Dikkat: SQL injection riskine karşı ifadeyi güvenli şekilde kullanın.

func (*Builder) Skip 

func (b *Builder) Skip(n int) *Builder

Skip, Offset aliasıdır.

func (*Builder) Table 

func (b *Builder) Table(name string) *Builder

Table, sorguda kullanılacak tablo adını ayarlar.

func (*Builder) TableAs 

func (b *Builder) TableAs(name, alias string) *Builder

TableAs, tablo adı ve aliasını ayarlar.

func (*Builder) Take 

func (b *Builder) Take(n int) *Builder

Take, Limit aliasıdır.

func (*Builder) ToDeleteSQL 

func (b *Builder) ToDeleteSQL() (string, []any, error)

ToDeleteSQL, DELETE sorgusunu derler.

func (*Builder) ToInsertSQL 

func (b *Builder) ToInsertSQL(data map[string]any) (string, []any, error)

ToInsertSQL, INSERT sorgusunu derler.

func (*Builder) ToSQL 

func (b *Builder) ToSQL() (string, []any, error)

ToSQL, sorguyu SQL string ve bindinglerle döndürür.

func (*Builder) ToSelectSQL 

func (b *Builder) ToSelectSQL() (string, []any, error)

ToSelectSQL, SELECT sorgusunu derler.

func (*Builder) ToUpdateSQL 

func (b *Builder) ToUpdateSQL(data map[string]any) (string, []any, error)

ToUpdateSQL, UPDATE sorgusunu derler.

func (*Builder) Unless 

func (b *Builder) Unless(condition bool, fn func(*Builder)) *Builder

Unless, When’in tersidir.

func (*Builder) Update 

func (b *Builder) Update(data map[string]any) (*QueryResult, error)

Update, UpdateContext’in context.Background() versiyonudur.

func (*Builder) UpdateContext 

func (b *Builder) UpdateContext(ctx context.Context, data map[string]any) (*QueryResult, error)

UpdateContext, UPDATE sorgusu çalıştırır.

func (*Builder) When 

func (b *Builder) When(condition bool, fn func(*Builder)) *Builder

When, koşullu olarak callback uygular.

func (*Builder) Where 

func (b *Builder) Where(column, operator string, value any) *Builder

Where, temel bir WHERE koşulu ekler.

func (*Builder) WhereBetween 

func (b *Builder) WhereBetween(column string, min, max any) *Builder

WhereBetween, WHERE BETWEEN koşulu ekler.

func (*Builder) WhereDate 

func (b *Builder) WhereDate(column string, value string) *Builder

WhereDate, DATE(column) = value koşulu ekler.

func (*Builder) WhereDay 

func (b *Builder) WhereDay(column string, value int) *Builder

WhereDay, DAY(column) = value koşulu ekler.

func (*Builder) WhereIn 

func (b *Builder) WhereIn(column string, values []any) *Builder

WhereIn, WHERE IN koşulu ekler.

func (*Builder) WhereLike 

func (b *Builder) WhereLike(column string, pattern string) *Builder

WhereLike, WHERE LIKE koşulu ekler.

func (*Builder) WhereMonth 

func (b *Builder) WhereMonth(column string, value int) *Builder

WhereMonth, MONTH(column) = value koşulu ekler.

func (*Builder) WhereNested 

func (b *Builder) WhereNested(fn func(*Builder)) *Builder

WhereNested, iç içe WHERE bloğu ekler.

func (*Builder) WhereNotBetween 

func (b *Builder) WhereNotBetween(column string, min, max any) *Builder

WhereNotBetween, WHERE NOT BETWEEN koşulu ekler.

func (*Builder) WhereNotIn 

func (b *Builder) WhereNotIn(column string, values []any) *Builder

WhereNotIn, WHERE NOT IN koşulu ekler.

func (*Builder) WhereNotLike 

func (b *Builder) WhereNotLike(column string, pattern string) *Builder

WhereNotLike, WHERE NOT LIKE koşulu ekler.

func (*Builder) WhereNotNull 

func (b *Builder) WhereNotNull(column string) *Builder

WhereNotNull, WHERE IS NOT NULL koşulu ekler.

func (*Builder) WhereNull 

func (b *Builder) WhereNull(column string) *Builder

WhereNull, WHERE IS NULL koşulu ekler.

func (*Builder) WhereRaw 

func (b *Builder) WhereRaw(sqlExpr string, bindings ...any) *Builder

WhereRaw, ham SQL WHERE ifadesi ekler.

func (*Builder) WhereYear 

func (b *Builder) WhereYear(column string, value int) *Builder

WhereYear, YEAR(column) = value koşulu ekler.

type BuilderOption 

type BuilderOption func(*Builder)

BuilderOption tipi, yalnızca query bazlı kullanılan yapılandırmalardır. DB Option'larından farklıdır çünkü her sorguda ayrı davranışlara izin verir.

Amaç: • Daha ince taneli kontrol • Bağlam bazlı varyasyon

type Config 

type Config struct {
	Driver       string        // Kullanılacak sürücü: "mysql", "postgres" vb.
	Host         string        // Veritabanı sunucusunun adresi (IP veya domain)
	Port         int           // Bağlantı portu
	Database     string        // Bağlanılacak veritabanı (schema) adı
	Username     string        // Yetkilendirme için kullanıcı adı
	Password     string        // Yetkilendirme için parola
	Charset      string        // Karakter seti (varsayılan: utf8mb4)
	Collation    string        // Sıralama ve karşılaştırma kuralları (varsayılan: utf8mb4_unicode_ci)
	Prefix       string        // Tablo isimlerinin önüne eklenecek önek (prefix)
	MaxOpenConns int           // Havuzdaki maksimum açık bağlantı sayısı (0 = sınırsız)
	MaxIdleConns int           // Havuzda boşta bekletilecek maksimum bağlantı sayısı
	ConnMaxLife  time.Duration // Bir bağlantının yaşam döngüsü süresi
	ConnMaxIdle  time.Duration // Bir bağlantının boşta kalabileceği maksimum süre
	TLS          bool          // TLS/SSL şifreli bağlantı zorunluluğu
}

Config, veritabanı bağlantısının DNA'sını oluşturan yapılandırma şemasıdır.

Bir veritabanı bağlantısı sadece host ve porttan ibaret değildir. Performanslı bir uygulama için Connection Pooling (Havuzlama), Timeout süreleri, Karakter setleri (Charset) ve SSL/TLS ayarları hayati önem taşır. Bu struct, tüm bu parametreleri tek bir çatı altında toplar.

func DefaultConfig 

func DefaultConfig() *Config

DefaultConfig, üretim ortamına (production) uygun varsayılan ayarlarla dolu bir konfigürasyon nesnesi döndürür.

Geliştirici hiçbir ayar yapmasa bile, bu metot sayesinde "çalışan" ve belirli bir performans standardına sahip bir yapılandırma elde eder.

func (*Config) DSN 

func (c *Config) DSN() string

DSN (Data Source Name), veritabanı sürücüsünün anlayacağı formatta bağlantı dizesini (connection string) oluşturur.

Özellikle MySQL için gereken karmaşık parametre dizilimini (user:pass@tcp(host:port)/db?param=val) dinamik olarak inşa eder. Charset, collation ve parseTime gibi kritik parametreleri sorgu dizesine (query string) ekler.

type DB 

type DB struct {
	*sql.DB // Standart Go DB nesnesi gömülü olarak bulunur.
	// contains filtered or unexported fields
}

DB struct'ı veritabanı bağlantısını sarar ve üzerine grammar, scanner, logging, prefix gibi ORM davranışlarını belirleyen özellikler ekler. Böylece DB artık yalnızca bağlanılan yer değil, sorguyu şekillendiren ve işleyen ana merkez olur.

Bu yapı; "Salt bağlantı" → "Akıllı ORM çekirdeği" dönüşümünün temel taşıdır. ---------------------------------------------------------------------

func Connect 

func Connect(driverName, dataSourceName string, opts ...Option) (*DB, error)

Connect, verilen driver ve veri kaynağıyla yeni bir veritabanı bağlantısı oluşturur ve DB örneğini döndürür. Bağlantının doğruluğunu kontrol eder ve hata oluşursa WrapError ile sarar.

Örnek: 

db, err := fluentsql.Connect("mysql", "user:pass@tcp(localhost:3306)/dbname")
if err != nil {
    log.Fatal(err)
}
defer db.Close()

func ConnectWithConfig 

func ConnectWithConfig(cfg *Config, opts ...Option) (*DB, error)

ConnectWithConfig, Config yapısı kullanarak yeni bir veritabanı bağlantısı oluşturur. Bağlantı havuz ayarlarını uygular ve DSN oluşturur.

Örnek: 

cfg := &fluentsql.Config{
    Driver:   "mysql",
    Host:     "localhost",
    Port:     3306,
    Database: "mydb",
    Username: "user",
    Password: "pass",
}
db, err := fluentsql.ConnectWithConfig(cfg)

func NewDB 

func NewDB(db *sql.DB, opts ...Option) *DB

NewDB -> DB sarmalayıcısının oluşturulduğu yerdir. Varsayılan Grammar ve Scanner atanır, opsiyonlar ile davranış şekillendirilebilir. Geliştirici, yalnızca sql.DB verip gerisini bu wrapper'a teslim eder → Akıcı yapı başlar. ---------------------------------------------------------------------

func (*DB) Begin 

func (d *DB) Begin() (*Transaction, error)

Begin -> Varsayılan ayarlarla transaction başlatır. Hızlı kullanım için kısayoldur. ---------------------------------------------------------------------

func (*DB) BeginTx 

func (d *DB) BeginTx(ctx context.Context, opts *sql.TxOptions) (*Transaction, error)

BeginTx -> Manuel transaction başlatır. Bağlantıya güvenip işi tek adımda yapmak yerine, adım adım ilerlemek isteyen geliştiriciler için kontrollü güç sunar. ---------------------------------------------------------------------

func (*DB) Close 

func (d *DB) Close() error

Close -> Veritabanı bağlantısını kapatır.

func (*DB) Grammar 

func (d *DB) Grammar() dialect.Grammar

Grammar -> Aktif SQL cümle oluşturma motorunu döndürür.

func (*DB) IsDebug 

func (d *DB) IsDebug() bool

IsDebug -> Debug modunda mıyız? Sorgular loglanacak mı? Bilgi verir.

func (*DB) Logger 

func (d *DB) Logger() Logger

Logger -> Sorgu izleme/raporlama sistemine dışarıdan erişim sağlar.

func (*DB) Ping 

func (d *DB) Ping(ctx context.Context) error

Ping -> Bağlantı canlı mı? Kontrol eder.

func (*DB) Scanner 

func (d *DB) Scanner() Scanner

Scanner -> Satır–>struct tarama mekanizmasını verir.

func (*DB) Table 

func (d *DB) Table(name string) *Builder

Table -> Yeni bir Query Builder oluşturur ve belirtilen tablo üzerinde çalışmaya başlar. Bu fonksiyon, sorgu yazımının ilk adımıdır. Zincirin başlangıç halkasıdır. ---------------------------------------------------------------------

func (*DB) TablePrefix 

func (d *DB) TablePrefix() string

TablePrefix -> Tüm tabloların başında kullanılacak ön-ek (prefix) değerini döndürür.

func (*DB) Transaction 

func (d *DB) Transaction(ctx context.Context, fn func(*Transaction) error) error

Transaction -> Verilen fonksiyon içerisinde otomatik transaction yönetimi sağlar. Başarılı olursa commit, hata veya panic durumunda rollback yapar. Laravel `DB::transaction()` davranışına doğrudan bir karşılıktır. ---------------------------------------------------------------------

type DefaultScanner 

type DefaultScanner struct {
	// contains filtered or unexported fields
}

DefaultScanner → Kütüphanenin standart tarama motorudur. Reflection kullanır, `db:"field"` tag’i ile eşleme yapar. Struct metadata bilgisi cache’de tutulduğu için yüksek performans sağlar.

func NewDefaultScanner 

func NewDefaultScanner() *DefaultScanner

NewDefaultScanner → Varsayılan scanner oluşturur. Dışarıdan bağımlılık gerektirmez, tek satırda çağrılır: 

scanner := NewDefaultScanner()

func (*DefaultScanner) GetFieldNames 

func (s *DefaultScanner) GetFieldNames(dest any) ([]string, error)

GetFieldNames → Struct içerisinde veritabanına karşılık gelen bütün kolon adlarını döner. SELECT * yerine SELECT id,name,email üretmek isteyen sistemler burada beslenir.

func (*DefaultScanner) GetPrimaryKey 

func (s *DefaultScanner) GetPrimaryKey(dest any) string

GetPrimaryKey → struct'ın birincil anahtar kolonunu döner. Eğer tanımlı değilse "id" fallback olarak kabul edilir.

func (*DefaultScanner) ScanColumn 

func (s *DefaultScanner) ScanColumn(rows *sql.Rows, dest any) error

ScanColumn → sonuçların tek bir kolon olup slice’a yazıldığı senaryolar içindir. Örnek: 

var ids []int
scanner.ScanColumn(rows, &ids)

func (*DefaultScanner) ScanRow 

func (s *DefaultScanner) ScanRow(row *sql.Row, dest any) error

ScanRow → Tek satırı karşılayan scanner fonksiyonudur. Struct pointer bekler, alanlar tek tek doldurulur. Row yok ise ErrNoRows döner.

func (*DefaultScanner) ScanRows 

func (s *DefaultScanner) ScanRows(rows *sql.Rows, dest any) error

ScanRows → Çoklu sonuç tarayıcı. rows sonuç kümesini slice’a aktarır. (Users → []User şeklinde)

ÖNEMLİ NOKTA: - Eğer hedef slice pointer değilse çalışmaz - Eğer slice element yapısı struct değilse hata döner

func (*DefaultScanner) ScanValue 

func (s *DefaultScanner) ScanValue(row *sql.Row, dest any) error

ScanValue → Tek kolon tek değer okuma. Sayım, tek field sonuçları gibi minimal sorgular için idealdir.

type Logger 

type Logger interface {
	Log(query string, args []any, duration time.Duration, err error)
}

Logger, sistemin kara kutusudur.

Çalışan SQL sorgularını, parametreleri, sorgunun ne kadar sürdüğünü ve olası hataları izlemek (observability) için kullanılan arayüzdür. Geliştirici kendi logger'ını enjekte ederek sorgu performansını analiz edebilir.

type NopLogger 

type NopLogger struct{}

NopLogger (No-Operation Logger), "sessiz mod" için kullanılan bir logger uygulamasıdır.

Eğer geliştirici herhangi bir loglama mekanizması belirtmezse, sistemin hata vermeden çalışmaya devam etmesi için bu boş (dummy) yapı kullanılır. Tüm logları yutar ve hiçbir işlem yapmaz.

func (NopLogger) Log 

func (NopLogger) Log(string, []any, time.Duration, error)

Log, NopLogger'ın implementasyonudur. Gelen tüm veriyi yok sayar.

type Option 

type Option func(*DB)

Option tipi, bir *DB* örneği üzerinde çalışan yapılandırma fonksiyonlarının temel imzasıdır. Bu tasarım sayesinde, yapılandırma parametreleri sabit ve katı değil; ihtiyaç oldukça genişletilebilir bir yapıya kavuşur.

Neden böyle? Çünkü proje büyüdükçe veritabanı davranışı da evrilir. Option pattern, kodu işlemeye dokunmadan yeni ayarlar eklemeye olanak tanır.

func WithDebug 

func WithDebug(enabled bool) Option

WithDebug fonksiyonu debug modunu aktif veya pasif hâle getirir. Debug açık olduğunda, oluşturulan her sorgu loglanır.

Neyi, nasıl değiştirir? • Debug = true -> tüm query'ler Logger üzerinden görünür hale gelir • Geliştirme aşamasında şeffaflık sağlar, hata analizini hızlandırır

Örnek: 

db := fluentsql.NewDB(sqlDB, fluentsql.WithDebug(true))

func WithGrammar 

func WithGrammar(g dialect.Grammar) Option

WithGrammar fonksiyonu, FluentSQL'in derleme aşamasında kullanacağı SQL gramerini değiştirmeye yarar. Varsayılan olarak MySQLGrammar kullanılır, fakat PostgreSQL, SQLite veya özel türevler kolayca eklenebilir.

Neyi sağlar? • Sorgu oluşturma kurallarının değişmesini • Farklı veri tabanı motorlarına geçişte minimum maliyet

Nasıl çalışır? • Option fonksiyonu olarak DB'ye enjekte edilir ve grammar alanını doldurur.

Örnek: 

db := fluentsql.NewDB(sqlDB, fluentsql.WithGrammar(fluentsql.NewPostgreSQLGrammar()))

func WithLogger 

func WithLogger(logger Logger) Option

WithLogger fonksiyonu özel bir logger tanımlamaya yarar. Debug moduyla birlikte kullanıldığında sorgularınızı istediğiniz formatta, istediğiniz hedefe aktarabilirsiniz.

Kullanım amacı? • CLI, file, remote log server gibi farklı log ortamlarını desteklemek • Geliştiriciye loglama mimarisini özgürce şekillendirme gücü vermek

Örnek: 

db := fluentsql.NewDB(sqlDB,
    fluentsql.WithDebug(true),
    fluentsql.WithLogger(myLogger),
)

func WithScanner 

func WithScanner(s Scanner) Option

WithScanner fonksiyonu, veritabanından dönen sonucu struct içerisine map eden tarayıcı yapısını değiştirmeye imkân tanır. Varsayılan tarayıcı DefaultScanner’dır ancak özel modellemede esneklik sunması için yeniden tanımlanabilir.

Neden önemli? • Farklı veri tipleri veya dönüş yapılarıyla çalışırken kontrol sağlar • Geliştiricinin kendi scan algoritmasını yazmasına olanak tanır

Örnek: 

db := fluentsql.NewDB(sqlDB, fluentsql.WithScanner(customScanner))

func WithTablePrefix 

func WithTablePrefix(prefix string) Option

WithTablePrefix fonksiyonu tüm tablo adlarına otomatik olarak prefix ekler. Çok tenantlı sistemlerde her müşterinin verisini ayırmak ya da proje genelinde ad çakışmalarını önlemek için oldukça zarif bir yaklaşımdır.

Örnek: 

db := fluentsql.NewDB(sqlDB, fluentsql.WithTablePrefix("app_"))
// db.Table("users")  →  "app_users"

type Pagination 

type Pagination struct {
	Page       int   // Mevcut sayfa numarası (1'den başlar)
	PerPage    int   // Sayfa başına gösterilecek kayıt sayısı
	Total      int64 // Veritabanındaki toplam kayıt sayısı
	TotalPages int   // Hesaplanan toplam sayfa sayısı
	HasMore    bool  // Sonraki sayfaların olup olmadığını belirten bayrak
}

Pagination, veri listeleme işlemlerinde "sayfalama" mantığını yöneten veri yapısıdır.

Modern web uygulamalarında ve API'lerde, binlerce kaydı tek seferde çekmek yerine parçalar halinde sunmak (chunking) performansın anahtarıdır. Bu yapı, hem istemciye sunulacak meta veriyi (toplam sayfa, mevcut sayfa vb.) hem de SQL sorgusu için gerekli olan LIMIT/OFFSET hesaplamalarını barındırır.

func NewPagination 

func NewPagination(page, perPage int, total int64) *Pagination

NewPagination, ham sayfalama parametrelerinden zengin bir Pagination nesnesi oluşturur.

Bu kurucu metot (constructor), geçersiz veya eksik parametreleri (örn: negatif sayfa sayısı) otomatik olarak "akıllı varsayılanlara" (sensible defaults) dönüştürür. Ayrıca toplam sayfa sayısını ve veri setinin devamı olup olmadığını matematiksel olarak hesaplar.

func (*Pagination) HasNext 

func (p *Pagination) HasNext() bool

HasNext, mevcut sayfadan ileriye gidilip gidilemeyeceğini kontrol eder. Eğer elimizdeki veri seti toplam sayfa sayısına ulaşmadıysa true döner.

func (*Pagination) HasPrev 

func (p *Pagination) HasPrev() bool

HasPrev, mevcut sayfadan geriye gidilip gidilemeyeceğini kontrol eder. Sayfa 1'de isek geriye gidiş yoktur.

func (*Pagination) Offset 

func (p *Pagination) Offset() int

Offset, SQL sorgusu için gerekli olan başlangıç noktasını (SKIP miktarını) hesaplar.

Örnek: 3. sayfadasınız ve her sayfada 10 kayıt var. Offset = (3 - 1) * 10 = 20. Yani ilk 20 kaydı atla, sonrakileri getir.

type QueryError 

type QueryError struct {
	Op    string // Operation: "select", "insert", "update", "delete", "compile"
	Table string // Table name
	SQL   string // Generated SQL (sanitized, no actual values)
	Err   error  // Underlying error
}

------------------------------------------------------------------------------- 🏷 QueryError -------------------------------------------------------------------------------

  • Amaç: Sorgu işlemlerinde bağlam kaybı olmadan hata taşımak.
  • Neden var?: Hatanın "hangi tablo", "hangi operasyon", "hangi SQL çıktısı" ile ilişkili olduğunun tek bakışta anlaşılması gerekir.
  • Kullanım: `return &QueryError{ ... }` şeklinde veya `NewQueryError()` ile üretilir. errors.Unwrap() ile alt hata geri alınabilir.

------------------------------------------------------------------------------

func NewQueryError 

func NewQueryError(op, table, sql string, err error) *QueryError

NewQueryError creates a new QueryError with context. Bu yardımcı fonksiyon hata üretimini standartlaştırır; proje genelinde tek tip format ve izlenebilirlik sağlar.

func (*QueryError) Error 

func (e *QueryError) Error() string

Error implements the error interface. Bu fonksiyon hata mesajını okunabilir formatta döndürür. Eğer tablo adı mevcut ise → "select on table X" şeklinde detaylı yazılır.

func (*QueryError) Unwrap 

func (e *QueryError) Unwrap() error

Unwrap returns the underlying error. Amaç: Go'nun error chain mekanizması ile hatanın köküne ulaşabilmek.

type QueryExecutor 

type QueryExecutor interface {

	// ExecContext -> INSERT/UPDATE/DELETE gibi sonuç satırı döndürmeyen komutlar için çalıştırma yöntemidir.
	// Parametre olarak context alır; timeout, cancel vb. durumlarda akış kontrolü sağlanabilir.
	ExecContext(ctx context.Context, query string, args ...any) (sql.Result, error)

	// QueryContext -> Birden fazla satır döndürebilen SELECT sorguları için çağrılır.
	QueryContext(ctx context.Context, query string, args ...any) (*sql.Rows, error)

	// QueryRowContext -> Tek satır beklenen SELECT işlemlerinde kullanılır.
	// Eğer veri yoksa *sql.Row.Err() ile boş dönebilir, bu durum bilinçli yönetilmelidir.
	QueryRowContext(ctx context.Context, query string, args ...any) *sql.Row
}

QueryExecutor arayüzü; hem *sql.DB hem *sql.Tx yapılarının ortak olarak sağlayabildiği temel veritabanı fonksiyonlarını soyutlar. Böylece işlem ister direkt DB'de olsun ister Transaction içinde, kod yapısı ve çağrım şekli değişmeden akıcı biçimde çalışabilir.

Bu mimari seçim, "Tek kod → iki farklı çalışma ortamı" yaklaşımının bir sonucudur. Özellikle transaction tabanlı finansal hareketlerde büyük esneklik sağlar. ---------------------------------------------------------------------

type QueryResult 

type QueryResult struct {
	// contains filtered or unexported fields
}

QueryResult, bir INSERT, UPDATE veya DELETE işlemi sonucunda veritabanından dönen ham yanıtı sarmalayan (wrapper) yapıdır.

Bu yapı, ham `sql.Result` arabirimini doğrudan dışarı sızdırmak yerine, üzerinde güvenli erişim metotları sunarak olası çalışma zamanı hatalarını (runtime errors) minimize etmeyi hedefler.

func NewQueryResult 

func NewQueryResult(result sql.Result) *QueryResult

NewQueryResult, ham `sql.Result` nesnesinden güvenli bir FluentSQL sonuç nesnesi türetir.

Bu fabrika metodu, veritabanı sürücüsünden dönen sonucu paketleyerek kütüphanenin standartlarına uygun hale getirir.

func (*QueryResult) LastInsertID 

func (r *QueryResult) LastInsertID() (int64, error)

LastInsertID, veritabanına son eklenen kaydın benzersiz kimliğini (ID) döndürür.

Genellikle AUTO_INCREMENT (MySQL) veya SERIAL (Postgres) alanlar için kullanılır. Eğer altta yatan veritabanı sürücüsü bu özelliği desteklemiyorsa veya işlem başarısızsa 0 ve hata döner. Ayrıca sonucun `nil` olup olmadığını kontrol ederek panic durumunu önler.

func (*QueryResult) RowsAffected 

func (r *QueryResult) RowsAffected() (int64, error)

RowsAffected, çalıştırılan sorgudan kaç adet satırın etkilendiğini bildirir.

Özellikle toplu güncellemelerde (UPDATE) veya silme (DELETE) işlemlerinde, operasyonun başarısını ve kapsamını doğrulamak için kritik bir metriktir.

type Raw 

type Raw struct {
	SQL      string
	Bindings []any
}

Raw, kaçış yapılmayacak ham SQL ifadesini temsil eder. Sadece güvenli ve kontrol edilen girdi için kullanın.

Bu tip, düzenli değerlerden ayırt edilebilmesi için bir işaretleyicidir.

func NewRaw 

func NewRaw(sql string, bindings ...any) Raw

NewRaw, yeni bir Raw SQL ifadesi oluşturur.

Örnek: 

qb.Select(fluentsql.NewRaw("COUNT(*) as total"))
qb.WhereRaw("YEAR(created_at) = ?", 2024)

func (Raw) String 

func (r Raw) String() string

String, ham SQL ifadesini string olarak döndürür.

type Scanner 

type Scanner interface {
	// ScanRow → Tek satırı tek struct’a işler.
	// Burada beklenen davranış; row’dan verileri okuyup struct alanlarına set etmektir.
	ScanRow(row *sql.Row, dest any) error

	// ScanRows → Birden fazla satırı slice içine işler.
	// ORM kullanıyormuş hissi veren ana fonksiyondur.
	ScanRows(rows *sql.Rows, dest any) error
}

Scanner veritabanından okunan satırları Go modellerine map eden davranış sözleşmesidir. Bu interface’i implement eden her yapı, satırları struct’a veya slice’a dönüştürebilir.

type Transaction 

type Transaction struct {
	// contains filtered or unexported fields
}

Transaction struct'ı, bir SQL transaction’ı temsil eder ve Query Builder entegrasyonu ile birlikte çalışır. Aynı *sql.Tx* üzerinden sorgular zincir halinde yürütülür. Ancak dikkat: Bu yapı thread-safe değildir. Her goroutine kendi Transaction nesnesini kullanmalıdır.

func (*Transaction) Commit 

func (t *Transaction) Commit() error

Commit metodu, yapılan tüm işlemleri kalıcı hale getirir. Bir kez işlendiğinde transaction kapanır ve tekrar kullanılmaya çalışılırsa ErrTxAlreadyClosed üretir.

Kullanım Amacı: • İşlemlerin başarıyla tamamlandığını onaylamak • Sistem bütünlüğünü korumak

func (*Transaction) ExecContext 

func (t *Transaction) ExecContext(ctx context.Context, query string, args ...any) (sql.Result, error)

ExecContext metodu — Builder kullanmaya gerek kalmadan raw SQL çalıştırmak için doğrudan erişim sunar.

Kullanım Alanı: • Özel SQL ifadeleri • Builder’ın desteklemediği query tipleri

func (*Transaction) Grammar 

func (t *Transaction) Grammar() dialect.Grammar

Grammar — transaction seviyesinde kullanılan SQL sözdizimini döndürür.

func (*Transaction) IsClosed 

func (t *Transaction) IsClosed() bool

IsClosed transaction'ın commit ya da rollback sonrası kapanıp kapanmadığını bildirir. Bu, işlem akışını kontrol ederken önemli bir güvenlik kilidi işlevi görür.

func (*Transaction) QueryContext 

func (t *Transaction) QueryContext(ctx context.Context, query string, args ...any) (*sql.Rows, error)

QueryContext — result set döndüren SELECT benzeri işlemler için kullanılır. Dönen sonuç satır tabanlıdır (*sql.Rows*).

func (*Transaction) QueryRowContext 

func (t *Transaction) QueryRowContext(ctx context.Context, query string, args ...any) *sql.Row

QueryRowContext — tek satır dönen sorgular içindir. Örneğin LIMIT 1, COUNT(), MAX() gibi yapılar için tercih edilir.

func (*Transaction) ReleaseSavepoint 

func (t *Transaction) ReleaseSavepoint(name string) error

ReleaseSavepoint — oluşturulan savepoint’i serbest bırakır. Bu işlem transaction’ı bitirmez, yalnızca savepoint'i temizler.

func (*Transaction) Rollback 

func (t *Transaction) Rollback() error

Rollback metodu — commit'in tam tersidir. Tüm değişiklikleri geri alır. Çok önemli not: Rollback tekrar tekrar çağıldığında hata vermez, idempotenttir.

Kullanım Senaryosu: • Hata oluştuğunda işlemi geri almak • Bir adım yanlış gittiğinde sistem tutarlılığını korumak

func (*Transaction) RollbackTo 

func (t *Transaction) RollbackTo(name string) error

RollbackTo — transaction’ı tamamen geri almadan yalnızca belirli savepoint’e dönüş sağlar. Büyük sistemlerde geri dönüş maliyetini minimize eder.

func (*Transaction) Savepoint 

func (t *Transaction) Savepoint(name string) error

Savepoint — büyük transaction blokları arasında güvenli dönüş noktası oluşturur. Tüm işlemi bozmak yerine yalnızca belirli bölümü geri almak için kullanılır.

Not: Her veritabanı savepoint desteklemez.

func (*Transaction) Scanner 

func (t *Transaction) Scanner() Scanner

Scanner — transaction’ın tarayıcı (struct-bind) bileşenini döndürür.

func (*Transaction) Table 

func (t *Transaction) Table(name string) *Builder

Table metodu, transaction kapsamında kullanılmak üzere yeni bir Builder üretir. Amaç: Transaction içerisinde akıcı query üretmeyi sürdürmek.

Örnek: 

tx, _ := db.Begin()
_, err := tx.Table("users").Where("id", "=", 1).Update(data)

func (*Transaction) Tx 

func (t *Transaction) Tx() *sql.Tx

Tx — alttaki *sql.Tx* referansına doğrudan erişim sağlar. ⚠ Kullanırken dikkatli olunmalıdır. Transaction metodları güvenlik kontrolleri içerirken raw erişim içermez.

type ValidationError 

type ValidationError struct {
	Type   string // "identifier", "operator", "value"
	Value  string // The invalid value
	Reason string // Why it's invalid
}

------------------------------------------------------------------------------- 🏷 ValidationError -------------------------------------------------------------------------------

  • Amaç: Identifier, operator veya value geçersiz olduğunda anlamlı geri dönüş üretmek.
  • Neden özel struct?: Çünkü bir hatanın yalnızca oluşması değil, *neden* oluştuğu da önemlidir. Örn: "identifier geçersiz" vs "value geçersiz" → farklı kök sebepler.
  • errors.Is() override edilmiştir, böylece ErrInvalidIdentifier gibi sabit hatalarla eşleştirilebilir.

------------------------------------------------------------------------------

func NewValidationError 

func NewValidationError(typ, value, reason string) *ValidationError

NewValidationError creates a new ValidationError. Kullanımı basitleştirilmiş factory fonksiyondur.

func (*ValidationError) Error 

func (e *ValidationError) Error() string

Error implements the error interface. Hatanın insan tarafından anlaşılabilir string halini döndürür.

func (*ValidationError) Is 

func (e *ValidationError) Is(target error) bool

Is allows errors.Is() to match against sentinel errors. Böylece errors.Is(err, ErrInvalidIdentifier) → true olabilir.

Source Files

View all Source files

Directories

Path Synopsis
Package dialect, farklı veritabanları için SQL dilbilgisi (grammar) implementasyonlarını sağlar.
 Package dialect, farklı veritabanları için SQL dilbilgisi (grammar) implementasyonlarını sağlar.
internal
validation
Package validation, SQL sorgularında kullanılan tablolar, kolonlar ve alias isimlerini güvenli bir şekilde doğrulamak için dahili yardımcı fonksiyonlar sağlar.
 Package validation, SQL sorgularında kullanılan tablolar, kolonlar ve alias isimlerini güvenli bir şekilde doğrulamak için dahili yardımcı fonksiyonlar sağlar.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.