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); } }