You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@asterixdb.apache.org by im...@apache.org on 2015/08/25 18:44:24 UTC
[36/51] [partial] incubator-asterixdb git commit: Change folder
structure for Java repackage
http://git-wip-us.apache.org/repos/asf/incubator-asterixdb/blob/34d81630/asterix-algebra/src/main/java/edu/uci/ics/asterix/translator/CompiledStatements.java
----------------------------------------------------------------------
diff --git a/asterix-algebra/src/main/java/edu/uci/ics/asterix/translator/CompiledStatements.java b/asterix-algebra/src/main/java/edu/uci/ics/asterix/translator/CompiledStatements.java
deleted file mode 100644
index bfa0331..0000000
--- a/asterix-algebra/src/main/java/edu/uci/ics/asterix/translator/CompiledStatements.java
+++ /dev/null
@@ -1,625 +0,0 @@
-/*
- * Copyright 2009-2013 by The Regents of the University of California
- * Licensed 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 from
- *
- * 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 edu.uci.ics.asterix.translator;
-
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Map;
-
-import edu.uci.ics.asterix.aql.base.Clause;
-import edu.uci.ics.asterix.aql.base.Expression;
-import edu.uci.ics.asterix.aql.base.Statement.Kind;
-import edu.uci.ics.asterix.aql.expression.CallExpr;
-import edu.uci.ics.asterix.aql.expression.FLWOGRExpression;
-import edu.uci.ics.asterix.aql.expression.FieldAccessor;
-import edu.uci.ics.asterix.aql.expression.FieldBinding;
-import edu.uci.ics.asterix.aql.expression.ForClause;
-import edu.uci.ics.asterix.aql.expression.Identifier;
-import edu.uci.ics.asterix.aql.expression.LiteralExpr;
-import edu.uci.ics.asterix.aql.expression.Query;
-import edu.uci.ics.asterix.aql.expression.RecordConstructor;
-import edu.uci.ics.asterix.aql.expression.VariableExpr;
-import edu.uci.ics.asterix.aql.expression.WhereClause;
-import edu.uci.ics.asterix.aql.literal.StringLiteral;
-import edu.uci.ics.asterix.common.config.DatasetConfig.IndexType;
-import edu.uci.ics.asterix.common.feeds.FeedConnectionRequest;
-import edu.uci.ics.asterix.common.functions.FunctionConstants;
-import edu.uci.ics.asterix.common.functions.FunctionSignature;
-import edu.uci.ics.asterix.metadata.declared.AqlMetadataProvider;
-import edu.uci.ics.asterix.metadata.entities.Dataset;
-import edu.uci.ics.asterix.om.types.ARecordType;
-import edu.uci.ics.asterix.om.types.IAType;
-import edu.uci.ics.hyracks.algebricks.common.exceptions.AlgebricksException;
-
-/**
- * An AQL statement instance is translated into an instance of type CompileX
- * that has additional fields for use by the AqlTranslator.
- */
-public class CompiledStatements {
-
- public static interface ICompiledStatement {
-
- public Kind getKind();
- }
-
- public static class CompiledDatasetDropStatement implements ICompiledStatement {
- private final String dataverseName;
- private final String datasetName;
-
- public CompiledDatasetDropStatement(String dataverseName, String datasetName) {
- this.dataverseName = dataverseName;
- this.datasetName = datasetName;
- }
-
- public String getDataverseName() {
- return dataverseName;
- }
-
- public String getDatasetName() {
- return datasetName;
- }
-
- @Override
- public Kind getKind() {
- return Kind.DATASET_DROP;
- }
- }
-
- // added by yasser
- public static class CompiledCreateDataverseStatement implements ICompiledStatement {
- private String dataverseName;
- private String format;
-
- public CompiledCreateDataverseStatement(String dataverseName, String format) {
- this.dataverseName = dataverseName;
- this.format = format;
- }
-
- public String getDataverseName() {
- return dataverseName;
- }
-
- public String getFormat() {
- return format;
- }
-
- @Override
- public Kind getKind() {
- return Kind.CREATE_DATAVERSE;
- }
- }
-
- public static class CompiledNodeGroupDropStatement implements ICompiledStatement {
- private String nodeGroupName;
-
- public CompiledNodeGroupDropStatement(String nodeGroupName) {
- this.nodeGroupName = nodeGroupName;
- }
-
- public String getNodeGroupName() {
- return nodeGroupName;
- }
-
- @Override
- public Kind getKind() {
- return Kind.NODEGROUP_DROP;
- }
- }
-
- public static class CompiledIndexDropStatement implements ICompiledStatement {
- private String dataverseName;
- private String datasetName;
- private String indexName;
-
- public CompiledIndexDropStatement(String dataverseName, String datasetName, String indexName) {
- this.dataverseName = dataverseName;
- this.datasetName = datasetName;
- this.indexName = indexName;
- }
-
- public String getDataverseName() {
- return dataverseName;
- }
-
- public String getDatasetName() {
- return datasetName;
- }
-
- public String getIndexName() {
- return indexName;
- }
-
- @Override
- public Kind getKind() {
- return Kind.INDEX_DROP;
- }
- }
-
- public static class CompiledDataverseDropStatement implements ICompiledStatement {
- private String dataverseName;
- private boolean ifExists;
-
- public CompiledDataverseDropStatement(String dataverseName, boolean ifExists) {
- this.dataverseName = dataverseName;
- this.ifExists = ifExists;
- }
-
- public String getDataverseName() {
- return dataverseName;
- }
-
- public boolean getIfExists() {
- return ifExists;
- }
-
- @Override
- public Kind getKind() {
- return Kind.DATAVERSE_DROP;
- }
- }
-
- public static class CompiledTypeDropStatement implements ICompiledStatement {
- private String typeName;
-
- public CompiledTypeDropStatement(String nodeGroupName) {
- this.typeName = nodeGroupName;
- }
-
- public String getTypeName() {
- return typeName;
- }
-
- @Override
- public Kind getKind() {
- return Kind.TYPE_DROP;
- }
- }
-
- public static interface ICompiledDmlStatement extends ICompiledStatement {
-
- public String getDataverseName();
-
- public String getDatasetName();
- }
-
- public static class CompiledCreateIndexStatement implements ICompiledDmlStatement {
- private final String indexName;
- private final String dataverseName;
- private final String datasetName;
- private final List<List<String>> keyFields;
- private final List<IAType> keyTypes;
- private final boolean isEnforced;
- private final IndexType indexType;
-
- // Specific to NGram index.
- private final int gramLength;
-
- public CompiledCreateIndexStatement(String indexName, String dataverseName, String datasetName,
- List<List<String>> keyFields, List<IAType> keyTypes, boolean isEnforced, int gramLength, IndexType indexType) {
- this.indexName = indexName;
- this.dataverseName = dataverseName;
- this.datasetName = datasetName;
- this.keyFields = keyFields;
- this.keyTypes = keyTypes;
- this.gramLength = gramLength;
- this.isEnforced = isEnforced;
- this.indexType = indexType;
- }
-
- public String getDatasetName() {
- return datasetName;
- }
-
- public String getDataverseName() {
- return dataverseName;
- }
-
- public String getIndexName() {
- return indexName;
- }
-
- public List<List<String>> getKeyFields() {
- return keyFields;
- }
-
- public List<IAType> getKeyFieldTypes() {
- return keyTypes;
- }
-
- public IndexType getIndexType() {
- return indexType;
- }
-
- public int getGramLength() {
- return gramLength;
- }
-
- public boolean isEnforced() {
- return isEnforced;
- }
-
- @Override
- public Kind getKind() {
- return Kind.CREATE_INDEX;
- }
- }
-
- public static class CompiledLoadFromFileStatement implements ICompiledDmlStatement {
- private String dataverseName;
- private String datasetName;
- private boolean alreadySorted;
- private String adapter;
- private Map<String, String> properties;
-
- public CompiledLoadFromFileStatement(String dataverseName, String datasetName, String adapter,
- Map<String, String> properties, boolean alreadySorted) {
- this.dataverseName = dataverseName;
- this.datasetName = datasetName;
- this.alreadySorted = alreadySorted;
- this.adapter = adapter;
- this.properties = properties;
- }
-
- public String getDataverseName() {
- return dataverseName;
- }
-
- public String getDatasetName() {
- return datasetName;
- }
-
- public boolean alreadySorted() {
- return alreadySorted;
- }
-
- public String getAdapter() {
- return adapter;
- }
-
- public Map<String, String> getProperties() {
- return properties;
- }
-
- @Override
- public Kind getKind() {
- return Kind.LOAD;
- }
- }
-
- public static class CompiledInsertStatement implements ICompiledDmlStatement {
- private final String dataverseName;
- private final String datasetName;
- private final Query query;
- private final int varCounter;
-
- public CompiledInsertStatement(String dataverseName, String datasetName, Query query, int varCounter) {
- this.dataverseName = dataverseName;
- this.datasetName = datasetName;
- this.query = query;
- this.varCounter = varCounter;
- }
-
- public String getDataverseName() {
- return dataverseName;
- }
-
- public String getDatasetName() {
- return datasetName;
- }
-
- public int getVarCounter() {
- return varCounter;
- }
-
- public Query getQuery() {
- return query;
- }
-
- @Override
- public Kind getKind() {
- return Kind.INSERT;
- }
- }
-
- public static class CompiledConnectFeedStatement implements ICompiledDmlStatement {
- private String dataverseName;
- private String feedName;
- private String datasetName;
- private String policyName;
- private Query query;
- private int varCounter;
-
- public CompiledConnectFeedStatement(String dataverseName, String feedName, String datasetName,
- String policyName, Query query, int varCounter) {
- this.dataverseName = dataverseName;
- this.feedName = feedName;
- this.datasetName = datasetName;
- this.policyName = policyName;
- this.query = query;
- this.varCounter = varCounter;
- }
-
- @Override
- public String getDataverseName() {
- return dataverseName;
- }
-
- public String getFeedName() {
- return feedName;
- }
-
- @Override
- public String getDatasetName() {
- return datasetName;
- }
-
- public int getVarCounter() {
- return varCounter;
- }
-
- public Query getQuery() {
- return query;
- }
-
- public void setQuery(Query query) {
- this.query = query;
- }
-
- @Override
- public Kind getKind() {
- return Kind.CONNECT_FEED;
- }
-
- public String getPolicyName() {
- return policyName;
- }
- }
-
- public static class CompiledSubscribeFeedStatement implements ICompiledDmlStatement {
-
- private final FeedConnectionRequest request;
- private Query query;
- private final int varCounter;
-
- public CompiledSubscribeFeedStatement(FeedConnectionRequest request, Query query, int varCounter) {
- this.request = request;
- this.query = query;
- this.varCounter = varCounter;
- }
-
- @Override
- public String getDataverseName() {
- return request.getReceivingFeedId().getDataverse();
- }
-
- @Override
- public String getDatasetName() {
- return request.getTargetDataset();
- }
-
- public int getVarCounter() {
- return varCounter;
- }
-
- public Query getQuery() {
- return query;
- }
-
- public void setQuery(Query query) {
- this.query = query;
- }
-
- @Override
- public Kind getKind() {
- return Kind.SUBSCRIBE_FEED;
- }
-
- }
-
-
- public static class CompiledDisconnectFeedStatement implements ICompiledDmlStatement {
- private String dataverseName;
- private String datasetName;
- private String feedName;
- private Query query;
- private int varCounter;
-
- public CompiledDisconnectFeedStatement(String dataverseName, String feedName, String datasetName) {
- this.dataverseName = dataverseName;
- this.feedName = feedName;
- this.datasetName = datasetName;
- }
-
- @Override
- public String getDataverseName() {
- return dataverseName;
- }
-
- @Override
- public String getDatasetName() {
- return datasetName;
- }
-
- public String getFeedName() {
- return feedName;
- }
-
- public int getVarCounter() {
- return varCounter;
- }
-
- public Query getQuery() {
- return query;
- }
-
- @Override
- public Kind getKind() {
- return Kind.DISCONNECT_FEED;
- }
-
- }
-
- public static class CompiledDeleteStatement implements ICompiledDmlStatement {
- private VariableExpr var;
- private String dataverseName;
- private String datasetName;
- private Expression condition;
- private int varCounter;
- private AqlMetadataProvider metadataProvider;
-
- public CompiledDeleteStatement(VariableExpr var, String dataverseName, String datasetName,
- Expression condition, int varCounter, AqlMetadataProvider metadataProvider) {
- this.var = var;
- this.dataverseName = dataverseName;
- this.datasetName = datasetName;
- this.condition = condition;
- this.varCounter = varCounter;
- this.metadataProvider = metadataProvider;
- }
-
- @Override
- public String getDatasetName() {
- return datasetName;
- }
-
- @Override
- public String getDataverseName() {
- return dataverseName;
- }
-
- public int getVarCounter() {
- return varCounter;
- }
-
- public Expression getCondition() {
- return condition;
- }
-
- public Query getQuery() throws AlgebricksException {
-
- List<Expression> arguments = new ArrayList<Expression>();
- String arg = dataverseName == null ? datasetName : dataverseName + "." + datasetName;
- LiteralExpr argumentLiteral = new LiteralExpr(new StringLiteral(arg));
- arguments.add(argumentLiteral);
-
- CallExpr callExpression = new CallExpr(new FunctionSignature(FunctionConstants.ASTERIX_NS, "dataset", 1),
- arguments);
- List<Clause> clauseList = new ArrayList<Clause>();
- Clause forClause = new ForClause(var, callExpression);
- clauseList.add(forClause);
- Clause whereClause = null;
- if (condition != null) {
- whereClause = new WhereClause(condition);
- clauseList.add(whereClause);
- }
-
- Dataset dataset = metadataProvider.findDataset(dataverseName, datasetName);
- if (dataset == null) {
- throw new AlgebricksException("Unknown dataset " + datasetName);
- }
- String itemTypeName = dataset.getItemTypeName();
- IAType itemType = metadataProvider.findType(dataset.getDataverseName(), itemTypeName);
- ARecordType recType = (ARecordType) itemType;
- String[] fieldNames = recType.getFieldNames();
- List<FieldBinding> fieldBindings = new ArrayList<FieldBinding>();
- for (int i = 0; i < fieldNames.length; i++) {
- FieldAccessor fa = new FieldAccessor(var, new Identifier(fieldNames[i]));
- FieldBinding fb = new FieldBinding(new LiteralExpr(new StringLiteral(fieldNames[i])), fa);
- fieldBindings.add(fb);
- }
- RecordConstructor rc = new RecordConstructor(fieldBindings);
-
- FLWOGRExpression flowgr = new FLWOGRExpression(clauseList, rc);
- Query query = new Query();
- query.setBody(flowgr);
- return query;
- }
-
- @Override
- public Kind getKind() {
- return Kind.DELETE;
- }
-
- }
-
- public static class CompiledCompactStatement implements ICompiledStatement {
- private final String dataverseName;
- private final String datasetName;
-
- public CompiledCompactStatement(String dataverseName, String datasetName) {
- this.dataverseName = dataverseName;
- this.datasetName = datasetName;
- }
-
- public String getDataverseName() {
- return dataverseName;
- }
-
- public String getDatasetName() {
- return datasetName;
- }
-
- @Override
- public Kind getKind() {
- return Kind.COMPACT;
- }
- }
-
- public static class CompiledIndexCompactStatement extends CompiledCompactStatement {
- private final String indexName;
- private final List<List<String>> keyFields;
- private final List<IAType> keyTypes;
- private final IndexType indexType;
- private final boolean isEnforced;
-
- // Specific to NGram index.
- private final int gramLength;
-
- public CompiledIndexCompactStatement(String dataverseName, String datasetName, String indexName,
- List<List<String>> keyFields, List<IAType> keyTypes, boolean isEnforced, int gramLength, IndexType indexType) {
- super(dataverseName, datasetName);
- this.indexName = indexName;
- this.keyFields = keyFields;
- this.keyTypes = keyTypes;
- this.gramLength = gramLength;
- this.indexType = indexType;
- this.isEnforced = isEnforced;
- }
-
- public String getIndexName() {
- return indexName;
- }
-
- public List<List<String>> getKeyFields() {
- return keyFields;
- }
-
- public List<IAType> getKeyTypes() {
- return keyTypes;
- }
-
- public IndexType getIndexType() {
- return indexType;
- }
-
- public int getGramLength() {
- return gramLength;
- }
-
- public boolean isEnforced() {
- return isEnforced;
- }
- }
-}
http://git-wip-us.apache.org/repos/asf/incubator-asterixdb/blob/34d81630/asterix-algebra/src/main/java/edu/uci/ics/asterix/translator/ConstantHelper.java
----------------------------------------------------------------------
diff --git a/asterix-algebra/src/main/java/edu/uci/ics/asterix/translator/ConstantHelper.java b/asterix-algebra/src/main/java/edu/uci/ics/asterix/translator/ConstantHelper.java
deleted file mode 100644
index dc75889..0000000
--- a/asterix-algebra/src/main/java/edu/uci/ics/asterix/translator/ConstantHelper.java
+++ /dev/null
@@ -1,71 +0,0 @@
-/*
- * Copyright 2009-2013 by The Regents of the University of California
- * Licensed 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 from
- *
- * 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 edu.uci.ics.asterix.translator;
-
-import edu.uci.ics.asterix.aql.base.Literal;
-import edu.uci.ics.asterix.aql.literal.DoubleLiteral;
-import edu.uci.ics.asterix.aql.literal.FloatLiteral;
-import edu.uci.ics.asterix.aql.literal.IntegerLiteral;
-import edu.uci.ics.asterix.aql.literal.LongIntegerLiteral;
-import edu.uci.ics.asterix.aql.literal.StringLiteral;
-import edu.uci.ics.asterix.om.base.ABoolean;
-import edu.uci.ics.asterix.om.base.ADouble;
-import edu.uci.ics.asterix.om.base.AFloat;
-import edu.uci.ics.asterix.om.base.AInt32;
-import edu.uci.ics.asterix.om.base.AInt64;
-import edu.uci.ics.asterix.om.base.ANull;
-import edu.uci.ics.asterix.om.base.AString;
-import edu.uci.ics.asterix.om.base.IAObject;
-
-public final class ConstantHelper {
-
- public static IAObject objectFromLiteral(Literal valLiteral) {
- switch (valLiteral.getLiteralType()) {
- case DOUBLE: {
- DoubleLiteral d = (DoubleLiteral) valLiteral;
- return new ADouble(d.getValue());
- }
- case FALSE: {
- return ABoolean.FALSE;
- }
- case FLOAT: {
- FloatLiteral fl = (FloatLiteral) valLiteral;
- return new AFloat(fl.getValue());
- }
- case INTEGER: {
- IntegerLiteral il = (IntegerLiteral) valLiteral;
- return new AInt32(il.getValue());
- }
- case LONG: {
- LongIntegerLiteral il = (LongIntegerLiteral) valLiteral;
- return new AInt64(il.getValue());
- }
- case NULL: {
- return ANull.NULL;
- }
- case STRING: {
- StringLiteral sl = (StringLiteral) valLiteral;
- return new AString(sl.getValue());
- }
- case TRUE: {
- return ABoolean.TRUE;
- }
- default: {
- throw new IllegalStateException();
- }
- }
- }
-
-}
http://git-wip-us.apache.org/repos/asf/incubator-asterixdb/blob/34d81630/asterix-algebra/src/main/java/edu/uci/ics/asterix/translator/TranslationContext.java
----------------------------------------------------------------------
diff --git a/asterix-algebra/src/main/java/edu/uci/ics/asterix/translator/TranslationContext.java b/asterix-algebra/src/main/java/edu/uci/ics/asterix/translator/TranslationContext.java
deleted file mode 100644
index 986b5ca..0000000
--- a/asterix-algebra/src/main/java/edu/uci/ics/asterix/translator/TranslationContext.java
+++ /dev/null
@@ -1,73 +0,0 @@
-/*
- * Copyright 2009-2013 by The Regents of the University of California
- * Licensed 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 from
- *
- * 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 edu.uci.ics.asterix.translator;
-
-import java.util.HashMap;
-
-import edu.uci.ics.asterix.aql.expression.VariableExpr;
-import edu.uci.ics.hyracks.algebricks.core.algebra.base.Counter;
-import edu.uci.ics.hyracks.algebricks.core.algebra.base.LogicalVariable;
-
-public final class TranslationContext {
-
- private Counter varCounter;
- private HashMap<Integer, LogicalVariable> varEnv = new HashMap<Integer, LogicalVariable>();
- private boolean topFlwor = true;
-
- public TranslationContext(Counter varCounter) {
- this.varCounter = varCounter;
- }
-
- public int getVarCounter() {
- return varCounter.get();
- }
-
- public boolean isTopFlwor() {
- return topFlwor;
- }
-
- public void setTopFlwor(boolean b) {
- topFlwor = b;
- }
-
- public LogicalVariable getVar(Integer varId) {
- return varEnv.get(varId);
- }
-
- public LogicalVariable getVar(VariableExpr v) {
- return varEnv.get(v.getVar().getId());
- }
-
- public LogicalVariable newVar(VariableExpr v) {
- Integer i = v.getVar().getId();
- if (i > varCounter.get()) {
- varCounter.set(i);
- }
- LogicalVariable var = new LogicalVariable(i);
- varEnv.put(i, var);
- return var;
- }
-
- public void setVar(VariableExpr v, LogicalVariable var) {
- varEnv.put(v.getVar().getId(), var);
- }
-
- public LogicalVariable newVar() {
- varCounter.inc();
- LogicalVariable var = new LogicalVariable(varCounter.get());
- varEnv.put(varCounter.get(), var);
- return var;
- }
-}
http://git-wip-us.apache.org/repos/asf/incubator-asterixdb/blob/34d81630/asterix-algebra/src/main/java/edu/uci/ics/asterix/translator/TranslationException.java
----------------------------------------------------------------------
diff --git a/asterix-algebra/src/main/java/edu/uci/ics/asterix/translator/TranslationException.java b/asterix-algebra/src/main/java/edu/uci/ics/asterix/translator/TranslationException.java
deleted file mode 100644
index 2819961..0000000
--- a/asterix-algebra/src/main/java/edu/uci/ics/asterix/translator/TranslationException.java
+++ /dev/null
@@ -1,32 +0,0 @@
-/*
- * Copyright 2009-2013 by The Regents of the University of California
- * Licensed 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 from
- *
- * 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 edu.uci.ics.asterix.translator;
-
-import edu.uci.ics.asterix.common.exceptions.AsterixException;
-
-public class TranslationException extends AsterixException {
- /**
- *
- */
- private static final long serialVersionUID = 685960054131778068L;
-
- public TranslationException() {
- super();
- }
-
- public TranslationException(String msg) {
- super(msg);
- }
-}
http://git-wip-us.apache.org/repos/asf/incubator-asterixdb/blob/34d81630/asterix-algebra/src/main/java/edu/uci/ics/asterix/translator/TypeTranslator.java
----------------------------------------------------------------------
diff --git a/asterix-algebra/src/main/java/edu/uci/ics/asterix/translator/TypeTranslator.java b/asterix-algebra/src/main/java/edu/uci/ics/asterix/translator/TypeTranslator.java
deleted file mode 100644
index e6f3d17..0000000
--- a/asterix-algebra/src/main/java/edu/uci/ics/asterix/translator/TypeTranslator.java
+++ /dev/null
@@ -1,392 +0,0 @@
-/*
- * Copyright 2009-2013 by The Regents of the University of California
- * Licensed 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 from
- *
- * 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 edu.uci.ics.asterix.translator;
-
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.LinkedList;
-import java.util.List;
-import java.util.Map;
-
-import edu.uci.ics.asterix.aql.expression.OrderedListTypeDefinition;
-import edu.uci.ics.asterix.aql.expression.RecordTypeDefinition;
-import edu.uci.ics.asterix.aql.expression.RecordTypeDefinition.RecordKind;
-import edu.uci.ics.asterix.aql.expression.TypeExpression;
-import edu.uci.ics.asterix.aql.expression.TypeReferenceExpression;
-import edu.uci.ics.asterix.aql.expression.UnorderedListTypeDefinition;
-import edu.uci.ics.asterix.common.annotations.IRecordFieldDataGen;
-import edu.uci.ics.asterix.common.annotations.RecordDataGenAnnotation;
-import edu.uci.ics.asterix.common.exceptions.AsterixException;
-import edu.uci.ics.asterix.metadata.MetadataException;
-import edu.uci.ics.asterix.metadata.MetadataManager;
-import edu.uci.ics.asterix.metadata.MetadataTransactionContext;
-import edu.uci.ics.asterix.metadata.entities.AsterixBuiltinTypeMap;
-import edu.uci.ics.asterix.metadata.entities.Datatype;
-import edu.uci.ics.asterix.om.types.AOrderedListType;
-import edu.uci.ics.asterix.om.types.ARecordType;
-import edu.uci.ics.asterix.om.types.AUnionType;
-import edu.uci.ics.asterix.om.types.AUnorderedListType;
-import edu.uci.ics.asterix.om.types.AbstractCollectionType;
-import edu.uci.ics.asterix.om.types.AbstractComplexType;
-import edu.uci.ics.asterix.om.types.BuiltinType;
-import edu.uci.ics.asterix.om.types.IAType;
-import edu.uci.ics.asterix.om.types.TypeSignature;
-import edu.uci.ics.hyracks.algebricks.common.exceptions.AlgebricksException;
-import edu.uci.ics.hyracks.api.exceptions.HyracksDataException;
-
-public class TypeTranslator {
-
- public static Map<TypeSignature, IAType> computeTypes(MetadataTransactionContext mdTxnCtx, TypeExpression typeExpr,
- String typeName, String typeDataverse) throws AlgebricksException, MetadataException {
- Map<TypeSignature, IAType> typeMap = new HashMap<TypeSignature, IAType>();
- return computeTypes(mdTxnCtx, typeExpr, typeName, typeDataverse, typeMap);
- }
-
- public static Map<TypeSignature, IAType> computeTypes(MetadataTransactionContext mdTxnCtx, TypeExpression typeExpr,
- String typeName, String typeDataverse, Map<TypeSignature, IAType> typeMap) throws AlgebricksException,
- MetadataException {
- Map<String, Map<ARecordType, List<Integer>>> incompleteFieldTypes = new HashMap<String, Map<ARecordType, List<Integer>>>();
- Map<TypeSignature, List<AbstractCollectionType>> incompleteItemTypes = new HashMap<TypeSignature, List<AbstractCollectionType>>();
- Map<TypeSignature, List<TypeSignature>> incompleteTopLevelTypeReferences = new HashMap<TypeSignature, List<TypeSignature>>();
- firstPass(typeExpr, typeName, typeMap, incompleteFieldTypes, incompleteItemTypes,
- incompleteTopLevelTypeReferences, typeDataverse);
- secondPass(mdTxnCtx, typeMap, incompleteFieldTypes, incompleteItemTypes, incompleteTopLevelTypeReferences,
- typeDataverse);
-
- for (IAType type : typeMap.values())
- if (type.getTypeTag().isDerivedType())
- ((AbstractComplexType) type).generateNestedDerivedTypeNames();
- return typeMap;
- }
-
- private static Map<String, BuiltinType> builtinTypeMap = AsterixBuiltinTypeMap.getBuiltinTypes();
-
- private static void firstPass(TypeExpression typeExpr, String typeName, Map<TypeSignature, IAType> typeMap,
- Map<String, Map<ARecordType, List<Integer>>> incompleteFieldTypes,
- Map<TypeSignature, List<AbstractCollectionType>> incompleteItemTypes,
- Map<TypeSignature, List<TypeSignature>> incompleteTopLevelTypeReferences, String typeDataverse)
- throws AlgebricksException {
-
- if (builtinTypeMap.get(typeName) != null) {
- throw new AlgebricksException("Cannot redefine builtin type " + typeName + " .");
- }
- TypeSignature typeSignature = new TypeSignature(typeDataverse, typeName);
- try {
- switch (typeExpr.getTypeKind()) {
- case TYPEREFERENCE: {
- TypeReferenceExpression tre = (TypeReferenceExpression) typeExpr;
- IAType t = solveTypeReference(new TypeSignature(typeDataverse, tre.getIdent().getValue()), typeMap);
- if (t != null) {
- typeMap.put(typeSignature, t);
- } else {
- addIncompleteTopLevelTypeReference(typeName, tre, incompleteTopLevelTypeReferences,
- typeDataverse);
- }
- break;
- }
- case RECORD: {
- RecordTypeDefinition rtd = (RecordTypeDefinition) typeExpr;
- ARecordType recType = computeRecordType(typeSignature, rtd, typeMap, incompleteFieldTypes,
- incompleteItemTypes, typeDataverse);
- typeMap.put(typeSignature, recType);
- break;
- }
- case ORDEREDLIST: {
- OrderedListTypeDefinition oltd = (OrderedListTypeDefinition) typeExpr;
- AOrderedListType olType = computeOrderedListType(typeSignature, oltd, typeMap, incompleteItemTypes,
- incompleteFieldTypes, typeDataverse);
- typeMap.put(typeSignature, olType);
- break;
- }
- case UNORDEREDLIST: {
- UnorderedListTypeDefinition ultd = (UnorderedListTypeDefinition) typeExpr;
- AUnorderedListType ulType = computeUnorderedListType(typeSignature, ultd, typeMap,
- incompleteItemTypes, incompleteFieldTypes, typeDataverse);
- typeMap.put(typeSignature, ulType);
- break;
- }
- default: {
- throw new IllegalStateException();
- }
- }
- } catch (AsterixException e) {
- throw new AlgebricksException(e);
- }
- }
-
- private static void secondPass(MetadataTransactionContext mdTxnCtx, Map<TypeSignature, IAType> typeMap,
- Map<String, Map<ARecordType, List<Integer>>> incompleteFieldTypes,
- Map<TypeSignature, List<AbstractCollectionType>> incompleteItemTypes,
- Map<TypeSignature, List<TypeSignature>> incompleteTopLevelTypeReferences, String typeDataverse)
- throws AlgebricksException, MetadataException {
- // solve remaining top level references
-
- for (TypeSignature typeSignature : incompleteTopLevelTypeReferences.keySet()) {
- IAType t;// = typeMap.get(trefName);
- Datatype dt = MetadataManager.INSTANCE.getDatatype(mdTxnCtx, typeSignature.getNamespace(),
- typeSignature.getName());
- if (dt == null) {
- throw new AlgebricksException("Could not resolve type " + typeSignature);
- } else
- t = dt.getDatatype();
- for (TypeSignature sign : incompleteTopLevelTypeReferences.get(typeSignature)) {
- typeMap.put(sign, t);
- }
- }
- // solve remaining field type references
- for (String trefName : incompleteFieldTypes.keySet()) {
- IAType t;// = typeMap.get(trefName);
- Datatype dt = MetadataManager.INSTANCE.getDatatype(mdTxnCtx, typeDataverse, trefName);
- if (dt == null) {
- throw new AlgebricksException("Could not resolve type " + trefName);
- } else
- t = dt.getDatatype();
- Map<ARecordType, List<Integer>> fieldsToFix = incompleteFieldTypes.get(trefName);
- for (ARecordType recType : fieldsToFix.keySet()) {
- List<Integer> positions = fieldsToFix.get(recType);
- IAType[] fldTypes = recType.getFieldTypes();
- for (Integer pos : positions) {
- if (fldTypes[pos] == null) {
- fldTypes[pos] = t;
- } else { // nullable
- AUnionType nullableUnion = (AUnionType) fldTypes[pos];
- nullableUnion.setTypeAtIndex(t, 1);
- }
- }
- }
- }
-
- // solve remaining item type references
- for (TypeSignature typeSignature : incompleteItemTypes.keySet()) {
- IAType t;// = typeMap.get(trefName);
- Datatype dt = null;
- if (MetadataManager.INSTANCE != null) {
- dt = MetadataManager.INSTANCE.getDatatype(mdTxnCtx, typeSignature.getNamespace(),
- typeSignature.getName());
- if (dt == null) {
- throw new AlgebricksException("Could not resolve type " + typeSignature);
- }
- t = dt.getDatatype();
- } else {
- t = typeMap.get(typeSignature);
- }
- for (AbstractCollectionType act : incompleteItemTypes.get(typeSignature)) {
- act.setItemType(t);
- }
- }
- }
-
- private static AOrderedListType computeOrderedListType(TypeSignature typeSignature, OrderedListTypeDefinition oltd,
- Map<TypeSignature, IAType> typeMap, Map<TypeSignature, List<AbstractCollectionType>> incompleteItemTypes,
- Map<String, Map<ARecordType, List<Integer>>> incompleteFieldTypes, String defaultDataverse)
- throws AsterixException {
- TypeExpression tExpr = oltd.getItemTypeExpression();
- String typeName = typeSignature != null ? typeSignature.getName() : null;
- AOrderedListType aolt = new AOrderedListType(null, typeName);
- setCollectionItemType(tExpr, typeMap, incompleteItemTypes, incompleteFieldTypes, aolt, defaultDataverse);
- return aolt;
- }
-
- private static AUnorderedListType computeUnorderedListType(TypeSignature typeSignature,
- UnorderedListTypeDefinition ultd, Map<TypeSignature, IAType> typeMap,
- Map<TypeSignature, List<AbstractCollectionType>> incompleteItemTypes,
- Map<String, Map<ARecordType, List<Integer>>> incompleteFieldTypes, String defaulDataverse)
- throws AsterixException {
- TypeExpression tExpr = ultd.getItemTypeExpression();
- String typeName = typeSignature != null ? typeSignature.getName() : null;
- AUnorderedListType ault = new AUnorderedListType(null, typeName);
- setCollectionItemType(tExpr, typeMap, incompleteItemTypes, incompleteFieldTypes, ault, defaulDataverse);
- return ault;
- }
-
- private static void setCollectionItemType(TypeExpression tExpr, Map<TypeSignature, IAType> typeMap,
- Map<TypeSignature, List<AbstractCollectionType>> incompleteItemTypes,
- Map<String, Map<ARecordType, List<Integer>>> incompleteFieldTypes, AbstractCollectionType act,
- String defaultDataverse) throws AsterixException {
- switch (tExpr.getTypeKind()) {
- case ORDEREDLIST: {
- OrderedListTypeDefinition oltd = (OrderedListTypeDefinition) tExpr;
- IAType t = computeOrderedListType(null, oltd, typeMap, incompleteItemTypes, incompleteFieldTypes,
- defaultDataverse);
- act.setItemType(t);
- break;
- }
- case UNORDEREDLIST: {
- UnorderedListTypeDefinition ultd = (UnorderedListTypeDefinition) tExpr;
- IAType t = computeUnorderedListType(null, ultd, typeMap, incompleteItemTypes, incompleteFieldTypes,
- defaultDataverse);
- act.setItemType(t);
- break;
- }
- case RECORD: {
- RecordTypeDefinition rtd = (RecordTypeDefinition) tExpr;
- IAType t = computeRecordType(null, rtd, typeMap, incompleteFieldTypes, incompleteItemTypes,
- defaultDataverse);
- act.setItemType(t);
- break;
- }
- case TYPEREFERENCE: {
- TypeReferenceExpression tre = (TypeReferenceExpression) tExpr;
- TypeSignature signature = new TypeSignature(defaultDataverse, tre.getIdent().getValue());
- IAType tref = solveTypeReference(signature, typeMap);
- if (tref != null) {
- act.setItemType(tref);
- } else {
- addIncompleteCollectionTypeReference(act, tre, incompleteItemTypes, defaultDataverse);
- }
- break;
- }
- default: {
- throw new IllegalStateException();
- }
- }
- }
-
- private static void addIncompleteCollectionTypeReference(AbstractCollectionType collType,
- TypeReferenceExpression tre, Map<TypeSignature, List<AbstractCollectionType>> incompleteItemTypes,
- String defaultDataverse) {
- String typeName = tre.getIdent().getValue();
- TypeSignature typeSignature = new TypeSignature(defaultDataverse, typeName);
- List<AbstractCollectionType> typeList = incompleteItemTypes.get(typeSignature);
- if (typeList == null) {
- typeList = new LinkedList<AbstractCollectionType>();
- incompleteItemTypes.put(typeSignature, typeList);
- }
- typeList.add(collType);
- }
-
- private static void addIncompleteFieldTypeReference(ARecordType recType, int fldPosition,
- TypeReferenceExpression tre, Map<String, Map<ARecordType, List<Integer>>> incompleteFieldTypes) {
- String typeName = tre.getIdent().getValue();
- Map<ARecordType, List<Integer>> refMap = incompleteFieldTypes.get(typeName);
- if (refMap == null) {
- refMap = new HashMap<ARecordType, List<Integer>>();
- incompleteFieldTypes.put(typeName, refMap);
- }
- List<Integer> typeList = refMap.get(recType);
- if (typeList == null) {
- typeList = new ArrayList<Integer>();
- refMap.put(recType, typeList);
- }
- typeList.add(fldPosition);
- }
-
- private static void addIncompleteTopLevelTypeReference(String tdeclName, TypeReferenceExpression tre,
- Map<TypeSignature, List<TypeSignature>> incompleteTopLevelTypeReferences, String defaultDataverse) {
- String name = tre.getIdent().getValue();
- TypeSignature typeSignature = new TypeSignature(defaultDataverse, name);
- List<TypeSignature> refList = incompleteTopLevelTypeReferences.get(name);
- if (refList == null) {
- refList = new LinkedList<TypeSignature>();
- incompleteTopLevelTypeReferences.put(new TypeSignature(defaultDataverse, tre.getIdent().getValue()),
- refList);
- }
- refList.add(typeSignature);
- }
-
- private static IAType solveTypeReference(TypeSignature typeSignature, Map<TypeSignature, IAType> typeMap) {
- IAType builtin = builtinTypeMap.get(typeSignature.getName());
- if (builtin != null) {
- return builtin;
- } else {
- return typeMap.get(typeSignature);
- }
- }
-
- private static ARecordType computeRecordType(TypeSignature typeSignature, RecordTypeDefinition rtd,
- Map<TypeSignature, IAType> typeMap, Map<String, Map<ARecordType, List<Integer>>> incompleteFieldTypes,
- Map<TypeSignature, List<AbstractCollectionType>> incompleteItemTypes, String defaultDataverse)
- throws AsterixException {
- List<String> names = rtd.getFieldNames();
- int n = names.size();
- String[] fldNames = new String[n];
- IAType[] fldTypes = new IAType[n];
- int i = 0;
- for (String s : names) {
- fldNames[i++] = s;
- }
- boolean isOpen = rtd.getRecordKind() == RecordKind.OPEN;
- ARecordType recType;
- try {
- recType = new ARecordType(typeSignature == null ? null : typeSignature.getName(), fldNames, fldTypes,
- isOpen);
- } catch (HyracksDataException e) {
- throw new AsterixException(e);
- }
-
- List<IRecordFieldDataGen> fieldDataGen = rtd.getFieldDataGen();
- if (fieldDataGen.size() == n) {
- IRecordFieldDataGen[] rfdg = new IRecordFieldDataGen[n];
- rfdg = fieldDataGen.toArray(rfdg);
- recType.getAnnotations().add(new RecordDataGenAnnotation(rfdg, rtd.getUndeclaredFieldsDataGen()));
- }
-
- for (int j = 0; j < n; j++) {
- TypeExpression texpr = rtd.getFieldTypes().get(j);
- switch (texpr.getTypeKind()) {
- case TYPEREFERENCE: {
- TypeReferenceExpression tre = (TypeReferenceExpression) texpr;
- TypeSignature signature = new TypeSignature(defaultDataverse, tre.getIdent().getValue());
- IAType tref = solveTypeReference(signature, typeMap);
- if (tref != null) {
- if (!rtd.getNullableFields().get(j)) { // not nullable
- fldTypes[j] = tref;
- } else { // nullable
- fldTypes[j] = AUnionType.createNullableType(tref);
- }
- } else {
- addIncompleteFieldTypeReference(recType, j, tre, incompleteFieldTypes);
- if (rtd.getNullableFields().get(j)) {
- fldTypes[j] = AUnionType.createNullableType(null);
- }
- }
- break;
- }
- case RECORD: {
- RecordTypeDefinition recTypeDef2 = (RecordTypeDefinition) texpr;
- IAType t2 = computeRecordType(null, recTypeDef2, typeMap, incompleteFieldTypes,
- incompleteItemTypes, defaultDataverse);
- if (!rtd.getNullableFields().get(j)) { // not nullable
- fldTypes[j] = t2;
- } else { // nullable
- fldTypes[j] = AUnionType.createNullableType(t2);
- }
- break;
- }
- case ORDEREDLIST: {
- OrderedListTypeDefinition oltd = (OrderedListTypeDefinition) texpr;
- IAType t2 = computeOrderedListType(null, oltd, typeMap, incompleteItemTypes, incompleteFieldTypes,
- defaultDataverse);
- fldTypes[j] = (rtd.getNullableFields().get(j)) ? AUnionType.createNullableType(t2) : t2;
- break;
- }
- case UNORDEREDLIST: {
- UnorderedListTypeDefinition ultd = (UnorderedListTypeDefinition) texpr;
- IAType t2 = computeUnorderedListType(null, ultd, typeMap, incompleteItemTypes,
- incompleteFieldTypes, defaultDataverse);
- fldTypes[j] = (rtd.getNullableFields().get(j)) ? AUnionType.createNullableType(t2) : t2;
- break;
- }
- default: {
- throw new IllegalStateException();
- }
- }
-
- }
-
- return recType;
- }
-}
http://git-wip-us.apache.org/repos/asf/incubator-asterixdb/blob/34d81630/asterix-algebra/src/main/java/org/apache/asterix/algebra/base/AsterixOperatorAnnotations.java
----------------------------------------------------------------------
diff --git a/asterix-algebra/src/main/java/org/apache/asterix/algebra/base/AsterixOperatorAnnotations.java b/asterix-algebra/src/main/java/org/apache/asterix/algebra/base/AsterixOperatorAnnotations.java
new file mode 100644
index 0000000..1ce5b5f
--- /dev/null
+++ b/asterix-algebra/src/main/java/org/apache/asterix/algebra/base/AsterixOperatorAnnotations.java
@@ -0,0 +1,22 @@
+/*
+ * Copyright 2009-2013 by The Regents of the University of California
+ * Licensed 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 from
+ *
+ * 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 edu.uci.ics.asterix.algebra.base;
+
+public interface AsterixOperatorAnnotations {
+ public static final String FIELD_ACCESS = "FIELD_ACCESS";
+ public static final String PUSHED_FIELD_ACCESS = "PUSHED_FIELD_ACCESS";
+ public static final String PUSHED_RUNNABLE_FIELD_ACCESS = "PUSHED_RUNNABLE_FIELD_ACCESS";
+ public static final String FIELD_TYPE = "FIELD_TYPE";
+}
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/incubator-asterixdb/blob/34d81630/asterix-algebra/src/main/java/org/apache/asterix/algebra/base/LogicalExpressionDeepCopyVisitor.java
----------------------------------------------------------------------
diff --git a/asterix-algebra/src/main/java/org/apache/asterix/algebra/base/LogicalExpressionDeepCopyVisitor.java b/asterix-algebra/src/main/java/org/apache/asterix/algebra/base/LogicalExpressionDeepCopyVisitor.java
new file mode 100644
index 0000000..a6ae0b1
--- /dev/null
+++ b/asterix-algebra/src/main/java/org/apache/asterix/algebra/base/LogicalExpressionDeepCopyVisitor.java
@@ -0,0 +1,149 @@
+/*
+ * Copyright 2009-2013 by The Regents of the University of California
+ * Licensed 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 from
+ *
+ * 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 edu.uci.ics.asterix.algebra.base;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+import org.apache.commons.lang3.mutable.Mutable;
+import org.apache.commons.lang3.mutable.MutableObject;
+
+import edu.uci.ics.hyracks.algebricks.common.exceptions.AlgebricksException;
+import edu.uci.ics.hyracks.algebricks.core.algebra.base.Counter;
+import edu.uci.ics.hyracks.algebricks.core.algebra.base.ILogicalExpression;
+import edu.uci.ics.hyracks.algebricks.core.algebra.base.LogicalVariable;
+import edu.uci.ics.hyracks.algebricks.core.algebra.expressions.AbstractFunctionCallExpression;
+import edu.uci.ics.hyracks.algebricks.core.algebra.expressions.AggregateFunctionCallExpression;
+import edu.uci.ics.hyracks.algebricks.core.algebra.expressions.ConstantExpression;
+import edu.uci.ics.hyracks.algebricks.core.algebra.expressions.IExpressionAnnotation;
+import edu.uci.ics.hyracks.algebricks.core.algebra.expressions.ScalarFunctionCallExpression;
+import edu.uci.ics.hyracks.algebricks.core.algebra.expressions.StatefulFunctionCallExpression;
+import edu.uci.ics.hyracks.algebricks.core.algebra.expressions.UnnestingFunctionCallExpression;
+import edu.uci.ics.hyracks.algebricks.core.algebra.expressions.VariableReferenceExpression;
+import edu.uci.ics.hyracks.algebricks.core.algebra.visitors.ILogicalExpressionVisitor;
+
+public class LogicalExpressionDeepCopyVisitor implements ILogicalExpressionVisitor<ILogicalExpression, Void> {
+ private final Counter counter;
+ private final Map<LogicalVariable, LogicalVariable> inVarMapping;
+ private final Map<LogicalVariable, LogicalVariable> outVarMapping;
+
+ public LogicalExpressionDeepCopyVisitor(Counter counter, Map<LogicalVariable, LogicalVariable> inVarMapping,
+ Map<LogicalVariable, LogicalVariable> variableMapping) {
+ this.counter = counter;
+ this.inVarMapping = inVarMapping;
+ this.outVarMapping = variableMapping;
+ }
+
+ public ILogicalExpression deepCopy(ILogicalExpression expr) throws AlgebricksException {
+ return expr.accept(this, null);
+ }
+
+ private void deepCopyAnnotations(AbstractFunctionCallExpression src, AbstractFunctionCallExpression dest) {
+ Map<Object, IExpressionAnnotation> srcAnnotations = src.getAnnotations();
+ Map<Object, IExpressionAnnotation> destAnnotations = dest.getAnnotations();
+ for (Object k : srcAnnotations.keySet()) {
+ IExpressionAnnotation annotation = srcAnnotations.get(k).copy();
+ destAnnotations.put(k, annotation);
+ }
+ }
+
+ private void deepCopyOpaqueParameters(AbstractFunctionCallExpression src, AbstractFunctionCallExpression dest) {
+ Object[] srcOpaqueParameters = src.getOpaqueParameters();
+ Object[] newOpaqueParameters = null;
+ if (srcOpaqueParameters != null) {
+ newOpaqueParameters = new Object[srcOpaqueParameters.length];
+ for (int i = 0; i < srcOpaqueParameters.length; i++) {
+ newOpaqueParameters[i] = srcOpaqueParameters[i];
+ }
+ }
+ dest.setOpaqueParameters(newOpaqueParameters);
+ }
+
+ public MutableObject<ILogicalExpression> deepCopyExpressionReference(Mutable<ILogicalExpression> exprRef)
+ throws AlgebricksException {
+ return new MutableObject<ILogicalExpression>(deepCopy(exprRef.getValue()));
+ }
+
+ // TODO return List<...>
+ public ArrayList<Mutable<ILogicalExpression>> deepCopyExpressionReferenceList(List<Mutable<ILogicalExpression>> list)
+ throws AlgebricksException {
+ ArrayList<Mutable<ILogicalExpression>> listCopy = new ArrayList<Mutable<ILogicalExpression>>(list.size());
+ for (Mutable<ILogicalExpression> exprRef : list) {
+ listCopy.add(deepCopyExpressionReference(exprRef));
+ }
+ return listCopy;
+ }
+
+ @Override
+ public ILogicalExpression visitAggregateFunctionCallExpression(AggregateFunctionCallExpression expr, Void arg)
+ throws AlgebricksException {
+ AggregateFunctionCallExpression exprCopy = new AggregateFunctionCallExpression(expr.getFunctionInfo(),
+ expr.isTwoStep(), deepCopyExpressionReferenceList(expr.getArguments()));
+ deepCopyAnnotations(expr, exprCopy);
+ deepCopyOpaqueParameters(expr, exprCopy);
+ return exprCopy;
+ }
+
+ @Override
+ public ILogicalExpression visitConstantExpression(ConstantExpression expr, Void arg) throws AlgebricksException {
+ return new ConstantExpression(expr.getValue());
+ }
+
+ @Override
+ public ILogicalExpression visitScalarFunctionCallExpression(ScalarFunctionCallExpression expr, Void arg)
+ throws AlgebricksException {
+ ScalarFunctionCallExpression exprCopy = new ScalarFunctionCallExpression(expr.getFunctionInfo(),
+ deepCopyExpressionReferenceList(expr.getArguments()));
+ deepCopyAnnotations(expr, exprCopy);
+ deepCopyOpaqueParameters(expr, exprCopy);
+ return exprCopy;
+
+ }
+
+ @Override
+ public ILogicalExpression visitStatefulFunctionCallExpression(StatefulFunctionCallExpression expr, Void arg)
+ throws AlgebricksException {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public ILogicalExpression visitUnnestingFunctionCallExpression(UnnestingFunctionCallExpression expr, Void arg)
+ throws AlgebricksException {
+ UnnestingFunctionCallExpression exprCopy = new UnnestingFunctionCallExpression(expr.getFunctionInfo(),
+ deepCopyExpressionReferenceList(expr.getArguments()));
+ deepCopyAnnotations(expr, exprCopy);
+ deepCopyOpaqueParameters(expr, exprCopy);
+ return exprCopy;
+ }
+
+ @Override
+ public ILogicalExpression visitVariableReferenceExpression(VariableReferenceExpression expr, Void arg)
+ throws AlgebricksException {
+ LogicalVariable var = expr.getVariableReference();
+ LogicalVariable givenVarReplacement = inVarMapping.get(var);
+ if (givenVarReplacement != null) {
+ outVarMapping.put(var, givenVarReplacement);
+ return new VariableReferenceExpression(givenVarReplacement);
+ }
+ LogicalVariable varCopy = outVarMapping.get(var);
+ if (varCopy == null) {
+ counter.inc();
+ varCopy = new LogicalVariable(counter.get());
+ outVarMapping.put(var, varCopy);
+ }
+ return new VariableReferenceExpression(varCopy);
+ }
+}
http://git-wip-us.apache.org/repos/asf/incubator-asterixdb/blob/34d81630/asterix-algebra/src/main/java/org/apache/asterix/algebra/base/LogicalOperatorDeepCopyVisitor.java
----------------------------------------------------------------------
diff --git a/asterix-algebra/src/main/java/org/apache/asterix/algebra/base/LogicalOperatorDeepCopyVisitor.java b/asterix-algebra/src/main/java/org/apache/asterix/algebra/base/LogicalOperatorDeepCopyVisitor.java
new file mode 100644
index 0000000..cedc962
--- /dev/null
+++ b/asterix-algebra/src/main/java/org/apache/asterix/algebra/base/LogicalOperatorDeepCopyVisitor.java
@@ -0,0 +1,469 @@
+/*
+ * Copyright 2009-2013 by The Regents of the University of California
+ * Licensed 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 from
+ *
+ * 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 edu.uci.ics.asterix.algebra.base;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import org.apache.commons.lang3.mutable.Mutable;
+import org.apache.commons.lang3.mutable.MutableObject;
+
+import edu.uci.ics.hyracks.algebricks.common.exceptions.AlgebricksException;
+import edu.uci.ics.hyracks.algebricks.common.utils.Pair;
+import edu.uci.ics.hyracks.algebricks.core.algebra.base.Counter;
+import edu.uci.ics.hyracks.algebricks.core.algebra.base.ILogicalExpression;
+import edu.uci.ics.hyracks.algebricks.core.algebra.base.ILogicalOperator;
+import edu.uci.ics.hyracks.algebricks.core.algebra.base.ILogicalPlan;
+import edu.uci.ics.hyracks.algebricks.core.algebra.base.IOptimizationContext;
+import edu.uci.ics.hyracks.algebricks.core.algebra.base.LogicalVariable;
+import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.AggregateOperator;
+import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.AssignOperator;
+import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.DataSourceScanOperator;
+import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.DistinctOperator;
+import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.DistributeResultOperator;
+import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.EmptyTupleSourceOperator;
+import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.ExchangeOperator;
+import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.ExtensionOperator;
+import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.ExternalDataLookupOperator;
+import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.GroupByOperator;
+import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.IndexInsertDeleteOperator;
+import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.InnerJoinOperator;
+import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.InsertDeleteOperator;
+import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.LeftOuterJoinOperator;
+import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.LimitOperator;
+import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.MaterializeOperator;
+import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.NestedTupleSourceOperator;
+import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.OrderOperator;
+import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.OrderOperator.IOrder;
+import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.PartitioningSplitOperator;
+import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.ProjectOperator;
+import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.ReplicateOperator;
+import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.RunningAggregateOperator;
+import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.ScriptOperator;
+import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.SelectOperator;
+import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.SinkOperator;
+import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.SubplanOperator;
+import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.TokenizeOperator;
+import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.UnionAllOperator;
+import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.UnnestMapOperator;
+import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.UnnestOperator;
+import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.WriteOperator;
+import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.WriteResultOperator;
+import edu.uci.ics.hyracks.algebricks.core.algebra.plan.ALogicalPlanImpl;
+import edu.uci.ics.hyracks.algebricks.core.algebra.properties.FunctionalDependency;
+import edu.uci.ics.hyracks.algebricks.core.algebra.visitors.ILogicalOperatorVisitor;
+
+public class LogicalOperatorDeepCopyVisitor implements ILogicalOperatorVisitor<ILogicalOperator, ILogicalOperator> {
+ private final Counter counter;
+ private final LogicalExpressionDeepCopyVisitor exprDeepCopyVisitor;
+
+ // Key: Variable in the original plan. Value: New variable replacing the original one in the copied plan.
+ private final Map<LogicalVariable, LogicalVariable> outVarMapping = new HashMap<LogicalVariable, LogicalVariable>();
+
+ // Key: Variable in the original plan. Value: Variable with which to replace original variable in the plan copy.
+ private final Map<LogicalVariable, LogicalVariable> inVarMapping;
+
+ public LogicalOperatorDeepCopyVisitor(Counter counter) {
+ this.counter = counter;
+ this.inVarMapping = Collections.emptyMap();
+ exprDeepCopyVisitor = new LogicalExpressionDeepCopyVisitor(counter, inVarMapping, outVarMapping);
+ }
+
+ /**
+ * @param counter
+ * Starting variable counter.
+ * @param inVarMapping
+ * Variable mapping keyed by variables in the original plan.
+ * Those variables are replaced by their corresponding value in the map in the copied plan.
+ */
+ public LogicalOperatorDeepCopyVisitor(Counter counter, Map<LogicalVariable, LogicalVariable> inVarMapping) {
+ this.counter = counter;
+ this.inVarMapping = inVarMapping;
+ exprDeepCopyVisitor = new LogicalExpressionDeepCopyVisitor(counter, inVarMapping, outVarMapping);
+ }
+
+ private void copyAnnotations(ILogicalOperator src, ILogicalOperator dest) {
+ dest.getAnnotations().putAll(src.getAnnotations());
+ }
+
+ public ILogicalOperator deepCopy(ILogicalOperator op, ILogicalOperator arg) throws AlgebricksException {
+ return op.accept(this, arg);
+ }
+
+ private void deepCopyInputs(ILogicalOperator src, ILogicalOperator dest, ILogicalOperator arg)
+ throws AlgebricksException {
+ List<Mutable<ILogicalOperator>> inputs = src.getInputs();
+ List<Mutable<ILogicalOperator>> inputsCopy = dest.getInputs();
+ for (Mutable<ILogicalOperator> input : inputs) {
+ inputsCopy.add(deepCopyOperatorReference(input, arg));
+ }
+ }
+
+ private Mutable<ILogicalOperator> deepCopyOperatorReference(Mutable<ILogicalOperator> opRef, ILogicalOperator arg)
+ throws AlgebricksException {
+ return new MutableObject<ILogicalOperator>(deepCopy(opRef.getValue(), arg));
+ }
+
+ private List<Mutable<ILogicalOperator>> deepCopyOperatorReferenceList(List<Mutable<ILogicalOperator>> list,
+ ILogicalOperator arg) throws AlgebricksException {
+ List<Mutable<ILogicalOperator>> listCopy = new ArrayList<Mutable<ILogicalOperator>>(list.size());
+ for (Mutable<ILogicalOperator> opRef : list) {
+ listCopy.add(deepCopyOperatorReference(opRef, arg));
+ }
+ return listCopy;
+ }
+
+ private IOrder deepCopyOrder(IOrder order) {
+ switch (order.getKind()) {
+ case ASC:
+ case DESC:
+ return order;
+ case FUNCTIONCALL:
+ default:
+ throw new UnsupportedOperationException();
+ }
+ }
+
+ private List<Pair<IOrder, Mutable<ILogicalExpression>>> deepCopyOrderExpressionReferencePairList(
+ List<Pair<IOrder, Mutable<ILogicalExpression>>> list) throws AlgebricksException {
+ ArrayList<Pair<IOrder, Mutable<ILogicalExpression>>> listCopy = new ArrayList<Pair<IOrder, Mutable<ILogicalExpression>>>(
+ list.size());
+ for (Pair<IOrder, Mutable<ILogicalExpression>> pair : list) {
+ listCopy.add(new Pair<OrderOperator.IOrder, Mutable<ILogicalExpression>>(deepCopyOrder(pair.first),
+ exprDeepCopyVisitor.deepCopyExpressionReference(pair.second)));
+ }
+ return listCopy;
+ }
+
+ private ILogicalPlan deepCopyPlan(ILogicalPlan plan, ILogicalOperator arg) throws AlgebricksException {
+ List<Mutable<ILogicalOperator>> rootsCopy = deepCopyOperatorReferenceList(plan.getRoots(), arg);
+ ILogicalPlan planCopy = new ALogicalPlanImpl(rootsCopy);
+ return planCopy;
+ }
+
+ private List<ILogicalPlan> deepCopyPlanList(List<ILogicalPlan> list, List<ILogicalPlan> listCopy,
+ ILogicalOperator arg) throws AlgebricksException {
+ for (ILogicalPlan plan : list) {
+ listCopy.add(deepCopyPlan(plan, arg));
+ }
+ return listCopy;
+ }
+
+ private LogicalVariable deepCopyVariable(LogicalVariable var) {
+ if (var == null) {
+ return null;
+ }
+ LogicalVariable givenVarReplacement = inVarMapping.get(var);
+ if (givenVarReplacement != null) {
+ outVarMapping.put(var, givenVarReplacement);
+ return givenVarReplacement;
+ }
+ LogicalVariable varCopy = outVarMapping.get(var);
+ if (varCopy == null) {
+ counter.inc();
+ varCopy = new LogicalVariable(counter.get());
+ outVarMapping.put(var, varCopy);
+ }
+ return varCopy;
+ }
+
+ private List<Pair<LogicalVariable, Mutable<ILogicalExpression>>> deepCopyVariableExpressionReferencePairList(
+ List<Pair<LogicalVariable, Mutable<ILogicalExpression>>> list) throws AlgebricksException {
+ List<Pair<LogicalVariable, Mutable<ILogicalExpression>>> listCopy = new ArrayList<Pair<LogicalVariable, Mutable<ILogicalExpression>>>(
+ list.size());
+ for (Pair<LogicalVariable, Mutable<ILogicalExpression>> pair : list) {
+ listCopy.add(new Pair<LogicalVariable, Mutable<ILogicalExpression>>(deepCopyVariable(pair.first),
+ exprDeepCopyVisitor.deepCopyExpressionReference(pair.second)));
+ }
+ return listCopy;
+ }
+
+ // TODO return List<...>
+ private ArrayList<LogicalVariable> deepCopyVariableList(List<LogicalVariable> list) {
+ ArrayList<LogicalVariable> listCopy = new ArrayList<LogicalVariable>(list.size());
+ for (LogicalVariable var : list) {
+ listCopy.add(deepCopyVariable(var));
+ }
+ return listCopy;
+ }
+
+ public void reset() {
+ outVarMapping.clear();
+ }
+
+ public void updatePrimaryKeys(IOptimizationContext context) {
+ for (Map.Entry<LogicalVariable, LogicalVariable> entry : outVarMapping.entrySet()) {
+ List<LogicalVariable> primaryKey = context.findPrimaryKey(entry.getKey());
+ if (primaryKey != null) {
+ List<LogicalVariable> head = new ArrayList<LogicalVariable>();
+ for (LogicalVariable variable : primaryKey) {
+ head.add(outVarMapping.get(variable));
+ }
+ List<LogicalVariable> tail = new ArrayList<LogicalVariable>(1);
+ tail.add(entry.getValue());
+ context.addPrimaryKey(new FunctionalDependency(head, tail));
+ }
+ }
+ }
+
+ public LogicalVariable varCopy(LogicalVariable var) throws AlgebricksException {
+ return outVarMapping.get(var);
+ }
+
+ @Override
+ public ILogicalOperator visitAggregateOperator(AggregateOperator op, ILogicalOperator arg)
+ throws AlgebricksException {
+ AggregateOperator opCopy = new AggregateOperator(deepCopyVariableList(op.getVariables()),
+ exprDeepCopyVisitor.deepCopyExpressionReferenceList(op.getExpressions()));
+ deepCopyInputs(op, opCopy, arg);
+ copyAnnotations(op, opCopy);
+ opCopy.setExecutionMode(op.getExecutionMode());
+ return opCopy;
+ }
+
+ @Override
+ public ILogicalOperator visitAssignOperator(AssignOperator op, ILogicalOperator arg) throws AlgebricksException {
+ AssignOperator opCopy = new AssignOperator(deepCopyVariableList(op.getVariables()),
+ exprDeepCopyVisitor.deepCopyExpressionReferenceList(op.getExpressions()));
+ deepCopyInputs(op, opCopy, arg);
+ copyAnnotations(op, opCopy);
+ opCopy.setExecutionMode(op.getExecutionMode());
+ return opCopy;
+ }
+
+ @Override
+ public ILogicalOperator visitDataScanOperator(DataSourceScanOperator op, ILogicalOperator arg)
+ throws AlgebricksException {
+ DataSourceScanOperator opCopy = new DataSourceScanOperator(deepCopyVariableList(op.getVariables()),
+ op.getDataSource());
+ deepCopyInputs(op, opCopy, arg);
+ copyAnnotations(op, opCopy);
+ opCopy.setExecutionMode(op.getExecutionMode());
+ return opCopy;
+ }
+
+ @Override
+ public ILogicalOperator visitDistinctOperator(DistinctOperator op, ILogicalOperator arg) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public ILogicalOperator visitEmptyTupleSourceOperator(EmptyTupleSourceOperator op, ILogicalOperator arg) {
+ EmptyTupleSourceOperator opCopy = new EmptyTupleSourceOperator();
+ opCopy.setExecutionMode(op.getExecutionMode());
+ return opCopy;
+ }
+
+ @Override
+ public ILogicalOperator visitExchangeOperator(ExchangeOperator op, ILogicalOperator arg) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public ILogicalOperator visitGroupByOperator(GroupByOperator op, ILogicalOperator arg) throws AlgebricksException {
+ List<Pair<LogicalVariable, Mutable<ILogicalExpression>>> groupByListCopy = deepCopyVariableExpressionReferencePairList(op
+ .getGroupByList());
+ List<Pair<LogicalVariable, Mutable<ILogicalExpression>>> decorListCopy = deepCopyVariableExpressionReferencePairList(op
+ .getDecorList());
+ List<ILogicalPlan> nestedPlansCopy = new ArrayList<ILogicalPlan>();
+
+ GroupByOperator opCopy = new GroupByOperator(groupByListCopy, decorListCopy, nestedPlansCopy);
+ deepCopyPlanList(op.getNestedPlans(), nestedPlansCopy, opCopy);
+ deepCopyInputs(op, opCopy, arg);
+ copyAnnotations(op, opCopy);
+ opCopy.setExecutionMode(op.getExecutionMode());
+ return opCopy;
+ }
+
+ @Override
+ public ILogicalOperator visitInnerJoinOperator(InnerJoinOperator op, ILogicalOperator arg)
+ throws AlgebricksException {
+ InnerJoinOperator opCopy = new InnerJoinOperator(exprDeepCopyVisitor.deepCopyExpressionReference(op
+ .getCondition()), deepCopyOperatorReference(op.getInputs().get(0), null), deepCopyOperatorReference(op
+ .getInputs().get(1), null));
+ copyAnnotations(op, opCopy);
+ opCopy.setExecutionMode(op.getExecutionMode());
+ return opCopy;
+ }
+
+ @Override
+ public ILogicalOperator visitLeftOuterJoinOperator(LeftOuterJoinOperator op, ILogicalOperator arg) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public ILogicalOperator visitLimitOperator(LimitOperator op, ILogicalOperator arg) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public ILogicalOperator visitNestedTupleSourceOperator(NestedTupleSourceOperator op, ILogicalOperator arg)
+ throws AlgebricksException {
+ NestedTupleSourceOperator opCopy = new NestedTupleSourceOperator(new MutableObject<ILogicalOperator>(arg));
+ deepCopyInputs(op, opCopy, arg);
+ copyAnnotations(op, opCopy);
+ opCopy.setExecutionMode(op.getExecutionMode());
+ return opCopy;
+ }
+
+ @Override
+ public ILogicalOperator visitOrderOperator(OrderOperator op, ILogicalOperator arg) throws AlgebricksException {
+ OrderOperator opCopy = new OrderOperator(deepCopyOrderExpressionReferencePairList(op.getOrderExpressions()));
+ deepCopyInputs(op, opCopy, arg);
+ copyAnnotations(op, opCopy);
+ opCopy.setExecutionMode(op.getExecutionMode());
+ return opCopy;
+ }
+
+ @Override
+ public ILogicalOperator visitPartitioningSplitOperator(PartitioningSplitOperator op, ILogicalOperator arg) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public ILogicalOperator visitProjectOperator(ProjectOperator op, ILogicalOperator arg) throws AlgebricksException {
+ ProjectOperator opCopy = new ProjectOperator(deepCopyVariableList(op.getVariables()));
+ deepCopyInputs(op, opCopy, arg);
+ copyAnnotations(op, opCopy);
+ opCopy.setExecutionMode(op.getExecutionMode());
+ return opCopy;
+ }
+
+ @Override
+ public ILogicalOperator visitReplicateOperator(ReplicateOperator op, ILogicalOperator arg)
+ throws AlgebricksException {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public ILogicalOperator visitMaterializeOperator(MaterializeOperator op, ILogicalOperator arg)
+ throws AlgebricksException {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public ILogicalOperator visitRunningAggregateOperator(RunningAggregateOperator op, ILogicalOperator arg) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public ILogicalOperator visitScriptOperator(ScriptOperator op, ILogicalOperator arg) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public ILogicalOperator visitSelectOperator(SelectOperator op, ILogicalOperator arg) throws AlgebricksException {
+ SelectOperator opCopy = new SelectOperator(exprDeepCopyVisitor.deepCopyExpressionReference(op.getCondition()),
+ op.getRetainNull(), deepCopyVariable(op.getNullPlaceholderVariable()));
+ deepCopyInputs(op, opCopy, arg);
+ copyAnnotations(op, opCopy);
+ opCopy.setExecutionMode(op.getExecutionMode());
+ return opCopy;
+ }
+
+ @Override
+ public ILogicalOperator visitSubplanOperator(SubplanOperator op, ILogicalOperator arg) throws AlgebricksException {
+ List<ILogicalPlan> nestedPlansCopy = new ArrayList<ILogicalPlan>();
+
+ SubplanOperator opCopy = new SubplanOperator(nestedPlansCopy);
+ deepCopyPlanList(op.getNestedPlans(), nestedPlansCopy, opCopy);
+ deepCopyInputs(op, opCopy, arg);
+ copyAnnotations(op, opCopy);
+ opCopy.setExecutionMode(op.getExecutionMode());
+ return opCopy;
+ }
+
+ @Override
+ public ILogicalOperator visitUnionOperator(UnionAllOperator op, ILogicalOperator arg) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public ILogicalOperator visitUnnestMapOperator(UnnestMapOperator op, ILogicalOperator arg)
+ throws AlgebricksException {
+ UnnestMapOperator opCopy = new UnnestMapOperator(deepCopyVariableList(op.getVariables()),
+ exprDeepCopyVisitor.deepCopyExpressionReference(op.getExpressionRef()), op.getVariableTypes(),
+ op.propagatesInput());
+ deepCopyInputs(op, opCopy, arg);
+ copyAnnotations(op, opCopy);
+ opCopy.setExecutionMode(op.getExecutionMode());
+ return opCopy;
+ }
+
+ @Override
+ public ILogicalOperator visitUnnestOperator(UnnestOperator op, ILogicalOperator arg) throws AlgebricksException {
+ UnnestOperator opCopy = new UnnestOperator(deepCopyVariable(op.getVariable()),
+ exprDeepCopyVisitor.deepCopyExpressionReference(op.getExpressionRef()),
+ deepCopyVariable(op.getPositionalVariable()), op.getPositionalVariableType(), op.getPositionWriter());
+ deepCopyInputs(op, opCopy, arg);
+ copyAnnotations(op, opCopy);
+ opCopy.setExecutionMode(op.getExecutionMode());
+ return opCopy;
+ }
+
+ @Override
+ public ILogicalOperator visitWriteOperator(WriteOperator op, ILogicalOperator arg) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public ILogicalOperator visitDistributeResultOperator(DistributeResultOperator op, ILogicalOperator arg) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public ILogicalOperator visitWriteResultOperator(WriteResultOperator op, ILogicalOperator arg) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public ILogicalOperator visitInsertDeleteOperator(InsertDeleteOperator op, ILogicalOperator arg) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public ILogicalOperator visitIndexInsertDeleteOperator(IndexInsertDeleteOperator op, ILogicalOperator arg) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public ILogicalOperator visitTokenizeOperator(TokenizeOperator op, ILogicalOperator arg) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public ILogicalOperator visitSinkOperator(SinkOperator op, ILogicalOperator arg) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public ILogicalOperator visitExtensionOperator(ExtensionOperator op, ILogicalOperator arg)
+ throws AlgebricksException {
+ throw new UnsupportedOperationException();
+ }
+
+ public Map<LogicalVariable, LogicalVariable> getVariableMapping() {
+ return outVarMapping;
+ }
+
+ @Override
+ public ILogicalOperator visitExternalDataLookupOperator(ExternalDataLookupOperator op, ILogicalOperator arg)
+ throws AlgebricksException {
+ throw new UnsupportedOperationException();
+ }
+}
http://git-wip-us.apache.org/repos/asf/incubator-asterixdb/blob/34d81630/asterix-algebra/src/main/java/org/apache/asterix/algebra/operators/CommitOperator.java
----------------------------------------------------------------------
diff --git a/asterix-algebra/src/main/java/org/apache/asterix/algebra/operators/CommitOperator.java b/asterix-algebra/src/main/java/org/apache/asterix/algebra/operators/CommitOperator.java
new file mode 100644
index 0000000..d65c67d
--- /dev/null
+++ b/asterix-algebra/src/main/java/org/apache/asterix/algebra/operators/CommitOperator.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright 2009-2013 by The Regents of the University of California
+ * Licensed 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 from
+ *
+ * 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 edu.uci.ics.asterix.algebra.operators;
+
+import java.util.Collection;
+import java.util.List;
+
+import edu.uci.ics.hyracks.algebricks.common.exceptions.AlgebricksException;
+import edu.uci.ics.hyracks.algebricks.core.algebra.base.LogicalVariable;
+import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.AbstractExtensibleLogicalOperator;
+import edu.uci.ics.hyracks.algebricks.core.algebra.operators.logical.IOperatorExtension;
+import edu.uci.ics.hyracks.algebricks.core.algebra.visitors.ILogicalExpressionReferenceTransform;
+
+public class CommitOperator extends AbstractExtensibleLogicalOperator {
+
+ private final List<LogicalVariable> primaryKeyLogicalVars;
+
+ public CommitOperator(List<LogicalVariable> primaryKeyLogicalVars) {
+ this.primaryKeyLogicalVars = primaryKeyLogicalVars;
+ }
+
+ @Override
+ public boolean isMap() {
+ // TODO Auto-generated method stub
+ return false;
+ }
+
+ @Override
+ public IOperatorExtension newInstance() {
+ return new CommitOperator(primaryKeyLogicalVars);
+ }
+
+ @Override
+ public boolean acceptExpressionTransform(ILogicalExpressionReferenceTransform transform) throws AlgebricksException {
+ // TODO Auto-generated method stub
+ return false;
+ }
+
+ @Override
+ public String toString() {
+ return "commit";
+ }
+
+ @Override
+ public void getUsedVariables(Collection<LogicalVariable> usedVars) {
+ usedVars.addAll(primaryKeyLogicalVars);
+ }
+
+ @Override
+ public void getProducedVariables(Collection<LogicalVariable> producedVars) {
+ // No produced variables.
+ }
+}