Les Variables et les Types de Données
|
Les Variables et les Types de Données |
Variables fondamentales |
Introduction |
|
Dans la leçon précédente, nous avons utilisé certaines valeurs comme 242 ou 'James Knight'. Ces types de valeurs sont appelés constantes parce que nous les connaissons certainement avant leur utilisation et nous ne les modifions pas dans nos déclarations. |
|
Si vous avez l'intention d'utiliser une certaine catégorie de valeur à maintes reprises, vous pouvez réserver une section de mémoire pour cette valeur. Cela vous permet de mettre la valeur dans une zone de la mémoire de l'ordinateur, facilement modifier la valeur d'une autre, maintes et maintes fois. Pour utiliser la même zone de mémoire pour stocker et supprimer les valeurs selon vos besoins, l'interprète SQL a besoin de deux pièces principales de l'information : un nom et la quantité d'espace dans la mémoire capable de stocker la valeur souhaitée. |
Une variable est une zone de mémoire utilisée pour stocker des valeurs qui peuvent être utilisées dans un programme. Avant d'utiliser une variable, vous devez informer l'interprète. Cela est également considéré comme le déclarant d'une variable. Pour déclarer une variable, utilisez le mot clé DECLARE en utilisant la formule suivante : DECLARE Options Le mot clé DECLARE permet à l'interprète de savoir que vous faites une déclaration. Le mot-clé DECLARE est suivi d'un nom pour la variable. Dans Transact-SQL, le nom d'une variable commence par le signe @. Le nom d'une variable vous permet d'identifier la zone de mémoire où la valeur de la variable est stockée. Transact-SQL est très flexible lorsqu'il s'agit de noms. Par exemple, un nom peut être fait uniquement des chiffres. Voici un exemple : DECLARE @264 Il y a des règles et des suggestions que vous utiliserez pour les noms :
Un nom ne peut pas être l'un des mots suivants réservés pour les mots-clés internes Transact-SQL.
Pour déclarer une variable, comme nous le verrons dans les sections qui suivent, après avoir donné un nom à une variable, vous devez également spécifier la quantité de mémoire dont la variable aurait besoin. La quantité de mémoire est également appelée un type de données. Donc, la déclaration d'une variable utilise la formule suivante : DECLARE @VariableName DataType; Vous pouvez également déclarer plusieurs variables. Pour le faire, séparez-les par une virgule. La formule serait : DECLARE @Variable1 DataType1, @Variable2 DataType2, @Variable_n DataType_n; Contrairement à de nombreux autres langages comme C/C ++, C #, Java ou Pascal, si vous déclarez beaucoup de variables qui utilisent le même type de données, le nom de chaque variable doit être suivi par son propre type de données.
Après la déclaration d'une variable, l'interprète réserve un espace dans la mémoire de l'ordinateur pour cela, mais l'espace ne tient pas nécessairement de valeur reconnaissable.Cela signifie que, à ce temps, la variable est nulle. La façon dont vous pouvez changer cela consiste à donner une valeur à la variable. Ceci est appelé l'initialisation de la variable. N'oubliez pas que le nom d'une variable commence par @ et chaque fois que vous avez besoin de faire allusion à la variable, vous devez veiller à inclure le signe @. Pour initialiser une variable, dans la section nécessaire, saisissez l'instruction SELECT ou le mot-clé SET suivi du nom de la variable, suivi par l'opérateur de devoir "=", suivi d'une valeur appropriée. La formule utilisée est la suivante : SELECT @VariableName = DesiredValue ou SET @VariableName = DesiredValue Dès qu'une variable a été initialisée, vous pouvez rendre sa valeur disponible ou l'afficher. Cette fois, vous pouvez taper le nom de la variable à la droite de PRINT ou SELECT.
Après avoir défini le nom d'une variable, vous devez spécifier la quantité de mémoire dont la variable devra conserver sa valeur. Comme il y a différents types d'informations qu'une base de données peut traiter, SQL fournit un ensemble de types de données.
Une valeur Booléenne est une information déclarée comme étant vraie ou fausse, Sur ou De, Oui ou Non, 1 ou 0. Pour déclarer une variable qui contient une valeur Booléenne, vous pouvez utiliser le BIT ou mot-clé de bits. Voici un exemple : DECLARE @IsOrganDonor bit; Après la déclaration d'une variable Booléenne, vous pouvez l'initialiser avec 0 ou une autre valeur. Si la variable est initialisée avec 0, elle reçoit la valeur Booléenne de Faux. Si elle est initialisée avec tout autre nombre, elle reçoit une Vraie valeur. Voici un exemple d'utilisation d'une variable Booléenne : 
Un entier, également appelé un nombre naturel ou un nombre entier, est un nombre qui peut commencer avec un signe + ou - et est fait de chiffres. Entre les chiffres, aucun caractère autre qu'un chiffre n'est autorisé. Dans le monde réel, quand un nombre est (très) long et devient difficile à lire, tel que 79435794, vous êtes autorisé à taper un symbole appelé le séparateur des milliers dans chaque incrément de mille. Exemple 79, 435, 794. Dans vos expressions SQL, ne jamais inclure le séparateur de milliers : vous recevrez un message d'erreur. Lorsque le numéro commence avec +, tel que +44 ou +8025, un tel numéro est considéré comme positif et vous devrez omettre le commencement par le signe +. Cela signifie que le nombre devrait être écrit comme 44 ou 8025. N'importe quel nombre qui commence par + ou simplement un chiffre est considéré comme positif ou supérieur à 0. Un nombre entier positif est considéré comme non signé/unsigned. D'autre part, un nombre qui commence avec un symbole - est désigné comme négatif.
Si une variable pourrait contenir des nombres naturels dans la gamme de -2,147,483,648 à 2 147 483 647, vous pouvez le déclarer avec le mot-clé int comme le type de données. Voici un exemple : DECLARE @Category int; SET @Category = 1450; PRINT @Category; GO Cela produirait 1450 :
La longueur d'un entier est le nombre d'octets que son champ peut contenir. Pour un type int, qui serait 4 octets.
Si vous voulez utiliser les très petits nombres tels que les âges des étudiants ou le nombre de pages d'une brochure ou d'un journal, utilisez le type de données tinyint. Une variable avec le type de données tinyint peut contenir des nombres positifs allant de 0 à 255. Voici un exemple :
Le type de données smallint suit les mêmes règles et les principes que le type de données int sauf qu'il est utilisé pour stocker les plus petits nombres qui seraient compris entre -32,768 et 32 767. Voici un exemple : 1> DECLARE @NumberOfPages SMALLINT; 2> SET @NumberOfPages = 16; 3> SELECT @NumberOfPages AS [Number of Pages]; 4> GO Number of Pages --------------- 16 ( (1 rows affected)
Le type de données bigint suit les mêmes règles et principes que le type de données int sauf qu'il peut contenir de très grands nombres de -9,223,372,036,854,775,808 à 9,223,372,036,854,775,807. Voici un exemple : 1> DECLARE @CountryPopulation BigInt; 2> SET @CountryPopulation = 16500000; 3> SELECT @CountryPopulation AS 'Country Population'; 4> GO Country Population -------------------- 16500000 (1 rows affected)
Le type de données binaires est utilisé pour une variable qui tiendrait des nombres hexadécimaux. Les exemples de nombres hexadécimaux sont 0x7238, 0xFA36 ou 0xAA48D. Utilisez le type de données binaires si toutes les valeurs de la variable ont exactement la même longueur (ou quantité). Si vous prévoyez que certaines entrées seraient différentes des autres, utilisez le type de données varbinary alternative. Le type varbinary est également utilisé pour les nombres hexadécimaux, mais permet des entrées différentes, tant que toutes les entrées sont hexadecimales.
Un nombre décimal est un nombre qui peut avoir une période (ou le caractère utilisé comme séparateur décimal, définis dans le Panneau de commande) entre les chiffres. Un exemple serait 12.625 ou 44.80. Comme un nombre entier, un nombre décimal peut commencer avec un + ou juste un chiffre, qui rendrait un nombre positif. Un nombre décimal peut également commencer avec le symbole -, qui rendrait un nombre négatif. Si le nombre représente une fraction, une période entre les chiffres spécifie quelle partie de 1 a été coupée.
Si vous prévoyez un tel nombre pour un champ, spécifiez son type de données comme numérique ou décimal (décimal ou numérique devrait produire le même effet dans SQL Server). DECLARE @Distance DECIMAL; 2>SET @Distance = 648.16; 3>PRINT @Distance; 4 GO 648
Un nombre à virgule flottante est un fractionnaire, comme le type décimal. Les nombres en virgule flottante peuvent être utilisés si vous permettrez au moteur de base de données d'appliquer une approximation au nombre réel. Pour déclarer une telle variable, utilisez le flotteur ou le mot-clé réel. Voici un exemple : DECLARE @Radius FLOAT; 2>SET @Radius = 48.16; 3>SELECT @Radius AS Radius; 4>GO Radius ------------------------ 48.159999999999997 (1 rows affected) Une précision est le nombre de chiffres utilisés pour afficher une valeur numérique. Par exemple, le numéro 42005 a une précision de 5, tandis que 226 a une valeur de précision de 3. Si le type de données est spécifié comme un nombre entier (l'int et ses variantes) ou un nombre à virgule flottante (le float et real), la précision est fixée par la base de données et vous pouvez accepter juste l'ensemble de valeurs défiie par l'interprète Microsoft SQL Server. Pour un nombre décimal ( types de données décimaux ou numériques), Microsoft SQL Server vous permet de spécifier la quantité de précision souhaitée. La valeur doit être un nombre entier compris entre 1 et 38 (28 si vous utilisez le SQL Server 7). Un nombre décimal est un nombre qui a une section fractionnée. Les exemples sont 12.05 ou 1450.4227. L'échelle d'un nombre si le nombre de chiffres à droite de la période (ou le jeu de caractères que le séparateur pour les nombres décimaux pour votre langage, comme spécifié dans le Panneau de configuration). L'échelle est utilisée uniquement pour les nombres qui ont une partie décimale, qui inclut la devise (money et smallmoney) et les décimales (numéric et décimal). Si une variable est déclarée avec le type de données décimales ou numériques, vous pouvez spécifier le montant de l'échelle souhaitée. La valeur doit être un nombre entier compris entre 0 et 18. Voici un exemple :
Si une variable pourrait contenir des valeurs monétaires, vous pouvez le déclarer avec le mot-clé de l'argent. Une variable avec un type de données d'argent peut contenir des valeurs positives ou négatives de-922,337,203,685,477.5808 à +922,337,203,685,477.5807. Voici un exemple : 1> DECLARE @YearlyIncome Money; 2> SET @YearlyIncome = 48500.15; 3> SELECT @YearlyIncome AS [Yearly Income]; 4> GO Yearly Income --------------------- 48500.1500 (1 rows affected) Alors que le type de données d'argent peut être utilisé pour une variable contenant de grandes quantités de valeurs monétaires, le type de données smallmoney peut être appliqué pour une variable dont la valeur ne peut pas être inférieure que-214,748.3648, ni supérieure à 214,748.3647. La précision et l'échelle d'une variable de l'argent ou smallmoney sont fixées par Microsoft SQL Server. L'échelle est fixée à 4.
Caractères et Chaînes Un champ de caractères peut se composer de toute sorte de symboles alphabétiques dans n'importe quelle combinaison, lisible ou non. Si vous voulez qu'une variable destinée à contenir un nombre fixe de caractères, tels que les nombres d'étagère de livres d'une bibliothèque, déclarez-le avec le type de données du genre char. Voici un exemple : DECLARE @Gender char;
Par défaut, le type de données char peut être appliqué à une variable qui pourrait contenir un caractère à la fois. Après avoir déclaré la variable, lors de l'initialisation, incluez sa valeur unique entre-guillemets. Voici un exemple : 1> DECLARE @Gender char; 2> SET @GENDER = 'M'; 3> SELECT @Gender AS Gender; 4> GO Gender ------ M (1 rows affected) Par défaut, lorsque vous initialisez une variable de caractères, l'interprète réserve 8 bits de mémoire pour la variable. Cela pourrait être un problème si vous voulez conserver des caractères autres que ceux utilisés en anglais américain. L'alternative est de demander à l'interprète de réserver de l'espace de 16 bits et de suivre les règles d'Unicode. Pour ce faire, lors de l'initialisation de la variable, faites précéder sa valeur avec N. Voici un exemple : 1> DECLARE @Gender char; 2> SET @GENDER = N'M'; 3> SELECT @Gender AS Gender; 4> GO Gender ------ M (1 rows affected) Si vous incluez plusieurs caractères dans l'unique-devis, seul le premier caractère (plus à gauche) pourrait être stocké dans la variable. Voici un exemple : 1> DECLARE @Gender char; 2> SET @Gender = N'Male'; 3> SELECT @Gender AS Gender; 4> GO Gender ------ M (1 rows affected) Une chaîne est un caractère ou une combinaison de caractères. Si une variable contiendra des chaînes de différentes longueurs, déclarez-la avec le type de données varchar. La longueur maximale de texte pouvant contenir un champ de type varchar équivaut à 8 kilo-octets. Dans certains cas, vous devrez peut-être modifier ou spécifier le nombre de caractères utilisés dans une variable de type chaîne. Bien qu'un prénom et un titre de livre, les variables doivent utiliser le type varchar, les deux variables n'auraient pas la même longueur d'entrées. Il se fait que les gens ont difficilement un prénom qui est au-delà de 20 caractères et beaucoup de titres de livres vont au de-delà de 32 caractères. Dans ce cas-là, les deux variables utiliseraient le même type de données, mais de différentes longueurs.n. Pour spécifier le nombre maximal de caractères pouvant être stockés dans une variable de type chaîne, sur le côté droit du char ou de varchar, tapez une ouverture et des parenthèses de fermeture. À l'intérieur des parenthèses, tapez le nombre souhaité. Pour initialiser la variable, si vous utilisez la ligne de commande (SQLCMD.EXE), incluez sa valeur entre doubles-quotes. Voici un exemple :
Si vous utilisez une fenêtre de requête, n'incluez pas la valeur de la chaîne en double-devis, autrement, vous recevrez une erreur.
Donc, en utilisant la fenêtre de requête, incluez la chaîne unique entre-guillemets.
Le type de données text peut être utilisé sur une variable dont les données seraient composées des caractères ASCII. Par opposition à un type varchar de champ, un type de champ de texte peut contenir les textes dont la longueur est supérieure à 8 kilo-octets. Les nchar, nvarchar et les types ntext suivent les mêmes règles que le char, varchar, et text respectivement, sauf qu'ils peuvent être appliqués aux variables qui tiendraient des caractères internationaux, c'est-à-dire les caractères des langues autre que l'anglais américain. Cela se fait suivant les règles de formats Unicode. Lors de l'initialisation de la variable, pour suivre les règles de l'Unicode, faites précéder sa valeur avec N suivie par simple-devis. Cette règle s'applique à la fenêtre de requête et PowerShell : 1> DECLARE @FirstName nchar(20), 2> @LastName nchar(20); 3> SET @FirstName = N'Philom�ne'; 4> SET @LastName = N'A�ore'; 5> SELECT @FirstName As "Pr�nom", 6> @LastName As "Nom de Famille"; 7> GO Pr�nom Nom de Famille -------------------- -------------------- Philom�ne A�ore (1 rows affected) 1>1> Notez que, dans Powershell, si vous n'utilisez pas de règles d'Unicode, la chaîne doit être incluse dans le double-devis et si vous utilisez Unicode, la chaîne doit être incluse dans le seul-devis.
Date et types d'heures
Un temps est une mesure non spatiale permettant de compter un certain nombre de défaillances qui ont eu lieu depuis un point de départ non-spatial. Le principal point de départ est appelé minuit. La principale unité de temps est appelée la seconde. Une seconde est identifiée par un nombre entier. En réalité, le second est divisé en fractions de 1000, à compter de 0 à 999 et appelé millisecondes. Une milliseconde est identifiée par un nombre entier. A partir de la seconde, une mesure de 60 secondes, comptées de 0 à 59, est appelée une minute. Une minute est identifiée par un nombre entier. Un groupe de 60 minutes, comptées de 0 à 59, une heure. Une heure est identifiée par un nombre entier. Pour représenter une valeur de temps, il y a des règles à suivre. Les règles peuvent être vérifiées à l'onglet heure pour personnaliser des options régionales de la Région et les options de Langage du panneau de configuration.
Pour prendre en charge les valeurs d'heure, Transact-SQL fournit le type de données TIME. Pour déclarer une variable contenant une valeur temporelle, utilisez TIME comme le type de données. Pour initialiser la variable, utilisez la formule suivante : hh:mm hh:mm:ss hh:mm:ss[.fractional seconds] La première partie comprend l'heure avec une valeur comprise entre 1 et 23. Si la valeur est inférieure à 10, vous pouvez l'écrire avec un 0 initial, comme dans 08. La deuxième partie représente les minutes et tient une valeur comprise entre 1 et 59. Si la valeur est inférieure à 10, vous pouvez l'entrer avec un 0 initial, comme dans 04. Les valeurs sont séparées par :. La valeur est incluse dans l'unique-devis. Pour indiquer que vous voulez suivre des règles de l'Unicode, faites précéder la valeur avec N. Voici un exemple : 1> DECLARE @ArrivalTime time; 2> SET @ArrivalTime = N'18:22'; 3> SELECT @ArrivalTime AS [Arrival Time]; 4> GO Arrival Time ---------------- 18:22:00.0000000 (1 rows affected) 1> La troisième partie de notre formule est facultative et représente la partie secondes du temps et contient une valeur comprise entre 1 et 59. Si la valeur est inférieure à 10, vous pouvez y fournir un 0 initial. Cette partie est séparée de ma précédente avec :. La dernière partie est également facultative. Elle te permet de fournir la partie millisecondes du temps. Si vous voulez la fournir, entrez une valeur comprise entre 1 et 999. Ceci est séparé de la partie secondes avec une période ".".
Un groupe de 24 heures, calculé à partir de 1 à 23, est appelé un jour. En réalité, un jour est fait de 24 heures et de quelques secondes en plus. Ceux-ci sont utilisés pour identifier un jour de différentes manières. Nous les mentionnerons ci-dessous. Au-dessus de la journée, l'unité de mesure est appelée une année. Une année est identifiée par une valeur numérique. Normalement, une année est représentée avec 4 chiffres, de 0 à 9999. Pour les rendre facile à gérer des années, elles sont regroupées dans certaines unités. Les années qui se sont produites avant Jésus Christ sont identifiées comme BC. Alors, il y a un point de départ a dénommé 0. Un groupe de 1000 ans est appelé un millénaire.Chacune des années dans un millénaire doit être identifiée avec 4 chiffres. 1608 est un exemple. Un autre exemple est 1978. 2118 est encore un autre exemple. Un groupe de 100 ans est appelé un siècle. Les années dans un siècle peuvent être identifiées avec 2 chiffres. 08 est un exemple. Un autre exemple est 78. Un autre exemple est de 18 (prédites-vous un peu de confusion ici ?). Dans une année, chaque jour peut être identifié par une valeur numérique. Le premier jour est 1, ou peut être considéré comme le Jour 1. Chacun des autres jours dans une année peut être identifié avec un nombre naturel, comme 216, ce qui serait 216 jours à partir du début de l'année. Le nombre de jours dans une année dépend de divers facteurs. Par exemple, dans certains scénarios, tels que certaines procédures commerciales ou comptables, une année pourrait compter pour 360 jours. Dans la plupart des calendriers, une année peut avoir 365 jours chaque année sauf que, après 4 ans, l'année aurait 366 jours (souvenez-vous, nous avons metionné qu'une journée est effectivement de 24 heures et quelques secondes; ces secondes sont regroupées tous les 4 ans pour compter comme une journée entière). Ceci est appelé une année bissextile. Pour vous aider à gérer les jours de l'année, une année est divisée en 12 unités appelées chacune un mois. Chaque mois peut être identifié par un nombre ou un nom. Lorsqu'un mois est identifié par un nombre, il peut utiliser une valeur comprise entre 1 et 12. Lorsqu'il s'agit de noms, un mois peut utiliser un long et/ou un court nom. Les longs noms sont janvier, février, mars, avril, mai, juin, juillet, août, septembre, octobre, novembre et décembre. Les noms courts sont jan, fév, mar, avr, mai, juin, juil, aoû, sep, oct, nov et déc. Chaque mois a un certain nombre de jours. Une journée dans un mois peut être identifiée avec un nombre. Le premier jour du mois est 1. Le quinzième jour serait identifié comme 15 ou le Jour 15. Le nombre de jours dans un mois dépend de divers facteurs. Nous l'avons mentionné qu'un jour dans un mois peut être identifié avec un nombre et un mois a un nom, dans un délai d'un an. Une journée peut être identifiée par son numéro, son mois et la valeur numérique de l'année. Il existe diverses règles à suivre pour représenter une date. Il est possible de vérifier les règles dans l'onglet date du fait de personnaliser les options régionales accessibles depuis les options régionales et linguistiques du Panneau de configuration.
Pour vous aider à gérer les mois de l'année, une année peut être divisée en trimestres ou semestres. Une année comporte 4 trimestres et chacun contient 3 mois. Une année a également 2 semestres disposant chacun de 6 mois. Pour vous aider à gérer les jours dans un mois, le mois est divisé en parties, chacune est appelée une semaine. Normalement, chaque semaine a 7 jours et chaque mois devrait avoir 4 semaines. Pour vous aider avec des valeurs de date, Microsoft SQL Server fournit le type de données DATE. Ce type de données compte des dates à partir du 1er janvier 0001 jusqu'au 31 décembre 9999. Par conséquent, pour déclarer une variable contenant une valeur date, utilisez le type de données DATE. Pour initialiser une variable DATE, utilisez une des formules suivantes : YYYYMMDD YYYY-MM-DD MM-DD-YY MM-DD-YYYY MM/DD/YY MM/DD/YYYY Vous pouvez démarrer la valeur avec un chiffre de 4 ans. Si vous utilisez la première formule, AAAAMMJJ (YYYYMMDD), vous devez fournir 4 chiffres pour l'année, immédiatement suivie par 2 chiffres pour le mois, immédiatement suivi de 2 chiffres pour le jour. Un exemple serait DECLARE @OneDay DATE; SET @OneDay = N'10360610'; SELECT @OneDay AS [Day to Prevail]; GO En anglais américain, cela représente le 6 octobre 1036.
Vous pouvez fournir la valeur dans une unité avec 6 chiffres. Dans ce cas, les 2 chiffres de gauche seraient considérés comme l'année du siècle actuel. Prenons l'exemple suivant :
Au lieu de fournir la valeur entière dans une combinaison de chiffres, vous pouvez utiliser la deuxième formule. Encore une fois vous devez fournir 4 chiffres pour l'année, suivis par le séparateur "-", suivi de 1 ou 2 chiffres pour le mois, suivi par le séparateur "-", suivi de 1 ou 2 chiffres pour le jour. Un exemple serait : DECLARE @EventDay date; SET @EventDay = N'1914-4-7'; SELECT @EventDay AS [Event Day]; GO En anglais américain, cela représente le 6 octobre 1036;
Si vous utilisez une invite de commande ou PowerShell, veillez à inclure la valeur unique entre-guillemets. Pour appliquer les règles de l'Unicode, commencez avec le préfixe N. Voici un exemple : 1> DECLARE @IndependenceDay DATETIME; 2> SET @IndependenceDay = N'01/01/1960'; 3> SELECT @IndependenceDay AS [Independence Day]; 4> GO Independence Day ----------------------- 1960-01-01 00:00:00.000 (1 rows affected) Nous avons vu que, si vous utilisez le MM-DD-YY (JJ-MM-AA) ou MM/DD/YY (MM/JJ/AA), vous pouvez fournir à une année 2 chiffres. Dans ce cas-là :
Voici des exemples : DECLARE @SomeDate Date; SET @SomeDate = N'5-7-05'; PRINT @SomeDate; GO PRINT N'-----------'; GO DECLARE @SomeDate Date; J SET @SomeDate = N'5/7/05'; PRINT @SomeDate; GO PRINT N'-----------'; GO DECLARE @SomeDate Date; SET @SomeDate = N'5-7-41'; I PRINT @SomeDate; GO PRINT N'-----------'; GO DECLARE @SomeDate Date; SET @SomeDate = N'5/7/41'; PRINT @SomeDate; GO I PRINT N'-----------'; GO DECLARE @SomeDate Date; SET @SomeDate = N'5-7-81'; PRINT @SomeDate; GO PRINT N'-----------'; GO DECLARE @SomeDate Date; SET @SomeDate = N'5/7/81'; PRINT @SomeDate; GO PRINT N'-----------'; GO Voici des exemples de résultats :
Une fois de plus, il est préférable de fournir à une année 4 chiffres.
La combinaison des valeurs de date et d'heure Au lieu de déclarer séparément une date ou une valeur de temps, vous pouvez combiner les deux valeurs en une seule. Pour cela, Transact-SQL fournit le type de données DATETIME2. Ce type de données compte des dates depuis le 1er janvier 0001 et se termine le 31 décembre 9999. Par conséquent, pour déclarer une variable qui prend en charge une date de valeur, une valeur de temps ou une combinaison de valeurs de date et d'heure, utilisez le type de données DATETIME2. Pour initialiser la variable, utilisez l'une des formules suivantes : YYYYMMDD YYYYMMDD hh:mm:ss YYYYMMDD hh:mm:ss[.fractional seconds] DDYYYY-MM-DD YYYY-MM-DD hh:mm:ss YYYY-MM-DD hh:mm:ss[.fractional seconds] MM-DD-YY MM-DD-YY hh:mm:ss MM-DD-YY hh:mm:ss[.fractional seconds] MM-DD-YYYY MM-DD-YYYY hh:mm:ss MM-DD-YYYY hh:mm:ss[.fractional seconds] MM/DD/YY MM/DD/YY hh:mm:ss MM/DD/YY hh:mm:ss[.fractional seconds] MM/DD/YYYY MM/DD/YYYY hh:mm:ss MM/DD/YYYY hh:mm:ss[.fractional seconds] N'oubliez pas d'inclure la valeur unique entre-guillemets. Voici des exemples : DECLARE @FullName nvarchar(60), @DateOfBirth date, @DateRegistered datetime2 SET @FullName = N'John Summons'; SET @DateOfBirth = N'19960426'; SET @DateRegistered = N'20090629'; SELECT @FullName AS [Full Name], @DateOfBirth AS [Date of Birth], @DateRegistered AS [Date Registered]; SET @FullName = N'James Haans'; SET @DateOfBirth = N'1994-10-25'; SET @DateRegistered = N'2009-08-02'; SELECT @FullName AS [Full Name], @DateOfBirth AS [Date of Birth], @DateRegistered AS [Date Registered]; SET @FullName = N'Gertrude Monay'; SET @DateOfBirth = N'06-16-92'; SET @DateRegistered = N'2009-12-24 12:36'; SELECT @FullName AS [Full Name], @DateOfBirth AS [Date of Birth], @DateRegistered AS [Date Registered]; SET @FullName = N'Philom�ne Guillon'; SET @DateOfBirth = N'1996-10-16'; SET @DateRegistered = N'10/14/08 09:42:05.136'; SELECT @FullName AS [Full Name], @DateOfBirth AS [Date of Birth], @DateRegistered AS [Date Registered]; SET @FullName = N'Eddie Monsoon'; SET @DateOfBirth = N'08/10/96'; SET @DateRegistered = N'2009-06-02 12:36'; SELECT @FullName AS [Full Name], @DateOfBirth AS [Date of Birth], @DateRegistered AS [Date Registered]; SET @FullName = N'Peter Mukoko'; SET @DateOfBirth = N'03-10-1994'; SET @DateRegistered = N'7/22/2009 10:24:46.248'; SELECT @FullName AS [Full Name], @DateOfBirth AS [Date of Birth], @DateRegistered AS [Date Registered]; SET @FullName = N'Chritian Allen'; SET @DateOfBirth = N'06/16/1995'; SET @DateRegistered = N'02-09-2009 12:36'; SELECT @FullName AS [Full Name], @DateOfBirth AS [Date of Birth], @DateRegistered AS [Date Registered]; GO Si vous commencez la valeur avec deux chiffres, la première partie est considérée comme un mois et non l'année. Outre la DATE, LE TEMPS et les types de données DATETIME2, Transact-SQL prend en charge le smalldatetime et les types de données datetime. Il s'agit d'anciens types de données. Bien que toujours disponibles, ils sont conservés à des fins de compatibilité descendante et vous devez cesser de les utiliser.
Si vous avez programmé dans les langages comme C/C ++ ou Pascal, vous êtes probablement familiarisés avec la possibilité de donner un nom convivial pour un type de données connu. Transact-SQL vous donne également cette option. Un type de données défini par l'utilisateur (UDT) est une technique de création d'un type de données basé sur un type de données Transact-SQL existant. Avant de créer un type de données défini par l'utilisateur, vous devez être familiarisé avec le type existant. Ce sont les types que nous avons vus jusqu'à présent. Si vous le souhaitez, vous pouvez créer un nom d'alias pour l'un d'entre eux. Vous pouvez le faire visuellement ou par programmation. Pour créer visuellement un UDT, dans l'Explorateur d'objets, développez une base de données, développez son noeud de Programmabilité et développez l'élément Types. Sous Types, cliquez avec le bouton droit de la souris sur les types de données définis par l'utilisateur, puis cliquez sur le type de données de New User-Defined.
Cela s'ouvrirait :
La première pièce de l'information que vous devez fournir est le schéma qui sera propriétaire du nouveau type. Normalement, un schéma par défaut est fourni et vous pouvez l'accepter seulement. Les deux informations les plus importantes que vous devez fournir sont un nom pour le nouveau type comme alias et le type de Transact-SQL sur lequel il sera fondé. Dans la zone de texte Nom, entrez un nom de votre choix. Le nom doit suivre les règles de noms dans Transact-SQL. Dans la zone de liste déroulante Type de données, sélectionnez le type de données de votre choix. Bien entendu, vous devez savoir quel type vous souhaitez utiliser. Après être entré et en sélectionnant les renseignements souhaités, cliquez sur OK. Pour créer un UDT avec le code, la formule de base à utiliser est la suivante : CREATE TYPE AliasName FROM BaseType
Pour obtenir de l'aide de code modèle, ouvrez une fenêtre de requête. Dans l'Explorateur de modèles, développez le noeud de type de données défini par l'utilisateur. Faites glisser le type de données de Create user-Defined dans la fenêtre Query. Le code squelette sera généré pour vous. -- ================================ -- Create User-defined Data Type -- ================================ USE <database_name,sysname,AdventureWorks> GO -- Create the data type CREATE TYPE <schema_name,sysname,dbo>.<type_name,sysname,Phone> FROM <base_type,,nvarchar> (<precision,int,25>) <allow_null,,NULL> -- Create table using the data type CREATE TABLE <table_name,sysname,test_data_type> ( ID int NOT NULL, Phone <schema_name,sysname,dbo>.<type_name,sysname,Phone> NULL ) GO Vous commencez avec l'expression CREATE TYPE, suivie par le nom souhaité pour le nouveau type. Après le mot clé FROM, saisissez un type de données Transact-SQL existant. Voici un exemple : CREATE TYPE NaturalNumber FROM int; GO De la même façon, vous pouvez créer autant d'alias de types de données connus que vous le souhaitez. Vous devez également être conscients des règles qui gouvernent chaque type de données. Voici des exemples : CREATE TYPE NaturalNumber FROM int; GO CREATE TYPE ShortString FROM nvarchar(20); GO CREATE TYPE ItemCode FROM nchar(10); GO CREATE TYPE LongString FROM nvarchar(80); GO CREATE TYPE Salary FROM decimal(8, 2); GO CREATE TYPE Boolean FROM bit; GO
Après avoir créé un UDT, vous pouvez l'utiliser comme bon vous semble. Par exemple, vous pouvez déclarer une variable pour cela. Puis, avant de l'utiliser, vous devez l'initialiser avec la valeur appropriée. Voici des exemples : DECLARE @EmployeeID NaturalNumber,
@EmployeeNumber ItemCode,
@FirstName ShortString,
@LastName ShortString,
@Address LongString,
@HourlySalary Salary,
@IsMarried Boolean;
SET @EmployeeID = 1;
SET @EmployeeNumber = N'28-380';
SET @FirstName = N'Gertrude';
SET @LastName = N'Monay';
SET @Address = N'1044 Alicot Drive';
SET @HourlySalary = 26.75;
SET @IsMarried = 1;
SELECT @EmployeeID AS [Empl ID], @EmployeeNumber AS [Empl #],
@FirstName AS [First Name], @LastName AS [Last Name],
@Address, @HourlySalary AS [Hourly Salary],
@IsMarried AS [Is Married ?;
GO
Évidemment, vous pouvez combiner des types de données Transact-SQL et votre propre type défini dans votre code.
Exercice : Utility Company
Exercice : US States
|
| Précédent | Copyright © 2010 Yevol.com | Suivant |
Etude
Pratique : Présentation des Variables
