public void CopyFrom(ColumnMetadata col)
{
if (col == null)
return;
if (!string.IsNullOrWhiteSpace(col.schema_name))
schema_name = col.schema_name;
if (!string.IsNullOrWhiteSpace(col.table_name))
table_name = col.table_name;
if (!string.IsNullOrWhiteSpace(col.column_name))
column_name = col.column_name;
if (col.column_ordinal != null)
column_ordinal = col.column_ordinal;
if (!string.IsNullOrWhiteSpace(col.data_type))
data_type = col.data_type;
if (col.is_nullable != null)
is_nullable = col.is_nullable;
if (!string.IsNullOrWhiteSpace(col.constraint_name))
constraint_name = col.constraint_name;
if (!string.IsNullOrWhiteSpace(col.unique_constraint_name))
unique_constraint_name = col.unique_constraint_name;
if (!string.IsNullOrWhiteSpace(col.unique_constraint_schema))
unique_constraint_schema = col.unique_constraint_schema;
if (col.is_auto_increment != null)
is_auto_increment = col.is_auto_increment;
if (col.string_length != null)
string_length = col.string_length;
if (!string.IsNullOrWhiteSpace(col.precision))
precision = col.precision;
}
public static bool TryParseJson(string jsonText, out ColumnMetadata columnOut)
{
columnOut = null;
if (string.IsNullOrWhiteSpace(jsonText))
return false;
try
{
var data = Encoding.UTF8.GetBytes(jsonText);
var jsonSerializer = new DataContractJsonSerializer(typeof(ColumnMetadata));
using (var ms = new MemoryStream(data))
{
columnOut = (ColumnMetadata)jsonSerializer.ReadObject(ms);
return true;
}
}
catch
{
columnOut = null;
return false;
}
}
public Ef35PropertyAttr(ColumnMetadata md, bool addUpdateCheckNever)
{
Name = Etc.ExtractLastWholeWord(md.column_name, Constants.DEFAULT_TYPE_SEPARATOR);
_composedName = Compose.PropertyName(md.column_name);
DbType = md.data_type.ToUpper();
if (Lexicon.Mssql2HbmTypes.ContainsKey(md.data_type) && Lexicon.Mssql2HbmTypes[md.data_type] == "AnsiString")
{
if (md.string_length != null && md.string_length < 0)
{
DbType = string.Format("{0}(MAX)", DbType);
}
else
{
DbType = string.Format("{0}({1})", DbType, md.string_length);
}
}
if (Globals.MssqlTypesWithPrecision.Contains(md.data_type))
{
DbType = string.Format("{0}({1})", DbType, md.precision);
}
if (md.is_nullable != null && md.is_nullable.Value == false)
{
DbType = string.Format("{0} NOT NULL", DbType);
CanBeNull = false;
}
else
{
CanBeNull = true;
}
if (md.is_auto_increment != null && md.is_auto_increment.Value)
{
DbType = string.Format("{0} IDENTITY", DbType);
IsPrimaryKey = true;
IsDbGenerated = true;
}
IsUpdateCheckNever = addUpdateCheckNever;
}
internal static ColumnMetadata GetFromAllColumnMetadata(ColumnMetadata cm)
{
if (cm == null || string.IsNullOrWhiteSpace(cm.table_name) || string.IsNullOrWhiteSpace(cm.column_name))
return null;
var acCol = DbContainers.AllColumns.Data.FirstOrDefault(
x => string.Equals(x.table_name, cm.table_name, StringComparison.OrdinalIgnoreCase) &&
string.Equals(x.column_name, cm.column_name, StringComparison.OrdinalIgnoreCase));
return acCol;
}
internal static void CopyFromDataSrc(this ColumnMetadata col, ColumnMetadata[] data)
{
var entry =
data.FirstOrDefault(
x =>
string.Equals(x.table_name, col.table_name, C) &&
string.Equals(x.column_name, col.column_name, C));
if (entry == null)
return;
col.CopyFrom(entry);
}
protected internal void AddToSimpleColumns(string key, ColumnMetadata val)
{
if (_simpleColumns.ContainsKey(key))
{
_simpleColumns[key] = val;
}
else
{
_simpleColumns.Add(key, val);
}
}
protected internal void GetCompositeKeyProperties()
{
if (!IsCompositeKey)
{
return;
}
var kmtoProps =
_hbmXml.SelectNodes(
CreateXpath(HbmXmlNames.HIBERNATE_MAPPING, HbmXmlNames.CLASS, HbmXmlNames.COMPOSITE_ID,
HbmXmlNames.KEY_MANY_TO_ONE), _nsMgr);
var keyProps = _hbmXml.SelectNodes(
CreateXpath(HbmXmlNames.HIBERNATE_MAPPING, HbmXmlNames.CLASS, HbmXmlNames.COMPOSITE_ID,
HbmXmlNames.KEY_PROPERTY), _nsMgr);
if (kmtoProps != null)
{
foreach (
var kmto in
kmtoProps.Cast <XmlElement>()
.Where(
t =>
t != null && t.HasAttributes && t.Attributes[HbmXmlNames.NAME] != null &&
t.Attributes[HbmXmlNames.CLASS] != null))
{
var kpName = kmto.Attributes[HbmXmlNames.NAME].Value;
var kpType = (new NfTypeName(kmto.Attributes[HbmXmlNames.CLASS].Value)).FullName;
//filter list used in GetAllTablesColumns
_keyManyToOnePropertyNames.Add(kpName);
AddToCompositeKeyProperties(kpName, kpType);
//add the comment data
if (!kmto.HasChildNodes)
{
continue;
}
var columnNode = kmto.FirstChild;
while (columnNode != null)
{
if (!columnNode.HasChildNodes)
{
columnNode = columnNode.NextSibling;
continue;
}
var pn =
Compose.PropertyName(
columnNode.Attributes[HbmXmlNames.NAME].Value.Replace("[", string.Empty)
.Replace("]", string.Empty));
var columnJson = columnNode.FirstChild.InnerText;
ColumnMetadata dataOut;
if (!ColumnMetadata.TryParseJson(columnJson, out dataOut))
{
columnNode = columnNode.NextSibling;
continue;
}
AddToKeyColumns(pn, dataOut);
columnNode = columnNode.NextSibling;
}
}
}
if (keyProps == null)
{
return;
}
foreach (
var kp in
keyProps.Cast <XmlElement>()
.Where(
t =>
t != null && t.HasAttributes && t.Attributes[HbmXmlNames.NAME] != null &&
t.Attributes[HbmXmlNames.TYPE] != null))
{
var kpName = kp.Attributes[HbmXmlNames.NAME].Value;
var kpType = Lexicon.Hbm2NetTypes[(kp.Attributes[HbmXmlNames.TYPE].Value)];
AddToCompositeKeyProperties(kpName, kpType);
if (!kp.HasChildNodes || !kp.FirstChild.HasChildNodes)
{
continue;
}
var columnNode = kp.FirstChild;
var columnJson = columnNode.FirstChild.InnerText;
ColumnMetadata dataOut;
if (ColumnMetadata.TryParseJson(columnJson, out dataOut))
{
AddToKeyColumns(kpName, dataOut);
}
}
}
internal static XElement GetSimplePropertyHbmXml(ColumnMetadata entry, string xElementName)
{
if (entry == null)
return null;
if (string.IsNullOrWhiteSpace(xElementName))
xElementName = Globals.HbmXmlNames.PROPERTY;
if (string.IsNullOrWhiteSpace(entry.data_type) &&
Sorting.DbContainers.AllColumns.Data.Any(
x => string.Equals(x.column_name, entry.constraint_name, Sorting.C)))
{
var acEntry =
Sorting.DbContainers.AllColumns.Data.First(
x => string.Equals(x.column_name, entry.constraint_name, Sorting.C));
entry.CopyFrom(acEntry);
}
else
{
entry.CopyFrom(Sorting.GetFromAllColumnMetadata(entry));
}
var simplePropName = Compose.PropertyName(entry.column_name);
var simplePropColumn = Util.Etc.ExtractLastWholeWord(entry.column_name, null);
var simplePropDataType = Globals.HbmXmlNames.ANSI_STRING;
if (!Util.Lexicon.DotNet2HbmTypes.ContainsKey(string.Format("{0}", entry.data_type)) &&
!Util.Lexicon.Mssql2HbmTypes.ContainsKey(string.Format("{0}", entry.data_type)))
{
Console.WriteLine("{0:yyyy-MM-dd HH:mm:ss.ffff} '{1}' has no matching type in the Lexicon [{2}].",
DateTime.Now,
entry.data_type, entry.ToJsonString());
}
else
{
simplePropDataType = entry.data_type.StartsWith("System.")
? Util.Lexicon.DotNet2HbmTypes[entry.data_type]
: Util.Lexicon.Mssql2HbmTypes[entry.data_type];
}
var simplePropLen = simplePropDataType == Globals.HbmXmlNames.ANSI_STRING
? entry.string_length == null || entry.string_length <= 0 ? Globals.MSSQL_MAX_VARCHAR : entry.string_length
: null;
if (simplePropDataType == typeof (Boolean).Name)
{
if (simplePropName.StartsWith(Util.NfTypeName.DefaultNamePrefix))
simplePropName = simplePropName.Remove(0, Util.NfTypeName.DefaultNamePrefix.Length);
simplePropName = "Is" + simplePropName;
}
return XeFactory.PropertyNode(xElementName, simplePropName, simplePropColumn,
simplePropDataType, simplePropLen.ToString(), entry.is_nullable.HasValue && entry.is_nullable == true,
entry.ToJsonString());
}
internal static void GetSimpleId(ColumnMetadata pkId, XElement classXe)
{
pkId.CopyFrom(Sorting.GetFromAllColumnMetadata(pkId));
var fullColumnName = pkId.column_name;
Compose.ValidSplit(fullColumnName, 3);
var columnName = Util.Etc.ExtractLastWholeWord(fullColumnName, null);
const string propertyName = Globals.HbmXmlNames.ID;
var type = Util.Lexicon.Mssql2HbmTypes[(pkId.data_type)];
var length = pkId.string_length ?? Globals.MSSQL_MAX_VARCHAR;
XElement idXe;
//don't let the '-1' from the database make it to the hbm.xml's
if (string.Equals(type, Globals.HbmXmlNames.ANSI_STRING))
{
if (length <= 0)
length = Globals.MSSQL_MAX_VARCHAR;
idXe = XeFactory.IdNode(propertyName, columnName, type,
length.ToString(CultureInfo.InvariantCulture),pkId.ToJsonString());
}
else
{
idXe = XeFactory.IdNode(propertyName, columnName, type, pkId.ToJsonString());
}
//simple split of assigned or is_identity
XElement generatorXe;
if (pkId.is_auto_increment.HasValue && pkId.is_auto_increment.Value)
{
generatorXe = XeFactory.GeneratorId(Globals.HbmXmlNames.IDENTITY);
}
else
{
generatorXe = XeFactory.GeneratorId(Globals.HbmXmlNames.ASSIGNED);
}
idXe.Add(generatorXe);
classXe.Add(idXe);
}
