Gestern hatte ich ja schon die Basics für SQL-CLR Integration beschrieben, heute treiben wir das mal weiter auf die Spitze: Wir wollen Regular Expressions im SQL Server nutzen.
Dazu erweitern wir uns ersteinmal die Klasse um drei neue Funktionen:
- RegEx_HasMatches soll uns sagen ob überhaupt Matches auftreten
- RegEx_MatchCount soll uns sagen wie viele Matches auftreten
- RegEx_GetMatches soll uns die Matches aufsgeben
Für die Copy+Paster unter euch ;) :
<SqlFunction()> _
Public Shared Function RegEx_HasMatches(ByVal inputstring As SqlString, ByVal regexstring As SqlString) As SqlBoolean
If Regex.Matches(inputstring.Value, regexstring.Value, RegexOptions.IgnoreCase).Count > 0 Then
Return True
Else
Return False
End If
End Function
<SqlFunction()> _
Public Shared Function RegEx_MatchCount(ByVal inputstring As SqlString, ByVal regexstring As SqlString) As SqlInt64
Return Regex.Matches(inputstring.Value, regexstring.Value, RegexOptions.IgnoreCase).Count
End Function
<SqlFunction()> _
Public Shared Sub RegEx_GetMatches(ByVal inputstring As SqlString, ByVal regexstring As SqlString)
Dim mc As MatchCollection = Regex.Matches(inputstring.Value, regexstring.Value, RegexOptions.IgnoreCase)
Dim result As New SqlDataRecord(New SqlMetaData("Match", SqlDbType.NVarChar, 4000))
Dim pipe As SqlPipe = SqlContext.Pipe
pipe.SendResultsStart(result)
For Each item As Match In mc
result.SetString(0, item.Value)
pipe.SendResultsRow(result)
Next
pipe.SendResultsEnd()
End Sub
Nach dem Bereitstellen können wir das ganze auch schon testen:
declare @inputstring nvarchar(4000)
set @inputstring= 'My favorite web sites include:
</P><A HREF="http://www.xentrope.de">Xylon''s Blog</A></P>
<A HREF="http://dotnet-forum.de">.NET Forum</A></P>
<A HREF="http://blogs.msdn.com/bclteam">.NET Base Class Library blog</A></P>'
declare @regexstring nvarchar(4000)
set @regexstring = 'href\s*=\s*(?:"(?<1>[^"]*)"|(?<1>\S+))'
select dbo.RegEx_HasMatches(@inputstring,@regexstring) 'HasMatches'
,dbo.RegEx_MatchCount(@inputstring,@regexstring) 'Nr of Matches'
exec dbo.RegEx_GetMatches @inputstring,@regexstring
Und als Ergebnisse bekommen wir:
HasMatches Nr of Matches
1 3
Match
HREF="http://www.xentrope.de"
HREF="http://dotnet-forum.de"
HREF="http://blogs.msdn.com/bclteam"
Coole Sache! :)
Eine beliebte Stringfunktion fehler leider nach wie vor im SLQ Server: Split. Das hat sich auch mit dem neuen SQL Server 2008 immer noch nicht geändert. Ich hatte ja schon mal eine Splitfunktion gepostet, möchte dies aber jetzt als CLR Funktion implementieren. Lange Reder kurzer Sinn:
- Man erstellt im Visual Studio ein neues Datenbankprojekt.
- In den Projekteinstellungen sollte die Assembly signiert werden (Einstellungen – Signing – Sign the assembly)
- Unter dem Karteireiter “Database” kann vorerst das Permissionlevel auf Safe bleiben, da wir ja keine externen Resources ansprechen wollen.
Safe = Zugriff auf Daten des eigenen SQL Servers über den In-process Managed Provider
External = Zugriff auf externe Resourcen ist erlaubt
Unsafe = Es kann unmanaged Code ausgeführt werden
Erhält man eine Fehlermeldung beim Bereitstellen der Assembly, kann es daran liegen das der Datenbank nicht vertraut wird. Dann sollte man die Trustworthy Eigenschaft setzen:
Alter Database [DB] Set Trustworthy on
- Man fügt dem Projekt eine neue Klasse hinzu, ich habe sie einfach “Stringfunctions” genannt.
- Dieser Klasse fügen wir eine Prozedur hinzu:
<SqlProcedure()> _
Public Shared Sub Split(ByVal Input As SqlString, ByVal Delimiter As SqlString)
Dim pipe As SqlPipe = SqlContext.Pipe
Dim splittet() As String = Input.Value.Split(Delimiter.Value.ToCharArray)
Dim reslist As New List(Of SqlMetaData)
For i As Integer = 0 To splittet.Length - 1
reslist.Add(New SqlMetaData("Col" + i.ToString(), SqlDbType.NVarChar, 4000))
Next
Dim result As New SqlDataRecord(reslist.ToArray())
For i As Integer = 0 To splittet.Length - 1
result.SetString(i, splittet(i))
Next
pipe.Send(result)
End Sub
Das Attribut SqlProcedure() sorgt dafür, das beim Bereitstellen automatisch eine neue Stored Procedure angelegt wird. Als Parameter der Prozedur übergeben wir zwei SQLStrings: Input und Delimiter. Wofür diese stehen sagen die Namen ja schon… ;) Um die Anzahl der notwendigen Spalten in unserer Ergnistabelle zu ermitteln legen wir uns ersteinmal eine neue Liste mit Spaltendefinitionen an. Danach wird unsere Ergebnistabelle erstellt:
Dim result As New SqlDataRecord(reslist.ToArray())
Jetzt können wir endlich alle Elemente aus dem Array in die Ergebnistabelle schreiben und zurückgeben:
For i As Integer = 0 To splittet.Length - 1
result.SetString(i, splittet(i))
Next
pipe.Send(result)
Die Verwendung der Funktion ist denkbar einfach:
exec Split 'feld1;feld2;feld3;feld4;feld5;feld6;feld7',';'
Und liefert uns eine Tabelle zurück:
Col0 Col1 Col2 Col3 Col4 Col5 Col6
feld1 feld2 feld3 feld4 feld5 feld6 feld7
SQL-Statement für jede Tabelle in der aktuellen Datenbank ausführen
exec sp_MSforeachtable '[SQL-Statement]'
SQL-Statement für jede Datenbank ausführen
exec sys.sp_MSforeachdb '[SQl-Statement]'
Tabelleninformationen auslesen (Erstellungsdatum, Schema, Tabellentyp (Table/View) etc.)
exec sys.sp_tables_rowset '[Tabellenname]'
Spalten in der Tabelle (Name, Collation)
exec sys.sp_tablecollations '[Tabellenname]'
Stored Procedures in der aktuellen Datenbank (Name, Owner, Anzahl Eingabeparameter (-1 = 0), Anzahl Ausgabeparameter (-1 = 0), Prozedurtyp)
exec sys.sp_stored_procedures
Ein anderes interessantes Phänomen lief mir gerade über den Weg: Liest man aus einem SQL Server eine richtig lange Zeichenkette (z.B. mehr als 2000 Zeichen, z.B. mit einer ‘FOR XML …’ Transformation im Select) wird einem das Ergebnis willkürlich bei um die 1000 Zeichen abgeschitten.
Eine generelle Workaroundfunktion ist schnell gebastelt:
Private Shared Function GetLongStringData(ByVal statement As String) As String
Dim sql As New System.Data.SqlClient.SqlCommand()
Dim con As New System.Data.SqlClient.SqlConnection()
con.ConnectionString = "connectionstring"
sql.CommandText = statement
sql.Connection = con
con.Open()
Dim r As System.Data.SqlClient.SqlDataReader = sql.ExecuteReader()
Dim strbuilder As New StringBuilder()
While r.Read()
strbuilder.Append(r(0))
End While
con.Close()
Return strbuilder.ToString()
End Function
Stellt sich allerdings nach wie vor die Frage warum die Daten abgeschnitten werden. Im SQL Server Management Studio wird alles korrekt angezeigt. Ich vermute das Problem liegt irgendwo bei der Übergabe vom SQL Server in den .Net String. Wenn jemand eine Idee hat, möge er sich bei mir melden. :)
Wer mal folgendes versucht:
select
(case
when bedingung1 then
(case
when bedingung2 then statement2
when bedingung3 then statement3
when bedingung4 then statement4
when bedingung5 then statement5
when bedingung6 then statement6
when bedingung7 then statement7
when bedingung8 then statement8
when bedingung9 then statement9
when bedingung10 then statement10
when bedingung11 then statement11
else statement12
end)
else statement1
end)
from linked_server.database.schema.table
wird feststellen, das einem der SQL Server eine Fehlermeldung bringt:
Meldung 8180, Ebene 16, Status 1, Zeile 1
Statement(s) could not be prepared.
Meldung 125, Ebene 15, Status 4, Zeile 1
Case expressions may only be nested to level 10.
Leider findet man hierzu nichts in der MSDN und auch sonst im Web wurde ich nicht fündig um diesen Fehler zu beheben. Wobei die Ursache relativ simpel ist, und die Fehlermeldung einen schon drauf hinweist: Case Statements dürfen über eine Linked-Server Verbindung nur bis maximal 10 Schachtelungen haben.
So einen Hinweis hätte ich eigentlich in der MSDN erwartet!
Das kann man auch nicht durch irgendwelche Einstellungen am Linked Server ändern. Da hilft nur eine Behelfsview in der Quelldatenbank. Dann kann man auch fröhlich und mit einer Erfahrung mehr die Datenmigration fortsetzen.
Kann man immer wieder mal brauchen: Eine Split-Funktion für MSSQL (ab 2000).
CREATE FUNCTION [dbo].[udf_ItemExtract]
(
@Position INTEGER,
@List VARCHAR(2000), --VARCHAR(MAX)
@Delimiter VARCHAR(1)
)
RETURNS VARCHAR(2000) --VARCHAR(MAX)
AS
BEGIN
DECLARE @RetVal VARCHAR(2000) SET @RetVal = '' --VARCHAR(MAX)
DECLARE @Counter INT SET @Counter = 0
DECLARE @StartPos INT
DECLARE @Length INT
DECLARE @DelimPos INT SET @DelimPos = 0
-- SCAN THROUGH UNTIL WE FIND THE ITEM AT THE POSITION OF THE INDEX - WE'LL GO THROUGH WHILE LOOP AT LEAST ONCE
WHILE @Counter < @Position
BEGIN
SET @Counter = @Counter + 1 -- increment counter
SET @StartPos = @DelimPos + 1 -- move the start position to right after previously found delimiter (or 1st char if this is the fist time through
SET @DelimPos = CHARINDEX(@Delimiter,@List,@DelimPos + 1) --find the next delimiter
-- IF THERE ARE NO DELIMITERS LEFT...
IF @DelimPos = 0
BEGIN
-- IF WE'RE ON THE POSITION WE'RE LOOKING FOR, THEN SET LENGTH TO THE REST OF THE STRING
IF @Counter = @Position SET @Length = (LEN(@List)+1)-@StartPos
-- OTHERWISE SET LENGTH TO -1 AND THAT WILL BE AN INDICATOR TO RETURN EMPTY STRING
ELSE SET @Length = -1
END
ELSE SET @Length = @DelimPos - @StartPos -- otherwise length is now from new start pos right up to delimiter
END
-- RETURN THE EXTRACTED STRING
IF @Length > 0 SET @RetVal = SUBSTRING(@List,@StartPos,@Length)
RETURN @RetVal
END
