public void AddQuerySource()
{
var sqlTable = SqlStatementModelObjectMother.CreateSqlTable();
var preparedFromExpressionInfo = new FromExpressionInfo(
sqlTable, new Ordering[] { }, new SqlTableReferenceExpression(sqlTable), null);
_stageMock
.Expect(
mock =>
mock.PrepareFromExpression(
Arg.Is(_mainFromClause.FromExpression),
Arg <ISqlPreparationContext> .Matches(c => c != _context),
Arg <Func <ITableInfo, SqlTable> > .Is.Anything))
.Return(preparedFromExpressionInfo)
.WhenCalled(mi =>
{
var tableCreator = (Func <ITableInfo, SqlTable>)mi.Arguments[2];
var sampleTableInfo = new UnresolvedTableInfo(typeof(Cook));
var table = tableCreator(sampleTableInfo);
Assert.That(table, Is.TypeOf(typeof(SqlTable)));
Assert.That(((SqlTable)table).TableInfo, Is.SameAs(sampleTableInfo));
Assert.That(table.JoinSemantics, Is.EqualTo(JoinSemantics.Inner));
});
_stageMock.Replay();
var result = _visitor.AddQuerySource(_mainFromClause, _mainFromClause.FromExpression);
_stageMock.VerifyAllExpectations();
Assert.That(result, Is.SameAs(sqlTable));
Assert.That(_visitor.Context.GetExpressionMapping(new QuerySourceReferenceExpression(_mainFromClause)), Is.Not.Null);
}
public static SqlTable CreateSqlTable_WithUnresolvedTableInfo(Type type)
{
var unresolvedTableInfo = new UnresolvedTableInfo(type);
var sqlTable = new SqlTable(unresolvedTableInfo, JoinSemantics.Inner);
return(sqlTable);
}
public ITableInfo VisitUnresolvedTableInfo(UnresolvedTableInfo tableInfo)
{
ArgumentUtility.CheckNotNull("tableInfo", tableInfo);
var result = _resolver.ResolveTableInfo(tableInfo, _generator);
return(result.Accept(this));
}
public void ApplyContext_UnresolvedTableInfo()
{
var tableInfo = new UnresolvedTableInfo(typeof(Cook));
var result = SqlContextTableInfoVisitor.ApplyContext(tableInfo, SqlExpressionContext.ValueRequired, _stageMock, _mappingresolutionContext);
Assert.That(result, Is.SameAs(tableInfo));
}
public IResolvedTableInfo ResolveTableInfo(UnresolvedTableInfo tableInfo, UniqueIdentifierGenerator generator)
{
ArgumentUtility.CheckNotNull("tableInfo", tableInfo);
ArgumentUtility.CheckNotNull("generator", generator);
var classDefinition = GetClassDefinition(tableInfo.ItemType);
return(_storageSpecificExpressionResolver.ResolveTable(classDefinition, generator.GetUniqueIdentifier("t")));
}
public void SetUp()
{
_stageMock = MockRepository.GenerateMock <IMappingResolutionStage>();
_resolverMock = MockRepository.GenerateMock <IMappingResolver>();
_unresolvedTableInfo = SqlStatementModelObjectMother.CreateUnresolvedTableInfo(typeof(Cook));
_resolvedTableInfo = SqlStatementModelObjectMother.CreateResolvedTableInfo(typeof(Cook));
_generator = new UniqueIdentifierGenerator();
_sqlStatement = SqlStatementModelObjectMother.CreateSqlStatement_Resolved(typeof(Cook));
_mappingResolutionContext = new MappingResolutionContext();
}
public void ResolveTableInfo()
{
var unresolvedTableInfo = new UnresolvedTableInfo(typeof(DataContextTestClass.Customer));
var resolvedTableInfo = (ResolvedSimpleTableInfo)_mappingResolver.ResolveTableInfo(unresolvedTableInfo, _generator);
Assert.That(resolvedTableInfo.ItemType, Is.EqualTo(typeof(DataContextTestClass.Customer)));
Assert.That(resolvedTableInfo.TableAlias, Is.EqualTo("t0"));
Assert.That(resolvedTableInfo.TableName, Is.EqualTo("Customers"));
}
public void SetUp()
{
_stageMock = MockRepository.GenerateStrictMock <IMappingResolutionStage>();
_mappingResolutionContext = new MappingResolutionContext();
_visitor = new TestableSqlStatementResolver(_stageMock, _mappingResolutionContext);
_unresolvedTableInfo = SqlStatementModelObjectMother.CreateUnresolvedTableInfo(typeof(Cook));
_sqlTable = SqlStatementModelObjectMother.CreateSqlTable(_unresolvedTableInfo);
_fakeResolvedSimpleTableInfo = SqlStatementModelObjectMother.CreateResolvedTableInfo(typeof(Cook));
}
public void SetUp()
{
_stageMock = MockRepository.GenerateMock <ISqlPreparationStage>();
_context = SqlStatementModelObjectMother.CreateSqlPreparationContext();
_cookMainFromClause = ExpressionHelper.CreateMainFromClause <Cook>();
_cookQuerySourceReferenceExpression = new QuerySourceReferenceExpression(_cookMainFromClause);
var source = new UnresolvedTableInfo(_cookMainFromClause.ItemType);
_sqlTable = new SqlTable(source, JoinSemantics.Inner);
_context.AddExpressionMapping(new QuerySourceReferenceExpression(_cookMainFromClause), new SqlTableReferenceExpression(_sqlTable));
_methodCallTransformerProvider = CompoundMethodCallTransformerProvider.CreateDefault();
}
public IResolvedTableInfo ResolveTableInfo(UnresolvedTableInfo tableInfo, UniqueIdentifierGenerator generator)
{
ArgumentUtility.CheckNotNull("tableInfo", tableInfo);
ArgumentUtility.CheckNotNull("generator", generator);
MetaTable table = GetMetaTable(tableInfo.ItemType);
// TODO RM-3127: Refactor when re-linq supports schema names
var tableName = table.TableName.StartsWith("dbo.") ? table.TableName.Substring(4) : table.TableName;
return(new ResolvedSimpleTableInfo(tableInfo.ItemType, tableName, generator.GetUniqueIdentifier("t")));
}
public void ResolveTableInfo()
{
var unresolvedTableInfo = new UnresolvedTableInfo(typeof(Order));
_storageSpecificExpressionResolverStub
.Stub(stub => stub.ResolveTable(MappingConfiguration.Current.GetTypeDefinition(typeof(Order)), "t0"))
.Return(_fakeSimpleTableInfo);
var resolvedTableInfo = (ResolvedSimpleTableInfo)_resolver.ResolveTableInfo(unresolvedTableInfo, _generator);
Assert.That(resolvedTableInfo, Is.SameAs(_fakeSimpleTableInfo));
}
public void SetUp()
{
_context = SqlStatementModelObjectMother.CreateSqlPreparationContext();
_source = ExpressionHelper.CreateMainFromClause <Cook>();
var source = new UnresolvedTableInfo(typeof(int));
_sqlTable = new SqlTable(source, JoinSemantics.Inner);
_parentContext = SqlStatementModelObjectMother.CreateSqlPreparationContext();
_parentSource = ExpressionHelper.CreateMainFromClause <Cook>();
_parentSqlTable = new SqlTable(new UnresolvedTableInfo(typeof(int)), JoinSemantics.Inner);
_sqlStatementBuilder = new SqlStatementBuilder();
_contextWithParent = new SqlPreparationContext(_parentContext, _sqlStatementBuilder);
}
public void SetUp()
{
_resolverMock = MockRepository.GenerateMock <IMappingResolver>();
_uniqueIdentifierGenerator = new UniqueIdentifierGenerator();
_unresolvedTableInfo = SqlStatementModelObjectMother.CreateUnresolvedTableInfo(typeof(Cook));
_sqlTable = SqlStatementModelObjectMother.CreateSqlTable(_unresolvedTableInfo);
_fakeResolvedSimpleTableInfo = SqlStatementModelObjectMother.CreateResolvedTableInfo(typeof(Cook));
_stage = new DefaultMappingResolutionStage(_resolverMock, _uniqueIdentifierGenerator);
_mappingResolutionContext = new MappingResolutionContext();
}
public virtual IResolvedTableInfo ResolveTableInfo(UnresolvedTableInfo tableInfo, UniqueIdentifierGenerator generator)
{
switch (tableInfo.ItemType.Name)
{
case "Cook":
case "Knife":
case "Kitchen":
case "Restaurant":
case "Company":
return(CreateResolvedTableInfo(tableInfo.ItemType, generator));
case "Chef":
return(new ResolvedSimpleTableInfo(tableInfo.ItemType, "dbo." + tableInfo.ItemType.Name + "Table", generator.GetUniqueIdentifier("t")));
}
throw new UnmappedItemException("The type " + tableInfo.ItemType + " cannot be queried from the stub provider.");
}
ITableInfo ITableInfoVisitor.VisitUnresolvedTableInfo(UnresolvedTableInfo tableInfo)
{
throw new InvalidOperationException("UnresolvedTableInfo is not valid at this point.");
}
public ITableInfo VisitUnresolvedTableInfo(UnresolvedTableInfo tableInfo)
{
ArgumentUtility.CheckNotNull("tableInfo", tableInfo);
return(tableInfo);
}
public void SetUp()
{
_tableInfo = SqlStatementModelObjectMother.CreateUnresolvedTableInfo(typeof(Cook));
}
public void ResolveTableInfo_NoDomainObject_ThrowsException()
{
var unresolvedTableInfo = new UnresolvedTableInfo(typeof(Student));
_resolver.ResolveTableInfo(unresolvedTableInfo, _generator);
}
