},
				NamedPet: &Pet{
					Name: "generics-nested-joins-manager-namepet-1",
					Toy: Toy{
						Name: "generics-nested-joins-manager-namepet-toy-1",
					},
				},
			},
			NamedPet: &Pet{Name: "generics-nested-joins-namepet-1", Toy: Toy{Name: "generics-nested-joins-namepet-toy-1"}},
		},
		{
			Name:     "generics-nested-joins-2",

		}
	}
}

// User has many Toys, its `Polymorphic` is `Owner`, Pet has one Toy, its `Polymorphic` is `Owner`
//
//	type User struct {
//	  Toys []Toy `gorm:"polymorphic:Owner;"`
//	}
//	type Pet struct {
//	  Toy Toy `gorm:"polymorphic:Owner;"`
//	}
//	type Toy struct {
//	  OwnerID   int
//	  OwnerType string
//	}

		},
		{
			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}},
		},
		{
			Name: "Company", Type: schema.BelongsTo, Schema: "User", FieldSchema: "Company",

# Erasure code sizing guide

## Toy Setups

Capacity constrained environments, MinIO will work but not recommended for production.

| servers | drives (per node) | stripe_size | parity chosen (default) | tolerance for reads (servers) | tolerance for writes (servers) |
|--------:|------------------:|------------:|------------------------:|------------------------------:|-------------------------------:|

	t.Run("Polymorphic", func(t *testing.T) {
		user := *GetUser("update-has-many", Config{})

		if err := DB.Create(&user).Error; err != nil {
			t.Fatalf("errors happened when create: %v", err)
		}

		user.Toys = []Toy{{Name: "toy1"}, {Name: "toy2"}}
		if err := DB.Save(&user).Error; err != nil {
			t.Fatalf("errors happened when update: %v", err)
		}

		var user2 User
		DB.Preload("Toys").Find(&user2, "id = ?", user.ID)

And an `APIRoute` subclass to use that custom request class.

### Create a custom `GzipRequest` class { #create-a-custom-gziprequest-class }

/// tip

This is a toy example to demonstrate how it works, if you need Gzip support, you can use the provided [`GzipMiddleware`](../advanced/middleware.md#gzipmiddleware).

///

```json
{
    "reason": <string>
}
```

The reason message is returned to the client.

## Example Plugin Implementation

	} else if debug == "false" {
		db.Logger = db.Logger.LogMode(logger.Silent)
	}

	return
}

func RunMigrations() {
	var err error
	allModels := []interface{}{&User{}, &Account{}, &Pet{}, &Company{}, &Toy{}, &Language{}, &Coupon{}, &CouponProduct{}, &Order{}, &Parent{}, &Child{}, &Tools{}}
	rand.Seed(time.Now().UnixNano())
	rand.Shuffle(len(allModels), func(i, j int) { allModels[i], allModels[j] = allModels[j], allModels[i] })

The command deploys MinIO on the Kubernetes cluster in the default configuration. The [configuration](#configuration) section lists the parameters that can be configured during installation.

### Installing the Chart (toy-setup)

Minimal toy setup for testing purposes can be deployed using:

```bash

	// Create a user with initial associations using real database
	user := User{Name: "TestClauseAssociationSetUpdateWithMultipleAssociations", Age: 25}
	user.Pets = []*Pet{{Name: "original-pet"}}
	user.Toys = []Toy{{Name: "original-toy"}}
	if err := DB.Create(&user).Error; err != nil {
		t.Fatalf("failed to create user with associations: %v", err)
	}

	// Verify initial state using real database queries