Oktatóanyag: Sztring keresése normál kifejezésekkel (regex) a C-ben#

A következőkre vonatkozik: SQL Server 2019 (15.x) és újabb verziók

Ez az oktatóanyag bemutatja, hogyan hozhat létre olyan C#-osztályt az SQL Server nyelvbővítményei használatával, amelyek két oszlopot (azonosítót és szöveget) kapnak az SQL Servertől, és egy regex kifejezést bemeneti paraméterként. Az osztály két oszlopot ad vissza az SQL Servernek (azonosító és szöveg).

A C# osztálynak küldött szövegoszlop adott szövege esetén a kód ellenőrzi, hogy a megadott reguláris kifejezés teljesül-e, és az eredeti azonosítóval együtt adja vissza a szöveget.

Ez a mintakód egy reguláris kifejezést használ, amely ellenőrzi, hogy egy szöveg tartalmazza-e a szót C# vagy c#a szót.

Előfeltételek

• Adatbázismotor-példány az SQL Server 2019 (15.x) és újabb verzióiban, a bővíthetőségi keretrendszerrel és a .NET programozási bővítményrel Windows rendszeren. További információ: Mi az AZ SQL Server nyelvi bővítménye? A kódolási követelményekről további információt a .NET-futtatókörnyezet meghívása az SQL Server Language Extensionsben című témakörben talál.

• Adatbázis-ügyfél. Az SQL Server egy példányához bármilyen ismerős SQL Server-ügyféleszközzel csatlakozhat, például sqlcmd, SQL Server Management Studio (SSMS) vagy a Visual Studio Code MSSQL-bővítményével.

• .NET 6 vagy újabb SDK Windows rendszeren.

• Az dotnet-core-CSharp-lang-extension-windows-release.zipSQL Serverhez készült C#-hoz készült Microsoft BővíthetőségI SDK fájlja.

Ehhez az oktatóanyaghoz elegendő a parancssori fordítás dotnet build .

Mintaadatok létrehozása

Először hozzon létre egy új adatbázist, és töltse fel a testdata táblázatot oszlopokkal és ID oszlopokkaltext.

CREATE DATABASE csharptest;
GO

USE csharptest;
GO

CREATE TABLE testdata
(
    [id] INT,
    [text] VARCHAR (100)
);
GO

INSERT INTO testdata (id, "text") VALUES (4, 'This sentence contains C#');
INSERT INTO testdata (id, "text") VALUES (1, 'This sentence does not');
INSERT INTO testdata (id, "text") VALUES (3, 'I love c#!');
INSERT INTO testdata (id, "text") VALUES (2, NULL);
GO

A főosztály létrehozása

Ebben a lépésben hozzon létre egy osztályfájlt, RegexSample.cs és másolja a következő C#-kódot a fájlba.

Ez a főosztály importálja az SDK-t, ami azt jelenti, hogy az első lépésben letöltött C#-fájlt ebből az osztályból kell felderíteni.

using System;
using System.Runtime.InteropServices;
using System.Collections.Generic;
using Microsoft.Data.Analysis;
using Microsoft.SqlServer.CSharpExtension.SDK;
using System.Text.RegularExpressions;

namespace UserExecutor
{
    /// <summary>
    /// This class extends the AbstractSqlServerExtensionExecutor and uses
    /// a regular expression that checks if a text contains the word "C#" or "c#"
    /// </summary>
    public class CSharpRegexExecutor: AbstractSqlServerExtensionExecutor
    {
        /// <summary>
        /// This method overrides the Execute method from AbstractSqlServerExtensionExecutor.
        /// </summary>
        /// <param name="input">
        /// A C# DataFrame contains the input dataset.
        /// </param>
        /// <param name="sqlParams">
        /// A Dictionary contains the parameters from SQL server with name as the key.
        /// </param>
        /// <returns>
        /// A C# DataFrame contains the output dataset.
        /// </returns>
        public override DataFrame Execute(DataFrame input, Dictionary<string, dynamic> sqlParams){
            // Drop NULL values and sort by id
            //
            input = input.DropNulls().OrderBy("id");

            // Create empty output DataFrame with two columns
            //
            DataFrame output = new DataFrame(new PrimitiveDataFrameColumn<int>("id", 0), new StringDataFrameColumn("text", 0));

            // Filter text containing specific substring using regex expression
            //
            DataFrameColumn texts = input.Columns["text"];
            for(int i = 0; i < texts.Length; ++i)
            {
                if(Regex.IsMatch((string)texts[i], sqlParams["@regexExpr"]))
                {
                    output.Append(input.Rows[i], true);
                }
            }

            // Modify the parameters
            //
            sqlParams["@rowsCount"]  = output.Rows.Count;
            sqlParams["@regexExpr"] = "Success!";

            // Return output dataset as a DataFrame
            //
            return output;
        }
    }
}

DLL-fájl fordítása és létrehozása

Csomagolja be az osztályokat és a függőségeket egy DLL-be. Létrehozhat egy .csproj hívott RegexSample.csproj fájlt, és a következő kódot másolhatja ebbe a fájlba.

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <TargetFramework>net6.0</TargetFramework>
    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
    <EnableDynamicLoading>true</EnableDynamicLoading>
  </PropertyGroup>
  <PropertyGroup>
    <OutputPath>$(BinRoot)/$(Configuration)/</OutputPath>
    <AppendTargetFrameworkToOutputPath>false</AppendTargetFrameworkToOutputPath>
  </PropertyGroup>
  <ItemGroup>
    <PackageReference Include="Microsoft.Data.Analysis" Version="0.4.0" />
  </ItemGroup>
  <ItemGroup>
    <Reference Include="Microsoft.SqlServer.CSharpExtension.SDK">
      <HintPath>[path]\Microsoft.SqlServer.CSharpExtension.dll</HintPath>
    </Reference>
  </ItemGroup>
</Project>

Nyissa meg a projektmappát, és futtassa dotnet builda következő fájlt létrehozó fájlt:

path\to\project\bin\Debug\RegexSample.dll

További információ: .NET DLL létrehozása C# projektből.

Külső nyelv létrehozása

Létre kell hoznia egy külső nyelvet az adatbázisban. A külső nyelv egy adatbázis hatókörébe tartozó objektum, ami azt jelenti, hogy minden olyan adatbázishoz létre kell hozni a C#-hoz hasonló külső nyelveket, amelyekben használni szeretné.

1. Hozzon létre egy .zip fájlt, amely tartalmazza a bővítményt.

   A Windows SQL Server telepítésének részeként a .NET-bővítményfájl .zip a következő helyre van telepítve: <SQL Server install path>\MSSQL\Binn>\dotnet-core-CSharp-lang-extension.zip. Ez a zip-fájl tartalmazza a nativecsharpextension.dll.

2. Hozzon létre egy külső nyelvet dotnet a .zip fájlból:

   CREATE EXTERNAL LANGUAGE [dotnet]
   FROM (
       CONTENT = N'<path>\dotnet-core-CSharp-lang-extension.zip',
       FILE_NAME = 'nativecsharpextension.dll'
   );
   GO
   

Engedélyek beállítása

A .NET C# kód végrehajtásához a felhasználónak SID S-1-15-2-1 (<LocalMachineName>\ALL APPLICATION PACKAGES) olvasási engedélyeket kell adni a \MSSQL mappához.

1. Kattintson a jobb gombbal a mappára, és válassza a Tulajdonságok>
2. Válassza a Szerkesztés lehetőséget
3. Válassza ki a -t, adja hozzá a-et
4. Felhasználók , számítógépek, szolgáltatásfiókok vagy csoportok kiválasztásakor:
   1. Válassza az Objektumtípusok lehetőséget , és győződjön meg arról , hogy a beépített biztonsági alapelvek és csoportok ki van választva
   2. Válassza a Helyek lehetőséget a helyi számítógép nevének kiválasztásához a lista tetején
   3. Adja meg ALL APPLICATION PACKAGES, ellenőrizze a nevet, és válassza az OK gombot a hozzáadáshoz. Ha a név nem oldható fel, tekintse meg újra a Helyek lépést. A rendszerazonosító (SID) helyi a számítógépen.

További információ: CREATE EXTERNAL LANGUAGE.

Külső kódtárak létrehozása

A CREATE EXTERNAL LIBRARY használatával hozzon létre egy külső tárat a DLL-fájlokhoz. Az SQL Server hozzáfér a .dll fájlokhoz, és nem kell külön engedélyeket beállítania a classpath.

Hozzon létre egy külső kódtárat a RegEx-kódhoz.

CREATE EXTERNAL LIBRARY [regex.dll]
FROM (CONTENT = N'<path>\RegexSample.dll')
WITH (LANGUAGE = 'Dotnet');
GO

A C# osztály meghívása

Hívja meg a tárolt eljárást sp_execute_external_script a C#-kód SQL Serverről való meghívásához. A szkriptparaméterben adja meg, hogy melyiket libraryname;namespace.classname szeretné meghívni. Az erőforrástár nevének megadása nélkül is megadhatja, hogy melyiket namespace.classname szeretné meghívni. A bővítmény megkeresi az első olyan könyvtárat, amely tartalmazza a megfelelő namespace.classname-t. Az alábbi kódban az osztály egy névtérhez tartozik, és egy úgynevezett UserExecutorCSharpRegexExecutorosztályhoz.

A kód nem határozza meg, hogy melyik metódust kell meghívni. Alapértelmezés szerint meghívják a Execute metódust. Ez azt jelenti, hogy követnie kell az SDK-felületet, és implementálnia kell egy metódust Execute a C# osztályban, ha meg szeretné hívni az osztályt az SQL Serverről.

A tárolt eljárás egy bemeneti lekérdezést (bemeneti adatkészletet) és egy reguláris kifejezést használ, és visszaadja azokat a sorokat, amelyek teljesítették az adott reguláris kifejezést. Egy reguláris kifejezést [Cc]# használ, amely ellenőrzi, hogy egy szöveg tartalmazza-e a szót vagy C#a szótc#.

DECLARE @rowsCount AS INT;
DECLARE @regexExpr AS VARCHAR (200);

SET @regexExpr = N'[Cc]#';

EXECUTE sp_execute_external_script
    @language = N'dotnet',
    @script = N'regex.dll;UserExecutor.CSharpRegexExecutor',
    @input_data_1 = N'SELECT * FROM testdata',
    @params = N'@regexExpr VARCHAR(200) OUTPUT, @rowsCount INT OUTPUT',
    @regexExpr = @regexExpr OUTPUT,
    @rowsCount = @rowsCount OUTPUT
    WITH RESULT SETS
(
        (id INT, TEXT VARCHAR (100))
);

SELECT @rowsCount AS rowsCount, @regexExpr AS message;

Results

A hívás végrehajtása után két sorból álló eredményhalmazt kell kapnia.

Kapcsolódó tartalom

• A .NET-futtatókörnyezet meghívása az SQL Server nyelvi bővítményeiben
• Mik az SQL Server nyelvi bővítményei?
• C# .NET és SQL Server által támogatott adattípusok