Question

我有2个表在解析具有一对一关系的记忆和位置，但指针位于位置表（指针）

中

我需要的是通过跳过和限制以及每个存储器读取所有存储器10到10，以获取具有位置对象的属性

到现在为止我有这个：

var _ = require('underscore.js');
Parse.Cloud.define("feed", function(request, response) {
    var memories = Parse.Object.extend("Memories");
    var memoriesQuery = new Parse.Query(memories);

    memoriesQuery.skip(0);//request.params.skip);
    memoriesQuery.limit(10);//request.params.limit);
    memoriesQuery.descending("createdAt");
    memoriesQuery.include("group");

    var parsedResults = [];

    memoriesQuery.find().then(function(memories) {

        var promise = Parse.Promise.as();
        _.each(memories, function(memory) {

            promise = promise.then(function() {
                var locations = Parse.Object.extend("Locations");
                var locationsQuery = new Parse.Query(locations);
                locationsQuery.equalTo("memory", memory);

                var subPromise = Parse.Promise();

                locationsQuery.first().then(function(location) {
                    memory["location"] = location;
                    console.log(JSON.stringify(memory) + " ........ " + memory["location"]);
                    console.log("=============");
                    parsedResults.push(memory);
                    subPromise.resolve(memory);
                });
                return subPromise ;
            });
            console.log("-----------");
            console.log("Promise:" +promise.toString());
        });

        return promise;

    }).then(function(){
        response.success(parsedResults);
    });
});

我不知道该怎么做..超过10个小时的尝试。我感谢任何帮助！

Answer 1

终于解决了！也许它会对某人有所帮助。

解决方案：

var _ = require('underscore.js');
var memoriesResult = [];
Parse.Cloud.define("feed", function(request, response) {
    var promises = [];
    var promise = findMemories();
    promise.then(function(memories){
        console.log("success promise!!");
        _.each(memories, function (memory) {
            console.log("each");
            promises.push(findLocation(memory));
        });
        return Parse.Promise.when(promises);
    }).then(function(){
        console.log("Finish");
        response.success(memoriesResult);
    }, function(error){
        console.error("Promise Error: " + error.message);
        response.error(error);
    });
});

function findMemories(){
    console.log("Enter findMemories");

    var memories = Parse.Object.extend("Memories");
    var memoriesQuery = new Parse.Query(memories);

    memoriesQuery.skip(0);//request.params.skip);
    memoriesQuery.limit(10);//request.params.limit);
    memoriesQuery.descending("createdAt");
    memoriesQuery.include("group");

    var promise = new Parse.Promise();

    memoriesQuery.find().then(function(memories) {
        console.log("Memories found!");
        promise.resolve(memories);
    }, function(error) {
        promise.reject(error);
    });
    return promise;
}

function findLocation(memory) {
    console.log("Enter findLocation");

    var locations = Parse.Object.extend("Locations");
    var locationsQuery = new Parse.Query(locations);
    locationsQuery.equalTo("memory", memory);

    var promise = new Parse.Promise();

    locationsQuery.first().then(function(location) {
        console.log("Location found");
        memoriesResult.push({"memory": memory, "location" : location});
        promise.resolve(memory);
    }, function(error) {
        promise.reject(error);
    });
    return promise;
}

Answer 2

在做了一些实验后，我提出了以下要求和解决方案：

您希望一次翻页Memories个项目，按其createdAt
您希望与每个内存相关的Locations
您受到关系为Locations->Memories

您的第一步是定义记忆查询：

var memoryQuery = new Parse.Query('Memories');
memoryQuery.skip(request.params.skip);
memoryQuery.skip(request.params.limit);
memoryQuery.descending('createdAt');

您现在可以使用此查询来限制返回的Locations个对象。如果您的链接都设置正确，您将获得10条记录：

var locationQuery = new Parse.Query('Locations');
// limit to only the page of Memory items requested
locationQuery.matchesQuery('memory', memoryQuery);
// include the Memory pointer's data
locationQuery.include('memory');
var memoriesResult = [];
locationQuery.find().then(function(locations) {
    var result = _.map(locations, function(location) {
        memory: location.get('memory'),
        location: location
    });
    response.success(result);
}, function(error) {
    response.error(error);
});

上面唯一的问题是我不确定返回记录的顺序，因此您可能希望在返回它们之前对它们进行重新排序。使用下划线库时，这非常简单。

无论页面大小如何，都会产生2个查询。

Parse.com - Promises - 将父对象与其他一对一对象一起作为属性返回

2 个答案: