Firebase实时数据库：仅获取指定子节点而非全部子节点

Hey there! I totally get your frustration with unnecessary data usage driving up your Firebase bills. Let's fix that by modifying how you fetch data so you only pull the token fields you need, not the entire device objects.

The Problem with Your Current Approach #

Right now, you're fetching the full phone node (including battery stats, device details, download records, etc.) and then extracting tokens locally. This wastes bandwidth and increases costs because you're downloading way more data than you actually need—those unused sibling nodes add up to that XXX MB of unnecessary transfer.

Solution: Fetch Only Token Fields Directly #

Firebase Realtime Database lets you request specific child fields when fetching data, which cuts down on redundant data transfer. Here are two efficient ways to do it with the Node.js Admin SDK:

Method 1: Use Field Projection (Recommended)

When calling once('value'), you can specify the fields option to only retrieve the token field for each device. This tells Firebase to send back only that data, not the entire device object.

const admin = require('firebase-admin');
admin.initializeApp(); // Ensure your app is initialized with proper credentials

const db = admin.database();
const phoneRef = db.ref('phone');

// Fetch only the 'token' field for all devices
phoneRef.once('value', { fields: ['token'] })
  .then(snapshot => {
    const tokens = [];
    // Iterate through each device entry
    snapshot.forEach(deviceSnapshot => {
      const token = deviceSnapshot.val().token;
      if (token) { // Optional: Skip entries without a valid token
        tokens.push(token);
      }
    });
    console.log('All retrieved tokens:', tokens);
    // Use your tokens here (e.g., send push notifications)
  })
  .catch(error => {
    console.error('Error retrieving tokens:', error);
  });

Method 2: Shallow Query + Individual Token Fetch

If you prefer a more granular approach, you can first get all device IDs using a shallow query, then fetch each token individually. This minimizes initial data transfer (only device IDs) and then pulls only the necessary token data for each device.

// First get all device IDs (shallow query returns only keys, no child data)
phoneRef.once('value', { shallow: true })
  .then(snapshot => {
    const deviceIds = Object.keys(snapshot.val());
    // Map device IDs to promises that fetch each token
    const tokenPromises = deviceIds.map(id => 
      db.ref(`phone/${id}/token`).once('value').then(snap => snap.val())
    );
    // Wait for all token fetches to complete
    return Promise.all(tokenPromises);
  })
  .then(tokens => {
    // Filter out any null/undefined tokens
    const validTokens = tokens.filter(token => token);
    console.log('Valid tokens:', validTokens);
  })
  .catch(error => {
    console.error('Error fetching tokens:', error);
  });

Why These Work #

• The first method uses Firebase's built-in field projection to limit the response to only token fields, directly eliminating that XXX MB of redundant data transfer.
• The shallow query approach keeps initial data transfer minimal (just device IDs) and then fetches only the exact data you need for each device.

Quick Notes #

• Since you're using the Admin SDK, you don't need to worry about security rules restricting access to the token fields—Admin SDK bypasses these rules by default.
• Both methods will reduce your Firebase bandwidth costs and speed up your queries, since less data is being transferred and processed.

内容的提问来源于stack exchange，提问作者Abhishek Batra