इस पेज का अनुवाद Cloud Translation API से किया गया है.
Switch to English

पुन: प्राप्त डेटा

यह दस्तावेज़ डेटाबेस डेटा को पुनः प्राप्त करने की मूल बातें शामिल करता है, डेटा कैसे ऑर्डर किया जाता है, और डेटा पर सरल क्वेरी कैसे करें। एडमिन एसडीके में डेटा पुनर्प्राप्ति को विभिन्न प्रोग्रामिंग भाषाओं में थोड़ा अलग तरीके से लागू किया जाता है।

  1. एसिंक्रोनस श्रोताओं: फायरबेस रियलटाइम डेटाबेस में संग्रहीत डेटा को एक अतुल्यकालिक श्रोता को डेटाबेस संदर्भ में संलग्न करके पुनर्प्राप्त किया जाता है। श्रोता को डेटा की प्रारंभिक स्थिति के लिए एक बार ट्रिगर किया जाता है और फिर कभी भी डेटा बदल जाता है। एक इवेंट श्रोता कई अलग-अलग प्रकार के ईवेंट प्राप्त कर सकता है। डेटा पुनर्प्राप्ति का यह तरीका Java, Node.js और Python Admin SDKs में समर्थित है।
  2. ब्लॉकिंग रीड्स: फायरबेस रियलटाइम डेटाबेस में संग्रहीत डेटा को एक डेटाबेस संदर्भ पर एक ब्लॉकिंग विधि को आमंत्रित करके पुनर्प्राप्त किया जाता है, जो संदर्भ में संग्रहीत डेटा लौटाता है। प्रत्येक विधि कॉल ऑनटाइम ऑपरेशन है। इसका मतलब है कि एसडीके कोई कॉलबैक दर्ज नहीं करता है जो बाद के डेटा अपडेट को सुनता है। डेटा पुनर्प्राप्ति का यह मॉडल पायथन और गो एडमिन एसडीके में समर्थित है।

शुरू करना

आइए पिछले लेख से ब्लॉगिंग उदाहरण को फिर से देखें, यह समझने के लिए कि फायरबेस डेटाबेस से डेटा कैसे पढ़ें। याद रखें कि उदाहरण एप्लिकेशन में ब्लॉग पोस्ट डेटाबेस URL https://docs-examples.firebaseio.com/server/saving-data/fireblog/posts.json पर संग्रहीत हैं। अपना पोस्ट डेटा पढ़ने के लिए, आप निम्न कार्य कर सकते हैं:

जावा
public static class Post {

  public String author;
  public String title;

  public Post(String author, String title) {
    // ...
  }

}

// Get a reference to our posts
final FirebaseDatabase database = FirebaseDatabase.getInstance();
DatabaseReference ref = database.getReference("server/saving-data/fireblog/posts");

// Attach a listener to read the data at our posts reference
ref.addValueEventListener(new ValueEventListener() {
  @Override
  public void onDataChange(DataSnapshot dataSnapshot) {
    Post post = dataSnapshot.getValue(Post.class);
    System.out.println(post);
  }

  @Override
  public void onCancelled(DatabaseError databaseError) {
    System.out.println("The read failed: " + databaseError.getCode());
  }
});
Node.js
04b99b6e10
अजगर
# Import database module.
from firebase_admin import db

# Get a database reference to our posts
ref = db.reference('server/saving-data/fireblog/posts')

# Read the data at the posts reference (this is a blocking operation)
print(ref.get())
जाओ

// Post is a json-serializable type.
type Post struct {
	Author string `json:"author,omitempty"`
	Title  string `json:"title,omitempty"`
}

// Create a database client from App.
client, err := app.Database(ctx)
if err != nil {
	log.Fatalln("Error initializing database client:", err)
}

// Get a database reference to our posts
ref := client.NewRef("server/saving-data/fireblog/posts")

// Read the data at the posts reference (this is a blocking operation)
var post Post
if err := ref.Get(ctx, &post); err != nil {
	log.Fatalln("Error reading value:", err)
}

यदि आप उपरोक्त कोड चलाते हैं, तो आपको कंसोल में लॉग की गई आपकी सभी पोस्ट वाली एक ऑब्जेक्ट दिखाई देगी। Node.js और Java के मामले में, श्रोता फ़ंक्शन को कभी भी कहा जाता है नया डेटा आपके डेटाबेस संदर्भ में जोड़ा जाता है, और ऐसा करने के लिए आपको कोई अतिरिक्त कोड लिखने की आवश्यकता नहीं है।

Java और Node.js में, कॉलबैक फ़ंक्शन एक DataSnapshot प्राप्त करता है, जो डेटा का स्नैपशॉट है। एक स्नैपशॉट एक समय में एक विशेष डेटाबेस संदर्भ में डेटा की एक तस्वीर है। val() / getValue() स्नैपशॉट पर डेटा की एक भाषा-विशिष्ट ऑब्जेक्ट प्रतिनिधित्व लौटाता है। यदि संदर्भ के स्थान पर कोई डेटा मौजूद नहीं है, तो स्नैपशॉट का मान null । पायथन में विधि get() विधि सीधे डेटा के पायथन प्रतिनिधित्व को लौटाती है। Get() फ़ंक्शन किसी दिए गए डेटा संरचना में डेटा को अनमर्ष करता है।

ध्यान दें कि हमने ऊपर उदाहरण में value घटना प्रकार का उपयोग किया था, जो फायरबेस डेटाबेस संदर्भ की संपूर्ण सामग्री को पढ़ता है, भले ही डेटा का केवल एक टुकड़ा बदल गया हो। value नीचे सूचीबद्ध पांच अलग-अलग घटनाओं में से एक है जिसका उपयोग आप डेटाबेस से डेटा पढ़ने के लिए कर सकते हैं।

जावा और Node.js में ईवेंट प्रकार पढ़ें

मूल्य

value इवेंट का उपयोग किसी दिए गए डेटाबेस पथ पर सामग्री के स्थिर स्नैपशॉट को पढ़ने के लिए किया जाता है, क्योंकि वे रीड इवेंट के समय मौजूद थे। यह शुरुआती डेटा के साथ एक बार चालू हो जाता है और फिर से हर बार डेटा बदल जाता है। ईवेंट कॉलबैक एक स्नैपशॉट है जिसमें उस स्थान पर सभी डेटा होते हैं, जिसमें चाइल्ड डेटा भी शामिल है। ऊपर दिए गए कोड उदाहरण में, value ने आपके एप्लिकेशन के सभी ब्लॉग पोस्ट लौटा दिए। हर बार एक नया ब्लॉग पोस्ट जोड़ा जाता है, कॉलबैक फ़ंक्शन सभी पदों को वापस कर देगा।

बच्चा जोड़ा

डेटाबेस से आइटम की सूची प्राप्त करते समय child_added इवेंट का उपयोग आमतौर पर किया जाता है। value विपरीत, जो स्थान की संपूर्ण सामग्री child_added है, child_added को प्रत्येक मौजूदा बच्चे के लिए एक बार ट्रिगर किया जाता है और फिर हर बार एक नए बच्चे को निर्दिष्ट पथ में जोड़ा जाता है। ईवेंट कॉलबैक एक स्नैपशॉट है जिसमें नए बच्चे का डेटा है। आदेश देने के उद्देश्यों के लिए, यह पिछले बच्चे की कुंजी वाला एक दूसरा तर्क भी है।

यदि आप अपने ब्लॉगिंग ऐप में जोड़े गए प्रत्येक नए पोस्ट पर केवल डेटा पुनर्प्राप्त करना चाहते हैं, तो आप child_added उपयोग कर सकते हैं:

जावा
ref.addChildEventListener(new ChildEventListener() {
  @Override
  public void onChildAdded(DataSnapshot dataSnapshot, String prevChildKey) {
    Post newPost = dataSnapshot.getValue(Post.class);
    System.out.println("Author: " + newPost.author);
    System.out.println("Title: " + newPost.title);
    System.out.println("Previous Post ID: " + prevChildKey);
  }

  @Override
  public void onChildChanged(DataSnapshot dataSnapshot, String prevChildKey) {}

  @Override
  public void onChildRemoved(DataSnapshot dataSnapshot) {}

  @Override
  public void onChildMoved(DataSnapshot dataSnapshot, String prevChildKey) {}

  @Override
  public void onCancelled(DatabaseError databaseError) {}
});
Node.js
// Retrieve new posts as they are added to our database
ref.on("child_added", function(snapshot, prevChildKey) {
  var newPost = snapshot.val();
  console.log("Author: " + newPost.author);
  console.log("Title: " + newPost.title);
  console.log("Previous Post ID: " + prevChildKey);
});
है

इस उदाहरण में स्नैपशॉट में एक व्यक्तिगत ब्लॉग पोस्ट के साथ एक ऑब्जेक्ट होगा। क्योंकि SDK मान को पुनः प्राप्त करके पोस्ट को ऑब्जेक्ट में परिवर्तित करता है, आपके पास क्रमशः author और title को कॉल करके पोस्ट के लेखक और शीर्षक गुणों तक पहुंच है। आपके पास दूसरी पोस्ट आईडी से दूसरे prevChildKey तर्क तक भी पहुंच है।

बच्चा बदल गया

किसी भी समय बच्चे के नोड को संशोधित करने पर child_changed घटना शुरू हो जाती है। इसमें बच्चे के नोड के वंशजों में कोई संशोधन शामिल है। आमतौर पर इसका उपयोग child_added और child_removed के साथ संयोजन के रूप में किया जाता है ताकि वस्तुओं की सूची में परिवर्तन का जवाब दिया जा सके। ईवेंट कॉलबैक में दिए गए स्नैपशॉट में बच्चे के लिए अपडेट किया गया डेटा है।

संपादित किए जाने पर आप ब्लॉग पोस्ट पर अपडेट किए गए डेटा को पढ़ने के लिए child_changed का उपयोग कर सकते हैं:

जावा
ref.addChildEventListener(new ChildEventListener() {
  @Override
  public void onChildAdded(DataSnapshot dataSnapshot, String prevChildKey) {}

  @Override
  public void onChildChanged(DataSnapshot dataSnapshot, String prevChildKey) {
    Post changedPost = dataSnapshot.getValue(Post.class);
    System.out.println("The updated post title is: " + changedPost.title);
  }

  @Override
  public void onChildRemoved(DataSnapshot dataSnapshot) {}

  @Override
  public void onChildMoved(DataSnapshot dataSnapshot, String prevChildKey) {}

  @Override
  public void onCancelled(DatabaseError databaseError) {}
});
Node.js
// Get the data on a post that has changed
ref.on("child_changed", function(snapshot) {
  var changedPost = snapshot.val();
  console.log("The updated post title is " + changedPost.title);
});

बच्चा निकाला गया

जब तत्काल बच्चा निकाल दिया जाता है, तो child_removed घटना शुरू हो जाती है। यह आमतौर पर child_added और child_changed के साथ संयोजन में उपयोग किया जाता है। ईवेंट कॉलबैक में दिए गए स्नैपशॉट में हटाए गए बच्चे के लिए डेटा होता है।

ब्लॉग उदाहरण में, आप कंसोल में हटाए गए पोस्ट के बारे में एक अधिसूचना लॉग करने के लिए child_removed का उपयोग कर सकते हैं:

जावा
ref.addChildEventListener(new ChildEventListener() {
  @Override
  public void onChildAdded(DataSnapshot dataSnapshot, String prevChildKey) {}

  @Override
  public void onChildChanged(DataSnapshot dataSnapshot, String prevChildKey) {}

  @Override
  public void onChildRemoved(DataSnapshot dataSnapshot) {
    Post removedPost = dataSnapshot.getValue(Post.class);
    System.out.println("The blog post titled " + removedPost.title + " has been deleted");
  }

  @Override
  public void onChildMoved(DataSnapshot dataSnapshot, String prevChildKey) {}

  @Override
  public void onCancelled(DatabaseError databaseError) {}
});
Node.js
// Get a reference to our posts
var ref = db.ref("server/saving-data/fireblog/posts");

// Get the data on a post that has been removed
ref.on("child_removed", function(snapshot) {
  var deletedPost = snapshot.val();
  console.log("The blog post titled '" + deletedPost.title + "' has been deleted");
});

बच्चा चला गया

ऑर्डर किए गए डेटा के साथ काम करते समय child_moved इवेंट का उपयोग किया जाता है, जो अगले भाग में कवर किया गया है।

घटना की गारंटी

Firebase डेटाबेस घटनाओं के बारे में कई महत्वपूर्ण गारंटी देता है:

डेटाबेस इवेंट गारंटी
स्थानीय स्थिति में परिवर्तन होने पर घटनाएँ हमेशा चालू रहेंगी।
इवेंट हमेशा डेटा की सही स्थिति को प्रतिबिंबित करेंगे, यहां तक ​​कि उन मामलों में भी जहां स्थानीय संचालन या समय के कारण अस्थायी अंतर होता है, जैसे कि नेटवर्क कनेक्शन के अस्थायी नुकसान में।
एक एकल क्लाइंट से राइट्स हमेशा सर्वर को लिखे जाएंगे और अन्य उपयोगकर्ताओं को इन-ऑर्डर के लिए प्रसारित किए जाएंगे।
मूल्य घटनाओं को हमेशा अंतिम ट्रिगर किया जाता है और स्नैपशॉट लेने से पहले हुई किसी भी अन्य घटनाओं से अपडेट रखने की गारंटी दी जाती है।

चूंकि मान ईवेंट हमेशा अंतिम ट्रिगर होते हैं, इसलिए निम्न उदाहरण हमेशा काम करेगा:

जावा
final AtomicInteger count = new AtomicInteger();

ref.addChildEventListener(new ChildEventListener() {
  @Override
  public void onChildAdded(DataSnapshot dataSnapshot, String prevChildKey) {
    // New child added, increment count
    int newCount = count.incrementAndGet();
    System.out.println("Added " + dataSnapshot.getKey() + ", count is " + newCount);
  }

  // ...
});

// The number of children will always be equal to 'count' since the value of
// the dataSnapshot here will include every child_added event triggered before this point.
ref.addListenerForSingleValueEvent(new ValueEventListener() {
  @Override
  public void onDataChange(DataSnapshot dataSnapshot) {
    long numChildren = dataSnapshot.getChildrenCount();
    System.out.println(count.get() + " == " + numChildren);
  }

  @Override
  public void onCancelled(DatabaseError databaseError) {}
});
Node.js
var count = 0;

ref.on("child_added", function(snap) {
  count++;
  console.log("added:", snap.key);
});

// length will always equal count, since snap.val() will include every child_added event
// triggered before this point
ref.once("value", function(snap) {
  console.log("initial data loaded!", snap.numChildren() === count);
});

कॉलबैक का पता लगाना

कॉलबैक ईवेंट प्रकार और कॉलबैक फ़ंक्शन को निर्दिष्ट करके हटा दिया जाता है, जैसे कि निम्नलिखित:

जावा
// Create and attach listener
ValueEventListener listener = new ValueEventListener() {
    // ...
};
ref.addValueEventListener(listener);

// Remove listener
ref.removeEventListener(listener);
Node.js
ref.off("value", originalCallback);

यदि आपने एक स्कोप रेफरेंस पास on() , तो कॉलबैक को अलग करते समय इसे पास करना होगा:

जावा
// Not applicable for Java
है
Node.js
ref.off("value", originalCallback, this);

यदि आप किसी स्थान पर सभी कॉलबैक निकालना चाहते हैं, तो आप निम्न कार्य कर सकते हैं:

जावा
// No Java equivalent, listeners must be removed individually.
Node.js
// Remove all value callbacks
ref.off("value");

// Remove all callbacks of any type
ref.off();

एक बार डेटा पढ़ना

कुछ मामलों में कॉलबैक के लिए एक बार कॉल किया जाना उपयोगी हो सकता है और फिर तुरंत हटा दिया जाएगा। हमने इसे आसान बनाने के लिए एक सहायक फ़ंक्शन बनाया है:

जावा
ref.addListenerForSingleValueEvent(new ValueEventListener() {
  @Override
  public void onDataChange(DataSnapshot dataSnapshot) {
    // ...
  }

  @Override
  public void onCancelled(DatabaseError databaseError) {
    // ...
  }
});
Node.js
ref.once("value", function(data) {
  // do some stuff once
});
अजगर
# Import database module.
from firebase_admin import db

# Get a database reference to our posts
ref = db.reference('server/saving-data/fireblog/posts')

# Read the data at the posts reference (this is a blocking operation)
print(ref.get())
जाओ
// Create a database client from App.
client, err := app.Database(ctx)
if err != nil {
	log.Fatalln("Error initializing database client:", err)
}

// Get a database reference to our posts
ref := client.NewRef("server/saving-data/fireblog/posts")

// Read the data at the posts reference (this is a blocking operation)
var post Post
if err := ref.Get(ctx, &post); err != nil {
	log.Fatalln("Error reading value:", err)
}

डेटा छोड़ना

फायरबेस डेटाबेस प्रश्नों के साथ, आप चुनिंदा रूप से विभिन्न कारकों के आधार पर डेटा प्राप्त कर सकते हैं। अपने डेटाबेस में एक क्वेरी का निर्माण करने के लिए, आप यह निर्दिष्ट करके शुरू करते हैं कि आप कैसे चाहते हैं कि आपका डेटा ऑर्डर करने वाले कार्यों में से एक का उपयोग करके ऑर्डर किया जाए: orderByChild() , orderByKey() , या orderByValue() । फिर आप जटिल प्रश्नों के संचालन के लिए इन्हें पाँच अन्य तरीकों से जोड़ सकते हैं: limitToFirst() , limitToLast() , startAt() , endAt() और equalTo()

चूंकि फायरबेस में हम सभी सोचते हैं कि डायनासोर बहुत अच्छे हैं, हम डायनासोर तथ्यों के एक नमूना डेटाबेस से एक स्निपेट का उपयोग करके यह प्रदर्शित करेंगे कि आप अपने फायरबेस डेटाबेस में डेटा को कैसे क्वेरी कर सकते हैं:

{
  "lambeosaurus": {
    "height" : 2.1,
    "length" : 12.5,
    "weight": 5000
  },
  "stegosaurus": {
    "height" : 4,
    "length" : 9,
    "weight" : 2500
  }
}

आप तीन तरीकों से डेटा आदेश कर सकते हैं: बच्चे कुंजी के द्वारा, कुंजी के द्वारा, या मान है। एक बुनियादी डेटाबेस क्वेरी इन आदेशों में से एक के साथ शुरू होती है, जिनमें से प्रत्येक को नीचे समझाया गया है।

एक निर्दिष्ट बाल कुंजी द्वारा आदेश देना

आप उस कुंजी को orderByChild() पास करके एक सामान्य बाल कुंजी द्वारा नोड्स का आदेश दे सकते हैं। उदाहरण के लिए, ऊंचाई द्वारा आदेशित सभी डायनासोर को पढ़ने के लिए, आप निम्न कार्य कर सकते हैं:

जावा
public static class Dinosaur {

  public int height;
  public int weight;

  public Dinosaur(int height, int weight) {
    // ...
  }

}

final DatabaseReference dinosaursRef = database.getReference("dinosaurs");
dinosaursRef.orderByChild("height").addChildEventListener(new ChildEventListener() {
  @Override
  public void onChildAdded(DataSnapshot dataSnapshot, String prevChildKey) {
    Dinosaur dinosaur = dataSnapshot.getValue(Dinosaur.class);
    System.out.println(dataSnapshot.getKey() + " was " + dinosaur.height + " meters tall.");
  }

  // ...
});
Node.js
var db = firebaseAdmin.database();
var ref = db.ref("dinosaurs");
ref.orderByChild("height").on("child_added", function(snapshot) {
  console.log(snapshot.key + " was " + snapshot.val().height + " meters tall");
});
अजगर
ref = db.reference('dinosaurs')
snapshot = ref.order_by_child('height').get()
for key, val in snapshot.items():
    print('{0} was {1} meters tall'.format(key, val))
जाओ

// Dinosaur is a json-serializable type.
type Dinosaur struct {
	Height int `json:"height"`
	Width  int `json:"width"`
}

ref := client.NewRef("dinosaurs")

results, err := ref.OrderByChild("height").GetOrdered(ctx)
if err != nil {
	log.Fatalln("Error querying database:", err)
}
for _, r := range results {
	var d Dinosaur
	if err := r.Unmarshal(&d); err != nil {
		log.Fatalln("Error unmarshaling result:", err)
	}
	fmt.Printf("%s was %d meteres tall", r.Key(), d.Height)
}

कोई भी नोड जिसमें बच्चे की कुंजी नहीं होती है जिस पर हम क्वेरी कर रहे हैं वह null मान के साथ सॉर्ट किया जाता है, जिसका अर्थ है कि यह क्रम में पहले आएगा। कैसे डेटा का आदेश दिया है पर जानकारी के लिए, कैसे डेटा अनुभाग आदेश दिया है

केवल एक स्तर से नीचे के बच्चों की बजाए गहरी नेस्टेड बच्चों द्वारा भी प्रश्नपत्र मंगवाए जा सकते हैं। यह उपयोगी है यदि आपके पास इस तरह से गहरा नेस्टेड डेटा है:

{
  "lambeosaurus": {
    "dimensions": {
      "height" : 2.1,
      "length" : 12.5,
      "weight": 5000
    }
  },
  "stegosaurus": {
    "dimensions": {
      "height" : 4,
      "length" : 9,
      "weight" : 2500
    }
  }
}

अब ऊंचाई को क्वेरी करने के लिए, आप एक ही कुंजी के बजाय ऑब्जेक्ट के लिए पूर्ण पथ का उपयोग कर सकते हैं:

जावा
dinosaursRef.orderByChild("dimensions/height").addChildEventListener(new ChildEventListener() {
  @Override
  public void onChildAdded(DataSnapshot dataSnapshot, String prevChildKey) {
    // ...
  }

  // ...
});
Node.js
var ref = db.ref("dinosaurs");
ref.orderByChild("dimensions/height").on("child_added", function(snapshot) {
  console.log(snapshot.key + " was " + snapshot.val().height + " meters tall");
});
अजगर
ref = db.reference('dinosaurs')
snapshot = ref.order_by_child('dimensions/height').get()
for key, val in snapshot.items():
    print('{0} was {1} meters tall'.format(key, val))
जाओ
ref := client.NewRef("dinosaurs")

results, err := ref.OrderByChild("dimensions/height").GetOrdered(ctx)
if err != nil {
	log.Fatalln("Error querying database:", err)
}
for _, r := range results {
	var d Dinosaur
	if err := r.Unmarshal(&d); err != nil {
		log.Fatalln("Error unmarshaling result:", err)
	}
	fmt.Printf("%s was %d meteres tall", r.Key(), d.Height)
}

क्वेरीज़ एक समय में केवल एक कुंजी द्वारा आदेश दे सकती हैं। एक ही क्वेरी पर कई बार orderByChild() कॉलिंग एक त्रुटि फेंकता है।

कुंजी द्वारा आदेश देना

आप भी आदेश कुंजी orderByKey() विधि का उपयोग करके उनकी कुंजी द्वारा नोड्स का आदेश दे सकते हैं। निम्न उदाहरण सभी डायनासोर को वर्णमाला क्रम में पढ़ता है:

जावा
dinosaursRef.orderByKey().addChildEventListener(new ChildEventListener() {
  @Override
  public void onChildAdded(DataSnapshot dataSnapshot, String prevChildKey) {
    System.out.println(dataSnapshot.getKey());
  }

  // ...
});
Node.js
var ref = db.ref("dinosaurs");
ref.orderByKey().on("child_added", function(snapshot) {
  console.log(snapshot.key);
});
अजगर
ref = db.reference('dinosaurs')
snapshot = ref.order_by_key().get()
print(snapshot)
जाओ
ref := client.NewRef("dinosaurs")

results, err := ref.OrderByKey().GetOrdered(ctx)
if err != nil {
	log.Fatalln("Error querying database:", err)
}
snapshot := make([]Dinosaur, len(results))
for i, r := range results {
	var d Dinosaur
	if err := r.Unmarshal(&d); err != nil {
		log.Fatalln("Error unmarshaling result:", err)
	}
	snapshot[i] = d
}
fmt.Println(snapshot)

मूल्य द्वारा आदेश देना

आप orderByValue() पद्धति का उपयोग करके उनके बच्चे की कुंजियों के मूल्य से नोड्स का आदेश दे सकते हैं। मान लीजिए कि डायनासोर एक डिनो खेल प्रतियोगिता कर रहे हैं और आप निम्नलिखित प्रारूप में उनके स्कोर पर नज़र रख रहे हैं:

{
  "scores": {
    "bruhathkayosaurus" : 55,
    "lambeosaurus" : 21,
    "linhenykus" : 80,
    "pterodactyl" : 93,
    "stegosaurus" : 5,
    "triceratops" : 22
  }
}

डायनासोर को उनके स्कोर के अनुसार क्रमबद्ध करने के लिए, आप निम्नलिखित प्रश्न का निर्माण कर सकते हैं:

जावा
DatabaseReference scoresRef = database.getReference("scores");
scoresRef.orderByValue().addChildEventListener(new ChildEventListener() {
  @Override
  public void onChildAdded(DataSnapshot dataSnapshot, String prevChildKey) {
    System.out.println("The " + dataSnapshot.getKey() + " score is " + dataSnapshot.getValue());
  }

  // ...
});
Node.js
var scoresRef = db.ref("scores");
scoresRef.orderByValue().on("value", function(snapshot) {
  snapshot.forEach(function(data) {
    console.log("The " + data.key + " dinosaur's score is " + data.val());
  });
});
अजगर
ref = db.reference('scores')
snapshot = ref.order_by_value().get()
for key, val in snapshot.items():
    print('The {0} dinosaur\'s score is {1}'.format(key, val))
जाओ
० अदबदबक ०bad०

देखें कि डेटा कैसे orderByValue() लिए कि null , बूलियन, स्ट्रिंग, और ऑब्जेक्ट मान orderByValue() का उपयोग orderByValue() करते हैं।

जटिल प्रश्न

अब यह स्पष्ट है कि आपका डेटा कैसे ऑर्डर किया जाता है, आप अधिक जटिल प्रश्नों के निर्माण के लिए नीचे बताई गई सीमा या सीमा विधियों का उपयोग कर सकते हैं।

सीमाएँ

limitToFirst() और limitToLast() प्रश्नों का उपयोग किसी दिए गए कॉलबैक के लिए अधिकतम संख्या में बच्चों को सिंक करने के लिए किया जाता है। यदि आप 100 की सीमा निर्धारित करते हैं, तो आप शुरू में केवल 100 तक child_added घटनाओं को प्राप्त करेंगे। यदि आपके डेटाबेस में 100 से कम संदेश संग्रहीत हैं, तो प्रत्येक संदेश के लिए एक child_added घटना आग जाएगी। हालाँकि, यदि आपके पास 100 से अधिक संदेश हैं, तो आपको केवल उन संदेशों में से 100 के लिए एक child_added घटना प्राप्त होगी। ये पहले 100 का आदेश दिया संदेश आप उपयोग कर रहे हैं कर रहे हैं limitToFirst() या पिछले 100 आदेश दिया संदेशों यदि आप उपयोग कर रहे हैं limitToLast() । जैसे-जैसे आइटम बदलते हैं, आपको उन आइटमों के लिए child_added इवेंट प्राप्त होंगे, जो इसे छोड़ने वाले आइटम्स के लिए क्वेरी और child_removed इवेंट्स दर्ज करते हैं, ताकि कुल संख्या 100 रह जाए।

डायनासोर तथ्य डेटाबेस और orderByChild() का उपयोग करके, आप दो सबसे भारी डायनासोर पा सकते हैं:

जावा
dinosaursRef.orderByChild("weight").limitToLast(2).addChildEventListener(new ChildEventListener() {
  @Override
  public void onChildAdded(DataSnapshot dataSnapshot, String prevChildKey) {
    System.out.println(dataSnapshot.getKey());
  }

  // ...
});
Node.js
var ref = db.ref("dinosaurs");
ref.orderByChild("weight").limitToLast(2).on("child_added", function(snapshot) {
  console.log(snapshot.key);
});
अजगर
ref = db.reference('dinosaurs')
snapshot = ref.order_by_child('weight').limit_to_last(2).get()
for key in snapshot:
    print(key)
जाओ
02 बी 4871 ए 90

जब तक डेटाबेस में दो डायनासोर कम न हों, child_added कॉलबैक को दो बार ट्रिगर किया जाता है। यह डेटाबेस में जुड़ने वाले हर नए, भारी डायनासोर के लिए भी निकाल दिया जाएगा। पाइथन में, क्वेरी सीधे एक OrderedDict को OrderedDict जिसमें दो सबसे भारी डायनासोर होते हैं।

इसी तरह, आप दो सबसे कम डायनासोर का उपयोग कर सकते हैं limitToFirst() का उपयोग करके:

जावा
dinosaursRef.orderByChild("weight").limitToFirst(2).addChildEventListener(new ChildEventListener() {
  @Override
  public void onChildAdded(DataSnapshot dataSnapshot, String prevChildKey) {
    System.out.println(dataSnapshot.getKey());
  }

  // ...
});
Node.js
var ref = db.ref("dinosaurs");
ref.orderByChild("height").limitToFirst(2).on("child_added", function(snapshot) {
  console.log(snapshot.key);
});
अजगर
ref = db.reference('dinosaurs')
snapshot = ref.order_by_child('height').limit_to_first(2).get()
for key in snapshot:
    print(key)
जाओ
ref := client.NewRef("dinosaurs")

results, err := ref.OrderByChild("height").LimitToFirst(2).GetOrdered(ctx)
if err != nil {
	log.Fatalln("Error querying database:", err)
}
for _, r := range results {
	fmt.Println(r.Key())
}

जब तक डेटाबेस में दो डायनासोर कम न हों, child_added कॉलबैक को दो बार ट्रिगर किया जाता है। यह भी फिर से निकाल दिया जाएगा अगर पहले दो डायनासोरों में से एक को डेटाबेस से हटा दिया जाता है, क्योंकि एक नया डायनासोर अब दूसरा सबसे छोटा होगा। पाइथन में, क्वेरी सीधे एक OrderedDict देता है जिसमें सबसे छोटा डायनासोर होता है।

आप orderByValue() साथ सीमा प्रश्न भी कर सकते हैं। यदि आप शीर्ष 3 उच्चतम स्कोरिंग डिनो स्पोर्ट्स डायनासोर के साथ लीडरबोर्ड बनाना चाहते हैं, तो आप निम्न कार्य कर सकते हैं:

जावा
scoresRef.orderByValue().limitToFirst(3).addChildEventListener(new ChildEventListener() {
  @Override
  public void onChildAdded(DataSnapshot dataSnapshot, String prevChildKey) {
    System.out.println("The " + dataSnapshot.getKey() + " score is " + dataSnapshot.getValue());
  }

  // ...
});
Node.js
var scoresRef = db.ref("scores");
scoresRef.orderByValue().limitToLast(3).on("value", function(snapshot) {
  snapshot.forEach(function(data) {
    console.log("The " + data.key + " dinosaur's score is " + data.val());
  });
});
अजगर
scores_ref = db.reference('scores')
snapshot = scores_ref.order_by_value().limit_to_last(3).get()
for key, val in snapshot.items():
    print('The {0} dinosaur\'s score is {1}'.format(key, val))
जाओ
ref := client.NewRef("scores")

results, err := ref.OrderByValue().LimitToLast(3).GetOrdered(ctx)
if err != nil {
	log.Fatalln("Error querying database:", err)
}
for _, r := range results {
	var score int
	if err := r.Unmarshal(&score); err != nil {
		log.Fatalln("Error unmarshaling result:", err)
	}
	fmt.Printf("The %s dinosaur's score is %d\n", r.Key(), score)
}

रेंज क्वेरी

startAt() , endAt() , और equalTo() का उपयोग करके आप अपने प्रश्नों के लिए मनमाने ढंग से आरंभ और समाप्ति बिंदु चुन सकते हैं। उदाहरण के लिए, यदि आप सभी डायनासोरों को ढूंढना चाहते हैं जो कम से कम तीन मीटर लंबे हैं, तो आप orderByChild() और startAt() जोड़ सकते हैं:

जावा
dinosaursRef.orderByChild("height").startAt(3).addChildEventListener(new ChildEventListener() {
  @Override
  public void onChildAdded(DataSnapshot dataSnapshot, String prevChildKey) {
    System.out.println(dataSnapshot.getKey());
  }

  // ...
});
Node.js
  var ref = db.ref("dinosaurs");
  ref.orderByChild("height").startAt(3).on("child_added", function(snapshot) {
    console.log(snapshot.key);
  });
अजगर
ref = db.reference('dinosaurs')
snapshot = ref.order_by_child('height').start_at(3).get()
for key in snapshot:
    print(key)
है
जाओ
ref := client.NewRef("dinosaurs")

results, err := ref.OrderByChild("height").StartAt(3).GetOrdered(ctx)
if err != nil {
	log.Fatalln("Error querying database:", err)
}
for _, r := range results {
	fmt.Println(r.Key())
}

आप सभी डायनासोरों के नाम खोजने के लिए endAt() का उपयोग कर सकते हैं जिनका नाम Pterodactyl lexicographically से पहले आता है:

जावा
dinosaursRef.orderByKey().endAt("pterodactyl").addChildEventListener(new ChildEventListener() {
  @Override
  public void onChildAdded(DataSnapshot dataSnapshot, String prevChildKey) {
    System.out.println(dataSnapshot.getKey());
  }

  // ...
});
Node.js
var ref = db.ref("dinosaurs");
ref.orderByKey().endAt("pterodactyl").on("child_added", function(snapshot) {
  console.log(snapshot.key);
});
अजगर
ref = db.reference('dinosaurs')
snapshot = ref.order_by_key().end_at('pterodactyl').get()
for key in snapshot:
    print(key)
जाओ
ref := client.NewRef("dinosaurs")

results, err := ref.OrderByKey().EndAt("pterodactyl").GetOrdered(ctx)
if err != nil {
	log.Fatalln("Error querying database:", err)
}
for _, r := range results {
	fmt.Println(r.Key())
}

आप अपनी क्वेरी के दोनों सिरों को सीमित करने के लिए startAt() और endAt() को जोड़ सकते हैं। निम्नलिखित उदाहरण उन सभी डायनासोरों को मिला है जिनका नाम "बी" अक्षर से शुरू होता है:

जावा
dinosaursRef.orderByKey().startAt("b").endAt("b\uf8ff").addChildEventListener(new ChildEventListener() {
  @Override
  public void onChildAdded(DataSnapshot dataSnapshot, String prevChildKey) {
    System.out.println(dataSnapshot.getKey());
  }

  // ...
});
Node.js
01 बी 8 ए 49 ए 10
अजगर
ref = db.reference('dinosaurs')
snapshot = ref.order_by_key().start_at('b').end_at(u'b\uf8ff').get()
for key in snapshot:
    print(key)
जाओ
04 बी 3 बी 1 ए 080

equalTo() विधि आपको सटीक मिलान के आधार पर फ़िल्टर करने की अनुमति देती है। जैसा कि अन्य श्रेणी के प्रश्नों के साथ होता है, यह प्रत्येक मिलान वाले बच्चे के नोड के लिए फायर करेगा। उदाहरण के लिए, आप सभी डायनासोर को खोजने के लिए निम्नलिखित क्वेरी का उपयोग कर सकते हैं जो 25 मीटर लंबा है:

जावा
dinosaursRef.orderByChild("height").equalTo(25).addChildEventListener(new ChildEventListener() {
  @Override
  public void onChildAdded(DataSnapshot dataSnapshot, String prevChildKey) {
    System.out.println(dataSnapshot.getKey());
  }

  // ...
});
Node.js
0 बी 4 एफ 7 ए 6370
अजगर
ref = db.reference('dinosaurs')
snapshot = ref.order_by_child('height').equal_to(25).get()
for key in snapshot:
    print(key)
जाओ
ref := client.NewRef("dinosaurs")

results, err := ref.OrderByChild("height").EqualTo(25).GetOrdered(ctx)
if err != nil {
	log.Fatalln("Error querying database:", err)
}
for _, r := range results {
	fmt.Println(r.Key())
}

जब आपको अपने डेटा को पग करने की आवश्यकता होती है, तो रेंज क्वेरीज़ भी उपयोगी होती हैं।

यह सब एक साथ डालें

जटिल प्रश्न बनाने के लिए आप इन सभी तकनीकों को जोड़ सकते हैं। उदाहरण के लिए, आप डायनासोर का नाम पा सकते हैं, जो स्टैगोसॉरस से छोटा है:

जावा
dinosaursRef.child("stegosaurus").child("height").addValueEventListener(new ValueEventListener() {
  @Override
  public void onDataChange(DataSnapshot stegoHeightSnapshot) {
    Integer favoriteDinoHeight = stegoHeightSnapshot.getValue(Integer.class);
    Query query = dinosaursRef.orderByChild("height").endAt(favoriteDinoHeight).limitToLast(2);
    query.addValueEventListener(new ValueEventListener() {
      @Override
      public void onDataChange(DataSnapshot dataSnapshot) {
        // Data is ordered by increasing height, so we want the first entry
        DataSnapshot firstChild = dataSnapshot.getChildren().iterator().next();
        System.out.println("The dinosaur just shorter than the stegosaurus is: " + firstChild.getKey());
      }

      @Override
      public void onCancelled(DatabaseError databaseError) {
        // ...
      }
    });
  }

  @Override
  public void onCancelled(DatabaseError databaseError) {
    // ...
  }
});
Node.js
var ref = db.ref("dinosaurs");
ref.child("stegosaurus").child("height").on("value", function(stegosaurusHeightSnapshot) {
  var favoriteDinoHeight = stegosaurusHeightSnapshot.val();

  var queryRef = ref.orderByChild("height").endAt(favoriteDinoHeight).limitToLast(2)
  queryRef.on("value", function(querySnapshot) {
    if (querySnapshot.numChildren() === 2) {
      // Data is ordered by increasing height, so we want the first entry
      querySnapshot.forEach(function(dinoSnapshot) {
        console.log("The dinosaur just shorter than the stegasaurus is " + dinoSnapshot.key);

        // Returning true means that we will only loop through the forEach() one time
        return true;
      });
    } else {
      console.log("The stegosaurus is the shortest dino");
    }
  });
});
अजगर
ref = db.reference('dinosaurs')
favotire_dino_height = ref.child('stegosaurus').child('height').get()
query = ref.order_by_child('height').end_at(favotire_dino_height).limit_to_last(2)
snapshot = query.get()
if len(snapshot) == 2:
    # Data is ordered by increasing height, so we want the first entry.
    # Second entry is stegosarus.
    for key in snapshot:
        print('The dinosaur just shorter than the stegosaurus is {0}'.format(key))
        return
else:
    print('The stegosaurus is the shortest dino')
जाओ
ref := client.NewRef("dinosaurs")

var favDinoHeight int
if err := ref.Child("stegosaurus").Child("height").Get(ctx, &favDinoHeight); err != nil {
	log.Fatalln("Error querying database:", err)
}

query := ref.OrderByChild("height").EndAt(favDinoHeight).LimitToLast(2)
results, err := query.GetOrdered(ctx)
if err != nil {
	log.Fatalln("Error querying database:", err)
}
if len(results) == 2 {
	// Data is ordered by increasing height, so we want the first entry.
	// Second entry is stegosarus.
	fmt.Printf("The dinosaur just shorter than the stegosaurus is %s\n", results[0].Key())
} else {
	fmt.Println("The stegosaurus is the shortest dino")
}

डेटा कैसे ऑर्डर किया जाता है

यह अनुभाग बताता है कि चार ऑर्डर कार्यों में से प्रत्येक का उपयोग करते समय आपका डेटा कैसे ऑर्डर किया जाता है।

आदेश

orderByChild() का उपयोग करते orderByChild() , निर्दिष्ट चाइल्ड कुंजी वाले डेटा को निम्नानुसार ऑर्डर किया जाता है:

  1. निर्दिष्ट चाइल्ड कुंजी के लिए null मान वाले बच्चे पहले आते हैं।
  2. निर्दिष्ट चाइल्ड कुंजी के लिए false मान वाले बच्चे अगले आते हैं। कई बच्चों के एक मूल्य है, तो false है, वे हल कर रहे हैं कोषगत कुंजी के द्वारा।
  3. निर्दिष्ट चाइल्ड कुंजी के लिए true मूल्य वाले बच्चे अगले आते हैं। यदि कई बच्चों के पास true मूल्य true , तो उन्हें कुंजी द्वारा क्रमबद्ध रूप से क्रमबद्ध किया जाता है।
  4. संख्यात्मक मान वाले बच्चे अगले क्रम में आते हैं, आरोही क्रम में क्रमबद्ध। यदि निर्दिष्ट चाइल्ड नोड के लिए कई बच्चों के समान संख्यात्मक मूल्य हैं, तो वे कुंजी द्वारा क्रमबद्ध किए जाते हैं।
  5. संख्याओं के बाद स्ट्रिंग्स आते हैं, और बढ़ते क्रम में लेक्सोग्राफिक रूप से क्रमबद्ध होते हैं। यदि कई बच्चों के निर्दिष्ट बाल नोड के लिए समान मूल्य है, तो उन्हें कुंजी द्वारा शाब्दिक रूप से आदेश दिया जाता है।
  6. ऑब्जेक्ट अंतिम आते हैं, और आरोही क्रम में कुंजी द्वारा क्रमबद्ध रूप से छांटे जाते हैं।

orderByKey

अपने डेटा को सॉर्ट करने के लिए orderByKey() का उपयोग करते orderByKey() , डेटा को निम्नानुसार आरोही क्रम में लौटाया जाता है। ध्यान रखें कि चाबियाँ केवल तार हो सकती हैं।

  1. 32-बिट पूर्णांक के रूप में पार्स की जा सकने वाली कुंजी वाले बच्चों को आरोही क्रम में क्रमबद्ध किया जाता है।
  2. उनकी कुंजी के रूप में एक स्ट्रिंग मान वाले बच्चे अगले आते हैं, आरोही क्रम में शाब्दिक रूप से क्रमबद्ध।

orderByValue

orderByValue() का उपयोग करते orderByValue() , बच्चों को उनके मूल्य का आदेश दिया जाता है। आदेश मानदंड उसी प्रकार है जैसे orderByChild() , एक निर्दिष्ट चाइल्ड कुंजी के मूल्य के बजाय नोड के मूल्य का उपयोग किया जाता है।