public void Document(DatabaseDefinition databaseDefinition)
{
Log(LogSeverity.Information, "Starting on {DatabaseName}.", "Documenter", DatabaseName);
var tables = RemoveKnownTechnicalTables(databaseDefinition.GetTables());
foreach (var table in tables)
{
if (!Customizer.ShouldSkip(table.SchemaAndTableName))
{
_sqlTablesByCategory.Add(new KeyValuePair <string, SqlTable>(Customizer.Category(table.SchemaAndTableName), table));
}
else
{
_skippedSqlTablesByCategory.Add(new KeyValuePair <string, SqlTable>(Customizer.Category(table.SchemaAndTableName), table));
}
}
var hasCategories = _sqlTablesByCategory.Any(x => !string.IsNullOrEmpty(x.Key));
var noOfTables = databaseDefinition.GetTables().Count;
var noOfNotSkippedTables = databaseDefinition.GetTables().Count(t => !Customizer.ShouldSkip(t.SchemaAndTableName));
WriteLine("Database", "Database name", DatabaseName);
WriteLine("Database", "Number of documented tables", noOfNotSkippedTables);
WriteLine("Database", "Number of skipped tables", noOfTables - noOfNotSkippedTables);
WriteLine("Database", "Number of tables", noOfTables);
if (hasCategories)
{
WriteLine("Database");
WriteLine("Database", "Documented category", "Table count");
Context.Logger.Log(LogSeverity.Verbose, "Writing tables by category.", "Documenter");
foreach (var category in _sqlTablesByCategory.Select(kvp => kvp.Key).Distinct().OrderBy(x => x))
{
WriteLine("Database", category ?? "(No category)", _sqlTablesByCategory.Count(kvp => kvp.Key == category));
}
if (_skippedSqlTablesByCategory.Count > 0)
{
WriteLine("Database");
WriteLine("Database", "Skipped category", "Table count");
foreach (var category in _skippedSqlTablesByCategory.Select(kvp => kvp.Key).Distinct().OrderBy(x => x))
{
WriteLine("Database", category ?? "(No category)", _skippedSqlTablesByCategory.Count(kvp => kvp.Key == category));
}
}
WriteLine("Tables", "Category", "Schema", "Table Name", "Link", "Number of columns", "Description");
if (!Context.DocumenterSettings.NoInternalDataTypes)
{
WriteLine("All columns", "Category", "Schema", "Table Name", "Column Name", "Data Type (DbTools)", "Data Type", "Column Length", "Column Scale", "Allow Nulls", "Primary Key", "Identity", "Default Value", "Description");
}
else
{
WriteLine("All columns", "Category", "Schema", "Table Name", "Column Name", "Data Type", "Column Length", "Column Scale", "Allow Nulls", "Primary Key", "Identity", "Default Value", "Description");
}
}
else
{
WriteLine("Tables", "Schema", "Table Name", "Link", "Number of columns", "Description");
if (!Context.DocumenterSettings.NoInternalDataTypes)
{
WriteLine("All columns", "Schema", "Table Name", "Column Name", "Data Type (DbTools)", "Data Type", "Column Length", "Column Scale", "Allow Nulls", "Primary Key", "Identity", "Default Value", "Description");
}
else
{
WriteLine("All columns", "Schema", "Table Name", "Column Name", "Data Type", "Column Length", "Column Scale", "Allow Nulls", "Primary Key", "Identity", "Default Value", "Description");
}
}
// Ensure sheet order
if (Customizer is PatternMatchingTableCustomizer)
{
Write("Patt.ma.-tables");
Write("Patt.ma.-patterns");
Write("Patt.ma.-ma.s w exceptions");
Write("Patt.ma.-no matches (unused)");
}
foreach (var tableKvp in _sqlTablesByCategory.OrderBy(kvp => kvp.Key).ThenBy(t => t.Value.SchemaAndTableName.Schema).ThenBy(t => t.Value.SchemaAndTableName.TableName))
{
Context.Logger.Log(LogSeverity.Verbose, "Generating {TableName}.", "Documenter", tableKvp.Value.SchemaAndTableName);
var category = tableKvp.Key;
var table = tableKvp.Value;
AddTableToTableList(category, table, hasCategories);
var sheetColor = GetColor(table.SchemaAndTableName);
if (sheetColor != null)
{
DocumenterWriter.SetSheetColor(Helper.GetSimplifiedSchemaAndTableName(table.SchemaAndTableName), sheetColor.Value);
}
AddTableHeader(hasCategories, category, table);
AddTableDetails(category, table, hasCategories);
}
WriteLine("Tables");
foreach (var tableKvp in _skippedSqlTablesByCategory.OrderBy(kvp => kvp.Key).ThenBy(t => t.Value.SchemaAndTableName.Schema).ThenBy(t => t.Value.SchemaAndTableName.TableName))
{
var category = tableKvp.Key;
var table = tableKvp.Value;
AddTableToTableList(category, table, hasCategories);
}
Context.Logger.Log(LogSeverity.Verbose, "Generating pattern matching info.", "Documenter");
AddPatternMatching();
AddPatternMatchingNoMatch();
Log(LogSeverity.Information, "Generating Document content.", "Documenter");
var content = DocumenterWriter.GetContent();
var fileName = FileName ?? (DatabaseName?.Length == 0 ? "Database.xlsx" : DatabaseName + ".xlsx");
var path = Context.DocumenterSettings?.WorkingDirectory;
Log(LogSeverity.Information, "Writing Document file {FileName} to folder {Folder}", "Documenter", fileName, path);
if (!string.IsNullOrEmpty(path))
{
fileName = Path.Combine(path, fileName);
}
File.WriteAllBytes(fileName, content);
}
public DatabaseCreator(DatabaseDefinition databaseDefinition, SqlStatementExecuter sqlExecuter)
: base(sqlExecuter)
{
DatabaseDefinition = databaseDefinition;
}
public Cluster Install(bool system, string clusterName, string username, string email, string password)
{
cluster = new Cluster(Context)
{
Name = clusterName,
System = system,
};
cluster.Save();
// Create machine roles and machines
// -- controller role
var mrcont = new MachineRole(cluster)
{
Name = Constants.ControllerMachineRoleName,
System = system,
MachineRoleType = MachineRoleType.StandAlone,
};
mrcont.Save();
var sv = new ServerVersion(mrcont)
{
Name = Constants.ServerVersionName,
System = system,
};
sv.Save();
var mcont = new Machine(mrcont)
{
Name = Constants.ControllerMachineName,
};
mcont.Save();
var sicont = new ServerInstance(mcont)
{
Name = Constants.ServerInstanceName,
ServerVersion = sv,
};
sicont.Save();
// -- node role
var mrnode = new MachineRole(cluster)
{
Name = Constants.NodeMachineRoleName,
MachineRoleType = MachineRoleType.MirroredSet,
};
mrnode.Save();
var nodesv = new ServerVersion(mrnode)
{
Name = Constants.ServerVersionName,
};
nodesv.Save();
// -- Create a node
/*
* Machine mnode = new Machine(Context, mrnode);
* mnode.Name = Constants.NodeMachineName;
* mnode.Save();
*
* si = new ServerInstance(Context, mnode);
* si.Name = Constants.ServerInstanceName;
* si.ServerVersionReference.Value = sv;
* si.Save();*/
// Create the shared domain for cluster level databases and users
var domain = new Domain(cluster)
{
Name = Constants.SharedDomainName,
Email = email,
System = system,
};
domain.Save();
// Create administrator group and user
GenerateAdminGroup(system);
GenerateAdmin(system, username, email, password);
// Create the shared feredation
var federation = new Federation(domain)
{
Name = Constants.SharedFederationName,
Email = email,
System = system,
ControllerMachine = mcont,
SchemaSourceServerInstance = sicont,
};
federation.Save();
// Temp database definition
var tempdd = new DatabaseDefinition(federation)
{
Name = Constants.TempDbName,
System = system,
LayoutType = DatabaseLayoutType.Monolithic,
DatabaseInstanceNamePattern = Constants.TempDbInstanceNamePattern,
DatabaseNamePattern = Constants.TempDbNamePattern,
SliceCount = 1,
PartitionCount = 1,
};
tempdd.Save();
var tempddi = new DatabaseDefinitionInstaller(tempdd);
tempddi.GenerateDefaultChildren(nodesv, Constants.TempDbName);
// Create cluster level jobs and queues
// -- admin queue definition
QueueDefinition qd = new QueueDefinition(cluster)
{
Name = Constants.MaintenanceQueueDefinitionName,
System = system,
};
qd.Save();
QueueInstance qi = new QueueInstance(mcont)
{
Name = Constants.MaintenanceQueueName,
RunningState = Registry.RunningState.Running,
};
qi.QueueDefinitionReference.Value = qd;
qi.Save();
// -- long queue definition
qd = new QueueDefinition(cluster)
{
Name = Constants.LongQueueDefinitionName
};
qd.Save();
qi = new QueueInstance(mcont)
{
Name = Constants.LongQueueName,
RunningState = Registry.RunningState.Running,
};
qi.QueueDefinitionReference.Value = qd;
qi.Save();
// -- quick queue definition
qd = new QueueDefinition(cluster)
{
Name = Constants.QuickQueueDefinitionName,
};
qd.Save();
qi = new QueueInstance(mcont)
{
Name = Constants.QuickQueueName,
RunningState = Registry.RunningState.Running,
};
qi.QueueDefinitionReference.Value = qd;
qi.Save();
// -- database mirror job
var jd = new JobDefinition(federation)
{
Name = typeof(Jhu.Graywulf.Jobs.MirrorDatabase.MirrorDatabaseJob).Name,
System = system,
WorkflowTypeName = typeof(Jhu.Graywulf.Jobs.MirrorDatabase.MirrorDatabaseJob).AssemblyQualifiedName,
};
jd.DiscoverWorkflowParameters();
jd.Save();
// -- test job
jd = new JobDefinition(federation)
{
Name = typeof(Jhu.Graywulf.Jobs.Test.TestJob).Name,
System = system,
WorkflowTypeName = typeof(Jhu.Graywulf.Jobs.Test.TestJob).AssemblyQualifiedName,
};
jd.DiscoverWorkflowParameters();
jd.Save();
return(cluster);
}
private void Button1_Click(object sender, EventArgs e)
{
if (!System.IO.Directory.Exists(Directory))
{
MessageBox.Show("You must select an output directory before trying to generate!");
return;
}
var connectionString = this.txt_ConnectionString.Text;
if (string.IsNullOrWhiteSpace(connectionString))
{
Log("Connection string is not provide, process aborted.");
}
Log($"Start generate with settings : mode : {mode} | language : {language}");
Task.Run(() =>
{
DatabaseDefinition databaseDefinition = GetDatabaseDefinition(connectionString);
try
{
switch (mode)
{
case SupportMode.Model:
var provider = language switch
{
SupportLanguage.CSharp => CSharpModelProvider.Context,
SupportLanguage.TypeScript => TypeScriptModelProvider.Context,
SupportLanguage.VisualBasic => VisualBasicModelProvider.Context,
_ => throw new NotSupportedException()
};
var modelGenerator = new ModelBuilder(Directory + "\\Models", Namespace, databaseDefinition);
modelGenerator.OnFileGenerated += (f) => Log($"Generated {f}");
modelGenerator.Generate(provider);
break;
case SupportMode.BackendService:
var serviceProvider = language switch
{
SupportLanguage.CSharp => CSharpServiceProvider.Context,
SupportLanguage.TypeScript => TypescriptServiceProvider.Context,
_ => throw new NotSupportedException()
};
var serviceGenerator = new ServiceBuilder(Directory, Namespace, databaseDefinition);
serviceGenerator.OnFileGenerated += (f) => Log($"Generated {f}");
serviceGenerator.Generate(serviceProvider);
//GeneratorFactory.PerformRepositoryGenerate(targetLanguage, targetDatabaseConnector, txt_connectionString.Text, outputDir, txt_namespace.Text);
break;
case SupportMode.FrontendService:
var consumerServiceProvider = language switch
{
SupportLanguage.CSharp => CSharpConsumerServiceProvider.Context,
_ => throw new NotSupportedException()
};
var consumerGenerator = new ServiceBuilder(Directory, Namespace, databaseDefinition);
consumerGenerator.OnFileGenerated += (f) => Log($"Geenrated {f}");
consumerGenerator.Generate(consumerServiceProvider);
break;
}
Log($"All tasks are done.");
this.Close();
}
catch (Exception ex)
{
Log($"Error with message : {ex.Message}");
}
});
}
public void Test()
{
var dbdef = new DatabaseDefinition()
.Table("KV")
.Column("Key").AsString().NotNull().Table
.Column("Value").AsText().NotNull().Table
.Index("IX_KV_Key").Asc("Key").Primary().Table
.Database;
var db = new EsentDatabase(@"c:\temp\fluesent\a.db");
using (var instance = db.CreateInstance())
{
using (var session = instance.CreateSession(false))
{
session.CreateDatabase(null, CreateDatabaseGrbit.OverwriteExisting);
using (var transaction = session.CreateTransaction())
{
dbdef.Create(transaction);
transaction.Commit();
}
}
}
using (var instance = db.CreateInstance())
{
using (var session = instance.CreateSession())
{
using (var transaction = session.CreateTransaction())
{
using (var table = transaction.OpenTable("KV"))
{
table.CreateInsertRecord()
.AddString("Key", "A")
.AddString("Value", "Some text")
.Insert();
table.CreateInsertRecord()
.AddString("Key", "B")
.AddString("Value", "Another text")
.Insert();
table.CreateInsertRecord()
.AddString("Key", "C")
.AddString("Value", "Text for C")
.Insert();
}
transaction.Commit();
}
}
}
using (var instance = db.CreateInstance())
{
using (var session = instance.CreateSession())
{
using (var transaction = session.CreateTransaction())
{
var stopwatch = new EsentStopwatch();
stopwatch.Start();
const int n = 100000;
using (var table = transaction.OpenTable("KV"))
{
foreach (var i in Enumerable.Range(0, n))
{
table.CreateInsertRecord()
.AddString("Key", "key" + i)
.AddString("Value", "akjsdhakhdkadhkajhd")
.Insert();
if ((i % 1000) == 999)
{
transaction.Pulse();
}
}
}
transaction.Commit();
stopwatch.Stop();
Console.Out.WriteLine("Inserted {0} records in {1}", n, stopwatch.Elapsed);
}
}
}
using (var instance = db.CreateInstance())
{
using (var session = instance.CreateSession())
{
using (var transaction = session.CreateTransaction())
{
using (var table = transaction.OpenTable("KV"))
{
var mapper = new RecordMapper<KvRecord>()
.String("Key", (o, s) => o.Key = s)
.String("Value", (o, s) => o.Value = s);
//var search = table.CreateSearch(mapper);
//var a = search.FindEq(
// table.CreateKey().String("A")
// )
// .ToArray();
//var b = search.FindEq(
// table.CreateKey().String("B")
// )
// .ToArray();
}
}
}
}
using (var instance = db.CreateInstance())
{
using (var session = instance.CreateSession())
{
session.AttachDatabase();
session.OpenDatabase();
using (var transaction = session.CreateTransaction())
{
using (var table = transaction.OpenTable("KV"))
{
var mapper = new RecordMapper<KvRecord>()
.String("Key", (o, s) => o.Key = s)
.String("Value", (o, s) => o.Value = s);
//var search = table.CreateSearch(mapper);
//foreach (var record in search.FindAll().Take(100))
//{
// Console.Out.WriteLine("({0},{1})",record.Key,record.Value);
//}
}
}
}
}
}
public AppOptions()
{
_source = new DatabaseDefinition();
_target = new DatabaseDefinition();
ExcludeSchemas = new HashSet <string>();
}
public AppOptions()
{
_source = new DatabaseDefinition();
}
public void CreateBackup2(string fullPath)
{
// Current version of backup system
int backupVersion = 2;
string sql = "select top 1 [DatabaseVersion] from [EasyBaseSystems]";
int databaseVersion = Convert.ToInt32(Connection.GetScalar(sql));
if (databaseVersion != DatabaseDefinition.DatabaseVersion)
{
throw new DatabaseVersionException("Wrong database version. The database's version is " + databaseVersion + ", but the current version of the application is " + DatabaseDefinition.DatabaseVersion + ". Backup is not possible.");
}
DatabaseSchema savedDatabase = new DatabaseSchema(DatabaseDefinition.GetDatabaseXmlDefinition(DatabaseDefinition.DatabaseVersion));
long totalRowsInDB = 0;
sql = "select (";
string plus = "";
foreach (TableSchema table in savedDatabase.Tables)
{
sql = sql + plus + "(select count(*) from [" + table.TableName + "])";
plus = "+";
}
sql += ")";
totalRowsInDB = Convert.ToInt64(Connection.GetScalar(sql));
StreamWriter streamWriter = new StreamWriter(fullPath);
streamWriter.Write("[" + backupVersion + ";" + CurrentApplication.Name + ";" + DatabaseDefinition.DatabaseVersion + ";" + totalRowsInDB + "]");
foreach (TableSchema table in savedDatabase.Tables)
{
StringBuilder commaSeparatedFields = new StringBuilder();
string comma = "";
foreach (FieldSchema field in table.DatabaseFields)
{
commaSeparatedFields.Append(comma + "[" + field.FieldName + "]");
comma = ", ";
}
sql = "select " + commaSeparatedFields + " from [" + table.TableName + "]";
DataTable dataTable = new DataTable();
Connection.GetTable(dataTable, sql);
streamWriter.Write("[" + table.TableName + ";" + dataTable.Rows.Count + "]");
if (dataTable.Rows.Count > 0)
{
foreach (FieldSchema field in table.DatabaseFields)
{
streamWriter.Write("[" + field.FieldName + "]");
foreach (DataRow dataRow in dataTable.Rows)
{
string data = field.SerializeData(dataRow[field.FieldName]);
streamWriter.Write(data);
}
}
}
}
streamWriter.Flush();
streamWriter.Close();
}
public AppOptions()
{
_source = new DatabaseDefinition();
_target = new DatabaseDefinition();
Files = new HashSet <string>();
}
public Task UpdateDatabaseAsync(DatabaseDefinition databaseDefinition)
{
throw new NotImplementedException();
}
/// <summary>
/// Designed for SQL Server, might not work with other DB Provider.
/// </summary>
/// <typeparam name="TDatabase"></typeparam>
/// <typeparam name="TParameter"></typeparam>
/// <param name="connectionString"></param>
/// <returns></returns>
public static DatabaseDefinition GetDatabaseDefinition <TDatabase, TParameter>(string connectionString, Func <string, string> tableNameTransformer = null)
where TDatabase : DbConnection, new()
where TParameter : DbParameter, new()
{
using var connection = new TDatabase()
{
ConnectionString = connectionString
};
connection.Open();
var result = new DatabaseDefinition();
result.Tables = new List <Table>();
result.ConnectionString = connectionString;
result.DatabaseProvider = typeof(TDatabase);
result.DatabaseProviderParameterType = typeof(TParameter);
try
{
result.StoredProcedures = connection.GetStoredProcedures().ToList();
}
catch
{
result.StoredProcedures = Enumerable.Empty <StoredProcedureSchema>().ToList();
}
using var tables = connection.GetSchema(SchemaRestriction.Tables);
foreach (DataRow row in tables.Rows)
{
try
{
var database = row[0].ToString();
var schema = row[1].ToString();
var tableName = row[2].ToString();
var type = row[3].ToString();
var schemaSearchName = tableNameTransformer != null?tableNameTransformer(tableName) : tableName;
var columns = connection.GetTableSchema(schemaSearchName);
string?primaryKey = null;
using var indexes = connection.GetSchema("IndexColumns", new[] { null, null, tableName });
if (indexes != null)
{
foreach (DataRow rowInfo in indexes.Rows)
{
primaryKey = rowInfo["column_name"].ToString();
}
}
var table = new Table()
{
Name = tableName,
Columns = columns,
PrimaryKey = primaryKey,
ConnectionProvider = typeof(TDatabase).FullName,
ConnectionProviderParameterType = typeof(TParameter).FullName
};
result.Tables.Add(table);
}
catch
{
//continue;
}
}
return(result);
}
private void Button_Click(object sender, RoutedEventArgs e)
{
var outputDir = txt_outputDir.Content.ToString();
if (!Directory.Exists(outputDir))
{
MessageBox.Show("You must select an output directory before trying to generate!");
return;
}
btn_Generate.IsEnabled = false;
var connectionString = txt_connectionString.Text;
var @namespace = txt_namespace.Text;
if (string.IsNullOrWhiteSpace(connectionString))
{
Log("Connection string is not provide, process aborted.");
}
Log($"Start generate with settings : mode : {mode} | language : {language}");
Task.Run(async() =>
{
try
{
DatabaseDefinition databaseDefinition = GetDatabaseDefinition(connectionString);
switch (mode)
{
case SupportMode.Model:
var provider = language switch
{
SupportLanguage.CSharp => CSharpModelProvider.Context,
SupportLanguage.TypeScript => TypeScriptModelProvider.Context,
SupportLanguage.VisualBasic => VisualBasicModelProvider.Context,
_ => throw new NotSupportedException()
};
var modelGenerator = new ModelBuilder(outputDir, @namespace, databaseDefinition);
modelGenerator.OnFileGenerated += (f) => Log($"Generated {f}");
modelGenerator.Generate(provider);
break;
case SupportMode.FrontendService:
var consumerServiceProvider = language switch
{
SupportLanguage.CSharp => CSharpConsumerServiceProvider.Context,
SupportLanguage.TypeScript => TypescriptServiceProvider.Context,
_ => throw new NotSupportedException()
};
var consumerGenerator = new ServiceBuilder(outputDir, @namespace, databaseDefinition);
consumerGenerator.OnFileGenerated += (f) => Log($"Geenrated {f}");
consumerGenerator.Generate(consumerServiceProvider);
break;
case SupportMode.BackendService:
IServiceBuilderProvider serviceProvider = language switch
{
SupportLanguage.CSharp => CSharpServiceProvider.Context,
_ => throw new NotSupportedException()
};
var serviceGenerator = new ServiceBuilder(outputDir, @namespace, databaseDefinition);
serviceGenerator.OnFileGenerated += (f) => Log($"Generated {f}");
serviceGenerator.Generate(serviceProvider);
//GeneratorFactory.PerformRepositoryGenerate(targetLanguage, targetDatabaseConnector, txt_connectionString.Text, outputDir, txt_namespace.Text);
break;
case SupportMode.Controller:
IControllerProvider controllerProvider = language switch
{
SupportLanguage.CSharp => CSharpControllerProvider.Context,
_ => throw new NotSupportedException()
};
var controllerGenerator = new ControllerBuilder(outputDir, @namespace, databaseDefinition);
controllerGenerator.OnFileGenerated += (f) => Log($"Generated {f}");
controllerGenerator.Generate(controllerProvider);
break;
}
Log($"All tasks are done.");
Process.Start("explorer.exe", outputDir);
}
catch (Exception ex)
{
Log($"Error with message : {ex.Message}");
}
});
btn_Generate.IsEnabled = true;
}
public void RestoreBackup(string fullPath, int toDatabaseVersion)
{
var reader = new StreamReader(fullPath);
var header = new StringBuilder();
int backupVersion = 0;
int databaseVersion = 0;
string databaseApplicationName = "";
long totalRowsInDB = 0;
try {
// Read header
char token = ' ';
while (token != ']')
{
token = (char)reader.Read();
if (token != '[' && token != ']')
{
header.Append(token);
}
}
string[] headerArray = header.ToString().Split(";".ToCharArray());
backupVersion = int.Parse(headerArray[0]);
databaseVersion = 0;
databaseApplicationName = "";
if (backupVersion == 1)
{
databaseVersion = int.Parse(headerArray[1]);
}
else
{
databaseApplicationName = headerArray[1];
databaseVersion = int.Parse(headerArray[2]);
totalRowsInDB = long.Parse(headerArray[3]);
}
}
catch (Exception ex) {
throw new BackupException("Backupfilens huvud har ett felaktigt format.", ex);
}
if (backupVersion >= 2)
{
if (databaseApplicationName != CurrentApplication.Name)
{
throw new BackupException("Den aktuella backupen tillhör inte det här programmet. Backupen är en backup för programmet \"" + databaseApplicationName + "\".");
}
}
// Create database
var database = new DatabaseSchema(DatabaseDefinition.GetDatabaseXmlDefinition(databaseVersion));
CreateDatabaseNoConstraints(databaseVersion);
// Call function that reads all table contents from the backup file.
switch (backupVersion)
{
case 1:
RestoreBackup1(reader, database, backupVersion);
break;
case 2:
RestoreBackup2(reader, database, backupVersion, totalRowsInDB);
break;
default:
throw new NotImplementedException("Backup version " + backupVersion + " is not implemented.");
}
// Efter inläsning, uppdatera databasen till senaste versionen
RunSqlUpdateCommands(CollectSqlUpdateDatabase(false, toDatabaseVersion));
}
public SqlParameter(DatabaseDefinition databaseDefinition)
{
DatabaseDefinition = databaseDefinition;
}
internal void Add(String key, DatabaseDefinition value)
{
databaseDefinitions.Add(key, value);
}
public static RelationalModel Convert(DatabaseDefinition sourceDefinition, string defaultSourceSchemaName, CaseInsensitiveStringKeyDictionary <string> schemaNameMap = null, Func <SqlTable, bool> filterDelegate = null)
{
var newDefaultSchemaName = schemaNameMap?[defaultSourceSchemaName] ?? defaultSourceSchemaName;
var newModel = new RelationalModel(newDefaultSchemaName);
var sourceTablesOrdered = sourceDefinition.GetTables()
.Where(x => filterDelegate?.Invoke(x) != false)
.OrderBy(x => x.SchemaAndTableName.SchemaAndName)
.ToList();
foreach (var sourceTable in sourceTablesOrdered)
{
var newSchemaName = schemaNameMap?[sourceTable.SchemaAndTableName.Schema] ?? sourceTable.SchemaAndTableName.Schema ?? newDefaultSchemaName;
var newSchema = newModel[newSchemaName]
?? newModel.AddSchema(newSchemaName);
var primaryKey = sourceTable.Properties.OfType <PrimaryKey>().FirstOrDefault();
var newTable = newSchema.AddTable(sourceTable.SchemaAndTableName.TableName);
foreach (var property in sourceTable.Properties.OfType <DwhTableFlagProperty>())
{
newTable.SetFlag(property.Name, true);
}
foreach (var property in sourceTable.Properties.OfType <DwhTableDataProperty>())
{
newTable.SetAdditionalData(property.Name, property.Value);
}
if (sourceTable.HasProperty <EtlRunInfoDisabledProperty>())
{
newTable.SetEtlRunInfoDisabled();
}
if (sourceTable.HasProperty <HasHistoryTableProperty>())
{
newTable.SetHasHistoryTable();
}
var sourceTableNameOverrideProperty = sourceTable.Properties.OfType <SourceTableNameOverrideProperty>().FirstOrDefault();
if (sourceTableNameOverrideProperty != null)
{
newTable.SetSourceTableNameOverride(sourceTableNameOverrideProperty.SourceTableName);
}
foreach (var sourceColumn in sourceTable.Columns)
{
var partOfPrimaryKey = primaryKey?.SqlColumns.Any(x => x.SqlColumn == sourceColumn) == true;
var newColumn = newTable.AddColumn(sourceColumn.Name, partOfPrimaryKey);
foreach (var property in sourceColumn.Properties.OfType <DwhColumnFlagProperty>())
{
newColumn.SetFlag(property.Name, true);
}
foreach (var property in sourceColumn.Properties.OfType <DwhColumnDataProperty>())
{
newColumn.SetAdditionalData(property.Name, property.Value);
}
if (sourceColumn.HasProperty <Identity>())
{
newColumn.SetIdentity();
}
if (sourceColumn.HasProperty <HistoryDisabledProperty>())
{
newColumn.SetHistoryDisabled();
}
if (sourceColumn.HasProperty <RecordTimestampIndicatorProperty>())
{
newColumn.SetRecordTimestampIndicator();
}
}
}
foreach (var table in sourceTablesOrdered)
{
var newSourceSchemaName = schemaNameMap?[table.SchemaAndTableName.Schema] ?? table.SchemaAndTableName.Schema ?? newDefaultSchemaName;
var newSourceSchema = newModel[newSourceSchemaName];
var newSourceTable = newSourceSchema[table.SchemaAndTableName.TableName];
foreach (var fk in table.Properties.OfType <ForeignKey>())
{
var newTargetSchemaName = schemaNameMap?[fk.ReferredTable.SchemaAndTableName.Schema] ?? fk.ReferredTable.SchemaAndTableName.Schema ?? newDefaultSchemaName;
var newTargetSchema = newModel[newTargetSchemaName];
var newTargetTable = newTargetSchema[fk.ReferredTable.SchemaAndTableName.TableName];
if (newTargetTable == null) // target table is filtered out
{
continue;
}
var newFk = newSourceTable.AddForeignKeyTo(newTargetTable);
foreach (var map in fk.ForeignKeyColumns)
{
var sourceColumn = newSourceTable[map.ForeignKeyColumn.Name];
var targetColumn = newTargetTable[map.ReferredColumn.Name];
newFk.AddColumnPair(sourceColumn, targetColumn);
}
}
}
return(newModel);
}
private void Application_Startup(object sender, StartupEventArgs e)
{
AppConfig.Init();
DatabaseDefinition.CreateDatabase();
DatabaseDefinition.SeedDatabase();
}