protected override void BuildStatement(SqlCodeObjectBuilder builder)
{
var userName = UserName;
foreach (var actionNode in Actions)
{
IAlterUserAction action;
if (actionNode is SetPasswordNode)
{
var password = ExpressionBuilder.Build(((SetPasswordNode)actionNode).Password);
action = new SetPasswordAction(password);
}
else if (actionNode is SetAccountStatusNode)
{
var statusText = ((SetAccountStatusNode)actionNode).Status;
var userStatus = ParseUserStatus(statusText);
action = new SetAccountStatusAction(userStatus);
}
else if (actionNode is SetGroupsNode)
{
var groupNames = ((SetGroupsNode)actionNode).Groups.Select(ExpressionBuilder.Build);
action = new SetUserGroupsAction(groupNames);
}
else
{
throw new NotSupportedException(String.Format("The action of type '{0}' is not supported.", actionNode.GetType()));
}
builder.AddObject(new AlterUserStatement(userName, action));
}
}
protected override void BuildStatement(SqlCodeObjectBuilder builder)
{
var parameters = new List <CursorParameter>();
if (Parameters != null)
{
foreach (var parameterNode in Parameters)
{
var dataType = builder.BuildDataType(parameterNode.ParameterType);
parameters.Add(new CursorParameter(parameterNode.ParameterName, dataType));
}
}
var flags = new CursorFlags();
if (Insensitive)
{
flags |= CursorFlags.Insensitive;
}
if (Scroll)
{
flags |= CursorFlags.Scroll;
}
var queryExpression = (SqlQueryExpression)ExpressionBuilder.Build(QueryExpression);
builder.AddObject(new DeclareCursorStatement(CursorName, parameters.ToArray(), flags, queryExpression));
}
protected override void BuildStatement(SqlCodeObjectBuilder builder)
{
var seqName = ObjectName.Parse(SequenceName);
var statement = new CreateSequenceStatement(seqName);
if (IncrementBy != null)
{
statement.IncrementBy = ExpressionBuilder.Build(IncrementBy);
}
if (Cache != null)
{
statement.Cache = ExpressionBuilder.Build(Cache);
}
if (StartWith != null)
{
statement.StartWith = ExpressionBuilder.Build(StartWith);
}
if (MinValue != null)
{
statement.MinValue = ExpressionBuilder.Build(MinValue);
}
if (MaxValue != null)
{
statement.MaxValue = ExpressionBuilder.Build(MaxValue);
}
statement.Cycle = Cycle;
builder.AddObject(statement);
}
protected override void BuildStatement(SqlCodeObjectBuilder builder)
{
var queryExpression = (SqlQueryExpression)ExpressionBuilder.Build(QueryExpression);
var statement = new CreateViewStatement(ViewName.Name, ColumnNames, queryExpression);
statement.ReplaceIfExists = ReplaceIfExists;
builder.AddObject(statement);
}
private void BuildSimpleUpdate(SqlCodeObjectBuilder builder, SimpleUpdateNode node)
{
var whereExpression = ExpressionBuilder.Build(node.WhereExpression);
var assignments = UpdateAssignments(node.Columns);
var statement = new UpdateStatement(node.TableName, whereExpression, assignments);
statement.Limit = node.Limit;
builder.AddObject(statement);
}
private IEnumerable <SortColumn> BuildOrderBy(IEnumerable <OrderByNode> nodes)
{
if (nodes == null)
{
return(null);
}
return(nodes.Select(node => new SortColumn(ExpressionBuilder.Build(node.Expression), node.Ascending)));
}
protected override void BuildStatement(SqlCodeObjectBuilder builder)
{
SqlExpression exp = null;
if (WhenExpression != null)
{
exp = ExpressionBuilder.Build(WhenExpression);
}
builder.AddObject(new LoopControlStatement(LoopControlType.Continue, Label, exp));
}
protected override void BuildStatement(SqlCodeObjectBuilder builder)
{
if (Identificator is IdentifiedByPasswordNode)
{
var passwordNode = (IdentifiedByPasswordNode)Identificator;
var password = ExpressionBuilder.Build(passwordNode.Password);
builder.AddObject(new CreateUserStatement(UserName, password));
}
else
{
throw new NotSupportedException();
}
}
protected override void BuildStatement(SqlCodeObjectBuilder builder)
{
var varRefExp = ExpressionBuilder.Build(VariableReference);
var valueExp = ExpressionBuilder.Build(ValueExpression);
if (!(varRefExp is SqlVariableReferenceExpression) &&
!(varRefExp is SqlReferenceExpression))
{
throw new NotSupportedException("Only simple references are supported now.");
}
builder.AddObject(new AssignVariableStatement(varRefExp, valueExp));
}
protected override void BuildStatement(SqlCodeObjectBuilder builder)
{
var varType = DataTypeBuilder.Build(builder.TypeResolver, Type);
var statement = new DeclareVariableStatement(VariableName, varType);
if (DefaultExpression != null)
{
statement.DefaultExpression = ExpressionBuilder.Build(DefaultExpression);
}
statement.IsConstant = IsConstant;
statement.IsNotNull = IsConstant || IsNotNull;
builder.AddObject(statement);
}
protected override void BuildStatement(SqlCodeObjectBuilder builder)
{
var tableName = ObjectName.Parse(TableName);
if (!FromCursor)
{
var whereExp = ExpressionBuilder.Build(WhereExpression);
builder.AddObject(new DeleteStatement(tableName, whereExp, Limit));
}
else
{
builder.AddObject(new DeleteCurrentStatement(tableName, CursorName));
}
}
protected override void BuildStatement(SqlCodeObjectBuilder builder)
{
var queryExpression = (SqlQueryExpression)ExpressionBuilder.Build(QueryExpression);
if (QueryExpression.IntoClause != null)
{
var refExp = ExpressionBuilder.Build(QueryExpression.IntoClause);
builder.AddObject(new SelectIntoStatement(queryExpression, refExp));
}
else
{
var orderBy = BuildOrderBy(OrderBy);
var statement = new SelectStatement(queryExpression, orderBy);
statement.Limit = BuildLimit(Limit);
builder.AddObject(statement);
}
}
public SqlTableConstraint BuildConstraint()
{
if (String.Equals(ConstraintTypeNames.Check, ConstraintType, StringComparison.OrdinalIgnoreCase))
{
var exp = ExpressionBuilder.Build(CheckExpression);
return(new SqlTableConstraint(ConstraintName, Tables.ConstraintType.Check, Columns.ToArray())
{
CheckExpression = exp
});
}
if (String.Equals(ConstraintTypeNames.PrimaryKey, ConstraintType, StringComparison.OrdinalIgnoreCase))
{
return(SqlTableConstraint.PrimaryKey(ConstraintName, Columns.ToArray()));
}
if (String.Equals(ConstraintTypeNames.UniqueKey, ConstraintType, StringComparison.OrdinalIgnoreCase))
{
return(SqlTableConstraint.UniqueKey(ConstraintName, Columns.ToArray()));
}
if (String.Equals(ConstraintTypeNames.ForeignKey, ConstraintType, StringComparison.OrdinalIgnoreCase))
{
var fTable = ReferencedTableName.Name;
var fColumns = ReferencedColumns;
var onDelete = ForeignKeyAction.NoAction;
var onUpdate = ForeignKeyAction.NoAction;
if (!String.IsNullOrEmpty(OnDeleteAction))
{
onDelete = SqlCodeObjectBuilder.GetForeignKeyAction(OnDeleteAction);
}
if (!String.IsNullOrEmpty(OnUpdateAction))
{
onUpdate = SqlCodeObjectBuilder.GetForeignKeyAction(OnUpdateAction);
}
var fkey = SqlTableConstraint.ForeignKey(ConstraintName, Columns.ToArray(), fTable,
fColumns.ToArray(), onDelete, onUpdate);
return(fkey);
}
throw new NotSupportedException();
}
protected override void BuildStatement(SqlCodeObjectBuilder builder)
{
var tableName = ObjectName.Parse(TableName);
if (ValuesInsert != null)
{
var valueInsert = ValuesInsert;
var values = valueInsert.Values.Select(x => x.Values.Select(ExpressionBuilder.Build)
.ToArray())
.ToList();
builder.AddObject(new InsertStatement(tableName, ColumnNames, values));
}
else if (SetInsert != null)
{
var assignments = SetInsert.Assignments;
var columnNames = new List <string>();
var values = new List <SqlExpression>();
foreach (var assignment in assignments)
{
var columnName = assignment.ColumnName;
var value = ExpressionBuilder.Build(assignment.Value);
columnNames.Add(columnName);
values.Add(value);
}
builder.AddObject(new InsertStatement(tableName, columnNames.ToArray(), new[] { values.ToArray() }));
}
else if (QueryInsert != null)
{
var queryInsert = QueryInsert;
var queryExpression = ExpressionBuilder.Build(queryInsert.QueryExpression) as SqlQueryExpression;
if (queryExpression == null)
{
throw new SqlParseException();
}
builder.AddObject(new InsertSelectStatement(tableName, ColumnNames, queryExpression));
}
}
protected override void BuildStatement(SqlCodeObjectBuilder builder)
{
FetchDirection direction;
if (!TryParseDirection(Direction, out direction))
{
throw new InvalidOperationException();
}
var statement = new FetchStatement(CursorName, direction);
if (Into != null)
{
statement.IntoReference = ExpressionBuilder.Build(Into);
}
if (Position != null)
{
statement.PositionExpression = ExpressionBuilder.Build(Position);
}
builder.AddObject(statement);
}
public static void Build(IQueryContext context, CreateTableNode node, ICollection<SqlStatement> statements)
{
string idColumn = null;
var dataTypeBuilder = new DataTypeBuilder();
var tableName = node.TableName;
var objTableName = ObjectName.Parse(tableName.Name);
var constraints = new List<ConstraintInfo>();
var columns = new List<SqlTableColumn>();
var expBuilder = new ExpressionBuilder();
foreach (var column in node.Columns) {
var dataType = dataTypeBuilder.Build(context.TypeResolver(), column.DataType);
var columnInfo = new SqlTableColumn(column.ColumnName.Text, dataType);
if (column.Default != null)
columnInfo.DefaultExpression = expBuilder.Build(column.Default);
if (column.IsIdentity) {
if (!String.IsNullOrEmpty(idColumn))
throw new InvalidOperationException(String.Format("Table {0} defines already {1} as identity column.",
node.TableName, idColumn));
if (column.Default != null)
throw new InvalidOperationException(String.Format("The identity column {0} cannot have a DEFAULT constraint.",
idColumn));
idColumn = column.ColumnName.Text;
columnInfo.DefaultExpression = SqlExpression.FunctionCall("UNIQUEKEY",
new[] {SqlExpression.Constant(node.TableName.Name)});
}
foreach (var constraint in column.Constraints) {
if (String.Equals(ConstraintTypeNames.Check, constraint.ConstraintType, StringComparison.OrdinalIgnoreCase)) {
var exp = expBuilder.Build(constraint.CheckExpression);
constraints.Add(ConstraintInfo.Check(objTableName, exp, column.ColumnName.Text));
} else if (String.Equals(ConstraintTypeNames.ForeignKey, constraint.ConstraintType, StringComparison.OrdinalIgnoreCase)) {
var fTable = ObjectName.Parse(constraint.ReferencedTable.Name);
var fColumn = constraint.ReferencedColumn.Text;
var fkey = ConstraintInfo.ForeignKey(objTableName, column.ColumnName.Text, fTable, fColumn);
if (!String.IsNullOrEmpty(constraint.OnDeleteAction))
fkey.OnDelete = GetForeignKeyAction(constraint.OnDeleteAction);
if (!String.IsNullOrEmpty(constraint.OnUpdateAction))
fkey.OnUpdate = GetForeignKeyAction(constraint.OnUpdateAction);
constraints.Add(fkey);
} else if (String.Equals(ConstraintTypeNames.PrimaryKey, constraint.ConstraintType, StringComparison.OrdinalIgnoreCase)) {
constraints.Add(ConstraintInfo.PrimaryKey(objTableName, column.ColumnName.Text));
} else if (String.Equals(ConstraintTypeNames.UniqueKey, constraint.ConstraintType, StringComparison.OrdinalIgnoreCase)) {
constraints.Add(ConstraintInfo.Unique(objTableName, column.ColumnName.Text));
} else if (String.Equals(ConstraintTypeNames.NotNull, constraint.ConstraintType, StringComparison.OrdinalIgnoreCase)) {
columnInfo.IsNotNull = true;
} else if (String.Equals(ConstraintTypeNames.Null, constraint.ConstraintType, StringComparison.OrdinalIgnoreCase)) {
columnInfo.IsNotNull = false;
}
}
columns.Add(columnInfo);
}
foreach (var constraint in node.Constraints) {
if (String.Equals(ConstraintTypeNames.Check, constraint.ConstraintType, StringComparison.OrdinalIgnoreCase)) {
var exp = expBuilder.Build(constraint.CheckExpression);
constraints.Add(ConstraintInfo.Check(constraint.ConstraintName, objTableName, exp, constraint.Columns.ToArray()));
} else if (String.Equals(ConstraintTypeNames.PrimaryKey, constraint.ConstraintType, StringComparison.OrdinalIgnoreCase)) {
constraints.Add(ConstraintInfo.PrimaryKey(constraint.ConstraintName, objTableName, constraint.Columns.ToArray()));
} else if (String.Equals(ConstraintTypeNames.UniqueKey, constraint.ConstraintType, StringComparison.OrdinalIgnoreCase)) {
constraints.Add(ConstraintInfo.Unique(constraint.ConstraintName, objTableName, constraint.Columns.ToArray()));
} else if (String.Equals(ConstraintTypeNames.ForeignKey, constraint.ConstraintType, StringComparison.OrdinalIgnoreCase)) {
var fTable = ObjectName.Parse(constraint.ReferencedTableName.Name);
var fColumns = constraint.ReferencedColumns;
var fkey = ConstraintInfo.ForeignKey(constraint.ConstraintName, objTableName, constraint.Columns.ToArray(), fTable,
fColumns.ToArray());
if (!String.IsNullOrEmpty(constraint.OnDeleteAction))
fkey.OnDelete = GetForeignKeyAction(constraint.OnDeleteAction);
if (!String.IsNullOrEmpty(constraint.OnUpdateAction))
fkey.OnUpdate = GetForeignKeyAction(constraint.OnUpdateAction);
constraints.Add(fkey);
}
}
//TODO: Optimization: merge same constraints
statements.Add(MakeCreateTable(tableName.Name, columns, node.IfNotExists, node.Temporary));
foreach (var constraint in constraints) {
statements.Add(MakeAlterTableAddConstraint(tableName.Name, constraint));
}
}
private static void BuildAction(ITypeResolver typeResolver, ObjectName tableName, IAlterActionNode action, SqlCodeObjectBuilder builder)
{
if (action is AddColumnNode)
{
var column = ((AddColumnNode)action).Column;
var constraints = new List <SqlTableConstraint>();
var columnInfo = column.BuildColumn(typeResolver, tableName.FullName, constraints);
builder.AddObject(new AlterTableStatement(tableName, new AddColumnAction(columnInfo)));
foreach (var constraint in constraints)
{
builder.AddObject(new AlterTableStatement(tableName, new AddConstraintAction(constraint)));
}
}
else if (action is AddConstraintNode)
{
var constraint = ((AddConstraintNode)action).Constraint;
var constraintInfo = constraint.BuildConstraint();
builder.AddObject(new AlterTableStatement(tableName, new AddConstraintAction(constraintInfo)));
}
else if (action is DropColumnNode)
{
var columnName = ((DropColumnNode)action).ColumnName;
builder.AddObject(new AlterTableStatement(tableName, new DropColumnAction(columnName)));
}
else if (action is DropConstraintNode)
{
var constraintName = ((DropConstraintNode)action).ConstraintName;
builder.AddObject(new AlterTableStatement(tableName, new DropConstraintAction(constraintName)));
}
else if (action is SetDefaultNode)
{
var actionNode = ((SetDefaultNode)action);
var columnName = actionNode.ColumnName;
var expression = ExpressionBuilder.Build(actionNode.Expression);
builder.AddObject(new AlterTableStatement(tableName, new SetDefaultAction(columnName, expression)));
}
else if (action is DropDefaultNode)
{
var columnName = ((DropDefaultNode)action).ColumnName;
builder.AddObject(new AlterTableStatement(tableName, new DropDefaultAction(columnName)));
}
else if (action is AlterColumnNode)
{
var column = ((AlterColumnNode)action).Column;
var constraints = new List <SqlTableConstraint>();
var columnInfo = column.BuildColumn(typeResolver, tableName.FullName, constraints);
// CHECK: Here we do a drop and add column: is there a better way on the back-end?
builder.AddObject(new AlterTableStatement(tableName, new DropColumnAction(columnInfo.ColumnName)));
builder.AddObject(new AlterTableStatement(tableName, new AddColumnAction(columnInfo)));
foreach (var constraint in constraints)
{
builder.AddObject(new AlterTableStatement(tableName, new AddConstraintAction(constraint)));
}
}
}
private IEnumerable <SqlColumnAssignment> UpdateAssignments(IEnumerable <UpdateColumnNode> columns)
{
if (columns == null)
{
return(null);
}
return(columns.Select(column => new SqlColumnAssignment(column.ColumnName, ExpressionBuilder.Build(column.Expression))));
}
private SqlExpression Expression(IExpressionNode node)
{
var visitor = new ExpressionBuilder();
return visitor.Build(node);
}
public SqlTableColumn BuildColumn(ITypeResolver typeResolver, string tableName, IList <SqlTableConstraint> constraints)
{
var dataType = DataTypeBuilder.Build(typeResolver, DataType);
var columnInfo = new SqlTableColumn(ColumnName, dataType);
if (Default != null)
{
columnInfo.DefaultExpression = ExpressionBuilder.Build(Default);
}
if (IsIdentity)
{
columnInfo.DefaultExpression = SqlExpression.FunctionCall("UNIQUEKEY",
new[] { SqlExpression.Constant(tableName) });
columnInfo.IsIdentity = true;
}
foreach (var constraint in Constraints)
{
if (String.Equals(ConstraintTypeNames.Check, constraint.ConstraintType, StringComparison.OrdinalIgnoreCase))
{
var exp = ExpressionBuilder.Build(constraint.CheckExpression);
constraints.Add(SqlTableConstraint.Check(null, exp));
}
else if (String.Equals(ConstraintTypeNames.ForeignKey, constraint.ConstraintType, StringComparison.OrdinalIgnoreCase))
{
var fTable = constraint.ReferencedTable.Name;
var fColumn = constraint.ReferencedColumn.Text;
var onDelete = ForeignKeyAction.NoAction;
var onUpdate = ForeignKeyAction.NoAction;
if (!String.IsNullOrEmpty(constraint.OnDeleteAction))
{
onDelete = SqlCodeObjectBuilder.GetForeignKeyAction(constraint.OnDeleteAction);
}
if (!String.IsNullOrEmpty(constraint.OnUpdateAction))
{
onUpdate = SqlCodeObjectBuilder.GetForeignKeyAction(constraint.OnUpdateAction);
}
constraints.Add(SqlTableConstraint.ForeignKey(null, new[] { ColumnName }, fTable, new[] { fColumn }, onDelete, onUpdate));
}
else if (String.Equals(ConstraintTypeNames.PrimaryKey, constraint.ConstraintType, StringComparison.OrdinalIgnoreCase))
{
constraints.Add(SqlTableConstraint.PrimaryKey(null, new[] { ColumnName }));
}
else if (String.Equals(ConstraintTypeNames.UniqueKey, constraint.ConstraintType, StringComparison.OrdinalIgnoreCase))
{
constraints.Add(SqlTableConstraint.UniqueKey(null, new[] { ColumnName }));
}
else if (String.Equals(ConstraintTypeNames.NotNull, constraint.ConstraintType, StringComparison.OrdinalIgnoreCase))
{
columnInfo.IsNotNull = true;
}
else if (String.Equals(ConstraintTypeNames.Null, constraint.ConstraintType, StringComparison.OrdinalIgnoreCase))
{
columnInfo.IsNotNull = false;
}
}
return(columnInfo);
}
/// <summary>
/// Parses the given SQL string to an expression that can be evaluated.
/// </summary>
/// <param name="s">The string to parse.</param>
/// <param name="context"></param>
/// <returns>
/// Returns an instance of <seealso cref="SqlExpression"/> that represents
/// the given SQL string parsed.
/// </returns>
public static SqlExpression Parse(string s, ISystemContext context)
{
try {
// TODO: Get the expression compiler from the context
var compiler = SqlParsers.Expression;
var result = compiler.Parse(s);
if (result.HasErrors)
throw new SqlParseException();
var visitor = new ExpressionBuilder();
return visitor.Build(result.RootNode);
} catch (SqlParseException ex) {
throw new SqlExpressionException(ExpressionErrorCodes.CannotParse,
"Could not parse input expression: see inner exception for details.", ex);
}
}
