)
const (
- null = iota
+ null Type = iota
Execf
Queryf
)
+type Type int
+
type CanTx interface {
BeginTx(ctx context.Context, opts *sql.TxOptions) (*sql.Tx, error)
}
type BeforeF[T any] func(ctxVP *T, sqlf *SqlFunc[T], e *error)
type AfterEF[T any] func(ctxVP *T, result sql.Result, e *error)
+
+// func(ctxVP *T, rows *sql.Rows, e *error)
type AfterQF[T any] func(ctxVP *T, rows *sql.Rows, e *error)
type SqlTx[T any] struct {
}
type SqlFunc[T any] struct {
- Ty int
+ // Execf or Queryf, default: auto detection
+ Ty Type
+ // default: use transaction Ctx
Ctx context.Context
- Query string
+ Sql string
Args []any
SkipSqlErr bool
beforeF BeforeF[T]
return &tx
}
-func (t *SqlTx[T]) SimpleDo(query string, args ...any) *SqlTx[T] {
+func (t *SqlTx[T]) SimpleDo(sql string, args ...any) *SqlTx[T] {
t.sqlFuncs = append(t.sqlFuncs, &SqlFunc[T]{
- Query: query,
- Args: args,
+ Sql: sql,
+ Args: args,
})
return t
}
}
// PlaceHolder will replaced by ?
-func (t *SqlTx[T]) SimplePlaceHolderA(query string, ptr any) *SqlTx[T] {
+func (t *SqlTx[T]) SimplePlaceHolderA(sql string, ptr any) *SqlTx[T] {
return t.DoPlaceHolder(SqlFunc[T]{
- Query: query,
+ Sql: sql,
}, ptr)
}
// PlaceHolder will replaced by $%d
-func (t *SqlTx[T]) SimplePlaceHolderB(query string, ptr any) *SqlTx[T] {
+func (t *SqlTx[T]) SimplePlaceHolderB(sql string, ptr any) *SqlTx[T] {
return t.DoPlaceHolder(SqlFunc[T]{
- Query: query,
+ Sql: sql,
}, ptr, func(index int, holder string) (replaceTo string) {
return fmt.Sprintf("$%d", index+1)
})
field := dataR.Field(i)
if field.IsValid() && field.CanSet() {
replaceS := "{" + dataR.Type().Field(i).Name + "}"
- if strings.Contains(sqlf.Query, replaceS) {
+ if strings.Contains(sqlf.Sql, replaceS) {
if len(replaceF) == 0 {
- sqlf.Query = strings.ReplaceAll(sqlf.Query, replaceS, "?")
+ sqlf.Sql = strings.ReplaceAll(sqlf.Sql, replaceS, "?")
} else {
- sqlf.Query = strings.ReplaceAll(sqlf.Query, replaceS, replaceF[0](index, replaceS))
+ sqlf.Sql = strings.ReplaceAll(sqlf.Sql, replaceS, replaceF[0](index, replaceS))
index += 1
}
sqlf.Args = append(sqlf.Args, field.Interface())
if sqlf.beforeF != nil {
sqlf.beforeF(&ctxVP, sqlf, &e)
if e != nil {
- e = errors.Join(e, fmt.Errorf("%s; >> %s", sqlf.Query, err))
+ e = errors.Join(e, fmt.Errorf("%s; >> %s", sqlf.Sql, err))
hasErr = true
}
}
- if strings.TrimSpace(sqlf.Query) == "" {
+ if strings.TrimSpace(sqlf.Sql) == "" {
continue
}
if sqlf.Ty == null {
sqlf.Ty = Execf
- if uquery := strings.ToUpper(strings.TrimSpace(sqlf.Query)); strings.HasPrefix(uquery, "SELECT") {
+ if uquery := strings.ToUpper(strings.TrimSpace(sqlf.Sql)); strings.HasPrefix(uquery, "SELECT") {
sqlf.Ty = Queryf
}
}
switch sqlf.Ty {
case Execf:
- if res, err := tx.ExecContext(sqlf.Ctx, sqlf.Query, sqlf.Args...); err != nil {
+ if res, err := tx.ExecContext(sqlf.Ctx, sqlf.Sql, sqlf.Args...); err != nil {
hasErr = true
if !sqlf.SkipSqlErr {
- e = errors.Join(e, fmt.Errorf("%s; %s >> %s", sqlf.Query, sqlf.Args, err))
+ e = errors.Join(e, fmt.Errorf("%s; %s >> %s", sqlf.Sql, sqlf.Args, err))
}
} else if sqlf.afterEF != nil {
sqlf.afterEF(&ctxVP, res, &e)
if e != nil {
hasErr = true
- e = errors.Join(e, fmt.Errorf("%s; %s >> %s", sqlf.Query, sqlf.Args, err))
+ e = errors.Join(e, fmt.Errorf("%s; %s >> %s", sqlf.Sql, sqlf.Args, err))
}
}
case Queryf:
- if res, err := tx.QueryContext(sqlf.Ctx, sqlf.Query, sqlf.Args...); err != nil {
+ if res, err := tx.QueryContext(sqlf.Ctx, sqlf.Sql, sqlf.Args...); err != nil {
hasErr = true
if !sqlf.SkipSqlErr {
- e = errors.Join(e, fmt.Errorf("%s; %s >> %s", sqlf.Query, sqlf.Args, err))
+ e = errors.Join(e, fmt.Errorf("%s; %s >> %s", sqlf.Sql, sqlf.Args, err))
}
} else if sqlf.afterQF != nil {
sqlf.afterQF(&ctxVP, res, &e)
if e != nil {
hasErr = true
- e = errors.Join(e, fmt.Errorf("%s; %s >> %s", sqlf.Query, sqlf.Args, err))
+ e = errors.Join(e, fmt.Errorf("%s; %s >> %s", sqlf.Sql, sqlf.Args, err))
}
}
}
tx = tx.Do(SqlFunc[[]string]{
Ty: Execf,
Ctx: ctx,
- Query: "create table log (msg text)",
+ Sql: "create table log (msg text)",
SkipSqlErr: true,
})
tx = tx.Do(SqlFunc[[]string]{
Ty: Execf,
Ctx: ctx,
- Query: "create table log2 (msg text)",
+ Sql: "create table log2 (msg text)",
SkipSqlErr: true,
})
tx = tx.Do(SqlFunc[[]string]{
- Ty: Execf,
- Ctx: ctx,
- Query: "delete from log",
+ Ty: Execf,
+ Ctx: ctx,
+ Sql: "delete from log",
})
tx = tx.Do(SqlFunc[[]string]{
- Ty: Execf,
- Ctx: ctx,
- Query: "delete from log2",
+ Ty: Execf,
+ Ctx: ctx,
+ Sql: "delete from log2",
})
tx = tx.Do(SqlFunc[[]string]{
- Ty: Execf,
- Ctx: ctx,
- Query: "insert into log values (?)",
- Args: []any{dateTime},
+ Ty: Execf,
+ Ctx: ctx,
+ Sql: "insert into log values (?)",
+ Args: []any{dateTime},
})
tx = tx.Do(SqlFunc[[]string]{
- Ty: Queryf,
- Ctx: ctx,
- Query: "select msg from log",
+ Ty: Queryf,
+ Ctx: ctx,
+ Sql: "select msg from log",
}).AfterQF(func(dataP *[]string, rows *sql.Rows, err *error) {
names := make([]string, 0)
for rows.Next() {
Ty: Execf,
Ctx: ctx,
}).BeforeF(func(dataP *[]string, sqlf *SqlFunc[[]string], txE *error) {
- sqlf.Query = "insert into log2 values (?)"
+ sqlf.Sql = "insert into log2 values (?)"
sqlf.Args = append(sqlf.Args, (*dataP)[0])
})
tx = tx.Do(SqlFunc[[]string]{
- Ty: Queryf,
- Ctx: ctx,
- Query: "select msg from log2",
+ Ty: Queryf,
+ Ctx: ctx,
+ Sql: "select msg from log2",
}).AfterQF(func(dataP *[]string, rows *sql.Rows, err *error) {
names := make([]string, 0)
for rows.Next() {
conn, _ := db.Conn(context.Background())
if _, e := BeginTx[any](conn, context.Background(), &sql.TxOptions{}).Do(SqlFunc[any]{
- Ty: Execf,
- Query: "create table log123 (msg text)",
+ Ty: Execf,
+ Sql: "create table log123 (msg text)",
}).Fin(); e != nil {
t.Fatal(e)
}
go func() {
x := BeginTx[any](db, context.Background(), &sql.TxOptions{})
x.Do(SqlFunc[any]{
- Ty: Execf,
- Query: "insert into log123 values (?)",
- Args: []any{"1"},
+ Ty: Execf,
+ Sql: "insert into log123 values (?)",
+ Args: []any{"1"},
})
if _, e := x.Fin(); e != nil {
res <- e.Error()
{
tx := BeginTx[any](db, context.Background())
- tx.Do(SqlFunc[any]{Query: "create table log123 (msg INT,msg2 text)"})
+ tx.Do(SqlFunc[any]{Sql: "create table log123 (msg INT,msg2 text)"})
if _, e := tx.Fin(); e != nil {
t.Fatal(e)
}
Msg2 string
}
- insertLog123 := SqlFunc[any]{Query: "insert into log123 values ({Msg},{Msg2})"}
+ insertLog123 := SqlFunc[any]{Sql: "insert into log123 values ({Msg},{Msg2})"}
{
tx := BeginTx[any](db, context.Background())
tx.DoPlaceHolder(insertLog123, &logg{Msg: 1, Msg2: "a"})
}
}
{
- selectLog123 := SqlFunc[[]logg]{Query: "select msg as Msg, msg2 as Msg2 from log123 where msg = {Msg}"}
+ selectLog123 := SqlFunc[[]logg]{Sql: "select msg as Msg, msg2 as Msg2 from log123 where msg = {Msg}"}
tx := BeginTx[[]logg](db, context.Background())
tx.DoPlaceHolder(selectLog123, &logg{Msg: 2, Msg2: "b"})
tx.AfterQF(func(ctxVP *[]logg, rows *sql.Rows, txE *error) {
conn, _ := db.Conn(context.Background())
if _, e := BeginTx[any](conn, context.Background(), &sql.TxOptions{}).Do(SqlFunc[any]{
- Ty: Execf,
- Query: "create table log123 (msg text)",
+ Ty: Execf,
+ Sql: "create table log123 (msg text)",
}).Fin(); e != nil {
t.Fatal(e)
}
conn.Close()
tx1 := BeginTx[any](db, context.Background(), &sql.TxOptions{}).Do(SqlFunc[any]{
- Ty: Execf,
- Query: "insert into log123 values ('1')",
+ Ty: Execf,
+ Sql: "insert into log123 values ('1')",
})
if _, e := tx1.Fin(); e != nil {
}
if _, e := BeginTx[any](db, pctx.GenTOCtx(time.Second), &sql.TxOptions{}).Do(SqlFunc[any]{
- Query: "create table test (created varchar(20))",
+ Sql: "create table test (created varchar(20))",
SkipSqlErr: true,
}).Fin(); e != nil {
t.Fatal(e)
}
if _, e := BeginTx[any](db, context.Background(), &sql.TxOptions{}).DoPlaceHolder(SqlFunc[any]{
- Query: "insert into test (created) values ({Created})",
+ Sql: "insert into test (created) values ({Created})",
}, &test1{"1"}, func(index int, holder string) (replaceTo string) {
return fmt.Sprintf("$%d", index+1)
}).Fin(); e != nil {
}
if _, e := BeginTx[any](db, context.Background(), &sql.TxOptions{}).Do(SqlFunc[any]{
- Query: "select created as sss from test",
+ Sql: "select created as sss from test",
afterQF: func(_ *any, rows *sql.Rows, txE *error) {
if rowsP, e := DealRows[test1](rows, func() test1 { return test1{} }); e != nil {
*txE = e
projects / part / .git / commitdiff