Skip to content

Commit

Permalink
AnalyzedStatement is now an interface
Browse files Browse the repository at this point in the history 
removed deprecated newAnalysis on Analyzer and let the vistors create instances directly
  • Loading branch information
@dobe
dobe committed Jan 27, 2015
1 parent db84c3f commit 40e4ace
Show file tree
Hide file tree
Showing 39 changed files with 376 additions and 465 deletions.
6 changes: 1 addition & 5 deletions sql/src/main/java/io/crate/analyze/AbstractDDLAnalyzedStatement.java
View file
Original file line number Diff line number Diff line change
Expand Up @@ -26,15 +26,11 @@
import io.crate.exceptions.InvalidTableNameException;
import io.crate.metadata.TableIdent;

public abstract class AbstractDDLAnalyzedStatement extends AnalyzedStatement {
public abstract class AbstractDDLAnalyzedStatement implements AnalyzedStatement {

protected final TableParameter tableParameter = new TableParameter();
protected TableIdent tableIdent;

protected AbstractDDLAnalyzedStatement(ParameterContext parameterContext) {
super(parameterContext);
}

public void table(TableIdent tableIdent) {
if (tableIdent.schema() != null && !isValidTableOrSchemaName(tableIdent.schema())) {
throw new InvalidSchemaNameException(tableIdent.schema());
Expand Down
6 changes: 1 addition & 5 deletions sql/src/main/java/io/crate/analyze/AbstractInsertAnalyzedStatement.java
View file
Original file line number Diff line number Diff line change
Expand Up @@ -40,7 +40,7 @@
/**
* holding analysis results for any insert statement variant
*/
public abstract class AbstractInsertAnalyzedStatement extends AnalyzedStatement {
public abstract class AbstractInsertAnalyzedStatement implements AnalyzedStatement {

private List<Reference> columns;
private IntSet primaryKeyColumnIndices = new IntOpenHashSet();
Expand All @@ -50,10 +50,6 @@ public abstract class AbstractInsertAnalyzedStatement extends AnalyzedStatement

private final Set<ReferenceInfo> allocatedReferences = new HashSet<>();

protected AbstractInsertAnalyzedStatement() {
super(null);
}

public List<Reference> columns() {
return columns;
}
Expand Down
19 changes: 16 additions & 3 deletions sql/src/main/java/io/crate/analyze/AbstractInsertAnalyzer.java
View file
Original file line number Diff line number Diff line change
Expand Up @@ -30,11 +30,17 @@
import io.crate.planner.symbol.Reference;
import io.crate.sql.tree.DefaultTraversalVisitor;
import io.crate.sql.tree.Insert;
import io.crate.sql.tree.Node;

import java.util.ArrayList;

public abstract class AbstractInsertAnalyzer<T> extends DefaultTraversalVisitor<AnalyzedStatement, T> {
public abstract class AbstractInsertAnalyzer extends DefaultTraversalVisitor<AbstractInsertAnalyzedStatement, Analysis> {

protected final AnalysisMetaData analysisMetaData;

protected AbstractInsertAnalyzer(AnalysisMetaData analysisMetaData) {
this.analysisMetaData = analysisMetaData;
}

protected void handleInsertColumns(Insert node, int maxInsertValues, AbstractInsertAnalyzedStatement context) {
// allocate columnsLists
Expand All @@ -49,7 +55,9 @@ protected void handleInsertColumns(Insert node, int maxInsertValues, AbstractIns

int i = 0;
for (ReferenceInfo columnInfo : context.tableInfo().columns()) {
if (i >= maxInsertValues) { break; }
if (i >= maxInsertValues) {
break;
}
addColumn(columnInfo.ident().columnIdent().name(), context, i);
i++;
}
Expand Down Expand Up @@ -94,7 +102,7 @@ protected Reference addColumn(String column, AbstractInsertAnalyzedStatement con
protected Reference addColumn(ReferenceIdent ident, AbstractInsertAnalyzedStatement context, int i) {
final ColumnIdent columnIdent = ident.columnIdent();
Preconditions.checkArgument(!columnIdent.name().startsWith("_"), "Inserting system columns is not allowed");
if(Constants.INVALID_COLUMN_NAME_PREDICATE.apply(columnIdent.name())){
if (Constants.INVALID_COLUMN_NAME_PREDICATE.apply(columnIdent.name())) {
throw new InvalidColumnNameException(columnIdent.name());
}

Expand Down Expand Up @@ -123,4 +131,9 @@ protected Reference addColumn(ReferenceIdent ident, AbstractInsertAnalyzedStatem
context.columns().add(columnReference);
return columnReference;
}

public AnalyzedStatement analyze(Node node, Analysis analysis) {
analysis.expectsAffectedRows(true);
return super.process(node, analysis);
}
}
17 changes: 1 addition & 16 deletions sql/src/main/java/io/crate/analyze/AddColumnAnalyzedStatement.java
View file
Original file line number Diff line number Diff line change
Expand Up @@ -23,7 +23,6 @@

import io.crate.exceptions.SchemaUnknownException;
import io.crate.exceptions.TableUnknownException;
import io.crate.metadata.FulltextAnalyzerResolver;
import io.crate.metadata.ReferenceInfos;
import io.crate.metadata.TableIdent;
import io.crate.metadata.table.SchemaInfo;
Expand All @@ -32,17 +31,12 @@
public class AddColumnAnalyzedStatement extends AbstractDDLAnalyzedStatement {

private final ReferenceInfos referenceInfos;
private final FulltextAnalyzerResolver fulltextAnalyzerResolver;
private TableInfo tableInfo;
private AnalyzedTableElements analyzedTableElements;
private boolean newPrimaryKeys = false;

protected AddColumnAnalyzedStatement(ReferenceInfos referenceInfos,
FulltextAnalyzerResolver fulltextAnalyzerResolver,
ParameterContext parameterContext) {
super(parameterContext);
protected AddColumnAnalyzedStatement(ReferenceInfos referenceInfos) {
this.referenceInfos = referenceInfos;
this.fulltextAnalyzerResolver = fulltextAnalyzerResolver;
}

@Override
Expand All @@ -66,20 +60,11 @@ public TableInfo table() {
return this.tableInfo;
}

@Override
public void normalize() {

}

@Override
public <C, R> R accept(AnalyzedStatementVisitor<C, R> visitor, C context) {
return visitor.visitAddColumnStatement(this, context);
}

public FulltextAnalyzerResolver fulltextAnalyzerResolver() {
return fulltextAnalyzerResolver;
}

public void analyzedTableElements(AnalyzedTableElements analyzedTableElements) {
this.analyzedTableElements = analyzedTableElements;
}
Expand Down
8 changes: 1 addition & 7 deletions sql/src/main/java/io/crate/analyze/AlterBlobTableAnalyzedStatement.java
View file
Original file line number Diff line number Diff line change
Expand Up @@ -33,8 +33,7 @@ public class AlterBlobTableAnalyzedStatement extends AbstractDDLAnalyzedStatemen
private final ReferenceInfos referenceInfos;
private TableInfo tableInfo;

public AlterBlobTableAnalyzedStatement(ParameterContext parameterContext, ReferenceInfos referenceInfos) {
super(parameterContext);
public AlterBlobTableAnalyzedStatement(ReferenceInfos referenceInfos) {
this.referenceInfos = referenceInfos;
}

Expand All @@ -56,11 +55,6 @@ public TableInfo table() {
return tableInfo;
}

@Override
public void normalize() {

}

@Override
public <C, R> R accept(AnalyzedStatementVisitor<C, R> analyzedStatementVisitor, C context) {
return analyzedStatementVisitor.visitAlterBlobTableStatement(this, context);
Expand Down
18 changes: 8 additions & 10 deletions sql/src/main/java/io/crate/analyze/AlterBlobTableAnalyzer.java
View file
Original file line number Diff line number Diff line change
Expand Up @@ -36,24 +36,22 @@ public AlterBlobTableAnalyzer(ReferenceInfos referenceInfos) {
}

@Override
public Void visitAlterBlobTable(AlterBlobTable node, AlterBlobTableAnalyzedStatement context) {
context.table(tableToIdent(node.table()));
public AlterBlobTableAnalyzedStatement visitAlterBlobTable(AlterBlobTable node, Analysis analysis) {
AlterBlobTableAnalyzedStatement statement = new AlterBlobTableAnalyzedStatement(referenceInfos);

statement.table(tableToIdent(node.table()));

if (node.genericProperties().isPresent()) {
TABLE_PROPERTIES_ANALYZER.analyze(
context.tableParameter(), context.table().tableParameterInfo(),
node.genericProperties(), context.parameters());
statement.tableParameter(), statement.table().tableParameterInfo(),
node.genericProperties(), analysis.parameterContext().parameters());
} else if (!node.resetProperties().isEmpty()) {
TABLE_PROPERTIES_ANALYZER.analyze(
context.tableParameter(), context.table().tableParameterInfo(),
statement.tableParameter(), statement.table().tableParameterInfo(),
node.resetProperties());
}

return null;
return statement;
}

@Override
public AnalyzedStatement newAnalysis(ParameterContext parameterContext) {
return new AlterBlobTableAnalyzedStatement(parameterContext, referenceInfos);
}
}
41 changes: 22 additions & 19 deletions sql/src/main/java/io/crate/analyze/AlterTableAddColumnAnalyzer.java
View file
Original file line number Diff line number Diff line change
Expand Up @@ -24,14 +24,15 @@
import io.crate.metadata.*;
import io.crate.metadata.table.TableInfo;
import io.crate.sql.tree.AlterTableAddColumn;
import io.crate.sql.tree.DefaultTraversalVisitor;
import io.crate.sql.tree.Node;
import io.crate.sql.tree.Table;
import io.crate.types.CollectionType;
import org.elasticsearch.common.inject.Inject;

import java.util.List;

public class AlterTableAddColumnAnalyzer extends AbstractStatementAnalyzer<Void, AddColumnAnalyzedStatement> {
public class AlterTableAddColumnAnalyzer extends DefaultTraversalVisitor<AddColumnAnalyzedStatement, Analysis> {

private final ReferenceInfos referenceInfos;
private final FulltextAnalyzerResolver fulltextAnalyzerResolver;
Expand All @@ -43,40 +44,41 @@ public AlterTableAddColumnAnalyzer(ReferenceInfos referenceInfos,
this.fulltextAnalyzerResolver = fulltextAnalyzerResolver;
}

@Override
public AnalyzedStatement newAnalysis(ParameterContext parameterContext) {
return new AddColumnAnalyzedStatement(referenceInfos, fulltextAnalyzerResolver, parameterContext);
public AddColumnAnalyzedStatement analyze(Node node, Analysis analysis) {
analysis.expectsAffectedRows(true);
return super.process(node, analysis);
}

@Override
protected Void visitNode(Node node, AddColumnAnalyzedStatement context) {
protected AddColumnAnalyzedStatement visitNode(Node node, Analysis analysis) {
throw new RuntimeException(
String.format("Encountered node %s but expected a AlterTableAddColumn node", node));
}

@Override
public Void visitAlterTableAddColumnStatement(AlterTableAddColumn node, AddColumnAnalyzedStatement context) {
setTableAndPartitionName(node.table(), context);
public AddColumnAnalyzedStatement visitAlterTableAddColumnStatement(AlterTableAddColumn node, Analysis analysis) {
AddColumnAnalyzedStatement statement = new AddColumnAnalyzedStatement(referenceInfos);
setTableAndPartitionName(node.table(), statement);

context.analyzedTableElements(TableElementsAnalyzer.analyze(
statement.analyzedTableElements(TableElementsAnalyzer.analyze(
node.tableElement(),
context.parameters(),
context.fulltextAnalyzerResolver()
analysis.parameterContext().parameters(),
fulltextAnalyzerResolver
));

for (AnalyzedColumnDefinition column : context.analyzedTableElements().columns()) {
ensureColumnLeafsAreNew(column, context.table());
for (AnalyzedColumnDefinition column : statement.analyzedTableElements().columns()) {
ensureColumnLeafsAreNew(column, statement.table());
}
addExistingPrimaryKeys(context);
ensureNoIndexDefinitions(context.analyzedTableElements().columns());
context.analyzedTableElements().finalizeAndValidate();
addExistingPrimaryKeys(statement);
ensureNoIndexDefinitions(statement.analyzedTableElements().columns());
statement.analyzedTableElements().finalizeAndValidate();

int numCurrentPks = context.table().primaryKey().size();
if (context.table().primaryKey().contains(new ColumnIdent("_id"))) {
int numCurrentPks = statement.table().primaryKey().size();
if (statement.table().primaryKey().contains(new ColumnIdent("_id"))) {
numCurrentPks -= 1;
}
context.newPrimaryKeys(context.analyzedTableElements().primaryKeys().size() > numCurrentPks);
return null;
statement.newPrimaryKeys(statement.analyzedTableElements().primaryKeys().size() > numCurrentPks);
return statement;
}

private void ensureColumnLeafsAreNew(AnalyzedColumnDefinition column, TableInfo tableInfo) {
Expand Down Expand Up @@ -130,4 +132,5 @@ private void setTableAndPartitionName(Table node, AddColumnAnalyzedStatement con
}
context.table(TableIdent.of(node));
}

}
8 changes: 1 addition & 7 deletions sql/src/main/java/io/crate/analyze/AlterTableAnalyzedStatement.java
View file
Original file line number Diff line number Diff line change
Expand Up @@ -38,8 +38,7 @@ public class AlterTableAnalyzedStatement extends AbstractDDLAnalyzedStatement {
private TableInfo tableInfo;
private Optional<PartitionName> partitionName = Optional.absent();

public AlterTableAnalyzedStatement(ParameterContext parameterContext, ReferenceInfos referenceInfos) {
super(parameterContext);
public AlterTableAnalyzedStatement(ReferenceInfos referenceInfos) {
this.referenceInfos = referenceInfos;
}

Expand Down Expand Up @@ -73,11 +72,6 @@ public Optional<PartitionName> partitionName() {
return partitionName;
}

@Override
public void normalize() {

}

@Override
public <C, R> R accept(AnalyzedStatementVisitor<C, R> analyzedStatementVisitor, C context) {
return analyzedStatementVisitor.visitAlterTableStatement(this, context);
Expand Down
35 changes: 18 additions & 17 deletions sql/src/main/java/io/crate/analyze/AlterTableAnalyzer.java
View file
Original file line number Diff line number Diff line change
Expand Up @@ -24,12 +24,10 @@
import io.crate.metadata.PartitionName;
import io.crate.metadata.ReferenceInfos;
import io.crate.metadata.TableIdent;
import io.crate.sql.tree.AlterTable;
import io.crate.sql.tree.ColumnDefinition;
import io.crate.sql.tree.Table;
import io.crate.sql.tree.*;
import org.elasticsearch.common.inject.Inject;

public class AlterTableAnalyzer extends AbstractStatementAnalyzer<Void, AlterTableAnalyzedStatement> {
public class AlterTableAnalyzer extends DefaultTraversalVisitor<AlterTableAnalyzedStatement, Analysis> {

private static final TablePropertiesAnalyzer TABLE_PROPERTIES_ANALYZER = new TablePropertiesAnalyzer();
private final ReferenceInfos referenceInfos;
Expand All @@ -40,7 +38,7 @@ public AlterTableAnalyzer(ReferenceInfos referenceInfos) {
}

@Override
public Void visitColumnDefinition(ColumnDefinition node, AlterTableAnalyzedStatement context) {
public AlterTableAnalyzedStatement visitColumnDefinition(ColumnDefinition node, Analysis analysis) {
if (node.ident().startsWith("_")) {
throw new IllegalArgumentException("Column ident must not start with '_'");
}
Expand All @@ -49,42 +47,45 @@ public Void visitColumnDefinition(ColumnDefinition node, AlterTableAnalyzedState
}

@Override
public Void visitAlterTable(AlterTable node, AlterTableAnalyzedStatement context) {
setTableAndPartitionName(node.table(), context);
public AlterTableAnalyzedStatement visitAlterTable(AlterTable node, Analysis analysis) {

TableParameterInfo tableParameterInfo = context.table().tableParameterInfo();
if (context.partitionName().isPresent()) {
AlterTableAnalyzedStatement statement = new AlterTableAnalyzedStatement(referenceInfos);
setTableAndPartitionName(node.table(), statement, analysis);

TableParameterInfo tableParameterInfo = statement.table().tableParameterInfo();
if (statement.partitionName().isPresent()) {
assert tableParameterInfo instanceof AlterPartitionedTableParameterInfo;
tableParameterInfo = ((AlterPartitionedTableParameterInfo) tableParameterInfo).partitionTableSettingsInfo();
}

if (node.genericProperties().isPresent()) {
TABLE_PROPERTIES_ANALYZER.analyze(
context.tableParameter(), tableParameterInfo, node.genericProperties(), context.parameters());
statement.tableParameter(), tableParameterInfo, node.genericProperties(),
analysis.parameterContext().parameters());
} else if (!node.resetProperties().isEmpty()) {
TABLE_PROPERTIES_ANALYZER.analyze(
context.tableParameter(), tableParameterInfo, node.resetProperties());
statement.tableParameter(), tableParameterInfo, node.resetProperties());
}

return null;
return statement;
}

private void setTableAndPartitionName(Table node, AlterTableAnalyzedStatement context) {
private void setTableAndPartitionName(Table node, AlterTableAnalyzedStatement context, Analysis analysis) {
context.table(TableIdent.of(node));
if (!node.partitionProperties().isEmpty()) {
PartitionName partitionName = PartitionPropertiesAnalyzer.toPartitionName(
context.table(),
node.partitionProperties(),
context.parameters());
analysis.parameterContext().parameters());
if (!context.table().partitions().contains(partitionName)) {
throw new IllegalArgumentException("Referenced partition does not exist.");
}
context.partitionName(partitionName);
}
}

@Override
public AnalyzedStatement newAnalysis(ParameterContext parameterContext) {
return new AlterTableAnalyzedStatement(parameterContext, referenceInfos);
public AnalyzedStatement analyze(Node node, Analysis analysis) {
analysis.expectsAffectedRows(true);
return process(node, analysis);
}
}
Loading

0 comments on commit 40e4ace

Please sign in to comment.