Podemos **ler** um único herói:

{* ../../docs_src/sql_databases/tutorial002_an_py310.py ln[75:80] hl[77] *}

### Atualizar um Hero com `HeroUpdate`

Podemos **atualizar um hero**. Para isso, usamos uma operação HTTP `PATCH`.

	nextToken := func() string {
		cntNewline--
		tok, _ := buf.ReadString('\n')
		return strings.TrimRight(tok, "\n")
	}

	// Parse for the number of entries.
	// Use integer overflow resistant math to check this.
	if err := feedTokens(1); err != nil {
		return nil, err
	}
	numEntries, err := strconv.ParseInt(nextToken(), 10, 0) // Intentionally parse as native int

        float boost = -1.0f;

        try {
            matchAllQueryCommand.execute(context, query, boost);
            fail("Should throw IllegalArgumentException for negative boost");
        } catch (IllegalArgumentException e) {
            // Expected exception
            assertTrue(e.getMessage().contains("negative [boost] are not allowed"));
        }
    }

  }

  private static void testEncodedLengthFails(String invalidString, int invalidCodePointIndex) {
    try {
      Utf8.encodedLength(invalidString);
      fail();
    } catch (IllegalArgumentException expected) {
      assertThat(expected)
          .hasMessageThat()
          .isEqualTo("Unpaired surrogate at index " + invalidCodePointIndex);
    }
  }

                        // Try creating resources
                        context.get("smb://server" + index + "/share/file" + j + ".txt");
                    }
                    results[index] = true;
                } catch (Exception e) {
                    logger.error("Thread {} failed", index, e);
                    results[index] = false;
                }
            });
            threads[i].start();
        }

This way, if any part of Starlette's internal code, or a Starlette extension or plug-in, raises a Starlette `HTTPException`, your handler will be able to catch and handle it.

In this example, to be able to have both `HTTPException`s in the same code, Starlette's exceptions is renamed to `StarletteHTTPException`:

```Python

      if (connection !in connections) {
        connection.withLock { put(connection) }
      }

      return 0L // run again immediately to create more connections if needed
    } catch (e: IOException) {
      // No need to log, user.connectFailed() will already have been called. Just try again later.
      return state.policy.backoffDelayMillis.jitterBy(state.policy.backoffJitterMillis) * 1_000_000
    }

            engineObj.numberOfInFlightFetch = response.getNumberOfInFlightFetch();
            engineObj.status = response.getStatus().name().toLowerCase(Locale.ROOT);
        } catch (final Exception e) {
            engineObj.status = "red";
            engineObj.exception = e.getMessage();
        }
        return engineObj;
    }

    /**

        synchronized (this) {
            try {
                this.state = 1;
                final DcerpcMessage bind = new DcerpcBind(this.binding, this);
                sendrecv(bind);
            } catch (final IOException ioe) {
                this.state = 0;
                throw ioe;
            }
        }
    }

    /**
     * Send and receive a DCE/RPC message
     *
     * @param msg

        try {
            notifications.clear();
            // If this succeeds, the implementation allows modification
            assertTrue(notifications.isEmpty());
        } catch (UnsupportedOperationException e) {
            // If this throws, the implementation returned an immutable list
            assertEquals(2, notifications.size());
        }
    }

    @Test