private static void CreateHistoryTable(RelationalTable baseTable, DwhBuilderConfiguration configuration)
        {
            var historyTable       = baseTable.Schema.AddTable(baseTable.Name + configuration.HistoryTableNamePostfix).SetIsHistoryTable();
            var identityColumnName = (configuration.HistoryTableIdentityColumnBase ?? historyTable.Name) + configuration.HistoryTableIdentityColumnPostfix;

            historyTable.AddColumn(identityColumnName, true).SetIdentity();

            foreach (var column in baseTable.Columns)
            {
                historyTable.AddColumn(column.Name, false);
            }

            if (baseTable.PrimaryKeyColumns.Count > 0)
            {
                var historyFkToBase = historyTable.AddForeignKeyTo(baseTable);
                foreach (var basePkColumn in baseTable.PrimaryKeyColumns)
                {
                    historyFkToBase.AddColumnPair(historyTable[basePkColumn.Name], basePkColumn);
                }
            }

            foreach (var baseFk in baseTable.ForeignKeys)
            {
                var historyFk = historyTable.AddForeignKeyTo(baseFk.TargetTable);

                foreach (var baseFkPair in baseFk.ColumnPairs)
                {
                    historyFk.AddColumnPair(historyTable[baseFkPair.SourceColumn.Name], baseFkPair.TargetColumn);
                }
            }

            baseTable.AddColumn(configuration.ValidFromColumnName, false);
            historyTable.AddColumn(configuration.ValidFromColumnName, false);
            historyTable.AddColumn(configuration.ValidToColumnName, false);
        }
Example #2
0
        public DwhTableBuilder(MsSqlDwhBuilder builder, ResilientTable resilientTable, RelationalTable table)
        {
            DwhBuilder     = builder;
            ResilientTable = resilientTable;
            Table          = table;

            HasEtlRunInfo = builder.Configuration.UseEtlRunInfo && !Table.GetEtlRunInfoDisabled();
            if (HasEtlRunInfo)
            {
                EtlRunInsertColumnNameEscaped = Table[builder.Configuration.EtlRunInsertColumnName].NameEscaped(builder.ConnectionString);
                EtlRunUpdateColumnNameEscaped = Table[builder.Configuration.EtlRunUpdateColumnName].NameEscaped(builder.ConnectionString);
                EtlRunFromColumnNameEscaped   = Table[builder.Configuration.EtlRunFromColumnName].NameEscaped(builder.ConnectionString);
                EtlRunToColumnNameEscaped     = Table[builder.Configuration.EtlRunToColumnName].NameEscaped(builder.ConnectionString);
            }

            ValidFromColumn            = Table[builder.Configuration.ValidFromColumnName];
            ValidFromColumnNameEscaped = ValidFromColumn?.NameEscaped(builder.ConnectionString);

            ValidToColumnName        = ValidFromColumn != null ? builder.Configuration.ValidToColumnName : null;
            ValidToColumnNameEscaped = ValidToColumnName != null?builder.ConnectionString.Escape(ValidToColumnName) : null;
        }
Example #3
0
        private IMutator CreateTempWriter(ResilientTable table, RelationalTable dwhTable)
        {
            var tempColumns = dwhTable.Columns
                              .Where(x => !x.GetUsedByEtlRunInfo());

            if (dwhTable.AnyPrimaryKeyColumnIsIdentity)
            {
                tempColumns = tempColumns
                              .Where(x => !x.IsPrimaryKey);
            }

            return(new MsSqlWriteToTableWithMicroTransactionsMutator(table.Topic, "Writer")
            {
                ConnectionString = table.Scope.Configuration.ConnectionString,
                TableDefinition = new DbTableDefinition()
                {
                    TableName = table.TempTableName,
                    Columns = tempColumns
                              .Select(c => new DbColumnDefinition(c.Name, c.NameEscaped(DwhBuilder.ConnectionString)))
                              .ToArray(),
                },
            });
        }
 public static bool GetEtlRunInfoDisabled(this RelationalTable table)
 {
     return(table.GetFlag("NoEtlRunInfo"));
 }
 public static RelationalTable SetEtlRunInfoDisabled(this RelationalTable table, bool value = true)
 {
     table.SetFlag("NoEtlRunInfo", value);
     return(table);
 }
 public static bool GetIsHistoryTable(this RelationalTable table)
 {
     return(table.GetFlag("IsHistory"));
 }
 public static RelationalTable SetIsHistoryTable(this RelationalTable table, bool value = true)
 {
     table.SetFlag("IsHistory", value);
     return(table);
 }
 public static string EscapedName(this RelationalTable table, NamedConnectionString connectionString)
 {
     return(connectionString.Escape(table.Name, table.Schema.Name));
 }
 public static RelationalColumn GetRecordTimestampIndicatorColumn(this RelationalTable table)
 {
     return(table.GetColumnsWithFlag("TimestampIndicator").FirstOrDefault());
 }
 public static string GetSourceTableNameOverride(this RelationalTable table)
 {
     return(table.GetAdditionalData("SourceTableName") as string);
 }
 public static RelationalTable SetSourceTableNameOverride(this RelationalTable table, string sourceTableName)
 {
     table.SetAdditionalData("SourceTableName", sourceTableName);
     return(table);
 }
 public static bool GetIsEtlRunInfo(this RelationalTable table)
 {
     return(table.GetFlag("EtlRunInfo"));
 }