feature(首页):

1、首页数据指标统计
2、websocket log 分开打印

opms_admin/app/service/sys_user_datascope.go

@@ -173,12 +173,12 @@ func (s *UserService) GetDataScope(userId int) (where g.Map, err error) {
 			return g.Map{"userIds": "-1"}, nil
 		case "20": // 自定数据权限
 			userIds, err := userDao.Fields(userDao.C.Id).WhereIn(
-				userDao.C.DeptId, dao.NewSysRoleDeptDao(s.Tenant).Fields(dao.SysRoleDept.C.DeptId).WhereIn(dao.SysRoleDept.C.RoleId, role.Id),
+				userDao.C.DeptId, dao.NewSysRoleDeptDao(s.Tenant).Fields(dao.SysRoleDept.C.DeptId).WhereIn(dao.SysRoleDept.C.RoleId, role.Id).M,
 			).Array()
 			if err != nil {
 				return nil, err
 			}
-			userIdArr.Add(userIds)
+			userIdArr.Add(gconv.Interfaces(userIds)...)
 		case "30": // 本部门数据权限
 			if deptAndSonFlag || deptFlag {
 				continue
@@ -188,7 +188,7 @@ func (s *UserService) GetDataScope(userId int) (where g.Map, err error) {
 			if err != nil {
 				return nil, err
 			}
-			userIdArr.Add(userIds)
+			userIdArr.Add(gconv.Interfaces(userIds)...)
 		case "40": // 本部门及以下数据权限
 			if deptAndSonFlag {
 				continue
@@ -204,7 +204,7 @@ func (s *UserService) GetDataScope(userId int) (where g.Map, err error) {
 			if err != nil {
 				return nil, err
 			}
-			userIdArr.Add(userIds)
+			userIdArr.Add(gconv.Interfaces(userIds)...)
 		case "50": // 仅本人数据权限
 			userIdArr.Add(userId)
 		}

opms_admin/app/service/websocket_manager.go

@@ -4,10 +4,9 @@ import (
 	"dashoo.cn/micro/app/model"
 	"encoding/json"
 	"fmt"
+	"github.com/gogf/gf/frame/g"
 	"github.com/gogf/gf/net/ghttp"
-	"github.com/gogf/gf/os/glog"
 	"github.com/gorilla/websocket"
-	"log"
 	"net/http"
 	"sync"
 	"time"
@@ -19,7 +18,7 @@ func CheckRun() {
 	go func() {
 		defer func() {
 			if r := recover(); r != nil {
-				log.Println(r)
+				g.Log("websocket").Println(r)
 			}
 		}()
 		heartbeat()
@@ -29,7 +28,7 @@ func CheckRun() {
 	go func() {
 		defer func() {
 			if r := recover(); r != nil {
-				log.Println(r)
+				g.Log("websocket").Println(r)
 			}
 		}()
 		register()
@@ -132,7 +131,7 @@ func accountUnBind(c *Client) {
 	Manager.mu.Lock()
 	// 取消连接
 	if err := c.Socket.Close(); err != nil {
-		glog.Error(err)
+		g.Log("websocket").Error(err)
 	}
 	delete(Manager.Clients, c.ID)
 	Manager.mu.Unlock()
@@ -148,14 +147,14 @@ func heartbeat() {
 			clients = append(clients, c)
 		}
 		Manager.mu.Unlock()
-		glog.Info("开始本次心跳：")
+		g.Log("websocket").Info("开始本次心跳：")
 		for _, c := range clients {
-			glog.Info(c.ID)
+			g.Log("websocket").Info(c.ID)
 			if time.Now().Unix()-c.HeartbeatTime > HeartbeatTime {
 				accountUnBind(c)
 			}
 		}
-		glog.Info("结束本次心跳：")
+		g.Log("websocket").Info("结束本次心跳：")
 
 		time.Sleep(time.Second * HeartbeatCheckTime)
 	}
@@ -176,7 +175,7 @@ func GetClient(uuid string) *Client {
 // 读取信息，即收到消息 TODO 服务端读取客户的返回消息，并维持心跳
 func (c *Client) Read() {
 	defer func() {
-		fmt.Println("历史数据关闭")
+		g.Log("websocket").Info("历史数据关闭")
 		_ = c.Socket.Close()
 	}()
 	for {
@@ -191,7 +190,7 @@ func (c *Client) Read() {
 		}
 		err = json.Unmarshal(body, &msg)
 		if err != nil {
-			log.Println(err)
+			g.Log("websocket").Error(err)
 			continue
 		}
 
@@ -203,7 +202,7 @@ func (c *Client) Read() {
 			replyMsg := CreateReplyMsg(MessageTypeHeartbeat, ServiceMessageContent{})
 			err = c.Socket.WriteMessage(websocket.TextMessage, replyMsg)
 			if err != nil {
-				log.Println(err)
+				g.Log("websocket").Error(err)
 			}
 			continue
 		}
@@ -232,7 +231,7 @@ func Send(uuids []string, message ServiceMessage) error {
 func MessageNotify(uuid string, data model.SysMessage) {
 	_, ok := Manager.Clients[uuid]
 	if !ok { // 无匹配数据，直接报错
-		glog.Error(fmt.Sprintf("uuid：%v 无匹配连接", uuid))
+		g.Log("websocket").Error(fmt.Sprintf("uuid：%v 无匹配连接", uuid))
 		return
 	}
 
@@ -245,7 +244,7 @@ func MessageNotify(uuid string, data model.SysMessage) {
 		}
 		err := Send([]string{uuid}, msg)
 		if err != nil {
-			log.Println(err)
+			g.Log("websocket").Error(err)
 		}
 	}()
 }
@@ -254,7 +253,7 @@ func CreateConnection(uuid string, r *ghttp.Request) {
 	// 将http升级为websocket
 	conn, err := r.WebSocket()
 	if err != nil {
-		log.Println(err)
+		g.Log("websocket").Error(err)
 		http.NotFound(r.Response.Writer, r.Request)
 		return
 	}
@@ -274,7 +273,7 @@ func CreateConnection(uuid string, r *ghttp.Request) {
 	go func() {
 		defer func() {
 			if r := recover(); r != nil {
-				log.Printf("MessageNotify read panic: %+v\n", r)
+				g.Log("websocket").Printf("MessageNotify read panic: %+v\n", r)
 			}
 		}()
 

opms_admin/config/config.toml

@@ -1,12 +1,17 @@
 # 应用系统设置
 [setting]
-    logpath = "/tmp/log/admin"
+    logpath = "./log/admin"
     bind-addr = "127.0.0.1:8888"
     need-advertise-addr = false
     srv-name = "dashoo.opms.admin-0.0.1"
     env = "dev"
     websocket-addr = "127.0.0.1:8899"
 
+[logger.websocket]
+    path   = "./log/websocket"
+    level  = "all"
+    stdout = false
+
 # 微服务注册中心配置
 [service_registry]
     registry = "peer2peer" # consul 或 peer2peer

opms_parent/app/dao/proj/internal/proj_business_contact.go

@@ -19,10 +19,11 @@ import (
 
 // ProjBusinessContactDao is the manager for logic model data accessing and custom defined data operations functions management.
 type ProjBusinessContactDao struct {
-	gmvc.M                            // M is the core and embedded struct that inherits all chaining operations from gdb.Model.
-	C      projBusinessContactColumns // C is the short type for Columns, which contains all the column names of Table for convenient usage.
-	DB     gdb.DB                     // DB is the raw underlying database management object.
-	Table  string                     // Table is the underlying table name of the DAO.
+	gmvc.M                             // M is the core and embedded struct that inherits all chaining operations from gdb.Model.
+	C       projBusinessContactColumns // C is the short type for Columns, which contains all the column names of Table for convenient usage.
+	DB      gdb.DB                     // DB is the raw underlying database management object.
+	Table   string                     // Table is the underlying table name of the DAO.
+	TableAs string                     // TableAs is the underlying table alias name of the DAO.
 }
 
 // ProjBusinessContactColumns defines and stores column names for table proj_business_contact.
@@ -90,7 +91,7 @@ func NewProjBusinessContactDao(tenant string) ProjBusinessContactDao {
 // Note that this returned DB object can be used only once, so do not assign it to
 // a global or package variable for long using.
 func (d *ProjBusinessContactDao) Ctx(ctx context.Context) *ProjBusinessContactDao {
-	return &ProjBusinessContactDao{M: d.M.Ctx(ctx)}
+	return &ProjBusinessContactDao{M: d.M.Ctx(ctx), Table: d.Table, TableAs: d.TableAs}
 }
 
 // GetCtx returns the context for current Model.
@@ -101,34 +102,34 @@ func (d *ProjBusinessContactDao) GetCtx() context.Context {
 
 // As sets an alias name for current table.
 func (d *ProjBusinessContactDao) As(as string) *ProjBusinessContactDao {
-	return &ProjBusinessContactDao{M: d.M.As(as)}
+	return &ProjBusinessContactDao{M: d.M.As(as), Table: d.Table, TableAs: as}
 }
 
 // TX sets the transaction for current operation.
 func (d *ProjBusinessContactDao) TX(tx *gdb.TX) *ProjBusinessContactDao {
-	return &ProjBusinessContactDao{M: d.M.TX(tx)}
+	return &ProjBusinessContactDao{M: d.M.TX(tx), Table: d.Table, TableAs: d.TableAs}
 }
 
 // Master marks the following operation on master node.
 func (d *ProjBusinessContactDao) Master() *ProjBusinessContactDao {
-	return &ProjBusinessContactDao{M: d.M.Master()}
+	return &ProjBusinessContactDao{M: d.M.Master(), Table: d.Table, TableAs: d.TableAs}
 }
 
 // Slave marks the following operation on slave node.
 // Note that it makes sense only if there's any slave node configured.
 func (d *ProjBusinessContactDao) Slave() *ProjBusinessContactDao {
-	return &ProjBusinessContactDao{M: d.M.Slave()}
+	return &ProjBusinessContactDao{M: d.M.Slave(), Table: d.Table, TableAs: d.TableAs}
 }
 
 // Args sets custom arguments for model operation.
 func (d *ProjBusinessContactDao) Args(args ...interface{}) *ProjBusinessContactDao {
-	return &ProjBusinessContactDao{M: d.M.Args(args...)}
+	return &ProjBusinessContactDao{M: d.M.Args(args...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // Handler calls each of "handlers" on current Model and returns a new Model.
 // ModelHandler is a function that handles given Model and returns a new Model that is custom modified.
 func (d *ProjBusinessContactDao) Handler(handlers ...gdb.ModelHandler) *ProjBusinessContactDao {
-	return &ProjBusinessContactDao{M: d.M.Handler(handlers...)}
+	return &ProjBusinessContactDao{M: d.M.Handler(handlers...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // LeftJoin does "LEFT JOIN ... ON ..." statement on the model.
@@ -137,7 +138,7 @@ func (d *ProjBusinessContactDao) Handler(handlers ...gdb.ModelHandler) *ProjBusi
 // Table("user").LeftJoin("user_detail", "user_detail.uid=user.uid")
 // Table("user", "u").LeftJoin("user_detail", "ud", "ud.uid=u.uid")
 func (d *ProjBusinessContactDao) LeftJoin(table ...string) *ProjBusinessContactDao {
-	return &ProjBusinessContactDao{M: d.M.LeftJoin(table...)}
+	return &ProjBusinessContactDao{M: d.M.LeftJoin(table...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // RightJoin does "RIGHT JOIN ... ON ..." statement on the model.
@@ -146,7 +147,7 @@ func (d *ProjBusinessContactDao) LeftJoin(table ...string) *ProjBusinessContactD
 // Table("user").RightJoin("user_detail", "user_detail.uid=user.uid")
 // Table("user", "u").RightJoin("user_detail", "ud", "ud.uid=u.uid")
 func (d *ProjBusinessContactDao) RightJoin(table ...string) *ProjBusinessContactDao {
-	return &ProjBusinessContactDao{M: d.M.RightJoin(table...)}
+	return &ProjBusinessContactDao{M: d.M.RightJoin(table...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // InnerJoin does "INNER JOIN ... ON ..." statement on the model.
@@ -155,93 +156,93 @@ func (d *ProjBusinessContactDao) RightJoin(table ...string) *ProjBusinessContact
 // Table("user").InnerJoin("user_detail", "user_detail.uid=user.uid")
 // Table("user", "u").InnerJoin("user_detail", "ud", "ud.uid=u.uid")
 func (d *ProjBusinessContactDao) InnerJoin(table ...string) *ProjBusinessContactDao {
-	return &ProjBusinessContactDao{M: d.M.InnerJoin(table...)}
+	return &ProjBusinessContactDao{M: d.M.InnerJoin(table...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // Fields sets the operation fields of the model, multiple fields joined using char ','.
 // The parameter <fieldNamesOrMapStruct> can be type of string/map/*map/struct/*struct.
 func (d *ProjBusinessContactDao) Fields(fieldNamesOrMapStruct ...interface{}) *ProjBusinessContactDao {
-	return &ProjBusinessContactDao{M: d.M.Fields(fieldNamesOrMapStruct...)}
+	return &ProjBusinessContactDao{M: d.M.Fields(fieldNamesOrMapStruct...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // FieldsEx sets the excluded operation fields of the model, multiple fields joined using char ','.
 // The parameter <fieldNamesOrMapStruct> can be type of string/map/*map/struct/*struct.
 func (d *ProjBusinessContactDao) FieldsEx(fieldNamesOrMapStruct ...interface{}) *ProjBusinessContactDao {
-	return &ProjBusinessContactDao{M: d.M.FieldsEx(fieldNamesOrMapStruct...)}
+	return &ProjBusinessContactDao{M: d.M.FieldsEx(fieldNamesOrMapStruct...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // FieldCount formats and appends commonly used field "COUNT(column)" to the select fields of model.
 func (d *ProjBusinessContactDao) FieldCount(column string, as ...string) *ProjBusinessContactDao {
-	return &ProjBusinessContactDao{M: d.M.FieldCount(column, as...)}
+	return &ProjBusinessContactDao{M: d.M.FieldCount(column, as...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // FieldSum formats and appends commonly used field "SUM(column)" to the select fields of model.
 func (d *ProjBusinessContactDao) FieldSum(column string, as ...string) *ProjBusinessContactDao {
-	return &ProjBusinessContactDao{M: d.M.FieldSum(column, as...)}
+	return &ProjBusinessContactDao{M: d.M.FieldSum(column, as...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // FieldMin formats and appends commonly used field "MIN(column)" to the select fields of model.
 func (d *ProjBusinessContactDao) FieldMin(column string, as ...string) *ProjBusinessContactDao {
-	return &ProjBusinessContactDao{M: d.M.FieldMin(column, as...)}
+	return &ProjBusinessContactDao{M: d.M.FieldMin(column, as...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // FieldMax formats and appends commonly used field "MAX(column)" to the select fields of model.
 func (d *ProjBusinessContactDao) FieldMax(column string, as ...string) *ProjBusinessContactDao {
-	return &ProjBusinessContactDao{M: d.M.FieldMax(column, as...)}
+	return &ProjBusinessContactDao{M: d.M.FieldMax(column, as...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // FieldAvg formats and appends commonly used field "AVG(column)" to the select fields of model.
 func (d *ProjBusinessContactDao) FieldAvg(column string, as ...string) *ProjBusinessContactDao {
-	return &ProjBusinessContactDao{M: d.M.FieldAvg(column, as...)}
+	return &ProjBusinessContactDao{M: d.M.FieldAvg(column, as...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // Option adds extra operation option for the model.
 // Deprecated, use separate operations instead.
 func (d *ProjBusinessContactDao) Option(option int) *ProjBusinessContactDao {
-	return &ProjBusinessContactDao{M: d.M.Option(option)}
+	return &ProjBusinessContactDao{M: d.M.Option(option), Table: d.Table, TableAs: d.TableAs}
 }
 
 // OmitEmpty sets OPTION_OMITEMPTY option for the model, which automatically filers
 // the data and where attributes for empty values.
 func (d *ProjBusinessContactDao) OmitEmpty() *ProjBusinessContactDao {
-	return &ProjBusinessContactDao{M: d.M.OmitEmpty()}
+	return &ProjBusinessContactDao{M: d.M.OmitEmpty(), Table: d.Table, TableAs: d.TableAs}
 }
 
 // OmitEmptyWhere sets optionOmitEmptyWhere option for the model, which automatically filers
 // the Where/Having parameters for "empty" values.
 func (d *ProjBusinessContactDao) OmitEmptyWhere() *ProjBusinessContactDao {
-	return &ProjBusinessContactDao{M: d.M.OmitEmptyWhere()}
+	return &ProjBusinessContactDao{M: d.M.OmitEmptyWhere(), Table: d.Table, TableAs: d.TableAs}
 }
 
 // OmitEmptyData sets optionOmitEmptyData option for the model, which automatically filers
 // the Data parameters for "empty" values.
 func (d *ProjBusinessContactDao) OmitEmptyData() *ProjBusinessContactDao {
-	return &ProjBusinessContactDao{M: d.M.OmitEmptyData()}
+	return &ProjBusinessContactDao{M: d.M.OmitEmptyData(), Table: d.Table, TableAs: d.TableAs}
 }
 
 // OmitNil sets optionOmitNil option for the model, which automatically filers
 // the data and where parameters for "nil" values.
 func (d *ProjBusinessContactDao) OmitNil() *ProjBusinessContactDao {
-	return &ProjBusinessContactDao{M: d.M.OmitNil()}
+	return &ProjBusinessContactDao{M: d.M.OmitNil(), Table: d.Table, TableAs: d.TableAs}
 }
 
 // OmitNilWhere sets optionOmitNilWhere option for the model, which automatically filers
 // the Where/Having parameters for "nil" values.
 func (d *ProjBusinessContactDao) OmitNilWhere() *ProjBusinessContactDao {
-	return &ProjBusinessContactDao{M: d.M.OmitNilWhere()}
+	return &ProjBusinessContactDao{M: d.M.OmitNilWhere(), Table: d.Table, TableAs: d.TableAs}
 }
 
 // OmitNilData sets optionOmitNilData option for the model, which automatically filers
 // the Data parameters for "nil" values.
 func (d *ProjBusinessContactDao) OmitNilData() *ProjBusinessContactDao {
-	return &ProjBusinessContactDao{M: d.M.OmitNilData()}
+	return &ProjBusinessContactDao{M: d.M.OmitNilData(), Table: d.Table, TableAs: d.TableAs}
 }
 
 // Filter marks filtering the fields which does not exist in the fields of the operated table.
 // Note that this function supports only single table operations.
 // Deprecated, filter feature is automatically enabled from GoFrame v1.16.0, it is so no longer used.
 func (d *ProjBusinessContactDao) Filter() *ProjBusinessContactDao {
-	return &ProjBusinessContactDao{M: d.M.Filter()}
+	return &ProjBusinessContactDao{M: d.M.Filter(), Table: d.Table, TableAs: d.TableAs}
 }
 
 // Where sets the condition statement for the model. The parameter <where> can be type of
@@ -256,7 +257,7 @@ func (d *ProjBusinessContactDao) Filter() *ProjBusinessContactDao {
 // Where("age IN(?,?)", 18, 50)
 // Where(User{ Id : 1, UserName : "john"})
 func (d *ProjBusinessContactDao) Where(where interface{}, args ...interface{}) *ProjBusinessContactDao {
-	return &ProjBusinessContactDao{M: d.M.Where(where, args...)}
+	return &ProjBusinessContactDao{M: d.M.Where(where, args...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WherePri does the same logic as M.Where except that if the parameter <where>
@@ -265,205 +266,205 @@ func (d *ProjBusinessContactDao) Where(where interface{}, args ...interface{}) *
 // WherePri function treats the condition as "id=123", but M.Where treats the condition
 // as string "123".
 func (d *ProjBusinessContactDao) WherePri(where interface{}, args ...interface{}) *ProjBusinessContactDao {
-	return &ProjBusinessContactDao{M: d.M.WherePri(where, args...)}
+	return &ProjBusinessContactDao{M: d.M.WherePri(where, args...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // Having sets the having statement for the model.
 // The parameters of this function usage are as the same as function Where.
 // See Where.
 func (d *ProjBusinessContactDao) Having(having interface{}, args ...interface{}) *ProjBusinessContactDao {
-	return &ProjBusinessContactDao{M: d.M.Having(having, args...)}
+	return &ProjBusinessContactDao{M: d.M.Having(having, args...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // Wheref builds condition string using fmt.Sprintf and arguments.
 // Note that if the number of "args" is more than the place holder in "format",
 // the extra "args" will be used as the where condition arguments of the Model.
 func (d *ProjBusinessContactDao) Wheref(format string, args ...interface{}) *ProjBusinessContactDao {
-	return &ProjBusinessContactDao{M: d.M.Wheref(format, args...)}
+	return &ProjBusinessContactDao{M: d.M.Wheref(format, args...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereLT builds "column < value" statement.
 func (d *ProjBusinessContactDao) WhereLT(column string, value interface{}) *ProjBusinessContactDao {
-	return &ProjBusinessContactDao{M: d.M.WhereLT(column, value)}
+	return &ProjBusinessContactDao{M: d.M.WhereLT(column, value), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereLTE builds "column <= value" statement.
 func (d *ProjBusinessContactDao) WhereLTE(column string, value interface{}) *ProjBusinessContactDao {
-	return &ProjBusinessContactDao{M: d.M.WhereLTE(column, value)}
+	return &ProjBusinessContactDao{M: d.M.WhereLTE(column, value), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereGT builds "column > value" statement.
 func (d *ProjBusinessContactDao) WhereGT(column string, value interface{}) *ProjBusinessContactDao {
-	return &ProjBusinessContactDao{M: d.M.WhereGT(column, value)}
+	return &ProjBusinessContactDao{M: d.M.WhereGT(column, value), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereGTE builds "column >= value" statement.
 func (d *ProjBusinessContactDao) WhereGTE(column string, value interface{}) *ProjBusinessContactDao {
-	return &ProjBusinessContactDao{M: d.M.WhereGTE(column, value)}
+	return &ProjBusinessContactDao{M: d.M.WhereGTE(column, value), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereBetween builds "column BETWEEN min AND max" statement.
 func (d *ProjBusinessContactDao) WhereBetween(column string, min, max interface{}) *ProjBusinessContactDao {
-	return &ProjBusinessContactDao{M: d.M.WhereBetween(column, min, max)}
+	return &ProjBusinessContactDao{M: d.M.WhereBetween(column, min, max), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereLike builds "column LIKE like" statement.
 func (d *ProjBusinessContactDao) WhereLike(column string, like interface{}) *ProjBusinessContactDao {
-	return &ProjBusinessContactDao{M: d.M.WhereLike(column, like)}
+	return &ProjBusinessContactDao{M: d.M.WhereLike(column, like), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereIn builds "column IN (in)" statement.
 func (d *ProjBusinessContactDao) WhereIn(column string, in interface{}) *ProjBusinessContactDao {
-	return &ProjBusinessContactDao{M: d.M.WhereIn(column, in)}
+	return &ProjBusinessContactDao{M: d.M.WhereIn(column, in), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereNull builds "columns[0] IS NULL AND columns[1] IS NULL ..." statement.
 func (d *ProjBusinessContactDao) WhereNull(columns ...string) *ProjBusinessContactDao {
-	return &ProjBusinessContactDao{M: d.M.WhereNull(columns...)}
+	return &ProjBusinessContactDao{M: d.M.WhereNull(columns...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereNotBetween builds "column NOT BETWEEN min AND max" statement.
 func (d *ProjBusinessContactDao) WhereNotBetween(column string, min, max interface{}) *ProjBusinessContactDao {
-	return &ProjBusinessContactDao{M: d.M.WhereNotBetween(column, min, max)}
+	return &ProjBusinessContactDao{M: d.M.WhereNotBetween(column, min, max), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereNotLike builds "column NOT LIKE like" statement.
 func (d *ProjBusinessContactDao) WhereNotLike(column string, like interface{}) *ProjBusinessContactDao {
-	return &ProjBusinessContactDao{M: d.M.WhereNotLike(column, like)}
+	return &ProjBusinessContactDao{M: d.M.WhereNotLike(column, like), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereNot builds "column != value" statement.
 func (d *ProjBusinessContactDao) WhereNot(column string, value interface{}) *ProjBusinessContactDao {
-	return &ProjBusinessContactDao{M: d.M.WhereNot(column, value)}
+	return &ProjBusinessContactDao{M: d.M.WhereNot(column, value), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereNotIn builds "column NOT IN (in)" statement.
 func (d *ProjBusinessContactDao) WhereNotIn(column string, in interface{}) *ProjBusinessContactDao {
-	return &ProjBusinessContactDao{M: d.M.WhereNotIn(column, in)}
+	return &ProjBusinessContactDao{M: d.M.WhereNotIn(column, in), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereNotNull builds "columns[0] IS NOT NULL AND columns[1] IS NOT NULL ..." statement.
 func (d *ProjBusinessContactDao) WhereNotNull(columns ...string) *ProjBusinessContactDao {
-	return &ProjBusinessContactDao{M: d.M.WhereNotNull(columns...)}
+	return &ProjBusinessContactDao{M: d.M.WhereNotNull(columns...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereOr adds "OR" condition to the where statement.
 func (d *ProjBusinessContactDao) WhereOr(where interface{}, args ...interface{}) *ProjBusinessContactDao {
-	return &ProjBusinessContactDao{M: d.M.WhereOr(where, args...)}
+	return &ProjBusinessContactDao{M: d.M.WhereOr(where, args...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereOrf builds "OR" condition string using fmt.Sprintf and arguments.
 func (d *ProjBusinessContactDao) WhereOrf(format string, args ...interface{}) *ProjBusinessContactDao {
-	return &ProjBusinessContactDao{M: d.M.WhereOrf(format, args...)}
+	return &ProjBusinessContactDao{M: d.M.WhereOrf(format, args...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereOrLT builds "column < value" statement in "OR" conditions..
 func (d *ProjBusinessContactDao) WhereOrLT(column string, value interface{}) *ProjBusinessContactDao {
-	return &ProjBusinessContactDao{M: d.M.WhereOrLT(column, value)}
+	return &ProjBusinessContactDao{M: d.M.WhereOrLT(column, value), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereOrLTE builds "column <= value" statement in "OR" conditions..
 func (d *ProjBusinessContactDao) WhereOrLTE(column string, value interface{}) *ProjBusinessContactDao {
-	return &ProjBusinessContactDao{M: d.M.WhereOrLTE(column, value)}
+	return &ProjBusinessContactDao{M: d.M.WhereOrLTE(column, value), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereOrGT builds "column > value" statement in "OR" conditions..
 func (d *ProjBusinessContactDao) WhereOrGT(column string, value interface{}) *ProjBusinessContactDao {
-	return &ProjBusinessContactDao{M: d.M.WhereOrGT(column, value)}
+	return &ProjBusinessContactDao{M: d.M.WhereOrGT(column, value), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereOrGTE builds "column >= value" statement in "OR" conditions..
 func (d *ProjBusinessContactDao) WhereOrGTE(column string, value interface{}) *ProjBusinessContactDao {
-	return &ProjBusinessContactDao{M: d.M.WhereOrGTE(column, value)}
+	return &ProjBusinessContactDao{M: d.M.WhereOrGTE(column, value), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereOrBetween builds "column BETWEEN min AND max" statement in "OR" conditions.
 func (d *ProjBusinessContactDao) WhereOrBetween(column string, min, max interface{}) *ProjBusinessContactDao {
-	return &ProjBusinessContactDao{M: d.M.WhereOrBetween(column, min, max)}
+	return &ProjBusinessContactDao{M: d.M.WhereOrBetween(column, min, max), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereOrLike builds "column LIKE like" statement in "OR" conditions.
 func (d *ProjBusinessContactDao) WhereOrLike(column string, like interface{}) *ProjBusinessContactDao {
-	return &ProjBusinessContactDao{M: d.M.WhereOrLike(column, like)}
+	return &ProjBusinessContactDao{M: d.M.WhereOrLike(column, like), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereOrIn builds "column IN (in)" statement in "OR" conditions.
 func (d *ProjBusinessContactDao) WhereOrIn(column string, in interface{}) *ProjBusinessContactDao {
-	return &ProjBusinessContactDao{M: d.M.WhereOrIn(column, in)}
+	return &ProjBusinessContactDao{M: d.M.WhereOrIn(column, in), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereOrNull builds "columns[0] IS NULL OR columns[1] IS NULL ..." statement in "OR" conditions.
 func (d *ProjBusinessContactDao) WhereOrNull(columns ...string) *ProjBusinessContactDao {
-	return &ProjBusinessContactDao{M: d.M.WhereOrNull(columns...)}
+	return &ProjBusinessContactDao{M: d.M.WhereOrNull(columns...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereOrNotBetween builds "column NOT BETWEEN min AND max" statement in "OR" conditions.
 func (d *ProjBusinessContactDao) WhereOrNotBetween(column string, min, max interface{}) *ProjBusinessContactDao {
-	return &ProjBusinessContactDao{M: d.M.WhereOrNotBetween(column, min, max)}
+	return &ProjBusinessContactDao{M: d.M.WhereOrNotBetween(column, min, max), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereOrNotLike builds "column NOT LIKE like" statement in "OR" conditions.
 func (d *ProjBusinessContactDao) WhereOrNotLike(column string, like interface{}) *ProjBusinessContactDao {
-	return &ProjBusinessContactDao{M: d.M.WhereOrNotLike(column, like)}
+	return &ProjBusinessContactDao{M: d.M.WhereOrNotLike(column, like), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereOrNotIn builds "column NOT IN (in)" statement.
 func (d *ProjBusinessContactDao) WhereOrNotIn(column string, in interface{}) *ProjBusinessContactDao {
-	return &ProjBusinessContactDao{M: d.M.WhereOrNotIn(column, in)}
+	return &ProjBusinessContactDao{M: d.M.WhereOrNotIn(column, in), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereOrNotNull builds "columns[0] IS NOT NULL OR columns[1] IS NOT NULL ..." statement in "OR" conditions.
 func (d *ProjBusinessContactDao) WhereOrNotNull(columns ...string) *ProjBusinessContactDao {
-	return &ProjBusinessContactDao{M: d.M.WhereOrNotNull(columns...)}
+	return &ProjBusinessContactDao{M: d.M.WhereOrNotNull(columns...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // Group sets the "GROUP BY" statement for the model.
 func (d *ProjBusinessContactDao) Group(groupBy ...string) *ProjBusinessContactDao {
-	return &ProjBusinessContactDao{M: d.M.Group(groupBy...)}
+	return &ProjBusinessContactDao{M: d.M.Group(groupBy...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // And adds "AND" condition to the where statement.
 // Deprecated, use Where instead.
 func (d *ProjBusinessContactDao) And(where interface{}, args ...interface{}) *ProjBusinessContactDao {
-	return &ProjBusinessContactDao{M: d.M.And(where, args...)}
+	return &ProjBusinessContactDao{M: d.M.And(where, args...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // Or adds "OR" condition to the where statement.
 // Deprecated, use WhereOr instead.
 func (d *ProjBusinessContactDao) Or(where interface{}, args ...interface{}) *ProjBusinessContactDao {
-	return &ProjBusinessContactDao{M: d.M.Or(where, args...)}
+	return &ProjBusinessContactDao{M: d.M.Or(where, args...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // GroupBy sets the "GROUP BY" statement for the model.
 func (d *ProjBusinessContactDao) GroupBy(groupBy string) *ProjBusinessContactDao {
-	return &ProjBusinessContactDao{M: d.M.Group(groupBy)}
+	return &ProjBusinessContactDao{M: d.M.Group(groupBy), Table: d.Table, TableAs: d.TableAs}
 }
 
 // Order sets the "ORDER BY" statement for the model.
 func (d *ProjBusinessContactDao) Order(orderBy ...string) *ProjBusinessContactDao {
-	return &ProjBusinessContactDao{M: d.M.Order(orderBy...)}
+	return &ProjBusinessContactDao{M: d.M.Order(orderBy...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // OrderAsc sets the "ORDER BY xxx ASC" statement for the model.
 func (d *ProjBusinessContactDao) OrderAsc(column string) *ProjBusinessContactDao {
-	return &ProjBusinessContactDao{M: d.M.OrderAsc(column)}
+	return &ProjBusinessContactDao{M: d.M.OrderAsc(column), Table: d.Table, TableAs: d.TableAs}
 }
 
 // OrderDesc sets the "ORDER BY xxx DESC" statement for the model.
 func (d *ProjBusinessContactDao) OrderDesc(column string) *ProjBusinessContactDao {
-	return &ProjBusinessContactDao{M: d.M.OrderDesc(column)}
+	return &ProjBusinessContactDao{M: d.M.OrderDesc(column), Table: d.Table, TableAs: d.TableAs}
 }
 
 // OrderRandom sets the "ORDER BY RANDOM()" statement for the model.
 func (d *ProjBusinessContactDao) OrderRandom() *ProjBusinessContactDao {
-	return &ProjBusinessContactDao{M: d.M.OrderRandom()}
+	return &ProjBusinessContactDao{M: d.M.OrderRandom(), Table: d.Table, TableAs: d.TableAs}
 }
 
 // OrderBy is alias of Model.Order.
 // See Model.Order.
 // Deprecated, use Order instead.
 func (d *ProjBusinessContactDao) OrderBy(orderBy string) *ProjBusinessContactDao {
-	return &ProjBusinessContactDao{M: d.M.Order(orderBy)}
+	return &ProjBusinessContactDao{M: d.M.Order(orderBy), Table: d.Table, TableAs: d.TableAs}
 }
 
 // Limit sets the "LIMIT" statement for the model.
@@ -471,30 +472,30 @@ func (d *ProjBusinessContactDao) OrderBy(orderBy string) *ProjBusinessContactDao
 // it then sets "LIMIT limit[0],limit[1]" statement for the model, or else it sets "LIMIT limit[0]"
 // statement.
 func (d *ProjBusinessContactDao) Limit(limit ...int) *ProjBusinessContactDao {
-	return &ProjBusinessContactDao{M: d.M.Limit(limit...)}
+	return &ProjBusinessContactDao{M: d.M.Limit(limit...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // Offset sets the "OFFSET" statement for the model.
 // It only makes sense for some databases like SQLServer, PostgreSQL, etc.
 func (d *ProjBusinessContactDao) Offset(offset int) *ProjBusinessContactDao {
-	return &ProjBusinessContactDao{M: d.M.Offset(offset)}
+	return &ProjBusinessContactDao{M: d.M.Offset(offset), Table: d.Table, TableAs: d.TableAs}
 }
 
 // Distinct forces the query to only return distinct results.
 func (d *ProjBusinessContactDao) Distinct() *ProjBusinessContactDao {
-	return &ProjBusinessContactDao{M: d.M.Distinct()}
+	return &ProjBusinessContactDao{M: d.M.Distinct(), Table: d.Table, TableAs: d.TableAs}
 }
 
 // Page sets the paging number for the model.
 // The parameter <page> is started from 1 for paging.
 // Note that, it differs that the Limit function start from 0 for "LIMIT" statement.
 func (d *ProjBusinessContactDao) Page(page, limit int) *ProjBusinessContactDao {
-	return &ProjBusinessContactDao{M: d.M.Page(page, limit)}
+	return &ProjBusinessContactDao{M: d.M.Page(page, limit), Table: d.Table, TableAs: d.TableAs}
 }
 
 // Batch sets the batch operation number for the model.
 func (d *ProjBusinessContactDao) Batch(batch int) *ProjBusinessContactDao {
-	return &ProjBusinessContactDao{M: d.M.Batch(batch)}
+	return &ProjBusinessContactDao{M: d.M.Batch(batch), Table: d.Table, TableAs: d.TableAs}
 }
 
 // Cache sets the cache feature for the model. It caches the result of the sql, which means
@@ -510,7 +511,7 @@ func (d *ProjBusinessContactDao) Batch(batch int) *ProjBusinessContactDao {
 //
 // Note that, the cache feature is disabled if the model is operating on a transaction.
 func (d *ProjBusinessContactDao) Cache(duration time.Duration, name ...string) *ProjBusinessContactDao {
-	return &ProjBusinessContactDao{M: d.M.Cache(duration, name...)}
+	return &ProjBusinessContactDao{M: d.M.Cache(duration, name...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // Data sets the operation data for the model.
@@ -521,7 +522,7 @@ func (d *ProjBusinessContactDao) Cache(duration time.Duration, name ...string) *
 // Data(g.Map{"uid": 10000, "name":"john"})
 // Data(g.Slice{g.Map{"uid": 10000, "name":"john"}, g.Map{"uid": 20000, "name":"smith"})
 func (d *ProjBusinessContactDao) Data(data ...interface{}) *ProjBusinessContactDao {
-	return &ProjBusinessContactDao{M: d.M.Data(data...)}
+	return &ProjBusinessContactDao{M: d.M.Data(data...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // All does "SELECT FROM ..." statement for the model.
@@ -666,17 +667,17 @@ func (d *ProjBusinessContactDao) Chunk(limit int, callback func(entities []*mode
 
 // LockUpdate sets the lock for update for current operation.
 func (d *ProjBusinessContactDao) LockUpdate() *ProjBusinessContactDao {
-	return &ProjBusinessContactDao{M: d.M.LockUpdate()}
+	return &ProjBusinessContactDao{M: d.M.LockUpdate(), Table: d.Table, TableAs: d.TableAs}
 }
 
 // LockShared sets the lock in share mode for current operation.
 func (d *ProjBusinessContactDao) LockShared() *ProjBusinessContactDao {
-	return &ProjBusinessContactDao{M: d.M.LockShared()}
+	return &ProjBusinessContactDao{M: d.M.LockShared(), Table: d.Table, TableAs: d.TableAs}
 }
 
 // Unscoped enables/disables the soft deleting feature.
 func (d *ProjBusinessContactDao) Unscoped() *ProjBusinessContactDao {
-	return &ProjBusinessContactDao{M: d.M.Unscoped()}
+	return &ProjBusinessContactDao{M: d.M.Unscoped(), Table: d.Table, TableAs: d.TableAs}
 }
 
 // DataScope enables the DataScope feature.
@@ -698,14 +699,18 @@ func (d *ProjBusinessContactDao) DataScope(ctx context.Context, userCol ...strin
 				dataScope["id"] = userIds
 			}
 		}
+		tableAs := d.TableAs
+		if d.TableAs != "" {
+			tableAs += "."
+		}
 		for k, v := range dataScope {
 			if ok, _ := d.M.HasField(k); ok {
-				columns = append(columns, k+" IN (?) ")
+				columns = append(columns, tableAs+k+" IN (?) ")
 				values = append(values, v)
 			}
 		}
 		whereSql := strings.Join(columns, " OR ")
-		return &ProjBusinessContactDao{M: d.M.Where(whereSql, values).Ctx(ctx)}
+		return &ProjBusinessContactDao{M: d.M.Where(whereSql, values).Ctx(ctx), Table: d.Table, TableAs: d.TableAs}
 	}
 	return d
 }

opms_parent/app/dao/proj/internal/proj_business_dynamics.go

@@ -19,10 +19,11 @@ import (
 
 // ProjBusinessDynamicsDao is the manager for logic model data accessing and custom defined data operations functions management.
 type ProjBusinessDynamicsDao struct {
-	gmvc.M                             // M is the core and embedded struct that inherits all chaining operations from gdb.Model.
-	C      projBusinessDynamicsColumns // C is the short type for Columns, which contains all the column names of Table for convenient usage.
-	DB     gdb.DB                      // DB is the raw underlying database management object.
-	Table  string                      // Table is the underlying table name of the DAO.
+	gmvc.M                              // M is the core and embedded struct that inherits all chaining operations from gdb.Model.
+	C       projBusinessDynamicsColumns // C is the short type for Columns, which contains all the column names of Table for convenient usage.
+	DB      gdb.DB                      // DB is the raw underlying database management object.
+	Table   string                      // Table is the underlying table name of the DAO.
+	TableAs string                      // TableAs is the underlying table alias name of the DAO.
 }
 
 // ProjBusinessDynamicsColumns defines and stores column names for table proj_business_dynamics.
@@ -102,7 +103,7 @@ func NewProjBusinessDynamicsDao(tenant string) ProjBusinessDynamicsDao {
 // Note that this returned DB object can be used only once, so do not assign it to
 // a global or package variable for long using.
 func (d *ProjBusinessDynamicsDao) Ctx(ctx context.Context) *ProjBusinessDynamicsDao {
-	return &ProjBusinessDynamicsDao{M: d.M.Ctx(ctx)}
+	return &ProjBusinessDynamicsDao{M: d.M.Ctx(ctx), Table: d.Table, TableAs: d.TableAs}
 }
 
 // GetCtx returns the context for current Model.
@@ -113,34 +114,34 @@ func (d *ProjBusinessDynamicsDao) GetCtx() context.Context {
 
 // As sets an alias name for current table.
 func (d *ProjBusinessDynamicsDao) As(as string) *ProjBusinessDynamicsDao {
-	return &ProjBusinessDynamicsDao{M: d.M.As(as)}
+	return &ProjBusinessDynamicsDao{M: d.M.As(as), Table: d.Table, TableAs: as}
 }
 
 // TX sets the transaction for current operation.
 func (d *ProjBusinessDynamicsDao) TX(tx *gdb.TX) *ProjBusinessDynamicsDao {
-	return &ProjBusinessDynamicsDao{M: d.M.TX(tx)}
+	return &ProjBusinessDynamicsDao{M: d.M.TX(tx), Table: d.Table, TableAs: d.TableAs}
 }
 
 // Master marks the following operation on master node.
 func (d *ProjBusinessDynamicsDao) Master() *ProjBusinessDynamicsDao {
-	return &ProjBusinessDynamicsDao{M: d.M.Master()}
+	return &ProjBusinessDynamicsDao{M: d.M.Master(), Table: d.Table, TableAs: d.TableAs}
 }
 
 // Slave marks the following operation on slave node.
 // Note that it makes sense only if there's any slave node configured.
 func (d *ProjBusinessDynamicsDao) Slave() *ProjBusinessDynamicsDao {
-	return &ProjBusinessDynamicsDao{M: d.M.Slave()}
+	return &ProjBusinessDynamicsDao{M: d.M.Slave(), Table: d.Table, TableAs: d.TableAs}
 }
 
 // Args sets custom arguments for model operation.
 func (d *ProjBusinessDynamicsDao) Args(args ...interface{}) *ProjBusinessDynamicsDao {
-	return &ProjBusinessDynamicsDao{M: d.M.Args(args...)}
+	return &ProjBusinessDynamicsDao{M: d.M.Args(args...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // Handler calls each of "handlers" on current Model and returns a new Model.
 // ModelHandler is a function that handles given Model and returns a new Model that is custom modified.
 func (d *ProjBusinessDynamicsDao) Handler(handlers ...gdb.ModelHandler) *ProjBusinessDynamicsDao {
-	return &ProjBusinessDynamicsDao{M: d.M.Handler(handlers...)}
+	return &ProjBusinessDynamicsDao{M: d.M.Handler(handlers...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // LeftJoin does "LEFT JOIN ... ON ..." statement on the model.
@@ -149,7 +150,7 @@ func (d *ProjBusinessDynamicsDao) Handler(handlers ...gdb.ModelHandler) *ProjBus
 // Table("user").LeftJoin("user_detail", "user_detail.uid=user.uid")
 // Table("user", "u").LeftJoin("user_detail", "ud", "ud.uid=u.uid")
 func (d *ProjBusinessDynamicsDao) LeftJoin(table ...string) *ProjBusinessDynamicsDao {
-	return &ProjBusinessDynamicsDao{M: d.M.LeftJoin(table...)}
+	return &ProjBusinessDynamicsDao{M: d.M.LeftJoin(table...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // RightJoin does "RIGHT JOIN ... ON ..." statement on the model.
@@ -158,7 +159,7 @@ func (d *ProjBusinessDynamicsDao) LeftJoin(table ...string) *ProjBusinessDynamic
 // Table("user").RightJoin("user_detail", "user_detail.uid=user.uid")
 // Table("user", "u").RightJoin("user_detail", "ud", "ud.uid=u.uid")
 func (d *ProjBusinessDynamicsDao) RightJoin(table ...string) *ProjBusinessDynamicsDao {
-	return &ProjBusinessDynamicsDao{M: d.M.RightJoin(table...)}
+	return &ProjBusinessDynamicsDao{M: d.M.RightJoin(table...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // InnerJoin does "INNER JOIN ... ON ..." statement on the model.
@@ -167,93 +168,93 @@ func (d *ProjBusinessDynamicsDao) RightJoin(table ...string) *ProjBusinessDynami
 // Table("user").InnerJoin("user_detail", "user_detail.uid=user.uid")
 // Table("user", "u").InnerJoin("user_detail", "ud", "ud.uid=u.uid")
 func (d *ProjBusinessDynamicsDao) InnerJoin(table ...string) *ProjBusinessDynamicsDao {
-	return &ProjBusinessDynamicsDao{M: d.M.InnerJoin(table...)}
+	return &ProjBusinessDynamicsDao{M: d.M.InnerJoin(table...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // Fields sets the operation fields of the model, multiple fields joined using char ','.
 // The parameter <fieldNamesOrMapStruct> can be type of string/map/*map/struct/*struct.
 func (d *ProjBusinessDynamicsDao) Fields(fieldNamesOrMapStruct ...interface{}) *ProjBusinessDynamicsDao {
-	return &ProjBusinessDynamicsDao{M: d.M.Fields(fieldNamesOrMapStruct...)}
+	return &ProjBusinessDynamicsDao{M: d.M.Fields(fieldNamesOrMapStruct...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // FieldsEx sets the excluded operation fields of the model, multiple fields joined using char ','.
 // The parameter <fieldNamesOrMapStruct> can be type of string/map/*map/struct/*struct.
 func (d *ProjBusinessDynamicsDao) FieldsEx(fieldNamesOrMapStruct ...interface{}) *ProjBusinessDynamicsDao {
-	return &ProjBusinessDynamicsDao{M: d.M.FieldsEx(fieldNamesOrMapStruct...)}
+	return &ProjBusinessDynamicsDao{M: d.M.FieldsEx(fieldNamesOrMapStruct...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // FieldCount formats and appends commonly used field "COUNT(column)" to the select fields of model.
 func (d *ProjBusinessDynamicsDao) FieldCount(column string, as ...string) *ProjBusinessDynamicsDao {
-	return &ProjBusinessDynamicsDao{M: d.M.FieldCount(column, as...)}
+	return &ProjBusinessDynamicsDao{M: d.M.FieldCount(column, as...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // FieldSum formats and appends commonly used field "SUM(column)" to the select fields of model.
 func (d *ProjBusinessDynamicsDao) FieldSum(column string, as ...string) *ProjBusinessDynamicsDao {
-	return &ProjBusinessDynamicsDao{M: d.M.FieldSum(column, as...)}
+	return &ProjBusinessDynamicsDao{M: d.M.FieldSum(column, as...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // FieldMin formats and appends commonly used field "MIN(column)" to the select fields of model.
 func (d *ProjBusinessDynamicsDao) FieldMin(column string, as ...string) *ProjBusinessDynamicsDao {
-	return &ProjBusinessDynamicsDao{M: d.M.FieldMin(column, as...)}
+	return &ProjBusinessDynamicsDao{M: d.M.FieldMin(column, as...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // FieldMax formats and appends commonly used field "MAX(column)" to the select fields of model.
 func (d *ProjBusinessDynamicsDao) FieldMax(column string, as ...string) *ProjBusinessDynamicsDao {
-	return &ProjBusinessDynamicsDao{M: d.M.FieldMax(column, as...)}
+	return &ProjBusinessDynamicsDao{M: d.M.FieldMax(column, as...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // FieldAvg formats and appends commonly used field "AVG(column)" to the select fields of model.
 func (d *ProjBusinessDynamicsDao) FieldAvg(column string, as ...string) *ProjBusinessDynamicsDao {
-	return &ProjBusinessDynamicsDao{M: d.M.FieldAvg(column, as...)}
+	return &ProjBusinessDynamicsDao{M: d.M.FieldAvg(column, as...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // Option adds extra operation option for the model.
 // Deprecated, use separate operations instead.
 func (d *ProjBusinessDynamicsDao) Option(option int) *ProjBusinessDynamicsDao {
-	return &ProjBusinessDynamicsDao{M: d.M.Option(option)}
+	return &ProjBusinessDynamicsDao{M: d.M.Option(option), Table: d.Table, TableAs: d.TableAs}
 }
 
 // OmitEmpty sets OPTION_OMITEMPTY option for the model, which automatically filers
 // the data and where attributes for empty values.
 func (d *ProjBusinessDynamicsDao) OmitEmpty() *ProjBusinessDynamicsDao {
-	return &ProjBusinessDynamicsDao{M: d.M.OmitEmpty()}
+	return &ProjBusinessDynamicsDao{M: d.M.OmitEmpty(), Table: d.Table, TableAs: d.TableAs}
 }
 
 // OmitEmptyWhere sets optionOmitEmptyWhere option for the model, which automatically filers
 // the Where/Having parameters for "empty" values.
 func (d *ProjBusinessDynamicsDao) OmitEmptyWhere() *ProjBusinessDynamicsDao {
-	return &ProjBusinessDynamicsDao{M: d.M.OmitEmptyWhere()}
+	return &ProjBusinessDynamicsDao{M: d.M.OmitEmptyWhere(), Table: d.Table, TableAs: d.TableAs}
 }
 
 // OmitEmptyData sets optionOmitEmptyData option for the model, which automatically filers
 // the Data parameters for "empty" values.
 func (d *ProjBusinessDynamicsDao) OmitEmptyData() *ProjBusinessDynamicsDao {
-	return &ProjBusinessDynamicsDao{M: d.M.OmitEmptyData()}
+	return &ProjBusinessDynamicsDao{M: d.M.OmitEmptyData(), Table: d.Table, TableAs: d.TableAs}
 }
 
 // OmitNil sets optionOmitNil option for the model, which automatically filers
 // the data and where parameters for "nil" values.
 func (d *ProjBusinessDynamicsDao) OmitNil() *ProjBusinessDynamicsDao {
-	return &ProjBusinessDynamicsDao{M: d.M.OmitNil()}
+	return &ProjBusinessDynamicsDao{M: d.M.OmitNil(), Table: d.Table, TableAs: d.TableAs}
 }
 
 // OmitNilWhere sets optionOmitNilWhere option for the model, which automatically filers
 // the Where/Having parameters for "nil" values.
 func (d *ProjBusinessDynamicsDao) OmitNilWhere() *ProjBusinessDynamicsDao {
-	return &ProjBusinessDynamicsDao{M: d.M.OmitNilWhere()}
+	return &ProjBusinessDynamicsDao{M: d.M.OmitNilWhere(), Table: d.Table, TableAs: d.TableAs}
 }
 
 // OmitNilData sets optionOmitNilData option for the model, which automatically filers
 // the Data parameters for "nil" values.
 func (d *ProjBusinessDynamicsDao) OmitNilData() *ProjBusinessDynamicsDao {
-	return &ProjBusinessDynamicsDao{M: d.M.OmitNilData()}
+	return &ProjBusinessDynamicsDao{M: d.M.OmitNilData(), Table: d.Table, TableAs: d.TableAs}
 }
 
 // Filter marks filtering the fields which does not exist in the fields of the operated table.
 // Note that this function supports only single table operations.
 // Deprecated, filter feature is automatically enabled from GoFrame v1.16.0, it is so no longer used.
 func (d *ProjBusinessDynamicsDao) Filter() *ProjBusinessDynamicsDao {
-	return &ProjBusinessDynamicsDao{M: d.M.Filter()}
+	return &ProjBusinessDynamicsDao{M: d.M.Filter(), Table: d.Table, TableAs: d.TableAs}
 }
 
 // Where sets the condition statement for the model. The parameter <where> can be type of
@@ -268,7 +269,7 @@ func (d *ProjBusinessDynamicsDao) Filter() *ProjBusinessDynamicsDao {
 // Where("age IN(?,?)", 18, 50)
 // Where(User{ Id : 1, UserName : "john"})
 func (d *ProjBusinessDynamicsDao) Where(where interface{}, args ...interface{}) *ProjBusinessDynamicsDao {
-	return &ProjBusinessDynamicsDao{M: d.M.Where(where, args...)}
+	return &ProjBusinessDynamicsDao{M: d.M.Where(where, args...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WherePri does the same logic as M.Where except that if the parameter <where>
@@ -277,205 +278,205 @@ func (d *ProjBusinessDynamicsDao) Where(where interface{}, args ...interface{})
 // WherePri function treats the condition as "id=123", but M.Where treats the condition
 // as string "123".
 func (d *ProjBusinessDynamicsDao) WherePri(where interface{}, args ...interface{}) *ProjBusinessDynamicsDao {
-	return &ProjBusinessDynamicsDao{M: d.M.WherePri(where, args...)}
+	return &ProjBusinessDynamicsDao{M: d.M.WherePri(where, args...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // Having sets the having statement for the model.
 // The parameters of this function usage are as the same as function Where.
 // See Where.
 func (d *ProjBusinessDynamicsDao) Having(having interface{}, args ...interface{}) *ProjBusinessDynamicsDao {
-	return &ProjBusinessDynamicsDao{M: d.M.Having(having, args...)}
+	return &ProjBusinessDynamicsDao{M: d.M.Having(having, args...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // Wheref builds condition string using fmt.Sprintf and arguments.
 // Note that if the number of "args" is more than the place holder in "format",
 // the extra "args" will be used as the where condition arguments of the Model.
 func (d *ProjBusinessDynamicsDao) Wheref(format string, args ...interface{}) *ProjBusinessDynamicsDao {
-	return &ProjBusinessDynamicsDao{M: d.M.Wheref(format, args...)}
+	return &ProjBusinessDynamicsDao{M: d.M.Wheref(format, args...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereLT builds "column < value" statement.
 func (d *ProjBusinessDynamicsDao) WhereLT(column string, value interface{}) *ProjBusinessDynamicsDao {
-	return &ProjBusinessDynamicsDao{M: d.M.WhereLT(column, value)}
+	return &ProjBusinessDynamicsDao{M: d.M.WhereLT(column, value), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereLTE builds "column <= value" statement.
 func (d *ProjBusinessDynamicsDao) WhereLTE(column string, value interface{}) *ProjBusinessDynamicsDao {
-	return &ProjBusinessDynamicsDao{M: d.M.WhereLTE(column, value)}
+	return &ProjBusinessDynamicsDao{M: d.M.WhereLTE(column, value), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereGT builds "column > value" statement.
 func (d *ProjBusinessDynamicsDao) WhereGT(column string, value interface{}) *ProjBusinessDynamicsDao {
-	return &ProjBusinessDynamicsDao{M: d.M.WhereGT(column, value)}
+	return &ProjBusinessDynamicsDao{M: d.M.WhereGT(column, value), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereGTE builds "column >= value" statement.
 func (d *ProjBusinessDynamicsDao) WhereGTE(column string, value interface{}) *ProjBusinessDynamicsDao {
-	return &ProjBusinessDynamicsDao{M: d.M.WhereGTE(column, value)}
+	return &ProjBusinessDynamicsDao{M: d.M.WhereGTE(column, value), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereBetween builds "column BETWEEN min AND max" statement.
 func (d *ProjBusinessDynamicsDao) WhereBetween(column string, min, max interface{}) *ProjBusinessDynamicsDao {
-	return &ProjBusinessDynamicsDao{M: d.M.WhereBetween(column, min, max)}
+	return &ProjBusinessDynamicsDao{M: d.M.WhereBetween(column, min, max), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereLike builds "column LIKE like" statement.
 func (d *ProjBusinessDynamicsDao) WhereLike(column string, like interface{}) *ProjBusinessDynamicsDao {
-	return &ProjBusinessDynamicsDao{M: d.M.WhereLike(column, like)}
+	return &ProjBusinessDynamicsDao{M: d.M.WhereLike(column, like), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereIn builds "column IN (in)" statement.
 func (d *ProjBusinessDynamicsDao) WhereIn(column string, in interface{}) *ProjBusinessDynamicsDao {
-	return &ProjBusinessDynamicsDao{M: d.M.WhereIn(column, in)}
+	return &ProjBusinessDynamicsDao{M: d.M.WhereIn(column, in), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereNull builds "columns[0] IS NULL AND columns[1] IS NULL ..." statement.
 func (d *ProjBusinessDynamicsDao) WhereNull(columns ...string) *ProjBusinessDynamicsDao {
-	return &ProjBusinessDynamicsDao{M: d.M.WhereNull(columns...)}
+	return &ProjBusinessDynamicsDao{M: d.M.WhereNull(columns...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereNotBetween builds "column NOT BETWEEN min AND max" statement.
 func (d *ProjBusinessDynamicsDao) WhereNotBetween(column string, min, max interface{}) *ProjBusinessDynamicsDao {
-	return &ProjBusinessDynamicsDao{M: d.M.WhereNotBetween(column, min, max)}
+	return &ProjBusinessDynamicsDao{M: d.M.WhereNotBetween(column, min, max), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereNotLike builds "column NOT LIKE like" statement.
 func (d *ProjBusinessDynamicsDao) WhereNotLike(column string, like interface{}) *ProjBusinessDynamicsDao {
-	return &ProjBusinessDynamicsDao{M: d.M.WhereNotLike(column, like)}
+	return &ProjBusinessDynamicsDao{M: d.M.WhereNotLike(column, like), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereNot builds "column != value" statement.
 func (d *ProjBusinessDynamicsDao) WhereNot(column string, value interface{}) *ProjBusinessDynamicsDao {
-	return &ProjBusinessDynamicsDao{M: d.M.WhereNot(column, value)}
+	return &ProjBusinessDynamicsDao{M: d.M.WhereNot(column, value), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereNotIn builds "column NOT IN (in)" statement.
 func (d *ProjBusinessDynamicsDao) WhereNotIn(column string, in interface{}) *ProjBusinessDynamicsDao {
-	return &ProjBusinessDynamicsDao{M: d.M.WhereNotIn(column, in)}
+	return &ProjBusinessDynamicsDao{M: d.M.WhereNotIn(column, in), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereNotNull builds "columns[0] IS NOT NULL AND columns[1] IS NOT NULL ..." statement.
 func (d *ProjBusinessDynamicsDao) WhereNotNull(columns ...string) *ProjBusinessDynamicsDao {
-	return &ProjBusinessDynamicsDao{M: d.M.WhereNotNull(columns...)}
+	return &ProjBusinessDynamicsDao{M: d.M.WhereNotNull(columns...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereOr adds "OR" condition to the where statement.
 func (d *ProjBusinessDynamicsDao) WhereOr(where interface{}, args ...interface{}) *ProjBusinessDynamicsDao {
-	return &ProjBusinessDynamicsDao{M: d.M.WhereOr(where, args...)}
+	return &ProjBusinessDynamicsDao{M: d.M.WhereOr(where, args...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereOrf builds "OR" condition string using fmt.Sprintf and arguments.
 func (d *ProjBusinessDynamicsDao) WhereOrf(format string, args ...interface{}) *ProjBusinessDynamicsDao {
-	return &ProjBusinessDynamicsDao{M: d.M.WhereOrf(format, args...)}
+	return &ProjBusinessDynamicsDao{M: d.M.WhereOrf(format, args...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereOrLT builds "column < value" statement in "OR" conditions..
 func (d *ProjBusinessDynamicsDao) WhereOrLT(column string, value interface{}) *ProjBusinessDynamicsDao {
-	return &ProjBusinessDynamicsDao{M: d.M.WhereOrLT(column, value)}
+	return &ProjBusinessDynamicsDao{M: d.M.WhereOrLT(column, value), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereOrLTE builds "column <= value" statement in "OR" conditions..
 func (d *ProjBusinessDynamicsDao) WhereOrLTE(column string, value interface{}) *ProjBusinessDynamicsDao {
-	return &ProjBusinessDynamicsDao{M: d.M.WhereOrLTE(column, value)}
+	return &ProjBusinessDynamicsDao{M: d.M.WhereOrLTE(column, value), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereOrGT builds "column > value" statement in "OR" conditions..
 func (d *ProjBusinessDynamicsDao) WhereOrGT(column string, value interface{}) *ProjBusinessDynamicsDao {
-	return &ProjBusinessDynamicsDao{M: d.M.WhereOrGT(column, value)}
+	return &ProjBusinessDynamicsDao{M: d.M.WhereOrGT(column, value), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereOrGTE builds "column >= value" statement in "OR" conditions..
 func (d *ProjBusinessDynamicsDao) WhereOrGTE(column string, value interface{}) *ProjBusinessDynamicsDao {
-	return &ProjBusinessDynamicsDao{M: d.M.WhereOrGTE(column, value)}
+	return &ProjBusinessDynamicsDao{M: d.M.WhereOrGTE(column, value), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereOrBetween builds "column BETWEEN min AND max" statement in "OR" conditions.
 func (d *ProjBusinessDynamicsDao) WhereOrBetween(column string, min, max interface{}) *ProjBusinessDynamicsDao {
-	return &ProjBusinessDynamicsDao{M: d.M.WhereOrBetween(column, min, max)}
+	return &ProjBusinessDynamicsDao{M: d.M.WhereOrBetween(column, min, max), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereOrLike builds "column LIKE like" statement in "OR" conditions.
 func (d *ProjBusinessDynamicsDao) WhereOrLike(column string, like interface{}) *ProjBusinessDynamicsDao {
-	return &ProjBusinessDynamicsDao{M: d.M.WhereOrLike(column, like)}
+	return &ProjBusinessDynamicsDao{M: d.M.WhereOrLike(column, like), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereOrIn builds "column IN (in)" statement in "OR" conditions.
 func (d *ProjBusinessDynamicsDao) WhereOrIn(column string, in interface{}) *ProjBusinessDynamicsDao {
-	return &ProjBusinessDynamicsDao{M: d.M.WhereOrIn(column, in)}
+	return &ProjBusinessDynamicsDao{M: d.M.WhereOrIn(column, in), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereOrNull builds "columns[0] IS NULL OR columns[1] IS NULL ..." statement in "OR" conditions.
 func (d *ProjBusinessDynamicsDao) WhereOrNull(columns ...string) *ProjBusinessDynamicsDao {
-	return &ProjBusinessDynamicsDao{M: d.M.WhereOrNull(columns...)}
+	return &ProjBusinessDynamicsDao{M: d.M.WhereOrNull(columns...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereOrNotBetween builds "column NOT BETWEEN min AND max" statement in "OR" conditions.
 func (d *ProjBusinessDynamicsDao) WhereOrNotBetween(column string, min, max interface{}) *ProjBusinessDynamicsDao {
-	return &ProjBusinessDynamicsDao{M: d.M.WhereOrNotBetween(column, min, max)}
+	return &ProjBusinessDynamicsDao{M: d.M.WhereOrNotBetween(column, min, max), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereOrNotLike builds "column NOT LIKE like" statement in "OR" conditions.
 func (d *ProjBusinessDynamicsDao) WhereOrNotLike(column string, like interface{}) *ProjBusinessDynamicsDao {
-	return &ProjBusinessDynamicsDao{M: d.M.WhereOrNotLike(column, like)}
+	return &ProjBusinessDynamicsDao{M: d.M.WhereOrNotLike(column, like), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereOrNotIn builds "column NOT IN (in)" statement.
 func (d *ProjBusinessDynamicsDao) WhereOrNotIn(column string, in interface{}) *ProjBusinessDynamicsDao {
-	return &ProjBusinessDynamicsDao{M: d.M.WhereOrNotIn(column, in)}
+	return &ProjBusinessDynamicsDao{M: d.M.WhereOrNotIn(column, in), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereOrNotNull builds "columns[0] IS NOT NULL OR columns[1] IS NOT NULL ..." statement in "OR" conditions.
 func (d *ProjBusinessDynamicsDao) WhereOrNotNull(columns ...string) *ProjBusinessDynamicsDao {
-	return &ProjBusinessDynamicsDao{M: d.M.WhereOrNotNull(columns...)}
+	return &ProjBusinessDynamicsDao{M: d.M.WhereOrNotNull(columns...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // Group sets the "GROUP BY" statement for the model.
 func (d *ProjBusinessDynamicsDao) Group(groupBy ...string) *ProjBusinessDynamicsDao {
-	return &ProjBusinessDynamicsDao{M: d.M.Group(groupBy...)}
+	return &ProjBusinessDynamicsDao{M: d.M.Group(groupBy...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // And adds "AND" condition to the where statement.
 // Deprecated, use Where instead.
 func (d *ProjBusinessDynamicsDao) And(where interface{}, args ...interface{}) *ProjBusinessDynamicsDao {
-	return &ProjBusinessDynamicsDao{M: d.M.And(where, args...)}
+	return &ProjBusinessDynamicsDao{M: d.M.And(where, args...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // Or adds "OR" condition to the where statement.
 // Deprecated, use WhereOr instead.
 func (d *ProjBusinessDynamicsDao) Or(where interface{}, args ...interface{}) *ProjBusinessDynamicsDao {
-	return &ProjBusinessDynamicsDao{M: d.M.Or(where, args...)}
+	return &ProjBusinessDynamicsDao{M: d.M.Or(where, args...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // GroupBy sets the "GROUP BY" statement for the model.
 func (d *ProjBusinessDynamicsDao) GroupBy(groupBy string) *ProjBusinessDynamicsDao {
-	return &ProjBusinessDynamicsDao{M: d.M.Group(groupBy)}
+	return &ProjBusinessDynamicsDao{M: d.M.Group(groupBy), Table: d.Table, TableAs: d.TableAs}
 }
 
 // Order sets the "ORDER BY" statement for the model.
 func (d *ProjBusinessDynamicsDao) Order(orderBy ...string) *ProjBusinessDynamicsDao {
-	return &ProjBusinessDynamicsDao{M: d.M.Order(orderBy...)}
+	return &ProjBusinessDynamicsDao{M: d.M.Order(orderBy...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // OrderAsc sets the "ORDER BY xxx ASC" statement for the model.
 func (d *ProjBusinessDynamicsDao) OrderAsc(column string) *ProjBusinessDynamicsDao {
-	return &ProjBusinessDynamicsDao{M: d.M.OrderAsc(column)}
+	return &ProjBusinessDynamicsDao{M: d.M.OrderAsc(column), Table: d.Table, TableAs: d.TableAs}
 }
 
 // OrderDesc sets the "ORDER BY xxx DESC" statement for the model.
 func (d *ProjBusinessDynamicsDao) OrderDesc(column string) *ProjBusinessDynamicsDao {
-	return &ProjBusinessDynamicsDao{M: d.M.OrderDesc(column)}
+	return &ProjBusinessDynamicsDao{M: d.M.OrderDesc(column), Table: d.Table, TableAs: d.TableAs}
 }
 
 // OrderRandom sets the "ORDER BY RANDOM()" statement for the model.
 func (d *ProjBusinessDynamicsDao) OrderRandom() *ProjBusinessDynamicsDao {
-	return &ProjBusinessDynamicsDao{M: d.M.OrderRandom()}
+	return &ProjBusinessDynamicsDao{M: d.M.OrderRandom(), Table: d.Table, TableAs: d.TableAs}
 }
 
 // OrderBy is alias of Model.Order.
 // See Model.Order.
 // Deprecated, use Order instead.
 func (d *ProjBusinessDynamicsDao) OrderBy(orderBy string) *ProjBusinessDynamicsDao {
-	return &ProjBusinessDynamicsDao{M: d.M.Order(orderBy)}
+	return &ProjBusinessDynamicsDao{M: d.M.Order(orderBy), Table: d.Table, TableAs: d.TableAs}
 }
 
 // Limit sets the "LIMIT" statement for the model.
@@ -483,30 +484,30 @@ func (d *ProjBusinessDynamicsDao) OrderBy(orderBy string) *ProjBusinessDynamicsD
 // it then sets "LIMIT limit[0],limit[1]" statement for the model, or else it sets "LIMIT limit[0]"
 // statement.
 func (d *ProjBusinessDynamicsDao) Limit(limit ...int) *ProjBusinessDynamicsDao {
-	return &ProjBusinessDynamicsDao{M: d.M.Limit(limit...)}
+	return &ProjBusinessDynamicsDao{M: d.M.Limit(limit...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // Offset sets the "OFFSET" statement for the model.
 // It only makes sense for some databases like SQLServer, PostgreSQL, etc.
 func (d *ProjBusinessDynamicsDao) Offset(offset int) *ProjBusinessDynamicsDao {
-	return &ProjBusinessDynamicsDao{M: d.M.Offset(offset)}
+	return &ProjBusinessDynamicsDao{M: d.M.Offset(offset), Table: d.Table, TableAs: d.TableAs}
 }
 
 // Distinct forces the query to only return distinct results.
 func (d *ProjBusinessDynamicsDao) Distinct() *ProjBusinessDynamicsDao {
-	return &ProjBusinessDynamicsDao{M: d.M.Distinct()}
+	return &ProjBusinessDynamicsDao{M: d.M.Distinct(), Table: d.Table, TableAs: d.TableAs}
 }
 
 // Page sets the paging number for the model.
 // The parameter <page> is started from 1 for paging.
 // Note that, it differs that the Limit function start from 0 for "LIMIT" statement.
 func (d *ProjBusinessDynamicsDao) Page(page, limit int) *ProjBusinessDynamicsDao {
-	return &ProjBusinessDynamicsDao{M: d.M.Page(page, limit)}
+	return &ProjBusinessDynamicsDao{M: d.M.Page(page, limit), Table: d.Table, TableAs: d.TableAs}
 }
 
 // Batch sets the batch operation number for the model.
 func (d *ProjBusinessDynamicsDao) Batch(batch int) *ProjBusinessDynamicsDao {
-	return &ProjBusinessDynamicsDao{M: d.M.Batch(batch)}
+	return &ProjBusinessDynamicsDao{M: d.M.Batch(batch), Table: d.Table, TableAs: d.TableAs}
 }
 
 // Cache sets the cache feature for the model. It caches the result of the sql, which means
@@ -522,7 +523,7 @@ func (d *ProjBusinessDynamicsDao) Batch(batch int) *ProjBusinessDynamicsDao {
 //
 // Note that, the cache feature is disabled if the model is operating on a transaction.
 func (d *ProjBusinessDynamicsDao) Cache(duration time.Duration, name ...string) *ProjBusinessDynamicsDao {
-	return &ProjBusinessDynamicsDao{M: d.M.Cache(duration, name...)}
+	return &ProjBusinessDynamicsDao{M: d.M.Cache(duration, name...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // Data sets the operation data for the model.
@@ -533,7 +534,7 @@ func (d *ProjBusinessDynamicsDao) Cache(duration time.Duration, name ...string)
 // Data(g.Map{"uid": 10000, "name":"john"})
 // Data(g.Slice{g.Map{"uid": 10000, "name":"john"}, g.Map{"uid": 20000, "name":"smith"})
 func (d *ProjBusinessDynamicsDao) Data(data ...interface{}) *ProjBusinessDynamicsDao {
-	return &ProjBusinessDynamicsDao{M: d.M.Data(data...)}
+	return &ProjBusinessDynamicsDao{M: d.M.Data(data...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // All does "SELECT FROM ..." statement for the model.
@@ -678,17 +679,17 @@ func (d *ProjBusinessDynamicsDao) Chunk(limit int, callback func(entities []*mod
 
 // LockUpdate sets the lock for update for current operation.
 func (d *ProjBusinessDynamicsDao) LockUpdate() *ProjBusinessDynamicsDao {
-	return &ProjBusinessDynamicsDao{M: d.M.LockUpdate()}
+	return &ProjBusinessDynamicsDao{M: d.M.LockUpdate(), Table: d.Table, TableAs: d.TableAs}
 }
 
 // LockShared sets the lock in share mode for current operation.
 func (d *ProjBusinessDynamicsDao) LockShared() *ProjBusinessDynamicsDao {
-	return &ProjBusinessDynamicsDao{M: d.M.LockShared()}
+	return &ProjBusinessDynamicsDao{M: d.M.LockShared(), Table: d.Table, TableAs: d.TableAs}
 }
 
 // Unscoped enables/disables the soft deleting feature.
 func (d *ProjBusinessDynamicsDao) Unscoped() *ProjBusinessDynamicsDao {
-	return &ProjBusinessDynamicsDao{M: d.M.Unscoped()}
+	return &ProjBusinessDynamicsDao{M: d.M.Unscoped(), Table: d.Table, TableAs: d.TableAs}
 }
 
 // DataScope enables the DataScope feature.
@@ -710,14 +711,18 @@ func (d *ProjBusinessDynamicsDao) DataScope(ctx context.Context, userCol ...stri
 				dataScope["id"] = userIds
 			}
 		}
+		tableAs := d.TableAs
+		if d.TableAs != "" {
+			tableAs += "."
+		}
 		for k, v := range dataScope {
 			if ok, _ := d.M.HasField(k); ok {
-				columns = append(columns, k+" IN (?) ")
+				columns = append(columns, tableAs+k+" IN (?) ")
 				values = append(values, v)
 			}
 		}
 		whereSql := strings.Join(columns, " OR ")
-		return &ProjBusinessDynamicsDao{M: d.M.Where(whereSql, values).Ctx(ctx)}
+		return &ProjBusinessDynamicsDao{M: d.M.Where(whereSql, values).Ctx(ctx), Table: d.Table, TableAs: d.TableAs}
 	}
 	return d
 }

opms_parent/app/dao/proj/internal/proj_business_file.go

@@ -19,10 +19,11 @@ import (
 
 // ProjBusinessFileDao is the manager for logic model data accessing and custom defined data operations functions management.
 type ProjBusinessFileDao struct {
-	gmvc.M                         // M is the core and embedded struct that inherits all chaining operations from gdb.Model.
-	C      projBusinessFileColumns // C is the short type for Columns, which contains all the column names of Table for convenient usage.
-	DB     gdb.DB                  // DB is the raw underlying database management object.
-	Table  string                  // Table is the underlying table name of the DAO.
+	gmvc.M                          // M is the core and embedded struct that inherits all chaining operations from gdb.Model.
+	C       projBusinessFileColumns // C is the short type for Columns, which contains all the column names of Table for convenient usage.
+	DB      gdb.DB                  // DB is the raw underlying database management object.
+	Table   string                  // Table is the underlying table name of the DAO.
+	TableAs string                  // TableAs is the underlying table alias name of the DAO.
 }
 
 // ProjBusinessFileColumns defines and stores column names for table proj_business_file.
@@ -99,7 +100,7 @@ func NewProjBusinessFileDao(tenant string) ProjBusinessFileDao {
 // Note that this returned DB object can be used only once, so do not assign it to
 // a global or package variable for long using.
 func (d *ProjBusinessFileDao) Ctx(ctx context.Context) *ProjBusinessFileDao {
-	return &ProjBusinessFileDao{M: d.M.Ctx(ctx)}
+	return &ProjBusinessFileDao{M: d.M.Ctx(ctx), Table: d.Table, TableAs: d.TableAs}
 }
 
 // GetCtx returns the context for current Model.
@@ -110,34 +111,34 @@ func (d *ProjBusinessFileDao) GetCtx() context.Context {
 
 // As sets an alias name for current table.
 func (d *ProjBusinessFileDao) As(as string) *ProjBusinessFileDao {
-	return &ProjBusinessFileDao{M: d.M.As(as)}
+	return &ProjBusinessFileDao{M: d.M.As(as), Table: d.Table, TableAs: as}
 }
 
 // TX sets the transaction for current operation.
 func (d *ProjBusinessFileDao) TX(tx *gdb.TX) *ProjBusinessFileDao {
-	return &ProjBusinessFileDao{M: d.M.TX(tx)}
+	return &ProjBusinessFileDao{M: d.M.TX(tx), Table: d.Table, TableAs: d.TableAs}
 }
 
 // Master marks the following operation on master node.
 func (d *ProjBusinessFileDao) Master() *ProjBusinessFileDao {
-	return &ProjBusinessFileDao{M: d.M.Master()}
+	return &ProjBusinessFileDao{M: d.M.Master(), Table: d.Table, TableAs: d.TableAs}
 }
 
 // Slave marks the following operation on slave node.
 // Note that it makes sense only if there's any slave node configured.
 func (d *ProjBusinessFileDao) Slave() *ProjBusinessFileDao {
-	return &ProjBusinessFileDao{M: d.M.Slave()}
+	return &ProjBusinessFileDao{M: d.M.Slave(), Table: d.Table, TableAs: d.TableAs}
 }
 
 // Args sets custom arguments for model operation.
 func (d *ProjBusinessFileDao) Args(args ...interface{}) *ProjBusinessFileDao {
-	return &ProjBusinessFileDao{M: d.M.Args(args...)}
+	return &ProjBusinessFileDao{M: d.M.Args(args...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // Handler calls each of "handlers" on current Model and returns a new Model.
 // ModelHandler is a function that handles given Model and returns a new Model that is custom modified.
 func (d *ProjBusinessFileDao) Handler(handlers ...gdb.ModelHandler) *ProjBusinessFileDao {
-	return &ProjBusinessFileDao{M: d.M.Handler(handlers...)}
+	return &ProjBusinessFileDao{M: d.M.Handler(handlers...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // LeftJoin does "LEFT JOIN ... ON ..." statement on the model.
@@ -146,7 +147,7 @@ func (d *ProjBusinessFileDao) Handler(handlers ...gdb.ModelHandler) *ProjBusines
 // Table("user").LeftJoin("user_detail", "user_detail.uid=user.uid")
 // Table("user", "u").LeftJoin("user_detail", "ud", "ud.uid=u.uid")
 func (d *ProjBusinessFileDao) LeftJoin(table ...string) *ProjBusinessFileDao {
-	return &ProjBusinessFileDao{M: d.M.LeftJoin(table...)}
+	return &ProjBusinessFileDao{M: d.M.LeftJoin(table...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // RightJoin does "RIGHT JOIN ... ON ..." statement on the model.
@@ -155,7 +156,7 @@ func (d *ProjBusinessFileDao) LeftJoin(table ...string) *ProjBusinessFileDao {
 // Table("user").RightJoin("user_detail", "user_detail.uid=user.uid")
 // Table("user", "u").RightJoin("user_detail", "ud", "ud.uid=u.uid")
 func (d *ProjBusinessFileDao) RightJoin(table ...string) *ProjBusinessFileDao {
-	return &ProjBusinessFileDao{M: d.M.RightJoin(table...)}
+	return &ProjBusinessFileDao{M: d.M.RightJoin(table...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // InnerJoin does "INNER JOIN ... ON ..." statement on the model.
@@ -164,93 +165,93 @@ func (d *ProjBusinessFileDao) RightJoin(table ...string) *ProjBusinessFileDao {
 // Table("user").InnerJoin("user_detail", "user_detail.uid=user.uid")
 // Table("user", "u").InnerJoin("user_detail", "ud", "ud.uid=u.uid")
 func (d *ProjBusinessFileDao) InnerJoin(table ...string) *ProjBusinessFileDao {
-	return &ProjBusinessFileDao{M: d.M.InnerJoin(table...)}
+	return &ProjBusinessFileDao{M: d.M.InnerJoin(table...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // Fields sets the operation fields of the model, multiple fields joined using char ','.
 // The parameter <fieldNamesOrMapStruct> can be type of string/map/*map/struct/*struct.
 func (d *ProjBusinessFileDao) Fields(fieldNamesOrMapStruct ...interface{}) *ProjBusinessFileDao {
-	return &ProjBusinessFileDao{M: d.M.Fields(fieldNamesOrMapStruct...)}
+	return &ProjBusinessFileDao{M: d.M.Fields(fieldNamesOrMapStruct...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // FieldsEx sets the excluded operation fields of the model, multiple fields joined using char ','.
 // The parameter <fieldNamesOrMapStruct> can be type of string/map/*map/struct/*struct.
 func (d *ProjBusinessFileDao) FieldsEx(fieldNamesOrMapStruct ...interface{}) *ProjBusinessFileDao {
-	return &ProjBusinessFileDao{M: d.M.FieldsEx(fieldNamesOrMapStruct...)}
+	return &ProjBusinessFileDao{M: d.M.FieldsEx(fieldNamesOrMapStruct...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // FieldCount formats and appends commonly used field "COUNT(column)" to the select fields of model.
 func (d *ProjBusinessFileDao) FieldCount(column string, as ...string) *ProjBusinessFileDao {
-	return &ProjBusinessFileDao{M: d.M.FieldCount(column, as...)}
+	return &ProjBusinessFileDao{M: d.M.FieldCount(column, as...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // FieldSum formats and appends commonly used field "SUM(column)" to the select fields of model.
 func (d *ProjBusinessFileDao) FieldSum(column string, as ...string) *ProjBusinessFileDao {
-	return &ProjBusinessFileDao{M: d.M.FieldSum(column, as...)}
+	return &ProjBusinessFileDao{M: d.M.FieldSum(column, as...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // FieldMin formats and appends commonly used field "MIN(column)" to the select fields of model.
 func (d *ProjBusinessFileDao) FieldMin(column string, as ...string) *ProjBusinessFileDao {
-	return &ProjBusinessFileDao{M: d.M.FieldMin(column, as...)}
+	return &ProjBusinessFileDao{M: d.M.FieldMin(column, as...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // FieldMax formats and appends commonly used field "MAX(column)" to the select fields of model.
 func (d *ProjBusinessFileDao) FieldMax(column string, as ...string) *ProjBusinessFileDao {
-	return &ProjBusinessFileDao{M: d.M.FieldMax(column, as...)}
+	return &ProjBusinessFileDao{M: d.M.FieldMax(column, as...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // FieldAvg formats and appends commonly used field "AVG(column)" to the select fields of model.
 func (d *ProjBusinessFileDao) FieldAvg(column string, as ...string) *ProjBusinessFileDao {
-	return &ProjBusinessFileDao{M: d.M.FieldAvg(column, as...)}
+	return &ProjBusinessFileDao{M: d.M.FieldAvg(column, as...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // Option adds extra operation option for the model.
 // Deprecated, use separate operations instead.
 func (d *ProjBusinessFileDao) Option(option int) *ProjBusinessFileDao {
-	return &ProjBusinessFileDao{M: d.M.Option(option)}
+	return &ProjBusinessFileDao{M: d.M.Option(option), Table: d.Table, TableAs: d.TableAs}
 }
 
 // OmitEmpty sets OPTION_OMITEMPTY option for the model, which automatically filers
 // the data and where attributes for empty values.
 func (d *ProjBusinessFileDao) OmitEmpty() *ProjBusinessFileDao {
-	return &ProjBusinessFileDao{M: d.M.OmitEmpty()}
+	return &ProjBusinessFileDao{M: d.M.OmitEmpty(), Table: d.Table, TableAs: d.TableAs}
 }
 
 // OmitEmptyWhere sets optionOmitEmptyWhere option for the model, which automatically filers
 // the Where/Having parameters for "empty" values.
 func (d *ProjBusinessFileDao) OmitEmptyWhere() *ProjBusinessFileDao {
-	return &ProjBusinessFileDao{M: d.M.OmitEmptyWhere()}
+	return &ProjBusinessFileDao{M: d.M.OmitEmptyWhere(), Table: d.Table, TableAs: d.TableAs}
 }
 
 // OmitEmptyData sets optionOmitEmptyData option for the model, which automatically filers
 // the Data parameters for "empty" values.
 func (d *ProjBusinessFileDao) OmitEmptyData() *ProjBusinessFileDao {
-	return &ProjBusinessFileDao{M: d.M.OmitEmptyData()}
+	return &ProjBusinessFileDao{M: d.M.OmitEmptyData(), Table: d.Table, TableAs: d.TableAs}
 }
 
 // OmitNil sets optionOmitNil option for the model, which automatically filers
 // the data and where parameters for "nil" values.
 func (d *ProjBusinessFileDao) OmitNil() *ProjBusinessFileDao {
-	return &ProjBusinessFileDao{M: d.M.OmitNil()}
+	return &ProjBusinessFileDao{M: d.M.OmitNil(), Table: d.Table, TableAs: d.TableAs}
 }
 
 // OmitNilWhere sets optionOmitNilWhere option for the model, which automatically filers
 // the Where/Having parameters for "nil" values.
 func (d *ProjBusinessFileDao) OmitNilWhere() *ProjBusinessFileDao {
-	return &ProjBusinessFileDao{M: d.M.OmitNilWhere()}
+	return &ProjBusinessFileDao{M: d.M.OmitNilWhere(), Table: d.Table, TableAs: d.TableAs}
 }
 
 // OmitNilData sets optionOmitNilData option for the model, which automatically filers
 // the Data parameters for "nil" values.
 func (d *ProjBusinessFileDao) OmitNilData() *ProjBusinessFileDao {
-	return &ProjBusinessFileDao{M: d.M.OmitNilData()}
+	return &ProjBusinessFileDao{M: d.M.OmitNilData(), Table: d.Table, TableAs: d.TableAs}
 }
 
 // Filter marks filtering the fields which does not exist in the fields of the operated table.
 // Note that this function supports only single table operations.
 // Deprecated, filter feature is automatically enabled from GoFrame v1.16.0, it is so no longer used.
 func (d *ProjBusinessFileDao) Filter() *ProjBusinessFileDao {
-	return &ProjBusinessFileDao{M: d.M.Filter()}
+	return &ProjBusinessFileDao{M: d.M.Filter(), Table: d.Table, TableAs: d.TableAs}
 }
 
 // Where sets the condition statement for the model. The parameter <where> can be type of
@@ -265,7 +266,7 @@ func (d *ProjBusinessFileDao) Filter() *ProjBusinessFileDao {
 // Where("age IN(?,?)", 18, 50)
 // Where(User{ Id : 1, UserName : "john"})
 func (d *ProjBusinessFileDao) Where(where interface{}, args ...interface{}) *ProjBusinessFileDao {
-	return &ProjBusinessFileDao{M: d.M.Where(where, args...)}
+	return &ProjBusinessFileDao{M: d.M.Where(where, args...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WherePri does the same logic as M.Where except that if the parameter <where>
@@ -274,205 +275,205 @@ func (d *ProjBusinessFileDao) Where(where interface{}, args ...interface{}) *Pro
 // WherePri function treats the condition as "id=123", but M.Where treats the condition
 // as string "123".
 func (d *ProjBusinessFileDao) WherePri(where interface{}, args ...interface{}) *ProjBusinessFileDao {
-	return &ProjBusinessFileDao{M: d.M.WherePri(where, args...)}
+	return &ProjBusinessFileDao{M: d.M.WherePri(where, args...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // Having sets the having statement for the model.
 // The parameters of this function usage are as the same as function Where.
 // See Where.
 func (d *ProjBusinessFileDao) Having(having interface{}, args ...interface{}) *ProjBusinessFileDao {
-	return &ProjBusinessFileDao{M: d.M.Having(having, args...)}
+	return &ProjBusinessFileDao{M: d.M.Having(having, args...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // Wheref builds condition string using fmt.Sprintf and arguments.
 // Note that if the number of "args" is more than the place holder in "format",
 // the extra "args" will be used as the where condition arguments of the Model.
 func (d *ProjBusinessFileDao) Wheref(format string, args ...interface{}) *ProjBusinessFileDao {
-	return &ProjBusinessFileDao{M: d.M.Wheref(format, args...)}
+	return &ProjBusinessFileDao{M: d.M.Wheref(format, args...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereLT builds "column < value" statement.
 func (d *ProjBusinessFileDao) WhereLT(column string, value interface{}) *ProjBusinessFileDao {
-	return &ProjBusinessFileDao{M: d.M.WhereLT(column, value)}
+	return &ProjBusinessFileDao{M: d.M.WhereLT(column, value), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereLTE builds "column <= value" statement.
 func (d *ProjBusinessFileDao) WhereLTE(column string, value interface{}) *ProjBusinessFileDao {
-	return &ProjBusinessFileDao{M: d.M.WhereLTE(column, value)}
+	return &ProjBusinessFileDao{M: d.M.WhereLTE(column, value), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereGT builds "column > value" statement.
 func (d *ProjBusinessFileDao) WhereGT(column string, value interface{}) *ProjBusinessFileDao {
-	return &ProjBusinessFileDao{M: d.M.WhereGT(column, value)}
+	return &ProjBusinessFileDao{M: d.M.WhereGT(column, value), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereGTE builds "column >= value" statement.
 func (d *ProjBusinessFileDao) WhereGTE(column string, value interface{}) *ProjBusinessFileDao {
-	return &ProjBusinessFileDao{M: d.M.WhereGTE(column, value)}
+	return &ProjBusinessFileDao{M: d.M.WhereGTE(column, value), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereBetween builds "column BETWEEN min AND max" statement.
 func (d *ProjBusinessFileDao) WhereBetween(column string, min, max interface{}) *ProjBusinessFileDao {
-	return &ProjBusinessFileDao{M: d.M.WhereBetween(column, min, max)}
+	return &ProjBusinessFileDao{M: d.M.WhereBetween(column, min, max), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereLike builds "column LIKE like" statement.
 func (d *ProjBusinessFileDao) WhereLike(column string, like interface{}) *ProjBusinessFileDao {
-	return &ProjBusinessFileDao{M: d.M.WhereLike(column, like)}
+	return &ProjBusinessFileDao{M: d.M.WhereLike(column, like), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereIn builds "column IN (in)" statement.
 func (d *ProjBusinessFileDao) WhereIn(column string, in interface{}) *ProjBusinessFileDao {
-	return &ProjBusinessFileDao{M: d.M.WhereIn(column, in)}
+	return &ProjBusinessFileDao{M: d.M.WhereIn(column, in), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereNull builds "columns[0] IS NULL AND columns[1] IS NULL ..." statement.
 func (d *ProjBusinessFileDao) WhereNull(columns ...string) *ProjBusinessFileDao {
-	return &ProjBusinessFileDao{M: d.M.WhereNull(columns...)}
+	return &ProjBusinessFileDao{M: d.M.WhereNull(columns...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereNotBetween builds "column NOT BETWEEN min AND max" statement.
 func (d *ProjBusinessFileDao) WhereNotBetween(column string, min, max interface{}) *ProjBusinessFileDao {
-	return &ProjBusinessFileDao{M: d.M.WhereNotBetween(column, min, max)}
+	return &ProjBusinessFileDao{M: d.M.WhereNotBetween(column, min, max), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereNotLike builds "column NOT LIKE like" statement.
 func (d *ProjBusinessFileDao) WhereNotLike(column string, like interface{}) *ProjBusinessFileDao {
-	return &ProjBusinessFileDao{M: d.M.WhereNotLike(column, like)}
+	return &ProjBusinessFileDao{M: d.M.WhereNotLike(column, like), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereNot builds "column != value" statement.
 func (d *ProjBusinessFileDao) WhereNot(column string, value interface{}) *ProjBusinessFileDao {
-	return &ProjBusinessFileDao{M: d.M.WhereNot(column, value)}
+	return &ProjBusinessFileDao{M: d.M.WhereNot(column, value), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereNotIn builds "column NOT IN (in)" statement.
 func (d *ProjBusinessFileDao) WhereNotIn(column string, in interface{}) *ProjBusinessFileDao {
-	return &ProjBusinessFileDao{M: d.M.WhereNotIn(column, in)}
+	return &ProjBusinessFileDao{M: d.M.WhereNotIn(column, in), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereNotNull builds "columns[0] IS NOT NULL AND columns[1] IS NOT NULL ..." statement.
 func (d *ProjBusinessFileDao) WhereNotNull(columns ...string) *ProjBusinessFileDao {
-	return &ProjBusinessFileDao{M: d.M.WhereNotNull(columns...)}
+	return &ProjBusinessFileDao{M: d.M.WhereNotNull(columns...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereOr adds "OR" condition to the where statement.
 func (d *ProjBusinessFileDao) WhereOr(where interface{}, args ...interface{}) *ProjBusinessFileDao {
-	return &ProjBusinessFileDao{M: d.M.WhereOr(where, args...)}
+	return &ProjBusinessFileDao{M: d.M.WhereOr(where, args...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereOrf builds "OR" condition string using fmt.Sprintf and arguments.
 func (d *ProjBusinessFileDao) WhereOrf(format string, args ...interface{}) *ProjBusinessFileDao {
-	return &ProjBusinessFileDao{M: d.M.WhereOrf(format, args...)}
+	return &ProjBusinessFileDao{M: d.M.WhereOrf(format, args...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereOrLT builds "column < value" statement in "OR" conditions..
 func (d *ProjBusinessFileDao) WhereOrLT(column string, value interface{}) *ProjBusinessFileDao {
-	return &ProjBusinessFileDao{M: d.M.WhereOrLT(column, value)}
+	return &ProjBusinessFileDao{M: d.M.WhereOrLT(column, value), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereOrLTE builds "column <= value" statement in "OR" conditions..
 func (d *ProjBusinessFileDao) WhereOrLTE(column string, value interface{}) *ProjBusinessFileDao {
-	return &ProjBusinessFileDao{M: d.M.WhereOrLTE(column, value)}
+	return &ProjBusinessFileDao{M: d.M.WhereOrLTE(column, value), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereOrGT builds "column > value" statement in "OR" conditions..
 func (d *ProjBusinessFileDao) WhereOrGT(column string, value interface{}) *ProjBusinessFileDao {
-	return &ProjBusinessFileDao{M: d.M.WhereOrGT(column, value)}
+	return &ProjBusinessFileDao{M: d.M.WhereOrGT(column, value), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereOrGTE builds "column >= value" statement in "OR" conditions..
 func (d *ProjBusinessFileDao) WhereOrGTE(column string, value interface{}) *ProjBusinessFileDao {
-	return &ProjBusinessFileDao{M: d.M.WhereOrGTE(column, value)}
+	return &ProjBusinessFileDao{M: d.M.WhereOrGTE(column, value), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereOrBetween builds "column BETWEEN min AND max" statement in "OR" conditions.
 func (d *ProjBusinessFileDao) WhereOrBetween(column string, min, max interface{}) *ProjBusinessFileDao {
-	return &ProjBusinessFileDao{M: d.M.WhereOrBetween(column, min, max)}
+	return &ProjBusinessFileDao{M: d.M.WhereOrBetween(column, min, max), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereOrLike builds "column LIKE like" statement in "OR" conditions.
 func (d *ProjBusinessFileDao) WhereOrLike(column string, like interface{}) *ProjBusinessFileDao {
-	return &ProjBusinessFileDao{M: d.M.WhereOrLike(column, like)}
+	return &ProjBusinessFileDao{M: d.M.WhereOrLike(column, like), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereOrIn builds "column IN (in)" statement in "OR" conditions.
 func (d *ProjBusinessFileDao) WhereOrIn(column string, in interface{}) *ProjBusinessFileDao {
-	return &ProjBusinessFileDao{M: d.M.WhereOrIn(column, in)}
+	return &ProjBusinessFileDao{M: d.M.WhereOrIn(column, in), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereOrNull builds "columns[0] IS NULL OR columns[1] IS NULL ..." statement in "OR" conditions.
 func (d *ProjBusinessFileDao) WhereOrNull(columns ...string) *ProjBusinessFileDao {
-	return &ProjBusinessFileDao{M: d.M.WhereOrNull(columns...)}
+	return &ProjBusinessFileDao{M: d.M.WhereOrNull(columns...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereOrNotBetween builds "column NOT BETWEEN min AND max" statement in "OR" conditions.
 func (d *ProjBusinessFileDao) WhereOrNotBetween(column string, min, max interface{}) *ProjBusinessFileDao {
-	return &ProjBusinessFileDao{M: d.M.WhereOrNotBetween(column, min, max)}
+	return &ProjBusinessFileDao{M: d.M.WhereOrNotBetween(column, min, max), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereOrNotLike builds "column NOT LIKE like" statement in "OR" conditions.
 func (d *ProjBusinessFileDao) WhereOrNotLike(column string, like interface{}) *ProjBusinessFileDao {
-	return &ProjBusinessFileDao{M: d.M.WhereOrNotLike(column, like)}
+	return &ProjBusinessFileDao{M: d.M.WhereOrNotLike(column, like), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereOrNotIn builds "column NOT IN (in)" statement.
 func (d *ProjBusinessFileDao) WhereOrNotIn(column string, in interface{}) *ProjBusinessFileDao {
-	return &ProjBusinessFileDao{M: d.M.WhereOrNotIn(column, in)}
+	return &ProjBusinessFileDao{M: d.M.WhereOrNotIn(column, in), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereOrNotNull builds "columns[0] IS NOT NULL OR columns[1] IS NOT NULL ..." statement in "OR" conditions.
 func (d *ProjBusinessFileDao) WhereOrNotNull(columns ...string) *ProjBusinessFileDao {
-	return &ProjBusinessFileDao{M: d.M.WhereOrNotNull(columns...)}
+	return &ProjBusinessFileDao{M: d.M.WhereOrNotNull(columns...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // Group sets the "GROUP BY" statement for the model.
 func (d *ProjBusinessFileDao) Group(groupBy ...string) *ProjBusinessFileDao {
-	return &ProjBusinessFileDao{M: d.M.Group(groupBy...)}
+	return &ProjBusinessFileDao{M: d.M.Group(groupBy...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // And adds "AND" condition to the where statement.
 // Deprecated, use Where instead.
 func (d *ProjBusinessFileDao) And(where interface{}, args ...interface{}) *ProjBusinessFileDao {
-	return &ProjBusinessFileDao{M: d.M.And(where, args...)}
+	return &ProjBusinessFileDao{M: d.M.And(where, args...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // Or adds "OR" condition to the where statement.
 // Deprecated, use WhereOr instead.
 func (d *ProjBusinessFileDao) Or(where interface{}, args ...interface{}) *ProjBusinessFileDao {
-	return &ProjBusinessFileDao{M: d.M.Or(where, args...)}
+	return &ProjBusinessFileDao{M: d.M.Or(where, args...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // GroupBy sets the "GROUP BY" statement for the model.
 func (d *ProjBusinessFileDao) GroupBy(groupBy string) *ProjBusinessFileDao {
-	return &ProjBusinessFileDao{M: d.M.Group(groupBy)}
+	return &ProjBusinessFileDao{M: d.M.Group(groupBy), Table: d.Table, TableAs: d.TableAs}
 }
 
 // Order sets the "ORDER BY" statement for the model.
 func (d *ProjBusinessFileDao) Order(orderBy ...string) *ProjBusinessFileDao {
-	return &ProjBusinessFileDao{M: d.M.Order(orderBy...)}
+	return &ProjBusinessFileDao{M: d.M.Order(orderBy...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // OrderAsc sets the "ORDER BY xxx ASC" statement for the model.
 func (d *ProjBusinessFileDao) OrderAsc(column string) *ProjBusinessFileDao {
-	return &ProjBusinessFileDao{M: d.M.OrderAsc(column)}
+	return &ProjBusinessFileDao{M: d.M.OrderAsc(column), Table: d.Table, TableAs: d.TableAs}
 }
 
 // OrderDesc sets the "ORDER BY xxx DESC" statement for the model.
 func (d *ProjBusinessFileDao) OrderDesc(column string) *ProjBusinessFileDao {
-	return &ProjBusinessFileDao{M: d.M.OrderDesc(column)}
+	return &ProjBusinessFileDao{M: d.M.OrderDesc(column), Table: d.Table, TableAs: d.TableAs}
 }
 
 // OrderRandom sets the "ORDER BY RANDOM()" statement for the model.
 func (d *ProjBusinessFileDao) OrderRandom() *ProjBusinessFileDao {
-	return &ProjBusinessFileDao{M: d.M.OrderRandom()}
+	return &ProjBusinessFileDao{M: d.M.OrderRandom(), Table: d.Table, TableAs: d.TableAs}
 }
 
 // OrderBy is alias of Model.Order.
 // See Model.Order.
 // Deprecated, use Order instead.
 func (d *ProjBusinessFileDao) OrderBy(orderBy string) *ProjBusinessFileDao {
-	return &ProjBusinessFileDao{M: d.M.Order(orderBy)}
+	return &ProjBusinessFileDao{M: d.M.Order(orderBy), Table: d.Table, TableAs: d.TableAs}
 }
 
 // Limit sets the "LIMIT" statement for the model.
@@ -480,30 +481,30 @@ func (d *ProjBusinessFileDao) OrderBy(orderBy string) *ProjBusinessFileDao {
 // it then sets "LIMIT limit[0],limit[1]" statement for the model, or else it sets "LIMIT limit[0]"
 // statement.
 func (d *ProjBusinessFileDao) Limit(limit ...int) *ProjBusinessFileDao {
-	return &ProjBusinessFileDao{M: d.M.Limit(limit...)}
+	return &ProjBusinessFileDao{M: d.M.Limit(limit...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // Offset sets the "OFFSET" statement for the model.
 // It only makes sense for some databases like SQLServer, PostgreSQL, etc.
 func (d *ProjBusinessFileDao) Offset(offset int) *ProjBusinessFileDao {
-	return &ProjBusinessFileDao{M: d.M.Offset(offset)}
+	return &ProjBusinessFileDao{M: d.M.Offset(offset), Table: d.Table, TableAs: d.TableAs}
 }
 
 // Distinct forces the query to only return distinct results.
 func (d *ProjBusinessFileDao) Distinct() *ProjBusinessFileDao {
-	return &ProjBusinessFileDao{M: d.M.Distinct()}
+	return &ProjBusinessFileDao{M: d.M.Distinct(), Table: d.Table, TableAs: d.TableAs}
 }
 
 // Page sets the paging number for the model.
 // The parameter <page> is started from 1 for paging.
 // Note that, it differs that the Limit function start from 0 for "LIMIT" statement.
 func (d *ProjBusinessFileDao) Page(page, limit int) *ProjBusinessFileDao {
-	return &ProjBusinessFileDao{M: d.M.Page(page, limit)}
+	return &ProjBusinessFileDao{M: d.M.Page(page, limit), Table: d.Table, TableAs: d.TableAs}
 }
 
 // Batch sets the batch operation number for the model.
 func (d *ProjBusinessFileDao) Batch(batch int) *ProjBusinessFileDao {
-	return &ProjBusinessFileDao{M: d.M.Batch(batch)}
+	return &ProjBusinessFileDao{M: d.M.Batch(batch), Table: d.Table, TableAs: d.TableAs}
 }
 
 // Cache sets the cache feature for the model. It caches the result of the sql, which means
@@ -519,7 +520,7 @@ func (d *ProjBusinessFileDao) Batch(batch int) *ProjBusinessFileDao {
 //
 // Note that, the cache feature is disabled if the model is operating on a transaction.
 func (d *ProjBusinessFileDao) Cache(duration time.Duration, name ...string) *ProjBusinessFileDao {
-	return &ProjBusinessFileDao{M: d.M.Cache(duration, name...)}
+	return &ProjBusinessFileDao{M: d.M.Cache(duration, name...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // Data sets the operation data for the model.
@@ -530,7 +531,7 @@ func (d *ProjBusinessFileDao) Cache(duration time.Duration, name ...string) *Pro
 // Data(g.Map{"uid": 10000, "name":"john"})
 // Data(g.Slice{g.Map{"uid": 10000, "name":"john"}, g.Map{"uid": 20000, "name":"smith"})
 func (d *ProjBusinessFileDao) Data(data ...interface{}) *ProjBusinessFileDao {
-	return &ProjBusinessFileDao{M: d.M.Data(data...)}
+	return &ProjBusinessFileDao{M: d.M.Data(data...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // All does "SELECT FROM ..." statement for the model.
@@ -675,17 +676,17 @@ func (d *ProjBusinessFileDao) Chunk(limit int, callback func(entities []*model.P
 
 // LockUpdate sets the lock for update for current operation.
 func (d *ProjBusinessFileDao) LockUpdate() *ProjBusinessFileDao {
-	return &ProjBusinessFileDao{M: d.M.LockUpdate()}
+	return &ProjBusinessFileDao{M: d.M.LockUpdate(), Table: d.Table, TableAs: d.TableAs}
 }
 
 // LockShared sets the lock in share mode for current operation.
 func (d *ProjBusinessFileDao) LockShared() *ProjBusinessFileDao {
-	return &ProjBusinessFileDao{M: d.M.LockShared()}
+	return &ProjBusinessFileDao{M: d.M.LockShared(), Table: d.Table, TableAs: d.TableAs}
 }
 
 // Unscoped enables/disables the soft deleting feature.
 func (d *ProjBusinessFileDao) Unscoped() *ProjBusinessFileDao {
-	return &ProjBusinessFileDao{M: d.M.Unscoped()}
+	return &ProjBusinessFileDao{M: d.M.Unscoped(), Table: d.Table, TableAs: d.TableAs}
 }
 
 // DataScope enables the DataScope feature.
@@ -707,14 +708,18 @@ func (d *ProjBusinessFileDao) DataScope(ctx context.Context, userCol ...string)
 				dataScope["id"] = userIds
 			}
 		}
+		tableAs := d.TableAs
+		if d.TableAs != "" {
+			tableAs += "."
+		}
 		for k, v := range dataScope {
 			if ok, _ := d.M.HasField(k); ok {
-				columns = append(columns, k+" IN (?) ")
+				columns = append(columns, tableAs+k+" IN (?) ")
 				values = append(values, v)
 			}
 		}
 		whereSql := strings.Join(columns, " OR ")
-		return &ProjBusinessFileDao{M: d.M.Where(whereSql, values).Ctx(ctx)}
+		return &ProjBusinessFileDao{M: d.M.Where(whereSql, values).Ctx(ctx), Table: d.Table, TableAs: d.TableAs}
 	}
 	return d
 }

opms_parent/app/dao/proj/internal/proj_business_product.go

@@ -19,10 +19,11 @@ import (
 
 // ProjBusinessProductDao is the manager for logic model data accessing and custom defined data operations functions management.
 type ProjBusinessProductDao struct {
-	gmvc.M                            // M is the core and embedded struct that inherits all chaining operations from gdb.Model.
-	C      projBusinessProductColumns // C is the short type for Columns, which contains all the column names of Table for convenient usage.
-	DB     gdb.DB                     // DB is the raw underlying database management object.
-	Table  string                     // Table is the underlying table name of the DAO.
+	gmvc.M                             // M is the core and embedded struct that inherits all chaining operations from gdb.Model.
+	C       projBusinessProductColumns // C is the short type for Columns, which contains all the column names of Table for convenient usage.
+	DB      gdb.DB                     // DB is the raw underlying database management object.
+	Table   string                     // Table is the underlying table name of the DAO.
+	TableAs string                     // TableAs is the underlying table alias name of the DAO.
 }
 
 // ProjBusinessProductColumns defines and stores column names for table proj_business_product.
@@ -114,7 +115,7 @@ func NewProjBusinessProductDao(tenant string) ProjBusinessProductDao {
 // Note that this returned DB object can be used only once, so do not assign it to
 // a global or package variable for long using.
 func (d *ProjBusinessProductDao) Ctx(ctx context.Context) *ProjBusinessProductDao {
-	return &ProjBusinessProductDao{M: d.M.Ctx(ctx)}
+	return &ProjBusinessProductDao{M: d.M.Ctx(ctx), Table: d.Table, TableAs: d.TableAs}
 }
 
 // GetCtx returns the context for current Model.
@@ -125,34 +126,34 @@ func (d *ProjBusinessProductDao) GetCtx() context.Context {
 
 // As sets an alias name for current table.
 func (d *ProjBusinessProductDao) As(as string) *ProjBusinessProductDao {
-	return &ProjBusinessProductDao{M: d.M.As(as)}
+	return &ProjBusinessProductDao{M: d.M.As(as), Table: d.Table, TableAs: as}
 }
 
 // TX sets the transaction for current operation.
 func (d *ProjBusinessProductDao) TX(tx *gdb.TX) *ProjBusinessProductDao {
-	return &ProjBusinessProductDao{M: d.M.TX(tx)}
+	return &ProjBusinessProductDao{M: d.M.TX(tx), Table: d.Table, TableAs: d.TableAs}
 }
 
 // Master marks the following operation on master node.
 func (d *ProjBusinessProductDao) Master() *ProjBusinessProductDao {
-	return &ProjBusinessProductDao{M: d.M.Master()}
+	return &ProjBusinessProductDao{M: d.M.Master(), Table: d.Table, TableAs: d.TableAs}
 }
 
 // Slave marks the following operation on slave node.
 // Note that it makes sense only if there's any slave node configured.
 func (d *ProjBusinessProductDao) Slave() *ProjBusinessProductDao {
-	return &ProjBusinessProductDao{M: d.M.Slave()}
+	return &ProjBusinessProductDao{M: d.M.Slave(), Table: d.Table, TableAs: d.TableAs}
 }
 
 // Args sets custom arguments for model operation.
 func (d *ProjBusinessProductDao) Args(args ...interface{}) *ProjBusinessProductDao {
-	return &ProjBusinessProductDao{M: d.M.Args(args...)}
+	return &ProjBusinessProductDao{M: d.M.Args(args...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // Handler calls each of "handlers" on current Model and returns a new Model.
 // ModelHandler is a function that handles given Model and returns a new Model that is custom modified.
 func (d *ProjBusinessProductDao) Handler(handlers ...gdb.ModelHandler) *ProjBusinessProductDao {
-	return &ProjBusinessProductDao{M: d.M.Handler(handlers...)}
+	return &ProjBusinessProductDao{M: d.M.Handler(handlers...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // LeftJoin does "LEFT JOIN ... ON ..." statement on the model.
@@ -161,7 +162,7 @@ func (d *ProjBusinessProductDao) Handler(handlers ...gdb.ModelHandler) *ProjBusi
 // Table("user").LeftJoin("user_detail", "user_detail.uid=user.uid")
 // Table("user", "u").LeftJoin("user_detail", "ud", "ud.uid=u.uid")
 func (d *ProjBusinessProductDao) LeftJoin(table ...string) *ProjBusinessProductDao {
-	return &ProjBusinessProductDao{M: d.M.LeftJoin(table...)}
+	return &ProjBusinessProductDao{M: d.M.LeftJoin(table...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // RightJoin does "RIGHT JOIN ... ON ..." statement on the model.
@@ -170,7 +171,7 @@ func (d *ProjBusinessProductDao) LeftJoin(table ...string) *ProjBusinessProductD
 // Table("user").RightJoin("user_detail", "user_detail.uid=user.uid")
 // Table("user", "u").RightJoin("user_detail", "ud", "ud.uid=u.uid")
 func (d *ProjBusinessProductDao) RightJoin(table ...string) *ProjBusinessProductDao {
-	return &ProjBusinessProductDao{M: d.M.RightJoin(table...)}
+	return &ProjBusinessProductDao{M: d.M.RightJoin(table...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // InnerJoin does "INNER JOIN ... ON ..." statement on the model.
@@ -179,93 +180,93 @@ func (d *ProjBusinessProductDao) RightJoin(table ...string) *ProjBusinessProduct
 // Table("user").InnerJoin("user_detail", "user_detail.uid=user.uid")
 // Table("user", "u").InnerJoin("user_detail", "ud", "ud.uid=u.uid")
 func (d *ProjBusinessProductDao) InnerJoin(table ...string) *ProjBusinessProductDao {
-	return &ProjBusinessProductDao{M: d.M.InnerJoin(table...)}
+	return &ProjBusinessProductDao{M: d.M.InnerJoin(table...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // Fields sets the operation fields of the model, multiple fields joined using char ','.
 // The parameter <fieldNamesOrMapStruct> can be type of string/map/*map/struct/*struct.
 func (d *ProjBusinessProductDao) Fields(fieldNamesOrMapStruct ...interface{}) *ProjBusinessProductDao {
-	return &ProjBusinessProductDao{M: d.M.Fields(fieldNamesOrMapStruct...)}
+	return &ProjBusinessProductDao{M: d.M.Fields(fieldNamesOrMapStruct...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // FieldsEx sets the excluded operation fields of the model, multiple fields joined using char ','.
 // The parameter <fieldNamesOrMapStruct> can be type of string/map/*map/struct/*struct.
 func (d *ProjBusinessProductDao) FieldsEx(fieldNamesOrMapStruct ...interface{}) *ProjBusinessProductDao {
-	return &ProjBusinessProductDao{M: d.M.FieldsEx(fieldNamesOrMapStruct...)}
+	return &ProjBusinessProductDao{M: d.M.FieldsEx(fieldNamesOrMapStruct...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // FieldCount formats and appends commonly used field "COUNT(column)" to the select fields of model.
 func (d *ProjBusinessProductDao) FieldCount(column string, as ...string) *ProjBusinessProductDao {
-	return &ProjBusinessProductDao{M: d.M.FieldCount(column, as...)}
+	return &ProjBusinessProductDao{M: d.M.FieldCount(column, as...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // FieldSum formats and appends commonly used field "SUM(column)" to the select fields of model.
 func (d *ProjBusinessProductDao) FieldSum(column string, as ...string) *ProjBusinessProductDao {
-	return &ProjBusinessProductDao{M: d.M.FieldSum(column, as...)}
+	return &ProjBusinessProductDao{M: d.M.FieldSum(column, as...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // FieldMin formats and appends commonly used field "MIN(column)" to the select fields of model.
 func (d *ProjBusinessProductDao) FieldMin(column string, as ...string) *ProjBusinessProductDao {
-	return &ProjBusinessProductDao{M: d.M.FieldMin(column, as...)}
+	return &ProjBusinessProductDao{M: d.M.FieldMin(column, as...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // FieldMax formats and appends commonly used field "MAX(column)" to the select fields of model.
 func (d *ProjBusinessProductDao) FieldMax(column string, as ...string) *ProjBusinessProductDao {
-	return &ProjBusinessProductDao{M: d.M.FieldMax(column, as...)}
+	return &ProjBusinessProductDao{M: d.M.FieldMax(column, as...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // FieldAvg formats and appends commonly used field "AVG(column)" to the select fields of model.
 func (d *ProjBusinessProductDao) FieldAvg(column string, as ...string) *ProjBusinessProductDao {
-	return &ProjBusinessProductDao{M: d.M.FieldAvg(column, as...)}
+	return &ProjBusinessProductDao{M: d.M.FieldAvg(column, as...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // Option adds extra operation option for the model.
 // Deprecated, use separate operations instead.
 func (d *ProjBusinessProductDao) Option(option int) *ProjBusinessProductDao {
-	return &ProjBusinessProductDao{M: d.M.Option(option)}
+	return &ProjBusinessProductDao{M: d.M.Option(option), Table: d.Table, TableAs: d.TableAs}
 }
 
 // OmitEmpty sets OPTION_OMITEMPTY option for the model, which automatically filers
 // the data and where attributes for empty values.
 func (d *ProjBusinessProductDao) OmitEmpty() *ProjBusinessProductDao {
-	return &ProjBusinessProductDao{M: d.M.OmitEmpty()}
+	return &ProjBusinessProductDao{M: d.M.OmitEmpty(), Table: d.Table, TableAs: d.TableAs}
 }
 
 // OmitEmptyWhere sets optionOmitEmptyWhere option for the model, which automatically filers
 // the Where/Having parameters for "empty" values.
 func (d *ProjBusinessProductDao) OmitEmptyWhere() *ProjBusinessProductDao {
-	return &ProjBusinessProductDao{M: d.M.OmitEmptyWhere()}
+	return &ProjBusinessProductDao{M: d.M.OmitEmptyWhere(), Table: d.Table, TableAs: d.TableAs}
 }
 
 // OmitEmptyData sets optionOmitEmptyData option for the model, which automatically filers
 // the Data parameters for "empty" values.
 func (d *ProjBusinessProductDao) OmitEmptyData() *ProjBusinessProductDao {
-	return &ProjBusinessProductDao{M: d.M.OmitEmptyData()}
+	return &ProjBusinessProductDao{M: d.M.OmitEmptyData(), Table: d.Table, TableAs: d.TableAs}
 }
 
 // OmitNil sets optionOmitNil option for the model, which automatically filers
 // the data and where parameters for "nil" values.
 func (d *ProjBusinessProductDao) OmitNil() *ProjBusinessProductDao {
-	return &ProjBusinessProductDao{M: d.M.OmitNil()}
+	return &ProjBusinessProductDao{M: d.M.OmitNil(), Table: d.Table, TableAs: d.TableAs}
 }
 
 // OmitNilWhere sets optionOmitNilWhere option for the model, which automatically filers
 // the Where/Having parameters for "nil" values.
 func (d *ProjBusinessProductDao) OmitNilWhere() *ProjBusinessProductDao {
-	return &ProjBusinessProductDao{M: d.M.OmitNilWhere()}
+	return &ProjBusinessProductDao{M: d.M.OmitNilWhere(), Table: d.Table, TableAs: d.TableAs}
 }
 
 // OmitNilData sets optionOmitNilData option for the model, which automatically filers
 // the Data parameters for "nil" values.
 func (d *ProjBusinessProductDao) OmitNilData() *ProjBusinessProductDao {
-	return &ProjBusinessProductDao{M: d.M.OmitNilData()}
+	return &ProjBusinessProductDao{M: d.M.OmitNilData(), Table: d.Table, TableAs: d.TableAs}
 }
 
 // Filter marks filtering the fields which does not exist in the fields of the operated table.
 // Note that this function supports only single table operations.
 // Deprecated, filter feature is automatically enabled from GoFrame v1.16.0, it is so no longer used.
 func (d *ProjBusinessProductDao) Filter() *ProjBusinessProductDao {
-	return &ProjBusinessProductDao{M: d.M.Filter()}
+	return &ProjBusinessProductDao{M: d.M.Filter(), Table: d.Table, TableAs: d.TableAs}
 }
 
 // Where sets the condition statement for the model. The parameter <where> can be type of
@@ -280,7 +281,7 @@ func (d *ProjBusinessProductDao) Filter() *ProjBusinessProductDao {
 // Where("age IN(?,?)", 18, 50)
 // Where(User{ Id : 1, UserName : "john"})
 func (d *ProjBusinessProductDao) Where(where interface{}, args ...interface{}) *ProjBusinessProductDao {
-	return &ProjBusinessProductDao{M: d.M.Where(where, args...)}
+	return &ProjBusinessProductDao{M: d.M.Where(where, args...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WherePri does the same logic as M.Where except that if the parameter <where>
@@ -289,205 +290,205 @@ func (d *ProjBusinessProductDao) Where(where interface{}, args ...interface{}) *
 // WherePri function treats the condition as "id=123", but M.Where treats the condition
 // as string "123".
 func (d *ProjBusinessProductDao) WherePri(where interface{}, args ...interface{}) *ProjBusinessProductDao {
-	return &ProjBusinessProductDao{M: d.M.WherePri(where, args...)}
+	return &ProjBusinessProductDao{M: d.M.WherePri(where, args...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // Having sets the having statement for the model.
 // The parameters of this function usage are as the same as function Where.
 // See Where.
 func (d *ProjBusinessProductDao) Having(having interface{}, args ...interface{}) *ProjBusinessProductDao {
-	return &ProjBusinessProductDao{M: d.M.Having(having, args...)}
+	return &ProjBusinessProductDao{M: d.M.Having(having, args...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // Wheref builds condition string using fmt.Sprintf and arguments.
 // Note that if the number of "args" is more than the place holder in "format",
 // the extra "args" will be used as the where condition arguments of the Model.
 func (d *ProjBusinessProductDao) Wheref(format string, args ...interface{}) *ProjBusinessProductDao {
-	return &ProjBusinessProductDao{M: d.M.Wheref(format, args...)}
+	return &ProjBusinessProductDao{M: d.M.Wheref(format, args...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereLT builds "column < value" statement.
 func (d *ProjBusinessProductDao) WhereLT(column string, value interface{}) *ProjBusinessProductDao {
-	return &ProjBusinessProductDao{M: d.M.WhereLT(column, value)}
+	return &ProjBusinessProductDao{M: d.M.WhereLT(column, value), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereLTE builds "column <= value" statement.
 func (d *ProjBusinessProductDao) WhereLTE(column string, value interface{}) *ProjBusinessProductDao {
-	return &ProjBusinessProductDao{M: d.M.WhereLTE(column, value)}
+	return &ProjBusinessProductDao{M: d.M.WhereLTE(column, value), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereGT builds "column > value" statement.
 func (d *ProjBusinessProductDao) WhereGT(column string, value interface{}) *ProjBusinessProductDao {
-	return &ProjBusinessProductDao{M: d.M.WhereGT(column, value)}
+	return &ProjBusinessProductDao{M: d.M.WhereGT(column, value), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereGTE builds "column >= value" statement.
 func (d *ProjBusinessProductDao) WhereGTE(column string, value interface{}) *ProjBusinessProductDao {
-	return &ProjBusinessProductDao{M: d.M.WhereGTE(column, value)}
+	return &ProjBusinessProductDao{M: d.M.WhereGTE(column, value), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereBetween builds "column BETWEEN min AND max" statement.
 func (d *ProjBusinessProductDao) WhereBetween(column string, min, max interface{}) *ProjBusinessProductDao {
-	return &ProjBusinessProductDao{M: d.M.WhereBetween(column, min, max)}
+	return &ProjBusinessProductDao{M: d.M.WhereBetween(column, min, max), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereLike builds "column LIKE like" statement.
 func (d *ProjBusinessProductDao) WhereLike(column string, like interface{}) *ProjBusinessProductDao {
-	return &ProjBusinessProductDao{M: d.M.WhereLike(column, like)}
+	return &ProjBusinessProductDao{M: d.M.WhereLike(column, like), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereIn builds "column IN (in)" statement.
 func (d *ProjBusinessProductDao) WhereIn(column string, in interface{}) *ProjBusinessProductDao {
-	return &ProjBusinessProductDao{M: d.M.WhereIn(column, in)}
+	return &ProjBusinessProductDao{M: d.M.WhereIn(column, in), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereNull builds "columns[0] IS NULL AND columns[1] IS NULL ..." statement.
 func (d *ProjBusinessProductDao) WhereNull(columns ...string) *ProjBusinessProductDao {
-	return &ProjBusinessProductDao{M: d.M.WhereNull(columns...)}
+	return &ProjBusinessProductDao{M: d.M.WhereNull(columns...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereNotBetween builds "column NOT BETWEEN min AND max" statement.
 func (d *ProjBusinessProductDao) WhereNotBetween(column string, min, max interface{}) *ProjBusinessProductDao {
-	return &ProjBusinessProductDao{M: d.M.WhereNotBetween(column, min, max)}
+	return &ProjBusinessProductDao{M: d.M.WhereNotBetween(column, min, max), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereNotLike builds "column NOT LIKE like" statement.
 func (d *ProjBusinessProductDao) WhereNotLike(column string, like interface{}) *ProjBusinessProductDao {
-	return &ProjBusinessProductDao{M: d.M.WhereNotLike(column, like)}
+	return &ProjBusinessProductDao{M: d.M.WhereNotLike(column, like), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereNot builds "column != value" statement.
 func (d *ProjBusinessProductDao) WhereNot(column string, value interface{}) *ProjBusinessProductDao {
-	return &ProjBusinessProductDao{M: d.M.WhereNot(column, value)}
+	return &ProjBusinessProductDao{M: d.M.WhereNot(column, value), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereNotIn builds "column NOT IN (in)" statement.
 func (d *ProjBusinessProductDao) WhereNotIn(column string, in interface{}) *ProjBusinessProductDao {
-	return &ProjBusinessProductDao{M: d.M.WhereNotIn(column, in)}
+	return &ProjBusinessProductDao{M: d.M.WhereNotIn(column, in), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereNotNull builds "columns[0] IS NOT NULL AND columns[1] IS NOT NULL ..." statement.
 func (d *ProjBusinessProductDao) WhereNotNull(columns ...string) *ProjBusinessProductDao {
-	return &ProjBusinessProductDao{M: d.M.WhereNotNull(columns...)}
+	return &ProjBusinessProductDao{M: d.M.WhereNotNull(columns...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereOr adds "OR" condition to the where statement.
 func (d *ProjBusinessProductDao) WhereOr(where interface{}, args ...interface{}) *ProjBusinessProductDao {
-	return &ProjBusinessProductDao{M: d.M.WhereOr(where, args...)}
+	return &ProjBusinessProductDao{M: d.M.WhereOr(where, args...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereOrf builds "OR" condition string using fmt.Sprintf and arguments.
 func (d *ProjBusinessProductDao) WhereOrf(format string, args ...interface{}) *ProjBusinessProductDao {
-	return &ProjBusinessProductDao{M: d.M.WhereOrf(format, args...)}
+	return &ProjBusinessProductDao{M: d.M.WhereOrf(format, args...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereOrLT builds "column < value" statement in "OR" conditions..
 func (d *ProjBusinessProductDao) WhereOrLT(column string, value interface{}) *ProjBusinessProductDao {
-	return &ProjBusinessProductDao{M: d.M.WhereOrLT(column, value)}
+	return &ProjBusinessProductDao{M: d.M.WhereOrLT(column, value), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereOrLTE builds "column <= value" statement in "OR" conditions..
 func (d *ProjBusinessProductDao) WhereOrLTE(column string, value interface{}) *ProjBusinessProductDao {
-	return &ProjBusinessProductDao{M: d.M.WhereOrLTE(column, value)}
+	return &ProjBusinessProductDao{M: d.M.WhereOrLTE(column, value), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereOrGT builds "column > value" statement in "OR" conditions..
 func (d *ProjBusinessProductDao) WhereOrGT(column string, value interface{}) *ProjBusinessProductDao {
-	return &ProjBusinessProductDao{M: d.M.WhereOrGT(column, value)}
+	return &ProjBusinessProductDao{M: d.M.WhereOrGT(column, value), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereOrGTE builds "column >= value" statement in "OR" conditions..
 func (d *ProjBusinessProductDao) WhereOrGTE(column string, value interface{}) *ProjBusinessProductDao {
-	return &ProjBusinessProductDao{M: d.M.WhereOrGTE(column, value)}
+	return &ProjBusinessProductDao{M: d.M.WhereOrGTE(column, value), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereOrBetween builds "column BETWEEN min AND max" statement in "OR" conditions.
 func (d *ProjBusinessProductDao) WhereOrBetween(column string, min, max interface{}) *ProjBusinessProductDao {
-	return &ProjBusinessProductDao{M: d.M.WhereOrBetween(column, min, max)}
+	return &ProjBusinessProductDao{M: d.M.WhereOrBetween(column, min, max), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereOrLike builds "column LIKE like" statement in "OR" conditions.
 func (d *ProjBusinessProductDao) WhereOrLike(column string, like interface{}) *ProjBusinessProductDao {
-	return &ProjBusinessProductDao{M: d.M.WhereOrLike(column, like)}
+	return &ProjBusinessProductDao{M: d.M.WhereOrLike(column, like), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereOrIn builds "column IN (in)" statement in "OR" conditions.
 func (d *ProjBusinessProductDao) WhereOrIn(column string, in interface{}) *ProjBusinessProductDao {
-	return &ProjBusinessProductDao{M: d.M.WhereOrIn(column, in)}
+	return &ProjBusinessProductDao{M: d.M.WhereOrIn(column, in), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereOrNull builds "columns[0] IS NULL OR columns[1] IS NULL ..." statement in "OR" conditions.
 func (d *ProjBusinessProductDao) WhereOrNull(columns ...string) *ProjBusinessProductDao {
-	return &ProjBusinessProductDao{M: d.M.WhereOrNull(columns...)}
+	return &ProjBusinessProductDao{M: d.M.WhereOrNull(columns...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereOrNotBetween builds "column NOT BETWEEN min AND max" statement in "OR" conditions.
 func (d *ProjBusinessProductDao) WhereOrNotBetween(column string, min, max interface{}) *ProjBusinessProductDao {
-	return &ProjBusinessProductDao{M: d.M.WhereOrNotBetween(column, min, max)}
+	return &ProjBusinessProductDao{M: d.M.WhereOrNotBetween(column, min, max), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereOrNotLike builds "column NOT LIKE like" statement in "OR" conditions.
 func (d *ProjBusinessProductDao) WhereOrNotLike(column string, like interface{}) *ProjBusinessProductDao {
-	return &ProjBusinessProductDao{M: d.M.WhereOrNotLike(column, like)}
+	return &ProjBusinessProductDao{M: d.M.WhereOrNotLike(column, like), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereOrNotIn builds "column NOT IN (in)" statement.
 func (d *ProjBusinessProductDao) WhereOrNotIn(column string, in interface{}) *ProjBusinessProductDao {
-	return &ProjBusinessProductDao{M: d.M.WhereOrNotIn(column, in)}
+	return &ProjBusinessProductDao{M: d.M.WhereOrNotIn(column, in), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereOrNotNull builds "columns[0] IS NOT NULL OR columns[1] IS NOT NULL ..." statement in "OR" conditions.
 func (d *ProjBusinessProductDao) WhereOrNotNull(columns ...string) *ProjBusinessProductDao {
-	return &ProjBusinessProductDao{M: d.M.WhereOrNotNull(columns...)}
+	return &ProjBusinessProductDao{M: d.M.WhereOrNotNull(columns...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // Group sets the "GROUP BY" statement for the model.
 func (d *ProjBusinessProductDao) Group(groupBy ...string) *ProjBusinessProductDao {
-	return &ProjBusinessProductDao{M: d.M.Group(groupBy...)}
+	return &ProjBusinessProductDao{M: d.M.Group(groupBy...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // And adds "AND" condition to the where statement.
 // Deprecated, use Where instead.
 func (d *ProjBusinessProductDao) And(where interface{}, args ...interface{}) *ProjBusinessProductDao {
-	return &ProjBusinessProductDao{M: d.M.And(where, args...)}
+	return &ProjBusinessProductDao{M: d.M.And(where, args...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // Or adds "OR" condition to the where statement.
 // Deprecated, use WhereOr instead.
 func (d *ProjBusinessProductDao) Or(where interface{}, args ...interface{}) *ProjBusinessProductDao {
-	return &ProjBusinessProductDao{M: d.M.Or(where, args...)}
+	return &ProjBusinessProductDao{M: d.M.Or(where, args...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // GroupBy sets the "GROUP BY" statement for the model.
 func (d *ProjBusinessProductDao) GroupBy(groupBy string) *ProjBusinessProductDao {
-	return &ProjBusinessProductDao{M: d.M.Group(groupBy)}
+	return &ProjBusinessProductDao{M: d.M.Group(groupBy), Table: d.Table, TableAs: d.TableAs}
 }
 
 // Order sets the "ORDER BY" statement for the model.
 func (d *ProjBusinessProductDao) Order(orderBy ...string) *ProjBusinessProductDao {
-	return &ProjBusinessProductDao{M: d.M.Order(orderBy...)}
+	return &ProjBusinessProductDao{M: d.M.Order(orderBy...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // OrderAsc sets the "ORDER BY xxx ASC" statement for the model.
 func (d *ProjBusinessProductDao) OrderAsc(column string) *ProjBusinessProductDao {
-	return &ProjBusinessProductDao{M: d.M.OrderAsc(column)}
+	return &ProjBusinessProductDao{M: d.M.OrderAsc(column), Table: d.Table, TableAs: d.TableAs}
 }
 
 // OrderDesc sets the "ORDER BY xxx DESC" statement for the model.
 func (d *ProjBusinessProductDao) OrderDesc(column string) *ProjBusinessProductDao {
-	return &ProjBusinessProductDao{M: d.M.OrderDesc(column)}
+	return &ProjBusinessProductDao{M: d.M.OrderDesc(column), Table: d.Table, TableAs: d.TableAs}
 }
 
 // OrderRandom sets the "ORDER BY RANDOM()" statement for the model.
 func (d *ProjBusinessProductDao) OrderRandom() *ProjBusinessProductDao {
-	return &ProjBusinessProductDao{M: d.M.OrderRandom()}
+	return &ProjBusinessProductDao{M: d.M.OrderRandom(), Table: d.Table, TableAs: d.TableAs}
 }
 
 // OrderBy is alias of Model.Order.
 // See Model.Order.
 // Deprecated, use Order instead.
 func (d *ProjBusinessProductDao) OrderBy(orderBy string) *ProjBusinessProductDao {
-	return &ProjBusinessProductDao{M: d.M.Order(orderBy)}
+	return &ProjBusinessProductDao{M: d.M.Order(orderBy), Table: d.Table, TableAs: d.TableAs}
 }
 
 // Limit sets the "LIMIT" statement for the model.
@@ -495,30 +496,30 @@ func (d *ProjBusinessProductDao) OrderBy(orderBy string) *ProjBusinessProductDao
 // it then sets "LIMIT limit[0],limit[1]" statement for the model, or else it sets "LIMIT limit[0]"
 // statement.
 func (d *ProjBusinessProductDao) Limit(limit ...int) *ProjBusinessProductDao {
-	return &ProjBusinessProductDao{M: d.M.Limit(limit...)}
+	return &ProjBusinessProductDao{M: d.M.Limit(limit...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // Offset sets the "OFFSET" statement for the model.
 // It only makes sense for some databases like SQLServer, PostgreSQL, etc.
 func (d *ProjBusinessProductDao) Offset(offset int) *ProjBusinessProductDao {
-	return &ProjBusinessProductDao{M: d.M.Offset(offset)}
+	return &ProjBusinessProductDao{M: d.M.Offset(offset), Table: d.Table, TableAs: d.TableAs}
 }
 
 // Distinct forces the query to only return distinct results.
 func (d *ProjBusinessProductDao) Distinct() *ProjBusinessProductDao {
-	return &ProjBusinessProductDao{M: d.M.Distinct()}
+	return &ProjBusinessProductDao{M: d.M.Distinct(), Table: d.Table, TableAs: d.TableAs}
 }
 
 // Page sets the paging number for the model.
 // The parameter <page> is started from 1 for paging.
 // Note that, it differs that the Limit function start from 0 for "LIMIT" statement.
 func (d *ProjBusinessProductDao) Page(page, limit int) *ProjBusinessProductDao {
-	return &ProjBusinessProductDao{M: d.M.Page(page, limit)}
+	return &ProjBusinessProductDao{M: d.M.Page(page, limit), Table: d.Table, TableAs: d.TableAs}
 }
 
 // Batch sets the batch operation number for the model.
 func (d *ProjBusinessProductDao) Batch(batch int) *ProjBusinessProductDao {
-	return &ProjBusinessProductDao{M: d.M.Batch(batch)}
+	return &ProjBusinessProductDao{M: d.M.Batch(batch), Table: d.Table, TableAs: d.TableAs}
 }
 
 // Cache sets the cache feature for the model. It caches the result of the sql, which means
@@ -534,7 +535,7 @@ func (d *ProjBusinessProductDao) Batch(batch int) *ProjBusinessProductDao {
 //
 // Note that, the cache feature is disabled if the model is operating on a transaction.
 func (d *ProjBusinessProductDao) Cache(duration time.Duration, name ...string) *ProjBusinessProductDao {
-	return &ProjBusinessProductDao{M: d.M.Cache(duration, name...)}
+	return &ProjBusinessProductDao{M: d.M.Cache(duration, name...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // Data sets the operation data for the model.
@@ -545,7 +546,7 @@ func (d *ProjBusinessProductDao) Cache(duration time.Duration, name ...string) *
 // Data(g.Map{"uid": 10000, "name":"john"})
 // Data(g.Slice{g.Map{"uid": 10000, "name":"john"}, g.Map{"uid": 20000, "name":"smith"})
 func (d *ProjBusinessProductDao) Data(data ...interface{}) *ProjBusinessProductDao {
-	return &ProjBusinessProductDao{M: d.M.Data(data...)}
+	return &ProjBusinessProductDao{M: d.M.Data(data...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // All does "SELECT FROM ..." statement for the model.
@@ -690,17 +691,17 @@ func (d *ProjBusinessProductDao) Chunk(limit int, callback func(entities []*mode
 
 // LockUpdate sets the lock for update for current operation.
 func (d *ProjBusinessProductDao) LockUpdate() *ProjBusinessProductDao {
-	return &ProjBusinessProductDao{M: d.M.LockUpdate()}
+	return &ProjBusinessProductDao{M: d.M.LockUpdate(), Table: d.Table, TableAs: d.TableAs}
 }
 
 // LockShared sets the lock in share mode for current operation.
 func (d *ProjBusinessProductDao) LockShared() *ProjBusinessProductDao {
-	return &ProjBusinessProductDao{M: d.M.LockShared()}
+	return &ProjBusinessProductDao{M: d.M.LockShared(), Table: d.Table, TableAs: d.TableAs}
 }
 
 // Unscoped enables/disables the soft deleting feature.
 func (d *ProjBusinessProductDao) Unscoped() *ProjBusinessProductDao {
-	return &ProjBusinessProductDao{M: d.M.Unscoped()}
+	return &ProjBusinessProductDao{M: d.M.Unscoped(), Table: d.Table, TableAs: d.TableAs}
 }
 
 // DataScope enables the DataScope feature.
@@ -722,14 +723,18 @@ func (d *ProjBusinessProductDao) DataScope(ctx context.Context, userCol ...strin
 				dataScope["id"] = userIds
 			}
 		}
+		tableAs := d.TableAs
+		if d.TableAs != "" {
+			tableAs += "."
+		}
 		for k, v := range dataScope {
 			if ok, _ := d.M.HasField(k); ok {
-				columns = append(columns, k+" IN (?) ")
+				columns = append(columns, tableAs+k+" IN (?) ")
 				values = append(values, v)
 			}
 		}
 		whereSql := strings.Join(columns, " OR ")
-		return &ProjBusinessProductDao{M: d.M.Where(whereSql, values).Ctx(ctx)}
+		return &ProjBusinessProductDao{M: d.M.Where(whereSql, values).Ctx(ctx), Table: d.Table, TableAs: d.TableAs}
 	}
 	return d
 }

opms_parent/app/dao/proj/internal/proj_business_team.go

@@ -19,10 +19,11 @@ import (
 
 // ProjBusinessTeamDao is the manager for logic model data accessing and custom defined data operations functions management.
 type ProjBusinessTeamDao struct {
-	gmvc.M                         // M is the core and embedded struct that inherits all chaining operations from gdb.Model.
-	C      projBusinessTeamColumns // C is the short type for Columns, which contains all the column names of Table for convenient usage.
-	DB     gdb.DB                  // DB is the raw underlying database management object.
-	Table  string                  // Table is the underlying table name of the DAO.
+	gmvc.M                          // M is the core and embedded struct that inherits all chaining operations from gdb.Model.
+	C       projBusinessTeamColumns // C is the short type for Columns, which contains all the column names of Table for convenient usage.
+	DB      gdb.DB                  // DB is the raw underlying database management object.
+	Table   string                  // Table is the underlying table name of the DAO.
+	TableAs string                  // TableAs is the underlying table alias name of the DAO.
 }
 
 // ProjBusinessTeamColumns defines and stores column names for table proj_business_team.
@@ -99,7 +100,7 @@ func NewProjBusinessTeamDao(tenant string) ProjBusinessTeamDao {
 // Note that this returned DB object can be used only once, so do not assign it to
 // a global or package variable for long using.
 func (d *ProjBusinessTeamDao) Ctx(ctx context.Context) *ProjBusinessTeamDao {
-	return &ProjBusinessTeamDao{M: d.M.Ctx(ctx)}
+	return &ProjBusinessTeamDao{M: d.M.Ctx(ctx), Table: d.Table, TableAs: d.TableAs}
 }
 
 // GetCtx returns the context for current Model.
@@ -110,34 +111,34 @@ func (d *ProjBusinessTeamDao) GetCtx() context.Context {
 
 // As sets an alias name for current table.
 func (d *ProjBusinessTeamDao) As(as string) *ProjBusinessTeamDao {
-	return &ProjBusinessTeamDao{M: d.M.As(as)}
+	return &ProjBusinessTeamDao{M: d.M.As(as), Table: d.Table, TableAs: as}
 }
 
 // TX sets the transaction for current operation.
 func (d *ProjBusinessTeamDao) TX(tx *gdb.TX) *ProjBusinessTeamDao {
-	return &ProjBusinessTeamDao{M: d.M.TX(tx)}
+	return &ProjBusinessTeamDao{M: d.M.TX(tx), Table: d.Table, TableAs: d.TableAs}
 }
 
 // Master marks the following operation on master node.
 func (d *ProjBusinessTeamDao) Master() *ProjBusinessTeamDao {
-	return &ProjBusinessTeamDao{M: d.M.Master()}
+	return &ProjBusinessTeamDao{M: d.M.Master(), Table: d.Table, TableAs: d.TableAs}
 }
 
 // Slave marks the following operation on slave node.
 // Note that it makes sense only if there's any slave node configured.
 func (d *ProjBusinessTeamDao) Slave() *ProjBusinessTeamDao {
-	return &ProjBusinessTeamDao{M: d.M.Slave()}
+	return &ProjBusinessTeamDao{M: d.M.Slave(), Table: d.Table, TableAs: d.TableAs}
 }
 
 // Args sets custom arguments for model operation.
 func (d *ProjBusinessTeamDao) Args(args ...interface{}) *ProjBusinessTeamDao {
-	return &ProjBusinessTeamDao{M: d.M.Args(args...)}
+	return &ProjBusinessTeamDao{M: d.M.Args(args...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // Handler calls each of "handlers" on current Model and returns a new Model.
 // ModelHandler is a function that handles given Model and returns a new Model that is custom modified.
 func (d *ProjBusinessTeamDao) Handler(handlers ...gdb.ModelHandler) *ProjBusinessTeamDao {
-	return &ProjBusinessTeamDao{M: d.M.Handler(handlers...)}
+	return &ProjBusinessTeamDao{M: d.M.Handler(handlers...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // LeftJoin does "LEFT JOIN ... ON ..." statement on the model.
@@ -146,7 +147,7 @@ func (d *ProjBusinessTeamDao) Handler(handlers ...gdb.ModelHandler) *ProjBusines
 // Table("user").LeftJoin("user_detail", "user_detail.uid=user.uid")
 // Table("user", "u").LeftJoin("user_detail", "ud", "ud.uid=u.uid")
 func (d *ProjBusinessTeamDao) LeftJoin(table ...string) *ProjBusinessTeamDao {
-	return &ProjBusinessTeamDao{M: d.M.LeftJoin(table...)}
+	return &ProjBusinessTeamDao{M: d.M.LeftJoin(table...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // RightJoin does "RIGHT JOIN ... ON ..." statement on the model.
@@ -155,7 +156,7 @@ func (d *ProjBusinessTeamDao) LeftJoin(table ...string) *ProjBusinessTeamDao {
 // Table("user").RightJoin("user_detail", "user_detail.uid=user.uid")
 // Table("user", "u").RightJoin("user_detail", "ud", "ud.uid=u.uid")
 func (d *ProjBusinessTeamDao) RightJoin(table ...string) *ProjBusinessTeamDao {
-	return &ProjBusinessTeamDao{M: d.M.RightJoin(table...)}
+	return &ProjBusinessTeamDao{M: d.M.RightJoin(table...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // InnerJoin does "INNER JOIN ... ON ..." statement on the model.
@@ -164,93 +165,93 @@ func (d *ProjBusinessTeamDao) RightJoin(table ...string) *ProjBusinessTeamDao {
 // Table("user").InnerJoin("user_detail", "user_detail.uid=user.uid")
 // Table("user", "u").InnerJoin("user_detail", "ud", "ud.uid=u.uid")
 func (d *ProjBusinessTeamDao) InnerJoin(table ...string) *ProjBusinessTeamDao {
-	return &ProjBusinessTeamDao{M: d.M.InnerJoin(table...)}
+	return &ProjBusinessTeamDao{M: d.M.InnerJoin(table...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // Fields sets the operation fields of the model, multiple fields joined using char ','.
 // The parameter <fieldNamesOrMapStruct> can be type of string/map/*map/struct/*struct.
 func (d *ProjBusinessTeamDao) Fields(fieldNamesOrMapStruct ...interface{}) *ProjBusinessTeamDao {
-	return &ProjBusinessTeamDao{M: d.M.Fields(fieldNamesOrMapStruct...)}
+	return &ProjBusinessTeamDao{M: d.M.Fields(fieldNamesOrMapStruct...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // FieldsEx sets the excluded operation fields of the model, multiple fields joined using char ','.
 // The parameter <fieldNamesOrMapStruct> can be type of string/map/*map/struct/*struct.
 func (d *ProjBusinessTeamDao) FieldsEx(fieldNamesOrMapStruct ...interface{}) *ProjBusinessTeamDao {
-	return &ProjBusinessTeamDao{M: d.M.FieldsEx(fieldNamesOrMapStruct...)}
+	return &ProjBusinessTeamDao{M: d.M.FieldsEx(fieldNamesOrMapStruct...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // FieldCount formats and appends commonly used field "COUNT(column)" to the select fields of model.
 func (d *ProjBusinessTeamDao) FieldCount(column string, as ...string) *ProjBusinessTeamDao {
-	return &ProjBusinessTeamDao{M: d.M.FieldCount(column, as...)}
+	return &ProjBusinessTeamDao{M: d.M.FieldCount(column, as...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // FieldSum formats and appends commonly used field "SUM(column)" to the select fields of model.
 func (d *ProjBusinessTeamDao) FieldSum(column string, as ...string) *ProjBusinessTeamDao {
-	return &ProjBusinessTeamDao{M: d.M.FieldSum(column, as...)}
+	return &ProjBusinessTeamDao{M: d.M.FieldSum(column, as...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // FieldMin formats and appends commonly used field "MIN(column)" to the select fields of model.
 func (d *ProjBusinessTeamDao) FieldMin(column string, as ...string) *ProjBusinessTeamDao {
-	return &ProjBusinessTeamDao{M: d.M.FieldMin(column, as...)}
+	return &ProjBusinessTeamDao{M: d.M.FieldMin(column, as...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // FieldMax formats and appends commonly used field "MAX(column)" to the select fields of model.
 func (d *ProjBusinessTeamDao) FieldMax(column string, as ...string) *ProjBusinessTeamDao {
-	return &ProjBusinessTeamDao{M: d.M.FieldMax(column, as...)}
+	return &ProjBusinessTeamDao{M: d.M.FieldMax(column, as...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // FieldAvg formats and appends commonly used field "AVG(column)" to the select fields of model.
 func (d *ProjBusinessTeamDao) FieldAvg(column string, as ...string) *ProjBusinessTeamDao {
-	return &ProjBusinessTeamDao{M: d.M.FieldAvg(column, as...)}
+	return &ProjBusinessTeamDao{M: d.M.FieldAvg(column, as...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // Option adds extra operation option for the model.
 // Deprecated, use separate operations instead.
 func (d *ProjBusinessTeamDao) Option(option int) *ProjBusinessTeamDao {
-	return &ProjBusinessTeamDao{M: d.M.Option(option)}
+	return &ProjBusinessTeamDao{M: d.M.Option(option), Table: d.Table, TableAs: d.TableAs}
 }
 
 // OmitEmpty sets OPTION_OMITEMPTY option for the model, which automatically filers
 // the data and where attributes for empty values.
 func (d *ProjBusinessTeamDao) OmitEmpty() *ProjBusinessTeamDao {
-	return &ProjBusinessTeamDao{M: d.M.OmitEmpty()}
+	return &ProjBusinessTeamDao{M: d.M.OmitEmpty(), Table: d.Table, TableAs: d.TableAs}
 }
 
 // OmitEmptyWhere sets optionOmitEmptyWhere option for the model, which automatically filers
 // the Where/Having parameters for "empty" values.
 func (d *ProjBusinessTeamDao) OmitEmptyWhere() *ProjBusinessTeamDao {
-	return &ProjBusinessTeamDao{M: d.M.OmitEmptyWhere()}
+	return &ProjBusinessTeamDao{M: d.M.OmitEmptyWhere(), Table: d.Table, TableAs: d.TableAs}
 }
 
 // OmitEmptyData sets optionOmitEmptyData option for the model, which automatically filers
 // the Data parameters for "empty" values.
 func (d *ProjBusinessTeamDao) OmitEmptyData() *ProjBusinessTeamDao {
-	return &ProjBusinessTeamDao{M: d.M.OmitEmptyData()}
+	return &ProjBusinessTeamDao{M: d.M.OmitEmptyData(), Table: d.Table, TableAs: d.TableAs}
 }
 
 // OmitNil sets optionOmitNil option for the model, which automatically filers
 // the data and where parameters for "nil" values.
 func (d *ProjBusinessTeamDao) OmitNil() *ProjBusinessTeamDao {
-	return &ProjBusinessTeamDao{M: d.M.OmitNil()}
+	return &ProjBusinessTeamDao{M: d.M.OmitNil(), Table: d.Table, TableAs: d.TableAs}
 }
 
 // OmitNilWhere sets optionOmitNilWhere option for the model, which automatically filers
 // the Where/Having parameters for "nil" values.
 func (d *ProjBusinessTeamDao) OmitNilWhere() *ProjBusinessTeamDao {
-	return &ProjBusinessTeamDao{M: d.M.OmitNilWhere()}
+	return &ProjBusinessTeamDao{M: d.M.OmitNilWhere(), Table: d.Table, TableAs: d.TableAs}
 }
 
 // OmitNilData sets optionOmitNilData option for the model, which automatically filers
 // the Data parameters for "nil" values.
 func (d *ProjBusinessTeamDao) OmitNilData() *ProjBusinessTeamDao {
-	return &ProjBusinessTeamDao{M: d.M.OmitNilData()}
+	return &ProjBusinessTeamDao{M: d.M.OmitNilData(), Table: d.Table, TableAs: d.TableAs}
 }
 
 // Filter marks filtering the fields which does not exist in the fields of the operated table.
 // Note that this function supports only single table operations.
 // Deprecated, filter feature is automatically enabled from GoFrame v1.16.0, it is so no longer used.
 func (d *ProjBusinessTeamDao) Filter() *ProjBusinessTeamDao {
-	return &ProjBusinessTeamDao{M: d.M.Filter()}
+	return &ProjBusinessTeamDao{M: d.M.Filter(), Table: d.Table, TableAs: d.TableAs}
 }
 
 // Where sets the condition statement for the model. The parameter <where> can be type of
@@ -265,7 +266,7 @@ func (d *ProjBusinessTeamDao) Filter() *ProjBusinessTeamDao {
 // Where("age IN(?,?)", 18, 50)
 // Where(User{ Id : 1, UserName : "john"})
 func (d *ProjBusinessTeamDao) Where(where interface{}, args ...interface{}) *ProjBusinessTeamDao {
-	return &ProjBusinessTeamDao{M: d.M.Where(where, args...)}
+	return &ProjBusinessTeamDao{M: d.M.Where(where, args...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WherePri does the same logic as M.Where except that if the parameter <where>
@@ -274,205 +275,205 @@ func (d *ProjBusinessTeamDao) Where(where interface{}, args ...interface{}) *Pro
 // WherePri function treats the condition as "id=123", but M.Where treats the condition
 // as string "123".
 func (d *ProjBusinessTeamDao) WherePri(where interface{}, args ...interface{}) *ProjBusinessTeamDao {
-	return &ProjBusinessTeamDao{M: d.M.WherePri(where, args...)}
+	return &ProjBusinessTeamDao{M: d.M.WherePri(where, args...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // Having sets the having statement for the model.
 // The parameters of this function usage are as the same as function Where.
 // See Where.
 func (d *ProjBusinessTeamDao) Having(having interface{}, args ...interface{}) *ProjBusinessTeamDao {
-	return &ProjBusinessTeamDao{M: d.M.Having(having, args...)}
+	return &ProjBusinessTeamDao{M: d.M.Having(having, args...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // Wheref builds condition string using fmt.Sprintf and arguments.
 // Note that if the number of "args" is more than the place holder in "format",
 // the extra "args" will be used as the where condition arguments of the Model.
 func (d *ProjBusinessTeamDao) Wheref(format string, args ...interface{}) *ProjBusinessTeamDao {
-	return &ProjBusinessTeamDao{M: d.M.Wheref(format, args...)}
+	return &ProjBusinessTeamDao{M: d.M.Wheref(format, args...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereLT builds "column < value" statement.
 func (d *ProjBusinessTeamDao) WhereLT(column string, value interface{}) *ProjBusinessTeamDao {
-	return &ProjBusinessTeamDao{M: d.M.WhereLT(column, value)}
+	return &ProjBusinessTeamDao{M: d.M.WhereLT(column, value), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereLTE builds "column <= value" statement.
 func (d *ProjBusinessTeamDao) WhereLTE(column string, value interface{}) *ProjBusinessTeamDao {
-	return &ProjBusinessTeamDao{M: d.M.WhereLTE(column, value)}
+	return &ProjBusinessTeamDao{M: d.M.WhereLTE(column, value), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereGT builds "column > value" statement.
 func (d *ProjBusinessTeamDao) WhereGT(column string, value interface{}) *ProjBusinessTeamDao {
-	return &ProjBusinessTeamDao{M: d.M.WhereGT(column, value)}
+	return &ProjBusinessTeamDao{M: d.M.WhereGT(column, value), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereGTE builds "column >= value" statement.
 func (d *ProjBusinessTeamDao) WhereGTE(column string, value interface{}) *ProjBusinessTeamDao {
-	return &ProjBusinessTeamDao{M: d.M.WhereGTE(column, value)}
+	return &ProjBusinessTeamDao{M: d.M.WhereGTE(column, value), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereBetween builds "column BETWEEN min AND max" statement.
 func (d *ProjBusinessTeamDao) WhereBetween(column string, min, max interface{}) *ProjBusinessTeamDao {
-	return &ProjBusinessTeamDao{M: d.M.WhereBetween(column, min, max)}
+	return &ProjBusinessTeamDao{M: d.M.WhereBetween(column, min, max), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereLike builds "column LIKE like" statement.
 func (d *ProjBusinessTeamDao) WhereLike(column string, like interface{}) *ProjBusinessTeamDao {
-	return &ProjBusinessTeamDao{M: d.M.WhereLike(column, like)}
+	return &ProjBusinessTeamDao{M: d.M.WhereLike(column, like), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereIn builds "column IN (in)" statement.
 func (d *ProjBusinessTeamDao) WhereIn(column string, in interface{}) *ProjBusinessTeamDao {
-	return &ProjBusinessTeamDao{M: d.M.WhereIn(column, in)}
+	return &ProjBusinessTeamDao{M: d.M.WhereIn(column, in), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereNull builds "columns[0] IS NULL AND columns[1] IS NULL ..." statement.
 func (d *ProjBusinessTeamDao) WhereNull(columns ...string) *ProjBusinessTeamDao {
-	return &ProjBusinessTeamDao{M: d.M.WhereNull(columns...)}
+	return &ProjBusinessTeamDao{M: d.M.WhereNull(columns...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereNotBetween builds "column NOT BETWEEN min AND max" statement.
 func (d *ProjBusinessTeamDao) WhereNotBetween(column string, min, max interface{}) *ProjBusinessTeamDao {
-	return &ProjBusinessTeamDao{M: d.M.WhereNotBetween(column, min, max)}
+	return &ProjBusinessTeamDao{M: d.M.WhereNotBetween(column, min, max), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereNotLike builds "column NOT LIKE like" statement.
 func (d *ProjBusinessTeamDao) WhereNotLike(column string, like interface{}) *ProjBusinessTeamDao {
-	return &ProjBusinessTeamDao{M: d.M.WhereNotLike(column, like)}
+	return &ProjBusinessTeamDao{M: d.M.WhereNotLike(column, like), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereNot builds "column != value" statement.
 func (d *ProjBusinessTeamDao) WhereNot(column string, value interface{}) *ProjBusinessTeamDao {
-	return &ProjBusinessTeamDao{M: d.M.WhereNot(column, value)}
+	return &ProjBusinessTeamDao{M: d.M.WhereNot(column, value), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereNotIn builds "column NOT IN (in)" statement.
 func (d *ProjBusinessTeamDao) WhereNotIn(column string, in interface{}) *ProjBusinessTeamDao {
-	return &ProjBusinessTeamDao{M: d.M.WhereNotIn(column, in)}
+	return &ProjBusinessTeamDao{M: d.M.WhereNotIn(column, in), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereNotNull builds "columns[0] IS NOT NULL AND columns[1] IS NOT NULL ..." statement.
 func (d *ProjBusinessTeamDao) WhereNotNull(columns ...string) *ProjBusinessTeamDao {
-	return &ProjBusinessTeamDao{M: d.M.WhereNotNull(columns...)}
+	return &ProjBusinessTeamDao{M: d.M.WhereNotNull(columns...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereOr adds "OR" condition to the where statement.
 func (d *ProjBusinessTeamDao) WhereOr(where interface{}, args ...interface{}) *ProjBusinessTeamDao {
-	return &ProjBusinessTeamDao{M: d.M.WhereOr(where, args...)}
+	return &ProjBusinessTeamDao{M: d.M.WhereOr(where, args...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereOrf builds "OR" condition string using fmt.Sprintf and arguments.
 func (d *ProjBusinessTeamDao) WhereOrf(format string, args ...interface{}) *ProjBusinessTeamDao {
-	return &ProjBusinessTeamDao{M: d.M.WhereOrf(format, args...)}
+	return &ProjBusinessTeamDao{M: d.M.WhereOrf(format, args...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereOrLT builds "column < value" statement in "OR" conditions..
 func (d *ProjBusinessTeamDao) WhereOrLT(column string, value interface{}) *ProjBusinessTeamDao {
-	return &ProjBusinessTeamDao{M: d.M.WhereOrLT(column, value)}
+	return &ProjBusinessTeamDao{M: d.M.WhereOrLT(column, value), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereOrLTE builds "column <= value" statement in "OR" conditions..
 func (d *ProjBusinessTeamDao) WhereOrLTE(column string, value interface{}) *ProjBusinessTeamDao {
-	return &ProjBusinessTeamDao{M: d.M.WhereOrLTE(column, value)}
+	return &ProjBusinessTeamDao{M: d.M.WhereOrLTE(column, value), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereOrGT builds "column > value" statement in "OR" conditions..
 func (d *ProjBusinessTeamDao) WhereOrGT(column string, value interface{}) *ProjBusinessTeamDao {
-	return &ProjBusinessTeamDao{M: d.M.WhereOrGT(column, value)}
+	return &ProjBusinessTeamDao{M: d.M.WhereOrGT(column, value), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereOrGTE builds "column >= value" statement in "OR" conditions..
 func (d *ProjBusinessTeamDao) WhereOrGTE(column string, value interface{}) *ProjBusinessTeamDao {
-	return &ProjBusinessTeamDao{M: d.M.WhereOrGTE(column, value)}
+	return &ProjBusinessTeamDao{M: d.M.WhereOrGTE(column, value), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereOrBetween builds "column BETWEEN min AND max" statement in "OR" conditions.
 func (d *ProjBusinessTeamDao) WhereOrBetween(column string, min, max interface{}) *ProjBusinessTeamDao {
-	return &ProjBusinessTeamDao{M: d.M.WhereOrBetween(column, min, max)}
+	return &ProjBusinessTeamDao{M: d.M.WhereOrBetween(column, min, max), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereOrLike builds "column LIKE like" statement in "OR" conditions.
 func (d *ProjBusinessTeamDao) WhereOrLike(column string, like interface{}) *ProjBusinessTeamDao {
-	return &ProjBusinessTeamDao{M: d.M.WhereOrLike(column, like)}
+	return &ProjBusinessTeamDao{M: d.M.WhereOrLike(column, like), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereOrIn builds "column IN (in)" statement in "OR" conditions.
 func (d *ProjBusinessTeamDao) WhereOrIn(column string, in interface{}) *ProjBusinessTeamDao {
-	return &ProjBusinessTeamDao{M: d.M.WhereOrIn(column, in)}
+	return &ProjBusinessTeamDao{M: d.M.WhereOrIn(column, in), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereOrNull builds "columns[0] IS NULL OR columns[1] IS NULL ..." statement in "OR" conditions.
 func (d *ProjBusinessTeamDao) WhereOrNull(columns ...string) *ProjBusinessTeamDao {
-	return &ProjBusinessTeamDao{M: d.M.WhereOrNull(columns...)}
+	return &ProjBusinessTeamDao{M: d.M.WhereOrNull(columns...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereOrNotBetween builds "column NOT BETWEEN min AND max" statement in "OR" conditions.
 func (d *ProjBusinessTeamDao) WhereOrNotBetween(column string, min, max interface{}) *ProjBusinessTeamDao {
-	return &ProjBusinessTeamDao{M: d.M.WhereOrNotBetween(column, min, max)}
+	return &ProjBusinessTeamDao{M: d.M.WhereOrNotBetween(column, min, max), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereOrNotLike builds "column NOT LIKE like" statement in "OR" conditions.
 func (d *ProjBusinessTeamDao) WhereOrNotLike(column string, like interface{}) *ProjBusinessTeamDao {
-	return &ProjBusinessTeamDao{M: d.M.WhereOrNotLike(column, like)}
+	return &ProjBusinessTeamDao{M: d.M.WhereOrNotLike(column, like), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereOrNotIn builds "column NOT IN (in)" statement.
 func (d *ProjBusinessTeamDao) WhereOrNotIn(column string, in interface{}) *ProjBusinessTeamDao {
-	return &ProjBusinessTeamDao{M: d.M.WhereOrNotIn(column, in)}
+	return &ProjBusinessTeamDao{M: d.M.WhereOrNotIn(column, in), Table: d.Table, TableAs: d.TableAs}
 }
 
 // WhereOrNotNull builds "columns[0] IS NOT NULL OR columns[1] IS NOT NULL ..." statement in "OR" conditions.
 func (d *ProjBusinessTeamDao) WhereOrNotNull(columns ...string) *ProjBusinessTeamDao {
-	return &ProjBusinessTeamDao{M: d.M.WhereOrNotNull(columns...)}
+	return &ProjBusinessTeamDao{M: d.M.WhereOrNotNull(columns...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // Group sets the "GROUP BY" statement for the model.
 func (d *ProjBusinessTeamDao) Group(groupBy ...string) *ProjBusinessTeamDao {
-	return &ProjBusinessTeamDao{M: d.M.Group(groupBy...)}
+	return &ProjBusinessTeamDao{M: d.M.Group(groupBy...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // And adds "AND" condition to the where statement.
 // Deprecated, use Where instead.
 func (d *ProjBusinessTeamDao) And(where interface{}, args ...interface{}) *ProjBusinessTeamDao {
-	return &ProjBusinessTeamDao{M: d.M.And(where, args...)}
+	return &ProjBusinessTeamDao{M: d.M.And(where, args...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // Or adds "OR" condition to the where statement.
 // Deprecated, use WhereOr instead.
 func (d *ProjBusinessTeamDao) Or(where interface{}, args ...interface{}) *ProjBusinessTeamDao {
-	return &ProjBusinessTeamDao{M: d.M.Or(where, args...)}
+	return &ProjBusinessTeamDao{M: d.M.Or(where, args...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // GroupBy sets the "GROUP BY" statement for the model.
 func (d *ProjBusinessTeamDao) GroupBy(groupBy string) *ProjBusinessTeamDao {
-	return &ProjBusinessTeamDao{M: d.M.Group(groupBy)}
+	return &ProjBusinessTeamDao{M: d.M.Group(groupBy), Table: d.Table, TableAs: d.TableAs}
 }
 
 // Order sets the "ORDER BY" statement for the model.
 func (d *ProjBusinessTeamDao) Order(orderBy ...string) *ProjBusinessTeamDao {
-	return &ProjBusinessTeamDao{M: d.M.Order(orderBy...)}
+	return &ProjBusinessTeamDao{M: d.M.Order(orderBy...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // OrderAsc sets the "ORDER BY xxx ASC" statement for the model.
 func (d *ProjBusinessTeamDao) OrderAsc(column string) *ProjBusinessTeamDao {
-	return &ProjBusinessTeamDao{M: d.M.OrderAsc(column)}
+	return &ProjBusinessTeamDao{M: d.M.OrderAsc(column), Table: d.Table, TableAs: d.TableAs}
 }
 
 // OrderDesc sets the "ORDER BY xxx DESC" statement for the model.
 func (d *ProjBusinessTeamDao) OrderDesc(column string) *ProjBusinessTeamDao {
-	return &ProjBusinessTeamDao{M: d.M.OrderDesc(column)}
+	return &ProjBusinessTeamDao{M: d.M.OrderDesc(column), Table: d.Table, TableAs: d.TableAs}
 }
 
 // OrderRandom sets the "ORDER BY RANDOM()" statement for the model.
 func (d *ProjBusinessTeamDao) OrderRandom() *ProjBusinessTeamDao {
-	return &ProjBusinessTeamDao{M: d.M.OrderRandom()}
+	return &ProjBusinessTeamDao{M: d.M.OrderRandom(), Table: d.Table, TableAs: d.TableAs}
 }
 
 // OrderBy is alias of Model.Order.
 // See Model.Order.
 // Deprecated, use Order instead.
 func (d *ProjBusinessTeamDao) OrderBy(orderBy string) *ProjBusinessTeamDao {
-	return &ProjBusinessTeamDao{M: d.M.Order(orderBy)}
+	return &ProjBusinessTeamDao{M: d.M.Order(orderBy), Table: d.Table, TableAs: d.TableAs}
 }
 
 // Limit sets the "LIMIT" statement for the model.
@@ -480,30 +481,30 @@ func (d *ProjBusinessTeamDao) OrderBy(orderBy string) *ProjBusinessTeamDao {
 // it then sets "LIMIT limit[0],limit[1]" statement for the model, or else it sets "LIMIT limit[0]"
 // statement.
 func (d *ProjBusinessTeamDao) Limit(limit ...int) *ProjBusinessTeamDao {
-	return &ProjBusinessTeamDao{M: d.M.Limit(limit...)}
+	return &ProjBusinessTeamDao{M: d.M.Limit(limit...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // Offset sets the "OFFSET" statement for the model.
 // It only makes sense for some databases like SQLServer, PostgreSQL, etc.
 func (d *ProjBusinessTeamDao) Offset(offset int) *ProjBusinessTeamDao {
-	return &ProjBusinessTeamDao{M: d.M.Offset(offset)}
+	return &ProjBusinessTeamDao{M: d.M.Offset(offset), Table: d.Table, TableAs: d.TableAs}
 }
 
 // Distinct forces the query to only return distinct results.
 func (d *ProjBusinessTeamDao) Distinct() *ProjBusinessTeamDao {
-	return &ProjBusinessTeamDao{M: d.M.Distinct()}
+	return &ProjBusinessTeamDao{M: d.M.Distinct(), Table: d.Table, TableAs: d.TableAs}
 }
 
 // Page sets the paging number for the model.
 // The parameter <page> is started from 1 for paging.
 // Note that, it differs that the Limit function start from 0 for "LIMIT" statement.
 func (d *ProjBusinessTeamDao) Page(page, limit int) *ProjBusinessTeamDao {
-	return &ProjBusinessTeamDao{M: d.M.Page(page, limit)}
+	return &ProjBusinessTeamDao{M: d.M.Page(page, limit), Table: d.Table, TableAs: d.TableAs}
 }
 
 // Batch sets the batch operation number for the model.
 func (d *ProjBusinessTeamDao) Batch(batch int) *ProjBusinessTeamDao {
-	return &ProjBusinessTeamDao{M: d.M.Batch(batch)}
+	return &ProjBusinessTeamDao{M: d.M.Batch(batch), Table: d.Table, TableAs: d.TableAs}
 }
 
 // Cache sets the cache feature for the model. It caches the result of the sql, which means
@@ -519,7 +520,7 @@ func (d *ProjBusinessTeamDao) Batch(batch int) *ProjBusinessTeamDao {
 //
 // Note that, the cache feature is disabled if the model is operating on a transaction.
 func (d *ProjBusinessTeamDao) Cache(duration time.Duration, name ...string) *ProjBusinessTeamDao {
-	return &ProjBusinessTeamDao{M: d.M.Cache(duration, name...)}
+	return &ProjBusinessTeamDao{M: d.M.Cache(duration, name...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // Data sets the operation data for the model.
@@ -530,7 +531,7 @@ func (d *ProjBusinessTeamDao) Cache(duration time.Duration, name ...string) *Pro
 // Data(g.Map{"uid": 10000, "name":"john"})
 // Data(g.Slice{g.Map{"uid": 10000, "name":"john"}, g.Map{"uid": 20000, "name":"smith"})
 func (d *ProjBusinessTeamDao) Data(data ...interface{}) *ProjBusinessTeamDao {
-	return &ProjBusinessTeamDao{M: d.M.Data(data...)}
+	return &ProjBusinessTeamDao{M: d.M.Data(data...), Table: d.Table, TableAs: d.TableAs}
 }
 
 // All does "SELECT FROM ..." statement for the model.
@@ -675,17 +676,17 @@ func (d *ProjBusinessTeamDao) Chunk(limit int, callback func(entities []*model.P
 
 // LockUpdate sets the lock for update for current operation.
 func (d *ProjBusinessTeamDao) LockUpdate() *ProjBusinessTeamDao {
-	return &ProjBusinessTeamDao{M: d.M.LockUpdate()}
+	return &ProjBusinessTeamDao{M: d.M.LockUpdate(), Table: d.Table, TableAs: d.TableAs}
 }
 
 // LockShared sets the lock in share mode for current operation.
 func (d *ProjBusinessTeamDao) LockShared() *ProjBusinessTeamDao {
-	return &ProjBusinessTeamDao{M: d.M.LockShared()}
+	return &ProjBusinessTeamDao{M: d.M.LockShared(), Table: d.Table, TableAs: d.TableAs}
 }
 
 // Unscoped enables/disables the soft deleting feature.
 func (d *ProjBusinessTeamDao) Unscoped() *ProjBusinessTeamDao {
-	return &ProjBusinessTeamDao{M: d.M.Unscoped()}
+	return &ProjBusinessTeamDao{M: d.M.Unscoped(), Table: d.Table, TableAs: d.TableAs}
 }
 
 // DataScope enables the DataScope feature.
@@ -707,14 +708,18 @@ func (d *ProjBusinessTeamDao) DataScope(ctx context.Context, userCol ...string)
 				dataScope["id"] = userIds
 			}
 		}
+		tableAs := d.TableAs
+		if d.TableAs != "" {
+			tableAs += "."
+		}
 		for k, v := range dataScope {
 			if ok, _ := d.M.HasField(k); ok {
-				columns = append(columns, k+" IN (?) ")
+				columns = append(columns, tableAs+k+" IN (?) ")
 				values = append(values, v)
 			}
 		}
 		whereSql := strings.Join(columns, " OR ")
-		return &ProjBusinessTeamDao{M: d.M.Where(whereSql, values).Ctx(ctx)}
+		return &ProjBusinessTeamDao{M: d.M.Where(whereSql, values).Ctx(ctx), Table: d.Table, TableAs: d.TableAs}
 	}
 	return d
 }

opms_parent/app/handler/sysreport/sys_report.go

@@ -13,7 +13,6 @@ type SysReportHandler struct{}
 
 // Swagger:Report 报表,测试tag 获取报表列表
 func (c *SysReportHandler) GetList(ctx context.Context, req *sys_report.SysReportListReq, rsp *comm_def.CommonMsg) error {
-	g.Log().Infof("SysReportHandler.List request %#v ", *req)
 	s, err := service.NewSysReportService(ctx)
 	if err != nil {
 		return err
@@ -28,7 +27,6 @@ func (c *SysReportHandler) GetList(ctx context.Context, req *sys_report.SysRepor
 
 // Swagger:Report 报表,测试tag 添加数据
 func (c *SysReportHandler) Create(ctx context.Context, req *sys_report.SysReport, rsp *comm_def.CommonMsg) error {
-	g.Log().Infof("SysReportHandler.Add request %#v ", *req)
 	s, err := service.NewSysReportService(ctx)
 	if err != nil {
 		return err
@@ -40,7 +38,6 @@ func (c *SysReportHandler) Create(ctx context.Context, req *sys_report.SysReport
 
 // Swagger:Report 报表,测试tag 更新数据
 func (c *SysReportHandler) UpdateById(ctx context.Context, req *sys_report.SysReport, rsp *comm_def.CommonMsg) error {
-	g.Log().Infof("SysReportHandler.Update request %#v ", *req)
 	s, err := service.NewSysReportService(ctx)
 	if err != nil {
 		return err
@@ -52,7 +49,6 @@ func (c *SysReportHandler) UpdateById(ctx context.Context, req *sys_report.SysRe
 
 // Swagger:Report 报表,测试tag 删除数据
 func (c *SysReportHandler) DeleteByIds(ctx context.Context, req *sys_report.IdsReq, rsp *comm_def.CommonMsg) error {
-	g.Log().Infof("SysReportHandler.Delete request %#v ", *req)
 	s, err := service.NewSysReportService(ctx)
 	if err != nil {
 		return err
@@ -66,7 +62,6 @@ func (c *SysReportHandler) DeleteByIds(ctx context.Context, req *sys_report.IdsR
 
 // Swagger:Report 报表,测试tag 数据详情
 func (c *SysReportHandler) GetEntityById(ctx context.Context, req *model.IdRequiredReq, rsp *comm_def.CommonMsg) error {
-	g.Log().Infof("SysReportHandler.Get request %#v ", *req)
 	s, err := service.NewSysReportService(ctx)
 	if err != nil {
 		return err

opms_parent/app/model/cust/cust_customer_contact.go

@@ -39,8 +39,9 @@ type UpdateCustCustomerContactSeq struct {
 
 // 客户联系人信息
 type ContactSeq struct {
-	CustId   int    ` p:"custId"  json:"custId"      v:"required#custId不能为空" `
-	CuctName string ` p:"cuctName"  json:"cuctName"       `
+	CustId     int    `p:"custId"  json:"custId"      v:"required#custId不能为空" `
+	CuctName   string `p:"cuctName"  json:"cuctName"       `
+	IsDecision string `p:"isDecision"  json:"isDecision"` // 关键决策人(10是20否)
 	request.PageReq
 }
 

opms_parent/app/model/proj/proj_business.go

@@ -109,6 +109,9 @@ type BusinessUpgradeReq struct {
 	ProductSatisfaction       string      `json:"productSatisfaction"`           // 产品/方案满足情况
 	PurchasingWay             string      `json:"purchasingWay"`                 // 采购方式
 	PurchasingTime            *gtime.Time `json:"purchasingTime"`                // 采购时间
+	MakerId                   int         `json:"makerId"`                       // 关联决策人
+	MakerName                 string      `json:"makerName"`                     // 决策人姓名
+	MakerDept                 string      `json:"makerDept"`                     // 决策人部门
 	IsAdoptDashoo             string      `json:"isAdoptDashoo"`                 // 是否采纳大数技术参数（上传附件）
 	HistoricalTransactionInfo string      `json:"historicalTransactionInfo"`     // 经销商与客户历史成交信息
 	DealerSalesId             int         `json:"dealerSalesId"`                 // 关联经销商销售

opms_parent/app/service/cust/cust_customer_contact.go

@@ -76,7 +76,9 @@ func (s *CustomercontactService) UpdateById(req *model.UpdateCustCustomerContact
 // 获取联系人信息
 func (s *CustomercontactService) GetList(req *model.ContactSeq) (total int, list []*model.CustCustomerContactInfo, err error) {
 	contactDao := s.Dao.M.Where("cust_id = ", req.CustId)
-
+	if req.IsDecision != "" {
+		contactDao = contactDao.Where("is_decision", req.IsDecision)
+	}
 	if req.CuctName != "" {
 		contactDao = contactDao.Where("cuct_name "+" like ?", "%"+req.CuctName+"%")
 	}

opms_parent/app/service/home/home.go

@@ -2,11 +2,18 @@ package home
 
 import (
 	"context"
+	contDao "dashoo.cn/micro/app/dao/contract"
+	custDao "dashoo.cn/micro/app/dao/cust"
+	platDao "dashoo.cn/micro/app/dao/plat"
+	projDao "dashoo.cn/micro/app/dao/proj"
 	"dashoo.cn/micro/app/model/home"
 	"dashoo.cn/micro/app/model/plat"
 	"dashoo.cn/micro/app/service"
 	server "dashoo.cn/micro/app/service/plat"
+	projSrv "dashoo.cn/micro/app/service/proj"
 	"encoding/json"
+	"fmt"
+	"github.com/gogf/gf/os/gtime"
 	"github.com/gogf/gf/util/gconv"
 )
 
@@ -46,7 +53,8 @@ func (s *HomeService) QueryHomeReportConfig(moduleCode string) (config *plat.Pla
 }
 
 func (s *HomeService) QueryHomeNumReportData(param *home.SearchNumReportData) (resp *home.NumReportResponses, err error) {
-	numConfig := make([]*home.NumReportResponse, len(param.ReportId))
+	resp = new(home.NumReportResponses)
+	numConfig := make([]*home.NumReportResponse, 0)
 	for _, v := range param.ReportId {
 		numReport := new(home.NumReportResponse)
 		numReport.Id = v
@@ -56,7 +64,6 @@ func (s *HomeService) QueryHomeNumReportData(param *home.SearchNumReportData) (r
 	}
 
 	resp.NumReportResponse = numConfig
-
 	return
 }
 
@@ -76,9 +83,9 @@ func (s *HomeService) QueryHomeDataReportData(param *home.SearchDataReportData)
 // 20000-30000之间：报表数据 TODO 疑似与 sys_report 表对应？
 func (s *HomeService) getReportData(id int64, params *map[string]interface{}) (interface{}, error) {
 	switch id {
-	case 10000:
-		// 个人看板数据
-		return nil, nil
+	case 10000, 10001, 10002, 10003, 10004, 10005, 10006, 10007, 10008, 10009, 10010, 10011, 10012, 10013, 10014, 10015, 10016:
+		// 获取数值指标统计数据
+		return s.getNumStatisticsData(id, params)
 	case 20000:
 		// 报表数据   个人销售金额
 		return getPersonalContractReportData(s.ContextService.Ctx, "CONTRACT", params)
@@ -95,3 +102,94 @@ func (s *HomeService) getReportData(id int64, params *map[string]interface{}) (i
 		return nil, nil
 	}
 }
+
+// 获取数值指标统计数据
+func (s *HomeService) getNumStatisticsData(id int64, params *map[string]interface{}) (string, error) {
+	customerDao := custDao.NewCustCustomerDao(s.Tenant)
+	businessDao := projDao.NewProjBusinessDao(s.Tenant)
+	busDynamicsDao := projDao.NewProjBusinessDynamicsDao(s.Tenant)
+	contractDao := contDao.NewCtrContractDao(s.Tenant)
+	collectionPlanDao := contDao.NewCtrContractCollectionPlanDao(s.Tenant)
+	taskDao := platDao.NewPlatTaskDao(s.Tenant)
+	currentTime := gtime.Now()
+	monthStart := currentTime.StartOfMonth()
+	monthEnd := currentTime.EndOfMonth()
+	yearStart := currentTime.StartOfYear()
+	yearEnd := currentTime.EndOfYear()
+
+	switch id {
+	case 10001: //当前客户数量（维度：总数）
+		count, err := customerDao.DataScope(s.Ctx, "sales_id").CountColumn("id")
+		return gconv.String(count), err
+
+	case 10002: //当前项目数量（维度：总数）
+		count, err := businessDao.DataScope(s.Ctx, "sale_id").CountColumn("id")
+		return gconv.String(count), err
+
+	case 10003: //当前合同数量（维度：总数）
+		count, err := contractDao.DataScope(s.Ctx, "incharge_id").CountColumn("id")
+		return gconv.String(count), err
+
+	case 10004: //当月新增客户数量（维度：月）
+		count, err := customerDao.DataScope(s.Ctx, "sales_id").WhereGTE(customerDao.C.CreatedTime, monthStart).WhereLTE(customerDao.C.CreatedTime, monthEnd).Count("id")
+		return gconv.String(count), err
+
+	case 10005: //当月新增项目数量（维度：月）
+		count, err := businessDao.DataScope(s.Ctx, "sale_id").WhereGTE(businessDao.C.CreatedTime, monthStart).WhereLTE(businessDao.C.CreatedTime, monthEnd).Count("id")
+		return gconv.String(count), err
+
+	case 10006: //当月新增合同数量（维度：月）
+		count, err := contractDao.DataScope(s.Ctx, "incharge_id").WhereGTE(contractDao.C.CreatedTime, monthStart).WhereLTE(contractDao.C.CreatedTime, monthEnd).Count("id")
+		return gconv.String(count), err
+
+	case 10007: //当月签约合同金额（维度：月）
+		count, err := contractDao.DataScope(s.Ctx, "incharge_id").WhereGTE(contractDao.C.CreatedTime, monthStart).WhereLTE(contractDao.C.CreatedTime, monthEnd).
+			Sum(contractDao.C.ContractAmount)
+		return gconv.String(count), err
+
+	case 10008: //当月回款金额（维度：月）
+		count, err := contractDao.DataScope(s.Ctx, "incharge_id").WhereGTE(contractDao.C.CreatedTime, monthStart).WhereLTE(contractDao.C.CreatedTime, monthEnd).
+			Sum(contractDao.C.CollectedAmount)
+		return gconv.String(count), err
+
+	case 10009: //当年的签约金额（维度：年）
+		count, err := contractDao.DataScope(s.Ctx, "incharge_id").WhereGTE(contractDao.C.CreatedTime, yearStart).WhereLTE(contractDao.C.CreatedTime, yearEnd).
+			Sum(contractDao.C.ContractAmount)
+		return gconv.String(count), err
+
+	case 10010: //当年的回款金额（维度：年）
+		count, err := contractDao.DataScope(s.Ctx, "incharge_id").WhereGTE(contractDao.C.CreatedTime, yearStart).WhereLTE(contractDao.C.CreatedTime, yearEnd).
+			Sum(contractDao.C.CollectedAmount)
+		return gconv.String(count), err
+
+	case 10011: //我发起的督办
+		count, err := taskDao.Where(taskDao.C.CreatedBy, s.GetCxtUserId()).CountColumn("id")
+		return gconv.String(count), err
+
+	case 10012: //我处理的督办
+		count, err := taskDao.As("task").InnerJoin("plat_task_handle", "handle", "handle.task_id=task.id").
+			Where(fmt.Sprintf("handle.task_status='20' AND handle.handle_user_id=%v", s.GetCxtUserId())).CountColumn("task.id")
+		return gconv.String(count), err
+
+	case 10013: //当月项目转化数量（升级）
+		count, err := busDynamicsDao.LeftJoin(businessDao.Table, "bus", "bus.id=proj_business_dynamics.bus_id").
+			WhereGTE("proj_business_dynamics."+busDynamicsDao.C.CreatedTime, monthStart).WhereLTE("proj_business_dynamics."+busDynamicsDao.C.CreatedTime, monthEnd).
+			Where(busDynamicsDao.C.OpnType, projSrv.OpnDowngradeApproval).
+			Fields(busDynamicsDao.C.BusId).DataScope(s.Ctx, "sale_id").Distinct().Count()
+		return gconv.String(count), err
+
+	case 10014: //计划回款金额
+		count, err := collectionPlanDao.LeftJoin(contractDao.Table, "contract", "contract.id=ctr_contract_collection_plan.contract_id").
+			DataScope(s.Ctx, "incharge_id").Sum(collectionPlanDao.C.PlanAmount)
+		return gconv.String(count), err
+
+	case 10015: //未开票金额
+		count, err := contractDao.DataScope(s.Ctx, "incharge_id").Sum(contractDao.C.ContractAmount + " - " + contractDao.C.InvoiceAmount)
+		return gconv.String(count), err
+
+	case 10016: //未回款金额
+		count, err := contractDao.DataScope(s.Ctx, "incharge_id").Sum(contractDao.C.ContractAmount + " - " + contractDao.C.CollectedAmount)
+		return gconv.String(count), err
+	}
+	return "", nil
+}