//	  OwnerType string
//	}
func (schema *Schema) buildPolymorphicRelation(relation *Relationship, field *Field) {
	polymorphic := field.TagSettings["POLYMORPHIC"]

	relation.Polymorphic = &Polymorphic{
		Value: schema.Table,
	}

	var (
		typeName = polymorphic + "Type"
		typeId   = polymorphic + "ID"
	)

	if value, ok := field.TagSettings["POLYMORPHICTYPE"]; ok {
		typeName = strings.TrimSpace(value)
	}

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

	t.Run("has one with custom polymorphic type and id", func(t *testing.T) {
		type Toy struct {
			ID    int

			}

			if r.Polymorphic != nil {
				if r.Polymorphic.PolymorphicID.Name != relation.Polymorphic.ID {
					t.Errorf("schema %v relation's polymorphic id field expects %v, but got %v", s, relation.Polymorphic.ID, r.Polymorphic.PolymorphicID.Name)
				}

				if r.Polymorphic.PolymorphicType.Name != relation.Polymorphic.Type {

)

// User has one `Account` (has one), many `Pets` (has many) and `Toys` (has many - polymorphic)
// He works in a Company (belongs to), he has a Manager (belongs to - single-table), and also managed a Team (has many - single-table)
// He speaks many languages (many to many) and has many friends (many to many - single-table)
// His pet also has one Toy (has one - polymorphic)
// NamedPet is a reference to a named `Pet` (has one)
type User struct {

			References: []Reference{{"ID", "User", "UserID", "Pet", "", true}},
		},
		{
			Name: "Toys", Type: schema.HasMany, Schema: "User", FieldSchema: "Toy",
			Polymorphic: Polymorphic{ID: "OwnerID", Type: "OwnerType", Value: "users"},
			References:  []Reference{{"ID", "User", "OwnerID", "Toy", "", true}, {"", "", "OwnerType", "Toy", "users", false}},
		},
		{

	// Find
	var toys []Toy
	if DB.Model(&users).Association("Toys").Find(&toys); len(toys) != 6 {
		t.Errorf("toys count should be %v, but got %v", 6, len(toys))
	}

	// Find Tools (polymorphic with custom type and id)
	var tools []Tools
	DB.Model(&users).Association("Tools").Find(&tools)

	if len(tools) != 2 {
		t.Errorf("tools count should be %v, but got %v", 2, len(tools))
	}

	// Append

<code>Add</code> and <code>Slice</code>.
</li>
</ul>

<h4 id="Go_1.18">Go 1.18</h4>
<p>
The 1.18 release adds polymorphic functions and types ("generics") to the language.
Specifically:
</p>
<ul>
<li>
The set of <a href="#Operators_and_punctuation">operators and punctuation</a> includes the new token <code>~</code>.
</li>