Come eseguire più scoperte () con $ fetta?

Question

Ho il requisito di tirare molte parti $ fettine di molti documenti.

Al momento non riesco a vedere come fare, quindi ho un anello parallelo che tira questo dati per me, tuttavia ora voglio recuperare oltre 1000 nodi alla volta, e questo non sta diventando prestazioni, specialmente come Il driver Sharp MONGODB C non supporta le query Async.

Questa è la (esempio ma simile) struttura:

{ TransactionID: Bindata, Uscite: [{Dati: BINDATA}, {Dati: BINDATA}] }

Il mio codice al momento viene visualizzato individualmente, come segue:

var outputs = new SpendableOutput[inputArray.Length];

Parallel.ForEach(inputArray, (input, s, i) =>
{
    var transactionQuery = Transactions.Find(Query<TransactionInfo>.EQ(x => x.Hash, input.PrevTxHash))
                                .SetFields(new FieldsBuilder().Slice("o", (int)input.PrevTxOutputIndex, 1)
                                                                .Include("_id"));
    var transaction = transactionQuery.ToArray();
    if (transaction.Length != 0)
    {
        outputs[i] = new SpendableOutput
        {
            TxHash = inputArray[i].PrevTxHash,
            Index = (int)inputArray[i].PrevTxOutputIndex,
            Output = transaction[0].Outputs[0]
        };
    }
});

.

Come puoi vedere, sto interrogando la raccolta delle transazioni, il campo "O", che è una serie di uscite. Da questo voglio un numero di uscite. Mi rendo conto di poter chiedere tutte le transazioni basate sull'escursione _id nella mia lista e ottenere le uscite dopo che sono state recuperate, ma molte transazioni hanno elenchi di output di grandi dimensioni da cui ho solo bisogno di solitamente uno o due elementi. Il primo modo di migliorare questo è ottenere molte fette da un documento, come questa (non funziona).

var transactionQuery = Transactions.Find(Query<TransactionInfo>.EQ(x => x.Hash, input.PrevTxHash))
                            .SetFields(new FieldsBuilder().Slice("o", itemNeededIndex1, 1)
                                                          .Slice("o", itemNeededIndex2, 1)
                                                          .Slice("o", itemNeededIndex3, 1).Include("_id"));

.

In secondo luogo (deve essere preferito) è per me per inviare un lotto di query <> oggetti, poiché ho molti (oltre 1000 solitamente) oggetti di transazione (con output associati da recuperare).

C'è qualche esperto di query mongodb che potrebbe suggerire un approccio al raggiungimento di questi, o suggerire un approccio alternativo a cui non ho pensato?

Modifica:

La fonte dell'ID Capogruppo e dell'indice figlio è un ingresso esterno che sta definendo quali articoli potrebbero essere necessari per cancellare un particolare equilibrio. Hanno l'ID del genitore e solo l'indice del bambino. Questo consiste in una serie di un array di byte (ID genitore / hash) e INT (indice figlio).

Answer 1

Ho determinato che non c'è modo di raggiungere questo obiettivo, invece ci devono essere molte domande composte e licenziate a Mongodb.

Inoltre, poiché gli array sono grandi vale la pena normalizzare questi dati in una nuova collezione, tuttavia che fa male alle mie dimensioni dei dati.