/**
     * @private
     */
    async update<T extends IModel>(manager: ModelManager, model: T, params: IUpdateParams, result: ModelOperationResult<T, IUpdateMeta>): Promise<ModelOperationResult<T, IUpdateMeta>> {
        if (!params.where) {
            throw new Error(`update() requires the 'where' option to be set.`);
        }

        let meta = manager.getModelMeta(model);
        const mongoQuery = convertQuery(manager, meta.ctor, params.where);

        const fieldUpdates: IKeyMap<any> = {};
        params.fields!.forEach((fieldName) => {
            const field = meta.fieldsByName[fieldName];
            if (field.options.stored && typeof model[fieldName] != 'undefined') {
                let value = field.toBackendValue(manager, model[fieldName]);
                if (typeof value != 'undefined') {
                    fieldUpdates[fieldName] = value;
                }
            }
        });

        const colName = this._getCollectionName(meta);
        const updateResult = await this.db.collection(colName).updateMany(mongoQuery, { $set: fieldUpdates });

        result.setMeta({ totalCount: updateResult.matchedCount });
        return result;
    }

 /**
  * @private
  */
 async read<T extends IModel>(manager: ModelManager, model: new() => T, options: IReadOptions, result: ModelOperationResult<T, IReadMeta>): Promise<ModelOperationResult<T, IReadMeta>> {
     const meta = manager.getModelMeta(model);
     const query = this._buildGraphQLQuery(manager, meta, options);
     const httpResult = await this._getGraphQLQueryResult(query);
     if (!httpResult.data.data
         || !httpResult.data.data[meta.name]
         || !(httpResult.data.data[meta.name].results instanceof Array)) {
         throw this._createHttpError('GraphQL response did not contain the expected model results', httpResult);
     }
     const returnedData = httpResult.data.data[meta.name].results;
     result.results = [];
     returnedData.forEach((record: any) => {
         result.results!.push(this._hydrateRecordWithRelated(manager, meta, record, options.related));
     });
     const returnedMeta = httpResult.data.data[meta.name].meta;
     result.setMeta(returnedMeta);
     return result;
 }

    /**
     * @private
     */
    async read<T extends IModel>(manager: ModelManager, model: new() => T, params: IReadParams, result: ModelOperationResult<T, IReadMeta>): Promise<ModelOperationResult<T, IReadMeta>> {
        const meta = manager.getModelMeta(model);
        const colName = this._getCollectionName(meta);

        const mongoQuery = convertQuery(manager, model, params.where);

        const records = await this.db.collection(colName)
            .find(mongoQuery)
            .sort(this._convertOrderBy(params.orderBy))
            .skip(params.offset)
            .limit(params.limit)
            .toArray();

        const primaryKeyValues: any[] = [];
        const foreignKeyValues: IForeignKeyValues = {};
        const rawValues: IRawValues = [];
        const relatedFieldNames = getOwnRelatedFieldNames(params.related);

        result.results = [];
        records.forEach((record) => {

            const modelInstance = manager.hydrate(meta.ctor, record);
            result.results!.push(modelInstance);

            if (meta.primaryKey) {
                primaryKeyValues.push(modelInstance[meta.primaryKey]);
            }

            // TODO: Refactor this into a method shared with InMemoryBackend (and future backends)
            if (relatedFieldNames) {
                for (let fieldName of relatedFieldNames) {
                    let field = meta.fieldsByName[fieldName];
                    let keyValue = record[fieldName];
                    if (field instanceof fields.RelatedModelField) {
                        if (!(fieldName in foreignKeyValues)) {
                            foreignKeyValues[fieldName] = [];
                        }
                        if (typeof keyValue != 'undefined' && keyValue !== null) {
                            modelInstance[fieldName] = keyValue;
                            if (foreignKeyValues[fieldName].indexOf(keyValue) == -1) {
                                foreignKeyValues[fieldName].push(keyValue);
                            }
                        }
                        else {
                            modelInstance[fieldName] = null;
                        }
                    }
                }
            }

            if (params.rawValues) {
                let rawValueObj: IRawValueRow = {};
                for (let fieldName of params.rawValues) {
                    rawValueObj[fieldName] = record[fieldName];
                }
                rawValues.push(rawValueObj);
            }
        });

        // TODO: Refactor this into a method shared with InMemoryBackend (and future backends)
        if (relatedFieldNames) {
            // Get related record data
            const related = await Promise.all([
                getRelatedModelInstances(manager, meta, foreignKeyValues, params),
                getRelatedModelListInstances(manager, meta, primaryKeyValues, params)
            ]);
            const [relatedModelInstances, relatedModelListInstances] = related;

            for (let instance of result.results) {
                for (let fieldName of relatedFieldNames) {
                    let field = meta.fieldsByName[fieldName];
                    if (field instanceof fields.RelatedModelField) {
                        if (instance[fieldName] !== null
                            && relatedModelInstances[fieldName]
                            && relatedModelInstances[fieldName][instance[fieldName]]) {
                                instance[fieldName] = relatedModelInstances[fieldName][instance[fieldName]];
                        }
                        else {
                            instance[fieldName] = null;
                        }
                    }
                    else if (field instanceof fields.RelatedModelListField) {
                        if (relatedModelListInstances[fieldName]
                            && relatedModelListInstances[fieldName][instance[meta.primaryKey!]]) {
                                instance[fieldName] = relatedModelListInstances[fieldName][instance[meta.primaryKey!]];
                        }
                        else {
                            instance[fieldName] = [];
                        }
                    }
                }
            }
        }

        if (params.rawValues) {
            result.setMeta({ rawValues });
        }
//.........这里部分代码省略.........