方法：reports.batchGet

{
  "viewId": string,
  "dateRanges": [
    {
      object(DateRange)
    }
  ],
  "samplingLevel": enum(Sampling),
  "dimensions": [
    {
      object(Dimension)
    }
  ],
  "dimensionFilterClauses": [
    {
      object(DimensionFilterClause)
    }
  ],
  "metrics": [
    {
      object(Metric)
    }
  ],
  "metricFilterClauses": [
    {
      object(MetricFilterClause)
    }
  ],
  "filtersExpression": string,
  "orderBys": [
    {
      object(OrderBy)
    }
  ],
  "segments": [
    {
      object(Segment)
    }
  ],
  "pivots": [
    {
      object(Pivot)
    }
  ],
  "cohortGroup": {
    object(CohortGroup)
  },
  "pageToken": string,
  "pageSize": number,
  "includeEmptyRows": boolean,
  "hideTotals": boolean,
  "hideValueRanges": boolean,
}

{
  "startDate": string,
  "endDate": string,
}

{
  "name": string,
  "histogramBuckets": [
    string
  ],
}

{
  "operator": enum(FilterLogicalOperator),
  "filters": [
    {
      object(DimensionFilter)
    }
  ],
}

{
  "dimensionName": string,
  "not": boolean,
  "operator": enum(Operator),
  "expressions": [
    string
  ],
  "caseSensitive": boolean,
}

整数比较过滤条件。对这些不区分大小写，且假定表达式是代表整数的字符串。失败的情况：

• 如果表达式不是有效的 int64，客户端应该会出现错误。
• 输入维度如果不是有效的 int64 值，不会匹配过滤条件。

使用该选项可以指定这样一类维度过滤条件：其表达式可从所选的一列值中提取任何值。对于对每一个响应行都采用了 OR 连接的多个完全匹配维度过滤条件，这有助于避免对其进行求值。例如：

expressions: ["A", "B", "C"]

其维度值为 A、B 或 C 的任何响应行匹配此 DimensionFilter。

{
  "expression": string,
  "alias": string,
  "formattingType": enum(MetricType),
}

{
  "operator": enum(FilterLogicalOperator),
  "filters": [
    {
      object(MetricFilter)
    }
  ],
}

{
  "metricName": string,
  "not": boolean,
  "operator": enum(Operator),
  "comparisonValue": string,
}

{
  "fieldName": string,
  "orderType": enum(OrderType),
  "sortOrder": enum(SortOrder),
}

{

  // Union field dynamicOrById can be only one of the following:
  "dynamicSegment": {
    object(DynamicSegment)
  },
  "segmentId": string,
  // End of list of possible types for union field dynamicOrById.
}

{
  "name": string,
  "userSegment": {
    object(SegmentDefinition)
  },
  "sessionSegment": {
    object(SegmentDefinition)
  },
}

{
  "segmentFilters": [
    {
      object(SegmentFilter)
    }
  ],
}

{
  "not": boolean,

  // Union field simpleOrSequence can be only one of the following:
  "simpleSegment": {
    object(SimpleSegment)
  },
  "sequenceSegment": {
    object(SequenceSegment)
  },
  // End of list of possible types for union field simpleOrSequence.
}

{
  "orFiltersForSegment": [
    {
      object(OrFiltersForSegment)
    }
  ],
}

{
  "segmentFilterClauses": [
    {
      object(SegmentFilterClause)
    }
  ],
}

{
  "not": boolean,

  // Union field dimensionOrMetricFilter can be only one of the following:
  "dimensionFilter": {
    object(SegmentDimensionFilter)
  },
  "metricFilter": {
    object(SegmentMetricFilter)
  },
  // End of list of possible types for union field dimensionOrMetricFilter.
}

{
  "dimensionName": string,
  "operator": enum(Operator),
  "caseSensitive": boolean,
  "expressions": [
    string
  ],
  "minComparisonValue": string,
  "maxComparisonValue": string,
}

使用该选项可以指定这样一类维度过滤条件：其表达式可从所选的一列值中提取任何值。对于对每一个响应行都采用了 OR 连接的多个完全匹配维度过滤条件，这有助于避免对其进行求值。例如：

expressions: ["A", "B", "C"]

其维度值为 A、B 或 C 的任何响应行匹配此 DimensionFilter。

整数比较过滤条件。对这些不区分大小写，且假定表达式是代表整数的字符串。失败的情况：

• 如果表达式不是有效的 int64，客户端应该会出现错误。
• 输入维度如果不是有效的 int64 值，不会匹配过滤条件。

检查该维度从数值上是否小于匹配表达式。

{
  "scope": enum(Scope),
  "metricName": string,
  "operator": enum(Operator),
  "comparisonValue": string,
  "maxComparisonValue": string,
}

{
  "segmentSequenceSteps": [
    {
      object(SegmentSequenceStep)
    }
  ],
  "firstStepShouldMatchFirstHit": boolean,
}

{
  "orFiltersForSegment": [
    {
      object(OrFiltersForSegment)
    }
  ],
  "matchType": enum(MatchType),
}

{
  "dimensions": [
    {
      object(Dimension)
    }
  ],
  "dimensionFilterClauses": [
    {
      object(DimensionFilterClause)
    }
  ],
  "metrics": [
    {
      object(Metric)
    }
  ],
  "startGroup": number,
  "maxGroupCount": number,
}

{
  "cohorts": [
    {
      object(Cohort)
    }
  ],
  "lifetimeValue": boolean,
}

{
  "name": string,
  "type": enum(Type),
  "dateRange": {
    object(DateRange)
  },
}

{
  "columnHeader": {
    object(ColumnHeader)
  },
  "data": {
    object(ReportData)
  },
  "nextPageToken": string,
}

{
  "dimensions": [
    string
  ],
  "metricHeader": {
    object(MetricHeader)
  },
}

{
  "metricHeaderEntries": [
    {
      object(MetricHeaderEntry)
    }
  ],
  "pivotHeaders": [
    {
      object(PivotHeader)
    }
  ],
}

{
  "name": string,
  "type": enum(MetricType),
}

{
  "pivotHeaderEntries": [
    {
      object(PivotHeaderEntry)
    }
  ],
  "totalPivotGroupsCount": number,
}

{
  "dimensionNames": [
    string
  ],
  "dimensionValues": [
    string
  ],
  "metric": {
    object(MetricHeaderEntry)
  },
}

{
  "rows": [
    {
      object(ReportRow)
    }
  ],
  "totals": [
    {
      object(DateRangeValues)
    }
  ],
  "rowCount": number,
  "minimums": [
    {
      object(DateRangeValues)
    }
  ],
  "maximums": [
    {
      object(DateRangeValues)
    }
  ],
  "samplesReadCounts": [
    string
  ],
  "samplingSpaceSizes": [
    string
  ],
  "isDataGolden": boolean,
}

{
  "dimensions": [
    string
  ],
  "metrics": [
    {
      object(DateRangeValues)
    }
  ],
}

{
  "values": [
    string
  ],
  "pivotValueRegions": [
    {
      object(PivotValueRegion)
    }
  ],
}

{
  "values": [
    string
  ],
}