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)); }