public void LoadDataContainersByRelatedID()
{
var objectID = DomainObjectIDs.Order1;
var relationEndPointDefinition = (RelationEndPointDefinition)GetEndPointDefinition(typeof(Order), "Official");
var sortExpression = new SortExpressionDefinition(
new[] { new SortedPropertySpecification(GetPropertyDefinition(typeof(Official), "Name"), SortOrder.Ascending) });
var fakeResult = DataContainer.CreateNew(objectID);
var commandMock =
_mockRepository.StrictMock <IStorageProviderCommand <IEnumerable <DataContainer>, IRdbmsProviderCommandExecutionContext> >();
using (_mockRepository.Ordered())
{
_connectionCreatorMock.Expect(mock => mock.CreateConnection()).Return(_connectionStub);
_commandFactoryMock
.Expect(mock => mock.CreateForRelationLookup(relationEndPointDefinition, objectID, sortExpression))
.Return(commandMock);
commandMock.Expect(mock => mock.Execute(_provider)).Return(new[] { fakeResult });
}
_mockRepository.ReplayAll();
var result = _provider.LoadDataContainersByRelatedID(relationEndPointDefinition, sortExpression, objectID);
_mockRepository.VerifyAll();
Assert.That(result, Is.EqualTo(new[] { fakeResult }));
}
public void LoadDataContainersByRelatedID_WithSortExpression()
{
_testHelper.ExpectExecuteReader(
CommandBehavior.SingleResult,
"SELECT [ID], [ClassID], [CreatedAt], [LastName] FROM [TableInheritance_Person] WHERE [ClientID] = @ClientID "
+ "UNION ALL SELECT [ID], [ClassID], [CreatedAt], NULL FROM [TableInheritance_OrganizationalUnit] WHERE [ClientID] = @ClientID "
+ "ORDER BY [CreatedAt] DESC, [LastName] ASC;",
Tuple.Create("@ClientID", DbType.Guid, DomainObjectIDs.Client.Value));
_testHelper.ExpectExecuteReader(
CommandBehavior.SingleResult,
"SELECT [ID], [ClassID], [Timestamp], [CreatedBy], [CreatedAt], [ClientID], [FirstName], [LastName], [DateOfBirth], [Photo], "
+ "[CustomerType], [CustomerSince], [RegionID] FROM [TableInheritance_Person] "
+ "WHERE [ID] IN (SELECT T.c.value('.', 'uniqueidentifier') FROM @ID.nodes('/L/I') T(c));",
Tuple.Create("@ID", DbType.Xml, (object)"<L><I>623016f9-b525-4cae-a2bd-d4a6155b2f33</I><I>084010c4-82e5-4b0d-ae9f-a953303c03a4</I><I>21e9bea1-3026-430a-a01e-e9b6a39928a8</I></L>"));
_testHelper.ExpectExecuteReader(
CommandBehavior.SingleResult,
"SELECT [ID], [ClassID], [Timestamp], [CreatedBy], [CreatedAt], [ClientID], [Name] FROM [TableInheritance_OrganizationalUnit] WHERE [ID] = @ID;",
Tuple.Create("@ID", DbType.Guid, DomainObjectIDs.OrganizationalUnit.Value));
_testHelper.Replay();
var relationEndPointDefinition = (RelationEndPointDefinition)GetEndPointDefinition(typeof(TIDomainBase), "Client");
var sortExpression = new SortExpressionDefinition(
new[]
{
new SortedPropertySpecification(GetPropertyDefinition(typeof(TIDomainBase), "CreatedAt"), SortOrder.Descending),
new SortedPropertySpecification(GetPropertyDefinition(typeof(TIPerson), "LastName"), SortOrder.Ascending)
});
_testHelper.Provider.LoadDataContainersByRelatedID(relationEndPointDefinition, sortExpression, DomainObjectIDs.Client).ToArray();
_testHelper.VerifyAllExpectations();
}
protected virtual IStorageProviderCommand <IEnumerable <DataContainer>, IRdbmsProviderCommandExecutionContext> CreateForIndirectRelationLookup(
UnionViewDefinition unionViewDefinition,
RelationEndPointDefinition foreignKeyEndPoint,
ObjectID foreignKeyValue,
SortExpressionDefinition sortExpression)
{
var selectedColumns = unionViewDefinition.ObjectIDProperty.GetColumns();
var dbCommandBuilder = _dbCommandBuilderFactory.CreateForSelect(
unionViewDefinition,
selectedColumns,
GetComparedColumns(foreignKeyEndPoint, foreignKeyValue),
GetOrderedColumns(sortExpression));
var objectIDReader = _objectReaderFactory.CreateObjectIDReader(unionViewDefinition, selectedColumns);
var objectIDLoadCommand = new MultiObjectIDLoadCommand(new[] { dbCommandBuilder }, objectIDReader);
var indirectDataContainerLoadCommand = new IndirectDataContainerLoadCommand(objectIDLoadCommand, _storageProviderCommandFactory);
return(DelegateBasedCommand.Create(
indirectDataContainerLoadCommand,
lookupResults => lookupResults.Select(
result =>
{
Assertion.IsNotNull(
result.LocatedObject,
"Because ID lookup and DataContainer lookup are executed within the same database transaction, the DataContainer can never be null.");
return result.LocatedObject;
})));
}
public override IEnumerable <DataContainer> LoadDataContainersByRelatedID(
RelationEndPointDefinition relationEndPointDefinition,
SortExpressionDefinition sortExpressionDefinition,
ObjectID relatedID)
{
CheckDisposed();
ArgumentUtility.CheckNotNull("relationEndPointDefinition", relationEndPointDefinition);
ArgumentUtility.CheckNotNull("relatedID", relatedID);
CheckClassDefinition(relationEndPointDefinition.ClassDefinition, "classDefinition");
Connect();
if (relationEndPointDefinition.PropertyDefinition.StorageClass == StorageClass.Transaction)
{
return(new DataContainerCollection());
}
var storageProviderCommand = _storageProviderCommandFactory.CreateForRelationLookup(
relationEndPointDefinition,
relatedID,
sortExpressionDefinition);
var dataContainers = storageProviderCommand.Execute(this);
var checkedSequence = CheckForNulls(CheckForDuplicates(dataContainers, "relation lookup"), "relation lookup");
return(new DataContainerCollection(checkedSequence, true));
}
public IStorageProviderCommand <IEnumerable <DataContainer>, IRdbmsProviderCommandExecutionContext> CreateForRelationLookup(
RelationEndPointDefinition foreignKeyEndPoint, ObjectID foreignKeyValue, SortExpressionDefinition sortExpressionDefinition)
{
ArgumentUtility.CheckNotNull("foreignKeyEndPoint", foreignKeyEndPoint);
ArgumentUtility.CheckNotNull("foreignKeyValue", foreignKeyValue);
return(_relationLookupCommandFactory.CreateForRelationLookup(foreignKeyEndPoint, foreignKeyValue, sortExpressionDefinition));
}
public virtual IStorageProviderCommand <IEnumerable <DataContainer>, IRdbmsProviderCommandExecutionContext> CreateForRelationLookup(
RelationEndPointDefinition foreignKeyEndPoint, ObjectID foreignKeyValue, SortExpressionDefinition sortExpressionDefinition)
{
ArgumentUtility.CheckNotNull("foreignKeyEndPoint", foreignKeyEndPoint);
ArgumentUtility.CheckNotNull("foreignKeyValue", foreignKeyValue);
return(InlineRdbmsStorageEntityDefinitionVisitor.Visit <IStorageProviderCommand <IEnumerable <DataContainer>, IRdbmsProviderCommandExecutionContext> > (
_rdbmsPersistenceModelProvider.GetEntityDefinition(foreignKeyEndPoint.ClassDefinition),
(table, continuation) => CreateForDirectRelationLookup(table, foreignKeyEndPoint, foreignKeyValue, sortExpressionDefinition),
(filterView, continuation) => continuation(filterView.BaseEntity),
(unionView, continuation) => CreateForIndirectRelationLookup(unionView, foreignKeyEndPoint, foreignKeyValue, sortExpressionDefinition),
(emptyView, continuation) => CreateForEmptyRelationLookup()));
}
protected virtual IEnumerable <OrderedColumn> GetOrderedColumns(SortExpressionDefinition sortExpression)
{
if (sortExpression == null)
{
return(new OrderedColumn[0]);
}
Assertion.IsTrue(sortExpression.SortedProperties.Count > 0, "The sort-epression must have at least one sorted property.");
return(from sortedProperty in sortExpression.SortedProperties
let storagePropertyDefinition = _rdbmsPersistenceModelProvider.GetStoragePropertyDefinition(sortedProperty.PropertyDefinition)
from column in storagePropertyDefinition.GetColumns()
select new OrderedColumn(column, sortedProperty.Order));
}
public void LoadWithOrderBy()
{
var relationEndPointDefinition = GetEndPointDefinition(typeof(Order), "Customer");
var orderNumberProperty = GetPropertyDefinition(typeof(Order), "OrderNumber");
var sortExpression = new SortExpressionDefinition(new[] { new SortedPropertySpecification(orderNumberProperty, SortOrder.Ascending) });
var orderContainers = Provider.LoadDataContainersByRelatedID(
(RelationEndPointDefinition)relationEndPointDefinition,
sortExpression,
DomainObjectIDs.Customer1).ToList();
Assert.That(orderContainers.Count, Is.EqualTo(2));
Assert.That(orderContainers[0].ID, Is.EqualTo(DomainObjectIDs.Order1));
Assert.That(orderContainers[1].ID, Is.EqualTo(DomainObjectIDs.Order2));
}
protected virtual IStorageProviderCommand <IEnumerable <DataContainer>, IRdbmsProviderCommandExecutionContext> CreateForDirectRelationLookup(
TableDefinition tableDefinition,
RelationEndPointDefinition foreignKeyEndPoint,
ObjectID foreignKeyValue,
SortExpressionDefinition sortExpression)
{
var selectedColumns = tableDefinition.GetAllColumns();
var dataContainerReader = _objectReaderFactory.CreateDataContainerReader(tableDefinition, selectedColumns);
var dbCommandBuilder = _dbCommandBuilderFactory.CreateForSelect(
tableDefinition,
selectedColumns,
GetComparedColumns(foreignKeyEndPoint, foreignKeyValue),
GetOrderedColumns(sortExpression));
return(new MultiObjectLoadCommand <DataContainer> (new[] { Tuple.Create(dbCommandBuilder, dataContainerReader) }));
}
public new void ToString()
{
var sortExpressionDefinition =
new SortExpressionDefinition(
new[]
{
SortExpressionDefinitionObjectMother.CreateSortedPropertyAscending(_productPropertyDefinition),
SortExpressionDefinitionObjectMother.CreateSortedPropertyDescending(_positionPropertyDefinition)
});
var result = sortExpressionDefinition.ToString();
var expected =
"Remotion.Data.DomainObjects.UnitTests.TestDomain.OrderItem.Product ASC, "
+ "Remotion.Data.DomainObjects.UnitTests.TestDomain.OrderItem.Position DESC";
Assert.That(result, Is.EqualTo(expected));
}
public void LoadDataContainersByRelatedID_WithAbstractBaseClass()
{
var relationEndPointDefinition = GetEndPointDefinition(typeof(TIDomainBase), "Client");
var createdAtProperty = GetPropertyDefinition(typeof(TIDomainBase), "CreatedAt");
var sortExpression = new SortExpressionDefinition(new[] { new SortedPropertySpecification(createdAtProperty, SortOrder.Ascending) });
var loadedDataContainers = _provider.LoadDataContainersByRelatedID(
(RelationEndPointDefinition)relationEndPointDefinition,
sortExpression,
DomainObjectIDs.Client).ToList();
Assert.That(loadedDataContainers, Is.Not.Null);
Assert.That(loadedDataContainers.Count, Is.EqualTo(4));
Assert.That(loadedDataContainers[0].ID, Is.EqualTo(DomainObjectIDs.OrganizationalUnit));
Assert.That(loadedDataContainers[1].ID, Is.EqualTo(DomainObjectIDs.Person));
Assert.That(loadedDataContainers[2].ID, Is.EqualTo(DomainObjectIDs.PersonForUnidirectionalRelationTest));
Assert.That(loadedDataContainers[3].ID, Is.EqualTo(DomainObjectIDs.Customer));
}
public void LoadDataContainersByRelatedID_WithSortExpression()
{
_testHelper.ExpectExecuteReader(
CommandBehavior.SingleResult,
"SELECT [ID], [ClassID], [Timestamp], [Name], [IndustrialSectorID], [ContactPersonID], [NumberOfShops], [SupplierQuality], [CustomerSince], [CustomerType] "
+ "FROM [Company] WHERE [IndustrialSectorID] = @IndustrialSectorID ORDER BY [CustomerSince] DESC, [Name] ASC;",
Tuple.Create("@IndustrialSectorID", DbType.Guid, DomainObjectIDs.IndustrialSector1.Value));
_testHelper.Replay();
var relationEndPointDefinition = (RelationEndPointDefinition)GetEndPointDefinition(typeof(Company), "IndustrialSector");
var sortExpression = new SortExpressionDefinition(
new[]
{
new SortedPropertySpecification(GetPropertyDefinition(typeof(Customer), "CustomerSince"), SortOrder.Descending),
new SortedPropertySpecification(GetPropertyDefinition(typeof(Company), "Name"), SortOrder.Ascending)
});
_testHelper.Provider.LoadDataContainersByRelatedID(relationEndPointDefinition, sortExpression, DomainObjectIDs.IndustrialSector1).ToArray();
_testHelper.VerifyAllExpectations();
}
public override IEnumerable <DataContainer> LoadDataContainersByRelatedID(RelationEndPointDefinition relationEndPointDefinition, SortExpressionDefinition sortExpressionDefinition, ObjectID relatedID)
{
throw new NotImplementedException();
}
public override IEnumerable <DataContainer> LoadDataContainersByRelatedID(RelationEndPointDefinition relationEndPointDefinition, SortExpressionDefinition sortExpressionDefinition, ObjectID relatedID)
{
if (InnerProvider != null)
{
return(InnerProvider.LoadDataContainersByRelatedID(relationEndPointDefinition, sortExpressionDefinition, relatedID));
}
else
{
return(null);
}
}
public abstract IEnumerable <DataContainer> LoadDataContainersByRelatedID(
RelationEndPointDefinition relationEndPointDefinition, SortExpressionDefinition sortExpressionDefinition, ObjectID relatedID);
