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 = NfString.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(NfString.DefaultNamePrefix))
{
simplePropName = simplePropName.Remove(0, NfString.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 = NfString.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);
}
protected static void GetBags(string outputNamespace, string tbl, Dictionary <string, List <ColumnMetadata> > hbmBags, bool hasNoPkAtAll,
string className, XElement classXe)
{
//----hbm bags
var hbmBagNames = new List <string>(); //check for duplicates
if (Settings.DoNotReference.Contains(tbl) || !hbmBags.ContainsKey(tbl) || hasNoPkAtAll)
{
return;
}
var distinctBagConstraintNames = hbmBags[tbl].Select(x => x.constraint_name).Distinct().ToList();
foreach (var distinctBagConstraintName in distinctBagConstraintNames)
{
var hbmBagPropertyName = Compose.PropertyName(distinctBagConstraintName);
var hbmBagXe = XeFactory.BagNode(hbmBagPropertyName, Globals.HbmXmlNames.ALL_DELETE_ORPHAN,
bool.TrueString.ToLower(), bool.TrueString.ToLower(),
Globals.REPRESENT_512);
var bagColumns =
hbmBags[tbl].Where(x => string.Equals(x.constraint_name, distinctBagConstraintName, Sorting.C))
.Select(x => x.column_name)
.ToList();
string hbmOneToMany;
if (bagColumns.Count > 1)
{
var hbmBagFirstKey =
hbmBags[tbl].First(
x => string.Equals(x.constraint_name, distinctBagConstraintName, Sorting.C));
if (Settings.DoNotReference.Contains(hbmBagFirstKey.table_name))
{
continue;
}
hbmOneToMany = Compose.ClassName((hbmBagFirstKey.table_name), outputNamespace);
var hbmBagFkKeyXe = XeFactory.KeyNodeClassName(className);
foreach (
var columnData in
hbmBags[tbl].Where(
x => string.Equals(x.constraint_name, distinctBagConstraintName, Sorting.C)).ToList())
{
columnData.CopyFrom(Sorting.GetFromAllColumnMetadata(columnData));
var fullColumnName = columnData.column_name;
Compose.ValidSplit(fullColumnName, 3);
var hbmBagKeyColumn = NfString.ExtractLastWholeWord(fullColumnName, null);
var hbmBagKeyXe = XeFactory.ColumnNode(hbmBagKeyColumn, columnData.ToJsonString());
hbmBagFkKeyXe.Add(hbmBagKeyXe);
}
hbmBagXe.Add(hbmBagFkKeyXe);
}
else
{
var hbmBagFirstKey =
hbmBags[tbl].First(
x => string.Equals(x.constraint_name, distinctBagConstraintName, Sorting.C));
if (Settings.DoNotReference.Contains(hbmBagFirstKey.table_name))
{
continue;
}
hbmBagFirstKey.CopyFrom(Sorting.GetFromAllColumnMetadata(hbmBagFirstKey));
var fullColumnName = hbmBagFirstKey.column_name;
hbmOneToMany = Compose.ClassName((hbmBagFirstKey.table_name), outputNamespace);
Compose.ValidSplit(fullColumnName, 3);
var hbmBagKeyColumn = NfString.ExtractLastWholeWord(fullColumnName, null);
var hbmBagKeyXe = XeFactory.KeyNodeColumnName(hbmBagKeyColumn, hbmBagFirstKey.ToJsonString());
hbmBagXe.Add(hbmBagKeyXe);
}
var hbmOneToManyXe = XeFactory.OneToManyNode(hbmOneToMany);
hbmBagXe.Add(hbmOneToManyXe);
//attempt to make the name plural
var newBagName = Compose.BagPropertyName(hbmOneToMany);
hbmBagXe.FirstAttribute.SetValue(newBagName);
classXe.Add(hbmBagXe);
hbmBagNames.Add(hbmBagPropertyName);
}
}
protected static void GetFksWhichAreNotPartOfPks(string outputNamespace, string tbl, Dictionary <string, FkItem> hbmFk, XElement classXe)
{
//----fks which are not part of pks
if (!hbmFk.ContainsKey(tbl))
{
return;
}
var tblFks = hbmFk[tbl].ManyToOne;
foreach (var fkName in tblFks.Keys)
{
//these would be FK ref to another type but its underlying table is excluded so now its just a bunch of value types
if (Settings.DoNotReference.Contains(fkName))
{
foreach (var reducedFk in tblFks[fkName])
{
var reducedFkSimpProp = GetSimplePropertyHbmXml(reducedFk,
Globals.HbmXmlNames.PROPERTY);
classXe.Add(reducedFkSimpProp);
}
continue; //these need representation but not as class types
}
var manytoOneColumns = new List <ColumnMetadata>();
if (!HbmOneToMany.GetManyToOneColumns(tbl, ref manytoOneColumns))
{
continue;
}
var fkColumnsByDistinctConstraintName = manytoOneColumns.Select(x => x.constraint_name).Distinct().ToList();
foreach (var distinctConstraintName in fkColumnsByDistinctConstraintName)
{
var dMtoColumnData = tblFks[fkName].Where(
x =>
string.Equals(x.constraint_name, distinctConstraintName, Sorting.C)).ToList();
if (dMtoColumnData.Count <= 0)
{
continue;
}
var fkColumnXes = new List <XElement>();
var fkColumnNames = new List <string>();
foreach (var x in dMtoColumnData)
{
x.CopyFrom(Sorting.GetFromAllColumnMetadata(x));
var fullColumnName = x.column_name;
Compose.ValidSplit(fullColumnName, 3);
var cn = NfString.ExtractLastWholeWord(fullColumnName, null);
//need to store these temp, since we are also drafting thier parent's name
fkColumnXes.Add(XeFactory.ColumnNode(cn, x.ToJsonString()));
fkColumnNames.Add(cn);
}
var fkPropertyType = new NfTypeName(Compose.ClassName(fkName, outputNamespace));
var fkPropertyName = Compose.ManyToOnePropertyName(Compose.ClassName(fkName, outputNamespace),
fkColumnNames.ToArray());
var manyToOneXe = XeFactory.ManyToOneNode(fkPropertyName, fkPropertyType.AssemblyQualifiedName);
foreach (var fkXe in fkColumnXes)
{
manyToOneXe.Add(fkXe);
}
classXe.Add(manyToOneXe);
}
}
}
protected static bool GetPk(string outputNamespace, string tbl, Dictionary <string, PkItem> hbmPk, XElement classXe)
{
//----PK
var pkId = hbmPk.ContainsKey(tbl) ? hbmPk[tbl].Id : null;
var hasNoPkAtAll = !hbmPk.ContainsKey(tbl);
if (pkId == null && !hasNoPkAtAll)
{
var compClassName = Compose.CompKeyClassName(tbl, outputNamespace);
const string compPropertyName = Globals.HbmXmlNames.ID;
var compKeyXe = XeFactory.CompositeIdNode(compPropertyName, compClassName);
//key-many-to-one
var hbmKeyManyToOne = hbmPk[tbl].KeyManyToOne ?? new Dictionary <string, List <ColumnMetadata> >();
if (hbmKeyManyToOne.Count > 0)
{
foreach (var keyname in hbmKeyManyToOne.Keys.Where(k => !Settings.DoNotReference.Contains(k)))
{
//need to iterate here on a per 'constraint_name', the json data-struct misses this
//eg a table, 4 columns; 2 are comp to another table's Pk and the other 2 are also a comp the SAME table's PK
var keyManytoOneColumns = new List <ColumnMetadata>();
if (!HbmKeys.GetKeyManyToOneColumns(tbl, ref keyManytoOneColumns))
{
continue;
}
foreach (var distinctColumn in keyManytoOneColumns.Distinct(new ConstraintNameComparer()))
{
var dKmtoCName = distinctColumn.constraint_name;
var keyMtoFullyQualTypeName = Compose.ClassName(keyname, outputNamespace);
var keyMtoNfTypeNameObj = new NfTypeName(keyMtoFullyQualTypeName);
var keyMtoSimpleName = keyMtoNfTypeNameObj.ClassName;
var keyMtoXe = XeFactory.KeyManyToOneNode(keyMtoSimpleName,
keyMtoFullyQualTypeName);
var dKmtoColumnData = hbmKeyManyToOne[keyname].Where(
x =>
string.Equals(x.constraint_name, dKmtoCName, Sorting.C)).ToList();
if (dKmtoColumnData.Count <= 0)
{
continue;
}
foreach (var kmtoColumn in dKmtoColumnData)
{
kmtoColumn.CopyFrom(Sorting.GetFromAllColumnMetadata(kmtoColumn));
var fullColumnName = kmtoColumn.column_name;
//not having the naming pattern is exceptional
Compose.ValidSplit(fullColumnName, 3);
var keyMtoColumnXe =
XeFactory.ColumnNode(NfString.ExtractLastWholeWord(fullColumnName, null),
kmtoColumn.ToJsonString());
keyMtoXe.Add(keyMtoColumnXe);
}
compKeyXe.Add(keyMtoXe);
} //end foreach distinct constraintname
}
} //end key-many-to-one
var hbmKeyProperty = hbmPk[tbl].KeyProperty ?? new Dictionary <string, List <ColumnMetadata> >();
//these would have been added as key-many-to-one, but thier underlying table has been excluded.
foreach (var reduced in hbmKeyManyToOne.Where(k => Settings.DoNotReference.Contains(k.Key)))
{
foreach (var redux in reduced.Value)
{
redux.CopyFrom(Sorting.GetFromAllColumnMetadata(redux));
}
//insure they got everything for being a value type
hbmKeyProperty.Add(reduced.Key, reduced.Value);
}
if (hbmKeyProperty.Count > 0)
{
//Dictionary<string, List<ColumnMetadata>>
foreach (var keyName in hbmKeyProperty.Keys)
{
//SPECIAL NOTE: the original PS code seemed to imply that a key-property is always just one column...
var keyPropJsonData = hbmKeyProperty[keyName].FirstOrDefault();
if (keyPropJsonData == null)
{
continue;
}
keyPropJsonData.CopyFrom(Sorting.GetFromAllColumnMetadata(keyPropJsonData));
var keyPropPropertyName = Compose.PropertyName(keyPropJsonData.column_name);
var fullcolumnName = keyPropJsonData.column_name;
Compose.ValidSplit(fullcolumnName, 3);
var keyPropDataType = Util.Lexicon.Mssql2HbmTypes[(keyPropJsonData.data_type)];
var keyPropColumn = NfString.ExtractLastWholeWord(fullcolumnName, null);
var keyPropLen = keyPropJsonData.string_length ?? Globals.MSSQL_MAX_VARCHAR;
if (string.Equals(keyPropDataType, Globals.HbmXmlNames.ANSI_STRING))
{
if (keyPropLen <= 0)
{
keyPropLen = Globals.MSSQL_MAX_VARCHAR;
}
var keyPropXe = XeFactory.KeyPropertyNode(keyPropPropertyName, keyPropColumn,
keyPropDataType, keyPropLen.ToString(CultureInfo.InvariantCulture),
keyPropJsonData.ToJsonString());
compKeyXe.Add(keyPropXe);
}
else
{
var keyPropXe = XeFactory.KeyPropertyNode(keyPropPropertyName, keyPropColumn,
keyPropDataType, keyPropJsonData.ToJsonString());
compKeyXe.Add(keyPropXe);
}
}
}
classXe.Add(compKeyXe);
}
else if (pkId != null)
{
GetSimpleId(pkId, classXe);
} //end PK
return(hasNoPkAtAll);
}
