|
public static Build ( IParseTree tree ) : |
||
| tree | IParseTree | |
| Résultat | ||
public static SqlStatement Statement(PlSqlParser.AssignmentStatementContext context)
{
SqlExpression varRef;
if (context.general_element() != null)
{
var element = ElementNode.Form(context.general_element());
if (element.Argument != null &&
element.Argument.Length > 0)
{
throw new ParseCanceledException("Invalid assignment: cannot assign a function");
}
var name = element.Id;
if (name.Parent != null)
{
throw new ParseCanceledException("Invalid assignment.");
}
varRef = SqlExpression.VariableReference(name.ToString());
}
else if (context.bind_variable() != null)
{
var varName = Name.Variable(context.bind_variable());
varRef = SqlExpression.VariableReference(varName);
}
else
{
throw new ParseCanceledException("Invalid assignment syntax");
}
var valueExp = Expression.Build(context.expression());
return(new AssignVariableStatement(varRef, valueExp));
}
public override SqlStatement VisitVariableDeclaration(PlSqlParser.VariableDeclarationContext context)
{
var name = Name.Simple(context.variable_name());
var type = SqlTypeParser.Parse(context.datatype());
bool notNull = context.NOT() != null && context.NULL() != null;
bool constant = context.CONSTANT() != null;
if (constant)
{
notNull = true;
}
SqlExpression defaultValue = null;
if (context.defaultValuePart() != null)
{
defaultValue = Expression.Build(context.defaultValuePart().expression());
}
return(new DeclareVariableStatement(name, type)
{
DefaultExpression = defaultValue,
IsNotNull = notNull,
IsConstant = constant
});
}
public override SqlExpression VisitTrimFunction(PlSqlParser.TrimFunctionContext context)
{
var arg1 = Expression.Build(context.concatenationWrapper());
var part = "both";
if (context.LEADING() != null)
{
part = "leading";
}
else if (context.TRAILING() != null)
{
part = "trailing";
}
else if (context.BOTH() != null)
{
part = "both";
}
var toTrim = " ";
if (context.quoted_string() != null)
{
toTrim = InputString.AsNotQuoted(context.quoted_string());
}
var arg2 = SqlExpression.Constant(part);
var arg3 = SqlExpression.Constant(toTrim);
return(SqlExpression.FunctionCall("SQL_TRIM", new SqlExpression[] { arg1, arg2, arg3 }));
}
public static SelectColumn BuildColumn(PlSqlParser.SelectedElementContext context)
{
string alias = null;
if (context.column_alias() != null &&
!context.column_alias().IsEmpty)
{
alias = Name.Simple(context.column_alias());
}
SelectColumn column;
if (context.expression() != null &&
!context.expression().IsEmpty)
{
column = new SelectColumn(Expression.Build(context.expression()), alias);
}
else if (context.selectedColumn() != null &&
!context.selectedColumn().IsEmpty)
{
bool glob = context.selectedColumn().glob != null;
ObjectName name = Name.Select(context.selectedColumn().objectName(), glob);
var exp = SqlExpression.Reference(name);
column = new SelectColumn(exp, alias);
}
else
{
throw new ParseCanceledException();
}
return(column);
}
public override SqlStatement VisitLoopStatement(PlSqlParser.LoopStatementContext context)
{
LoopStatement loop;
if (context.WHILE() != null)
{
var condition = Expression.Build(context.condition());
loop = new WhileLoopStatement(condition);
}
else if (context.FOR() != null)
{
var param = context.cursorLoopParam();
if (param.lowerBound() != null &&
param.upperBound() != null)
{
var lower = Expression.Build(param.lowerBound());
var upper = Expression.Build(param.upperBound());
var indexName = Name.Simple(param.id());
var reverse = param.REVERSE() != null;
loop = new ForLoopStatement(indexName, lower, upper)
{
Reverse = reverse
};
}
else
{
throw new NotImplementedException();
}
}
else
{
loop = new LoopStatement();
}
if (context.labelDeclaration() != null)
{
var labelName = Name.Simple(context.labelDeclaration().id());
loop.Label = labelName;
}
var seqOfStatements = context.seqOfStatements();
if (seqOfStatements != null)
{
var statements = seqOfStatements.statement().Select(Visit);
foreach (var statement in statements)
{
loop.Statements.Add(statement);
}
}
return(loop);
}
public override SqlStatement VisitInsertStatement(PlSqlParser.InsertStatementContext context)
{
var singleTableInsert = context.singleTableInsert();
var insertInto = singleTableInsert.insertIntoClause();
if (insertInto != null)
{
var tableName = Name.Object(insertInto.objectName());
var columnNames = new string[0];
if (insertInto.columnName() != null)
{
columnNames = insertInto.columnName().Select(Name.Simple).ToArray();
}
if (singleTableInsert.valuesClause() != null)
{
var values = new List <SqlExpression[]>();
foreach (var listContext in singleTableInsert.valuesClause().expression_list())
{
var array = listContext.expression().Select(Expression.Build).ToArray();
values.Add(array);
}
return(new InsertStatement(tableName, columnNames, values));
}
if (singleTableInsert.subquery() != null)
{
var query = Subquery.Form(singleTableInsert.subquery());
return(new InsertSelectStatement(tableName, columnNames, query));
}
}
else if (singleTableInsert.insertSetClause() != null)
{
var tableName = Name.Object(singleTableInsert.insertSetClause().objectName());
var columns = new List <string>();
var values = new List <SqlExpression>();
foreach (var assignmentContext in singleTableInsert.insertSetClause().insertAssignment())
{
var columnName = Name.Simple(assignmentContext.columnName());
var value = Expression.Build(assignmentContext.expression());
columns.Add(columnName);
values.Add(value);
}
return(new InsertStatement(tableName, columns.ToArray(), new[] { values.ToArray() }));
}
return(base.VisitInsertStatement(context));
}
public override SqlStatement VisitReturnStatement(PlSqlParser.ReturnStatementContext context)
{
var returnContext = context.condition();
SqlExpression returnExpression = null;
if (returnContext != null)
{
returnExpression = Expression.Build(returnContext);
}
return(new ReturnStatement(returnExpression));
}
public static UpdateStatement Build(PlSqlParser.UpdateStatementContext context)
{
var tableName = Name.Object(context.objectName());
var setClause = context.updateSetClause();
var limitClause = context.updateLimitClause();
if (setClause != null)
{
var assignments = new List <SqlColumnAssignment>();
var whereClause = context.whereClause();
int limit = -1;
if (limitClause != null)
{
limit = Number.PositiveInteger(limitClause.numeric()) ?? -1;
}
SqlExpression whereExpression = null;
if (whereClause != null)
{
whereExpression = Expression.Build(whereClause.conditionWrapper());
}
if (setClause.VALUE() != null)
{
var columnName = Name.Simple(setClause.columnName());
var value = Expression.Build(setClause.expression());
assignments.Add(new SqlColumnAssignment(columnName, value));
}
else
{
var pairs = setClause.columnBasedUpdateClause().Select(x => new {
columnName = Name.Simple(x.columnName()),
value = Expression.Build(x.expression())
});
assignments = pairs.Select(x => new SqlColumnAssignment(x.columnName, x.value)).ToList();
}
return(new UpdateStatement(tableName, whereExpression, assignments)
{
Limit = limit
});
}
if (context.updateFromClause() != null)
{
var query = Subquery.Form(context.updateFromClause().subquery());
}
throw new NotSupportedException();
}
private static LoopControlStatement Build(LoopControlType controlType, PlSqlParser.LabelNameContext labelContext, PlSqlParser.ConditionContext conditionContext)
{
string label = null;
SqlExpression whenExpression = null;
if (labelContext != null)
{
label = Name.Simple(labelContext);
}
if (conditionContext != null)
{
whenExpression = Expression.Build(conditionContext.expression());
}
return(new LoopControlStatement(controlType, label, whenExpression));
}
public override SqlStatement VisitIfStatement(PlSqlParser.IfStatementContext context)
{
var conditions = new List <ConditionPart> {
new ConditionPart {
Condition = Expression.Build(context.condition()),
Statements = context.seqOfStatements().statement().Select(Visit).ToArray()
}
};
foreach (var partContext in context.elsifPart())
{
conditions.Add(new ConditionPart {
Condition = Expression.Build(partContext.condition()),
Statements = partContext.seqOfStatements().statement().Select(Visit).ToArray()
});
}
if (context.elsePart() != null)
{
var statements = context.elsePart().seqOfStatements().statement().Select(Visit).ToArray();
conditions.Add(new ConditionPart {
Condition = SqlExpression.Constant(true),
Statements = statements
});
}
ConditionStatement conditional = null;
for (int i = conditions.Count - 1; i >= 0; i--)
{
var current = conditions[i];
var condition = new ConditionStatement(current.Condition, current.Statements);
if (conditional != null)
{
conditional = new ConditionStatement(current.Condition, current.Statements, new SqlStatement[] { conditional });
}
else
{
conditional = condition;
}
}
return(conditional);
}
public static IAlterTableAction Build(PlSqlParser.AlterTableActionContext context)
{
if (context.addColumnAction() != null)
{
var column = TableColumn.Form(context.addColumnAction().tableColumn(), new List <ColumnConstraint>());
return(new AddColumnAction(column));
}
if (context.addConstraintAction() != null)
{
var constraint = TableConstraint.Form(context.addConstraintAction().tableConstraint());
return(new AddConstraintAction(constraint));
}
if (context.dropColumnAction() != null)
{
var columnName = context.dropColumnAction().id().GetText();
return(new DropColumnAction(columnName));
}
if (context.dropConstraintAction() != null)
{
var constraintName = context.dropConstraintAction().id().GetText();
return(new DropConstraintAction(constraintName));
}
if (context.dropPrimaryKeyAction() != null)
{
return(new DropPrimaryKeyAction());
}
if (context.dropDefaultAction() != null)
{
var columnName = Name.Simple(context.dropDefaultAction().columnName());
return(new DropDefaultAction(columnName));
}
if (context.setDefaultAction() != null)
{
var columnName = Name.Simple(context.setDefaultAction().columnName());
var defaultValue = Expression.Build(context.setDefaultAction().expressionWrapper());
return(new SetDefaultAction(columnName, defaultValue));
}
throw new ParseCanceledException("The ALTER TABLE action is not supported");
}
public static CreateViewStatement Create(PlSqlParser.CreateViewStatementContext context)
{
var orReplace = context.OR() != null && context.REPLACE() != null;
var viewName = Name.Object(context.objectName());
var query = (SqlQueryExpression)Expression.Build(context.subquery());
string[] columnNames = null;
if (context.columnList() != null)
{
columnNames = context.columnList().columnName().Select(Name.Simple).ToArray();
}
return(new CreateViewStatement(viewName, columnNames, query)
{
ReplaceIfExists = orReplace
});
}
public override SqlStatement VisitSimpleCaseStatement(PlSqlParser.SimpleCaseStatementContext context)
{
var exp = Expression.Build(context.atom());
var switches = new List <CaseSwitch>();
foreach (var partContext in context.simpleCaseWhenPart())
{
var otherExp = Expression.Build(partContext.expressionWrapper());
switches.Add(new CaseSwitch {
Condition = SqlExpression.Equal(exp, otherExp),
ReturnStatements = partContext.seqOfStatements().statement().Select(Visit).ToArray()
});
}
if (context.caseElsePart() != null)
{
var returnstatements = context.caseElsePart().seqOfStatements().statement().Select(Visit).ToArray();
switches.Add(new CaseSwitch {
Condition = SqlExpression.Constant(true),
ReturnStatements = returnstatements
});
}
ConditionStatement conditional = null;
for (int i = switches.Count - 1; i >= 0; i--)
{
var current = switches[i];
var condition = new ConditionStatement(current.Condition, current.ReturnStatements);
if (conditional != null)
{
conditional = new ConditionStatement(current.Condition, current.ReturnStatements, new SqlStatement[] { conditional });
}
else
{
conditional = condition;
}
}
return(conditional);
}
public static RoutineParameter Routine(PlSqlParser.ParameterContext context)
{
var paramName = Name.Simple(context.parameter_name());
var paramType = SqlTypeParser.Parse(context.datatype());
var paramDir = ParameterDirection.Input;
if (context.IN() != null)
{
if (context.OUT() != null)
{
paramDir = ParameterDirection.InputOutput;
}
else
{
paramDir = ParameterDirection.Input;
}
}
else if (context.OUT() != null)
{
paramDir = ParameterDirection.Output;
}
else if (context.INOUT() != null)
{
paramDir = ParameterDirection.InputOutput;
}
SqlExpression defaultValue = null;
var defaultPart = context.defaultValuePart();
if (defaultPart != null)
{
defaultValue = Expression.Build(defaultPart.expression());
}
// TODO: Support default in RoutineParameter
return(new RoutineParameter(paramName, paramType, paramDir));
}
public static SqlStatement Build(PlSqlParser.SelectStatementContext context)
{
IntoClause into;
var query = Subquery.Form(context.subquery(), out into);
if (into != null)
{
SqlExpression reference;
if (into.TableName != null)
{
reference = SqlExpression.Reference(into.TableName);
}
else
{
var vars = into.Variables;
reference = SqlExpression.Tuple(vars.Select(SqlExpression.VariableReference).Cast <SqlExpression>().ToArray());
}
return(new SelectIntoStatement(query, reference));
}
var statement = new SelectStatement(query);
var orderBy = context.orderByClause();
var forUpdate = context.forUpdateClause();
if (orderBy != null)
{
var sortColumns = orderBy.orderByElements().orderByElement().Select(x => {
bool asc = x.DESC() == null;
var exp = Expression.Build(x.expression());
return(new SortColumn(exp, asc));
});
statement.OrderBy = sortColumns;
}
statement.ForUpdate = forUpdate != null;
var limit = context.queryLimitClause();
if (limit != null)
{
var n1 = Number.PositiveInteger(limit.n1);
var n2 = Number.PositiveInteger(limit.n2);
if (n1 == null)
{
throw new ParseCanceledException("Invalid LIMIT clause");
}
if (n2 != null)
{
statement.Limit = new QueryLimit(n1.Value, n2.Value);
}
else
{
statement.Limit = new QueryLimit(n1.Value);
}
}
return(statement);
}
public static SqlTableConstraint Form(PlSqlParser.TableConstraintContext context)
{
string constraintName = Name.Simple(context.id());
ConstraintType type;
string[] columns = null;
string refTable = null;
string[] refColumns = null;
SqlExpression checkExp = null;
ForeignKeyAction?onDelete = null;
ForeignKeyAction?onUpdate = null;
if (context.primaryKeyConstraint() != null)
{
type = ConstraintType.PrimaryKey;
columns = context.primaryKeyConstraint().columnList().columnName().Select(Name.Simple).ToArray();
}
else if (context.uniqueKeyConstraint() != null)
{
type = ConstraintType.Unique;
columns = context.uniqueKeyConstraint().columnList().columnName().Select(Name.Simple).ToArray();
}
else if (context.checkConstraint() != null)
{
type = ConstraintType.Check;
checkExp = Expression.Build(context.checkConstraint().expression());
}
else if (context.foreignKeyConstraint() != null)
{
type = ConstraintType.ForeignKey;
columns = context.foreignKeyConstraint().columns.columnName().Select(Name.Simple).ToArray();
refColumns = context.foreignKeyConstraint().refColumns.columnName().Select(Name.Simple).ToArray();
refTable = Name.Object(context.foreignKeyConstraint().objectName()).ToString();
var refActions = context.foreignKeyConstraint().referentialAction();
if (refActions != null && refActions.Length > 0)
{
foreach (var action in refActions)
{
if (action.onDelete() != null)
{
var actionType = GetForeignKeyAction(action.onDelete().referentialActionType().GetText());
onDelete = actionType;
}
else if (action.onUpdate() != null)
{
var actionType = GetForeignKeyAction(action.onUpdate().referentialActionType().GetText());
onUpdate = actionType;
}
}
}
}
else
{
throw new ParseCanceledException("Invalid ");
}
var constraint = new SqlTableConstraint(constraintName, type, columns);
if (type == ConstraintType.ForeignKey)
{
constraint.ReferenceTable = refTable;
constraint.ReferenceColumns = refColumns;
constraint.OnUpdate = onUpdate ?? ForeignKeyAction.NoAction;
constraint.OnDelete = onDelete ?? ForeignKeyAction.NoAction;
}
else if (type == ConstraintType.Check)
{
constraint.CheckExpression = checkExp;
}
return(constraint);
}
public static SqlTableColumn Form(PlSqlParser.TableColumnContext context, List <ColumnConstraint> constraints)
{
var columnName = Name.Simple(context.columnName());
var columnType = SqlTypeParser.Parse(context.datatype());
if (columnType == null)
{
throw new ParseCanceledException("No type was found for table.");
}
SqlExpression defaultExpression = null;
bool identity = false;
bool nullable = true;
string indexType = null;
if (context.IDENTITY() != null)
{
if (!(columnType is NumericType))
{
throw new InvalidOperationException("Cannot have an identity column that has not a numeric type");
}
identity = true;
}
else
{
var columnConstraints = context.columnConstraint();
if (columnConstraints != null &&
columnConstraints.Length > 0)
{
foreach (var constraintContext in columnConstraints)
{
if (constraintContext.PRIMARY() != null)
{
constraints.Add(new ColumnConstraint {
ColumnName = columnName,
Type = ConstraintType.PrimaryKey
});
}
else if (constraintContext.UNIQUE() != null)
{
constraints.Add(new ColumnConstraint {
Type = ConstraintType.Unique,
ColumnName = columnName
});
}
else if (constraintContext.NOT() != null &&
constraintContext.NULL() != null)
{
nullable = false;
}
}
}
if (context.defaultValuePart() != null)
{
defaultExpression = Expression.Build(context.defaultValuePart().expression());
}
if (context.columnIndex() != null)
{
var columnIndex = context.columnIndex();
if (columnIndex.BLIST() != null)
{
indexType = DefaultIndexTypes.InsertSearch;
}
else if (columnIndex.NONE() != null)
{
indexType = DefaultIndexTypes.BlindSearch;
}
else if (columnIndex.id() != null)
{
indexType = Name.Simple(columnIndex.id());
}
else if (columnIndex.CHAR_STRING() != null)
{
indexType = InputString.AsNotQuoted(columnIndex.CHAR_STRING());
}
}
}
return(new SqlTableColumn(columnName, columnType)
{
IsNotNull = !nullable,
IsIdentity = identity,
DefaultExpression = defaultExpression,
IndexType = indexType
});
}