फ़िल्टर की मदद से, डेटा दिखने की सुविधा मैनेज करना

इस दस्तावेज़ में, स्प्रेडशीट में दिखाए गए डेटा को क्रम से लगाने और फ़िल्टर करने के लिए, फ़िल्टर इस्तेमाल करने के बारे में बताया गया है.

फ़िल्टर की मदद से, स्प्रेडशीट देखते समय दिखने वाले डेटा को क्रम से लगाया जा सकता है और उसे फ़िल्टर किया जा सकता है. फ़िल्टर, आपकी स्प्रेडशीट में मौजूद डेटा वैल्यू में बदलाव नहीं करते. फ़िल्टर का इस्तेमाल करके, जानकारी को कुछ समय के लिए छिपाया या क्रम से लगाया जा सकता है. फ़िल्टर चालू होने पर, फ़िल्टर के लिए तय की गई शर्तों से मेल खाने वाला डेटा नहीं दिखता. फ़िल्टर व्यू की मदद से, अलग-अलग नाम वाले फ़िल्टर सेव किए जा सकते हैं. साथ ही, अपनी ज़रूरत के हिसाब से एक से दूसरे फ़िल्टर पर स्विच किया जा सकता है.

Google Sheets API के अनुरोध में दिखाए गए डेटा को फ़िल्टर करने के लिए, DataFilter ऑब्जेक्ट का इस्तेमाल करें. ज़्यादा जानकारी के लिए, मेटाडेटा को पढ़ना, लिखना, और खोजना लेख पढ़ें.

इस्तेमाल के उदाहरणों को फ़िल्टर करना

यहां फ़िल्टर इस्तेमाल करने के कुछ उदाहरण दिए गए हैं:

• किसी कॉलम के हिसाब से डेटा को क्रम से लगाएं. उदाहरण के लिए, उपयोगकर्ता के रिकॉर्ड को नाम के हिसाब से क्रम से लगाएं.
• किसी खास शर्त को पूरा करने वाले डेटा को छिपाना. उदाहरण के लिए, दो साल से ज़्यादा पुराने सभी रिकॉर्ड छिपाएं.
• किसी वैल्यू से मेल खाने वाले डेटा को छिपाना. उदाहरण के लिए, "बंद की गई" स्थिति वाली सभी समस्याएं छिपाएं.

बुनियादी फ़िल्टर

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

बुनियादी फ़िल्टर मैनेज करना

बेसिक फ़िल्टर सेट करने या हटाने के लिए, अनुरोध के सही टाइप के साथ spreadsheets.batchUpdate तरीके का इस्तेमाल करें:

• बेसिक फ़िल्टर सेट करने के लिए, SetBasicFilterRequest तरीके का इस्तेमाल करें.
• बेसिक फ़िल्टर हटाने के लिए, ClearBasicFilterRequest तरीके का इस्तेमाल करें.

बेसिक फ़िल्टर की सूची बनाने के लिए, spreadsheets.get तरीके का इस्तेमाल करें और fields यूआरएल पैरामीटर को sheets/basicFilter पर सेट करें. नीचे दिए गए spreadsheets.get कोड के सैंपल में, फ़ील्ड मास्क के साथ Google Sheets का यूआरएल दिखाया गया है:

GET https://sheets.googleapis.com/v4/spreadsheets/SPREADSHEET_ID?fields=sheets/basicFilter

फ़िल्टर व्यू

FilterView एक ऐसा फ़िल्टर है जिसे नाम दिया गया है. इसे अपनी ज़रूरत के हिसाब से चालू और बंद किया जा सकता है. किसी शीट में, सेव किए गए कई फ़िल्टर व्यू हो सकते हैं. हालांकि, एक बार में सिर्फ़ एक फ़िल्टर व्यू लागू किया जा सकता है. किसी शीट में, बुनियादी फ़िल्टर और एक से ज़्यादा फ़िल्टर व्यू, दोनों शामिल हो सकते हैं. हालांकि, एक ही डेटा रेंज पर दोनों को एक साथ लागू नहीं किया जा सकता.

फ़िल्टर व्यू के इस्तेमाल के उदाहरण

यहां फ़िल्टर व्यू के इस्तेमाल के कुछ उदाहरण दिए गए हैं:

• आपके पास कई अलग-अलग फ़िल्टर हैं, जिनके बीच आपको डेटा देखते समय स्विच करना है.
• आपके पास स्प्रेडशीट में बदलाव करने का ऐक्सेस नहीं है, लेकिन आपको फ़िल्टर लागू करना है. ऐसे में, कुछ समय के लिए इस्तेमाल किया जा सकने वाला एक फ़िल्टर व्यू बनाया जा सकता है. यह सिर्फ़ आपको दिखेगा.

• आपको अपनी स्प्रेडशीट को शेयर करने वाले हर व्यक्ति को डेटा अलग-अलग तरीके से दिखाना है. स्प्रेडशीट के यूआरएल में spreadsheetId और filterViewId जोड़कर, यह तय किया जा सकता है कि कौनसे फ़िल्टर व्यू लागू करने हैं. इसके लिए, फ़िल्टर व्यू बनाते समय जवाब में मिले filterViewId का इस्तेमाल करें.

  यहां दिए गए कोड सैंपल में, फ़िल्टर किए गए व्यू के साथ Sheets का यूआरएल दिखाया गया है:

  https://docs.google.com/spreadsheets/d/SPREADSHEET_ID/edit#gid=0&fvid=FILTER_VIEW_ID

फ़िल्टर व्यू मैनेज करना

फ़िल्टर व्यू बनाने, डुप्लीकेट करने, उनमें बदलाव करने या उन्हें मिटाने के लिए, अनुरोध के सही टाइप के साथ spreadsheets.batchUpdate तरीका इस्तेमाल करें:

• फ़िल्टर व्यू बनाने के लिए, AddFilterViewRequest तरीके का इस्तेमाल करें.
• किसी फ़िल्टर व्यू की कॉपी बनाने के लिए, DuplicateFilterViewRequest तरीके का इस्तेमाल करें.
• फ़िल्टर किए गए व्यू की प्रॉपर्टी में बदलाव करने के लिए, UpdateFilterViewRequest तरीके का इस्तेमाल करें.
• किसी फ़िल्टर व्यू को मिटाने के लिए, DeleteFilterViewRequest तरीके का इस्तेमाल करें.

अपने सभी फ़िल्टर किए गए व्यू की सूची बनाने के लिए, spreadsheets.get तरीके का इस्तेमाल करें और fields यूआरएल पैरामीटर को sheets/filterViews पर सेट करें. यहां दिए गए spreadsheets.get कोड के सैंपल में, फ़ील्ड मास्क के साथ Sheets का यूआरएल दिखाया गया है:

GET https://sheets.googleapis.com/v4/spreadsheets/SPREADSHEET_ID?fields=sheets/filterViews

फ़िल्टर का JSON फ़ॉर्मैट

यहां दिए गए कोड के सैंपल में, FilterView ऑब्जेक्ट के लिए JSON फ़ॉर्मैट दिखाया गया है. BasicFilter ऑब्जेक्ट, पहले वाले ऑब्जेक्ट जैसा ही है. हालांकि, इसमें filterViewId और title फ़ील्ड नहीं हैं. साथ ही, इसमें नाम वाली रेंज का इस्तेमाल नहीं किया जा सकता.

{
  "filterViewId": number,
  "title": string,
  "range": {
    object(GridRange)
  },
  "namedRangeId": string,
  "sortSpecs": [
    {
      object(SortSpec)
    }
  ],
  "criteria": {
    string: {
      object(FilterCriteria)
    },
    ...
  }
}

बिक्री के डेटा का सैंपल

इस दस्तावेज़ के बाकी हिस्से में, बिक्री के डेटा की इस सैंपल टेबल का रेफ़रंस दिया गया है:

पहली टेबल. बिक्री के डेटा का सैंपल

	A	B	C	D	E	F	G
1	आइटम की कैटगरी	मॉडल नंबर	लागत	मात्रा	क्षेत्र	सेल्सपर्सन	भेजने की तारीख
2	पहिया	W-24	20.50 डॉलर	4	पश्चिम	बेथ	1/3/2016
3	दरवाज़ा	D-01X	15.00 डॉलर	2	दक्षिण	अमीर	15/3/2016
4	फ़्रेम	FR-0B1	34.00 डॉलर	8	पूर्व	हन्ना	3/12/2016
5	पैनल	P-034	INR270	4	उत्तरी	डैविन	15/3/2016
6	पैनल	P-052	1,150 रुपये	7	पूर्व	एरिक	5/16/2016
7	पहिया	W-24	20.50 डॉलर	11	दक्षिण	Sheldon	4/30/2016
8	इंजन	ENG-0161	$330.00	2	उत्तरी	Jessie	7/2/2016

क्रम से लगाने की सेटिंग

किसी फ़िल्टर में, क्रम से लगाने की कई खास बातें हो सकती हैं. इन स्पेसिफ़िकेशन से यह तय होता है कि डेटा को कैसे क्रम से लगाया जाए. इन्हें बताए गए क्रम में लागू किया जाता है. SortSpec.dimensionIndex एट्रिब्यूट, कॉलम इंडेक्स के बारे में बताता है. इस इंडेक्स के हिसाब से ही डेटा को क्रम से लगाया जाता है.

यहां दिए गए कोड सैंपल में, क्रम से लगाने की जानकारी दी गई है:

[
  {
    "dimensionIndex": 3,
    "sortOrder": "ASCENDING"
  },
  {
    "dimensionIndex": 6,
    "sortOrder": "ASCENDING"
  }
]

बिक्री के सैंपल डेटा पर लागू होने पर, इस स्पेसिफ़िकेशन के हिसाब से डेटा को "मात्रा" कॉलम के हिसाब से क्रम में लगाया जाता है. इसके बाद, अगर दो लाइनों में मात्रा एक जैसी होती है, तो "शिपिंग की तारीख" के हिसाब से क्रम में लगाया जाता है.

टेबल 2. दो कॉलम के हिसाब से क्रम में लगाया गया बिक्री का डेटा

	A	B	C	D	E	F	G
1	आइटम की कैटगरी	मॉडल नंबर	लागत	मात्रा	क्षेत्र	सेल्सपर्सन	भेजने की तारीख
2	दरवाज़ा	D-01X	15.00 डॉलर	2	दक्षिण	अमीर	15/3/2016
3	इंजन	ENG-0161	$330.00	2	उत्तरी	Jessie	7/2/2016
4	पहिया	W-24	20.50 डॉलर	4	पश्चिम	बेथ	1/3/2016
5	पैनल	P-034	INR270	4	उत्तरी	डैविन	15/3/2016
6	पैनल	P-052	1,150 रुपये	7	पूर्व	एरिक	5/16/2016
7	फ़्रेम	FR-0B1	34.00 डॉलर	8	पूर्व	हन्ना	3/12/2016
8	पहिया	W-24	20.50 डॉलर	11	दक्षिण	Sheldon	4/30/2016

फ़िल्टर करने की शर्तें

FilterCriteria ऑब्जेक्ट से यह तय होता है कि बुनियादी फ़िल्टर या फ़िल्टर व्यू में कौनसा स्प्रेडशीट डेटा दिखाया या छिपाया जाएगा. हर शर्त, किसी कॉलम में मौजूद वैल्यू पर निर्भर करती है. फ़िल्टर करने की शर्तों को मैप के तौर पर दिया जाता है. इसमें कुंजियां, कॉलम इंडेक्स होती हैं और वैल्यू, शर्तें होती हैं.

बूलियन condition का इस्तेमाल करके तय की गई शर्तों के लिए, वैल्यू दिखाने के लिए शर्त true होनी चाहिए. शर्त, hiddenValues को बदले नहीं. अगर कोई वैल्यू hiddenValues में शामिल है, तो वैल्यू से मेल खाने वाले सभी नतीजे अब भी छिपे रहेंगे.

यहां फ़िल्टर के मानदंड का मैप दिखाने वाला कोड सैंपल दिया गया है:

{
  0: {
    'hiddenValues': ['Panel']
  },
  6: {
    'condition': {
      'type': 'DATE_BEFORE',
      'values': {
        'userEnteredValue': '4/30/2016'
      }
    }
  }
}

बिक्री के सैंपल डेटा पर लागू होने पर, यह मानदंड सिर्फ़ उन लाइनों को दिखाता है जहां "आइटम कैटगरी" कॉलम की वैल्यू "पैनल" नहीं है. साथ ही, जहां "शिपिंग की तारीख" कॉलम की वैल्यू "30 अप्रैल, 2016" से पहले की है.

तीसरी टेबल. फ़िल्टर करने की शर्तों का इस्तेमाल करके बिक्री का डेटा

	A	B	C	D	E	F	G
1	आइटम की कैटगरी	मॉडल नंबर	लागत	मात्रा	क्षेत्र	सेल्सपर्सन	भेजने की तारीख
2	पहिया	W-24	20.50 डॉलर	4	पश्चिम	बेथ	1/3/2016
3	दरवाज़ा	D-01X	15.00 डॉलर	2	दक्षिण	अमीर	15/3/2016
4	फ़्रेम	FR-0B1	34.00 डॉलर	8	पूर्व	हन्ना	3/12/2016

फ़िल्टर किए गए व्यू का कोड सैंपल

यहां दिए गए कोड के सैंपल में, फ़िल्टर व्यू बनाने, उसे डुप्लीकेट करने, और फिर बिक्री के सैंपल डेटा का इस्तेमाल करके, डुप्लीकेट किए गए वर्शन को अपडेट करने का तरीका बताया गया है.

Java

sheets/snippets/src/main/java/SheetsFilterViews.java

GitHub पर देखें

/*
 * Dependencies (Maven):
 * com.google.apis:google-api-services-sheets:v4-rev20220927-2.0.0
 * com.google.auth:google-auth-library-oauth2-http:1.19.0
 */

import com.google.api.client.googleapis.javanet.GoogleNetHttpTransport;
import com.google.api.client.json.gson.GsonFactory;
import com.google.api.services.sheets.v4.Sheets;
import com.google.api.services.sheets.v4.SheetsScopes;
import com.google.api.services.sheets.v4.model.*;
import com.google.auth.http.HttpCredentialsAdapter;
import com.google.auth.oauth2.GoogleCredentials;

import java.io.IOException;
import java.security.GeneralSecurityException;
import java.util.*;

public class SheetsFilterViews {

    public static void main(String... args) {
        filterViews("1CM29gwKIzeXsAppeNwrc8lbYaVMmUclprLuLYuHog4k");
    }

    public static void filterViews(String spreadsheetId) {
        try {
            // Load pre-authorized user credentials from the environment.
            // TODO(developer) - See https://developers.google.com/identity for guides on implementing OAuth2.
            GoogleCredentials credentials = GoogleCredentials.getApplicationDefault()
                    .createScoped(Collections.singleton(SheetsScopes.SPREADSHEETS));

            Sheets service = new Sheets.Builder(
                    GoogleNetHttpTransport.newTrustedTransport(),
                    GsonFactory.getDefaultInstance(),
                    new HttpCredentialsAdapter(credentials))
                    .setApplicationName("Sheets Filter Views Sample")
                    .build();

            // --- Step 1: Add Filter View ---
            GridRange myRange = new GridRange()
                    .setSheetId(0)
                    .setStartRowIndex(0)
                    .setStartColumnIndex(0);

            // Construct Criteria for Column 0 (Hidden Values)
            FilterCriteria criteria0 = new FilterCriteria()
                    .setHiddenValues(Collections.singletonList("Panel"));

            // Construct Criteria for Column 6 (Date Condition)
            ConditionValue dateValue = new ConditionValue().setUserEnteredValue("4/30/2016");
            BooleanCondition dateCondition = new BooleanCondition()
                    .setType("DATE_BEFORE")
                    .setValues(Collections.singletonList(dateValue));
            FilterCriteria criteria6 = new FilterCriteria().setCondition(dateCondition);

            // Map criteria to column indices (Note: keys are Strings in Java map)
            Map<String, FilterCriteria> criteriaMap = new HashMap<>();
            criteriaMap.put("0", criteria0);
            criteriaMap.put("6", criteria6);

            FilterView filterView = new FilterView()
                    .setTitle("Sample Filter")
                    .setRange(myRange)
                    .setSortSpecs(Collections.singletonList(
                            new SortSpec().setDimensionIndex(3).setSortOrder("DESCENDING")
                    ))
                    .setCriteria(criteriaMap);

            // --- Step 1: Add Filter View ---
            // (Request construction remains the same)
            // ...
            AddFilterViewRequest addFilterViewRequest = new AddFilterViewRequest().setFilter(filterView);

            BatchUpdateSpreadsheetRequest batchRequest1 = new BatchUpdateSpreadsheetRequest()
                    .setRequests(Collections.singletonList(new Request().setAddFilterView(addFilterViewRequest)));

            BatchUpdateSpreadsheetResponse response1 = service.spreadsheets()
                    .batchUpdate(spreadsheetId, batchRequest1)
                    .execute();

            if (response1.getReplies() == null || response1.getReplies().isEmpty()) {
                System.err.println("Error: No replies returned from AddFilterView request.");
                return;
            }

            Response reply1 = response1.getReplies().get(0);
            if (reply1.getAddFilterView() == null || reply1.getAddFilterView().getFilter() == null) {
                 System.err.println("Error: Response did not contain AddFilterView data.");
                 return;
            }

            int filterId = reply1.getAddFilterView().getFilter().getFilterViewId();

            // --- Step 2: Duplicate Filter View ---
            DuplicateFilterViewRequest duplicateRequest = new DuplicateFilterViewRequest()
                    .setFilterId(filterId);

            BatchUpdateSpreadsheetRequest batchRequest2 = new BatchUpdateSpreadsheetRequest()
                    .setRequests(Collections.singletonList(new Request().setDuplicateFilterView(duplicateRequest)));

            BatchUpdateSpreadsheetResponse response2 = service.spreadsheets()
                    .batchUpdate(spreadsheetId, batchRequest2)
                    .execute();

            if (response2.getReplies() == null || response2.getReplies().isEmpty()) {
                 System.err.println("Error: No replies returned from DuplicateFilterView request.");
                 return;
            }

            Response reply2 = response2.getReplies().get(0);
            if (reply2.getDuplicateFilterView() == null || reply2.getDuplicateFilterView().getFilter() == null) {
                System.err.println("Error: Response did not contain DuplicateFilterView data.");
                return;
            }

            int newFilterId = reply2.getDuplicateFilterView().getFilter().getFilterViewId();

            // --- Step 3: Update Filter View ---
            // Extract the new ID from the duplicate response
            int newFilterId = response2.getReplies().get(0)
                    .getDuplicateFilterView().getFilter().getFilterViewId();

            // Create update criteria
            Map<String, FilterCriteria> updateCriteriaMap = new HashMap<>();
            updateCriteriaMap.put("0", new FilterCriteria()); // Empty criteria

            ConditionValue numValue = new ConditionValue().setUserEnteredValue("5");
            BooleanCondition numCondition = new BooleanCondition()
                    .setType("NUMBER_GREATER")
                    .setValues(Collections.singletonList(numValue));
            updateCriteriaMap.put("3", new FilterCriteria().setCondition(numCondition));

            FilterView updateFilterView = new FilterView()
                    .setFilterViewId(newFilterId)
                    .setTitle("Updated Filter")
                    .setCriteria(updateCriteriaMap);

            UpdateFilterViewRequest updateRequest = new UpdateFilterViewRequest()
                    .setFilter(updateFilterView)
                    .setFields("criteria,title");

            BatchUpdateSpreadsheetRequest batchRequest3 = new BatchUpdateSpreadsheetRequest()
                    .setRequests(Collections.singletonList(new Request().setUpdateFilterView(updateRequest)));

            BatchUpdateSpreadsheetResponse response3 = service.spreadsheets()
                    .batchUpdate(spreadsheetId, batchRequest3)
                    .execute();

            System.out.println(response3.toPrettyString());

        } catch (IOException | GeneralSecurityException e) {
            System.err.println("An error occurred: " + e);
        }
    }
}

Python

sheets/snippets/sheets_filter_views.py

GitHub पर देखें

import google.auth
from googleapiclient.discovery import build
from googleapiclient.errors import HttpError


def filter_views(spreadsheet_id):
  """
  Creates the batch_update the user has access to.
  Load pre-authorized user credentials from the environment.
  TODO(developer) - See https://developers.google.com/identity
  for guides on implementing OAuth2 for the application.
  """
  creds, _ = google.auth.default()
  # pylint: disable=maybe-no-member
  try:
    service = build("sheets", "v4", credentials=creds)

    my_range = {
        "sheetId": 0,
        "startRowIndex": 0,
        "startColumnIndex": 0,
    }
    addfilterviewrequest = {
        "addFilterView": {
            "filter": {
                "title": "Sample Filter",
                "range": my_range,
                "sortSpecs": [{
                    "dimensionIndex": 3,
                    "sortOrder": "DESCENDING",
                }],
                "criteria": {
                    0: {"hiddenValues": ["Panel"]},
                    6: {
                        "condition": {
                            "type": "DATE_BEFORE",
                            "values": {"userEnteredValue": "4/30/2016"},
                        }
                    },
                },
            }
        }
    }

    body = {"requests": [addfilterviewrequest]}
    addfilterviewresponse = (
        service.spreadsheets()
        .batchUpdate(spreadsheetId=spreadsheet_id, body=body)
        .execute()
    )

    duplicatefilterviewrequest = {
        "duplicateFilterView": {
            "filterId": addfilterviewresponse["replies"][0]["addFilterView"][
                "filter"
            ]["filterViewId"]
        }
    }

    body = {"requests": [duplicatefilterviewrequest]}
    duplicatefilterviewresponse = (
        service.spreadsheets()
        .batchUpdate(spreadsheetId=spreadsheet_id, body=body)
        .execute()
    )

    updatefilterviewrequest = {
        "updateFilterView": {
            "filter": {
                "filterViewId": duplicatefilterviewresponse["replies"][0][
                    "duplicateFilterView"
                ]["filter"]["filterViewId"],
                "title": "Updated Filter",
                "criteria": {
                    0: {},
                    3: {
                        "condition": {
                            "type": "NUMBER_GREATER",
                            "values": {"userEnteredValue": "5"},
                        }
                    },
                },
            },
            "fields": {"paths": ["criteria", "title"]},
        }
    }

    body = {"requests": [updatefilterviewrequest]}
    updatefilterviewresponse = (
        service.spreadsheets()
        .batchUpdate(spreadsheetId=spreadsheet_id, body=body)
        .execute()
    )
    print(str(updatefilterviewresponse))
  except HttpError as error:
    print(f"An error occurred: {error}")


if __name__ == "__main__":
  # Pass: spreadsheet_id
  filter_views("1CM29gwKIzeXsAppeNwrc8lbYaVMmUclprLuLYuHog4k")

मिलते-जुलते विषय

• Google Sheets के डेटा पर फ़िल्टर लागू करना
• मेटाडेटा को पढ़ना, लिखना, और खोजना