getSchema example

    public function postGenerateSchema(GenerateSchemaEventArgs $event): void
    {
        $connection = $event->getEntityManager()->getConnection();

        foreach ($this->rememberMeHandlers as $rememberMeHandler) {
            if (
                $rememberMeHandler instanceof PersistentRememberMeHandler
                && ($tokenProvider = $rememberMeHandler->getTokenProvider()) instanceof DoctrineTokenProvider
            ) {
                $tokenProvider->configureSchema($event->getSchema(), $connection, $this->getIsSameDatabaseChecker($connection));
            }
        }
    }
}

// If there is no main property and only a single column, get all         // properties from the first field item and assume that they will be         // stored serialized.         // @todo Give field types more control over this behavior in         // https://www.drupal.org/node/2232427.         if (!$definition->getMainPropertyName() && count($columns) == 1) {
          $value = ($item = $entity->$field_name->first()) ? $item->getValue() : [];
        }
        else {
          $value = $entity->$field_name->$column_name ?? NULL;
        }
        if (!empty($definition->getSchema()['columns'][$column_name]['serialize'])) {
          $value = serialize($value);
        }

        // Do not set serial fields if we do not have a value. This supports all         // SQL database drivers.         // @see https://www.drupal.org/node/2279395         $value = SqlContentEntityStorageSchema::castValue($definition->getSchema()['columns'][$column_name], $value);
        $empty_serial = empty($value) && $this->isColumnSerial($table_name, $schema_name);
        // The user entity is a very special case where the ID field is a serial         // but we need to insert a row with an ID of 0 to represent the         // anonymous user.

  public function testCreateWithExplicitSchema() {
    $schema = [
      'dummy' => 'foobar',
    ];
    $field_storage = FieldStorageConfig::create([
      'field_name' => 'field_2',
      'entity_type' => 'entity_test',
      'type' => 'test_field',
      'schema' => $schema,
    ]);
    $this->assertEquals($schema, $field_storage->getSchema());
  }

  /** * Tests reading field storage definitions. */
  public function testRead() {
    $field_storage_definition = [
      'field_name' => 'field_1',
      'entity_type' => 'entity_test',
      'type' => 'test_field',
    ];
    

        $result = [
            'foo' => [
                'bar' => null,
            ],
        ];

        $this->cache->expects(static::once())
            ->method('get')
            ->willReturn($result);

        static::assertSame($result, $this->cachedEntitySchemaGenerator->getSchema([]));
    }

    public function testGetSchemaCallsInnerWithAbsentCache(): void
    {
        $result = [
            'fiz' => [
                'buz' => null,
            ],
        ];
        $this->entitySchemaGenerator->expects(static::once())
            ->method('getSchema')
            

    public function __construct(private iterable $dbalAdapters)
    {
    }

    public function postGenerateSchema(GenerateSchemaEventArgs $event): void
    {
        $connection = $event->getEntityManager()->getConnection();

        foreach ($this->dbalAdapters as $dbalAdapter) {
            $dbalAdapter->configureSchema($event->getSchema(), $connection, $this->getIsSameDatabaseChecker($connection));
        }
    }
}

    public function generate(array $definitions, string $api, string $apiType, ?string $bundleName): array
    {
        $this->innerService->generate($definitions, $api, $apiType, $bundleName);
    }

    /** * @return array<string, array<string, mixed>> */
    public function getSchema(array $definitions): array
    {
        return $this->cache->get(self::CACHE_KEY, fn () => $this->innerService->getSchema($definitions));
    }
}

        $outFile = $input->getArgument('outfile');
        if ($outFile === '-') {
            $outFile = 'php://stdout';
            $output = $output instanceof ConsoleOutputInterface ? $output->getErrorOutput() : $output;
        }
        $formatType = $input->getOption('schema-format');
        $bundleName = (empty($input->getOption('bundle-name'))) ? '' : $input->getOption('bundle-name');

        switch ($formatType) {
            case 'simple':
                $definitionContents = $this->definitionService->getSchema();

                break;
            case 'openapi3':
                $api = $input->getOption('store-api') ? DefinitionService::STORE_API : DefinitionService::API;
                $definitionContents = $this->definitionService->generate('openapi-3', $api, DefinitionService::TYPE_JSON_API, $bundleName);

                break;
            case 'entity-schema':
                $definitionContents = $this->definitionService->getSchema(EntitySchemaGenerator::FORMAT, DefinitionService::API);

                break;
            

    public function testGetCreationTimestamp(): void
    {
        static::assertEquals('1673964565', $this->migration->getCreationTimestamp());
    }

    public function testUpdate(): void
    {
        $this->migration->update($this->connection);

        static::assertStringContainsString('`referenced_id` binary(16) NOT NULL', $this->getSchema());
        static::assertStringContainsString('`referenced_version_id` binary(16) NOT NULL', $this->getSchema());
        static::assertStringNotContainsString('`entity_id`', $this->getSchema());
    }

    public function testUpdateTwice(): void
    {
        $this->migration->update($this->connection);
        $expected = $this->getSchema();

        static::assertStringContainsString('`referenced_id` binary(16) NOT NULL', $expected);
        static::assertStringContainsString('`referenced_version_id` binary(16) NOT NULL', $expected);
        

    public static function validateSchema(\DOMDocument $dom): array
    {
        $xliffVersion = static::getVersionNumber($dom);
        $internalErrors = libxml_use_internal_errors(true);
        if ($shouldEnable = self::shouldEnableEntityLoader()) {
            $disableEntities = libxml_disable_entity_loader(false);
        }
        try {
            $isValid = @$dom->schemaValidateSource(self::getSchema($xliffVersion));
            if (!$isValid) {
                return self::getXmlErrors($internalErrors);
            }
        } finally {
            if ($shouldEnable) {
                libxml_disable_entity_loader($disableEntities);
            }
        }

        $dom->normalizeDocument();

        

        $entities = CustomEntityXmlSchema::createFromXmlFile(__DIR__ . '/_fixtures/custom-entity-test/Resources/install.xml');

        $this->getContainer()
            ->get(CustomEntityPersister::class)
            ->update($entities->toStorage());

        $this->getContainer()
            ->get(CustomEntitySchemaUpdater::class)
            ->update();

        $schema = $this->getSchema();

        self::assertColumns($schema, 'custom_entity_blog', ['id', 'top_seller_id', 'author_id', 'created_at', 'updated_at', 'position', 'rating']);
        self::assertColumns($schema, 'ce_blog_comment', ['id', 'created_at', 'updated_at']);
        self::assertColumns($schema, 'custom_entity_to_remove', ['id', 'created_at', 'updated_at']);

        $entities = CustomEntityXmlSchema::createFromXmlFile(__DIR__ . '/_fixtures/custom-entity-test/Resources/update.xml');
        $this->getContainer()
            ->get(CustomEntityPersister::class)
            ->update($entities->toStorage());

        $this->getContainer()
            

$default_output = str_replace("\n", '', $renderer->renderRoot($image));
    $this->assertSession()->responseContains($default_output);

    // Verify that alt/title longer than allowed results in a validation error.     $test_size = 2000;
    $edit = [
      $field_name . '[0][alt]' => $this->randomMachineName($test_size),
      $field_name . '[0][title]' => $this->randomMachineName($test_size),
    ];
    $this->drupalGet('node/' . $nid . '/edit');
    $this->submitForm($edit, 'Save');
    $schema = $field->getFieldStorageDefinition()->getSchema();
    $this->assertSession()->statusMessageContains("Alternative text cannot be longer than {$schema['columns']['alt']['length']} characters but is currently {$test_size} characters long.", 'error');
    $this->assertSession()->statusMessageContains("Title cannot be longer than {$schema['columns']['title']['length']} characters but is currently {$test_size} characters long.", 'error');

    // Set cardinality to unlimited and add upload a second image.     // The image widget is extending on the file widget, but the image field     // type does not have the 'display_field' setting which is expected by     // the file widget. This resulted in notices before when cardinality is not     // 1, so we need to make sure the file widget prevents these notices by     // providing all settings, even if they are not used.     // @see FileWidget::formMultipleElements().     $this->drupalGet('admin/structure/types/manage/article/fields/node.article.' . $field_name . '/storage');
    

DefinitionService::API,
            'json',
            null
        );
        $entities = $schema['components']['schemas'];
        static::assertArrayHasKey('Simple', $entities);
        static::assertArrayHasKey('infoConfigResponse', $entities);
    }

    public function testSchemaBuilding(): void
    {
        $schema = $this->generator->getSchema(
            $this->definitionRegistry->getDefinitions()
        );

        static::assertArrayHasKey('simple', $schema);
    }

    public function testSchemaContainsCustomPathsOnly(): void
    {
        $schema = $this->customApiGenerator->generate(
            $this->definitionRegistry->getDefinitions(),
            DefinitionService::API,
            

        return $this->getGenerator($format, $type)->generate($this->getDefinitions($type), $type, $apiType, $bundleName);
    }

    /** * @phpstan-param Api $type * * @return ApiSchema */
    public function getSchema(string $format = 'openapi-3', string $type = self::API): array
    {
        return $this->getGenerator($format, $type)->getSchema($this->getDefinitions($type));
    }

    /** * @return ApiType|null */
    public function toApiType(string $apiType): ?string
    {
        if ($apiType !== self::TYPE_JSON_API && $apiType !== self::TYPE_JSON) {
            return null;
        }

        

    public function postGenerateSchema(GenerateSchemaEventArgs $event): void
    {
        $connection = $event->getEntityManager()->getConnection();

        foreach ($this->stores as $store) {
            if (!$store instanceof DoctrineDbalStore) {
                continue;
            }

            $store->configureSchema($event->getSchema(), $this->getIsSameDatabaseChecker($connection));
        }
    }
}

$revision_data_table && $entity_type->getRevisionDataTable() != $original->getRevisionDataTable());
  }

  /** * {@inheritdoc} */
  public function requiresFieldStorageSchemaChanges(FieldStorageDefinitionInterface $storage_definition, FieldStorageDefinitionInterface $original) {
    $table_mapping = $this->getTableMapping($this->entityType);

    if (
      $storage_definition->hasCustomStorage() != $original->hasCustomStorage() ||
      $storage_definition->getSchema() != $original->getSchema() ||
      $storage_definition->isRevisionable() != $original->isRevisionable() ||
      $table_mapping->allowsSharedTableStorage($storage_definition) != $table_mapping->allowsSharedTableStorage($original) ||
      $table_mapping->requiresDedicatedTableStorage($storage_definition) != $table_mapping->requiresDedicatedTableStorage($original)
    ) {
      return TRUE;
    }

    if ($storage_definition->hasCustomStorage()) {
      // The field has custom storage, so we don't know if a schema change is       // needed or not, but since per the initial checks earlier in this       // function, nothing about the definition changed that we manage, we