Function count

packages/sql/src/AbstractSqlDriver.ts:880–925

(entityName: EntityName<T>, where: any, options: CountOptions<T> = {})

  }

  async count<T extends object>(entityName: EntityName<T>, where: any, options: CountOptions<T> = {}): Promise<number> {
    const meta = this.metadata.get(entityName);

    if (meta.virtual) {
      return this.countVirtual<T>(entityName, where, options);
    }

    if (options.unionWhere?.length) {
      where = await this.applyUnionWhere(meta, where, options);
    }

    options = { populate: [], ...options };
    const populate = options.populate as unknown as PopulateOptions<T>[];
    const joinedProps = this.joinedProps(meta, populate, options as FindOptions<T>);
    const schema = this.getSchemaName(meta, options);
    const qb = this.createQueryBuilder<T>(entityName, options.ctx, options.connectionType, false, options.logging);
    qb.setAbortOptions(pickAbortOptions(options));
    const populateWhere = this.buildPopulateWhere(meta, joinedProps, options);

    if (meta && !Utils.isEmpty(populate)) {
      this.buildFields(meta, populate, joinedProps, qb, qb.alias, options as FindOptions<T>, schema);
    }

    this.validateSqlOptions(options);

    qb.state.resolvedPopulateWhere = (options as Dictionary)._populateWhere;
    qb.indexHint(options.indexHint as string)
      .collation(options.collation as string)
      .comment(options.comments)
      .hintComment(options.hintComments)
      .groupBy(options.groupBy as any)
      .having(options.having as any)
      .populate(
        populate,
        joinedProps.length > 0 ? populateWhere : undefined,
        joinedProps.length > 0 ? options.populateFilter : undefined,
      )
      .withSchema(schema)
      .where(where);

    if (options.em) {
      await qb.applyJoinedFilters(options.em, options.filters);
    }

    return this.rethrow(qb.getCount());
  }

  async nativeInsert<T extends object>(
    entityName: EntityName<T>,