public async Task RangeWithLongSubtype()
{
if (IsMultiplexing)
{
Assert.Ignore("Multiplexing, ReloadTypes");
}
using var conn = await OpenConnectionAsync();
await conn.ExecuteNonQueryAsync("CREATE TYPE pg_temp.textrange AS RANGE(subtype=text)");
conn.ReloadTypes();
Assert.That(await conn.ExecuteScalarAsync("SELECT 1"), Is.EqualTo(1));
var value = new NpgsqlRange <string>(
new string('a', conn.Settings.WriteBufferSize + 10),
new string('z', conn.Settings.WriteBufferSize + 10)
);
//var value = new NpgsqlRange<string>("bar", "foo");
using var cmd = new NpgsqlCommand("SELECT @p", conn);
cmd.Parameters.Add(new NpgsqlParameter("p", NpgsqlDbType.Range | NpgsqlDbType.Text)
{
Value = value
});
using var reader = await cmd.ExecuteReaderAsync(CommandBehavior.SequentialAccess);
reader.Read();
Assert.That(reader[0], Is.EqualTo(value));
}
public static NpgsqlRange <T> ParseNpgsqlRange <T>(string s)
{
if (string.IsNullOrEmpty(s) || s == "empty")
{
return(NpgsqlRange <T> .Empty());
}
string s1 = s.Trim('(', ')', '[', ']');
string[] ss = s1.Split(new char[] { ',' }, 2);
if (ss.Length != 2)
{
return(NpgsqlRange <T> .Empty());
}
T t1 = default(T);
T t2 = default(T);
if (!string.IsNullOrEmpty(ss[0]))
{
t1 = (T)Convert.ChangeType(ss[0], typeof(T));
}
if (!string.IsNullOrEmpty(ss[1]))
{
t2 = (T)Convert.ChangeType(ss[1], typeof(T));
}
return(new NpgsqlRange <T>(t1, s[0] == '[', s[0] == '(', t2, s[s.Length - 1] == ']', s[s.Length - 1] == ')'));
}
void CleanupState()
{
_buf = null;
_value = default(NpgsqlRange <TElement>);
_fieldDescription = null;
_state = State.Done;
}
public void RangeWithLongSubtype()
{
using (var conn = OpenConnection())
{
conn.ExecuteNonQuery("CREATE TYPE pg_temp.textrange AS RANGE(subtype=text)");
conn.ReloadTypes();
Assert.That(conn.ExecuteScalar("SELECT 1"), Is.EqualTo(1));
var value = new NpgsqlRange <string>(
new string('a', conn.Settings.WriteBufferSize + 10),
new string('z', conn.Settings.WriteBufferSize + 10)
);
//var value = new NpgsqlRange<string>("bar", "foo");
using (var cmd = new NpgsqlCommand("SELECT @p", conn))
{
cmd.Parameters.Add(new NpgsqlParameter("p", NpgsqlDbType.Range | NpgsqlDbType.Text)
{
Value = value
});
using (var reader = cmd.ExecuteReader(CommandBehavior.SequentialAccess))
{
reader.Read();
Assert.That(reader[0], Is.EqualTo(value));
}
}
}
}
public void Roundtrip_DateTime_ranges_through_ToString_and_Parse(NpgsqlRange <DateTime> input)
{
var wellKnownText = input.ToString();
var result = NpgsqlRange <DateTime> .Parse(wellKnownText);
Assert.AreEqual(input, result);
}
public void TestNotContains()
{
var r = new NpgsqlRange <int>(1, 2);
Assert.False(NpgsqlRangeExtensions.Includes(r, 0));
Assert.False(NpgsqlRangeExtensions.Includes(r, 3));
}
public override void PrepareWrite(object value, WriteBuffer buf, LengthCache lengthCache, NpgsqlParameter parameter)
{
_writeBuf = buf;
_lengthCache = lengthCache;
_value = (NpgsqlRange <TElement>)value;
_state = State.Flags;
}
private protected int ValidateAndGetLength <TAny>(NpgsqlRange <TAny> value, ref NpgsqlLengthCache?lengthCache, NpgsqlParameter?parameter)
{
var totalLen = 1;
var lengthCachePos = lengthCache?.Position ?? 0;
if (!value.IsEmpty)
{
if (!value.LowerBoundInfinite)
{
totalLen += 4;
if (value.LowerBound is not null)
{
totalLen += _subtypeHandler.ValidateAndGetLength(value.LowerBound, ref lengthCache, null);
}
}
if (!value.UpperBoundInfinite)
{
totalLen += 4;
if (value.UpperBound is not null)
{
totalLen += _subtypeHandler.ValidateAndGetLength(value.UpperBound, ref lengthCache, null);
}
}
}
// If we're traversing an already-populated length cache, rewind to first element slot so that
// the elements' handlers can access their length cache values
if (lengthCache != null && lengthCache.IsPopulated)
{
lengthCache.Position = lengthCachePos;
}
return(totalLen);
}
public void PrepareWrite(object value, NpgsqlBuffer buf, LengthCache lengthCache, NpgsqlParameter parameter)
{
_buf = buf;
_lengthCache = lengthCache;
_value = (NpgsqlRange <TElement>)value;
_state = State.Start;
}
public void RangeEquality_FiniteRange()
{
var r1 = new NpgsqlRange <int>(0, true, false, 1, false, false);
//different bounds
var r2 = new NpgsqlRange <int>(1, true, false, 2, false, false);
Assert.IsFalse(r1 == r2);
//lower bound is not inclusive
var r3 = new NpgsqlRange <int>(0, false, false, 1, false, false);
Assert.IsFalse(r1 == r3);
//upper bound is inclusive
var r4 = new NpgsqlRange <int>(0, true, false, 1, true, false);
Assert.IsFalse(r1 == r4);
var r5 = new NpgsqlRange <int>(0, true, false, 1, false, false);
Assert.IsTrue(r1 == r5);
//check some other combinations while we are here
Assert.IsFalse(r2 == r3);
Assert.IsFalse(r2 == r4);
Assert.IsFalse(r3 == r4);
}
public void TestContainsEqual()
{
var r = new NpgsqlRange <int>(0, 1);
Assert.True(NpgsqlRangeExtensions.Includes(r, 1));
Assert.True(NpgsqlRangeExtensions.Includes(r, 0));
}
public override int ValidateAndGetLength(NpgsqlRange <TElement> value, ref NpgsqlLengthCache lengthCache, NpgsqlParameter parameter)
{
var totalLen = 1;
var lengthCachePos = lengthCache?.Position ?? 0;
if (!value.IsEmpty)
{
if (!value.LowerBoundInfinite)
{
totalLen += 4 + ElementHandler.ValidateAndGetLength(value.LowerBound, ref lengthCache, null);
}
if (!value.UpperBoundInfinite)
{
totalLen += 4 + ElementHandler.ValidateAndGetLength(value.UpperBound, ref lengthCache, null);
}
}
// If we're traversing an already-populated length cache, rewind to first element slot so that
// the elements' handlers can access their length cache values
if (lengthCache != null && lengthCache.IsPopulated)
{
lengthCache.Position = lengthCachePos;
}
return(totalLen);
}
public void Range()
{
var cmd = new NpgsqlCommand("SELECT @p1, @p2, @p3, @p4", Conn);
var p1 = new NpgsqlParameter("p1", NpgsqlDbType.Range | NpgsqlDbType.Integer)
{
Value = NpgsqlRange <int> .Empty()
};
var p2 = new NpgsqlParameter {
ParameterName = "p2", Value = new NpgsqlRange <int>(1, 10)
};
var p3 = new NpgsqlParameter {
ParameterName = "p3", Value = new NpgsqlRange <int>(1, false, 10, false)
};
var p4 = new NpgsqlParameter {
ParameterName = "p4", Value = new NpgsqlRange <int>(0, false, true, 10, false, false)
};
Assert.That(p2.NpgsqlDbType, Is.EqualTo(NpgsqlDbType.Range | NpgsqlDbType.Integer));
cmd.Parameters.Add(p1);
cmd.Parameters.Add(p2);
cmd.Parameters.Add(p3);
cmd.Parameters.Add(p4);
var reader = cmd.ExecuteReader();
reader.Read();
Assert.That(reader[0].ToString(), Is.EqualTo("empty"));
Assert.That(reader[1].ToString(), Is.EqualTo("[1,11)"));
Assert.That(reader[2].ToString(), Is.EqualTo("[2,10)"));
Assert.That(reader[3].ToString(), Is.EqualTo("(,10)"));
reader.Dispose();
cmd.Dispose();
}
public void GivenStringRangeLiteral_WhenParsed_ThenReturnsStringRange(string input, string normalized)
{
// Act
var result = NpgsqlRange <string> .Parse(input);
// Assert
Assert.AreEqual(normalized, result.ToString());
}
public void GivenPoorlyFormedNullableIntRangeLiteral_WhenParsed_ThenReturnsNullableIntRange(string input, string normalized)
{
// Act
var result = NpgsqlRange <int?> .Parse(input);
// Assert
Assert.AreEqual(normalized, result.ToString());
}
public void GivenEmptyIntRangeLiteral_WhenParsed_ThenReturnsEmptyIntRange(string value)
{
// Act
var result = NpgsqlRange <int> .Parse(value);
// Assert
Assert.AreEqual(NpgsqlRange <int> .Empty, result);
}
public Task Write(
NpgsqlRange <DateOnly> value,
NpgsqlWriteBuffer buf,
NpgsqlLengthCache?lengthCache,
NpgsqlParameter?parameter,
bool async,
CancellationToken cancellationToken = default)
=> WriteRange(value, buf, lengthCache, parameter, async, cancellationToken);
public void GivenSimpleTypeRangeLiteral_WhenParsed_ThenReturnsSimpleTypeRange(string input)
{
// Act
var result = NpgsqlRange <SimpleType> .Parse(input);
// Assert
Assert.AreEqual(input, result.ToString());
}
public void GivenIntRangeLiteral_WhenParsed_ThenReturnsIntRange(string input)
{
// Act
var result = NpgsqlRange <int> .Parse(input);
// Assert
Assert.AreEqual(input.Replace(" ", null), result.ToString());
}
public void RangeNotContainedByRange(NpgsqlRange <int> range)
{
using var context = CreateContext();
var _ = context.RangeTestEntities
.Where(x => !range.ContainedBy(x.Range))
.ToArray();
AssertContainsSql(@"WHERE NOT (@__range_0 <@ r.""Range"")");
}
public void UserDefinedSchemaQualified()
{
using var context = CreateContext();
var e = context.RangeTestEntities.Single(x => x.SchemaRange == NpgsqlRange <double> .Parse("(0,10)"));
AssertContainsSql(@"WHERE r.""SchemaRange"" = '(0,10)'::test.""Schema_Range""");
Assert.Equal(0, e.SchemaRange.LowerBound);
Assert.Equal(10, e.SchemaRange.UpperBound);
}
public void RangeDoesNotContainRange(NpgsqlRange <int> range)
{
using var context = CreateContext();
var _ = context.RangeTestEntities
.Where(x => !x.Range.Contains(range))
.ToArray();
AssertContainsSql(@"WHERE NOT (r.""Range"" @> @__range_0)");
}
public void RangeIsNotAdjacentToRange(NpgsqlRange <int> range)
{
using var context = CreateContext();
var _ = context.RangeTestEntities
.Where(x => !x.Range.IsAdjacentTo(range))
.ToArray();
AssertContainsSql(@"WHERE NOT (r.""Range"" -|- @__range_0)");
}
public void RangeIntersectsRange(NpgsqlRange <int> range)
{
using var context = CreateContext();
var _ = context.RangeTestEntities
.Select(x => x.Range.Intersect(range))
.ToArray();
AssertContainsSql(@"r.""Range"" * @__range_0");
}
public void RangeIsNotStrictlyRightOfRange(NpgsqlRange <int> range)
{
using var context = CreateContext();
var _ = context.RangeTestEntities
.Where(x => !x.Range.IsStrictlyRightOf(range))
.ToArray();
AssertContainsSql(@"WHERE NOT (r.""Range"" >> @__range_0)");
}
public void RangeDoesNotExtendRightOfRange(NpgsqlRange <int> range)
{
using var context = CreateContext();
var _ = context.RangeTestEntities
.Where(x => x.Range.DoesNotExtendRightOf(range))
.ToArray();
AssertContainsSql(@"r.""Range"" &< @__range_0");
}
public void RangeIsStrictlyLeftOfRange(NpgsqlRange <int> range)
{
using var context = CreateContext();
var _ = context.RangeTestEntities
.Where(x => x.Range.IsStrictlyLeftOf(range))
.ToArray();
AssertContainsSql(@"r.""Range"" << @__range_0");
}
public void RangeOverlapsRange(NpgsqlRange <int> range)
{
using var context = CreateContext();
var _ = context.RangeTestEntities
.Where(x => x.Range.Overlaps(range))
.ToArray();
AssertContainsSql(@"r.""Range"" && @__range_0");
}
public void RangeDoesNotEqualsRange_Method(NpgsqlRange <int> range)
{
using var context = CreateContext();
var _ = context.RangeTestEntities
.Where(x => !x.Range.Equals(range))
.ToArray();
AssertContainsSql(@"r.""Range"" <> @__range_0");
}
public void RangeEqualsRange_Operator(NpgsqlRange <int> range)
{
using var context = CreateContext();
var _ = context.RangeTestEntities
.Where(x => x.Range == range)
.ToArray();
AssertContainsSql(@"r.""Range"" = @__range_0");
}
public void RangeWithLongSubtype()
{
ExecuteNonQuery("CREATE TYPE pg_temp.textrange AS RANGE(subtype=text)");
Conn.ReloadTypes();
Assert.That(ExecuteScalar("SELECT 1"), Is.EqualTo(1));
var value = new NpgsqlRange<string>(
new string('a', Conn.BufferSize + 10),
new string('z', Conn.BufferSize + 10)
);
//var value = new NpgsqlRange<string>("bar", "foo");
using (var cmd = new NpgsqlCommand("SELECT @p", Conn))
{
cmd.Parameters.Add(new NpgsqlParameter("p", NpgsqlDbType.Range | NpgsqlDbType.Text) { Value = value });
using (var reader = cmd.ExecuteReader(CommandBehavior.SequentialAccess))
{
reader.Read();
Assert.That(reader[0], Is.EqualTo(value));
}
}
}
