{"id":55000476,"date":"2025-10-01T00:00:00","date_gmt":"2025-12-28T17:56:10","guid":{"rendered":"http:\/\/access-im-unternehmen.aix-dev.de\/aiu\/?p=476"},"modified":"-0001-11-30T00:00:00","modified_gmt":"-0001-11-30T00:00:00","slug":"CodeSnippets_im_SQL_Server_Management_Studio","status":"publish","type":"post","link":"https:\/\/vbentwickler.de\/CodeSnippets_im_SQL_Server_Management_Studio\/","title":{"rendered":"Code-Snippets im SQL Server Management Studio"},"content":{"rendered":"

\"\"Es gibt Code-Snippets, die man immer wieder verwendet – sei es, um Tabellen, Views oder gespeicherte Prozeduren zu erstellen, Tabellen oder Indizes zu definieren und vieles mehr. Vielleicht nutzt Du auch verschiedene System-Befehle, um verschiedene Aktionen im Abfragefenster auszulösen, um beispielsweise Informationen zur Datenbank zu ermitteln. Solche Snippets hast Du vielleicht in einer Textdatei gespeichert, um sie jederzeit in das Abfragefenster kopieren zu können. Es gibt jedoch eine viel mächtigere Möglichkeit, solche Code-Snippets zu nutzen: Das Abfragefenster bietet nämlich die Möglichkeit, Code-Snippets per Kontextmenü einzufügen. Das Beste daran ist: Wir können sogar eigene Code-Snippets definieren, die darüber ausgewählt und eingefügt werden können. In diesem Artikel schauen wir uns an, wie wir diese Funktion nutzen können und wie wir sogar eigene Code-Snippets in diesem Menü verfügbar machen können.<\/b><\/p>\n

Eingebaute Code-Snippets nutzen<\/h2>\n

Als Erstes schauen wir uns an, wie die eingebauten Code-Snippets genutzt werden können. <\/p>\n

Dazu öffnen wir ein beliebiges Abfragefenster, am besten im Kontext der Datenbank, in der wir den Code-Schnipsel nutzen wollen.<\/p>\n

Dazu markieren wir die Datenbank und öffnen dann mit der Tastenkombination Strg + N <\/b>ein neues Abfragefenster. Hier können wir das Kontextmenü öffnen und finden den Eintrag Schnipsel einfügen… <\/b>vor. Alternativ können wir die Tastenkombination Strg + K, Strg + X <\/b>nutzen (siehe Bild 1).<\/p>\n

\"Schnipsel<\/p>\n

Bild 1: Schnipsel einfügen per Kontextmenü im Abfragefenster<\/span><\/b><\/p>\n

Dies öffnet das Widget aus Bild 2. Hier sehen wir den Befehl Schnipsel einfügen <\/b>und eine Auflistung der verschiedenen Kategorien.<\/p>\n

\"Auswahl<\/p>\n

Bild 2: Auswahl der Kategorien für die Code-Schnipsel<\/span><\/b><\/p>\n

Wählen wir eine aus, zum Beispiel Stored Procedure<\/b>, sehen wir alle in dieser Kategorie verfügbaren Schnipsel (siehe Bild 3). Außerdem zeigt dieser Bereich für den aktuell markierten Eintrag noch einen Hilfetext an.<\/p>\n

\"Auswahl<\/p>\n

Bild 3: Auswahl der Schnipsel einer Kategorie<\/span><\/b><\/p>\n

Wir wählen den Eintrag Standardvorlage für eine Prozedur erstellen <\/b>aus und sehen das Ergebnis aus Bild 4. Hier sind verschiedene Texte mit einem gelben Hintergrund markiert. Diese können wir nun mit der Tabulator-Taste durchlaufen. Der aktuelle Eintrag wird markiert, sodass wir diesen direkt durch den gewünschten Text ersetzen können. Wir würden also nun die einzelnen Texte durch die von uns gewünschten Texte einfach überschreiben und erhalten so die gewünschte gespeicherte Prozedur.<\/p>\n

\"Ein<\/p>\n

Bild 4: Ein frisch hinzugefügter Schnipsel<\/span><\/b><\/p>\n

Eigene Schnipsel nutzen<\/h2>\n

Es wird noch besser: Wir können nämlich eigene Schnipsel definieren, die dann ebenfalls im Schnipsel-Menü angezeigt werden.<\/p>\n

Erst einmal grundlegende Informationen:<\/p>\n

    \n
  • Es gibt zwei Bereiche, in denen die Schnipsel gespeichert werden. Der erste ist der Bereich mit den eingebauten Schnipseln. Der zweite ist der Bereich für die benutzerdefinierten Schnipsel.<\/li>\n
  • Wir können in beiden Bereichen eigene Schnipsel hinzufügen. Allerdings raten wir davon ab, Schnipsel zu den eingebauten Schnipseln hinzuzufügen, denn diese werden bei Updates von SQL Server Management Studio gegebenenfalls überschrieben.<\/li>\n
  • Allerdings können wir die eingebauten Schnipsel als Beispielmaterial für eigene Schnipsel verwenden.<\/li>\n
  • Wenn wir einen eigenen Schnipsel in dem dafür vorgesehenen Bereich angelegt haben, wird dieser erst beim nächsten Öffnen des SQL Server Management Studios angezeigt.<\/li>\n<\/ul>\n

    Speicherort für benutzerdefinierte Schnipsel<\/h2>\n

    Die benutzerdefinierten Schnipsel speichern wir in dem folgenden Ordner ab, hier zum Beispiel für die Version 21 von SQL Server Management Studio:<\/p>\n

    C:\\Users\\User\\Documents\\SQL Server Management Studio 21\\Code Snippets\\SQL\\My Code Snippets<\/pre>\n
    Hier können wir direkt eigene Schnipsel speichern, aber wir können auch Unterordner erstellen, die dann entsprechend im Schnipsel-Widget angezeigt werden.<\/p>\n
    Einen ersten eigenen Schnipsel erstellen<\/h2>\n
    Damit kommen wir zum spannenden Teil: Wir legen unseren ersten eigenen Schnipsel an.<\/p>\n
    Das können wir mit einem komplett neuen Schnipsel machen oder wir nutzen einen der Schnipsel als Vorlage. <\/p>\n
    Komplett neuen Schnipsel anlegen<\/h2>\n
    Für einen komplett neuen Schnipsel erstellen wir eine neue Textdatei und fügen dieser den gewünschten Text hinzu. Das kann eine einfache Anweisung sein, die Du immer wieder benötigst und die Du nicht immer im Internet suchen und einfügen möchtest.<\/p>\n
    Das folgende Skript zeigt beispielsweise die zuletzt angelegten Backups an:<\/p>\n
    SELECT\r\n     database_name,\r\n     backup_start_date,\r\n     backup_finish_date,\r\n     backup_size \/ 1024 \/ 1024 AS BackupMB,\r\n     physical_device_name\r\nFROM msdb.dbo.backupset b\r\nJOIN msdb.dbo.backupmediafamily m\r\n   ON b.media_set_id = m.media_set_id\r\nWHERE type = ''D''\r\nORDER BY backup_finish_date DESC;<\/pre>\n
    Dieses Skript fügen wir nun in die Grundstruktur ein und speichern sie im oben angegebenen Ordner unter dem Namen LetzteBackups.snippet<\/b>. Die Grundstruktur sieht wie folgt aus:<\/p>\n
    <CodeSnippets>\r\n   <CodeSnippet Format=\"1.0.0\">\r\n     <Header>\r\n       <Title>Letzte Backups anzeigen<\/Title>\r\n       <Shortcut>lastbackups<\/Shortcut>\r\n       <Description>Zeigt die zuletzt angefertigten Backups an.<\/Description>\r\n       <Author>André Minhorst<\/Author>\r\n     <\/Header>\r\n     <Snippet>\r\n       <Code Language=\"SQL\">\r\n         <![CDATA[\r\nSELECT\r\n     database_name,\r\n     backup_start_date,\r\n     backup_finish_date,\r\n     backup_size \/ 1024 \/ 1024 AS BackupMB,\r\n     physical_device_name\r\nFROM msdb.dbo.backupset b\r\nJOIN msdb.dbo.backupmediafamily m\r\n   ON b.media_set_id = m.media_set_id\r\nWHERE type = ''D''\r\nORDER BY backup_finish_date DESC;\r\n         ]]>\r\n       <\/Code>\r\n     <\/Snippet>\r\n   <\/CodeSnippet>\r\n<\/CodeSnippets><\/pre>\n
    Hier sehen wir einige Einstellungen wie den Titel, einen Shortcut, eine Beschreibung und den Autor des Schnipsels. Zwischen den Elementen >![CDATA[ <\/b>und ]]< <\/b>platzieren wir unseren T-SQL-Code.<\/p>\n
    Öffnen wir nun das SQL Server Management Studio erneut und wählen die Auswahl der Schnipsel aus, finden wir bereits unseren selbst angelegten Schnipsel vor (siehe Bild 5).<\/p>\n
    \"Unser<\/p>\n
    Bild 5: Unser neuer Schnipsel wird bereits zur Auswahl angeboten.<\/span><\/b><\/p>\n
    Wählen wir diesen aus, erscheint der von uns hinterlegte Code im Abfragefenster und kann direkt mit F5<\/b> ausgeführt werden (siehe Bild 6).<\/p>\n
    \"Der<\/p>\n
    Bild 6: Der frisch eingefügte Schnipsel mit dem gewünschten Abfrageergebnis.<\/span><\/b><\/p>\n
    Auf diese Weise können wir uns nun bereits eine Bibliothek aller wichtigen Befehle, die wir uns nicht merken, weil wir sie nur unregelmäßig benötigen, zusammenstellen und diese in einzelnen Ordnern nach Kategorien sortieren. Diese erscheinen dann unter dem Hauptordner My Code Snippets <\/b>im Schnipsel-Menü.<\/p>\n
    Nächstes Level: Platzhalter einbauen<\/h2>\n
    Nun stellt sich die Frage: Wie können wir Platzhalter in unsere Vorlage einbauen, wie wir sie in dem Schnipsel beispielsweise zum Einfügen einer gespeicherten Prozedur vorgefunden haben?<\/p>\n
    Dazu schauen wir uns einfach den Schnipsel für das Anlegen einer gespeicherten Prozedur an. Die eingebauten Schnipsel finden wir in einem eigenen Ordner. Um diesen herauszufinden, öffnen wir den Codeschnipsel-Manager von SQL Server Management Studio über den Menübefehl Extras|Codeschnipsel-Manager<\/b>… (siehe Bild 7).<\/p>\n
    \"Aufrufen<\/p>\n
    Bild 7: Aufrufen des Codeschnipsel-Managers<\/span><\/b><\/p>\n
    Dieser erscheint nun wie in Bild 8. Hier erkennen wir schnell die Ordner wieder, die wir auch in der Codeschnipsel-Auswahl vorgefunden haben. Klicken wir einen der Ordner oder auch einen der enthaltenen Codeschnipsel an, wird der Pfad zu diesem Element unter Speicherort <\/b>angezeigt.<\/p>\n
    \"Der<\/p>\n
    Bild 8: Der Codeschnipsel-Manager<\/span><\/b><\/p>\n
    Den Pfad kopieren wir in den Windows Explorer und finden so schnell die gewünschten Elemente (siehe Bild 9). Hier klicken wir doppelt auf den Eintrag Create Stored Procedure.snippet <\/b>und wählen den Editor zum Anzeigen aus.<\/p>\n
    \"Ordner<\/p>\n
    Bild 9: Ordner mit den eingebauten Codeschnipseln<\/span><\/b><\/p>\n
    Dies öffnet den Editor wie in Bild 10. Hier sehen wir im Vergleich zu unserem zuvor erstellten Codeschnipsel einige zusätzliche Elemente.<\/p>\n
    \"Code<\/p>\n
    Bild 10: Code eines eingebauten Codeschnipsels<\/span><\/b><\/p>\n
    Diese beziehen sich weitestgehend auf die Platzhalter. Für einen Platzhalter sind zwei Aktionen notwendig:<\/p>\n
      \n
    • das Anlegen eines Eintrags im Declarations<\/b>-Element und<\/li>\n
    • das Einfügen des eigentlichen Platzhalters in unserem Codeschnipsel.<\/li>\n<\/ul>\n
      Unter Declarations <\/b>fügen wir ein Element namens Literal <\/b>hinzu. Dieses erhält die folgenden drei Unterelemente:<\/p>\n
        \n
      • ID<\/b>: Eindeutiger Bezeichner des Platzhalters<\/li>\n
      • ToolTip<\/b>: ToolTip-Text, der beim Überfahren mit der Maus angezeigt werden soll<\/li>\n
      • Default<\/b>: Standardwert für das Element<\/li>\n<\/ul>\n
        Die für ID hinterlegte Bezeichnung fügen wir an der gewünschten Stelle im Codeschnipsel ein, und zwar in einer bestimmten Form, denn der Platzhalter muss in $<\/b>-Zeichen eingefasst werden.<\/p>\n
        Für einen Platzhalter namens Name <\/b>müssen wir also folgenden Code unter Declarations <\/b>einfügen:<\/p>\n
        <Literal>\r\n     <ID>Name<\/ID>\r\n     <ToolTip>Dies ist ein Beispielplatzhalter.<\/ToolTip>\r\n     <Default>Standardwert<\/Default>\r\n<\/Literal><\/pre>\n
        Im Code des Codeschnipsels selbst fügen wir dann an der gewünschten Stelle den Platzhalter $Name$ <\/b>ein.<\/p>\n
        Wir probieren das mit einem einfachen Beispiel. Wir wollen alle Felder einer bestimmten Tabelle ausgeben. Dazu nutzen wir die folgende Abfrage:<\/p>\n
        SELECT \r\n     c.name AS ColumnName,\r\n     t.name AS DataType,\r\n     c.max_length,\r\n     c.is_nullable,\r\n     c.is_identity\r\nFROM sys.columns c\r\nJOIN sys.types t \r\n     ON c.user_type_id = t.user_type_id\r\nWHERE c.object_id = OBJECT_ID(''dbo.tblMitarbeiter'')\r\nORDER BY c.column_id;<\/pre>\n
        Hier wollen wir tblMitarbeiter <\/b>durch einen Platzhalter namens TableName <\/b>ersetzen, damit wir diesen flexibel einsetzen können.<\/p>\n
        Also gestalten wir unseren neuen Codesnippets namens Alle Tabellenfelder auflisten <\/b>wie in Listing 1. Hier achten wir darauf, dass die erste Zeile unmittelbar auf <![CDATA[<\/b> folgt und die letzte Zeile mit ]]><\/b> abgeschlossen wird. So verhindern wir Leerzeilen im einzufügenden Code.<\/p>\n
        <?xml version=\"1.0\" encoding=\"utf-8\"?>\r\n<CodeSnippets xmlns=\"http:\/\/schemas.microsoft.com\/VisualStudio\/2005\/CodeSnippet\">\r\n    <CodeSnippet Format=\"1.0.0\">\r\n    <Header>\r\n        <Title>Alle Tabellenfelder ausgeben<\/Title>\r\n        <Description>Gibt alle Felder einer Tabelle aus.<\/Description>\r\n        <Author>André Minhorst<\/Author>\r\n    <\/Header>\r\n    <Snippet>\r\n        <Declarations>\r\n            <Literal>\r\n                <ID>TableName<\/ID>\r\n                <ToolTip>Name der Tabelle<\/ToolTip>\r\n                <Default>dbo.Tabellenname<\/Default>\r\n            <\/Literal>\r\n        <\/Declarations>\r\n        <Code Language=\"SQL\">\r\n            <![CDATA[SELECT \r\n     c.name AS ColumnName,\r\n     t.name AS DataType,\r\n     c.max_length,\r\n     c.is_nullable,\r\n     c.is_identity\r\nFROM sys.columns c\r\nJOIN sys.types t \r\n     ON c.user_type_id = t.user_type_id\r\nWHERE c.object_id = OBJECT_ID(''$TableName$'')\r\nORDER BY c.column_id;]]>\r\n        <\/Code>\r\n    <\/Snippet>\r\n    <\/CodeSnippet>\r\n<\/CodeSnippets><\/pre>\n
        Listing 1: Codeschnipsel zum Einfügen der Abfrage zum Ausgeben aller Felder einer Tabelle<\/span><\/b><\/p>\n
        Diesen speichern wir unter dem Namen Alle Tabellenfelder auflisten.snippet <\/b>im Unterordner My Code Snippets<\/b>.<\/p>\n
        Danach öffnen wir SQL Server Management Studio erneut und finden den neuen Codeschnipsel wie in Bild 11 vor.<\/p>\n
        \"Unser<\/p>\n
        Bild 11: Unser neuer Codeschnipsel in der Auswahl der benutzerdefinierten Codeschnipsel<\/span><\/b><\/p>\n
        Wählen wir diesen aus, erscheint der neue Codeschnipsel wie in Bild 12 im Abfragefenster. Der Platzhalter ist direkt selektiert, sodass wir direkt die zu untersuchende Tabelle dort eintragen können.<\/p>\n
        \"Der<\/p>\n
        Bild 12: Der neue Codeschnipsel mit dem Platzhalter dbo.Tabellenname<\/span><\/b><\/p>\n
        Nach Betätigen von F5 <\/b>erhalten wir die gewünschten Informationen (siehe Bild 13).<\/p>\n
        \"Codeschnipsel<\/p>\n
        Bild 13: Codeschnipsel mit ersetztem Platzhalter und Abfrageergebnis<\/span><\/b><\/p>\n
        Zusammenfassung und Ausblick<\/h2>\n
        Dieser Artikel stellt die Codeschnipsel-Funktion von SQL Server Management Studio vor und zeigt, wir Du eigene Codeschnipsel mit oder ohne Platzhalter erstellen und nutzen kannst.<\/p>\n
        In einem weiteren Artikel namens Codeschnipsel für SSMS per Access erstellen <\/b>(www.vbentwickler.de\/477<\/b>) schauen wir uns eine Access-Datenbank an, die das Erstellen von Codeschnipseln weiter vereinfacht.<\/p>\n","protected":false},"excerpt":{"rendered":"
        Es gibt Code-Snippets, die man immer wieder verwendet – sei es, um Tabellen, Views oder gespeicherte Prozeduren zu erstellen, Tabellen oder Indizes zu definieren und vieles mehr. Vielleicht nutzt Du auch verschiedene System-Befehle, um verschiedene Aktionen im Abfragefenster auszulösen, um beispielsweise Informationen zur Datenbank zu ermitteln. Solche Snippets hast Du vielleicht in einer Textdatei gespeichert, um sie jederzeit in das Abfragefenster kopieren zu können. Es gibt jedoch eine viel mächtigere Möglichkeit, solche Code-Snippets zu nutzen: Das Abfragefenster bietet nämlich die Möglichkeit, Code-Snippets per Kontextmenü einzufügen. Das Beste daran ist: Wir können sogar eigene Code-Snippets definieren, die darüber ausgewählt und eingefügt werden können. In diesem Artikel schauen wir uns an, wie wir diese Funktion nutzen können und wie wir sogar eigene Code-Snippets in diesem Menü verfügbar machen können.<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"om_disable_all_campaigns":false,"_monsterinsights_skip_tracking":false,"_monsterinsights_sitenote_active":false,"_monsterinsights_sitenote_note":"","_monsterinsights_sitenote_category":0,"_uf_show_specific_survey":0,"_uf_disable_surveys":false,"footnotes":""},"categories":[662025,66052025,44000023,44000036,44000006],"tags":[],"yst_prominent_words":[],"class_list":["post-55000476","post","type-post","status-publish","format-standard","hentry","category-662025","category-66052025","category-PowerApps","category-Ribbon_programmieren","category-SQL_Server_und_Co"],"aioseo_notices":[],"aioseo_head":"\n\t\t\n\t\n\t\n\t\n\t\n\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t