}

	if err = tx.First(&User{}, "name = ?", "transaction").Error; err != nil {
		t.Fatalf("Should find saved record, but got %v", err)
	}

	user1 := *GetUser("transaction1-1", Config{})

	if err = tx.Save(&user1).Error; err != nil {
		t.Fatalf("No error should raise, but got %v", err)
	}

	if err = tx.First(&User{}, "name = ?", user1.Name).Error; err != nil {

You can create dependencies that have **sub-dependencies**.

They can be as **deep** as you need them to be.

**FastAPI** will take care of solving them.

## First dependency "dependable" { #first-dependency-dependable }

You could create a first dependency ("dependable") like:

{* ../../docs_src/dependencies/tutorial005_an_py310.py hl[8:9] *}

It declares an optional query parameter `q` as a `str`, and then it just returns it.

     * NDR syntax UUID for DCE/RPC protocol
     */
    UUID DCERPC_UUID_SYNTAX_NDR = new UUID("8a885d04-1ceb-11c9-9fe8-08002b104860");

    /**
     * First fragment flag - indicates first fragment of a multi-fragment message
     */
    int DCERPC_FIRST_FRAG = 0x01; /* First fragment */
    /**
     * Last fragment flag - indicates last fragment of a multi-fragment message
     */
    int DCERPC_LAST_FRAG = 0x02; /* Last fragment */

	}

	if u, err := gorm.G[User](DB).Select("name").Where("name = ?", user.Name).First(ctx); err != nil {
		t.Fatalf("failed to find user, got error: %v", err)
	} else if u.Name != user.Name || u.Age != 0 {
		t.Errorf("found invalid user, got %v, expect %v", u, user)
	}

	if u, err := gorm.G[User](DB).Omit("name").Where("name = ?", user.Name).First(ctx); err != nil {
		t.Fatalf("failed to find user, got error: %v", err)

            DfsReferralDataImpl first = createInitializedDfsReferralDataImpl();
            DfsReferralDataImpl second = createInitializedDfsReferralDataImpl();

            // Set intermediate flag on first
            first.intermediate();
            assertTrue(first.isIntermediate());

            // Combine
            DfsReferralDataInternal combined = first.combine(second);
            assertNotNull(combined);

        assertEquals(1 + expectedString.length + 1, used, "Expected exactly one command byte plus OEM string and NUL terminator");
        assertEquals(0x04, buffer[0] & 0xFF, "First byte must be SMB_COM_QUERY_INFORMATION type 0x04");
        // Verify that the string part ends with the null terminator
        assertArrayEquals(expectedString, subArray(buffer, 1, expectedString.length));

    // have this Entry. The value in the map becomes false when this first entry has been copied, so
    // we know not to copy the remaining ones.
    IdentityHashMap<Entry<K, V>, Boolean> duplicates = null;
    int dupCount = 0;
    for (int entryIndex = n - 1; entryIndex >= 0; entryIndex--) {
      // requireNonNull is safe because the first `n` elements have been filled in.

     *
     * @param first the first entry of the table
     * @param entry the entry being removed from the table
     * @return the new first entry for the table
     */
    @GuardedBy("this")
    @Nullable E removeFromChain(E first, E entry) {
      int newCount = count;
      E newFirst = entry.getNext();
      for (E e = first; e != entry; e = e.getNext()) {

        buffer.order(ByteOrder.LITTLE_ENDIAN);

        // First notification with nextEntryOffset pointing to second
        int secondOffset = 48;
        buffer.putInt(secondOffset); // nextEntryOffset to second entry
        buffer.putInt(FileNotifyInformation.FILE_ACTION_ADDED);
        String fileName1 = "first.txt";
        byte[] fileNameBytes1 = fileName1.getBytes("UTF-16LE");

    assertEquals("Should be able to peek() at first element", "A", peekingIterator.peek());
    assertEquals(
        "Should be able to peek() first element multiple times", "A", peekingIterator.peek());
    assertEquals(
        "next() should still return first element after peeking", "A", peekingIterator.next());