public void Test_element_with_a_value()
{
var xsd = XsdNamespace;
var ns = "uri:test-schema";
var schema = new Schema("test", ns);
var stringType = TestDataTypes.String;
schema
.CreateRootElement("DesignModels")
.CreateElementWithValue("Element", stringType);
var outputXsd = new SchemaConverter().Convert(schema);
var outputXsdStr = outputXsd.Element.ToTestString().FixNewlines().Trim();
outputXsdStr.Should().Be(@"
<xs:schema elementFormDefault='qualified' targetNamespace='uri:test-schema' xmlns:tns='uri:test-schema' xmlns:xs='http://www.w3.org/2001/XMLSchema'>
<xs:element name='DesignModels'>
<xs:complexType>
<xs:sequence>
<xs:element maxOccurs='1' minOccurs='0' name='Element'>
<xs:complexType>
<xs:simpleContent>
<xs:extension base='xs:string'/>
</xs:simpleContent>
</xs:complexType>
</xs:element>
</xs:sequence>
</xs:complexType>
</xs:element>
</xs:schema>
".FixNewlines().Trim());
}
public override IList <DatabaseView> Views(string viewName)
{
var dt = _schemaReader.Views();
var views = SchemaConverter.Views(dt);
return(views);
}
/// <summary>
/// Gets all tables (just names, no columns).
/// </summary>
public IList <DatabaseTable> TableList()
{
RaiseReadingProgress(SchemaObjectType.Tables);
DataTable dt = _schemaReader.Tables();
return(SchemaConverter.Tables(dt));
}
public void Test_empty_repeating_element()
{
var xsd = XsdNamespace;
var ns = "uri:test-schema";
var schema = new Schema("test", ns);
schema
.CreateRootElement("DesignModels")
.CreateElement("Element", null, c => c.AllowMultiple = true);
var outputXsd = new SchemaConverter().Convert(schema);
var outputXsdStr = outputXsd.Element.ToTestString().FixNewlines().Trim();
outputXsdStr.Should().Be(@"
<xs:schema elementFormDefault='qualified' targetNamespace='uri:test-schema' xmlns:tns='uri:test-schema' xmlns:xs='http://www.w3.org/2001/XMLSchema'>
<xs:element name='DesignModels'>
<xs:complexType>
<xs:sequence>
<xs:element maxOccurs='unbounded' minOccurs='0' name='Element'/>
</xs:sequence>
</xs:complexType>
</xs:element>
</xs:schema>
".FixNewlines().Trim());
}
public void Test_empty_element_with_an_annotation()
{
var xsd = XsdNamespace;
var ns = "uri:test-schema";
var schema = new Schema("test", ns);
schema
.CreateRootElement("DesignModels")
.CreateElement("Element", "Empty element");
var outputXsd = new SchemaConverter().Convert(schema);
var outputXsdStr = outputXsd.Element.ToTestString().FixNewlines().Trim();
outputXsdStr.Should().Be(@"
<xs:schema elementFormDefault='qualified' targetNamespace='uri:test-schema' xmlns:tns='uri:test-schema' xmlns:xs='http://www.w3.org/2001/XMLSchema'>
<xs:element name='DesignModels'>
<xs:complexType>
<xs:sequence>
<xs:element maxOccurs='1' minOccurs='0' name='Element'>
<xs:annotation>
<xs:documentation>
Empty element
</xs:documentation>
</xs:annotation>
</xs:element>
</xs:sequence>
</xs:complexType>
</xs:element>
</xs:schema>
".FixNewlines().Trim());
}
public void Test_element_with_an_attribute()
{
var xsd = XsdNamespace;
var ns = "uri:test-schema";
var schema = new Schema("test", ns);
var stringType = new PrimitiveType("string", "xs:string");
schema
.CreateRootElement("DesignModels")
.CreateElement("Element")
.CreateAttribute("attrib", stringType);
var outputXsd = new SchemaConverter().Convert(schema);
var outputXsdStr = outputXsd.Element.ToTestString().Trim();
outputXsdStr.Should().Be(@"
<xs:schema elementFormDefault='qualified' targetNamespace='uri:test-schema' xmlns:tns='uri:test-schema' xmlns:xs='http://www.w3.org/2001/XMLSchema'>
<xs:element name='DesignModels'>
<xs:complexType>
<xs:sequence>
<xs:element maxOccurs='1' minOccurs='0' name='Element'>
<xs:complexType>
<xs:attribute name='attrib' type='xs:string'/>
</xs:complexType>
</xs:element>
</xs:sequence>
</xs:complexType>
</xs:element>
</xs:schema>
".Trim());
}
/// <summary>
/// Get all data for a specified table name.
/// </summary>
/// <param name="tableName">Name of the table. Oracle names can be case sensitive.</param>
/// <returns>A dataset containing the tables: Columns, Primary_Keys, Foreign_Keys, Unique_Keys (only filled for Oracle), Indexes, IndexColumns, Triggers</returns>
public override DataSet Table(string tableName)
{
//if (ProviderType != SqlType.SqlServer && ProviderType != SqlType.SqlServerCe && ProviderType != SqlType.Oracle && ProviderType != SqlType.MySql)
// return base.Table(tableName);
//more information from sqlserver, oracle and mysql
var ds = new DataSet();
ds.Locale = CultureInfo.InvariantCulture;
using (DbConnection conn = Factory.CreateConnection())
{
conn.ConnectionString = ConnectionString;
conn.Open();
//uses friend access to schemaReader
LoadTable(tableName, ds, conn);
if (ds.Tables.Count == 0)
{
return(null); //no data found
}
if (string.IsNullOrEmpty(Owner))
{
//we need schema for constraint look ups
Owner = SchemaConverter.FindSchema(ds.Tables[ColumnsCollectionName]);
}
ds.Tables.Add(PrimaryKeys(tableName, conn));
ds.Tables.Add(ForeignKeys(tableName, conn));
ds.Tables.Add(UniqueKeys(tableName, conn));
ds.Tables.Add(CheckConstraints(tableName, conn));
ds.Tables.Add(IdentityColumns(tableName, conn));
}
return(ds);
}
public override IList <DataType> DataTypes()
{
var list = SchemaConverter.DataTypes(_schemaReader.DataTypes());
if (list.Count == 0)
{
list = _schemaReader.SchemaDataTypes();
}
return(list);
}
public override void Execute()
{
var designProject = Projects.GetFirstProjectByType(BasePluginConstants.ProjectType_Design);
var schemaConverter = new SchemaConverter();
var projectConfigurationSchema = Schemas.GetSchemaByName(Core.CoreConstants.ProjectConfiguration_SchemaName);
var projectConfigurationSchemaOutputModel = schemaConverter.Convert(projectConfigurationSchema);
projectConfigurationSchemaOutputModel.File = designProject.GetFile("Schemas/XSD/ProjectConfiguration.xsd");
OutputModels.AddOutputModel(projectConfigurationSchemaOutputModel);
}
public override void Execute()
{
var designProject = Projects.GetFirstProjectByType(BasePluginConstants.ProjectType_Design);
var schemaConverter = new SchemaConverter();
var designModelSchema = Schemas.GetSchemaByName(BasePluginConstants.DesignModel_SchemaName);
var designModelSchemaOutputModel = schemaConverter.Convert(designModelSchema);
designModelSchemaOutputModel.Renderer = new XmlOutputModelRenderer();
designModelSchemaOutputModel.File = designProject.GetFile("Schemas/XSD/DesignModels.xsd");
OutputModels.AddOutputModel(designModelSchemaOutputModel);
}
/// <summary>
/// Gets all datatypes (and updates columns/arguments if already loaded)
/// </summary>
public IList <DataType> DataTypes()
{
List <DataType> list = SchemaConverter.DataTypes(_sr.DataTypes());
if (list.Count == 0)
{
list = _sr.SchemaDataTypes();
}
DatabaseSchema.DataTypes.Clear();
DatabaseSchema.DataTypes.AddRange(list);
DatabaseSchemaFixer.UpdateDataTypes(DatabaseSchema); //if columns/arguments loaded later, run this method again.
return(list);
}
public async Task RunAsync()
{
var schemas = await Task.WhenAll(
SchemaConverter.ReadAsync(options.From),
SchemaConverter.ReadAsync(options.To)
).ConfigureAwait(false);
var from = schemas.First();
var to = schemas.Last();
SchemaConverter.WriteFileAsync("from", from);
SchemaConverter.WriteFileAsync("to", to);
ShowDiff(from, to);
}
/// <summary>
/// Gets all views.
/// </summary>
public IList <DatabaseView> AllViews()
{
DataTable dt = _sr.Views();
List <DatabaseView> views = SchemaConverter.Views(dt);
//get full datatables for all tables, to minimize database calls
var columnLoader = new ViewColumnLoader(_sr);
foreach (DatabaseView v in views)
{
v.Columns.AddRange(columnLoader.Load(v.Name));
}
DatabaseSchema.Views.Clear();
DatabaseSchema.Views.AddRange(views);
return(views);
}
public async Task RunAsync()
{
var config = new GraphQlGeneratorConfiguration()
{
IncludeDeprecatedFields = options.GenerateDeprecatedTypes,
JsonPropertyGeneration = options.JsonPropertyGeneration,
CSharpVersion = options.UseNullable ? CSharpVersion.NewestWithNullableReferences : CSharpVersion.Compatible
};
var schema = await SchemaConverter.ReadAsync(options.Source).ConfigureAwait(false);
var generator = new GraphQlGenerator(config);
var content = generator.GenerateFullClientCSharpFile(schema, options.Namespace);
Console.WriteLine($"writing client-code to {options.DestinationFile}");
File.WriteAllText(options.DestinationFile, content);
}
/// <summary>
/// Gets all views.
/// </summary>
public IList <DatabaseView> AllViews(CancellationToken ct)
{
if (ct.IsCancellationRequested)
{
return(DatabaseSchema.Views);
}
RaiseReadingProgress(SchemaObjectType.Views);
DataTable dt = _schemaReader.Views();
if (ct.IsCancellationRequested)
{
return(DatabaseSchema.Views);
}
ReaderEventArgs.RaiseEvent(ReaderProgress, this, ProgressType.Processing, SchemaObjectType.Views);
List <DatabaseView> views = SchemaConverter.Views(dt);
var viewFilter = Exclusions.ViewFilter;
if (viewFilter != null)
{
views.RemoveAll(v => viewFilter.Exclude(v.Name));
}
//get full datatables for all tables, to minimize database calls
if (ct.IsCancellationRequested)
{
return(views);
}
RaiseReadingProgress(SchemaObjectType.ViewColumns);
var columnLoader = new ViewColumnLoader(_schemaReader);
var count = views.Count;
for (var index = 0; index < count; index++)
{
if (ct.IsCancellationRequested)
{
return(views);
}
DatabaseView v = views[index];
ReaderEventArgs.RaiseEvent(ReaderProgress, this, ProgressType.Processing, SchemaObjectType.ViewColumns, v.Name, index, count);
v.Columns.AddRange(columnLoader.Load(v.Name, v.SchemaOwner));
}
DatabaseSchema.Views.Clear();
DatabaseSchema.Views.AddRange(views);
return(views);
}
public void Test_element_with_an_enum_value()
{
var xsd = XsdNamespace;
var ns = "uri:test-schema";
var schema = new Schema("test", ns);
var enumType = new EnumType("testEnum", "testEnum desc", new EnumDataTypeValue("one"), new EnumDataTypeValue("two", "Second"));
schema
.CreateRootElement("DesignModels")
.CreateElementWithValue("Element", enumType);
var outputXsd = new SchemaConverter().Convert(schema);
var outputXsdStr = outputXsd.Element.ToTestString().FixNewlines().Trim();
outputXsdStr.Should().Be(@"
<xs:schema elementFormDefault='qualified' targetNamespace='uri:test-schema' xmlns:tns='uri:test-schema' xmlns:xs='http://www.w3.org/2001/XMLSchema'>
<xs:element name='DesignModels'>
<xs:complexType>
<xs:sequence>
<xs:element maxOccurs='1' minOccurs='0' name='Element'>
<xs:complexType>
<xs:simpleContent>
<xs:extension base='tns:enum-testEnum'/>
</xs:simpleContent>
</xs:complexType>
</xs:element>
</xs:sequence>
</xs:complexType>
</xs:element>
<xs:simpleType name='enum-testEnum'>
<xs:restriction base='xs:string'>
<xs:enumeration value='one'/>
<xs:enumeration value='two'>
<xs:annotation>
<xs:documentation>
Second
</xs:documentation>
</xs:annotation>
</xs:enumeration>
</xs:restriction>
</xs:simpleType>
</xs:schema>
".FixNewlines().Trim());
}
/// <summary>
/// Gets all views.
/// </summary>
public IList <DatabaseView> AllViews()
{
DataTable dt = _schemaReader.Views();
List <DatabaseView> views = SchemaConverter.Views(dt);
var viewFilter = Exclusions.ViewFilter;
if (viewFilter != null)
{
views.RemoveAll(v => viewFilter.Exclude(v.Name));
}
//get full datatables for all tables, to minimize database calls
var columnLoader = new ViewColumnLoader(_schemaReader);
foreach (DatabaseView v in views)
{
v.Columns.AddRange(columnLoader.Load(v.Name, v.SchemaOwner));
}
DatabaseSchema.Views.Clear();
DatabaseSchema.Views.AddRange(views);
return(views);
}
public IList <DatabaseTable> Load(CancellationToken ct)
{
if (ct.IsCancellationRequested)
{
return(EmptyList());
}
RaiseReadingProgress(SchemaObjectType.Tables);
//get full datatables for all tables, to minimize database calls
var tabs = _schemaReader.Tables();
//we either use the converters directly (DataTable to our db model)
//or loaders, which wrap the schema loader calls and converters
//loaders hide the switch between calling for all tables, or a specific table
if (ct.IsCancellationRequested)
{
return(EmptyList());
}
RaiseReadingProgress(SchemaObjectType.Columns);
var columnLoader = new ColumnLoader(_schemaReader);
if (ct.IsCancellationRequested)
{
return(EmptyList());
}
RaiseReadingProgress(SchemaObjectType.Constraints);
var constraintLoader = new SchemaConstraintLoader(_schemaReader);
var indexLoader = new IndexLoader(_schemaReader);
var ids = _schemaReader.IdentityColumns(null);
var computeds = _schemaReader.ComputedColumns(null);
if (ct.IsCancellationRequested)
{
return(EmptyList());
}
RaiseReadingProgress(SchemaObjectType.Descriptions);
var tableDescriptions = new TableDescriptionConverter(_schemaReader.TableDescription(null));
var columnDescriptions = new ColumnDescriptionConverter(_schemaReader.ColumnDescription(null));
DataTable triggers = _schemaReader.Triggers(null);
var triggerConverter = new TriggerConverter(triggers);
if (ct.IsCancellationRequested)
{
return(EmptyList());
}
ReaderEventArgs.RaiseEvent(ReaderProgress, this, ProgressType.Processing, SchemaObjectType.Tables);
var tables = SchemaConverter.Tables(tabs);
var tableFilter = _exclusions.TableFilter;
if (tableFilter != null)
{
tables.RemoveAll(t => tableFilter.Exclude(t.Name));
}
tables.Sort(delegate(DatabaseTable t1, DatabaseTable t2)
{
//doesn't account for mixed schemas
return(string.Compare(t1.Name, t2.Name, StringComparison.OrdinalIgnoreCase));
});
int tablesCount = tables.Count;
for (var i = 0; i < tablesCount; i++)
{
var table = tables[i];
var tableName = table.Name;
var schemaName = table.SchemaOwner;
if (ct.IsCancellationRequested)
{
return(tables);
}
ReaderEventArgs.RaiseEvent(ReaderProgress, this, ProgressType.Processing, SchemaObjectType.Tables, tableName, i, tablesCount);
table.Description = tableDescriptions.FindDescription(table.SchemaOwner, tableName);
var databaseColumns = columnLoader.Load(tableName, schemaName);
table.Columns.AddRange(databaseColumns);
columnDescriptions.AddDescriptions(table);
var pkConstraints = constraintLoader.Load(tableName, schemaName, ConstraintType.PrimaryKey);
PrimaryKeyLogic.AddPrimaryKey(table, pkConstraints);
var fks = constraintLoader.Load(tableName, schemaName, ConstraintType.ForeignKey);
table.AddConstraints(fks);
table.AddConstraints(constraintLoader.Load(tableName, schemaName, ConstraintType.UniqueKey));
table.AddConstraints(constraintLoader.Load(tableName, schemaName, ConstraintType.Check));
table.AddConstraints(constraintLoader.Load(tableName, schemaName, ConstraintType.Default));
indexLoader.AddIndexes(table);
SchemaConstraintConverter.AddIdentity(ids, table);
SchemaConstraintConverter.AddComputed(computeds, table);
table.Triggers.Clear();
table.Triggers.AddRange(triggerConverter.Triggers(tableName));
_schemaReader.PostProcessing(table);
}
return(tables);
}
/// <summary>
/// Gets all tables (just names, no columns).
/// </summary>
public IList <DatabaseTable> TableList()
{
DataTable dt = _sr.Tables();
return(SchemaConverter.Tables(dt));
}
public override IList <DatabaseTable> Tables(string tableName)
{
var dt = _schemaReader.Tables(tableName);
return(SchemaConverter.Tables(dt));
}
/// <summary>
/// Gets all tables (plus constraints, indexes and triggers).
/// </summary>
public IList <DatabaseTable> AllTables()
{
DataTable tabs = _sr.Tables();
//get full datatables for all tables, to minimize database calls
//we either use the converters directly (DataTable to our db model)
//or loaders, which wrap the schema loader calls and converters
//loaders hide the switch between calling for all tables, or a specific table
var columnLoader = new ColumnLoader(_sr);
var constraintLoader = new SchemaConstraintLoader(_sr);
var indexLoader = new IndexLoader(_sr);
DataTable ids = _sr.IdentityColumns(null);
DataTable triggers = _sr.Triggers(null);
var triggerConverter = new TriggerConverter(triggers);
var tables = SchemaConverter.Tables(tabs);
tables.Sort(delegate(DatabaseTable t1, DatabaseTable t2)
{
//doesn't account for mixed schemas
return(string.Compare(t1.Name, t2.Name, StringComparison.OrdinalIgnoreCase));
});
foreach (DatabaseTable table in tables)
{
var tableName = table.Name;
var databaseColumns = columnLoader.Load(tableName);
table.Columns.AddRange(databaseColumns);
var pkConstraints = constraintLoader.Load(tableName, ConstraintType.PrimaryKey);
PrimaryKeyLogic.AddPrimaryKey(table, pkConstraints);
var fks = constraintLoader.Load(tableName, ConstraintType.ForeignKey);
table.AddConstraints(fks);
table.AddConstraints(constraintLoader.Load(tableName, ConstraintType.UniqueKey));
table.AddConstraints(constraintLoader.Load(tableName, ConstraintType.Check));
indexLoader.AddIndexes(table);
SchemaConstraintConverter.AddIdentity(ids, table);
table.Triggers.Clear();
table.Triggers.AddRange(triggerConverter.Triggers(tableName));
_sr.PostProcessing(table);
}
DatabaseSchema.Tables.Clear();
DatabaseSchema.Tables.AddRange(tables);
UpdateReferences();
if (DatabaseSchema.DataTypes.Count > 0)
{
DatabaseSchemaFixer.UpdateDataTypes(DatabaseSchema);
}
_sr.PostProcessing(DatabaseSchema);
return(tables);
}
