DBZ-252 Misc typo fixes and clean-up
This commit is contained in:
Gunnar Morling
parent
b56d6efdf1
commit
84dd36df46
@ -6,7 +6,9 @@
|
||||
[](https://groups.google.com/forum/#!forum/debezium)
|
||||
[](http://stackoverflow.com/questions/tagged/debezium)
|
||||
|
||||
Copyright Debezium Authors. Licensed under the [Apache License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0).
|
||||
Copyright Debezium Authors.
|
||||
Licensed under the [Apache License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0).
|
||||
The Antlr grammars within the debezium-ddl-parser module are licensed under the [MIT License](https://opensource.org/licenses/MIT).
|
||||
|
||||
# Debezium
|
||||
|
||||
|
||||
@ -35,7 +35,7 @@
|
||||
import io.debezium.relational.TableId;
|
||||
|
||||
/**
|
||||
* A ANTLR based parser for MySQL DDL statements.
|
||||
* An ANTLR based parser for MySQL DDL statements.
|
||||
*
|
||||
* @author Roman Kuchár <kucharrom@gmail.com>.
|
||||
*/
|
||||
|
||||
@ -6,6 +6,13 @@
|
||||
|
||||
package io.debezium.connector.mysql.antlr.listener;
|
||||
|
||||
import static io.debezium.antlr.AntlrDdlParser.getText;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
|
||||
import org.antlr.v4.runtime.tree.ParseTreeListener;
|
||||
|
||||
import io.debezium.connector.mysql.antlr.MySqlAntlrDdlParser;
|
||||
import io.debezium.ddl.parser.mysql.generated.MySqlParser;
|
||||
import io.debezium.ddl.parser.mysql.generated.MySqlParserBaseListener;
|
||||
@ -14,15 +21,9 @@
|
||||
import io.debezium.relational.TableEditor;
|
||||
import io.debezium.relational.TableId;
|
||||
import io.debezium.text.ParsingException;
|
||||
import org.antlr.v4.runtime.tree.ParseTreeListener;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
|
||||
import static io.debezium.antlr.AntlrDdlParser.getText;
|
||||
|
||||
/**
|
||||
* Parser listeners that is parsing MySQL ALTER TABLE statements.
|
||||
* Parser listener that is parsing MySQL ALTER TABLE statements.
|
||||
*
|
||||
* @author Roman Kuchár <kucharrom@gmail.com>.
|
||||
*/
|
||||
@ -30,7 +31,7 @@ public class AlterTableParserListener extends MySqlParserBaseListener {
|
||||
|
||||
private static final int STARTING_INDEX = 1;
|
||||
|
||||
private final MySqlAntlrDdlParser parserCtx;
|
||||
private final MySqlAntlrDdlParser parser;
|
||||
private final List<ParseTreeListener> listeners;
|
||||
|
||||
private TableEditor tableEditor;
|
||||
@ -39,15 +40,15 @@ public class AlterTableParserListener extends MySqlParserBaseListener {
|
||||
private List<ColumnEditor> columnEditors;
|
||||
private int parsingColumnIndex = STARTING_INDEX;
|
||||
|
||||
public AlterTableParserListener(MySqlAntlrDdlParser parserCtx, List<ParseTreeListener> listeners) {
|
||||
this.parserCtx = parserCtx;
|
||||
public AlterTableParserListener(MySqlAntlrDdlParser parser, List<ParseTreeListener> listeners) {
|
||||
this.parser = parser;
|
||||
this.listeners = listeners;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void enterAlterTable(MySqlParser.AlterTableContext ctx) {
|
||||
TableId tableId = parserCtx.parseQualifiedTableId(ctx.tableName().fullId());
|
||||
tableEditor = parserCtx.databaseTables().editTable(tableId);
|
||||
TableId tableId = parser.parseQualifiedTableId(ctx.tableName().fullId());
|
||||
tableEditor = parser.databaseTables().editTable(tableId);
|
||||
if (tableEditor == null) {
|
||||
throw new ParsingException(null, "Trying to alter table " + tableId.toString()
|
||||
+ ", which does not exists. Query: " + getText(ctx));
|
||||
@ -57,20 +58,20 @@ public void enterAlterTable(MySqlParser.AlterTableContext ctx) {
|
||||
|
||||
@Override
|
||||
public void exitAlterTable(MySqlParser.AlterTableContext ctx) {
|
||||
parserCtx.runIfNotNull(() -> {
|
||||
parser.runIfNotNull(() -> {
|
||||
listeners.remove(columnDefinitionListener);
|
||||
parserCtx.databaseTables().overwriteTable(tableEditor.create());
|
||||
parserCtx.signalAlterTable(tableEditor.tableId(), null, ctx.getParent());
|
||||
parser.databaseTables().overwriteTable(tableEditor.create());
|
||||
parser.signalAlterTable(tableEditor.tableId(), null, ctx.getParent());
|
||||
}, tableEditor);
|
||||
super.exitAlterTable(ctx);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void enterAlterByAddColumn(MySqlParser.AlterByAddColumnContext ctx) {
|
||||
parserCtx.runIfNotNull(() -> {
|
||||
String columnName = parserCtx.parseName(ctx.uid(0));
|
||||
parser.runIfNotNull(() -> {
|
||||
String columnName = parser.parseName(ctx.uid(0));
|
||||
ColumnEditor columnEditor = Column.editor().name(columnName);
|
||||
columnDefinitionListener = new ColumnDefinitionParserListener(tableEditor, columnEditor, parserCtx.dataTypeResolver(), parserCtx.getConverters());
|
||||
columnDefinitionListener = new ColumnDefinitionParserListener(tableEditor, columnEditor, parser.dataTypeResolver(), parser.getConverters());
|
||||
listeners.add(columnDefinitionListener);
|
||||
}, tableEditor);
|
||||
super.exitAlterByAddColumn(ctx);
|
||||
@ -78,7 +79,7 @@ public void enterAlterByAddColumn(MySqlParser.AlterByAddColumnContext ctx) {
|
||||
|
||||
@Override
|
||||
public void exitAlterByAddColumn(MySqlParser.AlterByAddColumnContext ctx) {
|
||||
parserCtx.runIfNotNull(() -> {
|
||||
parser.runIfNotNull(() -> {
|
||||
Column column = columnDefinitionListener.getColumn();
|
||||
tableEditor.addColumn(column);
|
||||
|
||||
@ -87,7 +88,7 @@ public void exitAlterByAddColumn(MySqlParser.AlterByAddColumnContext ctx) {
|
||||
tableEditor.reorderColumn(columnName, null);
|
||||
}
|
||||
else if (ctx.AFTER() != null) {
|
||||
String afterColumn = parserCtx.parseName(ctx.uid(1));
|
||||
String afterColumn = parser.parseName(ctx.uid(1));
|
||||
tableEditor.reorderColumn(columnName, afterColumn);
|
||||
}
|
||||
}, tableEditor, columnDefinitionListener);
|
||||
@ -97,13 +98,13 @@ else if (ctx.AFTER() != null) {
|
||||
@Override
|
||||
public void enterAlterByAddColumns(MySqlParser.AlterByAddColumnsContext ctx) {
|
||||
// multiple columns are added. Initialize a list of column editors for them
|
||||
parserCtx.runIfNotNull(() -> {
|
||||
parser.runIfNotNull(() -> {
|
||||
columnEditors = new ArrayList<>(ctx.uid().size());
|
||||
for (MySqlParser.UidContext uidContext : ctx.uid()) {
|
||||
String columnName = parserCtx.parseName(uidContext);
|
||||
String columnName = parser.parseName(uidContext);
|
||||
columnEditors.add(Column.editor().name(columnName));
|
||||
}
|
||||
columnDefinitionListener = new ColumnDefinitionParserListener(tableEditor, columnEditors.get(0), parserCtx.dataTypeResolver(), parserCtx.getConverters());
|
||||
columnDefinitionListener = new ColumnDefinitionParserListener(tableEditor, columnEditors.get(0), parser.dataTypeResolver(), parser.getConverters());
|
||||
listeners.add(columnDefinitionListener);
|
||||
}, tableEditor);
|
||||
super.enterAlterByAddColumns(ctx);
|
||||
@ -111,7 +112,7 @@ public void enterAlterByAddColumns(MySqlParser.AlterByAddColumnsContext ctx) {
|
||||
|
||||
@Override
|
||||
public void exitColumnDefinition(MySqlParser.ColumnDefinitionContext ctx) {
|
||||
parserCtx.runIfNotNull(() -> {
|
||||
parser.runIfNotNull(() -> {
|
||||
if (columnEditors != null) {
|
||||
// column editor list is not null when a multiple columns are parsed in one statement
|
||||
if (columnEditors.size() > parsingColumnIndex) {
|
||||
@ -131,7 +132,7 @@ public void exitColumnDefinition(MySqlParser.ColumnDefinitionContext ctx) {
|
||||
|
||||
@Override
|
||||
public void exitAlterByAddColumns(MySqlParser.AlterByAddColumnsContext ctx) {
|
||||
parserCtx.runIfNotNull(() -> {
|
||||
parser.runIfNotNull(() -> {
|
||||
columnEditors.forEach(columnEditor -> tableEditor.addColumn(columnEditor.create()));
|
||||
}, tableEditor, columnEditors);
|
||||
super.exitAlterByAddColumns(ctx);
|
||||
@ -139,11 +140,11 @@ public void exitAlterByAddColumns(MySqlParser.AlterByAddColumnsContext ctx) {
|
||||
|
||||
@Override
|
||||
public void enterAlterByChangeColumn(MySqlParser.AlterByChangeColumnContext ctx) {
|
||||
parserCtx.runIfNotNull(() -> {
|
||||
String oldColumnName = parserCtx.parseName(ctx.oldColumn);
|
||||
parser.runIfNotNull(() -> {
|
||||
String oldColumnName = parser.parseName(ctx.oldColumn);
|
||||
Column existingColumn = tableEditor.columnWithName(oldColumnName);
|
||||
if (existingColumn != null) {
|
||||
columnDefinitionListener = new ColumnDefinitionParserListener(tableEditor, existingColumn.edit(), parserCtx.dataTypeResolver(), parserCtx.getConverters());
|
||||
columnDefinitionListener = new ColumnDefinitionParserListener(tableEditor, existingColumn.edit(), parser.dataTypeResolver(), parser.getConverters());
|
||||
listeners.add(columnDefinitionListener);
|
||||
}
|
||||
else {
|
||||
@ -156,17 +157,17 @@ public void enterAlterByChangeColumn(MySqlParser.AlterByChangeColumnContext ctx)
|
||||
|
||||
@Override
|
||||
public void exitAlterByChangeColumn(MySqlParser.AlterByChangeColumnContext ctx) {
|
||||
parserCtx.runIfNotNull(() -> {
|
||||
parser.runIfNotNull(() -> {
|
||||
Column column = columnDefinitionListener.getColumn();
|
||||
tableEditor.addColumn(column);
|
||||
String newColumnName = parserCtx.parseName(ctx.newColumn);
|
||||
String newColumnName = parser.parseName(ctx.newColumn);
|
||||
tableEditor.renameColumn(column.name(), newColumnName);
|
||||
|
||||
if (ctx.FIRST() != null) {
|
||||
tableEditor.reorderColumn(newColumnName, null);
|
||||
}
|
||||
else if (ctx.afterColumn != null) {
|
||||
tableEditor.reorderColumn(newColumnName, parserCtx.parseName(ctx.afterColumn));
|
||||
tableEditor.reorderColumn(newColumnName, parser.parseName(ctx.afterColumn));
|
||||
}
|
||||
}, tableEditor, columnDefinitionListener);
|
||||
super.exitAlterByChangeColumn(ctx);
|
||||
@ -174,11 +175,11 @@ else if (ctx.afterColumn != null) {
|
||||
|
||||
@Override
|
||||
public void enterAlterByModifyColumn(MySqlParser.AlterByModifyColumnContext ctx) {
|
||||
parserCtx.runIfNotNull(() -> {
|
||||
String columnName = parserCtx.parseName(ctx.uid(0));
|
||||
parser.runIfNotNull(() -> {
|
||||
String columnName = parser.parseName(ctx.uid(0));
|
||||
Column column = tableEditor.columnWithName(columnName);
|
||||
if (column != null) {
|
||||
columnDefinitionListener = new ColumnDefinitionParserListener(tableEditor, column.edit(), parserCtx.dataTypeResolver(), parserCtx.getConverters());
|
||||
columnDefinitionListener = new ColumnDefinitionParserListener(tableEditor, column.edit(), parser.dataTypeResolver(), parser.getConverters());
|
||||
listeners.add(columnDefinitionListener);
|
||||
}
|
||||
else {
|
||||
@ -191,7 +192,7 @@ public void enterAlterByModifyColumn(MySqlParser.AlterByModifyColumnContext ctx)
|
||||
|
||||
@Override
|
||||
public void exitAlterByModifyColumn(MySqlParser.AlterByModifyColumnContext ctx) {
|
||||
parserCtx.runIfNotNull(() -> {
|
||||
parser.runIfNotNull(() -> {
|
||||
Column column = columnDefinitionListener.getColumn();
|
||||
tableEditor.addColumn(column);
|
||||
|
||||
@ -199,7 +200,7 @@ public void exitAlterByModifyColumn(MySqlParser.AlterByModifyColumnContext ctx)
|
||||
tableEditor.reorderColumn(column.name(), null);
|
||||
}
|
||||
else if (ctx.AFTER() != null) {
|
||||
String afterColumn = parserCtx.parseName(ctx.uid(1));
|
||||
String afterColumn = parser.parseName(ctx.uid(1));
|
||||
tableEditor.reorderColumn(column.name(), afterColumn);
|
||||
}
|
||||
}, tableEditor, columnDefinitionListener);
|
||||
@ -208,17 +209,17 @@ else if (ctx.AFTER() != null) {
|
||||
|
||||
@Override
|
||||
public void enterAlterByDropColumn(MySqlParser.AlterByDropColumnContext ctx) {
|
||||
parserCtx.runIfNotNull(() -> {
|
||||
tableEditor.removeColumn(parserCtx.parseName(ctx.uid()));
|
||||
parser.runIfNotNull(() -> {
|
||||
tableEditor.removeColumn(parser.parseName(ctx.uid()));
|
||||
}, tableEditor);
|
||||
super.enterAlterByDropColumn(ctx);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void enterAlterByRename(MySqlParser.AlterByRenameContext ctx) {
|
||||
parserCtx.runIfNotNull(() -> {
|
||||
TableId newTableId = parserCtx.resolveTableId(parserCtx.currentSchema(), parserCtx.parseName(ctx.uid()));
|
||||
parserCtx.databaseTables().renameTable(tableEditor.tableId(), newTableId);
|
||||
parser.runIfNotNull(() -> {
|
||||
TableId newTableId = parser.resolveTableId(parser.currentSchema(), parser.parseName(ctx.uid()));
|
||||
parser.databaseTables().renameTable(tableEditor.tableId(), newTableId);
|
||||
// databaseTables are updated clear table editor so exitAlterTable will not update a table by table editor
|
||||
tableEditor = null;
|
||||
}, tableEditor);
|
||||
@ -227,8 +228,8 @@ public void enterAlterByRename(MySqlParser.AlterByRenameContext ctx) {
|
||||
|
||||
@Override
|
||||
public void enterAlterByChangeDefault(MySqlParser.AlterByChangeDefaultContext ctx) {
|
||||
parserCtx.runIfNotNull(() -> {
|
||||
String columnName = parserCtx.parseName(ctx.uid());
|
||||
parser.runIfNotNull(() -> {
|
||||
String columnName = parser.parseName(ctx.uid());
|
||||
Column column = tableEditor.columnWithName(columnName);
|
||||
if (column != null) {
|
||||
ColumnEditor columnEditor = column.edit();
|
||||
@ -240,15 +241,15 @@ public void enterAlterByChangeDefault(MySqlParser.AlterByChangeDefaultContext ct
|
||||
|
||||
@Override
|
||||
public void enterAlterByAddPrimaryKey(MySqlParser.AlterByAddPrimaryKeyContext ctx) {
|
||||
parserCtx.runIfNotNull(() -> {
|
||||
parserCtx.parsePrimaryIndexColumnNames(ctx.indexColumnNames(), tableEditor);
|
||||
parser.runIfNotNull(() -> {
|
||||
parser.parsePrimaryIndexColumnNames(ctx.indexColumnNames(), tableEditor);
|
||||
}, tableEditor);
|
||||
super.enterAlterByAddPrimaryKey(ctx);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void enterAlterByDropPrimaryKey(MySqlParser.AlterByDropPrimaryKeyContext ctx) {
|
||||
parserCtx.runIfNotNull(() -> {
|
||||
parser.runIfNotNull(() -> {
|
||||
tableEditor.setPrimaryKeyNames(new ArrayList<>());
|
||||
}, tableEditor);
|
||||
super.enterAlterByDropPrimaryKey(ctx);
|
||||
@ -256,10 +257,10 @@ public void enterAlterByDropPrimaryKey(MySqlParser.AlterByDropPrimaryKeyContext
|
||||
|
||||
@Override
|
||||
public void enterAlterByAddUniqueKey(MySqlParser.AlterByAddUniqueKeyContext ctx) {
|
||||
parserCtx.runIfNotNull(() -> {
|
||||
parser.runIfNotNull(() -> {
|
||||
if (!tableEditor.hasPrimaryKey()) {
|
||||
// this may eventually get overwritten by a real PK
|
||||
parserCtx.parsePrimaryIndexColumnNames(ctx.indexColumnNames(), tableEditor);
|
||||
parser.parsePrimaryIndexColumnNames(ctx.indexColumnNames(), tableEditor);
|
||||
}
|
||||
}, tableEditor);
|
||||
super.enterAlterByAddUniqueKey(ctx);
|
||||
|
||||
@ -19,30 +19,30 @@
|
||||
import java.util.List;
|
||||
|
||||
/**
|
||||
* Parser listeners that is parsing MySQL ALTER VIEW statements.
|
||||
* Parser listener that is parsing MySQL ALTER VIEW statements.
|
||||
*
|
||||
* @author Roman Kuchár <kucharrom@gmail.com>.
|
||||
*/
|
||||
public class AlterViewParserListener extends MySqlParserBaseListener {
|
||||
|
||||
private final MySqlAntlrDdlParser parserCtx;
|
||||
private final MySqlAntlrDdlParser parser;
|
||||
private final List<ParseTreeListener> listeners;
|
||||
|
||||
private TableEditor tableEditor;
|
||||
private ViewSelectedColumnsParserListener selectColumnsListener;
|
||||
|
||||
|
||||
public AlterViewParserListener(MySqlAntlrDdlParser parserCtx, List<ParseTreeListener> listeners) {
|
||||
this.parserCtx = parserCtx;
|
||||
public AlterViewParserListener(MySqlAntlrDdlParser parser, List<ParseTreeListener> listeners) {
|
||||
this.parser = parser;
|
||||
this.listeners = listeners;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void enterAlterView(MySqlParser.AlterViewContext ctx) {
|
||||
if (!parserCtx.skipViews()) {
|
||||
TableId tableId = parserCtx.parseQualifiedTableId(ctx.fullId());
|
||||
if (!parser.skipViews()) {
|
||||
TableId tableId = parser.parseQualifiedTableId(ctx.fullId());
|
||||
|
||||
tableEditor = parserCtx.databaseTables().editTable(tableId);
|
||||
tableEditor = parser.databaseTables().editTable(tableId);
|
||||
if (tableEditor == null) {
|
||||
throw new ParsingException(null, "Trying to alter view " + tableId.toString()
|
||||
+ ", which does not exists. Query:" + AntlrDdlParser.getText(ctx));
|
||||
@ -51,11 +51,11 @@ public void enterAlterView(MySqlParser.AlterViewContext ctx) {
|
||||
tableEditor.columnNames().forEach(tableEditor::removeColumn);
|
||||
// create new columns just with specified name for now
|
||||
if (ctx.uidList() != null) {
|
||||
ctx.uidList().uid().stream().map(parserCtx::parseName).forEach(columnName -> {
|
||||
ctx.uidList().uid().stream().map(parser::parseName).forEach(columnName -> {
|
||||
tableEditor.addColumn(Column.editor().name(columnName).create());
|
||||
});
|
||||
}
|
||||
selectColumnsListener = new ViewSelectedColumnsParserListener(tableEditor, parserCtx);
|
||||
selectColumnsListener = new ViewSelectedColumnsParserListener(tableEditor, parser);
|
||||
listeners.add(selectColumnsListener);
|
||||
}
|
||||
super.enterAlterView(ctx);
|
||||
@ -63,17 +63,17 @@ public void enterAlterView(MySqlParser.AlterViewContext ctx) {
|
||||
|
||||
@Override
|
||||
public void exitAlterView(MySqlParser.AlterViewContext ctx) {
|
||||
parserCtx.runIfNotNull(() -> {
|
||||
parser.runIfNotNull(() -> {
|
||||
tableEditor.addColumns(selectColumnsListener.getSelectedColumns());
|
||||
// Make sure that the table's character set has been set ...
|
||||
if (!tableEditor.hasDefaultCharsetName()) {
|
||||
tableEditor.setDefaultCharsetName(parserCtx.currentDatabaseCharset());
|
||||
tableEditor.setDefaultCharsetName(parser.currentDatabaseCharset());
|
||||
}
|
||||
parserCtx.databaseTables().overwriteTable(tableEditor.create());
|
||||
parser.databaseTables().overwriteTable(tableEditor.create());
|
||||
listeners.remove(selectColumnsListener);
|
||||
}, tableEditor);
|
||||
// signal view even if it was skipped
|
||||
parserCtx.signalAlterView(parserCtx.parseQualifiedTableId(ctx.fullId()), null, ctx);
|
||||
parser.signalAlterView(parser.parseQualifiedTableId(ctx.fullId()), null, ctx);
|
||||
super.exitAlterView(ctx);
|
||||
}
|
||||
}
|
||||
|
||||
@ -28,7 +28,7 @@
|
||||
import io.debezium.relational.ddl.DataType;
|
||||
|
||||
/**
|
||||
* Parser listeners that is parsing column definition part of MySQL statements.
|
||||
* Parser listener that is parsing column definition part of MySQL statements.
|
||||
*
|
||||
* @author Roman Kuchár <kucharrom@gmail.com>.
|
||||
*/
|
||||
|
||||
@ -6,52 +6,52 @@
|
||||
|
||||
package io.debezium.connector.mysql.antlr.listener;
|
||||
|
||||
import io.debezium.connector.mysql.antlr.MySqlAntlrDdlParser;
|
||||
import io.debezium.connector.mysql.MySqlSystemVariables;
|
||||
import io.debezium.connector.mysql.antlr.MySqlAntlrDdlParser;
|
||||
import io.debezium.ddl.parser.mysql.generated.MySqlParser;
|
||||
import io.debezium.ddl.parser.mysql.generated.MySqlParserBaseListener;
|
||||
|
||||
/**
|
||||
* Parser listeners that is parsing MySQL CREATE DATABASE and ALTER DATABASE statements,
|
||||
* Parser listener that is parsing MySQL CREATE DATABASE and ALTER DATABASE statements,
|
||||
* to get default character sets for database.
|
||||
*
|
||||
* @author Roman Kuchár <kucharrom@gmail.com>.
|
||||
*/
|
||||
public class CreateAndAlterDatabaseParserListener extends MySqlParserBaseListener {
|
||||
|
||||
private final MySqlAntlrDdlParser parserCtx;
|
||||
private final MySqlAntlrDdlParser parser;
|
||||
private String databaseName;
|
||||
|
||||
public CreateAndAlterDatabaseParserListener(MySqlAntlrDdlParser parserCtx) {
|
||||
this.parserCtx = parserCtx;
|
||||
public CreateAndAlterDatabaseParserListener(MySqlAntlrDdlParser parser) {
|
||||
this.parser = parser;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void enterCreateDatabase(MySqlParser.CreateDatabaseContext ctx) {
|
||||
databaseName = parserCtx.parseName(ctx.uid());
|
||||
databaseName = parser.parseName(ctx.uid());
|
||||
super.enterCreateDatabase(ctx);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void exitCreateDatabase(MySqlParser.CreateDatabaseContext ctx) {
|
||||
parserCtx.signalCreateDatabase(databaseName, ctx);
|
||||
parser.signalCreateDatabase(databaseName, ctx);
|
||||
super.exitCreateDatabase(ctx);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void enterAlterSimpleDatabase(MySqlParser.AlterSimpleDatabaseContext ctx) {
|
||||
databaseName = ctx.uid() == null ? parserCtx.currentSchema() : parserCtx.parseName(ctx.uid());
|
||||
databaseName = ctx.uid() == null ? parser.currentSchema() : parser.parseName(ctx.uid());
|
||||
super.enterAlterSimpleDatabase(ctx);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void enterCreateDatabaseOption(MySqlParser.CreateDatabaseOptionContext ctx) {
|
||||
if (ctx.charsetName() != null) {
|
||||
String charsetName = parserCtx.withoutQuotes(ctx.charsetName());
|
||||
String charsetName = parser.withoutQuotes(ctx.charsetName());
|
||||
if ("DEFAULT".equalsIgnoreCase(charsetName)) {
|
||||
charsetName = parserCtx.systemVariables().getVariable(MySqlSystemVariables.CHARSET_NAME_SERVER);
|
||||
charsetName = parser.systemVariables().getVariable(MySqlSystemVariables.CHARSET_NAME_SERVER);
|
||||
}
|
||||
parserCtx.charsetNameForDatabase().put(databaseName, charsetName);
|
||||
parser.charsetNameForDatabase().put(databaseName, charsetName);
|
||||
}
|
||||
super.enterCreateDatabaseOption(ctx);
|
||||
}
|
||||
|
||||
@ -6,6 +6,10 @@
|
||||
|
||||
package io.debezium.connector.mysql.antlr.listener;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
import org.antlr.v4.runtime.tree.ParseTreeListener;
|
||||
|
||||
import io.debezium.connector.mysql.antlr.MySqlAntlrDdlParser;
|
||||
import io.debezium.ddl.parser.mysql.generated.MySqlParser;
|
||||
import io.debezium.ddl.parser.mysql.generated.MySqlParserBaseListener;
|
||||
@ -14,12 +18,9 @@
|
||||
import io.debezium.relational.Table;
|
||||
import io.debezium.relational.TableEditor;
|
||||
import io.debezium.relational.TableId;
|
||||
import org.antlr.v4.runtime.tree.ParseTreeListener;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
/**
|
||||
* Parser listeners that is parsing MySQL CREATE TABLE statements.
|
||||
* Parser listener that is parsing MySQL CREATE TABLE statements.
|
||||
*
|
||||
* @author Roman Kuchár <kucharrom@gmail.com>.
|
||||
*/
|
||||
@ -27,57 +28,57 @@ public class CreateTableParserListener extends MySqlParserBaseListener {
|
||||
|
||||
private final List<ParseTreeListener> listeners;
|
||||
|
||||
private final MySqlAntlrDdlParser parserCtx;
|
||||
private final MySqlAntlrDdlParser parser;
|
||||
private TableEditor tableEditor;
|
||||
private ColumnDefinitionParserListener columnDefinitionListener;
|
||||
|
||||
public CreateTableParserListener(MySqlAntlrDdlParser parserCtx, List<ParseTreeListener> listeners) {
|
||||
this.parserCtx = parserCtx;
|
||||
public CreateTableParserListener(MySqlAntlrDdlParser parser, List<ParseTreeListener> listeners) {
|
||||
this.parser = parser;
|
||||
this.listeners = listeners;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void enterColumnCreateTable(MySqlParser.ColumnCreateTableContext ctx) {
|
||||
TableId tableId = parserCtx.parseQualifiedTableId(ctx.tableName().fullId());
|
||||
tableEditor = parserCtx.databaseTables().editOrCreateTable(tableId);
|
||||
TableId tableId = parser.parseQualifiedTableId(ctx.tableName().fullId());
|
||||
tableEditor = parser.databaseTables().editOrCreateTable(tableId);
|
||||
super.enterColumnCreateTable(ctx);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void exitColumnCreateTable(MySqlParser.ColumnCreateTableContext ctx) {
|
||||
parserCtx.runIfNotNull(() -> {
|
||||
parser.runIfNotNull(() -> {
|
||||
// Make sure that the table's character set has been set ...
|
||||
if (!tableEditor.hasDefaultCharsetName()) {
|
||||
tableEditor.setDefaultCharsetName(parserCtx.currentDatabaseCharset());
|
||||
tableEditor.setDefaultCharsetName(parser.currentDatabaseCharset());
|
||||
}
|
||||
listeners.remove(columnDefinitionListener);
|
||||
columnDefinitionListener = null;
|
||||
// remove column definition parser listener
|
||||
parserCtx.databaseTables().overwriteTable(tableEditor.create());
|
||||
parserCtx.signalCreateTable(tableEditor.tableId(), ctx);
|
||||
parser.databaseTables().overwriteTable(tableEditor.create());
|
||||
parser.signalCreateTable(tableEditor.tableId(), ctx);
|
||||
}, tableEditor);
|
||||
super.exitColumnCreateTable(ctx);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void exitCopyCreateTable(MySqlParser.CopyCreateTableContext ctx) {
|
||||
TableId tableId = parserCtx.parseQualifiedTableId(ctx.tableName(0).fullId());
|
||||
TableId originalTableId = parserCtx.parseQualifiedTableId(ctx.tableName(1).fullId());
|
||||
Table original = parserCtx.databaseTables().forTable(originalTableId);
|
||||
TableId tableId = parser.parseQualifiedTableId(ctx.tableName(0).fullId());
|
||||
TableId originalTableId = parser.parseQualifiedTableId(ctx.tableName(1).fullId());
|
||||
Table original = parser.databaseTables().forTable(originalTableId);
|
||||
if (original != null) {
|
||||
parserCtx.databaseTables().overwriteTable(tableId, original.columns(), original.primaryKeyColumnNames(), original.defaultCharsetName());
|
||||
parserCtx.signalCreateTable(tableId, ctx);
|
||||
parser.databaseTables().overwriteTable(tableId, original.columns(), original.primaryKeyColumnNames(), original.defaultCharsetName());
|
||||
parser.signalCreateTable(tableId, ctx);
|
||||
}
|
||||
super.exitCopyCreateTable(ctx);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void enterColumnDeclaration(MySqlParser.ColumnDeclarationContext ctx) {
|
||||
parserCtx.runIfNotNull(() -> {
|
||||
String columnName = parserCtx.parseName(ctx.uid());
|
||||
parser.runIfNotNull(() -> {
|
||||
String columnName = parser.parseName(ctx.uid());
|
||||
ColumnEditor columnEditor = Column.editor().name(columnName);
|
||||
if (columnDefinitionListener == null) {
|
||||
columnDefinitionListener = new ColumnDefinitionParserListener(tableEditor, columnEditor, parserCtx.dataTypeResolver(), parserCtx.getConverters());
|
||||
columnDefinitionListener = new ColumnDefinitionParserListener(tableEditor, columnEditor, parser.dataTypeResolver(), parser.getConverters());
|
||||
listeners.add(columnDefinitionListener);
|
||||
} else {
|
||||
columnDefinitionListener.setColumnEditor(columnEditor);
|
||||
@ -88,7 +89,7 @@ public void enterColumnDeclaration(MySqlParser.ColumnDeclarationContext ctx) {
|
||||
|
||||
@Override
|
||||
public void exitColumnDeclaration(MySqlParser.ColumnDeclarationContext ctx) {
|
||||
parserCtx.runIfNotNull(() -> {
|
||||
parser.runIfNotNull(() -> {
|
||||
tableEditor.addColumn(columnDefinitionListener.getColumn());
|
||||
}, tableEditor, columnDefinitionListener);
|
||||
super.exitColumnDeclaration(ctx);
|
||||
@ -96,17 +97,17 @@ public void exitColumnDeclaration(MySqlParser.ColumnDeclarationContext ctx) {
|
||||
|
||||
@Override
|
||||
public void enterPrimaryKeyTableConstraint(MySqlParser.PrimaryKeyTableConstraintContext ctx) {
|
||||
parserCtx.runIfNotNull(() -> {
|
||||
parserCtx.parsePrimaryIndexColumnNames(ctx.indexColumnNames(), tableEditor);
|
||||
parser.runIfNotNull(() -> {
|
||||
parser.parsePrimaryIndexColumnNames(ctx.indexColumnNames(), tableEditor);
|
||||
}, tableEditor);
|
||||
super.enterPrimaryKeyTableConstraint(ctx);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void enterUniqueKeyTableConstraint(MySqlParser.UniqueKeyTableConstraintContext ctx) {
|
||||
parserCtx.runIfNotNull(() -> {
|
||||
parser.runIfNotNull(() -> {
|
||||
if (!tableEditor.hasPrimaryKey()) {
|
||||
parserCtx.parsePrimaryIndexColumnNames(ctx.indexColumnNames(), tableEditor);
|
||||
parser.parsePrimaryIndexColumnNames(ctx.indexColumnNames(), tableEditor);
|
||||
}
|
||||
}, tableEditor);
|
||||
super.enterUniqueKeyTableConstraint(ctx);
|
||||
@ -114,10 +115,10 @@ public void enterUniqueKeyTableConstraint(MySqlParser.UniqueKeyTableConstraintCo
|
||||
|
||||
@Override
|
||||
public void enterTableOptionCharset(MySqlParser.TableOptionCharsetContext ctx) {
|
||||
parserCtx.runIfNotNull(() -> {
|
||||
String charsetName = parserCtx.withoutQuotes(ctx.charsetName());
|
||||
parser.runIfNotNull(() -> {
|
||||
String charsetName = parser.withoutQuotes(ctx.charsetName());
|
||||
tableEditor.setDefaultCharsetName(charsetName);
|
||||
}, tableEditor);
|
||||
super.enterTableOptionCharset(ctx);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -6,6 +6,8 @@
|
||||
|
||||
package io.debezium.connector.mysql.antlr.listener;
|
||||
|
||||
import static io.debezium.antlr.AntlrDdlParser.getText;
|
||||
|
||||
import io.debezium.connector.mysql.antlr.MySqlAntlrDdlParser;
|
||||
import io.debezium.ddl.parser.mysql.generated.MySqlParser;
|
||||
import io.debezium.ddl.parser.mysql.generated.MySqlParserBaseListener;
|
||||
@ -13,32 +15,29 @@
|
||||
import io.debezium.relational.TableId;
|
||||
import io.debezium.text.ParsingException;
|
||||
|
||||
import static io.debezium.antlr.AntlrDdlParser.getText;
|
||||
|
||||
/**
|
||||
* Parser listeners that is parsing MySQL CREATE UNIQUE INDEX statements, that will be used as a primary key
|
||||
* Parser listener that is parsing MySQL CREATE UNIQUE INDEX statements, that will be used as a primary key
|
||||
* if it's not already defined for the table.
|
||||
*
|
||||
* @author Roman Kuchár <kucharrom@gmail.com>.
|
||||
*/
|
||||
public class CreateUniqueIndexParserListener extends MySqlParserBaseListener {
|
||||
|
||||
private final MySqlAntlrDdlParser parserCtx;
|
||||
private final MySqlAntlrDdlParser parser;
|
||||
|
||||
|
||||
public CreateUniqueIndexParserListener(MySqlAntlrDdlParser parserCtx) {
|
||||
this.parserCtx = parserCtx;
|
||||
public CreateUniqueIndexParserListener(MySqlAntlrDdlParser parser) {
|
||||
this.parser = parser;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void enterCreateIndex(MySqlParser.CreateIndexContext ctx) {
|
||||
if (ctx.UNIQUE() != null) {
|
||||
TableId tableId = parserCtx.parseQualifiedTableId(ctx.tableName().fullId());
|
||||
TableEditor tableEditor = parserCtx.databaseTables().editTable(tableId);
|
||||
TableId tableId = parser.parseQualifiedTableId(ctx.tableName().fullId());
|
||||
TableEditor tableEditor = parser.databaseTables().editTable(tableId);
|
||||
if (tableEditor != null) {
|
||||
if (!tableEditor.hasPrimaryKey()) {
|
||||
parserCtx.parsePrimaryIndexColumnNames(ctx.indexColumnNames(), tableEditor);
|
||||
parserCtx.signalCreateIndex(parserCtx.parseName(ctx.uid()), null, ctx);
|
||||
parser.parsePrimaryIndexColumnNames(ctx.indexColumnNames(), tableEditor);
|
||||
parser.signalCreateIndex(parser.parseName(ctx.uid()), null, ctx);
|
||||
}
|
||||
}
|
||||
else {
|
||||
|
||||
@ -6,44 +6,45 @@
|
||||
|
||||
package io.debezium.connector.mysql.antlr.listener;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
import org.antlr.v4.runtime.tree.ParseTreeListener;
|
||||
|
||||
import io.debezium.connector.mysql.antlr.MySqlAntlrDdlParser;
|
||||
import io.debezium.ddl.parser.mysql.generated.MySqlParser;
|
||||
import io.debezium.ddl.parser.mysql.generated.MySqlParserBaseListener;
|
||||
import io.debezium.relational.Column;
|
||||
import io.debezium.relational.TableEditor;
|
||||
import org.antlr.v4.runtime.tree.ParseTreeListener;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
/**
|
||||
* Parser listeners that is parsing MySQL CREATE VIEW statements.
|
||||
* Parser listener that is parsing MySQL CREATE VIEW statements.
|
||||
*
|
||||
* @author Roman Kuchár <kucharrom@gmail.com>.
|
||||
*/
|
||||
public class CreateViewParserListener extends MySqlParserBaseListener {
|
||||
|
||||
private final MySqlAntlrDdlParser parserCtx;
|
||||
private final MySqlAntlrDdlParser parser;
|
||||
private final List<ParseTreeListener> listeners;
|
||||
|
||||
private TableEditor tableEditor;
|
||||
private ViewSelectedColumnsParserListener selectColumnsListener;
|
||||
|
||||
public CreateViewParserListener(MySqlAntlrDdlParser parserCtx, List<ParseTreeListener> listeners) {
|
||||
this.parserCtx = parserCtx;
|
||||
public CreateViewParserListener(MySqlAntlrDdlParser parser, List<ParseTreeListener> listeners) {
|
||||
this.parser = parser;
|
||||
this.listeners = listeners;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void enterCreateView(MySqlParser.CreateViewContext ctx) {
|
||||
if (!parserCtx.skipViews()) {
|
||||
tableEditor = parserCtx.databaseTables().editOrCreateTable(parserCtx.parseQualifiedTableId(ctx.fullId()));
|
||||
if (!parser.skipViews()) {
|
||||
tableEditor = parser.databaseTables().editOrCreateTable(parser.parseQualifiedTableId(ctx.fullId()));
|
||||
// create new columns just with specified name for now
|
||||
if (ctx.uidList() != null) {
|
||||
ctx.uidList().uid().stream().map(parserCtx::parseName).forEach(columnName -> {
|
||||
ctx.uidList().uid().stream().map(parser::parseName).forEach(columnName -> {
|
||||
tableEditor.addColumn(Column.editor().name(columnName).create());
|
||||
});
|
||||
}
|
||||
selectColumnsListener = new ViewSelectedColumnsParserListener(tableEditor, parserCtx);
|
||||
selectColumnsListener = new ViewSelectedColumnsParserListener(tableEditor, parser);
|
||||
listeners.add(selectColumnsListener);
|
||||
}
|
||||
super.enterCreateView(ctx);
|
||||
@ -51,19 +52,17 @@ public void enterCreateView(MySqlParser.CreateViewContext ctx) {
|
||||
|
||||
@Override
|
||||
public void exitCreateView(MySqlParser.CreateViewContext ctx) {
|
||||
parserCtx.runIfNotNull(() -> {
|
||||
parser.runIfNotNull(() -> {
|
||||
tableEditor.addColumns(selectColumnsListener.getSelectedColumns());
|
||||
// Make sure that the table's character set has been set ...
|
||||
if (!tableEditor.hasDefaultCharsetName()) {
|
||||
tableEditor.setDefaultCharsetName(parserCtx.currentDatabaseCharset());
|
||||
tableEditor.setDefaultCharsetName(parser.currentDatabaseCharset());
|
||||
}
|
||||
parserCtx.databaseTables().overwriteTable(tableEditor.create());
|
||||
parser.databaseTables().overwriteTable(tableEditor.create());
|
||||
listeners.remove(selectColumnsListener);
|
||||
}, tableEditor);
|
||||
// signal view even if it was skipped
|
||||
parserCtx.signalCreateView(parserCtx.parseQualifiedTableId(ctx.fullId()), ctx);
|
||||
parser.signalCreateView(parser.parseQualifiedTableId(ctx.fullId()), ctx);
|
||||
super.exitCreateView(ctx);
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
@ -11,24 +11,24 @@
|
||||
import io.debezium.ddl.parser.mysql.generated.MySqlParserBaseListener;
|
||||
|
||||
/**
|
||||
* Parser listeners that is parsing MySQL DROP DATABASE statements.
|
||||
* Parser listener that is parsing MySQL DROP DATABASE statements.
|
||||
*
|
||||
* @author Roman Kuchár <kucharrom@gmail.com>.
|
||||
*/
|
||||
public class DropDatabaseParserListener extends MySqlParserBaseListener {
|
||||
|
||||
private final MySqlAntlrDdlParser parserCtx;
|
||||
private final MySqlAntlrDdlParser parser;
|
||||
|
||||
public DropDatabaseParserListener(MySqlAntlrDdlParser parserCtx) {
|
||||
this.parserCtx = parserCtx;
|
||||
public DropDatabaseParserListener(MySqlAntlrDdlParser parser) {
|
||||
this.parser = parser;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void enterDropDatabase(MySqlParser.DropDatabaseContext ctx) {
|
||||
String databaseName = parserCtx.parseName(ctx.uid());
|
||||
parserCtx.databaseTables().removeTablesForDatabase(databaseName);
|
||||
parserCtx.charsetNameForDatabase().remove(databaseName);
|
||||
parserCtx.signalDropDatabase(databaseName, ctx);
|
||||
String databaseName = parser.parseName(ctx.uid());
|
||||
parser.databaseTables().removeTablesForDatabase(databaseName);
|
||||
parser.charsetNameForDatabase().remove(databaseName);
|
||||
parser.signalDropDatabase(databaseName, ctx);
|
||||
super.enterDropDatabase(ctx);
|
||||
}
|
||||
}
|
||||
|
||||
@ -13,16 +13,16 @@
|
||||
import org.antlr.v4.runtime.misc.Interval;
|
||||
|
||||
/**
|
||||
* Parser listeners that is parsing MySQL DROP TABLE statements.
|
||||
* Parser listener that is parsing MySQL DROP TABLE statements.
|
||||
*
|
||||
* @author Roman Kuchár <kucharrom@gmail.com>.
|
||||
*/
|
||||
public class DropTableParserListener extends MySqlParserBaseListener {
|
||||
|
||||
private final MySqlAntlrDdlParser parserCtx;
|
||||
private final MySqlAntlrDdlParser parser;
|
||||
|
||||
public DropTableParserListener(MySqlAntlrDdlParser parserCtx) {
|
||||
this.parserCtx = parserCtx;
|
||||
public DropTableParserListener(MySqlAntlrDdlParser parser) {
|
||||
this.parser = parser;
|
||||
}
|
||||
|
||||
@Override
|
||||
@ -30,9 +30,9 @@ public void enterDropTable(MySqlParser.DropTableContext ctx) {
|
||||
Interval interval = new Interval(ctx.start.getStartIndex(), ctx.tables().start.getStartIndex() - 1);
|
||||
String prefix = ctx.start.getInputStream().getText(interval);
|
||||
ctx.tables().tableName().forEach(tableNameContext -> {
|
||||
TableId tableId = parserCtx.parseQualifiedTableId(tableNameContext.fullId());
|
||||
parserCtx.databaseTables().removeTable(tableId);
|
||||
parserCtx.signalDropTable(tableId, prefix + tableId.table()
|
||||
TableId tableId = parser.parseQualifiedTableId(tableNameContext.fullId());
|
||||
parser.databaseTables().removeTable(tableId);
|
||||
parser.signalDropTable(tableId, prefix + tableId.table()
|
||||
+ (ctx.dropType != null ? " " + ctx.dropType.getText() : ""));
|
||||
});
|
||||
super.enterDropTable(ctx);
|
||||
|
||||
@ -11,23 +11,23 @@
|
||||
import io.debezium.ddl.parser.mysql.generated.MySqlParserBaseListener;
|
||||
|
||||
/**
|
||||
* Parser listeners that is parsing MySQL DROP VIEW statements.
|
||||
* Parser listener that is parsing MySQL DROP VIEW statements.
|
||||
*
|
||||
* @author Roman Kuchár <kucharrom@gmail.com>.
|
||||
*/
|
||||
public class DropViewParserListener extends MySqlParserBaseListener {
|
||||
|
||||
private final MySqlAntlrDdlParser parserCtx;
|
||||
private final MySqlAntlrDdlParser parser;
|
||||
|
||||
public DropViewParserListener(MySqlAntlrDdlParser parserCtx) {
|
||||
this.parserCtx = parserCtx;
|
||||
public DropViewParserListener(MySqlAntlrDdlParser parser) {
|
||||
this.parser = parser;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void enterDropView(MySqlParser.DropViewContext ctx) {
|
||||
ctx.fullId().stream().map(parserCtx::parseQualifiedTableId).forEach(tableId -> {
|
||||
parserCtx.databaseTables().removeTable(tableId);
|
||||
parserCtx.signalDropView(tableId, ctx);
|
||||
ctx.fullId().stream().map(parser::parseQualifiedTableId).forEach(tableId -> {
|
||||
parser.databaseTables().removeTable(tableId);
|
||||
parser.signalDropView(tableId, ctx);
|
||||
});
|
||||
super.enterDropView(ctx);
|
||||
}
|
||||
|
||||
@ -6,25 +6,27 @@
|
||||
|
||||
package io.debezium.connector.mysql.antlr.listener;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.Collection;
|
||||
import java.util.List;
|
||||
import java.util.concurrent.CopyOnWriteArrayList;
|
||||
|
||||
import org.antlr.v4.runtime.ParserRuleContext;
|
||||
import org.antlr.v4.runtime.tree.ErrorNode;
|
||||
import org.antlr.v4.runtime.tree.ParseTreeListener;
|
||||
import org.antlr.v4.runtime.tree.TerminalNode;
|
||||
|
||||
import io.debezium.antlr.AntlrDdlParserListener;
|
||||
import io.debezium.antlr.ProxyParseTreeListenerUtil;
|
||||
import io.debezium.connector.mysql.antlr.MySqlAntlrDdlParser;
|
||||
import io.debezium.ddl.parser.mysql.generated.MySqlParser;
|
||||
import io.debezium.ddl.parser.mysql.generated.MySqlParserBaseListener;
|
||||
import io.debezium.text.ParsingException;
|
||||
import org.antlr.v4.runtime.ParserRuleContext;
|
||||
import org.antlr.v4.runtime.tree.ErrorNode;
|
||||
import org.antlr.v4.runtime.tree.ParseTreeListener;
|
||||
import org.antlr.v4.runtime.tree.TerminalNode;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.Collection;
|
||||
import java.util.List;
|
||||
import java.util.concurrent.CopyOnWriteArrayList;
|
||||
|
||||
/**
|
||||
* Parser listener for MySQL column definition queries. It's purpose is to delegate events
|
||||
* Parser listener for MySQL column definition queries. Its purpose is to delegate events
|
||||
* to defined collection of concrete parser listeners. Each listener handles the specified type of DDL statement.
|
||||
* <p>
|
||||
* This listener is catching all occurred parsing exceptions and implements a skipping logic for BEGIN ... END
|
||||
* statements. No event will be delegated during skipping phase.
|
||||
*/
|
||||
@ -33,7 +35,7 @@ public class MySqlAntlrDdlParserListener extends MySqlParserBaseListener impleme
|
||||
/**
|
||||
* Collection of listeners for delegation of events.
|
||||
*/
|
||||
private List<ParseTreeListener> listeners = new CopyOnWriteArrayList<>();
|
||||
private final List<ParseTreeListener> listeners = new CopyOnWriteArrayList<>();
|
||||
|
||||
/**
|
||||
* Flag for skipping phase.
|
||||
@ -49,23 +51,23 @@ public class MySqlAntlrDdlParserListener extends MySqlParserBaseListener impleme
|
||||
/**
|
||||
* Collection of catched exceptions.
|
||||
*/
|
||||
private Collection<ParsingException> errors = new ArrayList<>();
|
||||
private final Collection<ParsingException> errors = new ArrayList<>();
|
||||
|
||||
public MySqlAntlrDdlParserListener(MySqlAntlrDdlParser parserCtx) {
|
||||
public MySqlAntlrDdlParserListener(MySqlAntlrDdlParser parser) {
|
||||
// initialize listeners
|
||||
listeners.add(new CreateAndAlterDatabaseParserListener(parserCtx));
|
||||
listeners.add(new DropDatabaseParserListener(parserCtx));
|
||||
listeners.add(new CreateTableParserListener(parserCtx, listeners));
|
||||
listeners.add(new AlterTableParserListener(parserCtx, listeners));
|
||||
listeners.add(new DropTableParserListener(parserCtx));
|
||||
listeners.add(new RenameTableParserListener(parserCtx));
|
||||
listeners.add(new TruncateTableParserListener(parserCtx));
|
||||
listeners.add(new CreateViewParserListener(parserCtx, listeners));
|
||||
listeners.add(new AlterViewParserListener(parserCtx, listeners));
|
||||
listeners.add(new DropViewParserListener(parserCtx));
|
||||
listeners.add(new CreateUniqueIndexParserListener(parserCtx));
|
||||
listeners.add(new SetStatementParserListener(parserCtx));
|
||||
listeners.add(new UseStatementParserListener(parserCtx));
|
||||
listeners.add(new CreateAndAlterDatabaseParserListener(parser));
|
||||
listeners.add(new DropDatabaseParserListener(parser));
|
||||
listeners.add(new CreateTableParserListener(parser, listeners));
|
||||
listeners.add(new AlterTableParserListener(parser, listeners));
|
||||
listeners.add(new DropTableParserListener(parser));
|
||||
listeners.add(new RenameTableParserListener(parser));
|
||||
listeners.add(new TruncateTableParserListener(parser));
|
||||
listeners.add(new CreateViewParserListener(parser, listeners));
|
||||
listeners.add(new AlterViewParserListener(parser, listeners));
|
||||
listeners.add(new DropViewParserListener(parser));
|
||||
listeners.add(new CreateUniqueIndexParserListener(parser));
|
||||
listeners.add(new SetStatementParserListener(parser));
|
||||
listeners.add(new UseStatementParserListener(parser));
|
||||
}
|
||||
|
||||
/**
|
||||
@ -73,6 +75,7 @@ public MySqlAntlrDdlParserListener(MySqlAntlrDdlParser parserCtx) {
|
||||
*
|
||||
* @return list of Parsing exceptions
|
||||
*/
|
||||
@Override
|
||||
public Collection<ParsingException> getErrors() {
|
||||
return errors;
|
||||
}
|
||||
@ -119,5 +122,4 @@ public void enterRoutineBody(MySqlParser.RoutineBodyContext ctx) {
|
||||
// this is a grammar rule for BEGIN ... END part of statements. Skip it.
|
||||
skipNodes = true;
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
@ -12,24 +12,24 @@
|
||||
import io.debezium.relational.TableId;
|
||||
|
||||
/**
|
||||
* Parser listeners that is parsing MySQL RENAME TABLE statements.
|
||||
* Parser listener that is parsing MySQL RENAME TABLE statements.
|
||||
*
|
||||
* @author Roman Kuchár <kucharrom@gmail.com>.
|
||||
*/
|
||||
public class RenameTableParserListener extends MySqlParserBaseListener {
|
||||
|
||||
private final MySqlAntlrDdlParser parserCtx;
|
||||
private final MySqlAntlrDdlParser parser;
|
||||
|
||||
public RenameTableParserListener(MySqlAntlrDdlParser parserCtx) {
|
||||
this.parserCtx = parserCtx;
|
||||
public RenameTableParserListener(MySqlAntlrDdlParser parser) {
|
||||
this.parser = parser;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void enterRenameTableClause(MySqlParser.RenameTableClauseContext ctx) {
|
||||
TableId oldTable = parserCtx.parseQualifiedTableId(ctx.tableName(0).fullId());
|
||||
TableId newTable = parserCtx.parseQualifiedTableId(ctx.tableName(1).fullId());
|
||||
parserCtx.databaseTables().renameTable(oldTable, newTable);
|
||||
parserCtx.signalAlterTable(newTable, oldTable, ctx);
|
||||
TableId oldTable = parser.parseQualifiedTableId(ctx.tableName(0).fullId());
|
||||
TableId newTable = parser.parseQualifiedTableId(ctx.tableName(1).fullId());
|
||||
parser.databaseTables().renameTable(oldTable, newTable);
|
||||
parser.signalAlterTable(newTable, oldTable, ctx);
|
||||
super.enterRenameTableClause(ctx);
|
||||
}
|
||||
}
|
||||
|
||||
@ -6,22 +6,22 @@
|
||||
|
||||
package io.debezium.connector.mysql.antlr.listener;
|
||||
|
||||
import io.debezium.connector.mysql.antlr.MySqlAntlrDdlParser;
|
||||
import io.debezium.connector.mysql.MySqlSystemVariables;
|
||||
import io.debezium.connector.mysql.antlr.MySqlAntlrDdlParser;
|
||||
import io.debezium.ddl.parser.mysql.generated.MySqlParser;
|
||||
import io.debezium.ddl.parser.mysql.generated.MySqlParserBaseListener;
|
||||
|
||||
/**
|
||||
* Parser listeners that is parsing MySQL SET statements, for defining a system variables.
|
||||
* Parser listener that is parsing MySQL SET statements, for defining a system variables.
|
||||
*
|
||||
* @author Roman Kuchár <kucharrom@gmail.com>.
|
||||
*/
|
||||
public class SetStatementParserListener extends MySqlParserBaseListener {
|
||||
|
||||
private final MySqlAntlrDdlParser parserCtx;
|
||||
private final MySqlAntlrDdlParser parser;
|
||||
|
||||
public SetStatementParserListener(MySqlAntlrDdlParser parserCtx) {
|
||||
this.parserCtx = parserCtx;
|
||||
public SetStatementParserListener(MySqlAntlrDdlParser parser) {
|
||||
this.parser = parser;
|
||||
}
|
||||
|
||||
@Override
|
||||
@ -66,51 +66,51 @@ else if (variableClauseContext.LOCAL() != null) {
|
||||
scope = MySqlSystemVariables.MySqlScope.LOCAL;
|
||||
}
|
||||
|
||||
variableName = parserCtx.parseName(variableClauseContext.uid());
|
||||
variableName = parser.parseName(variableClauseContext.uid());
|
||||
}
|
||||
String value = parserCtx.withoutQuotes(ctx.expression(i));
|
||||
String value = parser.withoutQuotes(ctx.expression(i));
|
||||
|
||||
parserCtx.systemVariables().setVariable(scope, variableName, value);
|
||||
parser.systemVariables().setVariable(scope, variableName, value);
|
||||
|
||||
// If this is setting 'character_set_database', then we need to record the character set for
|
||||
// the given database ...
|
||||
if (MySqlSystemVariables.CHARSET_NAME_DATABASE.equalsIgnoreCase(variableName)) {
|
||||
String currentDatabaseName = parserCtx.currentSchema();
|
||||
String currentDatabaseName = parser.currentSchema();
|
||||
if (currentDatabaseName != null) {
|
||||
parserCtx.charsetNameForDatabase().put(currentDatabaseName, value);
|
||||
parser.charsetNameForDatabase().put(currentDatabaseName, value);
|
||||
}
|
||||
}
|
||||
|
||||
// Signal that the variable was set ...
|
||||
parserCtx.signalSetVariable(variableName, value, ctx);
|
||||
parser.signalSetVariable(variableName, value, ctx);
|
||||
}
|
||||
super.enterSetVariable(ctx);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void enterSetCharset(MySqlParser.SetCharsetContext ctx) {
|
||||
String charsetName = ctx.charsetName() != null ? parserCtx.withoutQuotes(ctx.charsetName()) : parserCtx.currentDatabaseCharset();
|
||||
String charsetName = ctx.charsetName() != null ? parser.withoutQuotes(ctx.charsetName()) : parser.currentDatabaseCharset();
|
||||
// Sets variables according to documentation at
|
||||
// https://dev.mysql.com/doc/refman/5.7/en/set-character-set.html
|
||||
// Using default scope for these variables, because this type of set statement you cannot specify
|
||||
// the scope manually
|
||||
parserCtx.systemVariables().setVariable(MySqlSystemVariables.MySqlScope.SESSION, MySqlSystemVariables.CHARSET_NAME_CLIENT, charsetName);
|
||||
parserCtx.systemVariables().setVariable(MySqlSystemVariables.MySqlScope.SESSION, MySqlSystemVariables.CHARSET_NAME_RESULT, charsetName);
|
||||
parserCtx.systemVariables().setVariable(MySqlSystemVariables.MySqlScope.SESSION, MySqlSystemVariables.CHARSET_NAME_CONNECTION,
|
||||
parserCtx.systemVariables().getVariable(MySqlSystemVariables.CHARSET_NAME_DATABASE));
|
||||
parser.systemVariables().setVariable(MySqlSystemVariables.MySqlScope.SESSION, MySqlSystemVariables.CHARSET_NAME_CLIENT, charsetName);
|
||||
parser.systemVariables().setVariable(MySqlSystemVariables.MySqlScope.SESSION, MySqlSystemVariables.CHARSET_NAME_RESULT, charsetName);
|
||||
parser.systemVariables().setVariable(MySqlSystemVariables.MySqlScope.SESSION, MySqlSystemVariables.CHARSET_NAME_CONNECTION,
|
||||
parser.systemVariables().getVariable(MySqlSystemVariables.CHARSET_NAME_DATABASE));
|
||||
super.enterSetCharset(ctx);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void enterSetNames(MySqlParser.SetNamesContext ctx) {
|
||||
String charsetName = ctx.charsetName() != null ? parserCtx.withoutQuotes(ctx.charsetName()) : parserCtx.currentDatabaseCharset();
|
||||
String charsetName = ctx.charsetName() != null ? parser.withoutQuotes(ctx.charsetName()) : parser.currentDatabaseCharset();
|
||||
// Sets variables according to documentation at
|
||||
// https://dev.mysql.com/doc/refman/5.7/en/set-names.html
|
||||
// Using default scope for these variables, because this type of set statement you cannot specify
|
||||
// the scope manually
|
||||
parserCtx.systemVariables().setVariable(MySqlSystemVariables.MySqlScope.SESSION, MySqlSystemVariables.CHARSET_NAME_CLIENT, charsetName);
|
||||
parserCtx.systemVariables().setVariable(MySqlSystemVariables.MySqlScope.SESSION, MySqlSystemVariables.CHARSET_NAME_RESULT, charsetName);
|
||||
parserCtx.systemVariables().setVariable(MySqlSystemVariables.MySqlScope.SESSION, MySqlSystemVariables.CHARSET_NAME_CONNECTION, charsetName);
|
||||
parser.systemVariables().setVariable(MySqlSystemVariables.MySqlScope.SESSION, MySqlSystemVariables.CHARSET_NAME_CLIENT, charsetName);
|
||||
parser.systemVariables().setVariable(MySqlSystemVariables.MySqlScope.SESSION, MySqlSystemVariables.CHARSET_NAME_RESULT, charsetName);
|
||||
parser.systemVariables().setVariable(MySqlSystemVariables.MySqlScope.SESSION, MySqlSystemVariables.CHARSET_NAME_CONNECTION, charsetName);
|
||||
super.enterSetNames(ctx);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -12,23 +12,23 @@
|
||||
import io.debezium.relational.TableId;
|
||||
|
||||
/**
|
||||
* Parser listeners that is parsing MySQL TRUNCATE TABLE statements.
|
||||
* Parser listener that is parsing MySQL TRUNCATE TABLE statements.
|
||||
*
|
||||
* @author Roman Kuchár <kucharrom@gmail.com>.
|
||||
*/
|
||||
public class TruncateTableParserListener extends MySqlParserBaseListener {
|
||||
|
||||
private final MySqlAntlrDdlParser parserCtx;
|
||||
private final MySqlAntlrDdlParser parser;
|
||||
|
||||
public TruncateTableParserListener(MySqlAntlrDdlParser parserCtx) {
|
||||
this.parserCtx = parserCtx;
|
||||
public TruncateTableParserListener(MySqlAntlrDdlParser parser) {
|
||||
this.parser = parser;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void enterTruncateTable(MySqlParser.TruncateTableContext ctx) {
|
||||
TableId tableId = parserCtx.parseQualifiedTableId(ctx.tableName().fullId());
|
||||
TableId tableId = parser.parseQualifiedTableId(ctx.tableName().fullId());
|
||||
// Be aware the legacy parser is not signaling truncate events
|
||||
parserCtx.signalTruncateTable(tableId, ctx);
|
||||
parser.signalTruncateTable(tableId, ctx);
|
||||
super.enterTruncateTable(ctx);
|
||||
}
|
||||
}
|
||||
|
||||
@ -12,29 +12,29 @@
|
||||
import io.debezium.ddl.parser.mysql.generated.MySqlParserBaseListener;
|
||||
|
||||
/**
|
||||
* Parser listeners that is parsing MySQL USE statements that changes
|
||||
* Parser listener that is parsing MySQL USE statements that changes
|
||||
* current database/schema on which all changes are applied.
|
||||
*
|
||||
* @author Roman Kuchár <kucharrom@gmail.com>.
|
||||
*/
|
||||
public class UseStatementParserListener extends MySqlParserBaseListener {
|
||||
|
||||
private final MySqlAntlrDdlParser parserCtx;
|
||||
private final MySqlAntlrDdlParser parser;
|
||||
|
||||
public UseStatementParserListener(MySqlAntlrDdlParser parserCtx) {
|
||||
this.parserCtx = parserCtx;
|
||||
public UseStatementParserListener(MySqlAntlrDdlParser parser) {
|
||||
this.parser = parser;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void enterUseStatement(MySqlParser.UseStatementContext ctx) {
|
||||
String dbName = parserCtx.parseName(ctx.uid());
|
||||
parserCtx.setCurrentSchema(dbName);
|
||||
String dbName = parser.parseName(ctx.uid());
|
||||
parser.setCurrentSchema(dbName);
|
||||
|
||||
// Every time MySQL switches to a different database, it sets the "character_set_database" and "collation_database"
|
||||
// system variables. We replicate that behavior here (or the variable we care about) so that these variables are always
|
||||
// right for the current database.
|
||||
String charsetForDb = parserCtx.charsetNameForDatabase().get(dbName);
|
||||
parserCtx.systemVariables().setVariable(MySqlSystemVariables.MySqlScope.SESSION, MySqlSystemVariables.CHARSET_NAME_DATABASE, charsetForDb);
|
||||
String charsetForDb = parser.charsetNameForDatabase().get(dbName);
|
||||
parser.systemVariables().setVariable(MySqlSystemVariables.MySqlScope.SESSION, MySqlSystemVariables.CHARSET_NAME_DATABASE, charsetForDb);
|
||||
super.enterUseStatement(ctx);
|
||||
}
|
||||
}
|
||||
|
||||
@ -21,21 +21,21 @@
|
||||
import static io.debezium.relational.ddl.AbstractDdlParser.withoutQuotes;
|
||||
|
||||
/**
|
||||
* Parser listeners that is parsing MySQL SELECT statements used for definition of VIEW.
|
||||
* Parser listener that is parsing MySQL SELECT statements used for definition of VIEW.
|
||||
*
|
||||
* @author Roman Kuchár <kucharrom@gmail.com>.
|
||||
*/
|
||||
public class ViewSelectedColumnsParserListener extends MySqlParserBaseListener {
|
||||
|
||||
private final MySqlAntlrDdlParser parserCtx;
|
||||
private final MySqlAntlrDdlParser parser;
|
||||
private final TableEditor tableEditor;
|
||||
|
||||
private TableEditor selectTableEditor;
|
||||
private Map<TableId, Table> tableByAlias = new HashMap<>();
|
||||
|
||||
public ViewSelectedColumnsParserListener(TableEditor tableEditor, MySqlAntlrDdlParser parserCtx) {
|
||||
public ViewSelectedColumnsParserListener(TableEditor tableEditor, MySqlAntlrDdlParser parser) {
|
||||
this.tableEditor = tableEditor;
|
||||
this.parserCtx = parserCtx;
|
||||
this.parser = parser;
|
||||
}
|
||||
|
||||
public List<Column> getSelectedColumns() {
|
||||
@ -60,7 +60,7 @@ public void exitQuerySpecificationNointo(MySqlParser.QuerySpecificationNointoCon
|
||||
|
||||
@Override
|
||||
public void exitAtomTableItem(MySqlParser.AtomTableItemContext ctx) {
|
||||
parserCtx.runIfNotNull(() -> {
|
||||
parser.runIfNotNull(() -> {
|
||||
parseAtomTableItem(ctx, tableByAlias);
|
||||
}, tableEditor);
|
||||
super.exitAtomTableItem(ctx);
|
||||
@ -68,10 +68,10 @@ public void exitAtomTableItem(MySqlParser.AtomTableItemContext ctx) {
|
||||
|
||||
@Override
|
||||
public void exitSubqueryTableItem(MySqlParser.SubqueryTableItemContext ctx) {
|
||||
parserCtx.runIfNotNull(() -> {
|
||||
parser.runIfNotNull(() -> {
|
||||
// parsing subselect
|
||||
String tableAlias = parserCtx.parseName(ctx.uid());
|
||||
TableId aliasTableId = parserCtx.resolveTableId(parserCtx.currentSchema(), tableAlias);
|
||||
String tableAlias = parser.parseName(ctx.uid());
|
||||
TableId aliasTableId = parser.resolveTableId(parser.currentSchema(), tableAlias);
|
||||
selectTableEditor.tableId(aliasTableId);
|
||||
tableByAlias.put(aliasTableId, selectTableEditor.create());
|
||||
}, tableEditor);
|
||||
@ -79,7 +79,7 @@ public void exitSubqueryTableItem(MySqlParser.SubqueryTableItemContext ctx) {
|
||||
}
|
||||
|
||||
private void parseQuerySpecification(MySqlParser.SelectElementsContext selectElementsContext) {
|
||||
parserCtx.runIfNotNull(() -> {
|
||||
parser.runIfNotNull(() -> {
|
||||
selectTableEditor = parseSelectElements(selectElementsContext);
|
||||
}, tableEditor);
|
||||
}
|
||||
@ -88,14 +88,14 @@ private void parseAtomTableItem(MySqlParser.TableSourceItemContext ctx, Map<Tabl
|
||||
if (ctx instanceof MySqlParser.AtomTableItemContext) {
|
||||
MySqlParser.AtomTableItemContext atomTableItemContext = (MySqlParser.AtomTableItemContext) ctx;
|
||||
|
||||
TableId tableId = parserCtx.parseQualifiedTableId(atomTableItemContext.tableName().fullId());
|
||||
TableId tableId = parser.parseQualifiedTableId(atomTableItemContext.tableName().fullId());
|
||||
|
||||
Table table = tableByAlias.get(tableId);
|
||||
if (table == null) {
|
||||
table = parserCtx.databaseTables().forTable(tableId);
|
||||
table = parser.databaseTables().forTable(tableId);
|
||||
}
|
||||
if (atomTableItemContext.alias != null) {
|
||||
TableId aliasTableId = parserCtx.resolveTableId(tableId.schema(), parserCtx.parseName(atomTableItemContext.alias));
|
||||
TableId aliasTableId = parser.resolveTableId(tableId.schema(), parser.parseName(atomTableItemContext.alias));
|
||||
tableByAlias.put(aliasTableId, table);
|
||||
}
|
||||
else {
|
||||
@ -114,7 +114,7 @@ private TableEditor parseSelectElements(MySqlParser.SelectElementsContext ctx) {
|
||||
else {
|
||||
ctx.selectElement().forEach(selectElementContext -> {
|
||||
if (selectElementContext instanceof MySqlParser.SelectStarElementContext) {
|
||||
TableId tableId = parserCtx.parseQualifiedTableId(((MySqlParser.SelectStarElementContext) selectElementContext).fullId());
|
||||
TableId tableId = parser.parseQualifiedTableId(((MySqlParser.SelectStarElementContext) selectElementContext).fullId());
|
||||
Table selectedTable = tableByAlias.get(tableId);
|
||||
table.addColumns(selectedTable.columns());
|
||||
}
|
||||
@ -122,11 +122,11 @@ else if (selectElementContext instanceof MySqlParser.SelectColumnElementContext)
|
||||
MySqlParser.SelectColumnElementContext selectColumnElementContext = (MySqlParser.SelectColumnElementContext) selectElementContext;
|
||||
MySqlParser.FullColumnNameContext fullColumnNameContext = selectColumnElementContext.fullColumnName();
|
||||
|
||||
String schemaName = parserCtx.currentSchema();
|
||||
String schemaName = parser.currentSchema();
|
||||
String tableName = null;
|
||||
String columnName;
|
||||
|
||||
columnName = parserCtx.parseName(fullColumnNameContext.uid());
|
||||
columnName = parser.parseName(fullColumnNameContext.uid());
|
||||
if (fullColumnNameContext.dottedId(0) != null) {
|
||||
// shift by 1
|
||||
tableName = columnName;
|
||||
@ -144,10 +144,10 @@ else if (selectElementContext instanceof MySqlParser.SelectColumnElementContext)
|
||||
}
|
||||
String alias = columnName;
|
||||
if (selectColumnElementContext.uid() != null) {
|
||||
alias = parserCtx.parseName(selectColumnElementContext.uid());
|
||||
alias = parser.parseName(selectColumnElementContext.uid());
|
||||
}
|
||||
if (tableName != null) {
|
||||
Table selectedTable = tableByAlias.get(parserCtx.resolveTableId(schemaName, tableName));
|
||||
Table selectedTable = tableByAlias.get(parser.resolveTableId(schemaName, tableName));
|
||||
addColumnFromTable(table, columnName, alias, selectedTable);
|
||||
}
|
||||
else {
|
||||
|
||||
@ -13,7 +13,7 @@
|
||||
import java.util.stream.Collectors;
|
||||
|
||||
/**
|
||||
* Encapsulates a set of the MySQL system variables.
|
||||
* Encapsulates a set of a database's system variables.
|
||||
*
|
||||
* @author Randall Hauch
|
||||
*/
|
||||
|
||||
@ -28,8 +28,8 @@
|
||||
|
||||
/**
|
||||
* Base implementation of ANTLR based parsers.
|
||||
*
|
||||
* This abstract class provides generic initialization of parser and it's main sequence of steps
|
||||
* <p>
|
||||
* This abstract class provides generic initialization of parser and its main sequence of steps
|
||||
* that are needed to properly start parsing.
|
||||
* It also provides implementation of helper methods for any type of ANTLR listeners.
|
||||
*
|
||||
@ -38,11 +38,11 @@
|
||||
public abstract class AntlrDdlParser<L extends Lexer, P extends Parser> extends AbstractDdlParser {
|
||||
|
||||
/**
|
||||
* Flag to indicate if the errors catched during tree walk will be thrown.
|
||||
* Flag to indicate if the errors caught during tree walk will be thrown.
|
||||
* true = errors will be thrown
|
||||
* false = errors will not be thrown. They will be available to get by {@link AntlrDdlParser#getParsingExceptionsFromWalker()}.
|
||||
*/
|
||||
private boolean throwErrorsFromTreeWalk;
|
||||
private final boolean throwErrorsFromTreeWalk;
|
||||
|
||||
/**
|
||||
* Parser listener for tree walker.
|
||||
|
||||
Loading…
Reference in New Issue
Block a user