honeycombio 0.31.0, Mar 7 25

honeycombio 0.31.0 published on Friday, Mar 7, 2025 by honeycombio

honeycombio/terraform-provider-honeycombio

honeycombio.getQuerySpecification

Explore with Pulumi AI

honeycombio 0.31.0 published on Friday, Mar 7, 2025 by honeycombio

honeycombio/terraform-provider-honeycombio

# Data Source: honeycombio.getQuerySpecification

Generates a Query Specification in JSON format for use with resources that expect a JSON-formatted Query Specification like honeycombio.Query.

Using this data source to generate query specifications is optional. It is also valid to use literal JSON strings in your configuration or to use the file interpolation function to read a raw JSON query specification from a file.

Example Usage

import * as pulumi from "@pulumi/pulumi";
import * as honeycombio from "@pulumi/honeycombio";

const example = honeycombio.getQuerySpecification({
    calculations: [{
        op: "AVG",
        column: "duration_ms",
    }],
    filters: [
        {
            column: "trace.parent_id",
            op: "does-not-exist",
        },
        {
            column: "app.tenant",
            op: "=",
            value: "ThatSpecialTenant",
        },
    ],
    filterCombination: "AND",
    breakdowns: ["app.tenant"],
    timeRange: 28800,
});
export const jsonQuery = example.then(example => example.json);

import pulumi
import pulumi_honeycombio as honeycombio

example = honeycombio.get_query_specification(calculations=[{
        "op": "AVG",
        "column": "duration_ms",
    }],
    filters=[
        {
            "column": "trace.parent_id",
            "op": "does-not-exist",
        },
        {
            "column": "app.tenant",
            "op": "=",
            "value": "ThatSpecialTenant",
        },
    ],
    filter_combination="AND",
    breakdowns=["app.tenant"],
    time_range=28800)
pulumi.export("jsonQuery", example.json)

package main

import (
	"github.com/pulumi/pulumi-terraform-provider/sdks/go/honeycombio/honeycombio"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		example, err := honeycombio.GetQuerySpecification(ctx, &honeycombio.GetQuerySpecificationArgs{
			Calculations: []honeycombio.GetQuerySpecificationCalculation{
				{
					Op:     "AVG",
					Column: pulumi.StringRef("duration_ms"),
				},
			},
			Filters: []honeycombio.GetQuerySpecificationFilter{
				{
					Column: "trace.parent_id",
					Op:     "does-not-exist",
				},
				{
					Column: "app.tenant",
					Op:     "=",
					Value:  pulumi.StringRef("ThatSpecialTenant"),
				},
			},
			FilterCombination: pulumi.StringRef("AND"),
			Breakdowns: []string{
				"app.tenant",
			},
			TimeRange: pulumi.Float64Ref(28800),
		}, nil)
		if err != nil {
			return err
		}
		ctx.Export("jsonQuery", example.Json)
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Honeycombio = Pulumi.Honeycombio;

return await Deployment.RunAsync(() => 
{
    var example = Honeycombio.GetQuerySpecification.Invoke(new()
    {
        Calculations = new[]
        {
            new Honeycombio.Inputs.GetQuerySpecificationCalculationInputArgs
            {
                Op = "AVG",
                Column = "duration_ms",
            },
        },
        Filters = new[]
        {
            new Honeycombio.Inputs.GetQuerySpecificationFilterInputArgs
            {
                Column = "trace.parent_id",
                Op = "does-not-exist",
            },
            new Honeycombio.Inputs.GetQuerySpecificationFilterInputArgs
            {
                Column = "app.tenant",
                Op = "=",
                Value = "ThatSpecialTenant",
            },
        },
        FilterCombination = "AND",
        Breakdowns = new[]
        {
            "app.tenant",
        },
        TimeRange = 28800,
    });

    return new Dictionary<string, object?>
    {
        ["jsonQuery"] = example.Apply(getQuerySpecificationResult => getQuerySpecificationResult.Json),
    };
});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.honeycombio.HoneycombioFunctions;
import com.pulumi.honeycombio.inputs.GetQuerySpecificationArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        final var example = HoneycombioFunctions.getQuerySpecification(GetQuerySpecificationArgs.builder()
            .calculations(GetQuerySpecificationCalculationArgs.builder()
                .op("AVG")
                .column("duration_ms")
                .build())
            .filters(            
                GetQuerySpecificationFilterArgs.builder()
                    .column("trace.parent_id")
                    .op("does-not-exist")
                    .build(),
                GetQuerySpecificationFilterArgs.builder()
                    .column("app.tenant")
                    .op("=")
                    .value("ThatSpecialTenant")
                    .build())
            .filterCombination("AND")
            .breakdowns("app.tenant")
            .timeRange(28800)
            .build());

        ctx.export("jsonQuery", example.applyValue(getQuerySpecificationResult -> getQuerySpecificationResult.json()));
    }
}

variables:
  example:
    fn::invoke:
      function: honeycombio:getQuerySpecification
      arguments:
        calculations:
          - op: AVG
            column: duration_ms
        filters:
          - column: trace.parent_id
            op: does-not-exist
          - column: app.tenant
            op: =
            value: ThatSpecialTenant
        filterCombination: AND
        breakdowns:
          - app.tenant
        timeRange: 28800
outputs:
  jsonQuery: ${example.json}

Using getQuerySpecification

Two invocation forms are available. The direct form accepts plain arguments and either blocks until the result value is available, or returns a Promise-wrapped result. The output form accepts Input-wrapped arguments and returns an Output-wrapped result.

function getQuerySpecification(args: GetQuerySpecificationArgs, opts?: InvokeOptions): Promise<GetQuerySpecificationResult>
function getQuerySpecificationOutput(args: GetQuerySpecificationOutputArgs, opts?: InvokeOptions): Output<GetQuerySpecificationResult>

def get_query_specification(breakdowns: Optional[Sequence[str]] = None,
                            calculations: Optional[Sequence[GetQuerySpecificationCalculation]] = None,
                            end_time: Optional[float] = None,
                            filter_combination: Optional[str] = None,
                            filters: Optional[Sequence[GetQuerySpecificationFilter]] = None,
                            granularity: Optional[float] = None,
                            havings: Optional[Sequence[GetQuerySpecificationHaving]] = None,
                            limit: Optional[float] = None,
                            orders: Optional[Sequence[GetQuerySpecificationOrder]] = None,
                            start_time: Optional[float] = None,
                            time_range: Optional[float] = None,
                            opts: Optional[InvokeOptions] = None) -> GetQuerySpecificationResult
def get_query_specification_output(breakdowns: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                            calculations: Optional[pulumi.Input[Sequence[pulumi.Input[GetQuerySpecificationCalculationArgs]]]] = None,
                            end_time: Optional[pulumi.Input[float]] = None,
                            filter_combination: Optional[pulumi.Input[str]] = None,
                            filters: Optional[pulumi.Input[Sequence[pulumi.Input[GetQuerySpecificationFilterArgs]]]] = None,
                            granularity: Optional[pulumi.Input[float]] = None,
                            havings: Optional[pulumi.Input[Sequence[pulumi.Input[GetQuerySpecificationHavingArgs]]]] = None,
                            limit: Optional[pulumi.Input[float]] = None,
                            orders: Optional[pulumi.Input[Sequence[pulumi.Input[GetQuerySpecificationOrderArgs]]]] = None,
                            start_time: Optional[pulumi.Input[float]] = None,
                            time_range: Optional[pulumi.Input[float]] = None,
                            opts: Optional[InvokeOptions] = None) -> Output[GetQuerySpecificationResult]

func GetQuerySpecification(ctx *Context, args *GetQuerySpecificationArgs, opts ...InvokeOption) (*GetQuerySpecificationResult, error)
func GetQuerySpecificationOutput(ctx *Context, args *GetQuerySpecificationOutputArgs, opts ...InvokeOption) GetQuerySpecificationResultOutput

> Note: This function is named GetQuerySpecification in the Go SDK.

public static class GetQuerySpecification 
{
    public static Task<GetQuerySpecificationResult> InvokeAsync(GetQuerySpecificationArgs args, InvokeOptions? opts = null)
    public static Output<GetQuerySpecificationResult> Invoke(GetQuerySpecificationInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetQuerySpecificationResult> getQuerySpecification(GetQuerySpecificationArgs args, InvokeOptions options)
public static Output<GetQuerySpecificationResult> getQuerySpecification(GetQuerySpecificationArgs args, InvokeOptions options)

fn::invoke:
  function: honeycombio:index/getQuerySpecification:getQuerySpecification
  arguments:
    # arguments dictionary

The following arguments are supported:

Breakdowns List<string>: A list of fields to group by.
Calculations List<GetQuerySpecificationCalculation>: Zero or more configuration blocks (described below) with the calculations that should be displayed. If no calculations are specified, COUNT will be used.
EndTime double: The absolute end time of the query in Unix Time (= seconds since epoch).
FilterCombination string: How to combine multiple filters, either AND (default) or OR.
Filters List<GetQuerySpecificationFilter>: Zero or more configuration blocks (described below) with the filters that should be applied.
Granularity double: The time resolution of the query’s graph, in seconds. Valid values must be in between the query’s time range /10 at maximum, and /1000 at minimum.
NOTE It is not allowed to specify all three of time_range, start_time and end_time. For more details about specifying time windows, check Query specification: A caveat on time.
Havings List<GetQuerySpecificationHaving>: Zero or more filters used to restrict returned groups in the query result.
Limit double: The maximum number of query results, must be between 1 and 1000.
Orders List<GetQuerySpecificationOrder>: Zero or more configuration blocks (described below) describing how to order the query results. Each term must appear in either calculation or breakdowns.
StartTime double: The absolute start time of the query in Unix Time (= seconds since epoch).
TimeRange double: The time range of the query in seconds, defaults to 7200 (two hours).

Breakdowns []string: A list of fields to group by.
Calculations []GetQuerySpecificationCalculation: Zero or more configuration blocks (described below) with the calculations that should be displayed. If no calculations are specified, COUNT will be used.
EndTime float64: The absolute end time of the query in Unix Time (= seconds since epoch).
FilterCombination string: How to combine multiple filters, either AND (default) or OR.
Filters []GetQuerySpecificationFilter: Zero or more configuration blocks (described below) with the filters that should be applied.
Granularity float64: The time resolution of the query’s graph, in seconds. Valid values must be in between the query’s time range /10 at maximum, and /1000 at minimum.
NOTE It is not allowed to specify all three of time_range, start_time and end_time. For more details about specifying time windows, check Query specification: A caveat on time.
Havings []GetQuerySpecificationHaving: Zero or more filters used to restrict returned groups in the query result.
Limit float64: The maximum number of query results, must be between 1 and 1000.
Orders []GetQuerySpecificationOrder: Zero or more configuration blocks (described below) describing how to order the query results. Each term must appear in either calculation or breakdowns.
StartTime float64: The absolute start time of the query in Unix Time (= seconds since epoch).
TimeRange float64: The time range of the query in seconds, defaults to 7200 (two hours).

breakdowns List<String>: A list of fields to group by.
calculations List<GetQuerySpecificationCalculation>: Zero or more configuration blocks (described below) with the calculations that should be displayed. If no calculations are specified, COUNT will be used.
endTime Double: The absolute end time of the query in Unix Time (= seconds since epoch).
filterCombination String: How to combine multiple filters, either AND (default) or OR.
filters List<GetQuerySpecificationFilter>: Zero or more configuration blocks (described below) with the filters that should be applied.
granularity Double: The time resolution of the query’s graph, in seconds. Valid values must be in between the query’s time range /10 at maximum, and /1000 at minimum.
NOTE It is not allowed to specify all three of time_range, start_time and end_time. For more details about specifying time windows, check Query specification: A caveat on time.
havings List<GetQuerySpecificationHaving>: Zero or more filters used to restrict returned groups in the query result.
limit Double: The maximum number of query results, must be between 1 and 1000.
orders List<GetQuerySpecificationOrder>: Zero or more configuration blocks (described below) describing how to order the query results. Each term must appear in either calculation or breakdowns.
startTime Double: The absolute start time of the query in Unix Time (= seconds since epoch).
timeRange Double: The time range of the query in seconds, defaults to 7200 (two hours).

breakdowns string[]: A list of fields to group by.
calculations GetQuerySpecificationCalculation[]: Zero or more configuration blocks (described below) with the calculations that should be displayed. If no calculations are specified, COUNT will be used.
endTime number: The absolute end time of the query in Unix Time (= seconds since epoch).
filterCombination string: How to combine multiple filters, either AND (default) or OR.
filters GetQuerySpecificationFilter[]: Zero or more configuration blocks (described below) with the filters that should be applied.
granularity number: The time resolution of the query’s graph, in seconds. Valid values must be in between the query’s time range /10 at maximum, and /1000 at minimum.
NOTE It is not allowed to specify all three of time_range, start_time and end_time. For more details about specifying time windows, check Query specification: A caveat on time.
havings GetQuerySpecificationHaving[]: Zero or more filters used to restrict returned groups in the query result.
limit number: The maximum number of query results, must be between 1 and 1000.
orders GetQuerySpecificationOrder[]: Zero or more configuration blocks (described below) describing how to order the query results. Each term must appear in either calculation or breakdowns.
startTime number: The absolute start time of the query in Unix Time (= seconds since epoch).
timeRange number: The time range of the query in seconds, defaults to 7200 (two hours).

breakdowns Sequence[str]: A list of fields to group by.
calculations Sequence[GetQuerySpecificationCalculation]: Zero or more configuration blocks (described below) with the calculations that should be displayed. If no calculations are specified, COUNT will be used.
end_time float: The absolute end time of the query in Unix Time (= seconds since epoch).
filter_combination str: How to combine multiple filters, either AND (default) or OR.
filters Sequence[GetQuerySpecificationFilter]: Zero or more configuration blocks (described below) with the filters that should be applied.
granularity float: The time resolution of the query’s graph, in seconds. Valid values must be in between the query’s time range /10 at maximum, and /1000 at minimum.
NOTE It is not allowed to specify all three of time_range, start_time and end_time. For more details about specifying time windows, check Query specification: A caveat on time.
havings Sequence[GetQuerySpecificationHaving]: Zero or more filters used to restrict returned groups in the query result.
limit float: The maximum number of query results, must be between 1 and 1000.
orders Sequence[GetQuerySpecificationOrder]: Zero or more configuration blocks (described below) describing how to order the query results. Each term must appear in either calculation or breakdowns.
start_time float: The absolute start time of the query in Unix Time (= seconds since epoch).
time_range float: The time range of the query in seconds, defaults to 7200 (two hours).

breakdowns List<String>: A list of fields to group by.
calculations List<Property Map>: Zero or more configuration blocks (described below) with the calculations that should be displayed. If no calculations are specified, COUNT will be used.
endTime Number: The absolute end time of the query in Unix Time (= seconds since epoch).
filterCombination String: How to combine multiple filters, either AND (default) or OR.
filters List<Property Map>: Zero or more configuration blocks (described below) with the filters that should be applied.
granularity Number: The time resolution of the query’s graph, in seconds. Valid values must be in between the query’s time range /10 at maximum, and /1000 at minimum.
NOTE It is not allowed to specify all three of time_range, start_time and end_time. For more details about specifying time windows, check Query specification: A caveat on time.
havings List<Property Map>: Zero or more filters used to restrict returned groups in the query result.
limit Number: The maximum number of query results, must be between 1 and 1000.
orders List<Property Map>: Zero or more configuration blocks (described below) describing how to order the query results. Each term must appear in either calculation or breakdowns.
startTime Number: The absolute start time of the query in Unix Time (= seconds since epoch).
timeRange Number: The time range of the query in seconds, defaults to 7200 (two hours).

getQuerySpecification Result

The following output properties are available:

Id string: ID of the query specification.
Deprecated: Deprecated
Json string: JSON representation of the query according to the Query Specification, can be used as input for other resources.
Breakdowns List<string>
Calculations List<GetQuerySpecificationCalculation>
EndTime double
FilterCombination string
Filters List<GetQuerySpecificationFilter>
Granularity double
Havings List<GetQuerySpecificationHaving>
Limit double
Orders List<GetQuerySpecificationOrder>
StartTime double
TimeRange double

Id string: ID of the query specification.
Deprecated: Deprecated
Json string: JSON representation of the query according to the Query Specification, can be used as input for other resources.
Breakdowns []string
Calculations []GetQuerySpecificationCalculation
EndTime float64
FilterCombination string
Filters []GetQuerySpecificationFilter
Granularity float64
Havings []GetQuerySpecificationHaving
Limit float64
Orders []GetQuerySpecificationOrder
StartTime float64
TimeRange float64

id String: ID of the query specification.
Deprecated: Deprecated
json String: JSON representation of the query according to the Query Specification, can be used as input for other resources.
breakdowns List<String>
calculations List<GetQuerySpecificationCalculation>
endTime Double
filterCombination String
filters List<GetQuerySpecificationFilter>
granularity Double
havings List<GetQuerySpecificationHaving>
limit Double
orders List<GetQuerySpecificationOrder>
startTime Double
timeRange Double

id string: ID of the query specification.
Deprecated: Deprecated
json string: JSON representation of the query according to the Query Specification, can be used as input for other resources.
breakdowns string[]
calculations GetQuerySpecificationCalculation[]
endTime number
filterCombination string
filters GetQuerySpecificationFilter[]
granularity number
havings GetQuerySpecificationHaving[]
limit number
orders GetQuerySpecificationOrder[]
startTime number
timeRange number

id str: ID of the query specification.
Deprecated: Deprecated
json str: JSON representation of the query according to the Query Specification, can be used as input for other resources.
breakdowns Sequence[str]
calculations Sequence[GetQuerySpecificationCalculation]
end_time float
filter_combination str
filters Sequence[GetQuerySpecificationFilter]
granularity float
havings Sequence[GetQuerySpecificationHaving]
limit float
orders Sequence[GetQuerySpecificationOrder]
start_time float
time_range float

id String: ID of the query specification.
Deprecated: Deprecated
json String: JSON representation of the query according to the Query Specification, can be used as input for other resources.
breakdowns List<String>
calculations List<Property Map>
endTime Number
filterCombination String
filters List<Property Map>
granularity Number
havings List<Property Map>
limit Number
orders List<Property Map>
startTime Number
timeRange Number

Supporting Types

GetQuerySpecificationCalculation

Op string: The operator to apply, see the supported list of calculation operators at Calculation Operators.
Column string: The column to apply the operator to, not needed with COUNT or CONCURRENCY.

Op string: The operator to apply, see the supported list of calculation operators at Calculation Operators.
Column string: The column to apply the operator to, not needed with COUNT or CONCURRENCY.

op String: The operator to apply, see the supported list of calculation operators at Calculation Operators.
column String: The column to apply the operator to, not needed with COUNT or CONCURRENCY.

op string: The operator to apply, see the supported list of calculation operators at Calculation Operators.
column string: The column to apply the operator to, not needed with COUNT or CONCURRENCY.

op str: The operator to apply, see the supported list of calculation operators at Calculation Operators.
column str: The column to apply the operator to, not needed with COUNT or CONCURRENCY.

op String: The operator to apply, see the supported list of calculation operators at Calculation Operators.
column String: The column to apply the operator to, not needed with COUNT or CONCURRENCY.

GetQuerySpecificationFilter

Column string

The column to apply the filter to.

Op string

The operator to apply, see the supported list of filter operators at Filter Operators. Not all operators require a value.

Value string

The value used for the filter. Not needed if op is exists or not-exists. Mutually exclusive with the other value_* options.

NOTE Filter op in and not-in expect an array of strings as value. Use the value attribute and pass the values in single string separated by , without additional spaces (similar to the query builder in the UI). For example: the list foo, bar becomes foo,bar.

Column string

The column to apply the filter to.

Op string

The operator to apply, see the supported list of filter operators at Filter Operators. Not all operators require a value.

Value string

The value used for the filter. Not needed if op is exists or not-exists. Mutually exclusive with the other value_* options.

NOTE Filter op in and not-in expect an array of strings as value. Use the value attribute and pass the values in single string separated by , without additional spaces (similar to the query builder in the UI). For example: the list foo, bar becomes foo,bar.

column String

The column to apply the filter to.

op String

The operator to apply, see the supported list of filter operators at Filter Operators. Not all operators require a value.

value String

The value used for the filter. Not needed if op is exists or not-exists. Mutually exclusive with the other value_* options.

NOTE Filter op in and not-in expect an array of strings as value. Use the value attribute and pass the values in single string separated by , without additional spaces (similar to the query builder in the UI). For example: the list foo, bar becomes foo,bar.

column string

The column to apply the filter to.

op string

The operator to apply, see the supported list of filter operators at Filter Operators. Not all operators require a value.

value string

The value used for the filter. Not needed if op is exists or not-exists. Mutually exclusive with the other value_* options.

NOTE Filter op in and not-in expect an array of strings as value. Use the value attribute and pass the values in single string separated by , without additional spaces (similar to the query builder in the UI). For example: the list foo, bar becomes foo,bar.

column str

The column to apply the filter to.

op str

The operator to apply, see the supported list of filter operators at Filter Operators. Not all operators require a value.

value str

The value used for the filter. Not needed if op is exists or not-exists. Mutually exclusive with the other value_* options.

NOTE Filter op in and not-in expect an array of strings as value. Use the value attribute and pass the values in single string separated by , without additional spaces (similar to the query builder in the UI). For example: the list foo, bar becomes foo,bar.

column String

The column to apply the filter to.

op String

The operator to apply, see the supported list of filter operators at Filter Operators. Not all operators require a value.

value String

The value used for the filter. Not needed if op is exists or not-exists. Mutually exclusive with the other value_* options.

NOTE Filter op in and not-in expect an array of strings as value. Use the value attribute and pass the values in single string separated by , without additional spaces (similar to the query builder in the UI). For example: the list foo, bar becomes foo,bar.

GetQuerySpecificationHaving

CalculateOp string: The calculation operator to apply, supports all of the Calculation Operators with the exception of HEATMAP.
Op string: The operator to apply to filter the query results. One of =, !=, >, >=, <, or <=.
Value double: The value used with op. Currently assumed to be a number.
NOTE A having term's column/calculate_op pair must have a corresponding calculation. There can be multiple having blocks for the same column/calculate_op pair.
Column string: The column to apply the calculate_op to, not needed with COUNT or CONCURRENCY.

CalculateOp string: The calculation operator to apply, supports all of the Calculation Operators with the exception of HEATMAP.
Op string: The operator to apply to filter the query results. One of =, !=, >, >=, <, or <=.
Value float64: The value used with op. Currently assumed to be a number.
NOTE A having term's column/calculate_op pair must have a corresponding calculation. There can be multiple having blocks for the same column/calculate_op pair.
Column string: The column to apply the calculate_op to, not needed with COUNT or CONCURRENCY.

calculateOp String: The calculation operator to apply, supports all of the Calculation Operators with the exception of HEATMAP.
op String: The operator to apply to filter the query results. One of =, !=, >, >=, <, or <=.
value Double: The value used with op. Currently assumed to be a number.
NOTE A having term's column/calculate_op pair must have a corresponding calculation. There can be multiple having blocks for the same column/calculate_op pair.
column String: The column to apply the calculate_op to, not needed with COUNT or CONCURRENCY.

calculateOp string: The calculation operator to apply, supports all of the Calculation Operators with the exception of HEATMAP.
op string: The operator to apply to filter the query results. One of =, !=, >, >=, <, or <=.
value number: The value used with op. Currently assumed to be a number.
NOTE A having term's column/calculate_op pair must have a corresponding calculation. There can be multiple having blocks for the same column/calculate_op pair.
column string: The column to apply the calculate_op to, not needed with COUNT or CONCURRENCY.

calculate_op str: The calculation operator to apply, supports all of the Calculation Operators with the exception of HEATMAP.
op str: The operator to apply to filter the query results. One of =, !=, >, >=, <, or <=.
value float: The value used with op. Currently assumed to be a number.
NOTE A having term's column/calculate_op pair must have a corresponding calculation. There can be multiple having blocks for the same column/calculate_op pair.
column str: The column to apply the calculate_op to, not needed with COUNT or CONCURRENCY.

calculateOp String: The calculation operator to apply, supports all of the Calculation Operators with the exception of HEATMAP.
op String: The operator to apply to filter the query results. One of =, !=, >, >=, <, or <=.
value Number: The value used with op. Currently assumed to be a number.
NOTE A having term's column/calculate_op pair must have a corresponding calculation. There can be multiple having blocks for the same column/calculate_op pair.
column String: The column to apply the calculate_op to, not needed with COUNT or CONCURRENCY.

GetQuerySpecificationOrder

Column string: Either a column present in breakdown or a column that op applies to.
Op string: The calculation operator to apply, see the supported list of calculation operators at Calculation Operators.
Order string: The sort direction, if set must be ascending or descending.

Column string: Either a column present in breakdown or a column that op applies to.
Op string: The calculation operator to apply, see the supported list of calculation operators at Calculation Operators.
Order string: The sort direction, if set must be ascending or descending.

column String: Either a column present in breakdown or a column that op applies to.
op String: The calculation operator to apply, see the supported list of calculation operators at Calculation Operators.
order String: The sort direction, if set must be ascending or descending.

column string: Either a column present in breakdown or a column that op applies to.
op string: The calculation operator to apply, see the supported list of calculation operators at Calculation Operators.
order string: The sort direction, if set must be ascending or descending.

column str: Either a column present in breakdown or a column that op applies to.
op str: The calculation operator to apply, see the supported list of calculation operators at Calculation Operators.
order str: The sort direction, if set must be ascending or descending.

column String: Either a column present in breakdown or a column that op applies to.
op String: The calculation operator to apply, see the supported list of calculation operators at Calculation Operators.
order String: The sort direction, if set must be ascending or descending.

Package Details

Repository: honeycombio honeycombio/terraform-provider-honeycombio
License
Notes: This Pulumi package is based on the honeycombio Terraform Provider.

honeycombio 0.31.0 published on Friday, Mar 7, 2025 by honeycombio

honeycombio/terraform-provider-honeycombio

honeycombio.getQuerySpecification

On this page

On this page

# Data Source: honeycombio.getQuerySpecification

Example Usage

Using getQuerySpecification

getQuerySpecification Result

Supporting Types

GetQuerySpecificationCalculation

GetQuerySpecificationFilter

GetQuerySpecificationHaving

GetQuerySpecificationOrder

Package Details

On this page

On this page