public SqlColumnReferenceExpression (Type type, string tableAlias, string referencedColumnName, bool isPrimaryKey, SqlEntityExpression referencedEntity) : base (type, tableAlias, referencedColumnName, isPrimaryKey) { ArgumentUtility.CheckNotNull ("referencedEntity", referencedEntity); _referencedEntity = referencedEntity; }
public SqlColumnReferenceExpression(Type type, string tableAlias, string referencedColumnName, bool isPrimaryKey, SqlEntityExpression referencedEntity) : base(type, tableAlias, referencedColumnName, isPrimaryKey) { ArgumentUtility.CheckNotNull("referencedEntity", referencedEntity); _referencedEntity = referencedEntity; }
public void SetUp () { var sqlTable = SqlStatementModelObjectMother.CreateSqlTable_WithResolvedTableInfo(); _entityExpression = new SqlEntityDefinitionExpression ( typeof (string), "t", null, e => e.GetColumn (typeof (string), "ID", true), new SqlColumnExpression[] { new SqlColumnDefinitionExpression (typeof (string), "t", "ID", true), new SqlColumnDefinitionExpression (typeof (int), "t", "Name", false), new SqlColumnDefinitionExpression (typeof (int), "t", "City", false) }); _sqlStatement = new SqlStatement ( new TestStreamedValueInfo (typeof (int)), _entityExpression, new[] { sqlTable }, null, null, new Ordering[] { }, null, false, null, null); _commandBuilder = new SqlCommandBuilder(); }
public void SetUp () { _context = new MappingResolutionContext(); _entityExpression = SqlStatementModelObjectMother.CreateSqlEntityDefinitionExpression (typeof (Cook), null, "c"); _groupingSelectExpression = new SqlGroupingSelectExpression (Expression.Constant ("key"), Expression.Constant ("element")); _sqlTable = new SqlTable (new ResolvedSimpleTableInfo (typeof (Cook), "CookTable", "c"), JoinSemantics.Inner); }
public void AddSqlEntityMapping (SqlEntityExpression entityExpression, SqlTableBase sqlTable) { ArgumentUtility.CheckNotNull ("entityExpression", entityExpression); ArgumentUtility.CheckNotNull ("sqlTable", sqlTable); _entityMapping[entityExpression] = sqlTable; }
public SqlEntityReferenceExpression (Type itemType, string tableAlias, string entityName, SqlEntityExpression referencedEntity) : base(itemType, tableAlias, entityName, referencedEntity.IdentityExpressionGenerator) { ArgumentUtility.CheckNotNull ("referencedEntity", referencedEntity); _referencedEntity = referencedEntity; _columns = Array.AsReadOnly (referencedEntity.Columns.Select (col => GetColumn (col.Type, col.ColumnName, col.IsPrimaryKey)).ToArray ()); }
public Expression VisitSqlEntityExpression (SqlEntityExpression expression) { ArgumentUtility.CheckNotNull ("expression", expression); var reference = expression.CreateReference (_tableInfo.TableAlias, expression.Type); _context.AddSqlEntityMapping (reference, _sqlTable); return reference; }
public SqlEntityRefMemberExpression (SqlEntityExpression originatingEntity, MemberInfo memberInfo) : base (ReflectionUtility.GetMemberReturnType (ArgumentUtility.CheckNotNull ("memberInfo", memberInfo))) { ArgumentUtility.CheckNotNull ("entityExpression", originatingEntity); _originatingEntity = originatingEntity; _memberInfo = memberInfo; }
public SqlEntityReferenceExpression(Type itemType, string tableAlias, string entityName, SqlEntityExpression referencedEntity) : base(itemType, tableAlias, entityName, referencedEntity.IdentityExpressionGenerator) { ArgumentUtility.CheckNotNull("referencedEntity", referencedEntity); _referencedEntity = referencedEntity; _columns = Array.AsReadOnly(referencedEntity.Columns.Select(col => GetColumn(col.Type, col.ColumnName, col.IsPrimaryKey)).ToArray()); }
public void SetUp () { _columnExpression1 = new SqlColumnDefinitionExpression (typeof (int), "t", "ID", true); _columnExpression2 = new SqlColumnDefinitionExpression (typeof (int), "t", "Name", false); _columnExpression3 = new SqlColumnDefinitionExpression (typeof (int), "t", "City", false); _orginalColumns = new[] { _columnExpression1, _columnExpression2, _columnExpression3 }; _entityExpression = new SqlEntityDefinitionExpression (typeof (Cook), "t", null, e => e.GetColumn (typeof (int), "ID", true), _orginalColumns); _originalColumnsReadonly = _entityExpression.Columns; }
public SqlTableBase GetSqlTableForEntityExpression (SqlEntityExpression entityExpression) { ArgumentUtility.CheckNotNull ("entityExpression", entityExpression); SqlTableBase result; if (_entityMapping.TryGetValue (entityExpression, out result)) return result; var message = string.Format ("No associated table found for entity '{0}'.", FormattingExpressionTreeVisitor.Format (entityExpression)); throw new InvalidOperationException (message); }
public SqlEntityExpression UpdateEntityAndAddMapping (SqlEntityExpression entityExpression, Type itemType, string tableAlias, string newName) { ArgumentUtility.CheckNotNull ("entityExpression", entityExpression); ArgumentUtility.CheckNotNull ("itemType", itemType); ArgumentUtility.CheckNotNullOrEmpty ("tableAlias", tableAlias); var newEntityExpression = entityExpression.Update (itemType, tableAlias, newName); var tableForEntityExpression = GetSqlTableForEntityExpression (entityExpression); AddSqlEntityMapping (newEntityExpression, tableForEntityExpression); return newEntityExpression; }
public void SetUp () { _stageMock = MockRepository.GenerateStrictMock<IMappingResolutionStage>(); _resolverMock = MockRepository.GenerateStrictMock<IMappingResolver>(); _context = new MappingResolutionContext(); _entityIdentityResolver = new EntityIdentityResolver (_stageMock, _resolverMock, _context); _entityExpression = SqlStatementModelObjectMother.CreateSqlEntityDefinitionExpression (typeof (Cook), primaryKeyType: typeof (int)); _entityConstantExpression = new SqlEntityConstantExpression (typeof (Cook), new Cook (), Expression.Constant (0)); _entityRefMemberExpression = new SqlEntityRefMemberExpression ( SqlStatementModelObjectMother.CreateSqlEntityDefinitionExpression (typeof (Kitchen)), typeof (Kitchen).GetProperty ("Cook")); }
public UnresolvedJoinInfo (SqlEntityExpression originatingEntity, MemberInfo memberInfo, JoinCardinality cardinality) { ArgumentUtility.CheckNotNull ("originatingEntity", originatingEntity); ArgumentUtility.CheckNotNull ("memberInfo", memberInfo); _originatingEntity = originatingEntity; _memberInfo = memberInfo; _cardinality = cardinality; var memberReturnType = ReflectionUtility.GetMemberReturnType (memberInfo); if (Cardinality == JoinCardinality.One) _itemType = memberReturnType; else _itemType = ReflectionUtility.GetItemTypeOfClosedGenericIEnumerable (memberReturnType, "memberInfo"); }
public void SetUp () { _sqlTable = SqlStatementModelObjectMother.CreateSqlTable_WithResolvedTableInfo(); _entityExpression = new SqlEntityDefinitionExpression ( typeof(string), "t", null, e => e.GetColumn (typeof (int), "ID", true), new SqlColumnExpression[] { new SqlColumnDefinitionExpression (typeof (int), "t", "ID", true), new SqlColumnDefinitionExpression (typeof (int), "t", "Name", false), new SqlColumnDefinitionExpression (typeof (int), "t", "City", false) }); _stageMock = MockRepository.GenerateStrictMock<ISqlGenerationStage>(); _generator = new TestableSqlStatementTextGenerator (_stageMock); _commandBuilder = new SqlCommandBuilder(); }
public Expression VisitSqlEntityExpression (SqlEntityExpression expression) { if (_currentContext == SqlExpressionContext.SingleValueRequired) { string message = string.Format ( "Cannot use an entity expression ('{0}' of type '{1}') in a place where SQL requires a single value.", FormattingExpressionTreeVisitor.Format (expression), expression.Type.Name); throw new NotSupportedException (message); } return expression; // rely on VisitExpression to apply correct semantics }
public virtual Expression ResolveMemberExpression (SqlEntityExpression originatingEntity, MemberInfo memberInfo) { var memberType = ReflectionUtility.GetMemberReturnType (memberInfo); if (memberInfo.DeclaringType == typeof (Cook)) { switch (memberInfo.Name) { case "ID": return originatingEntity.GetColumn (memberType, memberInfo.Name, true); case "FirstName": case "Name": case "IsFullTimeCook": case "IsStarredCook": case "Weight": case "SpecificInformation": return originatingEntity.GetColumn (memberType, memberInfo.Name, false); case "KnifeID": return CreateMetaIDExpression ( originatingEntity.GetColumn (typeof (int), "KnifeID", false), originatingEntity.GetColumn (typeof (string), "KnifeClassID", false)); case "Substitution": case "Substituted": case "Kitchen": case "Knife": return new SqlEntityRefMemberExpression (originatingEntity, memberInfo); } } else if (memberInfo.DeclaringType == typeof (ISpecificCook)) { switch (memberInfo.Name) { case "SpecificInformation": return originatingEntity.GetColumn (memberType, memberInfo.Name, false); } } else if (memberInfo.DeclaringType == typeof (Chef)) { switch (memberInfo.Name) { case "LetterOfRecommendation": return originatingEntity.GetColumn (memberType, memberInfo.Name, false); } } else if (memberInfo.DeclaringType == typeof (Kitchen)) { switch (memberInfo.Name) { case "ID": return originatingEntity.GetColumn (memberType, memberInfo.Name, true); case "Name": case "RoomNumber": case "LastCleaningDay": case "PassedLastInspection": case "LastInspectionScore": return originatingEntity.GetColumn (memberType, memberInfo.Name, false); case "Cook": case "Restaurant": return new SqlEntityRefMemberExpression (originatingEntity, memberInfo); } } else if (memberInfo.DeclaringType == typeof (Restaurant)) { switch (memberInfo.Name) { case "ID": return originatingEntity.GetColumn (memberType, memberInfo.Name, true); case "SubKitchen": case "CompanyIfAny": return new SqlEntityRefMemberExpression (originatingEntity, memberInfo); } } else if (memberInfo.DeclaringType == typeof (Company)) { switch (memberInfo.Name) { case "ID": return originatingEntity.GetColumn (memberType, memberInfo.Name, true); case "DateOfIncorporation": return originatingEntity.GetColumn (memberType, memberInfo.Name, false); } } else if (memberInfo.DeclaringType == typeof (Knife)) { switch (memberInfo.Name) { case "ID": return CreateMetaIDExpression ( originatingEntity.GetColumn (typeof (int), "ID", true), originatingEntity.GetColumn (typeof (string), "ClassID", true)); case "Sharpness": return originatingEntity.GetColumn (memberType, memberInfo.Name, false); } } throw new UnmappedItemException ("Cannot resolve member: " + memberInfo); }
protected string GetAliasForColumnOfEntity (SqlColumnExpression column, SqlEntityExpression entity) { if (column.ColumnName != "*") { if (entity.Name != null) { return entity.Name + "_" + column.ColumnName; } else if ((entity is SqlEntityReferenceExpression) && ((SqlEntityReferenceExpression) entity).ReferencedEntity.Name != null) { // entity references without a name that point to an entity with a name must assign aliases to their columns; // otherwise, their columns would include the referenced entity's name return column.ColumnName; } } return null; }
public void SetUp () { _entityExpression = SqlStatementModelObjectMother.CreateSqlEntityDefinitionExpression (typeof (Cook)); }
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(); }
public override Expression VisitSqlEntityExpression (SqlEntityExpression expression) { ArgumentUtility.CheckNotNull ("expression", expression); var columnIds = expression.Columns .Select (e => GetNextColumnID (GetAliasForColumnOfEntity (e, expression) ?? e.ColumnName)) .ToArray(); var result = base.VisitSqlEntityExpression (expression); var newInMemoryProjectionBody = Expression.Call ( CommandBuilder.InMemoryProjectionRowParameter, s_getEntityMethod.MakeGenericMethod (expression.Type), Expression.Constant (columnIds)); CommandBuilder.SetInMemoryProjectionBody (newInMemoryProjectionBody); return result; }
private ResolvedJoinInfo CreateResolvedJoinInfo ( SqlEntityExpression originatingEntity, string leftColumnName, Type leftColumnType, bool leftColumnIsPrimaryKey, IResolvedTableInfo joinedTableInfo, string rightColumnName, Type rightColumnType, bool rightColumnIsPrimaryKey) { var leftColumn = originatingEntity.GetColumn (leftColumnType, leftColumnName, leftColumnIsPrimaryKey); var rightColumn = CreateColumn (rightColumnType, joinedTableInfo.TableAlias, rightColumnName, rightColumnIsPrimaryKey); return new ResolvedJoinInfo ( joinedTableInfo, ConversionUtility.MakeBinaryWithOperandConversion (ExpressionType.Equal, leftColumn, rightColumn, false, null)); }
protected override void AppendColumnForEntity (SqlEntityExpression entity, SqlColumnExpression column) { column.Accept (this); string alias = GetAliasForColumnOfEntity(column, entity); if (alias != null) { CommandBuilder.Append (" AS "); CommandBuilder.AppendIdentifier (alias); } }
public void SetUp () { _memberInfo = typeof (Cook).GetProperty ("Substitution"); _entityExpression = SqlStatementModelObjectMother.CreateSqlEntityDefinitionExpression (typeof (Cook), null, "c"); _expression = new SqlEntityRefMemberExpression (_entityExpression, _memberInfo); }