Equivalence du Sql propriétaire

Cette fiche compare le Structure Query Language (SQL) des différentes sources de données relationnelles. Elle est quasi exhaustive concernant le potentiel des expressions Sql.

La référence est l'exemple en Up ! 5GL pour connaître comment Up ! Query transforme les expressions ou les instructions lors de la génération du Sql en juste à temps. Cette fiche n'est pas exhaustive concernant le potentiel des expressions d'Up ! 5GL.

Type Binaire

Code ascii d'un octet

Système	Syntaxe
Db2.	`HEX ( Expression )`
Max DB.	`ASCII BYTE ( Expression )`
My Sql.	`HEX ( Expression )`
Odbc.	`ASCII ( Expression )`
Oracle.	`RAWTOHEX ( SUBSTRB (Expression , 1, 1 ) )`
PostgreSQL.	`GET_BYTE ( Expression , 1 )`
Sql Server.	`-`
Up ! Application System.	`Expression [ 0 ]`

Constructeur

Système	Syntaxe
Db2.	`BLOB ( Expression , ... ) GRAPHIC ( Expression ) LONG_VARGRAPHIC ( Expression ) VARGRAPHIC ( Expression )`
Max DB.	`-`
My Sql.	`CAST ( Expression AS VARBINARY )`
Odbc.	`{ fn CONVERT ( Expression, SQL_VARBINARY ) }`
Oracle.	`TO_BLOB ( Expression )`
PostgreSQL.	`CAST ( Expression AS VARBINARY )`
Sql Server.	`CAST ( Expression AS VARBINARY )`
Up ! Application System.	`Binaire( Expression )`

Type Caractere

Allongement

Système	Syntaxe
Db2.	`RPAD ( LPAD ( Expression1 , Expression2 / 2) , Expression2 / 2 + ( Expression2 MOD 2 ) ) )`
Max DB.	`RFILL ( LFILL ( Expression1 , Expression2 / 2) , Expression2 / 2 + ( Expression2 MOD 2 ) ) )`
My Sql.	`RPAD ( LPAD ( Expression1 , Expression2 / 2) , Expression2 / 2 + ( Expression2 MOD 2 ) ) )`
Odbc.	`{ fn CONCAT ( { fn CONCAT ( { fn SPACE ( ( Expression2 / 2 ) - { fn LENGTH ( Expression1 ) } ) } , Expression1 ) } , { fn SPACE ( ( Expression2 / 2 ) + { fn MOD ( Expression2 , 2 ) } - { fn LENGTH ( Expression1 ) } ) } }`
Oracle.	`RPAD ( LPAD ( Expression1 , Expression2 / 2) , Expression2 / 2 + ( Expression2 MOD 2 ) ) )`
PostgreSQL.	`RPAD ( LPAD ( Expression1 , Expression2 / 2) , Expression2 / 2 + ( Expression2 MOD 2 ) ) )`
Sql Server.	`SPACE ( ( Expression2 / 2 ) - LEN (Expression1 ) ) + Expression1 ) + SPACE ( ( Expression2 / 2 ) + ( Expression2 % 2 ) - LEN ( Expression1 ) )`
Up ! Application System.	`Expression1 . Ajouter ( Expression2 )`

Allongement à droite

Système	Syntaxe
Db2.	`RPAD ( Expression1 , Expression2 )`
Max DB.	`RFILL ( Expression1 , Expression2 )`
My Sql.	`RPAD ( Expression1 , Expression2 )`
Odbc.	`{ fn CONCAT ( Expression1 , { fn SPACE ( Expression2 - { fn LENGTH ( Expression1 ) } ) } ) }`
Oracle.	`RPAD ( Expression1 , Expression2 )`
PostgreSQL.	`RPAD ( Expression1 , Expression2 )`
Sql Server.	`Expression1 + SPACE ( Expression2 - LEN ( Expression1 ) )`
Up ! Application System.	`Expression1 . AjouterDroite ( Expression2 )`

Allonger à gauche

Système	Syntaxe
Db2.	`LPAD ( Expression1 , Expression2 )`
Max DB.	`LFILL ( Expression1 , Expression2 )`
My Sql.	`LPAD ( Expression1 , Expression2 )`
Odbc.	`{ fn CONCAT ( { fn SPACE ( Expression2 - { fn LENGTH ( Expression1 ) } ) } , Expression1 ) }`
Oracle.	`LPAD ( Expression1 , Expression2 )`
PostgreSQL.	`LPAD ( Expression1 , Expression2 )`
Sql Server.	`SPACE ( Expression2 - LEN ( Expression1 ) ) + Expression1`
Up ! Application System.	`Expression1 . AjouterGauche ( Expression2 )`

Chaîne de caractères

Système	Syntaxe
Db2.	`'coucou'`
Max DB.	`'coucou'`
My Sql.	`'coucou'`
Odbc.	`'coucou'`
Oracle.	`'coucou'`
PostgreSQL.	`'coucou'`
Sql Server.	`'coucou'`
Up ! Application System.	`coucou"`

Code ascii d'un caractère

Système	Syntaxe
Db2.	`ASCII ( Expression )`
Max DB.	`ASCII ( Expression )`
My Sql.	`ASCII ( Expression )`
Odbc.	`{ fn ASCII ( Expression ) }`
Oracle.	`ASCII ( Expression )`
PostgreSQL.	`ASCII ( Expression )`
Sql Server.	`ASCII ( Expression )`
Up ! Application System.	`Expression [ 0 ]`

Concaténation

Système	Syntaxe
Db2.	`CONCAT ( Expression1 , Expression2 )`
Max DB.	`Expression1 \|\| Expression2`
My Sql.	`CONCAT ( Expression1 , Expression2)`
Odbc.	`{ fn CONCAT ( Expression1 , Expression2 ) }`
Oracle.	`Expression1 \|\| Expression2`
PostgreSQL.	`Expression1 \|\| Expression2`
Sql Server.	`Expression1 + Expression2`
Up ! Application System.	`Expression1 + Expression2`

Constructeur

Système	Syntaxe
Db2.	`CHAR ( Expression , ... ) CHR ( Expression ) CLOB ( Expression ) DBCLOB ( Expression ) DIGITS ( Expression ) LONG_VARCHAR ( Expression ) TO_DATE ( Expression , ...) VARCHAR ( Expression , ...)`
Max DB.	`CHAR ( Expression , ... )`
My Sql.	`DATE_FORMAT ( Expression , ... )` `FORMAT ( Expression , ... )`
Odbc.	`{ fn CONVERT ( Expression, SQL_VARCHAR ) }`
Oracle.	`TO_CHAR ( Expression , ... ) TO_CLOB ( Expression )`
PostgreSQL.	`TO_CHAR ( Expression , ... )`
Sql Server.	`CAST ( Expression AS VARCHAR ) CONVERT ( VARCHAR, Expression , ... )`
Up ! Application System.	`Caractere( Expression , ... )`

Cryptage

Système	Syntaxe
Db2.	`ENCRYPT ( Expression1 , Expression2 )`
Max DB.	`-`
My Sql.	`ENCRYPT ( Expression1 , Expression2 )`
Odbc.	`-`
Oracle.	`-`
PostgreSQL.	`-`
Sql Server.	`-`
Up ! Application System.	`Crypter( Expression2 , Expression1 )`

Extraction de la partie centrale

Système	Syntaxe
Db2.	`SUBSTR ( Expression1 , Expression2 + 1 , Expression3 )`
Max DB.	`SUBSTR ( Expression1 , Expression2 + 1 , Expression3 )`
My Sql.	`MID ( Expression1 , Expression2 + 1 , Expression3 )`
Odbc.	`{ fn SUBSTR ( Expression1 , Expression2 + 1 , Expression3 ) }`
Oracle.	`SUBSTR ( Expression1 , Expression2 + 1 , Expression3 )`
PostgreSQL.	`SUBSTR ( Expression1 , Expression2 + 1 , Expression3 )`
Sql Server.	`SUBSTRING ( Expression1 , Expression2 + 1 , Expression3 )`
Up ! Application System.	`Expression . Milieu ( Expression2 , Expression3 )`

Extraction de la partie droite

Système	Syntaxe
Db2.	`RIGHT ( Expression1 , Expression2 )`
Max DB.	`SUBSTR ( Expression1 , LENGTH ( Expression2 ) - Expression2 , Expression2 )`
My Sql.	`RIGHT ( Expression1 , Expression2 )`
Odbc.	`{ fn RIGHT ( Expression1 , Expression2 ) }`
Oracle.	`SUBSTR ( Expression1 , - Expression2 , Expression2 )`
PostgreSQL.	`SUBSTR ( Expression1 , LENGTH ( Expression2 ) - Expression2 , Expression2 )`
Sql Server.	`RIGHT ( Expression1 , Expression2 )`
Up ! Application System.	`Expression1 . Droite ( Expression2 )`

Extraction de la partie gauche

Système	Syntaxe
Db2.	`LEFT ( Expression1 , Expression2 )`
Max DB.	`SUBSTR ( Expression1 , 1, Expression2 )`
My Sql.	`LEFT ( Expression1 , Expression2 )`
Odbc.	`{ fn LEFT ( Expression1 , Expression2 ) }`
Oracle.	`SUBSTR ( Expression1 , 1 , Expression2 )`
PostgreSQL.	`SUBSTR ( Expression1 , 1 , Expression2 )`
Sql Server.	`LEFT ( Expression1 , Expression2 )`
Up ! Application System.	`Expression1 . Gauche ( Expression2 )`

Insertion d'une sous-chaîne

Système	Syntaxe
Db2.	`INSERT ( Expression1 , Expression2 , 0, Expression3 )`
Max DB.	`CONCAT ( CONCAT ( SUBSTR ( Expression1 , 1, Expression2 ) , Expression3 ) , SUBSTR ( Expression1 , Expression2 , LENGTH ( Expression1 ) - Expression2 ) )`
My Sql.	`INSERT ( Expression1 , Expression3 , LENGTH ( Expression2 ) , Expression2 )`
Odbc.	`{ fn INSERT ( Expression1 , Expression2 , 0 , Expression3 ) }`
Oracle.	`SUBSTR ( Expression1 , 1, Expression2 ) \|\| Expression3 \|\| SUBSTR ( Expression1 , Expression2 , LENGTH ( Expression1 ) - Expression2 )`
PostgreSQL.	`SUBSTR ( Expression1 , 1, Expression2 ) \|\| Expression3 \|\| SUBSTR ( Expression1 , Expression2 , LENGTH ( Expression1 ) - Expression2 )`
Sql Server.	`SUBSTRING ( Expression1 , 1, Expression2 ) + Expression3 + SUBSTRING ( Expression1 , Expression2 , LEN ( Expression1 ) - Expression2 )`
Up ! Application System.	`Expression1 . Inserer ( Expression2 , Expression3 )`

Inversion d'une chaîne

Système	Syntaxe
Db2.	`-`
Max DB.	`-`
My Sql.	`REVERT ( Expression )`
Odbc.	`-`
Oracle.	`-`
PostgreSQL.	`-`
Sql Server.	`REVERSE ( Expression )`
Up ! Application System.	`- Expression`

Longueur

Système	Syntaxe
Db2.	`LENGTH ( Expression )`
Max DB.	`LENGTH ( Expression )`
My Sql.	`LENGTH ( Expression )`
Odbc.	`{ fn LENGTH ( Expression ) }`
Oracle.	`LENGTH ( Expression )`
PostgreSQL.	`LENGTH ( Expression )`
Sql Server.	`LEN ( Expression )`
Up ! Application System.	`Expression . Longueur ()`

Majuscule du premier caractère

Système	Syntaxe
Db2.	`INITCAP ( Expression )`
Max DB.	`CONCAT ( UPPER ( SUBSTR ( Expression , 1, 1 ) ) , LOWER ( SUBSTR ( Expression , 2, LENGTH ( Expression - 1 ) ) ) )`
My Sql.	`CONCAT ( UPPER ( LEFT ( Expression , 1 ) ) , LOWER ( RIGHT ( Expression , LENGTH ( Expression - 1 ) ) ) )`
Odbc.	`{ fn CONCAT ( { fn UCASE ( { fn LEFT ( Expression , 1 ) } ) } , { fn LCASE ( { fn RIGHT ( Expression , { fn LENGTH ( Expression - 1 ) } ) } ) } ) }`
Oracle.	`INITCAP ( Expression )`
PostgreSQL.	`INITCAP ( Expression )`
Sql Server.	`UPPER ( LEFT ( Expression , 1 ) ) + LOWER ( RIGHT ( Expression , LEN ( Expression - 1 ) ) )`
Up ! Application System.	`Expression . MajMinuscule ()`

Majuscule

Système	Syntaxe
Db2.	`UPPER ( Expression )`
Max DB.	`UPPER ( Expression )`
My Sql.	`UPPER ( Expression )`
Odbc.	`{ fn UCASE ( Expression ) }`
Oracle.	`UPPER ( Expression )`
PostgreSQL.	`UPPER ( Expression )`
Sql Server.	`UPPER ( Expression )`
Up ! Application System.	`Expression . Majuscule ()`

Minuscule

Système	Syntaxe
Db2.	`LOWER ( Expression )`
Max DB.	`LOWER ( Expression )`
My Sql.	`LOWER ( Expression )`
Odbc.	`{ fn LCASE ( Expression ) }`
Oracle.	`LOWER ( Expression )`
PostgreSQL.	`LOWER ( Expression )`
Sql Server.	`LOWER ( Expression )`
Up ! Application System.	`Expression . Minuscule ()`

Recherche de la position d'une sous-chaîne

Système	Syntaxe
Db2.	`LOCATE ( Expression1 , Expression2 + 1 , Expression3 ) - 1`
Max DB.	`INDEX ( Expression1 , Expression2 + 1 , Expression3 ) - 1`
My Sql.	`LOCATE ( Expression1 , Expression2 + 1 , Expression3 ) - 1`
Odbc.	`{ fn LOCATE ( Expression1 , Expression2 + 1 , Expression3 ) } - 1`
Oracle.	`INSTR ( Expression1 , Expression2 + 1 , Expression3 ) - 1`
PostgreSQL.	`STRPOS ( SUBSTR ( Expression1 , Expression2 + 1 ) , Expression3 ) - 1`
Sql Server.	`CHARINDEX ( Expression2 , Expression1 + 1 , Expression3 ) - 1`
Up ! Application System.	`Expression1 . Rechercher ( Expression2 , Expression3 )`

Remplacement d'occurences d'une sous-chaîne

Système	Syntaxe
Db2.	`REPLACE ( Expression1 , Expression2 , Expression3 )`
Max DB.	`REPLACE ( Expression1 , Expression2 , Expression3 )`
My Sql.	`REPLACE ( Expression1 , Expression2 , Expression3 )`
Odbc.	`{ fn REPLACE ( Expression1 , Expression2 , Expression3 ) }`
Oracle.	`REPLACE ( Expression1 , Expression2 , Expression3 )`
PostgreSQL.	`REPLACE ( Expression1 , Expression2 , Expression3 )`
Sql Server.	`REPLACE ( Expression1 , Expression2 , Expression3 )`
Up ! Application System.	`Expression1 . Remplacer ( Expression2 , Expression3 )`

Suppression des espaces

Système	Syntaxe
Db2.	`TRIM ( Expression )`
Max DB.	`RTRIM ( LTRIM ( Expression ) )`
My Sql.	`TRIM ( Expression )`
Odbc.	`{ fn RTRIM ( { fn LTRIM ( Expression ) } ) }`
Oracle.	`TRIM ( Expression )`
PostgreSQL.	`RTRIM ( LTRIM ( Expression ) )`
Sql Server.	`RTRIM ( LTRIM ( Expression ) )`
Up ! Application System.	`Expression . Supprimer ( " )`

Suppression des espaces à droite

Système	Syntaxe
Db2.	`RTRIM ( Expression )`
Max DB.	`RTRIM ( Expression )`
My Sql.	`RTRIM ( Expression )`
Odbc.	`{ fn RTRIM ( Expression ) }`
Oracle.	`RTRIM ( Expression )`
PostgreSQL.	`RTRIM ( Expression )`
Sql Server.	`RTRIM ( Expression )`
Up ! Application System.	`Expression . SupprimerDroite ( " )`

Suppression des espaces à gauche

Système	Syntaxe
Db2.	`LTRIM ( Expression )`
Max DB.	`LTRIM ( Expression )`
My Sql.	`LTRIM ( Expression )`
Odbc.	`{ fn LTRIM ( Expression ) }`
Oracle.	`LTRIM ( Expression )`
PostgreSQL.	`LTRIM ( Expression )`
Sql Server.	`LTRIM ( Expression )`
Up ! Application System.	`Expression . SupprimerGauche ( " )`

Type Date

Ajouter des jours

Système	Syntaxe
Db2.	`Expression1 + Expression2 DAYS`
Max DB.	`ADDDATE ( Expression1 , Expression2 ) SUBDATE ( Expression1 , Expression2 )`
My Sql.	`ADDDATE ( Expression1 , INTERVAL Expression2 DAY ) SUBDATE ( Expression1 , INTERVAL Expression2 DAY )`
Odbc.	`Expression1 + INTERVAL Expression2 DAY Expression1 - INTERVAL Expression2 DAY`
Oracle.	`Expression1 + Expression2`
PostgreSQL.	`Expression1 + INTERVAL Expression2 DAYS Expression1 - INTERVAL Expression2 DAYS`
Sql Server.	`DATEADD ( 'day' , Expression1 , Expression2 DAY )`
Up ! Application System.	`Expression1 . AjouterJours ( Expression2 )`

Ajouter des mois

Système	Syntaxe
Db2.	`Expression1 + Expression2 MONTHS`
Max DB.	`-`
My Sql.	`ADDDATE ( Expression1 , INTERVAL Expression2 MONTH ) SUBDATE ( Expression1 , INTERVAL Expression2 MONTH )`
Odbc.	`Expression1 + INTERVAL Expression2 MONTH Expression1 - INTERVAL Expression2 MONTH`
Oracle.	`ADD_MONTHS ( Expression1 , Expression2 )`
PostgreSQL.	`Expression1 + INTERVAL Expression2 MONTHSS Expression1 - INTERVAL Expression2 MONTHS`
Sql Server.	`DATEADD ( 'month' , Expression1 , Expression2 DAY )`
Up ! Application System.	`Expression1 . AjouterMois ( Expression2 )`

Ajouter des années

Système	Syntaxe
Db2.	`Expression1 + Expression2 YEARS`
Max DB.	`-`
My Sql.	`ADDDATE ( Expression1 , INTERVAL Expression2 YEAR ) SUBDATE ( Expression1 , INTERVAL Expression2 YEAR )`
Odbc.	`Expression1 + INTERVAL Expression2 YEAR Expression1 - INTERVAL Expression2 YEAR`
Oracle.	`ADD_MONTHS ( Expression1 , Expression2 * 12 )`
PostgreSQL.	`Expression1 + INTERVAL Expression2 YEARS Expression1 - INTERVAL Expression2 YEARS`
Sql Server.	`DATEADD ( 'year' , Expression1 , Expression2 )`
Up ! Application System.	`Expression1 . AjouterAnnees ( Expression2 )`

Ajouter des heures

Système	Syntaxe
Db2.	`Expression1 + Expression2 HOURS`
Max DB.	`-`
My Sql.	`ADDDATE ( Expression1 , INTERVAL Expression2 HOUR ) SUBDATE ( Expression1 , INTERVAL Expression2 HOUR )`
Odbc.	`Expression1 + INTERVAL Expression2 HOUR Expression1 - INTERVAL Expression2 HOUR`
Oracle.	`Expression1 + Expression2 / 24`
PostgreSQL.	`Expression1 + INTERVAL Expression2 HOURS Expression1 - INTERVAL Expression2 HOURS`
Sql Server.	`DATEADD ( 'hour' , Expression1 , Expression2 )`
Up ! Application System.	`Expression1 . AjouterHeures ( Expression2 )`

Ajouter des minutes

Système	Syntaxe
Db2.	`Expression1 + Expression2 MINUTES`
Max DB.	`-`
My Sql.	`ADDDATE ( Expression1 , INTERVAL Expression2 MINUTE ) SUBDATE ( Expression1 , INTERVAL Expression2 MINUTE )`
Odbc.	`Expression1 + INTERVAL Expression2 MINUTE Expression1 - INTERVAL Expression2 MINUTE`
Oracle.	Expression1 + Expression2 / ( 24 * 60 )
PostgreSQL.	`Expression1 + INTERVAL Expression2 MINUTES Expression1 - INTERVAL Expression2 MINUTES`
Sql Server.	`DATEADD ( 'minute' , Expression1 , Expression2 )`
Up ! Application System.	`Expression1 . AjouterMinutes ( Expression2 )`

Ajouter des secondes

Système	Syntaxe
Db2.	`Expression1 + Expression2 SECONDS`
Max DB.	`-`
My Sql.	`ADDDATE ( Expression1 , INTERVAL Expression2 SECOND ) SUBDATE ( Expression1 , INTERVAL Expression2 SECOND )`
Odbc.	`Expression1 + INTERVAL Expression2 SECOND Expression1 - INTERVAL Expression2 SECOND`
Oracle.	Expression1 + Expression2 / ( 24 * 60 * 60 )
PostgreSQL.	`Expression1 + INTERVAL Expression2 SECONDS Expression1 - INTERVAL Expression2 SECONDS`
Sql Server.	`DATEADD ( 'second' , Expression1 , Expression2 )`
Up ! Application System.	`Expression1 + Expression2`

Ajouter des millièmes de secondes

Système	Syntaxe
Db2.	`Expression1 + ( Expression2 * 1000 ) MICROSECONDS`
Max DB.	`-`
My Sql.	`ADDDATE ( Expression1 , INTERVAL Expression2 / 1000 MICROSECOND ) SUBDATE ( Expression1 , INTERVAL Expression2 * 1000 MICROSECOND )`
Odbc.	`Expression1 + INTERVAL Expression2 / 1000 SECOND Expression1 - INTERVAL Expression2 / 1000 SECOND`
Oracle.	Expression1 + Expression2 / ( 24 * 60 * 60 * 1000 )
PostgreSQL.	`Expression1 + INTERVAL Expression2 MILLISECONDS Expression1 - INTERVAL Expression2 MILLISECONDS`
Sql Server.	`DATEADD ( 'millisecond' , Expression1 , Expression2 )`
Up ! Application System.	`Expression1 . AjouterMilliemes ( Expression2 )`

Années

Système	Syntaxe
Db2.	`YEAR ( Expression )`
Max DB.	`YEAR ( Expression )`
My Sql.	`YEAR ( Expression )`
Odbc.	`{ fn YEAR ( Expression ) }`
Oracle.	`EXTRACT ( YEAR FROM Expression )`
PostgreSQL.	`EXTRACT ( YEAR FROM Expression )`
Sql Server.	`YEAR ( Expression )`
Up ! Application System.	`Expression . Annee`

Constructeur

Système	Syntaxe
Db2.	`DATE ( Expression , ... ) TIME ( Expression ) TIMESTAMP ( Expression ) TO_CHAR ( Expression , ...)`
Max DB.	`DATE ( Expression ) TIME ( Expression ) TIMESTAMP ( Expression )`
My Sql.	`DATE ( Expression )`
Odbc.	`{d Expression} {t Expression} {ts Expression} { fn CONVERT ( Expression, SQL_DATE ) } { fn CONVERT ( Expression, SQL_TIME ) } { fn CONVERT ( Expression, SQL_TIMESTAMP ) }`
Oracle.	`TO_DATE ( Expression , ... )`
PostgreSQL.	`TO_DATE ( Expression , ... )`
Sql Server.	`-`
Up ! Application System.	`Date( Expression , ... )`

Date système

Système	Syntaxe
Db2.	`CURRENT DATE CURRENT TIME`
Max DB.	`NOW ()`
My Sql.	`CURDATE () CURTIME () NOW ()`
Odbc.	`{ fn NOW () }`
Oracle.	`SYSDATE`
PostgreSQL.	`CURRENT DATE CURRENT TIME NOW ()`
Sql Server.	`-`
Up ! Application System.	DateSysteme ()

Dernier jour du mois

Système	Syntaxe
Db2.	`-`
Max DB.	`-`
My Sql.	`LAST_DAY ( Expression )`
Odbc.	`-`
Oracle.	`LAST_DAY ( Expression )`
PostgreSQL.	`-`
Sql Server.	`-`
Up ! Application System.	`Expression . DernierJour ()`

Différences entre deux dates en secondes

Système	Syntaxe
Db2.	`( Expression1 - Expression2 ) * 3600 * 24`
Max DB.	`DATEDIFF ( Expression1 , Expression2 ) * 3600 * 24`
My Sql.	`DATEDIFF ( Expression1 , Expression2 ) * 3600 * 24`
Odbc.	`{ fn TIMESTAMPDIFF ( SQL_TSI_SECOND, Expression1 , Expression2 ) }`
Oracle.	`( Expression1 - Expression2 ) * 3600 * 24`
PostgreSQL.	`( Expression1 - Expression2 ) * 3600 * 24`
Sql Server.	`DATEDIFF ( 'second' , Expression1 , Expression2 )`
Up ! Application System.	`Expression1 - Expression2`

Heures

Système	Syntaxe
Db2.	`HOUR ( Expression )`
Max DB.	`HOUR ( Expression )`
My Sql.	`HOUR ( Expression )`
Odbc.	`{ fn HOUR ( Expression ) }`
Oracle.	`EXTRACT ( HOUR FROM Expression )`
PostgreSQL.	`EXTRACT ( HOUR FROM Expression )`
Sql Server.	`DATEPART ( 'hour' , Expression )`
Up ! Application System.	`Expression . Heure`

Millièmes de seconde

Système	Syntaxe
Db2.	`MICROSECONDS ( Expression ) * 1000`
Max DB.	`MICROSECONDS ( Expression ) * 1000`
My Sql.	`MICROSECONDS ( Expression ) * 1000`
Odbc.	`{ fn MOD ( { fn EXTRACT ( SECOND FROM Expression ) } * 1000 ) , 1000 ) }`
Oracle.	`MOD ( EXTRACT ( SECOND FROM Expression ) * 1000 , 1000 )`
PostgreSQL.	`EXTRACT ( MILLISECONDS FROM Expression )`
Sql Server.	`DATEPART ( 'millisecond' , Expression )`
Up ! Application System.	`Expression . Millieme`

Minutes

Système	Syntaxe
Db2.	`MINUTE ( Expression )`
Max DB.	`MINUTE ( Expression )`
My Sql.	`MINUTE ( Expression )`
Odbc.	`{ fn MINUTE ( Expression ) }`
Oracle.	`EXTRACT ( MINUTE FROM Expression )`
PostgreSQL.	`EXTRACT ( MINUTE FROM Expression )`
Sql Server.	`DATEPART ( 'minute' , Expression )`
Up ! Application System.	`Expression . Minute`

Nom du jour

Système	Syntaxe
Db2.	`DAYNAME ( Expression )`
Max DB.	`DAYNAME ( Expression )`
My Sql.	`DAYNAME ( Expression )`
Odbc.	`{ fn DAYNAME ( Expression ) }`
Oracle.	`RTRIM ( TO_CHAR ( Expression , 'DAY' ) )`
PostgreSQL.	`RTRIM ( TO_CHAR ( Expression , 'day' ) )`
Sql Server.	`DATENAME ( 'day' , Expression )`
Up ! Application System.	Caractere ( `Expression , %JJ" )`

Nom du mois

Système	Syntaxe
Db2.	`MONTHNAME ( Expression )`
Max DB.	`MONTHNAME ( Expression )`
My Sql.	`MONTHNAME ( Expression )`
Odbc.	`{ fn MONTHNAME ( Expression ) }`
Oracle.	`RTRIM ( TO_CHAR ( Expression , 'MONTH' ) )`
PostgreSQL.	`RTRIM ( TO_CHAR ( Expression , 'month' ) )`
Sql Server.	`DATENAME ( 'month' , Expression )`
Up ! Application System.	Caractere ( `Expression , %MMM" )`

Numéro du jour dans la semaine

Système	Syntaxe
Db2.	`DAYOFWEEK ( Expression )`
Max DB.	`DAYOFWEEK ( Expression )`
My Sql.	`DAYOFWEEK ( Expression )`
Odbc.	`{ fn DAYOFWEEK ( Expression ) }`
Oracle.	`TO_NUMBER ( TO_CHAR ( Expression , 'D' ) )`
PostgreSQL.	`TO_NUMBER ( TO_CHAR ( Expression , 'D' ) )`
Sql Server.	`DATEPART ( 'weekday' , Expression )`
Up ! Application System.	`Entier( Caractere( Expression , %js" ) )`

Numéro du jour dans le mois

Système	Syntaxe
Db2.	`DAY ( Expression )`
Max DB.	`DAYOFMONTH ( Expression )`
My Sql.	`DAYOFMONTH ( Expression )`
Odbc.	`{ fn DAYOFMONTH ( Expression ) }`
Oracle.	`TO_NUMBER ( TO_CHAR ( Expression , 'DD' ) )`
PostgreSQL.	`TO_NUMBER ( TO_CHAR ( Expression , 'DD' ) )`
Sql Server.	`DAY ( Expression )`
Up ! Application System.	`Expression . Jour`

Numéro du jour dans l'année

Système	Syntaxe
Db2.	`DAYOFYEAR ( Expression )`
Max DB.	`DAYOFYEAR ( Expression )`
My Sql.	`DAYOFYEAR ( Expression )`
Odbc.	`{ fn DAYOFYEAR ( Expression ) }`
Oracle.	`TO_NUMBER ( TO_CHAR ( Expression , 'DDD' ) )`
PostgreSQL.	`TO_NUMBER ( TO_CHAR ( Expression , 'DDD' ) )`
Sql Server.	`DATEPART ( 'dayofyear' , Expression )`
Up ! Application System.	`Entier( Caractere( Expression , %jjj" ) )`

Numéro du jour dans le calendrier Julien

Système	Syntaxe
Db2.	`JULIAN_DAY ( Expression )`
Max DB.	`-`
My Sql.	`-`
Odbc.	`-`
Oracle.	`TO_NUMBER ( TO_CHAR ( Expression , 'J' ) )`
PostgreSQL.	`TO_NUMBER ( TO_CHAR ( Expression , 'J' ) )`
Sql Server.	`-`
Up ! Application System.	`Entier ( Expression )`

Numéro de la semaine

Système	Syntaxe
Db2.	`WEEK ( Expression )`
Max DB.	`WEEKOFYEAR ( Expression )`
My Sql.	`WEEK ( Expression )`
Odbc.	`{ fn WEEK ( Expression ) }`
Oracle.	`TO_NUMBER ( TO_CHAR ( Expression , 'W' ) )`
PostgreSQL.	`EXTRACT ( WEEK FROM Expression )`
Sql Server.	`DATEPART ( 'week' , Expression )`
Up ! Application System.	`Entier( Caractere( Expression , %w" ) )`

Numéro du mois

Système	Syntaxe
Db2.	`MONTH ( Expression )`
Max DB.	`MONTH ( Expression )`
My Sql.	`MONTH ( Expression )`
Odbc.	`{ fn MONTH ( Expression ) }`
Oracle.	`EXTRACT ( MONTH FROM Expression )`
PostgreSQL.	`EXTRACT ( MONTH FROM Expression )`
Sql Server.	`MONTH ( Expression )`
Up ! Application System.	`Expression . Mois`

Numéro du trimestre

Système	Syntaxe
Db2.	`QUARTER ( Expression )`
Max DB.	`TRUNC ( MONTH ( Expression ) / 3 )`
My Sql.	`QUARTER ( Expression )`
Odbc.	`{ fn QUARTER ( Expression ) }`
Oracle.	`TO_NUMBER ( TO_CHAR ( Expression , 'Q' ) )`
PostgreSQL.	`TO_NUMBER ( TO_CHAR ( Expression , 'Q' ) )`
Sql Server.	`DATEPART ( 'quarter' , Expression )`
Up ! Application System.	`Entier( Caractere( Expression , %t" ) )`

Secondes

Système	Syntaxe
Db2.	`SECOND ( Expression )`
Max DB.	`SECOND ( Expression )`
My Sql.	`SECOND ( Expression )`
Odbc.	`{ fn SECOND ( Expression ) }`
Oracle.	`EXTRACT ( SECOND FROM Expression )`
PostgreSQL.	`EXTRACT ( SECOND FROM Expression )`
Sql Server.	`DATEPART ( 'second' , Expression )`
Up ! Application System.	`Expression . Seconde`

Type Entier

Constructeur

Système	Syntaxe
Db2.	`BIGINT ( Expression )` INTEGER ( Expression ) SMALLINT ( Expression )
Max DB.	`INTEGER ( Expression ) NUM ( Expression )`
My Sql.	`CAST ( Expression AS INTEGER )`
Odbc.	`{ fn CONVERT ( Expression, SQL_INTEGER ) }`
Oracle.	`TO_NUMBER ( Expression , ... )`
PostgreSQL.	`TO_NUMBER ( Expression , ... )`
Sql Server.	`CAST ( Expression AS INTEGER ) CONVERT ( INTEGER, Expression , ... )`
Up ! Application System.	`Entier( Expression )`

Type Reel

Arrondir

Système	Syntaxe
Db2.	`ROUND ( Expression1 , Expression2 )`
Max DB.	`ROUND ( Expression1 , Expression2 )`
My Sql.	`ROUND ( Expression1 , Expression2 )`
Odbc.	`{ fn ROUND ( Expression1 , Expression2 ) }`
Oracle.	`ROUND ( Expression1 , Expression2 )`
PostgreSQL.	`ROUND ( Expression1 , Expression2 )`
Sql Server.	`ROUND ( Expression1 , Expression2 )`
Up ! Application System.	`Expression1 . Arrondir ( Expression2 )`

Constructeur

Système	Syntaxe
Db2.	`DECIMAL ( Expression , ... ) DOUBLE ( Expression ) FLOAT ( Expression ) REAL ( Expression )`
Max DB.	`FIXED ( Expression , 8 , 5 ) FLOAT ( Expression , 8 )`
My Sql.	`CAST ( Expression AS DOUBLE) CAST ( Expression AS FLOAT)`
Odbc.	`{ fn CONVERT ( Expression, SQL_FLOAT ) }`
Oracle.	`TO_NUMBER ( Expression , ... )`
PostgreSQL.	`TO_NUMBER ( Expression , ... )`
Sql Server.	`CAST ( Expression AS FLOAT ) CONVERT ( FLOAT, Expression , ... )`
Up ! Application System.	`Reel( Expression1 )`

Instructions des expressions

Calculs booléens

Différent

Système	Syntaxe
Db2.	`Expression1 <> Expression2`
Max DB.	`Expression1 <> Expression2`
My Sql.	`Expression1 <=> Expression2`
Odbc.	`Expression1 <> Expression2`
Oracle.	`Expression1 <> Expression2`
PostgreSQL.	`Expression1 <> Expression2`
PostgreSQL.	`Expression1 <> Expression2`
Up ! Application System.	`Expression1 != Expression2`

Egal

Système	Syntaxe
Db2.	`Expression1 = Expression2`
Max DB.	`Expression1 = Expression2`
My Sql.	`Expression1 = Expression2`
Odbc.	`Expression1 = Expression2`
Oracle.	`Expression1 = Expression2`
PostgreSQL.	`Expression1 = Expression2`
PostgreSQL.	`Expression1 = Expression2`
Up ! Application System.	`Expression1 == Expression2`

Et logique

Système	Syntaxe
Db2.	`Expression1 AND Expression2`
Max DB.	`Expression1 AND Expression2`
My Sql.	`Expression1 AND Expression2`
Odbc.	`Expression1 AND Expression2`
Oracle.	`Expression1 AND Expression2`
PostgreSQL.	`Expression1 AND Expression2`
PostgreSQL.	`Expression1 AND Expression2`
Up ! Application System.	`Expression1 Et Expression2`

Inférieur ou égal

Système	Syntaxe
Db2.	`Expression1 <= Expression2`
Max DB.	`Expression1 <= Expression2`
My Sql.	`Expression1 <= Expression2`
Odbc.	`Expression1 <= Expression2`
Oracle.	`Expression1 <= Expression2`
PostgreSQL.	`Expression1 <= Expression2`
PostgreSQL.	`Expression1 <= Expression2`
Up ! Application System.	`Expression1 <= Expression2`

Inférieur strict

Système	Syntaxe
Db2.	`Expression1 < Expression2`
Max DB.	`Expression1 < Expression2`
My Sql.	`Expression1 < Expression2`
Odbc.	`Expression1 < Expression2`
Oracle.	`Expression1 < Expression2`
PostgreSQL.	`Expression1 < Expression2`
PostgreSQL.	`Expression1 < Expression2`
Up ! Application System.	`Expression1 < Expression2`

Non logique

Système	Syntaxe
Db2.	`NOT Expression`
Max DB.	`NOT Expression`
My Sql.	`NOT Expression`
Odbc.	`NOT Expression`
Oracle.	`NOT Expression`
PostgreSQL.	`NOT Expression`
PostgreSQL.	`NOT Expression`
Up ! Application System.	`Non Expression`

Ou logique exclusif

Système	Syntaxe
Db2.	`Expression1 XOR Expression2`
Max DB.	`( Expression1 AND ( NOT Expression2 ) ) OR ( ( NOT Expression1 ) AND Expression2 )`
My Sql.	`Expression1 XOR Expression2`
Odbc.	`( Expression1 AND ( NOT Expression2 ) ) OR ( ( NOT Expression1 ) AND Expression2 )`
Oracle.	`( Expression1 AND ( NOT Expression2 ) ) OR ( ( NOT Expression1 ) AND Expression2 )`
PostgreSQL.	`( Expression1 AND ( NOT Expression2 ) ) OR ( ( NOT Expression1 ) AND Expression2 )`
Sql Server.	`( Expression1 AND ( NOT Expression2 ) ) OR ( ( NOT Expression1 ) AND Expression2 )`
Up ! Application System.	`Expression1 OuExclusif Expression2`

Ou logique inclusif

Système	Syntaxe
Db2.	`Expression1 OR Expression2`
Max DB.	`Expression1 OR Expression2`
My Sql.	`Expression1 OR Expression2`
Odbc.	`Expression1 OR Expression2`
Oracle.	`Expression1 OR Expression2`
PostgreSQL.	`Expression1 OR Expression2`
PostgreSQL.	`Expression1 OR Expression2`
Up ! Application System.	`Expression1 Ou Expression2`

Supérieur ou égal

Système	Syntaxe
Db2.	`Expression1 >= Expression2`
Max DB.	`Expression1 >= Expression2`
My Sql.	`Expression1 >= Expression2`
Odbc.	`Expression1 >= Expression2`
Oracle.	`Expression1 >= Expression2`
PostgreSQL.	`Expression1 >= Expression2`
PostgreSQL.	`Expression1 >= Expression2`
Up ! Application System.	`Expression1 >= Expression2`

Supérieur strict

Système	Syntaxe
Db2.	`Expression1 > Expression2`
Max DB.	`Expression1 > Expression2`
My Sql.	`Expression1 > Expression2`
Odbc.	`Expression1 > Expression2`
Oracle.	`Expression1 > Expression2`
PostgreSQL.	`Expression1 > Expression2`
PostgreSQL.	`Expression1 > Expression2`
Up ! Application System.	`Expression1 > Expression2`

Calculs scientifiques

Arc cosinus

Système	Syntaxe
Db2.	`ACOS ( Expression )`
Max DB.	`ACOS ( Expression )`
My Sql.	`ACOS ( Expression )`
Odbc.	`{ fn ACOS ( Expression ) }`
Oracle.	`ACOS ( Expression )`
PostgreSQL.	`ACOS ( Expression )`
Sql Server.	`ACOS ( Expression )`
Up ! Application System.	`ACos( Expression )`

Arc cosinus hyperbolique

Système	Syntaxe
Db2.	`Expression + SQRT ( POWER ( Expression, 2.0 ) - 1)`
Max DB.	`Expression + SQRT ( POWER ( Expression, 2.0 ) - 1)`
My Sql.	`Expression + SQRT ( POWER ( Expression, 2.0 ) - 1)`
Odbc.	`Expression + { fn SQRT ( { fn POWER ( Expression, 2.0 ) } - 1) }`
Oracle.	`Expression + SQRT ( POWER ( Expression, 2.0 ) - 1)`
PostgreSQL.	`Expression + SQRT ( POWER ( Expression, 2.0 ) - 1)`
Sql Server.	`Expression + SQRT ( POWER ( Expression, 2.0 ) - 1)`
Up ! Application System.	`ACosH( Expression )`

Arc cotangeante

Système	Syntaxe
Db2.	`ATAN ( 1 / Expression )`
Max DB.	`ATAN ( 1 / Expression )`
My Sql.	`ATAN ( 1 / Expression )`
Odbc.	`{ fn ATAN ( 1 / Expression ) }`
Oracle.	`ATAN ( 1 / Expression )`
PostgreSQL.	`ATAN ( 1 / Expression )`
Sql Server.	`ATAN ( 1 / Expression )`
Up ! Application System.	`ACot( Expression )`

Arc cotangeante hyperbolique

Système	Syntaxe
Db2.	`ATANH ( 1 / Expression )`
Max DB.	`ATANH ( 1 / Expression )`
My Sql.	`LN ( SQRT ( ( ( 1 / Expression ) + 1 ) / ( ( 1 / Expression ) - 1 ) ) )`
Odbc.	`{ fn LN ( { fn SQRT ( ( ( 1 / Expression ) + 1 ) / ( ( 1 / Expression ) - 1 ) ) } ) }`
Oracle.	`LN ( SQRT ( ( ( 1 / Expression ) + 1 ) / ( ( 1 / Expression ) - 1 ) ) )`
PostgreSQL.	`LN ( SQRT ( ( ( 1 / Expression ) + 1 ) / ( ( 1 / Expression ) - 1 ) ) )`
Sql Server.	`LOG ( SQRT ( ( ( 1 / Expression ) + 1 ) / ( ( 1 / Expression ) - 1 ) ) )`
Up ! Application System.	`ACotH( Expression )`

Arc sinus

Système	Syntaxe
Db2.	`ASIN ( Expression )`
Max DB.	`ASIN ( Expression )`
My Sql.	`ASIN ( Expression )`
Odbc.	`{ fn ASIN ( Expression ) }`
Oracle.	`ASIN ( Expression )`
PostgreSQL.	`ASIN ( Expression )`
Sql Server.	`ASIN ( Expression )`
Up ! Application System.	`ASin( Expression )`

Arc sinus hyperbolique

Système	Syntaxe
Db2.	`Expression + SQRT ( POWER ( Expression, 2.0 ) + 1)`
Max DB.	`Expression + SQRT ( POWER ( Expression, 2.0 ) + 1)`
My Sql.	`Expression + SQRT ( POWER ( Expression, 2.0 ) + 1)`
Odbc.	`Expression + { fn SQRT ( { fn POWER ( Expression, 2.0 ) } + 1) }`
Oracle.	`Expression + SQRT ( POWER ( Expression, 2.0 ) + 1)`
PostgreSQL.	`Expression + SQRT ( POWER ( Expression, 2.0 ) + 1)`
Sql Server.	`-`
Up ! Application System.	`ASinH( Expression )`

Arc tangeante

Système	Syntaxe
Db2.	`ATAN ( Expression )`
Max DB.	`ATAN ( Expression )`
My Sql.	`ATAN ( Expression )`
Odbc.	`{ fn ATAN ( Expression ) }`
Oracle.	`ATAN ( Expression )`
PostgreSQL.	`ATAN ( Expression )`
Sql Server.	`ATAN ( Expression )`
Up ! Application System.	`ATan( Expression )`

Arc tangeante hyperbolique

Système	Syntaxe
Db2.	`ATANH ( Expression )`
Max DB.	`ATANH ( Expression )`
My Sql.	`LN ( SQRT ( ( Expression + 1 ) / ( Expression - 1 ) ) )`
Odbc.	`{ fn LN ( { fn SQRT ( ( Expression + 1 ) / ( Expression - 1 ) ) } ) }`
Oracle.	`LN ( SQRT ( ( Expression + 1 ) / ( Expression - 1 ) ) )`
PostgreSQL.	`LN ( SQRT ( ( Expression + 1 ) / ( Expression - 1 ) ) )`
Sql Server.	`LOG ( SQRT ( ( Expression + 1 ) / ( Expression - 1 ) ) )`
Up ! Application System.	`ATanH( Expression )`

Conversion de degrés en radians

Système	Syntaxe
Db2.	`DEGREES ( Expression )`
Max DB.	`DEGREES ( Expression )`
My Sql.	`DEGREES ( Expression )`
Odbc.	`{ fn DEGREES ( Expression ) }`
Oracle.	`Expression / 180 * 3.14159265359`
PostgreSQL.	`DEGREES ( Expression )`
Sql Server.	`DEGREES ( Expression )`
Up ! Application System.	`ConvertirAngle( Expression , AngleDegres )`

Conversion de radians en degrés

Système	Syntaxe
Db2.	`RADIANS ( Expression )`
Max DB.	`RADIANS ( Expression )`
My Sql.	`RADIANS ( Expression )`
Odbc.	`{ fn RADIANS ( Expression ) }`
Oracle.	`Expression / 3.14159265359 * 180`
PostgreSQL.	`RADIANS ( Expression )`
Sql Server.	`RADIANS ( Expression )`
Up ! Application System.	`ConvertirAngle( Expression , AngleRadians )`

Cosinus

Système	Syntaxe
Db2.	`COS ( Expression )`
Max DB.	`COS ( Expression )`
My Sql.	`COS ( Expression )`
Odbc.	`{ fn COS ( Expression ) }`
Oracle.	`COS ( Expression )`
PostgreSQL.	`COS ( Expression )`
Sql Server.	`COS ( Expression )`
Up ! Application System.	`Cos( Expression )`

Cosinus hyperbolique

Système	Syntaxe
Db2.	`COSH ( Expression )`
Max DB.	`COSH ( Expression )`
My Sql.	`( EXP ( Expression ) + EXP ( - Expression ) ) / 2`
Odbc.	`( { fn EXP ( Expression ) } + { fn EXP ( - Expression ) } ) / 2`
Oracle.	`COSH ( Expression )`
PostgreSQL.	`( EXP ( Expression ) + EXP ( - Expression ) ) / 2`
Sql Server.	`( EXP ( Expression ) + EXP ( - Expression ) ) / 2`
Up ! Application System.	`CosH( Expression )`

Cotangeante

Système	Syntaxe
Db2.	`COT ( Expression )`
Max DB.	`COT ( Expression )`
My Sql.	`COT ( Expression )`
Odbc.	`{ fn COT ( Expression ) }`
Oracle.	`1 / TAN ( Expression )`
PostgreSQL.	`COT ( Expression )`
Sql Server.	`COT ( Expression )`
Up ! Application System.	`Cot( Expression )`

Cotangeante hyperbolique

Système	Syntaxe
Db2.	`EXP ( ( 2 * Expression ) + 1 ) / EXP ( ( 2 * Expression ) - 1 )`
Max DB.	`EXP ( ( 2 * Expression ) + 1 ) / EXP ( ( 2 * Expression ) - 1 )`
My Sql.	`EXP ( ( 2 * Expression ) + 1 ) / EXP ( ( 2 * Expression ) - 1 )`
Odbc.	`{ fn EXP ( ( 2 * Expression ) + 1 ) } / { fn EXP ( ( 2 * Expression ) - 1 ) }`
Oracle.	`EXP ( ( 2 * Expression ) + 1 ) / EXP ( ( 2 * Expression ) - 1 )`
PostgreSQL.	`EXP ( ( 2 * Expression ) + 1 ) / EXP ( ( 2 * Expression ) - 1 )`
Sql Server.	`EXP ( ( 2 * Expression ) + 1 ) / EXP ( ( 2 * Expression ) - 1 )`
Up ! Application System.	`CotH( Expression )`

Division entière

Système	Syntaxe
Db2.	`TRUNC ( Expression1 / Expression2 )`
Max DB.	`TRUNC ( Expression1 / Expression2 )`
My Sql.	`Expression1 DIV Expression2`
Odbc.	`{ fn TRUNC ( Expression1 / Expression2 , 0 ) }`
Oracle.	`TRUNC ( Expression1 / Expression2 )`
PostgreSQL.	`TRUNC ( Expression1 / Expression2 )`
Sql Server.	`TRUNC ( Expression1 / Expression2 )`
Up ! Application System.	`Expression1 / Expression2`

Exponentielle

Système	Syntaxe
Db2.	`EXP ( Expression )`
Max DB.	`EXP ( Expression )`
My Sql.	`EXP ( Expression )`
Odbc.	`{ fn EXP ( Expression ) }`
Oracle.	`EXP ( Expression )`
PostgreSQL.	`EXP ( Expression )`
Sql Server.	`EXP ( Expression )`
Up ! Application System.	`Exp( Expression )`

Logarithme décimal

Système	Syntaxe
Db2.	`LOG10 ( Expression )`
Max DB.	`LOG ( Expression , 10 )`
My Sql.	`LOG10 ( Expression )`
Odbc.	`{ fn LOG10 ( Expression ) }`
Oracle.	`LOG10 ( Expression )`
PostgreSQL.	`LOG ( Expression )`
Sql Server.	`LOG ( Expression )`
Up ! Application System.	`Log10( Expression )`

Logarithme népérien

Système	Syntaxe
Db2.	`LN ( Expression )`
Max DB.	`LN ( Expression )`
My Sql.	`LN ( Expression )`
Odbc.	`{ fn LN ( Expression ) }`
Oracle.	`LN ( Expression )`
PostgreSQL.	`LN ( Expression )`
Sql Server.	`LOG ( Expression )`
Up ! Application System.	`Log( Expression )`

Modulo

Système	Syntaxe
Db2.	`MOD ( Expression1 , Expression2 )`
Max DB.	`MOD ( Expression1 , Expression2 )`
My Sql.	`MOD ( Expression1 , Expression2 )`
Odbc.	`{ fn MOD ( Expression1 , Expression2 ) }`
Oracle.	`MOD ( Expression1 , Expression2 )`
PostgreSQL.	`Expression1 % Expression2`
Sql Server.	`Expression1 % Expression2`
Up ! Application System.	`Expression1 % Expression2`

Partie entière

Système	Syntaxe
Db2.	`FLOOR ( Expression )`
Max DB.	`FLOOR ( Expression )`
My Sql.	`FLOOR ( Expression )`
Odbc.	`{ fn FLOOR ( Expression ) }`
Oracle.	`FLOOR ( Expression )`
PostgreSQL.	`FLOOR ( Expression )`
Sql Server.	`FLOOR ( Expression )`
Up ! Application System.	`Entier( Expression )`

Puissance

Système	Syntaxe
Db2.	`POWER ( Expression1 , Expression2 )`
Max DB.	`POWER ( Expression1 , Expression2 )`
My Sql.	`POWER ( Expression1 , Expression2 )`
Odbc.	`{ fn POWER ( Expression1 , Expression2 ) }`
Oracle.	`POWER ( Expression1 , Expression2 )`
PostgreSQL.	`POWER ( Expression1 , Expression2 )`
Sql Server.	`POWER ( Expression1 , Expression2 )`
Up ! Application System.	`Expression1 ^ Expression2`

Racine carrée

Système	Syntaxe
Db2.	`SQRT ( Expression )`
Max DB.	`SQRT ( Expression )`
My Sql.	`SQRT ( Expression )`
Odbc.	`{ fn SQRT ( Expression ) }`
Oracle.	`SQRT ( Expression )`
PostgreSQL.	`SQRT ( Expression )`
Sql Server.	`SQRT ( Expression )`
Up ! Application System.	`Racine( Expression )`

Sinus

Système	Syntaxe
Db2.	`SIN ( Expression )`
Max DB.	`SIN ( Expression )`
My Sql.	`SIN ( Expression )`
Odbc.	`{ fn SIN ( Expression ) }`
Oracle.	`SIN ( Expression )`
PostgreSQL.	`SIN ( Expression )`
Sql Server.	`SIN ( Expression )`
Up ! Application System.	`Sin( Expression )`

Sinus hyperbolique

Système	Syntaxe
Db2.	`SINH ( Expression )`
Max DB.	`SINH ( Expression )`
My Sql.	`( EXP ( Expression ) - EXP ( Expression ) ) / 2`
Odbc.	`( { fn EXP ( Expression ) } - { fn EXP ( Expression ) } ) / 2`
Oracle.	`SINH ( Expression )`
PostgreSQL.	`( EXP ( Expression ) - EXP ( Expression ) ) / 2`
Sql Server.	`( EXP ( Expression ) - EXP ( Expression ) ) / 2`
Up ! Application System.	`SinH( Expression )`

Tangeante

Système	Syntaxe
Db2.	`TAN ( Expression )`
Max DB.	`TAN ( Expression )`
My Sql.	`TAN ( Expression )`
Odbc.	`{ fn TAN ( Expression ) }`
Oracle.	`TAN ( Expression )`
PostgreSQL.	`TAN ( Expression )`
Sql Server.	`TAN ( Expression )`
Up ! Application System.	`Tan( Expression )`

Tangeante hyperbolique

Système	Syntaxe
Db2.	`TANH ( Expression )`
Max DB.	`TANH ( Expression )`
My Sql.	`EXP ( ( 2 * Expression ) - 1 ) / EXP ( ( 2 * Expression + 1 ) )`
Odbc.	`{ fn EXP ( ( 2 * Expression ) - 1 ) } / { fn EXP ( ( 2 * Expression + 1 ) ) }`
Oracle.	`TANH ( Expression )`
PostgreSQL.	`EXP ( ( 2 * Expression ) - 1 ) / EXP ( ( 2 * Expression + 1 ) )`
Sql Server.	`EXP ( ( 2 * Expression ) - 1 ) / EXP ( ( 2 * Expression + 1 ) )`
Up ! Application System.	`TanH( Expression )`

Valeur absolue

Système	Syntaxe
Db2.	`ABS ( Expression )`
Max DB.	`ABS ( Expression )`
My Sql.	`ABS ( Expression )`
Odbc.	`{ fn ABS ( Expression ) }`
Oracle.	`ABS ( Expression )`
PostgreSQL.	`ABS ( Expression )`
Sql Server.	`ABS ( Expression )`
Up ! Application System.	`Abs( Expression )`

Opérateurs de groupe

Comptage

Système	Syntaxe
Db2.	`COUNT ( Expression )`
Max DB.	`COUNT ( Expression )`
My Sql.	`COUNT ( Expression )`
Odbc.	`COUNT ( Expression )`
Oracle.	`COUNT ( Expression )`
PostgreSQL.	`COUNT ( Expression )`
Sql Server.	`COUNT ( Expression )`
Up ! Application System.	`-`

Corrélation

Système	Syntaxe
Db2.	`CORRELATION ( Expression1 , Expression2 )`
Max DB.	`-`
My Sql.	`-`
Odbc.	`-`
Oracle.	`-`
PostgreSQL.	`-`
Sql Server.	`-`
Up ! Application System.	`-`

Covariance

Système	Syntaxe
Db2.	`COVARIANCE ( Expression1 , Expression2 )`
Max DB.	`-`
My Sql.	`-`
Odbc.	`-`
Oracle.	`-`
PostgreSQL.	`-`
Sql Server.	`-`
Up ! Application System.	`-`

Ecart-type

Système	Syntaxe
Db2.	`STDDEV ( Expression )`
Max DB.	`STDDEV ( Expression )`
My Sql.	`STDDEV ( Expression )`
Odbc.	`-`
Oracle.	`STDDEV ( Expression )`
PostgreSQL.	`STDDEV ( Expression )`
Sql Server.	`STDEV ( Expression )`
Up ! Application System.	`EcartType( Expression )`

Maximum

Système	Syntaxe
Db2.	`MAX ( Expression )`
Max DB.	`GREATEST ( Expression ) MAX ( Expression )`
My Sql.	`GREATEST ( Expression ) MAX ( Expression )`
Odbc.	`MAX ( Expression )`
Oracle.	`GREATEST ( Expression ) MAX ( Expression )`
PostgreSQL.	`GREATEST ( Expression ) MAX ( Expression )`
Sql Server.	`MAX ( Expression )`
Up ! Application System.	`Max( Expression )`

Minimum

Système	Syntaxe
Db2.	`MIN ( Expression )`
Max DB.	`LEAST ( Expression ) MIN ( Expression )`
My Sql.	`LEAST ( Expression ) MIN ( Expression )`
Odbc.	`MIN ( Expression )`
Oracle.	`LEAST ( Expression ) MIN ( Expression )`
PostgreSQL.	`LEAST ( Expression ) MIN ( Expression )`
Sql Server.	`MIN ( Expression )`
Up ! Application System.	`Min( Expression )`

Moyenne

Système	Syntaxe
Db2.	`AVG ( Expression )`
Max DB.	`AVG ( Expression )`
My Sql.	`AVG ( Expression )`
Odbc.	`AVG ( Expression )`
Oracle.	`AVG ( Expression )`
PostgreSQL.	`AVG ( Expression )`
Sql Server.	`AVG ( Expression )`
Up ! Application System.	`Moyenne( Expression )`

Somme

Système	Syntaxe
Db2.	`SUM ( Expression )`
Max DB.	`SUM ( Expression )`
My Sql.	`SUM ( Expression )`
Odbc.	`SUM ( Expression )`
Oracle.	`SUM ( Expression )`
PostgreSQL.	`SUM ( Expression )`
Sql Server.	`SUM ( Expression )`
Up ! Application System.	`Somme( Expression )`

Variance

Système	Syntaxe
Db2.	`VARIANCE ( Expression )`
Max DB.	`VARIANCE ( Expression )`
My Sql.	`VARIANCE ( Expression )`
Odbc.	`-`
Oracle.	`VARIANCE ( Expression )`
PostgreSQL.	`VARIANCE ( Expression )`
Sql Server.	`VARIANCE ( Expression )`
Up ! Application System.	`Variance( Expression )`

Test

Comme

Système	Syntaxe
Db2.	`Expression1 LIKE Expression2`
Max DB.	`Expression1 LIKE Expression2`
My Sql.	`Expression1 LIKE Expression2`
Odbc.	`Expression1 LIKE { escape '%' } Expression2`
Oracle.	`Expression1 LIKE Expression2`
PostgreSQL.	`Expression1 LIKE Expression2`
Sql Server.	`Expression1 LIKE Expression2`
Up ! Application System.	`Expression1 Comme Expression2`

Dans

Système	Syntaxe
Db2.	`Expression1 IN ( Expression2 , ... )`
Max DB.	`Expression1 IN ( Expression2 , ... )`
My Sql.	`Expression1 IN ( Expression2 , ... )`
Odbc.	`Expression1 IN ( Expression2 , ... )`
Oracle.	`Expression1 IN ( Expression2 , ... )`
PostgreSQL.	`Expression1 IN ( Expression2 , ... )`
Sql Server.	`Expression1 IN ( Expression2 , ... )`
Up ! Application System.	`Expression1 Dans ( Expression2 , ... )`

Entre

Système	Syntaxe
Db2.	`Expression1 BETWEEN Expression2 AND Expression2`
Max DB.	`Expression1 BETWEEN Expression2 AND Expression2`
My Sql.	`Expression1 BETWEEN Expression2 AND Expression2`
Odbc.	`Expression1 BETWEEN Expression2 AND Expression2`
Oracle.	`Expression1 BETWEEN Expression2 AND Expression2`
PostgreSQL.	`Expression1 BETWEEN Expression2 AND Expression2`
Sql Server.	`Expression1 BETWEEN Expression2 AND Expression2`
Up ! Application System.	`Expression1 Entre Expression2 Et Expression3`

Existence

Système	Syntaxe
Db2.	`EXIST ( Requete )`
Max DB.	`EXIST ( Requete )`
My Sql.	`EXIST ( Requete )`
Odbc.	`EXIST ( Requete )`
Oracle.	`EXIST ( Requete )`
PostgreSQL.	`EXIST ( Requete )`
Sql Server.	`EXIST ( Requete )`
Up ! Application System.	`-`

Valeur nulle

Système	Syntaxe
Db2.	`Expression IS NULL`
Max DB.	`Expression IS NULL`
My Sql.	`Expression IS NULL`
Odbc.	`Expression IS NULL`
Oracle.	`Expression IS NULL`
PostgreSQL.	`Expression IS NULL`
Sql Server.	`Expression IS NULL`
Up ! Application System.	`Expression1 == Nul`

Valeur non nulle

Système	Syntaxe
Db2.	`Expression IS NOT NULL`
Max DB.	`Expression IS NOT NULL`
My Sql.	`Expression IS NOT NULL`
Odbc.	`Expression IS NOT NULL`
Oracle.	`Expression IS NOT NULL`
PostgreSQL.	`Expression IS NOT NULL`
Sql Server.	`Expression IS NOT NULL`
Up ! Application System.	`Expression1 != Nul`

Transcodage

Conversion

Système	Syntaxe
Db2.	`CAST ( Expression AS NomDuType )`
Max DB.	`-`
My Sql.	`CAST ( Expression AS NomDuType )`
Odbc.	`{ fn CONVERT ( NomDuType , Expression ) }`
Oracle.	`CAST ( Expression AS NomDuType )`
PostgreSQL.	`CAST ( Expression AS NomDuType )`
Sql Server.	`CAST ( Expression AS NomDuType )`
Up ! Application System.	NomDuType ( Expression )

Décodage

Système	Syntaxe
Db2.	`CASE Expression1 WHEN Expression2 THEN Expression3 ... ELSE Expression4 END`
Max DB.	`DECODE ( Expression1 , Expression2 , Expression3 , ... , Expression4 ) CASE Expression1 WHEN Expression2 THEN Expression3 ... ELSE Expression4 END`
My Sql.	`CASE Expression1 WHEN Expression2 THEN Expression3 ... ELSE Expression4 END`
Odbc.	`-`
Oracle.	`DECODE ( Expression1 , Expression2 , Expression3 , ... , Expression4 )`
PostgreSQL.	`CASE Expression1 WHEN Expression2 THEN Expression3 ... ELSE Expression4 END`
Sql Server.	`CASE Expression1 WHEN Expression2 THEN Expression3 ... ELSE Expression4 END`
Up ! Application System.	`Decoder( Expression1 , Expression2 , Expression3 , ... , Expression4 )`

Elimination des valeurs nulles

Système	Syntaxe
Db2.	`NULLIF ( Expression1 , Expression2 )`
Max DB.	`VALUE ( Expression1 , Expression2 )`
My Sql.	`COALESCE ( Expression1 , Expression2 )`
Odbc.	`{ fn IFNULL ( Expression1 , Expression2 ) }`
Oracle.	`NVL ( Expression1 , Expression2 )`
PostgreSQL.	`COALESCE ( Expression1 , Expression2 )`
Sql Server.	`COALESCE ( Expression1 , Expression2 )`
Up ! Application System.	`SiNul( Expression1 , Expression2)`

Divers

Aléatoire

Système	Syntaxe
Db2.	`TRUNC ( RAND(0) * 2147483647 )`
Max DB.	`MICROSECONDS ( CURRENT TIME )`
My Sql.	`TRUNC ( RAND(0) * 2147483647 )`
Odbc.	`{ fn TRUNCATE( { fn RAND(0) } * 2147483647 , 0) }`
Oracle.	`TO_NUMBER ( TO_CHAR( SYSDATE , 'FF6' ) )`
PostgreSQL.	`TRUNC ( RANDOM(0) * 2147483647 )`
Sql Server.	`TRUNC ( RAND(0) * 2147483647 )`
Up ! Application System.	`Aleatoire ()`

Appel de fonction

Système	Syntaxe
Db2.	`NomFonction ( ... )`
Max DB.	`NomFonction ( ... )`
My Sql.	`NomFonction ( ... )`
Odbc.	`{ fn NomFonction ( ... ) }`
Oracle.	`NomFonction ( ... )`
PostgreSQL.	`NomFonction ( ... )`
Sql Server.	`NomFonction ( ... )`
Up ! Application System.	`NomFonction ( ... )`

Nom de l'utilisateur

Système	Syntaxe
Db2.	`CURRENT USER`
Max DB.	`USERNAME`
My Sql.	`USER ()`
Odbc.	`{ fn USER () }`
Oracle.	`USER`
PostgreSQL.	`CURRENT_USER`
Sql Server.	`CURRENT_USER`
Up ! Application System.	`NomUtilisateur`

Nom du serveur

Système	Syntaxe
Db2.	`CURRENT SERVER`
Max DB.	`APPPLICATIONNODE`
My Sql.	`DATABASE ()`
Odbc.	`{ fn DATABASE () }`
Oracle.	`SYS_CONTEXT ( 'DB_NAME' )`
PostgreSQL.	`CURRENT_DATABASE ()`
Sql Server.	`DB_NAME ()`
Up ! Application System.	`NomNoeud`

Valeur nulle

Système	Syntaxe
Db2.	`NULL`
Max DB.	`NULL`
My Sql.	`NULL`
Odbc.	`NULL`
Oracle.	`NULL`
PostgreSQL.	`NULL`
Sql Server.	`-`
Up ! Application System.	`Nul`

Manipulation de données

Ajout d'un enregistrement

Système	Syntaxe
Db2.	`INSERT INTO NomTable ( ListeColonnes ) VALUES ( ListeExpressions );`
Max DB.	`INSERT INTO NomTable ( ListeColonnes ) VALUES ( ListeExpressions );`
My Sql.	`INSERT INTO NomTable ( ListeColonnes ) VALUES ( ListeExpressions );`
Odbc.	`INSERT INTO NomTable ( ListeColonnes ) VALUES ( ListeExpressions );`
Oracle.	`INSERT INTO NomTable ( ListeColonnes ) VALUES ( ListeExpressions );`
PostgreSQL.	`INSERT INTO NomTable ( ListeColonnes ) VALUES ( ListeExpressions );`
Sql Server.	`INSERT INTO NomTable ( ListeColonnes ) VALUES ( ListeExpressions );`
Up ! Application System.	`-`

Invalidation des transactions

Système	Syntaxe
Db2.	`ROLLBACK ;`
Max DB.	`ROLLBACK ;`
My Sql.	`ROLLBACK ;`
Odbc.	`ROLLBACK ;`
Oracle.	`ROLLBACK ;`
PostgreSQL.	`ROLLBACK ;`
Sql Server.	`ROLLBACK ;`
Up ! Application System.	`TachePrincipale . TransactionPrincipale . Invalider() ;`

Jointure externe

Système	Syntaxe
Db2.	`NomTable1 OUTER JOIN NomTable2 ON Expression1 = Expression2`
Max DB.	`FROM NomTable1 , NomTable2 WHERE Expression1 = Expression2 ( + )`
My Sql.	`NomTable1 LEFT JOIN NomTable2 ON Expression`
Odbc.	`{ oj NomTable1 OUTER JOIN NomTable2 ON Expression1 = Expression2 }`
Oracle.	`FROM NomTable1 , NomTable2 WHERE Expression1 = Expression2 ( + )`
PostgreSQL.	`NomTable1 LEFT JOIN NomTable2 ON Expression`
Sql Server.	`-`
Up ! Application System.	`-`

Mise à jour d'enregistrements

Système	Syntaxe
Db2.	`UPDATE NomTable SET Colonne = Expression , ... WHERE Expression ;`
Max DB.	`UPDATE NomTable SET Colonne = Expression , ... WHERE Expression ;`
My Sql.	`UPDATE NomTable SET Colonne = Expression , ... WHERE Expression ;`
Odbc.	`UPDATE NomTable SET Colonne = Expression , ... WHERE Expression ;`
Oracle.	`UPDATE NomTable SET Colonne = Expression , ... WHERE Expression ;`
PostgreSQL.	`UPDATE NomTable SET Colonne = Expression , ... WHERE Expression ;`
Sql Server.	`UPDATE NomTable SET Colonne = Expression , ... WHERE Expression ;`
Up ! Application System.	`-`

Sélection d'enregistrements

Système	Syntaxe
Db2.	`SELECT Expression, ... FROM NomTable, ... WHERE Colonne = Expression , ... Expression ORDER BY Expression, ... GROUP BY Expression, ... HAVING Expression ;`
Max DB.	`SELECT Expression, ... FROM NomTable, ... WHERE Colonne = Expression , ... Expression ORDER BY Expression, ... GROUP BY Expression, ... HAVING Expression ;`
My Sql.	`SELECT Expression, ... FROM NomTable, ... WHERE Colonne = Expression , ... Expression ORDER BY Expression, ... GROUP BY Expression, ... HAVING Expression ;`
Odbc.	`SELECT Expression, ... FROM NomTable, ... WHERE Colonne = Expression , ... Expression ORDER BY Expression, ... GROUP BY Expression, ... HAVING Expression ;`
Oracle.	`SELECT Expression, ... FROM NomTable, ... WHERE Colonne = Expression , ... Expression ORDER BY Expression, ... GROUP BY Expression, ... HAVING Expression ;`
PostgreSQL.	`SELECT Expression, ... FROM NomTable, ... WHERE Colonne = Expression , ... Expression ORDER BY Expression, ... GROUP BY Expression, ... HAVING Expression ;`
Sql Server.	`SELECT Expression, ... FROM NomTable, ... WHERE Colonne = Expression , ... Expression ORDER BY Expression, ... GROUP BY Expression, ... HAVING Expression ;`
Up ! Application System.	`-`

Suppression d'enregistrements

Système	Syntaxe
Db2.	`DELETE FROM NomTable WHERE Expression ;`
Max DB.	`DELETE FROM NomTable WHERE Expression ;`
My Sql.	`DELETE FROM NomTable WHERE Expression ;`
Odbc.	`DELETE FROM NomTable WHERE Expression ;`
Oracle.	`DELETE FROM NomTable WHERE Expression ;`
PostgreSQL.	`DELETE FROM NomTable WHERE Expression ;`
Sql Server.	`DELETE FROM NomTable WHERE Expression ;`
Up ! Application System.	`-`

Validation des transactions

Système	Syntaxe
Db2.	`COMMIT ;`
Max DB.	`COMMIT ;`
My Sql.	`COMMIT ;`
Odbc.	`COMMIT ;`
Oracle.	`COMMIT ;`
PostgreSQL.	`COMMIT ;`
Sql Server.	`COMMIT ;`
Up ! Application System.	`TachePrincipale . TransactionPrincipale . Valider() ;`

Instructions

Affectation

Système	Syntaxe
Db2.	`SET Variable = Expression ;`
Max DB.	`SET Variable = Expression ;`
My Sql.	`SET Variable = Expression ;`
Odbc.	`-`
Oracle.	`Variable : = Expression ;`
PostgreSQL.	`Variable : = Expression ;`
Sql Server.	`SET @Variable = Expression ;`
Up ! Application System.	`Variable = Expression ;`

Appel de procédure

Système	Syntaxe
Db2.	`CALL NomProcedure ( ... ) ;`
Max DB.	`CALL NomProcedure ( ... ) ;`
My Sql.	`CALL NomProcedure ( ... ) ;` Seuls les paramètres d'entrée ou d'entrée sortie doivent être transmis et cela au travers de variables de session.
Odbc.	`{ call NomProcedure ( ... ) }`
Oracle.	`CALL NomProcedure ( ... ) ;`
PostgreSQL.	`NomProcedure ( ... ) ;`
Sql Server.	`EXECUTE NomProcedure ( ... ) ; Ne pas mettre les parenthèses s'il n'y a pas de paramètre.`
Up ! Application System.	`NomProcedure ( ... ) ;`

Boucle

Système	Syntaxe
Db2.	`Etiquette : LOOPListeDInstructions END LOOPEtiquette : WHILE Expression DO ListeDInstructions END WHILE`
Max DB.	`WHILE Expression DOListeDInstructions END WHILE`
My Sql.	`Etiquette : LOOPListeDInstructions END LOOPEtiquette : WHILE Expression DO ListeDInstructions END WHILE`
Odbc.	`-`
Oracle.	`<< Etiquette >> LOOPListeDInstructions END LOOP ;<< Etiquette >> WHILE Expression DO ListeDInstructions END WHILE ;`
PostgreSQL.	`<< Etiquette >> LOOPListeDInstructions END LOOP ;<< Etiquette >> WHILE Expression DO ListeDInstructions END WHILE ;`
Sql Server.	`WHILE Expression BEGINListeDInstructions END`
Up ! Application System.	`TantQue Vrai Faire ListeDInstructions Fin TantQue`

Commentaires

Système	Syntaxe
Db2.	`-- Commentaire`
Max DB.	`// Commentaire`
My Sql.	`-- Commentaire`
Odbc.	`-`
Oracle.	`-- Commentaire`
PostgreSQL.	`-- Commentaire /* Commentaire */`
Sql Server.	`-- Commentaire /* Commentaire */`
Up ! Application System.	`// Commentaire /* Commentaire */`

Déclaration de variables

Système	Syntaxe
Db2.	`BEGIN DECLARE Variable1 Type1 ; DECLARE Variable2 Type2 ; ... ; END`
Max DB.	`DECLARE Variable1 Type1 ; Variable2 Type2 ; BEGIN ... ; END`
My Sql.	`BEGIN DECLARE Variable1 Type1 ; DECLARE Variable2 Type2 ; ... ; END`
Odbc.	`-`
Oracle.	`DECLARE Variable1 Type1 ; Variable2 Type2 ; BEGIN ... ; END`
PostgreSQL.	`DECLARE Variable1 Type1 Variable2 Type2 ; BEGIN ... ; END ;`
Sql Server.	`DECLARE @Variable1 AS Type1 , @Variable2 AS Type2 ; BEGIN ... ; END`
Up ! Application System.	`Variable Variable1 : Type1 ; Variable2 : Type2 ; Debut ... ; Fin`

Eclatement

Système	Syntaxe
Db2.	`CASE Expression1 WHEN Expression2 THENListeDInstructions1 ... ELSE ListeDInstructions2 END CASE`
Max DB.	`-`
My Sql.	`CASE Expression1 WHEN Expression2 THENListeDInstructions1 ... ELSE ListeDInstructions2 END CASE`
Odbc.	`-`
Oracle.	`CASE Expression1 WHEN Expression2 THENListeDInstructions1 ... ELSE ListeDInstructions2 END CASE ;`
PostgreSQL.	`-`
Sql Server.	`-`
Up ! Application System.	`Selon Expression1 Faire Cas Pour Expression2 Faire ListeDInstructions1 Fin Cas ... Defaut ListeDInstructions2 Fin Defaut Fin Selon`

Passer à l'itération suivante

Système	Syntaxe
Db2.	`ITERATE Etiquette ;`
Max DB.	`CONTINUE ;`
My Sql.	`ITERATE Etiquette ;`
Odbc.	`-`
Oracle.	`GOTO Etiquette ;`
PostgreSQL.	`CONTINUE ;`
Sql Server.	`CONTINUE ;`
Up ! Application System.	`Continuer ;`

Sortie de la boucle

Système	Syntaxe
Db2.	`LEAVE Etiquette ;`
Max DB.	`BREAK ;`
My Sql.	`LEAVE Etiquette ;`
Odbc.	`-`
Oracle.	`EXIT ;`
PostgreSQL.	`EXIT ;`
Sql Server.	`BREAK ;`
Up ! Application System.	`Arreter ;`

Sortie de la procédure ou de la fonction

Système	Syntaxe
Db2.	`RETURN ... ;`
Max DB.	`RETURN ... ;`
My Sql.	`RETURN ... ;`
Odbc.	`-`
Oracle.	`RETURN ... ;`
PostgreSQL.	`RETURN ... ;`
Sql Server.	`RETURN ... ;`
Up ! Application System.	`Retourner ... ;`

Test

Système	Syntaxe
Db2.	`IF Expression1 THEN ListeDInstructions1 ELIF Expression2 THEN ListeDInstructions2 ... ELSE ListeDInstructions3 END IF`
Max DB.	`IF Expression1 THEN ListeDInstructions1 ELSE ListeDInstructions3 END IF`
My Sql.	`IF Expression1 THEN ListeDInstructions1 ELIF Expression2 THEN ListeDInstructions2 ... ELSE ListeDInstructions3 END IF`
Odbc.	`-`
Oracle.	`IF Expression1 THEN ListeDInstructions1 ELSIF Expression2 THEN ListeDInstructions2 ... ELSE ListeDInstructions3 END IF ;`
PostgreSQL.	`IF Expression1 THEN ListeDInstructions1 ELSIF Expression2 THEN ListeDInstructions2 ... ELSE ListeDInstructions3 END IF ;`
Sql Server.	`IF Expression1 THEN ListeDInstructions1 ELSE ListeDInstructions3 END IF`
Up ! Application System.	`Si Expression1 Alors ListeDInstructions1 SinonSi Expression2 Alors ListeDInstructions2 ... Sinon ListeDInstructions3 Fin Si`

Valorisation d'une expression

Système	Syntaxe
Db2.	`VALUES ( ListeExpressions ) INTO ListeVariables ;`
Max DB.	`SELECT ListeExpressions INTO ListeVariables FROM public.dual ;`
My Sql.	`SELECT ListeExpressions INTO ListeVariables ;`
Odbc.	`SELECT ListeExpressions INTO ListeVariables FROM public.dual ;`
Oracle.	`SELECT ListeExpressions INTO ListeVariables FROM dual ;`
PostgreSQL.	`SELECT ListeExpressions INTO ListeVariables ;`
Sql Server.	`SELECT ListeExpressions INTO ListeVariables ;`
Up ! Application System.	`Variable = Expression ; ...`

Définition de données et de traitements

Autoriser une action

Système	Syntaxe
Db2.	`GRANT DELETE, INSERT, REFERENCES, SELECT, UPDATE, EXECUTE ON NomSchema . NomObjet TO NomUtilisateur ;`
Max DB.	`GRANT SELECT, EXECUTE ON NomSchema . NomObjet TO NomUtilisateur ;`
My Sql.	`GRANT DELETE, INSERT, REFERENCES, SELECT, UPDATE, EXECUTE ON NomObjet TO 'NomServeur' . 'NomUtilisateur' ;`
Odbc.	`-`
Oracle.	`GRANT DELETE, INSERT, REFERENCES, SELECT, UPDATE, EXECUTE ON NomSchema . NomObjet TO NomUtilisateur ;`
PostgreSQL.	`GRANT DELETE, INSERT, REFERENCES, SELECT, UPDATE, EXECUTE ON NomSchema . NomObjet TO NomUtilisateur ;`
Sql Server.	`GRANT DELETE, INSERT, REFERENCES, SELECT, UPDATE, EXECUTE ON OBJECT :: NomSchema . NomObjet TO NomUtilisateur ;`
Up ! Application System.	`-`

Création d'une fonction

Système	Syntaxe
Db2.	`CREATE FUNCTION NomSchema . MaFonction ( ModePassage NomParametre TypeParametre , ... ) RETURNS TypeResultat LANGUAGE SQL BEGIN ... END`
Max DB.	`CREATE FUNCTION NomSchema . MaFonction ( NomParametre TypeParametre , ... ) RETURNS TypeResultat AS BEGIN ... END ;`
My Sql.	`CREATE FUNCTION MaFonction ( ModePassage NomParametre TypeParametre , ... ) RETURNS TypeResultat LANGUAGE SQL BEGIN ... END`
Odbc.	`-`
Oracle.	`CREATE FUNCTION NomSchema . MaFonction ( NomParametre ModePassage TypeParametre , ... ) RETURNS TypeResultat LANGUAGE SQL IS BEGIN ... END ;`
PostgreSQL.	`CREATE FUNCTION NomSchema . MaFonction ( ModePassage NomParametre TypeParametre , ... ) RETURNS TypeResultat $$ BEGIN ... END $$`
Sql Server.	`CREATE FUNCTION NomSchema . MaFonction ( @NomParametre TypeParametre ModePassage , ... ) RETURNS TypeResultat AS BEGIN ... END`
Up ! Application System.	`-`

Création d'un index

Système	Syntaxe
Db2.	`CREATE UNIQUE INDEX NomIndex ON NomSchema . NomTable ( ListeColonnes ) ;`
Max DB.	`CREATE UNIQUE INDEX NomIndex ON NomSchema . NomTable ( ListeColonnes ) ;`
My Sql.	`CREATE UNIQUE INDEX NomIndex ON NomSchema . NomTable ( ListeColonnes ) ;`
Odbc.	`-`
Oracle.	`CREATE UNIQUE INDEX NomIndex ON NomSchema . NomTable ( ListeColonnes ) ;`
PostgreSQL.	`CREATE UNIQUE INDEX NomIndex ON NomSchema . NomTable ( ListeColonnes ) ;`
Sql Server.	`CREATE UNIQUE INDEX NomIndex ON NomSchema . NomTable ( ListeColonnes ) ;`
Up ! Application System.	`-`

Création d'une procédure

Système	Syntaxe
Db2.	`CREATE PROCEDURE NomSchema . MaProcedure ( ModePassage NomParametre TypeParametre , ... ) LANGUAGE SQL BEGIN ... END`
Max DB.	`CREATE PROCEDURE NomSchema . MaProcedure ( NomParametre TypeParametre , ... ) AS BEGIN ... END ;`
My Sql.	`CREATE PROCEDURE MaFonction ( MaProcedure NomParametre TypeParametre , ... ) LANGUAGE SQL BEGIN ... END`
Odbc.	`-`
Oracle.	`CREATE PROCEDURE NomSchema . MaProcedure ( NomParametre ModePassage TypeParametre , ... ) LANGUAGE SQL IS BEGIN ... END ;`
PostgreSQL.	`CREATE FUNCTION NomSchema . MaProcedure ( ModePassage NomParametre TypeParametre , ... ) $$ BEGIN ... END $$`
Sql Server.	`CREATE PROCEDURE NomSchema . MaProcedure @NomParametre TypeParametre ModePassage , ... AS BEGIN ... END`
Up ! Application System.	`-`

Création d'un schéma

Système	Syntaxe
Db2.	`CREATE SCHEMA NomSchema ... ;`
Max DB.	`CREATE SCHEMA NomSchema ... ;`
My Sql.	`-`
Odbc.	`-`
Oracle.	`CREATE SCHEMA AUTHORIZATION NomSchema ... ;`
PostgreSQL.	`CREATE SCHEMA NomSchema ... ;`
Sql Server.	`CREATE SCHEMA NomSchema ... ;`
Up ! Application System.	`-`

Création d'une table

Système	Syntaxe
Db2.	`CREATE TABLE NomSchema . NomTable ( NomColonne Type PRIMARY KEY NOT NULL , ... , CONSTRAINT NomConstrainte FOREIGN KEY ( ListeColonnes ) REFERENCES NomSchemaPere.NomTablePere ( ListeColonnesPeres ) ) ;`
Max DB.	`CREATE TABLE NomSchema . NomTable ( NomColonne Type PRIMARY KEY NOT NULL , ... , FOREIGN KEY NomConstrainte ( ListeColonnes ) REFERENCES NomSchemaPere.NomTablePere ( ListeColonnesPeres ) ) ;`
My Sql.	`CREATE TABLE NomTable ( NomColonne Type NOT NULL , ... , CONSTRAINT NomConstrainte PRIMARY KEY ( ListeColonnes ) , CONSTRAINT NomConstrainte FOREIGN KEY ( ListeColonnes ) REFERENCES NomSchemaPere.NomTablePere ( ListeColonnesPeres ) ) ENGINE = InnoDB ;`
Odbc.	`-`
Oracle.	`CREATE TABLE NomSchema . NomTable ( NomColonne Type PRIMARY KEY NOT NULL NomColonne FOREIGN KEY ( ListeColonnes ) REFERENCES NomSchemaPere.NomTablePere ( ListeColonnesPeres ), ... , ) ;`
PostgreSQL.	`CREATE TABLE NomSchema . NomTable ( NomColonne Type NOT NULL , ... , CONSTRAINT NomConstrainte PRIMARY KEY ( ListeColonnes ) , CONSTRAINT NomConstrainte FOREIGN KEY ( ListeColonnes ) REFERENCES NomSchemaPere.NomTablePere ( ListeColonnesPeres ) ) WITHOUT OIDS ;`
Sql Server.	`CREATE TABLE NomSchema . NomTable ( NomColonne Type NOT NULL , ... , CONSTRAINT NomConstrainte PRIMARY KEY ( ListeColonnes ) , CONSTRAINT NomConstrainte FOREIGN KEY ( ListeColonnes ) REFERENCES NomSchemaPere.NomTablePere ( ListeColonnesPeres ) ) ;`
Up ! Application System.	`-`

Création d'un synonyme

Système	Syntaxe
Db2.	`CREATE ALIAS NomSchema . NomSynonyme FOR NomSchema . NomObjet ;`
Max DB.	`CREATE SYNONYM NomSchema . NomSynonyme FOR NomSchema . NomObjet ;`
My Sql.	`-`
Odbc.	`-`
Oracle.	`CREATE SYNONYM NomSchema . NomSynonyme FOR NomSchema . NomObjet ;`
PostgreSQL.	`-`
Sql Server.	`CREATE SYNONYM NomSchema . NomSynonyme FOR NomSchema . NomObjet ;`
Up ! Application System.	`-`

Création d'un utilisateur

Système	Syntaxe
Db2.	Créé au niveau du système d'exploitation uniquement.
Max DB.	`CREATE USER NomUtilisateur PASSWORDB MotDePasse RESOURCE ;`
My Sql.	`GRANT USAGE ON . TO 'NomUtilisateur'@'NomServeur' IDENTIFIED BY 'MotDePasse' ;`
Odbc.	`-`
Oracle.	`GRANT CONNECT, RESOURCE TO NomUtilisateur IDENTIFIED BY MotDePasse ;`
PostgreSQL.	`-`
Sql Server.	`CREATE USER NomUtilisateur FOR LOGIN NomRole ;`
Up ! Application System.	`-`

Création d'une vue

Système	Syntaxe
Db2.	`CREATE VIEW NomSchema . NomVue ( ListeColonnes ) AS SELECT ... ;`
Max DB.	`CREATE VIEW NomSchema . NomVue ( ListeColonnes ) AS SELECT ... ;`
My Sql.	`CREATE VIEW NomVue ( ListeColonnes ) AS SELECT ... ;`
Odbc.	`-`
Oracle.	`CREATE VIEW NomSchema . NomVue ( ListeColonnes ) AS SELECT ... ;`
PostgreSQL.	`CREATE VIEW NomSchema . NomVue ( ListeColonnes ) AS SELECT ... ;`
Sql Server.	`CREATE VIEW NomSchema . NomVue ( ListeColonnes ) AS SELECT ... ;`
Up ! Application System.	`-`

Interdire une action

Système	Syntaxe
Db2.	`REVOKE DELETE, INSERT, REFERENCES, SELECT, UPDATE, EXECUTE ON NomSchema . NomObjet FROM NomUtilisateur ;`
Max DB.	`GRANT SELECT, EXECUTE ON NomSchema . NomObjet FROM NomUtilisateur ;`
My Sql.	`GRANT DELETE, INSERT, REFERENCES, SELECT, UPDATE, EXECUTE ON NomObjet FROM 'NomServeur' . 'NomUtilisateur' ;`
Odbc.	`-`
Oracle.	`GRANT DELETE, INSERT, REFERENCES, SELECT, UPDATE, EXECUTE ON NomSchema . NomObjet FROM NomUtilisateur ;`
PostgreSQL.	`GRANT DELETE, INSERT, REFERENCES, SELECT, UPDATE, EXECUTE ON NomSchema . NomObjet FROM NomUtilisateur ;`
Sql Server.	`GRANT DELETE, INSERT, REFERENCES, SELECT, UPDATE, EXECUTE ON OBJECT :: NomSchema . NomObjet FROM NomUtilisateur ;`
Up ! Application System.	`-`

Suppression d'une fonction

Système	Syntaxe
Db2.	`DROP FUNCTION NomSchema . NomFonction ;`
Max DB.	`DROP FUNCTION NomSchema . NomFonction ;`
My Sql.	`DROP FUNCTION NomFonction ;`
Odbc.	`-`
Oracle.	`DROP FUNCTION NomSchema . NomFonction ;`
PostgreSQL.	`DROP FUNCTION NomSchema . NomFonction ;`
Sql Server.	`DROP FUNCTION NomSchema . NomFonction ;`
Up ! Application System.	`-`

Suppression d'un index

Système	Syntaxe
Db2.	`DROP INDEX NomIndex ;`
Max DB.	`DROP INDEX NomIndex ;`
My Sql.	`DROP INDEX NomIndex ;`
Odbc.	`-`
Oracle.	`DROP INDEX NomIndex ;`
PostgreSQL.	`DROP INDEX NomIndex ;`
Sql Server.	`DROP INDEX NomIndex ;`
Up ! Application System.	`-`

Suppression d'une procédure

Système	Syntaxe
Db2.	`DROP FUNCTION NomSchema . NomFonction ;`
Max DB.	`DROP FUNCTION NomSchema . NomFonction ;`
My Sql.	`DROP FUNCTION NomFonction ;`
Odbc.	`-`
Oracle.	`DROP FUNCTION NomSchema . NomFonction ;`
PostgreSQL.	`DROP PROCEDURE NomSchema . NomFonction ;`
Sql Server.	`DROP FUNCTION NomSchema . NomFonction ;`
Up ! Application System.	`-`

Suppression d'un schéma

Système	Syntaxe
Db2.	`DROP SCHEMA NomSchema ;`
Max DB.	`DROP SCHEMA NomSchema ;`
My Sql.	`-`
Odbc.	`-`
Oracle.	`DROP SCHEMA NomSchema ;`
PostgreSQL.	`DROP SCHEMA NomSchema ;`
Sql Server.	`DROP SCHEMA NomSchema ;`
Up ! Application System.	`-`

Suppression d'une table

Système	Syntaxe
Db2.	`DROP TABLE NomSchema . NomTable ;`
Max DB.	`DROP TABLE NomSchema . NomTable ;`
My Sql.	`DROP TABLE NomTable ;`
Odbc.	`-`
Oracle.	`DROP TABLE NomSchema . NomTable ;`
PostgreSQL.	`DROP TABLE NomSchema . NomTable ;`
Sql Server.	`DROP TABLE NomSchema . NomTable ;`
Up ! Application System.	`-`

Suppression d'un utilisateur

Système	Syntaxe
Db2.	Supprimé au niveau du système d'exploitation uniquement.
Max DB.	`DROP USER NomUtilisateur ;`
My Sql.	`DROP USER 'NomUtilisateur'@'NomServeur' ;`
Odbc.	`-`
Oracle.	`DROP USER NomUtilisateur ;`
PostgreSQL.	`DROP USER NomUtilisateur ;`
Sql Server.	`DROP USER NomUtilisateur ;`
Up ! Application System.	`-`

Suppression d'une vue

Système	Syntaxe
Db2.	`DROP VIEW NomSchema . NomVue ;`
Max DB.	`DROP VIEW NomSchema . NomVue ;`
My Sql.	`DROP VIEW NomVue ;`
Odbc.	`-`
Oracle.	`DROP VIEW NomSchema . NomVue ;`
PostgreSQL.	`DROP VIEW NomSchema . NomVue ;`
Sql Server.	`DROP VIEW NomSchema . NomVue ;`
Up ! Application System.	`-`