WIP on improving compatibility of efcore.pg with CockroachDB

.github/workflows/build-cockroach.yml

@@ -0,0 +1,166 @@
+name: Build Cockroach
+
+on:
+  push:
+    branches:
+      - cockroach
+    tags:
+      - v*
+  pull_request:
+  workflow_dispatch:
+
+env:
+  dotnet_sdk_version: '8.0.100-preview.2.23153.6'
+  postgis_version: 3
+  DOTNET_SKIP_FIRST_TIME_EXPERIENCE: true
+
+jobs:
+  build:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ ubuntu-22.04 ]
+        crdb_major: [ v23.1 ]
+        config: [ Release ]
+        # include:
+        #  - os: ubuntu-22.04
+        #    crdb_major: v23.1.3
+        #    config: Debug
+    outputs:
+      is_release: ${{ steps.analyze_tag.outputs.is_release }}
+      is_prerelease: ${{ steps.analyze_tag.outputs.is_prerelease }}
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v3
+
+      - name: Setup .NET Core SDK
+        uses: actions/setup-dotnet@v3
+        with:
+          dotnet-version: ${{ env.dotnet_sdk_version }}
+
+      - name: Build
+        run: dotnet build --configuration Debug
+        shell: bash
+
+      - name: Start CockroachDB ${{ matrix.crdb_major }} (Linux)
+        if: startsWith(matrix.os, 'ubuntu')
+        run: |
+          # First uninstall any cockroachDB installed on the image
+          sudo rm -f /usr/local/bin/cockroach
+          # Install CRDB
+
+          if [[ ${{ matrix.crdb_major }} == "master" ]]; then
+            wget --no-verbose -O cockroach  https://edge-binaries.cockroachdb.com/cockroach/cockroach.linux-gnu-amd64.LATEST
+            chmod u+x cockroach
+            sudo mv ./cockroach /usr/local/bin/cockroach
+          elif [[ ${{ matrix.crdb_major }} == "v23.1" ]]; then
+            wget --no-verbose -O cockroach  https://edge-binaries.cockroachdb.com/cockroach/cockroach.linux-gnu-amd64.release-23.1
+            chmod u+x cockroach
+            sudo mv ./cockroach /usr/local/bin/cockroach
+          else
+            curl https://binaries.cockroachdb.com/cockroach-v23.1.3.linux-amd64.tgz | tar -xz && sudo cp -i cockroach-v23.1.3.linux-amd64/cockroach /usr/local/bin/
+            sudo mkdir -p /usr/local/lib/cockroach
+            sudo cp -i cockroach-v23.1.3.linux-amd64/lib/libgeos.so /usr/local/lib/cockroach/
+            sudo cp -i cockroach-v23.1.3.linux-amd64/lib/libgeos_c.so /usr/local/lib/cockroach/
+          fi
+
+          which cockroach
+          cockroach version
+          # Create certificates
+          rm -rf cockroach-data
+          cockroach cert create-ca --certs-dir=certs --ca-key=certs/ca.key
+          cockroach cert create-client --certs-dir=certs --ca-key=certs/ca.key root
+          cockroach cert create-node --certs-dir=certs --ca-key=certs/ca.key 127.0.0.1 127.0.0.1
+          # Start the initialization
+          cockroach start-single-node --certs-dir=certs --advertise-addr=127.0.0.1:26257 --background
+          cockroach sql --certs-dir=certs -e "CREATE USER crdb_tests WITH PASSWORD 'crdb_tests'; GRANT admin TO crdb_tests" --url="postgresql://root@127.0.0.1:26257/defaultdb?sslcert=certs%2Fclient.root.crt&sslkey=certs%2Fclient.root.key&sslmode=verify-full&sslrootcert=certs%2Fca.crt"
+
+      - name: Test
+        run: TEST_COCKROACH_DB=true dotnet test -c ${{ matrix.config }} --blame-hang-timeout 600000 --blame-hang-dump-type mini --logger "GitHubActions;report-warnings=false"
+        shell: bash
+
+      - uses: actions/upload-artifact@v3
+        if: always()
+        with:
+          name: results
+          retention-days: 1
+          path: test/EFCore.PG.FunctionalTests/TestResults/**/*
+
+      - id: analyze_tag
+        name: Analyze tag
+        shell: bash
+        run: |
+          if [[ ${{ github.ref }} =~ ^refs/tags/v[0-9]+\.[0-9]+\.[0-9]+ ]]; then
+              echo "Release tag detected"
+              echo "::set-output name=is_release::true"
+              if [[ ${{ github.ref }} =~ ^refs/tags/v[0-9]+\.[0-9]+\.[0-9]+.*- ]]; then
+                  echo "Prerelease tag detected"
+                  echo "::set-output name=is_prerelease::true"
+              fi
+          fi
+
+  publish-ci:
+    needs: build
+    runs-on: ubuntu-22.04
+    if: github.event_name == 'push' && startsWith(github.repository, 'npgsql/')
+    environment: myget
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v3
+
+      - name: Setup .NET Core SDK
+        uses: actions/setup-dotnet@v3
+        with:
+          dotnet-version: ${{ env.dotnet_sdk_version }}
+
+      - name: Pack
+        run: dotnet pack --configuration Release --property:PackageOutputPath="$PWD/nupkgs" --version-suffix "ci.$(date -u +%Y%m%dT%H%M%S)+sha.${GITHUB_SHA:0:9}" -p:ContinuousIntegrationBuild=true
+
+      - name: Upload artifacts
+        uses: actions/upload-artifact@v3
+        with:
+          name: EFCore.PG.CI
+          path: nupkgs
+
+      - name: Publish packages to MyGet (vnext)
+        if: startsWith(github.ref, 'refs/heads/') && startsWith(github.ref, 'refs/heads/hotfix/') == false
+        run: dotnet nuget push "*.nupkg" --api-key ${{ secrets.MYGET_FEED_TOKEN }} --source https://www.myget.org/F/npgsql-vnext/api/v3/index.json
+        working-directory: nupkgs
+
+      - name: Publish packages to MyGet (patch)
+        if: startsWith(github.ref, 'refs/heads/hotfix/')
+        run: dotnet nuget push "*.nupkg" --api-key ${{ secrets.MYGET_FEED_TOKEN }} --source https://www.myget.org/F/npgsql/api/v3/index.json
+        working-directory: nupkgs
+
+  release:
+    needs: build
+    runs-on: ubuntu-22.04
+    if: github.event_name == 'push' && startsWith(github.repository, 'npgsql/') && needs.build.outputs.is_release == 'true'
+    environment: nuget.org
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v3
+
+      - name: Setup .NET Core SDK
+        uses: actions/setup-dotnet@v3
+        with:
+          dotnet-version: ${{ env.dotnet_sdk_version }}
+
+      - name: Pack
+        run: dotnet pack --configuration Release --property:PackageOutputPath="$PWD/nupkgs" -p:ContinuousIntegrationBuild=true
+
+      - name: Upload artifacts
+        uses: actions/upload-artifact@v3
+        with:
+          name: EFCore.PG.Release
+          path: nupkgs
+
+      # TODO: Create a release
+
+      - name: Publish to nuget.org
+        run: dotnet nuget push "*.nupkg" --api-key ${{ secrets.NUGET_ORG_API_KEY }} --source https://api.nuget.org/v3/index.json
+        working-directory: nupkgs

Directory.Packages.props

@@ -1,8 +1,8 @@
-  <Project>
+   <Project>
   <PropertyGroup>
     <EFCoreVersion>8.0.0-rc.2.23465.12</EFCoreVersion>
     <MicrosoftExtensionsVersion>8.0.0-rc.2.23465.13</MicrosoftExtensionsVersion>
-    <NpgsqlVersion>8.0.0-preview.4</NpgsqlVersion>
+    <NpgsqlVersion>8.0.0-preview.5-ci.20230725T094520</NpgsqlVersion>
   </PropertyGroup>
 
   <ItemGroup>

src/EFCore.PG/Extensions/NpgsqlConnectionExtensions.cs

@@ -0,0 +1,12 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Npgsql.EntityFrameworkCore.PostgreSQL.Extensions;
+
+internal static class NpgsqlConnectionExtensions
+{
+    internal static bool IsCockroachDb(this NpgsqlConnection connection)
+    {
+        return connection.PostgresParameters.TryGetValue("crdb_version", out var _);
+    }
+}

src/EFCore.PG/Extensions/NpgsqlDatabaseFacadeExtensions.cs

@@ -1,4 +1,5 @@
 using System.Data.Common;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Extensions;
 using Npgsql.EntityFrameworkCore.PostgreSQL.Infrastructure.Internal;
 using Npgsql.EntityFrameworkCore.PostgreSQL.Storage.Internal;
 
@@ -53,4 +54,15 @@ private static IRelationalDatabaseFacadeDependencies GetFacadeDependencies(Datab
 
         throw new InvalidOperationException(RelationalStrings.RelationalNotInUse);
     }
-}
+
+    /// <summary>
+    ///     This is an internal API that supports the Entity Framework Core infrastructure and not subject to
+    ///     the same compatibility standards as public APIs. It may be changed or removed without notice in
+    ///     any release. You should only use it directly in your code with extreme caution and knowing that
+    ///     doing so can result in application failures when updating to a new Entity Framework Core release.
+    /// </summary>
+    public static bool IsCockroachDb(this DatabaseFacade database)
+    {
+        return database.GetDbConnection() is NpgsqlConnection connection && connection.IsCockroachDb();
+    }
+}

src/EFCore.PG/Infrastructure/Internal/INpgsqlSingletonOptions.cs

@@ -22,6 +22,11 @@ public interface INpgsqlSingletonOptions : ISingletonOptions
     /// </summary>
     bool UseRedshift { get; }
 
+    /// <summary>
+    ///     Whether to target CockroachDB.
+    /// </summary>
+    bool UseCockroachDb { get; }
+
     /// <summary>
     ///     Whether reverse null ordering is enabled.
     /// </summary>

src/EFCore.PG/Infrastructure/Internal/NpgsqlOptionsExtension.cs

@@ -52,6 +52,11 @@ public virtual bool IsPostgresVersionSet
     /// </summary>
     public virtual bool UseRedshift { get; private set; }
 
+    /// <summary>
+    /// Whether to target CockroachDB.
+    /// </summary>
+    public virtual bool UseCockroachDb { get; private set; }
+
     /// <summary>
     /// The list of range mappings specified by the user.
     /// </summary>
@@ -96,6 +101,7 @@ public NpgsqlOptionsExtension(NpgsqlOptionsExtension copyFrom) : base(copyFrom)
         AdminDatabase = copyFrom.AdminDatabase;
         _postgresVersion = copyFrom._postgresVersion;
         UseRedshift = copyFrom.UseRedshift;
+        UseCockroachDb = copyFrom.UseCockroachDb;
         _userRangeDefinitions = new List<UserRangeDefinition>(copyFrom._userRangeDefinitions);
         ProvideClientCertificatesCallback = copyFrom.ProvideClientCertificatesCallback;
         RemoteCertificateValidationCallback = copyFrom.RemoteCertificateValidationCallback;
@@ -221,6 +227,22 @@ public virtual NpgsqlOptionsExtension WithRedshift(bool useRedshift)
         return clone;
     }
 
+    /// <summary>
+    /// Returns a copy of the current instance with the specified CockroachDB settings.
+    /// </summary>
+    /// <param name="useCockroachDb">Whether to target CockroachDB.</param>
+    /// <returns>
+    /// A copy of the current instance with the specified CockroachDB setting.
+    /// </returns>
+    public virtual NpgsqlOptionsExtension WithCockroachDb(bool useCockroachDb)
+    {
+        var clone = (NpgsqlOptionsExtension)Clone();
+
+        clone.UseCockroachDb = useCockroachDb;
+
+        return clone;
+    }
+
     /// <summary>
     /// Returns a copy of the current instance configured with the specified value..
     /// </summary>
@@ -268,6 +290,11 @@ public override void Validate(IDbContextOptions options)
         {
             throw new InvalidOperationException($"{nameof(UseRedshift)} and {nameof(PostgresVersion)} cannot both be set");
         }
+
+        if (UseCockroachDb && UseRedshift)
+        {
+            throw new InvalidOperationException($"{nameof(UseCockroachDb)} and {nameof(UseRedshift)} cannot both be set");
+        }
     }
 
     #region Authentication
@@ -368,6 +395,11 @@ public override string LogFragment
                     builder.Append(nameof(Extension.UseRedshift)).Append(' ');
                 }
 
+                if (Extension.UseCockroachDb)
+                {
+                    builder.Append(nameof(Extension.UseCockroachDb)).Append(' ');
+                }
+
                 if (Extension.ProvideClientCertificatesCallback is not null)
                 {
                     builder.Append(nameof(Extension.ProvideClientCertificatesCallback)).Append(" ");
@@ -437,6 +469,7 @@ public override int GetServiceProviderHashCode()
                 hashCode.Add(Extension.AdminDatabase);
                 hashCode.Add(Extension.PostgresVersion);
                 hashCode.Add(Extension.UseRedshift);
+                hashCode.Add(Extension.UseCockroachDb);
                 hashCode.Add(Extension.ProvideClientCertificatesCallback);
                 hashCode.Add(Extension.RemoteCertificateValidationCallback);
                 hashCode.Add(Extension.ProvidePasswordCallback);
@@ -454,7 +487,8 @@ public override bool ShouldUseSameServiceProvider(DbContextOptionsExtensionInfo
                 && ReferenceEquals(Extension.DataSource, otherInfo.Extension.DataSource)
                 && Extension.ReverseNullOrdering == otherInfo.Extension.ReverseNullOrdering
                 && Extension.UserRangeDefinitions.SequenceEqual(otherInfo.Extension.UserRangeDefinitions)
-                && Extension.UseRedshift == otherInfo.Extension.UseRedshift;
+                && Extension.UseRedshift == otherInfo.Extension.UseRedshift
+                && Extension.UseCockroachDb == otherInfo.Extension.UseCockroachDb;
 
         /// <inheritdoc />
         public override void PopulateDebugInfo(IDictionary<string, string> debugInfo)
@@ -468,6 +502,9 @@ public override void PopulateDebugInfo(IDictionary<string, string> debugInfo)
             debugInfo["Npgsql.EntityFrameworkCore.PostgreSQL:" + nameof(NpgsqlDbContextOptionsBuilder.UseRedshift)]
                 = Extension.UseRedshift.GetHashCode().ToString(CultureInfo.InvariantCulture);
 
+            debugInfo["Npgsql.EntityFrameworkCore.PostgreSQL:" + nameof(NpgsqlDbContextOptionsBuilder.UseCockroachDb)]
+                = Extension.UseCockroachDb.GetHashCode().ToString(CultureInfo.InvariantCulture);
+
             debugInfo["Npgsql.EntityFrameworkCore.PostgreSQL:" + nameof(NpgsqlDbContextOptionsBuilder.ReverseNullOrdering)]
                 = Extension.ReverseNullOrdering.GetHashCode().ToString(CultureInfo.InvariantCulture);
 

src/EFCore.PG/Infrastructure/NpgsqlDbContextOptionsBuilder.cs

@@ -46,6 +46,14 @@ public virtual NpgsqlDbContextOptionsBuilder SetPostgresVersion(int major, int m
     public virtual NpgsqlDbContextOptionsBuilder UseRedshift(bool useRedshift = true)
         => WithOption(e => e.WithRedshift(useRedshift));
 
+    /// <summary>
+    /// Configures the provider to work in CockroachDB compatibility mode, which avoids certain unsupported features from modern
+    /// PostgreSQL versions.
+    /// </summary>
+    /// <param name="useCockroachDb">Whether to target CockroachDB.</param>
+    public virtual NpgsqlDbContextOptionsBuilder UseCockroachDb(bool useCockroachDb = true)
+        => WithOption(e => e.WithCockroachDb(useCockroachDb));
+
     /// <summary>
     /// Maps a user-defined PostgreSQL range type for use.
     /// </summary>

src/EFCore.PG/Internal/NpgsqlSingletonOptions.cs

@@ -31,6 +31,14 @@ public class NpgsqlSingletonOptions : INpgsqlSingletonOptions
     /// </summary>
     public virtual bool UseRedshift { get; private set; }
 
+    /// <summary>
+    ///     This is an internal API that supports the Entity Framework Core infrastructure and not subject to
+    ///     the same compatibility standards as public APIs. It may be changed or removed without notice in
+    ///     any release. You should only use it directly in your code with extreme caution and knowing that
+    ///     doing so can result in application failures when updating to a new Entity Framework Core release.
+    /// </summary>
+    public virtual bool UseCockroachDb { get; private set; }
+
     /// <summary>
     ///     This is an internal API that supports the Entity Framework Core infrastructure and not subject to
     ///     the same compatibility standards as public APIs. It may be changed or removed without notice in
@@ -81,6 +89,7 @@ public virtual void Initialize(IDbContextOptions options)
         PostgresVersion = npgsqlOptions.PostgresVersion;
         IsPostgresVersionSet = npgsqlOptions.IsPostgresVersionSet;
         UseRedshift = npgsqlOptions.UseRedshift;
+        UseCockroachDb = npgsqlOptions.UseCockroachDb;
         ReverseNullOrderingEnabled = npgsqlOptions.ReverseNullOrdering;
         UserRangeDefinitions = npgsqlOptions.UserRangeDefinitions;
 
@@ -111,6 +120,14 @@ public virtual void Validate(IDbContextOptions options)
                     nameof(DbContextOptionsBuilder.UseInternalServiceProvider)));
         }
 
+        if (UseCockroachDb != npgsqlOptions.UseCockroachDb)
+        {
+            throw new InvalidOperationException(
+                CoreStrings.SingletonOptionChanged(
+                    nameof(NpgsqlDbContextOptionsBuilder.UseCockroachDb),
+                    nameof(DbContextOptionsBuilder.UseInternalServiceProvider)));
+        }
+
         if (ReverseNullOrderingEnabled != npgsqlOptions.ReverseNullOrdering)
         {
             throw new InvalidOperationException(

src/EFCore.PG/Metadata/Conventions/NpgsqlPostgresModelFinalizingConvention.cs

@@ -1,6 +1,8 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using Npgsql.EntityFrameworkCore.PostgreSQL.Storage.Internal;
+
 namespace Npgsql.EntityFrameworkCore.PostgreSQL.Metadata.Conventions;
 
 /// <summary>
@@ -71,6 +73,11 @@ protected virtual void DiscoverPostgresExtensions(
     /// </summary>
     protected virtual void ProcessRowVersionProperty(IConventionProperty property, RelationalTypeMapping typeMapping)
     {
+        if (_typeMappingSource is NpgsqlTypeMappingSource { IsCockroachDb: true })
+        {
+            return;
+        }
+
         if (property is { ValueGenerated: ValueGenerated.OnAddOrUpdate, IsConcurrencyToken: true }
             && typeMapping.StoreType == "xid")
         {