change update analyzer to have sourceRelation and use relationAnalyze…

…r/expressionAnalyzer

sql/src/main/java/io/crate/analyze/Analyzer.java

@@ -50,7 +50,6 @@ public static class AnalyzerDispatcher extends AstVisitor<AnalyzedStatement, Par
 
         private final SelectStatementAnalyzer selectStatementAnalyzer;
         private final InsertFromSubQueryAnalyzer insertFromSubQueryAnalyzer;
-        private final UpdateStatementAnalyzer updateStatementAnalyzer;
         private final DropTableStatementAnalyzer dropTableStatementAnalyzer;
         private final CreateTableStatementAnalyzer createTableStatementAnalyzer;
         private final CreateBlobTableStatementAnalyzer createBlobTableStatementAnalyzer;
@@ -67,7 +66,6 @@ public static class AnalyzerDispatcher extends AstVisitor<AnalyzedStatement, Par
         public AnalyzerDispatcher(AnalysisMetaData analysisMetaData,
                                   SelectStatementAnalyzer selectStatementAnalyzer,
                                   InsertFromSubQueryAnalyzer insertFromSubQueryAnalyzer,
-                                  UpdateStatementAnalyzer updateStatementAnalyzer,
                                   DropTableStatementAnalyzer dropTableStatementAnalyzer,
                                   CreateTableStatementAnalyzer createTableStatementAnalyzer,
                                   CreateBlobTableStatementAnalyzer createBlobTableStatementAnalyzer,
@@ -81,7 +79,6 @@ public AnalyzerDispatcher(AnalysisMetaData analysisMetaData,
             this.analysisMetaData = analysisMetaData;
             this.selectStatementAnalyzer = selectStatementAnalyzer;
             this.insertFromSubQueryAnalyzer = insertFromSubQueryAnalyzer;
-            this.updateStatementAnalyzer = updateStatementAnalyzer;
             this.dropTableStatementAnalyzer = dropTableStatementAnalyzer;
             this.createTableStatementAnalyzer = createTableStatementAnalyzer;
             this.createBlobTableStatementAnalyzer = createBlobTableStatementAnalyzer;
@@ -124,7 +121,8 @@ public AnalyzedStatement visitInsertFromSubquery(InsertFromSubquery node, Parame
 
         @Override
         public AnalyzedStatement visitUpdate(Update node, ParameterContext context) {
-            return analyze(node, updateStatementAnalyzer, context);
+            UpdateStatementAnalyzer updateStatementAnalyzer = new UpdateStatementAnalyzer(analysisMetaData, context);
+            return updateStatementAnalyzer.process(node, null);
         }
 
         @Override

sql/src/main/java/io/crate/analyze/CopyStatementAnalyzer.java

@@ -111,7 +111,8 @@ private void setExpressionAnalyzer(CopyAnalyzedStatement context) {
                 context.parameterContext(),
                 ImmutableMap.<QualifiedName, AnalyzedRelation>of(
                         new QualifiedName(Arrays.asList(tableInfo.schemaInfo().name(), tableInfo.ident().name())),
-                        new TableRelation(tableInfo)));
+                        new TableRelation(tableInfo)),
+                context.mode() == CopyAnalyzedStatement.Mode.FROM);
         expressionAnalysisContext = new ExpressionAnalysisContext();
     }
 

sql/src/main/java/io/crate/analyze/DeleteStatementAnalyzer.java

@@ -76,12 +76,12 @@ public AnalyzedStatement visitDelete(Delete node, Void context) {
         AnalyzedRelation analyzedRelation = relationAnalyzer.process(node.getRelation(), relationAnalysisContext);
         if (Relations.isReadOnly(analyzedRelation)) {
             throw new UnsupportedOperationException(String.format(
-                    "relation \"%s\" is read-only and cannot be updated", analyzedRelation));
+                    "relation \"%s\" is read-only and cannot be deleted", analyzedRelation));
         }
 
         DeleteAnalyzedStatement deleteAnalyzedStatement = new DeleteAnalyzedStatement(parameterContext, analyzedRelation);
         InnerAnalysisContext innerAnalysisContext = new InnerAnalysisContext(
-                new ExpressionAnalyzer(analysisMetaData, parameterContext, relationAnalysisContext.sources()),
+                new ExpressionAnalyzer(analysisMetaData, parameterContext, relationAnalysisContext.sources(), false),
                 new ExpressionAnalysisContext(),
                 deleteAnalyzedStatement
         );

sql/src/main/java/io/crate/analyze/InsertFromValuesAnalyzer.java

@@ -67,7 +67,8 @@ public Void visitInsertFromValues(InsertFromValues node, InsertFromValuesAnalyze
                 context.parameterContext(),
                 ImmutableMap.<QualifiedName, AnalyzedRelation>of(
                         new QualifiedName(Arrays.asList(table.schemaInfo().name(), table.ident().name())),
-                        new TableRelation(table))
+                        new TableRelation(table)),
+                true
         );
         expressionAnalysisContext = new ExpressionAnalysisContext();
 

sql/src/main/java/io/crate/analyze/SelectAnalyzedStatement.java

@@ -180,7 +180,7 @@ public <C, R> R accept(RelationVisitor<C, R> visitor, C context) {
     }
 
     @Override
-    public Reference getReference(ColumnIdent columnIdent) {
+    public Reference getReference(ColumnIdent columnIdent, boolean forWrite) {
         throw new UnsupportedOperationException("getReference on SelectAnalyzedStatement is not implemented");
     }
 

sql/src/main/java/io/crate/analyze/UpdateAnalyzedStatement.java

@@ -23,112 +23,83 @@
 
 import com.google.common.base.Predicate;
 import com.google.common.collect.Iterables;
-import io.crate.metadata.Functions;
-import io.crate.metadata.ReferenceInfos;
-import io.crate.metadata.ReferenceResolver;
-import io.crate.metadata.TableIdent;
-import io.crate.metadata.table.TableInfo;
+import io.crate.analyze.relations.AnalyzedRelation;
 import io.crate.planner.symbol.Reference;
 import io.crate.planner.symbol.Symbol;
 
 import javax.annotation.Nullable;
-import java.util.*;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
 
-public class UpdateAnalyzedStatement extends AbstractDataAnalyzedStatement {
+public class UpdateAnalyzedStatement extends AnalyzedStatement {
 
     private static final Predicate<NestedAnalyzedStatement> HAS_NO_RESULT_PREDICATE = new Predicate<NestedAnalyzedStatement>() {
         @Override
         public boolean apply(@Nullable NestedAnalyzedStatement input) {
-            return input != null && input.hasNoResult();
+            return input != null && input.whereClause.noMatch();
         }
     };
 
-    List<NestedAnalyzedStatement> nestedAnalysisList;
 
+    private final List<NestedAnalyzedStatement> nestedStatements;
+    private final AnalyzedRelation sourceRelation;
 
-    public UpdateAnalyzedStatement(ReferenceInfos referenceInfos,
-                                   Functions functions,
-                                   ParameterContext parameterContext,
-                                   ReferenceResolver referenceResolver) {
-        super(referenceInfos, functions, parameterContext, referenceResolver);
-        int numNested = 1;
-        if (parameterContext.bulkParameters.length > 0) {
-            numNested = parameterContext.bulkParameters.length;
-        }
 
-        nestedAnalysisList = new ArrayList<>(numNested);
-        for (int i = 0; i < numNested; i++) {
-            nestedAnalysisList.add(new NestedAnalyzedStatement(
-                    referenceInfos,
-                    functions,
-                    parameterContext,
-                    referenceResolver
-            ));
-        }
+    public UpdateAnalyzedStatement(AnalyzedRelation sourceRelation, List<NestedAnalyzedStatement> nestedStatements) {
+        super(null);
+        this.sourceRelation = sourceRelation;
+        this.nestedStatements = nestedStatements;
     }
 
-    @Override
-    public boolean expectsAffectedRows() {
-        return true;
+    public AnalyzedRelation sourceRelation() {
+        return sourceRelation;
     }
 
-    @Override
-    public void table(TableIdent tableIdent) {
-        throw new UnsupportedOperationException("used nested analysis");
+    public List<NestedAnalyzedStatement> nestedStatements() {
+        return nestedStatements;
     }
 
     @Override
-    public TableInfo table() {
-        throw new UnsupportedOperationException("used nested analysis");
+    public boolean expectsAffectedRows() {
+        return true;
     }
 
     @Override
     public boolean hasNoResult() {
-        return Iterables.all(nestedAnalysisList, HAS_NO_RESULT_PREDICATE);
+        return Iterables.all(nestedStatements, HAS_NO_RESULT_PREDICATE);
     }
 
     @Override
-    public void normalize() {
-
-    }
+    public void normalize() {}
 
     @Override
     public <C, R> R accept(AnalyzedStatementVisitor<C, R> analyzedStatementVisitor, C context) {
         return analyzedStatementVisitor.visitUpdateStatement(this, context);
     }
 
-    public List<NestedAnalyzedStatement> nestedAnalysis() {
-        return nestedAnalysisList;
-    }
-
-    public static class NestedAnalyzedStatement extends AbstractDataAnalyzedStatement {
+    public static class NestedAnalyzedStatement {
 
-        private Map<Reference, Symbol> assignments = new HashMap<>();
+        private final WhereClause whereClause;
+        private final Map<Reference, Symbol> assignments = new HashMap<>();
 
-        public NestedAnalyzedStatement(ReferenceInfos referenceInfos,
-                                       Functions functions,
-                                       ParameterContext parameterContext,
-                                       ReferenceResolver referenceResolver) {
-            super(referenceInfos, functions, parameterContext, referenceResolver);
-        }
-
-        @Override
-        public boolean hasNoResult() {
-            return whereClause().noMatch();
+        public NestedAnalyzedStatement(WhereClause whereClause) {
+            this.whereClause = whereClause;
         }
 
         public Map<Reference, Symbol> assignments() {
             return assignments;
         }
 
+        public WhereClause whereClause() {
+            return whereClause;
+        }
+
         public void addAssignment(Reference reference, Symbol value) {
-            if (assignments.containsKey(reference)) {
+            if (assignments.put(reference, value) != null) {
                 throw new IllegalArgumentException(String.format(Locale.ENGLISH, "reference repeated %s", reference.info().ident().columnIdent().fqn()));
             }
-            if (!reference.info().ident().tableIdent().equals(table().ident())) {
-                throw new UnsupportedOperationException("cannot update references from other tables.");
-            }
-            assignments.put(reference, value);
         }
     }
 }