खास जानकारी

Google Analytics Data API v1 की मदद से, पिवट टेबल जनरेट की जा सकती हैं. पिवट टेबल, डेटा की खास जानकारी देने वाले टूल हैं. इन टेबल की मदद से, अपने डेटा को एक या उससे ज़्यादा पिवट (घुमाव) करके, टेबल में दी गई जानकारी डाइमेंशन.

उदाहरण के लिए, यहां दी गई रॉ डेटा टेबल देखें:

इस डेटा का इस्तेमाल करके, पिवट टेबल बनाई जा सकती है. ब्राउज़र के हिसाब से सेशन का डेटा. इसमें देश और भाषा के डाइमेंशन को चुना गया है पिवट कर सकते हैं.

मुख्य रिपोर्ट के साथ शेयर की गई सुविधाएं

पिवट रिपोर्टिंग अनुरोधों का सिमैंटिक, कोर रिपोर्ट अनुरोधों जैसा ही होता है शेयर किए गए कई फ़ीचर शामिल हैं. उदाहरण के लिए, पेज नंबर, डाइमेंशन फ़िल्टर, और उपयोगकर्ता प्रॉपर्टी, पिवट रिपोर्ट की तरह ही मुख्य रिपोर्ट की तरह काम करती हैं. यह गाइड, पिवट रिपोर्टिंग सुविधाओं पर फ़ोकस करती है. कोर के साथ स्वयं को परिचित करने के लिए Data API v1 की रिपोर्टिंग सुविधाओं के बारे में जानने के लिए, रिपोर्टिंग की बुनियादी बातों वाली गाइड पढ़ें, साथ ही, इस्तेमाल के बेहतर उदाहरण गाइड भी पढ़ें.

पिवट रिपोर्टिंग के तरीके

Data API v1, रिपोर्टिंग के इन तरीकों में पिवट फ़ंक्शन के साथ काम करता है:

• runPivotReport यह तरीका यह विकल्प आपके Google Analytics इवेंट डेटा की, पसंद के मुताबिक बनाई गई पिवट रिपोर्ट दिखाता है. हर पिवट, रिपोर्ट के जवाब में दिखने वाले डाइमेंशन कॉलम और पंक्तियों की जानकारी देता है.

• batchRunPivotReports यह यह runPivotReport तरीके का बैच वर्शन है, जो जनरेट करने की सुविधा देता है कई रिपोर्ट बनाने के लिए किया जा सकता है.

रिपोर्टिंग इकाई चुनना

Data API v1 के सभी तरीकों के लिए, Google Analytics प्रॉपर्टी आइडेंटिफ़ायर का होना ज़रूरी है URL अनुरोध पथ के अंदर इस रूप में दर्ज की जानी चाहिए: properties/GA_PROPERTY_ID, जैसे:

  POST  https://analyticsdata.googleapis.com/v1beta/properties/GA_PROPERTY_ID:runPivotReport

मिलने वाली रिपोर्ट, Google Analytics के इवेंट डेटा के आधार पर जनरेट की जाएगी को खास Google Analytics प्रॉपर्टी में इकट्ठा किया जाता है.

अगर किसी Data API क्लाइंट लाइब्रेरी का इस्तेमाल किया जा रहा है, तो अनुरोध यूआरएल पाथ में मैन्युअल तरीके से बदलाव करने की कोई ज़रूरत नहीं है. ज़्यादातर एपीआई क्लाइंट ऐसा property पैरामीटर दें जिसके लिए स्ट्रिंग इस फ़ॉर्मैट में होनी चाहिए properties/GA_PROPERTY_ID. आसानी से सिखाने वाली गाइड देखें देखें.

पिवट रिपोर्ट का अनुरोध

पिवट टेबल की मदद से अनुरोध बनाने के लिए, runPivotReport या batchRunPivotReports तरीका.

पिवट किए गए डेटा का अनुरोध करने के लिए, RunPivotReportRequest को बनाया जा सकता है ऑब्जेक्ट है. हमारा सुझाव है कि आप इन अनुरोध पैरामीटर से शुरू करें:

• dateRanges फ़ील्ड में मान्य एंट्री.
• डाइमेंशन फ़ील्ड में कम से कम एक मान्य एंट्री हो.
• मेट्रिक फ़ील्ड में कम से कम एक मान्य एंट्री हो.
• पिवट फ़ील्ड में कम से कम दो मान्य पिवट एंट्री.

यहां सुझाए गए फ़ील्ड के साथ अनुरोध का एक सैंपल दिया गया है:

POST https://analyticsdata.googleapis.com/v1beta/properties/GA_PROPERTY_ID:runPivotReport
  {
    "dateRanges": [{ "startDate": "2020-09-01", "endDate": "2020-09-15" }],
    "dimensions": [
        { "name": "browser" },
        { "name": "country" },
        { "name": "language" }
      ],
    "metrics": [{ "name": "sessions" }],
    "pivots": [
      {
        "fieldNames": [
          "browser"
        ],
        "limit": 5
      },
      {
        "fieldNames": [
          "country"
        ],
        "limit": 250
      },
      {
        "fieldNames": [
          "language"
        ],
        "limit": 15
      }
    ]
  }

पिवट

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

Data API v1 में कई पिवट तब तक काम करते हैं, जब तक उस सीमा को ही पूरा कर लिया जाता है. हर पिवट के लिए पैरामीटर 1,00,000 से ज़्यादा नहीं होता.

नीचे एक स्निपेट दिया गया है, जिसमेंpivots देश के हिसाब से सेशन की संख्या, जिसमें browser डाइमेंशन के हिसाब से बदलाव हुआ है. ध्यान दें कि क्वेरी इसके लिए orderBys फ़ील्ड का इस्तेमाल करती है क्रम से लगाना, और सीमा और पेज नंबर लागू करने के लिए, ऑफ़सेट फ़ील्ड.

    "pivots": [
      {
        "fieldNames": [
          "country"
        ],
        "limit": 250,
        "orderBys": [
          {
            "dimension": {
              "dimensionName": "country"
            }
          }
        ]
      },
      {
        "fieldNames": [
          "browser"
        ],
        "offset": 3,
        "limit": 3,
        "orderBys": [
          {
            "metric": {
              "metricName": "sessions"
            },
            "desc": true
          }
        ]
      }
    ],
    ...

डाइमेंशन

डाइमेंशन में, आपके इवेंट डेटा की जानकारी दी जाती है और उसे ग्रुप में बांटा जाता है वेबसाइट या ऐप्लिकेशन पर भेजा जाएगा. उदाहरण के लिए, city डाइमेंशन से शहर ("पेरिस" का पता चलता है या "न्यूयॉर्क") जिससे हर इवेंट शुरू हुआ. रिपोर्ट अनुरोध में, ये काम किए जा सकते हैं शून्य या उससे ज़्यादा डाइमेंशन डालें.

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

नीचे एक स्निपेट दिया गया है, जिसमें dimension और fieldNames फ़ील्ड के इस्तेमाल के बारे में बताया गया है browser, country, और language पिवट वाली टेबल के लिए:

    "pivots": [
      {
        "fieldNames": [
          "browser"
        ],
        "limit": 5,
        "orderBys": [
          {
            "metric": {
              "metricName": "sessions"
            },
            "desc": true
          }
        ]
      },
      {
        "fieldNames": [
          "country"
        ],
        "limit": 250,
        "orderBys": [
          {
            "dimension": {
              "dimensionName": "country"
            }
          }
        ]
      },
      {
        "fieldNames": [
          "language"
        ],
        "limit": 10
      }
    ],

मेट्रिक

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

पिवट रिपोर्ट अनुरोधों में, मीट्रिक को इसके metrics फ़ील्ड का उपयोग करके निर्धारित किया जाता है अनुरोध का मुख्य हिस्सा, जो रिपोर्टिंग के मुख्य तरीकों जैसा ही होता है.

नीचे दिए गए उदाहरण में, सेशन की संख्या के बारे में बताया गया है. रिपोर्ट:

    "metrics": [
      {
        "name": "sessions"
      }
    ],

मेट्रिक एग्रीगेशन

metricAggregations का इस्तेमाल करें एग्रीगेट की गई मेट्रिक कैलकुलेट करने के लिए, पिवट ऑब्जेक्ट का फ़ील्ड हर पिवट के लिए मान तय करें.

एग्रीगेशन की गिनती सिर्फ़ तब की जाएगी, जब metricAggregations फ़ील्ड को किसी अनुरोध में दर्ज किया गया है.

नीचे एक क्वेरी का स्निपेट दिया गया है, जो browser पिवट डाइमेंशन:

"pivots": [
  {
    "fieldNames": [
      "browser"
    ],
    "limit": 10,
    "metricAggregations": [
      "TOTAL",
    ]
  },
  ...

कैलकुलेट की गई मेट्रिक को एग्रीगेट में दिखाया जाता है RunPivotReportResponse का फ़ील्ड ऑब्जेक्ट है. मेट्रिक की एग्रीगेट की गई लाइनों के लिए, dimensionValues फ़ील्ड में RESERVED_TOTAL, RESERVED_MAX या RESERVED_MIN का खास मान होता है.

  "aggregates": [
    {
      "dimensionValues": [
        {
          "value": "Chrome"
        },
        {
          "value": "RESERVED_TOTAL"
        },
        {
          "value": "RESERVED_TOTAL"
        }
      ],
      "metricValues": [
        {
          "value": "4"
        }
      ]
    },
    {
      "dimensionValues": [
        {
          "value": "Firefox"
        },
        {
          "value": "RESERVED_TOTAL"
        },
        {
          "value": "RESERVED_TOTAL"
        }
      ],
      "metricValues": [
        {
          "value": "6"
        }
      ]
    },
  ....

  }

पेज पर नंबर डालना

रिपोर्टिंग के मुख्य तरीकों की तरह ही, पिवट रिक्वेस्ट से भी आपको सीमा तय करने के लिए और ऑफ़सेट फ़ील्ड पेज नंबर लागू करने के लिए, पिवट ऑब्जेक्ट. खोज के नतीजों को पेजों में बांटने की सेटिंग, हर पिवट पर अलग-अलग लागू होती हैं. हर Pivot ऑब्जेक्ट के लिए limit फ़ील्ड की ज़रूरत होती है, ताकि एलिमेंट की संख्या की रिपोर्ट करें.

Data API v1, कई पिवट के साथ तब तक काम करता है, जब तक कि limit का प्रॉडक्ट ही उपलब्ध होता है हर पिवट के लिए पैरामीटर 1,00,000 से ज़्यादा नहीं होता.

नीचे एक स्निपेट दिया गया है, जो इन कामों के लिए offset और limit फ़ील्ड का इस्तेमाल दिखाता है 10 के ऑफ़सेट के साथ अगले पांच language डाइमेंशन फिर से पाएं:

      {
        "fieldNames": [
          "language"
        ],
        "offset": 10,
        "limit": 5
      }

फ़िल्टर करना

मुख्य रिपोर्टिंग फ़ंक्शन की तरह, अनुरोध के स्कोप वाला डाइमेंशन फ़िल्टर अगर पिवट रिपोर्टिंग में डाइमेंशन को फ़िल्टर करने की सुविधा चाहिए, तो 'ज़रूरी है' का इस्तेमाल करें अनुरोध.

क्रम से लगाना

हर पिवट रिपोर्ट के लिए, पिवट रिपोर्ट क्वेरी के क्रम के व्यवहार को कंट्रोल किया जा सकता है orderBys का इस्तेमाल करके एक पिवट ऑब्जेक्ट का फ़ील्ड, जिसमें OrderBy ऑब्जेक्ट.

हर OrderBy में, इनमें से एक चीज़ हो सकती है:

• DimensionOrderBy, डाइमेंशन की वैल्यू के मुताबिक नतीजों को क्रम से लगाता है.
• MetricOrderBy, क्रम से लगाया जाता है मेट्रिक की वैल्यू के आधार पर नतीजे मिलते हैं.
• PivotOrderBy, इसका इस्तेमाल इसमें किया गया पिवट क्वेरी और मेट्रिक की वैल्यू के हिसाब से नतीजों को क्रम से लगाया जा सकता है पिवट कॉलम ग्रुप में शामिल करें.

इस उदाहरण में, पिवट की परिभाषा के लिए एक स्निपेट दिखाया गया है, जो रिपोर्ट को पिवट करता है browser डाइमेंशन, जिसमें नतीजों को sessions मेट्रिक के हिसाब से क्रम में लगाया गया है घटते क्रम में.

      {
        "fieldNames": [
          "browser"
        ],
        "limit": 5,
        "orderBys": [
          {
            "metric": {
              "metricName": "sessions"
            },
            "desc": true
          }
        ]
      }

जवाब की शिकायत करें

किसी पिवट की पिवट रिपोर्ट रिस्पॉन्स रिपोर्ट एपीआई अनुरोध मुख्य रूप से एक हेडर और पंक्तियां होता है.

रिस्पॉन्स हेडर

पिवट रिपोर्ट के हेडर में PivotHeaders होते हैं, DimensionHeaders और MetricHeaders से पिवट रिपोर्ट में.

उदाहरण के लिए, browser, country, और language पिवट डाइमेंशन वाली रिपोर्ट और sessions मेट्रिक इस तरह से हेडर जनरेट करेगा:

{
  "pivotHeaders": [
    {
      "pivotDimensionHeaders": [
        {
          "dimensionValues": [
            {
              "value": "Chrome"
            }
          ]
        },
        {
          "dimensionValues": [
            {
              "value": "Firefox"
            }
          ]
        },
        ...

      ],
      ...
    },
    {
      "pivotDimensionHeaders": [
        {
          "dimensionValues": [
            {
              "value": "United States"
            }
          ]
        },
        {
          "dimensionValues": [
            {
              "value": "Canada"
            }
          ]
        },
        ...

      ],
      ...
    },
    {
      "pivotDimensionHeaders": [
        {
          "dimensionValues": [
            {
              "value": "English"
            }
          ]
        },
        {
          "dimensionValues": [
            {
              "value": "French"
            }
          ]
        },
        ...

      ],
      ...
    }
  ],
  "dimensionHeaders": [
    {
      "name": "browser"
    },
    {
      "name": "country"
    },
    {
      "name": "language"
    }
  ],
  "metricHeaders": [
    {
      "name": "sessions",
      "type": "TYPE_INTEGER"
    }
  ],
  ...

}

नीचे दिया गया चार्ट, पिवट रिपोर्ट के हर कॉम्पोनेंट की भूमिका दिखाता है पिवट रिपोर्ट को रेंडर करने में रिस्पॉन्स:

रिस्पॉन्स लाइन

runPivotReport का पिवट रिपोर्ट रिस्पॉन्स और batchRunPivotReports के तरीके, मुख्य रिपोर्टिंग के तरीकों में इस्तेमाल होने वाले रिस्पॉन्स से अलग होते हैं runReport जैसे और batchRunReports उस हर पिवट रिपोर्ट की प्रतिक्रिया पंक्ति में टेबल है, जबकि सामान्य रिपोर्ट में एक ही जवाब वाली पंक्ति तालिका पंक्ति.

नीचे पिवट रिपोर्ट रिस्पॉन्स का एक हिस्सा दिया गया है, browser, country, और language पिवट डाइमेंशन के साथ क्वेरी करते हैं और sessions मेट्रिक. पिवट रिपोर्ट का हर सेल अलग-अलग दिखाया जाता है:

  "rows": [
    {
      "dimensionValues": [
        {
          "value": "Chrome"
        },
        {
          "value": "United States"
        },
        {
          "value": "English"
        }
      ],
      "metricValues": [
        {
          "value": "1"
        }
      ]
    },
    {
      "dimensionValues": [
        {
          "value": "Firefox"
        },
        {
          "value": "Canada"
        },
        {
          "value": "French"
        }
      ],
      "metricValues": [
        {
          "value": "3"
        }
      ]
    },
    ...

  ]

यह डेटा नीचे दी गई टेबल में हाइलाइट की गई दो सेल से जुड़ा है:

क्लाइंट लाइब्रेरी

ज़्यादा जानकारी के लिए आसानी से सिखाने वाली गाइड देखें क्लाइंट लाइब्रेरी को इंस्टॉल और कॉन्फ़िगर करने का तरीका.

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

use Google\Analytics\Data\V1beta\Client\BetaAnalyticsDataClient;
use Google\Analytics\Data\V1beta\DateRange;
use Google\Analytics\Data\V1beta\Dimension;
use Google\Analytics\Data\V1beta\Metric;
use Google\Analytics\Data\V1beta\OrderBy;
use Google\Analytics\Data\V1beta\OrderBy\DimensionOrderBy;
use Google\Analytics\Data\V1beta\OrderBy\MetricOrderBy;
use Google\Analytics\Data\V1beta\Pivot;
use Google\Analytics\Data\V1beta\RunPivotReportRequest;
use Google\Analytics\Data\V1beta\RunPivotReportResponse;

/**
 * Runs a pivot query to build a report of session counts by country,
 * pivoted by the browser dimension.
 * @param string $propertyId Your GA-4 Property ID
 */
function run_pivot_report(string $propertyId)
{
    // Create an instance of the Google Analytics Data API client library.
    $client = new BetaAnalyticsDataClient();

    // Make an API call.
    $request = (new RunPivotReportRequest())
        ->setProperty('properties/' . $propertyId)
        ->setDateRanges([new DateRange([
            'start_date' => '2021-01-01',
            'end_date' => '2021-01-30',
            ]),
        ])
        ->setPivots([
            new Pivot([
                'field_names' => ['country'],
                'limit' => 250,
                'order_bys' => [new OrderBy([
                    'dimension' => new DimensionOrderBy([
                        'dimension_name' => 'country',
                    ]),
                ])],
            ]),
            new Pivot([
                'field_names' => ['browser'],
                'offset' => 3,
                'limit' => 3,
                'order_bys' => [new OrderBy([
                    'metric' => new MetricOrderBy([
                        'metric_name' => 'sessions',
                    ]),
                    'desc' => true,
                ])],
            ]),
        ])
        ->setMetrics([new Metric(['name' => 'sessions'])])
        ->setDimensions([
            new Dimension(['name' => 'country']),
            new Dimension(['name' => 'browser']),
        ]);
    $response = $client->runPivotReport($request);

    printPivotReportResponse($response);
}

/**
 * Print results of a runPivotReport call.
 * @param RunPivotReportResponse $response
 */
function printPivotReportResponse(RunPivotReportResponse $response)
{
    print 'Report result: ' . PHP_EOL;

    foreach ($response->getRows() as $row) {
        printf(
            '%s %s' . PHP_EOL,
            $row->getDimensionValues()[0]->getValue(),
            $row->getMetricValues()[0]->getValue()
        );
    }
}
run_pivot_report.php

from google.analytics.data_v1beta import BetaAnalyticsDataClient
from google.analytics.data_v1beta.types import (
    DateRange,
    Dimension,
    Metric,
    OrderBy,
    Pivot,
    RunPivotReportRequest,
)


def run_sample():
    """Runs the sample."""
    # TODO(developer): Replace this variable with your Google Analytics 4
    #  property ID before running the sample.
    property_id = "YOUR-GA4-PROPERTY-ID"
    run_pivot_report(property_id)


def run_pivot_report(property_id="YOUR-GA4-PROPERTY-ID"):
    """Runs a pivot query to build a report of session counts by country,
    pivoted by the browser dimension."""
    client = BetaAnalyticsDataClient()

    request = RunPivotReportRequest(
        property=f"properties/{property_id}",
        date_ranges=[DateRange(start_date="2021-01-01", end_date="2021-01-30")],
        pivots=[
            Pivot(
                field_names=["country"],
                limit=250,
                order_bys=[
                    OrderBy(
                        dimension=OrderBy.DimensionOrderBy(dimension_name="country")
                    )
                ],
            ),
            Pivot(
                field_names=["browser"],
                offset=3,
                limit=3,
                order_bys=[
                    OrderBy(
                        metric=OrderBy.MetricOrderBy(metric_name="sessions"), desc=True
                    )
                ],
            ),
        ],
        metrics=[Metric(name="sessions")],
        dimensions=[Dimension(name="country"), Dimension(name="browser")],
    )
    response = client.run_pivot_report(request)
    print_run_pivot_report_response(response)


def print_run_pivot_report_response(response):
    """Prints results of a runPivotReport call."""
    print("Report result:")
    for row in response.rows:
        for dimension_value in row.dimension_values:
            print(dimension_value.value)

        for metric_value in row.metric_values:
            print(metric_value.value)

run_pivot_report.py

  // TODO(developer): Uncomment this variable and replace with your
  // Google Analytics 4 property ID before running the sample.
  // propertyId = 'YOUR-GA4-PROPERTY-ID';

  // Imports the Google Analytics Data API client library.
  const {BetaAnalyticsDataClient} = require('@google-analytics/data');

  // Initialize client that will be used to send requests. This client only
  // needs to be created once, and can be reused for multiple requests.
  const analyticsDataClient = new BetaAnalyticsDataClient();

  // Runs a pivot query to build a report of session counts by country, pivoted by the browser dimension.
  async function runPivotReport() {
    const [response] = await analyticsDataClient.runPivotReport({
      property: `properties/${propertyId}`,
      dateRanges: [
        {
          startDate: '2021-01-01',
          endDate: '2021-01-30',
        },
      ],
      pivots: [
        {
          fieldNames: ['country'],
          limit: 250,
          orderBys: [
            {
              dimension: {
                dimensionName: 'country',
              },
            },
          ],
        },
        {
          fieldNames: ['browser'],
          offset: 3,
          limit: 3,
          orderBys: [
            {
              metric: {
                metricName: 'sessions',
              },
              desc: true,
            },
          ],
        },
      ],
      metrics: [
        {
          name: 'sessions',
        },
      ],
      dimensions: [
        {
          name: 'country',
        },
        {
          name: 'browser',
        },
      ],
    });
    printPivotReportResponse(response);
  }

  runPivotReport();

  // Prints results of a runReport call.
  function printPivotReportResponse(response) {
    console.log('Report result:');
    response.rows.forEach(row => {
      row.dimensionValues.forEach(dimensionValue => {
        console.log(dimensionValue.value);
      });

      row.metricValues.forEach(metricValue => {
        console.log(metricValue.value);
      });
    });
  }
run_pivot_report.js

डेमो ऐप्लिकेशन

Google Analytics API v1 पिवट रिपोर्ट का डेमो देखें ऐप्लिकेशन में, JavaScript का इस्तेमाल करके पिवट रिपोर्ट बनाने और उसे दिखाने का तरीका बताया गया है.