Nota
L'accesso a questa pagina richiede l'autorizzazione. È possibile provare ad accedere o modificare le directory.
L'accesso a questa pagina richiede l'autorizzazione. È possibile provare a modificare le directory.
Una stored procedure può avere zero o più parametri. Può anche restituire un valore. Quando si usa il provider OLE DB di SQL Server Native Client, i parametri di una stored procedure possono essere passati tramite:
Codifica hardcoded del valore dei dati.
Usando un marcatore di parametro (?) per specificare i parametri, associare una variabile di programma al marcatore di parametro e quindi inserire il valore dei dati nella variabile di programma.
Annotazioni
Quando si chiamano stored procedure di SQL Server usando parametri denominati con OLE DB, i nomi dei parametri devono iniziare con il carattere '@'. Si tratta di una restrizione specifica di SQL Server. Il provider OLE DB di SQL Server Native Client applica questa restrizione più rigorosamente di MDAC.
Per supportare i parametri, l'interfaccia ICommandWithParameters viene esposta nell'oggetto comando. Per usare i parametri, il consumer descrive innanzitutto i parametri per il provider chiamando il metodo ICommandWithParameters::SetParameterInfo oppure, facoltativamente, prepara un'istruzione chiamante che chiama il metodo GetParameterInfo . Il consumer crea quindi una funzione di accesso che specifica la struttura di un buffer e inserisce i valori dei parametri in questo buffer. Infine, passa l'handle della funzione di accesso e un puntatore al buffer a Execute. Nelle chiamate successive a Execute il consumer inserisce nuovi valori di parametro nel buffer e chiama Execute con l'handle della funzione di accesso e il puntatore del buffer.
Un comando che chiama una stored procedure temporanea usando i parametri deve prima chiamare ICommandWithParameters::SetParameterInfo per definire le informazioni sui parametri, prima che il comando possa essere preparato correttamente. Questo perché il nome interno di una stored procedure temporanea è diverso dal nome esterno usato da un client e SQLOLEDB non è in grado di eseguire query sulle tabelle di sistema per determinare le informazioni sui parametri per una stored procedure temporanea.
Questi sono i passaggi del processo di associazione dei parametri:
Inserire le informazioni sui parametri in una matrice di strutture DBPARAMBINDINFO; ovvero il nome del parametro, il nome specifico del provider per il tipo di dati del parametro o un nome di tipo di dati standard e così via. Ogni struttura nella matrice descrive un parametro. Questa matrice viene quindi passata al metodo SetParameterInfo .
Chiamare il metodo ICommandWithParameters::SetParameterInfo per descrivere i parametri al provider. SetParameterInfo specifica il tipo di dati nativo di ogni parametro. Gli argomenti SetParameterInfo sono:
Numero di parametri per cui impostare le informazioni sul tipo.
Matrice di ordinali di parametri per cui impostare le informazioni sul tipo.
Matrice di strutture DBPARAMBINDINFO.
Creare una funzione di accesso ai parametri usando il comando IAccessor::CreateAccessor . La funzione di accesso specifica la struttura di un buffer e inserisce i valori dei parametri nel buffer. Il comando CreateAccessor crea una funzione di accesso da un set di associazioni. Queste associazioni vengono descritte dal consumer usando una matrice di strutture DBBINDING. Ogni associazione associa un singolo parametro al buffer del consumer e contiene informazioni quali:
Ordinale del parametro a cui si applica l'associazione.
Che cosa è associato (il valore dei dati, la relativa lunghezza e il relativo stato).
Offset nel buffer in ognuna di queste parti.
Lunghezza e tipo del valore di dati presente nel buffer del consumer.
Una funzione di accesso viene identificata dal relativo handle, ovvero di tipo HACCESSOR. Questo handle viene restituito dal metodo CreateAccessor . Ogni volta che il consumer termina usando una funzione di accesso, il consumer deve chiamare il metodo ReleaseAccessor per rilasciare la memoria che contiene.
Quando il consumer chiama un metodo, ad esempio ICommand::Execute, passa l'handle a una funzione di accesso e un puntatore a un buffer stesso. Il provider usa questa funzione di accesso per determinare come trasferire i dati contenuti nel buffer.
Compilare la struttura DBPARAMS. Le variabili consumer da cui vengono acquisiti i valori dei parametri di input e in cui vengono scritti i valori dei parametri di output vengono passate in fase di esecuzione a ICommand::Execute nella struttura DBPARAMS. La struttura DBPARAMS include tre elementi:
Puntatore al buffer da cui il provider recupera i dati dei parametri di input e in cui il provider restituisce i dati dei parametri di output, in base alle associazioni specificate dall'handle della funzione di accesso.
Numero di set di parametri nel buffer.
Handle della funzione di accesso creato nel passaggio 3.
Eseguire il comando usando ICommand::Execute.
Metodi di chiamata di una stored procedure
Quando si esegue una stored procedure in SQL Server, il provider OLE DB di SQL Server Native Client supporta:
Sequenza di escape ODBC CALL.
Sequenza di escape RPC (Remote Procedure Call).
Transact-SQL'istruzione EXECUTE.
Sequenza di escape ODBC CALL
Se si conoscono le informazioni sui parametri, chiamare il metodo ICommandWithParameters::SetParameterInfo per descrivere i parametri al provider. In caso contrario, quando la sintassi ODBC CALL viene utilizzata per chiamare una stored procedure, il provider chiama una funzione helper per trovare le informazioni sul parametro della stored procedure.
Se non si è certi delle informazioni sui parametri (metadati dei parametri), è consigliabile usare la sintassi ODBC CALL.
La sintassi generale per chiamare una routine utilizzando la sequenza di escape ODBC CALL è:
{[?=]chiamareprocedure_name[([parametro][,[parametro]]... )]}
Per esempio:
{call SalesByCategory('Produce', '1995')}
Sequenza di escape RPC
La sequenza di escape RPC è simile alla sintassi ODBC CALL della chiamata a una stored procedure. Se si chiama la routine più volte, la sequenza di escape RPC offre prestazioni ottimali tra i tre metodi di chiamata di una stored procedure.
Quando la sequenza di escape RPC viene utilizzata per eseguire una stored procedure, il provider non chiama alcuna funzione helper per determinare le informazioni sui parametri, come nel caso della sintassi ODBC CALL. La sintassi RPC è più semplice della sintassi ODBC CALL, quindi il comando viene analizzato più velocemente, migliorando le prestazioni. In questo caso, è necessario fornire le informazioni sul parametro eseguendo ICommandWithParameters::SetParameterInfo.
Per la sequenza di escape RPC è necessario avere un valore restituito. Se la stored procedure non restituisce un valore, il server restituisce 0 per impostazione predefinita. Inoltre, non è possibile aprire un cursore di SQL Server nella stored procedure. La stored procedure viene preparata in modo implicito e la chiamata a ICommandPrepare::P repare avrà esito negativo. A causa dell'impossibilità di preparare una chiamata RPC, non è possibile eseguire query sui metadati della colonna; IColumnsInfo::GetColumnInfo e IColumnsRowset::GetColumnsRowset restituiranno DB_E_NOTPREPARED.
Se si conoscono tutti i metadati dei parametri, la sequenza di escape RPC è il modo consigliato per eseguire stored procedure.
Questo è un esempio di sequenza di escape RPC per chiamare una stored procedure:
{rpc SalesByCategory}
Per un'applicazione di esempio che illustra una sequenza di escape RPC, vedere Eseguire una stored procedure (utilizzando la sintassi RPC) e elaborare i codici restituiti e i parametri di output (OLE DB).
Istruzione EXECUTE Transact-SQL
La sequenza di escape ODBC CALL e la sequenza di escape RPC sono i metodi preferiti per chiamare una stored procedure anziché l'istruzione EXECUTE . Il provider OLE DB di SQL Server Native Client usa il meccanismo RPC di SQL Server per ottimizzare l'elaborazione dei comandi. Questo protocollo RPC aumenta le prestazioni eliminando gran parte dell'elaborazione dei parametri e dell'analisi delle istruzioni eseguite nel server.
Di seguito è riportato un esempio dell'istruzione EXECUTE Transact-SQL:
EXECUTE SalesByCategory 'Produce', '1995'