public Database(IDatabaseSchema databaseSchema)
{
classes = databaseSchema.Classes.Select(c => new Class
{
fields =
databaseSchema.Properties.Where(p => p.Value.ParentClassId == c.Value.ClassId.Id)
.Select(f => new Field {
name = f.Value.Name, protectionLevel = MUTDODQLProtectionLevel.Public
})
.ToList(),
isGeneric = false,
methods =
databaseSchema.Methods.ContainsKey(c.Key)
? databaseSchema.Methods[c.Key].Select(
m =>
new Method
{
name = m,
protectionLevel = MUTDODQLProtectionLevel.Public,
parameters = new List <Param>()
}).ToList()
: new List <Method>(),
protectionLevel = MUTDODQLProtectionLevel.Public,
name = c.Value.Name
}).ToList();
}
public override void Resolve(IDatabaseSchema database, IDBTable table)
{
base.Resolve (database, table);
ReferencesTable = database[ReferencesTableName];
ThroughTable = database[ThroughTableName];
ThroughColumnThis = FindFk(this.Table, ThroughColumnNameThis);
ThroughColumnThat = FindFk(ReferencesTable, ThroughColumnNameThat);
}
public void TestIsNotNull()
{
DTOQuery inputQuery = new DTOQuery();
IDatabaseSchema databaseSchema = CreateEmptyDatabaseSchema();
inputQuery.QueryText = "Student where name is not null;";
IQueryAnalyzer analizer = new EBNFQueryAnalyzer();
}
public async Task DeleteAsync(IDatabaseSchema schema)
{
Ensure.NotNull(schema, nameof(schema));
await db.DatabaseSchemas.PatchAsync(schema.Id, new[] {
Change.Replace("deleted", Now)
}, condition : IsNull("deleted"));
}
public IQueryTree ParseQuery(IQuery inputQuery, IDatabaseSchema databaseSchema)
{
SyntaxAnalyzer.SyntaxAnalyzer syntaxAlr = new SyntaxAnalyzer.SyntaxAnalyzer();
QueryTree qt = syntaxAlr.CheckQuerySyntax(inputQuery.QueryText);
SemanticAnalyzer.SemanticAnalyzer semanticAlr = new SemanticAnalyzer.SemanticAnalyzer();
semanticAlr.CheckQuerySemantic(qt, new Database(databaseSchema));
return(qt);
}
public void SaveSchema(IDatabaseSchema schema)
{
if (!_metadata.Databases.ContainsKey(schema.DatabaseId))
{
throw new DatabaseNotFoundException(String.Format("Nie odnaleziono bazy danych o id: '{0}'",
schema.DatabaseId));
}
_metadata.Databases[schema.DatabaseId].Schema = schema;
StorageMetadata.SaveMetadata(_metadata, _logger);
}
/// <summary>
/// 初始化
/// </summary>
/// <param name="databaseSchema">获取数据库结构信息接口</param>
/// <param name="tableSchema">表架构接口</param>
public BuildDatabase(IDatabaseSchema databaseSchema, ITableSchema tableSchema)
{
if (databaseSchema == null)
{
throw new ArgumentNullException("databaseSchema");
}
if (tableSchema == null)
{
throw new ArgumentNullException("tableSchema");
}
this.databaseSchema = databaseSchema;
this.tableSchema = tableSchema;
}
/// <summary>
/// 释放资源
/// </summary>
public void Dispose()
{
if (databaseSchema != null)
{
databaseSchema.Dispose();
}
if (tableSchema != null)
{
tableSchema.Dispose();
}
this.databaseSchema = null;
this.tableSchema = null;
}
public override void Resolve(IDatabaseSchema database, IDBTable table)
{
base.Resolve (database, table);
try
{
ReferencesTable = database[ReferencesTableName];
}
catch(KeyNotFoundException ex)
{
throw new Exception("Tabulka "+ReferencesTableName+" nebyla nalezena", ex);
}
if(ReferencesColumnName != null)
ReferencesColumn = ReferencesTable[ReferencesColumnName];
else
ReferencesColumn = ReferencesTable.PrimaryKey;
}
public static void InitDb <T>(T db) where T : Afx.Data.Entity.EntityContext
{
if (!ConfigUtils.InitDatabase || IsInit)
{
return;
}
lock (lockObj)
{
if (IsInit)
{
return;
}
string connectionString = ConfigUtils.ConnectionString;
IDatabaseSchema databaseSchema = null;
ITableSchema tableSchema = null;
switch (ConfigUtils.DatabaseType)
{
case DatabaseType.MSSQLServer:
databaseSchema = new Afx.Data.MSSQLServer.Entity.Schema.MsSqlDatabaseSchema(connectionString);
tableSchema = new Afx.Data.MSSQLServer.Entity.Schema.MsSqlTableSchema(connectionString);
break;
case DatabaseType.MySQL:
databaseSchema = new Afx.Data.MySql.Entity.Schema.MySqlDatabaseSchema(connectionString);
tableSchema = new Afx.Data.MySql.Entity.Schema.MySqlTableSchema(connectionString);
break;
default:
throw new Exception("【InitDatabase】InitDb, 数据库类型错误！");
}
//更新数据库结构sql 日志
databaseSchema.Log = WriteSQL;
tableSchema.Log = WriteSQL;
using (var build = new BuildDatabase(databaseSchema, tableSchema))
{
build.Build <T>();
}
IsInit = true;
}
}
public GeneratorSettings(IDatabaseSchema schema)
{
EntityFrameworkVersion = EntityFrameworkVersion.v6;
DatabaseName = schema.Name;
switch (schema.Provider.Name) {
case "SQLAnywhereSchemaProvider":
SchemaProviderName = "iAnywhere.Data.SQLAnywhere";
SchemaProviderManifestToken = "12";
break;
case "MySQLSchemaProvider":
SchemaProviderName = "MySql.Data.MySqlClient";
SchemaProviderManifestToken = "5.5";
break;
default:
SchemaProviderName = "System.Data.SqlClient";
SchemaProviderManifestToken = "2008";
break;
}
}
public GeneratorSettings(IDatabaseSchema schema)
{
EntityFrameworkVersion = EntityFrameworkVersion.v6;
DatabaseName = schema.Name;
switch (schema.Provider.Name)
{
case "SQLAnywhereSchemaProvider":
SchemaProviderName = "iAnywhere.Data.SQLAnywhere";
SchemaProviderManifestToken = "12";
break;
case "MySQLSchemaProvider":
SchemaProviderName = "MySql.Data.MySqlClient";
SchemaProviderManifestToken = "5.5";
break;
default:
SchemaProviderName = "System.Data.SqlClient";
SchemaProviderManifestToken = "2008";
break;
}
}
/// <summary>
/// 释放资源
/// </summary>
public void Dispose()
{
if (databaseSchema != null)
{
databaseSchema.Dispose();
}
if (dbContexSchema != null)
{
dbContexSchema.Dispose();
}
if (modelSchema != null)
{
modelSchema.Dispose();
}
if (tableSchema != null)
{
tableSchema.Dispose();
}
this.databaseSchema = null;
this.dbContexSchema = null;
this.modelSchema = null;
this.tableSchema = null;
}
/// <summary>
/// 初始化
/// </summary>
/// <param name="databaseSchema"></param>
/// <param name="tableSchema"></param>
/// <param name="dbContextSchema"></param>
/// <param name="modelSchema"></param>
public BuildModel(IDatabaseSchema databaseSchema, ITableSchema tableSchema,
IDbContextSchema dbContextSchema, IModelSchema modelSchema)
{
if (databaseSchema == null)
{
throw new ArgumentNullException("databaseSchema");
}
if (tableSchema == null)
{
throw new ArgumentNullException("tableSchema");
}
if (dbContextSchema == null)
{
throw new ArgumentNullException("dbContextSchema");
}
if (modelSchema == null)
{
throw new ArgumentNullException("modelSchema");
}
this.databaseSchema = databaseSchema;
this.tableSchema = tableSchema;
this.dbContexSchema = dbContextSchema;
this.modelSchema = modelSchema;
}
private void ExecuteSchemaAction(
SchemaAction schemaAction,
IDatabaseSchema databaseSchema)
{
schemaActionDictionary[schemaAction](databaseSchema);
}
public void Execute(DBTriggerPosition action, IDatabaseSchema database, IDBTable table, string query, DataRow row)
{
throw new NotImplementedException();
}
public DatabaseConnection(IDatabaseSchema Schema, string url)
{
this.Schema = Schema;
this.Server = new ServerConnection(url);
}
/// <summary>
/// Compare the source schema to the target schema
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void btnCompare_Click(object sender, EventArgs e)
{
rtbSourceText.Clear();
tvComparison.Nodes.Clear();
spcSource.ReportProgress($@"Validating...");
if (!spcSource.IsValid())
{
MessageBox.Show(@"Source schema is not correctly specified.", @"Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
spcSource.ReportProgress(string.Empty);
return;
}
if (!spcTarget.IsValid())
{
MessageBox.Show(@"Target schema is not correctly specified.", @"Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
spcSource.ReportProgress(string.Empty);
return;
}
if (!ValidateSettings())
{
return;
}
// Load both of the schemas
Cursor lastCursor = Cursor.Current;
Cursor.Current = Cursors.WaitCursor;
IDatabaseSchema TryGetSchema(Func <Either <IOperationError, DatabaseSchema> > schema)
{
try
{
return(schema()
.Map(valid => (IDatabaseSchema) new ValidDatabaseSchema(() => valid))
.Reduce(
schemaError => new InvalidDatabaseSchema(schemaError)));
}
catch (Exception exception)
{
return(new InvalidDatabaseSchema(new NonSpecificOperationError(exception)));
}
}
Func <DefaultOperationErrorMessageResolver> errorMessageResolver = DefaultOperationErrorMessageResolver
.Using(() => new List <IOperationErrorMessageSpecification>()
{
KustoOperationErrorSpecifications.ClusterNotFound(),
KustoOperationErrorSpecifications.DatabaseNotFound(),
KustoOperationErrorSpecifications.CannotAuthenticate(),
FilePathOperationErrorSpecifications.FolderNotFound()
});
spcSource.ReportProgress($@"Loading source schema...");
IDatabaseSchema sourceSchema = TryGetSchema(() => spcSource.TryLoadSchema());
spcSource.ReportProgress($@"Schema loaded.");
spcTarget.ReportProgress($@"Loading target schema...");
IDatabaseSchema targetSchema = sourceSchema is InvalidDatabaseSchema _
? new InvalidDatabaseSchema(new NonSpecificOperationError(
new InvalidOperationException("Target schema not loaded due to Source schema error.")))
: TryGetSchema(() => spcTarget.TryLoadSchema());
switch (sourceSchema)
{
case InvalidDatabaseSchema invalidSource:
MessageBox.Show($@"The Source schema is invalid: {errorMessageResolver().ResolveFor(invalidSource.Error).Get()}", @"Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
case ValidDatabaseSchema _ when targetSchema is InvalidDatabaseSchema invalidTarget:
MessageBox.Show($@"The Target schema is invalid: {errorMessageResolver().ResolveFor(invalidTarget.Error).Get()}", @"Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
case ValidDatabaseSchema source when targetSchema is ValidDatabaseSchema target:
spcTarget.ReportProgress($@"Schema loaded.");
_sourceSchema = source.Schema;
_targetSchema = target.Schema;
break;
}
Cursor.Current = lastCursor;
spcSource.ReportProgress($@"Comparing differences...");
IEnumerable <SchemaDifference> tableDifferences = new KustoSchemaDifferenceMapper(() =>
_sourceSchema.Tables.AsKustoSchema().DifferenceFrom(_targetSchema.Tables.AsKustoSchema()))
.GetDifferences();
IEnumerable <SchemaDifference> functionDifferences = new KustoSchemaDifferenceMapper(() =>
_sourceSchema.Functions.AsKustoSchema().DifferenceFrom(_targetSchema.Functions.AsKustoSchema()))
.GetDifferences();
// Add to the tree view control
PopulateTree(tableDifferences.Concat(functionDifferences), tvComparison);
spcSource.ReportProgress(string.Empty);
spcTarget.ReportProgress(string.Empty);
// Enable the update button now that a comparison has been generated.
btnUpdate.Enabled = true;
}
public HomeService(ISampleDatabase sampleDatabase, IDatabaseSchema dataBaseSchema)
{
this.sampleDatabase = sampleDatabase;
this.dataBaseSchema = dataBaseSchema;
}
public Oid SaveSchema(IDatabaseSchema schema)
{
throw new NotImplementedException();
}
/// <summary>
/// 初始化
/// </summary>
/// <param name="databaseSchema"></param>
/// <param name="tableSchema"></param>
/// <param name="modelSchema"></param>
public BuildModel(IDatabaseSchema databaseSchema, ITableSchema tableSchema, IModelSchema modelSchema)
: this(databaseSchema, tableSchema, new DbContextSchema(), modelSchema)
{
}
public ProjectBuilderSettings(IDatabaseSchema database)
{
if (database == null)
{
throw new ArgumentNullException("database");
}
QueryPattern = QueryPatternEnum.ManagerClasses;
EnsureMultipleResultSets = false;
ZipFileRoot = "Common";
SourceDatabase = database;
Type type = database.Provider.GetType();
DatabaseProvider = String.Format("{0}, {1}", type.FullName, type.Assembly.FullName.Split(',')[0]);
// System.Data.OleDb,
// System.Data.Odbc,
// http://www.mono-project.com/Provider_Factory
// http://msdn.microsoft.com/en-us/library/system.web.ui.webcontrols.sqldatasource.providername.aspx
switch (DatabaseProvider)
{
case "SchemaExplorer.ADOXSchemaProvider, SchemaExplorer.ADOXSchemaProvider":
ConnectionStringProvider = "System.Data.OleDb";
break;
case "SchemaExplorer.DB2zOSSchemaProvider, SchemaExplorer.DB2zOSSchemaProvider":
case "SchemaExplorer.ISeriesSchemaProvider, SchemaExplorer.ISeriesSchemaProvider":
ConnectionStringProvider = "IBM.Data.DB2";
break;
case "SchemaExplorer.MySQLSchemaProvider, SchemaExplorer.MySQLSchemaProvider":
ConnectionStringProvider = "MySql.Data.MySqlClient";
break;
case "SchemaExplorer.OracleSchemaProvider, SchemaExplorer.OracleSchemaProvider":
ConnectionStringProvider = "System.Data.OracleClient";
break;
case "SchemaExplorer.PostgreSQLSchemaProvider, SchemaExplorer.PostgreSQLSchemaProvider":
ConnectionStringProvider = "Npgsql";
break;
case "SchemaExplorer.SQLAnywhereSchemaProvider, SchemaExplorer.SQLAnywhereSchemaProvider":
ConnectionStringProvider = "IAnywhere.Data.SQLAnywhere";
break;
case "SchemaExplorer.SqlCompactSchemaProvider, SchemaExplorer.SqlCompactSchemaProvider":
ConnectionStringProvider = "System.Data.SqlServerCe.3.5";
break;
case "SchemaExplorer.SqlCompact4SchemaProvider, SchemaExplorer.SqlCompact4SchemaProvider":
ConnectionStringProvider = "System.Data.SqlServerCe.4.0";
break;
case "SchemaExplorer.SQLiteSchemaProvider, SchemaExplorer.SQLiteSchemaProvider":
ConnectionStringProvider = "System.Data.SQLite";
break;
case "SchemaExplorer.VistaDBSchemaProvider, SchemaExplorer.VistaDBSchemaProvider":
case "SchemaExplorer.VistaDB4SchemaProvider, SchemaExplorer.VistaDB4SchemaProvider":
ConnectionStringProvider = "System.Data.VistaDB";
break;
case "SchemaExplorer.SqlSchemaProvider, SchemaExplorer.SqlSchemaProvider":
EnsureMultipleResultSets = true;
ConnectionStringProvider = "System.Data.SqlClient";
break;
default:
Trace.WriteLine(String.Format("ConnectionStringProvider could not be resolved for provider: {0}", DatabaseProvider));
break;
}
}
public static string DropCreateSchema(this IDatabaseSchema databaseSchema)
{
return($"{databaseSchema.Drop()} {Environment.NewLine} {databaseSchema.Create()}");
}
public DatabaseSetTarefa(IDatabaseSchema databaseSchema, IUnitOfWork unitOfWork)
{
this.databaseSchema = databaseSchema;
this.unitOfWork = unitOfWork;
}
private void ExecuteSchemaAction(
SchemaAction schemaAction,
IDatabaseSchema databaseSchema)
{
schemaActionDictionary[schemaAction](databaseSchema);
}
public virtual void Resolve(IDatabaseSchema database, IDBTable table)
{
this.Table = table;
}
