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);
}
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);
}
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);
}
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);
}
private static DatabaseSchema CreateSchema()
{
var schema = new DatabaseSchema(null, "System.Data.SqlClient");
var orders = schema.AddTable("Orders")
.AddColumn <int>("Id").AddPrimaryKey("PK_Orders")
.AddColumn <string>("Name").AddUniqueKey("UK_NAME")
.AddColumn <string>("Desc").AddIndex("IDX_Desc")
.Table;
orders.SchemaOwner = Schema;
orders.Triggers.Add(new DatabaseTrigger {
Name = "MyTrigger"
});
var lines = schema.AddTable("Order_Line")
.AddColumn <int>("Id").AddPrimaryKey("PK_OrderLine")
.AddColumn <int>("Price")
.AddColumn <int>("Order_Id").AddForeignKey("FK_OrderLine_Orders", "Orders")
.Table;
lines.SchemaOwner = Schema;
schema.StoredProcedures.Add(new DatabaseStoredProcedure {
Name = "MySproc", SchemaOwner = Schema
});
schema.Functions.Add(new DatabaseFunction {
Name = "MyFunction", SchemaOwner = Schema
});
schema.Packages.Add(new DatabasePackage {
Name = "MyPackage", SchemaOwner = Schema
});
schema.Views.Add(new DatabaseView {
Name = "MyView", SchemaOwner = Schema
});
schema.Sequences.Add(new DatabaseSequence {
Name = "MySequence", SchemaOwner = Schema
});
//table with same name under different schema
var orders2 = schema.AddTable("Orders")
.AddColumn <int>("Id").AddPrimaryKey("PK_Orders")
.AddColumn <string>("Name").AddUniqueKey("UK_NAME")
.AddColumn <string>("Desc").AddIndex("IDX_Desc")
.Table;
orders2.SchemaOwner = Schema + "2";
return(schema);
}
public void TestConstraintEscaping()
{
//#119 escaping was not cascaded down from table generator to constraint generator
//arrange
var type = SqlType.PostgreSql;
var schemaTemp = new DatabaseSchema(null, type);
var newTable = schemaTemp.AddTable("Chapter");
var idColumn = newTable.AddColumn("Id", DbType.Int64);
idColumn.AddPrimaryKey("Chapter_Pk");
var migration = new DdlGeneratorFactory(type).MigrationGenerator();
migration.EscapeNames = false;
//act
var sql = migration.AddTable(newTable);
Assert.IsTrue(sql.Contains("ALTER TABLE Chapter ADD CONSTRAINT Chapter_Pk PRIMARY KEY (Id)"), "No escaping for names");
migration.EscapeNames = true;
sql = migration.AddTable(newTable);
Assert.IsTrue(sql.Contains("ALTER TABLE \"Chapter\" ADD CONSTRAINT \"Chapter_Pk\" PRIMARY KEY (\"Id\");"), "Escaping for names");
}
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);
}
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 GivenUnnamedConstraintsThenStandardNamesAssigned()
{
//arrange
var schema = new DatabaseSchema(null, SqlType.PostgreSql);
schema
.AddTable("Category")
.AddColumn <int>("CategoryId").AddPrimaryKey()
.AddColumn <string>("CategoryName").AddLength(50).AddNullable()
.AddTable("Product")
.AddColumn <int>("Id").AddPrimaryKey()
.AddColumn <string>("ProductName").AddLength(50).AddUniqueKey()
.AddColumn <int>("CategoryId").AddForeignKey("Category")
;
var table = schema.FindTableByName("Product");
var ddlGen = new DdlGeneratorFactory(SqlType.PostgreSql);
var tabGen = ddlGen.TableGenerator(table);
//act
var ddl = tabGen.Write();
//assert
var hasPrimaryKey =
ddl.Contains("ALTER TABLE \"Product\" ADD CONSTRAINT \"Product_Id_pkey\" PRIMARY KEY (\"Id\");");
var hasUniqueKey =
ddl.Contains("ALTER TABLE \"Product\" ADD CONSTRAINT \"Product_ProductName_key\" UNIQUE (\"ProductName\");");
Assert.IsTrue(hasPrimaryKey);
Assert.IsTrue(hasUniqueKey);
}
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 TestForeignKeysToUniqueKey()
{
//arrange
var schema = new DatabaseSchema(null, null);
schema.AddTable("Target")
.AddColumn <int>("Target_Id").AddPrimaryKey("TARGET_PK")
.AddColumn <string>("Name").AddLength(10).AddUniqueKey("TARGET_UQ1")
.AddTable("Source")
.AddColumn <int>("Source_Id").AddPrimaryKey("SOURCE_PK")
.AddColumn <string>("Target_Name");
var source = schema.FindTableByName("Source");
var target = schema.FindTableByName("Target");
source.AddConstraint(new DatabaseConstraint
{
ConstraintType = ConstraintType.ForeignKey,
Name = "SOURCE_FK",
RefersToTable = "Target",
TableName = "Source",
RefersToConstraint = "TARGET_UQ1",
});
var fk = source.ForeignKeys[0];
fk.Columns.Add("Target_Name");
//act
var referencedColumns = fk.ReferencedColumns(schema);
//assert
Assert.AreEqual(target.UniqueKeys[0].Columns, referencedColumns, "Columns are matched up");
}
public void TestSqlServerCeSchema()
{
//arrange
var schema = new DatabaseSchema(null, SqlType.SqlServerCe);
//two tables with a FK between them
schema.AddTable("Categories")
.AddColumn <int>("Id").AddIdentity().AddPrimaryKey()
.AddColumn <string>("Name").AddLength(200)
.AddTable("Products")
.AddColumn <int>("Id").AddIdentity().AddPrimaryKey()
.AddColumn <string>("Name").AddLength(200)
.AddColumn <int>("CategoryId").AddForeignKey("Categories")
;
var factory = new DdlGeneratorFactory(SqlType.SqlServerCe);
var tablesGenerator = factory.AllTablesGenerator(schema);
tablesGenerator.IncludeSchema = false;
//act
var ddl = tablesGenerator.Write();
//assert
Assert.IsTrue(ddl.Contains("GO")); //batch separators
Assert.IsFalse(ddl.Contains(";")); //valid but useless in SqlServer CE because you can't batch
}
private static DatabaseSchema BuildSchema()
{
var schema = new DatabaseSchema(null, "Dummy");
schema
.AddTable("Categories")
//chaining adding pk and identity
.AddColumn("CategoryId", "INT").AddPrimaryKey().AddIdentity()
//chaining from one column to next, with full access to the new column
.AddColumn("CategoryName", "VARCHAR", c => c.Length = 30)
.AddIndex("IndexByName")
//chaining from a column to the next table
.AddTable("Products")
.AddColumn("ProductId", "INT").AddIdentity().AddPrimaryKey("PK_PRODUCTS")
//add additional properties to column
.AddColumn("ProductName", "VARCHAR", c =>
{
c.Length = 30;
c.Nullable = true;
})
//adding a column directly
.AddColumn(new DatabaseColumn {
Name = "Price", DbDataType = "DECIMAL", Nullable = true
})
//adding a fk
.AddColumn("CategoryId", "INT")
.AddForeignKey("FK_CATEGORY", tables => tables.Where(x => x.Name == "Categories").First());
return(schema);
}
public void TestForeignKeysCrossSchema()
{
//arrange
var schema = new DatabaseSchema(null, null);
schema.AddTable("Target")
.AddColumn <int>("Target_Id").AddPrimaryKey("TARGET_PK")
.AddColumn <string>("Name").AddLength(10).AddUniqueKey("TARGET_UQ1")
.AddTable("Source")
.AddColumn <int>("Source_Id").AddPrimaryKey("SOURCE_PK")
.AddColumn <int>("Target_Id");
var source = schema.FindTableByName("Source");
var target = schema.FindTableByName("Target");
target.SchemaOwner = "dbo";
source.SchemaOwner = "other";
var targetId = source.FindColumn("Target_Id");
targetId.AddForeignKey("SOURCE_FK", tables => target);
//act
var fk = source.ForeignKeys[0];
//assert
Assert.AreEqual("Target", fk.RefersToTable, "Name of referenced table");
Assert.AreEqual(target, fk.ReferencedTable(schema), "Actual reference to table");
Assert.AreEqual(target.PrimaryKey.Columns, fk.ReferencedColumns(schema), "Columns are matched up");
}
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\")]"));
}
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 TestAddPrimaryKeyNoEscapeNames()
{
//arrange
var migration = new DdlGeneratorFactory(SqlType.SqlServer).MigrationGenerator();
migration.EscapeNames = false;
var schema = new DatabaseSchema(null, SqlType.SqlServer);
var table = schema.AddTable("Test")
.AddColumn <int>("Id")
.AddColumn <string>("Name")
.Table;
var pk = new DatabaseConstraint
{
Name = "Test_PK",
ConstraintType = ConstraintType.PrimaryKey
};
pk.Columns.Add("Id");
//act
var sql = migration.AddConstraint(table, pk);
//assert
Assert.IsTrue(sql.IndexOf("ADD CONSTRAINT Test_PK PRIMARY KEY (Id)", StringComparison.OrdinalIgnoreCase) != -1, "adding a primary key");
}
public void PropertiesTest()
{
var schema = new DatabaseSchema(null, null);
schema
.AddTable("Categories")
.AddColumn("CategoryId", DbType.Int32).AddPrimaryKey()
.AddColumn("CategoryName", DbType.String).AddLength(50).AddNullable()
.AddColumn("Cost", DbType.Decimal).AddPrecisionScale(15, 4).AddNullable();
//assert
var cats = schema.FindTableByName("Categories");
var catName = cats.FindColumn("CategoryName");
Assert.AreEqual("NVARCHAR", catName.DbDataType);
Assert.AreEqual(50, catName.Length);
Assert.AreEqual(true, catName.Nullable);
Assert.IsNotNull(catName.DataType);
Assert.AreEqual(true, catName.DataType.IsString);
var cost = cats.FindColumn("Cost");
Assert.AreEqual("DECIMAL", cost.DbDataType);
Assert.AreEqual(15, cost.Precision);
Assert.AreEqual(4, cost.Scale);
Assert.AreEqual(true, cost.Nullable);
Assert.IsNotNull(cost.DataType);
Assert.AreEqual(true, cost.DataType.IsNumeric);
}
public void TestReferencedTableViaRefersToTable()
{
//create a schema
var schema = new DatabaseSchema(null, SqlType.SqlServer);
schema.AddTable("Categories")
.AddColumn("CategoryId").AddPrimaryKey("CategoryPK")
.AddColumn("CategoryName")
.AddTable("Products")
.AddColumn("ProductId").AddPrimaryKey()
.AddColumn("ProductName")
.AddColumn("CategoryId").AddForeignKey("Categories");
//look at the schema
var categories = schema.FindTableByName("Categories");
var products = schema.FindTableByName("Products");
var fk = products.ForeignKeys.First();
//act
var referencedTable = fk.ReferencedTable(schema);
//assert
Assert.AreEqual(categories, referencedTable);
}
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");
}
public void TestOracleTableWithTrigger()
{
//arrange
var schema = new DatabaseSchema(null, SqlType.Oracle);
var table = schema.AddTable("Test");
var id = table.AddColumn <int>("Id").AddPrimaryKey();
id.IsAutoNumber = true;
table.AddColumn <string>("Name").AddLength(200);
table.Triggers.Add(new DatabaseTrigger
{
Name = "Test_INS_TRG",
TriggerEvent = "INSERT",
TriggerBody = @"BEGIN
SELECT ""Test_SEQ"".NEXTVAL INTO :NEW.""Id"" FROM DUAL;
END;",
TriggerType = "BEFORE EACH ROW",
});
var tableGen = new TableGenerator(table);
//act
var ddl = tableGen.Write();
//assert
Assert.IsTrue(ddl.Contains("\"Id\" NUMBER (9) NOT NULL,"), "Table should include Id column " + ddl);
//line breaks may cause environmental differences
Assert.IsTrue(ddl.Contains(@"CREATE OR REPLACE TRIGGER ""Test_INS_TRG"""), "Table should include 'create trigger' " + ddl);
Assert.IsTrue(ddl.Contains(@"SELECT ""Test_SEQ"".NEXTVAL INTO :NEW.""Id"" FROM DUAL;"), "Table should include trigger body " + ddl);
}
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 DataTypeWithGenericTypeTest()
{
//arrange
var schema = new DatabaseSchema(null, null);
schema
.AddTable("Categories")
.AddColumn <int>("CategoryId").AddPrimaryKey()
.AddColumn <string>("CategoryName").AddLength(50).AddNullable()
.AddColumn <decimal>("StockLevel").AddPrecisionScale(8, 2).AddNullable()
.AddColumn <DateTime>("Updated");
//assert
var cats = schema.FindTableByName("Categories");
var id = cats.PrimaryKeyColumn;
Assert.AreEqual("INT", id.DbDataType);
Assert.AreEqual(true, id.DataType.IsInt);
var catName = cats.FindColumn("CategoryName");
Assert.AreEqual("NVARCHAR", catName.DbDataType);
Assert.AreEqual(true, catName.DataType.IsString);
var stock = cats.FindColumn("StockLevel");
Assert.AreEqual("DECIMAL", stock.DbDataType);
Assert.AreEqual(true, stock.DataType.IsNumeric);
var updated = cats.FindColumn("Updated");
Assert.AreEqual("DATETIME", updated.DbDataType);
Assert.AreEqual(true, updated.DataType.IsDateTime);
}
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);
}
public void LongIntShouldBeNumber19()
{
//#12 MigrationGenerator does not generate correct oracle data type for int64
//arrange
var schema = new DatabaseSchema(null, SqlType.SqlServer);
var newTable = schema.AddTable("TestTable");
var idColumn = newTable.AddColumn("Id", DbType.Int64);
idColumn.AddPrimaryKey("PK_TestTable");
var summaryColumn = newTable.AddColumn("Summary", DbType.String);
summaryColumn.Length = 100;
var migration = new DdlGeneratorFactory(SqlType.Oracle).MigrationGenerator();
//act
var sql = migration.AddTable(newTable);
//assert
Assert.IsTrue(sql.Contains("\"Id\" NUMBER (19) NOT NULL"));
}
public void RemoveTable()
{
//arrange
var schema = new DatabaseSchema(null, null);
schema
.AddTable("Category")
.AddColumn <int>("CategoryId").AddPrimaryKey()
.AddColumn <string>("CategoryName").AddLength(50).AddNullable()
.AddTable("Product")
.AddColumn <int>("Id").AddPrimaryKey()
.AddColumn <int>("CategoryId").AddForeignKey("Category")
.AddTable("Vendor")
.AddColumn <int>("Id").AddPrimaryKey()
.AddColumn <int>("CategoryId").AddForeignKey("Category")
;
//act
schema.RemoveTable("Category");
//assert
Assert.AreEqual(2, schema.Tables.Count);
var prod = schema.FindTableByName("Product");
Assert.AreEqual(0, prod.ForeignKeys.Count);
var categoryId = prod.FindColumn("CategoryId");
Assert.IsFalse(categoryId.IsForeignKey);
}
public void TestAddPrimaryKeyWithGuid()
{
//arrange
var migration = new DdlGeneratorFactory(SqlType.SqlServer).MigrationGenerator();
var schema = new DatabaseSchema(null, SqlType.SqlServer);
var table = schema.AddTable("Test")
.AddColumn <Guid>("Id")
.AddColumn <string>("Name")
.Table;
var pk = new DatabaseConstraint
{
Name = "Test_PK",
ConstraintType = ConstraintType.PrimaryKey
};
pk.Columns.Add("Id");
table.Indexes.Add(new DatabaseIndex
{
IndexType = "PRIMARY NONCLUSTERED",
Columns = { new DatabaseColumn {
Name = "Id"
} }
});
//act
var sql = migration.AddConstraint(table, pk);
//assert
Assert.IsTrue(sql.IndexOf("ADD CONSTRAINT [Test_PK] PRIMARY KEY NONCLUSTERED([Id])", StringComparison.OrdinalIgnoreCase) != -1, "adding a primary key");
}
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);
}
public void UseEqualityTest()
{
//NamedSchemaObject = has a name and schemaOwner
var schema = new DatabaseSchema(null, null);
schema.Owner = "dbo";
schema.AddTable("A").AddTable("A");
var distinct = schema.Tables.Distinct().Count();
Assert.AreEqual(1, distinct);
//NamedObject = has a name
var cols = new List <DatabaseColumn> {
new DatabaseColumn {
Name = "Id"
}, new DatabaseColumn {
Name = "Name"
}
};
var cols2 = new List <DatabaseColumn> {
new DatabaseColumn {
Name = "Id"
}, new DatabaseColumn {
Name = "Name"
}
};
var union = cols.Union(cols2);
Assert.AreEqual(2, union.Count());
}
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);
}
