Fix: Long column identifiers in deeply nested joins cause fields to be omitted #7513

Author: IgorStepanov

callbacks/query.go

@@ -40,6 +40,9 @@ func BuildQuerySQL(db *gorm.DB) {
 		}
 	}
 
+	if db.Statement.TruncatedFields == nil {
+		db.Statement.TruncatedFields = make(map[string]string)
+	}
 	if db.Statement.SQL.Len() == 0 {
 		db.Statement.SQL.Grow(100)
 		clauseSelect := clause.Select{Distinct: db.Statement.Distinct}
@@ -158,11 +161,17 @@ func BuildQuerySQL(db *gorm.DB) {
 							selectColumns, restricted := columnStmt.SelectAndOmitColumns(false, false)
 							for _, s := range relation.FieldSchema.DBNames {
 								if v, ok := selectColumns[s]; (ok && v) || (!ok && !restricted) {
+									aliasName := db.NamingStrategy.JoinNestedRelationNames([]string{tableAliasName, s})
 									clauseSelect.Columns = append(clauseSelect.Columns, clause.Column{
 										Table: tableAliasName,
 										Name:  s,
-										Alias: utils.NestedRelationName(tableAliasName, s),
+										Alias: aliasName,
 									})
+									origTableAliasName := tableAliasName
+									if alias, ok := db.Statement.TruncatedFields[tableAliasName]; ok {
+										origTableAliasName = alias
+									}
+									db.Statement.TruncatedFields[aliasName] = utils.NestedRelationName(origTableAliasName, s)
 								}
 							}
 
@@ -236,7 +245,9 @@ func BuildQuerySQL(db *gorm.DB) {
 							// joins table alias like "Manager, Company, Manager__Company"
 							curAliasName := rel.Name
 							if parentTableName != clause.CurrentTable {
-								curAliasName = utils.NestedRelationName(parentTableName, curAliasName)
+								aliasName := db.NamingStrategy.JoinNestedRelationNames([]string{parentTableName, curAliasName})
+								db.Statement.TruncatedFields[aliasName] = utils.NestedRelationName(parentTableName, curAliasName)
+								curAliasName = aliasName
 							}
 
 							if _, ok := specifiedRelationsName[curAliasName]; !ok {

scan.go

@@ -227,6 +227,9 @@ func Scan(rows Rows, db *DB, mode ScanMode) {
 			if sch != nil {
 				matchedFieldCount := make(map[string]int, len(columns))
 				for idx, column := range columns {
+					if origName, ok := db.Statement.TruncatedFields[column]; ok {
+						column = origName
+					}
 					if field := sch.LookUpField(column); field != nil && field.Readable {
 						fields[idx] = field
 						if count, ok := matchedFieldCount[column]; ok {

schema/naming.go

@@ -2,11 +2,14 @@ package schema
 
 import (
 	"crypto/sha1"
+	"crypto/sha256"
 	"encoding/hex"
 	"regexp"
 	"strings"
 	"unicode/utf8"
 
+	"gorm.io/gorm/utils"
+
 	"github.com/jinzhu/inflection"
 	"golang.org/x/text/cases"
 	"golang.org/x/text/language"
@@ -22,6 +25,7 @@ type Namer interface {
 	CheckerName(table, column string) string
 	IndexName(table, column string) string
 	UniqueName(table, column string) string
+	JoinNestedRelationNames(relationNames []string) string
 }
 
 // Replacer replacer interface like strings.Replacer
@@ -95,6 +99,29 @@ func (ns NamingStrategy) UniqueName(table, column string) string {
 	return ns.formatName("uni", table, ns.toDBName(column))
 }
 
+// JoinNestedRelationNames nested relationships like `Manager__Company` with enforcing IdentifierMaxLength
+func (ns NamingStrategy) JoinNestedRelationNames(relationNames []string) string {
+	tableAlias := utils.JoinNestedRelationNames(relationNames)
+	return ns.truncateName(tableAlias)
+}
+
+// TruncatedName generate truncated name
+func (ns NamingStrategy) truncateName(ident string) string {
+	formattedName := ident
+	if ns.IdentifierMaxLength == 0 {
+		ns.IdentifierMaxLength = 64
+	}
+
+	if utf8.RuneCountInString(formattedName) > ns.IdentifierMaxLength {
+		h := sha256.New224()
+		h.Write([]byte(formattedName))
+		bs := h.Sum(nil)
+
+		formattedName = formattedName[0:ns.IdentifierMaxLength-8] + hex.EncodeToString(bs)[:8]
+	}
+	return formattedName
+}
+
 func (ns NamingStrategy) formatName(prefix, table, name string) string {
 	formattedName := strings.ReplaceAll(strings.Join([]string{
 		prefix, table, name,

statement.go

@@ -47,6 +47,7 @@ type Statement struct {
 	attrs                []interface{}
 	assigns              []interface{}
 	scopes               []func(*DB) *DB
+	TruncatedFields      map[string]string
 	Result               *result
 }
 

tests/joins_test.go

@@ -476,3 +476,61 @@ func TestJoinsPreload_Issue7013_NoEntries(t *testing.T) {
 
 	AssertEqual(t, len(entries), 0)
 }
+
+func TestJoinsLongName_Issue7513(t *testing.T) {
+	type (
+		Owner struct {
+			gorm.Model
+			Name string
+		}
+
+		Land struct {
+			gorm.Model
+			Address                                                                             string
+			OwneeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeerID uint `gorm:"column:owner_id"`
+			Owneeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeer   *Owner
+		}
+
+		Building struct {
+			gorm.Model
+			Name                                                                                string
+			LanaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaadID uint `gorm:"column:land_id"`
+			Lanaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaad   *Land
+		}
+	)
+
+	DB.Migrator().DropTable(&Building{}, &Owner{}, &Land{})
+	DB.Migrator().AutoMigrate(&Building{}, &Owner{}, &Land{})
+
+	home := &Building{
+		Model: gorm.Model{
+			ID: 1,
+		},
+		Name: "Awesome Building",
+		LanaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaadID: 2,
+		Lanaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaad: &Land{
+			Model: gorm.Model{
+				ID: 2,
+			},
+			Address: "Awesome Street",
+			OwneeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeerID: 3,
+			Owneeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeer: &Owner{
+				Model: gorm.Model{
+					ID: 3,
+				},
+				Name: "Awesome Person",
+			},
+		},
+	}
+	DB.Create(home)
+
+	var entries []Building
+	assert.NotPanics(t, func() {
+		assert.NoError(t,
+			DB.Joins("Lanaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaad").
+				Joins("Lanaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaad.Owneeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeer").
+				Find(&entries).Error)
+	})
+
+	AssertEqual(t, entries, []Building{*home})
+}