renamed FieldResolver to FieldProvider

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

@@ -23,7 +23,7 @@
 
 import io.crate.analyze.expressions.ExpressionAnalysisContext;
 import io.crate.analyze.expressions.ExpressionAnalyzer;
-import io.crate.analyze.relations.NameFieldResolver;
+import io.crate.analyze.relations.NameFieldProvider;
 import io.crate.analyze.relations.TableRelation;
 import io.crate.exceptions.PartitionUnknownException;
 import io.crate.exceptions.UnsupportedFeatureException;
@@ -136,7 +136,7 @@ private void setExpressionAnalyzer(TableRelation tableRelation, CopyAnalyzedStat
         expressionAnalyzer = new ExpressionAnalyzer(
                 analysisMetaData,
                 parameterContext,
-                new NameFieldResolver(tableRelation));
+                new NameFieldProvider(tableRelation));
         if (statement.mode() == CopyAnalyzedStatement.Mode.FROM) {
             expressionAnalyzer.resolveWritableFields(true);
         }

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

@@ -79,7 +79,7 @@ public AnalyzedStatement visitDelete(Delete node, Void context) {
         DeleteAnalyzedStatement deleteAnalyzedStatement = new DeleteAnalyzedStatement(analyzedRelation);
         InnerAnalysisContext innerAnalysisContext = new InnerAnalysisContext(
                 new ExpressionAnalyzer(analysisMetaData, parameterContext,
-                        new FullQualifedNameFieldResolver(relationAnalysisContext.sources())),
+                        new FullQualifedNameFieldProvider(relationAnalysisContext.sources())),
                 new ExpressionAnalysisContext(),
                 deleteAnalyzedStatement
         );

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

@@ -23,8 +23,8 @@
 
 import io.crate.analyze.expressions.ExpressionAnalysisContext;
 import io.crate.analyze.expressions.ExpressionAnalyzer;
-import io.crate.analyze.relations.FieldResolver;
-import io.crate.analyze.relations.NameFieldResolver;
+import io.crate.analyze.relations.FieldProvider;
+import io.crate.analyze.relations.NameFieldProvider;
 import io.crate.analyze.relations.TableRelation;
 import io.crate.core.StringUtils;
 import io.crate.core.collections.StringObjectMaps;
@@ -70,11 +70,11 @@ public AbstractInsertAnalyzedStatement visitInsertFromValues(InsertFromValues no
         TableRelation tableRelation = new TableRelation(tableInfo);
         validateTable(tableInfo);
 
-        FieldResolver fieldResolver = new NameFieldResolver(tableRelation);
+        FieldProvider fieldProvider = new NameFieldProvider(tableRelation);
         expressionAnalyzer = new ExpressionAnalyzer(
                 analysisMetaData,
                 analysis.parameterContext(),
-                fieldResolver
+                fieldProvider
                 );
         expressionAnalyzer.resolveWritableFields(true);
         expressionAnalysisContext = new ExpressionAnalysisContext();

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

@@ -78,9 +78,9 @@ public AnalyzedStatement visitUpdate(Update node, Void context) {
         TableRelation tableRelation = ((TableRelation) analyzedRelation);
         TableInfo tableInfo = tableRelation.tableInfo();
 
-        FieldResolver fieldResolver = new NameFieldResolver(analyzedRelation);
+        FieldProvider fieldProvider = new NameFieldProvider(analyzedRelation);
         ExpressionAnalyzer expressionAnalyzer =
-                new ExpressionAnalyzer(analysisMetaData, parameterContext, fieldResolver);
+                new ExpressionAnalyzer(analysisMetaData, parameterContext, fieldProvider);
         ExpressionAnalysisContext expressionAnalysisContext = new ExpressionAnalysisContext();
 
         int numNested = 1;

sql/src/main/java/io/crate/analyze/expressions/ExpressionAnalyzer.java

@@ -28,7 +28,7 @@
 import com.google.common.collect.ImmutableSet;
 import com.google.common.collect.Lists;
 import io.crate.analyze.*;
-import io.crate.analyze.relations.FieldResolver;
+import io.crate.analyze.relations.FieldProvider;
 import io.crate.analyze.where.WhereClauseValidator;
 import io.crate.exceptions.ColumnUnknownException;
 import io.crate.exceptions.ColumnValidationException;
@@ -84,19 +84,19 @@ public class ExpressionAnalyzer {
     private final static SubscriptVisitor SUBSCRIPT_VISITOR = new SubscriptVisitor();
     private final InnerExpressionAnalyzer innerAnalyzer;
     private final EvaluatingNormalizer normalizer;
-    private final FieldResolver fieldResolver;
+    private final FieldProvider fieldProvider;
     private final Functions functions;
     private final ReferenceInfos referenceInfos;
     private final ParameterContext parameterContext;
     private boolean forWrite = false;
 
     public ExpressionAnalyzer(AnalysisMetaData analysisMetaData,
                               ParameterContext parameterContext,
-                              FieldResolver fieldResolver) {
+                              FieldProvider fieldProvider) {
         functions = analysisMetaData.functions();
         referenceInfos = analysisMetaData.referenceInfos();
         this.parameterContext = parameterContext;
-        this.fieldResolver = fieldResolver;
+        this.fieldProvider = fieldProvider;
         this.innerAnalyzer = new InnerExpressionAnalyzer();
         this.normalizer = new EvaluatingNormalizer(
                 analysisMetaData.functions(), RowGranularity.CLUSTER, analysisMetaData.referenceResolver());
@@ -484,7 +484,7 @@ protected Symbol resolveSubscriptSymbol(SubscriptContext subscriptContext, Expre
             Symbol subscriptSymbol;
             Expression subscriptExpression = subscriptContext.expression();
             if (subscriptContext.qName() != null && subscriptExpression == null) {
-                subscriptSymbol = fieldResolver.resolveField(subscriptContext.qName(), subscriptContext.parts(), forWrite);
+                subscriptSymbol = fieldProvider.resolveField(subscriptContext.qName(), subscriptContext.parts(), forWrite);
             } else if (subscriptExpression != null) {
                 subscriptSymbol = subscriptExpression.accept(this, context);
             } else {
@@ -682,7 +682,7 @@ protected Symbol visitArithmeticExpression(ArithmeticExpression node, Expression
 
         @Override
         protected Symbol visitQualifiedNameReference(QualifiedNameReference node, ExpressionAnalysisContext context) {
-            return fieldResolver.resolveField(node.getName(), forWrite);
+            return fieldProvider.resolveField(node.getName(), forWrite);
         }
 
         @Override

sql/src/main/java/io/crate/analyze/relations/FieldResolver.java → sql/src/main/java/io/crate/analyze/relations/FieldProvider.java

@@ -27,7 +27,7 @@
 import javax.annotation.Nullable;
 import java.util.List;
 
-public interface FieldResolver {
+public interface FieldProvider {
 
     public Field resolveField(QualifiedName qualifiedName, boolean forWrite);
 

sql/src/main/java/io/crate/analyze/relations/FullQualifedNameFieldResolver.java → sql/src/main/java/io/crate/analyze/relations/FullQualifedNameFieldProvider.java

@@ -38,11 +38,11 @@
  * The Resolver also takes full qualified names so the name may contain table
  * and / or schema.
  */
-public class FullQualifedNameFieldResolver implements FieldResolver {
+public class FullQualifedNameFieldProvider implements FieldProvider {
 
     private Map<QualifiedName, AnalyzedRelation> sources;
 
-    public FullQualifedNameFieldResolver(Map<QualifiedName, AnalyzedRelation> sources) {
+    public FullQualifedNameFieldProvider(Map<QualifiedName, AnalyzedRelation> sources) {
         assert !sources.isEmpty() : "Must have at least one source";
         this.sources = sources;
     }

sql/src/main/java/io/crate/analyze/relations/NameFieldResolver.java → sql/src/main/java/io/crate/analyze/relations/NameFieldProvider.java

@@ -35,11 +35,11 @@
  *
  * The QualifiedNames must not contain a schema or a table.
  */
-public class NameFieldResolver implements FieldResolver {
+public class NameFieldProvider implements FieldProvider {
 
     private AnalyzedRelation relation;
 
-    public NameFieldResolver(AnalyzedRelation relation) {
+    public NameFieldProvider(AnalyzedRelation relation) {
         this.relation = relation;
     }
 

sql/src/main/java/io/crate/analyze/relations/RelationAnalyzer.java

@@ -74,8 +74,8 @@ protected AnalyzedRelation visitQuerySpecification(QuerySpecification node, Rela
             throw new UnsupportedOperationException
                     ("Only exactly one table is allowed in the FROM clause, got: " + context.sources().size());
         }
-        FieldResolver fieldResolver = new FullQualifedNameFieldResolver(context.sources());
-        expressionAnalyzer = new ExpressionAnalyzer(analysisMetaData, parameterContext, fieldResolver);
+        FieldProvider fieldProvider = new FullQualifedNameFieldProvider(context.sources());
+        expressionAnalyzer = new ExpressionAnalyzer(analysisMetaData, parameterContext, fieldProvider);
         expressionAnalysisContext = new ExpressionAnalysisContext();
 
         WhereClause whereClause = analyzeWhere(node.getWhere());

sql/src/test/java/io/crate/analyze/CompoundLiteralTest.java

@@ -25,7 +25,7 @@
 import io.crate.analyze.expressions.ExpressionAnalysisContext;
 import io.crate.analyze.expressions.ExpressionAnalyzer;
 import io.crate.analyze.relations.AnalyzedRelation;
-import io.crate.analyze.relations.FullQualifedNameFieldResolver;
+import io.crate.analyze.relations.FullQualifedNameFieldProvider;
 import io.crate.analyze.relations.AnalyzedRelationVisitor;
 import io.crate.metadata.*;
 import io.crate.metadata.table.SchemaInfo;
@@ -123,7 +123,7 @@ private Symbol analyzeExpression(String expression, Object[] params) {
         ExpressionAnalyzer expressionAnalyzer = new ExpressionAnalyzer(
                 analysisMetaData,
                 new ParameterContext(params, new Object[0][]),
-                new FullQualifedNameFieldResolver(
+                new FullQualifedNameFieldProvider(
                         ImmutableMap.<QualifiedName, AnalyzedRelation>of(
                             new QualifiedName("dummy"), new DummyRelation()
                 ))

sql/src/test/java/io/crate/analyze/ExpressionAnalyzerNormalizeTest.java

@@ -25,7 +25,7 @@
 import com.google.common.collect.ImmutableMap;
 import io.crate.analyze.expressions.ExpressionAnalyzer;
 import io.crate.analyze.relations.AnalyzedRelation;
-import io.crate.analyze.relations.FullQualifedNameFieldResolver;
+import io.crate.analyze.relations.FullQualifedNameFieldProvider;
 import io.crate.analyze.relations.TableRelation;
 import io.crate.exceptions.ColumnUnknownException;
 import io.crate.exceptions.ColumnValidationException;
@@ -136,7 +136,7 @@ public void prepare() {
                 .createInjector();
         expressionAnalyzer = new ExpressionAnalyzer(injector.getInstance(AnalysisMetaData.class),
                 new ParameterContext(new Object[0], new Object[0][]),
-                new FullQualifedNameFieldResolver(
+                new FullQualifedNameFieldProvider(
                         ImmutableMap.<QualifiedName, AnalyzedRelation>of(
                             new QualifiedName(Arrays.asList("doc", "test1")), new TableRelation(userTableInfo)))
         );

sql/src/test/java/io/crate/analyze/ReferenceToTrueVisitorTest.java

@@ -25,7 +25,7 @@
 import io.crate.analyze.expressions.ExpressionAnalysisContext;
 import io.crate.analyze.expressions.ExpressionAnalyzer;
 import io.crate.analyze.relations.AnalyzedRelation;
-import io.crate.analyze.relations.FullQualifedNameFieldResolver;
+import io.crate.analyze.relations.FullQualifedNameFieldProvider;
 import io.crate.analyze.relations.AnalyzedRelationVisitor;
 import io.crate.metadata.MetaDataModule;
 import io.crate.metadata.Path;
@@ -67,7 +67,7 @@ public void setUp() throws Exception {
         expressionAnalyzer = new ExpressionAnalyzer(
                 injector.getInstance(AnalysisMetaData.class),
                 new ParameterContext(new Object[0], new Object[0][]),
-                new FullQualifedNameFieldResolver(
+                new FullQualifedNameFieldProvider(
                         ImmutableMap.<QualifiedName, AnalyzedRelation>of(new QualifiedName("dummy"), new DummyRelation()))
         );
         expressionAnalysisContext = new ExpressionAnalysisContext();

sql/src/test/java/io/crate/analyze/expressions/ExpressionAnalyzerTest.java

@@ -26,7 +26,7 @@
 import io.crate.analyze.AnalysisMetaData;
 import io.crate.analyze.ParameterContext;
 import io.crate.analyze.relations.AnalyzedRelation;
-import io.crate.analyze.relations.FullQualifedNameFieldResolver;
+import io.crate.analyze.relations.FullQualifedNameFieldProvider;
 import io.crate.sql.parser.SqlParser;
 import io.crate.sql.tree.QualifiedName;
 import org.junit.Before;
@@ -59,7 +59,7 @@ public void setUp() throws Exception {
     public void testUnsupportedExpressionNullIf() throws Exception {
         expectedException.expect(UnsupportedOperationException.class);
         expectedException.expectMessage("Unsupported expression NULLIF(1, 3)");
-        ExpressionAnalyzer expressionAnalyzer = new ExpressionAnalyzer(analysisMetaData, emptyParameterContext, new FullQualifedNameFieldResolver(dummySources));
+        ExpressionAnalyzer expressionAnalyzer = new ExpressionAnalyzer(analysisMetaData, emptyParameterContext, new FullQualifedNameFieldProvider(dummySources));
         ExpressionAnalysisContext expressionAnalysisContext = new ExpressionAnalysisContext();
 
         expressionAnalyzer.convert(SqlParser.createExpression("NULLIF ( 1 , 3 )"), expressionAnalysisContext);
@@ -69,7 +69,7 @@ public void testUnsupportedExpressionNullIf() throws Exception {
     public void testUnsupportedExpressionCurrentDate() throws Exception {
         expectedException.expect(UnsupportedOperationException.class);
         expectedException.expectMessage("Unsupported expression current_time");
-        ExpressionAnalyzer expressionAnalyzer = new ExpressionAnalyzer(analysisMetaData, emptyParameterContext, new FullQualifedNameFieldResolver(dummySources));
+        ExpressionAnalyzer expressionAnalyzer = new ExpressionAnalyzer(analysisMetaData, emptyParameterContext, new FullQualifedNameFieldProvider(dummySources));
         ExpressionAnalysisContext expressionAnalysisContext = new ExpressionAnalysisContext();
 
         expressionAnalyzer.convert(SqlParser.createExpression("current_time"), expressionAnalysisContext);