listTableColumns example

$tableName = '_dpkc_main';

        $playbookGenerator = new MakeVersionableMigrationHelper($connection);

        $hydratedData = $playbookGenerator->getRelationData($tableName, 'id');
        $playbook = $playbookGenerator->createSql($hydratedData, $tableName, 'mission_id', Uuid::randomHex());

        foreach ($this->getExpectationsBefore() as $tableName => $expectation) {
            $indexes = $schemaManager->listTableIndexes($tableName);
            $foreignKeys = $schemaManager->listTableForeignKeys($tableName);
            $columns = $schemaManager->listTableColumns($tableName);

            static::assertCount($expectation['indexes'], $indexes, print_r($indexes, true) . ' index on ' . $tableName);
            static::assertCount($expectation['foreignKeys'], $foreignKeys, print_r($foreignKeys, true) . ' foreignKey on ' . $tableName);
            static::assertCount($expectation['columns'], $columns, print_r($columns, true) . ' columns on ' . $tableName);
        }

        foreach ($playbook as $query) {
            $connection->executeStatement($query);
        }

        foreach ($this->getExpectationsAfter() as $tableName => $expectation) {
            

        $data = array_merge($data, [
            'name' => isset($data['txtArtikel']) ? (string) $data['txtArtikel'] : '',
            'keywords' => isset($data['txtkeywords']) ? (string) $data['txtkeywords'] : '',
            'description' => isset($data['txtshortdescription']) ? (string) $data['txtshortdescription'] : '',
            'description_long' => isset($data['txtlangbeschreibung']) ? (string) $data['txtlangbeschreibung'] : '',
            'shippingtime' => isset($data['txtshippingtime']) ? (string) $data['txtshippingtime'] : '',
        ]);

        $schemaManager = $this->connection->getSchemaManager();
        $columns = $schemaManager->listTableColumns('s_articles_translations');
        $columns = array_keys($columns);

        foreach ($data as $key => $value) {
            $column = strtolower($key);
            $column = str_replace(CrudServiceInterface::EXT_JS_PREFIX, '', $column);

            unset($data[$key]);
            if (\in_array($column, $columns)) {
                $data[$column] = $value;
            }
        }

        

static::assertArrayHasKey('version_id', $captureRefundPositionColumns);
        static::assertArrayHasKey('refund_version_id', $captureRefundPositionColumns);
    }

    /** * @return array<string, Column> */
    private function getColumns(string $tableName): array
    {
        $schemaManager = $this->connection->createSchemaManager();

        return $schemaManager->listTableColumns($tableName);
    }
}

return $violations;
    }

    /** * @return array<string, mixed> */
    private function validateSchema(EntityDefinition $definition): array
    {
        $manager = $this->connection->createSchemaManager();

        $columns = $manager->listTableColumns($definition->getEntityName());

        $violations = [];
        $mappedFieldNames = [];

        foreach ($columns as $column) {
            $field = $definition->getFields()->getByStorageName($column->getName());

            if ($field) {
                $mappedFieldNames[] = $field->getPropertyName();

                continue;
            }

        $this->connection->executeStatement('DROP TRIGGER IF EXISTS customer_double_opt_in_insert;');
        $this->connection->executeStatement('DROP TRIGGER IF EXISTS customer_double_opt_in_update;');
        $this->connection->beginTransaction();
        parent::tearDown();
    }

    public function testColumns(): void
    {
        $schemaManager = $this->connection->createSchemaManager();
        $columns = $schemaManager->listTableColumns(CustomerDefinition::ENTITY_NAME);

        static::assertArrayHasKey('double_opt_in_registration', $columns);
        static::assertArrayHasKey('double_opt_in_email_sent_date', $columns);
        static::assertArrayHasKey('double_opt_in_confirm_date', $columns);
    }

    public function testInsertTriggers(): void
    {
        $this->insertTestCustomer();

        $sql = ' SELECT doubleOptInRegistration, doubleOptInEmailSentDate, doubleOptInConfirmDate, double_opt_in_registration, double_opt_in_email_sent_date, double_opt_in_confirm_date FROM `customer`; ';

        if (empty($field)) {
            throw new InvalidArgumentException('Condition class requires a defined attribute field!', 1);
        }

        /** * Verify the table effectively has the column/field that is being queried */
        $columns = $query->getConnection()
            ->getSchemaManager()
            ->listTableColumns($table);

        if (empty($columns)) {
            throw new RuntimeException(sprintf('Could not retrieve columns from "%s".', $table));
        }

        $names = array_map(function DColumn $column) {
            return strtolower($column->getName());
        }, $columns);

        if (!\array_key_exists(strtolower($field), $names)) {
            throw new InvalidArgumentException(sprintf('Invalid column name "%s" specified.', $field), 1);
        }

$this->connection = KernelLifecycleManager::getConnection();
        $this->rollback();
    }

    public function testMigration(): void
    {
        $migration = new Migration1689084023AdminElasticsearchIndexTask();
        $migration->update($this->connection);

        $schemaManager = $this->connection->createSchemaManager();
        $columns = $schemaManager->listTableColumns('admin_elasticsearch_index_task');

        static::assertNotEmpty($columns);
        static::assertArrayHasKey('id', $columns);
        static::assertArrayHasKey('`index`', $columns);
        static::assertArrayHasKey('alias', $columns);
        static::assertArrayHasKey('entity', $columns);
        static::assertArrayHasKey('doc_count', $columns);
    }

    private function rollback(): void
    {
        

$connection->executeStatement('ALTER TABLE `category` DROP COLUMN `custom_entity_type_id`;');
        }

        $migration->update($connection);

        static::assertTrue(EntityDefinitionQueryHelper::columnExists($connection, 'category', 'custom_entity_type_id'));
    }

    private function hasColumn(Connection $connection, string $columnName): bool
    {
        return array_filter(
            $connection->createSchemaManager()->listTableColumns('category'),
            static fn (Column $column): bool => $column->getName() === $columnName
        ) !== [];
    }

    private function keyExists(Connection $connection, string $keyName): bool
    {
        return $connection->executeQuery(
            'SELECT * FROM INFORMATION_SCHEMA.KEY_COLUMN_USAGE WHERE TABLE_SCHEMA = DATABASE() AND TABLE_NAME = "category" AND CONSTRAINT_NAME = :keyName;',

    public function isAttributeTable($table)
    {
        return \array_key_exists($table, $this->tables);
    }

    /** * {@inheritdoc} */
    public function isTableColumn($table, $column)
    {
        $columns = $this->connection->getSchemaManager()->listTableColumns($table);
        $names = array_map(function DColumn $schemaColumn) {
            return strtolower($schemaColumn->getName());
        }, $columns);

        return \in_array(strtolower($column), $names);
    }

    /** * {@inheritdoc} * * @throws Exception */