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"); } }