first commit

processing/src/main/java/io/druid/query/Query.java

@@ -25,6 +25,7 @@ import com.metamx.common.guava.Sequence;
 import io.druid.query.groupby.GroupByQuery;
 import io.druid.query.metadata.metadata.SegmentMetadataQuery;
 import io.druid.query.search.search.SearchQuery;
+import io.druid.query.select.SelectQuery;
 import io.druid.query.spec.QuerySegmentSpec;
 import io.druid.query.timeboundary.TimeBoundaryQuery;
 import io.druid.query.timeseries.TimeseriesQuery;
@@ -40,7 +41,8 @@ import java.util.Map;
     @JsonSubTypes.Type(name = Query.SEARCH, value = SearchQuery.class),
     @JsonSubTypes.Type(name = Query.TIME_BOUNDARY, value = TimeBoundaryQuery.class),
     @JsonSubTypes.Type(name = Query.GROUP_BY, value = GroupByQuery.class),
-    @JsonSubTypes.Type(name = Query.SEGMENT_METADATA, value = SegmentMetadataQuery.class)
+    @JsonSubTypes.Type(name = Query.SEGMENT_METADATA, value = SegmentMetadataQuery.class),
+    @JsonSubTypes.Type(name = Query.SELECT, value = SelectQuery.class)
 })
 public interface Query<T>
 {
@@ -49,6 +51,7 @@ public interface Query<T>
   public static final String TIME_BOUNDARY = "timeBoundary";
   public static final String GROUP_BY = "groupBy";
   public static final String SEGMENT_METADATA = "segmentMetadata";
+  public static final String SELECT = "select";
 
   public String getDataSource();
 

processing/src/main/java/io/druid/query/select/EventHolder.java

@@ -0,0 +1,49 @@
+package io.druid.query.select;
+
+import com.fasterxml.jackson.annotation.JsonValue;
+import com.google.common.collect.Maps;
+import org.joda.time.DateTime;
+
+import java.util.Map;
+
+/**
+ */
+public class EventHolder
+{
+  private final long timestamp;
+  private final Map<String, Object> entries = Maps.newLinkedHashMap();
+
+  public EventHolder(long timestamp)
+  {
+    this.timestamp = timestamp;
+  }
+
+  public void put(String key, Object val)
+  {
+    entries.put(key, val);
+  }
+
+  public void putAll(Map<String, Object> data)
+  {
+    entries.putAll(data);
+  }
+
+  public Object get(String key)
+  {
+    return entries.get(key);
+  }
+
+  public long getTimestamp()
+  {
+    return timestamp;
+  }
+
+  @JsonValue
+  public Map<String, Object> getBaseObject()
+  {
+    Map<String, Object> retVal = Maps.newLinkedHashMap();
+    retVal.put("timestamp", new DateTime(timestamp));
+    retVal.putAll(entries);
+    return retVal;
+  }
+}

processing/src/main/java/io/druid/query/select/PagingSpec.java

@@ -0,0 +1,42 @@
+package io.druid.query.select;
+
+import com.fasterxml.jackson.annotation.JsonCreator;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import com.google.common.base.Preconditions;
+
+/**
+ */
+public class PagingSpec
+{
+  private final int start;
+  private final int end;
+
+  @JsonCreator
+  public PagingSpec(
+      @JsonProperty("start") int start,
+      @JsonProperty("end") int end
+  )
+  {
+    Preconditions.checkArgument(end > start, "end must be greater than start");
+
+    this.start = start;
+    this.end = end;
+  }
+
+  @JsonProperty
+  public int getStart()
+  {
+    return start;
+  }
+
+  @JsonProperty
+  public int getEnd()
+  {
+    return end;
+  }
+
+  public int getThreshold()
+  {
+    return end - start;
+  }
+}

processing/src/main/java/io/druid/query/select/SelectBinaryFn.java

@@ -0,0 +1,77 @@
+/*
+ * Druid - a distributed column store.
+ * Copyright (C) 2012, 2013  Metamarkets Group Inc.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ */
+
+package io.druid.query.select;
+
+import com.metamx.common.guava.nary.BinaryFn;
+import io.druid.granularity.AllGranularity;
+import io.druid.granularity.QueryGranularity;
+import io.druid.query.Result;
+import org.joda.time.DateTime;
+
+/**
+ */
+public class SelectBinaryFn
+    implements BinaryFn<Result<SelectResultValue>, Result<SelectResultValue>, Result<SelectResultValue>>
+{
+  private final QueryGranularity gran;
+  private final PagingSpec pagingSpec;
+
+  public SelectBinaryFn(
+      QueryGranularity granularity,
+      PagingSpec pagingSpec
+  )
+  {
+    this.gran = granularity;
+    this.pagingSpec = pagingSpec;
+  }
+
+  @Override
+  public Result<SelectResultValue> apply(
+      Result<SelectResultValue> arg1, Result<SelectResultValue> arg2
+  )
+  {
+    if (arg1 == null) {
+      return arg2;
+    }
+
+    if (arg2 == null) {
+      return arg1;
+    }
+
+    final DateTime timestamp = (gran instanceof AllGranularity)
+                               ? arg1.getTimestamp()
+                               : gran.toDateTime(gran.truncate(arg1.getTimestamp().getMillis()));
+
+    SelectResultValueBuilder builder = new SelectResultValueBuilder(timestamp, pagingSpec.getThreshold());
+
+    SelectResultValue arg1Val = arg1.getValue();
+    SelectResultValue arg2Val = arg2.getValue();
+
+    for (EventHolder event : arg1Val) {
+      builder.addEntry(event);
+    }
+
+    for (EventHolder event : arg2Val) {
+      builder.addEntry(event);
+    }
+
+    return builder.build();
+  }
+}

processing/src/main/java/io/druid/query/select/SelectQuery.java

@@ -0,0 +1,153 @@
+/*
+ * Druid - a distributed column store.
+ * Copyright (C) 2012, 2013  Metamarkets Group Inc.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ */
+
+package io.druid.query.select;
+
+import com.fasterxml.jackson.annotation.JsonCreator;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import com.fasterxml.jackson.annotation.JsonTypeName;
+import io.druid.granularity.QueryGranularity;
+import io.druid.query.BaseQuery;
+import io.druid.query.Query;
+import io.druid.query.Result;
+import io.druid.query.filter.DimFilter;
+import io.druid.query.spec.QuerySegmentSpec;
+
+import java.util.List;
+import java.util.Map;
+
+/**
+ */
+@JsonTypeName("select")
+public class SelectQuery extends BaseQuery<Result<SelectResultValue>>
+{
+  private static final PagingSpec defaultPagingSpec = new PagingSpec(0, 10);
+
+  private final DimFilter dimFilter;
+  private final QueryGranularity granularity;
+  private final List<String> dimensions;
+  private final List<String> metrics;
+  private final PagingSpec pagingSpec;
+
+  @JsonCreator
+  public SelectQuery(
+      @JsonProperty("dataSource") String dataSource,
+      @JsonProperty("intervals") QuerySegmentSpec querySegmentSpec,
+      @JsonProperty("filter") DimFilter dimFilter,
+      @JsonProperty("granularity") QueryGranularity granularity,
+      @JsonProperty("dimensions") List<String> dimensions,
+      @JsonProperty("metrics") List<String> metrics,
+      @JsonProperty("pagingSpec") PagingSpec pagingSpec,
+      @JsonProperty("context") Map<String, String> context
+  )
+  {
+    super(dataSource, querySegmentSpec, context);
+    this.dimFilter = dimFilter;
+    this.granularity = granularity;
+    this.dimensions = dimensions;
+    this.metrics = metrics;
+    this.pagingSpec = pagingSpec == null ? defaultPagingSpec : pagingSpec;
+  }
+
+  @Override
+  public boolean hasFilters()
+  {
+    return dimFilter != null;
+  }
+
+  @Override
+  public String getType()
+  {
+    return Query.SELECT;
+  }
+
+  @JsonProperty("filter")
+  public DimFilter getDimensionsFilter()
+  {
+    return dimFilter;
+  }
+
+  @JsonProperty
+  public QueryGranularity getGranularity()
+  {
+    return granularity;
+  }
+
+  @JsonProperty
+  public List<String> getDimensions()
+  {
+    return dimensions;
+  }
+
+  @JsonProperty
+  public PagingSpec getPagingSpec()
+  {
+    return pagingSpec;
+  }
+
+  @JsonProperty
+  public List<String> getMetrics()
+  {
+    return metrics;
+  }
+
+  public SelectQuery withQuerySegmentSpec(QuerySegmentSpec querySegmentSpec)
+  {
+    return new SelectQuery(
+        getDataSource(),
+        querySegmentSpec,
+        dimFilter,
+        granularity,
+        dimensions,
+        metrics,
+        pagingSpec,
+        getContext()
+    );
+  }
+
+  public SelectQuery withOverriddenContext(Map<String, String> contextOverrides)
+  {
+    return new SelectQuery(
+        getDataSource(),
+        getQuerySegmentSpec(),
+        dimFilter,
+        granularity,
+        dimensions,
+        metrics,
+        pagingSpec,
+        computeOverridenContext(contextOverrides)
+    );
+  }
+
+  @Override
+  public String toString()
+  {
+    return "SelectQuery{" +
+           "dataSource='" + getDataSource() + '\'' +
+           ", querySegmentSpec=" + getQuerySegmentSpec() +
+           ", dimFilter=" + dimFilter +
+           ", granularity=" + granularity +
+           ", dimensions=" + dimensions +
+           ", metrics=" + metrics +
+           ", pagingSpec=" + pagingSpec +
+           '}';
+  }
+
+
+}

processing/src/main/java/io/druid/query/select/SelectQueryEngine.java

@@ -0,0 +1,139 @@
+/*
+ * Druid - a distributed column store.
+ * Copyright (C) 2012, 2013  Metamarkets Group Inc.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ */
+
+package io.druid.query.select;
+
+import com.google.common.base.Function;
+import com.google.common.collect.Lists;
+import com.google.common.collect.Maps;
+import com.metamx.common.guava.BaseSequence;
+import com.metamx.common.guava.Sequence;
+import io.druid.query.QueryRunnerHelper;
+import io.druid.query.Result;
+import io.druid.segment.Cursor;
+import io.druid.segment.DimensionSelector;
+import io.druid.segment.ObjectColumnSelector;
+import io.druid.segment.StorageAdapter;
+import io.druid.segment.TimestampColumnSelector;
+import io.druid.segment.data.IndexedInts;
+import io.druid.segment.filter.Filters;
+
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+
+/**
+ */
+public class SelectQueryEngine
+{
+  public Sequence<Result<SelectResultValue>> process(final SelectQuery query, final StorageAdapter adapter)
+  {
+    return new BaseSequence<>(
+        new BaseSequence.IteratorMaker<Result<SelectResultValue>, Iterator<Result<SelectResultValue>>>()
+        {
+          @Override
+          public Iterator<Result<SelectResultValue>> make()
+          {
+            final Iterable<String> dims;
+            if (query.getDimensions() == null || query.getDimensions().isEmpty()) {
+              dims = adapter.getAvailableDimensions();
+            } else {
+              dims = query.getDimensions();
+            }
+
+            final Iterable<String> metrics;
+            if (query.getMetrics() == null || query.getMetrics().isEmpty()) {
+              metrics = adapter.getAvailableMetrics();
+            } else {
+              metrics = query.getMetrics();
+            }
+
+            return QueryRunnerHelper.makeCursorBasedQuery(
+                adapter,
+                query.getQuerySegmentSpec().getIntervals(),
+                Filters.convertDimensionFilters(query.getDimensionsFilter()),
+                query.getGranularity(),
+                new Function<Cursor, Result<SelectResultValue>>()
+                {
+                  @Override
+                  public Result<SelectResultValue> apply(Cursor cursor)
+                  {
+                    final TimestampColumnSelector timestampColumnSelector = cursor.makeTimestampColumnSelector();
+                    final SelectResultValueBuilder builder = new SelectResultValueBuilder(cursor.getTime(), query.getPagingSpec().getThreshold());
+
+                    final Map<String, DimensionSelector> dimSelectors = Maps.newHashMap();
+                    for (String dim : dims) {
+                      final DimensionSelector dimSelector = cursor.makeDimensionSelector(dim);
+                      dimSelectors.put(dim, dimSelector);
+                    }
+
+                    final Map<String, ObjectColumnSelector> metSelectors = Maps.newHashMap();
+                    for (String metric : metrics) {
+                      final ObjectColumnSelector metricSelector = cursor.makeObjectColumnSelector(metric);
+                      metSelectors.put(metric, metricSelector);
+                    }
+
+                    while (!cursor.isDone()) {
+                      final EventHolder theEvent = new EventHolder(timestampColumnSelector.getTimestamp());
+
+                      for (Map.Entry<String, DimensionSelector> dimSelector : dimSelectors.entrySet()) {
+                        final String dim = dimSelector.getKey();
+                        final DimensionSelector selector = dimSelector.getValue();
+                        final IndexedInts vals = selector.getRow();
+
+                        if (vals.size() <= 1) {
+                          final String dimVal = selector.lookupName(vals.get(0));
+                          theEvent.put(dim, dimVal);
+                        } else {
+                          List<String> dimVals = Lists.newArrayList();
+                          for (int i = 0; i < vals.size(); ++i) {
+                            dimVals.add(selector.lookupName(vals.get(i)));
+                          }
+                          theEvent.put(dim, dimVals);
+                        }
+                      }
+
+                      for (Map.Entry<String, ObjectColumnSelector> metSelector : metSelectors.entrySet()) {
+                        final String metric = metSelector.getKey();
+                        final ObjectColumnSelector selector = metSelector.getValue();
+                        theEvent.put(metric, selector.get());
+                      }
+
+                      builder.addEntry(theEvent);
+                      cursor.advance();
+                    }
+
+                    return builder.build();
+                  }
+                }
+            ).iterator();
+          }
+
+          @Override
+          public void cleanup(Iterator<Result<SelectResultValue>> toClean)
+          {
+            // https://github.com/metamx/druid/issues/128
+            while (toClean.hasNext()) {
+              toClean.next();
+            }
+          }
+        }
+    );
+  }
+}

processing/src/main/java/io/druid/query/select/SelectQueryQueryToolChest.java

@@ -0,0 +1,228 @@
+/*
+ * Druid - a distributed column store.
+ * Copyright (C) 2012, 2013  Metamarkets Group Inc.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ */
+
+package io.druid.query.select;
+
+import com.fasterxml.jackson.core.type.TypeReference;
+import com.google.common.base.Function;
+import com.google.common.base.Functions;
+import com.google.common.base.Joiner;
+import com.google.common.collect.Lists;
+import com.google.common.collect.Maps;
+import com.google.common.collect.Ordering;
+import com.google.inject.Inject;
+import com.metamx.common.guava.MergeSequence;
+import com.metamx.common.guava.Sequence;
+import com.metamx.common.guava.nary.BinaryFn;
+import com.metamx.emitter.service.ServiceMetricEvent;
+import io.druid.collections.OrderedMergeSequence;
+import io.druid.granularity.QueryGranularity;
+import io.druid.query.CacheStrategy;
+import io.druid.query.IntervalChunkingQueryRunner;
+import io.druid.query.Query;
+import io.druid.query.QueryConfig;
+import io.druid.query.QueryRunner;
+import io.druid.query.QueryToolChest;
+import io.druid.query.Result;
+import io.druid.query.ResultGranularTimestampComparator;
+import io.druid.query.ResultMergeQueryRunner;
+import io.druid.query.aggregation.AggregatorFactory;
+import io.druid.query.aggregation.MetricManipulationFn;
+import io.druid.query.filter.DimFilter;
+import org.joda.time.DateTime;
+import org.joda.time.Interval;
+import org.joda.time.Minutes;
+
+import java.nio.ByteBuffer;
+import java.util.Arrays;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+
+/**
+ */
+public class SelectQueryQueryToolChest extends QueryToolChest<Result<SelectResultValue>, SelectQuery>
+{
+  private static final byte SELECT_QUERY = 0x13;
+
+  private static final Joiner COMMA_JOIN = Joiner.on(",");
+  private static final TypeReference<Object> OBJECT_TYPE_REFERENCE =
+      new TypeReference<Object>()
+      {
+      };
+
+  private static final TypeReference<Result<SelectResultValue>> TYPE_REFERENCE =
+      new TypeReference<Result<SelectResultValue>>()
+      {
+      };
+
+  private final QueryConfig config;
+
+  @Inject
+  public SelectQueryQueryToolChest(QueryConfig config)
+  {
+    this.config = config;
+  }
+
+  @Override
+  public QueryRunner<Result<SelectResultValue>> mergeResults(QueryRunner<Result<SelectResultValue>> queryRunner)
+  {
+    return new ResultMergeQueryRunner<Result<SelectResultValue>>(queryRunner)
+    {
+      @Override
+      protected Ordering<Result<SelectResultValue>> makeOrdering(Query<Result<SelectResultValue>> query)
+      {
+        return Ordering.from(
+            new ResultGranularTimestampComparator<SelectResultValue>(
+                ((SelectQuery) query).getGranularity()
+            )
+        );
+      }
+
+      @Override
+      protected BinaryFn<Result<SelectResultValue>, Result<SelectResultValue>, Result<SelectResultValue>> createMergeFn(
+          Query<Result<SelectResultValue>> input
+      )
+      {
+        SelectQuery query = (SelectQuery) input;
+        return new SelectBinaryFn(
+            query.getGranularity(),
+            query.getPagingSpec()
+        );
+      }
+    };
+  }
+
+  @Override
+  public Sequence<Result<SelectResultValue>> mergeSequences(Sequence<Sequence<Result<SelectResultValue>>> seqOfSequences)
+  {
+    return new OrderedMergeSequence<Result<SelectResultValue>>(getOrdering(), seqOfSequences);
+  }
+
+  @Override
+  public ServiceMetricEvent.Builder makeMetricBuilder(SelectQuery query)
+  {
+    int numMinutes = 0;
+    for (Interval interval : query.getIntervals()) {
+      numMinutes += Minutes.minutesIn(interval).getMinutes();
+    }
+
+    return new ServiceMetricEvent.Builder()
+        .setUser2(query.getDataSource())
+        .setUser4("Select")
+        .setUser5(COMMA_JOIN.join(query.getIntervals()))
+        .setUser6(String.valueOf(query.hasFilters()))
+        .setUser9(Minutes.minutes(numMinutes).toString());
+  }
+
+  @Override
+  public Function<Result<SelectResultValue>, Result<SelectResultValue>> makeMetricManipulatorFn(
+      final SelectQuery query, final MetricManipulationFn fn
+  )
+  {
+    return Functions.identity();
+  }
+
+  @Override
+  public TypeReference<Result<SelectResultValue>> getResultTypeReference()
+  {
+    return TYPE_REFERENCE;
+  }
+
+  @Override
+  public CacheStrategy<Result<SelectResultValue>, Object, SelectQuery> getCacheStrategy(final SelectQuery query)
+  {
+    return new CacheStrategy<Result<SelectResultValue>, Object, SelectQuery>()
+    {
+      @Override
+      public byte[] computeCacheKey(SelectQuery query)
+      {
+        final DimFilter dimFilter = query.getDimensionsFilter();
+        final byte[] filterBytes = dimFilter == null ? new byte[]{} : dimFilter.getCacheKey();
+        final byte[] granularityBytes = query.getGranularity().cacheKey();
+
+        return ByteBuffer
+            .allocate(1 + granularityBytes.length + filterBytes.length)
+            .put(SELECT_QUERY)
+            .put(granularityBytes)
+            .put(filterBytes)
+            .array();
+      }
+
+      @Override
+      public TypeReference<Object> getCacheObjectClazz()
+      {
+        return OBJECT_TYPE_REFERENCE;
+      }
+
+      @Override
+      public Function<Result<SelectResultValue>, Object> prepareForCache()
+      {
+        return new Function<Result<SelectResultValue>, Object>()
+        {
+          @Override
+          public Object apply(final Result<SelectResultValue> input)
+          {
+            return Arrays.asList(input.getTimestamp().getMillis(), input.getValue().getBaseObject());
+          }
+        };
+      }
+
+      @Override
+      public Function<Object, Result<SelectResultValue>> pullFromCache()
+      {
+        return new Function<Object, Result<SelectResultValue>>()
+        {
+          private final QueryGranularity granularity = query.getGranularity();
+
+          @Override
+          public Result<SelectResultValue> apply(Object input)
+          {
+            List<Object> results = (List<Object>) input;
+            Iterator<Object> resultIter = results.iterator();
+
+            DateTime timestamp = granularity.toDateTime(((Number) resultIter.next()).longValue());
+
+            return new Result<SelectResultValue>(
+                timestamp,
+                new SelectResultValue(Lists.newArrayList(resultIter))
+            );
+          }
+        };
+      }
+
+      @Override
+      public Sequence<Result<SelectResultValue>> mergeSequences(Sequence<Sequence<Result<SelectResultValue>>> seqOfSequences)
+      {
+        return new MergeSequence<Result<SelectResultValue>>(getOrdering(), seqOfSequences);
+      }
+    };
+  }
+
+  @Override
+  public QueryRunner<Result<SelectResultValue>> preMergeQueryDecoration(QueryRunner<Result<SelectResultValue>> runner)
+  {
+    return new IntervalChunkingQueryRunner<Result<SelectResultValue>>(runner, config.getChunkPeriod());
+  }
+
+  public Ordering<Result<SelectResultValue>> getOrdering()
+  {
+    return Ordering.natural();
+  }
+}

processing/src/main/java/io/druid/query/select/SelectQueryRunnerFactory.java

@@ -0,0 +1,106 @@
+/*
+ * Druid - a distributed column store.
+ * Copyright (C) 2012, 2013  Metamarkets Group Inc.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ */
+
+package io.druid.query.select;
+
+import com.google.inject.Inject;
+import com.metamx.common.ISE;
+import com.metamx.common.guava.Sequence;
+import io.druid.query.ChainedExecutionQueryRunner;
+import io.druid.query.Query;
+import io.druid.query.QueryConfig;
+import io.druid.query.QueryRunner;
+import io.druid.query.QueryRunnerFactory;
+import io.druid.query.QueryToolChest;
+import io.druid.query.Result;
+import io.druid.segment.Segment;
+import io.druid.segment.StorageAdapter;
+
+import java.util.concurrent.ExecutorService;
+
+/**
+ */
+public class SelectQueryRunnerFactory
+    implements QueryRunnerFactory<Result<SelectResultValue>, SelectQuery>
+{
+  public static SelectQueryRunnerFactory create()
+  {
+    return new SelectQueryRunnerFactory(
+        new SelectQueryQueryToolChest(new QueryConfig()),
+        new SelectQueryEngine()
+    );
+  }
+
+  private final SelectQueryQueryToolChest toolChest;
+  private final SelectQueryEngine engine;
+
+  @Inject
+  public SelectQueryRunnerFactory(
+      SelectQueryQueryToolChest toolChest,
+      SelectQueryEngine engine
+  )
+  {
+    this.toolChest = toolChest;
+    this.engine = engine;
+  }
+
+  @Override
+  public QueryRunner<Result<SelectResultValue>> createRunner(final Segment segment)
+  {
+    return new SelectQueryRunner(engine, segment.asStorageAdapter());
+  }
+
+  @Override
+  public QueryRunner<Result<SelectResultValue>> mergeRunners(
+      ExecutorService queryExecutor, Iterable<QueryRunner<Result<SelectResultValue>>> queryRunners
+  )
+  {
+    return new ChainedExecutionQueryRunner<Result<SelectResultValue>>(
+        queryExecutor, toolChest.getOrdering(), queryRunners
+    );
+  }
+
+  @Override
+  public QueryToolChest<Result<SelectResultValue>, SelectQuery> getToolchest()
+  {
+    return toolChest;
+  }
+
+  private static class SelectQueryRunner implements QueryRunner<Result<SelectResultValue>>
+  {
+    private final SelectQueryEngine engine;
+    private final StorageAdapter adapter;
+
+    private SelectQueryRunner(SelectQueryEngine engine, StorageAdapter adapter)
+    {
+      this.engine = engine;
+      this.adapter = adapter;
+    }
+
+    @Override
+    public Sequence<Result<SelectResultValue>> run(Query<Result<SelectResultValue>> input)
+    {
+      if (!(input instanceof SelectQuery)) {
+        throw new ISE("Got a [%s] which isn't a %s", input.getClass(), SelectQuery.class);
+      }
+
+      return engine.process((SelectQuery) input, adapter);
+    }
+  }
+}

processing/src/main/java/io/druid/query/select/SelectResultValue.java

@@ -0,0 +1,76 @@
+/*
+ * Druid - a distributed column store.
+ * Copyright (C) 2012, 2013  Metamarkets Group Inc.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ */
+
+package io.druid.query.select;
+
+import com.fasterxml.jackson.annotation.JsonCreator;
+import com.fasterxml.jackson.annotation.JsonValue;
+import com.google.common.base.Function;
+import com.google.common.collect.Lists;
+import com.metamx.common.ISE;
+
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+
+/**
+ */
+public class SelectResultValue implements Iterable<EventHolder>
+{
+  private final List<EventHolder> value;
+
+  @JsonCreator
+  public SelectResultValue(
+      List<?> value
+  )
+  {
+    this.value = (value == null) ? Lists.<EventHolder>newArrayList() : Lists.transform(
+        value,
+        new Function<Object, EventHolder>()
+        {
+          @Override
+          public EventHolder apply(Object input)
+          {
+            if (input instanceof EventHolder) {
+              return (EventHolder) input;
+            } else if (input instanceof Map) {
+              long timestamp = (long) ((Map) input).remove("timestamp");
+              EventHolder retVal = new EventHolder(timestamp);
+              retVal.putAll((Map) input);
+              return retVal;
+            } else {
+              throw new ISE("Unknown type : %s", input.getClass());
+            }
+          }
+        }
+    );
+  }
+
+  @JsonValue
+  public List<EventHolder> getBaseObject()
+  {
+    return value;
+  }
+
+  @Override
+  public Iterator<EventHolder> iterator()
+  {
+    return value.iterator();
+  }
+}

processing/src/main/java/io/druid/query/select/SelectResultValueBuilder.java

@@ -0,0 +1,85 @@
+/*
+ * Druid - a distributed column store.
+ * Copyright (C) 2012, 2013  Metamarkets Group Inc.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ */
+
+package io.druid.query.select;
+
+import com.google.common.collect.Lists;
+import com.google.common.collect.MinMaxPriorityQueue;
+import com.google.common.primitives.Longs;
+import io.druid.query.Result;
+import org.joda.time.DateTime;
+
+import java.util.Comparator;
+import java.util.List;
+
+/**
+ */
+public class SelectResultValueBuilder
+{
+  private static final Comparator<EventHolder> comparator = new Comparator<EventHolder>()
+  {
+    @Override
+    public int compare(EventHolder o1, EventHolder o2)
+    {
+      return Longs.compare(o1.getTimestamp(), o2.getTimestamp());
+    }
+  };
+
+  private final DateTime timestamp;
+
+  private MinMaxPriorityQueue<EventHolder> pQueue = null;
+
+  public SelectResultValueBuilder(
+      DateTime timestamp,
+      int threshold
+  )
+  {
+    this.timestamp = timestamp;
+
+    instantiatePQueue(threshold, comparator);
+  }
+
+  public SelectResultValueBuilder addEntry(
+      EventHolder event
+  )
+  {
+    pQueue.add(event);
+
+    return this;
+  }
+
+  public Result<SelectResultValue> build()
+  {
+        // Pull out top aggregated values
+    List<EventHolder> values = Lists.newArrayListWithCapacity(pQueue.size());
+    while (!pQueue.isEmpty()) {
+      values.add(pQueue.remove());
+    }
+
+    return new Result<SelectResultValue>(
+        timestamp,
+        new SelectResultValue(values)
+    );
+  }
+
+  private void instantiatePQueue(int threshold, final Comparator comparator)
+  {
+    this.pQueue = MinMaxPriorityQueue.orderedBy(comparator).maximumSize(threshold).create();
+  }
+}

processing/src/main/java/io/druid/segment/ColumnSelectorFactory.java

@@ -24,6 +24,7 @@ package io.druid.segment;
  */
 public interface ColumnSelectorFactory
 {
+  public TimestampColumnSelector makeTimestampColumnSelector();
   public DimensionSelector makeDimensionSelector(String dimensionName);
   public FloatColumnSelector makeFloatColumnSelector(String columnName);
   public ObjectColumnSelector makeObjectColumnSelector(String columnName);

processing/src/main/java/io/druid/segment/QueryableIndexStorageAdapter.java

@@ -23,6 +23,7 @@ import com.google.common.base.Function;
 import com.google.common.base.Functions;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.Maps;
+import com.google.common.collect.Sets;
 import com.google.common.io.Closeables;
 import com.metamx.common.collect.MoreIterators;
 import com.metamx.common.guava.FunctionalIterable;
@@ -77,6 +78,12 @@ public class QueryableIndexStorageAdapter implements StorageAdapter
     return index.getAvailableDimensions();
   }
 
+  @Override
+  public Iterable<String> getAvailableMetrics()
+  {
+    return Sets.difference(Sets.newHashSet(index.getColumnNames()), Sets.newHashSet(index.getAvailableDimensions()));
+  }
+
   @Override
   public int getDimensionCardinality(String dimension)
   {
@@ -236,6 +243,19 @@ public class QueryableIndexStorageAdapter implements StorageAdapter
                       cursorOffset = initOffset.clone();
                     }
 
+                    @Override
+                    public TimestampColumnSelector makeTimestampColumnSelector()
+                    {
+                      return new TimestampColumnSelector()
+                      {
+                        @Override
+                        public long getTimestamp()
+                        {
+                          return index.getTimeColumn().getGenericColumn().getLongSingleValueRow(cursorOffset.getOffset());
+                        }
+                      };
+                    }
+
                     @Override
                     public DimensionSelector makeDimensionSelector(String dimension)
                     {
@@ -620,6 +640,19 @@ public class QueryableIndexStorageAdapter implements StorageAdapter
                       currRow = initRow;
                     }
 
+                    @Override
+                    public TimestampColumnSelector makeTimestampColumnSelector()
+                    {
+                      return new TimestampColumnSelector()
+                      {
+                        @Override
+                        public long getTimestamp()
+                        {
+                          return timestamps.getLongSingleValueRow(currRow);
+                        }
+                      };
+                    }
+
                     @Override
                     public DimensionSelector makeDimensionSelector(String dimension)
                     {

processing/src/main/java/io/druid/segment/StorageAdapter.java

@@ -17,7 +17,9 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  */
 
-package io.druid.segment;import io.druid.segment.data.Indexed;
+package io.druid.segment;
+
+import io.druid.segment.data.Indexed;
 import org.joda.time.DateTime;
 import org.joda.time.Interval;
 
@@ -28,6 +30,7 @@ public interface StorageAdapter extends CursorFactory
   public String getSegmentIdentifier();
   public Interval getInterval();
   public Indexed<String> getAvailableDimensions();
+  public Iterable<String> getAvailableMetrics();
   public int getDimensionCardinality(String dimension);
   public DateTime getMinTime();
   public DateTime getMaxTime();

processing/src/main/java/io/druid/segment/TimestampColumnSelector.java

@@ -0,0 +1,27 @@
+/*
+ * Druid - a distributed column store.
+ * Copyright (C) 2012, 2013  Metamarkets Group Inc.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ */
+
+package io.druid.segment;
+
+/**
+ */
+public interface TimestampColumnSelector
+{
+  public long getTimestamp();
+}

processing/src/main/java/io/druid/segment/incremental/IncrementalIndex.java

@@ -45,6 +45,7 @@ import io.druid.segment.ColumnSelectorFactory;
 import io.druid.segment.DimensionSelector;
 import io.druid.segment.FloatColumnSelector;
 import io.druid.segment.ObjectColumnSelector;
+import io.druid.segment.TimestampColumnSelector;
 import io.druid.segment.serde.ComplexMetricExtractor;
 import io.druid.segment.serde.ComplexMetricSerde;
 import io.druid.segment.serde.ComplexMetrics;
@@ -197,6 +198,19 @@ public class IncrementalIndex implements Iterable<Row>
         aggs[i] = agg.factorize(
             new ColumnSelectorFactory()
             {
+              @Override
+              public TimestampColumnSelector makeTimestampColumnSelector()
+              {
+                return new TimestampColumnSelector()
+                {
+                  @Override
+                  public long getTimestamp()
+                  {
+                    return in.getTimestampFromEpoch();
+                  }
+                };
+              }
+
               @Override
               public FloatColumnSelector makeFloatColumnSelector(String columnName)
               {

processing/src/main/java/io/druid/segment/incremental/IncrementalIndexStorageAdapter.java

@@ -1,3 +1,4 @@
+
 /*
  * Druid - a distributed column store.
  * Copyright (C) 2012, 2013  Metamarkets Group Inc.
@@ -38,6 +39,7 @@ import io.druid.segment.DimensionSelector;
 import io.druid.segment.FloatColumnSelector;
 import io.druid.segment.ObjectColumnSelector;
 import io.druid.segment.StorageAdapter;
+import io.druid.segment.TimestampColumnSelector;
 import io.druid.segment.data.Indexed;
 import io.druid.segment.data.IndexedInts;
 import io.druid.segment.data.ListIndexed;
@@ -87,6 +89,12 @@ public class IncrementalIndexStorageAdapter implements StorageAdapter
     return new ListIndexed<String>(index.getDimensions(), String.class);
   }
 
+  @Override
+  public Iterable<String> getAvailableMetrics()
+  {
+    return index.getMetricNames();
+  }
+
   @Override
   public int getDimensionCardinality(String dimension)
   {
@@ -237,6 +245,19 @@ public class IncrementalIndexStorageAdapter implements StorageAdapter
 
                       }
 
+                      @Override
+                      public TimestampColumnSelector makeTimestampColumnSelector()
+                      {
+                        return new TimestampColumnSelector()
+                        {
+                          @Override
+                          public long getTimestamp()
+                          {
+                            return currEntry.getKey().getTimestamp();
+                          }
+                        };
+                      }
+
                       @Override
                       public DimensionSelector makeDimensionSelector(String dimension)
                       {

publications/whitepaper/README.md

@@ -0,0 +1,4 @@
+Download [MacTeX](http://tug.org/mactex/)
+```bash
+make
+```

publications/whitepaper/druid.bib

@@ -1,348 +1,368 @@
-@article{cattell2011scalable,
-  title={Scalable SQL and NoSQL data stores},
-  author={Cattell, Rick},
-  journal={ACM SIGMOD Record},
-  volume={39},
-  number={4},
-  pages={12--27},
-  year={2011},
-  publisher={ACM}
-}
+  @article{cattell2011scalable,
+    title={Scalable SQL and NoSQL data stores},
+    author={Cattell, Rick},
+    journal={ACM SIGMOD Record},
+    volume={39},
+    number={4},
+    pages={12--27},
+    year={2011},
+    publisher={ACM}
+  }
 
-@article{chang2008bigtable,
-  title={Bigtable: A distributed storage system for structured data},
-  author={Chang, Fay and Dean, Jeffrey and Ghemawat, Sanjay and Hsieh, Wilson C and Wallach, Deborah A and Burrows, Mike and Chandra, Tushar and Fikes, Andrew and Gruber, Robert E},
-  journal={ACM Transactions on Computer Systems (TOCS)},
-  volume={26},
-  number={2},
-  pages={4},
-  year={2008},
-  publisher={ACM}
-}
+  @article{chang2008bigtable,
+    title={Bigtable: A distributed storage system for structured data},
+    author={Chang, Fay and Dean, Jeffrey and Ghemawat, Sanjay and Hsieh, Wilson C and Wallach, Deborah A and Burrows, Mike and Chandra, Tushar and Fikes, Andrew and Gruber, Robert E},
+    journal={ACM Transactions on Computer Systems (TOCS)},
+    volume={26},
+    number={2},
+    pages={4},
+    year={2008},
+    publisher={ACM}
+  }
 
-@inproceedings{decandia2007dynamo,
-  title={Dynamo: amazon's highly available key-value store},
-  author={DeCandia, Giuseppe and Hastorun, Deniz and Jampani, Madan and Kakulapati, Gunavardhan and Lakshman, Avinash and Pilchin, Alex and Sivasubramanian, Swaminathan and Vosshall, Peter and Vogels, Werner},
-  booktitle={ACM SIGOPS Operating Systems Review},
-  volume={41},
-  number={6},
-  pages={205--220},
-  year={2007},
-  organization={ACM}
-}
+  @inproceedings{decandia2007dynamo,
+    title={Dynamo: amazon's highly available key-value store},
+    author={DeCandia, Giuseppe and Hastorun, Deniz and Jampani, Madan and Kakulapati, Gunavardhan and Lakshman, Avinash and Pilchin, Alex and Sivasubramanian, Swaminathan and Vosshall, Peter and Vogels, Werner},
+    booktitle={ACM SIGOPS Operating Systems Review},
+    volume={41},
+    number={6},
+    pages={205--220},
+    year={2007},
+    organization={ACM}
+  }
 
-@inproceedings{bear2012vertica,
-  title={The vertica database: SQL RDBMS for managing big data},
-  author={Bear, Chuck and Lamb, Andrew and Tran, Nga},
-  booktitle={Proceedings of the 2012 workshop on Management of big data systems},
-  pages={37--38},
-  year={2012},
-  organization={ACM}
-}
+  @inproceedings{bear2012vertica,
+    title={The vertica database: SQL RDBMS for managing big data},
+    author={Bear, Chuck and Lamb, Andrew and Tran, Nga},
+    booktitle={Proceedings of the 2012 workshop on Management of big data systems},
+    pages={37--38},
+    year={2012},
+    organization={ACM}
+  }
 
-@article{lakshman2010cassandra,
-  title={Cassandra—A decentralized structured storage system},
-  author={Lakshman, Avinash and Malik, Prashant},
-  journal={Operating systems review},
-  volume={44},
-  number={2},
-  pages={35},
-  year={2010}
-}
+  @article{lakshman2010cassandra,
+    title={Cassandra—A decentralized structured storage system},
+    author={Lakshman, Avinash and Malik, Prashant},
+    journal={Operating systems review},
+    volume={44},
+    number={2},
+    pages={35},
+    year={2010}
+  }
 
-@article{melnik2010dremel,
-  title={Dremel: interactive analysis of web-scale datasets},
-  author={Melnik, Sergey and Gubarev, Andrey and Long, Jing Jing and Romer, Geoffrey and Shivakumar, Shiva and Tolton, Matt and Vassilakis, Theo},
-  journal={Proceedings of the VLDB Endowment},
-  volume={3},
-  number={1-2},
-  pages={330--339},
-  year={2010},
-  publisher={VLDB Endowment}
-}
+  @article{melnik2010dremel,
+    title={Dremel: interactive analysis of web-scale datasets},
+    author={Melnik, Sergey and Gubarev, Andrey and Long, Jing Jing and Romer, Geoffrey and Shivakumar, Shiva and Tolton, Matt and Vassilakis, Theo},
+    journal={Proceedings of the VLDB Endowment},
+    volume={3},
+    number={1-2},
+    pages={330--339},
+    year={2010},
+    publisher={VLDB Endowment}
+  }
 
-@article{hall2012processing,
-  title={Processing a trillion cells per mouse click},
-  author={Hall, Alexander and Bachmann, Olaf and B{\"u}ssow, Robert and G{\u{a}}nceanu, Silviu and Nunkesser, Marc},
-  journal={Proceedings of the VLDB Endowment},
-  volume={5},
-  number={11},
-  pages={1436--1446},
-  year={2012},
-  publisher={VLDB Endowment}
-}
+  @article{hall2012processing,
+    title={Processing a trillion cells per mouse click},
+    author={Hall, Alexander and Bachmann, Olaf and B{\"u}ssow, Robert and G{\u{a}}nceanu, Silviu and Nunkesser, Marc},
+    journal={Proceedings of the VLDB Endowment},
+    volume={5},
+    number={11},
+    pages={1436--1446},
+    year={2012},
+    publisher={VLDB Endowment}
+  }
 
-@inproceedings{shvachko2010hadoop,
-  title={The hadoop distributed file system},
-  author={Shvachko, Konstantin and Kuang, Hairong and Radia, Sanjay and Chansler, Robert},
-  booktitle={Mass Storage Systems and Technologies (MSST), 2010 IEEE 26th Symposium on},
-  pages={1--10},
-  year={2010},
-  organization={IEEE}
-}
+  @inproceedings{shvachko2010hadoop,
+    title={The hadoop distributed file system},
+    author={Shvachko, Konstantin and Kuang, Hairong and Radia, Sanjay and Chansler, Robert},
+    booktitle={Mass Storage Systems and Technologies (MSST), 2010 IEEE 26th Symposium on},
+    pages={1--10},
+    year={2010},
+    organization={IEEE}
+  }
 
-@article{colantonio2010concise,
-  title={Concise: Compressed ‘n’Composable Integer Set},
-  author={Colantonio, Alessandro and Di Pietro, Roberto},
-  journal={Information Processing Letters},
-  volume={110},
-  number={16},
-  pages={644--650},
-  year={2010},
-  publisher={Elsevier}
-}
+  @article{colantonio2010concise,
+    title={Concise: Compressed ‘n’Composable Integer Set},
+    author={Colantonio, Alessandro and Di Pietro, Roberto},
+    journal={Information Processing Letters},
+    volume={110},
+    number={16},
+    pages={644--650},
+    year={2010},
+    publisher={Elsevier}
+  }
 
-@article{lerner2010redis,
-  title={At the Forge: Redis},
-  author={Lerner, Richard},
-  journal={Linux Journal},
-  volume={2010},
-  number={197},
-  pages={3},
-  year={2010}
-}
+  @inproceedings{stonebraker2005c,
+    title={C-store: a column-oriented DBMS},
+    author={Stonebraker, Mike and Abadi, Daniel J and Batkin, Adam and Chen, Xuedong and Cherniack, Mitch and Ferreira, Miguel and Lau, Edmond and Lin, Amerson and Madden, Sam and O'Neil, Elizabeth and others},
+    booktitle={Proceedings of the 31st international conference on Very large data bases},
+    pages={553--564},
+    year={2005},
+    organization={VLDB Endowment}
+  }
 
-@inproceedings{stonebraker2005c,
-  title={C-store: a column-oriented DBMS},
-  author={Stonebraker, Mike and Abadi, Daniel J and Batkin, Adam and Chen, Xuedong and Cherniack, Mitch and Ferreira, Miguel and Lau, Edmond and Lin, Amerson and Madden, Sam and O'Neil, Elizabeth and others},
-  booktitle={Proceedings of the 31st international conference on Very large data bases},
-  pages={553--564},
-  year={2005},
-  organization={VLDB Endowment}
-}
+  @inproceedings{engle2012shark,
+    title={Shark: fast data analysis using coarse-grained distributed memory},
+    author={Engle, Cliff and Lupher, Antonio and Xin, Reynold and Zaharia, Matei and Franklin, Michael J and Shenker, Scott and Stoica, Ion},
+    booktitle={Proceedings of the 2012 international conference on Management of Data},
+    pages={689--692},
+    year={2012},
+    organization={ACM}
+  }
 
-@inproceedings{engle2012shark,
-  title={Shark: fast data analysis using coarse-grained distributed memory},
-  author={Engle, Cliff and Lupher, Antonio and Xin, Reynold and Zaharia, Matei and Franklin, Michael J and Shenker, Scott and Stoica, Ion},
-  booktitle={Proceedings of the 2012 international conference on Management of Data},
-  pages={689--692},
-  year={2012},
-  organization={ACM}
-}
+  @inproceedings{zaharia2012discretized,
+    title={Discretized streams: an efficient and fault-tolerant model for stream processing on large clusters},
+    author={Zaharia, Matei and Das, Tathagata and Li, Haoyuan and Shenker, Scott and Stoica, Ion},
+    booktitle={Proceedings of the 4th USENIX conference on Hot Topics in Cloud Computing},
+    pages={10--10},
+    year={2012},
+    organization={USENIX Association}
+  }
 
-@inproceedings{zaharia2012discretized,
-  title={Discretized streams: an efficient and fault-tolerant model for stream processing on large clusters},
-  author={Zaharia, Matei and Das, Tathagata and Li, Haoyuan and Shenker, Scott and Stoica, Ion},
-  booktitle={Proceedings of the 4th USENIX conference on Hot Topics in Cloud Computing},
-  pages={10--10},
-  year={2012},
-  organization={USENIX Association}
-}
+  @misc{marz2013storm,
+  author = {Marz, Nathan},
+  title = {Storm: Distributed and Fault-Tolerant Realtime Computation},
+  month = {February},
+  year = {2013},
+  howpublished = "\url{http://storm-project.net/}"
+  }
 
-@misc{marz2013storm,
-author = {Marz, Nathan},
-title = {Storm: Distributed and Fault-Tolerant Realtime Computation},
-month = {February},
-year = {2013},
-howpublished = "\url{http://storm-project.net/}"
-}
+  @misc{tschetter2011druid,
+  author = {Eric Tschetter},
+  title = {Introducing Druid: Real-Time Analytics at a Billion Rows Per Second},
+  month = {April},
+  year = {2011},
+  howpublished = "\url{http://metamarkets.com/2011/druid-part-i-real-time-analytics-at-a-billion-rows-per-second/}"
+  }
 
-@article{farber2012sap,
-  title={SAP HANA database: data management for modern business applications},
-  author={F{\"a}rber, Franz and Cha, Sang Kyun and Primsch, J{\"u}rgen and Bornh{\"o}vd, Christof and Sigg, Stefan and Lehner, Wolfgang},
-  journal={ACM Sigmod Record},
-  volume={40},
-  number={4},
-  pages={45--51},
-  year={2012},
-  publisher={ACM}
-}
+  @article{farber2012sap,
+    title={SAP HANA database: data management for modern business applications},
+    author={F{\"a}rber, Franz and Cha, Sang Kyun and Primsch, J{\"u}rgen and Bornh{\"o}vd, Christof and Sigg, Stefan and Lehner, Wolfgang},
+    journal={ACM Sigmod Record},
+    volume={40},
+    number={4},
+    pages={45--51},
+    year={2012},
+    publisher={ACM}
+  }
 
-@misc{voltdb2010voltdb,
-  title={VoltDB Technical Overview},
-  author={VoltDB, LLC},
-  year={2010},
-howpublished = "\url{https://voltdb.com/}"
-}
+  @misc{voltdb2010voltdb,
+    title={VoltDB Technical Overview},
+    author={VoltDB, LLC},
+    year={2010},
+  howpublished = "\url{https://voltdb.com/}"
+  }
 
-@inproceedings{macnicol2004sybase,
-  title={Sybase IQ multiplex-designed for analytics},
-  author={MacNicol, Roger and French, Blaine},
-  booktitle={Proceedings of the Thirtieth international conference on Very large data bases-Volume 30},
-  pages={1227--1230},
-  year={2004},
-  organization={VLDB Endowment}
-}
+  @inproceedings{macnicol2004sybase,
+    title={Sybase IQ multiplex-designed for analytics},
+    author={MacNicol, Roger and French, Blaine},
+    booktitle={Proceedings of the Thirtieth international conference on Very large data bases-Volume 30},
+    pages={1227--1230},
+    year={2004},
+    organization={VLDB Endowment}
+  }
 
-@inproceedings{singh2011introduction,
-  title={Introduction to the IBM Netezza warehouse appliance},
-  author={Singh, Malcolm and Leonhardi, Ben},
-  booktitle={Proceedings of the 2011 Conference of the Center for Advanced Studies on Collaborative Research},
-  pages={385--386},
-  year={2011},
-  organization={IBM Corp.}
-}
+  @inproceedings{singh2011introduction,
+    title={Introduction to the IBM Netezza warehouse appliance},
+    author={Singh, Malcolm and Leonhardi, Ben},
+    booktitle={Proceedings of the 2011 Conference of the Center for Advanced Studies on Collaborative Research},
+    pages={385--386},
+    year={2011},
+    organization={IBM Corp.}
+  }
 
-@inproceedings{miner2012unified,
-  title={Unified analytics platform for big data},
-  author={Miner, Donald},
-  booktitle={Proceedings of the WICSA/ECSA 2012 Companion Volume},
-  pages={176--176},
-  year={2012},
-  organization={ACM}
-}
+  @inproceedings{miner2012unified,
+    title={Unified analytics platform for big data},
+    author={Miner, Donald},
+    booktitle={Proceedings of the WICSA/ECSA 2012 Companion Volume},
+    pages={176--176},
+    year={2012},
+    organization={ACM}
+  }
 
-@inproceedings{fink2012distributed,
-  title={Distributed computation on dynamo-style distributed storage: riak pipe},
-  author={Fink, Bryan},
-  booktitle={Proceedings of the eleventh ACM SIGPLAN workshop on Erlang workshop},
-  pages={43--50},
-  year={2012},
-  organization={ACM}
-}
+  @inproceedings{fink2012distributed,
+    title={Distributed computation on dynamo-style distributed storage: riak pipe},
+    author={Fink, Bryan},
+    booktitle={Proceedings of the eleventh ACM SIGPLAN workshop on Erlang workshop},
+    pages={43--50},
+    year={2012},
+    organization={ACM}
+  }
 
-@misc{paraccel2013,
-key = {ParAccel Analytic Database},
-title = {ParAccel Analytic Database},
-month = {March},
-year = {2013},
-howpublished = "\url{http://www.paraccel.com/resources/Datasheets/ParAccel-Core-Analytic-Database.pdf}"
-}
+  @misc{paraccel2013,
+  key = {ParAccel Analytic Database},
+  title = {ParAccel Analytic Database},
+  month = {March},
+  year = {2013},
+  howpublished = "\url{http://www.paraccel.com/resources/Datasheets/ParAccel-Core-Analytic-Database.pdf}"
+  }
 
-@article{barroso2009datacenter,
-  title={The datacenter as a computer: An introduction to the design of warehouse-scale machines},
-  author={Barroso, Luiz Andr{\'e} and H{\"o}lzle, Urs},
-  journal={Synthesis Lectures on Computer Architecture},
-  volume={4},
-  number={1},
-  pages={1--108},
-  year={2009},
-  publisher={Morgan \& Claypool Publishers}
-}
+  @misc{cloudera2013,
+  key = {Cloudera Impala},
+  title = {Cloudera Impala},
+  month = {March},
+  year = {2013},
+  url = {},
+  howpublished = "\url{http://blog.cloudera.com/blog}"
+  }
 
-@article{chaudhuri1997overview,
-  title={An overview of data warehousing and OLAP technology},
-  author={Chaudhuri, Surajit and Dayal, Umeshwar},
-  journal={ACM Sigmod record},
-  volume={26},
-  number={1},
-  pages={65--74},
-  year={1997}
-}
+  @inproceedings{hunt2010zookeeper,
+    title={ZooKeeper: Wait-free coordination for Internet-scale systems},
+    author={Hunt, Patrick and Konar, Mahadev and Junqueira, Flavio P and Reed, Benjamin},
+    booktitle={USENIX ATC},
+    volume={10},
+    year={2010}
+  }
 
-@article{dewitt1992parallel,
-  title={Parallel database systems: the future of high performance database systems},
-  author={DeWitt, David and Gray, Jim},
-  journal={Communications of the ACM},
-  volume={35},
-  number={6},
-  pages={85--98},
-  year={1992},
-  publisher={ACM}
-}
+  @inproceedings{kreps2011kafka,
+    title={Kafka: A distributed messaging system for log processing},
+    author={Kreps, Jay and Narkhede, Neha and Rao, Jun},
+    booktitle={Proceedings of 6th International Workshop on Networking Meets Databases (NetDB), Athens, Greece},
+    year={2011}
+  }
 
-@misc{cloudera2013,
-key = {Cloudera Impala},
-title = {Cloudera Impala},
-month = {March},
-year = {2013},
-url = {},
-howpublished = "\url{http://blog.cloudera.com/blog}"
-}
+  @misc{liblzf2013,
+  title = {LibLZF},
+  key = {LibLZF},
+  month = {March},
+  year = {2013},
+  howpublished = "\url{http://freecode.com/projects/liblzf}"
+  }
 
-@inproceedings{hunt2010zookeeper,
-  title={ZooKeeper: Wait-free coordination for Internet-scale systems},
-  author={Hunt, Patrick and Konar, Mahadev and Junqueira, Flavio P and Reed, Benjamin},
-  booktitle={USENIX ATC},
-  volume={10},
-  year={2010}
-}
+  @inproceedings{tomasic1993performance,
+    title={Performance of inverted indices in shared-nothing distributed text document information retrieval systems},
+    author={Tomasic, Anthony and Garcia-Molina, Hector},
+    booktitle={Parallel and Distributed Information Systems, 1993., Proceedings of the Second International Conference on},
+    pages={8--17},
+    year={1993},
+    organization={IEEE}
+  }
 
-@inproceedings{kreps2011kafka,
-  title={Kafka: A distributed messaging system for log processing},
-  author={Kreps, Jay and Narkhede, Neha and Rao, Jun},
-  booktitle={Proceedings of 6th International Workshop on Networking Meets Databases (NetDB), Athens, Greece},
-  year={2011}
-}
+  @inproceedings{antoshenkov1995byte,
+    title={Byte-aligned bitmap compression},
+    author={Antoshenkov, Gennady},
+    booktitle={Data Compression Conference, 1995. DCC'95. Proceedings},
+    pages={476},
+    year={1995},
+    organization={IEEE}
+  }
 
-@misc{liblzf2013,
-title = {LibLZF},
-key = {LibLZF},
-month = {March},
-year = {2013},
-howpublished = "\url{http://freecode.com/projects/liblzf}"
-}
+  @inproceedings{van2011memory,
+    title={A memory efficient reachability data structure through bit vector compression},
+    author={van Schaik, Sebastiaan J and de Moor, Oege},
+    booktitle={Proceedings of the 2011 international conference on Management of data},
+    pages={913--924},
+    year={2011},
+    organization={ACM}
+  }
 
-@inproceedings{tomasic1993performance,
-  title={Performance of inverted indices in shared-nothing distributed text document information retrieval systems},
-  author={Tomasic, Anthony and Garcia-Molina, Hector},
-  booktitle={Parallel and Distributed Information Systems, 1993., Proceedings of the Second International Conference on},
-  pages={8--17},
-  year={1993},
-  organization={IEEE}
-}
+  @inproceedings{o1993lru,
+    title={The LRU-K page replacement algorithm for database disk buffering},
+    author={O'neil, Elizabeth J and O'neil, Patrick E and Weikum, Gerhard},
+    booktitle={ACM SIGMOD Record},
+    volume={22},
+    number={2},
+    pages={297--306},
+    year={1993},
+    organization={ACM}
+  }
 
-@inproceedings{antoshenkov1995byte,
-  title={Byte-aligned bitmap compression},
-  author={Antoshenkov, Gennady},
-  booktitle={Data Compression Conference, 1995. DCC'95. Proceedings},
-  pages={476},
-  year={1995},
-  organization={IEEE}
-}
+  @article{kim2001lrfu,
+    title={LRFU: A spectrum of policies that subsumes the least recently used and least frequently used policies},
+    author={Kim, Chong Sang},
+    journal={IEEE Transactions on Computers},
+    volume={50},
+    number={12},
+    year={2001}
+  }
 
-@inproceedings{van2011memory,
-  title={A memory efficient reachability data structure through bit vector compression},
-  author={van Schaik, Sebastiaan J and de Moor, Oege},
-  booktitle={Proceedings of the 2011 international conference on Management of data},
-  pages={913--924},
-  year={2011},
-  organization={ACM}
-}
+  @article{wu2006optimizing,
+    title={Optimizing bitmap indices with efficient compression},
+    author={Wu, Kesheng and Otoo, Ekow J and Shoshani, Arie},
+    journal={ACM Transactions on Database Systems (TODS)},
+    volume={31},
+    number={1},
+    pages={1--38},
+    year={2006},
+    publisher={ACM}
+  }
 
-@inproceedings{o1993lru,
-  title={The LRU-K page replacement algorithm for database disk buffering},
-  author={O'neil, Elizabeth J and O'neil, Patrick E and Weikum, Gerhard},
-  booktitle={ACM SIGMOD Record},
-  volume={22},
-  number={2},
-  pages={297--306},
-  year={1993},
-  organization={ACM}
-}
+  @misc{twitter2013,
+  key = {Twitter Public Streams},
+  title = {Twitter Public Streams},
+  month = {March},
+  year = {2013},
+  howpublished = "\url{https://dev.twitter.com/docs/streaming-apis/streams/public}"
+  }
 
-@article{kim2001lrfu,
-  title={LRFU: A spectrum of policies that subsumes the least recently used and least frequently used policies},
-  author={Kim, Chong Sang},
-  journal={IEEE Transactions on Computers},
-  volume={50},
-  number={12},
-  year={2001}
-}
+  @article{fitzpatrick2004distributed,
+    title={Distributed caching with memcached},
+    author={Fitzpatrick, Brad},
+    journal={Linux journal},
+    number={124},
+    pages={72--74},
+    year={2004}
+  }
 
-@article{wu2006optimizing,
-  title={Optimizing bitmap indices with efficient compression},
-  author={Wu, Kesheng and Otoo, Ekow J and Shoshani, Arie},
-  journal={ACM Transactions on Database Systems (TODS)},
-  volume={31},
-  number={1},
-  pages={1--38},
-  year={2006},
-  publisher={ACM}
-}
+  @inproceedings{amdahl1967validity,
+    title={Validity of the single processor approach to achieving large scale computing capabilities},
+    author={Amdahl, Gene M},
+    booktitle={Proceedings of the April 18-20, 1967, spring joint computer conference},
+    pages={483--485},
+    year={1967},
+    organization={ACM}
+  }
+  @book{sarawagi1998discovery,
+    title={Discovery-driven exploration of OLAP data cubes},
+    author={Sarawagi, Sunita and Agrawal, Rakesh and Megiddo, Nimrod},
+    year={1998},
+    publisher={Springer}
+  }
+  @inproceedings{abadi2008column,
+    title={Column-Stores vs. Row-Stores: How different are they really?},
+    author={Abadi, Daniel J and Madden, Samuel R and Hachem, Nabil},
+    booktitle={Proceedings of the 2008 ACM SIGMOD international conference on Management of data},
+    pages={967--980},
+    year={2008},
+    organization={ACM}
+  }
+  @article{hu2011stream,
+    title={Stream Database Survey},
+    author={Hu, Bo},
+    year={2011}
+  }
 
-@misc{twitter2013,
-key = {Twitter Public Streams},
-title = {Twitter Public Streams},
-month = {March},
-year = {2013},
-howpublished = "\url{https://dev.twitter.com/docs/streaming-apis/streams/public}"
-}
+  @article{dean2008mapreduce,
+    title={MapReduce: simplified data processing on large clusters},
+    author={Dean, Jeffrey and Ghemawat, Sanjay},
+    journal={Communications of the ACM},
+    volume={51},
+    number={1},
+    pages={107--113},
+    year={2008},
+    publisher={ACM}
+  }
 
-@article{fitzpatrick2004distributed,
-  title={Distributed caching with memcached},
-  author={Fitzpatrick, Brad},
-  journal={Linux journal},
-  number={124},
-  pages={72--74},
-  year={2004}
-}
+  @misc{linkedin2013senseidb,
+  author = {LinkedIn},
+  title = {SenseiDB},
+  month = {July},
+  year = {2013},
+  howpublished = "\url{http://www.senseidb.com/}"
+  }
 
-@inproceedings{amdahl1967validity,
-  title={Validity of the single processor approach to achieving large scale computing capabilities},
-  author={Amdahl, Gene M},
-  booktitle={Proceedings of the April 18-20, 1967, spring joint computer conference},
-  pages={483--485},
-  year={1967},
-  organization={ACM}
-}
+  @misc{apache2013solr,
+  author = {Apache},
+  title = {Apache Solr},
+  month = {February},
+  year = {2013},
+  howpublished = "\url{http://lucene.apache.org/solr/}"
+  }
+
+  @misc{banon2013elasticsearch,
+  author = {Banon, Shay},
+  title = {ElasticSearch},
+  month = {July},
+  year = {2013},
+  howpublished = "\url{http://www.elasticseach.com/}"
+  }

server/src/main/java/io/druid/guice/QueryRunnerFactoryModule.java

@@ -31,6 +31,8 @@ import io.druid.query.metadata.SegmentMetadataQueryRunnerFactory;
 import io.druid.query.metadata.metadata.SegmentMetadataQuery;
 import io.druid.query.search.SearchQueryRunnerFactory;
 import io.druid.query.search.search.SearchQuery;
+import io.druid.query.select.SelectQuery;
+import io.druid.query.select.SelectQueryRunnerFactory;
 import io.druid.query.timeboundary.TimeBoundaryQuery;
 import io.druid.query.timeboundary.TimeBoundaryQueryRunnerFactory;
 import io.druid.query.timeseries.TimeseriesQuery;
@@ -49,6 +51,7 @@ public class QueryRunnerFactoryModule extends QueryToolChestModule
                   .put(TimeBoundaryQuery.class, TimeBoundaryQueryRunnerFactory.class)
                   .put(SegmentMetadataQuery.class, SegmentMetadataQueryRunnerFactory.class)
                   .put(GroupByQuery.class, GroupByQueryRunnerFactory.class)
+                  .put(SelectQuery.class, SelectQueryRunnerFactory.class)
                   .build();
 
   @Override