পিভট টেবিল

আপনার স্প্রেডশীটে পিভট টেবিল তৈরি করতে কীভাবে এবং কেন Google পত্রক API ব্যবহার করবেন তা এই নির্দেশিকা বর্ণনা করে।

একটি পিভট টেবিল কি?

পিভট টেবিলগুলি আপনার স্প্রেডশীটে ডেটা সংক্ষিপ্ত করার একটি উপায় প্রদান করে, একটি নতুন টেবিলে সংক্ষিপ্ত ফলাফলগুলি প্রদর্শন করার সময় স্বয়ংক্রিয়ভাবে ডেটা একত্রিত করা, বাছাই করা, গণনা করা বা গড় করা। একটি পিভট টেবিল একটি উৎস ডেটা সেটের বিরুদ্ধে এক ধরণের অনুসন্ধান হিসাবে কাজ করে। এই উৎস ডেটা স্প্রেডশীটের অন্য কোনো স্থানে বিদ্যমান, এবং পিভট টেবিল ডেটার একটি প্রক্রিয়াকৃত দৃশ্য উপস্থাপন করে।

উদাহরণস্বরূপ, নিম্নলিখিত বিক্রয় ডেটা সেট বিবেচনা করুন:

ক খ গ ডি ই চ জি
1 আইটেম বিভাগ মডেল নম্বার খরচ পরিমাণ অঞ্চল বিক্রয়কর্মী জাহাজের তারিখ
2 চাকা W-24 $20.50 4 পশ্চিম বেথ 3/1/2016
3 দরজা D-01X $15.00 2 দক্ষিণ আমীর 3/15/2016
4 ইঞ্জিন ENG-0134 $100.00 1 উত্তর কারমেন 3/20/2016
5 ফ্রেম FR-0B1 $34.00 8 পূর্ব হান্না 3/12/2016
6 প্যানেল পি-034 $6.00 4 উত্তর ডেভিন 4/2/2016
7 প্যানেল পি-052 $11.50 7 পূর্ব এরিক 5/16/2016
8 চাকা W-24 $20.50 11 দক্ষিণ শেলডন 4/30/2016
9 ইঞ্জিন ENG-0161 $330.00 2 উত্তর জেসি 7/2/2016
10 দরজা D-01Y $২৯.০০ 6 পশ্চিম আরমান্দো 3/13/2016
11 ফ্রেম FR-0B1 $34.00 9 দক্ষিণ ইউলিয়ানা 2/27/2016
12 প্যানেল P-102 $3.00 15 পশ্চিম কারমেন 4/18/2016
13 প্যানেল P-105 $8.25 13 পশ্চিম জেসি 6/20/2016
14 ইঞ্জিন ENG-0211 $283.00 1 উত্তর আমীর 6/21/2016
15 দরজা D-01X $15.00 2 পশ্চিম আরমান্দো 7/3/2016
16 ফ্রেম FR-0B1 $34.00 6 দক্ষিণ কারমেন 7/15/2016
17 চাকা W-25 $20.00 8 দক্ষিণ হান্না 5/2/2016
18 চাকা W-11 $২৯.০০ 13 পূর্ব এরিক 5/19/2016
19 দরজা D-05 $17.70 7 পশ্চিম বেথ 6/28/2016
20 ফ্রেম FR-0B1 $34.00 8 উত্তর শেলডন 3/30/2016

আপনি একটি পিভট টেবিল ব্যবহার করে একটি প্রতিবেদন তৈরি করতে পারেন যা দেখায় যে প্রতিটি অঞ্চলে কতগুলি মডেল নম্বর বিক্রি হয়েছে:

একটি পিভট টেবিলের স্ক্রিনশট অঞ্চল অনুসারে মডেল নম্বরের গণনা দেখাচ্ছে

এই পিভট টেবিল তৈরি করতে ব্যবহৃত সোর্স কোডের জন্য, নীচের উদাহরণ বিভাগটি দেখুন।

একবার একটি পিভট টেবিল একটি স্প্রেডশীটে স্থাপন করা হলে, ব্যবহারকারীরা পত্রক UI ব্যবহার করে সারাংশের গঠন এবং বিবরণ ইন্টারেক্টিভভাবে পরিবর্তন করতে পারে।

পিভট টেবিলের সাথে কাজ করা

একটি পিভট টেবিল সংজ্ঞা একটি শীট একটি একক ঘর সঙ্গে যুক্ত করা হয়. যদিও এর রেন্ডার করা চেহারাটি উচ্চতা এবং প্রস্থ উভয় ক্ষেত্রেই অনেকগুলি কোষ, প্রোগ্রাম্যাটিকভাবে এটি একটি একক কক্ষের স্থানাঙ্কে অবস্থিত। এই ঘরটি রেন্ডার করা পিভট টেবিলের উপরের-বাম কোণে পরিণত হয়, যার অনুভূমিক এবং উল্লম্ব ব্যাপ্তি এটির সংজ্ঞা দ্বারা নির্ধারিত হয়।

একটি পিভট টেবিল যোগ করা হচ্ছে

একটি পিভট টেবিল যোগ করতে, ব্যাচআপডেট পদ্ধতি ব্যবহার করুন, একটি আপডেটসেল অনুরোধ সরবরাহ করুন। আপনি নীচে দেখানো হিসাবে একটি ঘরের বিষয়বস্তু হিসাবে একটি PivotTable সংজ্ঞা সরবরাহ করতে এই অনুরোধটি ব্যবহার করেন:

"updateCells": {
  "rows": {
    "values": [{
      "pivotTable": MyPivotTable
    },
    "start": {
      "sheetId": sheetId,
      "rowIndex": 0,
      "columnIndex": 0
    },
    "fields": "pivotTable"
  }

এটি নির্দিষ্ট শীটে MyPivotTable দ্বারা বর্ণিত পিভট টেবিলটিকে A1 কক্ষে উপরের-বাম কোণে রাখে। (পিভট টেবিলের উচ্চতা এবং প্রস্থ গতিশীল; আপনি শুধুমাত্র উত্স নির্দিষ্ট করুন৷)

PivotTable প্রকার আপনাকে নির্দিষ্ট করতে দেয়:

  • উৎস তথ্য পরিসীমা
  • এক বা একাধিক ক্ষেত্র যার ডেটা পিভট টেবিলের সারি তৈরি করবে
  • এক বা একাধিক ক্ষেত্র যার ডেটা পিভট টেবিলের কলাম গঠন করবে
  • ফিল্টারিং এবং একত্রিতকরণের মানদণ্ড
  • পিভট টেবিল লেআউট

পিভট টেবিল পরিবর্তন এবং মুছে ফেলা হচ্ছে

একটি পিভট টেবিল সংশোধন বা মুছে ফেলার জন্য কোন স্পষ্ট অনুরোধ নেই। পরিবর্তে, বিভিন্ন সেল সামগ্রী সহ একটি আপডেট সেলস অনুরোধ ব্যবহার করুন:

  • একটি পিভট টেবিল পরিবর্তন করতে, একটি পরিবর্তিত PivotTable সংজ্ঞা তৈরি করুন এবং এটি ব্যবহার করে সেল আপডেট করুন, একটি নতুন পিভট টেবিল যোগ করার মতো।
  • একটি পিভট টেবিল মুছে ফেলতে, খালি মান সহ সেল আপডেট করুন। একটি উদাহরণের জন্য, একটি পিভট টেবিলের নমুনা মুছুন দেখুন।

ব্যবহারের ক্ষেত্রে

পরিসংখ্যানগত বিশ্লেষণ, ইআরপি অ্যাপ্লিকেশন, আর্থিক প্রতিবেদন এবং অন্যান্য সহ বিস্তৃত পরিসরে পিভট টেবিলের জন্য অনেকগুলি বিভিন্ন ব্যবহার রয়েছে। ক্লাসিক পিভট টেবিল ব্যবহারের ক্ষেত্রে যেমন আইটেম অন্তর্ভুক্ত:

  • অঞ্চল এবং ত্রৈমাসিক অনুসারে মোট বিক্রয়
  • শিরোনাম এবং অবস্থান অনুসারে গড় বেতন
  • পণ্য এবং দিনের সময় অনুসারে ঘটনার গণনা

পিভট টেবিলের সম্ভাব্য অ্যাপ্লিকেশানের সংখ্যা বিশাল, এবং সেগুলিকে প্রোগ্রাম্যাটিকভাবে তৈরি করার ক্ষমতা শক্তিশালী। আপনি পিভট টেবিল তৈরি করতে পারেন যা ইন্টারেক্টিভ অন্বেষণ সমর্থন করে কিন্তু নির্দিষ্ট পরিস্থিতিতে উপযোগী করা হয়, উদাহরণস্বরূপ:

  • সাম্প্রতিক 24-ঘন্টা সময়ের জন্য ঘটনার ডেটা অন্বেষণ করুন
  • বর্তমানে নির্বাচিত অ্যাকাউন্টের সাথে সামঞ্জস্যপূর্ণ একত্রিত ডেটা দেখুন/বিশ্লেষণ করুন
  • বর্তমান ব্যবহারকারীর অন্তর্গত অঞ্চলগুলির জন্য বিক্রয় ডেটা পরীক্ষা করুন৷

উদাহরণ

এই উদাহরণটি এই পৃষ্ঠার ভূমিকায় দেখানো "অঞ্চল অনুসারে মডেল নম্বর" প্রতিবেদন তৈরি করতে একটি ডেটা সেট থেকে একটি পিভট টেবিল তৈরি করে। অতিরিক্ত উদাহরণের জন্য, পিভট টেবিলের নমুনা পৃষ্ঠাটি দেখুন।

অ্যাপস স্ক্রিপ্ট

sheets/api/spreadsheet_snippets.gs
/**
 * Create pivot table
 * @param {string} spreadsheetId spreadsheet ID
 * @returns {*} pivot table's spreadsheet
 */
Snippets.prototype.pivotTable = (spreadsheetId) => {
  try {
    const spreadsheet = SpreadsheetApp.openById(spreadsheetId);

    // Create two sheets for our pivot table, assume we have one.
    let sheet = spreadsheet.getSheets()[0];
    sheet.copyTo(spreadsheet);

    const sourceSheetId = spreadsheet.getSheets()[0].getSheetId();
    const targetSheetId = spreadsheet.getSheets()[1].getSheetId();

    // Create pivot table
    const pivotTable = Sheets.newPivotTable();

    let gridRange = Sheets.newGridRange();
    gridRange.sheetId = sourceSheetId;
    gridRange.startRowIndex = 0;
    gridRange.startColumnIndex = 0;
    gridRange.endRowIndex = 20;
    gridRange.endColumnIndex = 7;
    pivotTable.source = gridRange;

    let pivotRows = Sheets.newPivotGroup();
    pivotRows.sourceColumnOffset = 1;
    pivotRows.showTotals = true;
    pivotRows.sortOrder = 'ASCENDING';
    pivotTable.rows = pivotRows;

    let pivotColumns = Sheets.newPivotGroup();
    pivotColumns.sourceColumnOffset = 4;
    pivotColumns.sortOrder = 'ASCENDING';
    pivotColumns.showTotals = true;
    pivotTable.columns = pivotColumns;

    let pivotValue = Sheets.newPivotValue();
    pivotValue.summarizeFunction = 'COUNTA';
    pivotValue.sourceColumnOffset = 4;
    pivotTable.values = [pivotValue];

    // Create other metadata for the updateCellsRequest
    let cellData = Sheets.newCellData();
    cellData.pivotTable = pivotTable;

    let rows = Sheets.newRowData();
    rows.values = cellData;

    let start = Sheets.newGridCoordinate();
    start.sheetId = targetSheetId;
    start.rowIndex = 0;
    start.columnIndex = 0;

    let updateCellsRequest = Sheets.newUpdateCellsRequest();
    updateCellsRequest.rows = rows;
    updateCellsRequest.start = start;
    updateCellsRequest.fields = 'pivotTable';

    // Batch update our spreadsheet
    let batchUpdate = Sheets.newBatchUpdateSpreadsheetRequest();
    let updateCellsRawRequest = Sheets.newRequest();
    updateCellsRawRequest.updateCells = updateCellsRequest;
    batchUpdate.requests = [updateCellsRawRequest];
    const response = Sheets.Spreadsheets.batchUpdate(batchUpdate,
      spreadsheetId);

    return response;
  } catch (err) {
    // TODO (developer) - Handle exception
    console.log('Failed with error %s', err.message);
  }
};

জাভা

sheets/snippets/src/main/java/PivotTables.java
import com.google.api.client.googleapis.json.GoogleJsonError;
import com.google.api.client.googleapis.json.GoogleJsonResponseException;
import com.google.api.client.http.HttpRequestInitializer;
import com.google.api.client.http.javanet.NetHttpTransport;
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.AddSheetRequest;
import com.google.api.services.sheets.v4.model.BatchUpdateSpreadsheetRequest;
import com.google.api.services.sheets.v4.model.BatchUpdateSpreadsheetResponse;
import com.google.api.services.sheets.v4.model.CellData;
import com.google.api.services.sheets.v4.model.GridCoordinate;
import com.google.api.services.sheets.v4.model.GridRange;
import com.google.api.services.sheets.v4.model.PivotGroup;
import com.google.api.services.sheets.v4.model.PivotTable;
import com.google.api.services.sheets.v4.model.PivotValue;
import com.google.api.services.sheets.v4.model.Request;
import com.google.api.services.sheets.v4.model.RowData;
import com.google.api.services.sheets.v4.model.UpdateCellsRequest;
import com.google.auth.http.HttpCredentialsAdapter;
import com.google.auth.oauth2.GoogleCredentials;
import com.google.common.collect.Lists;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

/* Class to demonstrate the use of Spreadsheet Create Pivot Tables API */
public class PivotTables {
  /**
   * Create pivot table.
   *
   * @param spreadsheetId - Id of the spreadsheet.
   * @return pivot table's spreadsheet
   * @throws IOException - if credentials file not found.
   */
  public static BatchUpdateSpreadsheetResponse pivotTables(String spreadsheetId)
      throws IOException {
        /* Load pre-authorized user credentials from the environment.
           TODO(developer) - See https://developers.google.com/identity for
            guides on implementing OAuth2 for your application. */
    GoogleCredentials credentials = GoogleCredentials.getApplicationDefault()
        .createScoped(Collections.singleton(SheetsScopes.SPREADSHEETS));
    HttpRequestInitializer requestInitializer = new HttpCredentialsAdapter(
        credentials);

    // Create the sheets API client
    Sheets service = new Sheets.Builder(new NetHttpTransport(),
        GsonFactory.getDefaultInstance(),
        requestInitializer)
        .setApplicationName("Sheets samples")
        .build();

    // Create two sheets for our pivot table.
    List<Request> sheetsRequests = new ArrayList<>();
    BatchUpdateSpreadsheetResponse result = null;
    try {
      sheetsRequests.add(new Request().setAddSheet(new AddSheetRequest()));
      sheetsRequests.add(new Request().setAddSheet(new AddSheetRequest()));

      BatchUpdateSpreadsheetRequest createSheetsBody = new BatchUpdateSpreadsheetRequest()
          .setRequests(sheetsRequests);
      BatchUpdateSpreadsheetResponse createSheetsResponse = service.spreadsheets()
          .batchUpdate(spreadsheetId, createSheetsBody).execute();
      int sourceSheetId = createSheetsResponse.getReplies().get(0).getAddSheet().getProperties()
          .getSheetId();
      int targetSheetId = createSheetsResponse.getReplies().get(1).getAddSheet().getProperties()
          .getSheetId();

      PivotTable pivotTable = new PivotTable()
          .setSource(
              new GridRange()
                  .setSheetId(sourceSheetId)
                  .setStartRowIndex(0)
                  .setStartColumnIndex(0)
                  .setEndRowIndex(20)
                  .setEndColumnIndex(7)
          )
          .setRows(Collections.singletonList(
              new PivotGroup()
                  .setSourceColumnOffset(1)
                  .setShowTotals(true)
                  .setSortOrder("ASCENDING")
          ))
          .setColumns(Collections.singletonList(
              new PivotGroup()
                  .setSourceColumnOffset(4)
                  .setShowTotals(true)
                  .setSortOrder("ASCENDING")
          ))
          .setValues(Collections.singletonList(
              new PivotValue()
                  .setSummarizeFunction("COUNTA")
                  .setSourceColumnOffset(4)
          ));
      List<Request> requests = Lists.newArrayList();
      Request updateCellsRequest = new Request().setUpdateCells(new UpdateCellsRequest()
          .setFields("*")
          .setRows(Collections.singletonList(
              new RowData().setValues(
                  Collections.singletonList(
                      new CellData().setPivotTable(pivotTable))
              )
          ))
          .setStart(new GridCoordinate()
              .setSheetId(targetSheetId)
              .setRowIndex(0)
              .setColumnIndex(0)

          ));

      requests.add(updateCellsRequest);
      BatchUpdateSpreadsheetRequest updateCellsBody = new BatchUpdateSpreadsheetRequest()
          .setRequests(requests);
      result = service.spreadsheets().batchUpdate(spreadsheetId, updateCellsBody).execute();
    } catch (GoogleJsonResponseException e) {
      // TODO(developer) - handle error appropriately
      GoogleJsonError error = e.getDetails();
      if (error.getCode() == 404) {
        System.out.printf("Spreadsheet not found with id '%s'.\n", spreadsheetId);
      } else {
        throw e;
      }
    }
    return result;
  }
}

জাভাস্ক্রিপ্ট

sheets/snippets/sheets_pivot_tables.js
function pivotTable(spreadsheetId, callback) {
  // Create two sheets for our pivot table
  const requests = [{
    addSheet: {},
  }, {
    addSheet: {},
  }];
  const batchUpdateRequest = {requests: requests};
  try {
    gapi.client.sheets.spreadsheets.batchUpdate({
      spreadsheetId: spreadsheetId,
      resource: batchUpdateRequest,
    }).then((response) => {
      const sourceSheetId = response.result.replies[0].addSheet.properties.sheetId;
      const targetSheetId = response.result.replies[1].addSheet.properties.sheetId;

      const requests = [{
        updateCells: {
          rows: {
            values: [{
              pivotTable: {
                source: {
                  sheetId: sourceSheetId,
                  startRowIndex: 0,
                  startColumnIndex: 0,
                  endRowIndex: 20,
                  endColumnIndex: 7,
                },
                rows: [{
                  sourceColumnOffset: 1,
                  showTotals: true,
                  sortOrder: 'ASCENDING',
                }],
                columns: [{
                  sourceColumnOffset: 4,
                  sortOrder: 'ASCENDING',
                  showTotals: true,
                }],
                values: [{
                  summarizeFunction: 'COUNTA',
                  sourceColumnOffset: 4,
                }],
                valueLayout: 'HORIZONTAL',
              },
            },
            ],
          },
          start: {
            sheetId: targetSheetId,
            rowIndex: 0,
            columnIndex: 0,
          },
          fields: 'pivotTable',
        },
      }];

      const body = {
        requests,
      };
      gapi.client.sheets.spreadsheets.batchUpdate({
        spreadsheetId: spreadsheetId,
        resource: body,
      }).then((response) => {
        if (callback) callback(response);
      });
    });
  } catch (err) {
    document.getElementById('content').innerText = err.message;
    return;
  }
}

Node.js

sheets/snippets/sheets_pivot_table.js
/**
 * Adds a pivot table to a spreadsheet.
 * @param {string} spreadsheetId The Spreadsheet to add the pivot table to.
 * @return {obj} spreadsheet information
 */
async function pivotTable(spreadsheetId) {
  const {GoogleAuth} = require('google-auth-library');
  const {google} = require('googleapis');

  const auth = new GoogleAuth({
    scopes: 'https://www.googleapis.com/auth/spreadsheets',
  });

  const service = google.sheets({version: 'v4', auth});
  try {
    // Create two sheets for our pivot table
    let requests = [
      {
        addSheet: {},
      },
      {
        addSheet: {},
      },
    ];
    let resource = {requests};
    let response = await service.spreadsheets.batchUpdate({
      spreadsheetId,
      resource,
    });
    const sourceSheetId = response.data.replies[0].addSheet.properties.sheetId;
    const targetSheetId = response.data.replies[1].addSheet.properties.sheetId;

    requests = [
      {
        updateCells: {
          rows: {
            values: [
              {
                pivotTable: {
                  source: {
                    sheetId: sourceSheetId,
                    startRowIndex: 0,
                    startColumnIndex: 0,
                    endRowIndex: 20,
                    endColumnIndex: 7,
                  },
                  rows: [
                    {
                      sourceColumnOffset: 1,
                      showTotals: true,
                      sortOrder: 'ASCENDING',
                    },
                  ],
                  columns: [
                    {
                      sourceColumnOffset: 4,
                      sortOrder: 'ASCENDING',
                      showTotals: true,
                    },
                  ],
                  values: [
                    {
                      summarizeFunction: 'COUNTA',
                      sourceColumnOffset: 4,
                    },
                  ],
                  valueLayout: 'HORIZONTAL',
                },
              },
            ],
          },
          start: {
            sheetId: targetSheetId,
            rowIndex: 0,
            columnIndex: 0,
          },
          fields: 'pivotTable',
        },
      },
    ];
    resource = {
      requests,
    };
    response = service.spreadsheets.batchUpdate({
      spreadsheetId,
      resource,
    });
    return response;
  } catch (err) {
    // TODO (developer) - Handle exception
    throw err;
  }
}

পিএইচপি

sheets/snippets/src/SpreadsheetPivotTables.php
use Google\Client;
use Google\Service\Drive;
use Google\Service\Sheets\BatchUpdateSpreadsheetRequest;


function pivotTables($spreadsheetId)
    {
        /* Load pre-authorized user credentials from the environment.
           TODO(developer) - See https://developers.google.com/identity for
            guides on implementing OAuth2 for your application. */
        $client = new Google\Client();
        $client->useApplicationDefaultCredentials();
        $client->addScope(Google\Service\Drive::DRIVE);
        $service = new Google_Service_Sheets($client);
        try{
            $requests = [
                new Google_Service_Sheets_Request([
                    'addSheet' => [
                        'properties' => [
                            'title' => 'Sheet 1'
                            ]
                ]
            ]),
            new Google_Service_Sheets_Request([
                'addSheet' => [
                    'properties' => [
                        'title' => 'Sheet 2'
                        ]
                        ]
                        ])
                    ];
                    // Create two sheets for our pivot table
                    $batchUpdateRequest = new Google_Service_Sheets_BatchUpdateSpreadsheetRequest([
                        'requests' => $requests
                    ]);
        $batchUpdateResponse = $service->spreadsheets->batchUpdate($spreadsheetId, $batchUpdateRequest);
        $sourceSheetId = $batchUpdateResponse->replies[0]->addSheet->properties->sheetId;
        $targetSheetId = $batchUpdateResponse->replies[1]->addSheet->properties->sheetId;
        $requests = [
            'updateCells' => [
                'rows' => [
                    'values' => [
                        [
                            'pivotTable' => [
                                'source' => [
                                    'sheetId' => $sourceSheetId,
                                    'startRowIndex' => 0,
                                    'startColumnIndex' => 0,
                                    'endRowIndex' => 20,
                                    'endColumnIndex' => 7
                                ],
                                'rows' => [
                                    [
                                        'sourceColumnOffset' => 1,
                                        'showTotals' => true,
                                        'sortOrder' => 'ASCENDING',
                                    ],
                                ],
                                'columns' => [
                                    [
                                        'sourceColumnOffset' => 4,
                                        'sortOrder' => 'ASCENDING',
                                        'showTotals' => true,
                                    ]
                                ],
                                'values' => [
                                    [
                                        'summarizeFunction' => 'COUNTA',
                                        'sourceColumnOffset' => 4
                                        ]
                                    ],
                                'valueLayout' => 'HORIZONTAL'
                            ]
                        ]
                        ]
                ],
                'start' => [
                    'sheetId' => $targetSheetId,
                    'rowIndex' => 0,
                    'columnIndex' => 0
                ],
                'fields' => 'pivotTable'
            ]
        ];
        return $batchUpdateResponse;
    }
        catch(Exception $e) {
            // TODO(developer) - handle error appropriately
            echo 'Message: ' .$e->getMessage();
        }
    }

পাইথন

sheets/snippets/sheets_pivot_tables.py
import google.auth
from googleapiclient.discovery import build
from googleapiclient.errors import HttpError


def pivot_tables(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)
    # Create two sheets for our pivot table.
    body = {"requests": [{"addSheet": {}}, {"addSheet": {}}]}
    batch_update_response = (
        service.spreadsheets()
        .batchUpdate(spreadsheetId=spreadsheet_id, body=body)
        .execute()
    )
    source_sheet_id = (
        batch_update_response.get("replies")[0]
        .get("addSheet")
        .get("properties")
        .get("sheetId")
    )
    target_sheet_id = (
        batch_update_response.get("replies")[1]
        .get("addSheet")
        .get("properties")
        .get("sheetId")
    )
    requests = []
    requests.append(
        {
            "updateCells": {
                "rows": {
                    "values": [
                        {
                            "pivotTable": {
                                "source": {
                                    "sheetId": source_sheet_id,
                                    "startRowIndex": 0,
                                    "startColumnIndex": 0,
                                    "endRowIndex": 20,
                                    "endColumnIndex": 7,
                                },
                                "rows": [
                                    {
                                        "sourceColumnOffset": 1,
                                        "showTotals": True,
                                        "sortOrder": "ASCENDING",
                                    },
                                ],
                                "columns": [{
                                    "sourceColumnOffset": 4,
                                    "sortOrder": "ASCENDING",
                                    "showTotals": True,
                                }],
                                "values": [{
                                    "summarizeFunction": "COUNTA",
                                    "sourceColumnOffset": 4,
                                }],
                                "valueLayout": "HORIZONTAL",
                            }
                        }
                    ]
                },
                "start": {
                    "sheetId": target_sheet_id,
                    "rowIndex": 0,
                    "columnIndex": 0,
                },
                "fields": "pivotTable",
            }
        }
    )
    body = {"requests": requests}
    response = (
        service.spreadsheets()
        .batchUpdate(spreadsheetId=spreadsheet_id, body=body)
        .execute()
    )
    return response

  except HttpError as error:
    print(f"An error occurred: {error}")
    return error


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

রুবি

sheets/snippets/lib/spreadsheet_snippets.rb
requests = [{
  update_cells: {
    rows:   {
      values: [
        {
          pivot_table: {
            source:       {
              sheet_id:           source_sheet_id,
              start_row_index:    0,
              start_column_index: 0,
              end_row_index:      20,
              end_column_index:   7
            },
            rows:         [
              {
                source_column_offset: 1,
                show_totals:          true,
                sort_order:           'ASCENDING',
              },
            ],
            columns:      [
              {
                source_column_offset: 4,
                sort_order:           'ASCENDING',
                show_totals:          true,
              }
            ],
            values:       [
              {
                summarize_function:   'COUNTA',
                source_column_offset: 4
              }
            ],
            value_layout: 'HORIZONTAL'
          }
        }
      ]
    },
    start:  {
      sheet_id:     target_sheet_id,
      row_index:    0,
      column_index: 0
    },
    fields: 'pivotTable'
  }
}]
result = service.batch_update_spreadsheet(spreadsheet_id, body, {})