public void SplitValuesForComparison()
{
var dateTime1 = new DateTime(2011, 7, 18);
var dateTime2 = new DateTime(2012, 8, 19);
var row1 = new ColumnValueTable.Row(new object[] { "2011" });
var row2 = new ColumnValueTable.Row(new object[] { "2012" });
var row3 = new ColumnValueTable.Row(new object[] { "7" });
var row4 = new ColumnValueTable.Row(new object[] { "8" });
var row5 = new ColumnValueTable.Row(new object[] { "18" });
var row6 = new ColumnValueTable.Row(new object[] { "19" });
_property1Stub
.Stub(stub => stub.SplitValuesForComparison(Arg <IEnumerable <object> > .List.Equal(new object[] { 2011, 2012 })))
.Return(new ColumnValueTable(new[] { _columnDefinition1 }, new[] { row1, row2 }));
_property2Stub
.Stub(stub => stub.SplitValuesForComparison(Arg <IEnumerable <object> > .List.Equal(new object[] { 7, 8 })))
.Return(new ColumnValueTable(new[] { _columnDefinition2 }, new[] { row3, row4 }));
_property3Stub
.Stub(stub => stub.SplitValuesForComparison(Arg <IEnumerable <object> > .List.Equal(new object[] { 18, 19 })))
.Return(new ColumnValueTable(new[] { _columnDefinition3 }, new[] { row5, row6 }));
var result = _compoundStoragePropertyDefinition.SplitValuesForComparison(new object[] { dateTime1, dateTime2 });
var expectedTable = new ColumnValueTable(
new[] { _columnDefinition1, _columnDefinition2, _columnDefinition3 },
new[]
{
new ColumnValueTable.Row(new object[] { "2011", "7", "18" }),
new ColumnValueTable.Row(new object[] { "2012", "8", "19" })
});
ColumnValueTableTestHelper.CheckTable(expectedTable, result);
}
public void Combine_Two()
{
var column1 = ColumnDefinitionObjectMother.CreateColumn("1");
var column2 = ColumnDefinitionObjectMother.CreateColumn("2");
var column3 = ColumnDefinitionObjectMother.CreateColumn("3");
var column4 = ColumnDefinitionObjectMother.CreateColumn("4");
var one = new ColumnValueTable(
new[] { column1, column2 },
new[]
{
new ColumnValueTable.Row(new[] { "a", "b" }),
new ColumnValueTable.Row(new[] { "c", "d" })
});
var two = new ColumnValueTable(
new[] { column3, column4 },
new[]
{
new ColumnValueTable.Row(new[] { "e", "f" }),
new ColumnValueTable.Row(new[] { "g", "h" })
});
var result = ColumnValueTable.Combine(one, two);
var expected = new ColumnValueTable(
new[] { column1, column2, column3, column4 },
new[]
{
new ColumnValueTable.Row(new[] { "a", "b", "e", "f" }),
new ColumnValueTable.Row(new[] { "c", "d", "g", "h" })
});
ColumnValueTableTestHelper.CheckTable(expected, result);
}
public static void CheckTable(ColumnValueTable expectedTable, ColumnValueTable actualTable)
{
Assert.That(actualTable.Columns, Is.EqualTo(expectedTable.Columns));
var actualRows = actualTable.Rows.ToArray();
var expectedRows = expectedTable.Rows.ToArray();
Assert.That(actualRows.Length, Is.EqualTo(expectedRows.Length));
for (int i = 0; i < expectedRows.Length; ++i)
{
Assert.That(actualRows[i].Values, Is.EqualTo(expectedRows[i].Values));
}
}
public void SplitValuesForComparison()
{
var row1 = new ColumnValueTable.Row(new[] { "1" });
var row2 = new ColumnValueTable.Row(new[] { "2" });
var columnValueTable = new ColumnValueTable(new[] { _columnDefinition }, new[] { row1, row2 });
_serializedIDPropertyStub
.Stub(stub => stub.SplitValuesForComparison(Arg <IEnumerable <object> > .List.Equal(
new[] { DomainObjectIDs.Order1.ToString(), DomainObjectIDs.Order3.ToString() })))
.Return(columnValueTable);
var result = _serializedObjectIDStoragePropertyDefinition.SplitValuesForComparison(new object[] { DomainObjectIDs.Order1, DomainObjectIDs.Order3 });
ColumnValueTableTestHelper.CheckTable(columnValueTable, result);
}
public void SplitValuesForComparison_NullValue()
{
var row1 = new ColumnValueTable.Row(new[] { "1" });
var row2 = new ColumnValueTable.Row(new[] { "2" });
var columnValueTable = new ColumnValueTable(new[] { _columnDefinition }, new[] { row1, row2 });
// Bug in Rhino Mocks: List.Equal constraint cannot handle nulls within the sequence
_serializedIDPropertyStub
.Stub(stub => stub.SplitValuesForComparison(
Arg <IEnumerable <object> > .Matches(seq => seq.SequenceEqual(new[] { null, DomainObjectIDs.Order3.ToString() }))))
.Return(columnValueTable);
var result = _serializedObjectIDStoragePropertyDefinition.SplitValuesForComparison(new object[] { null, DomainObjectIDs.Order3 });
ColumnValueTableTestHelper.CheckTable(columnValueTable, result);
}
public void SplitValuesForComparison_NullValue()
{
var value2 = new object();
var result = _storagePropertyDefinition.SplitValuesForComparison(new[] { null, value2 });
var expectedTable = new ColumnValueTable(
new[] { _innerColumnDefinition },
new[]
{
new ColumnValueTable.Row(new object[] { null }),
new ColumnValueTable.Row(new[] { value2 })
});
ColumnValueTableTestHelper.CheckTable(expectedTable, result);
}
public static bool AreEqual(ColumnValueTable t1, ColumnValueTable t2)
{
if (!t1.Columns.SequenceEqual(t2.Columns))
{
return(false);
}
var rows1 = t2.Rows.ToArray();
var rows2 = t1.Rows.ToArray();
if (rows1.Length != rows2.Length)
{
return(false);
}
return(rows2.Zip(rows1).All(t => t.Item1.Values.SequenceEqual(t.Item2.Values)));
}
public void CreateForSelect_Table_MultiValueLookup_MoreThanOneColumn()
{
var columnValueTable = new ColumnValueTable(
new[] { _column1, _column2 },
new[]
{
new ColumnValueTable.Row(new object[] { 12, 14 }),
new ColumnValueTable.Row(new object[] { 13, 15 }),
}
);
Assert.That(
() => _factory.CreateForSelect(_tableDefinition, new[] { _column1, _column2 }, columnValueTable, new[] { _orderColumn1, _orderColumn2 }),
Throws.TypeOf <NotSupportedException> ()
.With.Message.EqualTo("The SQL provider can only handle multi-value comparisons with a single ColumnDefinition.")
.And.InnerException.TypeOf <InvalidOperationException>());
}
public void Combine_Many()
{
var column1 = ColumnDefinitionObjectMother.CreateColumn("1");
var column2 = ColumnDefinitionObjectMother.CreateColumn("2");
var column3 = ColumnDefinitionObjectMother.CreateColumn("3");
var column4 = ColumnDefinitionObjectMother.CreateColumn("4");
var column5 = ColumnDefinitionObjectMother.CreateColumn("5");
var column6 = ColumnDefinitionObjectMother.CreateColumn("6");
var one = new ColumnValueTable(
new[] { column1, column2 },
new[]
{
new ColumnValueTable.Row(new[] { "a", "b" }),
new ColumnValueTable.Row(new[] { "c", "d" })
});
var two = new ColumnValueTable(
new[] { column3, column4 },
new[]
{
new ColumnValueTable.Row(new[] { "e", "f" }),
new ColumnValueTable.Row(new[] { "g", "h" })
});
var three = new ColumnValueTable(
new[] { column5, column6 },
new[]
{
new ColumnValueTable.Row(new[] { "i", "j" }),
new ColumnValueTable.Row(new[] { "k", "l" })
});
var result = ColumnValueTable.Combine(new[] { one, two, three });
var expected = new ColumnValueTable(
new[] { column1, column2, column3, column4, column5, column6 },
new[]
{
new ColumnValueTable.Row(new[] { "a", "b", "e", "f", "i", "j" }),
new ColumnValueTable.Row(new[] { "c", "d", "g", "h", "k", "l" })
});
ColumnValueTableTestHelper.CheckTable(expected, result);
}
public IDbCommandBuilder CreateForSelect(
TableDefinition table,
IEnumerable <ColumnDefinition> selectedColumns,
ColumnValueTable comparedColumnValueTable,
IEnumerable <OrderedColumn> orderedColumns)
{
ArgumentUtility.CheckNotNull("table", table);
ArgumentUtility.CheckNotNull("selectedColumns", selectedColumns);
ArgumentUtility.CheckNotNull("orderedColumns", orderedColumns);
var comparedValues = GetValuesForSingleColumnDefinition(comparedColumnValueTable);
return(new SelectDbCommandBuilder(
table,
new SelectedColumnsSpecification(selectedColumns),
new SqlXmlSetComparedColumnSpecification(comparedValues.Item1, comparedValues.Item2),
new OrderedColumnsSpecification(orderedColumns),
_sqlDialect));
}
public void CreateForSelect_Table_MultiValueLookup()
{
var columnValueTable = new ColumnValueTable(
new[] { _column1 },
new[]
{
new ColumnValueTable.Row(new object[] { 12 }),
new ColumnValueTable.Row(new object[] { 13 }),
}
);
var result = _factory.CreateForSelect(_tableDefinition, new[] { _column1, _column2 }, columnValueTable, new[] { _orderColumn1, _orderColumn2 });
Assert.That(result, Is.TypeOf(typeof(SelectDbCommandBuilder)));
var dbCommandBuilder = (SelectDbCommandBuilder)result;
Assert.That(dbCommandBuilder.Table, Is.SameAs(_tableDefinition));
Assert.That(((SelectedColumnsSpecification)dbCommandBuilder.SelectedColumns).SelectedColumns, Is.EqualTo(new[] { _column1, _column2 }));
Assert.That(((SqlXmlSetComparedColumnSpecification)dbCommandBuilder.ComparedColumns).ColumnDefinition, Is.SameAs(_column1));
Assert.That(((SqlXmlSetComparedColumnSpecification)dbCommandBuilder.ComparedColumns).ObjectValues, Is.EqualTo(new[] { 12, 13 }));
Assert.That(((OrderedColumnsSpecification)dbCommandBuilder.OrderedColumns).Columns, Is.EqualTo(new[] { _orderColumn1, _orderColumn2 }));
}
private Tuple <ColumnDefinition, IEnumerable <object> > GetValuesForSingleColumnDefinition(ColumnValueTable comparedColumnValueTable)
{
ColumnDefinition singleColumn;
try
{
singleColumn = comparedColumnValueTable.Columns.Single();
}
catch (InvalidOperationException ex)
{
throw new NotSupportedException("The SQL provider can only handle multi-value comparisons with a single ColumnDefinition.", ex);
}
// We assume that the Single below can never throw when the Single above didn't throw. (Otherwise, the ColumnValueTable wouldn't be correct.)
var values = comparedColumnValueTable.Rows.Select(r => r.Values.Single());
return(Tuple.Create(singleColumn, values));
}
public void CreateForMultiTimestampLookup()
{
var expectedSelectedColumns1 =
new[]
{
StoragePropertyDefinitionTestHelper.GetIDColumnDefinition(_tableDefinition1.ObjectIDProperty),
StoragePropertyDefinitionTestHelper.GetClassIDColumnDefinition(_tableDefinition1.ObjectIDProperty),
StoragePropertyDefinitionTestHelper.GetSingleColumn(_tableDefinition1.TimestampProperty)
};
var expectedComparedColumns1 = new ColumnValueTable(
new[] { StoragePropertyDefinitionTestHelper.GetIDColumnDefinition(_tableDefinition1.ObjectIDProperty) },
new[]
{
new ColumnValueTable.Row(new[] { _objectID1.Value }),
new ColumnValueTable.Row(new[] { _objectID2.Value }),
});
_dbCommandBuilderFactoryStrictMock
.Expect(
mock => mock.CreateForSelect(
Arg.Is(_tableDefinition1),
Arg <IEnumerable <ColumnDefinition> > .List.Equal(expectedSelectedColumns1),
Arg <ColumnValueTable> .Matches(t => ColumnValueTableTestHelper.AreEqual(expectedComparedColumns1, t)),
Arg <IEnumerable <OrderedColumn> > .List.Equal(new OrderedColumn[0])))
.Return(_dbCommandBuilder1Stub);
var expectedSelectedColumns2 =
new[]
{
StoragePropertyDefinitionTestHelper.GetIDColumnDefinition(_tableDefinition2.ObjectIDProperty),
StoragePropertyDefinitionTestHelper.GetClassIDColumnDefinition(_tableDefinition2.ObjectIDProperty),
StoragePropertyDefinitionTestHelper.GetSingleColumn(_tableDefinition2.TimestampProperty)
};
var expectedComparedColumns2 =
new[] { new ColumnValue(StoragePropertyDefinitionTestHelper.GetIDColumnDefinition(_tableDefinition2.ObjectIDProperty), _objectID3.Value) };
_dbCommandBuilderFactoryStrictMock
.Expect(
mock => mock.CreateForSelect(
Arg.Is(_tableDefinition2),
Arg <IEnumerable <ColumnDefinition> > .List.Equal(expectedSelectedColumns2),
Arg <IEnumerable <ColumnValue> > .List.Equal(expectedComparedColumns2),
Arg <IEnumerable <OrderedColumn> > .List.Equal(new OrderedColumn[0])))
.Return(_dbCommandBuilder2Stub);
_dbCommandBuilderFactoryStrictMock.Replay();
_objectReaderFactoryStrictMock
.Expect(
mock => mock.CreateTimestampReader(
Arg.Is(_tableDefinition1),
Arg <IEnumerable <ColumnDefinition> > .List.Equal(expectedSelectedColumns1)))
.Return(_timestampReader1Stub);
_objectReaderFactoryStrictMock
.Expect(
mock => mock.CreateTimestampReader(
Arg.Is(_tableDefinition2),
Arg <IEnumerable <ColumnDefinition> > .List.Equal(expectedSelectedColumns2)))
.Return(_timestampReader2Stub);
_objectReaderFactoryStrictMock.Replay();
var result = _factory.CreateForMultiTimestampLookup(new[] { _objectID1, _objectID2, _objectID3 });
_objectReaderFactoryStrictMock.VerifyAllExpectations();
_dbCommandBuilderFactoryStrictMock.VerifyAllExpectations();
var innerCommand =
CheckDelegateBasedCommandAndReturnInnerCommand <IEnumerable <Tuple <ObjectID, object> >, IEnumerable <ObjectLookupResult <object> > > (result);
Assert.That(innerCommand, Is.TypeOf(typeof(MultiObjectLoadCommand <Tuple <ObjectID, object> >)));
var commandBuildersAndReaders = ((MultiObjectLoadCommand <Tuple <ObjectID, object> >)innerCommand).DbCommandBuildersAndReaders;
Assert.That(commandBuildersAndReaders.Length, Is.EqualTo(2));
Assert.That(commandBuildersAndReaders[0].Item1, Is.SameAs(_dbCommandBuilder1Stub));
Assert.That(commandBuildersAndReaders[0].Item2, Is.SameAs(_timestampReader1Stub));
Assert.That(commandBuildersAndReaders[1].Item1, Is.SameAs(_dbCommandBuilder2Stub));
Assert.That(commandBuildersAndReaders[1].Item2, Is.SameAs(_timestampReader2Stub));
}
public void CreateForSortedMultiIDLookup_TableDefinition_MultipleIDLookup_AndMultipleTables()
{
var expectedSelectedColumns1 = _tableDefinition1.GetAllColumns();
var expectedComparedColumns1 = new ColumnValueTable(
new[] { StoragePropertyDefinitionTestHelper.GetIDColumnDefinition(_tableDefinition1.ObjectIDProperty) },
new[]
{
new ColumnValueTable.Row(new[] { _objectID1.Value }),
new ColumnValueTable.Row(new[] { _objectID2.Value }),
});
_dbCommandBuilderFactoryStrictMock
.Expect(
stub => stub.CreateForSelect(
Arg.Is(_tableDefinition1),
Arg <IEnumerable <ColumnDefinition> > .List.Equal(expectedSelectedColumns1),
Arg <ColumnValueTable> .Matches(t => ColumnValueTableTestHelper.AreEqual(expectedComparedColumns1, t)),
Arg <IEnumerable <OrderedColumn> > .List.Equal(new OrderedColumn[0])))
.Return(_dbCommandBuilder1Stub);
var expectedSelectedColumns2 = _tableDefinition2.GetAllColumns();
var expectedComparedColumns2 =
new[] { new ColumnValue(StoragePropertyDefinitionTestHelper.GetIDColumnDefinition(_tableDefinition2.ObjectIDProperty), _objectID3.Value) };
_dbCommandBuilderFactoryStrictMock
.Expect(
stub => stub.CreateForSelect(
Arg.Is(_tableDefinition2),
Arg <IEnumerable <ColumnDefinition> > .List.Equal(_tableDefinition2.GetAllColumns()),
Arg <IEnumerable <ColumnValue> > .List.Equal(expectedComparedColumns2),
Arg <IEnumerable <OrderedColumn> > .List.Equal(new OrderedColumn[0])))
.Return(_dbCommandBuilder2Stub);
_dbCommandBuilderFactoryStrictMock.Replay();
_objectReaderFactoryStrictMock
.Expect(
mock => mock.CreateDataContainerReader(
Arg.Is((IRdbmsStorageEntityDefinition)_tableDefinition1),
Arg <IEnumerable <ColumnDefinition> > .List.Equal(expectedSelectedColumns1)))
.Return(_dataContainerReader1Stub);
_objectReaderFactoryStrictMock
.Expect(
mock => mock.CreateDataContainerReader(
Arg.Is((IRdbmsStorageEntityDefinition)_tableDefinition2),
Arg <IEnumerable <ColumnDefinition> > .List.Equal(expectedSelectedColumns2)))
.Return(_dataContainerReader2Stub);
_objectReaderFactoryStrictMock.Replay();
var result = _factory.CreateForSortedMultiIDLookup(new[] { _objectID1, _objectID2, _objectID3 });
_objectReaderFactoryStrictMock.VerifyAllExpectations();
_dbCommandBuilderFactoryStrictMock.VerifyAllExpectations();
Assert.That(result, Is.TypeOf(typeof(MultiDataContainerAssociateWithIDsCommand)));
Assert.That(((MultiDataContainerAssociateWithIDsCommand)result).Command, Is.TypeOf(typeof(MultiObjectLoadCommand <DataContainer>)));
var dbCommandBuilderTuples =
((MultiObjectLoadCommand <DataContainer>)((MultiDataContainerAssociateWithIDsCommand)result).Command).DbCommandBuildersAndReaders;
Assert.That(dbCommandBuilderTuples.Length, Is.EqualTo(2));
// Convert to Dictionary because the order of tuples is not defined
var dbCommandBuilderDictionary = dbCommandBuilderTuples.ToDictionary(tuple => tuple.Item1, tuple => tuple.Item2);
Assert.That(dbCommandBuilderDictionary.ContainsKey(_dbCommandBuilder1Stub), Is.True);
Assert.That(dbCommandBuilderDictionary[_dbCommandBuilder1Stub], Is.SameAs(_dataContainerReader1Stub));
Assert.That(dbCommandBuilderDictionary.ContainsKey(_dbCommandBuilder2Stub), Is.True);
Assert.That(dbCommandBuilderDictionary[_dbCommandBuilder2Stub], Is.SameAs(_dataContainerReader2Stub));
}
