public async Task <IActionResult> Update(Guid expressionId, [FromBody] UpdateExpression toUpdate) { toUpdate.UserId = UserId; await mediator.Send(toUpdate); return(new OkResult()); }
public void UpdateExpression_WithDefaultConstructor_ShouldInitializeUpdateCommandsProperty() { // Arrange var updateExpression = new UpdateExpression <ITweet>(); // Assert Assert.IsNotNull(updateExpression.UpdateCommands, "UpdateCommands property should be correctly initialized."); }
public void UpdateExpression_WithDefaultConstructor_ShouldReturnValidObject() { // Arrange var updateExpression = new UpdateExpression <ITweet>(); // Assert Assert.IsNotNull(updateExpression, "UpdateExpression<ITweet> should not be null."); }
protected internal override Expression VisitUpdate(UpdateExpression update) { if (update.ReturnRowCount == false) { return(update); } return(new UpdateExpression(update.Table, update.UseHistoryTable, update.Source, update.Where, update.Assigments, returnRowCount: false)); }
public async Task <Unit> Handle(UpdateExpression message, CancellationToken cancellationToken) { var expression = await repository.Find(message.Id); expression.ExpressionString = message.ExpressionString; expression.Name = message.Name; await repository.Save(); return(Unit.Value); }
public void UpdateTest2() { var expression = new UpdateExpression(new[] { Change.Add("list", new[] { "A", "B", "C" }), Change.Remove("deleted") }, new JsonObject(), new AttributeCollection()); Assert.Equal(@"REMOVE deleted ADD list :v0", expression.ToString()); }
public void UpdateExpression_SetNullField_ShouldThrowArgumentNullExceptionWithFieldParamName() { // Arrange var updateExpression = new UpdateExpression <ITweet>(); var value = "Some value"; // Act + Assert var exception = Assert.Throws <ArgumentNullException>(() => updateExpression.Set <string>(null, value), @"ArgumentNullException should be thrown."); Assert.AreEqual("field", exception.ParamName, @"ParamName should be ""field""."); }
public void UpdateExpression_SetNullOrWhiteSpaceFieldName_ShouldThrowArgumentNullExceptionWithFieldNameParamName(string fieldName) { // Arrange var updateExpression = new UpdateExpression <ITweet>(); var value = "Some value"; // Act + Assert var exception = Assert.Throws <ArgumentNullException>(() => updateExpression.Set(fieldName, value), @"ArgumentNullException should be thrown."); Assert.AreEqual(nameof(fieldName), exception.ParamName, @"ParamName should be ""fieldName""."); }
public void UpdateTest3() { var expression = new UpdateExpression(new[] { Change.Replace("deleted", new DateTime(2015, 01, 01)), Change.Replace("colors", new [] { "red", "yellow", "blue" }), Change.Replace("version", 1) }, new JsonObject(), new AttributeCollection()); Assert.Equal(@"SET deleted = :v0, colors = :v1, version = :v2", expression.ToString()); }
protected internal override Expression VisitUpdate(UpdateExpression update) { var where = Visit(update.Where); var assigments = Visit(update.Assigments, VisitColumnAssigment); var source = Visit(update.Source); if (source != update.Source || where != update.Where || assigments != update.Assigments) { return(new UpdateExpression(update.Table, update.UseHistoryTable, (SourceWithAliasExpression)source, where, assigments, update.ReturnRowCount)); } return(update); }
public static ExpressionExecuter Build(Expression expression) { return(expression switch { AssignmentExpression assign => new AssignmentExpressionExecuter(assign), BinaryExpression binary => new BinaryExpressionExecuter(binary), UpdateExpression update => new UpdateExpressionExecuter(update), UnaryExpression unary => new UnaryExpressionExecuter(unary), Identifier identifier => new IdentifierExecuter(identifier), CallExpression call => new CallExpressionExecuter(call), Literal literal => new LiteralExecuter(literal), _ => ErrorHelper.ThrowUnknownNode <ExpressionExecuter>(expression), });
public void UpdateExpression_WithDefaultConstructor_ShouldInitializeUpdateCommandsField() { // Arrange const string UpdateCommandsFieldName = "updateCommands"; var updateExpression = new UpdateExpression <ITweet>(); // Act var privateObject = new Microsoft.VisualStudio.TestTools.UnitTesting.PrivateObject(updateExpression); var updateCommandsField = privateObject.GetField(UpdateCommandsFieldName); // Assert Assert.IsNotNull(updateCommandsField, "UpdateCommands field should be correctly initialized."); }
public void UpdateExpression() { var expression = ParseExpression <UpdateExpression>("x++"); var visitor = new AstVisitorEventSource(); UpdateExpression updateExpression = null; Identifier argument = null; visitor.VisitingUpdateExpression += (_, arg) => updateExpression = arg; visitor.VisitedIdentifier += (_, arg) => argument = arg; visitor.Visit(expression); Assert.Same(expression, updateExpression); Assert.Same(expression.Argument, argument); }
public void UpdateTest4() { var expression = new UpdateExpression(new[] { Change.Replace("deleted", new DateTime(2015, 01, 01)), Change.Replace("colors", new [] { "red", "yellow", "blue" }), Change.Remove("deleted"), Change.Add("version", 1), Change.Replace("modified", DateTime.UtcNow) }, new JsonObject(), new AttributeCollection()); Assert.Equal(@"SET deleted = :v0, colors = :v1, modified = :v3 REMOVE deleted ADD version :v2", expression.ToString()); }
public void TestUpldateExpression() { float b = 5; ExecutionEnvironment e = new ExecutionEnvironment(); UpdateExpression add = new UpdateExpression() { IsPrefix = false, Operator = UpdateOperator.Add, Expression = new Identifier() { Variable = "a" } }; UpdateExpression minus = new UpdateExpression() { IsPrefix = false, Operator = UpdateOperator.Minus, Expression = new Identifier() { Variable = "a" } }; //test int int a = 5; e.RegisterValue("a", a); Assert.AreEqual(add.Execute(e).ReturnValue, a++); Assert.AreEqual(e.GetValue("a"), a); Assert.AreEqual(minus.Execute(e).ReturnValue, a--); Assert.AreEqual(e.GetValue("a"), a); //test float b = 5; e.SetValue("a", b); Assert.AreEqual(add.Execute(e).ReturnValue, b++); Assert.AreEqual(e.GetValue("a"), b); Assert.AreEqual(minus.Execute(e).ReturnValue, b--); Assert.AreEqual(e.GetValue("a"), b); //test double double c = 7.1; e.SetValue("a", c); Assert.AreEqual(add.Execute(e).ReturnValue, c++); Assert.AreEqual(e.GetValue("a"), c); Assert.AreEqual(minus.Execute(e).ReturnValue, c--); Assert.AreEqual(e.GetValue("a"), c); //test string string s = "5"; e.SetValue("a", s); Assert.AreEqual(add.Execute(e).Type, CompletionType.Exception); Assert.AreEqual(minus.Execute(e).Type, CompletionType.Exception); }
public void UpdateTest1() { var locked = DateTimeOffset.FromUnixTimeSeconds(1497212690).UtcDateTime; var attributeNames = new JsonObject(); var values = new AttributeCollection(); var expression = new UpdateExpression(new[] { Change.Replace("locked", locked) }, attributeNames, values); Assert.Equal(@"SET locked = :v0", expression.ToString()); Assert.Equal(1497212690L, values.Get(":v0").Value); }
public void UpdateExpression_SetValidStringFieldNameAndAnyValueObject_ShouldRegisterSingleSetCommandInUpdateCommands(string fieldName, object value) { // Arrange var updateExpression = new UpdateExpression <ITweet>(); // Act updateExpression.Set(fieldName, value); // Assert Assert.AreEqual(1, updateExpression.UpdateCommands.Count(), "Number of UpdateCommands should be 1."); var command = updateExpression.UpdateCommands.Single(); Assert.IsNotNull(command, "IUpdateCommand object should not be null."); Assert.AreEqual("Set", command.UpdateVerb, @"UpdateVerb of the IUpdateCommand should be ""Set""."); Assert.AreEqual(fieldName, command.FieldName, @"FieldName of the IUpdateCommand should be """ + fieldName + @"""."); Assert.AreSame(value, command.Value, @"Value of the IUpdateCommand should be """ + value + @"""."); }
protected virtual void Update(IEntityProxy entity, TableAttribute table, IEnumerable <ColumnInfo> columns) { //TODO: do not let an identity field to be dirtied var update = new UpdateExpression(new TableExpression(table)); foreach (var column in columns.Where(c => c.IsIdentity)) { update.AddWhere(column.ToEqualExpression(entity)); } var type = entity.GetType(); foreach (var property in entity.DirtyProperties) { var pi = type.GetProperty(property); var column = columns.First(c => c.DescribesProperty(pi)); update.AddSet(new SetExpression(column.ToColumnExpression(), Expression.Constant(pi.GetValue(entity)))); } ExecuteNonQuery(update); }
public JsValue EvaluateUpdateExpression(UpdateExpression updateExpression) { var value = _engine.EvaluateExpression(updateExpression.Argument); Reference r; switch (updateExpression.Operator) { case UnaryOperator.Increment: r = value as Reference; if (r != null && r.IsStrict() && (r.GetBase().TryCast <EnvironmentRecord>() != null) && (Array.IndexOf(new[] { "eval", "arguments" }, r.GetReferencedName()) != -1)) { throw new JavaScriptException(_engine.SyntaxError); } var oldValue = TypeConverter.ToNumber(_engine.GetValue(value)); var newValue = oldValue + 1; _engine.PutValue(r, newValue); return(updateExpression.Prefix ? newValue : oldValue); case UnaryOperator.Decrement: r = value as Reference; if (r != null && r.IsStrict() && (r.GetBase().TryCast <EnvironmentRecord>() != null) && (Array.IndexOf(new[] { "eval", "arguments" }, r.GetReferencedName()) != -1)) { throw new JavaScriptException(_engine.SyntaxError); } oldValue = TypeConverter.ToNumber(_engine.GetValue(value)); newValue = oldValue - 1; _engine.PutValue(r, newValue); return(updateExpression.Prefix ? newValue : oldValue); default: throw new ArgumentException(); } }
internal override string GetUpdateCommand(UpdateExpression expression) { StringBuilder stringBuilder = new StringBuilder(); stringBuilder.Append($"UPDATE {expression.TableName} SET "); foreach (var setting in expression.SettingList) { stringBuilder.Append($"{setting.ColumnName}={setting.Value}"); if (setting != expression.SettingList.Last()) { stringBuilder.Append(", "); } } if (expression.ConditionBracket != null) { stringBuilder.Append($" {GetConditionCommand(expression.ConditionBracket)}"); } stringBuilder.Append(";"); return(stringBuilder.ToString()); }
public void UpdateExpression_SetValidExpressionForFavesFieldAndValidValue_ShouldRegisterSingleSetCommandInUpdateCommands() { // Arrange var updateExpression = new UpdateExpression <ITweet>(); var value = 123; // Act updateExpression.Set(t => t.Faves, value); // Assert Assert.AreEqual(1, updateExpression.UpdateCommands.Count(), "Number of UpdateCommands should be 1."); var command = updateExpression.UpdateCommands.Single(); Assert.IsNotNull(command, "IUpdateCommand object should not be null."); Assert.AreEqual("Set", command.UpdateVerb, @"UpdateVerb of the IUpdateCommand should be ""Set""."); Assert.AreEqual("Faves", command.FieldName, @"FieldName of the IUpdateCommand should be ""Faves""."); Assert.AreEqual(value, command.Value, @"Value of the IUpdateCommand should be """ + value + @"""."); }
protected internal override Expression VisitUpdate(UpdateExpression update) { var coll = GetColumnCollector(update.Source.KnownAliases); coll.Visit(update.Where); foreach (var ca in update.Assigments) { coll.Visit(ca.Expression); } var source = Visit(update.Source); var where = Visit(update.Where); var assigments = Visit(update.Assigments, VisitColumnAssigment); if (source != update.Source || where != update.Where || assigments != update.Assigments) { return(new UpdateExpression(update.Table, update.UseHistoryTable, (SourceWithAliasExpression)source, where, assigments, update.ReturnRowCount)); } return(update); }
protected override Expression VisitUpdate(UpdateExpression update) { sb.Append("UPDATE "); sb.Append(update.Table.Name.ToString()); sb.Append(" SET"); this.AppendNewLine(Indentation.Inner); for (int i = 0, n = update.Assigments.Count; i < n; i++) { ColumnAssignment assignment= update.Assigments[i]; if (i > 0) { sb.Append(","); this.AppendNewLine(Indentation.Same); } sb.Append(assignment.Column.SqlEscape()); sb.Append(" = "); this.Visit(assignment.Expression); } this.AppendNewLine(Indentation.Outer); sb.Append("FROM "); VisitSource(update.Source); if (update.Where != null) { this.AppendNewLine(Indentation.Same); sb.Append("WHERE "); Visit(update.Where); } return update; }
protected override Expression VisitUpdate(UpdateExpression update) { Visit(update.Where); update.Assigments.NewIfChange(VisitColumnAssigment); var source = Visit(update.Source); var where = Visit(update.Where); var assigments = update.Assigments.NewIfChange(VisitColumnAssigment); if (source != update.Source || where != update.Where || assigments != update.Assigments) return new UpdateExpression(update.Table, (SourceWithAliasExpression)source, where, assigments); return update; }
protected override Expression VisitUpdate(UpdateExpression update) { var source = Visit(update.Source); var where = Visit(update.Where); var assigments = update.Assigments.NewIfChange(c => { var exp = MakeSqlValue(Visit(c.Expression)); if (exp != c.Expression) return new ColumnAssignment(c.Column, exp); return c; }); if (source != update.Source || where != update.Where || assigments != update.Assigments) return new UpdateExpression(update.Table, (SelectExpression)source, where, assigments); return update; }
public virtual void VisitUpdateExpression(UpdateExpression updateExpression) { }
public JsValue EvaluateUpdateExpression(UpdateExpression updateExpression) { var value = _engine.EvaluateExpression(updateExpression.Argument); Reference r; switch (updateExpression.Operator) { case UnaryOperator.Increment: r = value as Reference; if (r != null && r.IsStrict() && (r.GetBase().TryCast<EnvironmentRecord>() != null) && (Array.IndexOf(new[] { "eval", "arguments" }, r.GetReferencedName()) != -1)) { throw new JavaScriptException(_engine.SyntaxError); } var oldValue = TypeConverter.ToNumber(_engine.GetValue(value)); var newValue = oldValue + 1; _engine.PutValue(r, newValue); return updateExpression.Prefix ? newValue : oldValue; case UnaryOperator.Decrement: r = value as Reference; if (r != null && r.IsStrict() && (r.GetBase().TryCast<EnvironmentRecord>() != null) && (Array.IndexOf(new[] { "eval", "arguments" }, r.GetReferencedName()) != -1)) { throw new JavaScriptException(_engine.SyntaxError); } oldValue = TypeConverter.ToNumber(_engine.GetValue(value)); newValue = oldValue - 1; _engine.PutValue(r, newValue); return updateExpression.Prefix ? newValue : oldValue; default: throw new ArgumentException(); } }
protected override void Visit(UpdateExpression node) { Encode(node, Member("operator", node.Operator), Member("argument", node.Argument), Member("prefix", node.Prefix)); }
protected abstract void Visit(UpdateExpression node);
protected virtual void VisitUpdateExpression(UpdateExpression updateExpression) { VisitExpression(updateExpression.Argument); }
public JintUpdateExpression(Engine engine, UpdateExpression expression) : base(engine, expression) { _initialized = false; }
protected override void VisitUpdateExpression(UpdateExpression updateExpression) { }
private void EmitUpdateExpression(UpdateExpression e) { using (var ec = new ExpressionContext(this, e)) { if (e.Prefix) { Write(ec.Token); Emit(e.Argument); } else { Emit(e.Argument); Write(ec.Token); } } }
protected override void VisitUpdateExpression(UpdateExpression updateExpression) => VisitUnaryExpression(updateExpression);
protected internal override void VisitUpdateExpression(UpdateExpression updateExpression) { VisitingUpdateExpression?.Invoke(this, updateExpression); base.VisitUpdateExpression(updateExpression); VisitedUpdateExpression?.Invoke(this, updateExpression); }