}

	DB.Create(&thing)

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

	result := DB.Clauses(clause.OnConflict{
		OnConstraint: "some_id_other_id_unique",
		UpdateAll:    true,
	}).Create(&thing2)
	if result.Error != nil {
		t.Errorf("creating second thing: %v", result.Error)
	}

	var things []Thing
	if err := DB.Find(&things).Error; err != nil {

	}

	DB.Create(&thing)

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

	result := DB.Clauses(clause.OnConflict{
		OnConstraint: "some_id_other_id_unique",
		UpdateAll:    true,
	}).Create(&thing2)
	if result.Error != nil {
		t.Errorf("creating second thing: %v", result.Error)
	}

	var things []Thing
	if err := DB.Find(&things).Error; err != nil {

import java.util.List;
import java.util.Map;
import org.jspecify.annotations.NullMarked;
import org.jspecify.annotations.Nullable;

/**
 * To be implemented by test generators of things that can contain elements. Such things include
 * both {@link Collection} and {@link Map}; since there isn't an established collective noun that
 * encompasses both of these, 'container' is used.
 *
 * @author George van den Driessche
 */

      - "https://server3-pool1:9000/mnt/disk{1...4}/"
      - "https://server4-pool1:9000/mnt/disk{1...4}/"
    set-drive-count: 4 # Advanced option, must be used under guidance from MinIO team.
```

### Things to know

- Fields such as `version` and `pools` are mandatory, however all other fields are optional.
- Each pool expects a minimum of 2 nodes per pool, and unique non-repeating hosts for each argument.

import java.util.List;
import java.util.Map;
import org.jspecify.annotations.NullMarked;
import org.jspecify.annotations.Nullable;

/**
 * To be implemented by test generators of things that can contain elements. Such things include
 * both {@link Collection} and {@link Map}; since there isn't an established collective noun that
 * encompasses both of these, 'container' is used.
 *
 * @author George van den Driessche
 */

## What is "Dependency Injection" { #what-is-dependency-injection }

**"Dependency Injection"** means, in programming, that there is a way for your code (in this case, your *path operation functions*) to declare things that it requires to work and use: "dependencies".

And then, that system (in this case **FastAPI**) will take care of doing whatever is needed to provide your code with those needed dependencies ("inject" the dependencies).

## Getting Started

* GORM Guides [https://gorm.io](https://gorm.io)
* Gen Guides [https://gorm.io/gen/index.html](https://gorm.io/gen/index.html)

## Contributing

[You can help to deliver a better GORM, check out things you can do](https://gorm.io/contribute.html)

## Contributors

[Thank you](https://github.com/go-gorm/gorm/graphs/contributors) for contributing to the GORM framework!

## License

© Jinzhu, 2013~time.Now

#### Shared reader thread

We can't rely on application threads to read data from the socket. Application threads are transient: sometimes they're reading and writing and sometimes they're off doing application-layer things. But the socket is permanent, and it needs constant attention: we dispatch all incoming frames so the connection is good-to-go when the application layer needs it.

If you want to secure your API, there are several better things you can do, for example:

* Make sure you have well defined Pydantic models for your request bodies and responses.
* Configure any required permissions and roles using dependencies.

## How to enable Fan-Out Uploads ?

Fan-Out uploads are automatically enabled if `x-minio-fanout-list` form-field is provided with the PostUpload API, to keep things simple higher level APIs are provided in our SDKs for example in `minio-go` SDK:

```