public Database ReadSchema(Parameters parameters, out ISchemaLoader schemaLoader)
{
Database dbSchema;
var nameAliases = NameAliasesLoader.Load(parameters.Aliases);
if (parameters.SchemaXmlFile == null) // read schema from DB
{
schemaLoader = SchemaLoaderFactory.Load(parameters);
parameters.Write(">>> Reading schema from {0} database", schemaLoader.Vendor.VendorName);
dbSchema = schemaLoader.Load(parameters.Database, nameAliases,
new NameFormat(parameters.Pluralize, GetCase(parameters), new CultureInfo(parameters.Culture)),
parameters.Sprocs, parameters.Namespace, parameters.Namespace);
dbSchema.Provider = parameters.Provider;
dbSchema.Tables.Sort(new LambdaComparer <Table>((x, y) => (x.Type.Name.CompareTo(y.Type.Name))));
foreach (var table in dbSchema.Tables)
{
table.Type.Columns.Sort(new LambdaComparer <Column>((x, y) => (x.Member.CompareTo(y.Member))));
}
dbSchema.Functions.Sort(new LambdaComparer <Function>((x, y) => (x.Method.CompareTo(y.Method))));
//SchemaPostprocess.PostProcess_DB(dbSchema);
}
else // load DBML
{
dbSchema = ReadSchema(parameters, parameters.SchemaXmlFile);
schemaLoader = SchemaLoaderFactory.Load(dbSchema.Provider);
}
if (schemaLoader == null)
{
throw new ApplicationException("Please provide -Provider=MySql (or Oracle, OracleODP, PostgreSql, Sqlite - see app.config for provider listing)");
}
return(dbSchema);
}
/// <exception cref="System.SqlSyntaxErrorException" />
public static void InitRouteRule(ISchemaLoader loader)
{
var functions = loader.Functions;
var functionManager = new MySqlFunctionManager(true);
BuildFuncManager(functionManager, functions);
foreach (var conf in loader.RuleConfigList)
{
var algorithmString = conf.Algorithm;
var lexer = new MySqlLexer(algorithmString);
var parser = new MySqlExprParser(lexer, functionManager, false, MySqlParser.DefaultCharset);
var expression = parser.Expression();
if (lexer.Token() != MySqlToken.Eof)
{
throw new ConfigException("route algorithm not end with EOF: " + algorithmString);
}
IRuleAlgorithm algorithm;
if (expression is IRuleAlgorithm)
{
algorithm = (IRuleAlgorithm)expression;
}
else
{
algorithm = new ExpressionAdapter(expression);
}
conf.RuleAlgorithm = algorithm;
}
}
public PipelineRunnerService(MasterRepository masterRepository, IMerchantDetailsLoader merchantDetailsLoader, IServiceProvider serviceProvider, ISchemaLoader schemaLoader)
{
this.masterRepository = masterRepository;
this.merchantDetailsLoader = merchantDetailsLoader;
this.serviceProvider = serviceProvider;
this.schemaLoader = schemaLoader;
}
public static XLEPlacementDocument OpenOrCreate(Uri uri, ISchemaLoader schemaLoader)
{
if (!uri.IsAbsoluteUri)
{
return(null);
}
var docRegistry = GetDocRegistry();
if (docRegistry != null)
{
var existing = docRegistry.FindDocument(uri);
if (existing != null)
{
return(null); // prevent a second reference here
}
}
string filePath = uri.LocalPath;
bool createdNewFile = false;
DomNode rootNode = null;
if (File.Exists(filePath))
{
// read existing document using custom dom XML reader
using (FileStream stream = File.OpenRead(filePath))
{
// Note -- Sony code uses "CustomDomXmlReader" to modify
// the urls of relative assets in reference types at
// load time.
// However, we're going to prefer a method that does this
// on demand, rather than at load time -- so we should be able
// to use a standard xml reader.
// var reader = new CustomDomXmlReader(Globals.ResourceRoot, schemaLoader);
var reader = new DomXmlReader(schemaLoader as XmlSchemaTypeLoader);
rootNode = reader.Read(stream, uri);
}
}
else
{
// create new document by creating a Dom node of the root type defined by the schema
rootNode = new DomNode(Schema.placementsDocumentType.Type, Schema.placementsDocumentRootElement);
createdNewFile = true;
}
var doc = rootNode.As <XLEPlacementDocument>();
doc.Uri = uri;
// Initialize Dom extensions now that the data is complete
rootNode.InitializeExtensions();
if (docRegistry != null)
{
docRegistry.Add(doc);
}
doc.Dirty = createdNewFile;
return(doc);
}
public virtual void Save(Uri uri, ISchemaLoader schemaLoader)
{
LevelEditorXLE.Patches.SelectNameForReferencedDocuments(this);
if (Dirty || m_uriChanged)
{
SaveDomDocument(DomNode, uri, schemaLoader);
m_uriChanged = false;
}
// save all the game-references
foreach (var gameRef in GetChildList <GameReference>(Schema.gameType.gameReferenceChild))
{
GameDocument subDoc = Adapters.As <GameDocument>(gameRef.Target);
if (subDoc == null)
{
continue;
}
subDoc.Save(subDoc.Uri, schemaLoader);
}
LevelEditorXLE.Patches.SaveReferencedDocuments(this, schemaLoader);
Dirty = false;
}
protected void WriteSchema(Database dbSchema, ISchemaLoader schemaLoader, Parameters parameters)
{
if (parameters.Dbml != null)
{
//we are supposed to write out a DBML file and exit
parameters.Write("<<< Writing file '{0}'", parameters.Dbml);
using (Stream dbmlFile = File.Create(parameters.Dbml))
{
DbmlSerializer.Write(dbmlFile, dbSchema);
}
}
else
{
if (!parameters.Schema)
{
RemoveSchemaFromTables(dbSchema);
}
// extract filename from output filename, database schema or schema name
string filename = parameters.Code;
if (string.IsNullOrEmpty(filename) && !string.IsNullOrEmpty(parameters.Database))
{
filename = parameters.Database.Replace("\"", "");
}
if (string.IsNullOrEmpty(filename))
{
filename = dbSchema.Name;
}
parameters.Write("<<< writing C# classes in file '{0}'", filename);
GenerateCode(parameters, dbSchema, schemaLoader, filename);
}
}
/// <exception cref="System.SqlSyntaxErrorException" />
public static void InitRouteRule(ISchemaLoader loader)
{
var functions = loader.Functions;
var functionManager = new MySqlFunctionManager(true);
BuildFuncManager(functionManager, functions);
foreach (var conf in loader.RuleConfigList)
{
var algorithmString = conf.Algorithm;
var lexer = new MySqlLexer(algorithmString);
var parser = new MySqlExprParser(lexer, functionManager, false, MySqlParser.DefaultCharset);
var expression = parser.Expression();
if (lexer.Token() != MySqlToken.Eof)
{
throw new ConfigException("route algorithm not end with EOF: " + algorithmString);
}
IRuleAlgorithm algorithm;
if (expression is IRuleAlgorithm)
{
algorithm = (IRuleAlgorithm)expression;
}
else
{
algorithm = new ExpressionAdapter(expression);
}
conf.RuleAlgorithm = algorithm;
}
}
public static DatabaseColumn[] GetColumnInfo(DatabaseServer server,
string tableName,
string connectionString)
{
ISchemaLoader loader = null;
switch (server)
{
case DatabaseServer.Access:
loader = new AccessSchemaLoader();
return(loader.GetColumnInfo(tableName, connectionString));
case DatabaseServer.SqlServer:
loader = new SqlServerSchemaLoader();
return(loader.GetColumnInfo(tableName, connectionString));
case DatabaseServer.MySql:
loader = new MySqlSchemaLoader();
return(loader.GetColumnInfo(tableName, connectionString));
case DatabaseServer.PostgreSQL:
loader = new PostgreSqlSchemaLoader();
return(loader.GetColumnInfo(tableName, connectionString));
default:
throw new Exception();
}
}
/// <summary>
///
/// </summary>
/// <param name="server"></param>
/// <param name="connectionString"></param>
/// <returns></returns>
public static List <string> GetTableList(DatabaseServer server,
string connectionString)
{
ISchemaLoader loader = null;
switch (server)
{
case DatabaseServer.Access:
loader = new AccessSchemaLoader();
return(loader.GetTableList(connectionString));
case DatabaseServer.SqlServer:
loader = new SqlServerSchemaLoader();
return(loader.GetTableList(connectionString));
case DatabaseServer.MySql:
loader = new MySqlSchemaLoader();
return(loader.GetTableList(connectionString));
case DatabaseServer.PostgreSQL:
loader = new PostgreSqlSchemaLoader();
return(loader.GetTableList(connectionString));
default:
throw new Exception();
}
}
private GenerationContext(GenerationContext original)
{
Parameters = original.Parameters;
Variables = new Dictionary <string, string>(original.Variables);
SchemaLoader = original.SchemaLoader;
ExtendedTypes = new Dictionary <Column, ExtendedTypeAndName>(original.ExtendedTypes);
AllImplementations = new List <IImplementation>(original.AllImplementations);
}
private GenerationContext(GenerationContext original)
{
Parameters = original.Parameters;
Variables = new Dictionary<string, string>(original.Variables);
SchemaLoader = original.SchemaLoader;
ExtendedTypes = new Dictionary<Column, ExtendedTypeAndName>(original.ExtendedTypes);
AllImplementations = new List<IImplementation>(original.AllImplementations);
}
public GenerationContext(Parameters parameters, ISchemaLoader schemaLoader)
{
Parameters = parameters;
Variables = new Dictionary <string, string>();
SchemaLoader = schemaLoader;
ExtendedTypes = new Dictionary <Column, ExtendedTypeAndName>();
AllImplementations.Add(new IModifiedImplementation());
AllImplementations.Add(new INotifyPropertyChangingImplementation());
AllImplementations.Add(new INotifyPropertyChangedImplementation());
}
public virtual void Save(Uri uri, ISchemaLoader schemaLoader)
{
if (Dirty || m_uriChanged)
{
SaveDomDocument(DomNode, uri, schemaLoader);
m_uriChanged = false;
}
Dirty = false;
}
public GenerationContext(Parameters parameters, ISchemaLoader schemaLoader)
{
Parameters = parameters;
Variables = new Dictionary<string, string>();
SchemaLoader = schemaLoader;
ExtendedTypes = new Dictionary<Column, ExtendedTypeAndName>();
AllImplementations.Add(new IModifiedImplementation());
AllImplementations.Add(new INotifyPropertyChangingImplementation());
AllImplementations.Add(new INotifyPropertyChangedImplementation());
}
private static void SaveDomDocument(DomNode node, Uri uri, ISchemaLoader schemaLoader)
{
string filePath = uri.LocalPath;
Directory.CreateDirectory(new FileInfo(filePath).Directory.FullName);
FileMode fileMode = File.Exists(filePath) ? FileMode.Truncate : FileMode.OpenOrCreate;
using (FileStream stream = new FileStream(filePath, fileMode))
{
var writer = new CustomDomXmlWriter(Globals.ResourceRoot, schemaLoader.TypeCollection);
writer.Write(node, stream, uri);
}
}
private static void SaveDomDocument(DomNode node, Uri uri, ISchemaLoader schemaLoader)
{
string filePath = uri.LocalPath;
Directory.CreateDirectory(new FileInfo(filePath).Directory.FullName);
FileMode fileMode = File.Exists(filePath) ? FileMode.Truncate : FileMode.OpenOrCreate;
using (FileStream stream = new FileStream(filePath, fileMode))
{
var writer = new CustomDomXmlWriter(uri, schemaLoader.TypeCollection);
writer.Write(node, stream, uri);
}
}
public static void SaveDomDocument(DomNode node, Uri uri, ISchemaLoader schemaLoader)
{
string filePath = uri.LocalPath;
Directory.CreateDirectory(new FileInfo(filePath).Directory.FullName); // (make sure the directory exists)
FileMode fileMode = File.Exists(filePath) ? FileMode.Truncate : FileMode.OpenOrCreate;
using (FileStream stream = new FileStream(filePath, fileMode))
{
// note -- "LevelEditor" project has a ComstDomXmlWriter object that contains some
// special case code for certain node types. We're just using the default
// DomXmlWriter, so we won't benefit from that special behaviour.
var writer = new Sce.Atf.Dom.DomXmlWriter(schemaLoader.TypeCollection);
writer.Write(node, stream, uri);
}
}
public XMLConfigLoader(ISchemaLoader schemaLoader)
{
functions = new Dictionary<string, IRuleAlgorithm>(schemaLoader.Functions).AsReadOnly();
dataSources = schemaLoader.DataSources;
dataNodes = schemaLoader.DataNodes;
schemas = schemaLoader.Schemas;
rules = schemaLoader.RuleConfigList;
schemaLoader = null;
var serverLoader = new XmlServerLoader();
SystemConfig = serverLoader.System;
users = serverLoader.Users;
QuarantineConfig = serverLoader.Quarantine;
ClusterConfig = serverLoader.Cluster;
serverLoader = null;
}
public XMLConfigLoader(ISchemaLoader schemaLoader)
{
functions = new Dictionary <string, IRuleAlgorithm>(schemaLoader.Functions).AsReadOnly();
dataSources = schemaLoader.DataSources;
dataNodes = schemaLoader.DataNodes;
schemas = schemaLoader.Schemas;
rules = schemaLoader.RuleConfigList;
schemaLoader = null;
var serverLoader = new XmlServerLoader();
SystemConfig = serverLoader.System;
users = serverLoader.Users;
QuarantineConfig = serverLoader.Quarantine;
ClusterConfig = serverLoader.Cluster;
serverLoader = null;
}
/// <inheritdoc />
public SqlGetSchemaPipelineStep(
IJobConfig jobConfig,
ILogger logger,
IElasticSearchUploader elasticSearchUploader,
IQueueManager queueManager,
IProgressMonitor progressMonitor,
ISchemaLoader schemaLoader,
IDetailedTemporaryFileWriter fileWriter,
CancellationToken cancellationToken)
: base(jobConfig, logger, queueManager, progressMonitor, cancellationToken)
{
this.elasticSearchUploader = elasticSearchUploader ?? throw new ArgumentNullException(nameof(elasticSearchUploader));
this.schemaLoader = schemaLoader ?? throw new ArgumentNullException(nameof(schemaLoader));
this.fileWriter = fileWriter ?? throw new ArgumentNullException(nameof(fileWriter));
this.folder = Path.Combine(this.Config.LocalSaveFolder, $"{this.UniqueId}-{LoggerName}");
this.fileWriter.CreateDirectory(this.folder);
}
public ISchemaLoader Load(Parameters parameters, string dbLinqSchemaLoaderTypeName, string databaseConnectionTypeName, string sqlDialectTypeName)
{
Type dbLinqSchemaLoaderType = Type.GetType(dbLinqSchemaLoaderTypeName);
Type databaseConnectionType = Type.GetType(databaseConnectionTypeName);
Type sqlDialectType = string.IsNullOrEmpty(sqlDialectTypeName) ? null : Type.GetType(sqlDialectTypeName);
if (dbLinqSchemaLoaderType == null)
{
throw new ArgumentException("Could not load dbLinqSchemaLoaderType type '" + dbLinqSchemaLoaderTypeName + "'. Try using the --with-schema-loader=TYPE option.");
}
if (databaseConnectionType == null)
{
throw new ArgumentException("Could not load databaseConnectionType type '" + databaseConnectionTypeName + "'. Try using the --with-dbconnection=TYPE option.");
}
ISchemaLoader loader = Load(parameters, dbLinqSchemaLoaderType, databaseConnectionType, sqlDialectType);
return(loader);
}
public virtual void Save(Uri uri, ISchemaLoader schemaLoader)
{
if (Dirty || m_uriChanged)
{
SaveDomDocument(DomNode, uri, schemaLoader);
m_uriChanged = false;
}
// save all the game-references
foreach (var gameRef in GetChildList<GameReference>(Schema.gameType.gameReferenceChild))
{
GameDocument subDoc = Adapters.As<GameDocument>(gameRef.Target);
if(subDoc == null) continue;
subDoc.Save(subDoc.Uri, schemaLoader);
}
LevelEditorXLE.Patches.SaveReferencedDocuments(this, schemaLoader);
Dirty = false;
}
public ISchemaLoader Load(Parameters parameters, string dbLinqSchemaLoaderTypeName, string databaseConnectionTypeName, string sqlDialectTypeName)
{
AppDomain.CurrentDomain.AssemblyResolve += CurrentDomain_AssemblyResolve;
Type dbLinqSchemaLoaderType = Type.GetType(dbLinqSchemaLoaderTypeName);
Type databaseConnectionType = Type.GetType(databaseConnectionTypeName);
Type sqlDialectType = string.IsNullOrEmpty(sqlDialectTypeName) ? null : Type.GetType(sqlDialectTypeName);
if (dbLinqSchemaLoaderType == null)
{
throw new ArgumentException("Unable to resolve dbLinqSchemaLoaderType: " + dbLinqSchemaLoaderTypeName);
}
if (databaseConnectionType == null)
{
throw new ArgumentException("Unable to resolve databaseConnectionType: " + databaseConnectionTypeName);
}
ISchemaLoader loader = Load(parameters, dbLinqSchemaLoaderType, databaseConnectionType, sqlDialectType);
AppDomain.CurrentDomain.AssemblyResolve -= CurrentDomain_AssemblyResolve;
return(loader);
}
public void GenerateCode(Parameters parameters, Database dbSchema, ISchemaLoader schemaLoader, string filename)
{
ICodeGenerator codeGenerator = FindCodeGenerator(parameters, filename) ??
(string.IsNullOrEmpty(parameters.Language)
? CodeDomGenerator.CreateFromFileExtension(Path.GetExtension(filename))
: CodeDomGenerator.CreateFromLanguage(parameters.Language));
if (string.IsNullOrEmpty(filename))
{
filename = dbSchema.Class;
}
if (String.IsNullOrEmpty(Path.GetExtension(filename)))
{
filename += codeGenerator.Extension;
}
using (var streamWriter = new StreamWriter(filename))
{
var generationContext = new GenerationContext(parameters, schemaLoader);
codeGenerator.Write(streamWriter, dbSchema, generationContext);
}
}
public static void SaveReferencedDocuments(IAdaptable gameNode, ISchemaLoader schemaLoader)
{
var game = gameNode.As <Game.GameExtensions>();
if (game == null)
{
return;
}
var placementsFolder = game.PlacementsFolder;
if (placementsFolder != null)
{
foreach (var cellRef in placementsFolder.Cells)
{
var doc = cellRef.Target;
if (doc == null)
{
continue;
}
doc.Save(cellRef.Uri, schemaLoader);
}
}
}
public void GenerateCode(Parameters parameters, Database dbSchema, ISchemaLoader schemaLoader, string filename)
{
ICodeGenerator codeGenerator = FindCodeGenerator(parameters, filename);
if (codeGenerator == null)
{
throw new ArgumentException("Please specify either a /language or a /code file");
}
if (string.IsNullOrEmpty(filename))
{
filename = dbSchema.Class;
}
if (String.IsNullOrEmpty(Path.GetExtension(filename)))
{
filename += codeGenerator.Extension;
}
using (var streamWriter = new StreamWriter(filename))
{
var generationContext = new GenerationContext(parameters, schemaLoader);
codeGenerator.Write(streamWriter, dbSchema, generationContext);
}
}
protected void WriteSchema(Database dbSchema, ISchemaLoader schemaLoader, Parameters parameters)
{
if (parameters.Dbml != null)
{
//we are supposed to write out a DBML file and exit
parameters.Write("<<< Writing file '{0}'", parameters.Dbml);
using (Stream dbmlFile = File.Create(parameters.Dbml))
{
DbmlSerializer.Write(dbmlFile, dbSchema);
}
}
else
{
if (!parameters.Schema)
RemoveSchemaFromTables(dbSchema);
// extract filename from output filename, database schema or schema name
string filename = parameters.Code;
if (string.IsNullOrEmpty(filename) && !string.IsNullOrEmpty(parameters.Database))
filename = parameters.Database.Replace("\"", "");
if (string.IsNullOrEmpty(filename))
filename = dbSchema.Name;
// TODO: move such check to runtime.
schemaLoader.CheckNamesSafety(dbSchema);
parameters.Write("<<< writing C# classes in file '{0}'", filename);
GenerateCode(parameters, dbSchema, schemaLoader, filename);
}
}
public static XLEPlacementDocument OpenOrCreate(Uri uri, ISchemaLoader schemaLoader)
{
if (!uri.IsAbsoluteUri)
{
return(null);
}
var docRegistry = GetDocRegistry();
if (docRegistry != null)
{
var existing = docRegistry.FindDocument(uri);
if (existing != null)
{
return(null); // prevent a second reference here
}
}
string filePath = uri.LocalPath;
bool createdNewFile = false;
DomNode rootNode = null;
if (File.Exists(filePath))
{
// read existing document using custom dom XML reader
using (FileStream stream = File.OpenRead(filePath))
{
var reader = new CustomDomXmlReader(uri, schemaLoader as XmlSchemaTypeLoader);
rootNode = reader.Read(stream, uri);
}
}
else
{
// create new document by creating a Dom node of the root type defined by the schema
rootNode = new DomNode(Schema.placementsDocumentType.Type, Schema.placementsDocumentRootElement);
createdNewFile = true;
}
var doc = rootNode.As <XLEPlacementDocument>();
doc.Uri = uri;
// Initialize Dom extensions now that the data is complete
rootNode.InitializeExtensions();
// sync all the prefab instances
{
UniqueNamer uniqueNamer = new UniqueNamer('_');
foreach (var prefab in doc.As <DomNode>().Subtree.AsIEnumerable <IPrefabInstance>())
{
prefab.Resolve(uniqueNamer);
}
}
if (docRegistry != null)
{
docRegistry.Add(doc);
}
doc.Dirty = createdNewFile;
return(doc);
}
public static void SaveReferencedDocuments(IAdaptable gameNode, ISchemaLoader schemaLoader)
{
var game = gameNode.As<Game.GameExtensions>();
if (game == null) return;
var placementsFolder = game.PlacementsFolder;
if (placementsFolder != null)
{
foreach (var cellRef in placementsFolder.Cells)
{
var doc = cellRef.Target;
if (doc == null) continue;
doc.Save(cellRef.Uri, schemaLoader);
}
}
}
public static void SaveDomDocument(DomNode node, Uri uri, ISchemaLoader schemaLoader)
{
string filePath = uri.LocalPath;
Directory.CreateDirectory(new FileInfo(filePath).Directory.FullName); // (make sure the directory exists)
FileMode fileMode = File.Exists(filePath) ? FileMode.Truncate : FileMode.OpenOrCreate;
using (FileStream stream = new FileStream(filePath, fileMode))
{
// note -- "LevelEditor" project has a ComstDomXmlWriter object that contains some
// special case code for certain node types. We're just using the default
// DomXmlWriter, so we won't benefit from that special behaviour.
var writer = new Sce.Atf.Dom.DomXmlWriter(schemaLoader.TypeCollection);
writer.Write(node, stream, uri);
}
}
public void GenerateCode(Parameters parameters, Database dbSchema, ISchemaLoader schemaLoader, string filename)
{
ICodeGenerator codeGenerator = FindCodeGenerator(parameters, filename) ??
(string.IsNullOrEmpty(parameters.Language)
? CodeDomGenerator.CreateFromFileExtension(Path.GetExtension(filename))
: CodeDomGenerator.CreateFromLanguage(parameters.Language));
if (string.IsNullOrEmpty(filename))
filename = dbSchema.Class;
if (String.IsNullOrEmpty(Path.GetExtension(filename)))
filename += codeGenerator.Extension;
using (var streamWriter = new StreamWriter(filename))
{
var generationContext = new GenerationContext(parameters, schemaLoader);
codeGenerator.Write(streamWriter, dbSchema, generationContext);
}
}
public virtual void Save(Uri uri, ISchemaLoader schemaLoader)
{
if (Dirty || m_uriChanged)
{
SaveDomDocument(DomNode, uri, schemaLoader);
m_uriChanged = false;
}
Dirty = false;
}
public static XLEPlacementDocument OpenOrCreate(Uri uri, ISchemaLoader schemaLoader)
{
if (!uri.IsAbsoluteUri)
return null;
var docRegistry = GetDocRegistry();
if (docRegistry != null)
{
var existing = docRegistry.FindDocument(uri);
if (existing != null) return null; // prevent a second reference here
}
string filePath = uri.LocalPath;
bool createdNewFile = false;
DomNode rootNode = null;
if (File.Exists(filePath))
{
// read existing document using custom dom XML reader
using (FileStream stream = File.OpenRead(filePath))
{
// Note -- Sony code uses "CustomDomXmlReader" to modify
// the urls of relative assets in reference types at
// load time.
// However, we're going to prefer a method that does this
// on demand, rather than at load time -- so we should be able
// to use a standard xml reader.
// var reader = new CustomDomXmlReader(Globals.ResourceRoot, schemaLoader);
var reader = new DomXmlReader(schemaLoader as XmlSchemaTypeLoader);
rootNode = reader.Read(stream, uri);
}
}
else
{
// create new document by creating a Dom node of the root type defined by the schema
rootNode = new DomNode(Schema.placementsDocumentType.Type, Schema.placementsDocumentRootElement);
createdNewFile = true;
}
var doc = rootNode.As<XLEPlacementDocument>();
doc.Uri = uri;
// Initialize Dom extensions now that the data is complete
rootNode.InitializeExtensions();
if (docRegistry!=null) docRegistry.Add(doc);
doc.Dirty = createdNewFile;
return doc;
}
public void GenerateCode(Parameters parameters, Database dbSchema, ISchemaLoader schemaLoader, string filename)
{
ICodeGenerator codeGenerator = FindCodeGenerator(parameters, filename);
if (codeGenerator == null)
throw new ArgumentException("Please specify either a /language or a /code file");
if (string.IsNullOrEmpty(filename))
filename = dbSchema.Class;
if (String.IsNullOrEmpty(Path.GetExtension(filename)))
filename += codeGenerator.Extension;
using (var streamWriter = new StreamWriter(filename))
{
var generationContext = new GenerationContext(parameters, schemaLoader);
codeGenerator.Write(streamWriter, dbSchema, generationContext);
}
}
public static async Task RunAsync(IEnumerable <string> sourcePath, ISchemaLoader schemaLoader, IEnumerable <string> templatesPaths, string outputPath, IEnumerable <IHelper>?customHelpers, TemplateDuplicationHandlingStrategy templateDuplicationHandlingStrategy = TemplateDuplicationHandlingStrategy.Throw, string?authorization = null)
{
var jsonObject = await schemaLoader.LoadSchemaAsync(sourcePath, authorization);
await RunAsync(jsonObject, templatesPaths, outputPath, customHelpers, templateDuplicationHandlingStrategy);
}
public Database ReadSchema(Parameters parameters, out ISchemaLoader schemaLoader)
{
Database dbSchema;
var nameAliases = NameAliasesLoader.Load(parameters.Aliases);
if (parameters.SchemaXmlFile == null) // read schema from DB
{
schemaLoader = SchemaLoaderFactory.Load(parameters);
parameters.Write(">>> Reading schema from {0} database", schemaLoader.Vendor.VendorName);
dbSchema = schemaLoader.Load(parameters.Database, nameAliases,
new NameFormat(parameters.Pluralize, GetCase(parameters), new CultureInfo(parameters.Culture)),
parameters.Sprocs, parameters.Namespace, parameters.Namespace);
dbSchema.Provider = parameters.Provider;
dbSchema.Tables.Sort(new LambdaComparer<Table>((x, y) => (x.Type.Name.CompareTo(y.Type.Name))));
foreach (var table in dbSchema.Tables)
table.Type.Columns.Sort(new LambdaComparer<Column>((x, y) => (x.Member.CompareTo(y.Member))));
dbSchema.Functions.Sort(new LambdaComparer<Function>((x, y) => (x.Method.CompareTo(y.Method))));
//SchemaPostprocess.PostProcess_DB(dbSchema);
}
else // load DBML
{
dbSchema = ReadSchema(parameters, parameters.SchemaXmlFile);
schemaLoader = SchemaLoaderFactory.Load(dbSchema.Provider);
}
if (schemaLoader == null)
throw new ApplicationException("Please provide -Provider=MySql (or Oracle, OracleODP, PostgreSql, Sqlite - see app.config for provider listing)");
return dbSchema;
}
public static Task RunAsync(string sourcePath, ISchemaLoader schemaLoader, string templatePath, string outputPath, IEnumerable <IHelper>?customHelpers = null, TemplateDuplicationHandlingStrategy templateDuplicationHandlingStrategy = TemplateDuplicationHandlingStrategy.Throw, string?authorization = null)
=> RunAsync(new[] { sourcePath }, schemaLoader, new[] { templatePath }, outputPath, customHelpers, templateDuplicationHandlingStrategy, authorization);
public virtual void Save(ISchemaLoader loader) {}
public override void Save(ISchemaLoader schemaLoader)
{
SelectNameIfNecessary();
Target.Save(Uri, schemaLoader);
}
