Merge pull request #8677 from swordqiu/hotfix/qj-fix-order-by-extra-fields-missing-columns-error

fix: missing column error when order by extra fields

pkg/cloudcommon/db/orderby.go

@@ -29,7 +29,7 @@ func OrderByFields(q *sqlchemy.SQuery, fieldOrders []string, fields []sqlchemy.I
 	for i := range fields {
 		if sqlchemy.SQL_ORDER_ASC.Equals(fieldOrders[i]) {
 			q = q.Asc(fields[i])
-		} else {
+		} else if sqlchemy.SQL_ORDER_DESC.Equals(fieldOrders[i]) {
 			q = q.Desc(fields[i])
 		}
 	}

pkg/compute/models/cloudregionresource.go

@@ -119,10 +119,14 @@ func (manager *SCloudregionResourceBaseManager) OrderByExtraFields(
 	userCred mcclient.TokenCredential,
 	query api.RegionalFilterListInput,
 ) (*sqlchemy.SQuery, error) {
-	q, orders, fields := manager.GetOrderBySubQuery(q, userCred, query)
-	if len(orders) > 0 {
-		q = db.OrderByFields(q, orders, fields)
+	if !db.NeedOrderQuery(manager.GetOrderByFields(query)) {
+		return q, nil
 	}
+	orderQ := CloudregionManager.Query("id")
+	orderSubQ := orderQ.SubQuery()
+	orderQ, orders, fields := manager.GetOrderBySubQuery(orderQ, orderSubQ, orderQ.Field("id"), userCred, query, nil, nil)
+	q = q.LeftJoin(orderSubQ, sqlchemy.Equals(q.Field("cloudregion_id"), orderSubQ.Field("id")))
+	q = db.OrderByFields(q, orders, fields)
 	return q, nil
 }
 
@@ -139,18 +143,22 @@ func (manager *SCloudregionResourceBaseManager) QueryDistinctExtraField(q *sqlch
 
 func (manager *SCloudregionResourceBaseManager) GetOrderBySubQuery(
 	q *sqlchemy.SQuery,
+	subq *sqlchemy.SSubQuery,
+	subqField sqlchemy.IQueryField,
 	userCred mcclient.TokenCredential,
 	query api.RegionalFilterListInput,
+	orders []string,
+	fields []sqlchemy.IQueryField,
 ) (*sqlchemy.SQuery, []string, []sqlchemy.IQueryField) {
-	regionQ := CloudregionManager.Query("id", "name", "city")
-	var orders []string
-	var fields []sqlchemy.IQueryField
-	if db.NeedOrderQuery(manager.GetOrderByFields(query)) {
-		subq := regionQ.SubQuery()
-		q = q.LeftJoin(subq, sqlchemy.Equals(q.Field("cloudregion_id"), subq.Field("id")))
-		orders = append(orders, query.OrderByRegion, query.OrderByCity)
-		fields = append(fields, subq.Field("name"), subq.Field("city"))
+	if !db.NeedOrderQuery(manager.GetOrderByFields(query)) {
+		return q, orders, fields
 	}
+	regions := CloudregionManager.Query().SubQuery()
+	q = q.LeftJoin(regions, sqlchemy.Equals(subqField, regions.Field("id")))
+	q = q.AppendField(regions.Field("name").Label("region"))
+	q = q.AppendField(regions.Field("city"))
+	orders = append(orders, query.OrderByRegion, query.OrderByCity)
+	fields = append(fields, subq.Field("region"), subq.Field("city"))
 	return q, orders, fields
 }
 

pkg/compute/models/dbinstanceresource.go

@@ -179,39 +179,35 @@ func (manager *SDBInstanceResourceBaseManager) OrderByExtraFields(
 	userCred mcclient.TokenCredential,
 	query api.DBInstanceFilterListInput,
 ) (*sqlchemy.SQuery, error) {
-	q, orders, fields := manager.GetOrderBySubQuery(q, userCred, query)
-	if len(orders) > 0 {
-		q = db.OrderByFields(q, orders, fields)
+	if !db.NeedOrderQuery(manager.GetOrderByFields(query)) {
+		return q, nil
 	}
+	orderQ := DBInstanceManager.Query("id")
+	orderSubQ := orderQ.SubQuery()
+	orderQ, orders, fields := manager.GetOrderBySubQuery(orderQ, orderSubQ, orderQ.Field("id"), userCred, query, nil, nil)
+	q = q.LeftJoin(orderSubQ, sqlchemy.Equals(q.Field("dbinstance_id"), orderSubQ.Field("id")))
+	q = db.OrderByFields(q, orders, fields)
 	return q, nil
 }
 
 func (manager *SDBInstanceResourceBaseManager) GetOrderBySubQuery(
 	q *sqlchemy.SQuery,
+	subq *sqlchemy.SSubQuery,
+	joinField sqlchemy.IQueryField,
 	userCred mcclient.TokenCredential,
 	query api.DBInstanceFilterListInput,
+	orders []string,
+	fields []sqlchemy.IQueryField,
 ) (*sqlchemy.SQuery, []string, []sqlchemy.IQueryField) {
-	dbQ := DBInstanceManager.Query("id", "name")
-	var orders []string
-	var fields []sqlchemy.IQueryField
-
-	if db.NeedOrderQuery(manager.SVpcResourceBaseManager.GetOrderByFields(query.VpcFilterListInput)) {
-		var vpcOrders []string
-		var vpcFields []sqlchemy.IQueryField
-		dbQ, vpcOrders, vpcFields = manager.SVpcResourceBaseManager.GetOrderBySubQuery(dbQ, userCred, query.VpcFilterListInput)
-		if len(vpcOrders) > 0 {
-			orders = append(orders, vpcOrders...)
-			fields = append(fields, vpcFields...)
-		}
-	}
-	if db.NeedOrderQuery(manager.GetOrderByFields(query)) {
-		subq := dbQ.SubQuery()
-		q = q.LeftJoin(subq, sqlchemy.Equals(q.Field("dbinstance_id"), subq.Field("id")))
-		if db.NeedOrderQuery([]string{query.OrderByDBInstance}) {
-			orders = append(orders, query.OrderByDBInstance)
-			fields = append(fields, subq.Field("name"))
-		}
+	if !db.NeedOrderQuery(manager.GetOrderByFields(query)) {
+		return q, orders, fields
 	}
+	dbQ := DBInstanceManager.Query().SubQuery()
+	q = q.LeftJoin(dbQ, sqlchemy.Equals(joinField, dbQ.Field("id")))
+	q = q.AppendField(dbQ.Field("name").Label("dbinstance"))
+	orders = append(orders, query.OrderByDBInstance)
+	fields = append(fields, subq.Field("dbinstance"))
+	q, orders, fields = manager.SVpcResourceBaseManager.GetOrderBySubQuery(q, subq, dbQ.Field("vpc_id"), userCred, query.VpcFilterListInput, orders, fields)
 	return q, orders, fields
 }
 

pkg/compute/models/diskresource.go

@@ -181,39 +181,35 @@ func (manager *SDiskResourceBaseManager) OrderByExtraFields(
 	userCred mcclient.TokenCredential,
 	query api.DiskFilterListInput,
 ) (*sqlchemy.SQuery, error) {
-	q, orders, fields := manager.GetOrderBySubQuery(q, userCred, query)
-	if len(orders) > 0 {
-		q = db.OrderByFields(q, orders, fields)
+	if !db.NeedOrderQuery(manager.GetOrderByFields(query)) {
+		return q, nil
 	}
+	orderQ := DiskManager.Query("id")
+	orderSubQ := orderQ.SubQuery()
+	orderQ, orders, fields := manager.GetOrderBySubQuery(orderQ, orderSubQ, orderQ.Field("id"), userCred, query, nil, nil)
+	q = q.LeftJoin(orderSubQ, sqlchemy.Equals(q.Field("disk_id"), orderSubQ.Field("id")))
+	q = db.OrderByFields(q, orders, fields)
 	return q, nil
 }
 
 func (manager *SDiskResourceBaseManager) GetOrderBySubQuery(
 	q *sqlchemy.SQuery,
+	subq *sqlchemy.SSubQuery,
+	joinField sqlchemy.IQueryField,
 	userCred mcclient.TokenCredential,
 	query api.DiskFilterListInput,
+	orders []string,
+	fields []sqlchemy.IQueryField,
 ) (*sqlchemy.SQuery, []string, []sqlchemy.IQueryField) {
-	diskQ := DiskManager.Query("id", "name")
-	var orders []string
-	var fields []sqlchemy.IQueryField
-
-	if db.NeedOrderQuery(manager.SStorageResourceBaseManager.GetOrderByFields(query.StorageFilterListInput)) {
-		var storageOrders []string
-		var storageFields []sqlchemy.IQueryField
-		diskQ, storageOrders, storageFields = manager.SStorageResourceBaseManager.GetOrderBySubQuery(diskQ, userCred, query.StorageFilterListInput)
-		if len(storageOrders) > 0 {
-			orders = append(orders, storageOrders...)
-			fields = append(fields, storageFields...)
-		}
-	}
-	if db.NeedOrderQuery(manager.GetOrderByFields(query)) {
-		subq := diskQ.SubQuery()
-		q = q.LeftJoin(subq, sqlchemy.Equals(q.Field("disk_id"), subq.Field("id")))
-		if db.NeedOrderQuery([]string{query.OrderByDisk}) {
-			orders = append(orders, query.OrderByDisk)
-			fields = append(fields, subq.Field("name"))
-		}
+	if !db.NeedOrderQuery(manager.GetOrderByFields(query)) {
+		return q, orders, fields
 	}
+	diskQ := DiskManager.Query().SubQuery()
+	q = q.LeftJoin(diskQ, sqlchemy.Equals(joinField, diskQ.Field("id")))
+	q = q.AppendField(diskQ.Field("name").Label("disk"))
+	orders = append(orders, query.OrderByDisk)
+	fields = append(fields, subq.Field("disk"))
+	q, orders, fields = manager.SStorageResourceBaseManager.GetOrderBySubQuery(q, subq, diskQ.Field("storage_id"), userCred, query.StorageFilterListInput, orders, fields)
 	return q, orders, fields
 }
 

pkg/compute/models/elasticcacheresource.go

@@ -193,51 +193,39 @@ func (manager *SElasticcacheResourceBaseManager) OrderByExtraFields(
 	userCred mcclient.TokenCredential,
 	query api.ElasticcacheFilterListInput,
 ) (*sqlchemy.SQuery, error) {
-	q, orders, fields := manager.GetOrderBySubQuery(q, userCred, query)
-	if len(orders) > 0 {
-		q = db.OrderByFields(q, orders, fields)
+	if !db.NeedOrderQuery(manager.GetOrderByFields(query)) {
+		return q, nil
 	}
+	orderQ := ElasticcacheManager.Query("id")
+	orderSubQ := orderQ.SubQuery()
+	orderQ, orders, fields := manager.GetOrderBySubQuery(orderQ, orderSubQ, orderQ.Field("id"), userCred, query, nil, nil)
+	q = q.LeftJoin(orderSubQ, sqlchemy.Equals(q.Field("elasticcache_id"), orderSubQ.Field("id")))
+	q = db.OrderByFields(q, orders, fields)
 	return q, nil
 }
 
 func (manager *SElasticcacheResourceBaseManager) GetOrderBySubQuery(
 	q *sqlchemy.SQuery,
+	subq *sqlchemy.SSubQuery,
+	joinField sqlchemy.IQueryField,
 	userCred mcclient.TokenCredential,
 	query api.ElasticcacheFilterListInput,
+	orders []string,
+	fields []sqlchemy.IQueryField,
 ) (*sqlchemy.SQuery, []string, []sqlchemy.IQueryField) {
-	cacheQ := ElasticcacheManager.Query("id", "name")
-	var orders []string
-	var fields []sqlchemy.IQueryField
-
-	if db.NeedOrderQuery(manager.SVpcResourceBaseManager.GetOrderByFields(query.VpcFilterListInput)) {
-		var vpcOrders []string
-		var vpcFields []sqlchemy.IQueryField
-		cacheQ, vpcOrders, vpcFields = manager.SVpcResourceBaseManager.GetOrderBySubQuery(cacheQ, userCred, query.VpcFilterListInput)
-		if len(vpcOrders) > 0 {
-			orders = append(orders, vpcOrders...)
-			fields = append(fields, vpcFields...)
-		}
+	if !db.NeedOrderQuery(manager.GetOrderByFields(query)) {
+		return q, orders, fields
 	}
+	cacheQ := ElasticcacheManager.Query("id", "name").SubQuery()
+	q = q.LeftJoin(cacheQ, sqlchemy.Equals(joinField, cacheQ.Field("id")))
+	q = q.AppendField(cacheQ.Field("name").Label("elasticcache"))
+	orders = append(orders, query.OrderByElasticcache)
+	fields = append(fields, subq.Field("elasticcache"))
+	q, orders, fields = manager.SVpcResourceBaseManager.GetOrderBySubQuery(q, subq, cacheQ.Field("vpc_id"), userCred, query.VpcFilterListInput, orders, fields)
 	zoneQuery := api.ZonalFilterListInput{
 		ZonalFilterListBase: query.ZonalFilterListBase,
 	}
-	if db.NeedOrderQuery(manager.SZoneResourceBaseManager.GetOrderByFields(zoneQuery)) {
-		var zoneOrders []string
-		var zoneFields []sqlchemy.IQueryField
-		cacheQ, zoneOrders, zoneFields = manager.SZoneResourceBaseManager.GetOrderBySubQuery(cacheQ, userCred, zoneQuery)
-		if len(zoneOrders) > 0 {
-			orders = append(orders, zoneOrders...)
-			fields = append(fields, zoneFields...)
-		}
-	}
-	if db.NeedOrderQuery(manager.GetOrderByFields(query)) {
-		subq := cacheQ.SubQuery()
-		q = q.LeftJoin(subq, sqlchemy.Equals(q.Field("elasticcache_id"), subq.Field("id")))
-		if db.NeedOrderQuery([]string{query.OrderByElasticcache}) {
-			orders = append(orders, query.OrderByElasticcache)
-			fields = append(fields, subq.Field("name"))
-		}
-	}
+	q, orders, fields = manager.SZoneResourceBaseManager.GetOrderBySubQuery(q, subq, cacheQ.Field("zone_id"), userCred, zoneQuery, orders, fields)
 	return q, orders, fields
 }
 

pkg/compute/models/groupresource.go

@@ -130,30 +130,34 @@ func (manager *SGroupResourceBaseManager) OrderByExtraFields(
 	userCred mcclient.TokenCredential,
 	query api.GroupFilterListInput,
 ) (*sqlchemy.SQuery, error) {
-	q, orders, fields := manager.GetOrderBySubQuery(q, userCred, query)
-	if len(orders) > 0 {
-		q = db.OrderByFields(q, orders, fields)
+	if !db.NeedOrderQuery(manager.GetOrderByFields(query)) {
+		return q, nil
 	}
+	orderQ := GroupManager.Query("id")
+	orderSubQ := orderQ.SubQuery()
+	orderQ, orders, fields := manager.GetOrderBySubQuery(orderQ, orderSubQ, orderQ.Field("id"), userCred, query, nil, nil)
+	q = q.LeftJoin(orderSubQ, sqlchemy.Equals(q.Field("group_id"), orderSubQ.Field("id")))
+	q = db.OrderByFields(q, orders, fields)
 	return q, nil
 }
 
 func (manager *SGroupResourceBaseManager) GetOrderBySubQuery(
 	q *sqlchemy.SQuery,
+	subq *sqlchemy.SSubQuery,
+	joinField sqlchemy.IQueryField,
 	userCred mcclient.TokenCredential,
 	query api.GroupFilterListInput,
+	orders []string,
+	fields []sqlchemy.IQueryField,
 ) (*sqlchemy.SQuery, []string, []sqlchemy.IQueryField) {
-	groupQ := GroupManager.Query("id", "name")
-	var orders []string
-	var fields []sqlchemy.IQueryField
-
-	if db.NeedOrderQuery(manager.GetOrderByFields(query)) {
-		subq := groupQ.SubQuery()
-		q = q.LeftJoin(subq, sqlchemy.Equals(q.Field("group_id"), subq.Field("id")))
-		if db.NeedOrderQuery([]string{query.OrderByGroup}) {
-			orders = append(orders, query.OrderByGroup)
-			fields = append(fields, subq.Field("name"))
-		}
+	if !db.NeedOrderQuery(manager.GetOrderByFields(query)) {
+		return q, orders, fields
 	}
+	groupQ := GroupManager.Query().SubQuery()
+	q = q.LeftJoin(groupQ, sqlchemy.Equals(joinField, groupQ.Field("id")))
+	q = q.AppendField(groupQ.Field("name").Label("group"))
+	orders = append(orders, query.OrderByGroup)
+	fields = append(fields, subq.Field("group"))
 	return q, orders, fields
 }
 

pkg/compute/models/guestresource.go

@@ -180,39 +180,35 @@ func (manager *SGuestResourceBaseManager) OrderByExtraFields(
 	userCred mcclient.TokenCredential,
 	query api.ServerFilterListInput,
 ) (*sqlchemy.SQuery, error) {
-	q, orders, fields := manager.GetOrderBySubQuery(q, userCred, query)
-	if len(orders) > 0 {
-		q = db.OrderByFields(q, orders, fields)
+	if !db.NeedOrderQuery(manager.GetOrderByFields(query)) {
+		return q, nil
 	}
+	orderQ := GuestManager.Query("id")
+	orderSubQ := orderQ.SubQuery()
+	orderQ, orders, fields := manager.GetOrderBySubQuery(orderQ, orderSubQ, orderQ.Field("id"), userCred, query, nil, nil)
+	q = q.LeftJoin(orderSubQ, sqlchemy.Equals(q.Field("guest_id"), orderSubQ.Field("id")))
+	q = db.OrderByFields(q, orders, fields)
 	return q, nil
 }
 
 func (manager *SGuestResourceBaseManager) GetOrderBySubQuery(
 	q *sqlchemy.SQuery,
+	subq *sqlchemy.SSubQuery,
+	joinField sqlchemy.IQueryField,
 	userCred mcclient.TokenCredential,
 	query api.ServerFilterListInput,
+	orders []string,
+	fields []sqlchemy.IQueryField,
 ) (*sqlchemy.SQuery, []string, []sqlchemy.IQueryField) {
-	guestQ := GuestManager.Query("id", "name")
-	var orders []string
-	var fields []sqlchemy.IQueryField
-
-	if db.NeedOrderQuery(manager.SHostResourceBaseManager.GetOrderByFields(query.HostFilterListInput)) {
-		var hostOrders []string
-		var hostFields []sqlchemy.IQueryField
-		guestQ, hostOrders, hostFields = manager.SHostResourceBaseManager.GetOrderBySubQuery(guestQ, userCred, query.HostFilterListInput)
-		if len(hostOrders) > 0 {
-			orders = append(orders, hostOrders...)
-			fields = append(fields, hostFields...)
-		}
-	}
-	if db.NeedOrderQuery(manager.GetOrderByFields(query)) {
-		subq := guestQ.SubQuery()
-		q = q.LeftJoin(subq, sqlchemy.Equals(q.Field("guest_id"), subq.Field("id")))
-		if db.NeedOrderQuery([]string{query.OrderByServer}) {
-			orders = append(orders, query.OrderByServer)
-			fields = append(fields, subq.Field("name"))
-		}
+	if !db.NeedOrderQuery(manager.GetOrderByFields(query)) {
+		return q, orders, fields
 	}
+	guestQ := GuestManager.Query().SubQuery()
+	q = q.LeftJoin(guestQ, sqlchemy.Equals(joinField, guestQ.Field("id")))
+	q = q.AppendField(guestQ.Field("name").Label("server"))
+	orders = append(orders, query.OrderByServer)
+	fields = append(fields, subq.Field("server"))
+	q, orders, fields = manager.SHostResourceBaseManager.GetOrderBySubQuery(q, subq, guestQ.Field("host_id"), userCred, query.HostFilterListInput, orders, fields)
 	return q, orders, fields
 }
 

pkg/compute/models/hostresource.go

@@ -198,48 +198,37 @@ func (manager *SHostResourceBaseManager) OrderByExtraFields(
 	userCred mcclient.TokenCredential,
 	query api.HostFilterListInput,
 ) (*sqlchemy.SQuery, error) {
-	q, orders, fields := manager.GetOrderBySubQuery(q, userCred, query)
-	if len(orders) > 0 {
-		q = db.OrderByFields(q, orders, fields)
+	if !db.NeedOrderQuery(manager.GetOrderByFields(query)) {
+		return q, nil
 	}
+	orderQ := HostManager.Query("id")
+	orderSubQ := orderQ.SubQuery()
+	orderQ, orders, fields := manager.GetOrderBySubQuery(orderQ, orderSubQ, orderQ.Field("id"), userCred, query, nil, nil)
+	q = q.LeftJoin(orderSubQ, sqlchemy.Equals(q.Field(manager.getHostIdFieldName()), orderSubQ.Field("id")))
+	q = db.OrderByFields(q, orders, fields)
 	return q, nil
 }
 
 func (manager *SHostResourceBaseManager) GetOrderBySubQuery(
 	q *sqlchemy.SQuery,
+	subq *sqlchemy.SSubQuery,
+	joinField sqlchemy.IQueryField,
 	userCred mcclient.TokenCredential,
 	query api.HostFilterListInput,
+	orders []string,
+	fields []sqlchemy.IQueryField,
 ) (*sqlchemy.SQuery, []string, []sqlchemy.IQueryField) {
-	hostQ := HostManager.Query("id", "name", "sn")
-	var orders []string
-	var fields []sqlchemy.IQueryField
-
-	if db.NeedOrderQuery(manager.SZoneResourceBaseManager.GetOrderByFields(query.ZonalFilterListInput)) {
-		var zoneOrders []string
-		var zoneFields []sqlchemy.IQueryField
-		hostQ, zoneOrders, zoneFields = manager.SZoneResourceBaseManager.GetOrderBySubQuery(hostQ, userCred, query.ZonalFilterListInput)
-		if len(zoneOrders) > 0 {
-			orders = append(orders, zoneOrders...)
-			fields = append(fields, zoneFields...)
-		}
-	}
-	if db.NeedOrderQuery(manager.SManagedResourceBaseManager.GetOrderByFields(query.ManagedResourceListInput)) {
-		var manOrders []string
-		var manFields []sqlchemy.IQueryField
-		hostQ, manOrders, manFields = manager.SManagedResourceBaseManager.GetOrderBySubQuery(hostQ, userCred, query.ManagedResourceListInput)
-		if len(manOrders) > 0 {
-			orders = append(orders, manOrders...)
-			fields = append(fields, manFields...)
-		}
-	}
-	if db.NeedOrderQuery(manager.GetOrderByFields(query)) {
-		subq := hostQ.SubQuery()
-		q = q.LeftJoin(subq, sqlchemy.Equals(q.Field(manager.getHostIdFieldName()), subq.Field("id")))
-		if db.NeedOrderQuery([]string{query.OrderByHost, query.OrderByHostSN}) {
-			orders = append(orders, query.OrderByHost, query.OrderByHostSN)
-			fields = append(fields, subq.Field("name"), subq.Field("sn"))
-		}
+	if !db.NeedOrderQuery(manager.GetOrderByFields(query)) {
+		return q, orders, fields
 	}
+	hostQ := HostManager.Query().SubQuery()
+	q = q.LeftJoin(hostQ, sqlchemy.Equals(joinField, hostQ.Field("id")))
+	q = q.AppendField(hostQ.Field("name").Label("host"))
+	q = q.AppendField(hostQ.Field("sn").Label("host_sn"))
+	orders = append(orders, query.OrderByHost, query.OrderByHostSN)
+	fields = append(fields, subq.Field("host"), subq.Field("host_sn"))
+	q, orders, fields = manager.SZoneResourceBaseManager.GetOrderBySubQuery(q, subq, hostQ.Field("zone_id"), userCred, query.ZonalFilterListInput, orders, fields)
+	q, orders, fields = manager.SManagedResourceBaseManager.GetOrderBySubQuery(q, subq, hostQ.Field("manager_id"), userCred, query.ManagedResourceListInput, orders, fields)
 	return q, orders, fields
 }
 

pkg/compute/models/loadbalanceraclresource.go

@@ -125,10 +125,14 @@ func (manager *SLoadbalancerAclResourceBaseManager) OrderByExtraFields(
 	userCred mcclient.TokenCredential,
 	query api.LoadbalancerAclFilterListInput,
 ) (*sqlchemy.SQuery, error) {
-	q, orders, fields := manager.GetOrderBySubQuery(q, userCred, query)
-	if len(orders) > 0 {
-		q = db.OrderByFields(q, orders, fields)
+	if !db.NeedOrderQuery(manager.GetOrderByFields(query)) {
+		return q, nil
 	}
+	orderQ := LoadbalancerAclManager.Query("id")
+	orderSubQ := orderQ.SubQuery()
+	orderQ, orders, fields := manager.GetOrderBySubQuery(orderQ, orderSubQ, orderQ.Field("id"), userCred, query, nil, nil)
+	q = q.LeftJoin(orderSubQ, sqlchemy.Equals(q.Field("acl_id"), orderSubQ.Field("id")))
+	q = db.OrderByFields(q, orders, fields)
 	return q, nil
 }
 
@@ -145,18 +149,21 @@ func (manager *SLoadbalancerAclResourceBaseManager) QueryDistinctExtraField(q *s
 
 func (manager *SLoadbalancerAclResourceBaseManager) GetOrderBySubQuery(
 	q *sqlchemy.SQuery,
+	subq *sqlchemy.SSubQuery,
+	joinField sqlchemy.IQueryField,
 	userCred mcclient.TokenCredential,
 	query api.LoadbalancerAclFilterListInput,
+	orders []string,
+	fields []sqlchemy.IQueryField,
 ) (*sqlchemy.SQuery, []string, []sqlchemy.IQueryField) {
-	aclQ := LoadbalancerAclManager.Query("id", "name")
-	var orders []string
-	var fields []sqlchemy.IQueryField
-	if db.NeedOrderQuery(manager.GetOrderByFields(query)) {
-		subq := aclQ.SubQuery()
-		q = q.LeftJoin(subq, sqlchemy.Equals(q.Field("acl_id"), subq.Field("id")))
-		orders = append(orders, query.OrderByAcl)
-		fields = append(fields, subq.Field("name"))
+	if !db.NeedOrderQuery(manager.GetOrderByFields(query)) {
+		return q, orders, fields
 	}
+	aclQ := LoadbalancerAclManager.Query().SubQuery()
+	q = q.LeftJoin(aclQ, sqlchemy.Equals(joinField, aclQ.Field("id")))
+	q = q.AppendField(aclQ.Field("name").Label("acl"))
+	orders = append(orders, query.OrderByAcl)
+	fields = append(fields, subq.Field("acl"))
 	return q, orders, fields
 }
 

pkg/compute/models/loadbalancerbackendgroupresource.go

@@ -213,41 +213,35 @@ func (manager *SLoadbalancerBackendgroupResourceBaseManager) OrderByExtraFields(
 	userCred mcclient.TokenCredential,
 	query api.LoadbalancerBackendGroupFilterListInput,
 ) (*sqlchemy.SQuery, error) {
-	q, orders, fields := manager.GetOrderBySubQuery(q, userCred, query)
-	if len(orders) > 0 {
-		q = db.OrderByFields(q, orders, fields)
+	if !db.NeedOrderQuery(manager.GetOrderByFields(query)) {
+		return q, nil
 	}
+	orderQ := LoadbalancerBackendGroupManager.Query("id")
+	orderSubQ := orderQ.SubQuery()
+	orderQ, orders, fields := manager.GetOrderBySubQuery(orderQ, orderSubQ, orderQ.Field("id"), userCred, query, nil, nil)
+	q = q.LeftJoin(orderSubQ, sqlchemy.Equals(q.Field("backend_group_id"), orderSubQ.Field("id")))
+	q = db.OrderByFields(q, orders, fields)
 	return q, nil
 }
 
 func (manager *SLoadbalancerBackendgroupResourceBaseManager) GetOrderBySubQuery(
 	q *sqlchemy.SQuery,
+	subq *sqlchemy.SSubQuery,
+	joinField sqlchemy.IQueryField,
 	userCred mcclient.TokenCredential,
 	query api.LoadbalancerBackendGroupFilterListInput,
+	orders []string,
+	fields []sqlchemy.IQueryField,
 ) (*sqlchemy.SQuery, []string, []sqlchemy.IQueryField) {
-	lbbgQ := LoadbalancerBackendGroupManager.Query("id", "name")
-	var orders []string
-	var fields []sqlchemy.IQueryField
-
-	if db.NeedOrderQuery(manager.SLoadbalancerResourceBaseManager.GetOrderByFields(query.LoadbalancerFilterListInput)) {
-		var lbOrders []string
-		var lbFields []sqlchemy.IQueryField
-		lbbgQ, lbOrders, lbFields = manager.SLoadbalancerResourceBaseManager.GetOrderBySubQuery(lbbgQ, userCred, query.LoadbalancerFilterListInput)
-		if len(lbOrders) > 0 {
-			orders = append(orders, lbOrders...)
-			fields = append(fields, lbFields...)
-		}
+	if !db.NeedOrderQuery(manager.GetOrderByFields(query)) {
+		return q, orders, fields
 	}
-
-	if db.NeedOrderQuery(manager.GetOrderByFields(query)) {
-		subq := lbbgQ.SubQuery()
-		q = q.LeftJoin(subq, sqlchemy.Equals(q.Field("backend_group_id"), subq.Field("id")))
-		if db.NeedOrderQuery([]string{query.OrderByBackendGroup}) {
-			orders = append(orders, query.OrderByBackendGroup)
-			fields = append(fields, subq.Field("name"))
-		}
-	}
-
+	lbbgQ := LoadbalancerBackendGroupManager.Query().SubQuery()
+	q = q.LeftJoin(lbbgQ, sqlchemy.Equals(joinField, lbbgQ.Field("id")))
+	q = q.AppendField(lbbgQ.Field("name").Label("backend_group"))
+	orders = append(orders, query.OrderByBackendGroup)
+	fields = append(fields, subq.Field("backend_group"))
+	q, orders, fields = manager.SLoadbalancerResourceBaseManager.GetOrderBySubQuery(q, subq, lbbgQ.Field("loadbalancer_id"), userCred, query.LoadbalancerFilterListInput, orders, fields)
 	return q, orders, fields
 }
 

pkg/compute/models/loadbalancercertificateresource.go

@@ -125,10 +125,14 @@ func (manager *SLoadbalancerCertificateResourceBaseManager) OrderByExtraFields(
 	userCred mcclient.TokenCredential,
 	query api.LoadbalancerCertificateFilterListInput,
 ) (*sqlchemy.SQuery, error) {
-	q, orders, fields := manager.GetOrderBySubQuery(q, userCred, query)
-	if len(orders) > 0 {
-		q = db.OrderByFields(q, orders, fields)
+	if !db.NeedOrderQuery(manager.GetOrderByFields(query)) {
+		return q, nil
 	}
+	orderQ := LoadbalancerCertificateManager.Query("id")
+	orderSubQ := orderQ.SubQuery()
+	orderQ, orders, fields := manager.GetOrderBySubQuery(orderQ, orderSubQ, orderQ.Field("id"), userCred, query, nil, nil)
+	q = q.LeftJoin(orderSubQ, sqlchemy.Equals(q.Field("certificate_id"), orderSubQ.Field("id")))
+	q = db.OrderByFields(q, orders, fields)
 	return q, nil
 }
 
@@ -145,18 +149,21 @@ func (manager *SLoadbalancerCertificateResourceBaseManager) QueryDistinctExtraFi
 
 func (manager *SLoadbalancerCertificateResourceBaseManager) GetOrderBySubQuery(
 	q *sqlchemy.SQuery,
+	subq *sqlchemy.SSubQuery,
+	joinField sqlchemy.IQueryField,
 	userCred mcclient.TokenCredential,
 	query api.LoadbalancerCertificateFilterListInput,
+	orders []string,
+	fields []sqlchemy.IQueryField,
 ) (*sqlchemy.SQuery, []string, []sqlchemy.IQueryField) {
-	certQ := LoadbalancerCertificateManager.Query("id", "name")
-	var orders []string
-	var fields []sqlchemy.IQueryField
-	if db.NeedOrderQuery(manager.GetOrderByFields(query)) {
-		subq := certQ.SubQuery()
-		q = q.LeftJoin(subq, sqlchemy.Equals(q.Field("certificate_id"), subq.Field("id")))
-		orders = append(orders, query.OrderByCertificate)
-		fields = append(fields, subq.Field("name"))
+	if !db.NeedOrderQuery(manager.GetOrderByFields(query)) {
+		return q, orders, fields
 	}
+	certQ := LoadbalancerCertificateManager.Query().SubQuery()
+	q = q.LeftJoin(certQ, sqlchemy.Equals(joinField, certQ.Field("id")))
+	q = q.AppendField(certQ.Field("name").Label("certificate"))
+	orders = append(orders, query.OrderByCertificate)
+	fields = append(fields, subq.Field("certificate"))
 	return q, orders, fields
 }
 

pkg/compute/models/loadbalancerclusterresource.go

@@ -161,10 +161,14 @@ func (manager *SLoadbalancerClusterResourceBaseManager) OrderByExtraFields(
 	userCred mcclient.TokenCredential,
 	query api.LoadbalancerClusterFilterListInput,
 ) (*sqlchemy.SQuery, error) {
-	q, orders, fields := manager.GetOrderBySubQuery(q, userCred, query)
-	if len(orders) > 0 {
-		q = db.OrderByFields(q, orders, fields)
+	if !db.NeedOrderQuery(manager.GetOrderByFields(query)) {
+		return q, nil
 	}
+	orderQ := LoadbalancerClusterManager.Query("id")
+	orderSubQ := orderQ.SubQuery()
+	orderQ, orders, fields := manager.GetOrderBySubQuery(orderQ, orderSubQ, orderQ.Field("id"), userCred, query, nil, nil)
+	q = q.LeftJoin(orderSubQ, sqlchemy.Equals(q.Field("cluster_id"), orderSubQ.Field("id")))
+	q = db.OrderByFields(q, orders, fields)
 	return q, nil
 }
 
@@ -191,31 +195,22 @@ func (manager *SLoadbalancerClusterResourceBaseManager) QueryDistinctExtraField(
 
 func (manager *SLoadbalancerClusterResourceBaseManager) GetOrderBySubQuery(
 	q *sqlchemy.SQuery,
+	subq *sqlchemy.SSubQuery,
+	joinField sqlchemy.IQueryField,
 	userCred mcclient.TokenCredential,
 	query api.LoadbalancerClusterFilterListInput,
+	orders []string,
+	fields []sqlchemy.IQueryField,
 ) (*sqlchemy.SQuery, []string, []sqlchemy.IQueryField) {
-	clusterQ := LoadbalancerClusterManager.Query("id", "name")
-	var orders []string
-	var fields []sqlchemy.IQueryField
-
-	if db.NeedOrderQuery(manager.SZoneResourceBaseManager.GetOrderByFields(query.ZonalFilterListInput)) {
-		var zoneOrders []string
-		var zoneFields []sqlchemy.IQueryField
-		clusterQ, zoneOrders, zoneFields = manager.SZoneResourceBaseManager.GetOrderBySubQuery(clusterQ, userCred, query.ZonalFilterListInput)
-		if len(zoneOrders) > 0 {
-			orders = append(orders, zoneOrders...)
-			fields = append(fields, zoneFields...)
-		}
-	}
-
-	if db.NeedOrderQuery(manager.GetOrderByFields(query)) {
-		subq := clusterQ.SubQuery()
-		q = q.LeftJoin(subq, sqlchemy.Equals(q.Field("cluster_id"), subq.Field("id")))
-		if db.NeedOrderQuery([]string{query.OrderByCluster}) {
-			orders = append(orders, query.OrderByCluster)
-			fields = append(fields, subq.Field("name"))
-		}
+	if !db.NeedOrderQuery(manager.GetOrderByFields(query)) {
+		return q, orders, fields
 	}
+	clusterQ := LoadbalancerClusterManager.Query().SubQuery()
+	q = q.LeftJoin(clusterQ, sqlchemy.Equals(joinField, clusterQ.Field("id")))
+	q = q.AppendField(clusterQ.Field("name").Label("cluster"))
+	orders = append(orders, query.OrderByCluster)
+	fields = append(fields, subq.Field("cluster"))
+	q, orders, fields = manager.SZoneResourceBaseManager.GetOrderBySubQuery(q, subq, clusterQ.Field("zone_id"), userCred, query.ZonalFilterListInput, orders, fields)
 	return q, orders, fields
 }
 

pkg/compute/models/loadbalancerlistenerresource.go

@@ -169,10 +169,14 @@ func (manager *SLoadbalancerListenerResourceBaseManager) OrderByExtraFields(
 	userCred mcclient.TokenCredential,
 	query api.LoadbalancerListenerFilterListInput,
 ) (*sqlchemy.SQuery, error) {
-	q, orders, fields := manager.GetOrderBySubQuery(q, userCred, query)
-	if len(orders) > 0 {
-		q = db.OrderByFields(q, orders, fields)
+	if !db.NeedOrderQuery(manager.GetOrderByFields(query)) {
+		return q, nil
 	}
+	orderQ := LoadbalancerListenerManager.Query("id")
+	orderSubQ := orderQ.SubQuery()
+	orderQ, orders, fields := manager.GetOrderBySubQuery(orderQ, orderSubQ, orderQ.Field("id"), userCred, query, nil, nil)
+	q = q.LeftJoin(orderSubQ, sqlchemy.Equals(q.Field("listener_id"), orderSubQ.Field("id")))
+	q = db.OrderByFields(q, orders, fields)
 	return q, nil
 }
 
@@ -195,32 +199,22 @@ func (manager *SLoadbalancerListenerResourceBaseManager) QueryDistinctExtraField
 
 func (manager *SLoadbalancerListenerResourceBaseManager) GetOrderBySubQuery(
 	q *sqlchemy.SQuery,
+	subq *sqlchemy.SSubQuery,
+	joinField sqlchemy.IQueryField,
 	userCred mcclient.TokenCredential,
 	query api.LoadbalancerListenerFilterListInput,
+	orders []string,
+	fields []sqlchemy.IQueryField,
 ) (*sqlchemy.SQuery, []string, []sqlchemy.IQueryField) {
-	listenerQ := LoadbalancerListenerManager.Query("id", "name")
-	var orders []string
-	var fields []sqlchemy.IQueryField
-
-	if db.NeedOrderQuery(manager.SLoadbalancerResourceBaseManager.GetOrderByFields(query.LoadbalancerFilterListInput)) {
-		var lbOrders []string
-		var lbFields []sqlchemy.IQueryField
-		listenerQ, lbOrders, lbFields = manager.SLoadbalancerResourceBaseManager.GetOrderBySubQuery(listenerQ, userCred, query.LoadbalancerFilterListInput)
-		if len(lbOrders) > 0 {
-			orders = append(orders, lbOrders...)
-			fields = append(fields, lbFields...)
-		}
+	if !db.NeedOrderQuery(manager.GetOrderByFields(query)) {
+		return q, orders, fields
 	}
-
-	if db.NeedOrderQuery(manager.GetOrderByFields(query)) {
-		subq := listenerQ.SubQuery()
-		q = q.LeftJoin(subq, sqlchemy.Equals(q.Field("listener_id"), subq.Field("id")))
-		if db.NeedOrderQuery([]string{query.OrderByListener}) {
-			orders = append(orders, query.OrderByListener)
-			fields = append(fields, subq.Field("name"))
-		}
-	}
-
+	listenerQ := LoadbalancerListenerManager.Query().SubQuery()
+	q = q.LeftJoin(listenerQ, sqlchemy.Equals(joinField, listenerQ.Field("id")))
+	q = q.AppendField(listenerQ.Field("name").Label("listener"))
+	orders = append(orders, query.OrderByListener)
+	fields = append(fields, subq.Field("listener"))
+	q, orders, fields = manager.SLoadbalancerResourceBaseManager.GetOrderBySubQuery(q, subq, listenerQ.Field("loadbalancer_id"), userCred, query.LoadbalancerFilterListInput, orders, fields)
 	return q, orders, fields
 }
 

pkg/compute/models/loadbalancerresource.go

@@ -258,53 +258,40 @@ func (manager *SLoadbalancerResourceBaseManager) OrderByExtraFields(
 	userCred mcclient.TokenCredential,
 	query api.LoadbalancerFilterListInput,
 ) (*sqlchemy.SQuery, error) {
-	q, orders, fields := manager.GetOrderBySubQuery(q, userCred, query)
-	if len(orders) > 0 {
-		q = db.OrderByFields(q, orders, fields)
+	if !db.NeedOrderQuery(manager.GetOrderByFields(query)) {
+		return q, nil
 	}
+	orderQ := LoadbalancerManager.Query("id")
+	orderSubQ := orderQ.SubQuery()
+	orderQ, orders, fields := manager.GetOrderBySubQuery(orderQ, orderSubQ, orderQ.Field("id"), userCred, query, nil, nil)
+	q = q.LeftJoin(orderSubQ, sqlchemy.Equals(q.Field("loadbalancer_id"), orderSubQ.Field("id")))
+	q = db.OrderByFields(q, orders, fields)
 	return q, nil
 }
 
 func (manager *SLoadbalancerResourceBaseManager) GetOrderBySubQuery(
 	q *sqlchemy.SQuery,
+	subq *sqlchemy.SSubQuery,
+	joinField sqlchemy.IQueryField,
 	userCred mcclient.TokenCredential,
 	query api.LoadbalancerFilterListInput,
+	orders []string,
+	fields []sqlchemy.IQueryField,
 ) (*sqlchemy.SQuery, []string, []sqlchemy.IQueryField) {
-	lbQ := LoadbalancerManager.Query("id", "name")
-	var orders []string
-	var fields []sqlchemy.IQueryField
+	if !db.NeedOrderQuery(manager.GetOrderByFields(query)) {
+		return q, orders, fields
+	}
+	lbQ := LoadbalancerManager.Query().SubQuery()
+	q = q.LeftJoin(lbQ, sqlchemy.Equals(joinField, lbQ.Field("id")))
+	q = q.AppendField(lbQ.Field("name").Label("loadbalancer"))
+	orders = append(orders, query.OrderByLoadbalancer)
+	fields = append(fields, subq.Field("loadbalancer"))
+
 	zoneQuery := api.ZonalFilterListInput{
 		ZonalFilterListBase: query.ZonalFilterListBase,
 	}
-	if db.NeedOrderQuery(manager.SZoneResourceBaseManager.GetOrderByFields(zoneQuery)) {
-		var zoneOrders []string
-		var zoneFields []sqlchemy.IQueryField
-		lbQ, zoneOrders, zoneFields = manager.SZoneResourceBaseManager.GetOrderBySubQuery(lbQ, userCred, zoneQuery)
-		if len(zoneOrders) > 0 {
-			orders = append(orders, zoneOrders...)
-			fields = append(fields, zoneFields...)
-		}
-	}
-
-	if db.NeedOrderQuery(manager.SVpcResourceBaseManager.GetOrderByFields(query.VpcFilterListInput)) {
-		var vpcOrders []string
-		var vpcFields []sqlchemy.IQueryField
-		lbQ, vpcOrders, vpcFields = manager.SVpcResourceBaseManager.GetOrderBySubQuery(lbQ, userCred, query.VpcFilterListInput)
-		if len(vpcOrders) > 0 {
-			orders = append(orders, vpcOrders...)
-			fields = append(fields, vpcFields...)
-		}
-	}
-
-	if db.NeedOrderQuery(manager.GetOrderByFields(query)) {
-		subq := lbQ.SubQuery()
-		q = q.LeftJoin(subq, sqlchemy.Equals(q.Field("loadbalancer_id"), subq.Field("id")))
-		if db.NeedOrderQuery([]string{query.OrderByLoadbalancer}) {
-			orders = append(orders, query.OrderByLoadbalancer)
-			fields = append(fields, subq.Field("name"))
-		}
-	}
-
+	q, orders, fields = manager.SZoneResourceBaseManager.GetOrderBySubQuery(q, subq, lbQ.Field("zone_id"), userCred, zoneQuery, orders, fields)
+	q, orders, fields = manager.SVpcResourceBaseManager.GetOrderBySubQuery(q, subq, lbQ.Field("vpc_id"), userCred, query.VpcFilterListInput, orders, fields)
 	return q, orders, fields
 }
 

pkg/compute/models/loadbalancers.go

@@ -221,11 +221,11 @@ func (man *SLoadbalancerManager) OrderByExtraFields(
 	if err != nil {
 		return nil, errors.Wrap(err, "SVirtualResourceBaseManager.OrderByExtraFields")
 	}
-	q, err = man.SManagedResourceBaseManager.ListItemFilter(ctx, q, userCred, query.ManagedResourceListInput)
+	q, err = man.SManagedResourceBaseManager.OrderByExtraFields(ctx, q, userCred, query.ManagedResourceListInput)
 	if err != nil {
 		return nil, errors.Wrap(err, "SManagedResourceBaseManager.ListItemFilter")
 	}
-	q, err = man.SCloudregionResourceBaseManager.ListItemFilter(ctx, q, userCred, query.RegionalFilterListInput)
+	q, err = man.SCloudregionResourceBaseManager.OrderByExtraFields(ctx, q, userCred, query.RegionalFilterListInput)
 	if err != nil {
 		return nil, errors.Wrap(err, "SCloudregionResourceBaseManager.ListItemFilter")
 	}

pkg/compute/models/managedresource.go

@@ -306,42 +306,39 @@ func (manager *SManagedResourceBaseManager) OrderByExtraFields(
 	userCred mcclient.TokenCredential,
 	query api.ManagedResourceListInput,
 ) (*sqlchemy.SQuery, error) {
-	q, orders, fields := manager.GetOrderBySubQuery(q, userCred, query)
-	if len(orders) > 0 {
-		q = db.OrderByFields(q, orders, fields)
+	if !db.NeedOrderQuery(manager.GetOrderByFields(query)) {
+		return q, nil
 	}
+	orderQ := CloudproviderManager.Query("id")
+	subOrderQ := orderQ.SubQuery()
+	orderQ, orders, fields := manager.GetOrderBySubQuery(orderQ, subOrderQ, orderQ.Field("id"), userCred, query, nil, nil)
+	q = q.LeftJoin(subOrderQ, sqlchemy.Equals(q.Field(manager.getManagerIdFileName()), subOrderQ.Field("id")))
+	q = db.OrderByFields(q, orders, fields)
 	return q, nil
 }
 
 func (manager *SManagedResourceBaseManager) GetOrderBySubQuery(
 	q *sqlchemy.SQuery,
+	subq *sqlchemy.SSubQuery,
+	subqField sqlchemy.IQueryField,
 	userCred mcclient.TokenCredential,
 	query api.ManagedResourceListInput,
+	orders []string,
+	fields []sqlchemy.IQueryField,
 ) (*sqlchemy.SQuery, []string, []sqlchemy.IQueryField) {
-	var orders []string
-	var fields []sqlchemy.IQueryField
-	orders = manager.GetOrderByFields(query)
-	if db.NeedOrderQuery(orders) {
-		providers := CloudproviderManager.Query("id", "name", "cloudaccount_id").SubQuery()
-		accounts := CloudaccountManager.Query("id", "name", "provider", "brand").SubQuery()
-		subq := providers.Query(
-			providers.Field("id"),
-			providers.Field("name"),
-			accounts.Field("name").Label("account"),
-			accounts.Field("provider"),
-			accounts.Field("brand"),
-		).Join(
-			accounts,
-			sqlchemy.Equals(providers.Field("cloudaccount_id"), accounts.Field("id")),
-		).SubQuery()
-		q = q.LeftJoin(subq, sqlchemy.Equals(q.Field(manager.getManagerIdFileName()), subq.Field("id")))
-		fields = []sqlchemy.IQueryField{
-			subq.Field("name"),
-			subq.Field("account"),
-			subq.Field("provider"),
-			subq.Field("brand"),
-		}
+	if !db.NeedOrderQuery(manager.GetOrderByFields(query)) {
+		return q, orders, fields
 	}
+	providers := CloudproviderManager.Query().SubQuery()
+	accounts := CloudaccountManager.Query().SubQuery()
+	q = q.LeftJoin(providers, sqlchemy.Equals(subqField, providers.Field("id")))
+	q = q.LeftJoin(accounts, sqlchemy.Equals(providers.Field("cloudaccount_id"), accounts.Field("id")))
+	q = q.AppendField(providers.Field("name").Label("manager"))
+	q = q.AppendField(accounts.Field("name").Label("account"))
+	q = q.AppendField(accounts.Field("provider"))
+	q = q.AppendField(accounts.Field("brand"))
+	orders = append(orders, query.OrderByManager, query.OrderByAccount, query.OrderByProvider, query.OrderByBrand)
+	fields = append(fields, subq.Field("manager"), subq.Field("account"), subq.Field("provider"), subq.Field("brand"))
 	return q, orders, fields
 }
 

pkg/compute/models/natgatewayresource.go

@@ -163,39 +163,35 @@ func (manager *SNatgatewayResourceBaseManager) OrderByExtraFields(
 	userCred mcclient.TokenCredential,
 	query api.NatGatewayFilterListInput,
 ) (*sqlchemy.SQuery, error) {
-	q, orders, fields := manager.GetOrderBySubQuery(q, userCred, query)
-	if len(orders) > 0 {
-		q = db.OrderByFields(q, orders, fields)
+	if !db.NeedOrderQuery(manager.GetOrderByFields(query)) {
+		return q, nil
 	}
+	orderQ := NatGatewayManager.Query("id")
+	orderSubQ := orderQ.SubQuery()
+	orderQ, orders, fields := manager.GetOrderBySubQuery(orderQ, orderSubQ, orderQ.Field("id"), userCred, query, nil, nil)
+	q = q.LeftJoin(orderSubQ, sqlchemy.Equals(q.Field("natgateway_id"), orderSubQ.Field("id")))
+	q = db.OrderByFields(q, orders, fields)
 	return q, nil
 }
 
 func (manager *SNatgatewayResourceBaseManager) GetOrderBySubQuery(
 	q *sqlchemy.SQuery,
+	subq *sqlchemy.SSubQuery,
+	joinField sqlchemy.IQueryField,
 	userCred mcclient.TokenCredential,
 	query api.NatGatewayFilterListInput,
+	orders []string,
+	fields []sqlchemy.IQueryField,
 ) (*sqlchemy.SQuery, []string, []sqlchemy.IQueryField) {
-	natQ := NatGatewayManager.Query("id", "name")
-	var orders []string
-	var fields []sqlchemy.IQueryField
-
-	if db.NeedOrderQuery(manager.SVpcResourceBaseManager.GetOrderByFields(query.VpcFilterListInput)) {
-		var vpcOrders []string
-		var vpcFields []sqlchemy.IQueryField
-		natQ, vpcOrders, vpcFields = manager.SVpcResourceBaseManager.GetOrderBySubQuery(natQ, userCred, query.VpcFilterListInput)
-		if len(vpcOrders) > 0 {
-			orders = append(orders, vpcOrders...)
-			fields = append(fields, vpcFields...)
-		}
-	}
-	if db.NeedOrderQuery(manager.GetOrderByFields(query)) {
-		subq := natQ.SubQuery()
-		q = q.LeftJoin(subq, sqlchemy.Equals(q.Field("natgateway_id"), subq.Field("id")))
-		if db.NeedOrderQuery([]string{query.OrderByNatgateway}) {
-			orders = append(orders, query.OrderByNatgateway)
-			fields = append(fields, subq.Field("name"))
-		}
+	if !db.NeedOrderQuery(manager.GetOrderByFields(query)) {
+		return q, orders, fields
 	}
+	natQ := NatGatewayManager.Query().SubQuery()
+	q = q.LeftJoin(natQ, sqlchemy.Equals(joinField, natQ.Field("id")))
+	q = q.AppendField(natQ.Field("name").Label("natgateway"))
+	orders = append(orders, query.OrderByNatgateway)
+	fields = append(fields, subq.Field("natgateway"))
+	q, orders, fields = manager.SVpcResourceBaseManager.GetOrderBySubQuery(q, subq, natQ.Field("vpc_id"), userCred, query.VpcFilterListInput, orders, fields)
 	return q, orders, fields
 }
 

pkg/compute/models/networkresource.go

@@ -189,39 +189,35 @@ func (manager *SNetworkResourceBaseManager) OrderByExtraFields(
 	userCred mcclient.TokenCredential,
 	query api.NetworkFilterListInput,
 ) (*sqlchemy.SQuery, error) {
-	q, orders, fields := manager.GetOrderBySubQuery(q, userCred, query)
-	if len(orders) > 0 {
-		q = db.OrderByFields(q, orders, fields)
+	if !db.NeedOrderQuery(manager.GetOrderByFields(query)) {
+		return q, nil
 	}
+	orderQ := NetworkManager.Query("id")
+	orderSubQ := orderQ.SubQuery()
+	orderQ, orders, fields := manager.GetOrderBySubQuery(orderQ, orderSubQ, orderQ.Field("id"), userCred, query, nil, nil)
+	q = q.LeftJoin(orderSubQ, sqlchemy.Equals(q.Field("network_id"), orderSubQ.Field("id")))
+	q = db.OrderByFields(q, orders, fields)
 	return q, nil
 }
 
 func (manager *SNetworkResourceBaseManager) GetOrderBySubQuery(
 	q *sqlchemy.SQuery,
+	subq *sqlchemy.SSubQuery,
+	joinField sqlchemy.IQueryField,
 	userCred mcclient.TokenCredential,
 	query api.NetworkFilterListInput,
+	orders []string,
+	fields []sqlchemy.IQueryField,
 ) (*sqlchemy.SQuery, []string, []sqlchemy.IQueryField) {
-	netQ := NetworkManager.Query("id", "name")
-	var orders []string
-	var fields []sqlchemy.IQueryField
-
-	if db.NeedOrderQuery(manager.SWireResourceBaseManager.GetOrderByFields(query.WireFilterListInput)) {
-		var wireOrders []string
-		var wireFields []sqlchemy.IQueryField
-		netQ, wireOrders, wireFields = manager.SWireResourceBaseManager.GetOrderBySubQuery(netQ, userCred, query.WireFilterListInput)
-		if len(wireOrders) > 0 {
-			orders = append(orders, wireOrders...)
-			fields = append(fields, wireFields...)
-		}
-	}
-	if db.NeedOrderQuery(manager.GetOrderByFields(query)) {
-		subq := netQ.SubQuery()
-		q = q.LeftJoin(subq, sqlchemy.Equals(q.Field("network_id"), subq.Field("id")))
-		if db.NeedOrderQuery([]string{query.OrderByNetwork}) {
-			orders = append(orders, query.OrderByNetwork)
-			fields = append(fields, subq.Field("name"))
-		}
+	if !db.NeedOrderQuery(manager.GetOrderByFields(query)) {
+		return q, orders, fields
 	}
+	netQ := NetworkManager.Query().SubQuery()
+	q = q.LeftJoin(netQ, sqlchemy.Equals(joinField, netQ.Field("id")))
+	q = q.AppendField(netQ.Field("name").Label("network"))
+	orders = append(orders, query.OrderByNetwork)
+	fields = append(fields, subq.Field("network"))
+	q, orders, fields = manager.SWireResourceBaseManager.GetOrderBySubQuery(q, subq, netQ.Field("wire_id"), userCred, query.WireFilterListInput, orders, fields)
 	return q, orders, fields
 }
 

pkg/compute/models/schedtagresource.go

@@ -126,10 +126,14 @@ func (manager *SSchedtagResourceBaseManager) OrderByExtraFields(
 	userCred mcclient.TokenCredential,
 	query api.SchedtagFilterListInput,
 ) (*sqlchemy.SQuery, error) {
-	q, orders, fields := manager.GetOrderBySubQuery(q, userCred, query)
-	if len(orders) > 0 {
-		q = db.OrderByFields(q, orders, fields)
+	if !db.NeedOrderQuery(manager.GetOrderByFields(query)) {
+		return q, nil
 	}
+	orderQ := SchedtagManager.Query("id")
+	orderSubQ := orderQ.SubQuery()
+	orderQ, orders, fields := manager.GetOrderBySubQuery(orderQ, orderSubQ, orderQ.Field("id"), userCred, query, nil, nil)
+	q = q.LeftJoin(orderSubQ, sqlchemy.Equals(q.Field("schedtag_id"), orderSubQ.Field("id")))
+	q = db.OrderByFields(q, orders, fields)
 	return q, nil
 }
 
@@ -146,18 +150,22 @@ func (manager *SSchedtagResourceBaseManager) QueryDistinctExtraField(q *sqlchemy
 
 func (manager *SSchedtagResourceBaseManager) GetOrderBySubQuery(
 	q *sqlchemy.SQuery,
+	subq *sqlchemy.SSubQuery,
+	joinField sqlchemy.IQueryField,
 	userCred mcclient.TokenCredential,
 	query api.SchedtagFilterListInput,
+	orders []string,
+	fields []sqlchemy.IQueryField,
 ) (*sqlchemy.SQuery, []string, []sqlchemy.IQueryField) {
-	tagQ := SchedtagManager.Query("id", "name", "resource_type")
-	var orders []string
-	var fields []sqlchemy.IQueryField
-	if db.NeedOrderQuery(manager.GetOrderByFields(query)) {
-		subq := tagQ.SubQuery()
-		q = q.LeftJoin(subq, sqlchemy.Equals(q.Field("schedtag_id"), subq.Field("id")))
-		orders = append(orders, query.OrderBySchedtag, query.OrderByResourceType)
-		fields = append(fields, subq.Field("name"), subq.Field("resource_type"))
+	if !db.NeedOrderQuery(manager.GetOrderByFields(query)) {
+		return q, orders, fields
 	}
+	tagQ := SchedtagManager.Query().SubQuery()
+	q = q.LeftJoin(tagQ, sqlchemy.Equals(joinField, tagQ.Field("id")))
+	q = q.AppendField(tagQ.Field("name").Label("schedtag"))
+	q = q.AppendField(tagQ.Field("resource_type").Label("resource_type"))
+	orders = append(orders, query.OrderBySchedtag, query.OrderByResourceType)
+	fields = append(fields, subq.Field("schedtag"), subq.Field("resource_type"))
 	return q, orders, fields
 }
 

pkg/compute/models/secgroupresource.go

@@ -127,10 +127,14 @@ func (manager *SSecurityGroupResourceBaseManager) OrderByExtraFields(
 	userCred mcclient.TokenCredential,
 	query api.SecgroupFilterListInput,
 ) (*sqlchemy.SQuery, error) {
-	q, orders, fields := manager.GetOrderBySubQuery(q, userCred, query)
-	if len(orders) > 0 {
-		q = db.OrderByFields(q, orders, fields)
+	if !db.NeedOrderQuery(manager.GetOrderByFields(query)) {
+		return q, nil
 	}
+	orderQ := SecurityGroupManager.Query("id")
+	orderSubQ := orderQ.SubQuery()
+	orderQ, orders, fields := manager.GetOrderBySubQuery(orderQ, orderSubQ, orderQ.Field("id"), userCred, query, nil, nil)
+	q = q.LeftJoin(orderSubQ, sqlchemy.Equals(q.Field("secgroup_id"), orderSubQ.Field("id")))
+	q = db.OrderByFields(q, orders, fields)
 	return q, nil
 }
 
@@ -147,18 +151,21 @@ func (manager *SSecurityGroupResourceBaseManager) QueryDistinctExtraField(q *sql
 
 func (manager *SSecurityGroupResourceBaseManager) GetOrderBySubQuery(
 	q *sqlchemy.SQuery,
+	subq *sqlchemy.SSubQuery,
+	joinField sqlchemy.IQueryField,
 	userCred mcclient.TokenCredential,
 	query api.SecgroupFilterListInput,
+	orders []string,
+	fields []sqlchemy.IQueryField,
 ) (*sqlchemy.SQuery, []string, []sqlchemy.IQueryField) {
-	secgrpQ := SecurityGroupManager.Query("id", "name")
-	var orders []string
-	var fields []sqlchemy.IQueryField
-	if db.NeedOrderQuery(manager.GetOrderByFields(query)) {
-		subq := secgrpQ.SubQuery()
-		q = q.LeftJoin(subq, sqlchemy.Equals(q.Field("secgroup_id"), subq.Field("id")))
-		orders = append(orders, query.OrderBySecgroup)
-		fields = append(fields, subq.Field("name"))
+	if !db.NeedOrderQuery(manager.GetOrderByFields(query)) {
+		return q, orders, fields
 	}
+	secgrpQ := SecurityGroupManager.Query().SubQuery()
+	q = q.LeftJoin(secgrpQ, sqlchemy.Equals(joinField, secgrpQ.Field("id")))
+	q = q.AppendField(secgrpQ.Field("name").Label("secgroup"))
+	orders = append(orders, query.OrderBySecgroup)
+	fields = append(fields, subq.Field("secgroup"))
 	return q, orders, fields
 }
 

pkg/compute/models/snapshotpolicyresource.go

@@ -123,10 +123,14 @@ func (manager *SSnapshotPolicyResourceBaseManager) OrderByExtraFields(
 	userCred mcclient.TokenCredential,
 	query api.SnapshotPolicyFilterListInput,
 ) (*sqlchemy.SQuery, error) {
-	q, orders, fields := manager.GetOrderBySubQuery(q, userCred, query)
-	if len(orders) > 0 {
-		q = db.OrderByFields(q, orders, fields)
+	if !db.NeedOrderQuery(manager.GetOrderByFields(query)) {
+		return q, nil
 	}
+	orderQ := SnapshotPolicyManager.Query("id")
+	orderSubQ := orderQ.SubQuery()
+	orderQ, orders, fields := manager.GetOrderBySubQuery(orderQ, orderSubQ, orderQ.Field("id"), userCred, query, nil, nil)
+	q = q.LeftJoin(orderSubQ, sqlchemy.Equals(q.Field("snapshotpolicy_id"), orderSubQ.Field("id")))
+	q = db.OrderByFields(q, orders, fields)
 	return q, nil
 }
 
@@ -143,19 +147,21 @@ func (manager *SSnapshotPolicyResourceBaseManager) QueryDistinctExtraField(q *sq
 
 func (manager *SSnapshotPolicyResourceBaseManager) GetOrderBySubQuery(
 	q *sqlchemy.SQuery,
+	subq *sqlchemy.SSubQuery,
+	joinField sqlchemy.IQueryField,
 	userCred mcclient.TokenCredential,
 	query api.SnapshotPolicyFilterListInput,
+	orders []string,
+	fields []sqlchemy.IQueryField,
 ) (*sqlchemy.SQuery, []string, []sqlchemy.IQueryField) {
-	snapQ := SnapshotPolicyManager.Query("id", "name")
-	var orders []string
-	var fields []sqlchemy.IQueryField
-	if db.NeedOrderQuery(manager.GetOrderByFields(query)) {
-		subq := snapQ.SubQuery()
-		q = q.LeftJoin(subq, sqlchemy.Equals(q.Field("snapshotpolicy_id"), subq.Field("id")))
-		orders = append(orders, query.OrderBySnapshotpolicy)
-		fields = append(fields, subq.Field("name"))
+	if !db.NeedOrderQuery(manager.GetOrderByFields(query)) {
+		return q, orders, fields
 	}
-
+	snapQ := SnapshotPolicyManager.Query().SubQuery()
+	q = q.LeftJoin(snapQ, sqlchemy.Equals(joinField, snapQ.Field("id")))
+	q = q.AppendField(snapQ.Field("name").Label("snapshotpolicy"))
+	orders = append(orders, query.OrderBySnapshotpolicy)
+	fields = append(fields, subq.Field("snapshotpolicy"))
 	return q, orders, fields
 }
 

pkg/compute/models/storageresource.go

@@ -188,48 +188,36 @@ func (manager *SStorageResourceBaseManager) OrderByExtraFields(
 	userCred mcclient.TokenCredential,
 	query api.StorageFilterListInput,
 ) (*sqlchemy.SQuery, error) {
-	q, orders, fields := manager.GetOrderBySubQuery(q, userCred, query)
-	if len(orders) > 0 {
-		q = db.OrderByFields(q, orders, fields)
+	if !db.NeedOrderQuery(manager.GetOrderByFields(query)) {
+		return q, nil
 	}
+	orderQ := StorageManager.Query("id")
+	orderSubQ := orderQ.SubQuery()
+	orderQ, orders, fields := manager.GetOrderBySubQuery(orderQ, orderSubQ, orderQ.Field("id"), userCred, query, nil, nil)
+	q = q.LeftJoin(orderSubQ, sqlchemy.Equals(q.Field("storage_id"), orderSubQ.Field("id")))
+	q = db.OrderByFields(q, orders, fields)
 	return q, nil
 }
 
 func (manager *SStorageResourceBaseManager) GetOrderBySubQuery(
 	q *sqlchemy.SQuery,
+	subq *sqlchemy.SSubQuery,
+	joinField sqlchemy.IQueryField,
 	userCred mcclient.TokenCredential,
 	query api.StorageFilterListInput,
+	orders []string,
+	fields []sqlchemy.IQueryField,
 ) (*sqlchemy.SQuery, []string, []sqlchemy.IQueryField) {
-	storageQ := StorageManager.Query("id", "name")
-	var orders []string
-	var fields []sqlchemy.IQueryField
-
-	if db.NeedOrderQuery(manager.SZoneResourceBaseManager.GetOrderByFields(query.ZonalFilterListInput)) {
-		var zoneOrders []string
-		var zoneFields []sqlchemy.IQueryField
-		storageQ, zoneOrders, zoneFields = manager.SZoneResourceBaseManager.GetOrderBySubQuery(storageQ, userCred, query.ZonalFilterListInput)
-		if len(zoneOrders) > 0 {
-			orders = append(orders, zoneOrders...)
-			fields = append(fields, zoneFields...)
-		}
-	}
-	if db.NeedOrderQuery(manager.SManagedResourceBaseManager.GetOrderByFields(query.ManagedResourceListInput)) {
-		var manOrders []string
-		var manFields []sqlchemy.IQueryField
-		storageQ, manOrders, manFields = manager.SManagedResourceBaseManager.GetOrderBySubQuery(storageQ, userCred, query.ManagedResourceListInput)
-		if len(manOrders) > 0 {
-			orders = append(orders, manOrders...)
-			fields = append(fields, manFields...)
-		}
-	}
-	if db.NeedOrderQuery(manager.GetOrderByFields(query)) {
-		subq := storageQ.SubQuery()
-		q = q.LeftJoin(subq, sqlchemy.Equals(q.Field("storage_id"), subq.Field("id")))
-		if db.NeedOrderQuery([]string{query.OrderByStorage}) {
-			orders = append(orders, query.OrderByStorage)
-			fields = append(fields, subq.Field("name"))
-		}
+	if !db.NeedOrderQuery(manager.GetOrderByFields(query)) {
+		return q, orders, fields
 	}
+	storageQ := StorageManager.Query().SubQuery()
+	q = q.LeftJoin(storageQ, sqlchemy.Equals(joinField, storageQ.Field("id")))
+	q = q.AppendField(storageQ.Field("name").Label("storage"))
+	orders = append(orders, query.OrderByStorage)
+	fields = append(fields, subq.Field("storage"))
+	q, orders, fields = manager.SZoneResourceBaseManager.GetOrderBySubQuery(q, subq, storageQ.Field("storage_id"), userCred, query.ZonalFilterListInput, orders, fields)
+	q, orders, fields = manager.SManagedResourceBaseManager.GetOrderBySubQuery(q, subq, storageQ.Field("manager_id"), userCred, query.ManagedResourceListInput, orders, fields)
 	return q, orders, fields
 }
 

pkg/compute/models/vpcresource.go

@@ -222,47 +222,36 @@ func (manager *SVpcResourceBaseManager) OrderByExtraFields(
 	userCred mcclient.TokenCredential,
 	query api.VpcFilterListInput,
 ) (*sqlchemy.SQuery, error) {
-	q, orders, fields := manager.GetOrderBySubQuery(q, userCred, query)
-	if len(orders) > 0 {
-		q = db.OrderByFields(q, orders, fields)
+	if !db.NeedOrderQuery(manager.GetOrderByFields(query)) {
+		return q, nil
 	}
+	orderQ := VpcManager.Query("id")
+	orderSubQ := orderQ.SubQuery()
+	orderQ, orders, fields := manager.GetOrderBySubQuery(orderQ, orderSubQ, orderQ.Field("id"), userCred, query, nil, nil)
+	q = q.LeftJoin(orderSubQ, sqlchemy.Equals(q.Field("vpc_id"), orderSubQ.Field("id")))
+	q = db.OrderByFields(q, orders, fields)
 	return q, nil
 }
 
 func (manager *SVpcResourceBaseManager) GetOrderBySubQuery(
 	q *sqlchemy.SQuery,
+	subq *sqlchemy.SSubQuery,
+	subqField sqlchemy.IQueryField,
 	userCred mcclient.TokenCredential,
 	query api.VpcFilterListInput,
+	orders []string,
+	fields []sqlchemy.IQueryField,
 ) (*sqlchemy.SQuery, []string, []sqlchemy.IQueryField) {
-	vpcQ := VpcManager.Query("id", "name")
-	var orders []string
-	var fields []sqlchemy.IQueryField
-	if db.NeedOrderQuery(manager.SCloudregionResourceBaseManager.GetOrderByFields(query.RegionalFilterListInput)) {
-		var regionOrders []string
-		var regionFields []sqlchemy.IQueryField
-		vpcQ, regionOrders, regionFields = manager.SCloudregionResourceBaseManager.GetOrderBySubQuery(vpcQ, userCred, query.RegionalFilterListInput)
-		if len(regionOrders) > 0 {
-			orders = append(orders, regionOrders...)
-			fields = append(fields, regionFields...)
-		}
-	}
-	if db.NeedOrderQuery(manager.SManagedResourceBaseManager.GetOrderByFields(query.ManagedResourceListInput)) {
-		var managerOrders []string
-		var managerFields []sqlchemy.IQueryField
-		vpcQ, managerOrders, managerFields = manager.SManagedResourceBaseManager.GetOrderBySubQuery(vpcQ, userCred, query.ManagedResourceListInput)
-		if len(managerOrders) > 0 {
-			orders = append(orders, managerOrders...)
-			fields = append(fields, managerFields...)
-		}
-	}
-	if db.NeedOrderQuery(manager.GetOrderByFields(query)) {
-		subq := vpcQ.SubQuery()
-		q = q.LeftJoin(subq, sqlchemy.Equals(q.Field("vpc_id"), subq.Field("id")))
-		if db.NeedOrderQuery([]string{query.OrderByVpc}) {
-			orders = append(orders, query.OrderByVpc)
-			fields = append(fields, subq.Field("name"))
-		}
+	if !db.NeedOrderQuery(manager.GetOrderByFields(query)) {
+		return q, orders, fields
 	}
+	vpcQ := VpcManager.Query().SubQuery()
+	q = q.LeftJoin(vpcQ, sqlchemy.Equals(subqField, vpcQ.Field("id")))
+	q = q.AppendField(vpcQ.Field("name").Label("vpc"))
+	orders = append(orders, query.OrderByVpc)
+	fields = append(fields, subq.Field("vpc"))
+	q, orders, fields = manager.SCloudregionResourceBaseManager.GetOrderBySubQuery(q, subq, vpcQ.Field("cloudregion_id"), userCred, query.RegionalFilterListInput, orders, fields)
+	q, orders, fields = manager.SManagedResourceBaseManager.GetOrderBySubQuery(q, subq, vpcQ.Field("manager_id"), userCred, query.ManagedResourceListInput, orders, fields)
 	return q, orders, fields
 }
 

pkg/compute/models/wireresource.go

@@ -244,53 +244,39 @@ func (manager *SWireResourceBaseManager) OrderByExtraFields(
 	userCred mcclient.TokenCredential,
 	query api.WireFilterListInput,
 ) (*sqlchemy.SQuery, error) {
-	q, orders, fields := manager.GetOrderBySubQuery(q, userCred, query)
-	if len(orders) > 0 {
-		q = db.OrderByFields(q, orders, fields)
+	if !db.NeedOrderQuery(manager.GetOrderByFields(query)) {
+		return q, nil
 	}
+	orderQ := WireManager.Query("id")
+	orderSubQ := orderQ.SubQuery()
+	orderQ, orders, fields := manager.GetOrderBySubQuery(orderQ, orderSubQ, orderQ.Field("id"), userCred, query, nil, nil)
+	q = q.LeftJoin(orderSubQ, sqlchemy.Equals(q.Field("wire_id"), orderSubQ.Field("id")))
+	q = db.OrderByFields(q, orders, fields)
 	return q, nil
 }
 
 func (manager *SWireResourceBaseManager) GetOrderBySubQuery(
 	q *sqlchemy.SQuery,
+	subq *sqlchemy.SSubQuery,
+	joinField sqlchemy.IQueryField,
 	userCred mcclient.TokenCredential,
 	query api.WireFilterListInput,
+	orders []string,
+	fields []sqlchemy.IQueryField,
 ) (*sqlchemy.SQuery, []string, []sqlchemy.IQueryField) {
-	wireQ := WireManager.Query("id", "name")
-	var orders []string
-	var fields []sqlchemy.IQueryField
+	if !db.NeedOrderQuery(manager.GetOrderByFields(query)) {
+		return q, orders, fields
+	}
+	wireQ := WireManager.Query().SubQuery()
+	q = q.LeftJoin(wireQ, sqlchemy.Equals(joinField, wireQ.Field("id")))
+	q = q.AppendField(wireQ.Field("name").Label("wire"))
+	orders = append(orders, query.OrderByWire)
+	fields = append(fields, subq.Field("wire"))
 	zoneQuery := api.ZonalFilterListInput{
 		ZonalFilterListBase: query.ZonalFilterListBase,
 	}
-	if db.NeedOrderQuery(manager.SZoneResourceBaseManager.GetOrderByFields(zoneQuery)) {
-		var zoneOrders []string
-		var zoneFields []sqlchemy.IQueryField
-		wireQ, zoneOrders, zoneFields = manager.SZoneResourceBaseManager.GetOrderBySubQuery(wireQ, userCred, zoneQuery)
-		if len(zoneOrders) > 0 {
-			orders = append(orders, zoneOrders...)
-			fields = append(fields, zoneFields...)
-		}
-	}
-
-	if db.NeedOrderQuery(manager.SVpcResourceBaseManager.GetOrderByFields(query.VpcFilterListInput)) {
-		var vpcOrders []string
-		var vpcFields []sqlchemy.IQueryField
-		wireQ, vpcOrders, vpcFields = manager.SVpcResourceBaseManager.GetOrderBySubQuery(wireQ, userCred, query.VpcFilterListInput)
-		if len(vpcOrders) > 0 {
-			orders = append(orders, vpcOrders...)
-			fields = append(fields, vpcFields...)
-		}
-	}
-
-	if db.NeedOrderQuery(manager.GetOrderByFields(query)) {
-		subq := wireQ.SubQuery()
-		q = q.LeftJoin(subq, sqlchemy.Equals(q.Field("wire_id"), subq.Field("id")))
-		if db.NeedOrderQuery([]string{query.OrderByWire}) {
-			orders = append(orders, query.OrderByWire)
-			fields = append(fields, subq.Field("name"))
-		}
-	}
-
+	q, orders, fields = manager.SZoneResourceBaseManager.GetOrderBySubQuery(q, subq, wireQ.Field("zone_id"), userCred, zoneQuery, orders, fields)
+	q, orders, fields = manager.SVpcResourceBaseManager.GetOrderBySubQuery(q, subq, wireQ.Field("vpc_id"), userCred, query.VpcFilterListInput, orders, fields)
 	return q, orders, fields
 }
 

pkg/compute/models/zoneresource.go

@@ -151,32 +151,35 @@ func (manager *SZoneResourceBaseManager) OrderByExtraFields(
 	userCred mcclient.TokenCredential,
 	query api.ZonalFilterListInput,
 ) (*sqlchemy.SQuery, error) {
-	q, orders, fields := manager.GetOrderBySubQuery(q, userCred, query)
-	if len(orders) > 0 {
-		q = db.OrderByFields(q, orders, fields)
+	if !db.NeedOrderQuery(manager.GetOrderByFields(query)) {
+		return q, nil
 	}
+	orderQ := ZoneManager.Query("id")
+	orderSubQ := orderQ.SubQuery()
+	orderQ, orders, fields := manager.GetOrderBySubQuery(orderQ, orderSubQ, orderQ.Field("id"), userCred, query, nil, nil)
+	q = q.LeftJoin(orderSubQ, sqlchemy.Equals(q.Field("zone_id"), orderSubQ.Field("id")))
+	q = db.OrderByFields(q, orders, fields)
 	return q, nil
 }
 
 func (manager *SZoneResourceBaseManager) GetOrderBySubQuery(
 	q *sqlchemy.SQuery,
+	subq *sqlchemy.SSubQuery,
+	joinField sqlchemy.IQueryField,
 	userCred mcclient.TokenCredential,
 	query api.ZonalFilterListInput,
+	orders []string,
+	fields []sqlchemy.IQueryField,
 ) (*sqlchemy.SQuery, []string, []sqlchemy.IQueryField) {
-	zoneQ := ZoneManager.Query("id", "name")
-	var orders []string
-	var fields []sqlchemy.IQueryField
-	if db.NeedOrderQuery(manager.SCloudregionResourceBaseManager.GetOrderByFields(query.RegionalFilterListInput)) {
-		zoneQ, orders, fields = manager.SCloudregionResourceBaseManager.GetOrderBySubQuery(zoneQ, userCred, query.RegionalFilterListInput)
-	}
-	if db.NeedOrderQuery(manager.GetOrderByFields(query)) {
-		subq := zoneQ.SubQuery()
-		q = q.LeftJoin(subq, sqlchemy.Equals(q.Field("zone_id"), subq.Field("id")))
-		if db.NeedOrderQuery([]string{query.OrderByZone}) {
-			orders = append(orders, query.OrderByZone)
-			fields = append(fields, subq.Field("name"))
-		}
+	if !db.NeedOrderQuery(manager.GetOrderByFields(query)) {
+		return q, orders, fields
 	}
+	zoneQ := ZoneManager.Query().SubQuery()
+	q = q.LeftJoin(zoneQ, sqlchemy.Equals(joinField, zoneQ.Field("id")))
+	q = q.AppendField(zoneQ.Field("name").Label("zone"))
+	orders = append(orders, query.OrderByZone)
+	fields = append(fields, subq.Field("zone"))
+	q, orders, fields = manager.SCloudregionResourceBaseManager.GetOrderBySubQuery(q, subq, zoneQ.Field("cloudregion_id"), userCred, query.RegionalFilterListInput, orders, fields)
 	return q, orders, fields
 }