Method execute

packages/sql/src/query/QueryBuilder.ts:2452–2514

* Executes this QB and returns the raw results, mapped to the property names (unless disabled via last parameter). * Use `method` to specify what kind of result you want to get (array/single/meta).

(method?: 'all' | 'get' | 'run', options?: ExecuteOptions | boolean)

   * Use `method` to specify what kind of result you want to get (array/single/meta).
   */
  async execute<U = any>(method?: 'all' | 'get' | 'run', options?: ExecuteOptions | boolean): Promise<U> {
    options = typeof options === 'boolean' ? { mapResults: options } : (options ?? {});
    options.mergeResults ??= true;
    options.mapResults ??= true;
    const isRunType = [QueryType.INSERT, QueryType.UPDATE, QueryType.DELETE, QueryType.TRUNCATE].includes(this.type);
    method ??= isRunType ? 'run' : 'all';

    if (!this.connectionType && (isRunType || this.context)) {
      this.connectionType = 'write';
    }

    if (!this.#state.finalized && method === 'get' && this.type === QueryType.SELECT) {
      this.limit(1);
    }

    const query = this.toQuery();
    const cached = await this.em?.tryCache<Entity, U>(this.mainAlias.entityName, this.#state.cache, [
      'qb.execute',
      query.sql,
      query.params,
      method,
    ]);

    if (cached?.data !== undefined) {
      return cached.data as unknown as U;
    }

    const loggerContext = { id: this.em?.id, ...this.loggerContext, ...this.#abortOptions };
    const res = await this.getConnection().execute(query.sql, query.params, method, this.context, loggerContext);
    const meta = this.mainAlias.meta;

    if (!options.mapResults || !meta) {
      await this.em?.storeCache(this.#state.cache, cached!, res);
      return res as unknown as U;
    }

    if (method === 'run') {
      return res as U;
    }

    const joinedProps = this.driver.joinedProps(meta, this.#state.populate);
    let mapped: EntityData<Entity>[];

    if (Array.isArray(res)) {
      const map: Dictionary = {};
      mapped = res.map(r => this.driver.mapResult<Entity>(r as Entity, meta, this.#state.populate, this as any, map)!);

      if (options.mergeResults && joinedProps.length > 0) {
        mapped = this.driver.mergeJoinedResult(mapped, this.mainAlias.meta, joinedProps);
      }
    } else {
      mapped = [this.driver.mapResult<Entity>(res, meta, joinedProps, this as any)!];
    }

    if (method === 'get') {
      await this.em?.storeCache(this.#state.cache, cached!, mapped[0]);
      return mapped[0] as U;
    }