public static SqlStatement Build(PlSqlParser.CreateTableStatementContext context)
{
var tableName = Name.Object(context.objectName());
var columnOrConstraints = context.columnOrConstraintList().columnOrConstraint();
bool ifNotExists = context.IF() != null && context.NOT() != null && context.EXISTS() != null;
bool temporary = context.TEMPORARY() != null;
var tableColumns = new List<SqlTableColumn>();
var tableConstraints = new List<SqlTableConstraint>();
var columnConstraints = new List<ColumnConstraint>();
foreach (var columnOrConstraint in columnOrConstraints) {
if (columnOrConstraint.tableColumn() != null) {
tableColumns.Add(TableColumn.Form(columnOrConstraint.tableColumn(), columnConstraints));
} else if (columnOrConstraint.tableConstraint() != null) {
tableConstraints.Add(TableConstraint.Form(columnOrConstraint.tableConstraint()));
}
}
if (columnConstraints.Count > 0) {
var constraintGroups = columnConstraints.GroupBy(x => x.Type);
foreach (var constraintGroup in constraintGroups) {
var columnNames = constraintGroup.Select(x => x.ColumnName).ToArray();
var index = tableConstraints.FindIndex(x => String.IsNullOrEmpty(x.ConstraintName) &&
x.ConstraintType == constraintGroup.Key);
if (index != -1) {
var unnamedConstraint = tableConstraints[index];
var columns = new List<string>(unnamedConstraint.Columns);
foreach (var columnName in columnNames) {
if (!columns.Contains(columnName))
columns.Add(columnName);
}
// TODO: set the new columns
} else {
tableConstraints.Add(new SqlTableConstraint(constraintGroup.Key, columnNames));
}
}
}
var block = new SequenceOfStatements();
block.Statements.Add(new CreateTableStatement(tableName, tableColumns) {
IfNotExists = ifNotExists,
Temporary = temporary
});
foreach (var constraint in tableConstraints) {
block.Statements.Add(new AlterTableStatement(tableName, new AddConstraintAction(constraint)));
}
return block;
}
public static ElementNode Form(PlSqlParser.General_elementContext context)
{
var id = Name.Object(context.objectName());
var arg = context.function_argument();
IEnumerable<FunctionArgument> argNodes = null;
if (arg != null) {
argNodes = arg.argument().Select(FunctionArgument.Form);
}
return new ElementNode {
Id = id,
Argument = argNodes != null ? argNodes.ToArray() : null
};
}
public static SqlStatement Drop(PlSqlParser.DropSequenceStatementContext context)
{
var names = context.objectName().Select(Name.Object).ToArray();
var ifExists = context.IF() != null && context.EXISTS() != null;
if (names.Length == 1)
return new DropSequenceStatement(names[0]);
var sequence = new SequenceOfStatements();
foreach (var name in names) {
sequence.Statements.Add(new DropSequenceStatement(name));
}
return sequence;
}
public static SqlStatement Build(PlSqlParser.DropTableStatementContext context)
{
var tableNames = context.objectName().Select(Name.Object).ToArray();
bool ifExists = context.IF() != null && context.EXISTS() != null;
if (tableNames.Length == 1)
return new DropTableStatement(tableNames[0], ifExists);
var list = new SequenceOfStatements();
foreach (var tableName in tableNames) {
list.Statements.Add(new DropTableStatement(tableName, ifExists));
}
return list;
}
public static SqlStatement Build(PlSqlParser.AlterTableStatementContext context)
{
var tableName = Name.Object(context.objectName());
var actions = context.alterTableAction().Select(ActionBuilder.Build).ToArray();
if (actions.Length == 1)
return new AlterTableStatement(tableName, actions[0]);
var list = new SequenceOfStatements();
foreach (var action in actions) {
list.Statements.Add(new AlterTableStatement(tableName, action));
}
return list;
}
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 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();
}
public static SqlStatement Build(PlSqlParser.DeleteStatementContext context)
{
var tableName = Name.Object(context.objectName());
var whereClause = WhereClause.Form(context.whereClause());
if (whereClause.CurrentOf != null)
return new DeleteCurrentStatement(tableName, whereClause.CurrentOf);
var statement = new DeleteStatement(tableName, whereClause.Expression);
if (context.deleteLimit() != null) {
var limit = Number.PositiveInteger(context.deleteLimit().numeric());
if (limit == null)
throw new ParseCanceledException("Invalid delete limit.");
statement.Limit = limit.Value;
}
return statement;
}
public static SqlStatement Create(PlSqlParser.CreateSequenceStatementContext context)
{
var seqName = Name.Object(context.objectName());
var statement = new CreateSequenceStatement(seqName);
var startWith = context.sequenceStartClause();
if (startWith != null) {
statement.StartWith = SqlExpression.Constant(Number.PositiveInteger(startWith.UNSIGNED_INTEGER()));
}
var specs = context.sequenceSpec();
if (specs != null && specs.Length > 0) {
foreach (var spec in specs) {
if (spec.INCREMENT() != null &&
spec.BY() != null) {
statement.IncrementBy = SqlExpression.Constant(Number.PositiveInteger(spec.UNSIGNED_INTEGER()));
} else if (spec.MAXVALUE() != null) {
statement.MaxValue = SqlExpression.Constant(Number.PositiveInteger(spec.UNSIGNED_INTEGER()));
} else if (spec.NOMAXVALUE() != null) {
statement.MaxValue = SqlExpression.Constant(null);
} else if (spec.MINVALUE() != null) {
statement.MinValue = SqlExpression.Constant(Number.PositiveInteger(spec.UNSIGNED_INTEGER()));
} else if (spec.NOMINVALUE() != null) {
statement.MinValue = SqlExpression.Constant(null);
} else if (spec.CACHE() != null) {
statement.Cache = SqlExpression.Constant(Number.PositiveInteger(spec.UNSIGNED_INTEGER()));
} else if (spec.NOCACHE() != null) {
statement.Cache = SqlExpression.Constant(null);
} else if (spec.CYCLE() != null) {
statement.Cycle = true;
} else if (spec.NOCYCLE() != null) {
statement.Cycle = false;
}
}
}
return statement;
}
private static FromSource FormSource(PlSqlParser.Dml_table_expression_clauseContext context)
{
var tableName = Name.Object(context.objectName());
var query = context.subquery();
var source = new FromSource();
if (tableName != null) {
source.TableName = tableName.ToString();
} else if (!query.IsEmpty) {
source.SubQuery = Form(query);
}
if (context.alias != null && !context.alias.IsEmpty) {
source.Alias = context.alias.GetText();
}
return source;
}
