Priority   int
}

// ParseIndexes parse schema indexes
func (schema *Schema) ParseIndexes() []*Index {
	indexesByName := map[string]*Index{}
	indexes := []*Index{}

	for _, field := range schema.Fields {
		if field.TagSettings["INDEX"] != "" || field.TagSettings["UNIQUEINDEX"] != "" {
			fieldIndexes, err := parseFieldIndexes(field)
			if err != nil {
				schema.err = err
				break
			}

### Same Schema for Input and Output Models in Docs { #same-schema-for-input-and-output-models-in-docs }

And now there will be one single schema for input and output for the model, only `Item`, and it will have `description` as **not required**:

<div class="screenshot">
<img src="/img/tutorial/separate-openapi-schemas/image05.png">
</div>

        application/json:
          schema:
            $ref: '#/components/schemas/Error'
    Unauthorized:
      description: Unauthorized request
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/Error'
    NotFound:
      description: Page not found
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/Error'

			if r.Name != relation.Name {
				t.Errorf("schema %v relation name expects %v, but got %v", s, r.Name, relation.Name)
			}

			if r.Type != relation.Type {
				t.Errorf("schema %v relation name expects %v, but got %v", s, r.Type, relation.Type)
			}

			if r.Schema.Name != relation.Schema {
				t.Errorf("schema %v relation's schema expects %v, but got %v", s, relation.Schema, r.Schema.Name)
			}

                    "schema": {
                        "$ref": "#/components/schemas/Message"
                    }
                }
            }
        },
        "200": {
            "description": "Successful Response",
            "content": {
                "application/json": {
                    "schema": {
                        "$ref": "#/components/schemas/Item"
                    }

        #  Additional schemas have original settings apart from the main schema.
        #  The settings are objectTypeTargetList, tableExceptList,
        #  tableTargetList, and columnExceptMap.
        #  They have the same specification as ones of the main schema.
        #  Elements of this map are as below: 
        #    o objectTypeTargetList: (NotRequired - Default 'map:{TABLE;VIEW}')
        #    o tableExceptList: (NotRequired - Default list:{})

	"database/sql/driver"
	"reflect"
	"strings"
	"time"

	"gorm.io/gorm/schema"
	"gorm.io/gorm/utils"
)

// prepareValues prepare values slice
func prepareValues(values []interface{}, db *DB, columnTypes []*sql.ColumnType, columns []string) {
	if db.Statement.Schema != nil {
		for idx, name := range columns {
			if field := db.Statement.Schema.LookUpField(name); field != nil {

                "application/json": {
                    "schema": {
                        "$ref": "#/components/schemas/HTTPValidationError"
                    }
                }
            }
        }
    }
}
```

Die Schemas werden von einer anderen Stelle innerhalb des OpenAPI-Schemas referenziert:

```JSON hl_lines="4-16"
{
    "components": {
        "schemas": {
            "Message": {

### OpenAPI

**FastAPI** 使用定義 API 的 **OpenAPI** 標準來生成一個 「schema」 與你的所有 API。

#### 「Schema」

「schema」是對某個事物的定義或描述。它並不是實作它的程式碼，而僅僅是一個抽象的描述。

#### API 「schema」

在這種情況下，<a href="https://github.com/OAI/OpenAPI-Specification" class="external-link" target="_blank">OpenAPI</a> 是一個規範，它規定了如何定義 API 的 schema。

這個 schema 定義包含了你的 API 路徑、可能接收的參數等內容。

#### 資料 「schema」

「schema」這個術語也可能指某些資料的結構，比如 JSON 內容的結構。

			}
		}

		switch rel.Type {
		case schema.BelongsTo:
			associationDB := association.DB.Session(&Session{})
			tx := associationDB.Model(reflect.New(rel.Schema.ModelType).Interface())

			_, pvs := schema.GetIdentityFieldValuesMap(association.DB.Statement.Context, reflectValue, rel.Schema.PrimaryFields)
			if pcolumn, pvalues := schema.ToQueryValues(rel.Schema.Table, rel.Schema.PrimaryFieldDBNames, pvs); len(pvalues) > 0 {