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); }