Simple and fast Redis backed key-value store library for Go

store [![GoDoc](https://godoc.org/github.com/gosuri/go-store?status.svg)](https://godoc.org/github.com/gosuri/go-store) [![Build Status](https://travis-ci.org/gosuri/go-store.svg?branch=master)](https://travis-ci.org/gosuri/go-store)
=======

store is a data-store library for [Go](http://golang.org) that provides a set of platform-independent interfaces to persist and retrieve data.

Its primary goal is to wrap existing implementations of such primitives, such as those in package redis, into shared public interfaces that abstract functionality, plus some other related primitives.

It currently supports [Redis](http://redis.io) from the [redis](redis/) package.

**NOTE**: This library is currently under **active development** and not ready for production use.

Example
-------

The below example stores, lists and fetches the saved records

```go
package main

import (
  "fmt"

  "github.com/gosuri/go-store/redis"
)

type hacker struct {
  Id        string
  Name      string
  Birthyear int
}

func (h *hacker) Key() string {
  return h.Id
}

func (h *hacker) SetKey(k string) {
  h.Id = k
}

func main() {
  store, err := redis.NewStore("", "")
  if err != nil {
    panic(err) // handle error
  }

  // Save a hacker in the store with a auto-generated uuid
  if err := store.Write(&hacker{Name: "Alan Turing", Birthyear: 1912}); err != nil {
    panic(err) // handle error
  }

  var hackers []hacker
  // Populate hackers slice with ids of all hackers in the store
  store.List(&hackers)

  alan := hackers[0]
  store.Read(&alan)
  fmt.Println("Hello,", alan.Name)

  fmt.Println("Listing all", len(hackers), "hackers")
  // Fetches all hackers with names from the store
  store.ReadMultiple(hackers)
  for _, h := range hackers {
    fmt.Printf("%s (%d) (%s)\n", h.Name, h.Birthyear, h.Id)
  }
}
```

Roadmap
-------

Below are items I am and plan on working on in the near future. Contributions are welcome.

Feature | Status
--- | ---
Save multiple records in a single call using pipelining | **implementing**
Query (using finders) and indexing |

Contributing
------------

### Dependency management

Users who import `store` into their package main are responsible to organize and maintain all of their dependencies to ensure code compatibility and build reproducibility.
Store makes no direct use of dependency management tools like [Godep](https://github.com/tools/godep).

We will use a variety of continuous integration providers to find and fix compatibility problems as soon as they occur.

Running Testing
----------------

```
$ make test
```

Benchmarks
----------

```
$ make benchmark
...
BenchmarkRedisWrite      10000  104302 ns/op
BenchmarkRead            20000  65870 ns/op
BenchmarkRead1k          20     67325041 ns/op
BenchmarkRedisList1k     50     27598338 ns/op
BenchmarkRedisList10k    30     71845057 ns/op
BenchmarkReadMultiple1k  200    7453783 ns/op
```


go-store

Grimoire is a database access layer and validation for golang. (Support: MySQL, PostgreSQL and SQLite3)

# grimoire
[![GoDoc](https://godoc.org/github.com/Fs02/grimoire?status.svg)](https://godoc.org/github.com/Fs02/grimoire) [![Build Status](https://travis-ci.org/Fs02/grimoire.svg?branch=master)](https://travis-ci.org/Fs02/grimoire) [![Go Report Card](https://goreportcard.com/badge/github.com/Fs02/grimoire)](https://goreportcard.com/report/github.com/Fs02/grimoire) [![Maintainability](https://api.codeclimate.com/v1/badges/d487e2be0ed7b0b1fed1/maintainability)](https://codeclimate.com/github/Fs02/grimoire/maintainability) [![Test Coverage](https://api.codeclimate.com/v1/badges/d487e2be0ed7b0b1fed1/test_coverage)](https://codeclimate.com/github/Fs02/grimoire/test_coverage)
[![FOSSA Status](https://app.fossa.io/api/projects/git%2Bgithub.com%2FFs02%2Fgrimoire.svg?type=shield)](https://app.fossa.io/projects/git%2Bgithub.com%2FFs02%2Fgrimoire?ref=badge_shield)

> :warning: Grimoire V2 is available as [REL](https://github.com/go-rel/rel) and [Changeset](https://github.com/Fs02/changeset) package.

Grimoire is a database access layer inspired by Ecto. It features a flexible query API and built-in validation. It currently supports MySQL, PostgreSQL, and SQLite3 but a custom adapter can be implemented easily using the Adapter interface.

Features:

- Query Builder
- Association Preloading
- Struct style create and update
- Changeset Style create and update
- Builtin validation using changeset
- Multi adapter support
- Logger

## Motivation

Common go ORM accepts struct as a value for modifying records which has a problem of unable to differentiate between an empty, nil, or undefined value. It's a tricky problem especially when you want to have an endpoint that supports partial updates. Grimoire attempts to solve that problem by integrating Changeset system inspired from Elixir's Ecto. Changeset is a form like entity which allows us to not only solve that problem but also help us with casting, validations, and constraints check.

## Install

```bash
go get github.com/Fs02/grimoire
```

## Quick Start

```golang
package main

import (
	"time"

	"github.com/Fs02/grimoire"
	"github.com/Fs02/grimoire/adapter/mysql"
	"github.com/Fs02/grimoire/changeset"
	"github.com/Fs02/grimoire/params"
)

type Product struct {
	ID        int
	Name      string
	Price     int
	CreatedAt time.Time
	UpdatedAt time.Time
}

// ChangeProduct prepares data before database operation.
// Such as casting value to appropriate types and perform validations.
func ChangeProduct(product interface{}, params params.Params) *changeset.Changeset {
	ch := changeset.Cast(product, params, []string{"name", "price"})
	changeset.ValidateRequired(ch, []string{"name", "price"})
	changeset.ValidateMin(ch, "price", 100)
	return ch
}

func main() {
	// initialize mysql adapter.
	adapter, err := mysql.Open("root@(127.0.0.1:3306)/db?charset=utf8&parseTime=True&loc=Local")
	if err != nil {
		panic(err)
	}
	defer adapter.Close()

	// initialize grimoire's repo.
	repo := grimoire.New(adapter)

	var product Product

	// Inserting Products.
	// Changeset is used when creating or updating your data.
	ch := ChangeProduct(product, params.Map{
		"name":  "shampoo",
		"price": 1000,
	})

	if ch.Error() != nil {
		// handle error
	}

	// Changeset can also be created directly from json string.
	jsonch := ChangeProduct(product, params.ParseJSON(`{
		"name":  "soap",
		"price": 2000,
	}`))

	// Create products with changeset and return the result to &product,
	if err = repo.From("products").Insert(&product, ch); err != nil {
		// handle error
	}

	// or panic when insertion failed
	repo.From("products").MustInsert(&product, jsonch)

	// Querying Products.
	// Find a product with id 1.
	repo.From("products").Find(1).MustOne(&product)

	// Updating Products.
	// Update products with id=1.
	repo.From("products").Find(1).MustUpdate(&product, ch)

	// Deleting Products.
	// Delete Product with id=1.
	repo.From("products").Find(1).MustDelete()
}
```

## Examples

- [Todo API](https://github.com/Fs02/grimoire-todo-example)

## Documentation

Guides: [https://fs02.github.io/grimoire](https://fs02.github.io/grimoire)

API Documentation: [https://godoc.org/github.com/Fs02/grimoire](https://godoc.org/github.com/Fs02/grimoire)

## License

Released under the [MIT License](https://github.com/Fs02/grimoire/blob/master/LICENSE)


[![FOSSA Status](https://app.fossa.io/api/projects/git%2Bgithub.com%2FFs02%2Fgrimoire.svg?type=large)](https://app.fossa.io/projects/git%2Bgithub.com%2FFs02%2Fgrimoire?ref=badge_large)


grimoire

Blazing-fast datastore and querying engine built on Redis

Zoom

A simple package that encapsulates database operations

# dbw package
[![Go Reference](https://pkg.go.dev/badge/github.com/hashicorp/go-dbw.svg)](https://pkg.go.dev/github.com/hashicorp/go-dbw)
[![Go Report Card](https://goreportcard.com/badge/github.com/hashicorp/go-dbw)](https://goreportcard.com/report/github.com/hashicorp/go-dbw)
[![Go Coverage](https://raw.githack.com/hashicorp/go-dbw/main/coverage/coverage.svg)](https://raw.githack.com/hashicorp/go-dbw/main/coverage/coverage.html)

[dbw](https://pkg.go.dev/github.com/hashicorp/go-dbw) is a database wrapper that 
supports connecting and using any database with a
[GORM](https://github.com/go-gorm/gorm) driver.   

[dbw](https://pkg.go.dev/github.com/hashicorp/go-dbw) is intended to completely
encapsulate an application's access to its database with the exception of
migrations. [dbw](https://pkg.go.dev/github.com/hashicorp/go-dbw) is
intentionally not an ORM and it removes typical ORM abstractions like "advanced
query building", associations and migrations.    

Of course you can use [dbw](https://pkg.go.dev/github.com/hashicorp/go-dbw) for
complicated queries, it's just that
[dbw](https://pkg.go.dev/github.com/hashicorp/go-dbw) doesn't try to reinvent
SQL by providing some sort of pattern for building them with functions. Of
course, [dbw](https://pkg.go.dev/github.com/hashicorp/go-dbw) also provides
lookup/search functions when you simply need to read resources from the
database. 

[dbw](https://pkg.go.dev/github.com/hashicorp/go-dbw) strives to make CRUD for
database resources fairly trivial for common use cases. It also supports an
[WithOnConflict(...)](https://pkg.go.dev/github.com/hashicorp/go-dbw#WithOnConflict)
option for its
[RW.Create(...)](https://pkg.go.dev/github.com/hashicorp/go-dbw#RW.Create) 
function for complex scenarios. [dbw](https://pkg.go.dev/github.com/hashicorp/go-dbw) also allows you to opt out of its CRUD
functions and use exec, query and scan rows directly. You may want to carefully
weigh when it's appropriate to use exec and query directly, since it's likely that
each time you use them you're leaking a bit of your database layer schema into
your application's domain.  

* [Usage highlights](./docs/README_USAGE.md)
* [Declaring Models](./docs/README_MODELS.md)
* [Connecting to a Database](./docs/README_OPEN.md)
* [Options](./docs/README_OPTIONS.md)
* [NonCreatable and NonUpdatable](./docs/README_INITFIELDS.md)
* [Readers and Writers](./docs/README_RW.md)
* [Create](./docs/README_CREATE.md)
* [Read](./docs/README_READ.md)
* [Update](./docs/README_UPDATE.md)
* [Delete](./docs/README_DELETE.md)
* [Queries](./docs/README_QUERY.md)
* [Transactions](./docs/README_TX.md)
* [Hooks](./docs/README_HOOKS.md)
* [Optimistic locking for write operations](./docs/README_LOCKS.md)
* [Debug output](./docs/README_DEBUG.md)


go-dbw

The fantastic ORM library for Golang, aims to be developer friendly

# GORM

The fantastic ORM library for Golang, aims to be developer friendly.

[![go report card](https://goreportcard.com/badge/github.com/go-gorm/gorm "go report card")](https://goreportcard.com/report/github.com/go-gorm/gorm)
[![test status](https://github.com/go-gorm/gorm/actions/workflows/tests.yml/badge.svg)](https://github.com/go-gorm/gorm/actions)
[![MIT license](https://img.shields.io/badge/license-MIT-brightgreen.svg)](https://opensource.org/licenses/MIT)
[![Go.Dev reference](https://img.shields.io/badge/go.dev-reference-blue?logo=go&logoColor=white)](https://pkg.go.dev/gorm.io/gorm?tab=doc)

## Overview

* Full-Featured ORM
* Associations (Has One, Has Many, Belongs To, Many To Many, Polymorphism, Single-table inheritance)
* Hooks (Before/After Create/Save/Update/Delete/Find)
* Eager loading with `Preload`, `Joins`
* Transactions, Nested Transactions, Save Point, RollbackTo to Saved Point
* Context, Prepared Statement Mode, DryRun Mode
* Batch Insert, FindInBatches, Find To Map
* SQL Builder, Upsert, Locking, Optimizer/Index/Comment Hints, NamedArg, Search/Update/Create with SQL Expr
* Composite Primary Key
* Auto Migrations
* Logger
* Extendable, flexible plugin API: Database Resolver (Multiple Databases, Read/Write Splitting) / Prometheus…
* Every feature comes with tests
* Developer Friendly

## Getting Started

* GORM Guides [https://gorm.io](https://gorm.io)
* Gen Guides [https://gorm.io/gen/index.html](https://gorm.io/gen/index.html)

## Contributing

[You can help to deliver a better GORM, check out things you can do](https://gorm.io/contribute.html)

## Contributors

[Thank you](https://github.com/go-gorm/gorm/graphs/contributors) for contributing to the GORM framework!

## License

© Jinzhu, 2013~time.Now

Released under the [MIT License](https://github.com/go-gorm/gorm/blob/master/LICENSE)


GORM

SQL query builder and ORM/Factory generator for Go. Successor of SQLBoiler

# Bob: Go SQL Access Toolkit

[![Test Status](https://github.com/stephenafamo/bob/actions/workflows/test.yml/badge.svg)](https://github.com/stephenafamo/bob/actions/workflows/test.yml) ![GitHub go.mod Go version](https://img.shields.io/github/go-mod/go-version/stephenafamo/bob) [![Go Reference](https://pkg.go.dev/badge/github.com/stephenafamo/bob.svg)](https://pkg.go.dev/github.com/stephenafamo/bob) [![Go Report Card](https://goreportcard.com/badge/github.com/stephenafamo/bob)](https://goreportcard.com/report/github.com/stephenafamo/bob) ![GitHub tag (latest SemVer)](https://img.shields.io/github/v/tag/stephenafamo/bob) [![Coverage Status](https://coveralls.io/repos/github/stephenafamo/bob/badge.svg)](https://coveralls.io/github/stephenafamo/bob)

## Links

- [Documentation][docs]
- [Reference][reference]

## About

Bob is a set of Go packages and tools to work with SQL databases.

Bob's philosophy centres around the following:

1. **Correctness**: Things should work correctly. Follow specifications as closely as possible.
2. **Convenience** (not magic): Bob provides convenient ways to perform actions, it does not add unexplainable magic, or needless abstraction.
3. **Cooperation**: Bob should work well with other tools and packages as much as possible, especially the standard library.

**Bob** can be progressively adopted from raw SQL query strings, to fully typed queries with models and factories generated for your database.

## Components of Bob

**Bob** consists of several components that build on each other for the full experience.

1. Query Builder
1. SQL Executor for convenient scanning of results
1. Models for convenient database queries
1. Code generation of Models and Factories from your database schema
1. Code generation of Queries similar to [`sqlc`](https://sqlc.dev).

Check out [the documentation][docs] for more information.

## Support

|               | Queries | Models | ORM Gen | Factory Gen | Query Gen |
| ------------- | ------- | ------ | ------- | ----------- | --------- |
| Postgres      | ✅      | ✅     | ✅      | ✅          | ✅        |
| MySQL/MariaDB | ✅      | ✅     | ✅      | ✅          | ✅        |
| SQLite        | ✅      | ✅     | ✅      | ✅          | ✅        |

## Comparisons

1. [Bob vs GORM](https://bob.stephenafamo.com/vs/gorm)
1. [Bob vs Ent](https://bob.stephenafamo.com/vs/ent)
1. [Bob vs SQLBoiler](https://bob.stephenafamo.com/vs/sqlboiler)
1. [Bob vs Jet](https://bob.stephenafamo.com/vs/jet)

[docs]: https://bob.stephenafamo.com/docs
[reference]: https://pkg.go.dev/github.com/stephenafamo/bob

## The layers of Bob

### Layer 1: [The query builder](https://bob.stephenafamo.com/docs/query-builder/intro) - Similar to [squirrel](https://github.com/Masterminds/squirrel)

This is just a fluent query builder that has no concept of your DB, and by extension cannot offer any type-safety.

The main reason, I consider it better than most alternatives is that since each dialect is hand-crafted, it can support building ANY query for that dialect.

However, each dialect is also independent, so you don't have to worry about creating an invalid query.

> **IMPORTANT: Queries are built using "Query Mods"**

```go
psql.Select(
    sm.From("users"), // This is a query mod
    sm.Where(psql.Quote("age").GTE(psql.Arg(21))), // This is also a mod
)
```

### Layer 2: [ORM Code Generation](https://bob.stephenafamo.com/docs/code-generation/intro) - Similar to [SQLBoiler](https://github.com/volatiletech/sqlboiler)

This is where the type safety comes.

A full ORM, and query mods that is based on the database schema. If you use the generated query mods, these will ensure correct type safety.

Here is the above query using generated query-mods.

```go
models.Users.Query(
    models.SelectWhere.Users.Age.GTE(21), // This is type-safe
)
```

### Layer 3: [Factory Code Generation](https://bob.stephenafamo.com/docs/code-generation/factories) - Inspired by [Ruby's FactoryBot](https://github.com/thoughtbot/factory_bot)

Factories make testing much much easier. Especially when the test depends on a database entry that depends on relations in other tables (e.g. testing comments that rely on posts which in turn rely on users).

With knowledge of the database schema, Bob can generate factories for each table.

```go
// Quickly create a 10 comments (posts and users are created appropriately)
comments, err := f.NewComment().CreateMany(ctx, db, 10)
```

### Layer 4: Generating code for [SQL Queries](https://bob.stephenafamo.com/docs/code-generation/queries) - similar to [sqlc](https://github.com/sqlc-dev/sqlc)

I believe this is the final peice of the puzzle, and extends the type-safety to hand-crafted SQL queries.

For example, you could generate code for the query:

```sql
-- UserPosts
SELECT * FROM posts WHERE user_id = $1
```

This will generate a function `UserPosts` that takes an `int32`.

```go
// UserPosts
userPosts, err := queries.UserPosts(1).All(ctx, db)
```

Then, if you need to, you can add an extra filter to get only published posts.

However whether it is type safe or not depends on if you use the generated mods or not:

```go
// Get only published posts
query := psql.Select(
    UserPosts(1),
    models.PostWhere.Status.EQ("published"), // type-safe
    sm.Where(psql.Quote("posts", "status").Eq(psql.Arg("published"))), // not type-safe
)
```

## Development

### Nix

You can get all the tools you need for developing against this repository with [nix](https://nixos.org/). Use `nix-shell` in the root of the repository to get a shell with all the dependencies and tools for development.

### Lint

This repository uses [golangci-lint](https://github.com/golangci/golangci-lint) for linting. You can run the linter with:

```
$ golangci-lint run
```

Before submitting pull requests you should ensure that your changes lint clean:

```
$ golangci-lint run
0 issues.
```

### Formatting

This repository uses [gofumpt](https://github.com/mvdan/gofumpt) for formatting. It's more strict than `go fmt`. The linter will fail if you haven't formatted for code correctly. You can format your code with:

```
$ gofumpt -l -w ./some/file
```

### Test

You can test this repository using [go test](https://pkg.go.dev/testing). A simple test of a single module can be run with:

```
$ go test ./dialect/psql/
```

A comprehensive test of all modules could be done with:

```
$ go test ./...
```

If you're interested in data [race detection](https://go.dev/doc/articles/race_detector) and [coverage](https://go.dev/blog/integration-test-coverage), both of which are done by the Github workflow prior to merging code, you'll need to add a few more arguments:

```
$ go test -race -covermode atomic --coverprofile=covprofile.out -coverpkg=github.com/stephenafamo/bob/... ./...
```

### Workflows

The project uses [Github Actions](https://docs.github.com/en/actions) as defined in [.github/workflows](.github/workflows). Pull requests are expected to pass linting and testing workflows before being accepted.

## Contributing

Thanks to all the people who have contributed to Bob!

[![contributors](https://contributors-img.web.app/image?repo=stephenafamo/bob)](https://github.com/stephenafamo/bob/graphs/contributors)


# Bun: SQL-first Golang ORM

[![build workflow](https://github.com/uptrace/bun/actions/workflows/build.yml/badge.svg)](https://github.com/uptrace/bun/actions)
[![PkgGoDev](https://pkg.go.dev/badge/github.com/uptrace/bun)](https://pkg.go.dev/github.com/uptrace/bun)
[![Documentation](https://img.shields.io/badge/bun-documentation-informational)](https://bun.uptrace.dev/)
[![Chat](https://discordapp.com/api/guilds/752070105847955518/widget.png)](https://discord.gg/rWtp5Aj)
[![Gurubase](https://img.shields.io/badge/Gurubase-Ask%20Bun%20Guru-006BFF)](https://gurubase.io/g/bun)

**Lightweight, SQL-first Golang ORM for PostgreSQL, MySQL, MSSQL, SQLite, and Oracle**

Bun is a modern ORM that embraces SQL rather than hiding it. Write complex queries in Go with type
safety, powerful scanning capabilities, and database-agnostic code that works across multiple SQL
databases.

## ✨ Key Features

- **SQL-first approach** - Write elegant, readable queries that feel like SQL
- **Multi-database support** - PostgreSQL, MySQL/MariaDB, MSSQL, SQLite, and Oracle
- **Type-safe operations** - Leverage Go's static typing for compile-time safety
- **Flexible scanning** - Query results into structs, maps, scalars, or slices
- **Performance optimized** - Built on `database/sql` with minimal overhead
- **Rich relationships** - Define complex table relationships with struct tags
- **Production ready** - Migrations, fixtures, soft deletes, and OpenTelemetry support

## 🚀 Quick Start

```bash
go get github.com/uptrace/bun
```

### Basic Example

```go
package main

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

    "github.com/uptrace/bun"
    "github.com/uptrace/bun/dialect/sqlitedialect"
    "github.com/uptrace/bun/driver/sqliteshim"
)

func main() {
    ctx := context.Background()

    // Open database
    sqldb, err := sql.Open(sqliteshim.ShimName, "file::memory:")
    if err != nil {
        panic(err)
    }

    // Create Bun instance
    db := bun.NewDB(sqldb, sqlitedialect.New())

    // Define model
    type User struct {
        ID   int64  `bun:",pk,autoincrement"`
        Name string `bun:",notnull"`
    }

    // Create table
    db.NewCreateTable().Model((*User)(nil)).Exec(ctx)

    // Insert user
    user := &User{Name: "John Doe"}
    db.NewInsert().Model(user).Exec(ctx)

    // Query user
    err = db.NewSelect().Model(user).Where("id = ?", user.ID).Scan(ctx)
    fmt.Printf("User: %+v\n", user)
}
```

## 🎯 Why Choose Bun?

### Elegant Complex Queries

Write sophisticated queries that remain readable and maintainable:

```go
regionalSales := db.NewSelect().
    ColumnExpr("region").
    ColumnExpr("SUM(amount) AS total_sales").
    TableExpr("orders").
    GroupExpr("region")

topRegions := db.NewSelect().
    ColumnExpr("region").
    TableExpr("regional_sales").
    Where("total_sales > (SELECT SUM(total_sales) / 10 FROM regional_sales)")

var results []struct {
    Region       string `bun:"region"`
    Product      string `bun:"product"`
    ProductUnits int    `bun:"product_units"`
    ProductSales int    `bun:"product_sales"`
}

err := db.NewSelect().
    With("regional_sales", regionalSales).
    With("top_regions", topRegions).
    ColumnExpr("region, product").
    ColumnExpr("SUM(quantity) AS product_units").
    ColumnExpr("SUM(amount) AS product_sales").
    TableExpr("orders").
    Where("region IN (SELECT region FROM top_regions)").
    GroupExpr("region, product").
    Scan(ctx, &results)
```

### Flexible Result Scanning

Scan query results into various Go types:

```go
// Into structs
var users []User
db.NewSelect().Model(&users).Scan(ctx)

// Into maps
var userMaps []map[string]interface{}
db.NewSelect().Table("users").Scan(ctx, &userMaps)

// Into scalars
var count int
db.NewSelect().Table("users").ColumnExpr("COUNT(*)").Scan(ctx, &count)

// Into individual variables
var id int64
var name string
db.NewSelect().Table("users").Column("id", "name").Limit(1).Scan(ctx, &id, &name)
```

## 📊 Database Support

| Database      | Driver                                     | Dialect               |
| ------------- | ------------------------------------------ | --------------------- |
| PostgreSQL    | `github.com/uptrace/bun/driver/pgdriver`   | `pgdialect.New()`     |
| MySQL/MariaDB | `github.com/go-sql-driver/mysql`           | `mysqldialect.New()`  |
| SQLite        | `github.com/uptrace/bun/driver/sqliteshim` | `sqlitedialect.New()` |
| SQL Server    | `github.com/denisenkom/go-mssqldb`         | `mssqldialect.New()`  |
| Oracle        | `github.com/sijms/go-ora/v2`               | `oracledialect.New()` |

## 🔧 Advanced Features

### Table Relationships

Define complex relationships with struct tags:

```go
type User struct {
    ID      int64   `bun:",pk,autoincrement"`
    Name    string  `bun:",notnull"`
    Posts   []Post  `bun:"rel:has-many,join:id=user_id"`
    Profile Profile `bun:"rel:has-one,join:id=user_id"`
}

type Post struct {
    ID     int64 `bun:",pk,autoincrement"`
    Title  string
    UserID int64
    User   *User `bun:"rel:belongs-to,join:user_id=id"`
}

// Load users with their posts
var users []User
err := db.NewSelect().
    Model(&users).
    Relation("Posts").
    Scan(ctx)
```

### Bulk Operations

Efficient bulk operations for large datasets:

```go
// Bulk insert
users := []User{{Name: "John"}, {Name: "Jane"}, {Name: "Bob"}}
_, err := db.NewInsert().Model(&users).Exec(ctx)

// Bulk update with CTE
_, err = db.NewUpdate().
    Model(&users).
    Set("updated_at = NOW()").
    Where("active = ?", true).
    Exec(ctx)

// Bulk delete
_, err = db.NewDelete().
    Model((*User)(nil)).
    Where("created_at < ?", time.Now().AddDate(-1, 0, 0)).
    Exec(ctx)
```

### Migrations

Version your database schema:

```go
import "github.com/uptrace/bun/migrate"

migrations := migrate.NewMigrations()

migrations.MustRegister(func(ctx context.Context, db *bun.DB) error {
    _, err := db.NewCreateTable().Model((*User)(nil)).Exec(ctx)
    return err
}, func(ctx context.Context, db *bun.DB) error {
    _, err := db.NewDropTable().Model((*User)(nil)).Exec(ctx)
    return err
})

migrator := migrate.NewMigrator(db, migrations)
err := migrator.Init(ctx)
err = migrator.Up(ctx)
```

## 📈 Monitoring & Observability

### Debug Queries

Enable query logging for development:

```go
import "github.com/uptrace/bun/extra/bundebug"

db.AddQueryHook(bundebug.NewQueryHook(
    bundebug.WithVerbose(true),
))
```

### OpenTelemetry Integration

Production-ready observability with distributed tracing:

```go
import "github.com/uptrace/bun/extra/bunotel"

db.AddQueryHook(bunotel.NewQueryHook(
    bunotel.WithDBName("myapp"),
))
```

> **Monitoring made easy**: Bun is brought to you by ⭐
> [**uptrace/uptrace**](https://github.com/uptrace/uptrace). Uptrace is an open-source APM tool that
> supports distributed tracing, metrics, and logs. You can use it to monitor applications and set up
> automatic alerts to receive notifications via email, Slack, Telegram, and others.
>
> See [OpenTelemetry example](example/opentelemetry) which demonstrates how you can use Uptrace to
> monitor Bun.

## 📚 Documentation & Resources

- **[Getting Started Guide](https://bun.uptrace.dev/guide/golang-orm.html)** - Comprehensive
  tutorial
- **[API Reference](https://pkg.go.dev/github.com/uptrace/bun)** - Complete package documentation
- **[Examples](https://github.com/uptrace/bun/tree/master/example)** - Working code samples
- **[Starter Kit](https://github.com/go-bun/bun-starter-kit)** - Production-ready template
- **[Community Discussions](https://github.com/uptrace/bun/discussions)** - Get help and share ideas

## 🤝 Contributing

We welcome contributions! Please see our [Contributing Guide](CONTRIBUTING.md) for details on how to
get started.

**Thanks to all our contributors:**

<a href="https://github.com/uptrace/bun/graphs/contributors">
  <img src="https://contributors-img.web.app/image?repo=uptrace/bun" alt="Contributors" />
</a>

## 🔗 Related Projects

- **[Golang HTTP router](https://github.com/uptrace/bunrouter)** - Fast and flexible HTTP router
- **[Golang msgpack](https://github.com/vmihailenco/msgpack)** - High-performance MessagePack
  serialization

---

<div align="center">
  <strong>Star ⭐ this repo if you find Bun useful!</strong><br>
  <sub>Join our community on <a href="https://discord.gg/rWtp5Aj">Discord</a> • Follow updates on <a href="https://github.com/uptrace/bun">GitHub</a></sub>
</div>


Schema based, typed Redis caching/memoize framework for Go

# cacheme - Redis Caching Framework For Go
![example workflow](https://github.com/Yiling-J/cacheme-go/actions/workflows/go.yml/badge.svg)
![Go Report Card](https://goreportcard.com/badge/github.com/Yiling-J/cacheme-go?style=flat-square)
[![Mentioned in Awesome Go](https://awesome.re/mentioned-badge-flat.svg)](https://github.com/avelino/awesome-go#orm)

[English](README.md) | [中文](README_zh.md)

- **Statically Typed** - 100% statically typed using code generation. Drop-in replacement, no reflect/type-assertion.
- **Scale Efficiently** - thundering herd protection via pub/sub.
- **Cluster Support** - same API for redis & redis cluster.
- **Memoize** - dynamic key params based on code generation.
- **Versioning** - cache versioning for better management.
- **Pipeline** - reduce io cost by redis pipeline.

🌀 Read this first: [Caches, Promises and Locks](https://redis.com/blog/caches-promises-locks/). This is how caching part works in cacheme.

🌀 Real world example with [Echo](https://github.com/labstack/echo) and [Ent](https://github.com/ent/ent): https://github.com/Yiling-J/echo-ent-cacheme-example
```go
// old
id, err := strconv.ParseInt(c.Param("id"), 10, 64)
comment, err := ent.Comment.Get(context.Background(), int(id))

// new
comment, err := cacheme.CommentCacheStore.Get(c.Request().Context(), c.Param("id"))
```

## Installation
```console
go get github.com/Yiling-J/cacheme-go/cmd
```
After installing `cacheme-go` codegen, go to the root directory(or the directory you think cacheme should stay) of your project, and run:
```console
go run github.com/Yiling-J/cacheme-go/cmd init
```
The command above will generate `cacheme` directory under current directory:
```console {12-20}
└── cacheme
    ├── fetcher
    │   └── fetcher.go
    └── schema
        └── schema.go
```
It's up to you where the cacheme directory should be, just remember to use the right directory in **Store Generation** step.

## Add Schema
Edit `schema.go` and add some schemas:
```go
package schema

import (
	"time"
	cacheme "github.com/Yiling-J/cacheme-go"
)

var (
	// default prefix for redis keys
	Prefix = "cacheme"
	// store schemas
	Stores = []*cacheme.StoreSchema{
		{
			Name:         "Simple",
			Key:          "simple:{{.ID}}",
			To:           "",
			Version:      1,
			TTL:          5 * time.Minute,
			Singleflight: false,
			MetaData: false,
		},
	}
)
```

More details [here](#schema-definition)

## Store Generation
Run code generation from the root directory of the project as follows:
```console
# this will use default schema path ./cacheme/schema
go run github.com/Yiling-J/cacheme-go/cmd generate
```
Or you can use custom schema path:
```console
go run github.com/Yiling-J/cacheme-go/cmd generate ./yours/cacheme/schema
```

This produces the following files:
```console {12-20}
└── cacheme
    ├── fetcher
    │   └── fetcher.go
    ├── schema
    │   └── schema.go
    ├── store
    │   ├── base.go
    │   └── simple.go
    └── store.go
```
If you update schema, just run `generate` again.

## Add Fetcher
Each cache store can provide a fetch function in `fetcher.go`, you should call this `Setup` function before create client:
```go
import "your/cacheme/store"

func Setup() {
	store.SimpleCacheStore.Fetch = func(ctx context.Context, ID string) (string, error) {
		return ID, nil
	}
}
```
**You can setup fetch functions in any place, using any pattern, not restricted to this file. Just make sure you have a fetch function when using store.**

## Use Your Stores

### Create client and setup fetcher
```go
import (
	"your_project/cacheme"
	"your_project/cacheme/fetcher"
)

func main() {
	// setup fetcher
	fetcher.Setup()
	// create client
	client := cacheme.New(
		redis.NewClient(&redis.Options{
			Addr:     "localhost:6379",
			Password: "",
			DB:       0,
		}),
	)
	// or cluster client
	client := cacheme.NewCluster(
		redis.NewClusterClient(&redis.ClusterOptions{
			Addrs: []string{
				":7000",
				":7001",
				":7002"},
		}),
	)
}
```
### Store API
#### Get single result: `Get`
Get cached result. If not in cache, call fetch function and store data to Redis.
```go
// "foo" is the {{.ID}} part of the schema
result, err := client.SimpleCacheStore.Get(ctx, "foo")
```
#### Get pipeline results: `GetP`
Get multiple keys from multiple stores using pipeline.
For each key, if not in cache, call fetch function and store data to Redis.
- single store
```go
pipeline := client.NewPipeline()
ids := []string{"1", "2", "3", "4"}
var ps []*store.SimplePromise
for _, i := range ids {
	promise, err := client.SimpleCacheStore.GetP(ctx, pipeline, i)
	ps = append(ps, promise)
}
err = pipeline.Execute(ctx)
fmt.Println(err)

for _, promise := range ps {
	r, err := promise.Result()
	fmt.Println(r, err)
}
```
Consider using `GetM` API for single store, see `GetM` example below.

- multiple stores
```go
// same pipeline for different stores
pipeline := client.NewPipeline()

ids := []string{"1", "2", "3", "4"}
var ps []*store.SimplePromise // cache string
var psf []*store.FooPromise // cache model.Foo struct
for _, i := range ids {
	promise, err := client.SimpleCacheStore.GetP(ctx, pipeline, i)
	ps = append(ps, promise)
}
for _, i := range ids {
	promise, err := client.FooCacheStore.GetP(ctx, pipeline, i)
	psf = append(psf, promise)
}
// execute only once
err = pipeline.Execute(ctx)
// simple store results
for _, promise := range ps {
	r, err := promise.Result()
	fmt.Println(r, err)
}
// foo store results
for _, promise := range psf {
	r, err := promise.Result()
	fmt.Println(r, err)
}

```
#### Get multiple results from single store: `GetM`
Get multiple keys from same store, also using Redis pipeline.
For each key, if not in cache, call fetch function and store data to Redis.
```go
qs, err := client.SimpleCacheStore.GetM("foo").GetM("bar").GetM("xyz").Do(ctx)
// qs is a queryset struct, support two methods: GetSlice and Get
// GetSlice return ordered results slice
r, err := qs.GetSlice() // r: {foo_result, bar_result, xyz_result}
// Get return result of given param
r, err := qs.Get("foo") // r: foo_result
r, err := qs.Get("bar") // r: bar_result
r, err := qs.Get("fake") // error, because "fake" not in queryset
```
You can also initialize a getter using `MGetter`
```go
getter := client.SimpleCacheStore.MGetter()
for _, id := range ids {
	getter.GetM(id)
}
qs, err := getter.Do(c.Request().Context())
```
#### Invalid single cache: `Invalid`
```go
err := client.SimpleCacheStore.Invalid(ctx, "foo")
```
#### Update single cache: `Update`
```go
err := client.SimpleCacheStore.Update(ctx, "foo")
```
#### Invalid all keys: `InvalidAll`
Only works when you enable `MetaData` option in schema.
```go
// invalid all version 1 simple cache
client.SimpleCacheStore.InvalidAll(ctx, "1")
```

## Schema Definition
Each schema has 5 fields:
- **Name** - store name, will be struct name in generated code, capital first.
- **Key** - key with variable using **go template syntax**, Variable name will be used in code generation.
- **To** - cached value, type of value will be used in code generation. Examples:
	- string: `""`
	- int: `1`
	- struct: `model.Foo{}`
	- struct pointer: `&model.Foo{}`
	- slice: `[]model.Foo{}`
	- map: `map[model.Foo]model.Bar{}`
- **Version** - version interface, can be `string`, `int`, or callable `func() string`.
- **TTL** - redis ttl using go time.
- **Singleflight** - bool, if `true`, concurrent requests to **same key** on **same executable** will call Redis only once
- **MetaData** - bool, if `true`, each store will save all generated keys to a Redis Set, so `InvalidAll` method can work.

#### Notes:
- Duplicate name/key is not allowed.
- Everytime you update schema, run code generation again.
- Not all store API support `Singleflight` option:
	- `Get`: support.
	- `GetM`: support. singleflight key will be the combination of all keys, order by alphabetical.
	```go
	// these two will use same singleflight group key
	store.GetM("foo").GetM("bar").GetM("xyz").Do(ctx)
	Store.GetM("bar").GetM("foo").GetM("xyz").Do(ctx)
	```
	- `GetP`: not support.
- `Version` callable can help you managing version better. Example:
	```go
	// models.go
	const FooCacheVersion = "1"
	type Foo struct {}
	const BarCacheVersion = "1"
	type Bar struct {Foo: Foo}
	```
	```go
	// schema.go
	// version has 3 parts: foo version & bar version & global version number
	// if you change struct, update FooCacheVersion or BarCacheVersion
	// if you change fetcher function or ttl or something else, change global version number
	{
		Name:    "Bar",
		Key:     "bar:{{.ID}}:info",
		To:      model.Bar{},
		Version: func() string {return model.FooCacheVersion + model.BarCacheVersion + "1"},
		TTL:     5 * time.Minute,
	},
	```
- If set `Singleflight` to `true`, Cacheme `Get` command will be wrapped in a [**singleflight**](https://pkg.go.dev/golang.org/x/sync/singleflight), so **concurrent requests to same key** will call `Redis` only once. Let's use some example to explain this:
	- you have some products to sell, and thousands people will view the detail at same time, so the product key `product:1:info` may be hit 100000 times per second. Now you should turn on **singleflight**, and the actually redis hit may reduce to 5000.
	- you have cache for user shopping cart `user:123:cart`, only the user himself can see that. Now no need to use **singleflight**, becauese there shouldn't be concurrent requests to that key.
	- you are using serverless platform, AWS Lambda or similar. So each request runs in isolated environment, can't talk to each other through channels. Then **singleflight** make no sense.
- Full redis key has 3 parts: **prefix** + **schema key** + **version**.
	Schema Key`category:{{.categoryID}}:book:{{.bookID}}` with prefix `cacheme`, version 1 will generate key:
	```
	cacheme:category:1:book:3:v1
	```
	Also you will see `categoryID` and `bookID` in generated code, as fetch func params.

## Logger
You can use custom logger with cacheme, your logger should implement cacheme logger interface:
```go
type Logger interface {
	Log(store string, key string, op string)
}
```
Here `store` is the store tag, `key` is cache key without prefix, `op` is operation type.
Default logger is `NOPLogger`, just return and do nothing.

#### Set client logger:
```go
logger := &YourCustomLogger{}
client.SetLogger(logger)
```
#### Operation Types:
 - **HIT**: cache hit to redis, if you enable singleflight, grouped requests only log once.
 - **MISS**: cache miss
 - **FETCH**: fetch data from fetcher

## Performance
Parallel benchmarks of Cacheme
 - params: 10000/1000000 hits, 10 keys loop, TTL 10s, `SetParallelism(100)`, singleflight on
```
cpu: Intel(R) Core(TM) i7-9750H CPU @ 2.60GHz
BenchmarkCachemeGetParallel-12    	   10000	    198082 ns/op
BenchmarkCachemeGetParallel-12    	 1000000	      9501 ns/op
```


cacheme

Built on top of GORM, adds compile-time verified queries based on auto-generated code

# CQL: Compiled Query Language 

[![Build Status](https://github.com/FrancoLiberali/cql/actions/workflows/cql.yml/badge.svg?branch=main)](https://github.com/FrancoLiberali/cql/actions)
[![Go Report Card](https://goreportcard.com/badge/github.com/FrancoLiberali/cql)](https://goreportcard.com/report/github.com/FrancoLiberali/cql)
[![Quality Gate Status](https://sonarcloud.io/api/project_badges/measure?project=FrancoLiberali_cql&metric=alert_status)](https://sonarcloud.io/summary/new_code?id=FrancoLiberali_cql)
[![Coverage](https://sonarcloud.io/api/project_badges/measure?project=FrancoLiberali_cql&metric=coverage)](https://sonarcloud.io/summary/new_code?id=FrancoLiberali_cql)
[![Mentioned in Awesome Go](https://awesome.re/mentioned-badge.svg)](https://github.com/avelino/awesome-go)

[![Go.Dev reference](https://img.shields.io/badge/go.dev-reference-blue?logo=go&logoColor=white)](https://pkg.go.dev/github.com/FrancoLiberali/cql)
[![Documentation Status](https://readthedocs.org/projects/compiledquerylenguage/badge/?version=latest)](https://compiledquerylenguage.readthedocs.io/en/latest/?badge=latest)



## What is cql?

CQL is a SQL query language that allows easy and safe persistence and querying of objects, with the following characteristics:

- Is compile-time safe: queries are validated at compile time to avoid errors such as comparing attributes that are of different types, trying to use attributes or navigate relationships that do not exist, using information from tables that are not included in the query, etc.; ensuring that a runtime error will not be raised.
- Is easy to use: the use of its query system does not require knowledge of databases, SQL languages or complex concepts. Writing queries only requires programming in Go and the result is easy to read.
- Is designed for real applications: the query system is designed to work well in real-world cases where queries are complex, require navigating multiple relationships, performing multiple comparisons, etc.
- Is designed so that developers can focus on the business model: its queries allow easy retrieval of model relationships to apply business logic to the model and it provides mechanisms to avoid errors in the business logic due to mistakes in loading information from the database.
- It is designed for high performance: the query system avoids as much as possible the use of reflection and aims that all the necessary model data can be retrieved in a single query to the database.

| Language | Query |
|---|---|
| SQL | SELECT cities.* FROM cities <br> INNER JOIN countries ON <br>&emsp;&emsp; countries.id = cities.country_id AND <br>&emsp;&emsp; countries.name = "France" <br> WHERE cities.name = "Paris" |
| GORM | db.Where(<br>&emsp;"cities.name = ?",<br>&emsp;"Paris",<br>).Joins(<br>&emsp;"Country",<br>&emsp;db.Where( <br>&emsp;&emsp; "Country.name = ?", <br>&emsp;&emsp; "France", <br>&emsp; ), <br> ).Find(&cities) |
| CQL | cql.Query[models.City]( <br>&emsp; context.Background(), <br>&emsp; db, <br>&emsp; conditions.City.Name.Is().Eq(cql.String("Paris")), <br>&emsp; conditions.City.Country( <br>&emsp;&emsp; conditions.Country.Name.Is().Eq(cql.String("France")), <br>&emsp; ), <br> ).FindOne() |

## Is cql an ORM?

CQL built on top of [gorm](https://gorm.io/), a library that actually provides the functionality of an ORM: mapping objects to tables in the SQL database. While gorm does this job well with its automatic migration then performing queries on these objects is somewhat limited, forcing us to write SQL queries directly when they are complex.

CQL uses gorm for connecting to the database, generating queries in SQL format, and mapping values to structures in Go. On this basis, CQL builds a query language rather than an ORM, allowing us to work with both business entities and independent values.

## Is cql a copy of [gorm-gen](https://gorm.io/gen/)?

It is true that its aim seems to be the same:

> 100% Type-safe DAO API without interface{}

Although gorm-gen provides a more structured API than gorm for performing queries, providing methods like:

```go
Where(conds ...gen.Condition) IUserDo
```

we can see from this signatures that, for example, the Where method receives parameters of type gen.Condition. In this way, conditions from different models could be mixed without generating a compilation error:

```go
u := query.User
c := query.Company
user, err := u.Where(c.Name.Eq("franco")).First()
```

which would generate a runtime error during the execution of the generated SQL:

```
SELECT * FROM `users` WHERE `companies`.`name` = "franco"
no such column: companies.name
```

Because of this, cql decides to go further in type safety and check that the conditions are of the correct model, that the compared values are of the same type, that the models are included in the query and more, ensuring that a runtime error will not be raised.

## Documentation

<https://compiledquerylenguage.readthedocs.io/en/latest/>

## Contributing

See [this section](./docs/contributing/contributing.md) to view the cql contribution guidelines.

## License

CQL is Licensed under the [Mozilla Public License Version 2.0](../LICENSE).

An entity framework for Go. Simple, yet powerful ORM for modeling and querying data

## ent - An Entity Framework For Go

[![Twitter](https://img.shields.io/twitter/url/https/twitter.com/entgo_io.svg?style=social&label=Follow%20%40entgo_io)](https://twitter.com/entgo_io)
[![Discord](https://img.shields.io/discord/885059418646003782?label=discord&logo=discord&style=flat-square&logoColor=white)](https://discord.gg/qZmPgTE6RX)

[English](README.md) | [中文](README_zh.md) | [日本語](README_jp.md) | [한국어](README_kr.md)

<img width="50%"
align="right"
style="display: block; margin:40px auto;"
src="https://s3.eu-central-1.amazonaws.com/entgo.io/assets/gopher_graph.png"/>

Simple, yet powerful entity framework for Go, that makes it easy to build and maintain applications
with large data-models.

- **Schema As Code** - model any database schema as Go objects.
- **Easily Traverse Any Graph** - run queries, aggregations and traverse any graph structure easily.
- **Statically Typed And Explicit API** - 100% statically typed and explicit API using code generation.
- **Multi Storage Driver** - supports MySQL, MariaDB, TiDB, PostgreSQL, CockroachDB, SQLite and Gremlin.
- **Extendable** - simple to extend and customize using Go templates.

## Quick Installation
```console
go install entgo.io/ent/cmd/ent@latest
```

For proper installation using [Go modules], visit [entgo.io website][entgo install].

## Docs and Support
The documentation for developing and using ent is available at: https://entgo.io

For discussion and support, [open an issue](https://github.com/ent/ent/issues/new/choose) or join our [Discord server](https://discord.gg/qZmPgTE6RX).

## Developed and Sponsored by the [Atlas](https://atlasgo.io) Team

[![image](https://github.com/user-attachments/assets/2a35b1b7-325f-4844-a2d7-d450c60de0dc)](https://atlasgo.io?utm_source=ent-readme)

## About the Project
The `ent` project was inspired by Ent, an entity framework used internally at Meta (Facebook). It was created by [a8m](https://github.com/a8m) and [alexsn](https://github.com/alexsn) from the [Facebook Connectivity][fbc] team. These days, it is developed and maintained by the [Atlas](https://github.com/ariga/atlas) team, and the roadmap for its v1 release is described [here](https://github.com/ent/ent/issues/46).

## Join the ent Community
Building `ent` would not have been possible without the collective work of our entire community. We maintain a [contributors page](doc/md/contributors.md)
which lists the contributors to this `ent`. 

In order to contribute to `ent`, see the [CONTRIBUTING](CONTRIBUTING.md) file for how to go get started.
If your company or your product is using `ent`, please let us know by adding yourself to the [ent users page](https://github.com/ent/ent/wiki/ent-users).

For updates, follow us on Twitter at https://twitter.com/entgo_io

## License
ent is licensed under Apache 2.0 as found in the [LICENSE file](LICENSE).


[entgo install]: https://entgo.io/docs/code-gen/#version-compatibility-between-entc-and-ent
[Go modules]: https://github.com/golang/go/wiki/Modules#quick-start
[fbc]: https://connectivity.fb.com


A simple ORM for Google/Firebase Cloud Firestore

[![pipeline status](https://gitlab.com/jens.schoedt/go-firestorm/badges/master/pipeline.svg)](https://gitlab.com/jens.schoedt/go-firestorm/commits/master)
[![coverage report](https://gitlab.com/jens.schoedt/go-firestorm/badges/master/coverage.svg)](https://gitlab.com/jens.schoedt/go-firestorm/commits/master)
[![Go Report Card](https://goreportcard.com/badge/github.com/jschoedt/go-firestorm)](https://goreportcard.com/report/github.com/jschoedt/go-firestorm)
[![GoDoc](https://godoc.org/github.com/jschoedt/go-firestorm?status.svg)](https://godoc.org/github.com/jschoedt/go-firestorm)
[![GitHub](https://img.shields.io/github/license/jschoedt/go-firestorm)](https://github.com/jschoedt/go-firestorm/blob/master/LICENSE)

# go-firestorm
Go ORM ([Object-relational mapping](https://en.wikipedia.org/wiki/Object-relational_mapping)) for [Google Cloud Firestore](https://cloud.google.com/firestore/).

#### Goals
1. Easy to use
2. Non-intrusive
4. Non-exclusive
3. Fast

#### Features
- Basic CRUD operations
- Search
- Concurrent requests support (except when run in transactions)
- Transactions
- Nested transactions will reuse the first transaction (reads before writes as required by firestore)
- Configurable auto load of references
- Handles cyclic references
- Sub collections
- Supports embedded/anonymous structs
- Supports unexported fields
- Custom mappers between fields and types
- Caching (session + second level)
- Supports Google App Engine - 2. Gen (go version >= 1.11)


## Getting Started

* [Prerequisites](#prerequisites)
* [Basic CRUD example](#basic-crud-example)
* [Search](#search)
* [Concurrent requests](#concurrent-requests)
* [Transactions](#transactions)
* [Cache](#cache)
* [Configurable auto load of references](#configurable-auto-load-of-references)
* [Customize data mapping](#customize-data-mapping)
* [Help](#help)


#### Prerequisites

This library only supports Firestore Native mode and not the old [Datastore](https://cloud.google.com/datastore/docs/firestore-or-datastore) mode.
```
go get -u github.com/jschoedt/go-firestorm
```

#### Setup

1. [Setup a Firestore client](https://firebase.google.com/docs/firestore/quickstart#set_up_your_development_environment)
2. Create a firestorm client and supply the names of the id and parent fields of your model structs.
Parent is optional. The id field must be a string but can be called anything.
```go
...
client, _ := app.Firestore(ctx)
fsc := firestorm.New(client, "ID", "")
```
3. Optional. For optimal caching to work consider adding the [CacheHandler](#cache).


#### Basic CRUD example

**Note:** Recursive Create/Delete is not supported and must be called on every entity. So to create an A->B relation. Create B first so the B.ID has been created and then create A.

```go
type Car struct {
	ID         string
	Make       string
	Year       time.Time
}
```
```go
car := &Car{}
car.Make = "Toyota"
car.Year, _ = time.Parse(time.RFC3339, "2001-01-01T00:00:00.000Z")

// Create the entity
fsc.NewRequest().CreateEntities(ctx, car)()

if car.ID == "" {
    t.Errorf("car should have an auto generated ID")
}

// Read the entity by ID
otherCar := &Car{ID:car.ID}
fsc.NewRequest().GetEntities(ctx, otherCar)()
if otherCar.Make != "Toyota" {
    t.Errorf("car should have name: Toyota but was: %s", otherCar.Make)
}
if otherCar.Year != car.Year {
    t.Errorf("car should have same year: %s", otherCar.Year)
}

// Update the entity
car.Make = "Jeep"
fsc.NewRequest().UpdateEntities(ctx, car)()

otherCar := &Car{ID:car.ID}
fsc.NewRequest().GetEntities(ctx, otherCar)()
if otherCar.Make != "Jeep" {
    t.Errorf("car should have name: Jeep but was: %s", otherCar.Make)
}

// Delete the entity
fsc.NewRequest().DeleteEntities(ctx, car)()

otherCar = &Car{ID:car.ID}
if err := fsc.NewRequest().GetEntities(ctx, otherCar)(); err == nil {
    t.Errorf("We expect a NotFoundError")
}
```
[More examples](https://github.com/jschoedt/go-firestorm/blob/master/tests/integration_test.go)

#### Search
Create a query using the firebase client

```go
car := &Car{}
car.ID = "testID"
car.Make = "Toyota"

fsc.NewRequest().CreateEntities(ctx, car)()

query := fsc.Client.Collection("Car").Where("make", "==", "Toyota")

result := make([]Car, 0)
if err := fsc.NewRequest().QueryEntities(ctx, query, &result)(); err != nil {
    t.Errorf("car was not found by search: %v", car)
}

if result[0].ID != car.ID || result[0].Make != car.Make {
    t.Errorf("entity did not match original entity : %v", result)
}
```
[More examples](https://github.com/jschoedt/go-firestorm/blob/master/tests/integration_test.go)

#### Concurrent requests
All CRUD operations are asynchronous and return a future func that when called will block until the operation is done.

**NOTE:** the state of the entities is undefined until the future func returns.
```go
car := &Car{Make:"Toyota"}

// Create the entity which returns a future func
future := fsc.NewRequest().CreateEntities(ctx, car)

// ID is not set
if car.ID != "" {
	t.Errorf("car ID should not have been set yet")
}

// do some more work

// blocks and waits for the database to finish
future()

// now the car has been saved and the ID has been set
if car.ID == "" {
    t.Errorf("car should have an auto generated ID now")
}
```
[More examples](https://github.com/jschoedt/go-firestorm/blob/master/tests/integration_test.go)

#### Transactions
Transactions are simply done in a function using the transaction context

```go
car := &Car{Make: "Toyota"}

fsc.DoInTransaction(ctx, func(transCtx context.Context) error {

    // Create the entity in the transaction using the transCtx
    fsc.NewRequest().CreateEntities(transCtx, car)()

    // Using the transCtx we can load the entity as it is saved in the session context
    otherCar := &Car{ID:car.ID}
    fsc.NewRequest().GetEntities(transCtx, otherCar)()
    if otherCar.Make != car.Make {
        t.Errorf("The car should have been saved in the transaction context")
    }

    // Loading using an other context (request) will fail as the car is not created until the func returns successfully
    if err := fsc.NewRequest().GetEntities(ctx, &Car{ID:car.ID})(); err == nil {
        t.Errorf("We expect a NotFoundError")
    }
})

// Now we can load the car as the transaction has been committed
otherCar := &Car{ID:car.ID}
fsc.NewRequest().GetEntities(ctx, otherCar)()
if otherCar.Make != "Toyota" {
    t.Errorf("car should have name: Toyota but was: %s", otherCar.Make)
}

```

[More examples](https://github.com/jschoedt/go-firestorm/blob/master/tests/integration_test.go)

#### Cache
Firestorm supports adding a session cache to the context.
The session cache only caches entities that are loaded within the same request.
```go
# add it to a single handler:
http.HandleFunc("/", firestorm.CacheHandler(otherHandler))
# or add it to the routing chain (for gorilla/mux, go-chi etc.):
r.Use(firestorm.CacheMiddleware)
```

To add a second level cache (such as Redis or memcache) the Cache interface needs to be implemented and added to the client:
```go
fsc.SetCache(c)
```

Firestore will first try to fetch an entity from the session cache. If it is not found it will try the second level cache.

#### Configurable auto load of references

Use the ```req.SetLoadPaths("fieldName")``` to auto load a particular field or ```req.SetLoadPaths(firestorm.AllEntities)``` to load all fields.

Load an entity path by adding multiple paths eg.: path->to->field

```go
fsc.NewRequest().SetLoadPaths("path", "path.to", "path.to.field").GetEntities(ctx, car)()
```

[More examples](https://github.com/jschoedt/go-firestorm/blob/master/tests/integration_test.go)

#### Customize data mapping
This library uses [go-structmapper](https://github.com/jschoedt/go-structmapper) for mapping values between Firestore and structs. The mapping can be customized by setting the
mappers:

```go
fsc.MapToDB = mapper.New()
fsc.MapFromDB = mapper.New()
```

#### Help

Help is provided in the [go-firestorm User Group](https://groups.google.com/forum/?fromgroups#!forum/go-firestorm)


go-firestorm

# gosql

[![GoTest](https://github.com/rushteam/gosql/workflows/Go/badge.svg)](https://github.com/rushteam/gosql/actions)
[![GoDoc](https://godoc.org/github.com/rushteam/gosql?status.svg)](https://pkg.go.dev/github.com/rushteam/gosql)
[![codecov](https://codecov.io/gh/rushteam/gosql/branch/master/graph/badge.svg)](https://codecov.io/gh/rushteam/gosql)
[![Go Report Card](https://goreportcard.com/badge/github.com/rushteam/gosql)](https://goreportcard.com/report/github.com/rushteam/gosql)
[![LICENSE](https://img.shields.io/github/license/rushteam/gosql)](https://github.com/rushteam/gosql/blob/master/LICENSE)

gosql is a easy ORM library for Golang. 

## Style:

```golang
var userList []UserModel
err := db.FetchAll(&userList,
    gosql.Columns("id","name"),
    gosql.Where("status", 1),
    gosql.Where("[like]name", "j%"),
    gosql.OrWhere(func(s *gosql.Clause) {
        s.Where("[>]score", "90")
        s.Where("[<]score", "100")
    }),
    gosql.GroupBy("type"),
    gosql.OrderBy("score DESC"),
    gosql.Offset(0),
    gosql.Limit(10),
)
// select id,name from user where status =1 and name like 'j%' or (score > 90 and score <100) group by type order by score DESC limit 0,10;
```


## Feature

* Functional Options Style SQL builder
* Unlimited nesting query
* Reading and Writing Separation
* Delay connection creation
* ORM mapping to struct
* Support transaction
* Versatile
* Clean Code
* Bulk Insert

## Structure

* db.go: Basic struct definition
* pool.go: Manage DB pool
* session.go: Session and Model
* builder.go: Building SQL
* scanner/*: scan struct

## Why build this wheels

I have read almost all open source operation database library implemented in golang on github. But never get the optimal solution.

Such as these:

1. gorm: Does not support read and write separation.

2. gendry: Occupy special keywords and partially ugly syntax.

3. sqlx: Mostly good, But the syntax is not simple enough, and does not support the separation of reading and writing.

This project refers to a large number of existing libs, refers to various documents, and uses golang style to achieve from scratch.

## NOTE

NOTE: Only supports mysql driver.

## Demo

Let's look a demo frist.

```sql
SELECT DISTINCT *
FROM `tbl1`.`t1`
    JOIN `tbl3` ON `a` = `b`
WHERE (`t1`.`status` = ?
    AND `name` = ?
    AND `nick` != ?
    AND `role1` IN (?, ?, ?, ?)
    AND `role2` NOT IN (?, ?, ?, ?)
    AND `card1` IN (?)
    AND `card2` NOT IN (?)
    AND (`age` > ?
        AND `age` < ?)
    AND v1 = 1
    AND v2 = ?
    AND `desc` LIKE ?
    AND `desc` NOT LIKE ?
    AND EXISTS (
        SELECT 1
    )
    AND NOT EXISTS (
        SELECT *
        FROM `tbl2`.`t2`
        WHERE `t2`.`id` = ?
    ))
GROUP BY `class`, `group`
HAVING `class` = ?
ORDER BY `score` DESC, `name` ASC, `age`
LIMIT 10, 30
FOR UPDATE
```

```golang
    s := gosql.NewSQLSegment()
    s.Flag("DISTINCT")
    s.Field("*")
    s.Table("tbl1.t1")
    s.Where("t1.status", "0")
    s.Where("name", "jack")
    s.Where("[!=]nick", "tom")
    s.Where("[in]role1", []string{"1", "2", "3", "4"})
    s.Where("[!in]role2", []string{"1", "2", "3", "4"})
    s.Where("[in]card1", 1)
    s.Where("[!in]card2", 1)
    s.Where(func(s *gosql.Clause) {
        s.Where("[>]age", "20")
        s.Where("[<]", "50")
    })
    s.Where("v1 = 1")
    s.Where("[#]v2 = ?", 2)
    s.Join("tbl3", "a", "=", "b")
    s.Having("class", "one")
    s.Where("[~]desc", "student")
    s.Where("[!~]desc", "teacher")
    s.Where("[exists]my_card", "select 1")
    s.Where("[!exists]my_card2", func(s *SQLSegments) {
        s.Table("tbl2.t2")
        s.Where("t2.id", 10000)
    })
    s.GroupBy("class","group")
    s.OrderBy("score desc", "name asc","age")
    s.Limit(30)
    s.Offset(10)
    s.ForUpdate()
    fmt.Println(s.BuildSelect())
```

## Getting Started

```golang
package main

import (
    "fmt"

    _ "github.com/go-sql-driver/mysql"
    "github.com/rushteam/gosql"
)

type UserModel struct {
    ID   int    `db:"id"`
    Name string `db:"name"`
}

func (u *UserModel) TableName() string {
    return "my_user"
}

func main() {
    db := gosql.NewCluster(
        gosql.AddDb("mysql", "user:password@tcp(127.0.0.1:3306)/test?parseTime=true&readTimeout=3s&writeTimeout=3s&timeout=3s"),
    )
    user := &UserModel{}
    err := db.Fetch(user, 
    	gosql.Where("id", 1), 
	gosql.Where("[like]name", "j%"),
    )
    if err != nil {
        fmt.Println(err)
    }
    fmt.Println(user)
}

```

## Doc

### Debug Mode

```golang
//this code will be start at debug mode and the sql will be print
gosql.Debug = true
```

### Struct Model

To define a Model struct, use the struct and tag syntax.

#### Simple define a model

```golang
type User struct {
    ID int64
    Age int
    Name string
    CreatedAt time.Time
}
```

Usually define a Struct can be used as a model, gosql will parse out the table name, field mapping relationship,etc.

table: user
columns: id,age,name,created_at

#### Using tag syntax

Use structure tags to customize field mapping

```golang
type User struct {
    ID int64 `db:"uid,pk"`
    Age int `db:"age"`
    Name string `db:"fisrt_name"`
    CreatedAt time.Time `db:"created_at"`
}
```

table: user
columns: uid,age,fisrt_name,created_at
pk: uid

#### Define table name

Implement "TableName" method to specify the table name

```golang
type User struct {}
func (u *User) TableName() string {
    return "my_user"
}
```

table: my_user

### Exec

#### INSERT

db.Insert(dst interface{}, opts ...Option) (Result, error)

```golang
user := &UserModel{}
user.Name = "jack"
ret,err := db.Insert(&user)
```

batch insert

```golang
users := []UserModel{}
u1 := UserModel{Name:"jack"}
u2 := UserModel{Name:"Tom"}
users = append(users,u1)
users = append(users,u2)
ret,err := db.Insert(users)
```

#### REPLACE

db.Replace(dst interface{}, opts ...Option) (Result, error)

```golang
user := &UserModel{}
user.Name = "jack"
ret,err := db.Replace(&user,gosql.Where("id",1))
```

#### UPDATE

Update(dst interface{}, opts ...Option) (Result, error)

```golang
user := &UserModel{}
user.Name = "jack Ma"
ret,err := db.Update(&user,gosql.Where("id",1))
```

#### DELETE

db.Delete(dst interface{}, opts ...Option) (Result, error)

```golang
user := &UserModel{}
ret,err := db.Delete(&user,gosql.Where("id",1))
//sql: delete from my_user where id = 1
```

### QUERY

#### Get a record: db.Fetch(dst interface{}, opts ...Option) error

```golang
user := &UserModel{}
err := db.Fetch(user,
    gosql.Columns("id","name"),
    gosql.Where("id", 1),
    gosql.Where("[like]name", "j%"),
    gosql.OrWhere(func(s *gosql.Clause) {
        s.Where("[>=]score", "90")
        s.Where("[<=]age", "100")
    }),
    gosql.GroupBy("type"),
    gosql.OrderBy("score DESC"),
)
```

#### Get multiple records: db.FetchAll(dst interface{}, opts ...Option) error

```golang
var userList []UserModel
err := db.FetchAll(&userList,
    gosql.Columns("id","name"),
    gosql.Where("id", 1),
    gosql.Where("[like]name", "j%"),
    gosql.OrWhere(func(s *gosql.Clause) {
        s.Where("[>]score", "90")
        s.Where("[<]score", "100")
    }),
    gosql.GroupBy("type"),
    gosql.OrderBy("score DESC"),
    gosql.Offset(0),
    gosql.Limit(10),
)
```

### OPTION

#### WHERE

* gosql.Where("id",1)

```golang
gosql.Where("id",1)
//sql: id = 1
```

* gosql.Where("[>]age",18)

```golang
gosql.Where("[>]age",18)
//sql: age > 18
```

* gosql.Where("[in]id",[]int{1,2})

```golang
gosql.Where("[in]id",[]int{1,2})
//sql: id in (1,2)
```

* gosql.Where("[!in]id",[]int{1,2})

```golang
gosql.Where("[!in]id",[]int{1,2})
//sql: id not in (1,2)
```

* gosql.Where("[~]name","ja%")

```golang
gosql.Where("[~]name","ja%")
//sql: name like 'ja%'
```

* gosql.Where("[!~]name","ja%")

```golang
gosql.Where("[!~]name","ja%")
//sql: name not like 'ja%'
```

#### symbol [?]

* [=] equal

```golang
gosql.Where("[=]id",1)
//sql: id = 1
```

* [!=] not equal

```golang
gosql.Where("[!=]id",1)
//sql: id != 1
```

* [>] greater than

```golang
gosql.Where("[>]id",1)
//sql: id > 1
```

* [>=] greater or equal

```golang
gosql.Where("[>=]id",1)
//sql: id >= 1
```

* [<] less

```golang
gosql.Where("[<]id",1)
//sql: id < 1
```

* [<=] less or equal

```golang
gosql.Where("[<=]id",1)
//sql: id <= 1
```

* [in] in

```golang
gosql.Where("[in]id",[]int{1,2})
//sql: id in (1,2)
```

* [!in] not in

```golang
gosql.Where("[!in]id",[]int{1,2})
//sql: id not in (1,2)
```

* [is] is null

```golang
gosql.Where("[is]name",nil)
//sql: name is null
```

* [!is] not is null

```golang
gosql.Where("[!is]name",nil)
//sql: id is not null
```

* [exists] exists

```golang
gosql.Where("[exists]name","select 1")
//sql: name exists(select 1)
```

* [!exists] not exists

```golang
gosql.Where("[!exists]name","select 1")
//sql: name not exists(select 1)
```

* [#] sql

```golang
gosql.Where("[#]age=age-1")
//sql: age = age-1
```

### Raw SQL: db.Query()

```golang
rows,err := db.Query("select * from my_user where id = ?",1)
//sql: select * from my_user where id = 1
```

### select primary or replica

* db.Primary() change to primary db

```golang
ret,err := db.Primary().Fetch(...)
```

* db.Replica() change to replica

```golang
ret,err := db.Replica().Fetch(...)
```

### Paging

Define a page function and return gosql.Option sturct

```golang 
//Page  pn: per page num ,ps: page size
func Page(pn, ps int) gosql.Option {
	if pn < 1 {
		pn = 1
	}
	return func(s gosql.SQLSegments) gosql.SQLSegments {
		s.Limit(ps)
		s.Offset((pn - 1) * ps)
		return s
	}
}
func main() {
    user := &UserModel{}
    err := db.Fetch(user,
        Page(1,15),
    )
}

```

### multi-database 

```golang
gosql.NewCollect(
    gosql.NewCluster(
        gosql.AddDb("mysql", "user:password@tcp(127.0.0.1:3306)/test?parseTime=true&readTimeout=3s&writeTimeout=3s&timeout=3s"),
    ),
    "db1",
)
gosql.NewCollect(
    gosql.NewCluster(
        gosql.AddDb("mysql", "user:password@tcp(127.0.0.1:3306)/test?parseTime=true&readTimeout=3s&writeTimeout=3s&timeout=3s"),
    ),
    "db2",
)

db1 := gosql.Collect("db1")


db2 := gosql.Collect("db2")
```

### builder of API

* builder.New() start a builder

```golang
s := builder.New()
```

* builder.Flag(f string) set a flag

```golang
s.Flag("test")
```

* builder.Field(fields string) Specified columns

default value *

```golang
s.Field("*")
```

* builder.Table(tbl string) Specified table name

```golang
s.Table("tbl.t1")
```

#### Where

builder.Where(key string, val inferface{})

* Eq

```golang
s.Where("t1.status", "0")
//sql: t1.status = 0
```

* Not Eq

```golang
s.Where("[!=]t1.status", "0")
//sql: t1.status != 0
```

* In

```golang
s.Where("[in]field", []string{"a", "b", "c"})
//sql: t1.field in (a,b,c)
```

* No In

```golang
s.Where("[!in]field", []string{"a", "b", "c"})
//sql: t1.status in (a,b,c)
```

### Nested Where

* s.Where(func(s *builder.Clause){}

```golang
s.Where("[!]t1.a",1).Where(func(s *builder.Clause){
    s.Where("t1.b",1)
    s.OrWhere("t1.c",1)
})
//sql: t1.a != 1  and (t1.b = 1 or t1.c = 1)
```

### Other statements

* Group By

```golang
s.GroupBy("class")
//sql: group by `class`
```

* Order By

```golang
s.OrderBy("id desc", "age asc")
//sql: order by `id` desc, `age` asc
```

* Limit

```golang
s.Limit(10)
//sql: limit 10
```

* Offset

```golang
s.Offset(10)
//sql: offset 10
```

## Contributing

When everybody adds fuel, the flames rise high.

Let's build our self library.

You will be a member of rushteam which is An open source organization

Thanks for you, Good Lucy.


go-sql

A flexible and powerful SQL string builder library plus a zero-config ORM

go-sqlbuilder

Simple, fast, type-safe, generic orm for developer happiness

[![GoDoc](https://godoc.org/github.com/golobby/orm/?status.svg)](https://godoc.org/github.com/golobby/orm)
[![CI](https://github.com/golobby/orm/actions/workflows/ci.yml/badge.svg)](https://github.com/golobby/orm/actions/workflows/ci.yml)
[![CodeQL](https://github.com/golobby/orm/actions/workflows/codeql-analysis.yml/badge.svg)](https://github.com/golobby/orm/actions/workflows/codeql-analysis.yml)
[![Go Report Card](https://goreportcard.com/badge/github.com/golobby/orm)](https://goreportcard.com/report/github.com/golobby/orm)
[![Coverage Status](https://coveralls.io/repos/github/golobby/orm/badge.svg?r=1)](https://coveralls.io/github/golobby/orm?branch=master)

# Golobby ORM

GoLobby ORM is a lightweight yet powerful, fast, customizable, type-safe object-relational mapper for the Go programming language.

## Table Of Contents
  * [Features](#features)
    + [Introduction](#introduction)
    + [Creating a new Entity](#creating-a-new-entity)
      - [Conventions](#conventions)
        * [Timestamps](#timestamps)
        * [Column names](#column-names)
        * [Primary Key](#primary-key)
    + [Initializing ORM](#initializing-orm)
    + [Fetching an entity from a database](#fetching-an-entity-from-a-database)
    + [Saving entities or Insert/Update](#saving-entities-or-insert-update)
    + [Using raw SQL](#using-raw-sql)
    + [Deleting entities](#deleting-entities)
    + [Relationships](#relationships)
      - [HasMany](#hasmany)
      - [HasOne](#hasone)
      - [BelongsTo](#belongsto)
      - [BelongsToMany](#belongstomany)
      - [Saving with relation](#saving-with-relation)
    + [Query Builder](#query-builder)
      - [Finishers](#finishers)
        * [All](#all)
        * [Get](#get)
        * [Update](#update)
        * [Delete](#delete)
      - [Select](#select)
        * [Column names](#column-names-1)
        * [Table](#table)
        * [Where](#where)
        * [Order By](#order-by)
        * [Limit](#limit)
        * [Offset](#offset)
        * [First, Latest](#first-latest)
      - [Update](#update)
        * [Where](#where-1)
        * [Table](#table-1)
        * [Set](#set)
      - [Delete](#delete)
        * [Table](#table-2)
        * [Where](#where-2)
    + [Database Validations](#database-validations)
  * [License](#license)

## Introduction
GoLobby ORM is an object-relational mapper (ORM) that makes it enjoyable to interact with your database. 
When using Golobby ORM, each database table has a corresponding "Entity" to interact with that table using elegant APIs.

## Features
- Elegant and easy-to-use APIs with the help of Generics.
- Type-safety.
- Using reflection at startup to be fast during runtime. 
- No code generation!
- Query builder for various query types.
- Binding query results to entities.
- Supports different kinds of relationship/Association types:
    - One to one
    - One to Many
    - Many to Many

## Performance
You can run performance benchmark against `GORM` using
```bash
make bench
```
here are results from my laptop
```
goos: darwin
goarch: arm64
pkg: github.com/golobby/orm/benchmark
BenchmarkGolobby
BenchmarkGolobby-8        235956              4992 ns/op            2192 B/op         66 allocs/op
BenchmarkGorm
BenchmarkGorm-8            54498             21308 ns/op            7208 B/op        147 allocs/op
PASS
ok      github.com/golobby/orm/benchmark        3.118s
```

## Quick Start

The following example demonstrates how to use the GoLobby ORM.

```go
package main

import "github.com/golobby/orm"

// User entity
type User struct {
  ID        int64
  FirstName string
  LastName  string
  Email     string
  orm.Timestamps
}

// It will be called by ORM to setup entity.
func (u User) ConfigureEntity(e *orm.EntityConfigurator) {
    // Specify related database table for the entity.
    e.Table("users")
}

func main() {
  // Setup ORM
  err := orm.Initialize(orm.ConnectionConfig{
    // Name:          "default",  // Optional. Specify connection names if you have more than on database.
    Driver:           "sqlite3",  // Database type. Currently supported sqlite3, mysql, mariadb, postgresql. 
    ConnectionString: ":memory:", // Database DSN.
    DatabaseValidations: true,    // Validates your database tables and each table schema
  })
  
  if err != nil {
	  panic(err)
  }
  
  // Find user by primary key (ID)
  user, err := orm.Find[User](1)
  
  // Update entity
  user.Email = "jack@mail.com"
  
  // Save entity
  orm.Save(&user)
}
```

### Creating a new Entity
Let's create a new `Entity` to represent `User` in our application.

```go
package main

import "github.com/golobby/orm"

type User struct {
  ID       int64
  Name     string
  LastName string
  Email    string
  orm.Timestamps
}

func (u User) ConfigureEntity(e *orm.EntityConfigurator) {
    e.Table("users").
      Connection("default") // You can omit connection name if you only have one.
	
}
```
As you see, our user entity is nothing else than a simple struct and two methods.
Entities in GoLobby ORM are implementations of `Entity` interface, which defines two methods:
- ConfigureEntity: configures table, fields, and also relations to other entities.
#### Conventions
We have standard conventions and we encourage you to follow, but if you want to change them for any reason you can use `Field` method to customize how ORM
inferres meta data from your `Entity`.

##### Column names
GoLobby ORM for each struct field(except slice, arrays, maps, and other nested structs) assumes a respective column named using snake case syntax.
If you want a custom column name, you should specify it in `ConfigureEntity` method using `Field()` method.
```go
package main

type User struct {
  Name string
}

func (u User) ConfigureEntity(e *orm.EntityConfigurator) {
    e.Field("Name").ColumnName("custom_name_for_column")

    e.Table("users")
}
```
##### Timestamps
for having `created_at`, `updated_at`, `deleted_at` timestamps in your entities you can embed `orm.Timestamps` struct in your entity,
```go
type User struct {
  ID       int64
  Name     string
  LastName string
  Email    string
  orm.Timestamps
}

```
Also, if you want custom names for them, you can do it like this.
```go
type User struct {
    ID       int64
    Name     string
    LastName string
    Email    string
    MyCreatedAt sql.NullTime
    MyUpdatedAt sql.NullTime
    MyDeletedAt sql.NullTime
}
func (u User) ConfigureEntity(e *orm.EntityConfigurator) {
    e.Field("MyCreatedAt").IsCreatedAt() // this will make ORM to use MyCreatedAt as created_at column
    e.Field("MyUpdatedAt").IsUpdatedAt() // this will make ORM to use MyUpdatedAt as updated_at column
    e.Field("MyDeletedAt").IsDeletedAt() // this will make ORM to use MyDeletedAt as deleted_at column

    e.Table("users")
}
```
As always you use `Field` method for configuring how ORM behaves to your struct field.

##### Primary Key
GoLobby ORM assumes that each entity has a primary key named `id`; if you want a custom primary key called, you need to specify it in entity struct.
```go
package main

type User struct {
	PK int64
}
func (u User) ConfigureEntity(e *orm.EntityConfigurator) {
    e.Field("PK").IsPrimaryKey() // this will make ORM use PK field as primary key.
    e.Table("users")
}
```

### Initializing ORM
After creating our entities, we need to initialize GoLobby ORM.
```go
package main

import "github.com/golobby/orm"

func main() {
  orm.Initialize(orm.ConnectionConfig{
    // Name:             "default", You should specify connection name if you have multiple connections
    Driver:           "sqlite3",
    ConnectionString: ":memory:",
  })
}
```
After this step, we can start using ORM.
### Fetching an entity from a database
GoLobby ORM makes it trivial to fetch entities from a database using its primary key.
```go
user, err := orm.Find[User](1)
```
`orm.Find` is a generic function that takes a generic parameter that specifies the type of `Entity` we want to query and its primary key value.
You can also use custom queries to get entities from the database.
```go

user, err := orm.Query[User]().Where("id", 1).First()
user, err := orm.Query[User]().WherePK(1).First()
```
GoLobby ORM contains a powerful query builder, which you can use to build `Select`, `Update`, and `Delete` queries, but if you want to write a raw SQL query, you can.
```go
users, err := orm.QueryRaw[User](`SELECT * FROM users`)
```

### Saving entities or Insert/Update
GoLobby ORM makes it easy to persist an `Entity` to the database using `Save` method, it's an UPSERT method, if the primary key field is not zero inside the entity
it will go for an update query; otherwise, it goes for the insert.
```go
// this will insert entity into the table
err := orm.Save(&User{Name: "Amirreza"}) // INSERT INTO users (name) VALUES (?) , "Amirreza"
```
```go
// this will update entity with id = 1
orm.Save(&User{ID: 1, Name: "Amirreza2"}) // UPDATE users SET name=? WHERE id=?, "Amirreza2", 1
```
Also, you can do custom update queries using query builder or raw SQL again as well.
```go
res, err := orm.Query[User]().Where("id", 1).Update(orm.KV{"name": "amirreza2"})
```

### Using raw SQL

```go
_, affected, err := orm.ExecRaw[User](`UPDATE users SET name=? WHERE id=?`, "amirreza", 1)
```
### Deleting entities  
It is also easy to delete entities from a database.
```go
err := orm.Delete(user)
```
You can also use query builder or raw SQL.
```go
_, affected, err := orm.Query[Post]().WherePK(1).Delete()

_, affected, err := orm.Query[Post]().Where("id", 1).Delete()

```
```go
_, affected, err := orm.ExecRaw[Post](`DELETE FROM posts WHERE id=?`, 1)
```
### Relationships
GoLobby ORM makes it easy to have entities that have relationships with each other. Configuring relations is using `ConfigureEntity` method, as you will see.
#### HasMany
```go
type Post struct {}

func (p Post) ConfigureEntity(e *orm.EntityConfigurator) {
    e.Table("posts").HasMany(&Comment{}, orm.HasManyConfig{})
}
```
As you can see, we are defining a `Post` entity that has a `HasMany` relation with `Comment`. You can configure how GoLobby ORM queries `HasMany` relation with `orm.HasManyConfig` object; by default, it will infer all fields for you.
Now you can use this relationship anywhere in your code.
```go
comments, err := orm.HasMany[Comment](post).All()
```
`HasMany` and other related functions in GoLobby ORM return `QueryBuilder`, and you can use them like other query builders and create even more
complex queries for relationships. for example, you can start a query to get all comments of a post made today.
```go
todayComments, err := orm.HasMany[Comment](post).Where("created_at", "CURDATE()").All()
```
#### HasOne
Configuring a `HasOne` relation is like `HasMany`.
```go
type Post struct {}

func (p Post) ConfigureEntity(e *orm.EntityConfigurator) {
    e.Table("posts").HasOne(&HeaderPicture{}, orm.HasOneConfig{})
}
```
As you can see, we are defining a `Post` entity that has a `HasOne` relation with `HeaderPicture`. You can configure how GoLobby ORM queries `HasOne` relation with `orm.HasOneConfig` object; by default, it will infer all fields for you.
Now you can use this relationship anywhere in your code.
```go
picture, err := orm.HasOne[HeaderPicture](post)
```
`HasOne` also returns a query builder, and you can create more complex queries for relations.
#### BelongsTo
```go
type Comment struct {}

func (c Comment) ConfigureEntity(e *orm.EntityConfigurator) {
    e.Table("comments").BelongsTo(&Post{}, orm.BelongsToConfig{})
}
```
As you can see, we are defining a `Comment` entity that has a `BelongsTo` relation with `Post` that we saw earlier. You can configure how GoLobby ORM queries `BelongsTo` relation with `orm.BelongsToConfig` object; by default, it will infer all fields for you.
Now you can use this relationship anywhere in your code.
```go
post, err := orm.BelongsTo[Post](comment).First()
```
#### BelongsToMany
```go
type Post struct {}

func (p Post) ConfigureEntity(e *orm.EntityConfigurator) {
    e.Table("posts").BelongsToMany(&Category{}, orm.BelongsToManyConfig{IntermediateTable: "post_categories"})
}

type Category struct{}

func(c Category) ConfigureEntity(r *orm.EntityConfigurator) {
    e.Table("categories").BelongsToMany(&Post{}, orm.BelongsToManyConfig{IntermediateTable: "post_categories"})
}

```
We are defining a `Post` entity and a `Category` entity with a `many2many` relationship; as you can see, we must configure the IntermediateTable name, which GoLobby ORM cannot infer.
Now you can use this relationship anywhere in your code.
```go
categories, err := orm.BelongsToMany[Category](post).All()
```
#### Saving with relation
You may need to save an entity that has some kind of relationship with another entity; in that case, you can use `Add` method.
```go
orm.Add(post, comments...) // inserts all comments passed in and also sets all post_id to the primary key of the given post.
orm.Add(post, categories...) // inserts all categories and also insert intermediate post_categories records.
```

### Query Builder
GoLobby ORM contains a powerful query builder to help you build complex queries with ease. QueryBuilder is accessible from `orm.Query[Entity]` method
which will create a new query builder for you with given type parameter.
Query builder can build `SELECT`,`UPDATE`,`DELETE` queries for you.

#### Finishers
Finishers are methods on QueryBuilder that will some how touch database, so use them with caution.
##### All
All will generate a `SELECT` query from QueryBuilder, execute it on database and return results in a slice of OUTPUT. It's useful for queries that have multiple results.
```go
posts, err := orm.Query[Post]().All() 
```
##### Get
Get will generate a `SELECT` query from QueryBuilder, execute it on database and return results in an instance of type parameter `OUTPUT`. It's useful for when you know your query has single result.
```go
post, err := orm.Query[Post]().First().Get()
```
##### Update
Update will generate an `UPDATE` query from QueryBuilder and executes it, returns rows affected by query and any possible error.
```go
rowsAffected, err := orm.Query[Post]().WherePK(1).Set("body", "body jadid").Update()
```
##### Delete
Delete will generate a `DELETE` query from QueryBuilder and executes it, returns rows affected by query and any possible error.
```go
rowsAffected, err := orm.Query[Post]().WherePK(1).Delete()
```
#### Select
Let's start with `Select` queries.
Each `Select` query consists of following:
```sql
SELECT [column names] FROM [table name] WHERE [cond1 AND/OR cond2 AND/OR ...] ORDER BY [column] [ASC/DESC] LIMIT [N] OFFSET [N] GROUP BY [col]
```
Query builder has methods for constructing each part, of course not all of these parts are necessary.
##### Column names
for setting column names to select use `Select` method as following:
```go
orm.Query[Post]().Select("id", "title")
```
##### Table
for setting table name for select use `Table` method as following:
```go
orm.Query[Post]().Table("users")
```
##### Where
for adding where conditions based on what kind of where you want you can use any of following:
```go
orm.Query[Post]().Where("name", "amirreza") // Equal mode: WHERE name = ?, ["amirreza"]
orm.Query[Post]().Where("age", "<", 19) // Operator mode: WHERE age < ?, [19]
orm.Query[Post]().WhereIn("id", 1,2,3,4,5) // WhereIn: WHERE id IN (?,?,?,?,?), [1,2,3,4,5]
```
You can also chain these together.
```go
orm.Query[Post]().
	Where("name", "amirreza").
	AndWhere("age", "<", 10).
	OrWhere("id", "!=", 1)
    // WHERE name = ? AND age < ? OR id != ?, ["amirreza", 10, 1]
```
##### Order By
You can set order by of query using `OrderBy` as following.
```go
orm.Query[Post]().OrderBy("id", orm.ASC) // ORDER BY id ASC
orm.Query[Post]().OrderBy("id", orm.DESC) // ORDER BY id DESC
```

##### Limit
You can set limit setting of query using `Limit` as following
```go
orm.Query[Post]().Limit1(1) // LIMIT 1
```

##### Offset
You can set limit setting of query using `Offset` as following
```go
orm.Query[Post]().Offset(1) // OFFSET 1
```

##### First, Latest
You can use `First`, `Latest` method which are also executers of query as you already seen to get first or latest record.
```go
orm.Query[Post]().First() // SELECT * FROM posts ORDER BY id ASC LIMIT 1
orm.Query[Post]().Latest() // SELECT * FROM posts ORDER BY id DESC LIMIT 1
```
#### Update
Each `Update` query consists of following:
```sql
UPDATE [table name] SET [col=val] WHERE [cond1 AND/OR cond2 AND/OR ...]
```
##### Where
Just like select where stuff, same code.

##### Table
Same as select.

##### Set
You can use `Set` method to set value.
```go
orm.Query[Message]().
  Where("id", 1).
  Set("read", true, "seen", true).
  Update() // UPDATE posts SET read=?, seen=? WHERE id = ?, [true, true, 1]
```

#### Delete
Each `Delete` query consists of following:
```sql
DELETE FROM [table name] WHERE [cond1 AND/OR cond2 AND/OR ...]
```
##### Table
Same as Select and Update.
##### Where
Same as Select and Update.
### Database Validations
Golobby ORM can validate your database state and compare it to your entities and if your database and code are not in sync give you error.
Currently there are two database validations possible:
1. Validate all necessary tables exists.
2. Validate all tables contain necessary columns.
You can enable database validations feature by enabling `DatabaseValidations` flag in your ConnectionConfig.
```go
return orm.SetupConnections(orm.ConnectionConfig{
    Name:                    "default",
    DB:                      db,
    Dialect:                 orm.Dialects.SQLite3,
    Entities:                []orm.Entity{&Post{}, &Comment{}, &Category{}, &HeaderPicture{}},
    DatabaseValidations: true,
  })
```
## License
GoLobby ORM is released under the [MIT License](http://opensource.org/licenses/mit-license.php).


golobby/orm

[![Build Status](https://travis-ci.org/xxjwxc/gormt.svg?branch=master)](https://travis-ci.org/xxjwxc/gormt)
[![Go Report Card](https://goreportcard.com/badge/github.com/xxjwxc/gormt)](https://goreportcard.com/report/github.com/xxjwxc/gormt)
[![GoDoc](https://godoc.org/github.com/xxjwxc/gormt?status.svg)](https://godoc.org/github.com/xxjwxc/gormt)
[![Mentioned in Awesome Go](https://awesome.re/mentioned-badge.svg)](https://github.com/avelino/awesome-go) 
<a href="https://hellogithub.com/repository/1d5e3365a5084198aa1c79fb7953f6e7" target="_blank"><img src="https://abroad.hellogithub.com/v1/widgets/recommend.svg?rid=1d5e3365a5084198aa1c79fb7953f6e7&claim_uid=6IkmGoxiuN4LWFn&theme=small" alt="Featured｜HelloGitHub" /></a>
 
## [中文文档](README_zh_cn.md)

###  mysql database to golang struct conversion tools base on [gorm(v1/v2)](https://github.com/go-gorm/gorm)，You can automatically generate golang sturct from mysql database. big Camel-Case Name Rule, JSON tag. 



## gui support

![show](/image/gormt/ui_en.gif)

```
./gormt -g=true
```

## cmd support

![show](/image/gormt/out.gif)
```
./gormt -g=false
```

## install

```
go get -u -v github.com/xxjwxc/gormt@latest
```

or: [Dowloading](https://github.com/xxjwxc/gormt/releases)

--------

## 1. Configure default configuration items through the current directory config.yml file
note: for latest version of config format, please check /data/config/MyIni.go
```yml
out_dir : "./model"  # out dir
url_tag : json # web url tag(json,db(https://github.com/google/go-querystring))
language :  # language(English,中 文)
db_tag : gorm # DB tag(gorm,db)
simple : false #simple output
is_out_sql : false # Whether to output sql
is_out_func : true # Whether to output function
is_foreign_key : true # Whether to mark foreign key or not
is_gui : false # Whether to operate on gui
is_table_name : false # Whether to out GetTableName/column function
is_null_to_point : false # database is 'DEFAULT NULL' then set element type as point
is_web_tag: false
is_web_tag_pk_hidden: false
table_prefix: "" #table prefix
table_names: "" # Specified table generation, multiple tables with , separated
is_column_name: true # Whether to generate column names
is_out_file_by_table_name: false # Whether to generate multiple models based on table names
db_info :
    host : "127.0.0.1"
    port : 3306
    username : "root"
    password : "qwer"
    database : "oauth_db"
    type: 0 # database type (0:mysql , 1:sqlite , 2:mssql)
self_type_define: # Custom data type mapping
    datetime: time.Time
    date: time.Time
out_file_name: "" # Custom build file name
web_tag_type: 0 # json tag 0: Small Camel-Case 1: _

```
## 2. get help
```
./gormt --help
or
./gormt -h

-------------------------------------------------------
base on gorm tools for mysql database to golang struct

Usage:
  main [flags]

Flags:
  -d, --database string   数据库名
  -f, --foreign           是否导出外键关联
  -F, --fun               是否导出函数
  -g, --gui               是否ui显示模式
  -h, --help              help for main
  -H, --host string       数据库地址.(注意-H为大写)
  -o, --outdir string     输出目录
  -p, --password string   密码.
      --port int          端口号 (default 3306)
  -s, --singular          是否禁用表名复数
  -b, --table_names string 表名称  
  -l, --url string        url标签(json,url)
  -u, --user string       用户名.
  
```
## 3. Can be updated configuration items using command line tools
```
./gormt -H=127.0.0.1 -d=oauth_db -p=qwer -u=root --port=3306 -F=true
```

## 4. Support for gorm attributes
   
- Database tables, column field annotation support
- json tag json tag output
- gorm.Model [Support export gorm.model>>>](doc/export.md)
- PRIMARY_KEY	Specifies column as primary key
- UNIQUE	Specifies column as unique
- NOT NULL	Specifies column as NOT NULL
- INDEX	Create index with or without name, same name creates composite indexes
- UNIQUE_INDEX	Like INDEX, create unique index
- Support foreign key related properties [Support export gorm.model>>>](doc/export.md)
- Support function export (foreign key, association, index , unique and more)[Support export function >>>](https://github.com/xxjwxc/gormt/blob/master/data/view/genfunc/genfunc_test.go)
- model.Condition{} sql link

### You can enrich data types in [def](data/view/cnf/def.go) 

## 5. Demonstration

- sql:
```
CREATE TABLE `user_account_tbl` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `account` varchar(64) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL,
  `password` varchar(64) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL,
  `account_type` int(11) NOT NULL DEFAULT '0' COMMENT '帐号类型:0手机号，1邮件',
  `app_key` varchar(255) CHARACTER SET utf8 COLLATE utf8_unicode_ci NOT NULL COMMENT 'authbucket_oauth2_client表的id',
  `user_info_tbl_id` int(11) NOT NULL,
  `reg_time` datetime DEFAULT NULL,
  `reg_ip` varchar(15) CHARACTER SET utf8 COLLATE utf8_general_ci DEFAULT NULL,
  `bundle_id` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci DEFAULT NULL,
  `describ` varchar(255) CHARACTER SET utf8 COLLATE utf8_unicode_ci DEFAULT NULL,
  PRIMARY KEY (`id`) USING BTREE,
  UNIQUE KEY `account` (`account`) USING BTREE,
  KEY `user_info_id` (`user_info_tbl_id`) USING BTREE,
  CONSTRAINT `user_account_tbl_ibfk_1` FOREIGN KEY (`user_info_tbl_id`) REFERENCES `user_info_tbl` (`id`) ON DELETE RESTRICT ON UPDATE RESTRICT
) ENGINE=InnoDB AUTO_INCREMENT=38 DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci COMMENT='用户账号'
```

###### --->Derived results

```
// UserAccountTbl 用户账号
type UserAccountTbl struct {
	ID            int    `gorm:"primary_key"`
	Account       string `gorm:"unique"`
	Password      string
	AccountType   int         // 帐号类型:0手机号，1邮件
	AppKey        string      // authbucket_oauth2_client表的id
	UserInfoTblID int         `gorm:"index"`
	UserInfoTbl   UserInfoTbl `gorm:"association_foreignkey:user_info_tbl_id;foreignkey:id"` // 用户信息
	RegTime       time.Time
	RegIP         string
	BundleID      string
	Describ       string
}
```

### [more>>>](doc/export.md)

## 6. support func export
### The exported function is only the auxiliary class function of Gorm, and calls Gorm completely
```
// FetchByPrimaryKey primary or index 获取唯一内容
func (obj *_UserAccountTblMgr) FetchByPrimaryKey(ID int) (result UserAccountTbl, err error) {
	err = obj.DB.Table(obj.GetTableName()).Where("id = ?", ID).Find(&result).Error
	if err == nil && obj.isRelated {
		{
			var info UserInfoTbl // 用户信息
			err = obj.DB.Table("user_info_tbl").Where("id = ?", result.UserInfoTblID).Find(&info).Error
			if err != nil {
				return
			}
			result.UserInfoTbl = info
		}
	}

	return
}

```

### [more>>>](https://github.com/xxjwxc/gormt/tree/master/doc/func.md)
### [how to use call style>>>](https://github.com/xxjwxc/gormt/blob/master/data/view/genfunc/genfunc_test.go)

## 7. page 
### [Use of paging query in gormt](https://xiaojujiang.blog.csdn.net/article/details/122315454?spm=1001.2014.3001.5502)

## 8. build
```
make windows
make linux
make mac
```
or

```
go generate
```

### note : in windows not support utf-8 style . ASCALL model
- Switch encoding mode
```
CHCP 65001 
```

### column notes default

- Add a comment to the column starting with `[@gorm default:'test']`
- example `[@gorm default:'test';->;<-:create]this is my notes` Indicates that the default value is 'test',can read/creat/write
- Use of foreign key notes`[@fk tableName.columnName]this is my notes` Represents the 'columnName' column associated with the 'tableName'
  
## 9. one windows gui tools

![1](/image/gormt/1.png)

![2](/image/gormt/2.jpg)

![3](/image/gormt/3.jpg)

![4](/image/gormt/4.jpg)

[Download](https://github.com/xxjwxc/gormt/releases/download/v0.3.8/v1.0.zip)



- ###### [link](https://xxjwxc.github.io/post/gormtools/)

## Stargazers over time

[![Stargazers over time](https://starchart.cc/xxjwxc/gormt.svg)](https://starchart.cc/xxjwxc/gormt)


gormt

Go Relational Persistence, ORM-ish library for Go

gorp

Simple and lightweight pseudo-ORM/pseudo-struct-mapping environment for Go

# LORE

[![GoDoc](https://godoc.org/github.com/abrahambotros/lore?status.svg)](https://godoc.org/github.com/abrahambotros/lore)
[![Build Status](https://travis-ci.org/abrahambotros/lore.svg)](https://travis-ci.org/abrahambotros/lore)
[![Go Report Card](https://goreportcard.com/badge/github.com/abrahambotros/lore)](https://goreportcard.com/report/github.com/abrahambotros/lore)
[![gocover.io](https://gocover.io/_badge/github.com/abrahambotros/lore)](https://gocover.io/github.com/abrahambotros/lore)

Light Object-Relational Environment (LORE) provides a simple and lightweight pseudo-ORM/pseudo-struct-mapping environment for Go.

## Motivation
With LORE, you weave your own lore and control your own magic (... bear with me, I'll explain). LORE provides a thin veil that abstracts away some of the inconveniences of object-relational mapping in general, but intentionally and explicitly avoids doing any hand-wavy magic tricks that place someone else's mystery black box between you and your data.

To do so, LORE acts as a simple layer gluing together some wonderful and powerful libraries, providing a minimal abstraction above them for convenience:

* Squirrel (https://github.com/Masterminds/squirrel) for SQL generation.
  * In particular, the entrypoints for building queries via LORE (Query.BuildSqlSelect/Insert/Update/Delete and related Query methods) directly return squirrel SQL builders, so you get all of the power of Squirrel with some added convenience (tablename handling, common related queries, etc.) via LORE.
* SQLX (http://jmoiron.github.io/sqlx/) for running DB SQL queries and parsing results.

Aside from this, you're in charge of your own schema, migration, etc. - no full ORM and cruft to get in the way of your lore!

Lastly, while I'm sure it could still be improved, I've tried (and will continue to try) to ensure documentation provides full transparency of what is going on, so that your lore is entirely in your control.

## Guide and examples
Below is a run-through of getting set up and constructing some simple examples. Check GoDoc/source documentation for more information on any item, and look through the test source files for more thorough examples of usage. I also recommend using string constants everywhere for your db field names (string literals everywhere are literally the devil and should be banned from your lore IMO - pun intended), but am just using literals here ONLY for simplicity and succinctness.

### Config
When initializing your app, you should inform LORE of your desired config before constructing any LORE queries. To do so, you can use the `SetConfig` function and pass in a `*lore.Config`. Currently, this only determines the SQL placeholder format used in all Squirrel queries.

```go
lore.SetConfig(&lore.Config{
    SQLPlaceholderFormat: lore.SQLPlaceholderFormatDollar, // Or: SQLPlaceholderFormatQuestion
})

// Or you can use the default config, which currently sets to the dollar-sign/$# placeholder format,
// but it's probably best to call SetConfig explicitly as above.
lore.SetConfigDefault()
```

### Model interface
To use LORE with your model, your model should implement `lore.ModelInterface`; see an example of
this below. Note that you can use "db:" tags for sqlx directly; LORE currently doesn't do any
specific handling of tags, as it delegates this all to sqlx.

Please check out the GoDoc for [ModelInterface](https://godoc.org/github.com/abrahambotros/lore#ModelInterface) for much more detail for each method you need to implement, in particular `DbFieldMap` (which shouldn't include auto-managed keys, such as serial keys).

```go
type Legend struct {
    Id      int     `db:"id"` // Serial/auto-incrementing primary key
    Name    string  `db:"name"`
    Culture string  `db:"culture"`
}

var _ lore.ModelInterface = (*Legend)(nil)

func (*Legend) DbTableName() string {
    return "legends"
}

func (l *Legend) DbFieldMap() map[string]interface{} {
    // Note that Id is purposefully left out, since this is a serial/auto-incrementing field!
    return map[string]interface{}{
        "name": l.Name,
        "culture": l.Culture,
    }
}

func (*Legend) DbPrimaryFieldKey() string {
    return "id"
}

func (l *Legend) DbPrimaryFieldValue() interface{} {
    return l.Id
}
```

### Build SQL query
Now we can use LORE to build a SQL query for your model. This involves 3 steps:

1. Create new `*lore.Query` instance, passing in your model (implementing `ModelInterface`).
2. Build SQL query via the `lore.Query.BuildSql*` methods, which wrap Squirrel builders.
3. Pass the completed SQL builder you made in step (2) back to the Query from (1) via `lore.Query.SetSqlBuilder`. Note that this can be combined with step (2) in simple cases as in the example below.

Let's try building the following query on the `Legend` model we defined above:

`SELECT * FROM legends WHERE name = 'Mars' AND culture = 'Roman' LIMIT 1;`

```go
/*
1. Create new *lore.Query with our Legend model.
*/
q := lore.NewQuery(&Legend{})

/*
2. Build the SQL query; here we use the BuildSqlSelectStar entrypoint and finish building via
Squirrel, then set it back into the Query via SetSqlBuilder in the same command. This tells LORE
that this is the SQl that will be run when the Query is executed later.

Note that BuildSqlSelectStar is an example of just one convenience wrapper that LORE provides;
alternatively, you can just build the SQL via Squirrel, or use BuildSqlSelect and pass in your
own column names, etc.
*/
q.SetSqlBuilder(
    q.BuildSqlSelectStar(). // This returns a Squirrel builder directly now, so the rest of this chain here is purely Squirrel.
    Where(squirrel.Eq{
        "name": "Mars",
        "culture": "Roman",
    }).
    Limit(1),
)

// If you want, you can use ToSql to get the Squirrel ToSql representation of the Query at any time.
qSql, qArgs, err := q.ToSql()
```

### Execute SQL query on your DB
Now that we've built a `*lore.Query` and attached our SQL builder to it, we can execute this as a query against our DB. LORE currently provides 3 methods for doing so:

1. `*lore.Query.Execute` - wraps sqlx.DB.Exec
2. `*lore.Query.ExecuteThenParseSingle` - wraps sqlx.DB.Get
3. `*lore.Query.ExecuteThenParseList` - wraps sqlx.DB.List

All of these methods attempt to return the number of rows affected by the query, along with of course an error if one was encountered. See GoDoc/source for more details, especially regarding numRowsAffected (see comments for the `Execute` functions in particular).

```go
/*
Execute and parse to list. Note that we pass in a POINTER to a list of structs we want to
scan the DB rows back into - when passing into the Execute* Query methods, LORE assumes you're
passing in a pointer (either to a list or a single struct), and will return an error if it
detects otherwise.
*/
db := getDb() // ... Your own lore should conjure up a *sqlx.DB instance here.
discoveredLegend := &Legend{}
// See notes for numRowsAffected in Query.Execute documentation.
numRowsAffected, err := q.ExecuteThenParseSingle(db, discoveredLegend)
if err != nil {
    // Handle errors here.
}
// Row matching the SQL query is written into discoveredLegend. Do whatever with it now.
discoveredLegend.GetCorrespondingCelestialBody()
discoveredLegend.TellUsYourTale()

...

/*
Also try the other query wrappers listed below for creating your SQL... (See GoDoc/source for more
details and possibly more functions)
*/
q.SetSqlBuilder(
    q.BuildSqlSelect(columns ...string)
    q.BuildSqlSelectStar()

    q.BuildSqlInsert()
    q.BuildSqlInsertColumnsAndValues(columns []string, values []interface{})
    q.BuildSqlInsertModel()

    q.BuildSqlUpdate()
    q.BuildSqlUpdateModelByPrimaryKey()

    q.BuildSqlDelete()
    q.BuildSqlDeleteModelByPrimaryKey()
)
```

### Convenience wrappers
The functions below handle both building a SQL statement and executing it on the DB you supply, all in one easy call. For many typical use cases, you might find you can just call these and not worry about the intermediate steps (note that you don't even need to explicitly create a Query, though you still need to supply a config on app init!). See the GoDoc/source for more details of any particular function.

```go
lore.SelectModelByPrimaryKey
lore.SelectModelsWhere
lore.InsertNewModel
lore.UpdateModelByPrimaryKey
lore.UpdateSetMapWhere
lore.DeleteModelByPrimaryKey
lore.DeleteModelsWhere
```

## DANGER: WIP
LORE is a major WIP. Contributions are welcome, but use in production is cautioned against at the moment unless you know full well what you're doing!

## TODO
* Augment convenience SQL-and-execute functions to call only Execute with no parse result if resultPtr is nil.
* Augment convenience SQL-and-execute functions with ORDER BY support.
* Allow using sqlx QueryRow/QueryRowX for large/unrestricted-length queries instead of just Get/Select.
* Better tests, especially for Execute\* methods and SQL-and-execute functions.
* Consider better way to relate updates to SQL-builders to the parent query without having to call `SetSqlBuilder` every time.
* Dedicated examples in GoDoc.

## Final notes
Thanks for looking, and please feel free to message me if you're having any problems with LORE! I'm also always open to suggestions on ways to improve LORE, whether minor changes/fixes or even large rewrites - always happy to learn of better ways to do things!


lore

Generated ORM from project structs for compile time safety assurances

<div style="text-align: center">
  <img src="https://s3.amazonaws.com/coverage.marlow.sizethree.cc/media/marlow.svg" width="65%" align="center"/>
</div>

---

Marlow is a code generation tool written in [golang] designed to create useful constructs that provide an ergonomic API
for interacting with a project's data persistence layer while maintaining strong compile time type safety assurance.

---- 

[![report.img]][report.url]
[![godoc.img]][godoc.url]
![build](https://github.com/marlow/marlow/workflows/build/badge.svg)

---- 

### Objective &amp; Inspiration

Marlow was created to improve developer velocity on projects written in [golang] that interact with a data persistence
layer, like [mysql] or [postgres]. In other web application backend environments, these interfaces are usually
provided by an application framework's [ORM], like the [ActiveRecord] library used by [Rails].

For web applications leveraging the benefits of using [golang], it can be difficult to construct the equivalent
abstraction of their database that provides [crud] operations - especially one that is type-safe and [dry]. There are
several open source projects in the golang ecosystem who's goal is exactly that; [`gorm`], [`beego`], and  [`gorp`] to
name a [few][awesome-go]. Marlow differs from these other projects in its philosophy; rather than attempt to provide an
eloquent orm for your project at runtime, it generates a tailored solution at compile time.

### Usage

At its core, marlow simply reads a package's [field tags] and generates valid [golang] code. The `marlowc` executable 
can be installed & used directly via:

```
go get -u github.com/marlow/marlowc
marlowc -input=./examples/library/models -stdout=true
```

For a full list of options supported by the compiler refer to `marlowc -help`. The command line tool can also be used
as the executable target for golang's [`go generate`] command using `//go:generate` comment syntax:

```go
package models

//go:generate marlowc -input=book.go

type Book struct {
  ID       string `marlow="column=id"`
  AuthorID string `marlow="column=author_id"`
}
```

The generated files will live in the same directory as their source counterparts, with an optional suffix to 
distinguish them (useful if a project is using [`make`] to manage the build pipeline). In general it is encouraged that
the generated files **are not committed to your project's revision control**; the source should *always* be generated
immediately before the rest of the package's source code is compiled.

### Generated Code &amp; Field Tag Configuration

The compiler parses the `marlow` field tag value using the `net/url` package's [`parseQuery`] function. This means that
each configuration option supported by marlow would end up in delimited by the ampersand (`&`) character where the key 
and value are separated by an equal sign (`=`). For example, a user record may look like:

```go
package models

type User struct {
	table        string `marlow:"tableName=users"`
	ID           uint   `marlow:"column=id"`
	Name         string `marlow:"column=name"`
	Email        string `marlow:"column=email"`
	SettingsMask uint8  `marlow:"column=settings&bitmask"`
}
```

In this example, marlow would create the following `UserStore` interface in the `models` package:

```go
type UserStore interface {
	UpdateUserID(uint, *UserBlueprint) (int64, error)
	FindUsers(*UserBlueprint) ([]*User, error)
	SelectUserEmails(*UserBlueprint) ([]string, error)
	CreateUsers(...User) (int64, error)
	UpdateUserEmail(string, *UserBlueprint) (int64, error)
	DropUserSettingsMask(uint8, *UserBlueprint) (int64, error)
	UpdateUserName(string, *UserBlueprint) (int64, error)
	SelectUserNames(*UserBlueprint) ([]string, error)
	AddUserSettingsMask(uint8, *UserBlueprint) (int64, error)
	CountUsers(*UserBlueprint) (int, error)
	SelectUserIDs(*UserBlueprint) ([]uint, error)
	UpdateUserSettingsMask(uint8, *UserBlueprint) (int64, error)
	DeleteUsers(*UserBlueprint) (int64, error)
	SelectUserSettingsMasks(*UserBlueprint) ([]uint8, error)
}
```

For every store that is generated, marlow will create a "blueprint" struct that defines a set of fields to be used for
querying against the database. In this example, the `UserBlueprint` generated for the store above would look like:

```go
type UserBlueprint struct {
	IDRange           []uint
	ID                []uint
	NameLike          []string
	Name              []string
	EmailLike         []string
	Email             []string
	SettingsMaskRange []uint8
	SettingsMask      []uint8
	Inclusive         bool
	Limit             int
	Offset            int
	OrderBy           string
	OrderDirection    string
}
```

**Special `table` field**

If present, marlow will recognize the `table` field's `marlow` tag value as a container for developer specified 
overrides for default marlow assumptions about the table.

| Option | Description |
| :--- | :--- |
| `tableName` | The name of the table (marlow will assume a lowercased &amp; pluralized version of the struct name). |
| `dialect` | Specifying the `dialect` option determines the syntax used by marlow during db queries. See [supported-drivers](#supported-drivers) for more info. |
| `primaryKey` | Some dialects require that marlow knows of the table's primary key during transactions. If provided, this value will be used as the _column name_ by marlow. |
| `storeName` | The name of the store type that will be generated, defaults to `%sStore`, where `%s` is the name of the struct. |
| `blueprintName` | The name of the blueprint type that will be generated, defaults to `%sBlueprint`, where `%s` is the name of the struct. |
| `defaultLimit` | When using the queryable feature, this will be the default maximum number of records to load. |
| `blueprintRangeFieldSuffix` | A string that is added to numerical blueprint fields for range selections. Defults to `%sRange` where `%s` is the name of the field (e.g: `AuthorIDRange`). |
| `blueprintLikeFieldSuffix` | A string that is added to string/text blueprint fields for like selections. Defaults to `%sLike` where `%s` is the name of the field (e.g: `FirstNameLike`). |

**All other fields**

For every other field found on the source `struct`, marlow will use the following field tag values:

| Option | Description |
| :--- | :--- |
| `column` | This is the column that any raw sql generated will target when scanning/selecting/querying this field. |
| `autoIncrement` | If `true`, this flag will prevent marlow from generating sql during creation that would attempt to insert the value of the field for the column. |
| `bitmask` | If present, the compiler will generate `AddRecordFieldMask` and `DropRecordFieldMask` methods which will perform native bitwise operations as `UPDATE` queries to the datbase. |

#### Generated Coverage & Documentation

While everyone's generated marlow code will likely be unique, the [`examples/library`] application includes a
comprehensive test suite that demonstrates the features of marlow using 3 models - [`Author`], [`Book`] and [`Genre`].

#### Supported Drivers

The follow is a list of officially support [`driver.Driver`] implementations supported by the generated marlow code. To request an additional driver, feel free to open up an [issue][issues].

| Driver Name | `dialect` Value |
| :--- | :--- |
| [`github.com/lib/pq`] | `postgres` | 
| [`github.com/mattn/go-sqlite3`] | none or `sql` | 
| [`github.com/go-sql-driver/mysql`] | none or `sql` | 


----

![logo][logo.img]

----

[preview]: https://s3.amazonaws.com/marlow-go/media/marlow.gif
[`ParseQuery`]: https://golang.org/pkg/net/url/#ParseQuery
[`make`]: https://www.gnu.org/software/make/
[`go generate`]: https://blog.golang.org/generate
[awesome-go]: https://github.com/avelino/awesome-go#orm
[`gorm`]: https://github.com/jinzhu/gorm
[`gorp`]: https://github.com/go-gorp/gorp
[`beego`]: https://github.com/astaxie/beego/tree/master/orm
[crud]: https://en.wikipedia.org/wiki/Create,_read,_update_and_delete
[dry]: https://en.wikipedia.org/wiki/Don%27t_repeat_yourself
[Rails]: http://rubyonrails.org
[issues]: https://github.com/marlow/marlow/issues
[ActiveRecord]: http://guides.rubyonrails.org/active_record_basics.html
[ORM]: https://en.wikipedia.org/wiki/Object-relational_mapping
[mysql]: https://www.mysql.com
[postgres]: https://www.postgresql.org
[struct field tags]: https://golang.org/ref/spec#Tag
[golang]: https://golang.org
[report.img]: https://goreportcard.com/badge/github.com/marlow/marlow?style=flat-square
[report.url]: https://goreportcard.com/report/github.com/marlow/marlow
[godoc.img]: http://img.shields.io/badge/godoc-reference-5272B4.svg?style=flat-square
[godoc.url]: https://godoc.org/github.com/marlow/marlow
[field tags]: https://golang.org/pkg/reflect/#StructTag
[logo.img]: https://s3.amazonaws.com/coverage.marlow.sizethree.cc/media/marlow.svg
[`github.com/lib/pq`]: https://github.com/lib/pq
[`github.com/mattn/go-sqlite3`]: https://github.com/mattn/go-sqlite3
[`github.com/go-sql-driver/mysql`]: https://github.com/go-sql-driver/mysql
[`driver.Driver`]: https://golang.org/pkg/database/sql/driver/#Driver
[`examples/library`]: https://github.com/marlow/library-demo
[`Author`]: https://github.com/marlow/library-demo/blob/master/models/author_test.go
[`Book`]: https://github.com/marlow/library-demo/blob/master/models/book_test.go
[`Genre`]: https://github.com/marlow/library-demo/blob/master/models/genre_test.go
[`GH-67`]: https://github.com/dadleyy/marlow/issues/67


marlow

Prisma Client Go, Typesafe database access for Go

<div align="center">
  <h1>Prisma Client Go</h1>
  <h2>Typesafe database access for Go</h2>
  <div>
    <a href="https://github.com/steebchen/prisma-client-go/releases"><img src="https://img.shields.io/github/v/release/steebchen/prisma-client-go?style=for-the-badge" /></a>
    <span>&nbsp;&nbsp;</span>
    <a href="./CONTRIBUTING.md"><img src="https://img.shields.io/badge/PRs-welcome-brightgreen.svg?style=for-the-badge" /></a>
    <span>&nbsp;&nbsp;</span>
    <a href="./LICENSE"><img src="https://img.shields.io/github/license/steebchen/prisma-client-go?style=for-the-badge" /></a>
    <span>&nbsp;&nbsp;</span>
    <a href="https://goprisma.org/docs/community"><img src="https://img.shields.io/static/v1?style=for-the-badge&label=community&message=join discord&color=blue" /></a>
  </div>
  <div>
    <a href="https://goprisma.org/docs/getting-started/quickstart">Quickstart</a>
    <span>&nbsp;&nbsp;•&nbsp;&nbsp;</span>
    <a href="https://www.prisma.io/">Prisma Core</a>
    <span>&nbsp;&nbsp;•&nbsp;&nbsp;</span>
    <a href="https://goprisma.org/docs">Docs</a>
    <span>&nbsp;&nbsp;•&nbsp;&nbsp;</span>
    <a href="https://goprisma.org/docs/walkthrough">Walkthrough</a>
    <span>&nbsp;&nbsp;•&nbsp;&nbsp;</span>
    <a href="https://www.prisma.io/blog">Prisma Blog</a>
    <span>&nbsp;&nbsp;•&nbsp;&nbsp;</span>
    <a href="https://twitter.com/prisma">Prisma Twitter</a>
    <span>&nbsp;&nbsp;•&nbsp;&nbsp;</span>
    <a href="https://goprisma.org/docs/community">Go Community</a>
  </div>
</div>

<hr>

## DEPRECATION NOTICE

The Prisma Go client is going to be deprecated and won't receive upgrades to Prisma v7+. Please see the [deprecation notice](https://github.com/steebchen/prisma-client-go/issues/1542).

## Description

Prisma Client Go is an **auto-generated query builder** that enables **type-safe** database access and **reduces
boilerplate**. You can use it as an alternative to traditional ORMs such as gorm, xorm, sqlboiler and most
database-specific tools.

It is part of the [Prisma](https://www.prisma.io/) ecosystem. Prisma provides database tools for data access,
declarative data modeling, schema migrations and visual data management.

## Getting started

To get started, [**read the quickstart tutorial**](https://goprisma.org/docs/getting-started/quickstart) to add Prisma
to your project in just a few minutes.

You also might want to read [deployment tips](https://goprisma.org/docs/reference/deploy) and
the [full API reference](https://goprisma.org/docs/reference).

## Status

The Go client is currently maintained by @steebchen and considered to be in alpha. I am actively looking
for [sponsors](https://github.com/sponsors/steebchen) who can support the continuous maintenance and development of new
features to finally make working with databases in Go fun. If you [sponsor](https://github.com/sponsors/steebchen) me, I
will prioritize your issues and feature requests and will help you set up and answer any questions you have.

## Contributing

Check out the [advanced contributing guide](./CONTRIBUTING.md).

## Security

If you have a security issue to report, please contact us
at [security@prisma.io](mailto:security@prisma.io?subject=[GitHub]%20Prisma%20Security%20Report%20Go&cc=contact@luca-steeb.com)


Prisma

Better ORM for Go, based on non-empty interfaces and code generation

# reform

[![Release](https://img.shields.io/github/release/go-reform/reform.svg)](https://github.com/go-reform/reform/releases/latest)
[![PkgGoDev](https://pkg.go.dev/badge/gopkg.in/reform.v1)](https://pkg.go.dev/gopkg.in/reform.v1)
[![CI](https://github.com/go-reform/reform/workflows/CI/badge.svg?branch=main&event=push)](https://github.com/go-reform/reform/actions)
[![AppVeyor Build status](https://ci.appveyor.com/api/projects/status/srwa0cuwf91qpjge/branch/main?svg=true)](https://ci.appveyor.com/project/AlekSi/reform/branch/main)
[![Coverage Report](https://codecov.io/gh/go-reform/reform/branch/main/graph/badge.svg)](https://codecov.io/gh/go-reform/reform)
[![Go Report Card](https://goreportcard.com/badge/gopkg.in/reform.v1)](https://goreportcard.com/report/gopkg.in/reform.v1)

<a href="https://en.wikipedia.org/wiki/Peter_the_Great"><img align="right" alt="Reform gopher logo" title="Peter the Reformer" src=".github/reform.png"></a>

A better ORM for Go and `database/sql`.

It uses non-empty interfaces, code generation (`go generate`), and initialization-time reflection
as opposed to `interface{}`, type system sidestepping, and runtime reflection. It will be kept simple.

Supported SQL dialects:

| RDBMS                | Library and drivers                                                                                 | Status
| -----                | -------------------                                                                                 | ------
| PostgreSQL           | [github.com/lib/pq](https://github.com/lib/pq) (`postgres`)                                         | Stable. Tested with all [supported](https://www.postgresql.org/support/versioning/) versions.
|                      | [github.com/jackc/pgx/stdlib](https://github.com/jackc/pgx) (`pgx` v3)                              | Stable. Tested with all [supported](https://www.postgresql.org/support/versioning/) versions.
| MySQL                | [github.com/go-sql-driver/mysql](https://github.com/go-sql-driver/mysql) (`mysql`)                  | Stable. Tested with all [supported](https://www.mysql.com/support/supportedplatforms/database.html) versions.
| SQLite3              | [github.com/mattn/go-sqlite3](https://github.com/mattn/go-sqlite3) (`sqlite3`)                      | Stable.
| Microsoft SQL Server | [github.com/denisenkom/go-mssqldb](https://github.com/denisenkom/go-mssqldb) (`sqlserver`, `mssql`) | Stable.<br/>Tested on Windows with: SQL2008R2SP2, SQL2012SP1, SQL2014, SQL2016.<br/>On Linux with: `mcr.microsoft.com/mssql/server:2017-latest` and `mcr.microsoft.com/mssql/server:2019-latest` [Docker images](https://hub.docker.com/_/microsoft-mssql-server).

Notes:
* [`clientFoundRows=true` flag](https://github.com/go-sql-driver/mysql#clientfoundrows) is required for `mysql` driver.
* `mssql` driver is [deprecated](https://github.com/denisenkom/go-mssqldb#deprecated) (but not `sqlserver` driver).


## Quickstart

1. Make sure you are using Go 1.17+, and Go modules support is enabled.
   Install or update `reform` package, `reform` and `reform-db` commands with:
    ```
    go get -v gopkg.in/reform.v1/...
    ```

   If you are not using Go modules yet, you can use dep to vendor desired version of reform,
   and then install commands with:
    ```
    go install -v ./vendor/gopkg.in/reform.v1/...
    ```

   You can also install the latest stable version of reform without using Go modules thanks to
   [gopkg.in redirection](https://gopkg.in/reform.v1), but please note that this will not use the stable
   versions of the database drivers:
    ```
    env GO111MODULE=off go get -u -v gopkg.in/reform.v1/...
    ```

   Canonical import path is `gopkg.in/reform.v1`; using `github.com/go-reform/reform` will not work.

   See note about versioning and branches below.

2. Use `reform-db` command to generate models for your existing database schema. For example:
    ```
    reform-db -db-driver=sqlite3 -db-source=example.sqlite3 init
    ```

3. Update generated models or write your own – `struct` representing a table or view row. For example,
   store this in file `person.go`:
    ```go
    //go:generate reform

    //reform:people
	type Person struct {
		ID        int32      `reform:"id,pk"`
		Name      string     `reform:"name"`
		Email     *string    `reform:"email"`
		CreatedAt time.Time  `reform:"created_at"`
		UpdatedAt *time.Time `reform:"updated_at"`
	}
    ```

    Magic comment `//reform:people` links this model to `people` table or view in SQL database.
    The first value in field's `reform` tag is a column name. `pk` marks primary key.
    Use value `-` or omit tag completely to skip a field.
    Use pointers (recommended) or `sql.NullXXX` types for nullable fields.

4. Run `reform [package or directory]` or `go generate [package or file]`. This will create `person_reform.go`
   in the same package with type `PersonTable` and methods on `Person`.

5. See [documentation](https://godoc.org/gopkg.in/reform.v1) how to use it. Simple example:

    ```go
	// Get *sql.DB as usual. PostgreSQL example:
	sqlDB, err := sql.Open("postgres", "postgres://127.0.0.1:5432/database")
	if err != nil {
		log.Fatal(err)
	}
	defer sqlDB.Close()

	// Use new *log.Logger for logging.
	logger := log.New(os.Stderr, "SQL: ", log.Flags())

	// Create *reform.DB instance with simple logger.
	// Any Printf-like function (fmt.Printf, log.Printf, testing.T.Logf, etc) can be used with NewPrintfLogger.
	// Change dialect for other databases.
	db := reform.NewDB(sqlDB, postgresql.Dialect, reform.NewPrintfLogger(logger.Printf))

	// Save record (performs INSERT or UPDATE).
	person := &Person{
		Name:  "Alexey Palazhchenko",
		Email: pointer.ToString("alexey.palazhchenko@gmail.com"),
	}
	if err := db.Save(person); err != nil {
		log.Fatal(err)
	}

	// ID is filled by Save.
	person2, err := db.FindByPrimaryKeyFrom(PersonTable, person.ID)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(person2.(*Person).Name)

	// Delete record.
	if err = db.Delete(person); err != nil {
		log.Fatal(err)
	}

	// Find records by IDs.
	persons, err := db.FindAllFrom(PersonTable, "id", 1, 2)
	if err != nil {
		log.Fatal(err)
	}
	for _, p := range persons {
		fmt.Println(p)
	}
    ```


## Background

reform was born during summer 2014 out of frustrations with existing Go ORMs. All of them have a method
`Save(record interface{})` which can be used like this:

```go
orm.Save(User{Name: "gopher"})
orm.Save(&User{Name: "gopher"})
orm.Save(nil)
orm.Save("Batman!!")
```

Now you can say that last invocation is obviously invalid, and that it's not hard to make an ORM to accept both
first and second versions. But there are two problems:

1. Compiler can't check it. Method's signature in `godoc` will not tell us how to use it.
   We are essentially working against those tools by sidestepping type system.
2. First version is still invalid, since one would expect `Save()` method to set record's primary key after `INSERT`,
   but this change will be lost due to passing by value.

First proprietary version of reform was used in production even before `go generate` announcement.
This free and open-source version is the fourth milestone on the road to better and idiomatic API.


## Versioning and branching policy

We are following [Semantic Versioning](http://semver.org/spec/v2.0.0.html),
using [gopkg.in](https://gopkg.in) and filling a [changelog](CHANGELOG.md).
All v1 releases are SemVer-compatible; breaking changes will not be applied.

We use tags `v1.M.m` for releases, branch `main` (default on GitHub) for the next minor release development,
and `release/1.M` branches for patch release development. (It was more complicated before 1.4.0 release.)

Major version 2 is currently not planned.


## Additional packages

* [github.com/AlekSi/pointer](https://github.com/AlekSi/pointer) is very useful for working with reform structs with pointers.


## Caveats and limitations

* There should be zero `pk` fields for Struct and exactly one `pk` field for Record.
  Composite primary keys are not supported ([#114](https://github.com/go-reform/reform/issues/114)).
* `pk` field can't be a pointer (`== nil` [doesn't work](https://golang.org/doc/faq#nil_error)).
* Database row can't have a Go's zero value (0, empty string, etc.) in primary key column.


## License

Code is covered by standard MIT-style license. Copyright (c) 2016-2020 Alexey Palazhchenko.
See [LICENSE](LICENSE) for details. Note that generated code is covered by the terms of your choice.

The reform gopher was drawn by Natalya Glebova. Please use it only as reform logo.
It is based on the original design by Renée French, released under [Creative Commons Attribution 3.0 USA license](https://creativecommons.org/licenses/by/3.0/).


## Contributing

See [Contributing Guidelines](.github/CONTRIBUTING.md).


reform

ORM generator. Generate a featureful and blazing-fast ORM tailored to your database schema

SQLBoiler

Database migration, creation, ORM, etc... for MySQL, PostgreSQL, and SQLite

<p align="center"><img src="logo.png" width="150" height="150"></p>

<p align="center">
    <a href="https://pkg.go.dev/github.com/gobuffalo/pop/v6"><img src="https://godoc.org/github.com/gobuffalo/pop?status.svg" alt="GoDoc" /></a>
    <a href="https://github.com/gobuffalo/pop/actions?query=workflow%3ATests+branch%3Amain"><img src="https://github.com/gobuffalo/pop/workflows/Tests/badge.svg" alt="Build Status" /></a>
</p>

# POP

## A Tasty Treat For All Your Database Needs

So what does Pop do exactly? Well, it wraps the absolutely amazing [https://github.com/jmoiron/sqlx](https://github.com/jmoiron/sqlx) library. It cleans up some of the common patterns and work flows usually associated with dealing with databases in Go.

Pop makes it easy to do CRUD operations, run migrations, and build/execute queries.

Pop, by default, follows conventions that were influenced by the [ActiveRecord](http://www.rubyonrails.org) Ruby gem. What does this mean?

* Tables must have an "id" column and a corresponding "ID" field on the `struct` being used.
* If there is a `timestamp` column named `created_at`, and a `CreatedAt time.Time` attribute on the `struct`, it will be set with the current time when the record is created.
* If there is a `timestamp` column named `updated_at`, and a `UpdatedAt time.Time` attribute on the `struct`, it will be set with the current time when the record is updated.
* Default database table names are lowercase, plural, and underscored versions of the `struct` name. Examples: User{} is "users", FooBar{} is "foo_bars", etc...

Want to know more? Take a look at the documentation!

## Documentation

Please visit [http://gobuffalo.io](https://gobuffalo.io/docs/db/getting-started) for the latest documentation, examples, and more.

### Quick Start
* [CLI Installation](https://gobuffalo.io/docs/db/toolbox)
* [Configuration](https://gobuffalo.io/docs/db/configuration)

## Shoulders of Giants

Pop would not be possible if not for all of the great projects it depends on. Please see [SHOULDERS.md](SHOULDERS.md) to see a list of them.

## Contributing

First, thank you so much for wanting to contribute! It means so much that you care enough to want to contribute. We appreciate every PR from the smallest of typos to the be biggest of features.

To contribute, please read the contribution guidelines: [CONTRIBUTING](.github/CONTRIBUTING.md)


pop/soda

Modern Database Access Layer for Golang - Testable, Extendable and Crafted Into a Clean and Elegant API

# REL

[![GoDoc](https://godoc.org/github.com/go-rel/rel?status.svg)](https://godoc.org/github.com/go-rel/rel)
[![Build Status](https://github.com/go-rel/rel/workflows/Build/badge.svg)](https://github.com/go-rel/rel/actions)
[![Go Report Card](https://goreportcard.com/badge/github.com/go-rel/rel)](https://goreportcard.com/report/github.com/go-rel/rel)
[![Maintainability](https://api.codeclimate.com/v1/badges/194611cc82f02edcda6e/maintainability)](https://codeclimate.com/github/go-rel/rel/maintainability)
[![Codecov](https://codecov.io/gh/go-rel/rel/branch/master/graph/badge.svg?token=0P505E1IWB)](https://codecov.io/gh/go-rel/rel)
[![Gitter chat](https://badges.gitter.im/go-rel/rel.png)](https://gitter.im/go-rel/rel)

> Modern Database Access Layer for Golang.

REL is golang orm-ish database layer for layered architecture. It's testable and comes with its own test library. REL also features extendable query builder that allows you to write query using builder or plain sql.

## Features

- Testable repository with builtin reltest package.
- Seamless nested transactions.
- Elegant, yet extendable query builder with mix of syntactic sugar.
- Supports Eager loading.
- Composite Primary Key.
- Multi adapter.
- Soft Deletion.
- Pagination.
- Schema Migration.

## Install

```bash
go get github.com/go-rel/rel
```

## Getting Started

- Guides [https://go-rel.github.io](https://go-rel.github.io)

## Examples

- [gin-example](https://github.com/go-rel/gin-example) - Todo Backend using Gin and REL
- [go-todo-backend](https://github.com/Fs02/go-todo-backend) - Todo Backend using Chi and REL
- [iris-example](https://github.com/iris-contrib/go-rel-iris-example) - Todo Backend using Iris and REL

## License

Released under the [MIT License](https://github.com/go-rel/rel/blob/master/LICENSE)


Single interface for interacting with different data sources through the use of adapters that wrap mature database drivers

<p align="center">
  <img src="https://upper.io/img/gopher.svg" width="256">
</p>

<p align="center">
  <a href="https://github.com/upper/db/actions?query=workflow%3Aunit-tests"><img alt="upper/db unit tests status" src="https://github.com/upper/db/workflows/unit-tests/badge.svg"></a>
</p>

# upper/db

`upper/db` is a productive data access layer (DAL) for [Go](https://golang.org)
that provides agnostic tools to work with different data sources, such as:

* [PostgreSQL](https://upper.io/v4/adapter/postgresql)
* [MySQL](https://upper.io/v4/adapter/mysql)
* [MSSQL](https://upper.io/v4/adapter/mssql)
* [CockroachDB](https://upper.io/v4/adapter/cockroachdb)
* [MongoDB](https://upper.io/v4/adapter/mongo)
* [QL](https://upper.io/v4/adapter/ql)
* [SQLite](https://upper.io/v4/adapter/sqlite)

See [upper.io/v4](//upper.io/v4) for documentation and code samples.

## The tour

![tour](https://user-images.githubusercontent.com/385670/91495824-c6fabb00-e880-11ea-925b-a30b94474610.png)

Take the [tour](https://tour.upper.io) to see real live examples in your
browser.

## License

Licensed under [MIT License](./LICENSE)

## Contributors

See the [list of contributors](https://github.com/upper/db/graphs/contributors).


The Best Go Libraries For ORM (24)