接下来，首先将数据放入 Pydantic 的 `UserInDB` 模型。

注意：永远不要保存明文密码，本例暂时先使用（伪）哈希密码系统。

如果密码不匹配，则返回与上面相同的错误。

#### 密码哈希 { #password-hashing }

**哈希**是指，将指定内容（本例中为密码）转换为形似乱码的字节序列（其实就是字符串）。

每次传入完全相同的内容（比如，完全相同的密码）时，得到的都是完全相同的乱码。

但这个乱码无法转换回传入的密码。

##### 为什么使用密码哈希 { #why-use-password-hashing }

原因很简单，假如数据库被盗，窃贼无法获取用户的明文密码，得到的只是哈希值。

这样一来，窃贼就无法在其它应用中使用窃取的密码，要知道，很多用户在所有系统中都使用相同的密码，风险超大。

    def mainApiChangesJsonFile = apiChangesJsonDirectory.file("accepted-public-api-changes.json")

    def acceptedViolationsFiles = apiChangesJsonDirectory.asFileTree.matching {
        include("**/*.json")
    }

    def isSnapshot = gradleModule.identity.snapshot
    inputs.files(acceptedViolationsFiles)
    inputs.property("baseline.version", compatibilityBaselineVersion)

Якщо ви ще не знаєте, що таке «хеш пароля», ви дізнаєтесь у [розділах про безпеку](security/simple-oauth2.md#password-hashing).

///

## Кілька моделей { #multiple-models }

Ось загальна ідея того, як можуть виглядати моделі з їхніми полями пароля та місцями використання:

### Create a backup job

#### Backup Virtual Machines with Veeam Backup and Replication

- Under Home > Jobs > Backup in Navigation Pane, click on Backup Job button in the ribbon and choose Virtual Machine. Follow the on screen wizard.

- On the Storage screen, choose the Scale-out Backup Repository that was configured previously.

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.google.common.io;

import static com.google.common.hash.Hashing.sha512;
import static com.google.common.io.SourceSinkFactory.ByteSourceFactory;
import static com.google.common.io.SourceSinkFactory.CharSourceFactory;
import static java.nio.charset.StandardCharsets.UTF_8;

 * @author Jens Nyman
 * @param <N> Node parameter type
 * @since 20.0
 */
@Immutable(containerOf = {"N"})
public class ImmutableGraph<N> extends ForwardingGraph<N> {
  @SuppressWarnings("Immutable") // The backing graph must be immutable.
  private final BaseGraph<N> backingGraph;

  ImmutableGraph(BaseGraph<N> backingGraph) {
    this.backingGraph = backingGraph;
  }

  /** Returns an immutable copy of {@code graph}. */

   * value with {@code asBytes()} as the least-significant bytes and {@code 0x00} as the remaining
   * most-significant bytes.
   *
   * @since 14.0 (since 11.0 as {@code Hashing.padToLong(HashCode)})
   */
  public abstract long padToLong();

  /**
   * Returns the value of this hash code as a byte array. The caller may modify the byte array;

import java.util.function.BiFunction;
import org.jspecify.annotations.Nullable;

/**
 * A general-purpose bimap implementation using any two backing {@code Map} instances.
 *
 * <p>Note that this class contains {@code equals()} calls that keep it from supporting {@code
 * IdentityHashMap} backing maps.
 *
 * @author Kevin Bourrillion
 * @author Mike Bostock
 */
@GwtCompatible

      },
      {
        "subprojects": [
          "base-services-groovy",
          "build-cache-packaging",
          "build-operations",
          "build-state",
          "daemon-services",
          "hashing",
          "precondition-tester",
          "report-rendering",
          "service-registry-builder",
          "test-suites-base",
          "testing-jvm"
        ],
        "parallelizationMethod": {

                writeText(readText().replace("\\Q<lastUpdated>\\E\\d+\\Q</lastUpdated>\\E".toRegex(), "<lastUpdated>${Year.now().value}0101000000</lastUpdated>"))
            }
            localRepository.get().asFileTree.matching { include("**/*.module") }.forEach {
                val content = it.readText()
                    .replace("\"buildId\":\\s+\"\\w+\"".toRegex(), "\"buildId\": \"\"")