RewriteInputObjectTypeDefinition(
InputObjectTypeDefinitionNode node,
MergeContext context)
{
InputObjectTypeDefinitionNode current = node;
if (context.Extensions.TryGetValue(
current.Name.Value,
out ITypeExtensionNode extension))
{
if (extension is InputObjectTypeExtensionNode iote)
{
current = AddInputFields(current, iote);
current = AddDirectives(current, iote,
d => current.WithDirectives(d), context);
}
else
{
throw new SchemaMergeException(
current,
extension,
string.Format(
CultureInfo.InvariantCulture,
StitchingResources.AddSchemaExtensionRewriter_TypeMismatch,
node.Name.Value,
node.Kind,
extension.Kind));
}
}
return(base.RewriteInputObjectTypeDefinition(current, context));
}
protected override ScalarTypeDefinitionNode RewriteScalarTypeDefinition(
ScalarTypeDefinitionNode node,
MergeContext context)
{
ScalarTypeDefinitionNode current = node;
if (context.Extensions.TryGetValue(
current.Name.Value,
out ITypeExtensionNode? extension))
{
if (extension is ScalarTypeExtensionNode ste)
{
current = AddDirectives(current, ste,
d => current.WithDirectives(d), context);
}
else
{
throw new SchemaMergeException(
current,
extension,
string.Format(
CultureInfo.InvariantCulture,
StitchingResources.AddSchemaExtensionRewriter_TypeMismatch,
node.Name.Value,
node.Kind,
extension.Kind));
}
}
return(base.RewriteScalarTypeDefinition(current, context));
}
public String GenerateRawSql(MergeContext context)
{
var sb = new StringBuilder();
var searchOnPropertyNames = String.Join(" AND ", context.SearchOnProperties.Select(x => $"source.[{x.Name}] = target.[{x.Name}]").ToArray());
var updatePropertyNames = String.Join(", ", context.Properties.Select(x => $"target.[{x.Name}] = source.[{x.Name}]").ToArray());
var insertPropertyNames = String.Join(", ", context.Properties.Select(x => $"[{x.Name}]").ToArray());
var insertPropertyValues = String.Join(", ", context.Properties.Select(x => $"source.[{x.Name}]").ToArray());
sb.AppendLine($"MERGE INTO [{context.DestinationSchemaName}].[{context.DestinationTableName}] AS target");
sb.AppendLine($"USING {context.TempTableName} AS source ON {searchOnPropertyNames}");
if (context.MergeType == MergeType.InsertOrUpdate || context.MergeType == MergeType.InsertOrUpdateOrDelete)
{
sb.AppendLine($"WHEN MATCHED THEN UPDATE SET {updatePropertyNames}");
}
if (context.MergeType == MergeType.Insert || context.MergeType == MergeType.InsertOrUpdate || context.MergeType == MergeType.InsertOrUpdateOrDelete)
{
sb.AppendLine($"WHEN NOT MATCHED BY TARGET THEN INSERT ({insertPropertyNames}) VALUES ({insertPropertyValues})");
}
if (context.MergeType == MergeType.InsertOrUpdateOrDelete)
{
sb.AppendLine($"WHEN NOT MATCHED BY SOURCE THEN DELETE");
}
return(String.Concat(sb.ToString().TrimEnd(), ";"));
}
public void GenerateRawSql_InsertOrUpdateOrDelete()
{
// Arrange
var pk_1 = Property("pk_1");
var pk_2 = Property("pk_2");
var property1 = Property("property1");
var property2 = Property("property2");
var context = new MergeContext
{
MergeType = MergeType.InsertOrUpdateOrDelete,
DestinationSchemaName = "dbo",
DestinationTableName = "DestinationTable",
SearchOnProperties = { pk_1, pk_2 },
Properties = { pk_1, pk_2, property1, property2 }
};
var generator = new MergeRawSqlGenerator();
// Act
var sql = generator.GenerateRawSql(context);
// Assert
sql.Should().Be(@"
MERGE INTO [dbo].[DestinationTable] AS target
USING #dbo_DestinationTable AS source ON source.[pk_1] = target.[pk_1] AND source.[pk_2] = target.[pk_2]
WHEN MATCHED THEN UPDATE SET target.[pk_1] = source.[pk_1], target.[pk_2] = source.[pk_2], target.[property1] = source.[property1], target.[property2] = source.[property2]
WHEN NOT MATCHED BY TARGET THEN INSERT ([pk_1], [pk_2], [property1], [property2]) VALUES (source.[pk_1], source.[pk_2], source.[property1], source.[property2])
WHEN NOT MATCHED BY SOURCE THEN DELETE;".Trim());
}
public MergeOutputContext(IBuildContext?parent, LambdaExpression lambda, MergeContext mergeContext, IBuildContext emptyTable, IBuildContext deletedTable, IBuildContext insertedTable)
: base(parent, lambda, emptyTable, deletedTable, insertedTable)
{
Statement = mergeContext.Statement;
Sequence[0].SelectQuery.Select.Columns.Clear();
Sequence[1].SelectQuery = Sequence[0].SelectQuery;
Sequence[2].SelectQuery = Sequence[0].SelectQuery;
}
public static async Task Merge <TEntity>(this DbContext db, TEntity[] data, MergeOptions options) where TEntity : class
{
var entityType = db.Model.FindEntityType(typeof(TEntity));
var context = new MergeContext
{
Logger = db.GetService <ILoggerFactory>().CreateLogger("EntityFrameworkCore.Extensions.SqlServer.Merge"),
MergeType = options.MergeType,
Connection = db.Database.GetDbConnection() as SqlConnection,
Transaction = db.Database.CurrentTransaction?.GetDbTransaction() as SqlTransaction,
DestinationSchemaName = entityType.FindAnnotation(RelationalAnnotationNames.Schema).Value.ToString(),
DestinationTableName = entityType.FindAnnotation(RelationalAnnotationNames.TableName).Value.ToString(),
SearchOnProperties = entityType.FindPrimaryKey().Properties.ToList(),
Properties = entityType.GetProperties().Where(x => !x.IsConcurrencyToken).ToList()
};
await context.Connection.EnsureOpenAsync();
var sw = Stopwatch.StartNew();
var createTempTableCommandText = $"SELECT TOP 0 * INTO {context.TempTableName} FROM [{context.DestinationSchemaName}].[{context.DestinationTableName}]";
using (var command = new SqlCommand(createTempTableCommandText, context.Connection))
{
await command.ExecuteNonQueryAsync();
}
context.Logger.LogInformation($"Executed DbCommand ({sw.ElapsedMilliseconds}ms){Environment.NewLine}{createTempTableCommandText}");
sw.Restart();
using (var bcp = new SqlBulkCopy(context.Connection, SqlBulkCopyOptions.Default, context.Transaction))
using (var reader = ObjectReader.Create(data, context.Properties.Select(x => x.Name).ToArray()))
{
bcp.DestinationTableName = context.TempTableName;
await bcp.WriteToServerAsync(reader);
}
context.Logger.LogInformation($"Executed SqlBulkCopy ({sw.ElapsedMilliseconds}ms) into {context.TempTableName}");
sw.Restart();
var generator = db.GetService <IMergeRawSqlGenerator>();
//var generator = new MergeRawSqlGenerator();
var commandText = generator.GenerateRawSql(context);
using (var command = context.Connection.CreateCommand())
{
command.CommandText = commandText;
await command.ExecuteNonQueryAsync();
}
context.Logger.LogInformation($"Executed DbCommand ({sw.ElapsedMilliseconds}ms){Environment.NewLine}{commandText}");
}
public DocumentNode AddExtensions(
DocumentNode schema,
DocumentNode extensions)
{
if (schema == null)
{
throw new ArgumentNullException(nameof(schema));
}
if (extensions == null)
{
throw new ArgumentNullException(nameof(extensions));
}
var newTypes = extensions.Definitions.OfType <ITypeDefinitionNode>().ToList();
var newDirectives = extensions.Definitions.OfType <DirectiveDefinitionNode>().ToList();
DocumentNode current = schema;
if (newTypes.Count > 0 || newDirectives.Count > 0)
{
current = RemoveDirectives(current, newDirectives.Select(t => t.Name.Value));
current = RemoveTypes(current, newTypes.Select(t => t.Name.Value));
var definitions = schema.Definitions.ToList();
definitions.AddRange(newTypes);
definitions.AddRange(newDirectives);
current = current.WithDefinitions(definitions);
}
var context = new MergeContext(current, extensions);
current = RewriteDocument(current, context);
if (context.Extensions.Count > 0)
{
var definitions = current.Definitions.ToList();
foreach (string notProcessed in context.Extensions.Keys.Except(
current.Definitions.OfType <ITypeDefinitionNode>().Select(t => t.Name.Value)))
{
definitions.Add(context.Extensions[notProcessed]);
}
return(current.WithDefinitions(definitions));
}
return(current);
}
private TDefinition AddDirectives <TDefinition, TExtension>(
TDefinition typeDefinition,
TExtension typeExtension,
Func <IReadOnlyList <DirectiveNode>, TDefinition> withDirectives,
MergeContext context)
where TDefinition : NamedSyntaxNode, ITypeDefinitionNode
where TExtension : NamedSyntaxNode, ITypeExtensionNode
{
if (typeExtension.Directives.Count == 0)
{
return(typeDefinition);
}
var alreadyDeclared = new HashSet <string>(
typeDefinition.Directives.Select(t => t.Name.Value));
var directives = new List <DirectiveNode>();
foreach (DirectiveNode directive in typeExtension.Directives)
{
if (!_globalDirectives.TryGetValue(directive.Name.Value,
out DirectiveDefinitionNode? directiveDefinition) &&
!context.Directives.TryGetValue(directive.Name.Value,
out directiveDefinition))
{
throw new SchemaMergeException(
typeDefinition, typeExtension,
string.Format(
CultureInfo.InvariantCulture, StitchingResources
.AddSchemaExtensionRewriter_DirectiveDoesNotExist,
directive.Name.Value));
}
if (!alreadyDeclared.Add(directive.Name.Value) &&
directiveDefinition.IsUnique)
{
throw new SchemaMergeException(
typeDefinition, typeExtension,
string.Format(
CultureInfo.InvariantCulture, StitchingResources
.AddSchemaExtensionRewriter_DirectiveIsUnique,
directive.Name.Value));
}
directives.Add(directive);
}
return(withDirectives.Invoke(directives));
}
public static List <TableOfContents> Merge(List <TableOfContentsCompiler.TocFolderCompilationResult> folderCompilationResults)
{
var mergeContext = new MergeContext();
foreach (var folderCompilationResult in folderCompilationResults)
{
mergeContext.AddCompiled(folderCompilationResult);
}
var resultTocs = mergeContext.CompiledTocs
.SelectMany(x => x.Value)
.Select(x => MergeToTableOfContents(x, mergeContext))
.ToList();
return(resultTocs);
}
public async Task Run()
{
try
{
await _cosmosRepository.SetThroughput(100000);
Console.WriteLine("Set calcresults RU at 100000");
CosmosDbQuery query = new CosmosDbQuery
{
QueryText = @" SELECT *
FROM c
WHERE c.documentType = 'ProviderResult'
AND c.deleted = false"
};
ICosmosDbFeedIterator <ProviderResult> feed = _cosmosRepository.GetFeedIterator <ProviderResult>(query);
ApiResponse <IEnumerable <FundingPeriod> > fundingPeriods = await _policiesPolicy.ExecuteAsync(() => _policies.GetFundingPeriods());
MergeContext context = new MergeContext(feed, fundingPeriods.Content);
IProducerConsumer producerConsumer = _producerConsumerFactory.CreateProducerConsumer(ProduceSpecificationInformation,
ConsumeSpecificationInformation,
8,
4,
_logger);
await producerConsumer.Run(context);
Console.WriteLine($"Starting bulk upsert of {_cachedProviderWithResultsForSpecifications.Count} providers with results for specifications summaries");
await _cosmosRepository.BulkUpsertAsync(_cachedProviderWithResultsForSpecifications);
}
catch (Exception e)
{
_logger.Error(e, "Unable to complete provider version migration");
throw;
}
finally
{
await _cosmosRepository.SetThroughput(10000);
Console.WriteLine("Set calcresults RU at 10000");
}
}
public static List <TableOfContents> Merge(List <TableOfContentsCompiler.TocFolderCompilationResult> folderCompilationResults)
{
var mergeContext = new MergeContext();
foreach (var folderCompilationResult in folderCompilationResults)
{
mergeContext.AddCompiled(folderCompilationResult);
}
var resultTocs = mergeContext.GetUnique();
var duplicatedEntries = mergeContext.GetDuplicated();
foreach (var duplicateGroup in duplicatedEntries)
{
var orderedDuplicates = OrderDuplicateTocsByPriority(duplicateGroup.Value);
var mergedToc = MergeTocs(orderedDuplicates);
resultTocs.Add(mergedToc);
}
return(resultTocs);
}
protected override ICascadedInterceptor HandleServiceIntern(Ioc.Factory.IBeanContextFactory beanContextFactory, Ioc.IServiceContext beanContext, Ioc.Config.IBeanConfiguration beanConfiguration, System.Type type, System.Collections.Generic.ISet <System.Type> requestedTypes)
{
MergeContext mergeContext = mergeContextCache.GetAnnotation(type);
if (mergeContext == null)
{
return(null);
}
IMethodLevelBehavior <Attribute> behavior = CreateInterceptorModeBehavior(type);
MergeInterceptor mergeInterceptor = new MergeInterceptor();
if (beanContext.IsRunning)
{
return(beanContext.RegisterWithLifecycle(mergeInterceptor) //
.PropertyValue("Behavior", behavior) //
.IgnoreProperties("ServiceName") //
.Finish());
}
beanContextFactory.RegisterWithLifecycle(mergeInterceptor) //
.PropertyValue("Behavior", behavior) //
.IgnoreProperties("ServiceName");
return(mergeInterceptor);
}
private static void AssignTocPosition(TableOfContents toc, MergeContext mergeContext)
{
var categoryIndex = mergeContext.GetCategoryIndex(toc.Version, toc.Category);
toc.Position = categoryIndex;
}
private static TableOfContents MergeToTableOfContents(MergeContext.RootItemEntry rootItem, MergeContext mergeContext)
{
if (rootItem.ContainsMultipleItems)
{
var orderedDuplicates = OrderDuplicateTocsByPriority(rootItem.Entries);
var mergedToc = MergeTocs(orderedDuplicates);
AssignTocPosition(mergedToc, mergeContext);
return(mergedToc);
}
var singleItem = rootItem.Entries.Single();
var toc = singleItem.TableOfContents;
AssignTocPosition(toc, mergeContext);
return(toc);
}
