table interface fix

Author: folospace

README.md

@@ -30,20 +30,22 @@ import (
 var db, _ = orm.OpenMysql("user:password@tcp(127.0.0.1:3306)/mydb?parseTime=true&charset=utf8mb4&loc=Asia%2FShanghai")
 
 //user table model
-var UserTable = orm.NewQuery(User{}, db)
+var UserTable = orm.NewQuery(User{})
 
 type User struct {
     Id   int    `json:"id"`
     Name string `json:"name"`
 }
 
-//Table interface: implements two methods below 
-func (User) TableName() string {
-    return "user"
+func (User) Connection() []*sql.DB {
+    return []*sql.DB{db}
 }
 func (User) DatabaseName() string {
     return "mydb"
 }
+func (User) TableName() string {
+    return "user"
+}
 ```
 
 ## migration (create table from struct | create struct from table)

example.go

@@ -10,30 +10,37 @@ import (
 //connect mysql db
 var db, _ = orm.OpenMysql("user:password@tcp(127.0.0.1:3306)/mydb?parseTime=true&charset=utf8mb4&loc=Asia%2FShanghai")
 
-//user table model
-var UserTable = orm.NewQuery(User{}, db)
+//query user
+var UserQuery = orm.NewQuery(User{})
 
 type User struct {
     Id   int    `json:"id"`
     Name string `json:"name"`
 }
 
-func (User) TableName() string {
-    return "user"
+func (User) Connection() []*sql.DB {
+    return []*sql.DB{db}
 }
 func (User) DatabaseName() string {
     return "mydb"
 }
+func (User) TableName() string {
+    return "user"
+}
 
 //user table model
-var OrderTable = orm.NewQuery(Order{}, db)
+var OrderQuery = orm.NewQuery(Order{})
 
 type Order struct {
     Id          int `json:"id"`
     UserId      int `json:"user_id"`
     OrderAmount int `json:"order_amount"`
 }
 
+func (o Order) Connection() []*sql.DB {
+    return []*sql.DB{db}
+}
+
 func (Order) TableName() string {
     return "order"
 }
@@ -44,88 +51,88 @@ func (Order) DatabaseName() string {
 func main() {
     {
         //create db table from go struct
-        _, _ = orm.CreateTableFromStruct(UserTable)
+        _, _ = orm.CreateTableFromStruct(UserQuery)
         //create go struct from db table
-        _ = orm.CreateStructFromTable(UserTable)
+        _ = orm.CreateStructFromTable(UserQuery)
     }
 
     //query select
     {
         //get first user (name='join') as struct
-        user, query := UserTable.Where(&UserTable.T.Name, "john").Get()
+        user, query := UserQuery.Where(&UserQuery.T.Name, "john").Get()
         fmt.Println(user, query.Sql(), query.Error())
 
         //get users by primary ids
-        users, query := UserTable.Gets(1, 2, 3)
+        users, query := UserQuery.Gets(1, 2, 3)
         fmt.Println(users, query.Sql(), query.Error())
 
         //get user rows as []map[string]interface
-        rows, query := UserTable.Limit(5).GetRows()
+        rows, query := UserQuery.Limit(5).GetRows()
         fmt.Println(rows, query.Sql(), query.Error())
 
         //get users count(*)
-        count, query := UserTable.GetCount()
+        count, query := UserQuery.GetCount()
         fmt.Println(count, query.Sql(), query.Error())
 
         //get user names map key by id
         var userNameKeyById map[int]string
-        UserTable.Select(&UserTable.T.Id, &UserTable.T.Name).GetTo(&userNameKeyById)
+        UserQuery.Select(&UserQuery.T.Id, &UserQuery.T.Name).GetTo(&userNameKeyById)
 
         //get users map key by name
         var usersMapkeyByName map[string][]User
-        UserTable.Select(&UserTable.T.Name, UserTable.AllCols()).GetTo(&usersMapkeyByName)
+        UserQuery.Select(&UserQuery.T.Name, UserQuery.AllCols()).GetTo(&usersMapkeyByName)
 
         //select rank by column
-        OrderTable.Where(&OrderTable.T.UserId, 1).
-            Select(OrderTable.AllCols()).
-            SelectRank(&OrderTable.T.OrderAmount, "order_amount_rank").GetRows()
+        OrderQuery.Where(&OrderQuery.T.UserId, 1).
+            Select(OrderQuery.AllCols()).
+            SelectRank(&OrderQuery.T.OrderAmount, "order_amount_rank").GetRows()
     }
 
     //query update and delete and insert
     {
         //update user set name="hello" where id=1
-        UserTable.WherePrimary(1).Update(&UserTable.T.Name, "hello")
+        UserQuery.WherePrimary(1).Update(&UserQuery.T.Name, "hello")
 
         //query delete
-        UserTable.Delete(1, 2, 3)
+        UserQuery.Delete(1, 2, 3)
 
         //query insert
-        _ = UserTable.Insert(User{Name: "han"}).LastInsertId //insert one row and get id
+        _ = UserQuery.Insert(User{Name: "han"}).LastInsertId //insert one row and get id
 
         //insert batch on duplicate key update name=values(name)
-        _ = UserTable.InsertsIgnore([]User{{Id: 1, Name: "han"}, {Id: 2, Name: "jen"}},
-            []orm.UpdateColumn{{Column: &UserTable.T.Name, Val: &UserTable.T.Name}})
+        _ = UserQuery.InsertsIgnore([]User{{Id: 1, Name: "han"}, {Id: 2, Name: "jen"}},
+            []orm.UpdateColumn{{Column: &UserQuery.T.Name, Val: &UserQuery.T.Name}})
     }
 
     //query join
     {
-        UserTable.Join(OrderTable.T, func(query orm.Query[User]) orm.Query[User] {
-            return query.Where(&UserTable.T.Id, &OrderTable.T.UserId)
-        }).Where(&OrderTable.T.OrderAmount, 100).
-            Select(UserTable.AllCols()).Gets()
+        UserQuery.Join(OrderQuery.T, func(query orm.Query[User]) orm.Query[User] {
+            return query.Where(&UserQuery.T.Id, &OrderQuery.T.UserId)
+        }).Where(&OrderQuery.T.OrderAmount, 100).
+            Select(UserQuery.AllCols()).Gets()
     }
     {
         //transaction
-        _ = UserTable.Transaction(func(tx *sql.Tx) error {
-            newId := UserTable.UseTx(tx).Insert(User{Name: "john"}).LastInsertId //insert
+        _ = UserQuery.Transaction(func(tx *sql.Tx) error {
+            newId := UserQuery.UseTx(tx).Insert(User{Name: "john"}).LastInsertId //insert
             fmt.Println(newId)
             return errors.New("I want rollback") //rollback
         })
     }
 
     {
         //subquery
-        subquery := UserTable.Where(&UserTable.T.Id, 1).SubQuery()
+        subquery := UserQuery.Where(&UserQuery.T.Id, 1).SubQuery()
 
         //where in suquery
-        UserTable.Where(&UserTable.T.Id, orm.WhereIn, subquery).Gets()
+        UserQuery.Where(&UserQuery.T.Id, orm.WhereIn, subquery).Gets()
 
         //insert subquery
-        UserTable.InsertSubquery(subquery, nil)
+        UserQuery.InsertSubquery(subquery, nil)
 
         //join subquery
-        UserTable.Join(subquery, func(query orm.Query[User]) orm.Query[User] {
-            return query.Where(&UserTable.T.Id, orm.Raw("sub.id"))
+        UserQuery.Join(subquery, func(query orm.Query[User]) orm.Query[User] {
+            return query.Where(&UserQuery.T.Id, orm.Raw("sub.id"))
         }).Gets()
     }
 }

orm/query.go

@@ -81,15 +81,24 @@ func (m Query[T]) UseTx(tx *sql.Tx) Query[T] {
 func (m Query[T]) DB() *sql.DB {
     return m.writeDB()
 }
+
+func (m Query[T]) DBs() []*sql.DB {
+    if len(m.writeAndReadDbs) == 0 && len(m.tables) > 0 {
+        m.writeAndReadDbs = m.tables[0].table.Connection()
+    }
+    return m.writeAndReadDbs
+}
 func (m Query[T]) writeDB() *sql.DB {
-    if len(m.writeAndReadDbs) > 0 {
-        return m.writeAndReadDbs[0]
+    dbs := m.DBs()
+    if len(dbs) > 0 {
+        return dbs[0]
     }
     return nil
 }
 func (m Query[T]) readDB() *sql.DB {
-    if len(m.writeAndReadDbs) > 1 {
-        return m.writeAndReadDbs[rand.Intn(len(m.writeAndReadDbs)-1)+1] //rand get db
+    dbs := m.DBs()
+    if len(dbs) > 1 {
+        return dbs[rand.Intn(len(dbs)-1)+1] //rand get db
     } else {
         return m.writeDB()
     }

orm/query_select_gen.go

@@ -12,7 +12,7 @@ func (m Query[T]) SubQuery() SubQuery {
         mt := cte.WithRecursiveCte(m.SubQuery(), cte.T.TableName())
         tempTable := mt.generateSelectQuery(mt.columns...)
 
-        tempTable.dbs = mt.writeAndReadDbs
+        tempTable.dbs = mt.DBs()
         tempTable.tx = mt.tx
         tempTable.dbName = mt.tables[0].table.DatabaseName()
         if mt.result.Err != nil {
@@ -24,7 +24,7 @@ func (m Query[T]) SubQuery() SubQuery {
         mt := m
         tempTable := mt.generateSelectQuery(mt.columns...)
 
-        tempTable.dbs = mt.writeAndReadDbs
+        tempTable.dbs = mt.DBs()
         tempTable.tx = mt.tx
         tempTable.dbName = mt.tables[0].table.DatabaseName()
         if mt.result.Err != nil {

orm/query_with.go

@@ -15,9 +15,9 @@ func (m Query[T]) WithParentsOnColumn(pidColumn interface{}) Query[T] {
     coln := strings.Split(col, ".")
     newcol := strings.Trim(coln[len(coln)-1], "`")
 
-    cte := NewQueryRaw(tempName, m.writeAndReadDbs...)
+    cte := NewQueryRaw(tempName, m.DBs()...)
 
-    appendQuery := NewQuery(*m.T, m.writeAndReadDbs...)
+    appendQuery := NewQuery(*m.T, m.DBs()...)
     appendQuery = appendQuery.Join(cte.T, func(query Query[T]) Query[T] {
         return query.Where(appendQuery.tables[0].tableStruct.Field(0).Addr().Interface(), Raw(tempName+"."+newcol))
     }).Select(appendQuery.AllCols())
@@ -43,9 +43,9 @@ func (m Query[T]) WithChildrenOnColumn(pidColumn interface{}) Query[T] {
     coln := strings.Split(col, ".")
     newcol := strings.Trim(coln[len(coln)-1], "`")
 
-    cte := NewQueryRaw(tempName, m.writeAndReadDbs...)
+    cte := NewQueryRaw(tempName, m.DBs()...)
 
-    appendQuery := NewQuery(*m.T, m.writeAndReadDbs...)
+    appendQuery := NewQuery(*m.T, m.DBs()...)
     appendQuery = appendQuery.Join(cte.T, func(query Query[T]) Query[T] {
         return query.Where(pcol, Raw(tempName+"."+newcol))
     }).Select(appendQuery.AllCols())

orm/subquery.go

@@ -24,6 +24,14 @@ func NewSubQuery(prepareSql string, bindings ...interface{}) SubQuery {
     return SubQuery{raw: prepareSql, bindings: bindings}
 }
 
+func (m SubQuery) Connection() []*sql.DB {
+    return m.dbs
+}
+
+func (m SubQuery) DatabaseName() string {
+    return m.dbName
+}
+
 func (m SubQuery) TableName() string {
     if m.tableName != "" {
         return m.tableName
@@ -34,10 +42,6 @@ func (m SubQuery) TableName() string {
     return ""
 }
 
-func (m SubQuery) DatabaseName() string {
-    return m.dbName
-}
-
 func (m SubQuery) Error() error {
     return m.err
 }

orm/table.go

@@ -1,6 +1,9 @@
 package orm
 
+import "database/sql"
+
 type Table interface {
-    TableName() string
+    Connection() []*sql.DB
     DatabaseName() string
+    TableName() string
 }

orm_migrate_test.go

@@ -1,6 +1,7 @@
 package main
 
 import (
+    "database/sql"
     "github.com/folospace/go-mysql-orm/orm"
     "testing"
     "time"
@@ -44,6 +45,9 @@ type Family struct {
     Updated            time.Time `json:"updated" orm:"updated,timestamp" default:"CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP"`
 }
 
+func (Family) Connection() []*sql.DB {
+    return []*sql.DB{tdb}
+}
 func (Family) TableName() string {
     return "family"
 }
@@ -54,7 +58,7 @@ func (Family) DatabaseName() string {
 
 func TestMigrate(t *testing.T) {
     t.Run("create_struct", func(t *testing.T) {
-        FamilyTable := orm.NewQuery(Family{}, tdb)
+        FamilyTable := orm.NewQuery(Family{})
 
         err := orm.CreateStructFromTable(FamilyTable)
 

orm_select_test.go

@@ -1,14 +1,15 @@
 package main
 
 import (
+    "database/sql"
     "github.com/folospace/go-mysql-orm/orm"
     "testing"
     "time"
 )
 
 var tdb, _ = orm.OpenMysql("rfamro@tcp(mysql-rfam-public.ebi.ac.uk:4497)/Rfam?parseTime=true&charset=utf8mb4&loc=Asia%2FShanghai")
 
-var FamilyTable2 = orm.NewQuery(Family2{}, tdb)
+var FamilyTable2 = orm.NewQuery(Family2{})
 
 type Family2 struct {
     RfamAcc            string    `json:"rfam_acc" orm:"rfam_acc,varchar(7),primary,unique"`
@@ -48,6 +49,10 @@ type Family2 struct {
     Updated            time.Time `json:"updated" orm:"updated,timestamp" default:"CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP"`
 }
 
+func (f Family2) Connection() []*sql.DB {
+    return []*sql.DB{tdb}
+}
+
 func (Family2) TableName() string {
     return "family"
 }