Inheritance: IMappingResolver
Ejemplo n.º 1
0
        private static void AppendCreateTableScript(StringBuilder sb, Type type)
        {
            var mappingResolver = new MappingResolverStub();
            var generator       = new UniqueIdentifierGenerator();
            var tableInfo       = (ResolvedSimpleTableInfo)mappingResolver.ResolveTableInfo(new UnresolvedTableInfo(type), generator);
            var entity          = mappingResolver.ResolveSimpleTableInfo(tableInfo, generator);

            var columnDeclarations = from c in entity.Columns
                                     let sqlTypeName = GetColumnType(c)
                                                       select string.Format("[{0}] {1}", c.ColumnName, sqlTypeName);

            var    primaryKeyColumns    = entity.Columns.Where(c => c.IsPrimaryKey).Select(c => c.ColumnName).ToArray();
            string primaryKeyConstraint = "";

            if (primaryKeyColumns.Length > 0)
            {
                primaryKeyConstraint = string.Format(
                    " CONSTRAINT PK_{0} PRIMARY KEY ({1})", tableInfo.TableName.Replace(".", "_"), string.Join(",", primaryKeyColumns));
            }

            sb.AppendFormat(
                "CREATE TABLE [{0}]{1}({1}{2}{1} {3})",
                tableInfo.TableName,
                Environment.NewLine,
                string.Join("," + Environment.NewLine, columnDeclarations.Select(c => "  " + c)),
                primaryKeyConstraint);
            sb.AppendLine();
        }
Ejemplo n.º 2
0
        private static KeyValuePair <string, object>[] TryResolveProperty(
            MappingResolverStub mappingResolver, SqlEntityExpression sqlEntityDefinition, PropertyInfo member, object entity)
        {
            Expression expression;

            try
            {
                expression = mappingResolver.ResolveMemberExpression(sqlEntityDefinition, member);
            }
            catch (UnmappedItemException)
            {
                return(new KeyValuePair <string, object> [0]);
            }

            var memberValue = member.GetValue(entity, null);

            return(TryResolvePropertyExpression(mappingResolver, expression, memberValue).ToArray());
        }
Ejemplo n.º 3
0
        private static void AppendInsertScript(StringBuilder sb, object entity)
        {
            var mappingResolver     = new MappingResolverStub();
            var generator           = new UniqueIdentifierGenerator();
            var resolvedTableInfo   = (ResolvedSimpleTableInfo)mappingResolver.ResolveTableInfo(new UnresolvedTableInfo(entity.GetType()), generator);
            var sqlEntityDefinition = mappingResolver.ResolveSimpleTableInfo(resolvedTableInfo, generator);
            var columnData          = (from c in sqlEntityDefinition.Columns
                                       let columnName = c.ColumnName
                                                        let columnValue =
                                           GetColumnValue(entity, mappingResolver, sqlEntityDefinition, columnName)
                                           select new { columnName, columnValue }).ToArray();

            var columnNames  = string.Join(",", columnData.Select(d => d.columnName));
            var columnValues = string.Join(",", columnData.Select(d => GetSqlValueString(d.columnValue)));

            sb.AppendFormat("INSERT INTO [{0}] ({1}) VALUES ({2});", resolvedTableInfo.TableName, columnNames, columnValues);
            sb.AppendLine();
        }
Ejemplo n.º 4
0
        private static KeyValuePair <string, object>[] TryResolvePropertyExpression(
            MappingResolverStub mappingResolver, Expression expression, object value)
        {
            var columnExpression = expression as SqlColumnExpression;

            if (columnExpression != null)
            {
                return new[] { new KeyValuePair <string, object> (columnExpression.ColumnName, value) }
            }
            ;

            var newExpression = expression as NewExpression;

            if (newExpression != null)
            {
                return
                    (newExpression.Arguments.SelectMany(
                         (a, i) =>
                {
                    var argumentMemberValue = value != null ? ((PropertyInfo)newExpression.Members[i]).GetValue(value, null) : null;
                    return TryResolvePropertyExpression(mappingResolver, a, argumentMemberValue);
                }).ToArray());
            }

            var namedExpression = expression as NamedExpression;

            if (namedExpression != null)
            {
                return(TryResolvePropertyExpression(mappingResolver, namedExpression.Expression, value));
            }

            var memberRefExpression = (SqlEntityRefMemberExpression)expression;
            var optimizedIdentity   = mappingResolver.TryResolveOptimizedIdentity(memberRefExpression);

            if (optimizedIdentity == null)
            {
                return(new KeyValuePair <string, object> [0]);
            }

            var idOfReferencedEntity = value != null?value.GetType().GetProperty("ID").GetValue(value, null) : null;

            return(TryResolvePropertyExpression(mappingResolver, optimizedIdentity, idOfReferencedEntity));
        }
Ejemplo n.º 5
0
        private static object GetColumnValue(object entity, MappingResolverStub mappingResolver, SqlEntityDefinitionExpression sqlEntityDefinition, string columnName)
        {
            var propertiesWithColumnName =
                entity.GetType()
                .GetProperties()
                .SelectMany(p => TryResolveProperty(mappingResolver, sqlEntityDefinition, p, entity), (p, t) => new { Property = p, ColumnNameAndValue = t })
                .ToArray();
            var matchingProperty = propertiesWithColumnName.FirstOrDefault(d => d.ColumnNameAndValue.Key == columnName);

            // Assert.That (matchingProperties, Has.Length.LessThanOrEqualTo (1), entity.GetType().Name + ": " + string.Join (",", matchingProperties));

            Assert.IsNotNull(
                matchingProperty,
                "No member found for column '{0}' on entity type '{1}'.\r\n(Found: {2})",
                columnName,
                entity.GetType().Name,
                string.Join(",", propertiesWithColumnName.Select(p => p.ToString())));
            return(matchingProperty.ColumnNameAndValue.Value);
        }
    private static void AppendCreateTableScript (StringBuilder sb, Type type)
    {
      var mappingResolver = new MappingResolverStub();
      var generator = new UniqueIdentifierGenerator();
      var tableInfo = (ResolvedSimpleTableInfo) mappingResolver.ResolveTableInfo (new UnresolvedTableInfo (type), generator);
      var entity = mappingResolver.ResolveSimpleTableInfo (tableInfo, generator);

      var columnDeclarations = from c in entity.Columns
                               let sqlTypeName = GetColumnType(c)
                               select string.Format ("[{0}] {1}", c.ColumnName, sqlTypeName);
      var primaryKeyColumns = entity.Columns.Where (c => c.IsPrimaryKey).Select (c => c.ColumnName).ToArray();
      string primaryKeyConstraint = "";
      if (primaryKeyColumns.Length > 0)
      {
        primaryKeyConstraint = string.Format (
            " CONSTRAINT PK_{0} PRIMARY KEY ({1})", tableInfo.TableName.Replace (".", "_"), string.Join (",", primaryKeyColumns));
      }

      sb.AppendFormat (
          "CREATE TABLE [{0}]{1}({1}{2}{1} {3})",
          tableInfo.TableName,
          Environment.NewLine,
          string.Join ("," + Environment.NewLine, columnDeclarations.Select (c => "  " + c)),
          primaryKeyConstraint);
      sb.AppendLine();
    }
    private static KeyValuePair<string, object>[] TryResolvePropertyExpression (
        MappingResolverStub mappingResolver, Expression expression, object value)
    {
      var columnExpression = expression as SqlColumnExpression;
      if (columnExpression != null)
        return new[] { new KeyValuePair<string, object> (columnExpression.ColumnName, value) };

      var newExpression = expression as NewExpression;
      if (newExpression != null)
      {
        return
            newExpression.Arguments.SelectMany (
            (a, i) =>
            {
              var argumentMemberValue = value != null ? ((PropertyInfo) newExpression.Members[i]).GetValue (value, null) : null;
              return TryResolvePropertyExpression (mappingResolver, a, argumentMemberValue);
            }).ToArray();
      }

      var namedExpression = expression as NamedExpression;
      if (namedExpression != null)
        return TryResolvePropertyExpression (mappingResolver, namedExpression.Expression, value);

      var memberRefExpression = (SqlEntityRefMemberExpression) expression;
      var optimizedIdentity = mappingResolver.TryResolveOptimizedIdentity (memberRefExpression);
      if (optimizedIdentity == null)
        return new KeyValuePair<string, object>[0];

      var idOfReferencedEntity = value != null ? value.GetType().GetProperty ("ID").GetValue (value, null) : null;
      return TryResolvePropertyExpression (mappingResolver, optimizedIdentity, idOfReferencedEntity);
    }
    private static KeyValuePair<string, object>[] TryResolveProperty (
        MappingResolverStub mappingResolver, SqlEntityExpression sqlEntityDefinition, PropertyInfo member, object entity)
    {
      Expression expression;
      try
      {
        expression = mappingResolver.ResolveMemberExpression (sqlEntityDefinition, member);
      }
      catch (UnmappedItemException)
      {
        return new KeyValuePair<string, object>[0];
      }

      var memberValue = member.GetValue (entity, null);
      return TryResolvePropertyExpression(mappingResolver, expression, memberValue).ToArray();
    }
    private static object GetColumnValue (object entity, MappingResolverStub mappingResolver, SqlEntityDefinitionExpression sqlEntityDefinition, string columnName)
    {
      var propertiesWithColumnName =
          entity.GetType()
                .GetProperties()
                .SelectMany (p => TryResolveProperty (mappingResolver, sqlEntityDefinition, p, entity), (p, t) => new { Property = p, ColumnNameAndValue = t })
                .ToArray();
      var matchingProperty = propertiesWithColumnName.FirstOrDefault (d => d.ColumnNameAndValue.Key == columnName);
      // Assert.That (matchingProperties, Has.Length.LessThanOrEqualTo (1), entity.GetType().Name + ": " + string.Join (",", matchingProperties));

      Assert.IsNotNull (
          matchingProperty,
          "No member found for column '{0}' on entity type '{1}'.\r\n(Found: {2})",
          columnName,
          entity.GetType().Name,
          string.Join (",", propertiesWithColumnName.Select (p=> p.ToString())));
      return matchingProperty.ColumnNameAndValue.Value;
    }
    private static void AppendInsertScript (StringBuilder sb, object entity)
    {
      var mappingResolver = new MappingResolverStub ();
      var generator = new UniqueIdentifierGenerator();
      var resolvedTableInfo = (ResolvedSimpleTableInfo) mappingResolver.ResolveTableInfo (new UnresolvedTableInfo (entity.GetType()), generator);
      var sqlEntityDefinition = mappingResolver.ResolveSimpleTableInfo (resolvedTableInfo, generator);
      var columnData = (from c in sqlEntityDefinition.Columns
                        let columnName = c.ColumnName
                        let columnValue =
                            GetColumnValue (entity, mappingResolver, sqlEntityDefinition, columnName)
                        select new { columnName, columnValue }).ToArray();

      var columnNames = string.Join (",", columnData.Select (d => d.columnName));
      var columnValues = string.Join (",", columnData.Select (d => GetSqlValueString (d.columnValue)));

      sb.AppendFormat ("INSERT INTO [{0}] ({1}) VALUES ({2});", resolvedTableInfo.TableName, columnNames, columnValues);
      sb.AppendLine();
    }