diff --git a/src/EFCore.PG/NpgsqlRangeExtensions.cs b/src/EFCore.PG/NpgsqlRangeExtensions.cs
new file mode 100644
index 000000000..d50b555bf
--- /dev/null
+++ b/src/EFCore.PG/NpgsqlRangeExtensions.cs
@@ -0,0 +1,168 @@
+#region License
+
+// The PostgreSQL License
+//
+// Copyright (C) 2016 The Npgsql Development Team
+//
+// Permission to use, copy, modify, and distribute this software and its
+// documentation for any purpose, without fee, and without a written
+// agreement is hereby granted, provided that the above copyright notice
+// and this paragraph and the following two paragraphs appear in all copies.
+//
+// IN NO EVENT SHALL THE NPGSQL DEVELOPMENT TEAM BE LIABLE TO ANY PARTY
+// FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES,
+// INCLUDING LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS
+// DOCUMENTATION, EVEN IF THE NPGSQL DEVELOPMENT TEAM HAS BEEN ADVISED OF
+// THE POSSIBILITY OF SUCH DAMAGE.
+//
+// THE NPGSQL DEVELOPMENT TEAM SPECIFICALLY DISCLAIMS ANY WARRANTIES,
+// INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+// AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS
+// ON AN "AS IS" BASIS, AND THE NPGSQL DEVELOPMENT TEAM HAS NO OBLIGATIONS
+// TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
+
+#endregion
+
+using System;
+using NpgsqlTypes;
+
+namespace Npgsql.EntityFrameworkCore.PostgreSQL
+{
+    /// <summary>
+    /// Provides extension methods for <see cref="NpgsqlRange{T}"/> supporting PostgreSQL translation.
+    /// </summary>
+    public static class NpgsqlRangeExtensions
+    {
+        /// <summary>
+        /// Determines whether a range contains a specified value.
+        /// </summary>
+        /// <param name="range">The range in which to locate the value.</param>
+        /// <param name="value">The value to locate in the range.</param>
+        /// <typeparam name="T">The type of the elements of <paramref name="range"/>.</typeparam>
+        /// <returns>
+        /// <value>true</value> if the range contains the specified value; otherwise, <value>false</value>.
+        /// </returns>
+        public static bool Contains<T>(this NpgsqlRange<T> range, T value) where T : IComparable<T> => throw new NotSupportedException();
+
+        /// <summary>
+        /// Determines whether a range contains a specified range.
+        /// </summary>
+        /// <param name="a">The range in which to locate the specified range.</param>
+        /// <param name="b">The specified range to locate in the range.</param>
+        /// <typeparam name="T">The type of the elements of <paramref name="a"/>.</typeparam>
+        /// <returns>
+        /// <value>true</value> if the range contains the specified range; otherwise, <value>false</value>.
+        /// </returns>
+        public static bool Contains<T>(this NpgsqlRange<T> a, NpgsqlRange<T> b) where T : IComparable<T> => throw new NotSupportedException();
+
+        /// <summary>
+        /// Determines whether a range is contained by a specified range.
+        /// </summary>
+        /// <param name="a">The specified range to locate in the range.</param>
+        /// <param name="b">The range in which to locate the specified range.</param>
+        /// <typeparam name="T">The type of the elements of <paramref name="a"/>.</typeparam>
+        /// <returns>
+        /// <value>true</value> if the range contains the specified range; otherwise, <value>false</value>.
+        /// </returns>
+        public static bool ContainedBy<T>(this NpgsqlRange<T> a, NpgsqlRange<T> b) where T : IComparable<T> => b.Contains(a);
+
+        /// <summary>
+        /// Determines whether a range overlaps another range.
+        /// </summary>
+        /// <param name="a">The first range.</param>
+        /// <param name="b">The second range.</param>
+        /// <typeparam name="T">The type of the elements of <paramref name="a"/>.</typeparam>
+        /// <returns>
+        /// <value>true</value> if the ranges overlap (share points in common); otherwise, <value>false</value>.
+        /// </returns>
+        public static bool Overlaps<T>(this NpgsqlRange<T> a, NpgsqlRange<T> b) where T : IComparable<T> => throw new NotSupportedException();
+
+        /// <summary>
+        /// Determines whether a range is strictly to the left of another range.
+        /// </summary>
+        /// <param name="a">The first range.</param>
+        /// <param name="b">The second range.</param>
+        /// <typeparam name="T">The type of the elements of <paramref name="a"/>.</typeparam>
+        /// <returns>
+        /// <value>true</value> if the first range is strictly to the left of the second; otherwise, <value>false</value>.
+        /// </returns>
+        public static bool IsStrictlyLeftOf<T>(this NpgsqlRange<T> a, NpgsqlRange<T> b) where T : IComparable<T> => throw new NotSupportedException();
+
+        /// <summary>
+        /// Determines whether a range is strictly to the right of another range.
+        /// </summary>
+        /// <param name="a">The first range.</param>
+        /// <param name="b">The second range.</param>
+        /// <typeparam name="T">The type of the elements of <paramref name="a"/>.</typeparam>
+        /// <returns>
+        /// <value>true</value> if the first range is strictly to the right of the second; otherwise, <value>false</value>.
+        /// </returns>
+        public static bool IsStrictlyRightOf<T>(this NpgsqlRange<T> a, NpgsqlRange<T> b) where T : IComparable<T> => throw new NotSupportedException();
+
+        /// <summary>
+        /// Determines whether a range does not extend to the left of another range.
+        /// </summary>
+        /// <param name="a">The first range.</param>
+        /// <param name="b">The second range.</param>
+        /// <typeparam name="T">The type of the elements of <paramref name="a"/>.</typeparam>
+        /// <returns>
+        /// <value>true</value> if the first range does not extend to the left of the second; otherwise, <value>false</value>.
+        /// </returns>
+        public static bool DoesNotExtendLeftOf<T>(this NpgsqlRange<T> a, NpgsqlRange<T> b) where T : IComparable<T> => throw new NotSupportedException();
+
+        /// <summary>
+        /// Determines whether a range does not extend to the right of another range.
+        /// </summary>
+        /// <param name="a">The first range.</param>
+        /// <param name="b">The second range.</param>
+        /// <typeparam name="T">The type of the elements of <paramref name="a"/>.</typeparam>
+        /// <returns>
+        /// <value>true</value> if the first range does not extend to the right of the second; otherwise, <value>false</value>.
+        /// </returns>
+        public static bool DoesNotExtendRightOf<T>(this NpgsqlRange<T> a, NpgsqlRange<T> b) where T : IComparable<T> => throw new NotSupportedException();
+
+        /// <summary>
+        /// Determines whether a range is adjacent to another range.
+        /// </summary>
+        /// <param name="a">The first range.</param>
+        /// <param name="b">The second range.</param>
+        /// <typeparam name="T">The type of the elements of <paramref name="a"/>.</typeparam>
+        /// <returns>
+        /// <value>true</value> if the ranges are adjacent; otherwise, <value>false</value>.
+        /// </returns>
+        public static bool IsAdjacentTo<T>(this NpgsqlRange<T> a, NpgsqlRange<T> b) where T : IComparable<T> => throw new NotSupportedException();
+
+        /// <summary>
+        /// Returns the set union, which means unique elements that appear in either of two ranges.
+        /// </summary>
+        /// <param name="a">The first range.</param>
+        /// <param name="b">The second range.</param>
+        /// <typeparam name="T">The type of the elements of <paramref name="a"/>.</typeparam>
+        /// <returns>
+        /// The unique elements that appear in either range.
+        /// </returns>
+        public static NpgsqlRange<T> Union<T>(this NpgsqlRange<T> a, NpgsqlRange<T> b) where T : IComparable<T> => throw new NotSupportedException();
+
+        /// <summary>
+        /// Returns the set intersection, which means elements that appear in each of two ranges.
+        /// </summary>
+        /// <param name="a">The first range.</param>
+        /// <param name="b">The second range.</param>
+        /// <typeparam name="T">The type of the elements of <paramref name="a"/>.</typeparam>
+        /// <returns>
+        /// The elements that appear in both ranges.
+        /// </returns>
+        public static NpgsqlRange<T> Intersect<T>(this NpgsqlRange<T> a, NpgsqlRange<T> b) where T : IComparable<T> => throw new NotSupportedException();
+
+        /// <summary>
+        /// Returns the set difference, which means the elements of one range that do not appear in a second range.
+        /// </summary>
+        /// <param name="a">The first range.</param>
+        /// <param name="b">The second range.</param>
+        /// <typeparam name="T">The type of the elements of <paramref name="a"/>.</typeparam>
+        /// <returns>
+        /// The elements that appear in the first range, but not the second range.
+        /// </returns>
+        public static NpgsqlRange<T> Except<T>(this NpgsqlRange<T> a, NpgsqlRange<T> b) where T : IComparable<T> => throw new NotSupportedException();
+    }
+}
diff --git a/src/EFCore.PG/Query/ExpressionTranslators/Internal/NpgsqlCompositeMethodCallTranslator.cs b/src/EFCore.PG/Query/ExpressionTranslators/Internal/NpgsqlCompositeMethodCallTranslator.cs
index 54feb84ab..3011d4b67 100644
--- a/src/EFCore.PG/Query/ExpressionTranslators/Internal/NpgsqlCompositeMethodCallTranslator.cs
+++ b/src/EFCore.PG/Query/ExpressionTranslators/Internal/NpgsqlCompositeMethodCallTranslator.cs
@@ -50,7 +50,8 @@ public class NpgsqlCompositeMethodCallTranslator : RelationalCompositeMethodCall
             new NpgsqlStringTrimEndTranslator(),
             new NpgsqlStringTrimStartTranslator(),
             new NpgsqlRegexIsMatchTranslator(),
-            new NpgsqlFullTextSearchMethodTranslator()
+            new NpgsqlFullTextSearchMethodTranslator(),
+            new NpgsqlRangeTranslator()
         };
 
         public NpgsqlCompositeMethodCallTranslator(
diff --git a/src/EFCore.PG/Query/ExpressionTranslators/Internal/NpgsqlRangeTranslator.cs b/src/EFCore.PG/Query/ExpressionTranslators/Internal/NpgsqlRangeTranslator.cs
new file mode 100644
index 000000000..39127c444
--- /dev/null
+++ b/src/EFCore.PG/Query/ExpressionTranslators/Internal/NpgsqlRangeTranslator.cs
@@ -0,0 +1,85 @@
+#region License
+
+// The PostgreSQL License
+//
+// Copyright (C) 2016 The Npgsql Development Team
+//
+// Permission to use, copy, modify, and distribute this software and its
+// documentation for any purpose, without fee, and without a written
+// agreement is hereby granted, provided that the above copyright notice
+// and this paragraph and the following two paragraphs appear in all copies.
+//
+// IN NO EVENT SHALL THE NPGSQL DEVELOPMENT TEAM BE LIABLE TO ANY PARTY
+// FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES,
+// INCLUDING LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS
+// DOCUMENTATION, EVEN IF THE NPGSQL DEVELOPMENT TEAM HAS BEEN ADVISED OF
+// THE POSSIBILITY OF SUCH DAMAGE.
+//
+// THE NPGSQL DEVELOPMENT TEAM SPECIFICALLY DISCLAIMS ANY WARRANTIES,
+// INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+// AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS
+// ON AN "AS IS" BASIS, AND THE NPGSQL DEVELOPMENT TEAM HAS NO OBLIGATIONS
+// TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
+
+#endregion
+
+using System.Linq.Expressions;
+using JetBrains.Annotations;
+using Microsoft.EntityFrameworkCore.Query.ExpressionTranslators;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Query.Expressions.Internal;
+
+namespace Npgsql.EntityFrameworkCore.PostgreSQL.Query.ExpressionTranslators.Internal
+{
+    /// <summary>
+    /// Provides translation services for PostgreSQL range operators.
+    /// </summary>
+    /// <remarks>
+    /// See: https://www.postgresql.org/docs/current/static/functions-range.html
+    /// </remarks>
+    public class NpgsqlRangeTranslator : IMethodCallTranslator
+    {
+        /// <inheritdoc />
+        [CanBeNull]
+        public Expression Translate(MethodCallExpression expression)
+        {
+            switch (expression.Method.Name)
+            {
+            case nameof(NpgsqlRangeExtensions.Contains):
+                return new CustomBinaryExpression(expression.Arguments[0], expression.Arguments[1], "@>", typeof(bool));
+
+            case nameof(NpgsqlRangeExtensions.ContainedBy):
+                return new CustomBinaryExpression(expression.Arguments[0], expression.Arguments[1], "<@", typeof(bool));
+
+            case nameof(NpgsqlRangeExtensions.Overlaps):
+                return new CustomBinaryExpression(expression.Arguments[0], expression.Arguments[1], "&&", typeof(bool));
+
+            case nameof(NpgsqlRangeExtensions.IsStrictlyLeftOf):
+                return new CustomBinaryExpression(expression.Arguments[0], expression.Arguments[1], "<<", typeof(bool));
+
+            case nameof(NpgsqlRangeExtensions.IsStrictlyRightOf):
+                return new CustomBinaryExpression(expression.Arguments[0], expression.Arguments[1], ">>", typeof(bool));
+
+            case nameof(NpgsqlRangeExtensions.DoesNotExtendRightOf):
+                return new CustomBinaryExpression(expression.Arguments[0], expression.Arguments[1], "&<", typeof(bool));
+
+            case nameof(NpgsqlRangeExtensions.DoesNotExtendLeftOf):
+                return new CustomBinaryExpression(expression.Arguments[0], expression.Arguments[1], "&>", typeof(bool));
+
+            case nameof(NpgsqlRangeExtensions.IsAdjacentTo):
+                return new CustomBinaryExpression(expression.Arguments[0], expression.Arguments[1], "-|-", typeof(bool));
+
+            case nameof(NpgsqlRangeExtensions.Union):
+                return new CustomBinaryExpression(expression.Arguments[0], expression.Arguments[1], "+", expression.Arguments[0].Type);
+
+            case nameof(NpgsqlRangeExtensions.Intersect):
+                return new CustomBinaryExpression(expression.Arguments[0], expression.Arguments[1], "*", expression.Arguments[0].Type);
+
+            case nameof(NpgsqlRangeExtensions.Except):
+                return new CustomBinaryExpression(expression.Arguments[0], expression.Arguments[1], "-", expression.Arguments[0].Type);
+
+            default:
+                return null;
+            }
+        }
+    }
+}
diff --git a/test/EFCore.PG.FunctionalTests/EFCore.PG.FunctionalTests.csproj b/test/EFCore.PG.FunctionalTests/EFCore.PG.FunctionalTests.csproj
index 050106099..e6f2d8420 100644
--- a/test/EFCore.PG.FunctionalTests/EFCore.PG.FunctionalTests.csproj
+++ b/test/EFCore.PG.FunctionalTests/EFCore.PG.FunctionalTests.csproj
@@ -26,4 +26,4 @@
     <PackageReference Include="Microsoft.Extensions.Configuration.Json" Version="2.1.0-rtm-30736" />
     <PackageReference Include="Microsoft.Extensions.Configuration.EnvironmentVariables" Version="2.1.0-rtm-30736" />
   </ItemGroup>
-</Project>
+</Project>
\ No newline at end of file
diff --git a/test/EFCore.PG.FunctionalTests/Query/RangeQueryNpgsqlTest.cs b/test/EFCore.PG.FunctionalTests/Query/RangeQueryNpgsqlTest.cs
new file mode 100644
index 000000000..c31d32016
--- /dev/null
+++ b/test/EFCore.PG.FunctionalTests/Query/RangeQueryNpgsqlTest.cs
@@ -0,0 +1,691 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.TestUtilities;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
+using Npgsql.EntityFrameworkCore.PostgreSQL.TestUtilities;
+using NpgsqlTypes;
+using Xunit;
+
+namespace Npgsql.EntityFrameworkCore.PostgreSQL.Query
+{
+    /// <summary>
+    /// Provides unit tests for range operator translations.
+    /// </summary>
+    public class RangeQueryNpgsqlTest : IClassFixture<RangeQueryNpgsqlTest.RangeQueryNpgsqlFixture>
+    {
+        /// <summary>
+        /// Provides resources for unit tests.
+        /// </summary>
+        RangeQueryNpgsqlFixture Fixture { get; }
+
+        /// <summary>
+        /// Initializes resources for unit tests.
+        /// </summary>
+        /// <param name="fixture">The fixture of resources for testing.</param>
+        public RangeQueryNpgsqlTest(RangeQueryNpgsqlFixture fixture)
+        {
+            Fixture = fixture;
+            Fixture.TestSqlLoggerFactory.Clear();
+        }
+
+        #region Tests
+
+        /// <summary>
+        /// Tests translation for <see cref="NpgsqlRangeExtensions.Contains{T}(NpgsqlRange{T},NpgsqlRange{T})"/>.
+        /// </summary>
+        [Theory]
+        [MemberData(nameof(RangeTheoryData))]
+        public void RangeContainsRange(NpgsqlRange<int> range)
+        {
+            using (RangeContext context = Fixture.CreateContext())
+            {
+                RangeTestEntity[] _ =
+                    context.RangeTestEntities
+                           .Where(x => x.Range.Contains(range))
+                           .ToArray();
+
+                AssertContainsSql("WHERE x.\"Range\" @> @__range_0 = TRUE");
+            }
+        }
+
+        /// <summary>
+        /// Tests inverse translation for <see cref="NpgsqlRangeExtensions.Contains{T}(NpgsqlRange{T}, NpgsqlRange{T})"/>.
+        /// </summary>
+        [Theory]
+        [MemberData(nameof(RangeTheoryData))]
+        public void RangeDoesNotContainRange(NpgsqlRange<int> range)
+        {
+            using (RangeContext context = Fixture.CreateContext())
+            {
+                RangeTestEntity[] _ =
+                    context.RangeTestEntities
+                           .Where(x => !x.Range.Contains(range))
+                           .ToArray();
+
+                AssertContainsSql("WHERE NOT (x.\"Range\" @> @__range_0 = TRUE)");
+            }
+        }
+
+        /// <summary>
+        /// Tests translation for <see cref="NpgsqlRangeExtensions.Contains{T}(NpgsqlRange{T}, T)"/>.
+        /// </summary>
+        [Theory]
+        [MemberData(nameof(IntegerTheoryData))]
+        public void RangeContainsValue(int value)
+        {
+            using (RangeContext context = Fixture.CreateContext())
+            {
+                RangeTestEntity[] _ =
+                    context.RangeTestEntities
+                           .Where(x => x.Range.Contains(value))
+                           .ToArray();
+
+                AssertContainsSql("WHERE x.\"Range\" @> @__value_0");
+            }
+        }
+
+        /// <summary>
+        /// Tests inverse translation for <see cref="NpgsqlRangeExtensions.Contains{T}(NpgsqlRange{T}, T)"/>.
+        /// </summary>
+        [Theory]
+        [MemberData(nameof(IntegerTheoryData))]
+        public void RangeDoesNotContainValue(int value)
+        {
+            using (RangeContext context = Fixture.CreateContext())
+            {
+                RangeTestEntity[] _ =
+                    context.RangeTestEntities
+                           .Where(x => !x.Range.Contains(value))
+                           .ToArray();
+
+                AssertContainsSql("WHERE NOT (x.\"Range\" @> @__value_0 = TRUE)");
+            }
+        }
+
+        /// <summary>
+        /// Tests translation for <see cref="NpgsqlRangeExtensions.ContainedBy{T}(NpgsqlRange{T}, NpgsqlRange{T})"/>.
+        /// </summary>
+        [Theory]
+        [MemberData(nameof(RangeTheoryData))]
+        public void RangeContainedByRange(NpgsqlRange<int> range)
+        {
+            using (RangeContext context = Fixture.CreateContext())
+            {
+                RangeTestEntity[] _ =
+                    context.RangeTestEntities
+                           .Where(x => range.ContainedBy(x.Range))
+                           .ToArray();
+
+                AssertContainsSql("WHERE @__range_0 <@ x.\"Range\" = TRUE");
+            }
+        }
+
+        /// <summary>
+        /// Tests inverse containment translation for <see cref="NpgsqlRangeExtensions.ContainedBy{T}(NpgsqlRange{T}, NpgsqlRange{T})"/>.
+        /// </summary>
+        [Theory]
+        [MemberData(nameof(RangeTheoryData))]
+        public void RangeNotContainedByRange(NpgsqlRange<int> range)
+        {
+            using (RangeContext context = Fixture.CreateContext())
+            {
+                RangeTestEntity[] _ =
+                    context.RangeTestEntities
+                           .Where(x => !range.ContainedBy(x.Range))
+                           .ToArray();
+
+                AssertContainsSql("WHERE NOT (@__range_0 <@ x.\"Range\" = TRUE)");
+            }
+        }
+
+        /// <summary>
+        /// Tests translation for <see cref="NpgsqlRange{T}.Equals(NpgsqlRange{T})"/> via the symbolic operator.
+        /// </summary>
+        [Theory]
+        [MemberData(nameof(RangeTheoryData))]
+        public void RangeEqualsRange_Operator(NpgsqlRange<int> range)
+        {
+            using (RangeContext context = Fixture.CreateContext())
+            {
+                RangeTestEntity[] _ =
+                    context.RangeTestEntities
+                           .Where(x => x.Range == range)
+                           .ToArray();
+
+                AssertContainsSql("WHERE x.\"Range\" = @__range_0");
+            }
+        }
+
+        /// <summary>
+        /// Tests translation for <see cref="NpgsqlRange{T}.Equals(NpgsqlRange{T})"/> via method call.
+        /// </summary>
+        [Theory]
+        [MemberData(nameof(RangeTheoryData))]
+        public void RangeEqualsRange_Method(NpgsqlRange<int> range)
+        {
+            using (RangeContext context = Fixture.CreateContext())
+            {
+                RangeTestEntity[] _ =
+                    context.RangeTestEntities
+                           .Where(x => x.Range.Equals(range))
+                           .ToArray();
+
+                AssertContainsSql("WHERE x.\"Range\" = @__range_0");
+            }
+        }
+
+        /// <summary>
+        /// Tests inverse translation for <see cref="NpgsqlRange{T}.Equals(NpgsqlRange{T})"/> via symbolic operator.
+        /// </summary>
+        [Theory]
+        [MemberData(nameof(RangeTheoryData))]
+        public void RangeDoesNotEqualsRange_Operator(NpgsqlRange<int> range)
+        {
+            using (RangeContext context = Fixture.CreateContext())
+            {
+                RangeTestEntity[] _ =
+                    context.RangeTestEntities
+                           .Where(x => x.Range != range)
+                           .ToArray();
+
+                AssertContainsSql("WHERE x.\"Range\" <> @__range_0");
+            }
+        }
+
+        /// <summary>
+        /// Tests inverse translation for <see cref="NpgsqlRange{T}.Equals(NpgsqlRange{T})"/> via method call.
+        /// </summary>
+        [Theory]
+        [MemberData(nameof(RangeTheoryData))]
+        public void RangeDoesNotEqualsRange_Method(NpgsqlRange<int> range)
+        {
+            using (RangeContext context = Fixture.CreateContext())
+            {
+                RangeTestEntity[] _ =
+                    context.RangeTestEntities
+                           .Where(x => !x.Range.Equals(range))
+                           .ToArray();
+
+                AssertContainsSql("WHERE x.\"Range\" <> @__range_0");
+            }
+        }
+
+        /// <summary>
+        /// Tests translation for <see cref="NpgsqlRangeExtensions.Overlaps{T}(NpgsqlRange{T}, NpgsqlRange{T})"/>.
+        /// </summary>
+        [Theory]
+        [MemberData(nameof(RangeTheoryData))]
+        public void RangeOvelapsRange(NpgsqlRange<int> range)
+        {
+            using (RangeContext context = Fixture.CreateContext())
+            {
+                RangeTestEntity[] _ =
+                    context.RangeTestEntities
+                           .Where(x => x.Range.Overlaps(range))
+                           .ToArray();
+
+                AssertContainsSql("WHERE x.\"Range\" && @__range_0");
+            }
+        }
+
+        /// <summary>
+        /// Tests inverse translation for <see cref="NpgsqlRangeExtensions.Overlaps{T}(NpgsqlRange{T}, NpgsqlRange{T})"/>.
+        /// </summary>
+        [Theory]
+        [MemberData(nameof(RangeTheoryData))]
+        public void RangeDoesNotOvelapRange(NpgsqlRange<int> range)
+        {
+            using (RangeContext context = Fixture.CreateContext())
+            {
+                RangeTestEntity[] _ =
+                    context.RangeTestEntities
+                           .Where(x => !x.Range.Overlaps(range))
+                           .ToArray();
+
+                AssertContainsSql("WHERE NOT (x.\"Range\" && @__range_0 = TRUE)");
+            }
+        }
+
+        /// <summary>
+        /// Tests translation for <see cref="NpgsqlRangeExtensions.IsStrictlyLeftOf{T}(NpgsqlRange{T}, NpgsqlRange{T})"/>.
+        /// </summary>
+        [Theory]
+        [MemberData(nameof(RangeTheoryData))]
+        public void RangeIsStrictlyLeftOfRange(NpgsqlRange<int> range)
+        {
+            using (RangeContext context = Fixture.CreateContext())
+            {
+                RangeTestEntity[] _ =
+                    context.RangeTestEntities
+                           .Where(x => x.Range.IsStrictlyLeftOf(range))
+                           .ToArray();
+
+                AssertContainsSql("WHERE x.\"Range\" << @__range_0");
+            }
+        }
+
+        /// <summary>
+        /// Tests inverse translation for <see cref="NpgsqlRangeExtensions.IsStrictlyLeftOf{T}(NpgsqlRange{T}, NpgsqlRange{T})"/>.
+        /// </summary>
+        [Theory]
+        [MemberData(nameof(RangeTheoryData))]
+        public void RangeIsNotStrictlyLeftOfRange(NpgsqlRange<int> range)
+        {
+            using (RangeContext context = Fixture.CreateContext())
+            {
+                RangeTestEntity[] _ =
+                    context.RangeTestEntities
+                           .Where(x => !x.Range.IsStrictlyLeftOf(range))
+                           .ToArray();
+
+                AssertContainsSql("WHERE NOT (x.\"Range\" << @__range_0 = TRUE)");
+            }
+        }
+
+        /// <summary>
+        /// Tests translation for <see cref="NpgsqlRangeExtensions.IsStrictlyRightOf{T}(NpgsqlRange{T}, NpgsqlRange{T})"/>.
+        /// </summary>
+        [Theory]
+        [MemberData(nameof(RangeTheoryData))]
+        public void RangeIsStrictlyRightOfRange(NpgsqlRange<int> range)
+        {
+            using (RangeContext context = Fixture.CreateContext())
+            {
+                RangeTestEntity[] _ =
+                    context.RangeTestEntities
+                           .Where(x => x.Range.IsStrictlyRightOf(range))
+                           .ToArray();
+
+                AssertContainsSql("WHERE x.\"Range\" >> @__range_0");
+            }
+        }
+
+        /// <summary>
+        /// Tests inverse translation for <see cref="NpgsqlRangeExtensions.IsStrictlyRightOf{T}(NpgsqlRange{T}, NpgsqlRange{T})"/>.
+        /// </summary>
+        [Theory]
+        [MemberData(nameof(RangeTheoryData))]
+        public void RangeIsNotStrictlyRightOfRange(NpgsqlRange<int> range)
+        {
+            using (RangeContext context = Fixture.CreateContext())
+            {
+                RangeTestEntity[] _ =
+                    context.RangeTestEntities
+                           .Where(x => !x.Range.IsStrictlyRightOf(range))
+                           .ToArray();
+
+                AssertContainsSql("WHERE NOT (x.\"Range\" >> @__range_0 = TRUE)");
+            }
+        }
+
+        /// <summary>
+        /// Tests translation for <see cref="NpgsqlRangeExtensions.DoesNotExtendLeftOf{T}(NpgsqlRange{T}, NpgsqlRange{T})"/>.
+        /// </summary>
+        [Theory]
+        [MemberData(nameof(RangeTheoryData))]
+        public void RangeDoesNotExtendLeftOfRange(NpgsqlRange<int> range)
+        {
+            using (RangeContext context = Fixture.CreateContext())
+            {
+                RangeTestEntity[] _ =
+                    context.RangeTestEntities
+                           .Where(x => x.Range.DoesNotExtendLeftOf(range))
+                           .ToArray();
+
+                AssertContainsSql("WHERE x.\"Range\" &> @__range_0");
+            }
+        }
+
+        /// <summary>
+        /// Tests inverse translation for <see cref="NpgsqlRangeExtensions.DoesNotExtendLeftOf{T}(NpgsqlRange{T}, NpgsqlRange{T})"/>.
+        /// </summary>
+        [Theory]
+        [MemberData(nameof(RangeTheoryData))]
+        public void RangeDoesExtendLeftOfRange(NpgsqlRange<int> range)
+        {
+            using (RangeContext context = Fixture.CreateContext())
+            {
+                RangeTestEntity[] _ =
+                    context.RangeTestEntities
+                           .Where(x => !x.Range.DoesNotExtendLeftOf(range))
+                           .ToArray();
+
+                AssertContainsSql("WHERE NOT (x.\"Range\" &> @__range_0 = TRUE)");
+            }
+        }
+
+        /// <summary>
+        /// Tests translation for <see cref="NpgsqlRangeExtensions.DoesNotExtendRightOf{T}(NpgsqlRange{T}, NpgsqlRange{T})"/>.
+        /// </summary>
+        [Theory]
+        [MemberData(nameof(RangeTheoryData))]
+        public void RangeDoesNotExtendRightOfRange(NpgsqlRange<int> range)
+        {
+            using (RangeContext context = Fixture.CreateContext())
+            {
+                RangeTestEntity[] _ =
+                    context.RangeTestEntities
+                           .Where(x => x.Range.DoesNotExtendRightOf(range))
+                           .ToArray();
+
+                AssertContainsSql("WHERE x.\"Range\" &< @__range_0");
+            }
+        }
+
+        /// <summary>
+        /// Tests inverse translation for <see cref="NpgsqlRangeExtensions.DoesNotExtendRightOf{T}(NpgsqlRange{T}, NpgsqlRange{T})"/>.
+        /// </summary>
+        [Theory]
+        [MemberData(nameof(RangeTheoryData))]
+        public void RangeDoesExtendRightOfRange(NpgsqlRange<int> range)
+        {
+            using (RangeContext context = Fixture.CreateContext())
+            {
+                RangeTestEntity[] _ =
+                    context.RangeTestEntities
+                           .Where(x => !x.Range.DoesNotExtendRightOf(range))
+                           .ToArray();
+
+                AssertContainsSql("WHERE NOT (x.\"Range\" &< @__range_0 = TRUE)");
+            }
+        }
+
+        /// <summary>
+        /// Tests translation for <see cref="NpgsqlRangeExtensions.IsAdjacentTo{T}(NpgsqlRange{T}, NpgsqlRange{T})"/>.
+        /// </summary>
+        [Theory]
+        [MemberData(nameof(RangeTheoryData))]
+        public void RangeIsAdjacentToRange(NpgsqlRange<int> range)
+        {
+            using (RangeContext context = Fixture.CreateContext())
+            {
+                RangeTestEntity[] _ =
+                    context.RangeTestEntities
+                           .Where(x => x.Range.IsAdjacentTo(range))
+                           .ToArray();
+
+                AssertContainsSql("WHERE x.\"Range\" -|- @__range_0");
+            }
+        }
+
+        /// <summary>
+        /// Tests inverse translation for <see cref="NpgsqlRangeExtensions.IsAdjacentTo{T}(NpgsqlRange{T}, NpgsqlRange{T})"/>.
+        /// </summary>
+        [Theory]
+        [MemberData(nameof(RangeTheoryData))]
+        public void RangeIsNotAdjacentToRange(NpgsqlRange<int> range)
+        {
+            using (RangeContext context = Fixture.CreateContext())
+            {
+                RangeTestEntity[] _ =
+                    context.RangeTestEntities
+                           .Where(x => !x.Range.IsAdjacentTo(range))
+                           .ToArray();
+
+                AssertContainsSql("WHERE NOT (x.\"Range\" -|- @__range_0 = TRUE)");
+            }
+        }
+
+        /// <summary>
+        /// Tests translation for <see cref="NpgsqlRangeExtensions.Union{T}(NpgsqlRange{T}, NpgsqlRange{T})"/>.
+        /// </summary>
+        [Theory]
+        [MemberData(nameof(RangeTheoryData))]
+        public void RangeUnionRange(NpgsqlRange<int> range)
+        {
+            using (RangeContext context = Fixture.CreateContext())
+            {
+                NpgsqlRange<int>[] _ =
+                    context.RangeTestEntities
+                           .Select(x => x.Range.Union(range))
+                           .ToArray();
+
+                AssertContainsSql("SELECT x.\"Range\" + @__range_0");
+            }
+        }
+
+        /// <summary>
+        /// Tests translation for <see cref="NpgsqlRangeExtensions.Intersect{T}(NpgsqlRange{T}, NpgsqlRange{T})"/>.
+        /// </summary>
+        [Theory]
+        [MemberData(nameof(RangeTheoryData))]
+        public void RangeIntersectsRange(NpgsqlRange<int> range)
+        {
+            using (RangeContext context = Fixture.CreateContext())
+            {
+                NpgsqlRange<int>[] _ =
+                    context.RangeTestEntities
+                           .Select(x => x.Range.Intersect(range))
+                           .ToArray();
+
+                AssertContainsSql("SELECT x.\"Range\" * @__range_0");
+            }
+        }
+
+        /// <summary>
+        /// Tests translation for <see cref="NpgsqlRangeExtensions.Except{T}(NpgsqlRange{T}, NpgsqlRange{T})"/>.
+        /// </summary>
+        [Theory]
+        [MemberData(nameof(RangeTheoryData))]
+        public void RangeExceptRange(NpgsqlRange<int> range)
+        {
+            using (RangeContext context = Fixture.CreateContext())
+            {
+                try
+                {
+                    NpgsqlRange<int>[] _ =
+                        context.RangeTestEntities
+                               .Select(x => x.Range.Except(range))
+                               .ToArray();
+                }
+                catch (PostgresException)
+                {
+                    // ignore: Npgsql.PostgresException : 22000: result of range difference would not be contiguous.
+                }
+
+                AssertContainsSql("SELECT x.\"Range\" - @__range_0");
+            }
+        }
+
+        #endregion Tests
+
+        #region TheoryData
+
+        /// <summary>
+        /// Provides theory data for integers.
+        /// </summary>
+        public static IEnumerable<object[]> IntegerTheoryData => Enumerable.Range(-10, 10).Select(x => new object[] { x });
+
+        /// <summary>
+        /// Provides theory data for ranges.
+        /// </summary>
+        public static IEnumerable<object[]> RangeTheoryData =>
+            new List<object[]>
+            {
+                // (0,5)
+                new object[] { new NpgsqlRange<int>(0, false, false, 5, false, false) },
+                // [0,5]
+                new object[] { new NpgsqlRange<int>(0, true, false, 5, true, false) },
+                // (,)
+                new object[] { new NpgsqlRange<int>(0, false, true, 0, false, true) },
+                // (,)
+                new object[] { new NpgsqlRange<int>(0, false, true, 5, false, true) },
+                // (0,)
+                new object[] { new NpgsqlRange<int>(0, false, false, 0, false, true) },
+                // (0,)
+                new object[] { new NpgsqlRange<int>(0, false, false, 5, false, true) },
+                // (,5)
+                new object[] { new NpgsqlRange<int>(0, false, true, 5, false, false) }
+            };
+
+        #endregion
+
+        #region Fixtures
+
+        /// <summary>
+        /// Represents a fixture suitable for testing range operators.
+        /// </summary>
+        public class RangeQueryNpgsqlFixture : IDisposable
+        {
+            /// <summary>
+            /// The <see cref="NpgsqlTestStore"/> used for testing.
+            /// </summary>
+            private readonly NpgsqlTestStore _testStore;
+
+            /// <summary>
+            /// The <see cref="DbContextOptions"/> used for testing.
+            /// </summary>
+            private readonly DbContextOptions _options;
+
+            /// <summary>
+            /// The logger factory used for testing.
+            /// </summary>
+            public TestSqlLoggerFactory TestSqlLoggerFactory { get; }
+
+            /// <summary>
+            /// Initializes a <see cref="RangeQueryNpgsqlFixture"/>.
+            /// </summary>
+            // ReSharper disable once UnusedMember.Global
+            public RangeQueryNpgsqlFixture()
+            {
+                TestSqlLoggerFactory = new TestSqlLoggerFactory();
+
+                _testStore = NpgsqlTestStore.CreateScratch();
+
+                _options =
+                    new DbContextOptionsBuilder()
+                        .UseNpgsql(_testStore.ConnectionString, b => b.ApplyConfiguration())
+                        .UseInternalServiceProvider(
+                            new ServiceCollection()
+                                .AddEntityFrameworkNpgsql()
+                                .AddSingleton<ILoggerFactory>(TestSqlLoggerFactory)
+                                .BuildServiceProvider())
+                        .Options;
+
+                using (RangeContext context = CreateContext())
+                {
+                    context.Database.EnsureCreated();
+
+                    context.RangeTestEntities.AddRange(
+                        new RangeTestEntity
+                        {
+                            Id = 1,
+                            // (0, 10)
+                            Range = new NpgsqlRange<int>(0, false, false, 10, false, false),
+                        },
+                        new RangeTestEntity
+                        {
+                            Id = 2,
+                            // [0, 10)
+                            Range = new NpgsqlRange<int>(0, true, false, 10, false, false)
+                        },
+                        new RangeTestEntity
+                        {
+                            Id = 3,
+                            // [0, 10]
+                            Range = new NpgsqlRange<int>(0, true, false, 10, true, false)
+                        },
+                        new RangeTestEntity
+                        {
+                            Id = 4,
+                            // [0, ∞)
+                            Range = new NpgsqlRange<int>(0, true, false, 0, false, true)
+                        },
+                        new RangeTestEntity
+                        {
+                            Id = 5,
+                            // (-∞, 10]
+                            Range = new NpgsqlRange<int>(0, false, true, 10, true, false)
+                        },
+                        new RangeTestEntity
+                        {
+                            Id = 6,
+                            // (-∞, ∞)
+                            Range = new NpgsqlRange<int>(0, false, true, 0, false, true)
+                        },
+                        new RangeTestEntity
+                        {
+                            Id = 7,
+                            // (-∞, ∞)
+                            Range = new NpgsqlRange<int>(0, false, true, 0, false, true)
+                        });
+
+                    context.SaveChanges();
+                }
+            }
+
+            /// <summary>
+            /// Creates a new <see cref="RangeContext"/>.
+            /// </summary>
+            /// <returns>
+            /// A <see cref="RangeContext"/> for testing.
+            /// </returns>
+            public RangeContext CreateContext()
+            {
+                return new RangeContext(_options);
+            }
+
+            /// <inheritdoc />
+            public void Dispose()
+            {
+                _testStore.Dispose();
+            }
+        }
+
+        /// <summary>
+        /// Represents an entity suitable for testing range operators.
+        /// </summary>
+        public class RangeTestEntity
+        {
+            /// <summary>
+            /// The primary key.
+            /// </summary>
+            public int Id { get; set; }
+
+            /// <summary>
+            /// The range of integers.
+            /// </summary>
+            public NpgsqlRange<int> Range { get; set; }
+        }
+
+        /// <summary>
+        /// Represents a database suitable for testing range operators.
+        /// </summary>
+        public class RangeContext : DbContext
+        {
+            /// <summary>
+            /// Represents a set of entities with <see cref="NpgsqlRange{T}"/> properties.
+            /// </summary>
+            public DbSet<RangeTestEntity> RangeTestEntities { get; set; }
+
+            /// <summary>
+            /// Initializes a <see cref="RangeContext"/>.
+            /// </summary>
+            /// <param name="options">
+            /// The options to be used for configuration.
+            /// </param>
+            public RangeContext(DbContextOptions options) : base(options) { }
+
+            /// <inheritdoc />
+            protected override void OnModelCreating(ModelBuilder builder) { }
+        }
+
+        #endregion
+
+        #region Helpers
+
+        /// <summary>
+        /// Asserts that the SQL fragment appears in the logs.
+        /// </summary>
+        /// <param name="sql">The SQL statement or fragment to search for in the logs.</param>
+        public void AssertContainsSql(string sql)
+        {
+            Assert.Contains(sql, Fixture.TestSqlLoggerFactory.Sql);
+        }
+
+        #endregion
+    }
+}