populate example

$helper = new ConsoleProgressHelper($output);
        $helper->start($query->fetchCount(), 'Start indexing stream search data');

        $this->container->get(\Doctrine\DBAL\Connection::class)->transactional(
            function D) use ($helper, $query) {
                $this->container->get(\Doctrine\DBAL\Connection::class)->executeUpdate('DELETE FROM s_customer_search_index');

                $indexer = $this->container->get(\Shopware\Bundle\CustomerSearchBundleDBAL\Indexing\SearchIndexerInterface::class);

                while ($ids = $query->fetch()) {
                    $indexer->populate($ids);
                    $helper->advance(\count($ids));
                }
            }
        );

        $helper->finish();

        return 0;
    }

    private function createQuery()
    {

    public function populate(Smarty_Template_Source $source, ?Smarty_Internal_Template $_template = null)
    {
        if (!isset($source->smarty->registered_plugins[Smarty::PLUGIN_BLOCK]['snippet'])) {
            $source->smarty->registerPlugin(Smarty::PLUGIN_BLOCK, 'snippet', [__CLASS__, 'compileSnippetBlock']);
        }
        if (!isset($source->smarty->registered_plugins[Smarty::PLUGIN_MODIFIER]['snippet'])) {
            $source->smarty->registerPlugin(Smarty::PLUGIN_MODIFIER, 'snippet', [$this, 'compileSnippetModifier']);
        }
        $default_resource = $source->smarty->default_resource_type;
        $source->smarty->default_resource_type = 'file';
        parent::populate($source, $_template);
        $source->smarty->default_resource_type = $default_resource;
    }

    /** * Compiles the given snippet block if the content parameter is filled. * * @param array<string, mixed> $params * @param string|null $content * * @return string */
    

public function loadEnv(string $path, string $envKey = null, string $defaultEnv = 'dev', array $testEnvs = ['test'], bool $overrideExistingVars = false): void
    {
        $k = $envKey ?? $this->envKey;

        if (is_file($path) || !is_file($p = "$path.dist")) {
            $this->doLoad($overrideExistingVars, [$path]);
        } else {
            $this->doLoad($overrideExistingVars, [$p]);
        }

        if (null === $env = $_SERVER[$k] ?? $_ENV[$k] ?? null) {
            $this->populate([$k => $env = $defaultEnv], $overrideExistingVars);
        }

        if (!\in_array($env, $testEnvs, true) && is_file($p = "$path.local")) {
            $this->doLoad($overrideExistingVars, [$p]);
            $env = $_SERVER[$k] ?? $_ENV[$k] ?? $env;
        }

        if ('local' === $env) {
            return;
        }

        

$smarty = $_template->smarty;

        //         // load resource handler         //         $this->handler = $handler = Smarty_CacheResource::load($smarty); // Note: prone to circular references
        //         // check if cache is valid         //         if (!($_template->caching == Smarty::CACHING_LIFETIME_CURRENT || $_template->caching == Smarty::CACHING_LIFETIME_SAVED) || $_template->source->recompiled) {
            $handler->populate($this, $_template);
            return;
        }
        while (true) {
            while (true) {
                $handler->populate($this, $_template);
                if ($this->timestamp === false || $smarty->force_compile || $smarty->force_cache) {
                    $this->valid = false;
                } else {
                    $this->valid = true;
                }
                if ($this->valid && $_template->caching == Smarty::CACHING_LIFETIME_CURRENT && $_template->cache_lifetime >= 0 && time() > ($this->timestamp + $_template->cache_lifetime)) {
                    

// check runtime cache         $_cache_key = 'template|' . $unique_resource_name;
        if ($smarty->compile_id) {
            $_cache_key .= '|' . $smarty->compile_id;
        }
        if (isset(self::$sources[$_cache_key])) {
            return self::$sources[$_cache_key];
        }

        // create source         $source = new Smarty_Template_Source($resource, $smarty, $template_resource, $type, $name, $unique_resource_name);
        $resource->populate($source, $_template);

        // runtime cache         self::$sources[$_cache_key] = $source;

        return $source;
    }

    /** * initialize Config Source Object for given resource * * @param Smarty_Internal_Config $_config config object * * @return Smarty_Config_Source Source Object */

    public function refresh()
    {
        $helper = new CronJobProgressHelper();

        $query = $this->createQuery();

        $this->connection->transactional(function D) use ($query) {
            $this->connection->executeUpdate('DELETE FROM s_customer_search_index');

            while ($ids = $query->fetch()) {
                $this->searchIndexer->populate($ids);
            }
        });

        $streams = $this->fetchStreams();

        if (empty($streams)) {
            return true;
        }

        foreach ($streams as $stream) {
            if ($stream['freeze_up']) {
                

$ids = $this->streamRepository->fetchSearchIndexIds($lastId, $full);

        if (!empty($ids)) {
            $this->connection->executeStatement(
                'DELETE FROM s_customer_search_index WHERE id IN (:ids)',
                [':ids' => $ids],
                [':ids' => Connection::PARAM_INT_ARRAY]
            );
        }

        $this->searchIndexer->populate($ids);

        return $ids;
    }

    /** * @return void */
    public function cleanupIndexSearchIndex()
    {
        $this->searchIndexer->cleanupIndex();
    }

    

foreach ($this->mappings as $mapping) {
            if (!empty($indexNames) && !\in_array($mapping->getType(), $indexNames)) {
                continue;
            }

            $configuration = $this->indexFactory->createIndexConfiguration($shop, $mapping->getType());
            $shopIndex = new ShopIndex($configuration->getName(), $shop, $mapping->getType());

            $this->createIndex($configuration, $shopIndex);
            $this->updateMapping($shopIndex, $mapping);
            $this->populate($shopIndex, $helper);
            $this->applyBacklog($shopIndex, $lastBacklogId);
            $this->createAlias($configuration);
        }
    }

    /** * Removes unused indices */
    public function cleanupIndices()
    {
        $prefix = $this->indexFactory->getPrefix();
        

        $this->expectException(PathException::class);
        $dotenv = new Dotenv();
        $dotenv->load(__DIR__);
    }

    public function testServerSuperglobalIsNotOverridden()
    {
        $originalValue = $_SERVER['argc'];

        $dotenv = new Dotenv();
        $dotenv->populate(['argc' => 'new_value']);

        $this->assertSame($originalValue, $_SERVER['argc']);
    }

    public function testEnvVarIsNotOverridden()
    {
        putenv('TEST_ENV_VAR=original_value');
        $_SERVER['TEST_ENV_VAR'] = 'original_value';

        $dotenv = (new Dotenv())->usePutenv();
        $dotenv->populate(['TEST_ENV_VAR' => 'new_value']);