重构提取逻辑，新增 area 表

web/queries/edge.gen.go

@@ -37,11 +37,20 @@ func newEdge(db *gorm.DB, opts ...gen.DOOption) edge {
 	_edge.IP = field.NewField(tableName, "ip")
 	_edge.Port = field.NewUint16(tableName, "port")
 	_edge.ISP = field.NewInt(tableName, "isp")
-	_edge.Prov = field.NewString(tableName, "prov")
-	_edge.City = field.NewString(tableName, "city")
+	_edge.AreaID = field.NewInt32(tableName, "area_id")
 	_edge.Status = field.NewInt(tableName, "status")
 	_edge.RTT = field.NewInt32(tableName, "rtt")
 	_edge.Loss = field.NewInt32(tableName, "loss")
+	_edge.Area = edgeBelongsToArea{
+		db: db.Session(&gorm.Session{}),
+
+		RelationField: field.NewRelation("Area", "models.Area"),
+		Parent: struct {
+			field.RelationField
+		}{
+			RelationField: field.NewRelation("Area.Parent", "models.Area"),
+		},
+	}
 
 	_edge.fillFieldMap()
 
@@ -62,11 +71,11 @@ type edge struct {
 	IP        field.Field
 	Port      field.Uint16
 	ISP       field.Int
-	Prov      field.String
-	City      field.String
+	AreaID    field.Int32
 	Status    field.Int
 	RTT       field.Int32
 	Loss      field.Int32
+	Area      edgeBelongsToArea
 
 	fieldMap map[string]field.Expr
 }
@@ -93,8 +102,7 @@ func (e *edge) updateTableName(table string) *edge {
 	e.IP = field.NewField(table, "ip")
 	e.Port = field.NewUint16(table, "port")
 	e.ISP = field.NewInt(table, "isp")
-	e.Prov = field.NewString(table, "prov")
-	e.City = field.NewString(table, "city")
+	e.AreaID = field.NewInt32(table, "area_id")
 	e.Status = field.NewInt(table, "status")
 	e.RTT = field.NewInt32(table, "rtt")
 	e.Loss = field.NewInt32(table, "loss")
@@ -125,23 +133,111 @@ func (e *edge) fillFieldMap() {
 	e.fieldMap["ip"] = e.IP
 	e.fieldMap["port"] = e.Port
 	e.fieldMap["isp"] = e.ISP
-	e.fieldMap["prov"] = e.Prov
-	e.fieldMap["city"] = e.City
+	e.fieldMap["area_id"] = e.AreaID
 	e.fieldMap["status"] = e.Status
 	e.fieldMap["rtt"] = e.RTT
 	e.fieldMap["loss"] = e.Loss
+
 }
 
 func (e edge) clone(db *gorm.DB) edge {
 	e.edgeDo.ReplaceConnPool(db.Statement.ConnPool)
+	e.Area.db = db.Session(&gorm.Session{Initialized: true})
+	e.Area.db.Statement.ConnPool = db.Statement.ConnPool
 	return e
 }
 
 func (e edge) replaceDB(db *gorm.DB) edge {
 	e.edgeDo.ReplaceDB(db)
+	e.Area.db = db.Session(&gorm.Session{})
 	return e
 }
 
+type edgeBelongsToArea struct {
+	db *gorm.DB
+
+	field.RelationField
+
+	Parent struct {
+		field.RelationField
+	}
+}
+
+func (a edgeBelongsToArea) Where(conds ...field.Expr) *edgeBelongsToArea {
+	if len(conds) == 0 {
+		return &a
+	}
+
+	exprs := make([]clause.Expression, 0, len(conds))
+	for _, cond := range conds {
+		exprs = append(exprs, cond.BeCond().(clause.Expression))
+	}
+	a.db = a.db.Clauses(clause.Where{Exprs: exprs})
+	return &a
+}
+
+func (a edgeBelongsToArea) WithContext(ctx context.Context) *edgeBelongsToArea {
+	a.db = a.db.WithContext(ctx)
+	return &a
+}
+
+func (a edgeBelongsToArea) Session(session *gorm.Session) *edgeBelongsToArea {
+	a.db = a.db.Session(session)
+	return &a
+}
+
+func (a edgeBelongsToArea) Model(m *models.Edge) *edgeBelongsToAreaTx {
+	return &edgeBelongsToAreaTx{a.db.Model(m).Association(a.Name())}
+}
+
+func (a edgeBelongsToArea) Unscoped() *edgeBelongsToArea {
+	a.db = a.db.Unscoped()
+	return &a
+}
+
+type edgeBelongsToAreaTx struct{ tx *gorm.Association }
+
+func (a edgeBelongsToAreaTx) Find() (result *models.Area, err error) {
+	return result, a.tx.Find(&result)
+}
+
+func (a edgeBelongsToAreaTx) Append(values ...*models.Area) (err error) {
+	targetValues := make([]interface{}, len(values))
+	for i, v := range values {
+		targetValues[i] = v
+	}
+	return a.tx.Append(targetValues...)
+}
+
+func (a edgeBelongsToAreaTx) Replace(values ...*models.Area) (err error) {
+	targetValues := make([]interface{}, len(values))
+	for i, v := range values {
+		targetValues[i] = v
+	}
+	return a.tx.Replace(targetValues...)
+}
+
+func (a edgeBelongsToAreaTx) Delete(values ...*models.Area) (err error) {
+	targetValues := make([]interface{}, len(values))
+	for i, v := range values {
+		targetValues[i] = v
+	}
+	return a.tx.Delete(targetValues...)
+}
+
+func (a edgeBelongsToAreaTx) Clear() error {
+	return a.tx.Clear()
+}
+
+func (a edgeBelongsToAreaTx) Count() int64 {
+	return a.tx.Count()
+}
+
+func (a edgeBelongsToAreaTx) Unscoped() *edgeBelongsToAreaTx {
+	a.tx = a.tx.Unscoped()
+	return &a
+}
+
 type edgeDo struct{ gen.DO }
 
 func (e edgeDo) Debug() *edgeDo {