Bei der Konvertierung der Tabellenerstellungs-SQL von Oracle in die Tabellenerstellungs-SQL von SQLServer ist Folgendes zu beachten:
1 Alle Kommentaranweisungen müssen gelöscht werden.
2. Konvertieren Sie den Clob-Typ in den Texttyp.
3. Konvertieren Sie den Blob-Typ in den Bildtyp.
4. Der Zahlentyp wird in int konvertiert, Zahl (16,2) usw. wird in Dezimalzahl (16,2) konvertiert und Zahl (18) wird in Bigint konvertiert.
5.Standard-Sysdate wird in Standard-getDate() geändert.
6.to_date('2009-12-18','yyyy-mm-dd') wird in cast('2009-12-18' as datetime)
SQLSERVER:
Variable geändert Deklaration:
Beim Deklarieren einer Variablen müssen Sie das @-Symbol vor der Variablen hinzufügen
DECLARE @I INT
Zuweisung der Variablen:
Beim Zuweisen einer Variablen müssen Sie setSET @I = 30
Mehrere Variablen deklarieren:
DECLARE @s varchar(10),@a INT
if-Anweisung:
Java-Code
if ..
begin
...
end
else if ..
begin
...
end
else
begin
...
end
Nach dem Login kopieren
Beispiel:
SQL-Code
DECLARE @d INT
set @d = 1
IF @d = 1 BEGIN
PRINT '正确'
END
ELSE BEGIN
PRINT '错误'
END
Nach dem Login kopieren
Anweisung zur Auswahl mehrerer Bedingungen:
Beispiel:
SQL-Code
declare @today int
declare @week nvarchar(3)
set @today=3
set @week= case
when @today=1 then '星期一'
when @today=2 then '星期二'
when @today=3 then '星期三'
when @today=4 then '星期四'
when @today=5 then '星期五'
when @today=6 then '星期六'
when @today=7 then '星期日'
else '值错误'
end
print @weekNach dem Login kopieren
Schleifenanweisung:
Java-Code
WHILE 条件 BEGIN
执行语句
END
Nach dem Login kopieren
Beispiel:
Java-Code
DECLARE @i INT
SET @i = 1
WHILE @i<1000000 BEGIN
set @i=@i+1
END
Nach dem Login kopieren
Cursor definieren:
SQL-Code
DECLARE @cur1 CURSOR FOR SELECT .........
OPEN @cur1
FETCH NEXT FROM @cur1 INTO 变量
WHILE(@@FETCH_STATUS=0)
BEGIN
处理.....
FETCH NEXT FROM @cur1 INTO 变量
END
CLOSE @cur1
DEALLOCATE @cur1
Nach dem Login kopieren
SQL-Code
AS
declare @CATEGORY_CI_TABLENAME VARCHAR(50) =''
declare @result VARCHAR(2000) = ''
declare @CI_ID DECIMAL = 0
declare @num int = 1
declare @countnum int = 1
BEGIN
select @countnum = count(ATTRIBUTE_CONFIG_ID) from T_ATTRIBUTE_CONFIG where CMDB_UPDATE_FLAG= 'Y' and CATEGORY_CODE =@CATEGORY_CODE
IF (@ATTRIBUTE2='A')
begin
DECLARE MyCursor CURSOR for select ATTRIBUTE_CONFIG_CODE from T_ATTRIBUTE_CONFIG where CMDB_UPDATE_FLAG= 'Y' and CATEGORY_CODE =@CATEGORY_CODE
OPEN MyCursor FETCH NEXT FROM MyCursor INTO @CONFIG_CODE
set @result = @result+@CONFIG_CODE+','
WHILE @@FETCH_STATUS = 0
BEGIN
FETCH NEXT FROM MyCursor INTO @CONFIG_CODE
set @num = @num+ 1
if(@num<@countnum)
begin
set @result = @result+@CONFIG_CODE+','
end
else if(@num=@countnum)
begin
set @result = @result +@CONFIG_CODE
end
END
CLOSE MyCursor
DEALLOCATE MyCursor
set @result = 'insert into ' + @ATTRIBUTE1 + '(' + @result +') select '+ @result +' from '+@CATEGORY_CI_TABLENAME +' where CI_ORDER_LINE_ID='+@KEY_ID
end
else if((@ATTRIBUTE2='U'))Nach dem Login kopieren
Temporäre Tabelle:
-- Select INTO erstellt eine neue Tabelle aus den Berechnungsergebnissen einer Abfrage . Die Daten werden nicht an den Client zurückgegeben, was sich von der normalen Auswahl unterscheidet. Die Felder der neuen Tabelle haben dieselben Namen und Datentypen wie die Ausgabefelder von Select.
* in NewTable auswählen
aus Uname
-- IN ABC Select einfügen
-- Tabelle ABC muss vorhanden sein
-- Kopieren Sie das Feld Benutzername in Tabelle Uname in Tabelle ABC
Einfügen INTO ABC Select Username FROM Uname
-- Temporäre Tabelle erstellen
TABLE erstellen #temp(
UID int Identity(1, 1) PRIMARY KEY,
UserName varchar(16) ,
Pwd varchar(50),
Age smallint,
Sex varchar(6)
)
--Offene temporäre Tabelle
Wählen Sie * aus #temp
1. Die lokale temporäre Tabelle (beginnend mit #) ist nur für die aktuelle Verbindung gültig und wird automatisch gelöscht, wenn die aktuelle Verbindung getrennt wird.
2. Die globale temporäre Tabelle (beginnend mit ##) gilt auch für andere Verbindungen und wird automatisch gelöscht, wenn die aktuelle Verbindung und andere Verbindungen, die darauf zugegriffen haben, getrennt werden.
3. Unabhängig von der lokalen temporären Tabelle oder der globalen temporären Tabelle können Sie die temporäre Tabelle mit Drop Table #Tmp (oder Drop Table ##Tmp) explizit löschen, solange die Verbindung über Zugriffsrechte verfügt.
Temporäre Tabellen sollten kaum Auswirkungen auf die Ausführungseffizienz haben, solange sie nicht zu groß sind. Im Gegenteil, sie können die Effizienz verbessern, insbesondere bei Verbindungsabfragen, solange der Speicherplatz Ihrer Datenbank für temporäre Tabellen ausreicht 🎜>Wenn zu viele Cursor vorhanden sind, wird die Ausführung schwerwiegend sein. Vermeiden Sie dies, wenn Sie können!
Andere:
--Gespeicherte Prozedur mit Eingabeparametern--
proc GetComment erstellen
(@commentid int)
as
wählen Sie * aus Kommentar aus, wobei CommentID=@commentid
--eine gespeicherte Prozedur mit Eingabe- und Ausgabeparametern--
proc GetCommentCount erstellen
@newsid int,
@count int Ausgabe
als
wählen Sie @count=count(*) aus Kommentar, wobei NewsID=@newsid
--Funktion, die einen einzelnen Wert zurückgibt--
Funktion MyFunction erstellen
(@newsid int)
gibt int zurück
as
begin
declare @count int
select @count=count(*) from Comment where NewsID=@newsid
return @count
end
--call method--
declare @count int
exec @count =MyFunction 2
print @count
--eine Funktion, deren Rückgabewert eine Tabelle ist--
Funktion GetFunctionTable erstellen
( @newsid int)
Rückgabetabelle
als
Rückgabe
(wählen Sie * aus dem Kommentar aus, wobei NewsID=@newsid ist)
--Aufruf einer Funktion, deren Rückgabewert eine Tabelle ist--
select * from GetFunctionTable(2)
-- ------------------ ---- ---------------------------------------------- ---- --------------
SQLServer verkettet keine SQL-Zeichenfolgen in der gespeicherten Prozedur mit Implementieren Sie eine Abfrage mit mehreren Bedingungen
Vorherige Schreibweise
set @sql=' select * from table where 1=1 '
if (@addDate is not null)
set @sql = @sql+' and addDate = '+ @addDate + ' '
if (@name '' and is not null)
set @sql = @sql+ ' and name = ' + @name + ' '
exec(@sql )
Das Folgende ist eine Lösung, um eine Abfrage mit mehreren Bedingungen zu erreichen, ohne SQL-Strings zu spleißen
Die erste Schreibweise ist, dass sich der Code etwas überflüssig anfühlt
wenn (@addDate nicht null ist) und (@name wähle * aus der Tabelle aus, wobei addDate = @addDate und name = @name
sonst wenn (@addDate nicht null ist) und (@name ='')
wähle * aus table where addDate = @addDate
else if(@addDate is null) and (@name '')
select * from table where and name = @name
else if(@addDate is null) und (@name = '')
select * from table
Die zweite Möglichkeit, es zu schreiben ist
select * from table where (addDate = @addDate or @addDate is null) and (name = @name oder @name = '')
Die dritte Schreibweise ist
SELECT * FROM table where
addDate = CASE @addDate IS NULL THEN addDate ELSE @addDate END,
name = CASE @ name WHEN '' THEN name ELSE @name END
---------------------------- ------ -------------------------------------------- ------ -------------------------------------------- ------
Grundlegende Syntax gespeicherter SQLSERVER-Prozeduren
1. Variablen definieren
--Einfache Zuweisung
declare @a int
set @a=5
print @a
--verwenden Sie die Select-Anweisung, um einen Wert zuzuweisen
declare @user1 nvarchar(50)
select @user1= '张三'
print @user1
declare @user2 nvarchar(50)
select @user2 = Name from ST_User where ID=1
print @user2
--update-Anweisung verwenden, um Wert zuzuweisen
declare @user3 nvarchar(50)
update ST_User set @user3 = Name where ID=1
print @user3
2. temporäre Tabelle, Tabellenvariable
--Temporäre Tabelle 1 erstellen
Tabelle erstellen #DU_User1
(
[ID] [ int ] NOT NULL , [ Oid] NOT NULL ,
[Login] [nvarchar](50) NOT NULL ,
[Rtx] [nvarchar](4) NOT NULL ,
[Name ] [nvarchar](5 ) NOT NULL ,
[ Passwort ] [nvarchar]( max ) NULL ,
[Status] [nvarchar](8) NOT NULL
) ;
--Einen Datensatz in temporäre Tabelle 1 einfügen
in #DU_User1 (ID,Oid,[Login],Rtx, Name,[Password],State) Werte einfügen (100 ,2, 'LS', '0000', 'Temporär', '321', 'Spezial'); Tabelle
wählen Sie * in #DU_User2 von ST_User aus, wobei ID
--Zwei temporäre Tabellen löschen
Tabelle #DU_User1 löschen
drop table #DU_User2
--Temporäre Tabelle erstellen
CREATE TABLE #t NOT NULL ,
[Login] [nvarchar]( 50) NICHT NULL ,
[Rtx] [nvarchar](4) NOT NULL ,
[State] [nvarchar](8) NOT NULL ,
)
--Fügen Sie den Abfrageergebnissatz (mehrere Datenelemente) in die temporäre Tabelle ein
insert into #t select * from ST_User
--kann nicht auf diese Weise eingefügt werden
--select * into #t from dbo.ST_User
--Fügen Sie eine Spalte als selbsterweiternden Unterabschnitt vom Typ int hinzu
alter table #t add [ myid] int NOT NULL IDENTITY(1,1)
--Fügen Sie eine Spalte hinzu, die global eindeutige Kennung wird standardmäßig ausgefüllt
alter table #t add [myid1] uniqueidentifier NOT NULL default (newid()) 🎜>drop table #t
--Fügen Sie dem Abfrageergebnissatz eine automatisch vergrößernde Spalte hinzu
--Wenn kein Primärschlüssel vorhanden ist :
wählen Sie IDENTITY( int ,1,1) als ID, Name,[Login],[Passwort] in #t aus ST_User
wählen Sie * aus #t
--wenn ein Primärschlüssel vorhanden ist:
wählen Sie (wählen Sie SUM (1) aus ST_User aus, wobei ID
--Tabellenvariablen definieren
@t-Tabelle deklarieren
(
id int not null ,
msg nvarchar(50) null
)
in @t-Werte (1, '1') einfügen
in @t-Werte (2, '2') einfügen
select * from @t
3. Schleife
--while-Schleife berechnet die Summe von 1 bis 100
declare @a int
declare @ sum int
set @a=1
set @ sum =0
while @a
begin
set @ sum +=@a
set @a+=1
end
print @ sum
4. Bedingte Anweisung
- -if,else bedingter Zweig
if(1+1=2 )
begin
print 'right'
end
sonst
Anfang
print 'Falsch'
Ende
--wann dann bedingter Zweig
deklarieren @today int
declare @week nvarchar(3)
set @today=3
set @week= case
when @today=1 then 'Montag'
wenn @today=2, dann 'Dienstag'
wenn @today=3, dann 'Mittwoch'
wenn @today=4, dann 'Donnerstag'
wenn @today=5, dann 'Freitag'
Wenn @heute=6, dann 'Samstag' @week
5. Cursor
declare @ID int
declare @Oid int
declare @Login varchar (50)
--Definiere einen Cursor
user_cur-Cursor deklarieren, um ID,Oid,[Login] aus ST_User auszuwählen
--Öffnen Sie den Cursor
öffnen Sie user_cur
while @@fetch_status=0
beginnen
--Lesecursor 🎜> @ID drucken
--print @Login
Ende
user_cur schließen
--Cursor zerstören
Benutzer_cur freigeben
6. Trigger
Temporäre Tabelle im Trigger:
Eingefügt
Speichern Sie die Daten nach Einfüge- und Aktualisierungsvorgängen
Gelöscht
Speichern Sie die Daten in Bearbeitung. Daten vor Lösch- und Aktualisierungsvorgängen
--Create-Trigger User_OnUpdate
Create-Trigger User_OnUpdate
Auf ST_User
für Update 🎜>As
deklarieren Sie @msg nvarchar(50)
--@msg Datensatzänderungsstatus
Wählen Sie @msg = N 'Name aus "' + Gelöscht. Name + N '" Ändern in "' + Eingefügt. Name + '"' aus Eingefügt, Gelöscht
--In Protokolltabelle einfügen
in [LOG](MSG)-Werte (@msg) einfügen
--Trigger löschen
Trigger löschen User_OnUpdate
7 . Gespeicherte Prozedur
--Erstellen Sie eine gespeicherte Prozedur mit Ausgabeparametern
CREATE PROCEDURE PR_Sum
@a int ,
@b int ,
@ sum int output
AS
BEGIN
set @ sum =@a+@b
END
--Erstellen Sie eine gespeicherte Prozedur für den Rückgabewert
CREATE PROCEDURE PR_Sum2
@a int ,
@b int
AS
BEGIN
Return @a+@b
END
– Führen Sie die gespeicherte Prozedur aus, um den Rückgabewert des Ausgabetyps
declare @mysum int
execute PR_Sum 1,2,@mysum Output
print @mysum
--Führen Sie die gespeicherte Prozedur aus um den Rückgabewert des Rückgabetyps zu erhalten
declare @mysum2 int
execute @mysum2= PR_Sum2 1 ,2
print @mysum2
8. Benutzerdefinierte Funktionen
Klassifizierung von Funktionen:
1) Skalarwertige Funktion
2) Tabellenwertige Funktion
a: Inline-Tabellenwertfunktion
b: Tabellenwertfunktion mit mehreren Anweisungen
3 ) Systemfunktion
--Funktion erstellen FUNC_Sum1
Funktion erstellen FUNC_Sum1
( @a int,
@b int
)
gibt int
as
begin
return @a+@b
end
--Neue Inline-Tabellenwertfunktion
Funktion FUNC_UserTab_1 erstellen
)
gibt Tabelle zurück
als
Rückgabe (wählen Sie * aus ST_User, wobei ID
--Erstellen Sie eine Tabellenwertfunktion mit mehreren Anweisungen FUNC_UserTab_2
( @myId int
) gibt @t table
(
zurück
[ID] [ int ] NOT NULL ,
[Oid] [ int ] NOT NULL ,
[Login] [nvarchar](50) NOT NULL ,
[Rtx] [nvarchar](4) NOT NULL ,
[Name] [nvarchar](5) NOT NULL ,
[ Passwort ] [nvarchar]( max ) NULL ,
[Status] [nvarchar](8) NOT NULL
)
as
Anfang
Einfügen in @t select * from ST_User where ID
return
end
--Tabellenwertfunktion aufrufen
select * from dbo.FUNC_UserTab_1(15)
--Skalarwertfunktion aufrufen
@s int deklarieren
set @s=dbo.FUNC_Sum1(100,50)
print @s
--Skalarwertfunktion löschen
Sprechen Sie über das Unterschied zwischen benutzerdefinierten Funktionen und gespeicherten Prozeduren:
1. Benutzerdefinierte Funktionen:
1. Kann Tabellenvariablen zurückgeben
2. Einschränkungen Es gibt viele, einschließlich
Der Ausgabeparameter kann nicht verwendet werden.
Die Operationen innerhalb der Funktion können sich nicht auf die externe Umgebung auswirken.
Er kann nicht übergeben werden gesetzt;
Datenbanktabellen können nicht aktualisiert oder gelöscht werden
3. Muss einen Skalarwert oder eine Tabellenvariable zurückgeben
Benutzerdefinierte Funktionen werden im Allgemeinen zur Wiederverwendung verwendet Hoher Grad an Genauigkeit, einfache und einzelne Funktion und starke Wettbewerbsfähigkeit.
2. Gespeicherte Prozeduren
1. Tabellenvariablen können nicht zurückgegeben werden
2. Wenige Einschränkungen, können Operationen an Datenbanktabellen ausführen und Datensätze zurückgeben
3. Sie können einen Skalarwert zurückgeben oder die Rückgabe weglassen
Gespeicherte Prozeduren werden im Allgemeinen zum Implementieren komplexer Funktionen und Datenmanipulationen verwendet.
-------------------------------------- --- -------------------------------- --- -------------------------------- ---
Gespeicherte SQLServer-Prozedur – Beispiel
Beispiel 1: Eine gespeicherte Prozedur, die nur einen einzelnen Datensatz zurückgibt.
Der Inhalt der Tabelle Bankeinlagen (bankMoney) lautet wie folgt
Anforderung 1: Gespeicherte Prozedur zum Abfragen des Inhalts der Tabelle bankMoney
Prozedur sp_query_bankMoney erstellen
as
select * from bankMoney
go
exec sp_query_bankMoney
Hinweis* Während der Verwendung müssen Sie nur die SQL-Anweisung in T-SQL durch ersetzen Der Name der gespeicherten Prozedur. Okay, das ist sehr praktisch!
Beispiel 2 (Übergabe von Parametern an die gespeicherte Prozedur):
Fügen Sie einen Datensatz zur Tabelle bankMoney hinzu und fragen Sie den Gesamtbetrag aller Einzahlungen mit userID = Zhangsan in dieser Tabelle ab.
Proc insert_bank @param1 char(10),@param2 varchar(20),@param3 varchar(20),@param4 int,@param5 int Ausgabe erstellen
mit Verschlüsselung ------- --Verschlüsselung
als
in bankMoney einfügen (id,userID,sex,Money)
Werte(@param1,@param2,@param3, @param4)
select @param5=sum(Money) from bankMoney where userID='Zhangsan'
go
Die Methode zum Ausführen dieser gespeicherten Prozedur im SQL Server Query Analyzer ist:
declare @total_price int
exec insert_bank '004','Zhangsan', ' Male',100,@total_price Ausgabe
print 'Der Gesamtsaldo ist'+convert(varchar,@total_price)
go
Hier besprechen wir die drei Rückgabewerte des Gespeicherte Prozedur (Für Freunde, die sich dieses Beispiel ansehen, ist es praktisch, den Syntaxinhalt nicht überprüfen zu müssen):
1 Geben Sie die Ganzzahl mit Return zurück
2. Geben Sie die Parameter im Ausgabeformat zurück
3.Recordset
Der Unterschied zwischen den zurückgegebenen Werten:
Sowohl Ausgabe als auch Rückgabe können mithilfe von Variablen im Batch-Programm empfangen werden, während Recordset an den Client zurückgegeben wird, der den Batch ausführt.
Beispiel 3: Verwendung einer einfachen Prozedur mit einer komplexen SELECT-Anweisung
Die folgende gespeicherte Prozedur gibt alle Autoren (Namen angegeben), veröffentlichte Bücher und Herausgeber aus einer Verknüpfung von vier Tabellen zurück. Diese gespeicherte Prozedur verwendet keine Parameter.
USE pubs
IF EXISTS (SELECT name FROM sysobjects
WHERE name = 'au_info_all' AND type = 'P')
DROP PROCEDURE au_info_all
GO
CREATE PROCEDURE au_info_all
AS
SELECT au_lname, au_fname, title, pub_name
FROM Authors a INNER JOIN titleauthor ta
ON a.au_id = ta.au_id INNER JOIN titles t
ON t.title_id = ta. title_id INNER JOIN Publishers p
ON t.pub_id = p.pub_id
GO
Die gespeicherte Prozedur au_info_all kann wie folgt ausgeführt werden:
EXECUTE au_info_all
-- Oder
EXEC au_info_all
Wenn die Prozedur die erste Anweisung im Stapel ist, können Sie sie verwenden :
au_info_all
Beispiel 4: Verwenden einer einfachen Prozedur mit Parametern
CREATE PROCEDURE au_info
@lastname varchar(40),
@ firstname varchar(20 )
AS
SELECT au_lname, au_fname, title, pub_name
FROM Authors a INNER JOIN titleauthor ta
ON a.au_id = ta.au_id INNER JOIN titles t
ON t .title_id = ta .title_id INNER JOIN editors p
ON t.pub_id = p.pub_id
WHERE au_fname = @firstname
AND au_lname = @lastname
GO
au_info gespeicherte Prozedur Es kann ausgeführt werden mit den folgenden Methoden: Oder
EXECUTE au_info @firstname = 'Ann', @lastname = 'Dull'
-- Oder
EXEC au_info 'Dull', 'Ann'
-- Oder
EXEC au_info @lastname = 'Dull', @firstname = 'Ann'
-- Oder
EXEC au_info @firstname = 'Ann', @lastname = 'Dull'
Wenn der Prozess ist Als erste in der Batch-A-Anweisung können Sie Folgendes verwenden:
au_info 'Dull', 'Ann'
-- Oder
au_info @lastname = 'Dull', @firstname = 'Ann'
-- Oder
au_info @firstname = 'Ann', @lastname = 'Dull'
Beispiel 5: Verwendung einer einfachen Prozedur mit Platzhalterparametern
PROZEDUR au_info2 ERSTELLEN
@lastname varchar(30) = 'D%',
@firstname varchar(18) = '%'
AS
SELECT au_lname, au_fname, title , pub_name
FROM Authors a INNER JOIN titleauthor ta
ON a.au_id = ta.au_id INNER JOIN titles t
ON t.title_id = ta.title_id INNER JOIN editors p
ON t.pub_id = p.pub_id
WHERE au_fname LIKE @firstname
AND au_lname LIKE @lastname
GO
Die gespeicherte Prozedur au_info2 kann in verschiedenen Kombinationen ausgeführt werden. Nachfolgend sind nur einige Kombinationen aufgeführt:
EXECUTE au_info2
-- Oder
EXECUTE au_info2 'Wh%'
-- Oder
EXECUTE au_info2 @firstname = 'A%'
-- Oder
AU_info2 '[CK]ars[OE]n' AUSFÜHREN
-- Oder
au_info2 'Hunter', 'Sheryl' AUSFÜHREN
-- Oder
au_info2 ' H. AUSFÜHREN %', 'S%'
= 'proc2'
Beispiel 6: if...else
Gespeichert Prozedur, in der @case als Auswahlbasis für die Ausführung von Updates verwendet wird und if...else verwendet wird, um verschiedene Änderungen entsprechend den während der Ausführung übergebenen Parametern zu implementieren
– Das Folgende ist die gespeicherte Prozedur von if ...sonst:
falls vorhanden (wählen Sie 1 aus sysobjects aus, wobei Name = 'Student' und Typ ='u' ist)
Tabelle Student löschen
gehen
falls vorhanden (wählen Sie 1 aus sysobjects where name = 'spUpdateStudent' and type = 'p' )
drop proc spUpdateStudent
go
create table Student
(
fName nvarchar (10),
fAge
smallint ,
fDiqu varchar (50),
fTel int
)
go
insert into Student Values ('X.X.Y' , 28, ' Tesing' , 888888)
go
create proc spUpdateStudent
(
@fCase int ,
@fName nvarchar (10),
@fAge smallint ,
@ fDiqu varchar (50),
@fTel int
)
as
update Student
set fAge = @fAge, -- Übergeben Sie 1,2,3, um fAge zu aktualisieren case
fDiqu = (Fall, wenn @ fCase = 2 oder @fCase = 3, dann @fDiqu, sonst fDiqu end ),
fTel = (Fall, wenn @fCase = 3, dann @fTel, sonst fTel end )
wobei fName = @fName
select * from Student
go
-- nur Alter ändern
exec spUpdateStudent
@fCase = 1,
@fName = N'X.X.Y' ,
@fAge = 80,
@fDiqu = N'Update' ,
@fTel = 1010101
-- Alter und Diqu ändern
exec spUpdateStudent
@fCase = 2,
@fName = N'X.X. Y' ,
@fAge = 80,
@fDiqu = N'Update' ,
@fTel = 1010101
--Vollständige Änderung
exec spUpdateStudent
@fCase = 3,
@fName = N'X
