Eclats de vers : Ordina 07 : Langages de script

perldoc mot-clé	Documentation
print	Affiche
;	Séparateur d'instructions

$/variable/	Variable
$/variable/ = `/commande/`	Substitution du résultat d'une commande externe
$/variable/ = qx//commande//
$_	Variable par défaut

$/variable/ = '/chaîne/'

$/variable/ = q//chaîne//

$/variable/ = q(/chaîne/)

$/variable/ = "/chaîne/"

$/variable/ = qq//chaîne//

$/variable/ = qq(/chaîne/)

'/chaîne_1/' . '/chaîne_2/'

$/variable_1/ . $/variable_2/

"$/variable_1/$/variable_2/"

"/chaîne/" x /Nombre/

$/variable/ = <>	Lecture d'une variable à l'entrée standard ou au(x) fichier(s) passé(s) en argument(s)
</globbing/>	Liste de fichiers correspondant à un globbing
rename	Renomme un fichier
unlink	Supprime un fichier

@/liste/ = ( /élément_1/, /élément_2/, /.../, /élément_N/ )

@/liste/ = ( '/chaîne_1/', '/chaîne_2/', /.../, '/chaîne_N/' )

@/liste/ = qw//mot_1/ /mot_2/ /.../ /mot_N//

@/liste/ = (/M/../N/)

@/listeRépétée/ = ( /.../, /.../, /.../ ) x /N/

@/liste/	Liste
$/liste/[/indice/]	Élément d'une liste
@/liste/[/M/,/N/]	Tranche
$#/liste/	Nombre d'éléments d'une liste
@_	Liste par défaut
@ARGV	Liste des arguments passés au script
$ARGV[/N/]	/N/<sup>ième</sup> argument
push @/liste/, élément	Ajoute un élément à la fin de la liste
$/variable/ = pop @/liste/	Supprime un élément à la fin de la liste et le renvoie
unshift @/liste/, élément	Ajoute un élément au début de la liste
$/variable/ = shift @/liste/	Supprime un élément au début de la liste et le renvoie

Remarque : push, pop, shift et unshift utilisent par défaut la liste @ARGV dans la partie principale du script et @_ dans les fonctions.

$/variable/ = join('/caractère/', @/liste/)

$/liste/ = join(//motif//, @/variable/)

%/dictionnaire/ = ( /clé_1/ => /valeur_1/, /.../, /clé_N/ => /valeur_N/ )

%/dictionnaire/ = ( /clé_1/, /valeur_1/, /.../, /clé_N/, /valeur_N/ )

%/dictionnaire/	Dictionnaire
$/dictionnaire/{clé}	Élément d'un dictionnaire
keys %/dictionnaire/	Liste des clés
values %/dictionnaire/	Liste des valeurs
reverse %/dictionnaire/	Inverse clé et valeurs

A == B	Vrai si les deux nombres sont égaux
A != B	Vrai si les deux nombres sont différents
< > <= >=	Comparaison de nombres
A eq B	Vrai si les deux chaînes sont identiques
A ne B	Vrai si les deux chaînes sont différentes
lt gt le ge	Comparaison de chaînes
&&	Et
			Ou
!	Non
sort	Trie une liste

La syntaxe A <=> B renvoie :

• 1 si A > B
• 0 si A = B
• -1 si A < B

Condition uniligne :

/commande/ if /condition/

$/variable/ =~ m//motif//	Test de correspondance d'un motif dans une variable
$/variable/ =~ s//motif///remplacement//	Substitution
$/variable/ =~ y//motif///remplacement//	Translittération
$/variable/ =~ tr//motif///remplacement//
m//motif//	Équivalent à $_ =~ m//motif// Idem avec s/…/…/ et y/…/…/
m/…/i s/…/…/i	Insensible à la casse
s/…/…/g	Substitution globale
$&	Variable contenant la dernière correspondance
$1, $2, $3, …	Rétro-références des groupes entre parenthèses
.	N'importe quel caractère sauf fin de ligne
*	Un nombre quelconque de fois l'élément précédent
+	Au moins une fois l'élément précédent
?	Zéro ou une fois l'élément précédent
{N}	N fois l'élément précédent
{M,/N/}	Entre M et N fois l'élément précédent
[/groupe/]	Un des caractères du groupe
(A ¦ B)	A ou B
^	Début de ligne
$	Fin de ligne

Pour chaque élément de la liste :

foreach $/variable/ ( @/liste/ ) {
/.../
/.../ $/variable/ /.../
/.../
}

foreach ( @/liste/ ) {
/.../
/.../ $_ /.../
/.../
}

@_	Liste des arguments
$_[/N/]	Argument N
my variable	Déclare une variable comme étant locale
return valeur	Retourne une valeur et quitte la fonction

sub /fonction/ {
my (/argument_1/, /.../) = @_
/.../
return /valeur/
}

Appel :

/fonction/(/arguments/)
/fonction/ /arguments/
&/fonction/(/arguments/)
&/fonction/ /arguments/

$/réf/ = \$/variable/	Référence vers une variable
$/réf/ = \@/variable/	Référence vers une liste
$/réf/ = \%/variable/	Référence vers un dictionnaire
$/réf/ = \&/fonction/	Référence vers une fonction
$/réf/ = [ …, …, … ]	Référence vers une liste
$/réf/ = { …, …, … }	Référence vers un dictionnaire

L'option -p permet de boucler implicitement sur les lignes de l'entrée standard ou des fichiers passés en argument. Chaque ligne est affichée à la suite des instructions. La ligne de commande :

perl -p -e '/instruction(s)/'

est équivalente à :

while ( <> ) {
/instruction(s)/
print $_
}

Remarque : l'option -p produit un comportement que l'on peut rapprocher du fonctionnement de sed.

L'option -n permet de boucler implicitement sur les lignes de l'entrée standard ou des fichiers passés en argument. Contrairement à l'option -p, aucune ligne n'est affichée à la suite des instructions. La ligne de commande :

perl -n -e '/instruction(s)/'

est équivalente à :

while ( <> ) {
/instruction(s)/
}

Remarque : l'option -n produit un comportement que l'on peut rapprocher du fonctionnement de sed -n.

cpan	Lance cpan
install module	Installe un module
o conf	Liste des options
o conf option valeur	Assigne une valeur à une option
o conf commit	Valide les modifications des options

#!/usr/bin/python

Début d'un script python

Les blocs en python ne se déclarent pas en utilisant des accolades comme dans d'autres langages, mais en utilisant l'indentation :

déclaration :

/début bloc/
...
/fin bloc/

suite du script

liste = [/e1/, e2, …, /eN/]	Définition d'une liste
liste[/i/]	L'élément i de la liste, en partant du premier d'indice 0
liste[-/i/]	L'élément i de la liste, en partant du dernier d'indice -1
liste[/i/:/j/]	Les éléments de la liste dont l'indice est supérieur ou égal à i
	et strictement inférieur à j
liste[-i:-/j/]	Les éléments de la liste dont l'indice négatif est supérieur ou égal à -i
	et strictement inférieur à -j
liste[:]	Tous les éléments de la liste
liste[/i/:]	Tous les éléments de la liste, sauf les i premiers
liste[:-/i/]	Tous les éléments de la liste, sauf les i derniers
liste.insert(pos, elt)	Insertion de l'élement elt à la position pos
del liste[/i/]	Suppression de l'élement d'indice i
liste.append(elt)	Ajout d'un élément à la fin de la liste
liste1 + liste2	Extension d'une liste par une autre
liste1.append(liste2)
liste.pop(pos)	Suppression de l'élément en position pos
liste.index(elt)	Renvoie l'indice de l'élement elt
liste.count(elt)	Donne le nombre d'occurences de l'élement elt
liste.reverse()	Renverse l'ordre des éléments
liste.sort()	Trie la liste

Pour éclater une chaîne de caractère :

#+BEGIN_EXAMPLE liste = chaine.split('séparateur') #+END_EXAMPLE <!– code –>

Pour fusionner une liste :

#+BEGIN_EXAMPLE chaine = 'séparateur'.join(liste) #+END_EXAMPLE <!– code –>

A and B	Est vrai si A et B sont vrais, est faux sinon
A or B	Est vrai si A ou B sont vrais, est faux sinon
a == b	Teste l'égalité entre a et b
a != b	Teste la différence entre a et b
a <= b	Teste l'infériorité de a par rapport à b
a >= b	Teste la supériorité de a par rapport à b
a < b	Teste l'infériorité stricte de a par rapport à b
a > b	Teste la supériorité stricte de a par rapport à b

if condition1 :

...

elif condition2 :

...

………. else :

...

Forme concise :

#+BEGIN_EXAMPLE variable = (1 if i == 2 else 0) #+END_EXAMPLE <!– code –>

Boucle for :

for élément in liste :

...

Boucle while :

while condition :

...

#+BEGIN_EXAMPLE listeDérivée = [ elt * elt for elt in /liste/] #+END_EXAMPLE <!– code –>

Un itérateur est une liste virtuelle qui ne sert qu'à être utilisée au sein d'une boucle, ce qui permet des optimisations.

def puissancesDeDeux(/n/) :
 /e/ = 1
 while /e/ <= /n/ :
	 yield /e/
	 /e/ = 2*/e/

for /element/ in puissancesDeDeux(10) :
...

for /element/ in (2**/x/ for /x/ in xrange(10)) :
...

Définition :

def /fonction/(/argument1/, /argument2/, ...) :
...
return /variable/

Définition avec valeurs par défaut des arguments :

def /fonction/(/argument1/ = /valeurParDéfaut1/, ...) :
...
return /variable/

Définition avec liste :

def /fonction/(..., */liste/) :
for /argument/ in /liste/ :
...
...

Définition avec dictionnaire :

def /fonction/(/arg1/, ..., **/dictionnaire/) :
for (/clé/, /valeur/) in /dictionnaire/.items() :
...
...

Définition avec liste et dictionnaire :

def /fonction/(..., */liste/, **/dictionnaire/) :
for /argument/ in /liste/ :
...
...
for (/clé/, /valeur/) in /dictionnaire/.items() :
...
...

Appel avec nom des arguments :

#+BEGIN_EXAMPLE var = fonction/(/nomArgument1 = valeur1, …) #+END_EXAMPLE <!– code –>

def factorielle(x) :
 return 1 if x == 0 else x * factorielle(x-1)

def /composée/(/f/, /g/) :
def /h/(/x/) :
return /g/(/f/(/x/))
return /h/

class Classe/(/ClasseDeBase1, ClasseDeBase2, …) :

Variable = …

def /__init__/(self, /a1/, /a2/, ...) :
self./attribut1/ = /a1/
self./attribut2/ = /a2/

def /__repr__/(self, /a1/, /a2/, ...) :
print self./attribut1/ + self./attribut2/

def /methode/(self, /a1/, /a2/, ...) :
...

/c/ = /Classe/(...)
/resultat/ = /c.methode(...)/
/variableDeClasse/ = /Classe.Variable/

Les blocs peuvent s'agencer de deux manières différentes. Soit :

déclaration / do |/variable1, …, /variableN/|

/bloc/

end

soit :

#+BEGIN_EXAMPLE déclaration { |/variables/| bloc } #+END_EXAMPLE <!– code –>

c = a + b
c = a - b
c = a * b
c = a / b
c = a ** b
c = a % b
a += b
a -= b
a *= b
a /= b
a **= b
a %= b

Conversions :

# Vers entier
/variable/.to_i
# Vers réel
/variable/.to_f

Afficher à la sortie standard :

# Sans passage à la ligne
print "/Coucou, je suis la variable/ #{/variable/}"
# Avec passage à la ligne
puts "/Coucou, je suis la variable/ #{/variable/}"

Récupérer à l'entrée standard :

/chaine/ = gets
#+END_EXAMPLE <!-- code -->

Concaténer :

#+BEGIN_EXAMPLE
/chaine/ = /chaine1/ + /chaine2/
/chaine/ += /autreChaine/
/chaine/ << /autreChaine/
#+END_EXAMPLE <!-- code -->

Répéter :

#+BEGIN_EXAMPLE
/chaine/ = /texte/ * /nombre/
#+END_EXAMPLE <!-- code -->

Remplacer :

#+BEGIN_EXAMPLE
/chaine/[/avant/] = /apres/
#+END_EXAMPLE <!-- code -->

Conversion vers chaîne :

#+BEGIN_EXAMPLE
/variable/.to_s

Enlever fin de ligne :

#+BEGIN_EXAMPLE chaine.chomp!/ #+END_EXAMPLE <!– code –>

Enlever fin de ligne sans modifier la chaîne originale :

#+BEGIN_EXAMPLE autreChaine = chaine.chomp/ #+END_EXAMPLE <!– code –>

Tester si une chaine est vide :

#+BEGIN_EXAMPLE chaine.empty?/ #+END_EXAMPLE <!– code –>

Passer en minuscules :

#+BEGIN_EXAMPLE chaine.downcase/ #+END_EXAMPLE <!– code –>

Passer en majuscules :

#+BEGIN_EXAMPLE chaine.upcase/ #+END_EXAMPLE <!– code –>

Echanger la casse :

#+BEGIN_EXAMPLE chaine.swapcase/ #+END_EXAMPLE <!– code –>

Listes :

/liste/ = ["/elt1/", "/elt2/", ..., "/eltN/"];
#+END_EXAMPLE <!-- code -->

Concaténer des listes :

#+BEGIN_EXAMPLE
/liste/ = /liste1/ + /liste2/
/liste/ += /autreListe/
/liste/ << /autreListe/
/liste/ << /élement/

Soustraction ensembliste de listes :

#+BEGIN_EXAMPLE liste = liste1 - liste2 #+END_EXAMPLE <!– code –>

liste[/i/]	L'élément i de la liste, en partant du premier d'indice 0
liste[-/i/]	L'élément i de la liste, en partant du dernier d'indice -1
liste[/i/…/j/]	Les éléments de la liste dont l'indice est supérieur
	ou égal à i et strictement inférieur à j
liste[-i…-/j/]	Les éléments de la liste dont l'indice négatif est supérieur
	ou égal à -i et strictement inférieur à -j
liste[/i/, /n/]	n éléments à partir de l'indice i
liste.pop()	Suppression du dernier élément
liste.shift()	Suppression du premier élément

Pour éclater une chaîne de caractère :

#+BEGIN_EXAMPLE liste = chaine.split('séparateur') #+END_EXAMPLE <!– code –>

Pour fusionner une liste :

#+BEGIN_EXAMPLE chaine =/liste/.join('séparateur') #+END_EXAMPLE <!– code –>

Obtenir une liste à partir d'entiers ou de chaines :

#+BEGIN_EXAMPLE (i../j/).to_a (0../9/).to_a ('a'../'z'/).to_a #+END_EXAMPLE <!– code –>

! A	Est vrai si A est faux
A && B	Est vrai si A et B sont vrais, est faux sinon
A ¦¦ B	Est vrai si A ou B sont vrais, est faux sinon
a == b	Teste l'égalité entre a et b
a != b	Teste la différence entre a et b
a <= b	Teste l'infériorité de a par rapport à b
a >= b	Teste la supériorité de a par rapport à b
a < b	Teste l'infériorité stricte de a par rapport à b
a > b	Teste la supériorité stricte de a par rapport à b
(i../j/) = a	Teste si a est compris entre i et j

if condition1

...

elsif condition2

...

………. else

...

end

Forme concise :

/commande/ if /condition/
#+END_EXAMPLE <!-- code -->

Forme ternaire :

#+BEGIN_EXAMPLE
/condition/ ? /commande si vrai/ : /commande si faux/
#+END_EXAMPLE <!-- code -->

Forme inverse :

unless /condition/
#+BEGIN_EXAMPLE
...

end

Aiguillage :

case variable when valeur(s)1

/commande1/

… when valeur(s)N

/commandeN/

end

Note : on peut aussi tester si la variable contient une correspondance d'une expression régulière.

Boucle while :

while condition

...

end

Boucle while inversée :

until condition

...

end

La boucle loop est une boucle infinie :

loop do

...
break if /condition/
...

end

Boucle for :

for i in liste do

...

end

Exemple classique :

for i in (0../N/) do

...

end

Boucle for sur un dictionnaire :

for cle, valeur in dictionnaire do

...

end

Les itérations utilisent des listes :

liste.each do |/element/|

puts /element/

end

L'équivalent d'une itération sur indice classique :

nombreFinal.each do |/i/|

puts /i/

end

En spécifiant les valeurs initiale et finale, en montant :

depart.upto(arrivee) do |/i/|

puts /i/

end

en descendant :

depart.downto(arrivee) do |/i/|

puts /i/

end

En spécifiant les valeurs initiale et finale et un pas de progression :

depart.step(arrivee, pas) do |/i/|

puts /i/

end

Les itérations peuvent aussi utiliser des dictionnaires :

dictionnaire.each do |/cle/, /valeur/|

puts /cle/ + " ---> " + /valeur/

end

Uniquement sur les clefs :

dictionnaire.each_key do |/cle/|

puts /cle/ + " ---> " + /dictionnaire/[/cle/]

end

Uniquement sur les valeurs :

dictionnaire.each_value do |/valeur/|

puts /valeur/

end

Itération sur les lignes d'une chaîne :

chaine.each_line do |/ligne/|

...

end

Définition :

def fonction/(/argument1, argument2, …)

......
return ......

end

La définition avec valeurs par défauts et les arguments rangés dans une liste sont similaires à celles du langage <a href="#pythonFonctions">python</a>.

...

Une procédure permet de donner un nom à un bloc de code.

Définition d'une procédure :

procédure = proc {

...

}

def /fonction/(…)

...
/procédure/.call
...

}

yield 1
yield 2
yield 3

puts /nombre/

puts yield(3)

/nombre/ * /nombre/

......
bloc.call(3)
......

puts /nombre/

L'opérateur a <=> b retourne 1 si a > b, 0 si a = b, -1 si a < b

metaListe.sort do |/L1/, L2/| if /L1[0] == L2[0]

/L1/[1] <=> /L2/[1]

else

/L1/[0] <=> /L2/[0]

end end

L'équivalent d'une boucle while :

def tantQue/(/condition)

return if not /condition/
yield
retry

end …. tantQue/(/i < 10) { print i ; i += 1 }

Définition d'un module :

module Module

...

end

Utilisation d'un module :

/Module/./méthode/(...)
/Module/::/Constante/

Utilisation concise :

include /Module/
/méthode/(...)
/Constante/

module Module1 def /méthodeDuModule/()

...

end end

module Module2 def /méthodeDeClasseDuModule/()

...

end end

class Classe / < /ClasseDeBase include Module1, Module2 extend Module2

@@/variableDeclasse/ = "Je m'appelle Classe";

def Classe./methodeDeClasse/

......

end

attr_accessor :/a/ attr_reader :/b/ attr_writer :/c/

def initialize(chaine = "")

super(/chaine/)
@/a/ = /chaine/
@/b/ = @/c/ = self./a/

end

def to_s

puts "a = #{@a} ; b = #{@b} ; c = #{@c}"

end

public

def methode_publique

......

end

protected

def methode_protegee

......

end

private

def methode_privee

......

end

…..

public :methode1, :methode2 end

objet = Classe.new("chaine") objet./méthodeDuModule()/ Classe::/méthodeDeClasse()/ Classe::/méthodeDeClasseDuModule()/

Tester si un objet est nul :

#+BEGIN_EXAMPLE objet.nil? #+END_EXAMPLE <!– code –>

Tester le type d'un objet :

#+BEGIN_EXAMPLE objet.kind_of? type objet.instance_of? classe #+END_EXAMPLE <!– code –>

Accéder à l'identifiant d'un objet :

#+BEGIN_EXAMPLE objet.object_id #+END_EXAMPLE <!– code –>

Tester si un objet possède une méthode :

#+BEGIN_EXAMPLE objet.respond_to?("methode") #+END_EXAMPLE <!– code –>

Exécuter une méthode d'après son nom :

#+BEGIN_EXAMPLE objet.send(:/nom/, argument1, …) objet.send("nom", argument1, …) #+END_EXAMPLE <!– code –>

Créer une méthode d'après une autre et l'appeler :

#+BEGIN_EXAMPLE méthode = method(:/nomFonction/) méthode.call(…) #+END_EXAMPLE <!– code –>

En Ruby, tout peut être redéfini : une méthode d'une classe de base, une méthode qui a déjà été définie dans la classe courante, ou même une méthode d'une instance particulière d'une classe.

...

chaine =~ expression	Opérateur d'expression régulière, renvoie true
	si une correspondance de l'expression est rencontré
	dans la chaîne, false sinon
.	N'importe quel caractère, sauf fin de ligne
^	Début de ligne
$	Fin de ligne
/x/*	0 ou plus d'occurence(s) de x
/x/+	1 ou plus d'occurence(s) de x
x?	0 ou 1 occurence de x
x/{/m, n}	Entre m et n occurences de x
x/{/m, }	Au moins m occurences de x
(expression1/¦/expression2)	expression1 ou expression2
[/groupe de caractères/]	N'importe quel caractère du groupe
[^/groupe de caractères/]	N'importe quel caractère tant qu'il n'appartient pas au groupe
[/b/-/y/]	n'importe quel caractère entre b et y
\d	N'importe quel chiffre
\D	N'importe quel caractère sauf un chiffre
\s	Espace
§	N'importe quel caractère sauf un espace
\w	Mot
\W	N'importe quoi sauf un mot
\b	Frontière de mot
\B	Frontière de non-mot
$~	Liste contenant les correspondances lors du dernier test d'expression régulière
$&	Dernière correspondance
\&	Dernière correspondance, utilisation dans une chaîne de remplacement
$1, $2, …	Variables où sont stockées les correspondances
	des expressions régulières mises entre parenthèses,
	équivalent à $~[1], $~[2], …
\1, \2, …	Variables où sont stockées les correspondances
	des expressions régulières mises entre parenthèses,
	utilisation dans une chaîne de remplacement

Correspondances :

#+BEGIN_EXAMPLE correspondances = expression.match(chaine) puts correspondances[0] puts correspondances[1] #+END_EXAMPLE <!– code –>

Remplacement :

#+BEGIN_EXAMPLE er = Regexp.new("expression") chaineModifiée = chaine.gsub(er, 'remplaçant') #+END_EXAMPLE <!– code –>

begin

/essais/

rescue

/cas particulier si ça n'a pas marché/

end

/usr/lib/postgresql//version//bin	Répertoire des exécutables postgresql À ajouter au PATH
postgres postmaster	Serveur postgresql
service postgresql-/version/</td>	Contrôle du serveur :
	start : démarrage
	stop : arrêt
	restart : redémarrage</td>

psql	Client postgresql (donne accès au serveur)
\h	Aide-mémoire des commandes SQL
\?	Aide-mémoire des commandes psql
; \g	Termine une commande SQL
\q	Quitter
<tab>	Complétion

Remarque : il faut faire attention à bien terminer chaque commande d'un point-virgule, sinon psql croira que la commande suivante continue la commande actuelle.

psql -f script

Exécute un script psql Peut contenir des commandes SQL et psql

CREATE	Crée un objet
ALTER	Modifie un objet
UPDATE	Mets à jour un objet
INSERT	Insère
SELECT	Sélectionne
DROP	Supprime un objet

/objet/ /type/[]

/objet/ /type/[/Taille/]

/objet/ /type/ ARRAY[/Taille/]

/objet/[/indice/]

/objet/./champ/

CREATE TYPE /typeÉnuméré/
AS ENUM ( /valeur1/, /.../, /valeurN/ ) ;

/.../
/colonne/ /type/ ARRAY[/taille/],
/.../

/.../
/colonne/ /typeComposite/,
/.../

/table/./colonne/

/table/./colonne/./champ/

/table/./colonne/[/indice/]

/colonne/ /type/ DEFAULT /valeur/

ALTER TABLE /table/ ADD COLUMN /colonne/ /type/

ALTER TABLE /table/ DROP COLUMN

DROP TABLE /table/

Une contrainte peut être associée à une colonne dans la définition de la table :

/colonne/ /type/ /contrainte/

Dans certains cas, une contrainte fait intervenir plusieurs colonnes. Il faut alors la déclarer indépendamment :

… colonneA typeA, colonneB typeB, contrainte, …

Voici quelques exemples de contraintes :

UNIQUE	Chaque valeur de la colonne doit être unique
NOT NULL	Aucun champ ne doit être laissé vide
CHECK ( condition )	Conditions diverses : inégalités entre colonnes ou avec une valeur, …

CONSTRAINT /nomContrainte/ /contrainte/

ALTER TABLE /table/
ADD CONSTRAINT /nomContrainte/ CHECK ( /.../) ;

/colonne/ /type/ PRIMARY KEY

CONSTRAINT /clé/
PRIMARY KEY (/colonneA/, /colonneB/, /.../)

/colonne/ /type/ REFERENCES /autreTable/ (/autreColonne/)

FOREIGN KEY ( /colonne(s)/ )
REFERENCES /autreTable/ ( /autreColonne(s)/ )

Efface une table et toutes les instructions REFERENCES qui en dépendent :

DROP TABLE /table/ CASCADE ;

Lors de la définition d'une clé étrangère, on peut demander d'effacer les lignes qui dépendent de la clé référencée en même temps que celle-ci :

/colonne/ REFERENCES /table/ (/clé/) ON DELETE CASCADE ;

On peut aussi interdire d'effacer la clé référencée :

/colonne/ REFERENCES /table/ (/clé/) ON DELETE RESTRICT ;

Pour remplacer la valeur par une valeur nulle, on définit :

/colonne/ REFERENCES /table/ (/clé/) ON DELETE SET NULL ;

Pour remplacer la valeur par la valeur par défaut, on définit :

/colonne/ REFERENCES /table/ (/clé/) ON DELETE SET DEFAULT ;

Un schéma est un regroupement de tables au sein d'une base de données. On en crée un par :

CREATE SCHEMA /schéma/ ;

Pour créer ou accéder à des tables au sein d'un schéma, on utilise :

/schéma/./table/

La création d'une table au sein d'un schéma se fait tout simplement par :

CREATE TABLE /schéma/./table/
( /.../ ) ;

DROP SCHEMA /schéma/ CASCADE

/table/ = public./table/

Une table peut dériver d'une autre et hériter de sa structure. La table dérivée contiendra les colonnes de base en plus de ses propres colonnes. Exemple :

CREATE TABLE base (

/colonneA/ /typeA/,
/colonneB/ /typeB/,

) ;

CREATE TABLE dérivée (

/colonneC/ /typeC/,
/colonneD/ /typeD/,

) INHERITS (base) ;

INSERT INTO /table/ ( /colonneA/, /colonneB/ )
VALUES ( /valeurA/, /valeurB/ ) ;

Les valeurs non numériques se mettent entre guillemets simples.

INSERT INTO /table/ ( /colonne/ )
VALUES ( '{ /elt1/, /.../, /eltN/ }' ) ;

COPY /table/ FROM '/fichier/' ;

COPY /table/ TO '/fichier/' ;

pg_dump /base/ > /fichier/

psql /base/ < /fichier/

pg_dump -Fc /base/ > /fichier/

pg_restore -d /base/ /fichier/

pg_dumpall > /fichier/

psql -f /fichier/ postgres

Les opérations scalaires associe un nombre à toutes les valeurs d'une colonne.

count( colonne )	Compte le nombre de lignes
count(DISTINCT colonne)	Compte le nombre de lignes distinctes
max( colonne )	Maximum
min( colonne )	Minimum
sum( colonne )	Somme
avg( colonne )	Moyenne

SELECT * FROM /table(s)/ ;

SELECT /colonne(s)/ FROM /table(s)/
WHERE /condition(s)/ ;

SELECT /colonne(s)/ FROM /table(s)/
GROUP BY /colonne(s)/ ;

SELECT /A/, sum(/B/) FROM /table(s)/
GROUP BY /A/ ;

SELECT /colonne(s)/ FROM /table(s)/
GROUP BY /colonne(s)/
HAVING /condition(s)/

SELECT /colonne(s)/ FROM /table(s)/
ORDER BY /colonne(s)/ ;

SELECT /colonne(s)/ FROM /table(s)/
ORDER BY /colonne(s)/ ASC ;

SELECT /colonne(s)/ FROM /table(s)/
ORDER BY /colonne(s)/ DESC ;

SELECT DISTINCT ON ( /colonne(s)/ ) * FROM /table(s)/
ORDER BY /colonne(s)/ ;

Une vue est une table virtuelle permettant de garder en mémoire une sélection particulière. Exemple :

CREATE VIEW /vue/
AS SELECT /colonne(s)/ FROM /table(s)/
WHERE /condition(s)/ ;

La plupart des opérations disponibles sur les tables le sont également sur les vues.

CREATE VIEW /vue/ ( /alias1/, /.../, /aliasN/ )
AS SELECT /colonne(s)/ FROM /table(s)/
WHERE /condition(s)/ ;

On peut modifier conditionnellement les valeurs d'une table :

UPDATE /table/
SET /colonne/ = /valeur/
WHERE /condition/ ;

UPDATE /table/
SET /colonne/ = /colonne/ + 1 ;

UPDATE /table/
SET /colonne/ = /valeur/
WHERE /colonne/ IN ( SELECT /.../ ) ;

DELETE FROM /table/
WHERE /condition/ ;

Une copie de table à table peut se faire en insérant une sélection de la table source dans la table destination :

INSERT INTO /destination/
SELECT /colonne(s)/ FROM /source/ ;

Si on veut réutiliser la sélection, on peut créer une vue associée

CREATE VIEW /vue/
AS /.../ ;

et l'insérer dans la destination :

INSERT INTO /destination/
SELECT * FROM /vue/ ;

SELECT * FROM /table1/ CROSS JOIN /table2/ ;

SELECT * FROM /table1/ INNER JOIN /table2/
ON /table1/./colonneA/ = /table2/./colonneB/ ;

SELECT * FROM /table1/ JOIN /table2/
ON /table1/./colonneA/ = /table2/./colonneB/ ;

SELECT * FROM /table1/ INNER JOIN /table2/
USING ( /colonne/ ) ;

SELECT * FROM /table1/ INNER JOIN /table2/
ON /table1/./colonne/ = /table2/./colonne/ ;

SELECT * FROM /table1/ NATURAL INNER JOIN /table2/ ;

SELECT * FROM /table1/ LEFT OUTER JOIN /table2/
ON /table1/./colonneA/ = /table2/./colonneB/ ;

SELECT * FROM /table1/ LEFT JOIN /table2/
ON /table1/./colonneA/ = /table2/./colonneB/ ;

SELECT * FROM /table1/ RIGHT OUTER JOIN /table2/
ON /table1/./colonneA/ = /table2/./colonneB/ ;

SELECT * FROM /table1/ RIGHT JOIN /table2/
ON /table1/./colonneA/ = /table2/./colonneB/ ;

SELECT * FROM /table1/ FULL OUTER JOIN /table2/
ON /table1/./colonneA/ = /table2/./colonneB/ ;

SELECT * FROM /table1/ FULL JOIN /table2/
ON /table1/./colonneA/ = /table2/./colonneB/ ;

Lorsqu'une recherche impliquant une sélection particulière est fréquente, il peut être utile de l'accélérer en créant un index sur cette colonne :

CREATE INDEX /index/ ON /table/ ( /colonne/ ) ;

REINDEX INDEX /index/ ;

REINDEX TABLE /table/

REINDEX DATABASE /base/

DROP INDEX /index/ ;

Le langage SQL dispose d'une structure conditionnelle multiple qui renvoie un résultat. Voici un exemple combiné avec une sélection :

SELECT CASE WHEN condition1 THEN valeur1 … WHEN conditionN THEN valeurN ELSE valeurParDéfaut END FROM table ;

Une transaction permet de demander l'exécution tout-ou-rien d'un bloc de commandes SQL, évitant les incohérences en cas de problème. Exemple :

BEGIN ;
/commandes SQL/
COMMIT ;

CREATE TABLESPACE /espace/
LOCATION '/répertoire/' ;

CREATE DATABASE /nom/ ;

CREATE DATABASE /nom/
TABLESPACE /espace/ ;

GRANT /droit/ ON /table/ TO /utilisateur ;/

REVOKE /droit/ ON /table/ TO /utilisateur ;/

GRANT /droit/ ON /table/ TO /utilisateur/
WITH GRANT OPTION ;

VACUUM ;

ANALYZE ;

<a href="../../index.php">Accueil</a>

<a title="Site déposé sur CopyrightFrance.com" href="http://www.copyrightfrance.com/phtml/p_logo1.php" target="_blank"><img border="0" src="images/logsc15.gif" alt="CopyrightFrance.com"></a>