{Name: "OwnerID", DBName: "company_owner_id", BindNames: []string{"Base", "OwnerID"}, DataType: schema.Int, Size: 64, TagSettings: map[string]string{"EMBEDDED": "EMBEDDED", "EMBEDDEDPREFIX": "company_"}},
		{Name: "OwnerID", DBName: "owner_id", BindNames: []string{"CorpBase", "OwnerID"}, DataType: schema.String},
	}

	for _, f := range fields {

						FieldSchema: "Toy",
						Polymorphic: Polymorphic{ID: "owner_id", Type: "Type", Value: "users"},
						References: []Reference{
							{ForeignKey: "Type", ForeignSchema: "Toy", PrimaryValue: "users"},
						},
					},
				},
			},
		})
	})

	t.Run("has many", func(t *testing.T) {
		type Toy struct {
			ID        int
			Name      string
			OwnerID   int
			OwnerType string
		}

		}
	}

	AssertObjEqual(t, pet, expect, "ID", "CreatedAt", "UpdatedAt", "DeletedAt", "UserID", "Name")

	AssertObjEqual(t, pet.Toy, expect.Toy, "ID", "CreatedAt", "UpdatedAt", "DeletedAt", "Name", "OwnerID", "OwnerType")

	if expect.Toy.Name != "" && expect.Toy.OwnerType != "pets" {
		t.Errorf("toys's OwnerType, expect: %v, got %v", "pets", expect.Toy.OwnerType)
	}
}

        prepareMinimalSecurityDescriptorBuffer(testBuffer, 0, true, false, false);

        securityDescriptor.decode(testBuffer, 0, testBuffer.length);

        SID ownerSid = securityDescriptor.getOwnerUserSid();
        assertNotNull(ownerSid);
        assertEquals(1, ownerSid.sub_authority_count);
    }

    @Test
    @DisplayName("Test getOwnerGroupSid returns correct SID")

	Number string
}

type Pet struct {
	gorm.Model
	UserID *uint
	Name   string
	Toy    Toy `gorm:"polymorphic:Owner;"`
}

type Toy struct {
	gorm.Model
	Name      string
	OwnerID   string
	OwnerType string
}

type Tools struct {
	gorm.Model
	Name     string
	CustomID string
	Type     string
}

type Company struct {
	ID   int
	Name string
}

func TestJoinsPreload_Issue7013_RelationEmpty(t *testing.T) {
	type (
		Furniture struct {
			gorm.Model
			OwnerID *uint
		}

		Owner struct {
			gorm.Model
			Furnitures []Furniture
			CompanyID  *uint
			Company    Company
		}

		Building struct {
			gorm.Model
			Name    string
			OwnerID *uint
			Owner   Owner
		}
	)

	DB.Migrator().DropTable(&Building{}, &Owner{}, &Furniture{})

		OtherID string
		Data    string
	}

	DB.Migrator().DropTable(&Thing{})
	DB.Migrator().CreateTable(&Thing{})
	if err := DB.Exec("ALTER TABLE things ADD CONSTRAINT some_id_other_id_unique UNIQUE (some_id, other_id)").Error; err != nil {
		t.Error(err)
	}

	thing := Thing{
		SomeID:  "1234",
		OtherID: "1234",
		Data:    "something",
	}

	DB.Create(&thing)

	thing2 := Thing{

		OtherID string
		Data    string
	}

	DB.Migrator().DropTable(&Thing{})
	DB.Migrator().CreateTable(&Thing{})
	if err := DB.Exec("ALTER TABLE things ADD CONSTRAINT some_id_other_id_unique UNIQUE (some_id, other_id)").Error; err != nil {
		t.Error(err)
	}

	thing := Thing{
		SomeID:  "1234",
		OtherID: "1234",
		Data:    "something",
	}

	DB.Create(&thing)

	thing2 := Thing{

//
//	type User struct {
//	  Toys []Toy `gorm:"polymorphic:Owner;"`
//	}
//	type Pet struct {
//	  Toy Toy `gorm:"polymorphic:Owner;"`
//	}
//	type Toy struct {
//	  OwnerID   int
//	  OwnerType string
//	}
func (schema *Schema) buildPolymorphicRelation(relation *Relationship, field *Field) {
	polymorphic := field.TagSettings["POLYMORPHIC"]

	relation.Polymorphic = &Polymorphic{

For example, if you have an app like this:

```Python
from fastapi import FastAPI
from pydantic import BaseModel

class Item(BaseModel):
    name: str
    price: Optional[float] = None
    owner_ids: Optional[List[int]] = None

app = FastAPI()

@app.get("/items/invalidnone", response_model=Item)
def get_invalid_none():
    return None
```