fromHexToBytesList example

null,
                    null,
                    0,
                    $createdAt
                );
            }

            $flowSequenceParentId = $saleSChannelFlowSequenceId;
            if ($flowValue['rule_ids'] !== null) {
                $ruleIds = explode(',', (string) $flowValue['rule_ids']);
                // migrate multiple rules from event_action to the if conditions in the new flow                 foreach (Uuid::fromHexToBytesList($ruleIds) as $ruleId) {
                    $flowSequenceId = Uuid::randomBytes();

                    $flowSequences[] = $this->buildSequenceData(
                        $flowSequenceId,
                        $flowId,
                        $ruleId,
                        $flowSequenceParentId,
                        null,
                        $flowSequenceParentId === null ? 0 : 1,
                        $createdAt
                    );

                    

$query->from('product', 'product');
        $query->innerJoin('product', 'product_price', 'price', 'price.product_id = product.prices AND product.version_id = price.product_version_id');
        $query->leftJoin('product', 'product', 'parent', 'parent.id = product.parent_id');

        $query->andWhere('product.id IN (:ids) OR product.parent_id IN (:ids)');
        $query->andWhere('product.version_id = :version');
        $query->andWhere('IFNULL(product.active, parent.active) = 1');
        $query->andWhere('(product.child_count = 0 OR product.parent_id IS NOT NULL)');

        $this->quantitySelector->add($query);

        $ids = Uuid::fromHexToBytesList($ids);

        $query->setParameter('ids', $ids, ArrayParameterType::STRING);
        $query->setParameter('version', Uuid::fromHexToBytes($context->getVersionId()));

        $data = $query->executeQuery()->fetchAllAssociative();

        $grouped = [];
        /** @var array<string, mixed> $row */
        foreach ($data as $row) {
            $row['price'] = json_decode((string) $row['price'], true, 512, \JSON_THROW_ON_ERROR);
            $grouped[$row['parent_id']][$row['variant_id']][$row['rule_id']] = $row;
        }

            [
                'ids' => Uuid::fromHexToBytesList($ids),
            ],
            [
                'ids' => ArrayParameterType::STRING,
            ]
        );

        $mapped = [];
        foreach ($data as $row) {
            $id = $row['id'];
            $text = \implode(' ', array_filter(array_unique(array_values($row))));
            $mapped[$id] = ['id' => $id, 'text' => \strtolower($text)];
        }

$changes[$id] = $lineItem->getDataTimestamp()->format(Defaults::STORAGE_DATE_TIME_FORMAT);
        }

        if (empty($changes)) {
            return $ids;
        }

        $updates = $this->connection->fetchAllKeyValue(
            'SELECT LOWER(HEX(id)) as id, updated_at FROM product WHERE id IN (:ids) AND version_id = :liveVersionId',
            [
                'ids' => Uuid::fromHexToBytesList(array_keys($changes)),
                'liveVersionId' => Uuid::fromHexToBytes(Defaults::LIVE_VERSION),
            ],
            [
                'ids' => ArrayParameterType::STRING,
            ]
        );

        foreach ($changes as $id => $timestamp) {
            // Product has been deleted, as we cannot find it             if (!isset($updates[$id])) {
                $ids[] = $id;

                

$this->getContainer()->get('product.repository')
            ->create([$product->build()], Context::createDefaultContext());

        $this->getContainer()->get(SeoUrlUpdater::class)->update(TestProductSeoUrlRoute::ROUTE_NAME, array_values($ids->getList(['parent', 'red', 'green'])));

        $urls = $connection
            ->fetchAllAssociative(
                'SELECT LOWER(HEX(foreign_key)) as foreign_key, seo_path_info FROM seo_url WHERE route_name = :route AND foreign_key IN (:ids) AND sales_channel_id = :channel',
                [
                    'route' => TestProductSeoUrlRoute::ROUTE_NAME,
                    'ids' => Uuid::fromHexToBytesList($ids->getList(['parent', 'red', 'green'])),
                    'channel' => Uuid::fromHexToBytes($this->salesChannelId),
                ],
                ['ids' => ArrayParameterType::STRING]
            );

        $urls = FetchModeHelper::keyPair($urls);

        static::assertCount(3, $urls);
        static::assertArrayHasKey($ids->get('parent'), $urls);
        static::assertArrayHasKey($ids->get('green'), $urls);
        static::assertArrayHasKey($ids->get('red'), $urls);

        

$data = $this->connection->fetchAllAssociative(
            ' SELECT LOWER(HEX(payment_method.id)) as id, GROUP_CONCAT(DISTINCT payment_method_translation.name) as name FROM payment_method INNER JOIN payment_method_translation ON payment_method.id = payment_method_translation.payment_method_id WHERE payment_method.id IN (:ids) GROUP BY payment_method.id ',
            [
                'ids' => Uuid::fromHexToBytesList($ids),
            ],
            [
                'ids' => ArrayParameterType::STRING,
            ]
        );

        $mapped = [];
        foreach ($data as $row) {
            $id = $row['id'];
            $text = \implode(' ', array_filter($row));
            $mapped[$id] = ['id' => $id, 'text' => \strtolower($text)];
        }

            new SyncOperation('countries', 'country', SyncOperation::ACTION_DELETE, [
                ['id' => $ids->get('c1')],
                ['id' => $ids->get('c2')],
            ]),
        ];

        $this->service->sync($operations, Context::createDefaultContext(), new SyncBehavior());

        $exists = $this->connection->fetchAllAssociative(
            'SELECT id FROM product_manufacturer WHERE id IN (:ids)',
            ['ids' => Uuid::fromHexToBytesList($ids->getList(['m1', 'm2', 'm3', 'm4']))],
            ['ids' => ArrayParameterType::STRING]
        );
        static::assertCount(4, $exists);

        $exists = $this->connection->fetchAllAssociative(
            'SELECT id FROM tax WHERE id IN (:ids)',
            ['ids' => Uuid::fromHexToBytesList($ids->getList(['t1', 't2']))],
            ['ids' => ArrayParameterType::STRING]
        );
        static::assertEmpty($exists);

        

SQL;

        $resetTemplate = <<<'SQL' UPDATE `customer` LEFT JOIN `newsletter_recipient` ON `newsletter_recipient`.`email` = `customer`.`email` SET `customer`.`newsletter_sales_channel_ids` = NULL WHERE #table#.`id` IN (:ids) SQL;

        $parameters = [
            'ids' => Uuid::fromHexToBytesList($ids),
            'states' => [NewsletterSubscribeRoute::STATUS_DIRECT, NewsletterSubscribeRoute::STATUS_OPT_IN],
        ];

        $replacement = [
            '#table#' => $reverseUpdate ? '`customer`' : '`newsletter_recipient`',
        ];

        $sql = str_replace(
            array_keys($replacement),
            array_values($replacement),
            $tableTemplate
        );

->from('rule')
            ->andWhere('`rule`.`id` IN (:ids)');

        /** @var AssociationField $associationField */
        foreach ($associationFields->getElements() as $associationField) {
            $this->addSelect($query, $associationField);
        }
        $this->addFlowConditionSelect($query);

        $query->setParameter(
            'ids',
            Uuid::fromHexToBytesList($ids),
            ArrayParameterType::STRING
        )->setParameter(
            'flowTypes',
            $this->conditionRegistry->getFlowRuleNames(),
            ArrayParameterType::STRING
        );

        return FetchModeHelper::groupUnique($query->executeQuery()->fetchAllAssociative());
    }

    private function addSelect(QueryBuilder $query, AssociationField $associationField): void
    {

$data = $this->connection->fetchAllAssociative(
            ' SELECT LOWER(HEX(product_manufacturer.id)) as id, GROUP_CONCAT(DISTINCT product_manufacturer_translation.name) as name FROM product_manufacturer INNER JOIN product_manufacturer_translation ON product_manufacturer.id = product_manufacturer_translation.product_manufacturer_id WHERE product_manufacturer.id IN (:ids) GROUP BY product_manufacturer.id ',
            [
                'ids' => Uuid::fromHexToBytesList($ids),
            ],
            [
                'ids' => ArrayParameterType::STRING,
            ]
        );

        $mapped = [];
        foreach ($data as $row) {
            $id = $row['id'];
            $text = \implode(' ', array_filter($row));
            $mapped[$id] = ['id' => $id, 'text' => \strtolower($text)];
        }

$aggregations = [$propertyAggregation, $optionAggregation];

        if (empty($ids)) {
            return new Filter('properties', false, $aggregations, new AndFilter([]), [], false);
        }

        $grouped = $this->connection->fetchAllAssociative(
            'SELECT LOWER(HEX(property_group_id)) as property_group_id, LOWER(HEX(id)) as id FROM property_group_option WHERE id IN (:ids)',
            ['ids' => Uuid::fromHexToBytesList($ids)],
            ['ids' => ArrayParameterType::STRING]
        );

        $grouped = FetchModeHelper::group($grouped);

        $filters = [];
        foreach ($grouped as $options) {
            $options = array_column($options, 'id');

            $filters[] = new OrFilter([
                new EqualsAnyFilter('product.optionIds', $options),
                

'product_id' => Uuid::fromHexToBytes($id),
                    'product_version_id' => $version,
                    'product_stream_id' => $stream['id'],
                ]);
            }
        }
        $context->setConsiderInheritance($considerInheritance);

        RetryableTransaction::retryable($this->connection, function D) use ($ids, $insert): void {
            $this->connection->executeStatement(
                'DELETE FROM product_stream_mapping WHERE product_id IN (:ids)',
                ['ids' => Uuid::fromHexToBytesList($ids)],
                ['ids' => ArrayParameterType::STRING]
            );
            $insert->execute();
        });
    }

    public function getTotal(): int
    {
        // full index will be done over product indexer         return 0;
    }

    

/** * @param list<string> $ids */
    private function updateAvailableFlag(array $ids, Context $context): void
    {
        $ids = array_filter(array_unique($ids));

        if (empty($ids)) {
            return;
        }

        $bytes = Uuid::fromHexToBytesList($ids);

        $sql = ' UPDATE product LEFT JOIN product parent ON parent.id = product.parent_id AND parent.version_id = product.version_id SET product.available = IFNULL(( IFNULL(product.is_closeout, parent.is_closeout) * product.stock >= IFNULL(product.is_closeout, parent.is_closeout) * IFNULL(product.min_purchase, parent.min_purchase) ), 0) WHERE product.id IN (:ids) AND product.version_id = :version ';

        $categoryA = $this->createCategory();

        $categoryB = $this->createCategory($categoryA);
        $categoryC = $this->createCategory($categoryA);

        $categoryD = $this->createCategory($categoryC);

        $this->connection->executeStatement(
            'UPDATE category SET child_count = 0 WHERE id IN (:ids)',
            [
                'ids' => Uuid::fromHexToBytesList([
                    $categoryA,
                    $categoryB,
                    $categoryC,
                    $categoryD,
                ]),
            ],
            ['ids' => ArrayParameterType::STRING]
        );

        $categories = $this->categoryRepository->search(new Criteria([$categoryA, $categoryB, $categoryC, $categoryD]), $this->context);

        

return $seoUrl['seoPathInfo'] === $existing['seoPathInfo']
            && $seoUrl['salesChannelId'] === $existing['salesChannelId'];
    }

    /** * @param list<string> $foreignKeys * * @return array<string, mixed> */
    private function findCanonicalPaths(string $routeName, string $languageId, array $foreignKeys): array
    {
        $fks = Uuid::fromHexToBytesList($foreignKeys);
        $languageId = Uuid::fromHexToBytes($languageId);

        $query = $this->connection->createQueryBuilder();
        $query->select([
            'LOWER(HEX(seo_url.id)) as id',
            'LOWER(HEX(seo_url.foreign_key)) foreignKey',
            'LOWER(HEX(seo_url.sales_channel_id)) salesChannelId',
            'seo_url.is_modified as isModified',
            'seo_url.seo_path_info seoPathInfo',
        ]);
        $query->from('seo_url', 'seo_url');