• Projection
• Restriction/Sélection
• Jointures

De plus, pendant ce cours, il se peut que je fasse référence à l'algèbre relationnelle. Ce n'est pas obligatoire, je ne m'attarderai pas dessus, mais si vous connaissez, ça ne peut être qu'un plus pour vraiment bien visualiser ce que vous voulez récupérer comme données.
En ayant vu ça, nous aurons déjà fait pas mal le tour des possibilités offertes par le SELECT.

I - Cas général :

Le SELECT est donc une requête SQL. En faisant un SELECT, on réalise une projection des données de la base de données, en fonction de différents critères.

On l'écrit de la forme suivante :
 

SELECT <liste des attributs projetés>
FROM <liste des relations touchées par la projection>

[ WHERE <liste des critères de restriction>
GROUP BY <liste des attributs d'agrégation>
HAVING <liste des critères de restriction des agrégats>
ORDER BY <liste des attributs du tri du résultat> ]

Pour ceux qui connaissent l'algèbre relationnelle, il est facile d'établir une correspondance avec un SELECT dans les requêtes simples.

Si vous n'avez pas compris grand chose de ce que je viens d'expliquer, pas de panique, il s'agit juste de la structure de la requête. Les éléments entre crochets sont facultatifs.

Tout au long de ce tutoriel, j'utiliserai le schéma de base de données suivant :

• DEPT(DEPTNO, DNAME, LOC)
• EMP(EMPNO, ENAME, JOB, #MGR, HIREDATE, SAL, COMM, #DEPTNO)

Les tables soulignées sont des clés primaires, et celles avec un #devant sont des clés étrangères. Pour mieux comprendre, je vous invite à jeter un coup d'oeil par ici : http://openclassrooms.com/courses/administrez-vos-bases-de-donnees-avec-mysql/cles-primaires-et-etrangeres

II - Projection :

On va sélectionner les données à l'aide de la commande SELECT.
Comme vu plus haut, dans un SELECT, il faut au minimum un FROM afin de dire dans quelle table on se situe. L'ordre s'écrit donc :

SELECT <liste des attributs>
FROM <nom des tables>

Pour prendre un exemple, mettons que je veuille récupérer toutes les entrées de la table DEPT, la requête sera la suivante :

SELECT *
FROM dept

J'utilise le joker * afin de dire que je veux tous les attributs de la table. Cependant, il est préférable de ne garder que ce dont on a vraiment besoin lorsque l'on effectue la requête, c'est une question d'optimisation.
 

SELECT deptno, dname
FROM dept

Ici, je sélectionne uniquement les attributs deptno et dname de la table dept.

Ce qui nous embête ici, et contrairement à l'algèbre relationnelle, C'est que cette requête n'élimine pas les doublons. On va donc ajouter un mot-clé juste après le SELECT, il s'agit de DISTINCT.

On obtient donc ;

SELECT DISTINCT job
FROM emp

Voila la différence :
Sans DISTINCT :

mysql> SELECT job FROM emp;
+-----------+
| job |
+-----------+
| EMPLOYE |
| VENDEUR |
| VENDEUR |
| MANAGER |
| EMPLOYE |
| PRESIDENT |
+-----------+
6 rows in set

Avec Distinct :

SELECT DISTINCT job FROM emp;
+-----------+
| job       |
+-----------+
| EMPLOYE   |
| VENDEUR   |
| MANAGER   |
| PRESIDENT |
+-----------+
4 rows in set

FROM nomdelatable alias

Ainsi, nous pourrons écrire des requêtes qui ressemblent à ça :
 

SELECT d.deptno
FROM dept d

Le "d.deptno" peut se traduire par "la colonne deptno de la table d".
Simple non ?
Aller, au suivant !

SELECT deptno AS Service, dname AS "Nom Service"
FROM dept;

On fait suivre le nom de la table par le mot clé "AS" et ensuite, si c'est un seul mot, pas de guillemets, sinon, on en met.
Note : Le AS est optionnel, on peut uniquement séparer le nom de table de l'alias par un espace.

Regardons le résultat :

mysql> SELECT deptno AS Service, dname AS "Nom Service"
FROM dept;
+---------+--------------+
| Service | Nom Service  |
+---------+--------------+
|       1 | Juridique    |
|       2 | Recherche    |
|       3 | Comptabilité |
|       4 | Support      |
+---------+--------------+
4 rows in set

On a bien les colonnes qui sont renommées dans le résultat.

• + : Addition
• - : Soustraction
• * : Multiplication
• / : Division

Ces opérateurs sont utilisables pour tout attribut numérique ! N'essayez pas de jouer avec les chaînes de caractères.

Exemple :

mysql> SELECT (sal*1.1)+comm FROM emp;
+----------------+
| (sal*1.1)+comm |
+----------------+
|            880 |
|           2060 |
|           2200 |
|         3372.5 |
|           1430 |
|          16000 |
+----------------+
6 rows in set

• Le classement par défaut est ascendant (ASC). Pour inverser, on rajoutera DESC (comme descendant).
• Une seule clause ORDER BY et TOUJOURS à la fin du SELECT
• Les éléments de tri ne figurent pas forcément dans le SELECT
• Les valeurs NULL se trouvent à la fin si on a un tri ASC, où au début en cas de tri DESC
• Les éléments de tri peuvent être le nom des colonnes, le numéro des colonnes ou même une expression.

Quelques exemples :

Premier exemple, on trie les résultats par numéro de département, puis par salaire.

mysql> SELECT ename, sal, deptno FROM emp ORDER BY deptno, sal;
+---------+-------+--------+
| ename   | sal   | deptno |
+---------+-------+--------+
| JONES   |  2975 |      2 |
| FORD    |  1300 |      3 |
| SMITH   |   800 |      4 |
| ALLEN   |  1600 |      4 |
| RICARDO |  2000 |      6 |
| KING    | 10000 |      6 |
+---------+-------+--------+
6 rows in set

Deuxième exemple, on trie par salaire (du plus petit au plus grand).

mysql> SELECT ename, sal, deptno FROM emp ORDER BY 2;
+---------+-------+--------+
| ename   | sal   | deptno |
+---------+-------+--------+
| SMITH   |   800 |      4 |
| FORD    |  1300 |      3 |
| ALLEN   |  1600 |      4 |
| RICARDO |  2000 |      6 |
| JONES   |  2975 |      2 |
| KING    | 10000 |      6 |
+---------+-------+--------+
6 rows in set

2 est le numéro de colonne de sal dans le SELECT (il est a la seconde position)

III - Restriction/sélection :

On commence directement par la clause WHERE. Avec le WHERE, on va réduire le nombre de lignes concernées par la recherche.
Par exemple, on sélectionne tous les employés du service 1 :

SELECT ename, sal
FROM emp
WHERE deptno = 10

Les conditions de recherche sont des expressions logiques vraies ou fausses, en fonction des enregistrements de la table. Une condition peut aussi être appelée prédicat.
Une condition est toujours composée de 3 membres : deux expressions encadrant un opérateur de comparaison.
On peut comparer un attribut avec une valeur constante (comme dans l'exemple), mais aussi deux attributs entre eux.

On retrouve les opérateurs de comparaison usuels à savoir :

• Comparaison : =, !=, <>, >, >=, <, <=
• Intervalles : BETWEEN
• Concordance de caractères : LIKE avec les jokers _ et %
• Gestion des colonnes "NULL" : IS NULL
• Enumération : IN
• Négation : NOT IN, NOT LIKE, NOT BETWEEN, IS NOT NULL

• numérique
• Alphabétique
• Chronologique (avec les dates)

Exemple avec les dates :

SELECT ename, hiredate
FROM emp
WHERE hiredate < '1981-01-01'
-- Le format de la date depend du SGBD

Pour les comparaisons de chaînes de caractères, les lettres majuscules et minuscules sont supérieures aux nombres et la casse peut importer, tout dépend de comment le SGBD est réglé.

Exemple avec les chaînes :

SELECT ename
FROM emp
WHERE ename > 'MARTIN'

• _ qui remplace une lettre
• % qui remplace tout chaîne de caractère

Peu compréhensible n'est-ce pas ?
Regardons un exemple pour mieux comprendre :

SELECT ename
FROM emp
WHERE ename LIKE ('_AR%')

Que demande cette requête ? On cherche les noms d'employés qui ont pour deuxième lettre A et troisième lettre R dans leur nom de famille. soit :

SELECT ename
FROM emp
WHERE ename LIKE ('_AR%');
+--------+
| ename  |
+--------+
| WARD   |
| MARTIN |
+--------+
2 rows in set

Déjà un peu plus compréhensible non ? C'est en jouant avec ces deux jokers qu'on arrive à trouver ce qu'on veut.

SELECT ename, deptno
FROM emp
WHERE deptno IN (3,4);
+--------+--------+
| ename  | deptno |
+--------+--------+
| SMITH  |      4 |
| ALLEN  |      4 |
| FORD   |      3 |
| WARD   |      3 |
| MARTIN |      3 |
+--------+--------+
5 rows in set

Les membres sont entre parenthèses et séparés par une virgule, on peut mettre autant de termes qu'on veut.
Le fonctionnement pour le NOT IN est le même. Seulement, on ne prendra que les données dont la valeur du champ n'est pas dans les parenthèses.
 

SELECT ename, sal
FROM emp
WHERE sal BETWEEN 1600 AND 3000;
+---------+------+
| ename   | sal  |
+---------+------+
| ALLEN   | 1600 |
| RICARDO | 2000 |
| JONES   | 2975 |
| MARTIN  | 1650 |
+---------+------+
4 rows in set

• Une valeur NULL est une valeur inconnue
  • NULL <> 0
  • NULL = valeur non renseignée
  • On teste par IS NULL et non = NULL

Exemple : Les employés et leur département qui ont une commission NULL

SELECT ename, deptno FROM emp WHERE comm IS NULL;
+--------+--------+
| ename  | deptno |
+--------+--------+
| WARD   |      3 |
| MARTIN |      3 |
+--------+--------+
2 rows in set

 

Seulement, une colonne NULL n'est pas très pratique pour faire des calculs. C'est pourquoi chaque SGBD permet de remplacer NULL par une autre valeur. Seulement, cette fonction dépend des SGBD :

• Pour Oracle : NVL()
• Pour SQL Server : ISNULL()
• Pour PostgreSQL : COALESCE()
• Pour MySQL : IFNULL()

Dans ce tutoriel, j'utilise MySQL donc je prendrai pour exemple IFNULL().
Regardons :

SELECT ename, sal, comm, sal + comm, sal + IFNULL(comm,0) FROM emp;
+---------+-------+------+------------+----------------------+
| ename   | sal   | comm | sal + comm | sal + IFNULL(comm,0) |
+---------+-------+------+------------+----------------------+
| SMITH   |   800 | NULL | NULL       |                  800 |
| ALLEN   |  1600 | 300  |       1900 |                 1900 |
| RICARDO |  2000 | NULL | NULL       |                 2000 |
| JONES   |  2975 | 100  |       3075 |                 3075 |
| FORD    |  1300 | NULL | NULL       |                 1300 |
| KING    | 10000 | 5000 |      15000 |                15000 |
| WARD    |  1500 | NULL | NULL       |                 1500 |
| MARTIN  |  1650 | NULL | NULL       |                 1650 |
+---------+-------+------+------------+----------------------+
8 rows in set

Pratique non ?
Passons à la suite !
 

• NOT
• AND
• OR

Ils s'utilisent comme cela :

SELECT * FROM emp WHERE deptno = 1 AND sal > 1000;

Il est plus que conseillé d'utiliser des parenthèses pour "imposer" l'ordre d'exécution des opérateur logiques.
 

• Sous requête
• Jointures
• UNION (et opérations ensemblistes)

Voila, le chapitre est terminé, on passe à la suite !
 
IV - Jointures
 
Passons au point le plus marrant de ce tutoriel, et ce sera le dernier. Écoutez bien, les jointures sont des notions importantes pour bien manipuler une base de données !

En effet, les jointures vont nous permettre de mettre en corrélation plusieurs tables au sein d'une même requête, donc en économisant (si c'est bien fait) des ressources système et sans avoir besoin de traitement dans un autre langage (tel que PHP, par exemple).

Il existe trois "grandes familles" de jointures :

• Le produit cartésien
• Les jointures naturelles
• Les théta-jointures (ou équi-jointures)

Je vais tous vous les présenter, mais celui qui nous intéresse est bien évidemment le dernier.

• Le produit cartésien : Il s'agit d'une opération entre les relations qui combine toutes les occurrences. C'est à dire que le nombre de lignes du résultat est égal au produit du nombre de lignes de chacune des relations. Autrement dit, si on a une table qui contient 3 entrées, et qu'on fait un produit cartésien avec une autre table qui en contient 4, le résultat fera 12 lignes.

Exemple :

mysql> SELECT *
    -> FROM lettre,chiffre;
+--------+---------+
| lettre | chiffre |
+--------+---------+
| a      | 1       |
| b      | 1       |
| c      | 1       |
| a      | 2       |
| b      | 2       |
| c      | 2       |
| a      | 3       |
| b      | 3       |
| c      | 3       |
| a      | 4       |
| b      | 4       |
| c      | 4       |
+--------+---------+
12 rows in set

Vous avouerez que, quand on manipule de grandes bases de données, cette méthode est très gourmande en ressources et en plus, il est très probable que nous n'utilisions pas tous les résultats.

• La jointure naturelle : En fait, ce que nous allons appeler jointure peut s'apparenter à un produit cartésien suivi d'une restriction, puis d'une projection. On va combiner des relations ayant des valeurs en commun. Dès maintenant, nous allons beaucoup utiliser les alias afin de simplifier un petit peu nos requêtes. Ne soyez donc pas étonnés lorsque j'en utilise, c'est devenu une habitude.

Dès maintenant, nous utiliserons aussi la syntaxe SQL 2 qui introduit justement ces différents types de jointures. Avant, les jointures n'étaient en fait que des produits cartésiens.

Trêve de papotages futiles, voici comment s'écrit une jointure naturelle :

SELECT deptno, ename
FROM dept
NATURAL JOIN emp
-- Fonctionne sous MySQL, Oracle et PostgreSQL mais pas sous MS SQL Server

En fait, une jointure naturelle cherche des champs avec le même nom afin de les mettre en commun. C'est dangereux à utiliser si des colonnes portant le même nom ne se réfèrent pas aux mêmes données. Je vous déconseille de l'utiliser, sauf si vous êtes surs de la base de données que vous utilisez et qu'elle est bien modélisée.

• La thêta-jointure : C'est le type de jointure le plus souvent utilisé. Nous sommes vraiment maîtres de ce que l'on recherche. La syntaxe est simple à comprendre :

-- Nom et salaire des employés gagnant plus que l'employé 7566
SELECT e1.ename, e1.sal
FROM emp e1
JOIN emp e2 ON e1.sal > e2.sal -- On fait la jointure avec la condition
WHERE e2.empno = 7566

Plutôt simple non ?

Pour l'équi-jointure, c'est le même principe, juste la condition change !

-- On cherche le nom de chaque employé avec le nom de son département
SELECT e.ename, d.dname
FROM emp e
JOIN dept d ON e.deptno=d.deptno

Alors, convaincus ? Ne vous inquiétez pas, j'ai bientôt fini ! Je vous présente juste une dernière notion

• Left/right join : En fait, une jointure élimine par défaut les résultats ou il n'y a pas de correspondance (exemple, si un employé n'a pas de département, il ne sera pas affiché). Pour pallier ce problème, il faut dire à SQL de garder les champs à gauche, même si il n'y a pas de correspondance.

Exemple :

mysql> SELECT ename, e.deptno, dname
    -> FROM emp e
    -> LEFT JOIN dept d ON e.deptno=d.deptno;
+---------+--------+--------------+
| ename   | deptno | dname        |
+---------+--------+--------------+
| JONES   |      2 | Recherche    |
| FORD    |      3 | Comptabilité |
| WARD    |      3 | Comptabilité |
| MARTIN  |      3 | Comptabilité |
| SMITH   |      4 | Support      |
| ALLEN   |      4 | Support      |
| KING    |      6 | HeadOffice   |
| RICARDO | NULL   | NULL         |
+---------+--------+--------------+
8 rows in set

Ici, on a dit : "Même si il n'y a pas de correspondance, tu gardes les membres étant à gauche (LEFT) de la jointure" et Ricardo est apparu. C'est exactement le même principe pour RIGHT, tout dépend de comment vous construisez vos requêtes.

Voilà, je pense avoir fait le tour pour ce tutoriel. N'hésitez pas à réagir, contester, demander des éclaircissements...

Bon courage dans vos requêtes SQL

Merci d'avoir lu,
Pirkoa

Je me lance dans une petite série de plusieurs tutoriels qui, je l'espère, serviront à beaucoup d'entre vous.

Pour ne rien vous cacher, j'utilise mes cours comme support en essayant de rester clair, et concis dans tout ce que j'explique.

Dans ce sujet, je vais vous présenter le SQL en général, ses principes, son historique, et aussi les SGBD, nous verrons ce que c'est, et à quoi ça sert. De plus, je vous donnerai des pistes afin de choisir le SGBD qui vous correspond.

Vous êtes prêts ? C'est parti !

I - Définition :

SQL signifie Structured Query Language, ou langage structuré de requêtes.

C'est un langage pseudo-informatique (de type requête) standard et normalisé. C'est à dire que l'on peut l'utiliser sur plusieurs systèmes différents, la syntaxe sera toujours (à peu près) la même.

Le SQL est destiné à interroger où à manipuler une base de données relationnelle.

II - Principes :

Le SQL est fondé sur la logique des prédicats, et le modèle relationnel. De plus, c'est un langage non procédural, il permet d'avoir un résultat sans spécifier l'ordre d'exécution des différentes opérations, comme on pourrait le faire en PHP par exemple. C'est un langage ensembliste, c'est à dire qu'il travaille sur des ensembles de données.

Au final, une requête SQL est équivalente à une suite d'opérations qui sont en relation.

Il faut aussi noter que SQL est une norme depuis 1986.

Pour rentrer un peu plus dans le sujet, le SQL se compose de 5 parties :

• Les ordres LDD (langage de définition des données) : Ce sont tous les ordres qui permettent de modifier la structure de la base de données.
• Les ordres LMD (langage de manipulation des données) : Ce sont les ordres qui permettent de consulter, ou de modifier le contenu de la base de données
• Les ordres LCD (langage de contrôle des données) : Ce sont tous les ordres qui servent à gérer les utilisateurs et les privilèges, ainsi que les actions qu'ils peuvent entreprendre
• Les ordres LCT (langage de contrôle des transactions) : C'est ce qui permet de gérer les transactions, c'est à dire rendre automatiques certains ordres enchaînés (des séquences, si vous préférez)
• Le SQL procédural : Ensemble d'outils pour que le SQL s'interface correctement avec des langages hôtes (PSM , CLI, Embedded SQL, ... )

III - Historique :

Je ne vous aurai pas laissé filer dans un petit bout d'historique voyons !

Voici les différents stades du langage SQL, qui sont importants à connaître :

• SQL86 - SQL89 ou encore SQL1 :  C'est la référence de base,
  • Requêtes compilées puis exécutées depuis un programme d'application
  • 4 types de données simples (entiers, réels, chaînes de taille fixes)
  • Opérations ensemblistes restreintes (uniquement le UNION)
• SQL92 ou SQL2 : Le standard actuel
  • Requêtes dynamiques
  • Types de données plus riches (intervalles, dates, chaînes de traille variables, ...)
  • Différents types de jointures (naturelle et externe) contre le produit cartésien uniquement en SQL1
  • Opérations ensemblistes : différence (EXCEPT), Intersection (INTERSECT)
  • Renommage des attributs dans un SELECT
• SQL99 ou SQL3 : SQL devient un langage de programmation
  • Extensions orientées-objet
  • Types structurés
  • BLOB, CLOB
  • Récusrivité

Il faut savoir que je parlerai dans mes différents tutos uniquement de SQL2, qui reste le SQL le plus utilisé (non orienté-objet).

Maintenant que nous savons tout ça, c'est bien, mais comment choisir le système qui gérera ma base de données ?

IV - Les SGBD :

• Un SGBD (Système de Gestion de Bases de Données) est un outil informatique permettant de définir, stocker, consulter, modifier et protéger les données de la base.

Il existe de nombreux SGBD, comment choisir le bon ? Que peut-on attendre d'un bon SGBD ?

• Assurer un accès simple, rapide et uniforme aux données de chaque utilisateur
• Faciliter les tâches d'administration des données
• Garantir l'intégrité, la sécurité, la confidentialité des données stockées
• Diminuer le temps de développement des applications qui utilisent ces données
• Être tolérant aux pannes matérielles et logicielles

Voila les principaux points. Je vais vous donner maintenant les principaux SGBD relationnels :

• MySQL (libre)
• Oracle (payant, mais beaucoup utilisé)
• PostgreSQL (libre)
• Microsoft SQL Server
• Ingres
• IBM DB2 (Un peu vieux)
• SQLite (libre)
• Microsoft Access (Soyons fous !)
• ...

Pour donner mon avis perso sur quel est le meilleur SGBD, je dirai que tout dépend de votre besoin.

Beaucoup se précipitent sur MySQL, pensant que c'est LA solution. A ceux-ci, je leur dirai que non, car MySQL est loin d'être le plus complet des SGBD, il y a beaucoup d'instrucitons que MySQL ne gère pas directement (il faut réfléchir un petit peu pour avoir ce qu'on veut). PostgreSQL est très bien et très complet. Il a aussi l'avantage d'être gratuit et fidèle à SQL2.

Sinon, si vous êtes une entreprise (sait-on jamais), Oracle reste la meilleure solution.

Voila, j'ai fini cette petite introduction au SQL relationnel, n'hésitez pas à réagir, commenter, critiquer...

Le prochain chapitre portera sur le SELECT, sous toutes les formes (en passant par les jointures ! )

A très vite,

Pirkoa !

mysqldump -u root --password=mot_de_passe bdd > dump.sql 

Vous l'aurez compris, il suffit de remplacer root par son nom d'utilisateur, mot_de_passe par son mot de passe, bdd par sa base de donnée existante et dump.sql sera le nom de votre fichier.

j'avais fais un beau tuto bien long et bien expliqué mais je me suis fail et tout a disparu en enfer... D:

Donc je fais une version abrégée, le mySQL est différent des autres oui, par exemple cette saloperie de SQLite ne prend pas le caractère " ` " pour isoler les variables même si il n'est pas obligatoire de plus certaines fonctions ne sont pas disponible. bref mySQL c'est bien et gratuit. ^-^

je vais pas refaire tout un truc sur la structure... il était tellement bien mon autre tuto disparu :'(

la structure de la commande se compose d'une action, une cible, de valeur(s)(optionnel), de condition(s)(optionnel), d'un ordre(optionnel) et une limite(optionnel).

exemple pour un ajout on utilise: une action, une cible et des valeurs::

#syntaxe: INSERT INTO [CIBLE] ([VARIABLE(S)]) VALUES([VALEURS]);
INSERT INTO `ma_table` (`texte`, `chiffre`) VALUES('Coucou', 123);

- la "cible" c'est la table que vous voulez affecter vous pouvez la sélectionner aussi à travers une db (ex: `db_forum`.`ma_table`).

- les variables sont les noms des colonnes dans votre table.

- les valeurs sont les valeurs (._.) que vous donnez aux variables.

> Documentation Mysql::INSERT

si la valeur est un chiffre vous n'êtes pas obligé de mettre de guillemets mais si vous désirez mettre un guillemet dans une phrase vous devait mettre un anti-slash devant (ex: 'C\'est bon le chocolat!').

il existe une syntaxe où vous n'êtes pas obligé de donner le nom des variables mais alors vous devez donner les valeurs pour toutes les variables dans l'ordre.

#dans le contexte il y a une variable guid qui sert d'index et l'ordre est: guid, texte, chiffre
INSERT INTO `ma_table` VALUES(NULL, 'Coucou', 123);

EDIT: je viens de me relire après ~8mois et je viens de voir que je n'ai pas indiqué comment ajouter plusieurs lignes en une commande, c'est simple il suffit de mettre une virgule entre les paquets de valeurs (les parenthèses).

Ce qui donne:

#syntaxe: INSERT INTO [CIBLE] ([VARIABLE(S)]) VALUES([VALEURS]);
INSERT INTO `ma_table` (`texte`, `chiffre`) VALUES('Coucou', 123), ('tu veux?', 456);

maintenant pour modifier des variables: action, cible, variables, nouvelles valeurs, limite (non obligatoire mais c'est une petite sécurité)::

#syntaxe: UPDATE [CIBLE] SET [VARIABLES] = [VALEURS] WHERE [CONDITION] LIMIT 1
#dans le contexte notre commande précédente, a affecté la valeur 58 à `guid`
UPDATE `ma_table` SET `texte` = 'Au revoir', `chiffre` = (`chiffre` + 250) WHERE `guid`= 58 LIMIT 1;

> Documentation Mysql::UPDATE

pour bien illustrer le "WHERE" dans mon exemple précédent je vais vous expliquer le "SELECT" (la sélection, impressionnant non?), la syntace:

SELECT [COLONNE] FROM [CIBLE] WHERE [CONDITION] ORDER BY [ORDRE] LIMIT [LIMIT];

-[CIBLE] : La table dans la quelle vous désirez faire votre recherche.

-[CONDITION] : La condition pour que la donnée soit sélectionnée.

-[ORDRE] : Ordre croissant (ASC) ou décroissant (DESC).

-[LIMIT] : La limite de la sélection.

> Documentation Mysql::SELECT

Premier exemple, nous allons sélectionner l'utilisateur dont l' "ID" est 169 dans une table du nom de "users":

SELECT * FROM `users` WHERE `ID` = 169 LIMIT 1;

maintenant nous allons faire un truc un peu plus compliqué, nous allons chercher dans une table du nom de "news" si le mot "patate" est présent dans la colonne "title" (titre) ou "content" (le contenu) et nous allons récupérer que le titre, le contenu et sont "guid" (qui correspond à son numéro d'index dans la table) dans l'ordre croissant selon le titre, mais vous vous dites pour trouver le mot ça va être compliqué non en faite regardez :

SELECT `guid`, `title`, `content` FROM `news` WHERE (`title` LIKE '%patate%') OR (`cotent` LIKE '%patate%`) ORDER BY `title` ASC;

il y a aussi l’apparition du "OR" qui signifie "ou", je dis donc à la requête que c'est ça ou ça pour être sélectionné, je mets des parenthèses pour bien séparer les conditions, vous pouvez aussi mettre un "AND" ("et" en français) si vous désirez que les deux conditions soient remplies.

pour un peu mieux illustrer l'exemple au dessus je vais le "traduite" dans un langage plus un langage plus "humain":

Sélectionne le `guid`, `title`, `content` dans les `news` où dans le `title` ressemble à '[n'importe]patate[n'importe]' ou dans le `content` si il y a une ressemblance à '[n'importe]patate[n'importe]' dans l'ordre de `title` en croissant.

maintenant la suppression <3

rien de plus simple de mettre fin aux jours de sa création,

comme exemple je vais reprendre l'exemple de l'users 169 ci-dessus et vu qu'il est méchant on va le supprimer:

#content: l'user (utilisateur) dont le `guid` (numéro index unique donné) est 169 est méchant donc on le supprime.
#syntaxe: DELETE FROM [CIBLE] WHERE [CONDITION];
DELETE FROM `users` WHERE `guid`= 169 LIMIT 1;

Le "LIMIT 1" est présent non pas pour hygiène mais par sécurité car une faute de syntaxe et vous risquez de grave perte si vous ne mettez pas de conditions c'est tout le mode qui disparait.

> Documentation Mysql::DELETE

La remise à zéro, la commande "DELETE" c'est bien mais la commande "TRUNCATE" c'est mieux, quand vous utilisez la commande "DELETE" si votre table à un ou plusieurs index il(s) reste(nt) marqué(s) donc si vous voulez tout effacer et repartir à zéro (0) vous devez utiliser la commande "TRUNCATE":

#context: vous avez un vieux site et vous désire l'utiliser avec ses dbs mais ils y a plein de vieux users à supprimer.
#syntaxe: TRUNCATE TABLE [CIBLE]
TRUNCATE TABLE `cible`;

> Documentation Mysql::TRUNCATE

Je pense avoir expliquer les commandes le plus utilisés, je ferais un autre topic sur la gestion des tables elle même, les comptes mysql et autre si j'en ai le courage x')

Bonne programmation à tous même si je considère par le SQL comme de la prog,

Mars073.

Je viens de découvert ce site : http://sql.sh/. Jetez un coup d’œil, c'est vraiment sympa.

Pour info, voici les objectifs de l'équipe administrant ce site :

Les objectifs sont multiples. L'idéal serait que SQL.sh devienne la référence française pour apprendre le SQL. Pour cela, l'objectif primaire consiste à étoffer le contenu en particulier sur les fonctions SQL et sur quelques commandes SQL assez spécifiques (exemple : la commande EXPLAIN ). Le second objectif consistera à proposer non plus des fiches pour comprendre une commande de SQL, mais des cours avancés pour résoudre une problématique bien précise ou mieux pour apprendre comment bien paramétrer un serveur afin d'améliorer les performances du Système de Gestion de Base de Données (SGBD).

 

Voilà.

je vais vous faire cette fois un topic sur les tables en elle même.

Commençons par la création (le début des temps lulz), connaître ces scripts devient presque obsolète vu les programmes et api disponiblent maintenant mais bon ça peut toujours servir:

#syntaxe: CREATE TABLE [NOM] ([VARIABLES+TYPE+PARAMÈTRES])[PARAMÈTRES SUPPLEMENTAIRES];
CREATE TABLE `ma_table` (
	`texte` text NOT NULL,
	`chiffre` int(10) unsigned NOT NULL,
);

- [NOM] = `ma_table` : C'est simplement le nom que vous voulez donner à votre table

- [VARIABLES] : Vous devez donner le nom de la variable/colonne, sont type (chiffre, texte, date, ..) la longueur qu'il doit faire, etc.

- [PARAMÈTRES SUPP] : paramètre de la table j'en montrerais dans les exemples suivants

au niveau des type de variables vous avez: >doc

- tinyint : chiffre entier (de -128 à 127)

- smallint : chiffre entier (de -32768 à 32767)

- mediumint : chiffre entier (de -8388608 à 8388607)

- int : chiffre entier (de -2147483648 à 2147483647)

- bigint : chiffre entier (de -9223372036854775808 à 9223372036854775807)

- float, decimal, double: pour faire simple on va dire chiffre à virgule

- bit: chiffre en binaire (ex: 10110010110100100100...)

- binary et varbinary : un peut comme bit sauf que la limite attribuée maximale est de 255 bits

- date : Attention c'est la date dans le format mysql uniquement (AAAA-MM-JJ), c'est la norme rfc-machin, ex: 1996-06-21

- time : une heure dans le format standard (HH:MM:SS), ex: 20:32:51

- datetime : le format de "date" et "time" séparé par un espace, ex: 199-06-21 20:32:51

- year : l'année en 4 chiffres, ex: 1996 ou 0666

- char : chaîne de caractères de maximum de 255 caractères (ex: "blsdkngki jsngkj rn1121 dgd")

- varchar : similaire à "char" sauf dans le fait que "char" considère les cratères vides comme un espaces jusqu'au comment où il arrive à la limite et oui char peut être avantageux au niveau d'utilisation de fonction par exemple

- text (tinytext, text, mediumtext et longtext) : simplement de text, je pense que la limite est dynamique malgré ses autres types qui peut changer la consommation de mémoire à mon avis, je regarderais quand j'aurais le temps.

- enum : liste de possibilité définie à la place de la limite.

- set : similaire à "enum" sauf que plusieurs possibilités peuvent être attribuées à la varible.

normalement toute on utilise pour toutes ses variables un limite de caractère (sauf text), on définie celle-ci entre parenthèses à la suite du type, exemple un "int" a une limite par défaut de 10:

`chiffre` int(10) ...

`chiffre2` float(3, 2) ...

`fruit` enum("fraise", "pomme", "cranberrys") ...

maintenant on va ajouter des paramètres à nos variables avec une valeur par défaut, une auto-incrémentation (A_I), ou déclarer comme

... en cours de rédaction, c'est long et chiant ...