type Person struct {
		ID       int
		Likes    []Thing `gorm:"many2many:likes"`
		Dislikes []Thing `gorm:"many2many:dislikes"`
	}

	checkStructRelation(t, &Person{},
		Relation{
			Name: "Likes", Type: schema.Many2Many, Schema: "Person", FieldSchema: "Thing",
			JoinTable: JoinTable{Name: "likes", Table: "likes"},
			References: []Reference{
				{"ID", "Person", "PersonID", "likes", "", true},

      } finally {
        // Ensure that if the thread was interrupted at all while processing the task queue, it
        // is returned to the delegate Executor interrupted so that it may handle the
        // interruption if it likes.
        if (interruptedDuringTask) {
          Thread.currentThread().interrupt();
        }
      }
    }

    @SuppressWarnings("GuardedBy")
    @Override
    public String toString() {

GOEXPERIMENT=cgocheck2 at build time.

It is possible to defeat this enforcement by using the unsafe package,
and of course there is nothing stopping the C code from doing anything
it likes. However, programs that break these rules are likely to fail
in unexpected and unpredictable ways.

The runtime/cgo.Handle type can be used to safely pass Go values

  `It's a friend of mine--a Cheshire Cat,' said Alice:  `allow me
to introduce it.'

  `I don't like the look of it at all,' said the King:
`however, it may kiss my hand if it likes.'

  `I'd rather not,' the Cat remarked.

  `Don't be impertinent,' said the King, `and don't look at me
like that!'  He got behind Alice as he spoke.

  `A cat may look at a king,' said Alice.  `I've read that in

  `It's a friend of mine--a Cheshire Cat,' said Alice:  `allow me
to introduce it.'

  `I don't like the look of it at all,' said the King:
`however, it may kiss my hand if it likes.'

  `I'd rather not,' the Cat remarked.

  `Don't be impertinent,' said the King, `and don't look at me
like that!'  He got behind Alice as he spoke.

  `A cat may look at a king,' said Alice.  `I've read that in

lib.oh.us lib.ok.us lib.or.us lib.pa.us lib.pr.us lib.ri.us lib.sc.us lib.sd.us lib.tn.us lib.tx.us lib.ut.us lib.va.us lib.vi.us lib.vt.us lib.wa.us lib.wi.us lib.wy.us lidl lier.no lierne.no life lifeinsurance lifestyle lig.it lighting liguria.it like likes-pie.com likescandy.com lillehammer.no lillesand.no lilly lima-city.at lima-city.ch lima-city.de lima-city.rocks lima.zone limanowa.pl limited limo lincoln lincoln.museum lindas.no linde lindesnes.no lindås.no link linkyard-cloud.ch linkyard.cloud...

So, instead of adding all that to each *path operation*, we can add it to the `APIRouter`.

```Python hl_lines="5-10  16  21" title="app/routers/items.py"
{!../../../docs_src/bigger_applications/app/routers/items.py!}
```

As the path of each *path operation* has to start with `/`, like in:

```Python hl_lines="1"
@router.get("/{item_id}")
async def read_item(item_id: str):
    ...
```

If you pass a custom list of `servers` and there's a `root_path` (because your API lives behind a proxy), **FastAPI** will insert a "server" with this `root_path` at the beginning of the list.

For example:

```Python hl_lines="4-7"
{!../../../docs_src/behind_a_proxy/tutorial003.py!}
```

Will generate an OpenAPI schema like:

```JSON hl_lines="5-7"
{
    "openapi": "3.1.0",
    // More stuff here
    "servers": [

=== "Python 3.9+"

    ```Python hl_lines="1  11"
    {!> ../../../docs_src/settings/app03_an_py39/main.py!}
    ```

=== "Python 3.8+"

    ```Python hl_lines="1  11"
    {!> ../../../docs_src/settings/app03_an/main.py!}
    ```

=== "Python 3.8+ non-Annotated"

    !!! tip
        Prefer to use the `Annotated` version if possible.

    ```Python hl_lines="1  10"

=== "Python 3.10+"

    ```Python hl_lines="1  4-6  9-10  21-22  25-26"
    {!> ../../../docs_src/sql_databases/sql_app_py310/schemas.py!}
    ```

=== "Python 3.9+"

    ```Python hl_lines="3  6-8  11-12  23-24  27-28"
    {!> ../../../docs_src/sql_databases/sql_app_py39/schemas.py!}
    ```

=== "Python 3.8+"

    ```Python hl_lines="3  6-8  11-12  23-24  27-28"