Please wait. This can take some minutes ...
Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $
You can buy this project and download/modify it how often you want.
io.druid.query.Druids Maven / Gradle / Ivy
/*
* Licensed to Metamarkets Group Inc. (Metamarkets) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. Metamarkets licenses this file
* to you 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.
*/
package io.druid.query;
import com.google.common.base.Function;
import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.Iterables;
import com.google.common.collect.Lists;
import io.druid.java.util.common.DateTimes;
import io.druid.java.util.common.granularity.Granularities;
import io.druid.java.util.common.granularity.Granularity;
import io.druid.query.aggregation.AggregatorFactory;
import io.druid.query.aggregation.PostAggregator;
import io.druid.query.datasourcemetadata.DataSourceMetadataQuery;
import io.druid.query.dimension.DefaultDimensionSpec;
import io.druid.query.dimension.DimensionSpec;
import io.druid.query.filter.AndDimFilter;
import io.druid.query.filter.DimFilter;
import io.druid.query.filter.InDimFilter;
import io.druid.query.filter.NoopDimFilter;
import io.druid.query.filter.NotDimFilter;
import io.druid.query.filter.OrDimFilter;
import io.druid.query.filter.SelectorDimFilter;
import io.druid.query.metadata.metadata.ColumnIncluderator;
import io.druid.query.metadata.metadata.SegmentMetadataQuery;
import io.druid.query.search.SearchResultValue;
import io.druid.query.search.ContainsSearchQuerySpec;
import io.druid.query.search.FragmentSearchQuerySpec;
import io.druid.query.search.InsensitiveContainsSearchQuerySpec;
import io.druid.query.search.SearchQuery;
import io.druid.query.search.SearchQuerySpec;
import io.druid.query.search.SearchSortSpec;
import io.druid.query.select.PagingSpec;
import io.druid.query.select.SelectQuery;
import io.druid.query.spec.LegacySegmentSpec;
import io.druid.query.spec.QuerySegmentSpec;
import io.druid.query.timeboundary.TimeBoundaryQuery;
import io.druid.query.timeboundary.TimeBoundaryResultValue;
import io.druid.query.timeseries.TimeseriesQuery;
import io.druid.segment.VirtualColumn;
import io.druid.segment.VirtualColumns;
import org.joda.time.DateTime;
import org.joda.time.Interval;
import javax.annotation.Nullable;
import java.util.Arrays;
import java.util.EnumSet;
import java.util.List;
import java.util.Map;
/**
*/
public class Druids
{
public static final Function DIMENSION_IDENTITY = new Function()
{
@Nullable
@Override
public DimensionSpec apply(String input)
{
return new DefaultDimensionSpec(input, input);
}
};
private Druids()
{
throw new AssertionError();
}
/**
* A Builder for AndDimFilter.
*
* Required: fields() must be called before build()
*
* Usage example:
*
* AndDimFilter andDimFilter = Druids.newAndDimFilterBuilder()
* .fields(listOfDimFilterFields)
* .build();
*
*
* @see AndDimFilter
*/
public static class AndDimFilterBuilder
{
private List fields;
public AndDimFilterBuilder()
{
fields = Lists.newArrayList();
}
public AndDimFilter build()
{
return new AndDimFilter(fields);
}
public AndDimFilterBuilder copy(AndDimFilterBuilder builder)
{
return new AndDimFilterBuilder()
.fields(builder.fields);
}
public AndDimFilterBuilder fields(List f)
{
fields.addAll(f);
return this;
}
}
public static AndDimFilterBuilder newAndDimFilterBuilder()
{
return new AndDimFilterBuilder();
}
/**
* A Builder for OrDimFilter.
*
* Required: fields() must be called before build()
*
* Usage example:
*
* OrDimFilter orDimFilter = Druids.newOrDimFilterBuilder()
* .fields(listOfDimFilterFields)
* .build();
*
*
* @see OrDimFilter
*/
public static class OrDimFilterBuilder
{
private List fields;
public OrDimFilterBuilder()
{
fields = Lists.newArrayList();
}
public OrDimFilter build()
{
return new OrDimFilter(fields);
}
public OrDimFilterBuilder copy(OrDimFilterBuilder builder)
{
return new OrDimFilterBuilder()
.fields(builder.fields);
}
public OrDimFilterBuilder fields(String dimensionName, String value, String... values)
{
fields = Lists.newArrayList(new SelectorDimFilter(dimensionName, value, null));
for (String val : values) {
fields.add(new SelectorDimFilter(dimensionName, val, null));
}
return this;
}
public OrDimFilterBuilder fields(List f)
{
fields.addAll(f);
return this;
}
}
public static OrDimFilterBuilder newOrDimFilterBuilder()
{
return new OrDimFilterBuilder();
}
/**
* A Builder for NotDimFilter.
*
* Required: field() must be called before build()
*
* Usage example:
*
* NotDimFilter notDimFilter = Druids.newNotDimFilterBuilder()
* .field(dimFilterField)
* .build();
*
*
* @see NotDimFilter
*/
public static class NotDimFilterBuilder
{
private DimFilter field;
public NotDimFilterBuilder()
{
field = null;
}
public NotDimFilter build()
{
return new NotDimFilter(field);
}
public NotDimFilterBuilder copy(NotDimFilterBuilder builder)
{
return new NotDimFilterBuilder()
.field(builder.field);
}
public NotDimFilterBuilder field(DimFilter f)
{
field = f;
return this;
}
}
public static NotDimFilterBuilder newNotDimFilterBuilder()
{
return new NotDimFilterBuilder();
}
/**
* A Builder for SelectorDimFilter.
*
* Required: dimension() and value() must be called before build()
*
* Usage example:
*
* Selector selDimFilter = Druids.newSelectorDimFilterBuilder()
* .dimension("test")
* .value("sample")
* .build();
*
*
* @see SelectorDimFilter
*/
public static class SelectorDimFilterBuilder
{
private String dimension;
private String value;
public SelectorDimFilterBuilder()
{
dimension = "";
value = "";
}
public SelectorDimFilter build()
{
return new SelectorDimFilter(dimension, value, null);
}
public SelectorDimFilterBuilder copy(SelectorDimFilterBuilder builder)
{
return new SelectorDimFilterBuilder()
.dimension(builder.dimension)
.value(builder.value);
}
public SelectorDimFilterBuilder dimension(String d)
{
dimension = d;
return this;
}
public SelectorDimFilterBuilder value(String v)
{
value = v;
return this;
}
}
public static SelectorDimFilterBuilder newSelectorDimFilterBuilder()
{
return new SelectorDimFilterBuilder();
}
/**
* A Builder for NoopDimFilter.
* Usage example:
*
* NoopDimFilter noopDimFilter = Druids.newNoopDimFilterBuilder()
* .build();
*
*
* @see NotDimFilter
*/
public static class NoopDimFilterBuilder
{
public NoopDimFilter build()
{
return new NoopDimFilter();
}
}
public static NoopDimFilterBuilder newNoopDimFilterBuilder()
{
return new NoopDimFilterBuilder();
}
/**
* A Builder for TimeseriesQuery.
*
* Required: dataSource(), intervals(), and aggregators() must be called before build()
* Optional: filters(), granularity(), postAggregators(), and context() can be called before build()
*
* Usage example:
*
* TimeseriesQuery query = Druids.newTimeseriesQueryBuilder()
* .dataSource("Example")
* .intervals("2012-01-01/2012-01-02")
* .aggregators(listofAggregators)
* .build();
*
*
* @see TimeseriesQuery
*/
public static class TimeseriesQueryBuilder
{
private DataSource dataSource;
private QuerySegmentSpec querySegmentSpec;
private boolean descending;
private VirtualColumns virtualColumns;
private DimFilter dimFilter;
private Granularity granularity;
private List aggregatorSpecs;
private List postAggregatorSpecs;
private Map context;
private TimeseriesQueryBuilder()
{
dataSource = null;
querySegmentSpec = null;
descending = false;
virtualColumns = null;
dimFilter = null;
granularity = Granularities.ALL;
aggregatorSpecs = Lists.newArrayList();
postAggregatorSpecs = Lists.newArrayList();
context = null;
}
public TimeseriesQuery build()
{
return new TimeseriesQuery(
dataSource,
querySegmentSpec,
descending,
virtualColumns,
dimFilter,
granularity,
aggregatorSpecs,
postAggregatorSpecs,
context
);
}
public static TimeseriesQueryBuilder copy(TimeseriesQuery query)
{
return new TimeseriesQueryBuilder()
.dataSource(query.getDataSource())
.intervals(query.getQuerySegmentSpec())
.descending(query.isDescending())
.virtualColumns(query.getVirtualColumns())
.filters(query.getDimensionsFilter())
.granularity(query.getGranularity())
.aggregators(query.getAggregatorSpecs())
.postAggregators(query.getPostAggregatorSpecs())
.context(query.getContext());
}
public DataSource getDataSource()
{
return dataSource;
}
public QuerySegmentSpec getQuerySegmentSpec()
{
return querySegmentSpec;
}
public DimFilter getDimFilter()
{
return dimFilter;
}
public boolean isDescending()
{
return descending;
}
public Granularity getGranularity()
{
return granularity;
}
public List getAggregatorSpecs()
{
return aggregatorSpecs;
}
public List getPostAggregatorSpecs()
{
return postAggregatorSpecs;
}
public Map getContext()
{
return context;
}
public TimeseriesQueryBuilder dataSource(String ds)
{
dataSource = new TableDataSource(ds);
return this;
}
public TimeseriesQueryBuilder dataSource(DataSource ds)
{
dataSource = ds;
return this;
}
public TimeseriesQueryBuilder intervals(QuerySegmentSpec q)
{
querySegmentSpec = q;
return this;
}
public TimeseriesQueryBuilder intervals(String s)
{
querySegmentSpec = new LegacySegmentSpec(s);
return this;
}
public TimeseriesQueryBuilder intervals(List l)
{
querySegmentSpec = new LegacySegmentSpec(l);
return this;
}
public TimeseriesQueryBuilder virtualColumns(VirtualColumns virtualColumns)
{
this.virtualColumns = virtualColumns;
return this;
}
public TimeseriesQueryBuilder virtualColumns(List virtualColumns)
{
return virtualColumns(VirtualColumns.create(virtualColumns));
}
public TimeseriesQueryBuilder virtualColumns(VirtualColumn... virtualColumns)
{
return virtualColumns(VirtualColumns.create(Arrays.asList(virtualColumns)));
}
public TimeseriesQueryBuilder filters(String dimensionName, String value)
{
dimFilter = new SelectorDimFilter(dimensionName, value, null);
return this;
}
public TimeseriesQueryBuilder filters(String dimensionName, String value, String... values)
{
dimFilter = new InDimFilter(dimensionName, Lists.asList(value, values), null);
return this;
}
public TimeseriesQueryBuilder filters(DimFilter f)
{
dimFilter = f;
return this;
}
public TimeseriesQueryBuilder descending(boolean d)
{
descending = d;
return this;
}
public TimeseriesQueryBuilder granularity(String g)
{
granularity = Granularity.fromString(g);
return this;
}
public TimeseriesQueryBuilder granularity(Granularity g)
{
granularity = g;
return this;
}
public TimeseriesQueryBuilder aggregators(List a)
{
aggregatorSpecs = a;
return this;
}
public TimeseriesQueryBuilder postAggregators(List p)
{
postAggregatorSpecs = p;
return this;
}
public TimeseriesQueryBuilder context(Map c)
{
context = c;
return this;
}
}
public static TimeseriesQueryBuilder newTimeseriesQueryBuilder()
{
return new TimeseriesQueryBuilder();
}
/**
* A Builder for SearchQuery.
*
* Required: dataSource(), intervals(), dimensions() and query() must be called before build()
*
* Optional: filters(), granularity(), and context() can be called before build()
*
* Usage example:
*
* SearchQuery query = Druids.newSearchQueryBuilder()
* .dataSource("Example")
* .dimensions(listofEgDims)
* .query(exampleQuery)
* .intervals("2012-01-01/2012-01-02")
* .build();
*
*
* @see SearchQuery
*/
public static class SearchQueryBuilder
{
private DataSource dataSource;
private DimFilter dimFilter;
private Granularity granularity;
private int limit;
private QuerySegmentSpec querySegmentSpec;
private List dimensions;
private SearchQuerySpec querySpec;
private SearchSortSpec sortSpec;
private Map context;
public SearchQueryBuilder()
{
dataSource = null;
dimFilter = null;
granularity = Granularities.ALL;
limit = 0;
querySegmentSpec = null;
dimensions = null;
querySpec = null;
sortSpec = null;
context = null;
}
public SearchQuery build()
{
return new SearchQuery(
dataSource,
dimFilter,
granularity,
limit,
querySegmentSpec,
dimensions,
querySpec,
sortSpec,
context
);
}
public static SearchQueryBuilder copy(SearchQuery query)
{
return new SearchQueryBuilder()
.dataSource(query.getDataSource())
.filters(query.getDimensionsFilter())
.granularity(query.getGranularity())
.limit(query.getLimit())
.intervals(query.getQuerySegmentSpec())
.dimensions(query.getDimensions())
.query(query.getQuery())
.sortSpec(query.getSort())
.context(query.getContext());
}
public SearchQueryBuilder dataSource(String d)
{
dataSource = new TableDataSource(d);
return this;
}
public SearchQueryBuilder dataSource(DataSource d)
{
dataSource = d;
return this;
}
public SearchQueryBuilder filters(String dimensionName, String value)
{
dimFilter = new SelectorDimFilter(dimensionName, value, null);
return this;
}
public SearchQueryBuilder filters(String dimensionName, String value, String... values)
{
dimFilter = new InDimFilter(dimensionName, Lists.asList(value, values), null);
return this;
}
public SearchQueryBuilder filters(DimFilter f)
{
dimFilter = f;
return this;
}
public SearchQueryBuilder granularity(String g)
{
granularity = Granularity.fromString(g);
return this;
}
public SearchQueryBuilder granularity(Granularity g)
{
granularity = g;
return this;
}
public SearchQueryBuilder limit(int l)
{
limit = l;
return this;
}
public SearchQueryBuilder intervals(QuerySegmentSpec q)
{
querySegmentSpec = q;
return this;
}
public SearchQueryBuilder intervals(String s)
{
querySegmentSpec = new LegacySegmentSpec(s);
return this;
}
public SearchQueryBuilder intervals(List l)
{
querySegmentSpec = new LegacySegmentSpec(l);
return this;
}
public SearchQueryBuilder dimensions(String d)
{
dimensions = ImmutableList.of(DIMENSION_IDENTITY.apply(d));
return this;
}
public SearchQueryBuilder dimensions(Iterable d)
{
dimensions = ImmutableList.copyOf(Iterables.transform(d, DIMENSION_IDENTITY));
return this;
}
public SearchQueryBuilder dimensions(DimensionSpec d)
{
dimensions = Lists.newArrayList(d);
return this;
}
public SearchQueryBuilder dimensions(List d)
{
dimensions = d;
return this;
}
public SearchQueryBuilder query(SearchQuerySpec s)
{
querySpec = s;
return this;
}
public SearchQueryBuilder query(String q)
{
Preconditions.checkNotNull(q, "no value");
querySpec = new InsensitiveContainsSearchQuerySpec(q);
return this;
}
public SearchQueryBuilder query(Map q)
{
String value = Preconditions.checkNotNull(q.get("value"), "no value").toString();
querySpec = new InsensitiveContainsSearchQuerySpec(value);
return this;
}
public SearchQueryBuilder query(String q, boolean caseSensitive)
{
Preconditions.checkNotNull(q, "no value");
querySpec = new ContainsSearchQuerySpec(q, caseSensitive);
return this;
}
public SearchQueryBuilder query(Map q, boolean caseSensitive)
{
String value = Preconditions.checkNotNull(q.get("value"), "no value").toString();
querySpec = new ContainsSearchQuerySpec(value, caseSensitive);
return this;
}
public SearchQueryBuilder fragments(List q)
{
return fragments(q, false);
}
public SearchQueryBuilder sortSpec(SearchSortSpec sortSpec)
{
this.sortSpec = sortSpec;
return this;
}
public SearchQueryBuilder fragments(List q, boolean caseSensitive)
{
Preconditions.checkNotNull(q, "no value");
querySpec = new FragmentSearchQuerySpec(q, caseSensitive);
return this;
}
public SearchQueryBuilder context(Map c)
{
context = c;
return this;
}
}
public static SearchQueryBuilder newSearchQueryBuilder()
{
return new SearchQueryBuilder();
}
/**
* A Builder for TimeBoundaryQuery.
*
* Required: dataSource() must be called before build()
*
* Usage example:
*
* TimeBoundaryQuery query = new MaxTimeQueryBuilder()
* .dataSource("Example")
* .build();
*
*
* @see TimeBoundaryQuery
*/
public static class TimeBoundaryQueryBuilder
{
private DataSource dataSource;
private QuerySegmentSpec querySegmentSpec;
private String bound;
private DimFilter dimFilter;
private Map context;
public TimeBoundaryQueryBuilder()
{
dataSource = null;
querySegmentSpec = null;
bound = null;
dimFilter = null;
context = null;
}
public TimeBoundaryQuery build()
{
return new TimeBoundaryQuery(
dataSource,
querySegmentSpec,
bound,
dimFilter,
context
);
}
public static TimeBoundaryQueryBuilder copy(TimeBoundaryQuery query)
{
return new TimeBoundaryQueryBuilder()
.dataSource(query.getDataSource())
.intervals(query.getQuerySegmentSpec())
.bound(query.getBound())
.filters(query.getFilter())
.context(query.getContext());
}
public TimeBoundaryQueryBuilder dataSource(String ds)
{
dataSource = new TableDataSource(ds);
return this;
}
public TimeBoundaryQueryBuilder dataSource(DataSource ds)
{
dataSource = ds;
return this;
}
public TimeBoundaryQueryBuilder intervals(QuerySegmentSpec q)
{
querySegmentSpec = q;
return this;
}
public TimeBoundaryQueryBuilder intervals(String s)
{
querySegmentSpec = new LegacySegmentSpec(s);
return this;
}
public TimeBoundaryQueryBuilder intervals(List l)
{
querySegmentSpec = new LegacySegmentSpec(l);
return this;
}
public TimeBoundaryQueryBuilder bound(String b)
{
bound = b;
return this;
}
public TimeBoundaryQueryBuilder filters(String dimensionName, String value)
{
dimFilter = new SelectorDimFilter(dimensionName, value, null);
return this;
}
public TimeBoundaryQueryBuilder filters(String dimensionName, String value, String... values)
{
dimFilter = new InDimFilter(dimensionName, Lists.asList(value, values), null);
return this;
}
public TimeBoundaryQueryBuilder filters(DimFilter f)
{
dimFilter = f;
return this;
}
public TimeBoundaryQueryBuilder context(Map c)
{
context = c;
return this;
}
}
public static TimeBoundaryQueryBuilder newTimeBoundaryQueryBuilder()
{
return new TimeBoundaryQueryBuilder();
}
/**
* A Builder for Result.
*
* Required: timestamp() and value() must be called before build()
*
* Usage example:
*
* Result<T> result = Druids.newResultBuilder()
* .timestamp(egDateTime)
* .value(egValue)
* .build();
*
*
* @see Result
*/
public static class ResultBuilder
{
private DateTime timestamp;
private Object value;
public ResultBuilder()
{
timestamp = DateTimes.EPOCH;
value = null;
}
public Result build()
{
return new Result(timestamp, (T) value);
}
public ResultBuilder copy(ResultBuilder builder)
{
return new ResultBuilder()
.timestamp(builder.timestamp)
.value(builder.value);
}
public ResultBuilder timestamp(DateTime t)
{
timestamp = t;
return this;
}
public ResultBuilder value(Object v)
{
value = v;
return this;
}
}
public static ResultBuilder newResultBuilder()
{
return new ResultBuilder();
}
public static ResultBuilder newSearchResultBuilder()
{
return new ResultBuilder();
}
public static ResultBuilder newTimeBoundaryResultBuilder()
{
return new ResultBuilder();
}
/**
* A Builder for SegmentMetadataQuery.
*
* Required: dataSource(), intervals() must be called before build()
*
* Usage example:
*
* SegmentMetadataQuery query = new SegmentMetadataQueryBuilder()
* .dataSource("Example")
* .interval("2010/2013")
* .build();
*
*
* @see SegmentMetadataQuery
*/
public static class SegmentMetadataQueryBuilder
{
private DataSource dataSource;
private QuerySegmentSpec querySegmentSpec;
private ColumnIncluderator toInclude;
private EnumSet analysisTypes;
private Boolean merge;
private Boolean lenientAggregatorMerge;
private Map context;
public SegmentMetadataQueryBuilder()
{
dataSource = null;
querySegmentSpec = null;
toInclude = null;
analysisTypes = null;
merge = null;
lenientAggregatorMerge = null;
context = null;
}
public SegmentMetadataQuery build()
{
return new SegmentMetadataQuery(
dataSource,
querySegmentSpec,
toInclude,
merge,
context,
analysisTypes,
false,
lenientAggregatorMerge
);
}
public static SegmentMetadataQueryBuilder copy(SegmentMetadataQuery query)
{
return new SegmentMetadataQueryBuilder()
.dataSource(query.getDataSource())
.intervals(query.getQuerySegmentSpec())
.toInclude(query.getToInclude())
.analysisTypes(query.getAnalysisTypes())
.merge(query.isMerge())
.lenientAggregatorMerge(query.isLenientAggregatorMerge())
.context(query.getContext());
}
public SegmentMetadataQueryBuilder dataSource(String ds)
{
dataSource = new TableDataSource(ds);
return this;
}
public SegmentMetadataQueryBuilder dataSource(DataSource ds)
{
dataSource = ds;
return this;
}
public SegmentMetadataQueryBuilder intervals(QuerySegmentSpec q)
{
querySegmentSpec = q;
return this;
}
public SegmentMetadataQueryBuilder intervals(String s)
{
querySegmentSpec = new LegacySegmentSpec(s);
return this;
}
public SegmentMetadataQueryBuilder intervals(List l)
{
querySegmentSpec = new LegacySegmentSpec(l);
return this;
}
public SegmentMetadataQueryBuilder toInclude(ColumnIncluderator toInclude)
{
this.toInclude = toInclude;
return this;
}
public SegmentMetadataQueryBuilder analysisTypes(SegmentMetadataQuery.AnalysisType... analysisTypes)
{
if (analysisTypes == null) {
this.analysisTypes = null;
} else {
this.analysisTypes = analysisTypes.length == 0
? EnumSet.noneOf(SegmentMetadataQuery.AnalysisType.class)
: EnumSet.copyOf(Arrays.asList(analysisTypes));
}
return this;
}
public SegmentMetadataQueryBuilder analysisTypes(EnumSet analysisTypes)
{
this.analysisTypes = analysisTypes;
return this;
}
public SegmentMetadataQueryBuilder merge(boolean merge)
{
this.merge = merge;
return this;
}
public SegmentMetadataQueryBuilder lenientAggregatorMerge(boolean lenientAggregatorMerge)
{
this.lenientAggregatorMerge = lenientAggregatorMerge;
return this;
}
public SegmentMetadataQueryBuilder context(Map c)
{
context = c;
return this;
}
}
public static SegmentMetadataQueryBuilder newSegmentMetadataQueryBuilder()
{
return new SegmentMetadataQueryBuilder();
}
/**
* A Builder for SelectQuery.
*
* Required: dataSource(), intervals() must be called before build()
*
* Usage example:
*
* SelectQuery query = new SelectQueryBuilder()
* .dataSource("Example")
* .interval("2010/2013")
* .build();
*
*
* @see SelectQuery
*/
public static class SelectQueryBuilder
{
private DataSource dataSource;
private QuerySegmentSpec querySegmentSpec;
private boolean descending;
private Map context;
private DimFilter dimFilter;
private Granularity granularity;
private List dimensions;
private List metrics;
private VirtualColumns virtualColumns;
private PagingSpec pagingSpec;
public SelectQueryBuilder()
{
dataSource = null;
querySegmentSpec = null;
descending = false;
context = null;
dimFilter = null;
granularity = Granularities.ALL;
dimensions = Lists.newArrayList();
metrics = Lists.newArrayList();
virtualColumns = null;
pagingSpec = null;
}
public SelectQuery build()
{
return new SelectQuery(
dataSource,
querySegmentSpec,
descending,
dimFilter,
granularity,
dimensions,
metrics,
virtualColumns,
pagingSpec,
context
);
}
public static SelectQueryBuilder copy(SelectQuery query)
{
return new SelectQueryBuilder()
.dataSource(query.getDataSource())
.intervals(query.getQuerySegmentSpec())
.descending(query.isDescending())
.filters(query.getFilter())
.granularity(query.getGranularity())
.dimensionSpecs(query.getDimensions())
.metrics(query.getMetrics())
.virtualColumns(query.getVirtualColumns())
.pagingSpec(query.getPagingSpec())
.context(query.getContext());
}
public SelectQueryBuilder dataSource(String ds)
{
dataSource = new TableDataSource(ds);
return this;
}
public SelectQueryBuilder dataSource(DataSource ds)
{
dataSource = ds;
return this;
}
public SelectQueryBuilder intervals(QuerySegmentSpec q)
{
querySegmentSpec = q;
return this;
}
public SelectQueryBuilder intervals(String s)
{
querySegmentSpec = new LegacySegmentSpec(s);
return this;
}
public SelectQueryBuilder intervals(List l)
{
querySegmentSpec = new LegacySegmentSpec(l);
return this;
}
public SelectQueryBuilder descending(boolean descending)
{
this.descending = descending;
return this;
}
public SelectQueryBuilder context(Map c)
{
context = c;
return this;
}
public SelectQueryBuilder filters(String dimensionName, String value)
{
dimFilter = new SelectorDimFilter(dimensionName, value, null);
return this;
}
public SelectQueryBuilder filters(String dimensionName, String value, String... values)
{
dimFilter = new InDimFilter(dimensionName, Lists.asList(value, values), null);
return this;
}
public SelectQueryBuilder filters(DimFilter f)
{
dimFilter = f;
return this;
}
public SelectQueryBuilder granularity(String g)
{
granularity = Granularity.fromString(g);
return this;
}
public SelectQueryBuilder granularity(Granularity g)
{
granularity = g;
return this;
}
public SelectQueryBuilder dimensionSpecs(List d)
{
dimensions = d;
return this;
}
public SelectQueryBuilder dimensions(List d)
{
dimensions = DefaultDimensionSpec.toSpec(d);
return this;
}
public SelectQueryBuilder metrics(List m)
{
metrics = m;
return this;
}
public SelectQueryBuilder virtualColumns(VirtualColumns vcs)
{
virtualColumns = vcs;
return this;
}
public SelectQueryBuilder virtualColumns(List vcs)
{
return virtualColumns(VirtualColumns.create(vcs));
}
public SelectQueryBuilder virtualColumns(VirtualColumn... vcs)
{
return virtualColumns(VirtualColumns.create(Arrays.asList(vcs)));
}
public SelectQueryBuilder pagingSpec(PagingSpec p)
{
pagingSpec = p;
return this;
}
}
public static SelectQueryBuilder newSelectQueryBuilder()
{
return new SelectQueryBuilder();
}
/**
* A Builder for DataSourceMetadataQuery.
*
* Required: dataSource() must be called before build()
*
* Usage example:
*
* DataSourceMetadataQueryBuilder query = new DataSourceMetadataQueryBuilder()
* .dataSource("Example")
* .build();
*
*
* @see DataSourceMetadataQuery
*/
public static class DataSourceMetadataQueryBuilder
{
private DataSource dataSource;
private QuerySegmentSpec querySegmentSpec;
private Map context;
public DataSourceMetadataQueryBuilder()
{
dataSource = null;
querySegmentSpec = null;
context = null;
}
public DataSourceMetadataQuery build()
{
return new DataSourceMetadataQuery(
dataSource,
querySegmentSpec,
context
);
}
public static DataSourceMetadataQueryBuilder copy(DataSourceMetadataQuery query)
{
return new DataSourceMetadataQueryBuilder()
.dataSource(query.getDataSource())
.intervals(query.getQuerySegmentSpec())
.context(query.getContext());
}
public DataSourceMetadataQueryBuilder dataSource(String ds)
{
dataSource = new TableDataSource(ds);
return this;
}
public DataSourceMetadataQueryBuilder dataSource(DataSource ds)
{
dataSource = ds;
return this;
}
public DataSourceMetadataQueryBuilder intervals(QuerySegmentSpec q)
{
querySegmentSpec = q;
return this;
}
public DataSourceMetadataQueryBuilder intervals(String s)
{
querySegmentSpec = new LegacySegmentSpec(s);
return this;
}
public DataSourceMetadataQueryBuilder intervals(List l)
{
querySegmentSpec = new LegacySegmentSpec(l);
return this;
}
public DataSourceMetadataQueryBuilder context(Map c)
{
context = c;
return this;
}
}
public static DataSourceMetadataQueryBuilder newDataSourceMetadataQueryBuilder()
{
return new DataSourceMetadataQueryBuilder();
}
}