/// check | **FastAPI** le recommande comme

Le serveur web principal pour exécuter les applications **FastAPI**.

Vous pouvez également utiliser l'option de ligne de commande `--workers` pour avoir un serveur multi‑processus asynchrone.

Pour plus de détails, consultez la section [Déploiement](deployment/index.md).

///

## Benchmarks et vitesse { #benchmarks-and-speed }

labels.crawlingThreadCount=Nombre d'explorations simultanées
labels.boost=Boost
labels.crawlingConfigName=Nom
labels.crawlingConfigPath=Chemin à explorer
labels.processType=Type de processus
labels.parameters=Paramètres
labels.designFile=Fichier à téléverser
labels.bulkFile=Fichier en vrac
labels.appendQueryParameter=Ajouter des paramètres de recherche
labels.configId=ID de configuration

     * @param resultData the result data to be processed
     * @return the access result containing the processed data
     */
    @Override
    protected AccessResult<?> createAccessResult(final ResponseData responseData, final ResultData resultData) {
        return super.createAccessResult(responseData, ingest(responseData, resultData));
    }

    /**
     * Processes the result data through all available ingesters.

     * @param query the Lucene query to be processed
     * @param boost the boost factor to apply to the query
     * @return the processed OpenSearch QueryBuilder
     */
    public QueryBuilder execute(final QueryContext context, final Query query, final float boost) {
        return filterChain.execute(context, query, boost);
    }

    /**
     * Adds a query command to the processor.
     *

     * @param pageSize The number of hits per scroll page
     * @param processor The processor to convert each hit into result items
     * @return A list of processed results
     */
    public static <T> List<T> scrollSearch(final Client client, final SuggestSettings settings, final String index,
            final QueryBuilder query, final int pageSize, final HitProcessor<T> processor) {

        final List<T> results = new ArrayList<>();

    /**
     * Set of fully qualified class names that have been processed and contain the {@link Named} annotation.
     */
    private final Set<String> processedClasses = new HashSet<>();

    /**
     * Processes classes with the {@link Named} annotation and generates an index file.
     *
     * @param annotations the annotation types requested to be processed

	match     func(*DB) bool
	handler   func(*DB)
	processor *processor
}

func (cs *callbacks) Create() *processor {
	return cs.processors["create"]
}

func (cs *callbacks) Query() *processor {
	return cs.processors["query"]
}

func (cs *callbacks) Update() *processor {
	return cs.processors["update"]
}

func (cs *callbacks) Delete() *processor {
	return cs.processors["delete"]
}

    }

    /**
     * Processes a document map for datastore operations.
     * Default implementation delegates to the basic process method.
     *
     * @param target the document data to process
     * @param params the data store parameters
     * @return the processed document data
     */
    public Map<String, Object> process(final Map<String, Object> target, final DataStoreParams params) {

        }
    }

    /**
     * Processes and normalizes a document title.
     * Applies text normalization using configured space characters and returns
     * a clean title suitable for indexing.
     *
     * @param responseData the response data from crawling (not currently used)
     * @param title the raw title text to process
     * @param dataMap additional data map (not currently used)

        }

        ModelObjectProcessor processor = ProcessorHolder.CACHED_PROCESSOR.get();
        if (processor == null) {
            processor = loadProcessor();
            ProcessorHolder.CACHED_PROCESSOR.compareAndSet(null, processor);
            processor = ProcessorHolder.CACHED_PROCESSOR.get();
        }
        return processor.process(object);
    }

    /**