Abstract Class Yiisoft\Db\Schema\AbstractSchema

                public function __construct(protected ConnectionInterface $db, private SchemaCache $schemaCache) {}

            

                protected function clearFullName(string $fullName): string
{
    return $this->resolveFullName(...$this->db->getQuoter()->getTableNameParts($fullName));
}

            

                public function enableCache(bool $value): void
{
    $this->schemaCache->setEnabled($value);
}

            

                protected function findConstraints(TableSchemaInterface $table): void
{
    $tableName = $this->resolveFullName($table->getName(), $table->getSchemaName());
    $table->checks(...$this->getTableMetadata($tableName, SchemaInterface::CHECKS));
    $table->defaultValues(...$this->getTableMetadata($tableName, SchemaInterface::DEFAULT_VALUES));
    $table->foreignKeys(...$this->getTableMetadata($tableName, SchemaInterface::FOREIGN_KEYS));
    $table->indexes(...$this->getTableMetadata($tableName, SchemaInterface::INDEXES));
}

            

                protected function findSchemaNames(): array
{
    throw new NotSupportedException(static::class . ' does not support fetching all schema names.');
}

            

                protected function findTableNames(string $schema): array
{
    throw new NotSupportedException(static::class . ' does not support fetching all table names.');
}

            

                protected function findViewNames(string $schema = ''): array
{
    return [];
}

            

                abstract protected function getCacheKey(string $name): array;

            

                abstract protected function getCacheTag(): string;

            

                public function getDataType(mixed $data): int
{
    return match (gettype($data)) {
        // php type => SQL data type
        GettypeResult::BOOLEAN => DataType::BOOLEAN,
        GettypeResult::INTEGER => DataType::INTEGER,
        GettypeResult::RESOURCE => DataType::LOB,
        GettypeResult::NULL => DataType::NULL,
        default => DataType::STRING,
    };
}

            

                public function getDefaultSchema(): string
{
    return $this->defaultSchema;
}

            

                final public function getResultColumn(array $metadata): ?ColumnInterface
{
    if (empty($metadata)) {
        return null;
    }
    $cacheKey = $this->getResultColumnCacheKey($metadata);
    if (array_key_exists($cacheKey, $this->resultColumns)) {
        return $this->resultColumns[$cacheKey];
    }
    $isCacheEnabled = $this->schemaCache->isEnabled();
    if ($isCacheEnabled) {
        /** @var ColumnInterface */
        $this->resultColumns[$cacheKey] = $this->schemaCache->get($cacheKey);
        if (isset($this->resultColumns[$cacheKey])) {
            return $this->resultColumns[$cacheKey];
        }
    }
    $column = $this->loadResultColumn($metadata);
    $this->resultColumns[$cacheKey] = $column;
    if ($column !== null && $isCacheEnabled) {
        $this->schemaCache->set($cacheKey, $column, $this->getCacheTag());
    }
    return $column;
}

            

                abstract protected function getResultColumnCacheKey(array $metadata): string;

            

                public function getSchemaChecks(string $schema = '', bool $refresh = false): array
{
    /** @var Check[] */
    return $this->getSchemaMetadata($schema, SchemaInterface::CHECKS, $refresh);
}

            

                public function getSchemaDefaultValues(string $schema = '', bool $refresh = false): array
{
    /** @var DefaultValue[] */
    return $this->getSchemaMetadata($schema, SchemaInterface::DEFAULT_VALUES, $refresh);
}

            

                public function getSchemaForeignKeys(string $schema = '', bool $refresh = false): array
{
    /** @var ForeignKey[] */
    return $this->getSchemaMetadata($schema, SchemaInterface::FOREIGN_KEYS, $refresh);
}

            

                public function getSchemaIndexes(string $schema = '', bool $refresh = false): array
{
    /** @var Index[] */
    return $this->getSchemaMetadata($schema, SchemaInterface::INDEXES, $refresh);
}

            

                protected function getSchemaMetadata(string $schema, string $type, bool $refresh): array
{
    $metadata = [];
    $quoter = $this->db->getQuoter();
    $tableNames = $this->getTableNames($schema, $refresh);
    foreach ($tableNames as $name) {
        $name = $quoter->quoteSimpleTableName($name);
        if ($schema !== '') {
            $name = $schema . '.' . $name;
        }
        $tableMetadata = $this->getTableTypeMetadata($type, $name, $refresh);
        if ($tableMetadata !== null) {
            $metadata[] = $tableMetadata;
        }
    }
    return $metadata;
}

            

                public function getSchemaNames(bool $refresh = false): array
{
    if (empty($this->schemaNames) || $refresh) {
        $this->schemaNames = $this->findSchemaNames();
    }
    return $this->schemaNames;
}

            

                public function getSchemaPrimaryKeys(string $schema = '', bool $refresh = false): array
{
    /** @var Index[] */
    return $this->getSchemaMetadata($schema, SchemaInterface::PRIMARY_KEY, $refresh);
}

            

                public function getSchemaUniques(string $schema = '', bool $refresh = false): array
{
    /** @var Index[] */
    return $this->getSchemaMetadata($schema, SchemaInterface::UNIQUES, $refresh);
}

            

                public function getTableChecks(string $name, bool $refresh = false): array
{
    /** @var Check[] */
    return $this->getTableMetadata($this->clearFullName($name), SchemaInterface::CHECKS, $refresh);
}

            

                public function getTableDefaultValues(string $name, bool $refresh = false): array
{
    /** @var DefaultValue[] */
    return $this->getTableMetadata($this->clearFullName($name), SchemaInterface::DEFAULT_VALUES, $refresh);
}

            

                public function getTableForeignKeys(string $name, bool $refresh = false): array
{
    /** @var ForeignKey[] */
    return $this->getTableMetadata($this->clearFullName($name), SchemaInterface::FOREIGN_KEYS, $refresh);
}

            

                public function getTableIndexes(string $name, bool $refresh = false): array
{
    /** @var Index[] */
    return $this->getTableMetadata($this->clearFullName($name), SchemaInterface::INDEXES, $refresh);
}

            

                protected function getTableMetadata(
    string $name,
    string $type,
    bool $refresh = false,
): array|Index|TableSchemaInterface|null {
    if (!isset($this->tableMetadata[$name])) {
        $this->loadTableMetadataFromCache($name);
    }
    if ($refresh || !isset($this->tableMetadata[$name][$type])) {
        $this->tableMetadata[$name][$type] = $this->loadTableTypeMetadata($type, $name);
        $this->saveTableMetadataToCache($name);
    }
    return $this->tableMetadata[$name][$type];
}

            

                public function getTableNames(string $schema = '', bool $refresh = false): array
{
    if (!isset($this->tableNames[$schema]) || $refresh) {
        $this->tableNames[$schema] = $this->findTableNames($schema);
    }
    return $this->tableNames[$schema];
}

            

                public function getTablePrimaryKey(string $name, bool $refresh = false): ?Index
{
    foreach ($this->getTableIndexes($name, $refresh) as $index) {
        if ($index->isPrimaryKey) {
            return $index;
        }
    }
    return null;
}

            

                public function getTableSchema(string $name, bool $refresh = false): ?TableSchemaInterface
{
    $rawName = $this->clearFullName($name);
    if ($refresh) {
        // Some constraints are loading and caching together.
        // Reset the table constraint cache to load them without refreshing.
        $this->tableMetadata[$rawName] = [];
        if ($this->schemaCache->isEnabled()) {
            $this->schemaCache->remove($this->getCacheKey($rawName));
        }
    }
    /** @var TableSchemaInterface|null */
    return $this->getTableMetadata($rawName, SchemaInterface::SCHEMA, $refresh);
}

            

                public function getTableSchemas(string $schema = '', bool $refresh = false): array
{
    /** @var TableSchemaInterface[] */
    return $this->getSchemaMetadata($schema, SchemaInterface::SCHEMA, $refresh);
}

            

                protected function getTableTypeMetadata(
    string $type,
    string $name,
    bool $refresh = false,
): array|Index|TableSchemaInterface|null {
    return match ($type) {
        SchemaInterface::SCHEMA => $this->getTableSchema($name, $refresh),
        SchemaInterface::PRIMARY_KEY => $this->getTablePrimaryKey($name, $refresh),
        SchemaInterface::UNIQUES => $this->getTableUniques($name, $refresh),
        SchemaInterface::FOREIGN_KEYS => $this->getTableForeignKeys($name, $refresh),
        SchemaInterface::INDEXES => $this->getTableIndexes($name, $refresh),
        SchemaInterface::DEFAULT_VALUES => $this->getTableDefaultValues($name, $refresh),
        SchemaInterface::CHECKS => $this->getTableChecks($name, $refresh),
        default => null,
    };
}

            

                public function getTableUniques(string $name, bool $refresh = false): array
{
    return array_filter(
        $this->getTableIndexes($name, $refresh),
        static fn(Index $index): bool => $index->isUnique,
    );
}

            

                public function getViewNames(string $schema = '', bool $refresh = false): array
{
    if (!isset($this->viewNames[$schema]) || $refresh) {
        $this->viewNames[$schema] = $this->findViewNames($schema);
    }
    return $this->viewNames[$schema];
}

            

                public function hasSchema(string $schema, bool $refresh = false): bool
{
    $schemas = $this->getSchemaNames($refresh);
    return in_array($schema, $schemas);
}

            

                public function hasTable(string $tableName, string $schema = '', bool $refresh = false): bool
{
    $tables = $this->getTableNames($schema, $refresh);
    $rawTableName = $this->db->getQuoter()->getRawTableName($tableName);
    return in_array($rawTableName, $tables);
}

            

                public function hasView(string $viewName, string $schema = '', bool $refresh = false): bool
{
    $views = $this->getViewNames($schema, $refresh);
    $rawViewName = $this->db->getQuoter()->getRawTableName($viewName);
    return in_array($rawViewName, $views);
}

            

                abstract protected function loadResultColumn(array $metadata): ?ColumnInterface;

            

                abstract protected function loadTableChecks(string $tableName): array;

            

                abstract protected function loadTableDefaultValues(string $tableName): array;

            

                abstract protected function loadTableForeignKeys(string $tableName): array;

            

                abstract protected function loadTableIndexes(string $tableName): array;

            

                abstract protected function loadTableSchema(string $name): ?TableSchemaInterface;

            

                protected function loadTableTypeMetadata(string $type, string $name): array|TableSchemaInterface|null
{
    return match ($type) {
        SchemaInterface::SCHEMA => $this->loadTableSchema($name),
        SchemaInterface::FOREIGN_KEYS => $this->loadTableForeignKeys($name),
        SchemaInterface::INDEXES => $this->loadTableIndexes($name),
        SchemaInterface::DEFAULT_VALUES => $this->loadTableDefaultValues($name),
        SchemaInterface::CHECKS => $this->loadTableChecks($name),
        default => null,
    };
}

            

                public function refresh(): void
{
    if ($this->schemaCache->isEnabled()) {
        $this->schemaCache->invalidate($this->getCacheTag());
    }
    $this->tableNames = [];
    $this->tableMetadata = [];
    $this->schemaNames = [];
    $this->viewNames = [];
    $this->resultColumns = [];
}

            

                public function refreshTableSchema(string $name): void
{
    $rawName = $this->clearFullName($name);
    unset($this->tableMetadata[$rawName]);
    $this->tableNames = [];
    $this->viewNames = [];
    if ($this->schemaCache->isEnabled()) {
        $this->schemaCache->remove($this->getCacheKey($rawName));
    }
}

            

                protected function resolveFullName(string $name, string $schemaName = ''): string
{
    $quoter = $this->db->getQuoter();
    $rawName = $quoter->getRawTableName($name);
    return match ($schemaName) {
        '', $this->defaultSchema => $rawName,
        default => $quoter->getRawTableName($schemaName) . ".$rawName",
    };
}

            

                protected function setTableMetadata(
    string $rawName,
    string $type,
    array|Index|TableSchemaInterface|null $data,
): void {
    $this->tableMetadata[$rawName][$type] = $data;
}