swift - फायरस्टार: एक संग्रह में यादृच्छिक दस्तावेज कैसे प्राप्त करें




database firebase (4)

फायरबेस में संग्रह से यादृच्छिक पर कई दस्तावेजों का चयन करने में सक्षम होने के लिए मेरे आवेदन के लिए यह महत्वपूर्ण है।

चूंकि फायरबेस (जिसमें मुझे पता है) में एक क्वेरी प्राप्त करने के लिए कोई देशी कार्य नहीं किया गया है, जो ऐसा करता है, मेरा पहला विचार एक यादृच्छिक शुरुआत और अंत इंडेक्स का चयन करने के लिए क्वेरी कर्सर का उपयोग करना था बशर्ते कि मेरे पास दस्तावेजों की संख्या हो संग्रह।

यह दृष्टिकोण काम करेगा लेकिन केवल एक सीमित फैशन में, क्योंकि हर दस्तावेज़ को हर बार अपने पड़ोसी दस्तावेजों के साथ अनुक्रम में परोसा जाएगा; हालाँकि, अगर मैं इसके मूल संग्रह में इसके सूचकांक द्वारा एक दस्तावेज़ का चयन करने में सक्षम था, तो मैं एक यादृच्छिक दस्तावेज़ क्वेरी प्राप्त कर सकता था, लेकिन समस्या यह है कि मुझे कोई भी दस्तावेज़ नहीं मिल रहा है जो बताता है कि आप यह कैसे कर सकते हैं या भले ही आप ऐसा कर सकते हैं।

यहाँ मैं क्या करने में सक्षम होना चाहता हूँ, निम्नलिखित फायरस्टार स्कीमा पर विचार करें:

root/
  posts/
     docA
     docB
     docC
     docD

फिर मेरे ग्राहक में (मैं एक स्विफ्ट वातावरण में हूँ) मैं एक प्रश्न लिखना चाहूंगा जो यह कर सकता है:

db.collection("posts")[0, 1, 3] // would return: docA, docB, docD

वहाँ वैसे भी मैं इस की तर्ज पर कुछ कर सकता हूँ? या, क्या एक अलग तरीके से मैं एक समान फैशन में यादृच्छिक दस्तावेजों का चयन कर सकता हूं?

कृपया मदद कीजिए।


एंगुलर + फायरस्टार का उपयोग करने वालों के लिए, @ मैक मैकग्रा तकनीक पर बिल्डिंग, यहां कोड स्निपेट है।

नीचे कोड स्निपेट 1 दस्तावेज़ देता है।

  getDocumentRandomlyParent(): Observable<any> {
    return this.getDocumentRandomlyChild()
      .pipe(
        expand((document: any) => document === null ? this.getDocumentRandomlyChild() : EMPTY),
      );
  }

  getDocumentRandomlyChild(): Observable<any> {
      const random = this.afs.createId();
      return this.afs
        .collection('my_collection', ref =>
          ref
            .where('random_identifier', '>', random)
            .limit(1))
        .valueChanges()
        .pipe(
          map((documentArray: any[]) => {
            if (documentArray && documentArray.length) {
              return documentArray[0];
            } else {
              return null;
            }
          }),
        );
  }

1) .expand () पुनरावर्तन के लिए एक rxjs ऑपरेशन है यह सुनिश्चित करने के लिए कि हम निश्चित रूप से यादृच्छिक चयन से एक दस्तावेज प्राप्त करते हैं।

2) उम्मीद के अनुसार काम करने के लिए हमें 2 अलग-अलग कार्य करने की आवश्यकता है।

3) हम .MPand () ऑपरेटर को समाप्त करने के लिए EMPTY का उपयोग करते हैं।

import { Observable, EMPTY } from 'rxjs';

बस इस काम को एंगुलर 7 + आरएक्सजेएस में बनाया गया है, इसलिए यहां उन लोगों के साथ साझा करना चाहिए जो एक उदाहरण चाहते हैं।

मैंने @Dan McGrath के उत्तर का उपयोग किया, और मैंने इन विकल्पों को चुना: रैंडम इंटेगर संस्करण + कुल्ला और कई नंबरों के लिए दोहराएं। मैंने इस लेख में समझाया गया सामान भी इस्तेमाल किया: RxJS, इफ-एल्स ऑपरेटर कहाँ है? यदि धारा स्तर पर / अन्यथा कथन बनाने के लिए (यदि आप में से किसी को उस पर प्राइमर की आवश्यकता है)।

यह भी ध्यान दें कि मैंने कोणीय में आसान angularfire2 एकीकरण के लिए angularfire2 का उपयोग किया था।

यहाँ कोड है:

import { Component, OnInit } from '@angular/core';
import { Observable, merge, pipe } from 'rxjs';
import { map, switchMap, filter, take } from 'rxjs/operators';
import { AngularFirestore, QuerySnapshot } from '@angular/fire/firestore';

@Component({
  selector: 'pp-random',
  templateUrl: './random.component.html',
  styleUrls: ['./random.component.scss']
})
export class RandomComponent implements OnInit {

  constructor(
    public afs: AngularFirestore,
  ) { }

  ngOnInit() {
  }

  public buttonClicked(): void {
    this.getRandom().pipe(take(1)).subscribe();
  }

  public getRandom(): Observable<any[]> {
    const randomNumber = this.getRandomNumber();
    const request$ = this.afs.collection('your-collection', ref => ref.where('random', '>=', randomNumber).orderBy('random').limit(1)).get();
    const retryRequest$ = this.afs.collection('your-collection', ref => ref.where('random', '<=', randomNumber).orderBy('random', 'desc').limit(1)).get();

    const docMap = pipe(
      map((docs: QuerySnapshot<any>) => {
        return docs.docs.map(e => {
          return {
            id: e.id,
            ...e.data()
          } as any;
        });
      })
    );

    const random$ = request$.pipe(docMap).pipe(filter(x => x !== undefined && x[0] !== undefined));

    const retry$ = request$.pipe(docMap).pipe(
      filter(x => x === undefined || x[0] === undefined),
      switchMap(() => retryRequest$),
      docMap
    );

    return merge(random$, retry$);
  }

  public getRandomNumber(): number {
    const min = Math.ceil(Number.MIN_VALUE);
    const max = Math.ceil(Number.MAX_VALUE);
    return Math.floor(Math.random() * (max - min + 1)) + min;
  }
}

भविष्य में इस समस्या वाले किसी भी व्यक्ति की मदद करने के लिए पोस्ट करना।

यदि आप ऑटो आईडी का उपयोग कर रहे हैं, तो आप दान मैकग्राथ के उत्तर में उल्लिखित निकटतम ऑटो आईडी के लिए एक नई ऑटो आईडी और क्वेरी उत्पन्न कर सकते हैं।

मैंने हाल ही में एक यादृच्छिक उद्धरण एपीआई बनाया है और एक फायरस्टार संग्रह से यादृच्छिक उद्धरण प्राप्त करने की आवश्यकता है।
मैंने इस समस्या को हल किया है:

var db = admin.firestore();
var quotes = db.collection("quotes");

var key = quotes.doc().id;

quotes.where(admin.firestore.FieldPath.documentId(), '>', key).limit(1).get()
.then(snapshot => {
    if(snapshot.size > 0) {
        snapshot.forEach(doc => {
            console.log(doc.id, '=>', doc.data());
        });
    }
    else {
        var quote = quotes.where(admin.firestore.FieldPath.documentId(), '<', key).limit(1).get()
        .then(snapshot => {
            snapshot.forEach(doc => {
                console.log(doc.id, '=>', doc.data());
            });
        })
        .catch(err => {
            console.log('Error getting documents', err);
        });
    }
})
.catch(err => {
    console.log('Error getting documents', err);
});

क्वेरी की कुंजी यह है:

.where(admin.firestore.FieldPath.documentId(), '>', key)

और यदि कोई दस्तावेज नहीं मिलते हैं, तो ऑपरेशन के साथ इसे फिर से उलट दिया जाता है।

आशा है कि ये आपकी मदद करेगा!
यदि रुचि है, तो आप GitHub पर मेरे एपीआई के इस विशिष्ट भाग को पा सकते हैं


मेरे पास Firebase Firestore में यादृच्छिक रूप से एक सूची दस्तावेज़ प्राप्त करने का एक तरीका है, यह वास्तव में आसान है। जब मैं फायरस्टार पर डेटा अपलोड करता हूं तो मैं 1 से 1 मिलिअन से यादृच्छिक मान के साथ एक फ़ील्ड नाम "स्थिति" बनाता हूं। जब मैं फायर स्टोर से डेटा प्राप्त करता हूं, तो मैं ऑर्डर "फ़ील्ड" द्वारा सेट कर दूंगा और इसके लिए अपडेट मूल्य, बहुत सारे उपयोगकर्ता लोड डेटा और डेटा हमेशा अपडेट करते हैं और यह यादृच्छिक मूल्य होगा।





google-cloud-firestore