void Read_StatementParams(XmlReader reader, StatementMap statement)
{
string name = string.Empty;
DbType?dbType = null;
while (reader.MoveToNextAttribute())
{
string currentAttribute = reader.Name;
switch (currentAttribute)
{
case "name":
name = reader.Value;
break;
case "dbType":
var dbTypeVal = reader.Value;
if (!string.IsNullOrWhiteSpace(dbTypeVal))
{
dbType = ReadEnumType <DbType>(dbTypeVal);
}
break;
default:
break;
}
}
if (string.IsNullOrWhiteSpace(name))
{
throw new MappingSerializationException(typeof(StatementMap), string.Format("statement {0} - all parameters must have name and value attributes. {1} {2}", statement.Name, name, dbType));
}
statement.DbParametersMap.Add(name, dbType);
reader.MoveToElement();
}
void Read_StatementInputParam(XmlReader reader, StatementMap statement)
{
string name = string.Empty;
string type = string.Empty;
while (reader.MoveToNextAttribute())
{
string currentAttribute = reader.Name;
switch (currentAttribute)
{
case "name":
name = reader.Value;
break;
case "type":
type = reader.Value;
break;
default:
break;
}
}
if (string.IsNullOrWhiteSpace(name) || string.IsNullOrWhiteSpace(type))
{
throw new MappingSerializationException(typeof(StatementMap), string.Format("statement {0} - all parameters must have name and type attributes. {1} {2}", statement.Name, name, type));
}
statement.InputParametersMap.Add(name, type);
reader.MoveToElement();
}
//void InitializeRelObject(ref Relation rel, Property prop)
//{
// if (rel == null)
// rel = new Relation(prop);
//}
#region <statement>
StatementMap Read_StatementElement(XmlReader reader, MapConfig config, string elementName)
{
if (reader.CanReadElement(elementName))
{
StatementMap statement = new StatementMap();
while (reader.MoveToNextAttribute())
{
string currentAttribute = reader.Name;
switch (currentAttribute)
{
case "name":
statement.Name = reader.Value;
break;
case "dbName":
statement.DbName = reader.Value;
break;
case "canRunOn":
statement.CanRunOn = reader.Value;
break;
case "resultMap":
statement.ResultMap = reader.Value;
break;
case "resultIsCollection":
statement.ResultIsCollection = ReadBool(reader.Value);
break;
case "inputParamType":
statement.InputParametersMap.Add("a", reader.Value);
break;
case "parse":
statement.IsParsingRequired = ReadBool(reader.Value);
break;
case "operationType":
statement.OperationType = ReadEnumType <MappedStatementType>(reader.Value);
break;
default:
break;
}
}
if ((statement.OperationType == MappedStatementType.Undefined) && !elementName.ToUpper().Equals("STATEMENT"))
{
statement.OperationType = ReadEnumType <MappedStatementType>(elementName);
}
return(statement);
}
else
{
return(null);
}
}
public virtual void Process(IDictionary <string, EntityMap> entityList, StatementStore mappedStatementStore, IDictionary <string, string> entityRenames)
{
foreach (var ent in entityList.Values)
{
try
{
//find link tables
if (settings.SupportManyToMany && ent.IsLinkTable)
{
var aRel = ent.PrimaryKey.Keys[0].Key as Relation;
var bRel = ent.PrimaryKey.Keys[1].Key as Relation;
if ((aRel == null) || (bRel == null))
{
continue;
}
if (entityList.TryGetValue(NamePostProcessor.GetTableKeyName(aRel), out EntityMap aEnt))
{
if (entityList.TryGetValue(NamePostProcessor.GetTableKeyName(bRel), out EntityMap bEnt))
{
var aRepPropName = bEnt.Name.Pluralize();
if (aEnt.Relations.Contains(aRepPropName))
{
aRepPropName = $"{bEnt.Name.Pluralize()}On{ent.Name}_{aRel.ColumnName.Pascalize()}";
}
var keyName = $"{aEnt.Name}.{aRepPropName}";
if (entityRenames.ContainsKey(keyName))
{
aRepPropName = entityRenames[keyName];
}
keyName = $"{aEnt.Name}.{bEnt.Name.Pluralize()}On{ent.Name}_{aRel.ColumnName.Pascalize()}";
if (entityRenames.ContainsKey(keyName))
{
aRepPropName = entityRenames[keyName];
}
var aRelationProp = new Relation()
{
IsComplexType = true,
LazyLoad = true,
ColumnName = aRel.ReferenceColumn ?? string.Empty,
ReferenceColumn = bRel.ReferenceColumn ?? string.Empty,
ReferenceProperty = bRel.ReferenceProperty ?? string.Empty,
CollectionType = CollectionType.List,
MapTableName = ent.TableName,
MapColumn = aRel.ColumnName ?? string.Empty,
MapPropertyName = aRel.ReferenceColumn ?? string.Empty,
MapReferenceColumn = bRel.ColumnName ?? string.Empty,
PropertyName = aRepPropName,
ReferenceEntityName = bEnt.FullName,
ReferenceTable = bEnt.TableName,
RelationType = RelationshipType.ManyToMany,
Inverse = true,
};
aEnt.Relations.Add(aRelationProp);
string aColCamel = aRel.ColumnName.Camelize();
string bColCamel = bRel.ColumnName.Camelize();
logger.Log(LogLevel.Debug, $"Processing map table {ent.TableName} statements -> {aColCamel}, {bColCamel}");
//build mapped statement for ease of adding and removing association
var aInsertStatement = new StatementMap
{
Name = $"{aEnt.FullName}_{aColCamel}_associate_{aEnt.Name}_with_{bEnt.Name}",
OperationType = MappedStatementType.Insert,
Body = $"INSERT INTO {ent.TableName} ({aRel.ColumnName}, {bRel.ColumnName}) VALUES({StatementMap.BuildPropTag(aColCamel, aRel.ReferenceProperty)}, {StatementMap.BuildPropTag(bColCamel, bRel.ReferenceProperty)});",
DependsOnEntity = aEnt.FullName
};
aInsertStatement.InputParametersMap.Add(aColCamel, aEnt.FullName);
aInsertStatement.InputParametersMap.Add(bColCamel, bEnt.FullName);
var aDeleteStatement = new StatementMap
{
Name = $"{aEnt.FullName}_{aColCamel}_disassociate_{aEnt.Name}_with_{bEnt.Name}",
OperationType = MappedStatementType.Delete,
Body = string.Format("DELETE FROM {0} WHERE {1} = {3} AND {2} = {4};", ent.TableName, aRel.ColumnName, bRel.ColumnName, StatementMap.BuildPropTag(aColCamel, aRel.ReferenceProperty), StatementMap.BuildPropTag(bColCamel, bRel.ReferenceProperty)),
DependsOnEntity = aEnt.FullName
};
aDeleteStatement.InputParametersMap.Add(aColCamel, aEnt.FullName);
aDeleteStatement.InputParametersMap.Add(bColCamel, bEnt.FullName);
mappedStatementStore.Add(aInsertStatement);
mappedStatementStore.Add(aDeleteStatement);
var bRepPropName = aEnt.Name.Pluralize();
if (bEnt.Relations.Contains(aRepPropName))
{
bRepPropName = $"{aEnt.Name.Pluralize()}On{ent.Name}_{bRel.ColumnName.Pascalize()}";
}
keyName = $"{bEnt.Name}.{bRepPropName}";
if (entityRenames.ContainsKey(keyName))
{
bRepPropName = entityRenames[keyName];
}
keyName = $"{bEnt.Name}.{aEnt.Name.Pluralize()}On{ent.Name}_{bRel.ColumnName.Pascalize()}";
if (entityRenames.ContainsKey(keyName))
{
bRepPropName = entityRenames[keyName];
}
bEnt.Relations.Add(new Relation()
{
IsComplexType = true,
ColumnName = bRel.ReferenceColumn ?? string.Empty,
ReferenceColumn = aRel.ReferenceColumn ?? string.Empty,
ReferenceProperty = aRel.ReferenceProperty ?? string.Empty,
MapTableName = ent.TableName,
MapColumn = bRel.ColumnName ?? string.Empty,
MapPropertyName = bRel.ReferenceColumn ?? string.Empty,
MapReferenceColumn = aRel.ColumnName ?? string.Empty,
CollectionType = CollectionType.List,
LazyLoad = true,
PropertyName = bRepPropName,
ReferenceEntityName = aEnt.FullName,
ReferenceTable = aEnt.TableName,
ManyToManyPropertyName = aRelationProp.PropertyName,
RelationType = RelationshipType.ManyToMany,
});
aRelationProp.ManyToManyPropertyName = bRepPropName;
var bInsertStatement = new StatementMap
{
Name = $"{bEnt.FullName}_{bColCamel}_associate_{bEnt.Name}_with_{aEnt.Name}",
OperationType = MappedStatementType.Insert,
Body =
$"INSERT INTO {ent.TableName} ({aRel.ColumnName}, {bRel.ColumnName}) VALUES({StatementMap.BuildPropTag(aColCamel, aRel.ReferenceProperty)}, {StatementMap.BuildPropTag(bColCamel, bRel.ReferenceProperty)});",
DependsOnEntity = bEnt.FullName
};
bInsertStatement.InputParametersMap.Add(aColCamel, aEnt.FullName);
bInsertStatement.InputParametersMap.Add(bColCamel, bEnt.FullName);
var bDeleteStatement = new StatementMap
{
Name = $"{bEnt.FullName}_{bColCamel}_dissaciate_{bEnt.Name}_with_{aEnt.Name}",
OperationType = MappedStatementType.Delete,
Body = string.Format("DELETE FROM {0} WHERE {1} = {3} AND {2} = {4};", ent.TableName, aRel.ColumnName, bRel.ColumnName, StatementMap.BuildPropTag(aColCamel, aRel.ReferenceProperty), StatementMap.BuildPropTag(bColCamel, bRel.ReferenceProperty)),
DependsOnEntity = bEnt.FullName
};
bDeleteStatement.InputParametersMap.Add(aColCamel, aEnt.FullName);
bDeleteStatement.InputParametersMap.Add(bColCamel, bEnt.FullName);
mappedStatementStore.Add(bInsertStatement);
mappedStatementStore.Add(bDeleteStatement);
}
}
}
else
{
if ((ent.PrimaryKey != null) && (ent.PrimaryKey.Keys.Count == 1) && settings.SupportTableInheritance)
{
var key = ent.PrimaryKey.Keys[0];
if ((key != null) && (key.Key is Relation))
{
var pk = (Relation)key.Key;
ent.Extends = pk.ReferenceEntityName;
logger.Log(LogLevel.Debug, $"Processing {ent.Name} extends -> {ent.Extends}.");
}
}
else if (!settings.SupportManyToMany && (ent.PrimaryKey != null) && (ent.PrimaryKey.Keys.Count > 1))
{
for (var i = 0; i < ent.PrimaryKey.Keys.Count; i++)
{
var k = ent.PrimaryKey.Keys[i].Key as Relation;
if (k != null && k.RelationType == RelationshipType.ManyToOne)
{
if (entityList.TryGetValue(NamePostProcessor.GetTableKeyName(k), out EntityMap other))
{
logger.Log(LogLevel.Debug, $"Processing One-To-Many ent:{ent.Name} other:{other.Name}.");
var aRepPropName = ent.Name.Pluralize();
if (other.Relations.Contains(aRepPropName))
{
aRepPropName = $"{ent.Name.Pluralize()}On{k.ColumnName.Pascalize()}";
}
var keyName = $"{other.Name}.{aRepPropName}";
if (entityRenames.ContainsKey(keyName))
{
aRepPropName = entityRenames[keyName];
}
other.Relations.Add(new Relation()
{
IsComplexType = true,
LazyLoad = true,
ColumnName = k.ReferenceColumn,
ReferenceColumn = k.ColumnName,
ReferenceProperty = k.PropertyName,
PropertyName = aRepPropName,
ReferenceTable = ent.TableName,
RelationType = RelationshipType.OneToMany,
ReferenceEntityName = ent.FullName,
CollectionType = CollectionType.List,
});
}
}
}
}
for (int i = 0; i < ent.Relations.Count; i++)
{
var reference = ent.Relations[i];
if (reference.RelationType != RelationshipType.ManyToOne)
{
continue;
}
if (entityList.TryGetValue(NamePostProcessor.GetTableKeyName(reference), out EntityMap other))
{
logger.Log(LogLevel.Debug, $"Processing One-To-Many ent:{ent.Name} other:{other.Name}.");
var aRepPropName = ent.Name.Pluralize();
var aNameByRelationPropName = $"{ent.Name.Pluralize()}On{reference.PropertyName.Pascalize()}";
if (other.Relations.Contains(aRepPropName))
{
aRepPropName = aNameByRelationPropName;
}
var keyName = $"{other.Name}.{aRepPropName}";
if (entityRenames.ContainsKey(keyName))
{
aRepPropName = entityRenames[keyName];
}
keyName = $"{other.Name}.{aNameByRelationPropName}";
if (!aRepPropName.Equals(aNameByRelationPropName) && entityRenames.ContainsKey(keyName))
{
aRepPropName = entityRenames[keyName];
}
other.Relations.Add(new Relation()
{
IsComplexType = true,
LazyLoad = true,
ColumnName = reference.ReferenceColumn,
ReferenceColumn = reference.ColumnName,
ReferenceProperty = reference.PropertyName,
PropertyName = aRepPropName,
ReferenceTable = ent.TableName,
RelationType = RelationshipType.OneToMany,
ReferenceEntityName = ent.FullName,
CollectionType = CollectionType.List,
});
}
}
}
}
catch (Exception ex)
{
logger.Error("Processing exception", ex);
}
}
}
void WriteTransformations(XmlTextWriter xmlWriter, EntityMap entity, StatementMap statement)
{
string elementName;
bool writeOperation = false;
switch (statement.OperationType)
{
case MappedStatementType.Insert:
elementName = "insert";
break;
case MappedStatementType.Delete:
elementName = "delete";
break;
case MappedStatementType.Query:
elementName = "query";
break;
case MappedStatementType.Update:
elementName = "update";
break;
default:
elementName = "statement";
writeOperation = true;
break;
}
string statName;
string resultMap = statement.ResultMap;
if (entity != null)
{
statName = statement.Name.Replace(entity.FullName + "_", string.Empty);
}
else
{
statName = statement.Name;
//resultMap = statement.ResultMap;
}
xmlWriter.WriteStartElement(elementName);
if (!string.IsNullOrWhiteSpace(statement.Name))
{
xmlWriter.WriteStartAttribute("name");
xmlWriter.WriteString(statName);
xmlWriter.WriteEndAttribute();
}
if (!string.IsNullOrWhiteSpace(resultMap))
{
xmlWriter.WriteStartAttribute("resultMap");
xmlWriter.WriteString(resultMap);
xmlWriter.WriteEndAttribute();
}
if (!string.IsNullOrWhiteSpace(statement.DbName))
{
xmlWriter.WriteStartAttribute("dbName");
xmlWriter.WriteString(statement.DbName);
xmlWriter.WriteEndAttribute();
}
if (writeOperation)
{
xmlWriter.WriteStartAttribute("operationType");
xmlWriter.WriteString(statement.OperationType.ToString());
xmlWriter.WriteEndAttribute();
}
bool writeBodyElement = false;
if (statement.DbParametersMap.Count > 0)
{
writeBodyElement = true;
xmlWriter.WriteStartElement("dbParameters");
foreach (var dbParam in statement.DbParametersMap)
{
xmlWriter.WriteStartElement("param");
xmlWriter.WriteStartAttribute("name");
xmlWriter.WriteString(dbParam.Key);
xmlWriter.WriteEndAttribute();
if (dbParam.Value.HasValue)
{
xmlWriter.WriteStartAttribute("dbType");
xmlWriter.WriteString(dbParam.Value.Value.ToString());
xmlWriter.WriteEndAttribute();
}
xmlWriter.WriteEndElement();
}
xmlWriter.WriteEndElement();
}
if (statement.InputParametersMap.Count > 0)
{
writeBodyElement = true;
xmlWriter.WriteStartElement("inputParameters");
foreach (var input in statement.InputParametersMap)
{
xmlWriter.WriteStartElement("input");
xmlWriter.WriteStartAttribute("name");
xmlWriter.WriteString(input.Key);
xmlWriter.WriteEndAttribute();
xmlWriter.WriteStartAttribute("type");
xmlWriter.WriteString(input.Value);
xmlWriter.WriteEndAttribute();
xmlWriter.WriteEndElement();
}
xmlWriter.WriteEndElement();
}
if (!string.IsNullOrWhiteSpace(statement.Body))
{
if (writeBodyElement)
{
xmlWriter.WriteStartElement("body");
}
xmlWriter.WriteCData(statement.Body);
if (writeBodyElement)
{
xmlWriter.WriteEndElement();
}
}
xmlWriter.WriteEndElement();
}
void Read_StatementsElement(XmlReader reader, MapConfig config, EntityMap entMap)
{
bool hasReachedEndGracefully = false;
bool dependsOnEntity = entMap != null;
while (reader.Read())
{
StatementMap statement = null;
string elementName = reader.Name;
if (reader.CanReadElement("query") || reader.CanReadElement("insert") || reader.CanReadElement("statement") || reader.CanReadElement("update") || reader.CanReadElement("delete"))
{
statement = Read_StatementElement(reader, config, elementName);
if (string.IsNullOrEmpty(statement.Name))
{
if (dependsOnEntity)
{
statement.Name = StatementStore.BuildMappedStatementName(entMap, statement.OperationType);
switch (statement.OperationType)
{
case MappedStatementType.Insert:
entMap.UseMappedInsert = true;
break;
case MappedStatementType.Delete:
entMap.UseMappedDelete = true;
break;
case MappedStatementType.Update:
entMap.UseMappedUpdate = true;
break;
}
}
else
{
throw new MappingSerializationException(typeof(StatementMap), "A statement in goliath.data/statements does not have name defined. A name cannot be infered.");
}
}
if (dependsOnEntity)
{
statement.DependsOnEntity = entMap.FullName;
if (string.IsNullOrEmpty(statement.ResultMap))
{
switch (statement.OperationType)
{
case MappedStatementType.Update:
case MappedStatementType.ExecuteNonQuery:
case MappedStatementType.Insert:
case MappedStatementType.Delete:
statement.ResultMap = typeof(Int32).ToString();
break;
case MappedStatementType.Query:
statement.ResultMap = entMap.FullName;
break;
case MappedStatementType.Undefined:
break;
default:
break;
}
}
if ((statement.InputParametersMap.Count == 0) && ((statement.OperationType == MappedStatementType.Insert) || (statement.OperationType == MappedStatementType.Update)))
{
//statement.InputParametersMap.Add("a", entMap.FullName);
}
}
if (string.IsNullOrWhiteSpace(statement.CanRunOn))
{
//if can run on is empty we expect the platform to be on the main file.
if (string.IsNullOrWhiteSpace(config.Settings.Platform))
{
throw new MappingSerializationException(typeof(StatementMap), string.Format("Statement {0} missing canRunOn. Please specify which platform to run or specify one config rdbms.", statement.Name));
}
statement.CanRunOn = config.Settings.Platform;
}
reader.MoveToElement();
if (!reader.IsEmptyElement)
{
while (reader.Read())
{
if (reader.HasReachedEndOfElement(elementName))
{
break;
}
if ((reader.NodeType == XmlNodeType.Text) || (reader.NodeType == XmlNodeType.CDATA))
{
statement.Body = reader.Value;
}
else if (reader.CanReadElement("dbParameters"))
{
while (reader.Read())
{
if (reader.HasReachedEndOfElement("dbParameters"))
{
break;
}
if (reader.CanReadElement("param"))
{
Read_StatementParams(reader, statement);
}
}
}
else if (reader.CanReadElement("inputParameters"))
{
while (reader.Read())
{
if (reader.HasReachedEndOfElement("inputParameters"))
{
break;
}
if (reader.CanReadElement("input"))
{
Read_StatementInputParam(reader, statement);
}
}
}
else if (reader.CanReadElement("body"))
{
while (reader.Read())
{
if (reader.HasReachedEndOfElement("body"))
{
break;
}
if ((reader.NodeType == XmlNodeType.Text) || (reader.NodeType == XmlNodeType.CDATA))
{
statement.Body = reader.Value;
}
}
}
}
}
if (statement.OperationType == MappedStatementType.Undefined)
{
throw new MappingSerializationException(typeof(StatementMap), string.Format("Statement {0} must have have an operationType", statement.Name));
}
config.UnprocessedStatements.Add(statement);
}
else if (reader.HasReachedEndOfElement("statements"))
{
hasReachedEndGracefully = true;
break;
}
}
if (!hasReachedEndGracefully)
{
throw new MappingSerializationException(typeof(StatementMap), "missing a </statements> end tag");
}
}
