naoina / genmai Goto Github PK

package main

import (
    "github.com/naoina/genmai"
    //    _ "github.com/go-sql-driver/mysql"
    "database/sql"
    _ "github.com/mattn/go-sqlite3"
    "log"
    "os"
    "runtime"
)

type Sample struct {
    Id   int64 `db:"pk"`
    Name string
}

func prepare(db *genmai.DB) {
    if err := db.CreateTable(&Sample{}); err != nil {
        log.Panic(err)
    }
    sampleData := [...]Sample{
        {1, "foo"},
        {2, "bar"},
        {3, "baz"},
        {4, "hoo"},
    }
    db.Insert(sampleData[:])
}

type Rollback struct {
    error
}

func (er Rollback) Error() string {
    return "Rollback is required."
}

func doTransact(db *genmai.DB, fn func(*genmai.DB) error) (ter error) {
    log.Print("Begin transaction")
    err := db.Begin()
    if err != nil {
        log.Print(err)
        return err
    }
    defer func() {
        e := recover()
        if e != nil {
            db.Rollback()

            if e2, ok := e.(error); ok {
                if _, ok = e2.(Rollback); !ok {
                    ter = e2
                }
            }
        } else {
            db.Commit()
        }
    }()
    err = fn(db)
    if err != nil {
        log.Print(err)
    }
    return err
}

func byGenmai(db *genmai.DB) error {
    var r []Sample

    err := db.Select(&r, db.Where("id", "=", 2))
    if err != nil {
        panic(err)
    }

    r[0].Name = "piyo"

    _, err = db.Update(r[0])
    if err != nil {
        panic(err)
    }

    return nil
}

func byGoSQL(db *sql.DB) {
    tx, _ := db.Begin()

    var r Sample
    stmt, err := tx.Prepare("SELECT * from sample WHERE id = (?)")
    if err != nil {
        tx.Rollback()
        return
    }
    if rows, err := stmt.Query(2); err != nil {
        tx.Rollback()
        return
    } else {
        defer rows.Close()
        cl, _ := rows.Columns()
        log.Print(cl)
        for rows.Next() {
            rows.Scan(&(r.Id), &(r.Name))
            break
        }
    }
    r.Name = "hoge"
    if stmt, err := tx.Prepare("UPDATE sample SET name = ? where id = ?"); err != nil {
        tx.Rollback()
        return
    } else {
        stmt.Exec(r.Name, r.Id)
    }

    tx.Commit()
}

func main() {
    db, err := genmai.New(&genmai.SQLite3Dialect{}, ":memory:")
    //    db, err := genmai.New(&genmai.MySQLDialect{}, "someone:pass@(localhost:3306)/test")

    if err != nil {
        return
    }
    db.SetLogOutput(os.Stdout)

    func() {
        prepare(db)
        defer db.DropTable(&Sample{})

        byGoSQL(db.DB())    // It work well.
    }()

    func() {
        prepare(db)
        defer db.DropTable(&Sample{})

        byGenmai(db)    // It work well too.
    }()

    func() {
        prepare(db)
        defer db.DropTable(&Sample{})

        doTransact(db, byGenmai)    // It cause SEGV inside of SQLite.
    }()
}

package main

import (
	"fmt"
	_ "github.com/mattn/go-sqlite3"
	"time"
	// _ "github.com/go-sql-driver/mysql"
	// _ "github.com/lib/pq"
	"github.com/naoina/genmai"
)

type Book struct {
	Id        int       `db: column:"id,key,auto"`
	Title     string    `db: column:"title"`
	Author    string    `db: column:"author"`
	Published time.Time `db: column:"published"`
}

func main() {
	db, err := genmai.New(&genmai.SQLite3Dialect{}, "gen.db")

//	err = db.CreateTable(&Book{})

	fmt.Println(err)
	var book = &Book{
		Title:     "date right  Hobbit",
		Author:    "time.Time for Date",
		Published: time.Date(2020, 10, 13, 0, 0, 0, 0, time.UTC),
	}
	n, err := db.Insert(book)
	if err != nil {
		panic(err)
	}
	fmt.Printf("inserted rows: %d\n", n)

}