getColumns example

  }

  /** * {@inheritdoc} */
  protected function defineOptions() {
    $options = parent::defineOptions();

    $field_storage_definition = $this->getFieldStorageDefinition();
    $field_type = $this->fieldTypePluginManager->getDefinition($field_storage_definition->getType());
    $column_names = array_keys($field_storage_definition->getColumns());
    $default_column = '';
    // Try to determine a sensible default.     if (count($column_names) == 1) {
      $default_column = $column_names[0];
    }
    elseif (in_array('value', $column_names)) {
      $default_column = 'value';
    }

    // If the field has a "value" column, we probably need that one.     $options['click_sort_column'] = [
      

    public function testConfigureSchemaTableExists()
    {
        $connection = DriverManager::getConnection(['driver' => 'pdo_sqlite', 'path' => self::$dbFile], $this->getDbalConfig());
        $schema = new Schema();
        $schema->createTable('cache_items');

        $adapter = new DoctrineDbalAdapter($connection);
        $adapter->configureSchema($schema, $connection, fn () => true);
        $table = $schema->getTable('cache_items');
        $this->assertEmpty($table->getColumns(), 'The table was not overwritten');
    }

    /** * @dataProvider provideDsn */
    public function testDsn(string $dsn, string $file = null)
    {
        try {
            $pool = new DoctrineDbalAdapter($dsn);
            $pool->createTable();

            

    /** * @param int $maxCount * * @return int */
    public function migrate($maxCount)
    {
        $maxId = $this->connection->query('SELECT max_id FROM translation_migration_id')->fetch(PDO::FETCH_COLUMN);

        $columns = $this->getColumns();

        $statement = $this->connection->prepare(
            <<<EOL SELECT * FROM s_core_translations WHERE objecttype IN ("article", "variantMain", "variant") AND id > :lastId AND id <= :maxId ORDER BY id ASC LIMIT 250 EOL
        );

$dom = new \DOMDocument();
        $listingElement = $dom->createElement('listing');
        $columnsElement = $dom->createElement('columns');

        $listingElement->appendChild(
            $columnsElement
        );

        $listing = Listing::fromXml($listingElement);
        static::assertInstanceOf(Listing::class, $listing);

        $columns = $listing->getColumns();
        static::assertInstanceOf(Columns::class, $columns);
    }
}

    public function testConfigureSchemaTableExists()
    {
        $driverConnection = $this->getDBALConnectionMock();
        $schema = new Schema();
        $schema->createTable('messenger_messages');

        $connection = new Connection([], $driverConnection);
        $connection->configureSchema($schema, $driverConnection, fn () => true);
        $table = $schema->getTable('messenger_messages');
        $this->assertEmpty($table->getColumns(), 'The table was not overwritten');
    }

    /** * @dataProvider provideFindAllSqlGeneratedByPlatform */
    public function testFindAllSqlGenerated(AbstractPlatform $platform, string $expectedSql)
    {
        $driverConnection = $this->createMock(DBALConnection::class);
        $driverConnection->method('getDatabasePlatform')->willReturn($platform);
        $driverConnection->method('createQueryBuilder')->willReturnCallback(function D) use ($driverConnection) {
            return new QueryBuilder($driverConnection);
        });

public function testConfigureSchemaTableExists()
    {
        $conn = $this->createMock(Connection::class);
        $schema = new Schema();
        $schema->createTable('lock_keys');

        $dbalStore = new DoctrineDbalStore($conn);
        $someFunction = fn () => true;
        $dbalStore->configureSchema($schema, $someFunction);
        $table = $schema->getTable('lock_keys');
        $this->assertEmpty($table->getColumns(), 'The table was not overwritten');
    }
}

/** * @param string[] $entityFields */
    private function validateListingConfiguration(
        array $entityFields,
        Listing $listing,
        string $customEntityName
    ): void {
        $this->checkReferences(
            $entityFields,
            $this->getRefsAsList($listing->getColumns()->getContent()),
            $customEntityName,
            '<listing>'
        );
    }

    /** * @param string[] $entityFields */
    private function validateDetailConfiguration(
        array $entityFields,
        Detail $detail,
        

$databaseName = $this->connection->fetchOne('SELECT DATABASE()');
        \assert(\is_string($databaseName));
        $query = sprintf(self::FIND_RELATIONSHIPS_QUERY, $databaseName, $tableName);

        return $this->connection->fetchAllAssociative($query);
    }

    private function createModifyPrimaryKeyQuery(string $tableName, string $newColumnName, string $defaultValue): string
    {
        $pk = $this->schemaManager->listTableIndexes($tableName)['primary'];

        if (\count($pk->getColumns()) !== 1) {
            throw new \RuntimeException(
                'Tables with multi column primary keys not supported. Maybe this migration did already run.'
            );
        }
        $pkName = current($pk->getColumns());

        return sprintf(self::MODIFY_PRIMARY_KEY_IN_MAIN, $tableName, $newColumnName, $defaultValue, $pkName, $pkName, $newColumnName);
    }

    private function findForeignKeyDefinition(array $keyStructure): ForeignKeyConstraint
    {
        

$this->assertTrue($schema->hasTable('sessions'));
    }

    public function testConfigureSchemaTableExistsPdo()
    {
        $schema = new Schema();
        $schema->createTable('sessions');

        $pdoSessionHandler = new PdoSessionHandler($this->getMemorySqlitePdo());
        $pdoSessionHandler->configureSchema($schema, fn () => true);
        $table = $schema->getTable('sessions');
        $this->assertEmpty($table->getColumns(), 'The table was not overwritten');
    }

    public static function provideUrlDsnPairs()
    {
        yield ['mysql://localhost/test', 'mysql:host=localhost;dbname=test;'];
        yield ['mysql://localhost/test?charset=utf8mb4', 'mysql:charset=utf8mb4;host=localhost;dbname=test;'];
        yield ['mysql://localhost/test?unix_socket=socket.sock&charset=utf8mb4', 'mysql:charset=utf8mb4;unix_socket=socket.sock;dbname=test;'];
        yield ['mysql://localhost:56/test', 'mysql:host=localhost;port=56;dbname=test;'];
        yield ['mysql2://root:pwd@localhost/test', 'mysql:host=localhost;dbname=test;', 'root', 'pwd'];
        yield ['postgres://localhost/test', 'pgsql:host=localhost;dbname=test;'];
        yield ['postgresql://localhost:5634/test', 'pgsql:host=localhost;port=5634;dbname=test;'];
        

// If there are more specifiers to work with then continue             // processing. If this is the last specifier then use the reserved             // keyword as a column name.             if ($key < $count) {
              $next = $specifiers[$key + 1];
            }
            else {
              $column = TableMappingInterface::DELTA;
            }
          }
          // Is this a field column?           $columns = $field_storage->getColumns();
          if (isset($columns[$next]) || in_array($next, $table_mapping->getReservedColumns())) {
            // Use it.             $column = $next;
            // Do not process it again.             $key++;
          }
          // If there are more specifiers, the next one must be a           // relationship. Either the field name followed by a relationship           // specifier, for example $node->field_image->entity. Or a field           // column followed by a relationship specifier, for example           // $node->field_image->fid->entity. In both cases, prepare the

            static::assertNotNull($enrichedCustomEntity->getFlags()['admin-ui']);

            /** @var AdminUiEntity $adminUi */
            $adminUi = $enrichedCustomEntity->getFlags()['admin-ui'];
            static::assertEquals('sw-content', $adminUi->getVars()['navigationParent']);
            static::assertEquals(50, $adminUi->getVars()['position']);
            static::assertEquals('regular-tools-alt', $adminUi->getVars()['icon']);
            static::assertEquals('#f00', $adminUi->getVars()['color']);

            $listingColumns = $adminUi->getListing()->getColumns()->getContent();
            static::assertCount(3, $listingColumns);

            $listingColumnNames = array_map(static fn ($column) => $column->getVars()['ref'], $listingColumns);

            static::assertIsArray($listingColumns);

            static::assertContains('test_string', $listingColumnNames);
            static::assertFalse($listingColumns[0]->isHidden());
            static::assertContains('test_text', $listingColumnNames);
            static::assertFalse($listingColumns[1]->isHidden());
            static::assertContains('test_int', $listingColumnNames);
            

protected function importTranslation(string $table, Translations $translations, Connection $connection): TranslationWriteResult
    {
        $germanIds = $this->getLanguageIds($connection, 'de-DE');
        $englishIds = array_diff(
            array_merge($this->getLanguageIds($connection, 'en-GB'), [Defaults::LANGUAGE_SYSTEM]),
            $germanIds
        );

        $columns = [];
        $values = [];

        $keys = array_merge($translations->getColumns(), ['created_at', 'language_id']);
        foreach ($keys as $column) {
            $columns[] = '`' . $column . '`';
            $values[] = ':' . $column;
        }

        $sql = str_replace(
            ['#columns#', '#values#', '#table#'],
            [
                implode(',', $columns),
                implode(',', $values),
                '`' . $table . '`',
            ],

  protected function getModuleAndPath() {
    return ['path', dirname(__DIR__, 4)];
  }

  /** * @covers ::getColumns * @covers ::getSchema */
  public function testGetColumns() {
    $this->assertSame([], $this->definition->getColumns());
  }

}

    /** * {@inheritdoc} */
    protected function execute(InputInterface $input, OutputInterface $output)
    {
        $io = new SymfonyStyle($input, $output);

        $this->connection = $this->container->get(Connection::class);
        $this->updateStatement = $this->connection->prepare('UPDATE s_core_translations SET objectdata=:data WHERE id=:id');
        $this->columns = $this->getColumns();

        $result = $this->connection
            ->query('SELECT MAX(id) AS maxId, count(1) AS count FROM s_core_translations;')
            ->fetch(PDO::FETCH_ASSOC);

        $this->migrate($io->createProgressBar($result['count']), $result['maxId']);

        return 0;
    }

    /** * @param int $maxId */

return $entities[$name];
    }

    /** * @param list<string> $refs */
    private function checkListing(Entity $entity, array $refs): void
    {
        $listing = $entity->getListing();
        static::assertInstanceOf(Listing::class, $listing);

        $columns = $listing->getColumns();
        static::assertInstanceOf(Columns::class, $columns);
        static::assertCount(\count($refs), $columns->getContent());

        foreach ($columns->getContent() as $column) {
            static::assertInstanceOf(Column::class, $column);
            static::assertIsString($column->getRef());
            static::assertContains($column->getRef(), $refs);
            unset($refs[array_search($column->getRef(), $refs, true)]);
        }
        static::assertCount(0, $refs);
    }