public HeadOffice Handle(TransferCashToAtmCommand request)
{
var headOfficeRepository = serviceProvider.GetService <IHeadOfficeRepository>();
var headOffice = headOfficeRepository.GetById(request.HeadOfficeId);
using (var scope = new DatabaseScope(serviceProvider))
{
scope.Execute(() => {
try
{
var atmRepository = serviceProvider.GetService <IAtmRepository>();
var atm = atmRepository.GetById(request.AtmId);
atmRepository = scope.GetService <IAtmRepository>();
headOfficeRepository = scope.GetService <IHeadOfficeRepository>();
headOffice.TransferCashToAtm(atm);
atmRepository.Save(atm);
headOfficeRepository.Save(headOffice);
}
catch (Exception exc)
{
exc.ToString();
//TODO: do sth with exc
}
});
}
return(headOffice);
}
private void Timer_Job(object obj)
{
try
{
var databases = databasesRepository.GetAll();
foreach (var d in databases)
{
try
{
using (var scope = new DatabaseScope(d.Name))
{
var data = builder.Build();
data.StoredProcedures.IntersectWith(data.StoredProcedures.Where(x => ContainsView(x)));
data.Views.IntersectWith(data.Views.Where(x => ContainsView(x)));
dependencyHierarchyFilteredForViewPerDatabase.AddOrUpdate(d.ID, data, (k, v) => data);
}
}
catch (Exception ex)
{
log.Write(ex);
}
}
}
catch (Exception ex)
{
log.Write(ex);
}
}
public bool TryGetPrimaryKey(uint relationId, out PrimaryKeyData primaryKey)
{
if (!primaryKeyPerRelation.ContainsKey(relationId))
{
using (var scope = new DatabaseScope(databaseName))
{
var relation = relationsRepository.Get(relationId);
PrimaryKeyData primaryKeyToAdd = null;
if (relation != null)
{
List <AttributeData> primaryKeyAttributes = new List <AttributeData>();
if (relation.PrimaryKeyAttributeNames != null)
{
foreach (var attributeName in relation.PrimaryKeyAttributeNames)
{
primaryKeyAttributes.Add(new AttributeData(GetRelation(relationId), attributesRepository.Get(relationId, attributeName)));
}
}
if (primaryKeyAttributes.Count > 0)
{
primaryKeyToAdd = new PrimaryKeyData(primaryKeyAttributes);
}
}
primaryKeyPerRelation.Add(relationId, primaryKeyToAdd);
}
}
primaryKey = primaryKeyPerRelation[relationId];
return(primaryKey != null);
}
public Task Handle(BalanceChangedEvent domainEvent)
{
Guard.Against.Null(domainEvent, nameof(domainEvent));
using (var scope = new DatabaseScope(serviceProvider))
{
scope.Execute(() => {
try
{
var repository = serviceProvider.GetService <IHeadOfficeRepository>();
var headOffice = repository.GetById(domainEvent.TargetId);
repository = scope.GetService <IHeadOfficeRepository>();
headOffice.ChangeBalance(domainEvent.Delta);
repository.Save(headOffice);
}
catch (Exception exc)
{
exc.ToString();
//TODO: do sth with exc
}
});
}
return(Task.CompletedTask);
}
public void ReadBooksWithImages()
{
_booksWithImagesDatabaseDump = BooksWithImagesDatabaseDump();
LocalDbRepository <Book> books;
LocalDbRepository <Image> images;
using (var scope = new DatabaseScope())
{
var config = new DbConfig(true);
books = new LocalDbRepository <Book>(config);
images = new LocalDbRepository <Image>(config);
scope.SetupDone += Scope_SetupDone;
}
Assert.That(books.Count, Is.EqualTo(3));
Assert.That(images.Count, Is.EqualTo(3));
CollectionAssert.AllItemsAreInstancesOfType(books, typeof(Book));
CollectionAssert.AllItemsAreNotNull(books);
CollectionAssert.AllItemsAreUnique(books);
CollectionAssert.AllItemsAreInstancesOfType(images, typeof(Image));
CollectionAssert.AllItemsAreNotNull(images);
CollectionAssert.AllItemsAreUnique(images);
Assert.That(books, Is.All.Property("BookId").Not.EqualTo(0).And.All.Property("BookName").Null);
Assert.That(images, Is.All.Property("ImageId").Not.EqualTo(0)
.And.All.Property("Text").Null
.And.All.Property("IdBook").Not.EqualTo(0));
}
public SnackMachine Handle(BuySnackCommand request)
{
if (request.SnackMachine.CanBuySnack(request.Position))
{
request.SnackMachine.BuySnack(request.Position);
using (var scope = new DatabaseScope(serviceProvider))
{
scope.Execute(() => {
try
{
var repository = scope.GetService <ISnackMachineRepository>();
repository.Save(request.SnackMachine);
}
catch (Exception exc)
{
exc.ToString();
//TODO: do sth with exc
}
});
}
}
return(request.SnackMachine);
}
protected override void OnExecute()
{
using (var scope = new DatabaseScope(context.Database.Name))
{
repository.InitializeEnvironment();
}
}
public SmartcardReader(string readerName, DatabaseScope scope) {
if (readerName == null)
throw new ArgumentNullException("readerName", ResourceController.GetString("Error_ParamNull"));
int ret = NativeMethods.SCardEstablishContext((int)scope, IntPtr.Zero, IntPtr.Zero, out m_Context);
if (ret != NativeMethods.SCARD_S_SUCCESS)
throw new SmartcardException(ResourceController.GetString("Error_SmartcardEstablishContext"), ret);
m_ReaderName = readerName;
}
protected override void OnExecute()
{
using (var scope = new DatabaseScope(context.Database.Name))
{
foreach (var kv in context.StatementsData.All)
{
ExtractDataFromStatement(kv.Value);
}
}
}
private LocalDbRepository <Users> MockRepro()
{
LocalDbRepository <Users> users;
using (var db = new DatabaseScope())
{
users = new LocalDbRepository <Users>(new DbConfig(true));
}
return(users);
}
public void TestInvalidReplicationScope_WithoutTransaction()
{
Assert.That(() =>
{
using (var scope = new DatabaseScope())
{
using (var replicationScope = new ReplicationScope())
{
}
}
}, Throws.Exception.TypeOf <InvalidOperationException>());
}
public SmartcardReader(string readerName, DatabaseScope scope)
{
if (readerName == null)
{
throw new ArgumentNullException("readerName", ResourceController.GetString("Error_ParamNull"));
}
int ret = NativeMethods.SCardEstablishContext((int)scope, IntPtr.Zero, IntPtr.Zero, out m_Context);
if (ret != NativeMethods.SCARD_S_SUCCESS)
{
throw new SmartcardException(ResourceController.GetString("Error_SmartcardEstablishContext"), ret);
}
m_ReaderName = readerName;
}
protected override void OnExecute()
{
foreach (var database in context.Databases)
{
using (DatabaseScope scope = new DatabaseScope(database.Name))
{
try
{
context.TotalDatabaseStatistics.Add(database.ID, repository.GetLatest());
}
catch (Exception ex)
{
log.Write(ex);
}
}
}
}
private RelationData GetRelation(uint relationId)
{
if (!allRelations.ContainsKey(relationId))
{
using (var scope = new DatabaseScope(databaseName))
{
var loadedRelation = relationsRepository.Get(relationId);
RelationData relationData = null;
if (loadedRelation != null)
{
relationData = new RelationData(loadedRelation);
}
allRelations.Add(relationId, relationData);
}
}
return(allRelations[relationId]);
}
public void ReadUsers()
{
_usersDatabaseDump = UsersDatabaseDump();
LocalDbRepository <Users> users;
using (var scope = new DatabaseScope())
{
users = new LocalDbRepository <Users>(new DbConfig(true));
scope.SetupDone += Scope_SetupDone1;
}
Assert.That(users.Count, Is.EqualTo(3));
Assert.That(users.ElementAt(0), Is.Not.Null.And.Property("UserID").EqualTo(1));
Assert.That(users.ElementAt(1), Is.Not.Null.And.Property("UserID").EqualTo(2));
Assert.That(users.ElementAt(2), Is.Not.Null.And.Property("UserID").EqualTo(3));
}
private void UpdateAtm(Atm atm)
{
using (var scope = new DatabaseScope(serviceProvider))
{
scope.Execute(() => {
try
{
var atmRepository = scope.GetService <IAtmRepository>();
atmRepository.Save(atm);
}
catch (Exception exc)
{
exc.ToString();
//TODO: do sth with exc
}
});
}
}
protected override void OnExecute()
{
using (var scope = new DatabaseScope(context.Database.Name))
{
var existingIndices = indicesRepository.GetAll();
foreach (var i in existingIndices)
{
var relation = relationsRepository.Get(i.RelationID);
var relationData = new RelationData(relation);
var attributes = new List <AttributeData>();
var includedAttributes = new List <AttributeData>();
foreach (var atrributeName in i.AttributesNames)
{
var attribute = attributesRepository.Get(relation.ID, atrributeName);
var toAdd = new AttributeData(relationData, attribute);
if (IsIncludedAttribute(i.CreateDefinition, attribute.Name))
{
includedAttributes.Add(toAdd);
}
else
{
attributes.Add(toAdd);
}
}
var existingIndexToAdd = new IndexDefinition(Convert(i.AccessMethod), relationData, attributes, includedAttributes);
if (context.StatementsData.AllQueriesByRelation.TryGetValue(relation.ID, out var possibleQueriesForIndex))
{
foreach (var statementQueryPair in possibleQueriesForIndex)
{
var normalizedStatementID = statementQueryPair.NormalizedStatementID;
var normalizedStatement = context.StatementsData.All[normalizedStatementID].NormalizedStatement;
var query = statementQueryPair.Query;
var extractedData = context.StatementsExtractedData.DataPerQuery[statementQueryPair];
if (IndexApplicability.IsIndexApplicableForQuery(extractedData, existingIndexToAdd))
{
context.IndicesDesignData.ExistingIndices.TryAddPossibleIndices(new[] { existingIndexToAdd }, normalizedStatement, query);
}
}
}
}
}
}
protected override void OnExecute()
{
var dictionary = getDictionaryFunc();
dictionary.Clear();
using (var scope = new DatabaseScope(context.Database.Name))
{
foreach (var s in context.StatementsData.All)
{
IExplainResult explainResult = null;
try
{
explainResult = explainRepository.Eplain(s.Value.RepresentativeStatistics.RepresentativeStatement);
}
catch (Exception ex)
{
log.Write(ex);
}
dictionary.Add(s.Key, explainResult ?? new EmptyExplainResult());
}
}
}
public HeadOffice Handle(TransferInCashFromSnackMachineCommand request)
{
var snackMachineRepository = serviceProvider.GetService <ISnackMachineRepository>();
var snackMachine = snackMachineRepository.GetById(request.SnackMachineId);
if (snackMachine == null)
{
return(null);
}
var headOfficeRepository = serviceProvider.GetService <IHeadOfficeRepository>();
var headOffice = headOfficeRepository.GetById(request.HeadOfficeId);
using (var scope = new DatabaseScope(serviceProvider))
{
scope.Execute(() => {
try
{
snackMachineRepository = scope.GetService <ISnackMachineRepository>();
headOfficeRepository = scope.GetService <IHeadOfficeRepository>();
headOffice.TransferInCashFromSnackMachine(snackMachine);
snackMachineRepository.Save(snackMachine);
headOfficeRepository.Save(headOffice);
}
catch (Exception exc)
{
exc.ToString();
//TODO: do sth with exc
}
});
}
return(headOffice);
}
public DbScope()
{
database = new DatabaseScope();
users = new LocalDbRepository <Users>(new DbConfig(true));
}
protected override void OnExecute()
{
context.IndicesDesignData.PossibleIndexSizes.Clear();
#if DEBUG
int counter = 0;
#endif
using (var scope = new DatabaseScope(context.Database.Name))
{
foreach (var env in context.IndicesDesignData.Environments)
{
#if DEBUG
if (System.Diagnostics.Debugger.IsAttached)
{
++counter;
if (counter % 10 == 0)
{
Console.WriteLine(((counter / (double)context.IndicesDesignData.Environments.Count) * 100).ToString("F2") + "%");
}
}
#endif
try
{
virtualIndicesRepository.DestroyAll();
var virtualIndicesMapping = new Dictionary <IndexDefinition, IVirtualIndex>();
bool indicesCreated = false;
try
{
foreach (var index in env.PossibleIndices.All)
{
var targetRelationData = context.RelationsData.GetReplacementOrOriginal(index.Relation.ID);
var virtualIndex = virtualIndicesRepository.Create(dbObjectDefinitionGenerator.Generate(index.WithReplacedRelation(targetRelationData)));
if (virtualIndex != null)
{
virtualIndicesMapping.Add(index, virtualIndex);
}
if (!context.IndicesDesignData.PossibleIndexSizes.ContainsKey(index))
{
context.IndicesDesignData.PossibleIndexSizes.Add(index, virtualIndicesRepository.GetVirtualIndexSize(virtualIndex.ID));
}
}
indicesCreated = true;
}
catch (Exception ex)
{
log.Write(ex);
}
if (indicesCreated)
{
foreach (var kv in env.PossibleIndices.AllPerStatement)
{
var statementID = kv.Key;
var indices = kv.Value;
var workloadStatement = context.StatementsData.All[statementID];
var normalizedStatement = workloadStatement.NormalizedStatement;
var representativeStatement = workloadStatement.RepresentativeStatistics.RepresentativeStatement;
var statementToUse = RepresentativeStatementReplacementUtility.Provide(normalizedStatement, representativeStatement, context.RelationsData);
var explainResult = explainRepository.Eplain(statementToUse);
var latestPlan = explainResult.Plan;
var realPlan = context.RealExecutionPlansForStatements[statementID].Plan;
HashSet <IndexDefinition> improvingVirtualIndices = new HashSet <IndexDefinition>();
VirtualEnvironmentStatementEvaluation statementEvaluation = new VirtualEnvironmentStatementEvaluation();
statementEvaluation.ExecutionPlan = explainResult;
decimal fromPrice = realPlan.TotalCost;
decimal toPrice = latestPlan.TotalCost;
decimal divisor = Math.Abs(Math.Max(fromPrice, toPrice));
if (divisor > 0)
{
statementEvaluation.LocalImprovementRatio = ((toPrice - fromPrice) / divisor) * -1m;
}
decimal statementPortion = context.StatementsData.AllExecutionsCount > 0 ? workloadStatement.TotalExecutionsCount / (decimal)context.StatementsData.AllExecutionsCount : 0m;
statementEvaluation.GlobalImprovementRatio = statementEvaluation.LocalImprovementRatio * statementPortion;
env.StatementsEvaluation.Add(statementID, statementEvaluation);
foreach (var i in indices)
{
var virtualIndex = virtualIndicesMapping[i];
if (!env.IndicesEvaluation.ContainsKey(i))
{
env.IndicesEvaluation.Add(i, new VirtualIndicesEnvironmentIndexEvaluation());
}
if (explainResult.UsedIndexScanIndices.Contains(virtualIndex.Name))
{
statementEvaluation.UsedIndices.Add(i);
statementEvaluation.AffectingIndices.Add(i);
if (latestPlan.TotalCost < realPlan.TotalCost)
{
improvingVirtualIndices.Add(i);
}
env.IndicesEvaluation[i].ImprovementRatio += statementEvaluation.GlobalImprovementRatio;
}
else
{
if (normalizedStatement.CommandType == DAL.Contracts.StatementQueryCommandType.Insert ||
normalizedStatement.CommandType == DAL.Contracts.StatementQueryCommandType.Update ||
normalizedStatement.CommandType == DAL.Contracts.StatementQueryCommandType.Delete)
{
statementEvaluation.AffectingIndices.Add(i);
}
}
}
foreach (var query in normalizedStatement.StatementDefinition.IndependentQueries)
{
var queryKey = new NormalizedStatementQueryPair(statementID, query);
env.ImprovingPossibleIndices.TryAddPossibleIndices(improvingVirtualIndices, normalizedStatement, query);
if (env.PossibleIndices.AllCoveringPerQuery.ContainsKey(queryKey))
{
env.ImprovingPossibleIndices.TryAddPossibleCoveringIndices(env.PossibleIndices.AllCoveringPerQuery[queryKey].Intersect(improvingVirtualIndices), normalizedStatement, query);
}
}
}
}
}
finally
{
virtualIndicesRepository.DestroyAll();
}
}
}
}
protected override void OnExecute()
{
using (var scope = new DatabaseScope(context.Database.Name))
{
foreach (var env in context.HPartitioningDesignData.Environments)
{
try
{
virtualHPartitioningsRepository.DestroyAll();
bool hPartitioningCreated = false;
try
{
var targetRelationData = context.RelationsData.GetReplacementOrOriginal(env.Partitioning.Relation.ID);
virtualHPartitioningsRepository.Create(dbObjectDefinitionGenerator.Generate(env.Partitioning.WithReplacedRelation(targetRelationData)));
hPartitioningCreated = true;
}
catch (Exception ex)
{
log.Write(ex);
}
if (hPartitioningCreated)
{
foreach (var queryPair in context.StatementsData.AllQueriesByRelation[env.Partitioning.Relation.ID])
{
var statementID = queryPair.NormalizedStatementID;
if (!env.StatementsEvaluation.ContainsKey(statementID))
{
var workloadStatement = context.StatementsData.All[statementID];
var normalizedStatement = workloadStatement.NormalizedStatement;
var representativeStatement = workloadStatement.RepresentativeStatistics.RepresentativeStatement;
var statementToUse = RepresentativeStatementReplacementUtility.Provide(normalizedStatement, representativeStatement, context.RelationsData);
var realPlan = context.RealExecutionPlansForStatements[statementID].Plan;
IExplainResult explainResult = context.RealExecutionPlansForStatements[statementID];
var latestPlan = realPlan;
if (normalizedStatement.CommandType == DAL.Contracts.StatementQueryCommandType.Select ||
normalizedStatement.CommandType == DAL.Contracts.StatementQueryCommandType.Insert) // hypo pg currently does not support explain for delete/update for h partitioning
{
try
{
explainResult = explainRepository.Eplain(statementToUse);
latestPlan = explainResult.Plan;
}
catch (Exception ex)
{
log.Write(ex);
}
}
VirtualEnvironmentStatementEvaluation statementEvaluation = new VirtualEnvironmentStatementEvaluation();
statementEvaluation.ExecutionPlan = explainResult;
decimal fromPrice = realPlan.TotalCost;
decimal toPrice = latestPlan.TotalCost;
decimal divisor = Math.Abs(Math.Max(fromPrice, toPrice));
if (divisor > 0)
{
statementEvaluation.LocalImprovementRatio = ((toPrice - fromPrice) / divisor) * -1m;
}
decimal statementPortion = context.StatementsData.AllExecutionsCount > 0 ? workloadStatement.TotalExecutionsCount / (decimal)context.StatementsData.AllExecutionsCount : 0m;
statementEvaluation.GlobalImprovementRatio = statementEvaluation.LocalImprovementRatio * statementPortion;
env.StatementsEvaluation.Add(statementID, statementEvaluation);
env.Evaluation.ImprovementRatio += statementEvaluation.GlobalImprovementRatio;
}
}
env.IsImproving = env.Evaluation.ImprovementRatio >= settings.HPartitioningMinTotalImprovementRatio;
}
}
finally
{
virtualHPartitioningsRepository.DestroyAll();
}
}
}
}
protected override void OnExecute()
{
using (var scope = new DatabaseScope(context.Database.Name))
{
virtualIndicesRepository.DestroyAll();
foreach (var index in context.IndicesDesignData.PossibleIndices.All)
{
Dictionary <AttributeData, List <string> > possibleFilteredAttributeValues = new Dictionary <AttributeData, List <string> >();
foreach (var a in index.Attributes)
{
List <string> mostSignificantValues = new List <string>();
List <string> leastSignificantValues = new List <string>();
if (a.MostCommonValuesFrequencies != null && a.MostCommonValuesFrequencies.Length >= 2)// we need at least two values
{
decimal frequenciesSum = 0;
for (int i = 0; i < Math.Min(a.MostCommonValuesFrequencies.Length - 1, MOST_COMMON_VALUES_MAX_COUNT); i++)
{
if (a.MostCommonValuesFrequencies[i] >= MOST_COMMON_VALUE_MIN_FREQUENCY)
{
var sqlStringValue = toSqlValueStringConverter.ConvertStringRepresentation(a.DbType, a.MostCommonValues[i]);
if (sqlStringValue != null)
{
mostSignificantValues.Add(sqlStringValue);
frequenciesSum += a.MostCommonValuesFrequencies[i];
}
}
}
if (frequenciesSum < MOST_COMMON_VALUES_MIN_FREQUENCIES_SUM || frequenciesSum > MOST_COMMON_VALUES_MAX_FREQUENCIES_SUM)
{
mostSignificantValues.Clear();
}
frequenciesSum = 0;
for (int i = a.MostCommonValuesFrequencies.Length - 1; i >= Math.Max(1, a.MostCommonValuesFrequencies.Length - MOST_COMMON_VALUES_MAX_COUNT + 1); i--)
{
var sqlStringValue = toSqlValueStringConverter.ConvertStringRepresentation(a.DbType, a.MostCommonValues[i]);
if (sqlStringValue != null)
{
leastSignificantValues.Add(sqlStringValue);
frequenciesSum += a.MostCommonValuesFrequencies[i];
}
}
if (frequenciesSum > MOST_COMMON_VALUES_MIN_FREQUENCIES_SUM)
{
leastSignificantValues.Clear();
}
}
if (mostSignificantValues.Count > 0)
{
possibleFilteredAttributeValues.Add(a, mostSignificantValues);
}
else if (leastSignificantValues.Count > 0)
{
possibleFilteredAttributeValues.Add(a, leastSignificantValues);
}
}
if (possibleFilteredAttributeValues.Count > 0)
{
string filter = CreateFilterString(possibleFilteredAttributeValues);
var targetRelationData = context.RelationsData.GetReplacementOrOriginal(index.Relation.ID);
var virtualIndex = virtualIndicesRepository.Create(dbObjectDefinitionGenerator.Generate(index.WithReplacedRelation(targetRelationData), filter));
var size = virtualIndicesRepository.GetVirtualIndexSize(virtualIndex.ID);
var filters = new Dictionary <string, long>();
filters.Add(filter, size);
context.IndicesDesignData.PossibleIndexFilters.Add(index, filters);
}
}
}
}
