public TableDescriptor(TSqlTable table)
{
Columns = BuildColumnDescriptors(table);
Name = table.Name;
Constraints = BuildConstraints(table);
}
private List<ColumnDescriptor> BuildColumnDescriptors(TSqlTable table)
{
if (!CanDecodeAllColumns(table))
{
//throw new InvalidOperationException
MessageBox.Show("Unable to work out column types for: " + table.Name.GetSchemaObjectName() +
" \r\nIf it has any user defined types then MergeUi doesn't support that right now");
return null;
}
return table.Columns.Where(column => column.ColumnType == ColumnType.Column).Select(column => new ColumnDescriptor(column)).ToList();
}
private IEnumerable<Constraint> BuildConstraints(TSqlTable table)
{
var constraints = new List<Constraint>();
foreach (var c in table.PrimaryKeyConstraints)
{
constraints.Add(new Constraint()
{
Name = c.Name, Type = ConstraintType.PrimaryKey
});
}
return constraints;
}
private bool CanDecodeAllColumns(TSqlTable table)
{
try
{
foreach (TSqlColumn column in table.Columns.Where(column => column.ColumnType == ColumnType.Column))
{
if (column.ObjectType == UserDefinedType.TypeClass)
{
}
var descriptor = new ColumnDescriptor(column);
}
}
catch (Exception e)
{
return false;
}
return true;
}
public ProcedureBuilder(string testSchema, string testName, TSqlTableValuedFunction procedureUnderTest)
{
CodeType = CodeType.Function;
_testProcedure.StatementList = new StatementList();
foreach (var t in procedureUnderTest.BodyDependencies)
{
if (t.ObjectType == ModelSchema.Table)
{
//table to fake
var table = new TSqlTable(t.Element);
AddTable(table.Name);
}
}
foreach (var p in procedureUnderTest.Parameters)
{
AddParameter(p.Name.GetName().UnQuote(), GetParameterType(p.DataType));
}
CreateTestProcedureDefinition(testSchema, testName);
CreateSelectForFunctionUnderTest(procedureUnderTest.Name);
}
private static string GenerateTest(TSqlProcedure procedure)
{
var builder = new ProcedureBuilder(procedure.Name.Parts.Last(), "[test To Be Implemented]", procedure.Name.ToSchemaObjectName());
foreach (var param in procedure.Parameters)
{
foreach (var type in param.DataType)
{
builder.AddParameter(param.Name.Parts.Last(), type.SqlDataType);
break;
}
}
foreach (var dependency in procedure.BodyDependencies)
{
if (dependency.ObjectType == ModelSchema.Table)
{
var table = new TSqlTable(dependency);
builder.AddTable(table.Name.ToSchemaObjectName());
}
}
return builder.GetScript();
}
private static void ValidateColumnDataType(TSqlTable table, string columnName, SqlDataType columnType, SqlDataType? baseSqlType)
{
TSqlColumn ssnColomn = table.Columns.SingleOrDefault(c => c.Name.Parts[2] == columnName);
Assert.IsNotNull(ssnColomn, "Missing {0} Column", columnName);
var columnDataType = ssnColomn.DataType.SingleOrDefault() as TSqlDataTypeReference;
Assert.IsNotNull(columnDataType, "{0} column data type should not be null", columnName);
Assert.AreEqual(columnType, columnDataType.SqlDataType, "{0} data type should be based off {1}", columnName, columnType);
if (baseSqlType != null)
{
var baseType = columnDataType.Type.SingleOrDefault();
Assert.IsNotNull(baseType, "column base type should not be null");
Assert.AreEqual(baseSqlType, baseType.SqlDataType, "Incorrect SQLDataType for base type");
}
}
