//[ExpectedException(typeof(InvalidQueryException))] public void InvalidDelete1() { DeleteQuery query = new DeleteQuery("_dummy_table_"); //RenderDelete(query); Assert.Throws <InvalidQueryException>(() => RenderDelete(query)); }
public void test_Delete_Where() { var d = new DeleteQuery() { Table = "TestTable", Where = new Equals { Left = "Column1", Right = 1 } }; Assert.AreEqual("DELETE FROM TestTable WHERE ( Column1 = 1 );", d.ToString()); d.Where = new And { Left = new Equals { Left = "Column1", Right = 1 }, Right = new Equals { Left = "Column2", Right = 1 }, }; Assert.AreEqual("DELETE FROM TestTable WHERE ( ( Column1 = 1 ) AND ( Column2 = 1 ) );", d.ToString()); }
protected void RenderDelete(DeleteQuery query) { string sql = Renderer.RenderDelete(query); Console.WriteLine(sql); RunSql(sql); }
public void GenerateQuery() { var Mappings = new MappingSource(new IMapping[] { new BaseClass1Mapping(), new ConcreteClass1Mapping(), new ConcreteClass2Mapping(), new ConcreteClass3Mapping(), new IInterface1Mapping(), new IInterface2Mapping() }, new MockDatabaseMapping(), new QueryProviderManager(new[] { new SQLServerQueryProvider(Configuration, ObjectPool) }, Logger), Canister.Builder.Bootstrapper.Resolve <ILogger>(), ObjectPool); var TestObject = new DeleteQuery <ConcreteClass1>(Mappings, ObjectPool); var Result = TestObject.GenerateQueries(new ConcreteClass1 { ID = 10 })[0]; Assert.Equal(CommandType.Text, Result.DatabaseCommandType); Assert.Single(Result.Parameters); Assert.Equal(10, Result.Parameters[0].InternalValue); Assert.Equal("ID", Result.Parameters[0].ID); Assert.Equal("DELETE FROM [dbo].[IInterface1_] WHERE [dbo].[IInterface1_].[ID_]=@ID;\r\n", Result.QueryString); Assert.Equal(QueryType.Delete, Result.QueryType); }
private void btnResetQuery_Click(object sender, EventArgs e) { foreach (TableInDiagram t in tablesInForm) { for (int i = 0; i < t.Fields.Count; i++) { Field f = t.Fields[i]; f.Brush = Brushes.Black; t.Fields[i] = f; } } mainSelectQuery = new SelectQuery(); mainInsertQuery = new InsertQuery(); mainUpdateQuery = new UpdateQuery(); mainDeleteQuery = new DeleteQuery(); rtbQueryConstructor.Text = ""; dgvAlias.Rows.Clear(); dgvJoin.Rows.Clear(); pbDiagram.Invalidate(); dgvInsertFields.Rows.Clear(); rtbInsertSelectQuery.Text = "Введи SELECT запрос для команды INSERT"; dgvUpdateFields.Rows.Clear(); dgvDeleteFields.Rows.Clear(); rtbDeleteWhere.Text = ""; tbDeleteLimit.Text = ""; cbDeleteLow.Checked = false; cbDeleteQuick.Checked = false; }
private IExecuteItemResponse ExecuteQuery(DeleteQuery deleteQuery) { var response = new ExecuteItemResponse() { Success = false, RowsAffected = 0, ErrorMessage = string.Empty }; if (!TryParsePrimaryValue(deleteQuery, out var primaryValue)) { response.ErrorMessage = "Cannot find primary value from filter"; return(response); } if (!TryGetEntity(deleteQuery.RootSchemaName, primaryValue, out var entity, out var errorMessage)) { response.ErrorMessage = errorMessage; return(response); } try { response.Success = entity.Delete(); response.RowsAffected = 1; } catch (Exception e) { response.ErrorMessage = e.Message; } return(response); }
public void DeleteQueryTest(Common.Enums.FhirVersion fhirVersion, string resourceName, string resourceId) { //Setup var IOperationOutcomeSupportMock = IOperationOutcomeSupport_MockFactory.Get(); var IFhirResourceNameSupportMock = IFhirResourceNameSupport_MockFactory.Get(resourceName); var IFhirResourceIdSupportMock = IFhirResourceIdSupport_MockFactory.Get(resourceId); FhirUriFactory FhirUriFactory = GetFhirUriFactory(resourceName); ValidateQueryService ValidateQueryService = new ValidateQueryService(IOperationOutcomeSupportMock.Object, IFhirResourceNameSupportMock.Object, IFhirResourceIdSupportMock.Object, FhirUriFactory); var DeleteQuery = new DeleteQuery( HttpVerb.GET, fhirVersion, new Uri($"{TestData.BaseUrlServer}/{resourceName}/{resourceId}"), new Dictionary <string, Microsoft.Extensions.Primitives.StringValues>(), new Dictionary <string, Microsoft.Extensions.Primitives.StringValues>(), resourceName, resourceId); //Act bool Result = ValidateQueryService.IsValid(DeleteQuery, out Common.FhirTools.FhirResource? IsNotValidOperationOutCome); //Assert Assert.True(Result); Assert.Null(IsNotValidOperationOutCome); }
public void Delete() { DeleteQuery query = new DeleteQuery("products"); query.WhereClause.Terms.Add(WhereTerm.CreateCompare(SqlExpression.Field("productId"), SqlExpression.Number(999), CompareOperator.Equal)); RenderDelete(query); }
public void delete(ActiveRecord item) { DeleteQuery query = new DeleteQuery(item.GetType()); query.addWhere("id", item.id.ToString()); Console.WriteLine(query.build()); query.exec(); }
public DeleteStudent(string sn, string fn, string ln, string em, string ph, string a1, string a2, string ci, string co, short lv, string cs, string username) { dq = new DeleteQuery(); uhq = new UpdateHistoryQuery(); dq.delete(int.Parse(sn)); uhq.update(username, 3, int.Parse(sn), fn, ln, em, ph, a1, a2, ci, co, lv, cs); }
public void ToString_NoTableName() { //Arrange DeleteQuery q = new DeleteQuery(); //Act q.ToString(); }
public Property Ctor_populates_properties(DeleteQuery query, string schema) { DeleteMigrationOperation operation = new(query, schema); return(operation.Query.Equals(query).Label("Query") .And(operation.Schema == schema).Label("Schema") .And(operation.IsDestructiveChange).Label(nameof(operation.IsDestructiveChange))); }
private void Dispose(bool disposing) { AccessSemaphore?.Dispose(); InsertQuery?.Dispose(); UpdateQuery?.Dispose(); DeleteQuery?.Dispose(); SelectHashQuery?.Dispose(); }
public void test_Delete() { var d = new DeleteQuery() { Table = "TestTable" }; Assert.AreEqual("DELETE FROM TestTable;", d.ToString()); }
public async Task <ActionResult> Delete(int id) { var query = new DeleteQuery { Id = id }; await _mediator.Send(query); return(NoContent()); }
/// <summary> /// Render the whole DELETE statement in ANSI SQL standard /// </summary> /// <param name="query"></param> /// <returns>The rendered SQL statement</returns> public virtual string DeleteStatement(DeleteQuery query) { query.Validate(); StringBuilder builder = new StringBuilder(); Delete(builder, query.FromObject, query.FromType, query.Schema); Where(builder, query.WhereClause); WhereClause(builder, query.WhereClause); return(builder.ToString()); }
public void DeleteConnection(int id) { DeleteQuery query = QueryBuilder.Delete(TABLE); ((DeleteQuery)query).AddWhereFragment(id); var cmd = db.GetCommand(query.Build()); cmd.ExecuteNonQuery(); }
/// <summary> /// Render the whole DELETE statement in ANSI SQL standard /// </summary> /// <param name="query"></param> /// <returns>The rendered SQL statement</returns> public virtual string DeleteStatement(DeleteQuery query) { query.Validate(); StringBuilder builder = new StringBuilder(); Delete(builder, query.TableName); Where(builder, query.WhereClause); WhereClause(builder, query.WhereClause); return(builder.ToString()); }
private void OpenDeleteConstructor() { if (!isOpenConstructior) { isOpenConstructior = true; mainDeleteQuery = new DeleteQuery(); } isOpenDeleteInConstructor = true; mainDeleteQuery = new DeleteQuery(); ResizeElements(); }
public void ToString_EmptyTableName() { //Arrange DeleteQuery q = new DeleteQuery() { TableName = "" }; //Act q.ToString(); }
public override object VisitSingleDeleteStatement([NotNull] PostgresParser.SingleDeleteStatementContext context) { var res = new DeleteQuery(); res.DeleteTable = (TableRef)Visit(context.tableName()); if (context.expression() != null) { res.Where = ExpressionToCnfWhere(context.expression()); } return(res); }
/// <summary> /// Performs a delete /// </summary> /// <param name="target">Entity to be deleted</param> /// <param name="deleteQuery">SQL delete query</param> public void Delete(object target, DeleteQuery deleteQuery) { deleteQuery.Target = target; using (var dbCommand = deleteQuery.GetCommand()) { // log command deleteQuery.DataContext.WriteLog(dbCommand.Command); int rowsCount = dbCommand.Command.ExecuteNonQuery(); dbCommand.Commit(); } }
public void GenerateDeleteQuery() { var entity = new FakeEntity(); var query = new DeleteQuery <FakeEntity>(entity); var actual = query.Token.Value; var expected = "DELETE FROM schema.table " + "WHERE (id = @id AND name = @name AND valid = @valid)"; Assert.AreEqual(expected, actual); }
public void VisitDeleteQuery(DeleteQuery deleteQuery, Expression <Func <CollectVariableVisitor, bool> > visitorExpectation, Expression <Func <DeleteQuery, bool> > queryAfterVisitExpectation) { // Arrange CollectVariableVisitor _sut = new(); // Act _sut.Visit(deleteQuery); // Assert _sut.Should() .Match(visitorExpectation); deleteQuery.Should().Match(queryAfterVisitExpectation); }
public async Task DeletePostOrThread(ulong theadNumber) { uint currentTimestamp = Utility.GetNewYorkTimestamp(DateTimeOffset.Now); using (var rentedConnection = await ConnectionPool.RentConnectionAsync()) { DeleteQuery.Connection = rentedConnection; DeleteQuery.Parameters["@timestamp_expired"].Value = currentTimestamp; DeleteQuery.Parameters["@thread_no"].Value = theadNumber; await DeleteQuery.ExecuteNonQueryAsync(); } }
public void ToString_Delete() { //Arrange DeleteQuery q = new DeleteQuery() { TableName = "table" }; string expected = "delete from [table] "; //Act string res = q.ToString(); //Assert Assert.AreEqual(expected, res); }
public Property Delete(NonWhiteSpaceString providerName, DeleteQuery deleteQuery, string schema) { // Arrange Lazy <MigrationBuilder> deleteQueryLazy = new(() => { MigrationBuilder builder = new(providerName.Item); return(builder.Delete(deleteQuery, schema)); }); // Act return(Prop.Throws <ArgumentNullException, MigrationBuilder>(deleteQueryLazy).Label("ArgumentNullCases") .When(deleteQuery is null) .Or(deleteQueryLazy.Value.Operations.Once(op => op is DeleteMigrationOperation)).When(deleteQuery is not null) .Label("Builder must have the corresponding operation")); }
public int Delete <T>(SqlCriteria aCriteria) where T : class, new() { DeleteQuery <T> query = QueryFactory.CreateDeleteQuery <T>(); query.SetCriteria(aCriteria); int result = 0; IntBinder binder = new IntBinder(); binder.OnBind = delegate(IntResult aResult) { result = aResult.value; }; Connetion.execute <IntResult>(query, binder); return(result); }
public static DeleteQuery Parse(String input) { List<string> keywords = Constants.KEYWORDS.ToList(); keywords.ForEach(x => input = input.Replace(x.ToLower(), x)); List<string> values = input.Trim().Split(keywords.ToArray(), StringSplitOptions.RemoveEmptyEntries). ToList(); values.RemoveAll(x => { return String.IsNullOrWhiteSpace(x); }); DeleteQuery query = new DeleteQuery(); query.Table = values[0].Trim(); if (values.Count > 1) { query.Conditions = GetColumnValues(values[1]); } return query; }
public void SqlServerDeleteQuery_ShouldGenQuery() { // Arrange var command = new System.Data.SqlClient.SqlCommand(); var where = new WhereBuilder <Person>(command, p => p.ID == 5, false); IQuery query = new DeleteQuery("dbo.People", where.ToString()); // Act string queryText = query.Generate(); // Assert Assert.IsNotNull(queryText); Assert.IsTrue(queryText.Contains("DELETE FROM dbo.People")); Assert.IsTrue(queryText.Contains("WHERE ([ID] = @P0)")); Assert.AreEqual(command.Parameters["@P0"].Value, 5); }
private static BaseQuery BuildDeleteQuery(ITrackedModel <BaseModel> trackedModel) { var rootSchemaName = trackedModel.Model.GetSchemaName(); var deleteQuery = new DeleteQuery() { RootSchemaName = rootSchemaName, Filters = new Filters() { FilterType = FilterType.FilterGroup, Items = new Dictionary <string, Filter>() { { "PrimaryFilter", GeneratePrimaryFilter(trackedModel) } }, } }; return(deleteQuery); }
bool DeleteObject(DeleteQuery deleteQuery) { // TODO: 11/15/15 (Karan) It might be alright to say 'true'. if (!idMap.ContainsKey (deleteQuery.objectId)) return false; AskObject askObject = idMap [deleteQuery.objectId]; try { int helpvalue; if (KDTree.TryFindValueAt (askObject.position, out helpvalue) == false) return false; KDTree.RemoveAt (askObject.position); idMap.Remove (deleteQuery.objectId); } catch (Exception e) { Console.WriteLine (e.Message); return false; } return true; }