共有設定から条件を検索、削除

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.v17.enums.CriterionTypeEnum.CriterionType;
import com.google.ads.googleads.v17.errors.GoogleAdsError;
import com.google.ads.googleads.v17.errors.GoogleAdsException;
import com.google.ads.googleads.v17.resources.SharedCriterion;
import com.google.ads.googleads.v17.resources.SharedSet;
import com.google.ads.googleads.v17.services.GoogleAdsRow;
import com.google.ads.googleads.v17.services.GoogleAdsServiceClient;
import com.google.ads.googleads.v17.services.GoogleAdsServiceClient.SearchPagedResponse;
import com.google.ads.googleads.v17.services.MutateSharedCriteriaResponse;
import com.google.ads.googleads.v17.services.MutateSharedCriterionResult;
import com.google.ads.googleads.v17.services.SearchGoogleAdsRequest;
import com.google.ads.googleads.v17.services.SharedCriterionOperation;
import com.google.ads.googleads.v17.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 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 = null;
    try {
      googleAdsClient = GoogleAdsClient.newBuilder().fromPropertiesFile().build();
    } catch (FileNotFoundException fnfe) {
      System.err.printf(
          "Failed to load GoogleAdsClient configuration from file. Exception: %s%n", fnfe);
      System.exit(1);
    } catch (IOException ioe) {
      System.err.printf("Failed to create GoogleAdsClient. Exception: %s%n", ioe);
      System.exit(1);
    }

    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);
      }
      System.exit(1);
    }
  }

  /**
   * 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))
              .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(), sharedSet.getName());
        sharedSetIds.add(sharedSet.getId());
      }
    }

    // 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))
              .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 CommandLine;
using Google.Ads.Gax.Examples;
using Google.Ads.GoogleAds.Lib;
using Google.Ads.GoogleAds.V17.Errors;
using Google.Ads.GoogleAds.V17.Resources;
using Google.Ads.GoogleAds.V17.Services;
using Google.Api.Gax;
using System;
using System.Collections.Generic;
using static Google.Ads.GoogleAds.V17.Enums.CriterionTypeEnum.Types;

namespace Google.Ads.GoogleAds.Examples.V17
{
    /// <summary>
    /// This code example demonstrates how to find shared sets, shared set criteria, and
    /// how to remove them.
    /// </summary>
    public class FindAndRemoveCriteriaFromSharedSet : ExampleBase
    {
        /// <summary>
        /// Command line options for running the <see cref="FindAndRemoveCriteriaFromSharedSet"/>
        /// example.
        /// </summary>
        public class Options : OptionsBase
        {
            /// <summary>
            /// The Google Ads customer ID for which the call is made.
            /// </summary>
            [Option("customerId", Required = true, HelpText =
                "The Google Ads customer ID for which the call is made.")]
            public long CustomerId { get; set; }

            /// <summary>
            /// The ID of the campaign for which shared criterion is updated.
            /// </summary>
            [Option("campaignId", Required = true, HelpText =
                "The ID of the campaign for which shared criterion is updated.")]
            public long CampaignId { get; set; }
        }

        /// <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)
        {
            Options options = ExampleUtilities.ParseCommandLine<Options>(args);

            FindAndRemoveCriteriaFromSharedSet codeExample =
                new FindAndRemoveCriteriaFromSharedSet();
            Console.WriteLine(codeExample.Description);
            codeExample.Run(new GoogleAdsClient(), options.CustomerId, options.CampaignId);
        }

        /// <summary>
        /// Returns a description about the code example.
        /// </summary>
        public override string Description =>
            "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.V17.SharedCriterionService);

                GoogleAdsServiceClient googleAdsService = client.GetService(
                    Services.V17.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\V17\GoogleAdsClient;
use Google\Ads\GoogleAds\Lib\V17\GoogleAdsClientBuilder;
use Google\Ads\GoogleAds\Lib\V17\GoogleAdsException;
use Google\Ads\GoogleAds\Lib\OAuth2TokenBuilder;
use Google\Ads\GoogleAds\V17\Enums\CriterionTypeEnum\CriterionType;
use Google\Ads\GoogleAds\V17\Enums\KeywordMatchTypeEnum\KeywordMatchType;
use Google\Ads\GoogleAds\V17\Errors\GoogleAdsError;
use Google\Ads\GoogleAds\V17\Resources\SharedCriterion;
use Google\Ads\GoogleAds\V17\Services\GoogleAdsRow;
use Google\Ads\GoogleAds\V17\Services\MutateSharedCriteriaRequest;
use Google\Ads\GoogleAds\V17\Services\SearchGoogleAdsRequest;
use Google\Ads\GoogleAds\V17\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';

    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)
            // We set this value to true to show how to use GAPIC v2 source code. You can remove the
            // below line if you wish to use the old-style source code. Note that in that case, you
            // probably need to modify some parts of the code below to make it work.
            // For more information, see
            // https://developers.devsite.corp.google.com/google-ads/api/docs/client-libs/php/gapic.
            ->usingGapicV2Source(true)
            ->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.
        $response =
            $googleAdsServiceClient->search(SearchGoogleAdsRequest::build($customerId, $query));

        // 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()->getId(),
                $googleAdsRow->getSharedSet()->getName(),
                PHP_EOL
            );
            $sharedSetIds[] = $googleAdsRow->getSharedSet()->getId();
        }

        // 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.
        $response =
            $googleAdsServiceClient->search(SearchGoogleAdsRequest::build($customerId, $query));

        // 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()->getText(),
                    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(
            MutateSharedCriteriaRequest::build($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.googleads.client import GoogleAdsClient
from google.ads.googleads.errors import GoogleAdsException


def main(client, customer_id, campaign_id):
    ga_service = client.get_service("GoogleAdsService")
    shared_criterion_service = client.get_service("SharedCriterionService")

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

    try:
        shared_set_search_request = client.get_type("SearchGoogleAdsRequest")
        shared_set_search_request.customer_id = customer_id
        shared_set_search_request.query = shared_sets_query

        shared_set_response = ga_service.search(
            request=shared_set_search_request
        )

        shared_set_ids = []
        for row in shared_set_response:
            shared_set = row.shared_set
            shared_set_ids.append(str(shared_set.id))
            print(
                f'Campaign shared set ID "{shared_set.id}" and name '
                f'"{shared_set.name}" was found.'
            )
    except GoogleAdsException as ex:
        handle_googleads_exception(ex)

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

    try:
        shared_criteria_search_request = client.get_type(
            "SearchGoogleAdsRequest"
        )
        shared_criteria_search_request.customer_id = customer_id
        shared_criteria_search_request.query = shared_criteria_query

        shared_criteria_response = ga_service.search(
            request=shared_criteria_search_request
        )
    except GoogleAdsException as ex:
        handle_googleads_exception(ex)

    criterion_type_enum = client.enums.CriterionTypeEnum
    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_ == criterion_type_enum.KEYWORD:
            keyword = shared_criterion.keyword
            print(
                "Shared criterion with resource name "
                f'"{shared_criterion_resource_name}" for negative keyword '
                f'with text "{keyword.text}" and match type '
                f'"{keyword.match_type.name}" was found.'
            )

        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")
        shared_criterion_operation.remove = criteria_id
        operations.append(shared_criterion_operation)

    try:
        response = shared_criterion_service.mutate_shared_criteria(
            customer_id=customer_id, operations=operations
        )

        for result in response.results:
            print(f'Removed shared criterion "{result.resource_name}".')
    except GoogleAdsException as ex:
        handle_googleads_exception(ex)


def handle_googleads_exception(exception):
    print(
        f'Request with ID "{exception.request_id}" failed with status '
        f'"{exception.error.code().name}" and includes the following errors:'
    )
    for error in exception.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)


if __name__ == "__main__":
    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()

    # GoogleAdsClient will read the google-ads.yaml configuration file in the
    # home directory if none is specified.
    googleads_client = GoogleAdsClient.load_from_storage(version="v17")

    main(googleads_client, args.customer_id, 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: customer_id,
    query: 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: customer_id,
    query: 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: customer_id,
    operations: 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
  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::V17::Enums::CriterionTypeEnum qw(KEYWORD);
use
  Google::Ads::GoogleAds::V17::Services::GoogleAdsService::SearchGoogleAdsRequest;
use
  Google::Ads::GoogleAds::V17::Services::SharedCriterionService::SharedCriterionOperation;

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

# 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::V17::Services::GoogleAdsService::SearchGoogleAdsRequest
    ->new({
      customerId => $customer_id,
      query      => $search_query
    });

  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::V17::Services::GoogleAdsService::SearchGoogleAdsRequest
    ->new({
      customerId => $customer_id,
      query      => $search_query
    });

  $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::V17::Services::SharedCriterionService::SharedCriterionOperation
      ->new({
        remove => $criterion_resource_name
      });
  }

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

  foreach my $result (@{$shared_criteria_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();

# 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