Utilisation de séquences d'échappement SQL
Le pilote JDBC Microsoft SQL Server prend en charge l'utilisation des séquences d'échappement SQL, tel que le définit l'API JDBC. Les séquences d'échappement sont utilisées dans une instruction SQL pour indiquer au pilote que la partie d'échappement de la chaîne SQL doit être gérée différemment. Lorsque le pilote JDBC traite la partie d'échappement d'une chaîne SQL, il traduit cette partie de la chaîne en code SQL compris par SQL Server.
Il existe cinq types de séquences d'échappement requis par l'API JDBC, et tous sont pris en charge par le pilote JDBC :
- Littéraux génériques LIKE
- Gestion de fonction
- Littéraux de date et heure
- Appels de procédure stockée
- Jointures externes
La syntaxe de séquence d'échappement utilisée par le pilote JDBC est la suivante :
{keyword ...parameters...}
Notes
Le traitement d'échappement SQL est toujours activé pour le pilote JDBC.
Les sections suivantes décrivent les cinq types de séquences d'échappement et comment ils sont pris en charge par le pilote JDBC.
Littéraux génériques LIKE
Le pilote JDBC prend en charge la syntaxe {escape 'escape character'} pour l'utilisation de caractères génériques de clause LIKE comme littéraux. Par exemple, le code suivant retournera des valeurs pour col3, où la valeur de col2 commence littéralement par un trait de soulignement (et pas son utilisation générique).
ResultSet rst = stmt.executeQuery("SELECT col3 FROM test1 WHERE col2
LIKE '\\_%' {escape '\\'}");
Notes
La séquence d'échappement doit être à la fin de l'instruction SQL. Pour plusieurs instructions SQL dans une chaîne de commande, la séquence d'échappement doit être à la fin de chaque instruction SQL pertinente.
Gestion de fonction
Le pilote JDBC prend en charge les séquences d'échappement de fonction dans les instructions SQL avec la syntaxe suivante :
{fn functionName}
où functionName est une fonction prise en charge par le pilote JDBC. Exemple :
SELECT {fn UCASE(Name)} FROM Employee
Le tableau suivant répertorie les différentes fonctions prises en charge par le pilote JDBC lors de l'utilisation d'une séquence d'échappement de fonction :
| Fonctions de chaîne | Fonctions numériques | Fonctions datetime | Fonctions système |
|---|---|---|---|
ASCII CHAR CONCAT DIFFERENCE INSERT LCASE LEFT LENGTH LOCATE LTRIM REPEAT REPLACE RIGHT RTRIM SOUNDEX SPACE SUBSTRING UCASE |
ABS ACOS ASIN ATAN ATAN2 CEILING COS COT DEGREES EXP FLOOR LOG LOG10 MOD PI POWER RADIANS RAND ROUND SIGN SIN SQRT TAN TRUNCATE |
CURDATE CURTIME DAYNAME DAYOFMONTH DAYOFWEEK DAYOFYEAR EXTRACT HOUR MINUTE MONTH MONTHNAME NOW QUARTER SECOND TIMESTAMPADD TIMESTAMPDIFF WEEK YEAR |
DATABASE IFNULL USER |
Notes
Si vous essayez d'utiliser une fonction que la base de données ne prend pas en charge, une erreur se produit.
Littéraux de date et heure
La syntaxe d'échappement pour les littéraux de date, heure et horodatage est la suivante :
{literal-type 'value'}
où literal-type est l'un des éléments suivants :
| Type littéral | Description | Format de la valeur |
|---|---|---|
d |
Date |
aaaa-mm-jj |
t |
Heure |
hh:mm:ss [1] |
ts |
TimeStamp |
aaaa-mm-jj hh:mm:ss[.f...] |
Exemple :
UPDATE Orders SET OpenDate={d '2005-01-31'}
WHERE OrderID=1025
Appels de procédure stockée
Le pilote JDBC prend en charge la syntaxe d'échappement {? = call proc_name(?,...)} et {call proc_name(?,...)} pour les appels de procédure stockée, selon que vous devez ou non traiter un paramètre de retour.
Une procédure est un objet exécutable stocké dans la base de données. Généralement, il s'agit d'une ou plusieurs instructions SQL qui ont été précompilées. La syntaxe de séquence d'échappement pour appeler une procédure stockée est la suivante :
{[?=]call procedure-name[([parameter][,[parameter]]...)]}
où procedure-name spécifie le nom d'une procédure stockée et parameter un paramètre de procédure stockée.
Pour plus d'informations sur l'utilisation de la syntaxe d'échappement call avec des procédures stockées, consultez Utilisation d'instructions avec des procédures stockées.
Jointures externes
Le pilote JDBC prend en charge la syntaxe de jointure externe SQL92 gauche, droite et entière. La séquence d'échappement pour les jointures externes est la suivante :
{oj outer-join}
où outer-join est :
table-reference {LEFT | RIGHT | FULL} OUTER JOIN
{table-reference | outer-join} ON search-condition
où table-reference est un nom de table et search-condition est la condition de jointure que vous souhaitez utiliser pour les tables.
Exemple :
SELECT Customers.CustID, Customers.Name, Orders.OrderID, Orders.Status
FROM {oj Customers LEFT OUTER JOIN
Orders ON Customers.CustID=Orders.CustID}
WHERE Orders.Status='OPEN'
Les séquences d'échappement de jointure externe suivantes sont prises en charge par le pilote JDBC :
- Jointures externes gauches
- Jointures externes droites
- Jointures externes entières
- Jointures externes imbriquées