/// <summary>
/// Creates a collection of tables found in the schema.
/// </summary>
/// <param name="xmlSchema">The schema that describes the data model.</param>
/// <returns>A list of TableSchema objects that describe the tables found in the data model schema.</returns>
private void FirstPass(XmlSchemaSet xmlSchemaSet)
{
// Scan through the schema set looking for table elements. These can either be defined at the root element for a standard
// schema or they can be found as choices of a special element describing a 'DataSet' for the Microsoft version of a
// schema.
foreach (XmlSchemaElement xmlSchemaElement in xmlSchemaSet.GlobalElements.Values)
{
// If the element read from the schema is the Microsoft DataSet element, then the tables are described as choices
// associated with an implicit complex type on that element.
if (ObjectSchema.IsDataSetElement(xmlSchemaElement))
{
// The tables are described as an choices of an implicit (nested) complex type.
if (xmlSchemaElement.SchemaType is XmlSchemaComplexType)
{
// The complex type describes the table.
XmlSchemaComplexType xmlSchemaComplexType = xmlSchemaElement.SchemaType as XmlSchemaComplexType;
// The data model is described as a set of one or more choices of tables.
if (xmlSchemaComplexType.Particle is XmlSchemaChoice)
{
// The data model is described as a set of choices. Each choice represents a table.
XmlSchemaChoice xmlSchemaChoice = xmlSchemaComplexType.Particle as XmlSchemaChoice;
// Create a table for each of the choices described in the complex type.
foreach (XmlSchemaObject choiceObject in xmlSchemaChoice.Items)
{
if (choiceObject is XmlSchemaElement)
{
XmlSchemaElement tableElement = choiceObject as XmlSchemaElement;
this.tableList.Add(tableElement.Name, new TableSchema(this, tableElement));
}
}
}
}
// The constraints describe the columns that are unique for a table.
foreach (XmlSchemaIdentityConstraint xmlSchemaIdentityConstraint in xmlSchemaElement.Constraints)
{
// This describes the columns that must be unique within a table.
if (xmlSchemaIdentityConstraint is XmlSchemaUnique)
{
XmlSchemaUnique xmlSchemaUnique = xmlSchemaIdentityConstraint as XmlSchemaUnique;
UniqueConstraintSchema uniqueConstraintSchema = new UniqueConstraintSchema(this, xmlSchemaUnique);
uniqueConstraintSchema.Table.Add(uniqueConstraintSchema);
}
}
}
}
}
/// <summary>
/// Creates an array of values from a unique constraint that can be used for finding records.
/// </summary>
/// <param name="uniqueConstraintSchema">A description of a unique constraint.</param>
/// <returns>An array of expressions that can be used as a key for finding records in a table.</returns>
public CodeExpression[] CreateKey(UniqueConstraintSchema uniqueConstraintSchema)
{
// This will cycle through all the foreign and simple parameters looking for any columns that match up to the child
// columns of the constraint. When found, they are placed in the array in the proper order to match up against the
// given unique constraint.
List <CodeExpression> keys = new List <CodeExpression>();
foreach (ColumnSchema uniqueColumn in uniqueConstraintSchema.Columns)
{
foreach (KeyValuePair <string, ExternalParameterItem> parameterPair in this.ExternalParameterItems)
{
// This correlates the unique constraint columns with the variables that have been created in the method to
// hold the key values from the foreign tables. These variables exist outside of the conditional logic that
// finds the parent row, so if the parent key is null, these values will also be null. However, since they're
// still declared, they can be used to construct keys, which is useful when they're optional values.
if (parameterPair.Value is ForeignKeyConstraintParameterItem)
{
ForeignKeyConstraintParameterItem foreignKeyConstraintParameterItem = parameterPair.Value as ForeignKeyConstraintParameterItem;
ForeignKeyConstraintSchema foreignKeyConstraintSchema = foreignKeyConstraintParameterItem.ForeignKeyConstraintSchema;
for (int columnIndex = 0; columnIndex < foreignKeyConstraintSchema.Columns.Length; columnIndex++)
{
if (uniqueColumn == foreignKeyConstraintSchema.Columns[columnIndex])
{
foreach (ForeignKeyVariableItem foreignKeyVariableItem in foreignKeyConstraintParameterItem.ForeignKeyVariables)
{
if (foreignKeyConstraintSchema.Columns[columnIndex] == foreignKeyVariableItem.ColumnSchema)
{
keys.Add(foreignKeyVariableItem.Expression);
}
}
}
}
}
// This will match the columns described in the simple parameters to the columns in the unique constraint.
if (parameterPair.Value is SimpleParameterItem)
{
SimpleParameterItem simpleParameterItem = parameterPair.Value as SimpleParameterItem;
if (uniqueColumn == simpleParameterItem.ColumnSchema)
{
keys.Add(new CodeVariableReferenceExpression(CommonConversion.ToCamelCase(simpleParameterItem.ColumnSchema.Name)));
}
}
}
}
// This array can be used as a key to find the record in a table.
return(keys.ToArray());
}
/// <summary>
/// Adds a constraint to the table.
/// </summary>
/// <param name="constraintSchema">The constraint to be added.</param>
public void Add(ConstraintSchema constraintSchema)
{
// This member provides quick access to the primary unique constraint.
if (constraintSchema is UniqueConstraintSchema)
{
UniqueConstraintSchema uniqueSchema = constraintSchema as UniqueConstraintSchema;
if (uniqueSchema.IsPrimaryKey)
{
this.primaryKey = uniqueSchema;
}
}
// All constraints on the table are place in this collection. When the CodeDOM is created, this table will be
// examined and an equivalent constraint will be placed on the target table.
this.constraintList.Add(constraintSchema.Name, constraintSchema);
}