NOTE TECHNIQUE ERP SQL PGI. Version 2.00 du 02/04/2019 Document Public

NOTE TECHNIQUE

ERP

SQL PGI

SOMMAIRE

1. I

... 2

2. E

SQL PGI ... 3

Scripts, batchs, instructions SQL ... 3

Eléments terminaux de base et ponctuation... 4

3. I

DML ... 5

Instruction SELECT ... 5

Common Table Expression - CTE ... 8

Instruction INSERT ... 10

Instruction UPDATE ... 10

Instruction DELETE ... 11

Instruction MERGE ... 11

4. I

DDL ... 14

Instructions de création d'objets ... 14

Instructions de suppression d'objets ... 19

Modification (activation/désactivation) des triggers ... 19

Instruction DDL : DdlStatement ... 19

5. F

... 23

Fonctions internes ... 23

Fonctions étendues ... 25

1. I NTRODUCTION

Le Langage SQL PGI est inspiré de SQL 92, de TSQL (SQL spécifique Microsoft) et ORACLE-SQL.

Les instructions SQL sont traduites dans le SQL natif du SGBD utilisé (SQL Server, ORACLE ou Sqlite) par les différents outils CBP : traduction à la volée pour le Framework CBP.net, traduction lors de la création/recréation dans la base par DbScriptGenerator.

L’analyse et la traduction du SQL PGI implique une syntaxe stricte qui interdit l’utilisation de fonctions spécifiques au moteur non prévues dans la grammaire du SQL PGI.

Pour la même raison, certaines requêtes qui étaient valides pour les versions précédentes de CBP (versions de CBP antérieures à la version 10) ne sont plus valides et doivent être corrigées.

Le présent document fournit des éléments de base du langage, quelques schémas de syntaxe et des liens vers la référence de la grammaire du SQL PGI sous forme BNF (Backus Naur Form).

Les éléments terminaux (mots clés du langage) sont notés en gras, les règles de syntaxe du langage (règles de production BNF) sont notées en italique.

Les éléments optionnels sont suffixés par la terminaison opt et/ou encadrés par des [ ].

Les règles BNF ont été simplifiées par rapport à la référence pour plus de lisibilité, en cas de doute, se référer au document html : SqlGrammar.html

2. E LEMENTS DE BASE DU SQL PGI Scripts, batchs, instructions SQL

Un programme SQL PGI est soit une instruction SQL simple soit un script SQL : SqlSyntax :

SimpleSqlStatement SqlScript;

Un script SQL est une liste de batch séparés par des GO :

SqlScript : SqlBatch

SqlScript GO SqlBatch

Un batch SQL est une liste d'instructions :

SqlBatch :

SqlInstruction

SqlBatch SqlInstruction

Une instruction SQL est un statement SQL terminé par ;

SqlInstruction :

SimpleSqlStatement ;

Une instruction SQL peut éventuellement débuter par un commentaire qui est conservé lors de la traduction en SQL spécifique et transmis au moteur de base de données

SimpleSqlStatement :

DelimitedComment^Opt SqlStatement

Le commentaire optionnel conservé lors de la traduction en SQL spécifique et transmis au moteur de base de données, ce qui permet par exemple de se repérer dans les traces ou de fournir des hint au moteur SQL (déconseillé aussi bien par Microsoft que ORACLE)

DelimitedComment^Opt : /* Chaine de texte */

Une instruction SQL est soit une instruction DML (Data Manipulation Language : SELECT UPDATE , DELETE ou INSERT), soit une instruction ou un bloc DDL (Data Definition Langage : création de table, index, procédure, trigger etc.) de création d’objet – cf. les chapitres dédiés au DML et DDL.

SqlStatement :

SqlDmlStatement SqlDdlStatement DdlStatementBlock;

Eléments terminaux de base et ponctuation

Les éléments terminaux sont des éléments mots clé du langage ou des éléments reconnus directement par l’analyseur SQL : chaine entre simple ou double quotes, nombre, identifiant (nom de table colonne ou autre objet SQL).

SqlIdentifier : Chaine [ Chaine ]

Un identifiant permet de d’identifier (nommer) une colonne, une table ou tout autre objet Sql.

Un identifiant peut éventuellement s’écrire entre crochets, il est dans ce cas possible d’utiliser des caractères spéciaux non autorisés habituellement pour un identifiant ($, ., espace etc.)

La syntaxe ANSI d’un identifiant (chaine entre doubles quotes) n’est pas supportée, seule la syntaxe spécifique Microsoft (chaine entre crochets [] ) est autorisée pour pouvoir utiliser des caractères spéciaux en tant que partie de l’identifiant.

Exemple :

SELECT 'Hello World' as [Hello World Column]

FROM DETABLES SqlStringLiteral:

"chaine"

‘Chaine’

Littéral de type chaine délimité par ' ou "

Il faut doubler les caractères « ou ‘ pour les inclure dans la sortie.

Punctuation :

( ) ;

, n’est pas un élément de ponctuation car utilisé comme mot clé dans les jointures (ancienne syntaxe de jointure équivalente au produit cartésien de deux tables ou CROSS-JOIN)

3. I NSTRUCTIONS DML

Les instructions DML (Data Manipulation Language) regroupent toutes les instructions SQL qui manipulent les données : SELECT, INSERT, UPDATE, DELETE et MERGE, par opposition aux instructions DDL (Data Definition Language) qui permettent de créer des objets dans la base : tables, vues, procédures, fonctions et triggers.

SqlDmlStatement :

QueryStatement DeleteStatement InsertStatement UpdateStatement MergeStatement

ProcedureCallStatement

Instruction SELECT

Le SelectStatement

L’instruction SELECT (ou QueryStatement dans la grammaire PGI) est l’instruction SQL qui permet de lire les données.

QueryStatement : WithStatement SelectStatement

/// Instruction retournant le résultat d'un requête éventuellement trié SelectStatement :

SelectStatementQuery OrderByClauseOpt

SelectStatement :

La clause ORDER BY peut être suivie d’une clause OFFSET xxx LIMIT yyy, qui permet de gérer de la pagination dans le resultset.

/// Requête qui récupère des lignes de la base de données et permet de sélectionner une ou plusieurs lignes ou colonnes d'une ou de plusieurs tables

Query

SELECT SelectHintOpt RestrictionOpt TopClauseOpt ColumnList FromClauseOpt WhereClauseOpt GroupByClauseOpt HavingClauseOpt

Query (

ORDER

UNION UNION ALL

)

EXCEPT

INTERSECT

OrderItem

,

ASC DESC

OFFSET OffsetExpression

LIMIT LimitExpression BY

Le HintComment est un commentaire utilisé par ORACLE pour spécifier un hint (conseil) de plan de requête.

Son usage est très spécifique et déconseillé.

Clause From

La clause FROM TableSource spécifie la source des données.

Cette clause est optionnelle comme en MsSQL (pour ORACLE, un FROM DUAL est ajouté par le traducteur CBP), et peut inclure une table, des jointures entre plusieurs tables, une sous requête, un LOOKUP (tablette PGI), et dans un trigger uniquement les tables virtuelles :NEW ou :OLD qui correspondent aux enregistrements ajoutés et supprimés par l’instruction qui a déclenché le trigger.

TableSource:

La clause TEMPORARY.TableName permet de spécifier une table temporaire PGI, créée à l’aide d’un CREATE TEMPORARY.TableName (… ). Cbp.net ouvre et ferme de nombreuses connexions, il n’y donc pas de connexion permanente au serveur et pas de table temporaire au sens Sql Server (supprimée à la fermeture de la connexion).

Ces tables doivent donc être supprimées en fin d’utilisation.

PGI_SHARED_DB(SourceName) permet de rediriger la source de données vers une autre base de données ou dossier PGI. SourceName est le nom d’une base de données ou dossier PGI.

PGI_LOOKUP(LookupName) n’est pas littéralement traduit en SQL mais supporté par le framework via le chargement du MCD (Modèle de données Conceptuel).

SELECT

Query :

HintComment */

/* ALL

DISTINCT

TOP

Variable Reference Constante

ColumnList

TableSource WHERE Condition GROUP BY ValueList HAVING Condition

FROM

/// Requête valide pour un select statement SelectStatementQuery :

QueryUnionExpression QueryExpression;

/// Sous select statement SubSelectStatement :

( SelectStatement ) /// Expression d'une requête QueryExpression :

Query

SubQueryExpression /// Sous requête

SubQueryExpression : ( QueryExpression ) /// Expression d'une union QueryUnionExpression :

QueryUnion

SubQueryUnionExpression /// Sous union

SubQueryUnionExpression : ( QueryUnionExpression ) /// Union entre deux requêtes QueryUnion :

QueryUnionLeft UnionOperator QueryUnionRight /// Expression valide à droite d'une union

QueryUnionRight :

QueryExpression

SubQueryUnionExpression /// Expression valide à gauche d'une union QueryUnionLeft :

QueryExpression QueryUnionExpression

/// Opérateurs d'union entre deux requêtes UnionOperator

UNION UNION ALL INTERSECT

EXCEPT // Oracle -> MINUS

La clause INTERSECT permet de réaliser l’intersection entre les résultats de deux requêtes, c’est-à-dire l’ensemble de lignes communes aux ensembles résultant de chacune des requêtes.

Clause Where

WhereClause:

La clause WHERE est facultative. Si elle n’est pas présence, toutes les lignes de la source (table, jointure etc.) seront affectée par l’instruction.

Comparison Operator

Référence du SelectStatement PGI : cf. document SqlGrammar.html

Common Table Expression - CTE

La CTE (Common Table Expression) ou WithStatement est une extension du QueryStatement, elle précède l’instruction SELECT et permet de définir une requête réutilisable dans le SELECT.

WHERE Predicate

=

<>

!=

<

<=

>

>=

/// Instruction définissant une requête utilisant des CTE (Common Table Expression) WithStatement :

WithClause SelectStatement /// Clause de définition des CTE WithClause :

WITH CommonTableExpressionList /// Liste des CTE

CommonTableExpressionList : CommonTableExpression

CommonTableExpressionList , CommonTableExpression /// Définition d'une CTE

CommonTableExpression :

TableName ColumnsDefinitionOpt AS ( SelectStatementQuery )

Exemples de CTE :

Les familles d’article PGI étant définies comme des « tablettes » enregistrées dans CHOIXCOD dont le type (CC_TYPE) est égal à FN1 pour la famille d’article 1 , FN2 pour la famille no 2 etc. , on peut définir et utiliser la CTE FamilleArticle comme suit :

-- Enregistrements de la famille d'article FNx WITH FamilleArticle ( Famille, Code, Libelle ) AS (

SELECT CC_TYPE, CC_CODE, CC_LIBELLE FROM CHOIXCOD

WHERE CC_TYPE LIKE 'FN[0-9]' )

-- LISTER LA FAMILLE 1 SELECT *

FROM FamilleArticle WHERE Famille = 'FN1' ;

-- Articles de la famille d'articles no 2

WITH FamilleArticle ( Famille, Code, Libelle ) AS (

SELECT CC_TYPE, CC_CODE, CC_LIBELLE FROM CHOIXCOD

WHERE CC_TYPE LIKE 'FN[0-9]' )

SELECT FamilleArticle.Famille, FamilleArticle.Code, FamilleArticle.Libelle, GA_ARTICLE, GA_LIBELLE, GA_LIBCOMPL, GA_DPA

FROM ARTICLE

, WithStatement:

WITH CTE SelectStatement

Name AS ( SelectStatement )

Query

( ColumnName )

,

INNER JOIN FamilleArticle

ON FamilleArticle.Famille = 'FN2' AND GA_FAMILLENIV2 = FamilleArticle.Code ORDER BY FamilleArticle.Code, ARTICLE.GA_LIBELLE ;

Instruction INSERT

L’instruction INSERT permet d’insérer des nouvelles données dans une table.

InsertStatement

INSERT IntoOpt TableReference ValuesSpecification /// Clauses valides pour la spécification des données à insérer ValuesSpecification

AffectedValues

SelectStatementValues DefaultValues

/// Clause déterminant d'une part les colonnes à modifier et d'autre part une requête retournant la liste des valeurs à affecter SelectStatementValues

( ColumnNames ) SelectStatement

/// Clause déterminant d'une part les colonnes à modifier et d'autre part la liste des valeurs à affecter AffectedValues

( ColumnNames )VALUES( ValueList )

/// Clause indiquant qu'il faut utiliser les valeurs par défaut spécifiées dans la base de données DefaultValues

DEFAULTVALUES Into

INTO

/// Liste de noms de colonnes séparés par des virgules ColumnNames

ObjectIdentifierList

Instruction UPDATE

/// Instruction de mise à jour de données UpdateStatement

UPDATE TableReference SET AssignList UpdateStatementFromClause WhereClauseOpt

UpdateStatement

/// Liste des mises à jour de colonnes AssignList { AssignStatement, , }

/// Instruction de mise à jour de colonne AssignStatement

ColumnName = Value

/// Alias technique d'une UpdateFromClause optionnelle UpdateStatementFromClause

UpdateFromClauseOpt

/// Détermine une source de données complémentaire qui, jointe à la table mise à jour via la condition (INNER), permettra de déterminer les lignes à modifier et/ou les valeurs à affecter

UpdateFromClause

FROM UpdateFromClauseSource ON Condition /// Sources valide dans un UPDATE FROM

UpdateFromClauseSource TriggerRelatedRows TableReferenceSource SelectStatementSource

Référence du UpdateStatement : cf. document SqlGrammar.html

Instruction DELETE

L’instruction DELETE permet de supprimer des données dans une table DeleteStatement

DELETE FromOpt TableReference WhereClauseOpt FromOpt

[ FROM ];

WhereClause : Voir description du Select

Instruction MERGE

L’instruction MERGE permet la mise à jour d'une table par fusion du résultat d'une requête. Elle permet d’effectuer un INSERT et/ou un UPDATE et/ou un DELETE selon des conditions spécifiées pour chacune de ces clauses.

MergeStatement

UPDATE TableName SET

, ColumnName

Identifier AS

Condition

SelectStatement FROM

= Expression

:NEW :OLD

( )

Identifier AS

Condition

TableName

WHERE

ON

MERGEINTO MergeStatementTarget

USING MergeStatementSource ON Condition MergeUpdateOpt MergeInsertOpt

/// Cible d'un merge (table) MergeStatementTarget

TableReferenceSource

/// Source de données provenant d'une table TableReferenceSource

TableReference AsClauseOpt

/// Sources d'enregistrement relatives au triggers TriggerRelatedRows

/// Enregistrements insérés ou mis à jour ayant déclenché le trigger :NEW

/// Enregistrements supprimés ou mis à jour ayant déclenché le trigger :OLD

/// Source d'un merge MergeStatementSource

TableReferenceSource SelectStatementSource LookupSource

TriggerRelatedRows MergeInsertOpt

[ MergeInsert ]

/// Instruction de fusion des éléments manquants dans la cible, la source du {MergeStatement} peut être utilisée pour définir une condition de fusion

MergeInsert

INSERT MergeInsertValueSpecification MergeConditionOpt

/// Clauses valides pour la spécification des données à insérer dans un merge

/// la source du {MergeStatement} peut être utilisée pour alimenter les valeurs à insérer MergeInsertValueSpecification

AffectedValues DefaultValues MergeUpdateOpt

[ MergeUpdate ]

/// Instruction de fusion des éléments assortis par mise à jour,

/// la source et la cible du {MergeStatement} peuvent être utilisées pour définir une condition de fusion MergeUpdate

UPDATESET AssignList MergeConditionOpt MergeDeleteOpt MergeDeleteOpt

[ MergeDelete ]

/// Instruction de fusion des éléments assortis par suppression,

/// la source et la cible du {MergeStatement} peuvent être utilisées pour définir une condition de fusion MergeDelete

DELETE MergeConditionOpt

MergeConditionOpt

[ MergeCondition ]

/// Limitation d'une instruction de fusion MergeCondition

WHEN Condition

Référence du MergeStatement :cf. document SqlGrammar.html

4. I NSTRUCTIONS DDL

Le terme DDL (Data Definition Language) désigne l’ensemble des instructions de définition (création modification, suppression) d’objets SQL : tables, index, vues, procédures, triggers et fonctions SQL.

SqlDdlStatement

CreateStatement AlterStatement DropStatement ToggleTrigger

RenameTableStatement

Instructions de création d'objets

CreateStatement CreateTable CreateView CreateIndex CreateTrigger CreateProcedure CreateFunction

Instruction de création de table : CREATE TABLE

CreateTable

CREATETABLE TableReference ( TableElementList ) /// Eléments, colonnes et contraintes, définissant une table TableElementList

{ TableElement , }

/// Elément, colonne ou contrainte, de définition d'une table TableElement

ColumnDefinition TableConstraint /// Définition d'une colonne

ColumnDefinition

ColumnName SqlType ColumnDefaultOpt NullConstraintOpt /// Valeur par défaut d'une colonne

ColumnDefault

DEFAULT Value NullConstraint

NULL NOTNULL /// Contrainte de table TableConstraint

CONSTRAINT ConstraintName ConstraintDefinition

/// Définition de contrainte ConstraintDefinition

ColumnsConstraint ForeignKeyConstraint /// Contrainte de clé étrangère ForeignKeyConstraint

FOREIGNKEY ( ForeignKeyConstraintColumns )

REFERENCES TableReference ( ForeignKeyConstraintKeys ) /// Noms des colonnes de la table définissant la clé étrangère

ForeignKeyConstraintColumns ColumnIdentifierList

/// Noms des colonnes de la table référencée définissant la clé étrangère ForeignKeyConstraintKeys

ColumnIdentifierList /// Contrainte de colonne ColumnsConstraint

ColumnsConstraintType ( ColumnIdentifierList ) /// Type de contrainte : clé primaire ou valeur unique ColumnsConstraintType

PRIMARY KEY UNIQUE

Référence du CreateTable PGI : cf. document SqlGrammar.html

Instruction de création de vue

CreateView

CREATEVIEW ViewName ColumnsDefinitionOpt AS SelectStatement /// Définition des colonnes de la vue

ColumnsDefinition

( ColumnNames )

Instruction de création d'index

CreateIndex

CREATE UniqueOpt ClusteredOpt INDEX IndexName ON TableName ( OrderList ) /// Indique qu'un index doit être unique (optimisation pour certains moteurs)

Unique

UNIQUE

/// Indique qu'un index doit être clustered (spécifique Microsoft SQL Server) Clustered

CLUSTERED

Référence du CREATE INDEX PGI : cf. document SqlGrammar.html

Types SQL

/// Définition d'un type de donnée SqlType

SqlTypeName PrecisionScale^Opt SqlTypeName

BIT DATETIME DATE TIMESTAMP

// Note : (Entity Framework support)

// TIME et DATETIMEOFFSET ne sont pas supportés pleinement par Oracle et SQLite, // et ne sont donc pas implémentés

DECIMAL DEC REAL FLOAT SMALLINT INT VARCHAR NVARCHAR CHAR NCHAR BIGINT TINYINT // types PGI INTEGER // INT NUMERIC // DECIMAL RATE // NUMERIC COMBO // CHAR(3) BOOLEAN // CHAR(1) DOUBLE // DECIMAL EXTENDED // DECIMAL BLOB // NVARCHAR / TEXT DATA // BLOB / BINARY

LONGCHAR // Obsolete VARCHAR(2000) GUID // UNIQUEIDENTIFIER, RAW(16) /// Définition de précision (ou longueur) et/ou échelle PrecisionScale

SqlTypePrecision

SqlTypePrecisionAndScale

/// Définition de précision (ou longueur) SqlTypePrecision ( Precision )

/// Définition de précision (ou longueur) et d'échelle SqlTypePrecisionAndScale

( Precision , Scale ) /// Précision ou longueur Precision

SqlIntegerLiteral;

/// Echelle Scale

SqlIntegerLiteral;

Création de Triggers

Les triggers permettent d’exécuter du code SQL après une instruction DML de mise à jour (INSERT, UPDATE ou DELETE) sur une table.

Dans le code du trigger, des pseudo tables virtuelles :NEW et :OLD sont accessibles au code du trigger pour manipuler les enregistrements ajoutés, supprimés ou mis à jour.

Il n’est pas nécessaire d‘ajouter une instruction DROP TRIGGER avant l’instruction CREATE, car la traduction du CREATE inclut un test d’existence et de DROP du trigger s’il existe déjà.

Les triggers PGI sont des triggers déclenchés après l’instruction (trigger AFTER) CreateTrigger

Grammaire :

/// Instruction de création de trigger CreateTrigger

CREATETRIGGER TriggerName FOR TriggerEvents ON TableName AS CreateTriggerBody

/// Liste des types d'évènement déclenchant le trigger séparés par 'OR' TriggerEvents { TriggerEvent, OR }

/// Types d'évènements déclenchant le trigger TriggerEvent

INSERT UPDATE DELETE /// Corps du trigger

CreateTriggerBody DdlStatement

Référence du CREATE TRIGGER :cf. document SqlGrammar.html

Création de procédures

/// Instruction de création d'une procédure CreateProcedure

CREATEPROCEDURE ProcedureName ( Arguments )AS CreateProcedureBody Create Procedure

INSERT UPDATE DELETE CREATE TRIGGER TriggerName FOR

OR

ON TableName AS DDlStatemement

Argument

/// Liste des arguments d'une procédure ou fonction Arguments ( Argument, , )

/// Argument d'une procédure ou fonction Argument

ArgumentName ArgumentDirectionOpt SqlType /// Corps de la procédure

CreateProcedureBody DdlStatement

/// Direction de l'argument (IN si en entrée, OUT si en sortie) ArgumentDirectionOpt

IN OUT IN OUT

Référence du CREATE PROCEDURE :cf. document SqlGrammar.html

Création de fonctions

Une fonction SQL définie par l’utilisateur peut être utilisée dans toute expression SQL. Son utilisation dans les expressions de jointures ou dans les prédicats de recherche (clause WHERE) peut cependant entrainer une dégradation des performances en invalidant l’utilisation d’index existants.

/// Instruction de création de fonction utilisateur CreateFunction

CREATEFUNCTION FunctionName ( Arguments ) RETURNS SqlType AS DdlStatement

Create Function

Argument

CREATE ProcedureName (

,

)

Argument

DDlStatemement PROCEDURE AS

ArgumentName

IN

OUT

Type

CREATE FunctionName (

,

)

Argument

DDlStatemement AS

FUNCTION RETURNS ReturnType

ArgumentName Type

Instructions de suppression d'objets

DropStatement

DROPTABLE TableReference

DROPINDEX IndexName ON TableReference DROPVIEW ViewName

DROPTRIGGER TriggerName DROPPROCEDURE ProcedureName DROPFUNCTION FunctionName

Modification (activation/désactivation) des triggers

ToggleTrigger

ToggleTriggerAction TriggerSpecification ON TableReference;

/// Activation ou désactivation de trigger ToggleTriggerAction

ENABLE DISABLE

/// Spécification du trigger à modifier TriggerSpecification

SingleTriggerSpecification AllTriggersSpecification;

/// Spécification du trigger à modifier SingleTriggerSpecification

TRIGGER TriggerName

/// Spécification de l'altération de tous les triggers AllTriggersSpecification

ALLTRIGGERS

Instruction DDL : DdlStatement

Une instruction DDL est une instruction pouvant se trouver dans un TRIGGER, une procédure ou une fonction SQL et peut être instruction de manipulation de données (INSERT, UPDATE, DELETE, MERGE) qui ne renvoie pas de jeu de données, une instruction de contrôle de flot (WHILE, IF, FOREACH, RETURN, EXECUTE, THROW), une affectation (SELECT INTO ou affectation).

/// Instructions DDL pouvant composer un bloc DDL DdlStatement

DdlStatementBlock InsertStatement UpdateStatement DeleteStatement MergeStatement

SelectIntoVariableStatement AffectationStatement ReturnStatement IfThenStatement IfThenElseStatement

ProcedureCallStatement WhileStatement

ForeachStatement ThrowStatement

Référence du DdlStatement :cf. document SqlGrammar.html /// Définition d'un bloc DDL

DdlStatementBlock

DeclarationBlockOpt BEGIN DdlStatementBlockBody END /// Corps du bloc DDL : liste de DdlStatement séparés par des ‘;’ DdlStatementBlockBody

DdlStatementList InstructionEndOpt /// Liste d'instruction DDL

DdlStatementList

{ DdlStatement, ; } /// Fin d'instruction DDL InstructionEnd;

Déclaration de variables

Un DDL Statement Block peut commencer par une ou plusieurs déclarations de variables (DeclarationBlockOpt)

Declaration Block

DeclarationBlockOpt

[ DeclarationBlock ]

/// Déclaration des variables d'un bloc DDL DeclarationBlock

DECLARE VariableDeclarationList InstructionEndOpt /// Liste de variables séparées par des ',' VariableDeclarationList

{ VariableDeclaration, , } /// Déclaration de variable VariableDeclaration

VariableName SqlType

Instructions de contrôle de flot

Les instructions de contrôle de flot permettent de controler le déroulement du programme par le biais d’instructions itératives (WHILE, FOREACH), ou de branchements (IF, IF ELSE, RETURN, EXECUTE).

IfThenStatement

DECLARE VariableName

,

; SqlType

IF Condition THEN ThenBody END IfThenElseStatement

IF Condition THEN ThenBody ELSE ElseBody END ThenBody

DdlStatementBlockBody ElseBody

DdlStatementBlockBody WhileStatement

WHILE Condition DO WhileStatementBody END WhileStatementBody

DdlStatementBlockBody

L’instruction FOREACH permet de traiter séquentiellement un jeu de résultat via un SelectIntoVariableStatement

ForeachStatement

FOREACH SelectIntoVariableStatement DO ForeachStatementBody END /// Instructions à exécuter pour chaque élément du jeu de résultat

ForeachStatementBody

DdlStatementBlockBody /// Appel de procédure

ProcedureCallStatement

EXECUTE ProcedureName Parameters /// Instruction de retour

ReturnStatement

RETURN ValueOpt ThrowStatement

THROW( ErrorCode , ErrorMessage ) Annule le traitement en cours et lève une erreur Cette instruction est supportée à partir de CBP 11 /// Code d'erreur

ErrorCode

SqlStringLiteral

Voir SqlStringLiteral : ‘Chaine‘ ou «Chaine»

Les chaines peuvent être délimitées par des simples ou doubles quotes (syntaxe PGI historique, dans la norme ANSI les doubles quotes sont utilisées pour délimiter des alias de colonnes).

/// Message d'erreur ErrorMessage

SqlStringLiteral

Les conditions utilisables dans une instruction de contrôle de flot sont élargies dans le cadre d’un trigger : il est possible de tester l’événement qui a déclenché le trigger (INSERT, UPDATE ou DELETE) en utilisant les mots clés INSERTING, UPDATING, DELETING ou la modification d’une ou plusieurs colonnes via la syntaxe UPDATING ( ColumnName) .

Référence de la Condition :cf. document SqlGrammar.html

/// Tests sur les conditions de déclenchement d'un trigger TriggerUpdateCondition

TriggerTableUpdateCondition TriggerColumnUpdateCondition

/// Condition testant l'évènement de déclenchement du trigger TriggerTableUpdateCondition

UPDATING INSERTING DELETING

/// Condition testant la mise à jour d'une colonne TriggerColumnUpdateCondition

UPDATING ( ColumnName )

Affectations de variables

L’affectation de variables peut se faire en utilisant l’instruction SELECT INTO ou via l’instruction d’affectation (Variable = Valeur)

L’instruction SELECT INTO est identique à l’instruction SELECT, mais une clause INTO Variable1, Variable2, Variable3 … VariableN précède la clause FROM

/// Instruction permettant d'affecter une ligne de résultat de requête à des variables SelectIntoVariableStatement

SELECT SelectHintOpt RestrictionOpt TopClauseOpt IntoVariableClause

FromClauseOpt

WhereClauseOpt GroupByClauseOpt HavingClauseOpt OrderByClauseOpt

/// Clause déterminant l'association des affectations colonne / variable. Le nombre de colonnes doit impérativement être équivalent au nombre de variables

IntoVariableClause

ColumnList INTO VariableNameList /// Instruction d'affectation

AffectationStatement

VariableName = Value

5. F ONCTIONS INTERNES ET ÉTENDUES

Les fonctions internes et étendues peuvent être utilisées dans toutes les expressions SQL : liste de colonnes, prédicats dans la clause WHERE, jointures etc. Leur utilisation peut cependant invalider l’utilisation d’index et entrainer une dégradation des performances.

Fonctions internes

Appel de fonction intégrée native sur tous les moteurs (éventuellement avec un nom différent).

Les fonctions étendues (dont la traduction n’existe pas pour tous les moteurs) sont indiquées plus loin.

BuiltInFunctionCall

BuiltInFunction ( Parameters )

/// Nom de la fonction intégrée native. Pour plus d'informations se référer aux documentations des différents moteurs supportés.

BuiltInFunction Function Name

Fonctions chaines

// Character ASCII (Expr )

Renvoie le code ASCII du caractère le plus à gauche de l’expression chaine passée en paramètre.

CHR( IntegerExpression )

Renvoie le caractère dont le code ascii correspond à l’expression entière passée en paramètre.

CHARINDEX( Expr1 , Expr2 [ , Start ] )

Renvoie la position de Expr1 dans Expr2, éventuellement à partir de la position Start si elle est spécifiée.

INSTR ( Expr1 , Expr2 [ , Start ] )

Identique à CHARINDEX, pour compatibilité avec du SQL écrit pour ORACLE LEN ( Expression )

Renvoie la longueur en caractères de l’expression chaine passée en paramètre LENGTH ( Expression )

Identique à LEN LOWER ( Expression )

Renvoie l’expression passée en paramètre transformée en minuscule.

LTRIM ( Expression )

Supprime les espaces à gauche de l’expression passée en paramètre.

REPLACE ( Expression, Pattern, Replacement )

Remplace l’expression Pattern dans Expression par la chaine Replacement. REVERSE ( Expression )

SQL PGI

Renvoie l’expression chaine passée en paramètre en ordre inverse.

RTRIM ( Expression )

Supprime les espaces à droite de l’expression passée en paramètre.

SOUNDEX ( Expression )

Renvoie un code sur 4 caractères correspondant à l’expression passée en paramètre.

Ce code peut être utilisé pour évaluer la similarité phonétique de plusieurs expressions.

STR ( Expression )

Convertit l’expression passée en paramètre en chaine( CONVERT(VARCHAR…) pour SQL Server, TO_CHAR pour ORACLE).

SUBSTR ( Expression, Start, Length )

Renvoie la sous-chaine extraite de Expression , à partir de la position Start pour une longueur de Length.

SUBSTRING ( Expression, Start, Length ) Equivalent à SUBSTR

TO_CHAR ( Expression ) Equivalent à STR() TRIM ( Expression )

Supprime les espaces à droite et à gauche de Expression.

UPPER ( Expression )

Renvoie l’expression passée en paramètre transformée en majuscules.

Fonctions mathématiques

// Math ABS ROUND SIGN SQRT POWER CEILING EXP LN LOG FLOOR TRUNCATE // Trigo

ACOS ASIN ATAN COS COT DEGREES

PI RADIANS SIN TAN // Misc

NEWID SYS_GUID

NEWSEQUENTIALID /// Fonctions de création de type

TypeFunctionCall ::= TypeFunction "(" Parameters ")";

/// Nom de la fonction de création de type

TypeFunction ::= "BIT" | "DATE" | "DATETIME" | "TIME" | "TIMESTAMP" | "DECIMAL" |

"NUMERIC" | "DEC" | "REAL" | "FLOAT" | "SMALLINT" | "INT" | "INTEGER" | "INTERVAL" | "VARCHAR" |

"NVARCHAR" | "CHAR" | "NCHAR" | "CHARACTER";

Fonctions étendues

Fonctions étendues par le langage SQL Pgi. Ces fonctions ne sont pas natives à tous les moteurs de base de données (pour la plupart la traduction de ces fonctions est disponible pour SQL Server et ORACLE, mais pas Sqlite).

ExtendedFunctionCall

ExtendedDateTimeFunctionCall ExtendedCharacterFunctionCall ExtendedMathFunctionCal

ExtendedMiscellaneousFunctionCall

Fonctions étendues diverses

ExtendedMiscellaneousFunctionCall PgiGuidFunctionCall HostNameFunctionCall UserNameFunctionCall RowOrderFunctionCall

/// Calcule un guid et le retourne sous forme de chaine - varchar(36) - contenant le guid, /// ex: '{12345678-1234-1234-1234-123456789012}'

PgiGuidFunctionCall PGIGUID()

/// Retourne le nom du serveur SQL HostNameFunctionCall

HOSTNAME()

/// Retourne le nom de l'utilisateur SQL UserNameFunctionCall

USERNAME ( )

/// Retourne le numéro de l'enregistrement d'une requête triée.

/// Cette fonctionnalité n'est compatible qu’avec les requêtes spécifiant un ORDER BY.

RowOrderFunctionCall

ROWORDER ( )

Fonctions étendues de manipulation de chaines

ExtendedCharacterFunctionCall TrimFunctionCall PaddingFunctionCall StuffFunctionCall TruncateFunctionCall ReplicateFunctionCall SpaceFunctionCall PatIndexFunctionCall

/// Appel de fonction supprimant les espaces en début et fin de chaine TrimFunctionCall

TRIM( Parameter )

/// Appel de fonction permettant de fixer la longueur d'une chaine soit en la tronquant soit en complétant avec une chaine de remplissage

PaddingFunctionCall

PaddingFunction ( Parameter , PaddingFunctionCallLength , PaddingFunctionCallFiller ) /// Chaine de remplissage

PaddingFunctionCallFiller SqlStringLiteral /// Longueur désirée

PaddingFunctionCallLength Value

/// Fonction de remplissage déterminant le côté d'attaque PaddingFunction

PADLEFT PADRIGHT

/// Appel de fonction permettant le remplacement d'une partie d'une chaine par une autre StuffFunctionCall

STUFF( Parameter , Start , Length , Replacement ) /// Index base 1 de début du remplacement

Start Value

/// Nombre de caractères à remplacer Length

Value

/// Chaine de remplacement Replacement

Value

/// Appel de fonction tronquant une chaine à la longueur maximum désirée TruncateFunctionCall

TruncateFunction ( Parameter , Length );

/// Fonction de tronquage à utiliser TruncateFunction

LEFT RIGHT

/// Appel de fonction permettant de construire une chaine par réplication d'un fragment ReplicateFunctionCall

REPLICATE( Parameter , Count )

/// Appel de fonction produisant une chaine composée d'espaces répétés SpaceFunctionCall

SPACE ( Count )

/// Retourne l'index base 1 de première apparition d'un pattern dans une chaine PatIndexFunctionCall

PATINDEX ( Pattern , Parameter )

Le Parttern est identique au pattern d'un LIKE, à ceci près qu’il DOIT ABSOLUMENT commencer et terminer par

'%'

Fonctions de gestion des dates

/// Fonction de manipulation de date étendues ExtendedDateTimeFunctionCall

DatePartFunctionCall DateDiffFunctionCall DateAddFunctionCall CurrentDateFunctionCall TruncDateFunctionCall IsDateFunctionCall ToDateFunctionCall

/// Appel de fonction d'extraction d'une partie de la date DatePartFunctionCall

DatePartFunction ( Parameter ) /// Fonctions d'extraction de la date

DatePartFunction YEAR QUARTER MONTH

DAY

HOUR MINUTE SECOND MILLISECOND WEEK YDAY WDAY

/// Différence entre deux dates. Retourne un décimal exprimant la durée séparant les 2 dates, dans l'unité de temps définie par la fonction utilisée.

DateDiffFunctionCall

DateDiffFunction (StartDate , EndDate )

/// Fonctions de calcul de différence définissant l'unité d'expression de l'écart entre les dates DateDiffFunction

DIFFYEARS DIFFMONTHS DIFFDAYS DIFFHOURS DIFFMINUTES DIFFSECONDS DIFFMILLISECONDS DIFFMICROSECONDS DIFFNANOSECONDS

/// Appel de fonction d'ajout de durée à une date DateAddFunctionCall

DateAddFunction ( Parameter , Value )

/// Fonction d'ajout de durée déterminant l'unité de la durée ajoutée DateAddFunction

ADDYEARS ADDMONTHS ADDDAYS ADDHOURS ADDMINUTES ADDSECONDS ADDMILLISECONDS ADDMICROSECONDS ADDNANOSECONDS

/// Appel de fonction déterminant la date courante CurrentDateFunctionCall

CurrentDateFunction ( )

/// Variantes équivalentes du nom de fonction CurrentDateFunction

GETDATE CURRENT_DATE NOW

/// Appel de fonction effectuant la mise à zéro des fractions de jour TruncDateFunctionCall

TRUNC ( DateParameter )

/// Appel de fonction déterminant si l'argument est une date bien formatée (format ISO8160) IsDateFunctionCall

ISDATE( DateParameter )

/// Appel de fonction convertissant une chaine de caractère bien formatée en date (format ISO8160) ToDateFunctionCall

TODATE( StringParameter )

Fonctions mathématiques étendues

ExtendedMathFunctionCall RandFunctionCall SquareFunctionCall IsNumericFunctionCall ToNumericFunctionCall

/// Appel de fonction retournant un décimal aléatoire compris entre 0 et 1 RandFunctionCall

RAND ( )

/// Appel de fonction retournant le carré d'un nombre SquareFunctionCall

SQUARE( Parameter )

/// Appel de fonction déterminant si la chaine de caractère passée en paramètre représente un nombre valide

IsNumericFunctionCall

ISNUMERIC( Parameter )

/// Appel de fonction convertissant la chaine de caractère passée en paramètre en nombre valide ToNumericFunctionCall

TONUMERIC( Parameter )

Fonction de fenêtrage

/// les fonctions de fenêtrage ne peuvent être utilisées que dans les clauses SELECT /// OrderByClause est optionnelle dans le cas des agrégations

WindowFunctionClause

WindowFunctionClauseFunction

OVER ( PartitionByClauseOpt OrderByClauseOpt ) /// Fonctions compatibles avec le fenêtrage

WindowFunctionClauseFunction Aggregation

WindowFunctionCall /// Appel de fonction de fenêtrage

WindowFunctionCall WindowFunction ( ) /// Fonctions de fenêtrage

WindowFunction ROW_NUMBER RANK

// Limité actuellement à ces 2 fonctions, bien qu’il y en ait d'autres (NTILE, DENSE_RANK) car elles ne sont pas forcément les mêmes sur tous les moteurs

PartitionByClauseOpt [ PartitionByClause ]

/// Clause de partitionnement d'une fonction de fenêtrage PartitionByClause

PARTITION BY PartitionList

/// Liste des colonnes de partitionnement d'une fonction de fenêtrage PartitionList

ValueList

/// Liste de paramètres Parameters ( Parameter , … ); /// Paramètre

Parameter

Value

/// Liste de valeurs séparées par des "," ValueList { Value , }

/// Liste d'identifiants de colonne séparés par des "," ColumnIdentifierList { ColumnIdentifier , }

/// Identifiant de colonne ColumnIdentifier TableColumn ColumnSelector TriggerRelatedColumn

/// Référence à une colonne d'enregistrement déclenchant un trigger TriggerRelatedColumn

TriggerRelatedRows . ColumnSelector;

/// Colonne d'une table ou d'une projection TableColumn

TableName . ColumnSelector /// Sélecteurs de colonne

ColumnSelector AllColumns ColumnName

/// Sélectionne toutes les colonnes disponibles AllColumns

*

/// Identifiant de table ou de projection intermédiaire TableName

ObjectIdentifier /// Identifiant de colonne

ColumnName

ObjectIdentifier

/// Liste d'identifiants ObjectIdentifierList { ObjectIdentifier , }

/// Identifiant d'objet ObjectIdentifier SqlIdentifier