Moved query and exec process to Relation.

delete.go

@@ -0,0 +1,38 @@
+package ar
+
+import (
+	"database/sql"
+
+	"github.com/monochromegane/argen/query"
+)
+
+type Delete struct {
+	*query.Delete
+	exec *Executer
+}
+
+func NewDelete(db *sql.DB, logger *Logger) *Delete {
+	return &Delete{
+		Delete: &query.Delete{},
+		exec:   &Executer{db, logger},
+	}
+}
+
+func (d *Delete) Table(table string) *Delete {
+	d.Delete.Table(table)
+	return d
+}
+
+func (d *Delete) Where(cond string, args ...interface{}) *Delete {
+	d.Delete.Where(cond, args...)
+	return d
+}
+
+func (d *Delete) And(cond string, args ...interface{}) *Delete {
+	return d.Where(cond, args...)
+}
+
+func (d *Delete) Exec() (sql.Result, error) {
+	q, b := d.Delete.Build()
+	return d.exec.Exec(q, b...)
+}

executer.go

@@ -0,0 +1,20 @@
+package ar
+
+import (
+	"database/sql"
+	"time"
+)
+
+type Executer struct {
+	db     *sql.DB
+	logger *Logger
+}
+
+func (e *Executer) Exec(q string, b ...interface{}) (sql.Result, error) {
+	defer e.log(time.Now(), q, b...)
+	return e.db.Exec(q, b...)
+}
+
+func (e *Executer) log(t time.Time, sql string, args ...interface{}) {
+	e.logger.Print(time.Now().Sub(t), sql, args)
+}

gen/template.go

@@ -71,22 +71,14 @@ var structLogger = `package {{.Package}}
 import (
 	"log"
 	"os"
-	"time"
 
 	"github.com/monochromegane/argen"
 )
 
-var logMode bool
-var logger = ar.Logger{log.New(os.Stdout, "", 0)}
+var logger = &ar.Logger{Logger: log.New(os.Stdout, "", 0)}
 
 func LogMode(mode bool) {
-	logMode = mode
-}
-
-func Log(t time.Time, sql string, args ...interface{}) {
-	if logMode {
-		logger.Print(time.Now().Sub(t), sql, args)
-	}
+	logger.LogMode = mode
 }
 `
 

gen/tpl_delete.go

@@ -5,11 +5,7 @@ var delete = &Template{
 	Text: `
 func (m *{{.Name}}) Delete() (bool, *ar.Errors) {
         errs := &ar.Errors{}
-        del := ar.NewDelete()
-	q, b := del.Table("{{.TableName}}").Where("{{.PrimaryKeyColumn}}", m.{{.PrimaryKeyField}}).Build()
-	defer Log(time.Now(), q, b...)
-
-        if _, err := db.Exec(q, b...); err != nil {
+        if _, err := ar.NewDelete(db, logger).Table("{{.TableName}}").Where("{{.PrimaryKeyColumn}}", m.{{.PrimaryKeyField}}).Exec(); err != nil {
                 errs.AddError("base", err)
                 return false, errs
         }
@@ -18,12 +14,7 @@ func (m *{{.Name}}) Delete() (bool, *ar.Errors) {
 
 func (m {{.Name}}) DeleteAll() (bool, *ar.Errors) {
         errs := &ar.Errors{}
-        del := ar.NewDelete()
-        del.Table("{{.TableName}}")
-        q, b := del.Build()
-	defer Log(time.Now(), q, b...)
-
-        if _, err := db.Exec(q, b...); err != nil {
+        if _, err := ar.NewDelete(db, logger).Table("{{.TableName}}").Exec(); err != nil {
                 errs.AddError("base", err)
                 return false, errs
         }

gen/tpl_explain.go

@@ -4,10 +4,7 @@ var explain = &Template{
 	Name: "Explain",
 	Text: `
 func (r *{{.Name}}Relation) Explain() error {
-        r.Relation.Explain()
-        q, b := r.Build()
-	defer Log(time.Now(), q, b...)
-        rows, err := db.Query(q, b...)
+        rows, err := r.Relation.Explain().Query()
         if err != nil {
                 return err
         }
@@ -25,7 +22,6 @@ func (r *{{.Name}}Relation) Explain() error {
                 values = append(values, vals)
         }
 
-        fmt.Printf("%s %v\n", q, b)
         goban.Render(columns, values)
         return nil
 }

gen/tpl_query.go

@@ -4,13 +4,11 @@ var query = &Template{
 	Name: "Query",
 	Text: `
 func (r *{{.Name}}Relation) Query() ([]*{{.Name}}, error) {
-        q, b := r.Build()
-	defer Log(time.Now(), q, b...)
-        rows, err := db.Query(q, b...)
-        if err != nil {
-                return nil, err
-        }
-        defer rows.Close()
+	rows, err := r.Relation.Query()
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
 
         results := []*{{.Name}}{}
         for rows.Next() {

gen/tpl_query_row.go

@@ -4,10 +4,8 @@ var queryRow = &Template{
 	Name: "QueryRow",
 	Text: `
 func (r *{{.Name}}Relation) QueryRow() (*{{.Name}}, error) {
-	q, b := r.Build()
-	defer Log(time.Now(), q, b...)
 	row := &{{.Name}}{}
-	err := db.QueryRow(q, b...).Scan(row.fieldPtrsByName(r.Relation.GetColumns())...)
+	err := r.Relation.QueryRow(row.fieldPtrsByName(r.Relation.GetColumns())...)
 	if err != nil {
 		return nil, err
 	}

gen/tpl_relation.go

@@ -9,7 +9,7 @@ type {{.Name}}Relation struct {
 }
 
 func (m *{{.Name}}) newRelation() *{{.Name}}Relation {
-	r := ar.NewRelation()
+	r := ar.NewRelation(db, logger)
         r.Table("{{.TableName}}").Columns({{range .Fields}}
 		"{{.ColumnName}}",{{end}}
 	)

gen/tpl_save.go

@@ -19,13 +19,11 @@ func (m *{{.Name}}) Save(validate ...bool) (bool, *ar.Errors) {
 	}
 	errs := &ar.Errors{}
         if m.IsNewRecord() {
-		ins := ar.NewInsert()
-                q, b := ins.Table("{{.TableName}}").Params(map[string]interface{}{ {{range .FieldsWithoutPrimaryKey}}
+                ins := ar.NewInsert(db, logger).Table("{{.TableName}}").Params(map[string]interface{}{ {{range .FieldsWithoutPrimaryKey}}
 			"{{.ColumnName}}": m.{{.Name}},{{end}}
-                }).Build()
-		defer Log(time.Now(), q, b...)
+                })
 
-                if result, err := db.Exec(q, b...); err != nil {
+                if result, err := ins.Exec(); err != nil {
 			errs.AddError("base", err)
                         return false, errs
                 } else {
@@ -35,13 +33,11 @@ func (m *{{.Name}}) Save(validate ...bool) (bool, *ar.Errors) {
 		}
                 return true, nil
         }else{
-		upd := ar.NewUpdate()
-		q, b := upd.Table("{{.TableName}}").Params(map[string]interface{}{ {{range .Fields}}
+		upd := ar.NewUpdate(db, logger).Table("{{.TableName}}").Params(map[string]interface{}{ {{range .Fields}}
 		"{{.ColumnName}}": m.{{.Name}},{{end}}
-		}).Where("{{.PrimaryKeyColumn}}", m.{{.PrimaryKeyField}}).Build()
-		defer Log(time.Now(), q, b...)
+		}).Where("{{.PrimaryKeyColumn}}", m.{{.PrimaryKeyField}})
 
-		if _, err := db.Exec(q, b...); err != nil {
+		if _, err := upd.Exec(); err != nil {
 			errs.AddError("base", err)
 			return false, errs
 		}

insert.go

@@ -0,0 +1,34 @@
+package ar
+
+import (
+	"database/sql"
+
+	"github.com/monochromegane/argen/query"
+)
+
+type Insert struct {
+	*query.Insert
+	exec *Executer
+}
+
+func NewInsert(db *sql.DB, logger *Logger) *Insert {
+	return &Insert{
+		Insert: &query.Insert{},
+		exec:   &Executer{db, logger},
+	}
+}
+
+func (i *Insert) Table(table string) *Insert {
+	i.Insert.Table(table)
+	return i
+}
+
+func (i *Insert) Params(params map[string]interface{}) *Insert {
+	i.Insert.Params(params)
+	return i
+}
+
+func (i *Insert) Exec() (sql.Result, error) {
+	q, b := i.Insert.Build()
+	return i.exec.Exec(q, b...)
+}

logger.go

@@ -8,9 +8,14 @@ import (
 
 type Logger struct {
 	*log.Logger
+	LogMode bool
 }
 
 func (l Logger) Print(values ...interface{}) {
+	if !l.LogMode {
+		return
+	}
+
 	log := []interface{}{}
 	// currentTime
 	currentTime := "\033[33m[" + time.Now().Format("2006-01-02 15:04:05") + "]\033[0m"

query/delete_test.go

@@ -9,6 +9,6 @@ func TestDelete(t *testing.T) {
 
 	q, b := del.Build()
 
-	assertQuery(t, "DELETE FROM table WHERE columnA = ?", q)
+	assertQuery(t, "DELETE FROM table WHERE columnA = ?;", q)
 	assertBinds(t, []interface{}{"value1", "value2", "value1"}, b)
 }

query/update_test.go

@@ -12,6 +12,6 @@ func TestUpdate(t *testing.T) {
 
 	q, b := update.Build()
 
-	assertQuery(t, "UPDATE table SET columnA = ? WHERE columnA = ?", q)
+	assertQuery(t, "UPDATE table SET columnA = ? WHERE columnA = ?;", q)
 	assertBinds(t, []interface{}{"value1", "value1"}, b)
 }

relation.go

@@ -1,43 +1,27 @@
 package ar
 
 import (
+	"database/sql"
 	"reflect"
 	"strings"
+	"time"
 	"unicode"
 
 	"github.com/monochromegane/argen/query"
 )
 
 type Relation struct {
 	*query.Select
+	db     *sql.DB
+	logger *Logger
 }
 
-type Insert struct {
-	*query.Insert
-}
-
-type Update struct {
-	*query.Update
-}
-
-type Delete struct {
-	*query.Delete
-}
-
-func NewRelation() *Relation {
-	return &Relation{&query.Select{}}
-}
-
-func NewInsert() *Insert {
-	return &Insert{&query.Insert{}}
-}
-
-func NewUpdate() *Update {
-	return &Update{&query.Update{}}
-}
-
-func NewDelete() *Delete {
-	return &Delete{&query.Delete{}}
+func NewRelation(db *sql.DB, logger *Logger) *Relation {
+	return &Relation{
+		Select: &query.Select{},
+		db:     db,
+		logger: logger,
+	}
 }
 
 func (r *Relation) Table(table string) *Relation {
@@ -97,6 +81,22 @@ func (r *Relation) Build() (string, []interface{}) {
 	return r.Select.Build()
 }
 
+func (r *Relation) Query() (*sql.Rows, error) {
+	q, b := r.Build()
+	defer r.log(time.Now(), q, b...)
+	return r.db.Query(q, b...)
+}
+
+func (r *Relation) QueryRow(dest ...interface{}) error {
+	q, b := r.Build()
+	defer r.log(time.Now(), q, b...)
+	return r.db.QueryRow(q, b...).Scan(dest...)
+}
+
+func (r *Relation) log(t time.Time, sql string, args ...interface{}) {
+	r.logger.Print(time.Now().Sub(t), sql, args)
+}
+
 func IsZero(v interface{}) bool {
 	return reflect.ValueOf(v).Interface() == reflect.Zero(reflect.TypeOf(v)).Interface()
 }

tests/logger_gen.go

@@ -3,20 +3,12 @@ package tests
 import (
 	"log"
 	"os"
-	"time"
 
 	"github.com/monochromegane/argen"
 )
 
-var logMode bool
-var logger = ar.Logger{log.New(os.Stdout, "", 0)}
+var logger = &ar.Logger{Logger: log.New(os.Stdout, "", 0)}
 
 func LogMode(mode bool) {
-	logMode = mode
-}
-
-func Log(t time.Time, sql string, args ...interface{}) {
-	if logMode {
-		logger.Print(time.Now().Sub(t), sql, args)
-	}
+	logger.LogMode = mode
 }