//[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;
}
