Find and Remove Criteria from Shared Set

Java

// Copyright 2018 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package com.google.ads.googleads.examples.advancedoperations;

import com.beust.jcommander.Parameter;
import com.google.ads.googleads.examples.utils.ArgumentNames;
import com.google.ads.googleads.examples.utils.CodeSampleParams;
import com.google.ads.googleads.lib.GoogleAdsClient;
import com.google.ads.googleads.v3.enums.CriterionTypeEnum.CriterionType;
import com.google.ads.googleads.v3.errors.GoogleAdsError;
import com.google.ads.googleads.v3.errors.GoogleAdsException;
import com.google.ads.googleads.v3.resources.SharedCriterion;
import com.google.ads.googleads.v3.resources.SharedSet;
import com.google.ads.googleads.v3.services.GoogleAdsRow;
import com.google.ads.googleads.v3.services.GoogleAdsServiceClient;
import com.google.ads.googleads.v3.services.GoogleAdsServiceClient.SearchPagedResponse;
import com.google.ads.googleads.v3.services.MutateSharedCriteriaResponse;
import com.google.ads.googleads.v3.services.MutateSharedCriterionResult;
import com.google.ads.googleads.v3.services.SearchGoogleAdsRequest;
import com.google.ads.googleads.v3.services.SharedCriterionOperation;
import com.google.ads.googleads.v3.services.SharedCriterionServiceClient;
import com.google.common.base.Joiner;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

/**
 * Demonstrates how to find shared sets, how to find shared set criteria, and how to remove shared
 * set criteria.
 */
public class FindAndRemoveCriteriaFromSharedSet {

  private static final int PAGE_SIZE = 1_000;

  private static class FindAndRemoveCriteriaFromSharedSetParams extends CodeSampleParams {

    @Parameter(names = ArgumentNames.CUSTOMER_ID, required = true)
    private Long customerId;

    @Parameter(names = ArgumentNames.CAMPAIGN_ID, required = true)
    private Long campaignId;
  }

  public static void main(String[] args) throws IOException {
    FindAndRemoveCriteriaFromSharedSetParams params =
        new FindAndRemoveCriteriaFromSharedSetParams();
    if (!params.parseArguments(args)) {

      // Either pass the required parameters for this example on the command line, or insert them
      // into the code here. See the parameter class definition above for descriptions.
      params.customerId = Long.parseLong("INSERT_CUSTOMER_ID_HERE");
      params.campaignId = Long.parseLong("INSERT_CAMPAIGN_ID_HERE");
    }

    GoogleAdsClient googleAdsClient;
    try {
      googleAdsClient = GoogleAdsClient.newBuilder().fromPropertiesFile().build();
    } catch (FileNotFoundException fnfe) {
      System.err.printf(
          "Failed to load GoogleAdsClient configuration from file. Exception: %s%n", fnfe);
      return;
    } catch (IOException ioe) {
      System.err.printf("Failed to create GoogleAdsClient. Exception: %s%n", ioe);
      return;
    }

    try {
      new FindAndRemoveCriteriaFromSharedSet()
          .runExample(googleAdsClient, params.customerId, params.campaignId);
    } catch (GoogleAdsException gae) {
      // GoogleAdsException is the base class for most exceptions thrown by an API request.
      // Instances of this exception have a message and a GoogleAdsFailure that contains a
      // collection of GoogleAdsErrors that indicate the underlying causes of the
      // GoogleAdsException.
      System.err.printf(
          "Request ID %s failed due to GoogleAdsException. Underlying errors:%n",
          gae.getRequestId());
      int i = 0;
      for (GoogleAdsError googleAdsError : gae.getGoogleAdsFailure().getErrorsList()) {
        System.err.printf("  Error %d: %s%n", i++, googleAdsError);
      }
    }
  }

  /**
   * Runs the example.
   *
   * @param googleAdsClient the Google Ads API client.
   * @param customerId the client customer ID.
   * @param campaignId the campaign ID.
   * @throws GoogleAdsException if an API request failed with one or more service errors.
   */
  private void runExample(GoogleAdsClient googleAdsClient, long customerId, long campaignId) {

    List<Long> sharedSetIds = new ArrayList<>();
    List<String> criterionResourceNames = new ArrayList<>();

    // Retrieves all shared sets associated with the campaign.
    try (GoogleAdsServiceClient googleAdsServiceClient =
        googleAdsClient.getLatestVersion().createGoogleAdsServiceClient()) {
      String searchQuery =
          String.format(
              "SELECT shared_set.id, shared_set.name FROM campaign_shared_set WHERE "
                  + "campaign.id = %d",
              campaignId);

      SearchGoogleAdsRequest request =
          SearchGoogleAdsRequest.newBuilder()
              .setCustomerId(Long.toString(customerId))
              .setPageSize(PAGE_SIZE)
              .setQuery(searchQuery)
              .build();
      SearchPagedResponse searchPagedResponse = googleAdsServiceClient.search(request);
      for (GoogleAdsRow googleAdsRow : searchPagedResponse.iterateAll()) {
        SharedSet sharedSet = googleAdsRow.getSharedSet();
        System.out.printf(
            "Campaign shared set with ID %d and name '%s' was found.%n",
            sharedSet.getId().getValue(), sharedSet.getName().getValue());
        sharedSetIds.add(sharedSet.getId().getValue());
      }
    }

    // Retrieves shared criteria for all found shared sets.
    try (GoogleAdsServiceClient googleAdsServiceClient =
        googleAdsClient.getLatestVersion().createGoogleAdsServiceClient()) {
      String searchQuery =
          String.format(
              "SELECT shared_criterion.type, shared_criterion.keyword.text, "
                  + "  shared_criterion.keyword.match_type, shared_set.id "
                  + "  FROM shared_criterion "
                  + "  WHERE shared_set.id IN (%s)",
              Joiner.on(",").join(sharedSetIds));

      SearchGoogleAdsRequest request =
          SearchGoogleAdsRequest.newBuilder()
              .setCustomerId(Long.toString(customerId))
              .setPageSize(PAGE_SIZE)
              .setQuery(searchQuery)
              .build();
      SearchPagedResponse searchPagedResponse = googleAdsServiceClient.search(request);
      for (GoogleAdsRow googleAdsRow : searchPagedResponse.iterateAll()) {
        SharedCriterion sharedCriterion = googleAdsRow.getSharedCriterion();
        if (sharedCriterion.getType() == CriterionType.KEYWORD) {
          System.out.printf(
              "Shared criterion with resource name '%s' for negative keyword with text '%s' and "
                  + "match type '%s' was found.%n",
              sharedCriterion.getResourceName(),
              sharedCriterion.getKeyword().getText(),
              sharedCriterion.getKeyword().getMatchType());
        } else {
          System.out.printf(
              "Shared criterion with resource name '%s' was found.",
              sharedCriterion.getResourceName());
        }
        criterionResourceNames.add(sharedCriterion.getResourceName());
      }
    }

    // Removes the criteria.
    try (SharedCriterionServiceClient sharedCriterionServiceClient =
        googleAdsClient.getLatestVersion().createSharedCriterionServiceClient()) {
      List<SharedCriterionOperation> operations = new ArrayList<>();
      for (String criterionResourceName : criterionResourceNames) {
        SharedCriterionOperation operation =
            SharedCriterionOperation.newBuilder().setRemove(criterionResourceName).build();
        operations.add(operation);
      }
      // Sends the operation in a mutate request.
      MutateSharedCriteriaResponse response =
          sharedCriterionServiceClient.mutateSharedCriteria(Long.toString(customerId), operations);
      // Prints the resource name of each removed object.
      for (MutateSharedCriterionResult mutateSharedCriterionResult : response.getResultsList()) {
        System.out.printf(
            "Removed shared criterion with resource name: '%s'.%n",
            mutateSharedCriterionResult.getResourceName());
      }
    }
  }
}

C#

// Copyright 2019 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

using Google.Ads.GoogleAds.Lib;
using Google.Ads.GoogleAds.V3.Errors;
using Google.Ads.GoogleAds.V3.Resources;
using Google.Ads.GoogleAds.V3.Services;
using Google.Api.Gax;
using System;
using System.Collections.Generic;
using static Google.Ads.GoogleAds.V3.Enums.CriterionTypeEnum.Types;

namespace Google.Ads.GoogleAds.Examples.V3
{
    /// <summary>
    /// This code example demonstrates how to find shared sets, shared set criteria, and
    /// how to remove them.
    /// </summary>
    public class FindAndRemoveCriteriaFromSharedSet : ExampleBase
    {
        /// <summary>
        /// Main method, to run this code example as a standalone application.
        /// </summary>
        /// <param name="args">The command line arguments.</param>
        public static void Main(string[] args)
        {
            FindAndRemoveCriteriaFromSharedSet codeExample =
                new FindAndRemoveCriteriaFromSharedSet();
            Console.WriteLine(codeExample.Description);

            // The Google Ads customer ID for which the call is made.
            long customerId = long.Parse("INSERT_CUSTOMER_ID_HERE");

            // The ID of the campaign for which shared criterion is updated.
            long campaignId = long.Parse("INSERT_CAMPAIGN_ID_HERE");

            codeExample.Run(new GoogleAdsClient(), customerId, campaignId);
        }

        /// <summary>
        /// Returns a description about the code example.
        /// </summary>
        public override string Description
        {
            get
            {
                return "This code example demonstrates how to find shared sets, shared set " +
                    "criteria, and how to remove them.";
            }
        }

        /// <summary>
        /// Runs the code example.
        /// </summary>
        /// <param name="client">The Google Ads client.</param>
        /// <param name="customerId">The Google Ads customer ID for which the call is made.</param>
        /// <param name="campaignId">The ID of the campaign for which shared criterion is updated.
        /// </param>
        public void Run(GoogleAdsClient client, long customerId, long campaignId)
        {
            try
            {
                SharedCriterionServiceClient sharedCriterionService = client.GetService(
                    Services.V3.SharedCriterionService);

                GoogleAdsServiceClient googleAdsService = client.GetService(
                    Services.V3.GoogleAdsService);

                List<long?> sharedSetIds = new List<long?>();
                List<string> criterionResources = new List<string>();

                // First, retrieve all shared sets associated with the campaign.
                string sharedSetQuery = $"SELECT shared_set.id, shared_set.name FROM " +
                    $"campaign_shared_set WHERE campaign.id = {campaignId}";

                PagedEnumerable<SearchGoogleAdsResponse, GoogleAdsRow> sharedSetResponse =
                    googleAdsService.Search(customerId.ToString(), sharedSetQuery);

                // Display the results.
                foreach (GoogleAdsRow googleAdsRow in sharedSetResponse)
                {
                    SharedSet sharedSet = googleAdsRow.SharedSet;
                    Console.WriteLine("Campaign shared set ID {0} and name '{1}' was found.",
                        sharedSet.Id, sharedSet.Name);

                    sharedSetIds.Add(sharedSet.Id);
                }

                // Next, retrieve shared criteria for all found shared sets.
                string sharedCriterionQuery =
                    "SELECT shared_criterion.type, shared_criterion.keyword.text, " +
                    "shared_criterion.keyword.match_type, shared_set.id FROM shared_criterion " +
                    $"WHERE shared_set.id IN(" +
                    string.Join(",", sharedSetIds.ConvertAll(x => x.ToString())) + ")";

                PagedEnumerable<SearchGoogleAdsResponse, GoogleAdsRow> sharedCriterionResponse =
                    googleAdsService.Search(customerId.ToString(), sharedCriterionQuery);

                // Display the results.
                foreach (GoogleAdsRow googleAdsRow in sharedCriterionResponse)
                {
                    SharedCriterion sharedCriterion = googleAdsRow.SharedCriterion;
                    if (sharedCriterion.Type == CriterionType.Keyword)
                    {
                        Console.WriteLine("Shared criterion with resource name '{0}' for " +
                            "negative keyword with text '{1}' and match type '{2}' was found.",
                            sharedCriterion.ResourceName,
                            sharedCriterion.Keyword.Text,
                            sharedCriterion.Keyword.MatchType);
                    }
                    else
                    {
                        Console.WriteLine("Shared criterion with resource name '{0}' was found.",
                            sharedCriterion.ResourceName);
                    }
                    criterionResources.Add(sharedCriterion.ResourceName);
                }

                // Finally, remove the criteria.
                List<SharedCriterionOperation> operations = new List<SharedCriterionOperation>();
                foreach (string criterionResource in criterionResources)
                {
                    SharedCriterionOperation operation = new SharedCriterionOperation()
                    {
                        Remove = criterionResource
                    };
                    operations.Add(operation);
                }

                MutateSharedCriteriaResponse response =
                    sharedCriterionService.MutateSharedCriteria(
                        customerId.ToString(), operations);

                foreach (MutateSharedCriterionResult result in response.Results)
                {
                    Console.WriteLine($"Removed shared criterion {result.ResourceName}.");
                }
            }
            catch (GoogleAdsException e)
            {
                Console.WriteLine("Failure:");
                Console.WriteLine($"Message: {e.Message}");
                Console.WriteLine($"Failure: {e.Failure}");
                Console.WriteLine($"Request ID: {e.RequestId}");
                throw;
            }
        }
    }
}

PHP

<?php

/**
 * Copyright 2018 Google LLC
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     https://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

namespace Google\Ads\GoogleAds\Examples\AdvancedOperations;

require __DIR__ . '/../../vendor/autoload.php';

use GetOpt\GetOpt;
use Google\Ads\GoogleAds\Examples\Utils\ArgumentNames;
use Google\Ads\GoogleAds\Examples\Utils\ArgumentParser;
use Google\Ads\GoogleAds\Lib\V3\GoogleAdsClient;
use Google\Ads\GoogleAds\Lib\V3\GoogleAdsClientBuilder;
use Google\Ads\GoogleAds\Lib\V3\GoogleAdsException;
use Google\Ads\GoogleAds\Lib\OAuth2TokenBuilder;
use Google\Ads\GoogleAds\V3\Enums\CriterionTypeEnum\CriterionType;
use Google\Ads\GoogleAds\V3\Enums\KeywordMatchTypeEnum\KeywordMatchType;
use Google\Ads\GoogleAds\V3\Errors\GoogleAdsError;
use Google\Ads\GoogleAds\V3\Resources\SharedCriterion;
use Google\Ads\GoogleAds\V3\Services\GoogleAdsRow;
use Google\Ads\GoogleAds\V3\Services\SharedCriterionOperation;
use Google\ApiCore\ApiException;

/**
 * This example demonstrates how to find shared sets, how to find shared set criteria, and how to
 * remove shared set criteria.
 */
class FindAndRemoveCriteriaFromSharedSet
{
    private const CUSTOMER_ID = 'INSERT_CUSTOMER_ID_HERE';
    private const CAMPAIGN_ID = 'INSERT_CAMPAIGN_ID_HERE';

    private const PAGE_SIZE = 1000;

    public static function main()
    {
        // Either pass the required parameters for this example on the command line, or insert them
        // into the constants above.
        $options = (new ArgumentParser())->parseCommandArguments([
            ArgumentNames::CUSTOMER_ID => GetOpt::REQUIRED_ARGUMENT,
            ArgumentNames::CAMPAIGN_ID => GetOpt::REQUIRED_ARGUMENT
        ]);

        // Generate a refreshable OAuth2 credential for authentication.
        $oAuth2Credential = (new OAuth2TokenBuilder())->fromFile()->build();

        // Construct a Google Ads client configured from a properties file and the
        // OAuth2 credentials above.
        $googleAdsClient = (new GoogleAdsClientBuilder())->fromFile()
            ->withOAuth2Credential($oAuth2Credential)
            ->build();

        try {
            self::runExample(
                $googleAdsClient,
                $options[ArgumentNames::CUSTOMER_ID] ?: self::CUSTOMER_ID,
                $options[ArgumentNames::CAMPAIGN_ID] ?: self::CAMPAIGN_ID
            );
        } catch (GoogleAdsException $googleAdsException) {
            printf(
                "Request with ID '%s' has failed.%sGoogle Ads failure details:%s",
                $googleAdsException->getRequestId(),
                PHP_EOL,
                PHP_EOL
            );
            foreach ($googleAdsException->getGoogleAdsFailure()->getErrors() as $error) {
                /** @var GoogleAdsError $error */
                printf(
                    "\t%s: %s%s",
                    $error->getErrorCode()->getErrorCode(),
                    $error->getMessage(),
                    PHP_EOL
                );
            }
            exit(1);
        } catch (ApiException $apiException) {
            printf(
                "ApiException was thrown with message '%s'.%s",
                $apiException->getMessage(),
                PHP_EOL
            );
            exit(1);
        }
    }

    /**
     * Runs the example.
     *
     * @param GoogleAdsClient $googleAdsClient the Google Ads API client
     * @param int $customerId the customer ID
     * @param int $campaignId the ID of the campaign
     */
    public static function runExample(
        GoogleAdsClient $googleAdsClient,
        int $customerId,
        int $campaignId
    ) {
        $sharedSetIds = [];
        $criterionResourceNames = [];

        // First, retrieves all shared sets associated with the campaign.
        $googleAdsServiceClient = $googleAdsClient->getGoogleAdsServiceClient();
        $query = "SELECT shared_set.id, shared_set.name FROM campaign_shared_set WHERE "
            . "campaign.id = $campaignId";

        // Issues a search request by specifying page size.
        $response =
            $googleAdsServiceClient->search($customerId, $query, ['pageSize' => self::PAGE_SIZE]);

        // Iterates over all rows in all pages and prints the requested field values for
        // the shared set in each row.
        foreach ($response->iterateAllElements() as $googleAdsRow) {
            /** @var GoogleAdsRow $googleAdsRow */
            printf(
                "Campaign shared set with ID %d and name '%s' was found.%s",
                $googleAdsRow->getSharedSet()->getIdUnwrapped(),
                $googleAdsRow->getSharedSet()->getNameUnwrapped(),
                PHP_EOL
            );
            $sharedSetIds[] = $googleAdsRow->getSharedSet()->getIdUnwrapped();
        }

        // Next, retrieves shared criteria for all found shared sets.
        $query = sprintf("SELECT shared_criterion.type, shared_criterion.keyword.text, "
              . "shared_criterion.keyword.match_type, shared_set.id "
              . "FROM shared_criterion "
              . "WHERE shared_set.id IN (%s)", implode(',', $sharedSetIds));

        // Issues a search request by specifying page size.
        $response =
            $googleAdsServiceClient->search($customerId, $query, ['pageSize' => self::PAGE_SIZE]);

        // Iterates over all rows in all pages and prints the requested field values for
        // the shared criterion in each row.
        foreach ($response->iterateAllElements() as $googleAdsRow) {
            /** @var GoogleAdsRow $googleAdsRow */
            $sharedCriterionResourceName = $googleAdsRow->getSharedCriterion()->getResourceName();
            if ($googleAdsRow->getSharedCriterion()->getType() === CriterionType::KEYWORD) {
                printf(
                    "Shared criterion with resource name '%s' for negative keyword with text "
                    . "'%s' and match type '%s' was found.%s",
                    $sharedCriterionResourceName,
                    $googleAdsRow->getSharedCriterion()->getKeyword()->getTextUnwrapped(),
                    KeywordMatchType::name(
                        $googleAdsRow->getSharedCriterion()->getKeyword()->getMatchType()
                    ),
                    PHP_EOL
                );
            } else {
                printf(
                    "Shared criterion with resource name '%s' was found.%s",
                    $sharedCriterionResourceName,
                    PHP_EOL
                );
            }
            $criterionResourceNames[] = $sharedCriterionResourceName;
        }

        // Finally, removes the criteria.
        $sharedCriterionOperations = [];
        foreach ($criterionResourceNames as $criterionResourceName) {
            $sharedCriterionOperation = new SharedCriterionOperation();
            $sharedCriterionOperation->setRemove($criterionResourceName);
            $sharedCriterionOperations[] = $sharedCriterionOperation;
        }

        // Sends the operation in a mutate request.
        $sharedCriterionServiceClient = $googleAdsClient->getSharedCriterionServiceClient();
        $response = $sharedCriterionServiceClient->mutateSharedCriteria(
            $customerId,
            $sharedCriterionOperations
        );

        // Prints the resource name of each removed shared criterion.
        foreach ($response->getResults() as $removedSharedCriterion) {
            /** @var SharedCriterion $removedSharedCriterion */
            printf(
                "Removed shared criterion with resource name: '%s'.%s",
                $removedSharedCriterion->getResourceName(),
                PHP_EOL
            );
        }
    }
}

FindAndRemoveCriteriaFromSharedSet::main();

Python

#!/usr/bin/env python
# Copyright 2020 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Demonstrates how to find and remove shared sets, and shared set criteria."""


import argparse
import sys

from google.ads.google_ads.client import GoogleAdsClient
from google.ads.google_ads.errors import GoogleAdsException


_DEFAULT_PAGE_SIZE = 1000


def main(client, customer_id, page_size, campaign_id):
    ga_service = client.get_service('GoogleAdsService', version='v3')
    shared_criterion_service = client.get_service('SharedCriterionService',
                                                  version='v3')

    # First, retrieve all shared sets associated with the campaign.
    shared_sets_query = (
        'SELECT shared_set.id, shared_set.name FROM campaign_shared_set '
        f'WHERE campaign.id = {campaign_id}')

    try:
        shared_set_response = ga_service.search(
            customer_id, query=shared_sets_query, page_size=page_size)

        shared_set_ids = []
        for row in shared_set_response:
            shared_set = row.shared_set
            shared_set_id = str(shared_set.id.value)
            shared_set_ids.append(shared_set_id)
            print(f'Campaign shared set ID "{shared_set_id}" and name '
                  f'"{shared_set.name.value}" was found.')
    except GoogleAdsException as ex:
        print(f'Request with ID "{ex.request_id}" failed with status '
              f'"{ex.error.code().name}" and includes the following errors:')
        for error in ex.failure.errors:
            print(f'\tError with message "{error.message}".')
            if error.location:
                for field_path_element in error.location.field_path_elements:
                    print(f'\t\tOn field: {field_path_element.field_name}')
        sys.exit(1)

    # Next, retrieve shared criteria for all found shared sets.
    shared_criteria_query = (
        'SELECT shared_criterion.type, shared_criterion.keyword.text, '
        'shared_criterion.keyword.match_type, shared_set.id '
        'FROM shared_criterion WHERE shared_set.id IN '
        f'({", ".join(shared_set_ids)})')

    try:
        shared_criteria_response = ga_service.search(
            customer_id, query=shared_criteria_query, page_size=page_size)
    except GoogleAdsException as ex:
        print(f'Request with ID "{ex.request_id}" failed with status '
              f'"{ex.error.code().name}" and includes the following errors:')
        for error in ex.failure.errors:
            print(f'\tError with message "{error.message}".')
            if error.location:
                for field_path_element in error.location.field_path_elements:
                    print(f'\t\tOn field: {field_path_element.field_name}')
        sys.exit(1)

    # Use the enum type to determine the enum name from the value.
    keyword_match_type_enum = (
        client.get_type('KeywordMatchTypeEnum', version='v3').KeywordMatchType)

    criterion_ids = []
    for row in shared_criteria_response:
        shared_criterion = row.shared_criterion
        shared_criterion_resource_name = shared_criterion.resource_name
        if (shared_criterion.type ==
                client.get_type('CriterionTypeEnum', version='v3').KEYWORD):
            keyword = shared_criterion.keyword
            print('Shared criterion with resource name "%s" for negative '
                  'keyword with text "%s" and match type "%s" was found.'
                  % (shared_criterion_resource_name, keyword.text.value,
                     keyword_match_type_enum.Name(keyword.match_type)))
        criterion_ids.append(shared_criterion_resource_name)

    operations = []

    # Finally, remove the criteria.
    for criteria_id in criterion_ids:
        shared_criterion_operation = client.get_type('SharedCriterionOperation',
                                                     version='v3')
        shared_criterion_operation.remove = criteria_id
        operations.append(shared_criterion_operation)

    try:
        response = shared_criterion_service.mutate_shared_criteria(
            customer_id, operations)
    except GoogleAdsException as ex:
        print(f'Request with ID "{ex.request_id}" failed with status '
              f'"{ex.error.code().name}" and includes the following errors:')
        for error in ex.failure.errors:
            print(f'\tError with message "{error.message}".')
            if error.location:
                for field_path_element in error.location.field_path_elements:
                    print(f'\t\tOn field: {field_path_element.field_name}')
        sys.exit(1)

    for result in response.results:
        print(f'Removed shared criterion "{result.resource_name}".')


if __name__ == '__main__':
    # GoogleAdsClient will read the google-ads.yaml configuration file in the
    # home directory if none is specified.
    google_ads_client = GoogleAdsClient.load_from_storage()

    parser = argparse.ArgumentParser(
        description=('Finds shared sets, then finds and removes shared set '
                     'criteria under them.'))
    # The following argument(s) should be provided to run the example.
    parser.add_argument('-c', '--customer_id', type=str,
                        required=True, help='The Google Ads customer ID.')
    parser.add_argument('-i', '--campaign_id', type=str,
                        required=True, help='The campaign ID.')
    args = parser.parse_args()

    main(google_ads_client, args.customer_id, _DEFAULT_PAGE_SIZE,
         args.campaign_id)

Ruby

#!/usr/bin/env ruby
# Encoding: utf-8
#
# Copyright 2018 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
# This example demonstrates how to find shared sets, shared set criteria, and
# how to remove them.

require 'optparse'
require 'google/ads/google_ads'

def find_and_remove_criteria_from_shared_set(customer_id, campaign_id)
  # GoogleAdsClient will read a config file from
  # ENV['HOME']/google_ads_config.rb when called without parameters

  client = Google::Ads::GoogleAds::GoogleAdsClient.new
  ga_service = client.service.google_ads

  shared_set_ids = []
  criterion_ids = []

  # First, retrieve all shared sets associated with the campaign.
  query = <<~QUERY
    SELECT shared_set.id, shared_set.name
    FROM campaign_shared_set
    WHERE campaign.id = #{campaign_id}
  QUERY

  response = ga_service.search(customer_id, query, page_size: PAGE_SIZE)

  response.each do |row|
    shared_set = row.shared_set
    puts "Campaign shared set ID #{shared_set.id} and name '#{shared_set.name}' was found."

    shared_set_ids << shared_set.id
  end

  # Next, retrieve shared criteria for all found shared sets.
  query = <<~QUERY
    SELECT shared_criterion.type, shared_criterion.keyword.text,
        shared_criterion.keyword.match_type, shared_set.id
    FROM shared_criterion
    WHERE shared_set.id IN (#{shared_set_ids.join(',')})
  QUERY

  response = ga_service.search(customer_id, query, page_size: PAGE_SIZE)

  response.each do |row|
    sc = row.shared_criterion
    if sc.type == :KEYWORD
      puts "Shared criterion with resource name '#{sc.resource_name}' for negative keyword " +
          "with text '#{sc.keyword.text}' and match type '#{sc.keyword.match_type}' was found."
    else
      puts "Shared criterion with resource name '#{sc.resource_name}' was found."
    end

    criterion_ids << sc.resource_name
  end

  # Finally, remove the criteria.
  operations = criterion_ids.map do |criterion|
    client.operation.remove_resource.shared_criterion(criterion)
  end

  response = client.service.shared_criterion.mutate_shared_criteria(customer_id, operations)
  response.results.each do |result|
    puts "Removed shared criterion #{result.resource_name}"
  end
end

if __FILE__ == $PROGRAM_NAME
  PAGE_SIZE = 1000

  options = {}
  # The following parameter(s) should be provided to run the example. You can
  # either specify these by changing the INSERT_XXX_ID_HERE values below, or on
  # the command line.
  #
  # Parameters passed on the command line will override any parameters set in
  # code.
  #
  # Running the example with -h will print the command line usage.
  options[:customer_id] = 'INSERT_CUSTOMER_ID_HERE'
  options[:campaign_id] = 'INSERT_CAMPAIGN_ID_HERE'

  OptionParser.new do |opts|
    opts.banner = sprintf('Usage: ruby %s [options]', File.basename(__FILE__))

    opts.separator ''
    opts.separator 'Options:'

    opts.on('-C', '--customer-id CUSTOMER-ID', String, 'Customer ID') do |v|
      options[:customer_id] = v
    end

    opts.on('-c', '--campaign-id CAMPAIGN-ID', String, 'Campaign ID') do |v|
      options[:campaign_id] = v
    end

    opts.separator ''
    opts.separator 'Help:'

    opts.on_tail('-h', '--help', 'Show this message') do
      puts opts
      exit
    end
  end.parse!

  begin
    find_and_remove_criteria_from_shared_set(options.fetch(:customer_id).tr("-", ""),
        options[:campaign_id])
  rescue Google::Ads::GoogleAds::Errors::GoogleAdsError => e
    e.failure.errors.each do |error|
      STDERR.printf("Error with message: %s\n", error.message)
      if error.location
        error.location.field_path_elements.each do |field_path_element|
          STDERR.printf("\tOn field: %s\n", field_path_element.field_name)
        end
      end
      error.error_code.to_h.each do |k, v|
        next if v == :UNSPECIFIED
        STDERR.printf("\tType: %s\n\tCode: %s\n", k, v)
      end
    end
    raise
  rescue Google::Gax::RetryError => e
    STDERR.printf("Error: '%s'\n\tCause: '%s'\n\tCode: %d\n\tDetails: '%s'\n" \
        "\tRequest-Id: '%s'\n", e.message, e.cause.message, e.cause.code,
                  e.cause.details, e.cause.metadata['request-id'])
    raise
  end
end

Perl

#!/usr/bin/perl -w
#
# Copyright 2019, Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
# This example demonstrates how to find shared sets, how to find shared set
# criteria, and how to remove shared set criteria.

use strict;
use warnings;
use utf8;

use FindBin qw($Bin);
use lib "$Bin/../../lib";
use Google::Ads::GoogleAds::Client;
use Google::Ads::GoogleAds::Utils::GoogleAdsHelper;
use Google::Ads::GoogleAds::Utils::SearchGoogleAdsIterator;
use Google::Ads::GoogleAds::V3::Enums::CriterionTypeEnum qw(KEYWORD);
use
  Google::Ads::GoogleAds::V3::Services::GoogleAdsService::SearchGoogleAdsRequest;
use
  Google::Ads::GoogleAds::V3::Services::SharedCriterionService::SharedCriterionOperation;

use Getopt::Long qw(:config auto_help);
use Pod::Usage;
use Cwd qw(abs_path);

use constant PAGE_SIZE => 1000;

# The following parameter(s) should be provided to run the example. You can
# either specify these by changing the INSERT_XXX_ID_HERE values below, or on
# the command line.
#
# Parameters passed on the command line will override any parameters set in
# code.
#
# Running the example with -h will print the command line usage.
my $customer_id = "INSERT_CUSTOMER_ID_HERE";
my $campaign_id = "INSERT_CAMPAIGN_ID_HERE";

sub find_and_remove_criteria_from_shared_set {
  my ($api_client, $customer_id, $campaign_id) = @_;

  my $shared_set_ids           = [];
  my $criterion_resource_names = [];

  # First, retrieve all shared sets associated with the campaign.
  my $search_query =
    "SELECT shared_set.id, shared_set.name FROM campaign_shared_set " .
    "WHERE campaign.id = $campaign_id";

  my $search_request =
    Google::Ads::GoogleAds::V3::Services::GoogleAdsService::SearchGoogleAdsRequest
    ->new({
      customerId => $customer_id,
      query      => $search_query,
      pageSize   => PAGE_SIZE
    });

  my $google_ads_service = $api_client->GoogleAdsService();

  my $iterator = Google::Ads::GoogleAds::Utils::SearchGoogleAdsIterator->new({
    service => $google_ads_service,
    request => $search_request
  });

  # Iterate over all rows in all pages and print the requested field values for
  # the shared set in each row.
  while ($iterator->has_next) {
    my $google_ads_row = $iterator->next;
    printf "Campaign shared set with ID %d and name '%s' was found.\n",
      $google_ads_row->{sharedSet}{id}, $google_ads_row->{sharedSet}{name};

    push @$shared_set_ids, $google_ads_row->{sharedSet}{id};
  }

  # Return 0 when no shared set was found for this campaign.
  if (scalar @$shared_set_ids == 0) {
    warn "Campaign shared set was not found for campaign $campaign_id.\n";
    return 0;
  }

  # Next, retrieve shared criteria for all found shared sets.
  $search_query =
    sprintf "SELECT shared_criterion.type, shared_criterion.keyword.text, " .
    "shared_criterion.keyword.match_type, shared_set.id " .
    "FROM shared_criterion WHERE shared_set.id IN (%s)",
    join(',', @$shared_set_ids);

  $search_request =
    Google::Ads::GoogleAds::V3::Services::GoogleAdsService::SearchGoogleAdsRequest
    ->new({
      customerId => $customer_id,
      query      => $search_query,
      pageSize   => PAGE_SIZE
    });

  $iterator = Google::Ads::GoogleAds::Utils::SearchGoogleAdsIterator->new({
    service => $google_ads_service,
    request => $search_request
  });

  # Iterate over all rows in all pages and print the requested field values for
  # the shared criterion in each row.
  while ($iterator->has_next) {
    my $google_ads_row = $iterator->next;

    my $shared_criterion_resource_name =
      $google_ads_row->{sharedCriterion}{resourceName};

    if ($google_ads_row->{sharedCriterion}{type} eq KEYWORD) {
      printf "Shared criterion with resource name '%s' for negative keyword " .
        "with text '%s' and match type '%s' was found.\n",
        $shared_criterion_resource_name,
        $google_ads_row->{sharedCriterion}{keyword}{text},
        $google_ads_row->{sharedCriterion}{keyword}{matchType};
    } else {
      printf "Shared criterion with resource name '%s' was found.\n",
        $shared_criterion_resource_name;
    }

    push @$criterion_resource_names, $shared_criterion_resource_name;
  }

  # Finally, remove the criteria.
  my $shared_criterion_operations = [];
  foreach my $criterion_resource_name (@$criterion_resource_names) {
    push @$shared_criterion_operations,
      Google::Ads::GoogleAds::V3::Services::SharedCriterionService::SharedCriterionOperation
      ->new({
        remove => $criterion_resource_name
      });
  }

  # Send the operations in mutate request.
  my $shared_criterion_response =
    $api_client->SharedCriterionService()->mutate({
      customerId => $customer_id,
      operations => $shared_criterion_operations
    });

  foreach my $result (@{$shared_criterion_response->{results}}) {
    printf "Removed shared criterion with resource name: '%s'.\n",
      $result->{resourceName};
  }

  return 1;
}

# Don't run the example if the file is being included.
if (abs_path($0) ne abs_path(__FILE__)) {
  return 1;
}

# Get Google Ads Client, credentials will be read from ~/googleads.properties.
my $api_client = Google::Ads::GoogleAds::Client->new({version => "V3"});

# By default examples are set to die on any server returned fault.
$api_client->set_die_on_faults(1);

# Parameters passed on the command line will override any parameters set in code.
GetOptions("customer_id=s" => \$customer_id, "campaign_id=i" => \$campaign_id);

# Print the help message if the parameters are not initialized in the code nor
# in the command line.
pod2usage(2) if not check_params($customer_id, $campaign_id);

# Call the example.
find_and_remove_criteria_from_shared_set($api_client, $customer_id =~ s/-//gr,
  $campaign_id);

=pod

=head1 NAME

find_and_remove_criteria_from_shared_set

=head1 DESCRIPTION

This example demonstrates how to find shared sets, how to find shared set criteria,
and how to remove shared set criteria.

=head1 SYNOPSIS

find_and_remove_criteria_from_shared_set.pl [options]

    -help                       Show the help message.
    -customer_id                The Google Ads customer ID.
    -campaign_id                The campaign ID.

=cut