Author Archives:

Introducing Partial Structured Data File Upload

Today we’re introducing Partial Structured Data File Upload to Display & Video 360! This new capability allows you to upload Line Item Structured Data Files (SDFs) that only include certain subsets of columns.

Standard Line Item Structured Data Files require the inclusion of over 120 columns to support a wide breadth of Display & Video 360 settings. Partial SDFs let you only include settings that you want to update, making the files smaller and easier to manage. The reduced size of partial SDFs enables:

  • A higher overall resource limit for a single file.
  • Faster file uploads and resource updates.
  • Reduced risk of unintended changes to other line item settings.

Partial SDFs are uploaded using the Display & Video 360 UI, the same as you would upload a standard SDF. No additional enrollment or configuration is required. See the Partial SDF Upload guide to learn which SDF columns are currently supported and download sample files to get started.

If you have any questions or want to discuss this post, please reach out to us on our “Google Advertising and Measurement Community” Discord server.

- Trevor Mulchay, Display & Video 360 API Team

This entry was posted in Uncategorized on by .

Construct with Collaborators, Call with Work

This article was adapted from a Google Tech on the Toilet (TotT) episode. You can download a printer-friendly version of this TotT episode and post it in your office.

By Shahar Roth 

Classes require various objects and parameters to function. The "Construct with Collaborators, Call with Work" guideline can help you construct effective inputs: 

  • Use the constructor for collaborators—the dependencies that establish the object’s identity. Collaborators stay with the object for its lifetime to enable it to fulfill its ongoing duties.

  • Pass work—the parameters that change with each interaction—to methods. Unique to each call, these inputs provide the specific data needed for an operation such as a file path or database query.

Consider a ReportGenerator that needs a database, a formatter, and a date range to generate a report. The database and formatter, as collaborators, are injected via the constructor, while dateRange, which varies per report generation, is passed as a method parameter to the generate method:

class ReportGenerator {

  private final Database database;

  private final Formatter formatter;


  // database and formatter are passed as collaborators.

  ReportGenerator(Database database, Formatter formatter) {

    this.database = database;

    this.formatter = formatter;

  }


  // dateRange is passed as a parameter.

  Report generate(Range<Instant> dateRange) {

    return formatter.format(database.getRecords(dateRange));

  }

}

A single ReportGenerator object can generate multiple reports with different date ranges:

ReportGenerator generator = new ReportGenerator(database, formatter);

Report report1 = generator.generate(dateRange1);

Report report2 = generator.generate(dateRange2);

Following the "Construct with Collaborators, Call with Work" guideline promotes:

  • Reusability: Enables instances to be used for multiple, distinct operations.

  • Testability: Separates dependency setup from business logic.

  • Cleaner code: Hides implementation dependencies from the object’s users.

  • Predictable behavior: Locks in dependencies at creation time.

Note that the definition of "collaborator" versus "work" depends on the object's identity. For example, a RequestMessage could be a collaborator for a RequestHandler if the handler operates on a single request, or work if the handler processes different requests with each method call.



This entry was posted in Uncategorized on by .