Ejemplo n.º 1
0
        private static AstOleDBCommandNode CreateInsertNode(AstLateArrivingLookupNode lookup, AstLookupNode codegenLookup)
        {
            var insertPlaceholder = new AstOleDBCommandNode(lookup.ParentItem)
                                        {
                                            Name = String.Format(CultureInfo.InvariantCulture, "__LALookupPlaceholderInsert_{0}", lookup.Name),
                                            Connection = lookup.Table.Connection,
                                        };

            insertPlaceholder.Query = new AstTransformationMappedQueryNode(insertPlaceholder) { Body = TableLowerer.EmitInsertDefaultRowStatement(lookup.Table) };
            insertPlaceholder.InputPath = new AstDataflowMappedInputPathNode(insertPlaceholder) { OutputPath = codegenLookup.NoMatchPath };
            return insertPlaceholder;
        }
Ejemplo n.º 2
0
        private static AstUnionAllNode CreateUnionAllNode(AstLateArrivingLookupNode lookup, AstLookupNode codegenLookup, AstOleDBCommandNode insertPlaceholder)
        {
            var unionAll = new AstUnionAllNode(lookup.ParentItem) { Name = String.Format(CultureInfo.InvariantCulture, "__LALookupUnionAll_{0}", lookup.Name) };
            unionAll.InputPaths.Add(new AstDataflowMappedInputPathNode(unionAll) { OutputPath = codegenLookup.MatchPath });
            unionAll.InputPaths.Add(new AstDataflowMappedInputPathNode(unionAll) { OutputPath = insertPlaceholder.OutputPath });

            foreach (var outgoingPath in lookup.OutputPath.References)
            {
                if (outgoingPath.ReferencingItem != null && outgoingPath.PropertyName != null)
                {
                    PropertyInfo propertyInfo = outgoingPath.GetType().GetProperty(outgoingPath.PropertyName);
                    if (propertyInfo != null)
                    {
                        propertyInfo.SetValue(outgoingPath.ReferencingItem, unionAll.OutputPath, null);
                    }
                }
            }

            return unionAll;
        }
Ejemplo n.º 3
0
        private static AstDataflowOutputPathNode BuildHistoricalSubpath(AstTableNode targetTable, IFrameworkItem parentItem, List<AstTransformationNode> workflowFragment, AstDataflowOutputPathNode scdHistoricalPath)
        {
            var historicalTransform = new AstDerivedColumnListNode(parentItem);
            historicalTransform.InputPath = new AstDataflowMappedInputPathNode(historicalTransform) { OutputPath = scdHistoricalPath };
            historicalTransform.Name = Utility.NameCleanerAndUniqifier(targetTable.Name + "_HistoricalDerivedColumns");
            historicalTransform.Columns.Add(new AstDerivedColumnNode(historicalTransform)
            {
                Name = "_scdTo",
                Expression = "(DT_DBTIMESTAMP2,7)(@[System::StartTime])",
                Scale = 7,
                DerivedColumnType = ColumnType.DateTime2,
                ReplaceExisting = false
            });
            workflowFragment.Add(historicalTransform);

            var historicalCommand = new AstOleDBCommandNode(parentItem)
                                        {
                                            Name = Utility.NameCleanerAndUniqifier(targetTable.Name + "_HistoricalCommand"), 
                                            Connection = targetTable.Connection
                                        };
            historicalCommand.Query = new AstTransformationMappedQueryNode(historicalCommand);

            var historicalSetColumnValueMappings = new List<TableColumnValueMapping>();
            var historicalWhereColumnValueMappings = new List<TableColumnValueMapping>();
            historicalCommand.Query.Mappings.Add(new AstDataflowColumnMappingNode(historicalCommand) { SourceName = "_scdTo", TargetName = "Param_0" });
            historicalSetColumnValueMappings.Add(new TableColumnValueMapping("_scdTo", "?", MappingOperator.Assign));

            historicalWhereColumnValueMappings.Add(new TableColumnValueMapping("_scdTo", "NULL", MappingOperator.CompareIs));
            int historicalIndex = 1;
            foreach (var keyColumn in targetTable.PreferredKey.Columns)
            {
                historicalCommand.Query.Mappings.Add(new AstDataflowColumnMappingNode(historicalCommand) { SourceName = keyColumn.Column.Name, TargetName = String.Format(CultureInfo.InvariantCulture, "Param_{0}", historicalIndex++) });
                historicalWhereColumnValueMappings.Add(new TableColumnValueMapping(keyColumn.Column.Name, "?", MappingOperator.CompareEqual));
            }

            historicalCommand.Query.Body = TableLowerer.EmitUpdateStatement(targetTable, historicalSetColumnValueMappings, historicalWhereColumnValueMappings);
            historicalCommand.ValidateExternalMetadata = false;
            workflowFragment.Add(historicalCommand);

            return historicalCommand.OutputPath;
        }
Ejemplo n.º 4
0
        private static void BuildChangePath(AstTableNode targetTable, IFrameworkItem parentItem, List<AstTransformationNode> workflowFragment, AstDataflowOutputPathNode scdChangePath)
        {
            // Change Path should only be built if we actually have a column that takes a Type-1 Update

            bool doUpdate = false;
            foreach (var column in targetTable.Columns)
            {
                if (column.IsAssignable && column.ScdType == ScdType.Update && !column.IsAutoGenerated)
                {
                    doUpdate = true;
                    break;
                }
            }
            if (doUpdate)
            {
                var changeCommand = new AstOleDBCommandNode(parentItem)
                                        {
                                            Name = Utility.NameCleanerAndUniqifier(targetTable.Name + "_ChangeCommand"),
                                            Connection = targetTable.Connection
                                        };
                changeCommand.Query = new AstTransformationMappedQueryNode(changeCommand);
                int changeIndex = 0;
                var changeSetColumnValueMappings = new List<TableColumnValueMapping>();
                foreach (var column in targetTable.Columns)
                {
                    if (column.IsAssignable && column.ScdType == ScdType.Update && !column.IsAutoGenerated)
                    {
                        changeCommand.Query.Mappings.Add(new AstDataflowColumnMappingNode(changeCommand) { SourceName = column.Name, TargetName = String.Format(CultureInfo.InvariantCulture, "Param_{0}", changeIndex++) });
                        changeSetColumnValueMappings.Add(new TableColumnValueMapping(column.Name, "?", MappingOperator.Assign));
                    }
                }

                var changeWhereColumnValueMappings = new List<TableColumnValueMapping>();
                foreach (var keyColumn in targetTable.PreferredKey.Columns)
                {
                    changeCommand.Query.Mappings.Add(new AstDataflowColumnMappingNode(changeCommand) { SourceName = keyColumn.Column.Name, TargetName = String.Format(CultureInfo.InvariantCulture, "Param_{0}", changeIndex++) });
                    changeWhereColumnValueMappings.Add(new TableColumnValueMapping(keyColumn.Column.Name, "?", MappingOperator.CompareEqual));
                }

                changeWhereColumnValueMappings.Add(new TableColumnValueMapping("_scdTo", "NULL", MappingOperator.CompareIs));
                changeCommand.Query.Body = TableLowerer.EmitUpdateStatement(targetTable, changeSetColumnValueMappings, changeWhereColumnValueMappings);
                changeCommand.ValidateExternalMetadata = false;
                changeCommand.InputPath = new AstDataflowMappedInputPathNode(changeCommand) { OutputPath = scdChangePath };

                workflowFragment.Add(changeCommand);
            }
        }
Ejemplo n.º 5
0
        private static void BuildLateArrivingPath(AstTableNode targetTable, IFrameworkItem parentItem, List<AstTransformationNode> workflowFragment, AstDataflowOutputPathNode scdLateArrivingPath)
        {
            var inferredCommand = new AstOleDBCommandNode(parentItem)
                                      {
                                          Name = Utility.NameCleanerAndUniqifier(targetTable.Name + "_InferredCommand"), 
                                          Connection = targetTable.Connection
                                      };
            inferredCommand.Query = new AstTransformationMappedQueryNode(inferredCommand);
            int inferredIndex = 0;
            var inferredSetColumnValueMappings = new List<TableColumnValueMapping>();
            
            foreach (var column in targetTable.Columns)
            {
                if (column.IsAssignable && !column.IsAutoGenerated)
                {
                    inferredCommand.Query.Mappings.Add(new AstDataflowColumnMappingNode(inferredCommand) { SourceName = column.Name, TargetName = String.Format(CultureInfo.InvariantCulture, "Param_{0}", inferredIndex++) });
                    inferredSetColumnValueMappings.Add(new TableColumnValueMapping(column.Name, "?", MappingOperator.Assign));
                }
            }

            if (targetTable.LateArriving)
            {
                inferredSetColumnValueMappings.Add(new TableColumnValueMapping("_LateArrived", "NULL", MappingOperator.Assign));
            }

            var inferredWhereColumnValueMappings = new List<TableColumnValueMapping>();
            foreach (var keyColumn in targetTable.PreferredKey.Columns)
            {
                inferredCommand.Query.Mappings.Add(new AstDataflowColumnMappingNode(inferredCommand) { SourceName = keyColumn.Column.Name, TargetName = String.Format(CultureInfo.InvariantCulture, "Param_{0}", inferredIndex++) });
                inferredWhereColumnValueMappings.Add(new TableColumnValueMapping(keyColumn.Column.Name, "?", MappingOperator.CompareEqual));
            }

            if (targetTable.LateArriving)
            {
                inferredWhereColumnValueMappings.Add(new TableColumnValueMapping("_LateArrived", "NULL", MappingOperator.CompareIsNot));
            }

            inferredCommand.Query.Body = TableLowerer.EmitUpdateStatement(targetTable, inferredSetColumnValueMappings, inferredWhereColumnValueMappings);
            inferredCommand.ValidateExternalMetadata = false;
            inferredCommand.InputPath = new AstDataflowMappedInputPathNode(inferredCommand) { OutputPath = scdLateArrivingPath };

            workflowFragment.Add(inferredCommand);
        }
Ejemplo n.º 6
0
 public OleDBCommand(LoweringContext context, AstNode astNode) : base(context, astNode as AstTransformationNode)
 {
     _astOleDBCommandNode = astNode as AstOleDBCommandNode;
     RegisterInputBinding(_astOleDBCommandNode);
 }