private void InitializeColumn(CremaDataColumn dataColumn, ColumnBase column)
{
if (dataColumn.CremaType != null)
{
if (dataColumn.CremaType.IsFlag == true)
{
column.CellEditor = this.FindResource("CremaFlagTypeSelector") as CellEditor;
}
else
{
column.CellEditor = this.FindResource("CremaTypeSelector") as CellEditor;
}
SetCremaTypeMembers(column, dataColumn.CremaType.Members);
}
CremaDataTableItemControl.SetIsKey(column, dataColumn.IsKey);
CremaDataTableItemControl.SetIsUnique(column, dataColumn.Unique);
CremaDataTableItemControl.SetFieldType(column, dataColumn.DataType);
CremaDataTableItemControl.SetTags(column, dataColumn.Tags);
CremaDataTableItemControl.SetComment(column, dataColumn.Comment);
CremaDataTableItemControl.SetReference(column, dataColumn);
column.TitleTemplate = this.FindResource("Title_Template") as DataTemplate;
if (dataColumn.DerivedTags.Color != null)
{
CremaDataTableItemControl.SetHasTagColor(column, true);
column.SetValue(TextElement.ForegroundProperty, new BrushConverter().ConvertFrom(dataColumn.DerivedTags.Color));
}
}
public void SetCremaType_Fail()
{
var type = new CremaDataType();
var column = new CremaDataColumn();
column.CremaType = type;
}
private static void WriteField(XmlWriter writer, CremaDataRow dataRow, CremaDataColumn dataColumn, bool ignoreDefaultValue)
{
var dataType = dataColumn.DataType;
var value = dataRow[dataColumn];
if (value == DBNull.Value)
{
return;
}
var converter = TypeDescriptor.GetConverter(dataColumn.DataType);
var textValue = CremaXmlConvert.ToString(value, dataType);
if (object.Equals(value, dataColumn.DefaultValue) == true)
{
writer.WriteStartElement(dataColumn.ColumnName);
writer.WriteEndElement();
}
else
{
writer.WriteStartElement(dataColumn.ColumnName);
writer.WriteValue(textValue);
writer.WriteEndElement();
}
}
private void WriteElement(XmlSchema schema, XmlSchemaSequence sequence, CremaDataColumn dataColumn)
{
var element = new XmlSchemaElement()
{
Name = dataColumn.ColumnName,
SchemaTypeName = this.GetXmlQualifiedName(schema, dataColumn)
};
var defaultValue = CremaXmlConvert.ToString(dataColumn.DefaultValue, dataColumn.DataType);
if (string.IsNullOrEmpty(defaultValue) == false)
{
element.DefaultValue = defaultValue;
}
if (dataColumn.AllowDBNull == true && dataColumn.IsKey == false)
{
element.MinOccursString = "0";
}
element.WriteAppInfo(CremaSchema.ColumnInfo, CremaSchema.Creator, dataColumn.CreationInfo.ID, schema.TargetNamespace);
element.WriteAppInfo(CremaSchema.ColumnInfo, CremaSchema.CreatedDateTime, dataColumn.CreationInfo.DateTime, schema.TargetNamespace);
element.WriteAppInfo(CremaSchema.ColumnInfo, CremaSchema.Modifier, dataColumn.ModificationInfo.ID, schema.TargetNamespace);
element.WriteAppInfo(CremaSchema.ColumnInfo, CremaSchema.ModifiedDateTime, dataColumn.ModificationInfo.DateTime, schema.TargetNamespace);
element.WriteAppInfo(CremaSchema.ColumnInfo, CremaSchema.AutoIncrement, dataColumn.AutoIncrement, schema.TargetNamespace);
element.WriteAppInfo(CremaSchema.ColumnInfo, CremaSchema.ID, dataColumn.ColumnID, schema.TargetNamespace);
element.WriteAppInfo(CremaSchema.ColumnInfo, CremaSchema.Tags, dataColumn.Tags, schema.TargetNamespace);
element.WriteAppInfo(CremaSchema.ColumnInfo, CremaSchema.ReadOnly, dataColumn.ReadOnly, schema.TargetNamespace);
element.WriteDescription(dataColumn.Comment);
sequence.Items.Add(element);
}
public void Remove_Fail()
{
var dataTable = new CremaDataTable();
var dataColumn = new CremaDataColumn();
dataTable.Columns.Remove(dataColumn);
}
public static void CompareColumn(CremaDataColumn column1, CremaDataColumn column2)
{
if (column1 == null && column2 == null)
{
return;
}
if (column1 == null || column2 == null)
{
Assert.Fail("컬럼이 같지 않습니다.");
}
Assert.AreEqual(column1.AllowDBNull, column2.AllowDBNull, "AllowDBNull");
Assert.AreEqual(column1.AutoIncrement, column2.AutoIncrement, "AutoIncrement");
Assert.AreEqual(column1.ColumnName, column2.ColumnName, "ColumnName");
Assert.AreEqual(column1.DataType, column2.DataType, "DataType");
CremaComparer.CompareType(column1.CremaType, column2.CremaType);
Assert.AreEqual(column1.DefaultValue, column2.DefaultValue, "DefaultValue");
Assert.AreEqual(column1.Expression, column2.Expression, "Expression");
Assert.AreEqual(column1.Validation, column2.Validation, "Validation");
Assert.AreEqual(column1.Unique, column2.Unique, "Unique");
Assert.AreEqual(column1.ReadOnly, column2.ReadOnly, "ReadOnly");
Assert.AreEqual(column1.Comment, column2.Comment, "Comment");
Assert.AreEqual(column1.IsKey, column2.IsKey, "IsKey");
Assert.AreEqual(column1.CreationInfo, column2.CreationInfo, "CreationInfo");
Assert.AreEqual(column1.ModificationInfo, column2.ModificationInfo, "ModificationInfo");
Assert.AreEqual(column1.ColumnID, column2.ColumnID, "ColumnID");
Assert.AreEqual(column1.Tags, column2.Tags, "Tags");
Assert.AreEqual(column1.ColumnInfo, column2.ColumnInfo, "ColumnInfo");
Assert.AreEqual(column1.Index, column2.Index, "Ordinal");
}
private void WriteDataColumn(XmlSchema schema, CremaDataColumn dataColumn)
{
if (dataColumn.Validation != string.Empty)
{
var simpleType = new XmlSchemaSimpleType()
{
Name = dataColumn.GetXmlSchemaTypeName(),
};
{
var simpleTypeRestriction = new XmlSchemaSimpleTypeRestriction()
{
BaseTypeName = GetSystemQualifiedName(dataColumn.DataType)
};
{
var facet = new XmlSchemaPatternFacet()
{
Value = dataColumn.Validation
};
simpleTypeRestriction.Facets.Add(facet);
}
simpleType.Content = simpleTypeRestriction;
}
schema.Items.Add(simpleType);
}
}
public void NewWithNullName()
{
var column = new CremaDataColumn(null);
Assert.AreNotEqual(Guid.Empty, column.ColumnID);
Assert.AreEqual(-1, column.Index);
Assert.AreEqual(string.Empty, column.ColumnName);
Assert.AreEqual(typeof(string), column.DataType);
Assert.AreEqual(string.Empty, column.Comment);
Assert.IsFalse(column.IsKey);
Assert.IsFalse(column.Unique);
Assert.IsFalse(column.ReadOnly);
Assert.AreEqual(null, column.Table);
Assert.AreEqual(TagInfo.All, column.Tags);
Assert.AreEqual(TagInfo.All, column.DerivedTags);
Assert.AreEqual(string.Empty, column.Validation);
Assert.AreEqual(string.Empty, column.Expression);
Assert.IsNull(column.CremaType);
Assert.IsTrue(column.AllowDBNull);
Assert.IsFalse(column.AutoIncrement);
Assert.AreEqual(DBNull.Value, column.DefaultValue);
Assert.AreEqual(column.CreationInfo, SignatureDate.Empty);
Assert.AreEqual(column.ModificationInfo, SignatureDate.Empty);
}
public void NewWithNameAndCremaType()
{
var dataSet = new CremaDataSet();
var columnName = RandomUtility.NextIdentifier();
var columnType = dataSet.AddRandomType();
var column = new CremaDataColumn(columnName, columnType);
Assert.AreNotEqual(Guid.Empty, column.ColumnID);
Assert.AreEqual(-1, column.Index);
Assert.AreEqual(columnName, column.ColumnName);
Assert.AreEqual(typeof(string), column.DataType);
Assert.AreEqual(string.Empty, column.Comment);
Assert.IsFalse(column.IsKey);
Assert.IsFalse(column.Unique);
Assert.IsFalse(column.ReadOnly);
Assert.AreEqual(null, column.Table);
Assert.AreEqual(TagInfo.All, column.Tags);
Assert.AreEqual(TagInfo.All, column.DerivedTags);
Assert.AreEqual(string.Empty, column.Validation);
Assert.AreEqual(string.Empty, column.Expression);
Assert.AreEqual(columnType, column.CremaType);
Assert.IsTrue(column.AllowDBNull);
Assert.IsFalse(column.AutoIncrement);
Assert.AreEqual(DBNull.Value, column.DefaultValue);
Assert.AreEqual(column.CreationInfo, SignatureDate.Empty);
Assert.AreEqual(column.ModificationInfo, SignatureDate.Empty);
Assert.AreEqual(0, columnType.ReferencedColumns.Length);
}
private void ReadValue(XmlReader reader, CremaDataRow dataRow, CremaDataColumn dataColumn)
{
if (reader.IsEmptyElement == false)
{
reader.ReadStartElement();
reader.MoveToContent();
if (reader.HasValue == true)
{
this.ReadValue(dataRow, dataColumn, reader.ReadContentAsString());
}
reader.MoveToContent();
reader.ReadEndElement();
}
else
{
if (dataColumn.AllowDBNull == true && object.Equals(dataColumn.DefaultValue, DBNull.Value) == false)
{
dataRow[dataColumn] = dataColumn.DefaultValue;
}
else if (object.Equals(dataColumn.DefaultValue, DBNull.Value) == true)
{
this.ReadValue(dataRow, dataColumn, string.Empty);
}
reader.Skip();
}
reader.MoveToContent();
}
private void ReadColumn(XmlSchemaElement element, CremaDataTable dataTable)
{
var dataColumn = new CremaDataColumn()
{
InternalColumnName = element.Name,
InternalComment = element.ReadDescription(),
};
this.ReadColumnDataType(element.ElementSchemaType as XmlSchemaSimpleType, dataColumn);
if (element.MinOccursString == null)
{
dataColumn.InternalAllowDBNull = false;
}
if (string.IsNullOrEmpty(element.DefaultValue) == false)
{
dataColumn.InternalDefaultValue = CremaXmlConvert.ToValue(element.DefaultValue, dataColumn.DataType);
}
if (this.version.Major == CremaSchema.MajorVersion)
{
this.ReadColumnInfo(element, dataColumn);
}
else
{
this.ReadColumnInfoVersion2(element, dataColumn);
}
dataTable.Columns.Add(dataColumn);
}
public CremaTemplateColumn_InTableTest()
{
var dataSet = CremaDataSetExtensions.CreateRandomSet();
this.template = new CremaTemplate(dataSet.Tables.Random(item => item.TemplateNamespace == string.Empty));
this.column = this.template.Columns.Random();
this.targetColumn = this.template.TargetTable.Columns[this.column.Name];
}
public void AddColumn()
{
var dataTable = new CremaDataTable();
var dataColumn = new CremaDataColumn();
dataTable.Columns.Add(dataColumn);
Assert.AreEqual(1, dataTable.Columns.Count);
}
public void Create()
{
foreach (var item in CremaDataTypeUtility.GetBaseTypes())
{
var column = new CremaDataColumn(RandomUtility.NextIdentifier(), item);
Assert.IsNotNull(column);
}
}
private void ReadColumnInfo(XmlSchemaAnnotated annotated, CremaDataColumn dataColumn)
{
dataColumn.InternalCreationInfo = annotated.ReadAppInfoAsSigunatureDate(CremaSchema.ColumnInfo, CremaSchema.Creator, CremaSchema.CreatedDateTime);
dataColumn.InternalModificationInfo = annotated.ReadAppInfoAsSigunatureDate(CremaSchema.ColumnInfo, CremaSchema.Modifier, CremaSchema.ModifiedDateTime);
dataColumn.InternalAutoIncrement = annotated.ReadAppInfoAsBoolean(CremaSchema.ColumnInfo, CremaSchema.AutoIncrement);
dataColumn.InternalColumnID = annotated.ReadAppInfoAsGuid(CremaSchema.ColumnInfo, CremaSchema.ID);
dataColumn.InternalTags = annotated.ReadAppInfoAsTagInfo(CremaSchema.ColumnInfo, CremaSchema.Tags);
dataColumn.InternalReadOnly = annotated.ReadAppInfoAsBoolean(CremaSchema.ColumnInfo, CremaSchema.ReadOnly);
}
public static void InitializeRandom(this CremaDataColumn dataColumn)
{
var dataTable = dataColumn.Table;
if (RandomUtility.Within(75) == true)
{
dataColumn.DataType = CremaDataTypeUtility.GetBaseTypes().Random();
}
else if (dataTable != null && dataTable.DataSet != null && dataTable.DataSet.Types.Any())
{
dataColumn.CremaType = dataTable.DataSet.Types.Random();
}
if (RandomUtility.Within(25) == true)
{
SetHopeType(dataColumn);
}
if (dataTable != null && dataTable.PrimaryKey.Any() == false)
{
dataColumn.IsKey = true;
}
else if (RandomUtility.Within(10) && dataColumn.DataType != typeof(bool))
{
dataColumn.IsKey = true;
dataColumn.Unique = RandomUtility.Within(75);
}
if (RandomUtility.Within(25) && dataColumn.DataType != typeof(bool))
{
var unique = RandomUtility.Within(75);
if (unique != false || dataTable == null || dataTable.PrimaryKey.Count() != 1)
{
dataColumn.Unique = unique;
}
}
if (RandomUtility.Within(25) == true)
{
dataColumn.Comment = RandomUtility.NextString();
}
if (RandomUtility.Within(25) == true)
{
dataColumn.DefaultValue = dataColumn.GetRandomValue();
}
if (CremaDataTypeUtility.CanUseAutoIncrement(dataColumn.DataType) == true && dataColumn.DefaultValue == DBNull.Value)
{
dataColumn.AutoIncrement = RandomUtility.NextBoolean();
}
if (RandomUtility.Within(5) == true)
{
dataColumn.ReadOnly = true;
}
}
private void ReadColumnDataType(XmlSchemaSimpleType simpleType, CremaDataColumn column)
{
var typeName = simpleType.QualifiedName.Name;
if (simpleType.QualifiedName.Namespace == XmlSchema.Namespace)
{
column.InternalDataType = CremaDataTypeUtility.GetType(typeName) ?? typeof(string);
}
else if (simpleType.QualifiedName.Name == typeof(Guid).GetTypeName() && simpleType.QualifiedName.Namespace == simpleType.GetSchema().TargetNamespace)
{
column.InternalDataType = typeof(Guid);
}
else
{
var categoryPath = PathUtility.Separator;
if (simpleType.QualifiedName.Namespace == CremaSchema.BaseNamespace)
{
if (this.version.Minor >= CremaSchema.MinorVersion)
{
categoryPath = simpleType.ReadAppInfoAsString(CremaSchema.TypeInfo, CremaSchema.CategoryPath, PathUtility.Separator);
}
else
{
var xmlRestriction = simpleType.Content as XmlSchemaSimpleTypeRestriction;
if (xmlRestriction == null)
{
if (simpleType.Content is XmlSchemaSimpleTypeList == true)
{
simpleType = (simpleType.Content as XmlSchemaSimpleTypeList).BaseItemType;
}
}
var categoryName = simpleType.ReadAppInfoAsString(CremaSchema.TypeInfo, CremaSchema.Category) ?? string.Empty;
categoryPath = categoryName == string.Empty ? PathUtility.Separator : categoryName.WrapSeparator();
}
}
else
{
if (this.version.Major >= CremaSchema.MajorVersion)
{
categoryPath = this.dataSet.GetTypeCategoryPath(simpleType.QualifiedName.Namespace);
}
else
{
categoryPath = PathUtility.Separator;
}
}
if (this.dataSet.Types.Contains(typeName, categoryPath) == false)
{
this.ReadType(simpleType);
}
column.InternalCremaType = (InternalDataType)this.dataSet.Types[typeName, categoryPath];
}
}
private static void Import(CremaDataColumn dataColumn, SerializationColumn serializedColumn)
{
dataColumn.ColumnName = serializedColumn.Name;
dataColumn.Tags = serializedColumn.Tags;
dataColumn.DataTypeName = serializedColumn.DataType;
dataColumn.Comment = serializedColumn.Comment;
dataColumn.AllowDBNull = serializedColumn.AllowNull;
dataColumn.AutoIncrement = serializedColumn.AutoIncrement;
dataColumn.ReadOnly = serializedColumn.ReadOnly;
}
public void CreateWithCremaType()
{
var dataSet = CremaDataSetExtensions.CreateRandomSet();
foreach (var item in dataSet.Types)
{
var column = new CremaDataColumn(RandomUtility.NextIdentifier(), item);
Assert.IsNotNull(column);
}
}
public void AddKeyColumn()
{
var dataTable = new CremaDataTable();
var dataColumn = new CremaDataColumn()
{
IsKey = true
};
dataTable.Columns.Add(dataColumn);
Assert.AreEqual(1, dataTable.Columns.Count);
Assert.AreEqual(1, dataTable.PrimaryKey.Length);
}
public static object GetHopeType(this CremaDataColumn dataColumn)
{
if (dataColumn.ExtendedProperties.ContainsKey(hopeTypeKey) == false)
{
if (dataColumn.CremaType != null)
{
return(dataColumn.CremaType);
}
return(dataColumn.DataType);
}
return(dataColumn.ExtendedProperties[hopeTypeKey]);
}
public void AddColumnMany()
{
var dataTable = new CremaDataTable();
var columnCount = RandomUtility.Next(1, 10);
for (var i = 0; i < columnCount; i++)
{
var dataColumn = new CremaDataColumn();
dataTable.Columns.Add(dataColumn);
}
Assert.AreEqual(columnCount, dataTable.Columns.Count);
}
private XmlQualifiedName GetXmlQualifiedName(XmlSchema schema, CremaDataColumn dataColumn)
{
if (dataColumn.CremaType != null)
{
var cremaType = dataColumn.CremaType;
foreach (var item in schema.Includes)
{
if (item is XmlSchemaImport == true)
{
var n = (item as XmlSchemaImport).Namespace;
if (cremaType.Namespace == n)
{
return(new XmlQualifiedName(cremaType.TypeName, cremaType.Namespace));
}
}
}
if (this.dataSet == null)
{
using (var sr = new StringReader(cremaType.GetXmlSchema()))
{
var typeSchema = XmlSchema.Read(sr, ValidationCallbackOne);
var schemaLocation = UriUtility.MakeRelative(dataColumn.Namespace, cremaType.Namespace) + CremaSchema.SchemaExtension;
schema.Includes.Add(new XmlSchemaImport()
{
Schema = typeSchema,
SchemaLocation = schemaLocation,
Namespace = cremaType.Namespace,
});
}
return(new XmlQualifiedName(cremaType.TypeName, cremaType.Namespace));
}
return(new XmlQualifiedName(cremaType.TypeName, schema.TargetNamespace));
}
else if (string.IsNullOrEmpty(dataColumn.Validation) == false)
{
return(new XmlQualifiedName(dataColumn.GetXmlSchemaTypeName(), schema.TargetNamespace));
}
else if (dataColumn.DataType == typeof(Guid))
{
return(new XmlQualifiedName(typeof(Guid).GetTypeName(), schema.TargetNamespace));
}
else
{
return(GetSystemQualifiedName(dataColumn.DataType));
}
}
public SerializationColumn(CremaDataColumn dataColumn)
: this()
{
this.Index = dataColumn.Index;
this.Tags = dataColumn.Tags;
this.DerivedTags = dataColumn.DerivedTags;
this.Name = dataColumn.ColumnName;
this.DataType = dataColumn.DataTypeName;
this.Comment = dataColumn.Comment;
this.IsKey = dataColumn.IsKey;
this.IsUnique = dataColumn.Unique;
this.AllowNull = dataColumn.AllowDBNull;
this.AutoIncrement = dataColumn.AutoIncrement;
this.ReadOnly = dataColumn.ReadOnly;
}
public static object GetRandomValue(CremaDataColumn dataColumn)
{
if (dataColumn.AllowDBNull == true && RandomUtility.Next(4) == 0)
{
return(DBNull.Value);
}
else if (dataColumn.CremaType != null)
{
return(GetRandomValue(dataColumn.CremaType));
}
else
{
return(RandomUtility.Next(dataColumn.DataType));
}
}
public static bool SetRandomValue(this CremaDataRow dataRow, CremaDataColumn dataColumn)
{
if (dataRow.RowState != System.Data.DataRowState.Detached && dataColumn.ReadOnly == true)
{
return(true);
}
var value = GetRandomValue(dataRow, dataColumn);
if (value == null)
{
return(false);
}
dataRow.SetField(dataColumn, value);
return(true);
}
public void AddKeyColumnMany()
{
var dataTable = new CremaDataTable();
var columnCount = RandomUtility.Next(1, 10);
for (var i = 0; i < columnCount; i++)
{
var dataColumn = new CremaDataColumn()
{
IsKey = true
};
dataTable.Columns.Add(dataColumn);
}
Assert.AreEqual(columnCount, dataTable.Columns.Count);
Assert.AreEqual(columnCount, dataTable.PrimaryKey.Length);
}
public static void CopyFrom(this CremaTemplateColumn templateColumn, CremaDataColumn dataColumn)
{
templateColumn.ColumnID = dataColumn.ColumnID;
templateColumn.Tags = dataColumn.Tags;
templateColumn.Name = dataColumn.ColumnName;
templateColumn.IsKey = dataColumn.IsKey;
templateColumn.DataTypeName = dataColumn.DataTypeName;
templateColumn.Comment = dataColumn.Comment;
templateColumn.Unique = dataColumn.Unique;
templateColumn.AutoIncrement = dataColumn.AutoIncrement;
templateColumn.ReadOnly = dataColumn.ReadOnly;
templateColumn.AllowNull = dataColumn.AllowDBNull;
templateColumn.DefaultValue = dataColumn.DefaultValueString;
templateColumn.CreationInfo = dataColumn.CreationInfo;
templateColumn.ModificationInfo = dataColumn.ModificationInfo;
}
internal static FindResultInfo FromDataRow(CremaDataRow dataRow, CremaDataColumn dataColumn, int index)
{
CremaDataTable table = dataRow.Table;
FindResultInfo fri = new FindResultInfo()
{
Path = table.CategoryPath + table.Name,
Row = index,
ColumnName = dataColumn.ColumnName,
Value = dataRow[dataColumn].ToString(),
Tags = dataRow.DerivedTags.ToString(),
IsEnabled = dataRow.IsEnabled,
ModificationInfo = dataRow.ModificationInfo,
};
return(fri);
}
/// <summary>
/// for version 2.0
/// </summary>
private void ReadColumnInfoVersion2(XmlSchemaAnnotated annotated, CremaDataColumn dataColumn)
{
dataColumn.InternalCreationInfo = annotated.ReadAppInfoAsSigunatureDate(CremaSchema.ColumnInfo, CremaSchemaObsolete.CreatorObsolete, CremaSchema.CreatedDateTime);
dataColumn.InternalModificationInfo = annotated.ReadAppInfoAsSigunatureDate(CremaSchema.ColumnInfo, CremaSchema.Modifier, CremaSchema.ModifiedDateTime);
dataColumn.InternalAutoIncrement = annotated.ReadAppInfoAsBoolean(CremaSchema.ColumnInfo, CremaSchema.AutoIncrement);
dataColumn.InternalColumnID = annotated.ReadAppInfoAsGuidVersion2(CremaSchema.ColumnInfo, CremaSchema.ID, dataColumn.ColumnName);
dataColumn.InternalTags = annotated.ReadAppInfoAsTagInfo(CremaSchema.ColumnInfo, CremaSchema.Tags);
var properties = new PropertyCollection();
this.ReadExtendedProperties(annotated, properties);
if (properties.ContainsKey(CremaSchemaObsolete.DataLocation) == true)
{
dataColumn.InternalTags = new TagInfo(properties[CremaSchemaObsolete.DataLocation] as string);
properties.Remove(CremaSchemaObsolete.DataLocation);
}
}
