Eclats de vers : Ordina 07 : Langages de script

Index des Grimoires

Retour à l’accueil

Table des matières

1 Emacs-Lisp

Expression Interprétation
expr interprétation de l’expression expr
(quote expr) expr
'expr expr
#'fun référence à la fonction fun
`(… ,var … ,@liste-a-plat) backquote
:symbol constant symbol
(type-of …) type d’un objet
(set 'var valeur) change la valeur dans var
(setq var valeur) synonyme de (set 'var valeur)
(setf expr valeur) change la valeur dans la variable
  référencée par le résultat de expr
  par exemple expr = (fun …)
  ne fonctionne pas avec toutes les fonctions
(setq ptr (gv-ref expr)) définit un pointeur ptr vers la variable
  référencée par le résultat de expr
(setf (gv-deref ptr) valeur) modifie la valeur de la variable référencée
  par ptr
(cons a b) (a . b)
(car '(a . b)) a
(cdr '(a . b)) b
(setcar liste) change le car de liste
(setcdr liste) change le cdr de liste
(list a b) (a b)
  (a . (b))
(list a b c) (a b c)
  (a . (b c)
  (a . (b . (c)))
(car '(a b c)) a
(cdr '(a b c)) (b c)
(eq a b) teste si a et b référencent la même variable
(equal a b) teste si a et b contiennent la même valeur
(elt sequence N) référence vers le N/ième élément de /sequence
(nth N liste) référence vers le N/ième élément de /liste
(nthcdr index liste) référence vers la liste sans ses N premiers
  éléments
(last liste N) référence vers la liste contenant
  les N derniers éléments de liste
(butlast liste N) copie de liste sans ses N derniers éléments
(nbutlast liste N) enlève les N derniers éléments de liste
(copy-seq …) copie le contenu d’une séquence
(copy-tree …) copie récursivement le contenu d’une liste
(intern-soft "var") symbole 'var de la variable de nom "var"
(intern "var") comme intern-soft mais crée la variable
  si elle n’existe pas encore
(unintern "var") détruit la variable var
(symbol-name 'var) nom "var" de la variable
(symbol-value 'var) valeur de la variable de symbole var
(symbol-function 'fun) valeur de la fonction de symbole fun
(eval expr) évalue le contenu de l’expression expr
(eval 'expr) évalue le contenu de l’expression 'expr
(eval `/expr/) évalue le contenu de l’expression `/expr/
(eval (car (read-from-string text))) évalue le contenu du texte text
(eval-buffer buffer) évalue le buffer
(fun args) application de la fonction fun
  aux arguments args
(defun …) définition d’une fonction
(lambda … ) définition d’une fonction anonyme
(funcall 'fun args) applique la fonction de symbole fun
  aux args
(apply 'fun args) similaire à funcall mais le dernier
  argument est considéré comme la liste
  des arguments restants
(defmacro …) définition d’une macro
(macroexpand …) étend une macro
(macroexpand-all …) étend une macro récursivement
(caar …) (car (car …))
(cadr …) (car (cdr …))
(cddr …) (cdr (cdr …))
(let ((…)) …) définition de variables locales
(if …) if else
(when …) if sans else
(unless …) if not sans else
(cond …) série de conditions
(pcase var …) série de conditions sur une variable var
(progn …) bloc de code
(push elem liste) Ajoute elem au début de liste
(pop liste) Renvoie le premier élément de liste et l’enlève
  de liste
(append …) Concatène plusieurs listes et renvoie le résultat
(nconc …) Concatène plusieurs listes et les remplace
  par les résultats

2 Perl

2.1 Générique

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

2.2 Variables

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

2.3 Chaînes de caractères

2.3.1 Effet des caractères magiques annulé

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

2.3.2 Effet des caractères magiques actif

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

2.3.3 Concaténer

'/chaîne_1/' . '/chaîne_2/'
$/variable_1/ . $/variable_2/
"$/variable_1/$/variable_2/"

2.3.4 Répéter

"/chaîne/" x /Nombre/

2.4 Fichiers

$/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

2.5 Listes

@/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.

2.5.1 Fusion

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

2.5.2 Éclatement

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

2.6 Dictionnaires

%/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

2.7 Conditions

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/

2.8 Expressions régulières

$/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

2.9 Boucles

Pour chaque élément de la liste :

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

2.9.1 Variable par défaut

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

2.10 Fonctions

@_ 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/

2.11 Références

$/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

2.12 Options

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.

2.13 CPAN

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

3 Python

3.1 Scripts

#!/usr/bin/python Début d'un script python

3.2 Blocs

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

3.3 Listes

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 :

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

Pour fusionner une liste :

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

3.3.1 Dictionnaires

#+BEGINEXAMPLE dictionnaire = {"cle1": "valeur1", …, "cleN": "valeur1"}; #+ENDEXAMPLE <!– code –>

3.4 Logique

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

3.5 Conditions

if condition1 :

...

elif condition2 :

...

………. else :

...

Forme concise :

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

3.6 Boucles

Boucle for :

for élément in liste :

...

Boucle while :

while condition :

...

3.7 Expressions de liste

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

3.7.1 Multi-liste

#+BEGINEXAMPLE liste = [/e1/ + e2 for e1 in L1 for e2 in /L2/] #+ENDEXAMPLE <!– code –>

3.7.2 Filtre

#+BEGINEXAMPLE listeFiltrée = [/elt/ for elt in liste if /condition/] #+ENDEXAMPLE <!– code –>

3.8 Itérateurs

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

3.8.1 Générateur

Un générateur est une fonction permettant de générer un itérateur. Une boucle while ou for indique la condition permettant la fin des itérations et le mot-clé yield permet d'indiquer le passage à l'itération suivante. Un exemple permettant d'itérer sur les puissances de deux :

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

et une application :

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

équivalente à :

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

3.9 Fonctions

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 :

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

3.9.1 Récursivité

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

3.9.2 Fonctionnelles

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

3.10 Classes

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/

4 Ruby

4.1 Blocs

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

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

/bloc/

end

soit :

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

4.2 Arythmétique

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

4.3 Chaînes de caractère

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 :

#+BEGINEXAMPLE chaine.chomp!/ #+ENDEXAMPLE <!– code –>

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

#+BEGINEXAMPLE autreChaine = chaine.chomp/ #+ENDEXAMPLE <!– code –>

Tester si une chaine est vide :

#+BEGINEXAMPLE chaine.empty?/ #+ENDEXAMPLE <!– code –>

Passer en minuscules :

#+BEGINEXAMPLE chaine.downcase/ #+ENDEXAMPLE <!– code –>

Passer en majuscules :

#+BEGINEXAMPLE chaine.upcase/ #+ENDEXAMPLE <!– code –>

Echanger la casse :

#+BEGINEXAMPLE chaine.swapcase/ #+ENDEXAMPLE <!– code –>

4.4 Listes

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 :

#+BEGINEXAMPLE liste = liste1 - liste2 #+ENDEXAMPLE <!– 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 :

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

Pour fusionner une liste :

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

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

#+BEGINEXAMPLE (i../j/).toa (0../9/).toa ('a'../'z'/).toa #+ENDEXAMPLE <!– code –>

4.4.1 Dictionnaires

#+BEGINEXAMPLE dictionnaire = {"cle1" => "valeur1", …, "cleN" => "valeurN"} #+ENDEXAMPLE <!– code –>

4.5 Logique

! 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

4.6 Conditions

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.

4.7 Boucles

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.eachkey do |/cle/|

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

end

Uniquement sur les valeurs :

dictionnaire.eachvalue do |/valeur/|

puts /valeur/

end

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

chaine.eachline do |/ligne/|

...

end

4.8 Fonctions

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>.

4.8.1 Symbole

Le symbole de la fonction de nom fonction est :

#+BEGINEXAMPLE :/fonction/ #+ENDEXAMPLE <!– code –>

4.8.2 Alias

Créer une copie d'une fonction

def fonction1

...

end … alias fonction2 fonction1

4.9 Procédure

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
...

}

4.9.1 Fonctions et blocs

Une fonction peut envoyer des données vers un bloc :

def fonction

yield 1
yield 2
yield 3

end

fonction do |/nombre/|

puts /nombre/

end

Une fonction peut déléguer le calcul d'une valeur à un bloc :

def fonction

puts yield(3)

end

fonction do |/nombre/|

/nombre/ * /nombre/

end

Une fonction peut prendre un bloc en argument :

def fonction/(/argument, &/bloc/)

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

end

fonction/(/argument) do |/nombre/|

puts /nombre/

end

4.10 Tri

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 }

4.11 Modules

Définition d'un module :

module Module

...

end

Utilisation d'un module :

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

Utilisation concise :

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

4.12 Classes

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

attraccessor :/a/ attrreader :/b/ attrwriter :/c/

def initialize(chaine = "")

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

end

def tos

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

end

public

def methodepublique

......

end

protected

def methodeprotegee

......

end

private

def methodeprivee

......

end

…..

public :methode1, :methode2 end

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

Tester si un objet est nul :

#+BEGINEXAMPLE objet.nil? #+ENDEXAMPLE <!– code –>

Tester le type d'un objet :

#+BEGINEXAMPLE objet.kindof? type objet.instanceof? classe #+ENDEXAMPLE <!– code –>

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

#+BEGINEXAMPLE objet.objectid #+ENDEXAMPLE <!– code –>

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

#+BEGINEXAMPLE objet.respondto?("methode") #+ENDEXAMPLE <!– code –>

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

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

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

#+BEGINEXAMPLE méthode = method(:/nomFonction/) méthode.call(…) #+ENDEXAMPLE <!– 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.

4.12.1 Classes particulières

Classe qui n'existe que par une seule instance du même nom :

class << nom

...

end

4.13 Expressions régulières

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 :

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

Remplacement :

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

4.14 Exceptions

begin

/essais/

rescue

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

end

5 PostgreSQL

5.1 Serveur

/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>

5.1.1 Environnement

PGDATA Variable d'environnement contenant le chemin de la grappe par défaut

5.1.2 Utilisateurs

postgres Utilisateur administrateur de postgresql
createuser utilisateur Crée un nouvel utilisateur postgresql
createuser -s utilisateur Crée un nouvel aministrateur postgresql

5.1.3 Bases de donnée

createdb nom Crée une nouvelle base de données
dropdb nom Supprime une base de données

5.2 Client

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.

5.3 Scripts

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

5.4 Méta-commandes

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

5.5 Types

5.5.1 Date et heure

DATE Date
TIME WITHOUT TIME ZONE Heure sans la zone
TIME WITH TIME ZONE Heure avec la zone
TIMESTAMP WITHOUT TIME ZONE Date et heure sans la zone
TIMESTAMP WITH TIME ZONE Date et heure avec la zone
INTERVAL Intervalle de temps

5.5.2 Nombres

INTEGER Entier
SERIAL Numéro auto-incrémenté
BIGSERIAL Numéro auto-incrémenté, maximum élevé
BOOLEAN Booléen
REAL Réel simple précision
DOUBLE PRECISION Réel double précision

5.5.3 Texte

VARCHAR(N) Texte d'au maximum N caractères
text Texte de taille quelconque

5.5.4 Binaires

bytea Binaire (image, son, …)

5.5.5 Tableaux

Déclaration d'un objet pouvant contenir un tableau d'éléments de type type :

/objet/ /type/[]

Lorsque la taille du tableau est fixe et connue, on peut la préciser :

/objet/ /type/[/Taille/]

On a aussi la syntaxe du standard SQL :

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

L'accès à un élément d'un tableau se fait par :

/objet/[/indice/]

5.5.6 Composites

Définition d'un type comportant plusieurs champs :

CREATE TYPE typeComposite AS ( champ1 type1, champ2 type2, champN typeN ) ;

L'accès à un champ d'un objet de type composite se fait par :

/objet/./champ/

5.5.7 Énumération

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

5.5.8 Conversion

CAST ( valeur AS type ) Convertit une valeur en un type
valeur::/type/ Convertit une valeur en un type (jargon postgresql)

5.6 Conditions

5.6.1 Opérations

NOT Vrai si la condition est fausse
AND Et
OR Ou

5.6.2 Existence

valeur IS NULL Vrai si la valeur est vide
valeur IS NOT NULL Vrai si la valeur n'est pas vide
EXISTS liste Vrai si la liste n'est pas vide
UNIQUE liste Vrai si les éléments sont toutes distincts Deux éléments vides sont considérés comme distincts
DISTINCT liste Vrai si les éléments sont toutes distincts Deux éléments vides sont considérés comme identiques

5.6.3 Comparaison

= Égalité (valeurs ou listes)
<> != Différent
< Strictement inférieur
> Strictement supérieur
<= Inférieur ou égal
>= Supérieur ou égal
5.6.3.1 Existence
A IS DISTINCT FROM B Comme <>, mais donne vrai si une seule des entrées est vide et faux si les deux le sont

5.6.4 Motifs

% Correspond à n'importe quelle chaîne de caractère
_ Correspond à n'importe quel caractère

5.6.5 Valeurs et listes

5.6.5.1 Appartenance
valeur IN (liste) Vrai si la valeure est dans la liste
valeur LIKE motif Vrai si la valeur correspond au motif
valeur BETWEEN min AND max Vrai si la valeur est comprise entre les valeurs minimale et maximale
I1 OVERLAPS I2 Vrai si les deux intervalles de temps se superposent
5.6.5.2 Comparaison
valeur comparaison ALL liste Vrai si la valeur valide la comparaison avec tous les éléments de la liste
valeur comparaison ANY liste Vrai si la valeur valide la comparaison avec au moins un des éléments de la liste
valeur comparaison SOME liste Vrai si la valeur valide la comparaison avec au moins un des éléments de la liste

5.7 Tables

5.7.1 Création

CREATE TABLE table ( colonne1 type1, colonne2 type2, colonneN typeN, ) ;

5.7.2 Colonnes contenant des tableaux

Les colonnes peuvent contenir des tableaux :

CREATE TABLE table (

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

) ;

5.7.3 Colonnes composites

Les colonnes peuvent contenir des types composites :

CREATE TABLE table (

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

) ;

5.7.4 Accès

Lorsqu'il y a ambiguité, on accède à la colonne d'une table par :

/table/./colonne/

On peut accéder à un champ d'une colonne composite par :

/table/./colonne/./champ/

On peut accéder à un élément d'une colonne-tableau par :

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

5.7.5 Valeurs par défaut

/colonne/ /type/ DEFAULT /valeur/

5.7.6 Modifications

5.7.6.1 Ajout d'une colonne
ALTER TABLE /table/ ADD COLUMN /colonne/ /type/
5.7.6.2 Suppression d'une colonne
ALTER TABLE /table/ DROP COLUMN

5.7.7 Suppression

DROP TABLE /table/

5.8 Contraintes

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, …

5.8.1 Nommées

CONSTRAINT /nomContrainte/ /contrainte/

5.8.2 Ajout d'une contrainte

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

5.8.3 Domaines

Les domaines sont des types avec valeurs par défaut et contraintes :

CREATE DOMAIN domaine AS typeDeBase DEFAULT valeurParDéfaut CONSTRAINT contrainte CHECK ( VALUE ) ;

Exemple :

CREATE DOMAIN domaine AS typeDeBase DEFAULT valeurParDéfaut CONSTRAINT contrainte CHECK ( VALUE < 5 ) ;

5.9 Clés

5.9.1 Clé primaire

Une clé primaire est constituée d'une ou plusieurs colonnes d'une même table. Elle permet d'en identifier de façon unique chaque ligne.

Lorsqu'elle ne concerne qu'une seule colonne, on peut la placer dans la définition de la table sous forme d'une contrainte de colonne :

/colonne/ /type/ PRIMARY KEY

Si la clé implique plusieurs colonnes, on la place sous la forme d'une contrainte de table :

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

5.9.2 Clé étrangère

Sous forme de contrainte associée à une colonne :

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

Sous forme de contrainte indépendante :

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

La valeur par défaut de la colonne de la table étrangère est sa clé primaire.

5.10 Dépendances

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 ;

5.11 Schémas

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/
( /.../ ) ;

5.11.1 Suppression

Pour supprimer un schéma et les tables qu'il contient, on utilise :

DROP SCHEMA /schéma/ CASCADE

5.11.2 Par défaut

Lorsqu'on ne précise pas de schéma pour une table, elle appartient au schéma « public ». On a donc :

/table/ = public./table/

5.12 Héritage

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) ;

5.13 Insertion

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

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

5.13.1 Tableaux

Les valeurs des tableaux se mettent entre accolades :

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

5.14 Import - Export

5.14.1 Tables

On peut insérer un fichier dans la table :

COPY /table/ FROM '/fichier/' ;

On peut insérer une table dans un fichier :

COPY /table/ TO '/fichier/' ;

5.14.2 Bases

On peut sauvegarder une base de données en instructions SQL :

pg_dump /base/ > /fichier/

On la restaure par :

psql /base/ < /fichier/
5.14.2.1 Compression

On peut faire une sauvegarde compressée :

pg_dump -Fc /base/ > /fichier/

On la restaure par :

pg_restore -d /base/ /fichier/

5.14.3 Grappe

On peut sauvegarder toutes les bases de données d'une grappe en instructions SQL :

pg_dumpall > /fichier/

On la restaure par :

psql -f /fichier/ postgres

5.15 Opérations scalaires

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

5.16 Sélections

5.16.1 Totale

SELECT * FROM /table(s)/ ;

5.16.2 Conditionnelle

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

5.16.3 Groupement

La clause GROUP BY regroupe les lignes par valeurs identiques d'une colonne :

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

On peut s'en servir pour opérer sur les groupes :

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

5.16.4 Filtre de groupes

La clause HAVING permet de filtrer les groupes :

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

Contrairement à la clause WHERE qui ne peut filtrer que sur la valeur de chaque ligne, la clause HAVING permet de faire intervenir des opérations scalaires dans les conditions.

5.16.5 Tri

La clause ORDER BY permet de trier les données :

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

Par défaut le tri est croissant. On peut préciser le sens, croissant :

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

ou décroissant :

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

5.16.6 Redondance

On peut sélectionner seulement les lignes distinctes du point de vue de certaines colonnes :

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

5.16.7 Héritage

Une sélection regroupe toutes les valeurs valables de la table plus toutes celles des tables qui en sont dérivées.

5.17 Vues

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.

5.17.1 Alias

On peut définir des alias locaux à la vue pour les colonnes :

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

5.18 Modifications

On peut modifier conditionnellement les valeurs d'une table :

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

5.18.1 Références aux anciennes valeurs

Les nouvelles valeurs peuvent dépendre des anciennes. Exemple :

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

5.18.2 Sélection

La condition peut faire appel à une sélection :

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

5.18.3 Suppression

DELETE FROM /table/
WHERE /condition/ ;

5.19 Copie

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/ ;

5.20 Jointures

5.20.1 Produit cartésien

Le produit cartésion CROSS JOIN affiche toutes les possibilités de combinaisons entre les lignes de deux tables :

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

ce qui donne :

ligne1-Table1 ligne1-Table2 ligne1-Table1 ligneN-Table2 ligneM-Table1 ligne1-Table2 ligneM-Table1 ligneN-Table2

5.20.2 Interne

La jointure interne est un sous-ensemble du produit cartésien : seules les lignes vérifiant les conditions seront affichées. Exemple :

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

La jointure interne étant la jointure par défaut, on a la commande équivalente :

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

La commande :

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

est un raccourci pour :

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

à la différence près que les colonnes homonymes utilisées n'apparaissent qu'une fois dans l'affichage, au lieu de deux si on utilise la directive ON.

5.20.2.2 Naturelle

La commande :

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

est un raccourci pour la directive USING sur toutes les colonnes homonymes des deux tables.

5.20.3 Externe

5.20.3.1 Gauche

La jointure externe gauche est une jointure interne à laquelle on ajoute les colonnes de la première table ne respectant pas les conditions. Dans ces lignes ajoutées, les colonnes de la seconde table sont laissées à une valeur NULL (vide). Les directives ON, USING, NATURAL sont semblables. Exemple :

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

Le raccourci LEFT JOIN est identique à LEFT OUTER JOIN :

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

La jointure externe droite est une jointure interne à laquelle on ajoute les colonnes de la seconde table ne respectant pas les conditions. Dans ces lignes ajoutées, les colonnes de la première table sont laissées à une valeur NULL (vide). Les directives ON, USING, NATURAL sont semblables. Exemple :

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

Le raccourci RIGHT JOIN est identique à RIGHT OUTER JOIN :

SELECT * FROM /table1/ RIGHT JOIN /table2/
ON /table1/./colonneA/ = /table2/./colonneB/ ;
5.20.3.3 Complète

La jointure externe complète est une jointure interne à laquelle ajoute les colonnes de la première table ne respectant pas les conditions. Dans ces lignes ajoutées, les colonnes de la seconde table sont laissées à une valeur NULL (vide). Ensuite, on ajoute les colonnes de la seconde table ne respectant pas les conditions. Dans ces lignes ajoutées, les colonnes de la première table sont laissées à une valeur NULL (vide). Les directives ON, USING, NATURAL sont semblables. Exemple :

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

Le raccourci FULL JOIN est identique à FULL OUTER JOIN :

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

5.21 Opérations ensemblistes

5.21.1 Les lignes redondantes sont retirées du résultat

sélection1 UNION sélection2 Union de deux sélections
sélection1 INTERSECT sélection2 Intersection de deux sélections
sélection1 EXCEPT sélection2 Tout ce qui est dans la première sélection mais pas dans la seconde

5.21.2 Les lignes redondantes ne sont pas retirées du résultat

sélection1 UNION ALL sélection2 Union de deux sélections
sélection1 INTERSECT ALL sélection2 Intersection de deux sélections
sélection1 EXCEPT ALL sélection2 Tout ce qui est dans la première sélection mais pas dans la seconde

5.22 Index

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/ ) ;

5.22.1 Reconstruction

Lorsqu'une table est très modifiée, l'index finit par contenir des données devenues inutiles. On peut alors le reconstruire en utilisant la commande :

REINDEX INDEX /index/ ;

On peut aussi reconstruire tous les index d'une table :

REINDEX TABLE /table/

ou d'une base de données :

REINDEX DATABASE /base/

5.22.2 Suppression

Pour supprimer un index, on fait :

DROP INDEX /index/ ;

5.23 Structures

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 ;

5.23.1 Condition

La clause CASE peut servir de condition :

SELECT * FROM table WHERE CASE WHEN condition1 THEN autreCondition1 WHEN conditionN THEN autreConditionN ELSE autreConditionParDéfaut END ;

5.23.2 Raccourci

La forme :

CASE colonne WHEN val1 THEN valeur1 WHEN valN THEN valeurN ELSE valeurParDéfaut END

est équivalente à :

CASE WHEN colonne = val1 THEN valeur1 WHEN colonne = valN THEN valeurN ELSE valeurParDéfaut END

5.24 Transactions

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 ;

5.25 Administration

5.25.1 Système de fichier

On définit un emplacement dans le système de fichiers par :

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

5.25.2 Base de donnnées

On crée une base de donnée par :

CREATE DATABASE /nom/ ;

On peut préciser l'emplacement où elle sera stockée :

CREATE DATABASE /nom/
TABLESPACE /espace/ ;

5.25.3 Utilisateurs

CREATE USER utilisateur ; Crée un utilisateur
ALTER USER utilisateur WITH privilège ; Modifie les privilèges d'un utilisateur

<tr> <td>ALTER USER utilisateur WITH ENCRYPTED PASSWORD 'motDePasse' ;</td> <td>Modifie le mot de passe d'un utilisateur</td> </tr>

5.25.4 Droits

Pour accorder un droit à un utilisateur :

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

Pour révoquer un droit à un utilisateur :

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

Voici quelques droits :

CREATE   INSERT   UPDATE DELETE   SELECT   REFERENCES

On peut aussi accorder ou révoquer des droits sur des schémas et autres objets.

5.25.4.1 Transmission

La clause WITH GRANT OPTION donne le droit à un utilisateur de partager les droits dont il dispose à d'autres utilisateurs :

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

5.25.5 Optimisation

La commande :

VACUUM ;

récupère l'espace disque des ligne supprimées ou mises à jour. La commande :

ANALYZE ;

collecte des statistiques sur la base de données afin d'optimiser les requêtes.

<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>

Auteur: chimay

Created: 2020-03-14 sam 11:20

Validate