private static DatabaseSchema Arrange()
{
const string key1 = "OriginKey1";
const string key2 = "OriginKey2";
var schema = new DatabaseSchema(null, null);
var table = schema.AddTable("Products")
.AddColumn("ProductId", "INT").AddPrimaryKey().AddIdentity()
.AddColumn("ProductName", "NVARCHAR")
.AddColumn(key1, "NVARCHAR").AddForeignKey("Origin")
.AddColumn(key2, "NVARCHAR")
.Table;
table.ForeignKeys.Single().AddColumn(table.FindColumn(key2));
var pk = new DatabaseConstraint {
ConstraintType = ConstraintType.PrimaryKey,
};
pk.Columns.Add(key1);
pk.Columns.Add(key2);
schema.AddTable("Origin")
.AddColumn <string>(key1).AddPrimaryKey()
.AddColumn <string>(key2)
.Table.AddConstraint(pk);
schema.DataTypes.Add(new DataType("INT", "System.Int32"));
schema.DataTypes.Add(new DataType("NVARCHAR", "System.String"));
DatabaseSchemaFixer.UpdateDataTypes(schema);
//make sure .Net names are assigned
PrepareSchemaNames.Prepare(schema, new Namer());
return(schema);
}
public void WriteSharedPrimaryKeyTest()
{
//arrange
var schema = new DatabaseSchema(null, null);
schema
.AddTable("vehicle")
.AddColumn <string>("regnum").AddPrimaryKey().AddLength(25)
.AddColumn <string>("model").AddLength(32)
.AddTable("car")
.AddColumn <string>("regnum").AddLength(25).AddPrimaryKey().AddForeignKey("fk", "vehicle")
.AddColumn <int>("doors");
//make sure it's all tied up
DatabaseSchemaFixer.UpdateReferences(schema);
//make sure .Net names are assigned
PrepareSchemaNames.Prepare(schema, new Namer());
var table = schema.FindTableByName("car");
var cw = new ClassWriter(table, new CodeWriterSettings {
CodeTarget = CodeTarget.PocoEntityCodeFirst
});
//act
var txt = cw.Write();
//assert
var hasScalarKey = txt.Contains("public string Regnum { get; set; }");
var hasForeignKey = txt.Contains("public virtual Vehicle Vehicle { get; set; }");
Assert.IsTrue(hasScalarKey);
Assert.IsTrue(hasForeignKey);
}
/// <summary>
/// Gets all tables (plus constraints, indexes and triggers).
/// </summary>
public IList <DatabaseTable> AllTables(CancellationToken ct)
{
if (ct.IsCancellationRequested)
{
return(new List <DatabaseTable>());
}
RaiseReadingProgress(SchemaObjectType.Tables);
IList <DatabaseTable> tables;
using (_readerAdapter.CreateConnection())
{
var builder = new TableBuilder(_readerAdapter);
tables = builder.Execute(ct);
}
if (ct.IsCancellationRequested)
{
return(tables);
}
DatabaseSchema.Tables.Clear();
DatabaseSchema.Tables.AddRange(tables);
UpdateReferences();
if (DatabaseSchema.DataTypes.Count == 0)
{
DataTypes(); //force load of datatypes
}
else
{
DatabaseSchemaFixer.UpdateDataTypes(DatabaseSchema);
}
return(tables);
}
public void MappingNameTest()
{
//arrange
var schema = new DatabaseSchema(null, null);
var table = schema.AddTable("Products")
.AddColumn("ProductId", DbType.Int32).AddPrimaryKey().AddIdentity()
.Table;
table.NetName = "Product";
//we need datatypes
schema.DataTypes.Add(new DataType("INT", "System.Int32"));
//make sure it's all tied up
DatabaseSchemaFixer.UpdateReferences(schema);
var codeWriterSettings = new CodeWriterSettings {
CodeTarget = CodeTarget.PocoEntityCodeFirst
};
var target = new CodeFirstMappingWriter(table, codeWriterSettings, new MappingNamer());
//act
target.Write();
//now the name is assigned
var className = target.MappingClassName;
//assert
Assert.AreEqual("ProductMapping", className);
}
public void IsImageTest()
{
//arrange
var schema = new DatabaseSchema(null, null);
var table = schema.AddTable("Products")
.AddColumn("ProductId", DbType.Int32).AddPrimaryKey().AddIdentity()
.AddColumn("Picture", "image")
.Table;
//we need datatypes
schema.DataTypes.Add(new DataType("INT", "System.Int32"));
schema.DataTypes.Add(new DataType("image", "System.Byte[]"));
//make sure it's all tied up
DatabaseSchemaFixer.UpdateReferences(schema);
var target = new CodeFirstMappingWriter(table, new CodeWriterSettings(), new MappingNamer());
//act
var result = target.Write();
//assert
//EF CF will default to varbinary so we must specify
var hasImageType = result.Contains("Property(x => x.Picture).HasColumnType(\"image\")");
Assert.IsTrue(hasImageType);
}
private static DatabaseSchema Arrange()
{
var schema = new DatabaseSchema(null, null);
schema.AddTable("Categories")
.AddColumn <int>("CategoryId").AddPrimaryKey()
.AddColumn <string>("CategoryName")
.AddTable("Products")
.AddColumn <int>("ProductId").AddPrimaryKey()
.AddColumn <string>("ProductName");
var assoc =
schema.AddTable("ProductCategories")
.AddColumn <int>("CategoryId").AddPrimaryKey().AddForeignKey("Categories")
.AddColumn <int>("ProductId").AddForeignKey("Products")
.Table;
assoc.PrimaryKey.AddColumn(assoc.FindColumn("ProductId"));
DatabaseSchemaFixer.UpdateDataTypes(schema);
//make sure .Net names are assigned
PrepareSchemaNames.Prepare(schema, new Namer());
return(schema);
}
public void TestCompositeKeys()
{
//arrange
var schema = new DatabaseSchema(null, null);
schema.AddTable("Store")
.AddColumn <int>("Store_Id").AddPrimaryKey("Store_PK")
.AddColumn <string>("Name").AddLength(10)
.AddTable("StoreSale")
.AddColumn <int>("Store_Id").AddForeignKey("Store_FK", "Store")
.AddColumn <int>("StoreSale_Id")
.AddTable("StoreSaleDetail")
.AddColumn <int>("Store_Id").AddForeignKey("Store_FK", "Store")
.AddColumn <int>("StoreSale_Id")
.AddColumn <int>("StoreSaleDetail_Id")
;
var store = schema.FindTableByName("Store");
var storeSale = schema.FindTableByName("StoreSale");
var storeSaleDetail = schema.FindTableByName("StoreSaleDetail");
var pk1 = new DatabaseConstraint {
ConstraintType = ConstraintType.PrimaryKey
};
pk1.Columns.Add("Store_Id");
pk1.Columns.Add("StoreSale_Id");
storeSale.AddConstraint(pk1);
var pk2 = new DatabaseConstraint {
ConstraintType = ConstraintType.PrimaryKey
};
pk2.Columns.Add("Store_Id");
pk2.Columns.Add("StoreSale_Id");
pk2.Columns.Add("StoreSaleDetail_Id");
storeSaleDetail.AddConstraint(pk2);
var fk = new DatabaseConstraint {
ConstraintType = ConstraintType.ForeignKey, RefersToTable = "StoreSale"
};
fk.Columns.Add("Store_Id");
fk.Columns.Add("StoreSale_Id");
storeSaleDetail.AddConstraint(fk);
//act
DatabaseSchemaFixer.UpdateReferences(schema);
//assert
Assert.AreEqual(2, store.ForeignKeyChildren.Count, "Store is target of foreign keys from StoreSale and StoreSaleDetail");
Assert.AreEqual(1, storeSale.ForeignKeyChildren.Count, "StoreSale is target of foreign key from StoreSaleDetail");
var storeId = storeSaleDetail.FindColumn("Store_Id");
Assert.AreEqual(2, storeId.ForeignKeyTableNames.Count, "StoreSaleDetail.StoreId is fk to both Store and StoreSale");
var storeSaleId = storeSaleDetail.FindColumn("StoreSale_Id");
Assert.AreEqual(1, storeSaleId.ForeignKeyTableNames.Count, "StoreSaleDetail.StoreSale_Id is fk to StoreSale");
}
public void TestCompositeKey()
{
//arrange
var schema = new DatabaseSchema(null, null);
var orderDetail = schema.AddTable("OrderDetails")
.AddColumn("OrderID", DbType.Int32).AddPrimaryKey()
.AddColumn("ProductID", DbType.Int32)
.AddColumn <int>("UnitPrice")
.Table;
orderDetail.PrimaryKey.AddColumn(orderDetail.FindColumn("ProductID"));
DatabaseSchemaFixer.UpdateReferences(schema);
var settings = new CodeWriterSettings {
Namespace = "MyTest", CodeTarget = CodeTarget.PocoNHibernateHbm
};
PrepareSchemaNames.Prepare(schema, settings.Namer);
//act
var target = new MappingWriter(orderDetail, settings);
var txt = target.Write();
//assert
var errors = Validate(txt);
Assert.IsFalse(errors);
}
public void TestNaturalKey()
{
//arrange
var schema = new DatabaseSchema(null, null);
var diagrams = schema.AddTable("Diagrams")
.AddColumn("diagram_id", DbType.Int32).AddPrimaryKey()
.AddColumn <string>("name").AddLength(10).AddUniqueKey()
.AddColumn <int>("principal_id")
.Table;
diagrams.UniqueKeys.Single().AddColumn(diagrams.FindColumn("principal_id"));
DatabaseSchemaFixer.UpdateReferences(schema);
var settings = new CodeWriterSettings {
Namespace = "MyTest", CodeTarget = CodeTarget.PocoNHibernateHbm
};
PrepareSchemaNames.Prepare(schema, settings.Namer);
//act
var target = new MappingWriter(diagrams, settings);
var txt = target.Write();
//assert
var errors = Validate(txt);
Assert.IsFalse(errors);
}
/// <summary>
/// Gets the table. If <see cref="Owner" /> is specified, it is used.
/// </summary>
/// <param name="tableName">Name of the table. Oracle names can be case sensitive.</param>
/// <param name="ct">The ct.</param>
public DatabaseTable Table(string tableName, CancellationToken ct)
{
if (string.IsNullOrEmpty(tableName))
{
throw new ArgumentNullException("tableName");
}
var loader = new TableLoader(_schemaReader, DatabaseSchema);
var handler = ReaderProgress;
if (handler != null)
{
loader.ReaderProgress += RaiseReadingProgress;
}
var table = loader.Load(tableName, ct);
if (ct.IsCancellationRequested)
{
return(table);
}
if (DatabaseSchema.DataTypes.Count > 0)
{
DatabaseSchemaFixer.UpdateDataTypes(DatabaseSchema);
}
_schemaReader.PostProcessing(DatabaseSchema);
return(table);
}
public void TestSimpleMapping()
{
//arrange
var schema = new DatabaseSchema(null, null);
schema.AddTable("Categories")
.AddColumn("CategoryId", DbType.Int32).AddPrimaryKey()
.AddColumn("CategoryName", DbType.String);
var products = schema.AddTable("Products")
.AddColumn("ProductId", DbType.Int32).AddPrimaryKey()
.AddColumn("ProductName", DbType.String)
.AddColumn("CategoryId", DbType.Int32).AddForeignKey("fk", "Categories")
.Table;
DatabaseSchemaFixer.UpdateReferences(schema);
var settings = new CodeWriterSettings {
Namespace = "MyTest", CodeTarget = CodeTarget.PocoNHibernateHbm
};
PrepareSchemaNames.Prepare(schema, settings.Namer);
//act
var target = new MappingWriter(products, settings);
var txt = target.Write();
//assert
var errors = Validate(txt);
Assert.IsFalse(errors);
}
public void WriteTest()
{
//arrange
var schema = new DatabaseSchema(null, null);
var table = schema.AddTable("Categories")
.AddColumn("CategoryId", "INT").AddPrimaryKey().AddIdentity()
.AddColumn("CategoryName", "NVARCHAR").Table;
//we need datatypes
schema.DataTypes.Add(new DataType("INT", "System.Int32"));
schema.DataTypes.Add(new DataType("NVARCHAR", "System.String"));
DatabaseSchemaFixer.UpdateDataTypes(schema);
//make sure .Net names are assigned
PrepareSchemaNames.Prepare(schema, new Namer());
//inject the custom code inserter
var codeWriterSettings = new CodeWriterSettings {
CodeInserter = new CustomCodeInserter()
};
var cw = new ClassWriter(table, codeWriterSettings);
//act
var txt = cw.Write();
//assert
Assert.IsTrue(txt.Contains("using System.ComponentModel.DataAnnotations.Schema"));
Assert.IsTrue(txt.Contains("[Table(\"Categories\")]"));
Assert.IsTrue(txt.Contains("[Column(\"CategoryId\")]"));
}
/// <summary>
/// Gets all tables (plus constraints, indexes and triggers).
/// </summary>
public IList <DatabaseTable> AllTables(CancellationToken ct)
{
var loader = new AllTablesLoader(_schemaReader, Exclusions);
var handler = ReaderProgress;
if (handler != null)
{
loader.ReaderProgress += RaiseReadingProgress;
}
var tables = loader.Load(ct);
if (ct.IsCancellationRequested)
{
return(tables);
}
DatabaseSchema.Tables.Clear();
DatabaseSchema.Tables.AddRange(tables);
UpdateReferences();
if (DatabaseSchema.DataTypes.Count > 0)
{
DatabaseSchemaFixer.UpdateDataTypes(DatabaseSchema);
}
_schemaReader.PostProcessing(DatabaseSchema);
return(tables);
}
public void HasMaxLengthTest()
{
//arrange
var schema = new DatabaseSchema(null, null);
var table = schema.AddTable("Products")
.AddColumn("ProductId", DbType.Int32).AddPrimaryKey().AddIdentity()
.AddColumn("ProductName", DbType.String).AddLength(20)
.Table;
//we need datatypes
schema.DataTypes.Add(new DataType("INT", "System.Int32"));
schema.DataTypes.Add(new DataType("NVARCHAR", "System.String"));
//make sure it's all tied up
DatabaseSchemaFixer.UpdateReferences(schema);
var target = new CodeFirstMappingWriter(table, new CodeWriterSettings(), new MappingNamer());
//act
var result = target.Write();
//assert
var hasMaxLength = result.Contains("Property(x => x.ProductName).HasMaxLength(20)");
Assert.IsTrue(hasMaxLength);
}
public void MappingSharedPrimaryKeyTest()
{
//arrange
var schema = new DatabaseSchema(null, null);
schema
.AddTable("vehicle")
.AddColumn <string>("regnum").AddPrimaryKey().AddLength(25)
.AddColumn <string>("model").AddLength(32)
.AddTable("car")
.AddColumn <string>("regnum").AddLength(25).AddPrimaryKey().AddForeignKey("fk", "vehicle")
.AddColumn <int>("doors");
//make sure it's all tied up
DatabaseSchemaFixer.UpdateReferences(schema);
//make sure .Net names are assigned
PrepareSchemaNames.Prepare(schema, new Namer());
var table = schema.FindTableByName("car");
var mappingNamer = new MappingNamer();
var codeWriterSettings = new CodeWriterSettings {
CodeTarget = CodeTarget.PocoEntityCodeFirst
};
var target = new CodeFirstMappingWriter(table, codeWriterSettings, mappingNamer);
//act
var txt = target.Write();
//assert
var hasScalarKey = txt.Contains("HasKey(x => x.Regnum);");
var hasForeignKey = txt.Contains("HasRequired(x => x.Vehicle);");
Assert.IsTrue(hasScalarKey);
Assert.IsTrue(hasForeignKey);
}
public void MappingNameWithConflictsTest()
{
//arrange
var schema = new DatabaseSchema(null, null);
var table = schema.AddTable("Products")
.AddColumn("ProductId", DbType.Int32).AddPrimaryKey().AddIdentity()
.Table;
table.NetName = "Product";
//we need datatypes
schema.DataTypes.Add(new DataType("INT", "System.Int32"));
//make sure it's all tied up
DatabaseSchemaFixer.UpdateReferences(schema);
var mappingNamer = new MappingNamer();
var target = new CodeFirstMappingWriter(table, new CodeWriterSettings(), mappingNamer);
//we also have a table called "ProductMapping"
//so we can't call the mapping class for "Product" the same name
mappingNamer.EntityNames.Add("ProductMapping");
mappingNamer.EntityNames.Add("ProductMappingMap");
//act
target.Write();
//now the name is assigned
var className = target.MappingClassName;
//assert
Assert.AreEqual("ProductMappingMapMap", className, "Should not conflict with the existing names");
Assert.AreEqual(3, mappingNamer.EntityNames.Count, "Should add the name to the list");
}
/// <summary>
/// Gets all views.
/// </summary>
public IList <DatabaseView> AllViews(CancellationToken ct)
{
if (ct.IsCancellationRequested)
{
return(DatabaseSchema.Views);
}
IList <DatabaseView> views;
using (_readerAdapter.CreateConnection())
{
var builder = new ViewBuilder(_readerAdapter, Exclusions);
var handler = ReaderProgress;
if (handler != null)
{
builder.ReaderProgress += RaiseReadingProgress;
}
views = builder.Execute(ct);
}
DatabaseSchema.Views.Clear();
DatabaseSchema.Views.AddRange(views);
UpdateReferences();
if (DatabaseSchema.DataTypes.Count > 0)
{
DatabaseSchemaFixer.UpdateDataTypes(DatabaseSchema);
}
return(views);
}
public void WriteTest()
{
//arrange
var schema = new DatabaseSchema(null, null);
var table = schema.AddTable("Categories")
.AddColumn("CategoryId", "INT").AddPrimaryKey().AddIdentity()
.AddColumn("CategoryName", "NVARCHAR").Table;
//we need datatypes
schema.DataTypes.Add(new DataType("INT", "System.Int32"));
schema.DataTypes.Add(new DataType("NVARCHAR", "System.String"));
DatabaseSchemaFixer.UpdateDataTypes(schema);
//make sure .Net names are assigned
PrepareSchemaNames.Prepare(schema);
var cw = new ClassWriter(table, new CodeWriterSettings());
//act
var txt = cw.Write();
//assert
var hasName = txt.Contains("public class Category");
var hasCategoryId = txt.Contains("public virtual int CategoryId { get; set; }");
var hasCategoryName = txt.Contains("public virtual string CategoryName { get; set; }");
Assert.IsTrue(hasName);
Assert.IsTrue(hasCategoryId);
Assert.IsTrue(hasCategoryName);
}
private static DatabaseSchema PrepareModel()
{
var schema = new DatabaseSchema(null, null);
schema.AddTable("Categories")
.AddColumn("CategoryId", DbType.Int32).AddPrimaryKey()
.AddColumn("CategoryName", DbType.String);
schema.AddTable("Suppliers")
.AddColumn("SupplierId", DbType.Int32).AddPrimaryKey()
.AddColumn("SupplierName", DbType.String);
schema.AddTable("Products")
.AddColumn("ProductId", DbType.Int32).AddPrimaryKey().AddIdentity()
.AddColumn("ProductName", DbType.String)
.AddColumn("SupplierKey", DbType.Int32).AddForeignKey("fk", "Suppliers");
schema.AddTable("CategoryProducts")
.AddColumn("CategoryId", DbType.Int32).AddPrimaryKey()
.AddForeignKey("fk", "Categories")
.AddColumn("ProductId", DbType.Int32).AddPrimaryKey()
.AddForeignKey("fk", "Products");
DatabaseSchemaFixer.UpdateReferences(schema);
PrepareSchemaNames.Prepare(schema, new Namer());
return(schema);
}
/// <summary>
/// Gets all datatypes (and updates columns/arguments if already loaded)
/// </summary>
public IList <DataType> DataTypes()
{
var list = _readerAdapter.DataTypes();
DatabaseSchema.DataTypes.Clear();
DatabaseSchema.DataTypes.AddRange(list);
DatabaseSchemaFixer.UpdateDataTypes(DatabaseSchema); //if columns/arguments loaded later, run this method again.
return(list);
}
private void UpdateReferences()
{
//a simple latch so ReadAll will only call this at the end
if (!_fixUp)
{
return;
}
DatabaseSchemaFixer.UpdateReferences(DatabaseSchema); //updates all references
}
private void UpdateReferences()
{
//a simple latch so ReadAll will only call this at the end
if (!_fixUp)
{
return;
}
DatabaseSchemaFixer.UpdateReferences(DatabaseSchema); //updates all references
//last, do custom post processing if implemented
_sr.PostProcessing(DatabaseSchema);
}
/// <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 void TestSqlServerTimeStampWithTimeZone()
{
//arrange
_column.DbDataType = "TIMESTAMP(6) WITH TIME ZONE";
_column.Precision = 6;
//automatically assign oracle datatypes
var types = new DataTypeList().Execute();
DatabaseSchemaFixer.UpdateDataTypes(types, new List <DatabaseColumn>(new [] { _column }));
//act
var result = _typeWriter.WriteDataType(_column);
//assert
Assert.AreEqual("TIMESTAMP (6) WITH TIME ZONE", result);
}
private static DatabaseTable Arrange()
{
var schema = new DatabaseSchema(null, SqlType.SqlServer);
schema.DataTypes.Add(new DataType("NUMBER", "System.Int32"));
schema.DataTypes.Add(new DataType("VARCHAR2", "System.String"));
var bu = schema.AddTable("BUSINESS_UNITS")
.AddColumn("BUSINESS_UNIT_ID", "NUMBER").AddPrimaryKey().AddIdentity()
.AddColumn("DESCRIPTION", "VARCHAR2")
.Table;
var dept = schema.AddTable("DEPARTMENTS")
.AddColumn("BUSINESS_UNIT_ID", "NUMBER")
.AddColumn("DEPARTMENT_ID", "VARCHAR2").AddLength(4)
.AddColumn("GROUP_ID", "NUMBER")
.Table;
var businessUnitFk = new DatabaseConstraint
{
ConstraintType = ConstraintType.ForeignKey,
RefersToTable = bu.Name
};
businessUnitFk.Columns.Add("BUSINESS_UNIT_ID");
dept.AddConstraint(businessUnitFk);
//This one IS NOT in the model, so there are broken fk links
var groupFk = new DatabaseConstraint
{
ConstraintType = ConstraintType.ForeignKey,
RefersToTable = "GROUPS"
};
groupFk.Columns.Add("BUSINESS_UNIT_ID");
groupFk.Columns.Add("DEPARTMENT_ID");
groupFk.Columns.Add("GROUP_ID");
dept.AddConstraint(groupFk);
var pk = new DatabaseConstraint {
ConstraintType = ConstraintType.PrimaryKey
};
pk.Columns.Add("BUSINESS_UNIT_ID");
pk.Columns.Add("DEPARTMENT_ID");
dept.AddConstraint(pk);
DatabaseSchemaFixer.UpdateDataTypes(schema);
return(dept);
}
//One to one relationships are used for two main reasons:
// * Divide a large table into smaller parts (Product - ProductDetail)
// * Divide a table for security (or because it's updated frequently...) (User, UserPassword)
private static DatabaseSchema Arrange()
{
var schema = new DatabaseSchema(null, null);
schema.AddTable("Products")
.AddColumn <int>("Id").AddPrimaryKey()
.AddColumn <string>("Name")
.AddTable("ProductDetails")
.AddColumn <int>("Id").AddPrimaryKey().AddForeignKey("Products")
.AddColumn <string>("Description");
DatabaseSchemaFixer.UpdateDataTypes(schema);
//make sure .Net names are assigned
PrepareSchemaNames.Prepare(schema, new Namer());
return(schema);
}
public void TestRiaServices()
{
//arrange
var schema = new DatabaseSchema(null, null);
schema.AddTable("Categories")
.AddColumn("CategoryId", DbType.Int32).AddPrimaryKey()
.AddColumn("CategoryName", DbType.String);
schema.AddTable("Products")
.AddColumn("ProductId", DbType.Int32).AddPrimaryKey()
.AddColumn("ProductName", DbType.String)
.AddColumn("CategoryId", DbType.Int32).AddForeignKey("fk", "Categories");
DatabaseSchemaFixer.UpdateReferences(schema);
var directory = TestHelper.CreateDirectory("TestRiaServices");
const string @namespace = "MyTest";
var settings = new CodeWriterSettings {
Namespace = @namespace, CodeTarget = CodeTarget.PocoRiaServices
};
//act
var target = new CodeWriter(schema, settings);
target.Execute(directory);
//assert
var files = directory.GetFiles("*.cs");
var products = files.FirstOrDefault(f => f.Name == "Product.cs");
Assert.IsNotNull(products, "Should have written Product class to represent [Products] table");
var category = files.FirstOrDefault(f => f.Name == "Category.cs");
Assert.IsNotNull(category, "Should have written Category class to represent [Categories] table");
var cs = File.ReadAllText(category.FullName);
var ok = cs.Contains("[MetadataType(typeof(Category.CategoryMetadata))]");
Assert.IsTrue(ok, "Should contain nested metadata class");
}
/// <summary>
/// Gets all stored procedures (and functions) with their arguments
/// </summary>
public IList <DatabaseStoredProcedure> AllStoredProcedures(CancellationToken ct)
{
using (_readerAdapter.CreateConnection())
{
var builder = new ProcedureBuilder(_readerAdapter, DatabaseSchema, Exclusions);
var handler = ReaderProgress;
if (handler != null)
{
builder.ReaderProgress += RaiseReadingProgress;
}
builder.Execute(ct);
}
UpdateReferences();
if (DatabaseSchema.DataTypes.Count > 0)
{
DatabaseSchemaFixer.UpdateDataTypes(DatabaseSchema);
}
return(DatabaseSchema.StoredProcedures);
}
private static DatabaseSchema ArrangeSchema()
{
var schema = new DatabaseSchema(null, null);
schema
.AddTable("Address")
.AddColumn <int>("Address_Id").AddPrimaryKey().AddIdentity()
.AddColumn <string>("Street")
.AddColumn <string>("City")
.AddTable("Orders")
.AddColumn <int>("Order_Id").AddPrimaryKey().AddIdentity()
.AddColumn <string>("Name")
.AddColumn <int>("BillingAddress").AddForeignKey("fk_Orders_Address_Billing", "Address")
.AddColumn <int>("DeliveryAddress").AddForeignKey("fk_Orders_Address_Delivery", "Address")
;
//make sure it's all tied up
DatabaseSchemaFixer.UpdateReferences(schema);
//make sure .Net names are assigned
PrepareSchemaNames.Prepare(schema, new Namer());
return(schema);
}
private static DatabaseSchema ArrangeSchema()
{
var schema = new DatabaseSchema(null, null);
schema
.AddTable("Categories")
.AddColumn("CategoryId", "INT").AddPrimaryKey().AddIdentity()
.AddColumn("CategoryName", "NVARCHAR")
.AddTable("Products")
.AddColumn("ProductId", "INT").AddPrimaryKey()
.AddColumn("ProductName", "NVARCHAR")
.AddColumn("CategoryId", "INT").AddForeignKey("fk", "Categories");
//we need datatypes
schema.DataTypes.Add(new DataType("INT", "System.Int32"));
schema.DataTypes.Add(new DataType("NVARCHAR", "System.String"));
//make sure it's all tied up
DatabaseSchemaFixer.UpdateReferences(schema);
//make sure .Net names are assigned
PrepareSchemaNames.Prepare(schema);
return(schema);
}
