wie SQL-Abfrage-Leistung in meinem Fall zu verbessern

Question

Ich habe eine Tabelle, Schema ist sehr einfach, eine ID-Spalte als eindeutiger Primärschlüssel (uniqueidentifier Typ) und einige andere Nvarchar-Spalten. Mein aktuelles Ziel ist es, für 5000 Eingaben zu berechnen, welche bereits in der Tabelle enthalten sind und welche nicht. Tht-Eingaben sind Zeichenfolge und ich habe eine C# -Funktion, die Zeichenfolge in Uniqueidentifier (GUID) konvertiert. Meine Logik ist, wenn es eine vorhandene ID gibt, behandle ich die Zeichenfolge als bereits in der Tabelle enthalten.

Meine Frage ist, wenn ich herausfinden muss, welche aus den 5000 Eingabezeichenfolgen bereits in DB enthalten sind, und was nicht, was ist der effizienteste Weg?

BTW: Meine aktuelle Implementierung ist, konvertieren Zeichenfolge in GUID mit C# -Code, dann aufrufen/implementieren eine Speicherprozedur, die Abfrage, ob eine ID in der Datenbank vorhanden ist und zurück zu C# -Code.

Meine Arbeitsumgebung: VSTS 2008 + SQL Server 2008 + C# 3.5.

Answer 1

Mein erster Instinkt wäre Ihre 5000 Eingänge in eine einspaltig temporäre Tabelle X zu pumpen, möglicherweise Index, und dann verwenden:

SELECT X.thecol 
FROM X 
JOIN ExistingTable USING (thecol) 

auf diejenigen zu bekommen, die vorhanden sind, und (wenn beide Sätze werden benötigt)

SELECT X.thecol 
FROM X 
LEFT JOIN ExistingTable USING (thecol) 
WHERE ExistingTable.thecol IS NULL 

um diejenigen zu bekommen, die abwesend sind. Mindestens Benchmarking wert.

Edit: wie angefordert, hier sind einige gute docs & Tutorials auf temporäre Tabellen in SQL Server. Bill Graziano hat eine einfache Einführung, die temporäre Tabellen, Tabellenvariablen und globale temporäre Tabellen abdeckt. Randy Dyess und SQL Master diskutieren Leistungsproblem für und gegen sie (aber denken Sie daran, dass wenn Sie Performance-Probleme haben Sie wollen, Benchmark-Alternativen, nicht gehen Sie einfach auf theoretische Überlegungen! -).

MSDN hat Artikel auf tempdb (wo temporäre Tabellen gespeichert sind) und optimizing seine Leistung.

Answer 2

Versuchen Sie sicherzustellen, dass Sie nur eine Abfrage ausführen. Wenn Ihre Lösung beispielsweise 5000 Abfragen für die Datenbank ausführt, ist dies wahrscheinlich der größte Ressourcenverbraucher für die Operation.

Wenn Sie die 5000 IDs in eine temporäre Tabelle einfügen können, können Sie eine einzelne Abfrage schreiben, um diejenigen zu finden, die nicht in der Datenbank vorhanden sind.

Answer 3

Was müssen Sie mit den Einträgen tun, die in Ihrer Tabelle vorhanden sind oder nicht?

Je nachdem, was Sie benötigen, möglicherweise die neue MERGE Anweisung in SQL Server 2008 könnte Ihre Rechnung passen - zu aktualisieren, was bereits vorhanden ist, fügen Sie neue Sachen, alle ordentlich in eine einzige SQL-Anweisung. Hör zu!

• http://blogs.conchango.com/davidportas/archive/2007/11/14/SQL-Server-2008-MERGE.aspx
• http://www.sql-server-performance.com/articles/dba/SQL_Server_2008_MERGE_Statement_p1.aspx
• http://blogs.msdn.com/brunoterkaly/archive/2008/11/12/sql-server-2008-merge-capability.aspx

Ihre Aussage würde wie folgt aussehen:

MERGE INTO 
    (your target table) AS t 
USING 
    (your source table, e.g. a temporary table) AS s 
ON t.ID = s.ID 
WHEN NOT MATCHED THEN -- new rows does not exist in base table 
    ....(do whatever you need to do) 
WHEN MATCHED THEN  -- row exists in base table 
    ... (do whatever else you need to do) 
; 

dies wirklich schnell zu machen, würde ich die "neue" Datensätze laden von zB Datei eine TXT oder CSV in eine temporäre Tabelle in SQL Server unter Verwendung von Bulk:

BULK INSERT YourTemporaryTable 
FROM 'c:\temp\yourimportfile.csv' 
WITH 
(
    FIELDTERMINATOR =',', 
    ROWTERMINATOR =' |\n' 
) 

INSERT BULK mit MERGE kombiniert sollten Sie die beste Leistung geben Sie auf diesem Planeten :-)

Marc

bekommen

PS: hier ist eine Notiz von TechNet auf MERGE Leistung und warum es schneller ist als Einzelaussage:

In SQL Server 2008 können Sie mehrere Datenbearbeitungssprache (DML) durchzuführen, in einer einzigen Anweisung mit der MERGE-Anweisung. Beispielsweise müssen Sie möglicherweise zwei Tabellen synchronisieren, indem Sie Zeilen in einer Tabelle basierend auf den in der anderen Tabelle gefundenen Unterschieden einfügen, aktualisieren oder löschen. In der Regel erfolgt dies durch Ausführen einer gespeicherten Prozedur oder eines Stapels, der einzelne INSERT-, UPDATE- und DELETE-Anweisungen enthält. Dies bedeutet jedoch, dass die Daten sowohl in der Quell- als auch in der Zieltabelle mehrfach ausgewertet und verarbeitet werden. mindestens einmal für jede Aussage. Mithilfe der MERGE-Anweisung können Sie die einzelnen DML-Anweisungen durch eine einzelne Anweisung ersetzen. Dies kann die Abfrageleistung verbessern, da die Vorgänge in einer einzigen Anweisung ausgeführt werden und somit die Anzahl der Verarbeitungsvorgänge der Daten in den Quell- und Zieltabellen minimiert wird. Leistungssteigerungen hängen jedoch von korrekten Indizes, Joins und anderen Überlegungen ab. Dieses Thema enthält Best-Practice-Empfehlungen, mit denen Sie eine optimale Leistung bei Verwendung der MERGE-Anweisung erzielen können.

Answer 4

Schritt 1. Stellen Sie sicher, dass Sie ein Problem zu lösen haben. Fünftausend Inserts ist nicht viel, um in vielen Kontexten eins nach dem anderen einzufügen.

Sind Sie sicher, dass der einfachste Weg nicht ausreicht? Welche Leistungsprobleme haben Sie bisher gemessen?

Answer 5

Wenn Sie Einfachheit wollen, da 5000 Datensätze nicht sehr viele sind, dann verwenden Sie aus C# einfach eine Schleife, um eine Insert-Anweisung für jede der Zeichenfolgen zu generieren, die Sie der Tabelle hinzufügen möchten. Wickeln Sie die Einfügung in einen TRY CATCH-Block. Senden Sie sie alle in einem Schuss wie diese auf den Server hoch:

BEGIN TRY 
INSERT INTO table (theCol, field2, field3) 
SELECT theGuid, value2, value3 
END TRY BEGIN CATCH END CATCH 

BEGIN TRY 
INSERT INTO table (theCol, field2, field3) 
SELECT theGuid, value2, value3 
END TRY BEGIN CATCH END CATCH 

BEGIN TRY 
INSERT INTO table (theCol, field2, field3) 
SELECT theGuid, value2, value3 
END TRY BEGIN CATCH END CATCH 

wenn Sie einen eindeutigen Index oder Primärschlüssel auf dem String GUID definiert haben, dann werden die doppelten Einsätze scheitern. Wenn Sie im Voraus überprüfen, ob der Datensatz nicht existiert, werden nur Duplikate ausgeführt, die SQL ohnehin ausführen wird.

Wenn die Leistung wirklich wichtig ist, dann sollten Sie die 5000 GUIDS auf Ihre lokale Station herunterladen und alle Analysen durchführen. Das Lesen von 5000 GUIDs sollte viel weniger als 1 Sekunde dauern. Dies ist einfacher als der Massenimport in eine temporäre Tabelle (dies ist die einzige Möglichkeit, Leistung von einer temporären Tabelle zu erhalten) und eine Aktualisierung mithilfe einer Verknüpfung zur temporären Tabelle.

Answer 6

Auf keinen Fall eins nach dem anderen.

Meine bevorzugte Lösung ist eine gespeicherte Prozedur mit einem Parameter zu erstellen, die in folgendem Format nehmen und XML können:

<ROOT> 
    <MyObject ID="60EAD98F-8A6C-4C22-AF75-000000000000"> 
    <MyObject ID="60EAD98F-8A6C-4C22-AF75-000000000001"> 
    .... 
</ROOT> 

Dann in dem Verfahren mit dem Argument vom Typ NCHAR (MAX) Sie wandeln es in XML, nach was Sie es als Tabelle mit einer einzelnen Spalte verwenden (nennen wir es @FilterTable). Der Speichervorgang wie folgt aussieht:

CREATE PROCEDURE dbo.sp_MultipleParams(@FilterXML NVARCHAR(MAX)) 
AS BEGIN 
    SET NOCOUNT ON 

    DECLARE @x XML 
    SELECT @x = CONVERT(XML, @FilterXML) 

    -- temporary table (must have it, because cannot join on XML statement) 
    DECLARE @FilterTable TABLE (
     "ID" UNIQUEIDENTIFIER 
    ) 

    -- insert into temporary table 
    -- @important: XML iS CaSe-SenSiTiv 
    INSERT  @FilterTable 
    SELECT  x.value('@ID', 'UNIQUEIDENTIFIER') 
    FROM  @x.nodes('/ROOT/MyObject') AS R(x) 

    SELECT  o.ID, 
       SIGN(SUM(CASE WHEN t.ID IS NULL THEN 0 ELSE 1 END)) AS FoundInDB 
    FROM  @FilterTable o 
    LEFT JOIN dbo.MyTable t 
      ON o.ID = t.ID 
    GROUP BY o.ID 

END 
GO 

Sie führen es als:

EXEC sp_MultipleParams '<ROOT><MyObject ID="60EAD98F-8A6C-4C22-AF75-000000000000"/><MyObject ID="60EAD98F-8A6C-4C22-AF75-000000000002"/></ROOT>' 

Und Ihre Ergebnisse wie folgt aussehen:

ID         FoundInDB 
------------------------------------ ----------- 
60EAD98F-8A6C-4C22-AF75-000000000000 1 
60EAD98F-8A6C-4C22-AF75-000000000002 0 

Answer 7

Da Sie SQL Server 2008 verwenden, können Sie Tabelle verwenden könnte -bewertete Parameter. Es ist eine Möglichkeit, eine Tabelle als Parameter für eine gespeicherte Prozedur bereitzustellen.

Mit ADO.NET können Sie einfach eine DataTable vorbelegen und als SqlParameter übergeben. Schritte müssen Sie ausführen:

Erstellen einer benutzerdefinierten SQL-Typ

CREATE TYPE MyType AS TABLE 
(
UniqueId INT NOT NULL, 
Column NVARCHAR(255) NOT NULL 
) 

eine gespeicherte Prozedur erstellen, die den Typ

CREATE PROCEDURE spInsertMyType 
@Data MyType READONLY 
AS 
xxxx 

Anruf mit C#

SqlCommand insertCommand = new SqlCommand(
    "spInsertMyType", connection); 
insertCommand.CommandType = CommandType.StoredProcedure; 
SqlParameter tvpParam = 
    insertCommand.Parameters.AddWithValue(
    "@Data", dataReader); 
tvpParam.SqlDbType = SqlDbType.Structured; 

Verbindungen akzeptiert: Table-valued Parameters in Sql 2008