public ObjectProjector(SqlQueryProvider queryProvider, DataAccessModel dataAccessModel, SqlDatabaseContext sqlDatabaseContext, SqlQueryFormatResult formatResult)
{
this.QueryProvider = queryProvider;
this.DataAccessModel = dataAccessModel;
this.SqlDatabaseContext = sqlDatabaseContext;
this.formatResult = formatResult;
}
private static void CommitNewPhase1(SqlDatabaseContext sqlDatabaseContext, HashSet <DatabaseTransactionContextAcquisition> acquisitions, IObjectsByIdCache cache, TransactionContext transactionContext, Dictionary <TypeAndTransactionalCommandsContext, InsertResults> insertResultsByType, Dictionary <TypeAndTransactionalCommandsContext, IReadOnlyList <DataAccessObject> > fixups)
{
var acquisition = transactionContext.AcquirePersistenceTransactionContext(sqlDatabaseContext);
acquisitions.Add(acquisition);
var persistenceTransactionContext = acquisition.SqlDatabaseCommandsContext;
foreach (var j in cache.GetNewObjects())
{
var key = new TypeAndTransactionalCommandsContext(j.Key, persistenceTransactionContext);
var currentInsertResults = persistenceTransactionContext.Insert(j.Key, j.Value.Values);
if (currentInsertResults.ToRetry.Count > 0)
{
insertResultsByType[key] = currentInsertResults;
}
if (currentInsertResults.ToFixUp.Count > 0)
{
fixups[key] = currentInsertResults.ToFixUp;
}
}
}
public void Update(Guid id, Todo todo)
{
Todo UplTodo;
try
{
using (var context = new SqlDatabaseContext(SqlDatabaseContext.ops.dbOptions))
{
UplTodo = context.todos.Find(id);
}
using (var context = new SqlDatabaseContext(SqlDatabaseContext.ops.dbOptions))
{
if (UplTodo != null)
{
todo.Id = id;
context.todos.Update(todo);
context.SaveChanges();
}
}
}
catch (Exception e)
{
Console.WriteLine(e.Message);
throw new Exception("SQL Update error");
}
}
public ObjectProjector(SqlQueryProvider queryProvider, DataAccessModel dataAccessModel, SqlDatabaseContext sqlDatabaseContext, SqlQueryFormatResult formatResult)
{
this.QueryProvider = queryProvider;
this.DataAccessModel = dataAccessModel;
this.SqlDatabaseContext = sqlDatabaseContext;
this.formatResult = formatResult;
}
public void DeleteById(Guid id)
{
Todo DelTodo;
try
{
using (var context = new SqlDatabaseContext(SqlDatabaseContext.ops.dbOptions))
{
DelTodo = context.todos.Find(id);
}
using (var context = new SqlDatabaseContext(SqlDatabaseContext.ops.dbOptions))
{
if (DelTodo != null)
{
context.todos.Remove(DelTodo);
context.SaveChanges();
}
}
}
catch (Exception e)
{
Console.WriteLine(e.Message);
throw new Exception("SQL Delete error");
}
}
public static Expression Optimize(DataAccessModel dataAccessModel, SqlDatabaseContext sqlDatabaseContext, Expression expression)
{
expression = SqlGroupByCollator.Collate(expression);
expression = SqlAggregateSubqueryRewriter.Rewrite(expression);
expression = SqlUnusedColumnRemover.Remove(expression);
expression = SqlRedundantColumnRemover.Remove(expression);
expression = SqlRedundantSubqueryRemover.Remove(expression);
expression = SqlFunctionCoalescer.Coalesce(expression);
expression = SqlExistsSubqueryOptimizer.Optimize(expression);
expression = SqlRedundantBinaryExpressionsRemover.Remove(expression);
expression = SqlCrossJoinRewriter.Rewrite(expression);
expression = SqlConditionalEliminator.Eliminate(expression);
expression = SqlExpressionCollectionOperationsExpander.Expand(expression);
expression = SqlSubCollectionOrderByAmender.Amend(dataAccessModel.TypeDescriptorProvider, expression);
expression = SqlOrderByRewriter.Rewrite(expression);
var rewritten = SqlCrossApplyRewriter.Rewrite(expression);
if (rewritten != expression)
{
expression = rewritten;
expression = SqlUnusedColumnRemover.Remove(expression);
expression = SqlRedundantColumnRemover.Remove(expression);
expression = SqlRedundantSubqueryRemover.Remove(expression);
expression = SqlOrderByRewriter.Rewrite(expression);
}
expression = SqlDeleteNormalizer.Normalize(expression);
expression = SqlUpdateNormalizer.Normalize(expression);
expression = SqlInsertIntoNormalizer.Normalize(expression);
return(expression);
}
public static LambdaExpression Build(DataAccessModel dataAccessModel, SqlDatabaseContext sqlDatabaseContext, SqlQueryProvider queryProvider, Expression expression, ProjectionBuilderScope scope)
{
var projectionBuilder = new ProjectionBuilder(dataAccessModel, sqlDatabaseContext, queryProvider, scope);
var body = projectionBuilder.Visit(expression);
return(Expression.Lambda(body, projectionBuilder.objectProjector, projectionBuilder.dataReader, projectionBuilder.versionParameter, projectionBuilder.dynamicParameters));
}
/// <summary>
/// Builds the lambda expression that will perform the projection
/// </summary>
/// <param name="dataAccessModel">The related data access model</param>
/// <param name="sqlDatabaseContext">The related <see cref="SqlDatabaseContext"/></param>
/// <param name="expression">
/// The expression that performs the projection (can be any expression but usually is a MemberInit expression)
/// </param>
/// <returns>
/// A <see cref="LambdaExpression"/> that takes two parameters: an <see cref="ObjectProjector"/>
/// and an <see cref="IDataReader"/>. The lambda expression will construct a single
/// object for return from the current row in the given <see cref="IDataReader"/>.
/// </returns>
public static LambdaExpression Build(DataAccessModel dataAccessModel, SqlDatabaseContext sqlDatabaseContext, Expression expression, IEnumerable<string> columns)
{
var projectionBuilder = new ProjectionBuilder(dataAccessModel, sqlDatabaseContext, columns);
var body = projectionBuilder.Visit(expression);
return Expression.Lambda(body, projectionBuilder.objectProjector, projectionBuilder.dataReader, projectionBuilder.dynamicParameters);
}
private static void CommitUpdated(SqlDatabaseContext sqlDatabaseContext, IObjectsByIdCache cache, HashSet <DatabaseTransactionContextAcquisition> acquisitions, TransactionContext transactionContext)
{
var acquisition = transactionContext.AcquirePersistenceTransactionContext(sqlDatabaseContext);
acquisitions.Add(acquisition);
acquisition.SqlDatabaseCommandsContext.Update(cache.Type, cache.GetObjectsById());
acquisition.SqlDatabaseCommandsContext.Update(cache.Type, cache.GetObjectsByPredicate());
}
/// <summary>
/// Builds the lambda expression that will perform the projection
/// </summary>
/// <param name="dataAccessModel">The related data access model</param>
/// <param name="sqlDatabaseContext">The related <see cref="SqlDatabaseContext"/></param>
/// <param name="expression">
/// The expression that performs the projection (can be any expression but usually is a MemberInit expression)
/// </param>
/// <returns>
/// A <see cref="LambdaExpression"/> that takes two parameters: an <see cref="ObjectProjector"/>
/// and an <see cref="IDataReader"/>. The lambda expression will construct a single
/// object for return from the current row in the given <see cref="IDataReader"/>.
/// </returns>
public static LambdaExpression Build(DataAccessModel dataAccessModel, SqlDatabaseContext sqlDatabaseContext, Expression expression, IEnumerable <string> columns)
{
var projectionBuilder = new ProjectionBuilder(dataAccessModel, sqlDatabaseContext, columns);
var body = projectionBuilder.Visit(expression);
return(Expression.Lambda(body, projectionBuilder.objectProjector, projectionBuilder.dataReader, projectionBuilder.dynamicParameters));
}
public SqlTransactionalCommandsContext GetCurrentDatabaseTransactionContext(SqlDatabaseContext sqlDatabaseContext)
{
if (this.Transaction == null)
{
throw new InvalidOperationException("Transaction required");
}
return(this.AcquirePersistenceTransactionContext(sqlDatabaseContext).SqlDatabaseCommandsContext);
}
public ObjectProjector(IQueryProvider provider, DataAccessModel dataAccessModel, SqlQueryFormatResult formatResult, SqlDatabaseContext sqlDatabaseContext, IRelatedDataAccessObjectContext relatedDataAccessObjectContext, SelectFirstType selectFirstType, SqlAggregateType?sqlAggregateType, bool isDefaultIfEmpty)
{
this.sqlAggregateType = sqlAggregateType;
this.isDefaultIfEmpty = isDefaultIfEmpty;
this.provider = provider;
this.DataAccessModel = dataAccessModel;
this.FormatResult = formatResult;
this.SqlDatabaseContext = sqlDatabaseContext;
this.selectFirstType = selectFirstType;
this.relatedDataAccessObjectContext = relatedDataAccessObjectContext;
}
private void frmDatabase_Load(object sender, EventArgs e)
{
var sql = new SqlDatabaseContext(Common.connection);
cmbDatabase.DataSource = sql.GetAllDatatable();
isEndLoad = true;
if (!string.IsNullOrWhiteSpace(Common.InfoServer.Database))
{
cmbDatabase.Text = Common.InfoServer.Database;
}
}
public SqlDatabaseTests()
{
var databaseName = "inMemoryDatabase";
database = new SqlDatabaseInMemory(databaseName);
localDatabaseContext = new SqlDatabaseContext(
new DbContextOptionsBuilder <SqlDatabaseContext>().
UseInMemoryDatabase(databaseName).
Options
);
}
public void DatabaseQueryBuilder_Detach_AddQueryTest()
{
var provider = new Mock<IConnectionProvider>();
var settings = new Mock<ISettings>();
var context = new SqlDatabaseContext(provider.Object, settings.Object, new InterceptorCollection());
// Act
var queryBuilder = new DatabaseQueryBuilder(context, new QueryPartsContainer());
queryBuilder.Detach();
Assert.IsTrue(context.QueryStore.Any());
}
private void btnLoad_Click(object sender, EventArgs e)
{
SqlConnectionStringBuilder buid = new SqlConnectionStringBuilder(Common.connection.ConnectionString);
txtDatabase.Text = buid.InitialCatalog;
fpnCode.Controls.Clear();
var lstTable = new SqlDatabaseContext(Common.connection).GetTable();
lstUc = new List <ucBussiness>();
foreach (var item in lstTable)
{
FlowLayoutPanel pn = new FlowLayoutPanel();
fpnCode.Controls.Add(pn);
pn.Width = fpnCode.Width;
pn.Height = 39;
var lbl = new Label()
{
Text = Common.Setting.GetNameTable(item)
};
toolTip1.SetToolTip(lbl, Common.Setting.GetNameTable(item));
lbl.Click += Lbl_Click;
lbl.BackColor = Color.Thistle;
pn.Controls.Add(lbl);
if (cbBus.Checked)
{
var uc = new ucBussiness(new Bus(item, Common.connection, Common.Setting));
uc.Visible = true;
lstUc.Add(uc);
pn.Controls.Add(uc);
}
if (cbDal.Checked)
{
var uc = new ucBussiness(new Dal(item, Common.connection, Common.Setting));
lstUc.Add(uc);
pn.Controls.Add(uc);
}
if (cbDto.Checked)
{
var uc = new ucBussiness(new Dto(item, Common.connection, Common.Setting));
lstUc.Add(uc);
pn.Controls.Add(uc);
}
if (cbProc.Checked)
{
var uc = new ucBussiness(new Proc(item, Common.connection, Common.Setting));
lstUc.Add(uc);
pn.Controls.Add(uc);
}
}
btnRun.Visible = true;
}
private ProjectionBuilder(DataAccessModel dataAccessModel, SqlDatabaseContext sqlDatabaseContext, IEnumerable<string> columns)
{
var x = 0;
this.dataAccessModel = dataAccessModel;
this.sqlDatabaseContext = sqlDatabaseContext;
this.columnIndexes = columns.ToDictionary(c => c, c => x++);
this.dataReader = Expression.Parameter(typeof(IDataReader), "dataReader");
this.objectProjector = Expression.Parameter(typeof(ObjectProjector), "objectProjector");
this.dynamicParameters = Expression.Parameter(typeof (object[]), "dynamicParameters");
}
protected SqlTransactionalCommandsContext(SqlDatabaseContext sqlDatabaseContext, IDbConnection dbConnection, Transaction transaction)
{
this.DbConnection = dbConnection;
this.Transaction = transaction;
this.SqlDatabaseContext = sqlDatabaseContext;
this.DataAccessModel = sqlDatabaseContext.DataAccessModel;
if (transaction != null)
{
this.dbTransaction = dbConnection.BeginTransaction(ConvertIsolationLevel(transaction.IsolationLevel));
}
}
private ProjectionBuilder(DataAccessModel dataAccessModel, SqlDatabaseContext sqlDatabaseContext, IEnumerable <string> columns)
{
var x = 0;
this.dataAccessModel = dataAccessModel;
this.sqlDatabaseContext = sqlDatabaseContext;
this.columnIndexes = columns.ToDictionary(c => c, c => x++);
this.dataReader = Expression.Parameter(typeof(IDataReader), "dataReader");
this.objectProjector = Expression.Parameter(typeof(ObjectProjector), "objectProjector");
this.dynamicParameters = Expression.Parameter(typeof(object[]), "dynamicParameters");
}
private ProjectionBuilder(DataAccessModel dataAccessModel, SqlDatabaseContext sqlDatabaseContext, SqlQueryProvider queryProvider, ProjectionBuilderScope scope)
{
this.dataAccessModel = dataAccessModel;
this.sqlDatabaseContext = sqlDatabaseContext;
this.queryProvider = queryProvider;
this.scope = scope;
this.dataReader = Expression.Parameter(typeof(IDataReader), "dataReader");
this.objectProjector = Expression.Parameter(typeof(ObjectProjector), "objectProjector");
this.dynamicParameters = Expression.Parameter(typeof(object[]), "dynamicParameters");
this.versionParameter = Expression.Parameter(typeof(int), "version");
}
private ProjectionBuilder(DataAccessModel dataAccessModel, SqlDatabaseContext sqlDatabaseContext, SqlQueryProvider queryProvider, ProjectionBuilderScope scope)
{
this.dataAccessModel = dataAccessModel;
this.sqlDatabaseContext = sqlDatabaseContext;
this.queryProvider = queryProvider;
this.scope = scope;
this.dataReader = Expression.Parameter(typeof(IDataReader), "dataReader");
this.objectProjector = Expression.Parameter(typeof(ObjectProjector), "objectProjector");
this.dynamicParameters = Expression.Parameter(typeof (object[]), "dynamicParameters");
this.versionParameter = Expression.Parameter(typeof(int), "version");
this.filterParameter = Expression.Parameter(typeof(Func<DataAccessObject, DataAccessObject>), "filter");
}
public void DatabaseQueryBuilder_Detach_SetDBTest()
{
var provider = new Mock<IConnectionProvider>();
provider.SetupGet(exp => exp.Database).Returns(() => "DatabaseName");
var settings = new Mock<ISettings>();
var context = new SqlDatabaseContext(provider.Object, settings.Object, new InterceptorCollection());
// Act
var queryBuilder = new DatabaseQueryBuilder(context, new QueryPartsContainer());
queryBuilder.Detach();
var part = queryBuilder.QueryParts.FirstOrDefault(p => p.OperationType == OperationType.DetachDatabase);
Assert.AreEqual("DatabaseName", part.Compile());
}
public override void Backup(SqlDatabaseContext sqlDatabaseContext)
{
if (!(sqlDatabaseContext is SqliteOfficialSqlDatabaseContext))
{
throw new ArgumentException($"Needs to be a {nameof(SqliteOfficialSqlDatabaseContext)}", nameof(sqlDatabaseContext));
}
using (var connection = this.OpenConnection())
{
using (var otherConnection = sqlDatabaseContext.OpenConnection())
{
this.GetSqliteConnection(connection).BackupDatabase(this.GetSqliteConnection(otherConnection), "main", "main", -1, null, 1000);
}
}
}
public override async Task BackupAsync(SqlDatabaseContext sqlDatabaseContext, CancellationToken cancellationToken)
{
if (!(sqlDatabaseContext is SqliteOfficialSqlDatabaseContext))
{
throw new ArgumentException($"Needs to be a {nameof(SqliteOfficialSqlDatabaseContext)}", nameof(sqlDatabaseContext));
}
using (var connection = (await OpenConnectionAsync(cancellationToken).ConfigureAwait(false)))
{
using (var otherConnection = (await sqlDatabaseContext.OpenConnectionAsync(cancellationToken).ConfigureAwait(false)))
{
GetSqliteConnection(connection).BackupDatabase(GetSqliteConnection(otherConnection), "main", "main", -1, null, 1000);
}
}
}
public List <Todo> GetAll()
{
List <Todo> allTodos;
var context = new SqlDatabaseContext(SqlDatabaseContext.ops.dbOptions);
try
{
allTodos = context.todos.ToList();
}
catch (Exception e)
{
Console.WriteLine(e.Message);
throw new Exception("SQL getAll error");
}
return(allTodos);
}
public static LambdaExpression Build(DataAccessModel dataAccessModel, SqlDatabaseContext sqlDatabaseContext, SqlQueryProvider queryProvider, Expression expression, ProjectionBuilderScope scope, out Expression<Func<IDataReader, object[]>> rootKeys)
{
var projectionBuilder = new ProjectionBuilder(dataAccessModel, sqlDatabaseContext, queryProvider, scope);
var body = projectionBuilder.Visit(expression);
if (projectionBuilder.scope.rootPrimaryKeys.Count > 0)
{
rootKeys = Expression.Lambda<Func<IDataReader, object[]>>(Expression.NewArrayInit(typeof(object), projectionBuilder.scope.rootPrimaryKeys), projectionBuilder.dataReader);
}
else
{
rootKeys = null;
}
return Expression.Lambda(body, projectionBuilder.objectProjector, projectionBuilder.dataReader, projectionBuilder.versionParameter, projectionBuilder.dynamicParameters, projectionBuilder.filterParameter);
}
public static LambdaExpression Build(DataAccessModel dataAccessModel, SqlDatabaseContext sqlDatabaseContext, SqlQueryProvider queryProvider, Expression expression, ProjectionBuilderScope scope, out Expression <Func <IDataReader, object[]> > rootKeys)
{
var projectionBuilder = new ProjectionBuilder(dataAccessModel, sqlDatabaseContext, queryProvider, scope);
var body = projectionBuilder.Visit(expression);
if (projectionBuilder.scope.rootPrimaryKeys.Count > 0)
{
rootKeys = Expression.Lambda <Func <IDataReader, object[]> >(Expression.NewArrayInit(typeof(object), projectionBuilder.scope.rootPrimaryKeys), projectionBuilder.dataReader);
}
else
{
rootKeys = null;
}
return(Expression.Lambda(typeof(ObjectReaderFunc <>).MakeGenericType(body.Type), body, projectionBuilder.objectProjector, projectionBuilder.dataReader, projectionBuilder.versionParameter, projectionBuilder.dynamicParameters));
}
private static void CommitUpdated <T>(SqlDatabaseContext sqlDatabaseContext, ObjectsByIdCache <T> cache, HashSet <DatabaseTransactionContextAcquisition> acquisitions, TransactionContext transactionContext)
{
var acquisition = transactionContext.AcquirePersistenceTransactionContext(sqlDatabaseContext);
acquisitions.Add(acquisition);
foreach (var j in cache.objectsByIdCache)
{
acquisition.SqlDatabaseCommandsContext.Update(j.Key, j.Value.Values);
}
if (cache.objectsByIdCacheComposite != null)
{
foreach (var j in cache.objectsByIdCacheComposite)
{
acquisition.SqlDatabaseCommandsContext.Update(j.Key, j.Value.Values);
}
}
}
public void Constructor()
{
//---------------Set up test pack-------------------
var connectionStringProvider = Substitute.For <IConnectionStringProvider>();
var databaseConnectionProvider = Substitute.For <IDatabaseConnectionProvider>();
var databaseTransactionProvider = Substitute.For <IDatabaseTransactionProvider>();
var sqlStatementBuildProvider = Substitute.For <IStatementBuildProvider>();
var dataModelPopulateProvider = Substitute.For <IDataModelPopulateProvider>();
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
var databaseContext = new SqlDatabaseContext(connectionStringProvider,
databaseConnectionProvider,
databaseTransactionProvider,
sqlStatementBuildProvider,
dataModelPopulateProvider);
//---------------Test Result -----------------------
databaseContext.Should().NotBeNull();
}
public void UpdateDatetime(Guid id, DateTime date)
{
try
{
using (var context = new SqlDatabaseContext(SqlDatabaseContext.ops.dbOptions))
{
Todo tempTodo = new Todo {
Id = id
};
tempTodo.Date = date;
context.Entry(tempTodo).Property("Date").IsModified = true;
context.SaveChanges();
}
}
catch (Exception e)
{
Console.WriteLine(e.Message);
throw new Exception("SQL UpdateDatetime error");
}
}
public void DatabaseQueryBuilder_Detach_SetMasterDBTest()
{
var db = string.Empty;
var provider = new Mock<IConnectionProvider>();
provider.SetupGet(exp => exp.Database).Returns(() => "DatabaseName");
provider.SetupSet(exp => exp.Database).Callback(s => db = s);
var settings = new Mock<ISettings>();
var context = new SqlDatabaseContext(provider.Object, settings.Object, new InterceptorCollection());
// Act
var queryBuilder = new DatabaseQueryBuilder(context, new QueryPartsContainer());
queryBuilder.Detach();
foreach (var part in queryBuilder.QueryParts)
{
part.Compile();
}
Assert.AreEqual(db, "Master");
}
public void Insert(Guid id, string task, string title, DateTime date)
{
Todo NewTodo = new Todo
{
Id = id,
Task = task,
Title = title,
Date = date
};
using (var context = new SqlDatabaseContext(SqlDatabaseContext.ops.dbOptions))
{
try
{
context.todos.Add(NewTodo);
context.SaveChanges();
}
catch (Exception e)
{
Console.WriteLine(e.Message);
throw new Exception("SQL insert error");
}
}
}
private IEnumerable<Sysobjects> GetTables(SqlDatabaseContext context)
{
return context.Select<Sysobjects>(so => so.Type == "U");
}
public PostgresDotConnectSqlTransactionalCommandsContext(SqlDatabaseContext sqlDatabaseContext, IDbConnection connection, TransactionContext transactionContext)
: base(sqlDatabaseContext, connection, transactionContext)
{
}
public SqlQueryProvider(DataAccessModel dataAccessModel, SqlDatabaseContext sqlDatabaseContext)
{
this.DataAccessModel = dataAccessModel;
this.SqlDatabaseContext = sqlDatabaseContext;
}
public DataAccessObjectDataContext(DataAccessModel dataAccessModel, SqlDatabaseContext sqlDatabaseContext)
{
this.DataAccessModel = dataAccessModel;
this.SqlDatabaseContext = sqlDatabaseContext;
}
public DatabaseTransactionContextAcquisition(TransactionContext transactionContext, SqlDatabaseContext sqlDatabaseContext, SqlTransactionalCommandsContext sqlDatabaseCommandsContext)
{
this.TransactionContext = transactionContext;
this.SqlDatabaseContext = sqlDatabaseContext;
this.SqlDatabaseCommandsContext = sqlDatabaseCommandsContext;
}
public ComplexDataAccessObjectProjector(SqlQueryProvider provider, DataAccessModel dataAccessModel, SqlDatabaseContext sqlDatabaseContext, SqlQueryFormatResult formatResult, object[] placeholderValues, Func <ObjectProjector, IDataReader, int, object[], Func <DataAccessObject, DataAccessObject>, U> objectReader, Func <IDataReader, object[]> keysGenerator)
: base(provider, dataAccessModel, sqlDatabaseContext, formatResult, placeholderValues, objectReader)
{
this.keysGenerator = keysGenerator;
}
public DataAccessObjectProjector(SqlQueryProvider provider, DataAccessModel dataAccessModel, SqlDatabaseContext sqlDatabaseContext, SqlQueryFormatResult formatResult, object[] placeholderValues, Func <ObjectProjector, IDataReader, int, object[], U> objectReader)
: base(provider, dataAccessModel, sqlDatabaseContext, formatResult, placeholderValues, objectReader)
{
}
public void DatabaseQueryBuilder_DropTest()
{
var provider = new Mock<IConnectionProvider>();
var settings = new Mock<ISettings>();
var context = new SqlDatabaseContext(provider.Object, settings.Object, new InterceptorCollection());
// Act
var queryBuilder = new DatabaseQueryBuilder(context, new QueryPartsContainer());
queryBuilder.Drop();
Assert.IsTrue(queryBuilder.QueryParts.Count() == 2);
}
