}

func TestSameForeignKey(t *testing.T) {
	type UserAux struct {
		gorm.Model
		Aux  string
		UUID string
	}

	type User struct {
		gorm.Model
		Name string
		UUID string
		Aux  *UserAux `gorm:"foreignkey:UUID;references:UUID"`
	}

	checkStructRelation(t, &User{},
		Relation{
			Name: "Aux", Type: schema.HasOne, Schema: "User", FieldSchema: "UserAux",
			References: []Reference{

	// what the compiler uses when creating OpArg{Int,Float}Reg ops.
	for _, v := range f.Entry.Values {
		if v.Op == OpArgIntReg || v.Op == OpArgFloatReg {
			aux := v.Aux.(*AuxNameOffset)
			sl := LocalSlot{N: aux.Name, Type: v.Type, Off: aux.Offset}
			// install slot in lookup table
			idx, _ := sc.lookup(sl)
			// add to f.NamedValues if not already present
			addToNV(v, sc.canonSlot(idx))

00000070  04 30 82 02 00 30 82 01  62 02 09 00 b8 bf 2d 47  |.0...0..b.....-G|
00000080  a0 d2 eb f4 30 09 06 07  2a 86 48 ce 3d 04 01 30  |....0...*.H.=..0|
00000090  45 31 0b 30 09 06 03 55  04 06 13 02 41 55 31 13  |E1.0...U....AU1.|
000000a0  30 11 06 03 55 04 08 13  0a 53 6f 6d 65 2d 53 74  |0...U....Some-St|
000000b0  61 74 65 31 21 30 1f 06  03 55 04 0a 13 18 49 6e  |ate1!0...U....In|

00000070  04 30 82 02 00 30 82 01  62 02 09 00 b8 bf 2d 47  |.0...0..b.....-G|
00000080  a0 d2 eb f4 30 09 06 07  2a 86 48 ce 3d 04 01 30  |....0...*.H.=..0|
00000090  45 31 0b 30 09 06 03 55  04 06 13 02 41 55 31 13  |E1.0...U....AU1.|
000000a0  30 11 06 03 55 04 08 13  0a 53 6f 6d 65 2d 53 74  |0...U....Some-St|
000000b0  61 74 65 31 21 30 1f 06  03 55 04 0a 13 18 49 6e  |ate1!0...U....In|

	"bytes"
	"encoding/binary"
	"internal/abi"
)

// CUFileIndex is used to index the filenames that are stored in the
// per-package/per-CU FileList.
type CUFileIndex uint32

// FuncInfo is serialized as a symbol (aux symbol). The symbol data is
// the binary encoding of the struct below.
type FuncInfo struct {
	Args      uint32
	Locals    uint32
	FuncID    abi.FuncID
	FuncFlag  abi.FuncFlag
	StartLine int32

{"item_id":3}
```

!!! check "vérifier"
    Comme vous l'avez remarqué, la valeur reçue par la fonction (et renvoyée ensuite) est `3`,
    en tant qu'entier (`int`) Python, pas la chaîne de caractères (`string`) `"3"`.

    Grâce aux déclarations de types, **FastAPI** fournit du
    <abbr title="conversion de la chaîne de caractères venant de la requête HTTP en données Python">"parsing"</abbr> automatique.

## Validation de données

    fi

    echo -n $"Starting $prog: "
    # if not running, start it up here, usually something like "daemon $exec"
    daemon --user $FESS_USER --pidfile="$pidfile" $exec -d
    retval=$?
    pid=`ps aux | grep "^${FESS_USER}" | grep "${PROC_NAME}" | sed 's/[\t ]\+/\t/g' | cut -f2`
    if [ -n "$pid" ]; then
        echo $pid > "$pidfile"
    fi
    echo
    [ $retval -eq 0 ] && touch $lockfile
    return $retval

			Reg:    wasm.REG_SP,
			Offset: 0,
		}

	case ssa.OpWasmLoweredAddr:
		if v.Aux == nil { // address of off(SP), no symbol
			getValue64(s, v.Args[0])
			i64Const(s, v.AuxInt)
			s.Prog(wasm.AI64Add)
			break
		}
		p := s.Prog(wasm.AGet)
		p.From.Type = obj.TYPE_ADDR
		switch v.Aux.(type) {
		case *obj.LSym:
			ssagen.AddAux(&p.From, v)
		case *ir.Name:
			p.From.Reg = v.Args[0].Reg()

	}
	return nil
}

type pkfunc struct {
	pk, fcn uint32
}

func (ts *tstate) readAuxMetaFiles(metafiles string, importpaths map[string]struct{}) error {
	// Unmarshal the information on available aux metafiles into
	// a MetaFileCollection struct.
	var mfc coverage.MetaFileCollection
	data, err := os.ReadFile(metafiles)
	if err != nil {
		return fmt.Errorf("error reading auxmetafiles file %q: %v", metafiles, err)

    Le `Union[str, None]` est uniquement là pour permettre à votre éditeur un meilleur support.

Ensuite, nous pouvons passer d'autres paramètres à `Query`. Dans cet exemple, le paramètre `max_length` qui s'applique aux chaînes de caractères :

```Python
q: Union[str, None] = Query(default=None, max_length=50)
```