You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@calcite.apache.org by mm...@apache.org on 2017/09/05 14:36:48 UTC
[05/16] calcite git commit: [CALCITE-1967] Elasticsearch 5 adapter
(Christian Beikov)
[CALCITE-1967] Elasticsearch 5 adapter (Christian Beikov)
Move code that is independent of Elasticsearch into a
org.apache.calcite.adapter.elasticsearch package under core. It
provides abstract classes that the elasticsearch2 and elasticsearch5
modules make concrete.
Close apache/calcite#528
Project: http://git-wip-us.apache.org/repos/asf/calcite/repo
Commit: http://git-wip-us.apache.org/repos/asf/calcite/commit/e1525926
Tree: http://git-wip-us.apache.org/repos/asf/calcite/tree/e1525926
Diff: http://git-wip-us.apache.org/repos/asf/calcite/diff/e1525926
Branch: refs/heads/branch-1.14
Commit: e1525926790b058ae1845db32dcbf59b80ed270e
Parents: 2156d82
Author: Christian Beikov <ch...@gmail.com>
Authored: Thu Aug 24 16:28:50 2017 +0200
Committer: Julian Hyde <jh...@apache.org>
Committed: Tue Aug 29 10:12:29 2017 -0700
----------------------------------------------------------------------
.../AbstractElasticsearchTable.java | 128 ++++++++
.../elasticsearch/ElasticsearchFilter.java | 297 +++++++++++++++++++
.../elasticsearch/ElasticsearchMethod.java | 50 ++++
.../elasticsearch/ElasticsearchProject.java | 98 ++++++
.../adapter/elasticsearch/ElasticsearchRel.java | 58 ++++
.../elasticsearch/ElasticsearchRules.java | 238 +++++++++++++++
.../elasticsearch/ElasticsearchSchema.java | 33 +++
.../elasticsearch/ElasticsearchSort.java | 104 +++++++
.../elasticsearch/ElasticsearchTableScan.java | 90 ++++++
.../ElasticsearchToEnumerableConverter.java | 124 ++++++++
.../ElasticsearchToEnumerableConverterRule.java | 42 +++
.../MapProjectionFieldVisitor.java | 42 +++
.../adapter/elasticsearch/package-info.java | 26 ++
elasticsearch/pom.xml | 148 ---------
.../elasticsearch/ElasticsearchEnumerator.java | 151 ----------
.../elasticsearch/ElasticsearchFilter.java | 287 ------------------
.../elasticsearch/ElasticsearchMethod.java | 50 ----
.../elasticsearch/ElasticsearchProject.java | 95 ------
.../adapter/elasticsearch/ElasticsearchRel.java | 58 ----
.../elasticsearch/ElasticsearchRules.java | 236 ---------------
.../elasticsearch/ElasticsearchSchema.java | 127 --------
.../ElasticsearchSchemaFactory.java | 63 ----
.../elasticsearch/ElasticsearchSort.java | 93 ------
.../elasticsearch/ElasticsearchTable.java | 152 ----------
.../elasticsearch/ElasticsearchTableScan.java | 88 ------
.../ElasticsearchToEnumerableConverter.java | 124 --------
.../ElasticsearchToEnumerableConverterRule.java | 42 ---
.../adapter/elasticsearch/package-info.java | 26 --
.../calcite/test/ElasticsearchAdapterIT.java | 270 -----------------
.../resources/elasticsearch-zips-model.json | 50 ----
.../src/test/resources/log4j.properties | 24 --
elasticsearch2/pom.xml | 148 +++++++++
.../Elasticsearch2Enumerator.java | 152 ++++++++++
.../elasticsearch2/Elasticsearch2Schema.java | 134 +++++++++
.../Elasticsearch2SchemaFactory.java | 63 ++++
.../elasticsearch2/Elasticsearch2Table.java | 66 +++++
.../adapter/elasticsearch2/package-info.java | 26 ++
.../calcite/test/Elasticsearch2AdapterIT.java | 270 +++++++++++++++++
.../resources/elasticsearch-zips-model.json | 50 ++++
.../src/test/resources/log4j.properties | 24 ++
elasticsearch5/pom.xml | 153 ++++++++++
.../Elasticsearch5Enumerator.java | 154 ++++++++++
.../elasticsearch5/Elasticsearch5Schema.java | 138 +++++++++
.../Elasticsearch5SchemaFactory.java | 63 ++++
.../elasticsearch5/Elasticsearch5Table.java | 86 ++++++
.../adapter/elasticsearch5/package-info.java | 26 ++
.../calcite/test/Elasticsearch5AdapterIT.java | 270 +++++++++++++++++
.../resources/elasticsearch-zips-model.json | 50 ++++
.../src/test/resources/log4j.properties | 24 ++
pom.xml | 4 +-
site/_docs/adapter.md | 5 +-
site/_docs/elasticsearch_adapter.md | 5 +-
sqlline | 2 +-
sqlline.bat | 2 +-
54 files changed, 3240 insertions(+), 2089 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/calcite/blob/e1525926/core/src/main/java/org/apache/calcite/adapter/elasticsearch/AbstractElasticsearchTable.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/adapter/elasticsearch/AbstractElasticsearchTable.java b/core/src/main/java/org/apache/calcite/adapter/elasticsearch/AbstractElasticsearchTable.java
new file mode 100644
index 0000000..0980469
--- /dev/null
+++ b/core/src/main/java/org/apache/calcite/adapter/elasticsearch/AbstractElasticsearchTable.java
@@ -0,0 +1,128 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF 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 org.apache.calcite.adapter.elasticsearch;
+
+import org.apache.calcite.adapter.java.AbstractQueryableTable;
+import org.apache.calcite.linq4j.Enumerable;
+import org.apache.calcite.linq4j.Enumerator;
+import org.apache.calcite.linq4j.QueryProvider;
+import org.apache.calcite.linq4j.Queryable;
+import org.apache.calcite.plan.RelOptCluster;
+import org.apache.calcite.plan.RelOptTable;
+import org.apache.calcite.rel.RelNode;
+import org.apache.calcite.rel.type.RelDataType;
+import org.apache.calcite.rel.type.RelDataTypeFactory;
+import org.apache.calcite.schema.SchemaPlus;
+import org.apache.calcite.schema.TranslatableTable;
+import org.apache.calcite.schema.impl.AbstractTableQueryable;
+import org.apache.calcite.sql.type.SqlTypeName;
+
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Table based on an Elasticsearch type.
+ */
+public abstract class AbstractElasticsearchTable extends AbstractQueryableTable
+ implements TranslatableTable {
+ protected final String indexName;
+ protected final String typeName;
+
+ /**
+ * Creates an ElasticsearchTable.
+ */
+ public AbstractElasticsearchTable(String indexName, String typeName) {
+ super(Object[].class);
+ this.indexName = indexName;
+ this.typeName = typeName;
+ }
+
+ @Override public String toString() {
+ return "ElasticsearchTable{" + typeName + "}";
+ }
+
+ public RelDataType getRowType(RelDataTypeFactory relDataTypeFactory) {
+ final RelDataType mapType = relDataTypeFactory.createMapType(
+ relDataTypeFactory.createSqlType(SqlTypeName.VARCHAR),
+ relDataTypeFactory.createTypeWithNullability(
+ relDataTypeFactory.createSqlType(SqlTypeName.ANY),
+ true));
+ return relDataTypeFactory.builder().add("_MAP", mapType).build();
+ }
+
+ public <T> Queryable<T> asQueryable(QueryProvider queryProvider, SchemaPlus schema,
+ String tableName) {
+ return new ElasticsearchQueryable<>(queryProvider, schema, this, tableName);
+ }
+
+ public RelNode toRel(RelOptTable.ToRelContext context, RelOptTable relOptTable) {
+ final RelOptCluster cluster = context.getCluster();
+ return new ElasticsearchTableScan(cluster, cluster.traitSetOf(ElasticsearchRel.CONVENTION),
+ relOptTable, this, null);
+ }
+
+ /** Executes a "find" operation on the underlying type.
+ *
+ * <p>For example,
+ * <code>client.prepareSearch(index).setTypes(type)
+ * .setSource("{\"fields\" : [\"state\"]}")</code></p>
+ *
+ * @param index Elasticsearch index
+ * @param ops List of operations represented as Json strings.
+ * @param fields List of fields to project; or null to return map
+ * @return Enumerator of results
+ */
+ protected abstract Enumerable<Object> find(String index, List<String> ops,
+ List<Map.Entry<String, Class>> fields);
+
+ /**
+ * Implementation of {@link Queryable} based on
+ * a {@link AbstractElasticsearchTable}.
+ *
+ * @param <T> element type
+ */
+ public static class ElasticsearchQueryable<T> extends AbstractTableQueryable<T> {
+ public ElasticsearchQueryable(QueryProvider queryProvider, SchemaPlus schema,
+ AbstractElasticsearchTable table, String tableName) {
+ super(queryProvider, schema, table, tableName);
+ }
+
+ public Enumerator<T> enumerator() {
+ return null;
+ }
+
+ private String getIndex() {
+ return schema.unwrap(ElasticsearchSchema.class).getIndex();
+ }
+
+ private AbstractElasticsearchTable getTable() {
+ return (AbstractElasticsearchTable) table;
+ }
+
+ /** Called via code-generation.
+ *
+ * @see ElasticsearchMethod#ELASTICSEARCH_QUERYABLE_FIND
+ */
+ @SuppressWarnings("UnusedDeclaration")
+ public Enumerable<Object> find(List<String> ops,
+ List<Map.Entry<String, Class>> fields) {
+ return getTable().find(getIndex(), ops, fields);
+ }
+ }
+}
+
+// End AbstractElasticsearchTable.java
http://git-wip-us.apache.org/repos/asf/calcite/blob/e1525926/core/src/main/java/org/apache/calcite/adapter/elasticsearch/ElasticsearchFilter.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/adapter/elasticsearch/ElasticsearchFilter.java b/core/src/main/java/org/apache/calcite/adapter/elasticsearch/ElasticsearchFilter.java
new file mode 100644
index 0000000..c1bc317
--- /dev/null
+++ b/core/src/main/java/org/apache/calcite/adapter/elasticsearch/ElasticsearchFilter.java
@@ -0,0 +1,297 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF 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 org.apache.calcite.adapter.elasticsearch;
+
+import org.apache.calcite.plan.RelOptCluster;
+import org.apache.calcite.plan.RelOptCost;
+import org.apache.calcite.plan.RelOptPlanner;
+import org.apache.calcite.plan.RelOptUtil;
+import org.apache.calcite.plan.RelTraitSet;
+import org.apache.calcite.rel.RelNode;
+import org.apache.calcite.rel.core.Filter;
+import org.apache.calcite.rel.core.Project;
+import org.apache.calcite.rel.metadata.RelMetadataQuery;
+import org.apache.calcite.rex.RexCall;
+import org.apache.calcite.rex.RexInputRef;
+import org.apache.calcite.rex.RexLiteral;
+import org.apache.calcite.rex.RexNode;
+import org.apache.calcite.util.JsonBuilder;
+import org.apache.calcite.util.Pair;
+
+import com.google.common.collect.HashMultimap;
+import com.google.common.collect.Multimap;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+
+
+/**
+ * Implementation of a {@link org.apache.calcite.rel.core.Filter}
+ * relational expression in Elasticsearch.
+ */
+public class ElasticsearchFilter extends Filter implements ElasticsearchRel {
+ public ElasticsearchFilter(RelOptCluster cluster, RelTraitSet traitSet, RelNode child,
+ RexNode condition) {
+ super(cluster, traitSet, child, condition);
+ assert getConvention() == ElasticsearchRel.CONVENTION;
+ assert getConvention() == child.getConvention();
+ }
+
+ @Override public RelOptCost computeSelfCost(RelOptPlanner planner, RelMetadataQuery mq) {
+ return super.computeSelfCost(planner, mq).multiplyBy(0.1);
+ }
+
+ @Override public Filter copy(RelTraitSet relTraitSet, RelNode input, RexNode condition) {
+ return new ElasticsearchFilter(getCluster(), relTraitSet, input, condition);
+ }
+
+ @Override public void implement(Implementor implementor) {
+ implementor.visitChild(0, getInput());
+ List<String> fieldNames;
+ if (input instanceof Project) {
+ final List<RexNode> projects = ((Project) input).getProjects();
+ fieldNames = new ArrayList<>(projects.size());
+ for (RexNode project : projects) {
+ String name = project.accept(MapProjectionFieldVisitor.INSTANCE);
+ fieldNames.add(name);
+ }
+ } else {
+ fieldNames = ElasticsearchRules.elasticsearchFieldNames(getRowType());
+ }
+ Translator translator = new Translator(fieldNames);
+ String match = translator.translateMatch(condition);
+ implementor.add(match);
+ }
+
+ /**
+ * Translates {@link RexNode} expressions into Elasticsearch expression strings.
+ */
+ static class Translator {
+ final JsonBuilder builder = new JsonBuilder();
+ final Multimap<String, Pair<String, RexLiteral>> multimap =
+ HashMultimap.create();
+ final Map<String, RexLiteral> eqMap = new LinkedHashMap<>();
+ private final List<String> fieldNames;
+
+ Translator(List<String> fieldNames) {
+ this.fieldNames = fieldNames;
+ }
+
+ private String translateMatch(RexNode condition) {
+ // filter node
+ final Map<String, Object> filterMap = new LinkedHashMap<>();
+ filterMap.put("filter", translateOr(condition));
+
+ // constant_score node
+ final Map<String, Object> map = builder.map();
+ map.put("constant_score", filterMap);
+
+ return "\"query\" : " + builder.toJsonString(map).replaceAll("\\s+", "")
+ .toLowerCase(Locale.ROOT);
+ }
+
+ private Object translateOr(RexNode condition) {
+ final List<Object> list = new ArrayList<>();
+
+ final List<RexNode> orNodes = RelOptUtil.disjunctions(condition);
+ for (RexNode node : orNodes) {
+ List<Map<String, Object>> andNodes = translateAnd(node);
+
+ if (andNodes.size() > 0) {
+ Map<String, Object> andClause = new HashMap<>();
+ andClause.put("must", andNodes);
+
+ // boolean filters
+ LinkedHashMap<String, Object> filterEvaluator = new LinkedHashMap<>();
+ filterEvaluator.put("bool", andClause);
+ list.add(filterEvaluator);
+ } else {
+ list.add(andNodes.get(0));
+ }
+ }
+
+ if (orNodes.size() > 1) {
+ Map<String, Object> map = builder.map();
+ map.put("should", list);
+
+ // boolean filters
+ LinkedHashMap<String, Object> filterEvaluator = new LinkedHashMap<>();
+ filterEvaluator.put("bool", map);
+ return filterEvaluator;
+ } else {
+ return list.get(0);
+ }
+ }
+
+ private void addPredicate(Map<String, Object> map, String op, Object v) {
+ if (map.containsKey(op) && stronger(op, map.get(op), v)) {
+ return;
+ }
+ map.put(op, v);
+ }
+
+ /**
+ * Translates a condition that may be an AND of other conditions. Gathers
+ * together conditions that apply to the same field.
+ */
+ private List<Map<String, Object>> translateAnd(RexNode node0) {
+ eqMap.clear();
+ multimap.clear();
+ for (RexNode node : RelOptUtil.conjunctions(node0)) {
+ translateMatch2(node);
+ }
+ List<Map<String, Object>> filters = new ArrayList<>();
+ for (Map.Entry<String, RexLiteral> entry : eqMap.entrySet()) {
+ multimap.removeAll(entry.getKey());
+
+ Map<String, Object> filter = new HashMap<>();
+ filter.put(entry.getKey(), literalValue(entry.getValue()));
+
+ Map<String, Object> map = new HashMap<>();
+ map.put("term", filter);
+ filters.add(map);
+ }
+ for (Map.Entry<String, Collection<Pair<String, RexLiteral>>> entry
+ : multimap.asMap().entrySet()) {
+ Map<String, Object> map2 = builder.map();
+
+ Map<String, Object> map = new HashMap<>();
+ for (Pair<String, RexLiteral> s : entry.getValue()) {
+ if (!s.left.equals("not")) {
+ addPredicate(map2, s.left, literalValue(s.right));
+
+ Map<String, Object> filter = new HashMap<>();
+ filter.put(entry.getKey(), map2);
+
+ map.put("range", filter);
+ } else {
+ map2.put(entry.getKey(), literalValue(s.right));
+
+ Map<String, Object> termMap = new HashMap<>();
+ termMap.put("term", map2);
+
+ map.put("not", termMap);
+ }
+ }
+ filters.add(map);
+ }
+ return filters;
+ }
+
+ private boolean stronger(String key, Object v0, Object v1) {
+ if (key.equals("lt") || key.equals("lte")) {
+ if (v0 instanceof Number && v1 instanceof Number) {
+ return ((Number) v0).doubleValue() < ((Number) v1).doubleValue();
+ }
+ if (v0 instanceof String && v1 instanceof String) {
+ return v0.toString().compareTo(v1.toString()) < 0;
+ }
+ }
+ if (key.equals("gt") || key.equals("gte")) {
+ return stronger("lt", v1, v0);
+ }
+ return false;
+ }
+
+ private static Object literalValue(RexLiteral literal) {
+ return literal.getValue2();
+ }
+
+ private Void translateMatch2(RexNode node) {
+ switch (node.getKind()) {
+ case EQUALS:
+ return translateBinary(null, null, (RexCall) node);
+ case LESS_THAN:
+ return translateBinary("lt", "gt", (RexCall) node);
+ case LESS_THAN_OR_EQUAL:
+ return translateBinary("lte", "gte", (RexCall) node);
+ case NOT_EQUALS:
+ return translateBinary("not", "not", (RexCall) node);
+ case GREATER_THAN:
+ return translateBinary("gt", "lt", (RexCall) node);
+ case GREATER_THAN_OR_EQUAL:
+ return translateBinary("gte", "lte", (RexCall) node);
+ default:
+ throw new AssertionError("cannot translate " + node);
+ }
+ }
+
+ /**
+ * Translates a call to a binary operator, reversing arguments if
+ * necessary.
+ */
+ private Void translateBinary(String op, String rop, RexCall call) {
+ final RexNode left = call.operands.get(0);
+ final RexNode right = call.operands.get(1);
+ boolean b = translateBinary2(op, left, right);
+ if (b) {
+ return null;
+ }
+ b = translateBinary2(rop, right, left);
+ if (b) {
+ return null;
+ }
+ throw new AssertionError("cannot translate op " + op + " call " + call);
+ }
+
+ /**
+ * Translates a call to a binary operator. Returns whether successful.
+ */
+ private boolean translateBinary2(String op, RexNode left, RexNode right) {
+ switch (right.getKind()) {
+ case LITERAL:
+ break;
+ default:
+ return false;
+ }
+ final RexLiteral rightLiteral = (RexLiteral) right;
+ switch (left.getKind()) {
+ case INPUT_REF:
+ final RexInputRef left1 = (RexInputRef) left;
+ String name = fieldNames.get(left1.getIndex());
+ translateOp2(op, name, rightLiteral);
+ return true;
+ case CAST:
+ return translateBinary2(op, ((RexCall) left).operands.get(0), right);
+ case OTHER_FUNCTION:
+ String itemName = ElasticsearchRules.isItem((RexCall) left);
+ if (itemName != null) {
+ translateOp2(op, itemName, rightLiteral);
+ return true;
+ }
+ // fall through
+ default:
+ return false;
+ }
+ }
+
+ private void translateOp2(String op, String name, RexLiteral right) {
+ if (op == null) {
+ eqMap.put(name, right);
+ } else {
+ multimap.put(name, Pair.of(op, right));
+ }
+ }
+ }
+}
+
+// End ElasticsearchFilter.java
http://git-wip-us.apache.org/repos/asf/calcite/blob/e1525926/core/src/main/java/org/apache/calcite/adapter/elasticsearch/ElasticsearchMethod.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/adapter/elasticsearch/ElasticsearchMethod.java b/core/src/main/java/org/apache/calcite/adapter/elasticsearch/ElasticsearchMethod.java
new file mode 100644
index 0000000..72753e6
--- /dev/null
+++ b/core/src/main/java/org/apache/calcite/adapter/elasticsearch/ElasticsearchMethod.java
@@ -0,0 +1,50 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF 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 org.apache.calcite.adapter.elasticsearch;
+
+import org.apache.calcite.linq4j.tree.Types;
+
+import com.google.common.collect.ImmutableMap;
+
+import java.lang.reflect.Method;
+import java.util.List;
+
+/**
+ * Builtin methods in the Elasticsearch adapter.
+ */
+enum ElasticsearchMethod {
+ ELASTICSEARCH_QUERYABLE_FIND(AbstractElasticsearchTable.ElasticsearchQueryable.class,
+ "find", List.class, List.class);
+
+ public final Method method;
+
+ public static final ImmutableMap<Method, ElasticsearchMethod> MAP;
+
+ static {
+ final ImmutableMap.Builder<Method, ElasticsearchMethod> builder = ImmutableMap.builder();
+ for (ElasticsearchMethod value: ElasticsearchMethod.values()) {
+ builder.put(value.method, value);
+ }
+ MAP = builder.build();
+ }
+
+ ElasticsearchMethod(Class clazz, String methodName, Class... argumentTypes) {
+ this.method = Types.lookupMethod(clazz, methodName, argumentTypes);
+ }
+}
+
+// End ElasticsearchMethod.java
http://git-wip-us.apache.org/repos/asf/calcite/blob/e1525926/core/src/main/java/org/apache/calcite/adapter/elasticsearch/ElasticsearchProject.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/adapter/elasticsearch/ElasticsearchProject.java b/core/src/main/java/org/apache/calcite/adapter/elasticsearch/ElasticsearchProject.java
new file mode 100644
index 0000000..b42abd7
--- /dev/null
+++ b/core/src/main/java/org/apache/calcite/adapter/elasticsearch/ElasticsearchProject.java
@@ -0,0 +1,98 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF 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 org.apache.calcite.adapter.elasticsearch;
+
+import org.apache.calcite.adapter.java.JavaTypeFactory;
+import org.apache.calcite.plan.RelOptCluster;
+import org.apache.calcite.plan.RelOptCost;
+import org.apache.calcite.plan.RelOptPlanner;
+import org.apache.calcite.plan.RelTraitSet;
+import org.apache.calcite.rel.RelNode;
+import org.apache.calcite.rel.core.Project;
+import org.apache.calcite.rel.metadata.RelMetadataQuery;
+import org.apache.calcite.rel.type.RelDataType;
+import org.apache.calcite.rex.RexNode;
+import org.apache.calcite.util.Pair;
+import org.apache.calcite.util.Util;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Implementation of {@link org.apache.calcite.rel.core.Project}
+ * relational expression in Elasticsearch.
+ */
+public class ElasticsearchProject extends Project implements ElasticsearchRel {
+ public ElasticsearchProject(RelOptCluster cluster, RelTraitSet traitSet, RelNode input,
+ List<? extends RexNode> projects, RelDataType rowType) {
+ super(cluster, traitSet, input, projects, rowType);
+ assert getConvention() == ElasticsearchRel.CONVENTION;
+ assert getConvention() == input.getConvention();
+ }
+
+ @Override public Project copy(RelTraitSet relTraitSet, RelNode input, List<RexNode> projects,
+ RelDataType relDataType) {
+ return new ElasticsearchProject(getCluster(), traitSet, input, projects, relDataType);
+ }
+
+ @Override public RelOptCost computeSelfCost(RelOptPlanner planner, RelMetadataQuery mq) {
+ return super.computeSelfCost(planner, mq).multiplyBy(0.1);
+ }
+
+ @Override public void implement(Implementor implementor) {
+ implementor.visitChild(0, getInput());
+
+ final List<String> inFields =
+ ElasticsearchRules.elasticsearchFieldNames(getInput().getRowType());
+ final ElasticsearchRules.RexToElasticsearchTranslator translator =
+ new ElasticsearchRules.RexToElasticsearchTranslator(
+ (JavaTypeFactory) getCluster().getTypeFactory(), inFields);
+
+ final List<String> findItems = new ArrayList<>();
+ final List<String> scriptFieldItems = new ArrayList<>();
+ for (Pair<RexNode, String> pair: getNamedProjects()) {
+ final String name = pair.right;
+ final String expr = pair.left.accept(translator);
+
+ if (expr.equals("\"" + name + "\"")) {
+ findItems.add(ElasticsearchRules.quote(name));
+ } else if (expr.matches("\"literal\":.+")) {
+ scriptFieldItems.add(ElasticsearchRules.quote(name)
+ + ":{\"script\": "
+ + expr.split(":")[1] + "}");
+ } else {
+ scriptFieldItems.add(ElasticsearchRules.quote(name)
+ + ":{\"script\":\"params._source."
+ + expr.replaceAll("\"", "") + "\"}");
+ }
+ }
+ final String findString = Util.toString(findItems, "", ", ", "");
+ final String scriptFieldString = "\"script_fields\": {"
+ + Util.toString(scriptFieldItems, "", ", ", "") + "}";
+ final String fieldString = "\"_source\" : [" + findString + "]"
+ + ", " + scriptFieldString;
+
+ for (String opfield : implementor.list) {
+ if (opfield.startsWith("\"_source\"")) {
+ implementor.list.remove(opfield);
+ }
+ }
+ implementor.add(fieldString);
+ }
+}
+
+// End ElasticsearchProject.java
http://git-wip-us.apache.org/repos/asf/calcite/blob/e1525926/core/src/main/java/org/apache/calcite/adapter/elasticsearch/ElasticsearchRel.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/adapter/elasticsearch/ElasticsearchRel.java b/core/src/main/java/org/apache/calcite/adapter/elasticsearch/ElasticsearchRel.java
new file mode 100644
index 0000000..436adf9
--- /dev/null
+++ b/core/src/main/java/org/apache/calcite/adapter/elasticsearch/ElasticsearchRel.java
@@ -0,0 +1,58 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF 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 org.apache.calcite.adapter.elasticsearch;
+
+import org.apache.calcite.plan.Convention;
+import org.apache.calcite.plan.RelOptTable;
+import org.apache.calcite.rel.RelNode;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Relational expression that uses Elasticsearch calling convention.
+ */
+public interface ElasticsearchRel extends RelNode {
+ void implement(Implementor implementor);
+
+ /**
+ * Calling convention for relational operations that occur in Elasticsearch.
+ */
+ Convention CONVENTION = new Convention.Impl("ELASTICSEARCH", ElasticsearchRel.class);
+
+ /**
+ * Callback for the implementation process that converts a tree of
+ * {@link ElasticsearchRel} nodes into an Elasticsearch query.
+ */
+ class Implementor {
+ final List<String> list = new ArrayList<>();
+
+ RelOptTable table;
+ AbstractElasticsearchTable elasticsearchTable;
+
+ public void add(String findOp) {
+ list.add(findOp);
+ }
+
+ public void visitChild(int ordinal, RelNode input) {
+ assert ordinal == 0;
+ ((ElasticsearchRel) input).implement(this);
+ }
+ }
+}
+
+// End ElasticsearchRel.java
http://git-wip-us.apache.org/repos/asf/calcite/blob/e1525926/core/src/main/java/org/apache/calcite/adapter/elasticsearch/ElasticsearchRules.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/adapter/elasticsearch/ElasticsearchRules.java b/core/src/main/java/org/apache/calcite/adapter/elasticsearch/ElasticsearchRules.java
new file mode 100644
index 0000000..c4f6728
--- /dev/null
+++ b/core/src/main/java/org/apache/calcite/adapter/elasticsearch/ElasticsearchRules.java
@@ -0,0 +1,238 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF 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 org.apache.calcite.adapter.elasticsearch;
+
+import org.apache.calcite.adapter.enumerable.RexImpTable;
+import org.apache.calcite.adapter.enumerable.RexToLixTranslator;
+import org.apache.calcite.adapter.java.JavaTypeFactory;
+import org.apache.calcite.plan.Convention;
+import org.apache.calcite.plan.RelOptRule;
+import org.apache.calcite.plan.RelTrait;
+import org.apache.calcite.plan.RelTraitSet;
+import org.apache.calcite.rel.RelCollations;
+import org.apache.calcite.rel.RelNode;
+import org.apache.calcite.rel.convert.ConverterRule;
+import org.apache.calcite.rel.core.Sort;
+import org.apache.calcite.rel.logical.LogicalFilter;
+import org.apache.calcite.rel.logical.LogicalProject;
+import org.apache.calcite.rel.type.RelDataType;
+import org.apache.calcite.rex.RexCall;
+import org.apache.calcite.rex.RexInputRef;
+import org.apache.calcite.rex.RexLiteral;
+import org.apache.calcite.rex.RexNode;
+import org.apache.calcite.rex.RexVisitorImpl;
+import org.apache.calcite.sql.SqlKind;
+import org.apache.calcite.sql.fun.SqlStdOperatorTable;
+import org.apache.calcite.sql.type.SqlTypeName;
+import org.apache.calcite.sql.validate.SqlValidatorUtil;
+
+import java.util.AbstractList;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Rules and relational operators for
+ * {@link ElasticsearchRel#CONVENTION ELASTICSEARCH}
+ * calling convention.
+ */
+class ElasticsearchRules {
+ static final RelOptRule[] RULES = {
+ ElasticsearchSortRule.INSTANCE,
+ ElasticsearchFilterRule.INSTANCE,
+ ElasticsearchProjectRule.INSTANCE
+ };
+
+ private ElasticsearchRules() {}
+
+ /**
+ * Returns 'string' if it is a call to item['string'], null otherwise.
+ */
+ static String isItem(RexCall call) {
+ if (call.getOperator() != SqlStdOperatorTable.ITEM) {
+ return null;
+ }
+ final RexNode op0 = call.getOperands().get(0);
+ final RexNode op1 = call.getOperands().get(1);
+
+ if (op0 instanceof RexInputRef
+ && ((RexInputRef) op0).getIndex() == 0
+ && op1 instanceof RexLiteral
+ && ((RexLiteral) op1).getValue2() instanceof String) {
+ return (String) ((RexLiteral) op1).getValue2();
+ }
+ return null;
+ }
+
+ static List<String> elasticsearchFieldNames(final RelDataType rowType) {
+ return SqlValidatorUtil.uniquify(
+ new AbstractList<String>() {
+ @Override public String get(int index) {
+ final String name = rowType.getFieldList().get(index).getName();
+ return name.startsWith("$") ? "_" + name.substring(2) : name;
+ }
+
+ @Override public int size() {
+ return rowType.getFieldCount();
+ }
+ },
+ SqlValidatorUtil.EXPR_SUGGESTER, true);
+ }
+
+ static String quote(String s) {
+ return "\"" + s + "\"";
+ }
+
+ /**
+ * Translator from {@link RexNode} to strings in Elasticsearch's expression
+ * language.
+ */
+ static class RexToElasticsearchTranslator extends RexVisitorImpl<String> {
+ private final JavaTypeFactory typeFactory;
+ private final List<String> inFields;
+
+ RexToElasticsearchTranslator(JavaTypeFactory typeFactory, List<String> inFields) {
+ super(true);
+ this.typeFactory = typeFactory;
+ this.inFields = inFields;
+ }
+
+ @Override public String visitLiteral(RexLiteral literal) {
+ if (literal.getValue() == null) {
+ return "null";
+ }
+ return "\"literal\":\""
+ + RexToLixTranslator.translateLiteral(literal, literal.getType(),
+ typeFactory, RexImpTable.NullAs.NOT_POSSIBLE)
+ + "\"";
+ }
+
+ @Override public String visitInputRef(RexInputRef inputRef) {
+ return quote(inFields.get(inputRef.getIndex()));
+ }
+
+ @Override public String visitCall(RexCall call) {
+ final String name = isItem(call);
+ if (name != null) {
+ return "\"" + name + "\"";
+ }
+
+ final List<String> strings = visitList(call.operands);
+ if (call.getKind() == SqlKind.CAST) {
+ return strings.get(0).startsWith("$") ? strings.get(0).substring(1) : strings.get(0);
+ }
+ if (call.getOperator() == SqlStdOperatorTable.ITEM) {
+ final RexNode op1 = call.getOperands().get(1);
+ if (op1 instanceof RexLiteral && op1.getType().getSqlTypeName() == SqlTypeName.INTEGER) {
+ return stripQuotes(strings.get(0)) + "[" + ((RexLiteral) op1).getValue2() + "]";
+ }
+ }
+ throw new IllegalArgumentException("Translation of " + call.toString()
+ + "is not supported by ElasticsearchProject");
+ }
+
+ private String stripQuotes(String s) {
+ return s.startsWith("'") && s.endsWith("'") ? s.substring(1, s.length() - 1) : s;
+ }
+
+ List<String> visitList(List<RexNode> list) {
+ final List<String> strings = new ArrayList<>();
+ for (RexNode node: list) {
+ strings.add(node.accept(this));
+ }
+ return strings;
+ }
+ }
+
+ /**
+ * Base class for planner rules that convert a relational expression to
+ * Elasticsearch calling convention.
+ */
+ abstract static class ElasticsearchConverterRule extends ConverterRule {
+ final Convention out;
+
+ ElasticsearchConverterRule(Class<? extends RelNode> clazz, RelTrait in, Convention out,
+ String description) {
+ super(clazz, in, out, description);
+ this.out = out;
+ }
+ }
+
+ /**
+ * Rule to convert a {@link org.apache.calcite.rel.core.Sort} to an
+ * {@link ElasticsearchSort}.
+ */
+ private static class ElasticsearchSortRule extends ElasticsearchConverterRule {
+ private static final ElasticsearchSortRule INSTANCE =
+ new ElasticsearchSortRule();
+
+ private ElasticsearchSortRule() {
+ super(Sort.class, Convention.NONE, ElasticsearchRel.CONVENTION,
+ "ElasticsearchSortRule");
+ }
+
+ @Override public RelNode convert(RelNode relNode) {
+ final Sort sort = (Sort) relNode;
+ final RelTraitSet traitSet = sort.getTraitSet().replace(out).replace(sort.getCollation());
+ return new ElasticsearchSort(relNode.getCluster(), traitSet,
+ convert(sort.getInput(), traitSet.replace(RelCollations.EMPTY)), sort.getCollation(),
+ sort.offset, sort.fetch);
+ }
+ }
+
+ /**
+ * Rule to convert a {@link org.apache.calcite.rel.logical.LogicalFilter} to an
+ * {@link ElasticsearchFilter}.
+ */
+ private static class ElasticsearchFilterRule extends ElasticsearchConverterRule {
+ private static final ElasticsearchFilterRule INSTANCE = new ElasticsearchFilterRule();
+
+ private ElasticsearchFilterRule() {
+ super(LogicalFilter.class, Convention.NONE, ElasticsearchRel.CONVENTION,
+ "ElasticsearchFilterRule");
+ }
+
+ @Override public RelNode convert(RelNode relNode) {
+ final LogicalFilter filter = (LogicalFilter) relNode;
+ final RelTraitSet traitSet = filter.getTraitSet().replace(out);
+ return new ElasticsearchFilter(relNode.getCluster(), traitSet,
+ convert(filter.getInput(), out),
+ filter.getCondition());
+ }
+ }
+
+ /**
+ * Rule to convert a {@link org.apache.calcite.rel.logical.LogicalProject}
+ * to an {@link ElasticsearchProject}.
+ */
+ private static class ElasticsearchProjectRule extends ElasticsearchConverterRule {
+ private static final ElasticsearchProjectRule INSTANCE = new ElasticsearchProjectRule();
+
+ private ElasticsearchProjectRule() {
+ super(LogicalProject.class, Convention.NONE, ElasticsearchRel.CONVENTION,
+ "ElasticsearchProjectRule");
+ }
+
+ @Override public RelNode convert(RelNode relNode) {
+ final LogicalProject project = (LogicalProject) relNode;
+ final RelTraitSet traitSet = project.getTraitSet().replace(out);
+ return new ElasticsearchProject(project.getCluster(), traitSet,
+ convert(project.getInput(), out), project.getProjects(), project.getRowType());
+ }
+ }
+}
+
+// End ElasticsearchRules.java
http://git-wip-us.apache.org/repos/asf/calcite/blob/e1525926/core/src/main/java/org/apache/calcite/adapter/elasticsearch/ElasticsearchSchema.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/adapter/elasticsearch/ElasticsearchSchema.java b/core/src/main/java/org/apache/calcite/adapter/elasticsearch/ElasticsearchSchema.java
new file mode 100644
index 0000000..7247d19
--- /dev/null
+++ b/core/src/main/java/org/apache/calcite/adapter/elasticsearch/ElasticsearchSchema.java
@@ -0,0 +1,33 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF 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 org.apache.calcite.adapter.elasticsearch;
+
+import org.apache.calcite.schema.Schema;
+
+/**
+ * Gives access to some basic information of the Elasticsearch schema.
+ */
+public interface ElasticsearchSchema extends Schema {
+ /**
+ * The name of the Elasticsearch index.
+ *
+ * @return The index name
+ */
+ String getIndex();
+}
+
+// End ElasticsearchSchema.java
http://git-wip-us.apache.org/repos/asf/calcite/blob/e1525926/core/src/main/java/org/apache/calcite/adapter/elasticsearch/ElasticsearchSort.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/adapter/elasticsearch/ElasticsearchSort.java b/core/src/main/java/org/apache/calcite/adapter/elasticsearch/ElasticsearchSort.java
new file mode 100644
index 0000000..851e51b
--- /dev/null
+++ b/core/src/main/java/org/apache/calcite/adapter/elasticsearch/ElasticsearchSort.java
@@ -0,0 +1,104 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF 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 org.apache.calcite.adapter.elasticsearch;
+
+import org.apache.calcite.plan.RelOptCluster;
+import org.apache.calcite.plan.RelOptCost;
+import org.apache.calcite.plan.RelOptPlanner;
+import org.apache.calcite.plan.RelTraitSet;
+import org.apache.calcite.rel.RelCollation;
+import org.apache.calcite.rel.RelFieldCollation;
+import org.apache.calcite.rel.RelNode;
+import org.apache.calcite.rel.core.Project;
+import org.apache.calcite.rel.core.Sort;
+import org.apache.calcite.rel.metadata.RelMetadataQuery;
+import org.apache.calcite.rel.type.RelDataTypeField;
+import org.apache.calcite.rex.RexLiteral;
+import org.apache.calcite.rex.RexNode;
+import org.apache.calcite.util.Util;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Implementation of {@link org.apache.calcite.rel.core.Sort}
+ * relational expression in Elasticsearch.
+ */
+public class ElasticsearchSort extends Sort implements ElasticsearchRel {
+ public ElasticsearchSort(RelOptCluster cluster, RelTraitSet traitSet, RelNode child,
+ RelCollation collation, RexNode offset, RexNode fetch) {
+ super(cluster, traitSet, child, collation, offset, fetch);
+ assert getConvention() == ElasticsearchRel.CONVENTION;
+ assert getConvention() == child.getConvention();
+ }
+
+ @Override public RelOptCost computeSelfCost(RelOptPlanner planner, RelMetadataQuery mq) {
+ return super.computeSelfCost(planner, mq).multiplyBy(0.05);
+ }
+
+ @Override public Sort copy(RelTraitSet traitSet, RelNode relNode, RelCollation relCollation,
+ RexNode offset, RexNode fetch) {
+ return new ElasticsearchSort(getCluster(), traitSet, relNode, collation, offset, fetch);
+ }
+
+ @Override public void implement(Implementor implementor) {
+ implementor.visitChild(0, getInput());
+ if (!collation.getFieldCollations().isEmpty()) {
+ final List<String> keys = new ArrayList<>();
+ if (input instanceof Project) {
+ final List<RexNode> projects = ((Project) input).getProjects();
+
+ for (RelFieldCollation fieldCollation : collation.getFieldCollations()) {
+ RexNode project = projects.get(fieldCollation.getFieldIndex());
+ String name = project.accept(MapProjectionFieldVisitor.INSTANCE);
+ keys.add(ElasticsearchRules.quote(name) + ": " + direction(fieldCollation));
+ }
+ } else {
+ final List<RelDataTypeField> fields = getRowType().getFieldList();
+
+ for (RelFieldCollation fieldCollation : collation.getFieldCollations()) {
+ final String name = fields.get(fieldCollation.getFieldIndex()).getName();
+ keys.add(ElasticsearchRules.quote(name) + ": " + direction(fieldCollation));
+ }
+ }
+
+ implementor.add("\"sort\": [ " + Util.toString(keys, "{", "}, {", "}") + "]");
+ }
+
+ if (offset != null) {
+ implementor.add("\"from\": " + ((RexLiteral) offset).getValue());
+ }
+
+ if (fetch != null) {
+ implementor.add("\"size\": " + ((RexLiteral) fetch).getValue());
+ }
+ }
+
+ private String direction(RelFieldCollation fieldCollation) {
+ switch (fieldCollation.getDirection()) {
+ case DESCENDING:
+ case STRICTLY_DESCENDING:
+ return "\"desc\"";
+ case ASCENDING:
+ case STRICTLY_ASCENDING:
+ default:
+ return "\"asc\"";
+ }
+ }
+}
+
+// End ElasticsearchSort.java
http://git-wip-us.apache.org/repos/asf/calcite/blob/e1525926/core/src/main/java/org/apache/calcite/adapter/elasticsearch/ElasticsearchTableScan.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/adapter/elasticsearch/ElasticsearchTableScan.java b/core/src/main/java/org/apache/calcite/adapter/elasticsearch/ElasticsearchTableScan.java
new file mode 100644
index 0000000..33ca14f
--- /dev/null
+++ b/core/src/main/java/org/apache/calcite/adapter/elasticsearch/ElasticsearchTableScan.java
@@ -0,0 +1,90 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF 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 org.apache.calcite.adapter.elasticsearch;
+
+import org.apache.calcite.plan.RelOptCluster;
+import org.apache.calcite.plan.RelOptCost;
+import org.apache.calcite.plan.RelOptPlanner;
+import org.apache.calcite.plan.RelOptRule;
+import org.apache.calcite.plan.RelOptTable;
+import org.apache.calcite.plan.RelTraitSet;
+import org.apache.calcite.rel.RelNode;
+import org.apache.calcite.rel.core.TableScan;
+import org.apache.calcite.rel.metadata.RelMetadataQuery;
+import org.apache.calcite.rel.type.RelDataType;
+
+import com.google.common.base.Preconditions;
+
+import java.util.List;
+
+/**
+ * Relational expression representing a scan of an Elasticsearch type.
+ *
+ * <p> Additional operations might be applied,
+ * using the "find" method.</p>
+ */
+public class ElasticsearchTableScan extends TableScan implements ElasticsearchRel {
+ private final AbstractElasticsearchTable elasticsearchTable;
+ private final RelDataType projectRowType;
+
+ /**
+ * Creates an ElasticsearchTableScan.
+ *
+ * @param cluster Cluster
+ * @param traitSet Trait set
+ * @param table Table
+ * @param elasticsearchTable Elasticsearch table
+ * @param projectRowType Fields and types to project; null to project raw row
+ */
+ protected ElasticsearchTableScan(RelOptCluster cluster, RelTraitSet traitSet,
+ RelOptTable table, AbstractElasticsearchTable elasticsearchTable,
+ RelDataType projectRowType) {
+ super(cluster, traitSet, table);
+ this.elasticsearchTable = Preconditions.checkNotNull(elasticsearchTable);
+ this.projectRowType = projectRowType;
+
+ assert getConvention() == ElasticsearchRel.CONVENTION;
+ }
+
+ @Override public RelNode copy(RelTraitSet traitSet, List<RelNode> inputs) {
+ assert inputs.isEmpty();
+ return this;
+ }
+
+ @Override public RelDataType deriveRowType() {
+ return projectRowType != null ? projectRowType : super.deriveRowType();
+ }
+
+ @Override public RelOptCost computeSelfCost(RelOptPlanner planner, RelMetadataQuery mq) {
+ final float f = projectRowType == null ? 1f : (float) projectRowType.getFieldCount() / 100f;
+ return super.computeSelfCost(planner, mq).multiplyBy(.1 * f);
+ }
+
+ @Override public void register(RelOptPlanner planner) {
+ planner.addRule(ElasticsearchToEnumerableConverterRule.INSTANCE);
+ for (RelOptRule rule: ElasticsearchRules.RULES) {
+ planner.addRule(rule);
+ }
+ }
+
+ @Override public void implement(Implementor implementor) {
+ implementor.elasticsearchTable = elasticsearchTable;
+ implementor.table = table;
+ }
+}
+
+// End ElasticsearchTableScan.java
http://git-wip-us.apache.org/repos/asf/calcite/blob/e1525926/core/src/main/java/org/apache/calcite/adapter/elasticsearch/ElasticsearchToEnumerableConverter.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/adapter/elasticsearch/ElasticsearchToEnumerableConverter.java b/core/src/main/java/org/apache/calcite/adapter/elasticsearch/ElasticsearchToEnumerableConverter.java
new file mode 100644
index 0000000..768f4e5
--- /dev/null
+++ b/core/src/main/java/org/apache/calcite/adapter/elasticsearch/ElasticsearchToEnumerableConverter.java
@@ -0,0 +1,124 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF 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 org.apache.calcite.adapter.elasticsearch;
+
+import org.apache.calcite.adapter.enumerable.EnumerableRel;
+import org.apache.calcite.adapter.enumerable.EnumerableRelImplementor;
+import org.apache.calcite.adapter.enumerable.JavaRowFormat;
+import org.apache.calcite.adapter.enumerable.PhysType;
+import org.apache.calcite.adapter.enumerable.PhysTypeImpl;
+
+import org.apache.calcite.linq4j.tree.BlockBuilder;
+import org.apache.calcite.linq4j.tree.Expression;
+import org.apache.calcite.linq4j.tree.Expressions;
+import org.apache.calcite.linq4j.tree.MethodCallExpression;
+import org.apache.calcite.plan.ConventionTraitDef;
+import org.apache.calcite.plan.RelOptCluster;
+import org.apache.calcite.plan.RelOptCost;
+import org.apache.calcite.plan.RelOptPlanner;
+import org.apache.calcite.plan.RelTraitSet;
+import org.apache.calcite.prepare.CalcitePrepareImpl;
+import org.apache.calcite.rel.RelNode;
+import org.apache.calcite.rel.convert.ConverterImpl;
+import org.apache.calcite.rel.metadata.RelMetadataQuery;
+import org.apache.calcite.rel.type.RelDataType;
+import org.apache.calcite.runtime.Hook;
+import org.apache.calcite.util.BuiltInMethod;
+import org.apache.calcite.util.Pair;
+
+import com.google.common.base.Function;
+import com.google.common.collect.Lists;
+
+import java.util.AbstractList;
+import java.util.List;
+import javax.annotation.Nullable;
+
+/**
+ * Relational expression representing a scan of a table in an Elasticsearch data source.
+ */
+public class ElasticsearchToEnumerableConverter extends ConverterImpl implements EnumerableRel {
+ protected ElasticsearchToEnumerableConverter(RelOptCluster cluster, RelTraitSet traits,
+ RelNode input) {
+ super(cluster, ConventionTraitDef.INSTANCE, traits, input);
+ }
+
+ @Override public RelNode copy(RelTraitSet traitSet, List<RelNode> inputs) {
+ return new ElasticsearchToEnumerableConverter(getCluster(), traitSet, sole(inputs));
+ }
+
+ @Override public RelOptCost computeSelfCost(RelOptPlanner planner, RelMetadataQuery mq) {
+ return super.computeSelfCost(planner, mq).multiplyBy(.1);
+ }
+
+ @Override public Result implement(EnumerableRelImplementor implementor, Prefer prefer) {
+ final BlockBuilder list = new BlockBuilder();
+ final ElasticsearchRel.Implementor elasticsearchImplementor =
+ new ElasticsearchRel.Implementor();
+ elasticsearchImplementor.visitChild(0, getInput());
+ final RelDataType rowType = getRowType();
+ final PhysType physType = PhysTypeImpl.of(implementor.getTypeFactory(), rowType,
+ prefer.prefer(JavaRowFormat.ARRAY));
+ final Expression fields = list.append("fields",
+ constantArrayList(
+ Pair.zip(ElasticsearchRules.elasticsearchFieldNames(rowType),
+ new AbstractList<Class>() {
+ @Override public Class get(int index) {
+ return physType.fieldClass(index);
+ }
+
+ @Override public int size() {
+ return rowType.getFieldCount();
+ }
+ }),
+ Pair.class));
+ final Expression table = list.append("table",
+ elasticsearchImplementor.table
+ .getExpression(AbstractElasticsearchTable.ElasticsearchQueryable.class));
+ List<String> opList = elasticsearchImplementor.list;
+ final Expression ops = list.append("ops", constantArrayList(opList, String.class));
+ Expression enumerable = list.append("enumerable",
+ Expressions.call(table, ElasticsearchMethod.ELASTICSEARCH_QUERYABLE_FIND.method, ops,
+ fields));
+ if (CalcitePrepareImpl.DEBUG) {
+ System.out.println("Elasticsearch: " + opList);
+ }
+ Hook.QUERY_PLAN.run(opList);
+ list.add(Expressions.return_(null, enumerable));
+ return implementor.result(physType, list.toBlock());
+ }
+
+ /** E.g. {@code constantArrayList("x", "y")} returns
+ * "Arrays.asList('x', 'y')". */
+ private static <T> MethodCallExpression constantArrayList(List<T> values, Class clazz) {
+ return Expressions.call(BuiltInMethod.ARRAYS_AS_LIST.method,
+ Expressions.newArrayInit(clazz, constantList(values)));
+ }
+
+ /** E.g. {@code constantList("x", "y")} returns
+ * {@code {ConstantExpression("x"), ConstantExpression("y")}}. */
+ private static <T> List<Expression> constantList(List<T> values) {
+ return Lists.transform(values,
+ new Function<T, Expression>() {
+ @Nullable
+ @Override public Expression apply(@Nullable T t) {
+ return Expressions.constant(t);
+ }
+ });
+ }
+}
+
+// End ElasticsearchToEnumerableConverter.java
http://git-wip-us.apache.org/repos/asf/calcite/blob/e1525926/core/src/main/java/org/apache/calcite/adapter/elasticsearch/ElasticsearchToEnumerableConverterRule.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/adapter/elasticsearch/ElasticsearchToEnumerableConverterRule.java b/core/src/main/java/org/apache/calcite/adapter/elasticsearch/ElasticsearchToEnumerableConverterRule.java
new file mode 100644
index 0000000..1047757
--- /dev/null
+++ b/core/src/main/java/org/apache/calcite/adapter/elasticsearch/ElasticsearchToEnumerableConverterRule.java
@@ -0,0 +1,42 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF 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 org.apache.calcite.adapter.elasticsearch;
+
+import org.apache.calcite.adapter.enumerable.EnumerableConvention;
+import org.apache.calcite.plan.RelTraitSet;
+import org.apache.calcite.rel.RelNode;
+import org.apache.calcite.rel.convert.ConverterRule;
+
+/**
+ * Rule to convert a relational expression from
+ * {@link ElasticsearchRel#CONVENTION} to {@link EnumerableConvention}.
+ */
+public class ElasticsearchToEnumerableConverterRule extends ConverterRule {
+ public static final ConverterRule INSTANCE = new ElasticsearchToEnumerableConverterRule();
+
+ private ElasticsearchToEnumerableConverterRule() {
+ super(RelNode.class, ElasticsearchRel.CONVENTION, EnumerableConvention.INSTANCE,
+ "ElasticsearchToEnumerableConverterRule");
+ }
+
+ @Override public RelNode convert(RelNode relNode) {
+ RelTraitSet newTraitSet = relNode.getTraitSet().replace(getOutConvention());
+ return new ElasticsearchToEnumerableConverter(relNode.getCluster(), newTraitSet, relNode);
+ }
+}
+
+// End ElasticsearchToEnumerableConverterRule.java
http://git-wip-us.apache.org/repos/asf/calcite/blob/e1525926/core/src/main/java/org/apache/calcite/adapter/elasticsearch/MapProjectionFieldVisitor.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/adapter/elasticsearch/MapProjectionFieldVisitor.java b/core/src/main/java/org/apache/calcite/adapter/elasticsearch/MapProjectionFieldVisitor.java
new file mode 100644
index 0000000..bcb99a7
--- /dev/null
+++ b/core/src/main/java/org/apache/calcite/adapter/elasticsearch/MapProjectionFieldVisitor.java
@@ -0,0 +1,42 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF 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 org.apache.calcite.adapter.elasticsearch;
+
+import org.apache.calcite.rex.RexCall;
+import org.apache.calcite.rex.RexLiteral;
+import org.apache.calcite.rex.RexVisitorImpl;
+import org.apache.calcite.sql.fun.SqlStdOperatorTable;
+
+/**
+ * Visitor that extracts the actual field name from an item expression.
+ */
+public class MapProjectionFieldVisitor extends RexVisitorImpl<String> {
+ public static final MapProjectionFieldVisitor INSTANCE = new MapProjectionFieldVisitor();
+
+ private MapProjectionFieldVisitor() {
+ super(true);
+ }
+
+ @Override public String visitCall(RexCall call) {
+ if (call.op == SqlStdOperatorTable.ITEM) {
+ return ((RexLiteral) call.getOperands().get(1)).getValueAs(String.class);
+ }
+ return super.visitCall(call);
+ }
+}
+
+// End MapProjectionFieldVisitor.java
http://git-wip-us.apache.org/repos/asf/calcite/blob/e1525926/core/src/main/java/org/apache/calcite/adapter/elasticsearch/package-info.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/adapter/elasticsearch/package-info.java b/core/src/main/java/org/apache/calcite/adapter/elasticsearch/package-info.java
new file mode 100644
index 0000000..98e1a92
--- /dev/null
+++ b/core/src/main/java/org/apache/calcite/adapter/elasticsearch/package-info.java
@@ -0,0 +1,26 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF 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.
+ */
+
+/**
+ * Base classes for a query provider based on an Elasticsearch DB.
+ */
+@PackageMarker
+package org.apache.calcite.adapter.elasticsearch;
+
+import org.apache.calcite.avatica.util.PackageMarker;
+
+// End package-info.java
http://git-wip-us.apache.org/repos/asf/calcite/blob/e1525926/elasticsearch/pom.xml
----------------------------------------------------------------------
diff --git a/elasticsearch/pom.xml b/elasticsearch/pom.xml
deleted file mode 100644
index aee216a..0000000
--- a/elasticsearch/pom.xml
+++ /dev/null
@@ -1,148 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
-Licensed to the Apache Software Foundation (ASF) under one or more
-contributor license agreements. See the NOTICE file distributed with
-this work for additional information regarding copyright ownership.
-The ASF 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.
--->
-<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
- <modelVersion>4.0.0</modelVersion>
-
- <parent>
- <groupId>org.apache.calcite</groupId>
- <artifactId>calcite</artifactId>
- <version>1.14.0-SNAPSHOT</version>
- </parent>
-
- <artifactId>calcite-elasticsearch</artifactId>
- <packaging>jar</packaging>
- <version>1.14.0-SNAPSHOT</version>
- <name>Calcite Elasticsearch</name>
- <description>Elasticsearch adapter for Calcite</description>
-
- <properties>
- <top.dir>${project.basedir}/..</top.dir>
- </properties>
-
- <dependencies>
- <dependency>
- <groupId>com.google.guava</groupId>
- <artifactId>guava</artifactId>
- </dependency>
- <dependency>
- <groupId>org.apache.calcite</groupId>
- <artifactId>calcite-core</artifactId>
- <type>jar</type>
- </dependency>
- <dependency>
- <groupId>org.apache.calcite</groupId>
- <artifactId>calcite-core</artifactId>
- <type>test-jar</type>
- <scope>test</scope>
- </dependency>
- <dependency>
- <groupId>com.fasterxml.jackson.core</groupId>
- <artifactId>jackson-core</artifactId>
- </dependency>
- <dependency>
- <groupId>com.fasterxml.jackson.core</groupId>
- <artifactId>jackson-databind</artifactId>
- </dependency>
- <dependency>
- <groupId>junit</groupId>
- <artifactId>junit</artifactId>
- <scope>test</scope>
- </dependency>
- <dependency>
- <groupId>org.apache.calcite</groupId>
- <artifactId>calcite-linq4j</artifactId>
- </dependency>
- <dependency>
- <groupId>org.elasticsearch</groupId>
- <artifactId>elasticsearch</artifactId>
- <version>${elasticsearch-java-driver.version}</version>
- </dependency>
- <dependency>
- <groupId>com.carrotsearch</groupId>
- <artifactId>hppc</artifactId>
- <version>${hppc.version}</version>
- </dependency>
- <dependency>
- <groupId>com.google.code.findbugs</groupId>
- <artifactId>jsr305</artifactId>
- </dependency>
- <dependency>
- <groupId>org.slf4j</groupId>
- <artifactId>slf4j-api</artifactId>
- </dependency>
- </dependencies>
-
- <build>
- <plugins>
- <plugin>
- <artifactId>maven-dependency-plugin</artifactId>
- <version>${maven-dependency-plugin.version}</version>
- <executions>
- <execution>
- <id>analyze</id>
- <goals>
- <goal>analyze-only</goal>
- </goals>
- <configuration>
- <failOnWarning>true</failOnWarning>
- <!-- ignore "unused but declared" warnings -->
- <ignoredUnusedDeclaredDependencies>
- <ignoredUnusedDeclaredDependency>org.apache.calcite.avatica:avatica</ignoredUnusedDeclaredDependency>
- <ignoredUnusedDeclaredDependency>org.slf4j:slf4j-api</ignoredUnusedDeclaredDependency>
- <ignoredUnusedDeclaredDependency>org.slf4j:slf4j-log4j12</ignoredUnusedDeclaredDependency>
- </ignoredUnusedDeclaredDependencies>
- </configuration>
- </execution>
- </executions>
- </plugin>
- <plugin>
- <groupId>org.apache.maven.plugins</groupId>
- <artifactId>maven-jar-plugin</artifactId>
- <executions>
- <execution>
- <goals>
- <goal>test-jar</goal>
- </goals>
- </execution>
- </executions>
- </plugin>
- <plugin>
- <groupId>org.apache.maven.plugins</groupId>
- <artifactId>maven-release-plugin</artifactId>
- </plugin>
- <!-- Parent module has the same plugin and does the work of
- generating -sources.jar for each project. But without the
- plugin declared here, IDEs don't know the sources are
- available. -->
- <plugin>
- <groupId>org.apache.maven.plugins</groupId>
- <artifactId>maven-source-plugin</artifactId>
- <executions>
- <execution>
- <id>attach-sources</id>
- <phase>verify</phase>
- <goals>
- <goal>jar-no-fork</goal>
- <goal>test-jar-no-fork</goal>
- </goals>
- </execution>
- </executions>
- </plugin>
- </plugins>
- </build>
-</project>
http://git-wip-us.apache.org/repos/asf/calcite/blob/e1525926/elasticsearch/src/main/java/org/apache/calcite/adapter/elasticsearch/ElasticsearchEnumerator.java
----------------------------------------------------------------------
diff --git a/elasticsearch/src/main/java/org/apache/calcite/adapter/elasticsearch/ElasticsearchEnumerator.java b/elasticsearch/src/main/java/org/apache/calcite/adapter/elasticsearch/ElasticsearchEnumerator.java
deleted file mode 100644
index e7478f5..0000000
--- a/elasticsearch/src/main/java/org/apache/calcite/adapter/elasticsearch/ElasticsearchEnumerator.java
+++ /dev/null
@@ -1,151 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF 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 org.apache.calcite.adapter.elasticsearch;
-
-import org.apache.calcite.avatica.util.DateTimeUtils;
-import org.apache.calcite.linq4j.Enumerator;
-import org.apache.calcite.linq4j.function.Function1;
-import org.apache.calcite.linq4j.tree.Primitive;
-
-import org.elasticsearch.search.SearchHit;
-
-import java.util.Date;
-import java.util.Iterator;
-import java.util.List;
-import java.util.Map;
-
-/**
- * Enumerator that reads from an Elasticsearch type.
- */
-public class ElasticsearchEnumerator implements Enumerator<Object> {
- private final Iterator<SearchHit> cursor;
- private final Function1<SearchHit, Object> getter;
- private Object current;
-
- /**
- * Creates an ElasticsearchEnumerator.
- *
- * @param cursor Iterator over Elasticsearch {@link SearchHit} objects
- * @param getter Converts an object into a list of fields
- */
- public ElasticsearchEnumerator(Iterator<SearchHit> cursor, Function1<SearchHit, Object> getter) {
- this.cursor = cursor;
- this.getter = getter;
- }
-
- public Object current() {
- return current;
- }
-
- public boolean moveNext() {
- if (cursor.hasNext()) {
- SearchHit map = cursor.next();
- current = getter.apply(map);
- return true;
- } else {
- current = null;
- return false;
- }
- }
-
- public void reset() {
- throw new UnsupportedOperationException();
- }
-
- public void close() {
- // nothing to do
- }
-
- private static Function1<SearchHit, Map> mapGetter() {
- return new Function1<SearchHit, Map>() {
- public Map apply(SearchHit searchHitFields) {
- return (Map) searchHitFields.fields();
- }
- };
- }
-
- private static Function1<SearchHit, Object> singletonGetter(final String fieldName,
- final Class fieldClass) {
- return new Function1<SearchHit, Object>() {
- public Object apply(SearchHit searchHitFields) {
- if (searchHitFields.fields().isEmpty()) {
- return convert(searchHitFields.getSource(), fieldClass);
- } else {
- return convert(searchHitFields.getFields(), fieldClass);
- }
- }
- };
- }
-
- /**
- * Function that extracts a given set of fields from {@link SearchHit}
- * objects.
- *
- * @param fields List of fields to project
- */
- private static Function1<SearchHit, Object[]> listGetter(
- final List<Map.Entry<String, Class>> fields) {
- return new Function1<SearchHit, Object[]>() {
- public Object[] apply(SearchHit searchHitFields) {
- Object[] objects = new Object[fields.size()];
- for (int i = 0; i < fields.size(); i++) {
- final Map.Entry<String, Class> field = fields.get(i);
- final String name = field.getKey();
- if (searchHitFields.fields().isEmpty()) {
- objects[i] = convert(searchHitFields.getSource().get(name), field.getValue());
- } else {
- objects[i] = convert(searchHitFields.field(name).getValue(), field.getValue());
- }
- }
- return objects;
- }
- };
- }
-
- static Function1<SearchHit, Object> getter(List<Map.Entry<String, Class>> fields) {
- //noinspection unchecked
- return fields == null
- ? (Function1) mapGetter()
- : fields.size() == 1
- ? singletonGetter(fields.get(0).getKey(), fields.get(0).getValue())
- : (Function1) listGetter(fields);
- }
-
- private static Object convert(Object o, Class clazz) {
- if (o == null) {
- return null;
- }
- Primitive primitive = Primitive.of(clazz);
- if (primitive != null) {
- clazz = primitive.boxClass;
- } else {
- primitive = Primitive.ofBox(clazz);
- }
- if (clazz.isInstance(o)) {
- return o;
- }
- if (o instanceof Date && primitive != null) {
- o = ((Date) o).getTime() / DateTimeUtils.MILLIS_PER_DAY;
- }
- if (o instanceof Number && primitive != null) {
- return primitive.number((Number) o);
- }
- return o;
- }
-}
-
-// End ElasticsearchEnumerator.java
http://git-wip-us.apache.org/repos/asf/calcite/blob/e1525926/elasticsearch/src/main/java/org/apache/calcite/adapter/elasticsearch/ElasticsearchFilter.java
----------------------------------------------------------------------
diff --git a/elasticsearch/src/main/java/org/apache/calcite/adapter/elasticsearch/ElasticsearchFilter.java b/elasticsearch/src/main/java/org/apache/calcite/adapter/elasticsearch/ElasticsearchFilter.java
deleted file mode 100644
index 8e923a1..0000000
--- a/elasticsearch/src/main/java/org/apache/calcite/adapter/elasticsearch/ElasticsearchFilter.java
+++ /dev/null
@@ -1,287 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF 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 org.apache.calcite.adapter.elasticsearch;
-
-import org.apache.calcite.plan.RelOptCluster;
-import org.apache.calcite.plan.RelOptCost;
-import org.apache.calcite.plan.RelOptPlanner;
-import org.apache.calcite.plan.RelOptUtil;
-import org.apache.calcite.plan.RelTraitSet;
-import org.apache.calcite.rel.RelNode;
-import org.apache.calcite.rel.core.Filter;
-import org.apache.calcite.rel.metadata.RelMetadataQuery;
-import org.apache.calcite.rex.RexCall;
-import org.apache.calcite.rex.RexInputRef;
-import org.apache.calcite.rex.RexLiteral;
-import org.apache.calcite.rex.RexNode;
-import org.apache.calcite.util.JsonBuilder;
-import org.apache.calcite.util.Pair;
-
-import com.google.common.collect.HashMultimap;
-import com.google.common.collect.Multimap;
-
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.HashMap;
-import java.util.LinkedHashMap;
-import java.util.List;
-import java.util.Locale;
-import java.util.Map;
-
-
-/**
- * Implementation of a {@link org.apache.calcite.rel.core.Filter}
- * relational expression in Elasticsearch.
- */
-public class ElasticsearchFilter extends Filter implements ElasticsearchRel {
- public ElasticsearchFilter(RelOptCluster cluster, RelTraitSet traitSet, RelNode child,
- RexNode condition) {
- super(cluster, traitSet, child, condition);
- assert getConvention() == ElasticsearchRel.CONVENTION;
- assert getConvention() == child.getConvention();
- }
-
- @Override public RelOptCost computeSelfCost(RelOptPlanner planner, RelMetadataQuery mq) {
- return super.computeSelfCost(planner, mq).multiplyBy(0.1);
- }
-
- @Override public Filter copy(RelTraitSet relTraitSet, RelNode input, RexNode condition) {
- return new ElasticsearchFilter(getCluster(), relTraitSet, input, condition);
- }
-
- @Override public void implement(Implementor implementor) {
- implementor.visitChild(0, getInput());
- final List<String> fieldNames =
- ElasticsearchRules.elasticsearchFieldNames(getRowType());
- final Translator translator = new Translator(fieldNames);
- final String match = translator.translateMatch(condition);
- implementor.add(match);
- }
-
- /**
- * Translates {@link RexNode} expressions into Elasticsearch expression strings.
- */
- static class Translator {
- final JsonBuilder builder = new JsonBuilder();
- final Multimap<String, Pair<String, RexLiteral>> multimap =
- HashMultimap.create();
- final Map<String, RexLiteral> eqMap = new LinkedHashMap<>();
- private final List<String> fieldNames;
-
- Translator(List<String> fieldNames) {
- this.fieldNames = fieldNames;
- }
-
- private String translateMatch(RexNode condition) {
- // filter node
- final Map<String, Object> filterMap = new LinkedHashMap<>();
- filterMap.put("filter", translateOr(condition));
-
- // constant_score node
- final Map<String, Object> map = builder.map();
- map.put("constant_score", filterMap);
-
- return "\"query\" : " + builder.toJsonString(map).replaceAll("\\s+", "")
- .toLowerCase(Locale.ROOT);
- }
-
- private Object translateOr(RexNode condition) {
- final List<Object> list = new ArrayList<>();
-
- final List<RexNode> orNodes = RelOptUtil.disjunctions(condition);
- for (RexNode node : orNodes) {
- List<Map<String, Object>> andNodes = translateAnd(node);
-
- if (andNodes.size() > 0) {
- Map<String, Object> andClause = new HashMap<>();
- andClause.put("must", andNodes);
-
- // boolean filters
- LinkedHashMap<String, Object> filterEvaluator = new LinkedHashMap<>();
- filterEvaluator.put("bool", andClause);
- list.add(filterEvaluator);
- } else {
- list.add(andNodes.get(0));
- }
- }
-
- if (orNodes.size() > 1) {
- Map<String, Object> map = builder.map();
- map.put("should", list);
-
- // boolean filters
- LinkedHashMap<String, Object> filterEvaluator = new LinkedHashMap<>();
- filterEvaluator.put("bool", map);
- return filterEvaluator;
- } else {
- return list.get(0);
- }
- }
-
- private void addPredicate(Map<String, Object> map, String op, Object v) {
- if (map.containsKey(op) && stronger(op, map.get(op), v)) {
- return;
- }
- map.put(op, v);
- }
-
- /**
- * Translates a condition that may be an AND of other conditions. Gathers
- * together conditions that apply to the same field.
- */
- private List<Map<String, Object>> translateAnd(RexNode node0) {
- eqMap.clear();
- multimap.clear();
- for (RexNode node : RelOptUtil.conjunctions(node0)) {
- translateMatch2(node);
- }
- List<Map<String, Object>> filters = new ArrayList<>();
- for (Map.Entry<String, RexLiteral> entry : eqMap.entrySet()) {
- multimap.removeAll(entry.getKey());
-
- Map<String, Object> filter = new HashMap<>();
- filter.put(entry.getKey(), literalValue(entry.getValue()));
-
- Map<String, Object> map = new HashMap<>();
- map.put("term", filter);
- filters.add(map);
- }
- for (Map.Entry<String, Collection<Pair<String, RexLiteral>>> entry
- : multimap.asMap().entrySet()) {
- Map<String, Object> map2 = builder.map();
-
- Map<String, Object> map = new HashMap<>();
- for (Pair<String, RexLiteral> s : entry.getValue()) {
- if (!s.left.equals("not")) {
- addPredicate(map2, s.left, literalValue(s.right));
-
- Map<String, Object> filter = new HashMap<>();
- filter.put(entry.getKey(), map2);
-
- map.put("range", filter);
- } else {
- map2.put(entry.getKey(), literalValue(s.right));
-
- Map<String, Object> termMap = new HashMap<>();
- termMap.put("term", map2);
-
- map.put("not", termMap);
- }
- }
- filters.add(map);
- }
- return filters;
- }
-
- private boolean stronger(String key, Object v0, Object v1) {
- if (key.equals("lt") || key.equals("lte")) {
- if (v0 instanceof Number && v1 instanceof Number) {
- return ((Number) v0).doubleValue() < ((Number) v1).doubleValue();
- }
- if (v0 instanceof String && v1 instanceof String) {
- return v0.toString().compareTo(v1.toString()) < 0;
- }
- }
- if (key.equals("gt") || key.equals("gte")) {
- return stronger("lt", v1, v0);
- }
- return false;
- }
-
- private static Object literalValue(RexLiteral literal) {
- return literal.getValue2();
- }
-
- private Void translateMatch2(RexNode node) {
- switch (node.getKind()) {
- case EQUALS:
- return translateBinary(null, null, (RexCall) node);
- case LESS_THAN:
- return translateBinary("lt", "gt", (RexCall) node);
- case LESS_THAN_OR_EQUAL:
- return translateBinary("lte", "gte", (RexCall) node);
- case NOT_EQUALS:
- return translateBinary("not", "not", (RexCall) node);
- case GREATER_THAN:
- return translateBinary("gt", "lt", (RexCall) node);
- case GREATER_THAN_OR_EQUAL:
- return translateBinary("gte", "lte", (RexCall) node);
- default:
- throw new AssertionError("cannot translate " + node);
- }
- }
-
- /**
- * Translates a call to a binary operator, reversing arguments if
- * necessary.
- */
- private Void translateBinary(String op, String rop, RexCall call) {
- final RexNode left = call.operands.get(0);
- final RexNode right = call.operands.get(1);
- boolean b = translateBinary2(op, left, right);
- if (b) {
- return null;
- }
- b = translateBinary2(rop, right, left);
- if (b) {
- return null;
- }
- throw new AssertionError("cannot translate op " + op + " call " + call);
- }
-
- /**
- * Translates a call to a binary operator. Returns whether successful.
- */
- private boolean translateBinary2(String op, RexNode left, RexNode right) {
- switch (right.getKind()) {
- case LITERAL:
- break;
- default:
- return false;
- }
- final RexLiteral rightLiteral = (RexLiteral) right;
- switch (left.getKind()) {
- case INPUT_REF:
- final RexInputRef left1 = (RexInputRef) left;
- String name = fieldNames.get(left1.getIndex());
- translateOp2(op, name, rightLiteral);
- return true;
- case CAST:
- return translateBinary2(op, ((RexCall) left).operands.get(0), right);
- case OTHER_FUNCTION:
- String itemName = ElasticsearchRules.isItem((RexCall) left);
- if (itemName != null) {
- translateOp2(op, itemName, rightLiteral);
- return true;
- }
- // fall through
- default:
- return false;
- }
- }
-
- private void translateOp2(String op, String name, RexLiteral right) {
- if (op == null) {
- eqMap.put(name, right);
- } else {
- multimap.put(name, Pair.of(op, right));
- }
- }
- }
-}
-
-// End ElasticsearchFilter.java
http://git-wip-us.apache.org/repos/asf/calcite/blob/e1525926/elasticsearch/src/main/java/org/apache/calcite/adapter/elasticsearch/ElasticsearchMethod.java
----------------------------------------------------------------------
diff --git a/elasticsearch/src/main/java/org/apache/calcite/adapter/elasticsearch/ElasticsearchMethod.java b/elasticsearch/src/main/java/org/apache/calcite/adapter/elasticsearch/ElasticsearchMethod.java
deleted file mode 100644
index a0b3af6..0000000
--- a/elasticsearch/src/main/java/org/apache/calcite/adapter/elasticsearch/ElasticsearchMethod.java
+++ /dev/null
@@ -1,50 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF 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 org.apache.calcite.adapter.elasticsearch;
-
-import org.apache.calcite.linq4j.tree.Types;
-
-import com.google.common.collect.ImmutableMap;
-
-import java.lang.reflect.Method;
-import java.util.List;
-
-/**
- * Builtin methods in the Elasticsearch adapter.
- */
-enum ElasticsearchMethod {
- ELASTICSEARCH_QUERYABLE_FIND(ElasticsearchTable.ElasticsearchQueryable.class, "find",
- List.class, List.class);
-
- public final Method method;
-
- public static final ImmutableMap<Method, ElasticsearchMethod> MAP;
-
- static {
- final ImmutableMap.Builder<Method, ElasticsearchMethod> builder = ImmutableMap.builder();
- for (ElasticsearchMethod value: ElasticsearchMethod.values()) {
- builder.put(value.method, value);
- }
- MAP = builder.build();
- }
-
- ElasticsearchMethod(Class clazz, String methodName, Class... argumentTypes) {
- this.method = Types.lookupMethod(clazz, methodName, argumentTypes);
- }
-}
-
-// End ElasticsearchMethod.java