Comment créer une base de données dans un environnement SQL Server. SQL - qu'est-ce que c'est, à quoi sert le langage et fonctions de base pour les débutants
Dernière mise à jour : 07/09/2017
Pour créer des tables, utilisez la commande CREATE TABLE. Vous pouvez utiliser un certain nombre d'opérateurs avec cette commande qui définissent les colonnes du tableau et leurs attributs. De plus, vous pouvez utiliser un certain nombre d'opérateurs qui déterminent les propriétés de la table dans son ensemble. Une base de données peut contenir jusqu'à 2 milliards de tables.
La syntaxe générale de création d'un tableau est la suivante :
CREATE TABLE nom_table (nom_colonne1 type_données attributs_colonne1, nom_colonne2 type_données attributs_colonne2, ..................................... . ......... nom_colonneN type_données attributs_colonneN, attributs_table)
Après la commande CREATE TABLE vient le nom de la table en cours de création. Le nom de la table fait office d'identifiant dans la base de données, il doit donc être unique. Le nom ne doit pas comporter plus de 128 caractères. Le nom peut être composé de caractères alphanumériques, ainsi que des caractères $ et de trait de soulignement. De plus, le premier caractère doit être une lettre ou un trait de soulignement.
Le nom de l'objet ne peut pas inclure d'espaces et ne peut pas représenter l'un des mots clés Transact-SQL. Si l'identifiant contient des espaces, il doit être placé entre guillemets. S'il est nécessaire d'utiliser des mots-clés comme nom, alors ces mots sont placés entre crochets.
Exemples d'identifiants corrects :
Tags utilisateurs 345 $ users_accounts "comptes utilisateurs"
Après le nom de la table, les paramètres de toutes les colonnes sont indiqués entre parenthèses et, à la toute fin, les attributs qui s'appliquent à l'ensemble de la table. Les attributs de colonne et les attributs de table sont des composants facultatifs et peuvent être omis.
Dans sa forme la plus simple, la commande CREATE TABLE doit contenir au minimum le nom de la table ainsi que les noms et types de colonnes.
Un tableau peut contenir de 1 à 1024 colonnes. Chaque colonne doit avoir un nom unique dans la table actuelle et se voir attribuer un type de données.
Par exemple, en définissant la table Clients la plus simple :
CREATE TABLE Clients (Id INT, Age INT, FirstName NVARCHAR(20), LastName NVARCHAR(20), Email VARCHAR(30), Phone VARCHAR(20))
Dans ce cas, six colonnes sont définies dans la table Clients : Id, Prénom, Nom, Âge, Email, Téléphone. Les deux premières colonnes représentent l'ID et l'âge du client et sont de type INT, ce qui signifie qu'elles stockeront des valeurs numériques. Les deux colonnes suivantes représentent le prénom et le nom du client et sont de type NVARCHAR(20) , ce qui signifie qu'elles représentent une chaîne UNICODE de 20 caractères maximum. Les deux dernières colonnes Email et Phone représentent l'e-mail et le téléphone du client et sont de type VARCHAR(30/20) - elles stockent également une chaîne, mais pas en codage UNICODE.
Création d'une table dans SQL Management Studio
Créons une table simple sur le serveur. Pour ce faire, ouvrez SQL Server Management Studio et cliquez avec le bouton droit sur le nom du serveur. Dans le menu contextuel qui apparaît, sélectionnez Nouvelle requête.
La table est créée dans la base de données actuelle. Si nous lançons la fenêtre de l'éditeur SQL comme ci-dessus - sous le nom du serveur, alors la base de données par défaut n'est pas installée. Et pour l'installer, vous devez utiliser la commande USE, suivie du nom de la base de données. Par conséquent, nous saisissons les expressions suivantes dans le champ de l'éditeur de commandes SQL :
UTILISER la base de données d'utilisateurs ; CREATE TABLE Clients (Id INT, Age INT, FirstName NVARCHAR(20), LastName NVARCHAR(20), Email VARCHAR(30), Phone VARCHAR(20)) ;
Autrement dit, la table Customers, évoquée précédemment, est ajoutée à la base de données.
Vous pouvez également ouvrir l'éditeur sous la base de données en cliquant dessus avec le bouton droit et en sélectionnant Nouvelle requête :
Dans ce cas, la base de données à partir de laquelle l'éditeur a été ouvert sera considérée comme la base actuelle et il ne sera pas nécessaire de l'installer en plus à l'aide de la commande USE.
Suppression de tableaux
Pour supprimer des tables, utilisez la commande DROP TABLE, qui a la syntaxe suivante :
DROP TABLE table1 [, table2, ...]
Par exemple, en supprimant la table Clients :
Clients de DROP TABLE
Renommer une table
Pour renommer les tables, utilisez la procédure stockée système « sp_rename ». Par exemple, renommer la table Users en UserAccounts dans la base de données usersdb :
UTILISER la base de données d'utilisateurs ; EXEC sp_rename "Utilisateurs", "Comptes utilisateurs" ;
Avant de pouvoir créer une table SQL, vous devez définir le modèle de base de données. Concevez un diagramme ER dans lequel définir les entités, les attributs et les relations.
Concepts de base
Les entités sont des objets ou des faits sur lesquels des informations doivent être stockées. Par exemple, un employé d'une entreprise ou des projets mis en œuvre par l'entreprise. Les attributs sont des composants qui décrivent ou qualifient une entité. Par exemple, l'attribut de l'entité « employé » est le salaire, et l'attribut de l'entité « projet » est le coût estimé. Les connexions sont des associations entre deux éléments. Cela peut être bidirectionnel. Il existe également une connexion récursive, c'est-à-dire la connexion d'une entité avec elle-même.
Il est également nécessaire de déterminer les clés et les conditions dans lesquelles l'intégrité de la base de données sera maintenue. Qu'est-ce que ça veut dire? En d’autres termes, des restrictions qui permettront de conserver les bases de données sous une forme correcte et cohérente.
Transition du diagramme ER au modèle tabulaire
Règles de transition vers un modèle tabulaire :
- Convertissez toutes les entités en tables.
- Convertissez tous les attributs en colonnes, c'est-à-dire que chaque attribut d'entité doit apparaître dans le nom de la colonne du tableau.
- Convertissez les identifiants uniques en clés primaires.
- Convertissez toutes les relations en clés étrangères.
- Créez la table SQL.
Création d'une base de données
Vous devez d'abord démarrer le serveur MySQL. Pour le lancer, allez dans le menu "Démarrer", puis dans "Programmes", puis dans MySQL et MySQL Server, sélectionnez MySQL-Command-Line-Client.
Pour créer une base de données, utilisez la commande Créer une base de données. Cette fonction a le format suivant :
CRÉER UNE BASE DE DONNÉES nom_base de données.
Les restrictions sur le nom de la base de données sont les suivantes :
- la longueur peut aller jusqu'à 64 caractères et peut inclure des lettres, des chiffres, des symboles "" et "" ;
- le nom peut commencer par un chiffre, mais il doit contenir des lettres.
Vous devez rappeler la règle générale : toute requête ou commande se termine par un délimiteur. En SQL, il est courant d'utiliser un point-virgule comme délimiteur.
Le serveur doit indiquer avec quelle base de données il devra travailler. Il existe une instruction USE pour cela. Cet opérateur a une syntaxe simple : USE n nom_base de données.
Création d'une table SQL
Ainsi, le modèle est conçu, la base de données est créée et le serveur sait exactement comment l'utiliser. Vous pouvez maintenant commencer à créer des tables SQL. Il existe un langage de définition de données (DDL). Il est utilisé pour créer une table MS SQL, ainsi que pour définir des objets et travailler avec leur structure. DDL comprend un ensemble de commandes.
Création de table SQL Server
En utilisant une seule commande DDL, vous pouvez créer divers objets de base de données en faisant varier ses paramètres. La commande Créer une table est utilisée. Le format tt ressemble à ceci :
CRÉER UNE TAILLE nom_table,(nom_colonne1 Nom _colonne2 type de données [column_constraint], [table_constraints]).
La syntaxe de cette commande doit être décrite plus en détail :
- Le nom de la table doit comporter jusqu'à 30 caractères et commencer par une lettre. Seuls les caractères alphabétiques, les lettres et les symboles "_", "$" et "#" sont autorisés. L'utilisation de l'alphabet cyrillique est autorisée. Il est important de noter que les noms de tables ne doivent pas être identiques aux autres noms d'objets ou aux mots réservés au serveur de base de données tels que Colonne, Table, Index, etc.
- Vous devez spécifier un type de données pour chaque colonne. Il existe un ensemble de normes utilisées par la plupart. Par exemple, Char, Varchar, Number, Date, type Null, etc.
- Le paramètre Default vous permet de définir une valeur par défaut. Cela garantit qu'il n'y a pas de valeurs nulles dans le tableau. Comment comprendre cela ? La valeur par défaut peut être un symbole, une expression, une fonction. Il est important de se rappeler que ce type de données par défaut doit correspondre au type de données d'entrée de la colonne.
- Les contraintes sur chaque colonne sont utilisées pour appliquer des conditions d'intégrité pour les données au niveau de la table. Il y a d'autres nuances. Il est interdit de supprimer une table si d'autres tables en dépendent.
Comment travailler avec la base de données
Les grands projets nécessitent souvent la création de plusieurs bases de données, chacune nécessitant de nombreuses tables. Bien entendu, il est impossible pour les utilisateurs de conserver toutes les informations dans leur tête. Pour ce faire, il est possible de visualiser la structure des bases de données et des tables qu'elles contiennent. Il existe plusieurs commandes, à savoir :
- AFFICHER LES BASES DE DONNÉES - affiche toutes les bases de données SQL créées à l'écran ;
- SHOW TABLES - affiche une liste de toutes les tables de la base de données actuelle sélectionnées par la commande USE ;
- DÉCRIRE nom_table- affiche une description de toutes les colonnes du tableau.
- ALTER TABLE - vous permet de modifier la structure de la table.
La dernière commande permet :
- ajouter une colonne ou une contrainte à une table ;
- modifier une colonne existante ;
- supprimer une ou plusieurs colonnes ;
- supprimer les contraintes d’intégrité.
La syntaxe de cette commande est : ALTER TABLE nom_table( | | | | [(ACTIVER | DÉSACTIVER) CONSTANTE nom_contrainte ] | }.
Il existe d'autres commandes :
- RENAME - renommez la table.
- TRUNCATE TABLE - supprime toutes les lignes de la table. Cette fonction peut être nécessaire lorsqu'il est nécessaire de remplir à nouveau le tableau, mais il n'est pas nécessaire de stocker les données précédentes.
Il existe également des situations où la structure de la base de données a changé et la table doit être supprimée. Il existe une commande DROP pour cela. Bien entendu, vous devez d'abord sélectionner la base de données dans laquelle vous souhaitez supprimer la table, si elle est différente de celle actuelle.
La syntaxe de la commande est assez simple : DROP TABLE Nom_tables.
Dans SQL Access, les tables sont créées et modifiées à l'aide des mêmes commandes répertoriées ci-dessus.
En utilisant CREATE TABLE, vous pouvez créer une table vide puis la remplir de données. Mais ce n'est pas tout. Vous pouvez également créer directement une table à partir d'une autre table. Comment ça ? Autrement dit, il est possible de définir une table et de la remplir avec les données d'une autre table. Il existe un mot-clé spécial AS pour cela.
La syntaxe est très simple :
- CRÉER UN TABLEAU Nom_tables[(définition_colonne)] Sous-requête AS ;
- définition_colonne - noms de colonnes, règles d'intégrité pour les colonnes de table nouvellement créées et valeurs par défaut ;
- sous-requête - renvoie les lignes qui doivent être ajoutées à la nouvelle table.
Ainsi, une telle commande crée une table avec certaines colonnes, y insère des lignes qui sont renvoyées dans la requête.
Tableaux temporaires
Les tables temporaires sont des tables dont les données sont effacées à la fin de chaque session ou avant. Ils servent à enregistrer des valeurs ou des résultats intermédiaires. Ils peuvent être utilisés comme feuilles de travail. Vous pouvez en définir des temporaires dans n'importe quelle session, mais vous ne pouvez utiliser leurs données que dans la session en cours. La création de tables SQL temporaires est similaire aux tables classiques, à l'aide de la commande CREATE TABLE. Afin de montrer au système que la table est temporaire, vous devez utiliser le paramètre GLOBAL TEMPORARY.
La clause ON COMMIT définit la durée de vie des données dans une telle table et peut effectuer les opérations suivantes :
- DELETE ROWS - effacez la table temporaire (supprimez toutes les données de session) après la fin de chaque transaction. Il s'agit généralement de la valeur par défaut.
- PRÉSERVER LES LIGNES - laissez les données pour les utiliser lors de la prochaine transaction. De plus, vous ne pouvez vider la table qu'après la fin de la session. Mais il y a quelques particularités. Si une transaction est annulée (ROLLBACK), la table reviendra à son état à la fin de la transaction précédente.
La syntaxe de création d'une table temporaire peut être représentée comme suit : CREATE TABLE Nom_tableaux,(Nomcolonne_1 type de données [column_constraint], Nom _colonne2 type de données [column_constraint], [table_constraints]).
Jusqu'à présent, nous avons interrogé des tables de données et exécuté des commandes pour récupérer ces données, en supposant que ces tables avaient déjà été créées par quelqu'un avant nous. Il s'agit en effet de la situation la plus réaliste dans laquelle un petit nombre de personnes créent des tables qui sont ensuite utilisées par d'autres personnes. Notre objectif est d’abord de couvrir l’information de manière plus large, puis de passer à des questions plus spécifiques.
Dans ce chapitre, nous aborderons la création, la modification et la suppression de tables. Tout cela s'applique aux tables elles-mêmes, et non aux données qu'elles contiennent. Que vous effectuiez ou non ces opérations vous-même, une compréhension conceptuelle de celles-ci augmentera votre compréhension du langage SQL et de la nature des tables que vous utilisez. Ce chapitre nous présente un domaine de SQL appelé DDL (Data Definition Language), où sont créés les objets de données SQL.
Ce chapitre montrera également un autre type d'objet de données SQL : l'index. Les index sont utilisés pour rendre la recherche plus efficace et, parfois, pour faire différer les valeurs les unes des autres. Ils fonctionnent généralement sans que vous vous en rendiez compte, mais si vous essayez de mettre des valeurs dans une table et qu'elles sont rejetées parce qu'elles ne sont pas uniques, cela signifie qu'une autre ligne a la même valeur pour ce champ et que ce champ a un index unique. ou une contrainte qui dicte son unicité. La discussion de ce qui précède se poursuivra au chapitre 18.
COMMANDE DE CRÉATION DE TABLE
Les tables sont créées avec la commande CREATE TABLE. Cette commande crée une table vide – une table sans lignes. Les valeurs sont saisies à l'aide de la commande DML INSERT (Voir Chapitre 15). La commande CREATE TABLE définit essentiellement des tables en décrivant un ensemble de noms de colonnes spécifiés dans un ordre spécifique. Il définit également les types de données et la taille des colonnes. Chaque tableau doit avoir au moins une colonne.Syntaxe de la commande CREATE TABLE : CREATE TABLE
Étant donné que les espaces sont utilisés pour séparer les parties d'une commande SQL, ils ne peuvent pas faire partie du nom d'une table (ou de tout autre objet, tel qu'un index). Le trait de soulignement (_) est couramment utilisé pour séparer les mots dans les noms de tableaux.
La valeur de l'argument size dépend du type de données. Si vous ne le précisez pas, votre système attribuera automatiquement la valeur. Pour les valeurs numériques, c'est la meilleure solution, car dans ce cas, tous vos sols de ce type auront la même dimension, vous libérant ainsi des problèmes de compatibilité globale (voir chapitre 14). De plus, utiliser l’argument size avec certains ensembles numériques n’est pas vraiment simple. Si vous devez stocker un grand nombre de personnes, vous devrez sans doute veiller à ce que le sol soit suffisamment grand pour les accueillir.
Un type de données auquel vous devez principalement attribuer une taille est CHAR. L'argument size est un entier qui spécifie le nombre maximum de caractères que le champ peut contenir. En fait, le nombre de caractères dans le champ peut aller de zéro (si le champ est NULL) à ce nombre. Par défaut, l'argument taille est 1, ce qui signifie que le champ ne peut contenir qu'une seule lettre. Bien sûr, ce n’est pas exactement ce que vous souhaitez.
Les tables appartiennent à l'utilisateur qui les a créées, et les noms de toutes les tables appartenant à un utilisateur donné doivent être différents les uns des autres, ainsi que les noms de toutes les colonnes d'une table donnée. Des tables distinctes peuvent utiliser les mêmes noms de colonnes, même si elles appartiennent au même utilisateur. Un exemple de ceci est la colonne ville dans la table Clients et dans la table Vendeurs. Les utilisateurs qui ne sont pas propriétaires de tables peuvent faire référence à ces tables en utilisant le nom du propriétaire de la table suivi d'un point ; par exemple, la table Employés créée par Smith s'appellera Smith.Employees lorsqu'elle est mentionnée par un autre utilisateur (nous comprenons que Smith est l'identifiant d'autorisation (ID). (ID) signalé par l'utilisateur (votre ID résolu est votre nom en SQL. Cette sortie est discutée au chapitre 2 et sera continuée au chapitre 22).
Cette commande créera la table Salespeople : CREATE TABLE Saleepeople (snum integer, sname char (10), city char (10), comm declmal) ; L'ordre des colonnes du tableau est déterminé par l'ordre dans lequel elles sont répertoriées. Les colonnes ne doivent pas être séparées par celles-ci lors des sauts de ligne (ce qui est fait pour des raisons de lisibilité), mais séparées par des virgules.
INDICES
Un index est une liste ordonnée (alphabétique ou numérique) de colonnes ou de groupes de colonnes dans un tableau. Les tableaux peuvent comporter un grand nombre de lignes et, comme les lignes ne sont pas classées dans un ordre particulier, la recherche d'une valeur spécifiée peut prendre du temps. L'adresse d'index est à la fois une préoccupation et permet en même temps de regrouper toutes les valeurs en groupes d'une ou plusieurs chaînes différentes les unes des autres. Au chapitre 18, nous décrirons une manière plus directe de forcer vos valeurs à être uniques. Mais cette méthode n’existe pas dans les versions antérieures de SQL. L’unicité étant souvent nécessaire, des index ont été utilisés à cette fin.Les index sont un outil SQL issu du marché lui-même, et non de l'ANSI. Par conséquent, la norme ANSI elle-même ne prend actuellement pas en charge les index, bien qu’ils soient très utiles et largement utilisés.
Lorsque vous créez un index sur un champ, votre base de données mémorise l'ordre correspondant de toutes les valeurs de ce champ dans une zone mémoire. Supposons que notre table Clients contienne des milliers d'entrées et que vous souhaitiez trouver un client avec le numéro = 2999. Comme les lignes ne sont pas ordonnées, votre programme parcourra toute la table, ligne par ligne, en vérifiant à chaque fois que la valeur du champ cnum est égale à la valeur 2999. Cependant, s'il y avait un index sur le champ cnum, alors le Le programme pourrait atteindre le nombre 2999 directement à partir de l'index et donner des informations sur la façon de trouver la bonne ligne du tableau.
Bien qu'un index améliore considérablement l'efficacité des requêtes, son utilisation rend les opérations de modification DML (telles que INSERT et DELETE) un peu plus lentes et l'index lui-même occupe beaucoup de mémoire. Par conséquent, chaque fois que vous créez une table, vous devez décider si vous souhaitez l'indexer ou non. Les index peuvent être constitués de plusieurs champs. Si plusieurs champs sont spécifiés pour le même index, le deuxième est classé dans le premier, le troisième dans le second, et ainsi de suite. Si vous aviez le prénom et le nom dans deux champs différents d'une table, vous pourriez créer un index qui trierait le champ précédent dans le suivant. Cela peut être fait quelle que soit la manière dont les colonnes du tableau ont été disposées.
La syntaxe de création d'un index est généralement la suivante (rappelez-vous qu'il ne s'agit pas d'une norme ANSI) : CREATE INDEX Heureusement, il n’est pas nécessaire que l’index de l’exemple précédent soit unique, malgré notre observation selon laquelle c’est l’un des objectifs de l’index. Un vendeur donné peut avoir n’importe quel nombre de clients. Cependant, cela n'arrivera pas si nous utilisons le mot-clé UNIQUE avant le mot-clé INDEX. Le champ cnum, en tant que clé primaire, sera le premier candidat pour un index unique : CREATE UNIQUE INDEX Custid ON Customers (cnum) ; REMARQUE : cette commande sera rejetée s'il y a déjà des valeurs identiques dans le champ cnum. La meilleure façon de gérer les index est de les créer immédiatement après la création de la table et avant la saisie de valeurs. Notez également que, pour un indice unique de plus d’un sexe, il s’agit d’une combinaison de valeurs, dont chacune peut ne pas être unique.(
CRÉER UN INDEX Groupe de clients SUR Clients (snum); Désormais, le vendeur lié à cette table pourra trouver très rapidement sa propre clientèle.
CARACTÉRISTIQUE DE L'INDICE L'exemple précédent est une manière indirecte de faire en sorte que le champ cnum fasse office de clé primaire de la table Customers. Les bases de données agissent plus directement sur les clés primaires et autres. Nous discuterons plus en détail de ce résultat dans les chapitres 18 et .
SUPPRESSION D'INDICES L’attribut principal d’un index est qu’il est nommé – il peut donc être supprimé. En règle générale, les utilisateurs ignorent l’existence de l’index. SQL détermine automatiquement si l'utilisateur est autorisé à utiliser l'index et, si c'est le cas, autorise son utilisation. Cependant, si vous souhaitez supprimer un index, vous devez le connaître par celui-ci. Cette syntaxe est utilisée pour supprimer un index : DROP INDEX ; La suppression d'un index n'affecte pas le contenu des champs.
La commande ALTER TABLE ne fait pas partie de la norme ANSI ; mais il s'agit d'une forme largement accessible et très significative, même si ses capacités sont quelque peu limitées. Il permet de changer la définition d'une table existante. Généralement, il ajoute des colonnes à un tableau. Il peut parfois supprimer ou redimensionner des colonnes, et dans certains programmes, ajouter ou supprimer des contraintes (discuté au chapitre 18). La syntaxe typique pour ajouter une colonne à une table est : ALTER TABLE
