ashapkin commented on code in PR #1460:
URL: https://github.com/apache/ignite-3/pull/1460#discussion_r1054564621
##########
modules/platforms/dotnet/Apache.Ignite.Tests/Proto/BinaryTuple/BinaryTupleTests.cs:
##########
@@ -645,6 +645,120 @@ public void TestDefault()
Assert.AreEqual(default(LocalDateTime), reader.GetDateTime(0));
}
+ [Test]
+ public void TestGetNullable()
+ {
+ var reader = BuildAndRead((ref BinaryTupleBuilder b) =>
b.AppendNull());
+
+ Assert.IsNull(reader.GetIntNullable(0));
+ Assert.IsNull(reader.GetByteNullable(0));
+ Assert.IsNull(reader.GetShortNullable(0));
+ Assert.IsNull(reader.GetLongNullable(0));
+ Assert.IsNull(reader.GetDoubleNullable(0));
+ Assert.IsNull(reader.GetFloatNullable(0));
+ Assert.IsNull(reader.GetDecimalNullable(0, 123));
+ Assert.IsNull(reader.GetNumberNullable(0));
+ Assert.IsNull(reader.GetStringNullable(0));
+ Assert.IsNull(reader.GetBitmaskNullable(0));
+ Assert.IsNull(reader.GetGuidNullable(0));
+ Assert.IsNull(reader.GetBytesNullable(0));
+ Assert.IsNull(reader.GetDurationNullable(0));
+ Assert.IsNull(reader.GetPeriodNullable(0));
+ Assert.IsNull(reader.GetTimeNullable(0));
+ Assert.IsNull(reader.GetDateNullable(0));
+ Assert.IsNull(reader.GetDateTimeNullable(0));
+ }
+
+ [Test]
+ public void TestAppendNullable()
+ {
+ var guid = Guid.NewGuid();
Review Comment:
Minor
Personally I like having all the values defined in advance, but here you are
mixing some if them with raw literals. For Guid could be Guid.Empty, for
DateTime -> MaxVal, etc.
##########
modules/platforms/dotnet/Apache.Ignite.Tests/Linq/LinqTests.cs:
##########
@@ -501,6 +522,102 @@ public void
TestSelectDecimalIntoUserDefinedTypeUsesCorrectScale()
Assert.AreEqual(9.0m, res[0].Val);
}
+ [Test]
+ public void TestSelectAllColumnTypes()
+ {
+ var res = PocoAllColumnsSqlView.AsQueryable()
+ .OrderBy(x => x.Key)
+ .Take(3)
+ .ToList();
+
+ Assert.AreEqual(0, res[0].Key);
+ Assert.AreEqual(1, res[0].Int8);
+ Assert.AreEqual(2, res[0].Int16);
+ Assert.AreEqual(3, res[0].Int32);
+ Assert.AreEqual(4, res[0].Int64);
+ Assert.AreEqual(5.5f, res[0].Float);
+ Assert.AreEqual(6.5, res[0].Double);
+ Assert.AreEqual(7.7, res[0].Decimal);
+ Assert.AreEqual(new LocalDate(2022, 12, 1), res[0].Date);
+ Assert.AreEqual(new LocalTime(11, 38, 1), res[0].Time);
+ Assert.AreEqual(new LocalDateTime(2022, 12, 19, 11, 1),
res[0].DateTime);
+ Assert.AreEqual(Instant.FromUnixTimeSeconds(1), res[0].Timestamp);
+ Assert.AreEqual(new byte[] { 1, 2 }, res[0].Blob);
+ }
+
+ [Test]
+ public void TestSelectAllColumnTypesNullable()
+ {
+ var res = PocoAllColumnsSqlNullableView.AsQueryable()
+ .OrderBy(x => x.Key)
+ .ToList();
+
+ Assert.AreEqual(0, res[0].Key);
+ Assert.AreEqual(1, res[0].Int8);
+ Assert.AreEqual(2, res[0].Int16);
+ Assert.AreEqual(3, res[0].Int32);
+ Assert.AreEqual(4, res[0].Int64);
+ Assert.AreEqual(5.5f, res[0].Float);
+ Assert.AreEqual(6.5, res[0].Double);
+ Assert.AreEqual(7.7, res[0].Decimal);
+ Assert.AreEqual(new LocalDate(2022, 12, 1), res[0].Date);
+ Assert.AreEqual(new LocalTime(11, 38, 1), res[0].Time);
+ Assert.AreEqual(new LocalDateTime(2022, 12, 19, 11, 1),
res[0].DateTime);
+ Assert.AreEqual(Instant.FromUnixTimeSeconds(1), res[0].Timestamp);
+ Assert.AreEqual(new byte[] { 1, 2 }, res[0].Blob);
+ }
+
+ [Test]
+ public void TestSelectAllColumnTypesNullableNull()
+ {
+ var res = PocoAllColumnsSqlNullableView.AsQueryable()
+ .OrderByDescending(x => x.Key)
+ .ToList();
+
+ Assert.AreEqual(100, res[0].Key);
+ Assert.IsNull(res[0].Str);
+ Assert.IsNull(res[0].Int8);
+ Assert.IsNull(res[0].Int16);
+ Assert.IsNull(res[0].Int32);
+ Assert.IsNull(res[0].Int64);
+ Assert.IsNull(res[0].Float);
+ Assert.IsNull(res[0].Double);
+ Assert.IsNull(res[0].Decimal);
+ Assert.IsNull(res[0].Date);
+ Assert.IsNull(res[0].Time);
+ Assert.IsNull(res[0].DateTime);
+ Assert.IsNull(res[0].Timestamp);
+ Assert.IsNull(res[0].Blob);
+ }
+
+ [Test]
+ public void TestWhereNull()
+ {
+ var query = PocoAllColumnsSqlNullableView.AsQueryable()
+ .Where(x => x.Int8 == null);
+
+ StringAssert.Contains("where (_T0.INT8 IS NOT DISTINCT FROM ?)",
query.ToString());
+
+ var res = query.ToList();
+
+ Assert.AreEqual(100, res[0].Key);
+ Assert.AreEqual(1, res.Count);
+ }
+
+ [Test]
+ public void TestWhereNotNull()
+ {
+ var query = PocoAllColumnsSqlNullableView.AsQueryable()
+ .Where(x => x.Int8 != null)
+ .OrderBy(x => x.Key);
+
+ StringAssert.Contains("where (_T0.INT8 IS DISTINCT FROM ?)",
query.ToString());
+
+ var res = query.ToList();
Review Comment:
Add another constraint? check that there are 10 items?
##########
modules/platforms/dotnet/Apache.Ignite/Internal/Proto/BinaryTuple/BinaryTupleBuilder.cs:
##########
@@ -280,6 +344,22 @@ public void AppendFloat(float value)
OnWrite();
}
+ /// <summary>
+ /// Appends a gloat.
+ /// </summary>
+ /// <param name="value">Value.</param>
+ public void AppendFloatNullable(float? value)
Review Comment:
Just curious, why woudn't we go with method overloading rather than having a
separate naming? I.e. AppendFloat(float? value)?
To make it in sync with Get* methods? Like GetFloatNullable?
##########
modules/platforms/dotnet/Apache.Ignite.Tests/Linq/LinqTests.Aggregate.cs:
##########
@@ -156,4 +158,39 @@ public void TestAny()
// Additional Where.
Assert.IsFalse(PocoView.AsQueryable().Where(x => x.Key > 7).Any(x =>
x.Key < 5));
}
+
+ [Test]
+ public void TestAggregateNullableDouble()
+ {
+ var query = PocoAllColumnsSqlNullableView.AsQueryable();
+
+ double? sumNotNull = query.Sum(x => x.Double);
+ double? sumNull = query.Where(x => x.Double == null).Sum(x =>
x.Double);
+
+ Assert.AreEqual(110d, sumNotNull);
+ Assert.IsNull(sumNull);
+ }
+
+ [Test]
+ public void TestAggregateNullableAllTypes()
+ {
+ Test(q => q.Sum(x => x.Int8));
+ Test(q => q.Sum(x => x.Int16));
+ Test(q => q.Sum(x => x.Int32));
+ Test(q => q.Sum(x => x.Int64));
+ Test(q => q.Sum(x => x.Float));
+ Test(q => q.Sum(x => x.Double));
+ Test(q => q.Sum(x => x.Decimal));
+
+ void Test<T>(Func<IQueryable<PocoAllColumnsSqlNullable>, T> sumFunc)
+ {
+ var query = PocoAllColumnsSqlNullableView.AsQueryable();
+
+ var sumNotNull = sumFunc(query);
+ var sumNull = sumFunc(query.Where(x => x.Double == null));
Review Comment:
Looks a bit weird, probably we should yield a separate test explicitly
testing for summing nullable values.
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: [email protected]
For queries about this service, please contact Infrastructure at:
[email protected]
