Home

Une Revue des Fonctions Intégrées

 

Principes de Base de Fonctions Intégrées

 

Introduction

Pour vous aider à identifier les fonctions que vous pouvez utiliser, ils sont classés par leurs types et probablement leur utilité.

En raison de leur complexité, certaines valeurs peuvent être facilement reconnus ou fixe. Par exemple, une date comme le 6 janvier 1995, est constante et peut ne jamais changer. Ce type de la valeur est désigné comme déterministes car il est toujours la même.

De la même manière, une valeur de temps comme 5 PM est constante et ne pouvez pas modifier. Il existe d'autres valeurs qui ne peuvent être connus à l'avance car ils changent en fonction de certaines circonstances. Par exemple, la date de début des changements année scolaire d'une année à une autre mais elle toujours survient. Cela signifie que, vous savez cela se produira, mais vous ne connaissez pas la date exacte. Une telle valeur est appelée à comme non déterministes.

Pour prendre en charge déterminisme et non-déterminisme, Transact-SQL fournit deux grandes catégories de fonctions. Une fonction qui renvoie toujours la valeur même ou connue est désignée comme déterministes. Une fonction dont la valeur renvoyée peut dépendre d'une condition est appelée à comme non déterministes.

Practical LearningFormation pratique : Fonctions intégrées introduction

  1. Démarrez Microsoft SQL Server et de se connecter au serveur
  2. Dans la barre d'outils standard, cliquez sur le bouton Nouvelle requête
  3. Pour créer une nouvelle base de données, tapez ce qui suit
    CREATE DATABASE Exercise1 Exercise1 GO USE ; GO
  4. Appuyez sur F5 pour exécuter

Une valeur de casting

Dans la plupart des cas, une valeur que l'utilisateur envoie à votre base de données est considéré principalement comme une chaîne. Cela est utile si c'est ce qui vous attendent. Si la valeur de que l'utilisateur fournit doit être considérée comme autre chose qu'une chaîne, par exemple, si l'utilisateur fournit un numéro, avant d'utiliser une telle valeur, vous devriez tout d'abord convertir dans le type approprié, c'est-à-dire d'une chaîne de type attendu.

Pour aider à la conversion, vous pouvez utiliser le CAST() ou la fonction Convert(). La syntaxe de laLa fonction CAST() est :

CAST(Expression AS DataType)

L' expression est la valeur qui doit être convertie. Le facteur de type de données est le type de valeur que vous voulez convertir l' expression à. Le type de données peut être l'une de celles que nous avons examinés dans Leçon 5.

Practical LearningFormation pratique : Casting une valeur

  1. Dans la fenêtre de requête, tapez ce qui suit :
    DECLARE @ StrSalary Varchar(10),
    @StrHours Varchar(6),
    @WeeklySalary Decimal(6,2)
    SET @StrSalary = '22.18' N;
    SET @StrHours = '38.50' N;
    SET @WeeklySalary = CAST (@StrSalary As Decimal(6,2)) *
                        CAST(@StrHours As Decimal(6,2));
    SELECT @WeeklySalary; GO
  2. Appuyez sur F5 pour exécuter

Cast

Conversion d'une valeur

Comme CAST(), la fonction Convert() est utilisée pour convertir une valeur.Contrairement aux CAST(), CONVERT permet de convertir une valeur son type original un type non-similaire. Par exemple, vous pouvez utiliser CONVERT pour convertir un nombre en une chaîne et vice versa.

La syntaxe de laFonction Convert() est :

CONVERT (DataType [(longueur)], expression [, style])

Le premier argument doit être un type de données connues, telles que celles que nous avons examinés dans Leçon 5. Si vous convertissez la valeur dans une chaîne (varchar, nvarchar, char, nchar) ou d'un type binaire, vous devez spécifier le nombre de permis de caractères le type de données propre entre parenthèses.Comme examiné pour la fonction CAST(), l' expression est la valeur qui doit être converti.

Practical LearningFormation pratique : Conversion d'une valeur

  1. Sélectionnez le code dans l'éditeur de requête et tapez le texte suivant :
    --Square Calculation
    DECLARE @Side As Decimal(10,3),
            @Perimeter As Decimal(10,3),
            @Area As Decimal(10,3);
    SET @Side = 48.126;
    SET @Perimeter = @Side * 4;
    SET @Area = @Side * @Side;
    PRINT 'Square Characteristics';
    PRINT '-----------------------';
    PRINT 'Side = N' + CONVERT(VARCHAR(10)... ;
    PRINT ' périmètre = N ' + CONVERT(varchar(10), @ périmètre, 10);
    PRINT ' espace = N ' + CONVERT(varchar(10), @ espace, 10); GO
  2. Appuyez sur F5 pour exécuter

Convert

Macros de Transact-SQL

 

Introduction

Une macro est une action qui peut être effectuée sur une base de données ou certaines parties d'une base de données ou d'un serveur de base de données. Une macro est semblable à une fonction sans être exactement un. Transact-SQL fournit diverses macros pour vous aider à la gestion des bases de données et leurs objets.

Vérification de l'existence d'un enregistrement

Un des opérations plus simples qu'un utilisateur peut effectuer sur une table consiste à la recherche d'un enregistrement. Pour ce faire, l'utilisateur pourrait ouvrir la table contenant les enregistrements et visuellement archiver, recherchez un morceau d'informations, telles que le nom d'un étudiant.

Le développeur de base de données, vous pouvez aussi consulter pour un enregistrement et il existe différentes techniques que vous pouvez utiliser. Pour vous aider à cela, Transact-SQL fournit une macro appelée EXISTS. Sa syntaxe est la suivante :

BIT EXISTS(SELECT Something)

Cette macro prend un argument. L'argument doit être une instruction SELECT qui serait utilisée pour obtenir la valeur dont l'existence pourrait être vérifiée. Par exemple, dans la leçon 3, nous l'avons mentionné un système de base de données noms de bases de données qui contient un enregistrement de toutes les bases de données stockées sur votre serveur. Vous pouvez utiliser la macro EXISTS() pour vérifier l'existence d'une certaine base de données. La formule que vous utiliseriez est la suivante :

IF EXISTS ( SELECT Nom FROM sys.databases WHERE Nom = N ' DatabaseName ' )

Dans l'espace réservé pour DatabaseName, vous pouvez saisir le nom de la base de données.

Fonctions de chaîne-based

 

Introduction

La chaîne est la plus simple, la valeur primaire qui est présentée à une base de données. C'est parce que, toute valeur, avant d'être traités en particulier, est considéré d'abord comme une chaîne. Dans une application, il existe diverses manières vous utilisez ou obtenez une chaîne. Vous pouvez l'obtenir ou fournir à une fonction comme une chaîne constante, c'est-à-dire une chaîne dont vous connaissez certainement la valeur et que vous passent à une fonction. Vous pouvez également obtenir une chaîne qui fournit un utilisateur. Autres fonctions peuvent également produire ou renvoyer une chaîne.

Pour vous aider à gérer les chaînes ou effectuer des opérations sur les, Transact-SQL fournit différentes fonctions. Les fonctions peuvent diviser en catégories qui sont basés sur le caractère, les conversions, addition, sub-strings, etc..

La longueur d'une chaîne

Certaines opérations effectuées sur les chaînes nécessitent que vous connaissez le nombre de caractères d'une chaîne. C'est parce que certaines opérations nécessitent un nombre minimum de caractères et de certaines autres fonctions nécessitent que la chaîne ont au moins un caractère. Le nombre de caractères d'une chaîne est également appelé la longueur de la chaîne.

Pour obtenir la longueur d'une chaîne, vous pouvez utiliser le LEN() fonction. Sa syntaxe est la suivante :

int natation (String)

Cette fonction prend un argument que la chaîne à considérer. Elle renvoie le nombre de caractères dans la chaîne.

Practical LearningFormation pratique : Obtenir la longueur d'une chaîne

  1. Sélectionnez le code dans l'éditeur de requête et tapez le texte suivant :
    DECLARE @FIFA  varchar(120)
    SET @FIFA = N'Fédération Internationale de football association'
    SELECT @FIFA  la AS SELECTLEN(@FIFA) AS [nombre de caractères]
  2. Appuyez sur F5 pour exécuter

Length

Conversion de la chaîne : Conversion de type integer ASCII

Comme vous le savez peut-être déjà, une chaîne est principalement un ou un groupe de caractères. Ces caractères sont des valeurs ASCII. Si vous avez une chaîne, pour obtenir le code ASCII de son caractère plus à gauche, vous pouvez utiliser la fonction ASCII(). Sa syntaxe est la suivante :

int ASCII (String)

Cette fonction prend comme argument comme chaîne et renvoie le code ASCII du premier (gauche) caractères de la chaîne.

Practical LearningFormation pratique : Conversion en entier pour ASCII

  1. Sélectionnez le code dans l'éditeur de requête et tapez le texte suivant :
    DECLARE @ES varchar(100)
    SET @ES = Salvador N'El '
    SELECT @ES AS SELECT ASCII(@ES) AS [dans le format de ASCII]
  2. Appuyez sur F5 pour exécuter

ASCII

Conversion de la chaîne : Conversion de ASCII à Integer

Si vous avez le code ASCII du caractère et que vous souhaitez trouver son caractère réel, vous pouvez utiliser la fonction CHAR(). Sa syntaxe est la suivante :

CHAR CHAR (int valeur)

Cette fonction prend comme argument une valeur numérique sous la forme d'un entier. Lors de la conversion, la fonction renvoie l'équivalent ASCII de ce nombre.

Conversions de chaîne : minuscules

Comme vous le savez peut-être déjà, une chaîne peut en être faite en majuscules, minuscules et les symboles qui ne disposent pas d'un cas particulier. Lorsque vous recevez une chaîne, si vous souhaitez convertir tous ses caractères en minuscules, vous pouvez utiliser la fonction LOWER(). Sa syntaxe est la suivante :

VARCHAR LOWER(String)

Cette fonction prend comme argument une chaîne. Toute lettre minuscule qui fait partie de la chaîne ne changerait pas. Toute lettre qui fait partie de la chaîne serait converti en minuscules. Tout autre caractère ou symbole pourrait être conservé "tel quel". Après la conversion, la fonction LOWER() renvoie une nouvelle chaîne.

Voici un exemple :

DECLARE @FIFA  varchar(120)
SET @FIFA = N'Fédération Internationale de football association'
SELECT @FIFA  AS SELECTLOWER(@FIFA) AS convertis

Cela donnerait :

Lower

Practical LearningFormation pratique : Conversion d'une valeur de type String en minuscules

  1. Sélectionnez le code dans la fenêtre de requête
  2. Pour créer une fonction, tapez ce qui suit :
    USE Exercise1 ;
    GO
    --=============================================
    --function : GetUsername
    --=============================================
    CREATE FUNCTION GetUsername (@FirstName nvarchar(40),
                                 @LastName  varchar(40)) varchar(50)
    RETURNS AS BEGIN varchar(50) AS
    DECLARE @Username;
    SELECT @Username = LOWER(@FirstName) + LOWER(@LastName) ;
    RETURN @UserName ;
    END
    GO
  3. Appuyez sur F5 pour exécuter l'instruction
  4. Appuyez sur Ctrl + A pour sélectionner le code et appuyez sur la touche Suppr pour supprimer le code
  5. Pour tester la fonction, tapez ce qui suit:
    USE Exercise1
    GO SELECT Exercise1.dbo.GetUsername(N'Francine', N'Moukoko');
    GO
  6. Appuyez sur F5 pour exécuter l'instruction

    Function
  7. Dans l'Explorateur d'objets, développez le nœud de bases de données, si nécessaire et développez Exercise1
  8. Développez Programmabilité
  9. Développez des fonctions
  10. Développez les fonctions Scalar
  11. Cliquez avec le bouton droit de la souris sur dbo.GetUserName, puis cliquez sur Supprimer
  12. Dans la boîte de dialogue Supprimer un objet, cliquez sur OK

Sub-Strings : Caractères début d'une chaîne

Une sous-chaîne est une section obtenue à partir d'une chaîne. L'idée est d'isoler un ou un groupe de caractères pour quelque raison que ce soit nécessaire.

Une sous-chaîne de gauche est un ou un groupe de caractères récupérée du côté gauche d'une chaîne connue. Pour obtenir la sous-chaîne d'une chaîne de gauche, vous pouvez utiliser la fonction LEFT(). Sa syntaxe est la suivante :

VARCHAR LEFT (String, NumberOfCharacters)

Cette fonction prend deux arguments. Le premier argument spécifie la chaîne d'origine. Le deuxième argument spécifie le nombre de caractères à partir de la gauche la plupart qui constituera la sous-chaîne. Après l'opération, la fonction LEFT() renvoie une nouvelle chaîne de caractère gauche + la NumberOfCharacters sur sa droite de la chaîne.

Practical LearningFormation pratique : Création d'un Sub-String avec les caractères de gauche

  1. Supprimer le code précédent à partir de la fenêtre de requête
  2. Pour utiliser la fonction LEFT(), tapez ce qui suit :
    USE Exercise1 ;
    GO
    --=============================================
    --function : GetUsername
    --=============================================
    CREATE FUNCTION GetUsername (@FirstName nvarchar(40),
    @LastName  varchar(40)) RETURNS varchar(50)
    AS
     BEGIN DECLARE @Username AS nvarchar(50) ;
     SELECT @Username = LOWER (LEFT(@FirstName, 1)) + LEFT(LOWER(@LastName), 4)
     RETURN @Username;
    END
    GO
  3. Appuyez sur F5 pour exécuter l'instruction.
  4. Supprimer le code dans la fenêtre de requête
  5. Pour tester la fonction, tapez ce qui suit :
    SELECT Exercise1.dbo.GetUsername(N'Francine', N'Moukoko');
    GO
  6. Exécutez l'instruction dans la fenêtre

    Function
  7. Modifiez l'appel avec un nom plus court que 5 caractères tels que "Um" et exécutez l'instruction. Voici un exemple :

    Function

Sub-Strings : Caractères de fin d'une chaîne

Au lieu des caractères de début d'une chaîne, vous pouvez créer une chaîne utilisant les caractères plus à droite d'une chaîne existante. Pour prendre en charge cette opération, Transact-SQL fournit la fonction RIGHT(). Sa syntaxe est la suivante :

RIGHT VARCHAR (String, NumberOfCharacters)

Cette fonction prend deux arguments. Le premier argument spécifie la chaîne d'origine. Le deuxième argument spécifie le nombre de caractères de la plupart de droite qui constituera la sous-chaîne.

Practical LearningFormation pratique : Obtenir la droite caractères

  1. Supprimer le code précédent à partir de la fenêtre de requête
  2. Pour créer une fonction, tapez ce qui suit :
    USE Exercise1;
    GO
    --=============================================
    --function : Last4DigitsOfSSN
    --=============================================
    CREATE FUNCTION (@SSN varchar(12)) de Last4DigitsOfSSN
        RETURNS char(4) AS BEGIN RETURN RIGHT (@ SSN, 4);
    END
    GO
  3. Appuyez sur F5 pour exécuter l'instruction.
  4. Supprimer le code précédent à partir de la fenêtre de requête
  5. Pour tester la fonction, tapez ce qui suit :
    USE Exercise1 Exercise1.dbo.Last4DigitsOfSSN(N'836483846')
    SELECT
    GO;
    GO
  6. Exécutez l'instruction

    Function

Sub-Strings : Remplacement des événements dans une chaîne

Une des situations plus agaçant que vous pouvez rencontrer avec une chaîne est de traiter avec un contenant des caractères inattendus. Cela pourrait être due à sa mise en forme ou toute autre raison. Par exemple, si vous demandez un numéro de téléphone d'un utilisateur, il existe diverses façons que la chaîne pourrait être présentée pour vous. Exemples sont 000-000-0000, 0000000000 ou (000) 000-0000.

Tous ces formats est un acceptable américains et Canadiens numéro de téléphone, mais si vous impliquer cette chaîne dans une opération, vous a pu obtenir un résultat imprévisible. Une façon vous pouvez résoudre ce type de problème consiste à supprimer tous les caractères indésirables de la chaîne. Cette opération peut également consister en remplacement de certains caractères par autres (s).

Pour remplacer un caractère ou une sous-chaîne d'une chaîne, vous pouvez utiliser la fonction REPLACE(). Sa syntaxe est la suivante :

VARCHAR REPLACE (String, FindString, ReplaceWith)

ou

REPLACE binaire (String, FindString, ReplaceWith)

Cette fonction accepte trois arguments. La première est la chaîne qui sera utilisée comme référence. Le deuxième argument, FindString, est un caractère ou une sous-chaîne à rechercher dans l'argument de type string. Si le caractère de FindString ou de la sous-chaîne est trouvé dans la chaîne, puis il est remplacé par la valeur du dernier argument, ReplaceWith.

Practical LearningFormation pratique : Remplacement des caractères ou Sub-Strings

  1. Dans l'Explorateur d'objets, supprimez dbo.Last4DigitsOfSSN
  2. Supprimer le code dans la fenêtre de requête
  3. Pour utiliser la fonction REPLACE(), modifiez le code comme suit :
    USE Exercise1;
    GO
    --=============================================
    --function : Last4DigitsOfSSN
    --=============================================
    CREATE FUNCTION Last4DigitsOfSSN (@SSN  varchar(12))
    RETURNS char(4)
    AS
    BEGIN DECLARE @StringWithoutSymbol As varchar(12);
    --tout d'abord supprimer les espaces vides
    SET @StringWithoutSymbol = REPLACE(@SSN, N' ', N'');
    --maintenant supprimer les tirets "-" si elles existent
    SET @StringWithoutSymbol = REPLACE(@StringWithoutSymbol, N'-', N'');
     RETURN RIGHT (@ StringWithoutSymbol, 4); FIN ALLER
  4. Exécutez l'instruction
  5. Supprimer le code dans la fenêtre de requête
  6. Pour tester la fonction, tapez ce qui suit
    USE Exercise1 GO SELECT Exercise1.dbo.Last4DigitsOfSSN(N'244-04-8502');
    GO
  7. Exécutez l'instruction dans la fenêtre

Fonctions arithmétiques

 

Le signe d'un nombre

En arithmétique, un numéro est considéré comme étant négatif (moins de 0), null (égal à 0) ou positive (supérieur à 0). Lorsqu'un nombre est négatif, il doit avoir un - symbole à sa gauche. S'il est positif, il peut afficher un + symbole à sa gauche, ou il peut omettre il. Un nombre sans- ou + symbole à sa gauche est considérée comme positive, a également évoqué comme non signé.

Le symbole qui détermine si un nombre est positif ou négatif est dénommé son signe. Le signe est facilement vérifiable si vous connaissez déjà le numéro. Dans certains cas, lorsqu'un nombre est soumis à votre application, avant d'entreprendre toute action, vous devrez peut-être obtenir cet élément d'information.

Pour savoir que si une valeur est positive, négative ou null, Transact-SQL fournit la fonction SIGN(). Sa syntaxe est la suivante :

SIGN (expression)

Cette fonction prend comme argument un nombre ou une expression qui peut être évaluée à un nombre. L'interpréteur examinerait alors le numéro :

  • Si l' expression est positive, la fonction renvoie 1. Voici un exemple :
    SET @Nombre;
    DECLARE @numéro AS int = 24.75;
    SELECT SIGN(@Number) AS [signe de 1058];
    GO
    Sign
  • Si l' expression est null, la fonction renvoie la valeur 0
    SET @Nombre;
    DECLARE @ numéro comme int = 0;
    SELECT SIGN(@Number) AS [signe du numéro];
    GO
  • Si l'expression est négatif, la fonction renvoie -1
    SET @ nombre ; DECLARE @ numéro comme int =-57.05;
    SELECT SIGN(@Number) AS [signe de-57.05];
    GO
    The Sign of a Negative Number

Sur cette base, vous pouvez utiliser la fonction SIGN() pour savoir si une valeur est positive ou négative, null,: simplement transmettre la valeur (ou une variable) à SIGN() et un opérateur logique permet de vérifier son signe.Voici un exemple :

--Calcul carré
DECLARE @ côté sous Decimal(10,3),
        @ périmètre sous Decimal(10,3),
        @ espace sous Decimal(10,3) ;
SET @ côté = 48.126 ;
SET @ périmètre = côté @ * 4;
SET @ zone = côté @ * @ côté ;

IF SIGN(@Side) > 0

BEGIN PRINT 'Square Characteristics';
PRINT '-----------------------';
PRINT ' Side = N' + CONVERT(VARCHAR(10), @Side, 10) ;
PRINT ' périmètre = N ' + CONVERT(varchar(10),
      @périmètre, 10);
PRINT ' espace = N ' + CONVERT(varchar(10),
@ espace, 10);
END;
ELSE
PRINT «Vous devez fournir une valeur positive»;
GO

Voici un exemple de l'exécution de l'instruction :

Sign

Voici un autre exemple de l'exécution de l'instruction :

Sign

Notez que l'interpréteur agit différemment en réponse au résultat de la fonction SIGN().

La valeur absolue d'un nombre

Le système numérique décimal compte du moins l'infini à l'infini. Cela signifie que les numéros sont généralement négatifs ou positifs, en fonction de leur position de 0, ce qui est considéré comme neutre. Dans certaines opérations, le nombre considéré devra seulement être positif même si elle est fournie sous la forme d'un négatif. La valeur absolue d'un nombre x est x si le nombre est (déjà) positif. Si le nombre est négatif, sa valeur absolue est son équivalent positive. Par exemple, la valeur absolue de 12 est 12, tandis que la valeur absolue de © 12 est 12.

Pour obtenir la valeur absolue d'un nombre, vous pouvez utiliser la fonction ABS(). Sa syntaxe est la suivante :

ABS (expression)

Cette fonction prend une expression ou un nombre comme argument et renvoie sa valeur absolue. Voici un exemple :

DECLARE @ NumberOfStudents INTEGER ;
         SET @ NumberOfStudents =-32 ;
          SELECT ABS(@NumberOfStudents) AS [nombre d'étudiants];
        GO

Cela donnerait :

Abs

Le Plafond d'un Numéro

Envisagez une valeur décimale tels que 12.155. Ce numéro est entre entier 12 et 13 entier

De la même façon, à tenir compte un nombre comme © 24.06. Ce nombre est négatif, il est entre © 24 et © 25, avec © 24 étant supérieure.

En algèbre, le plafond d'un nombre est le nombre entier le plus proche est supérieur ou plus élevé que le nombre considéré. Dans le premier cas, le plafond des 12.155 est de 13 13 étant l'entier le plus proche supérieur ou égal à 12.155. Le plafond de © est 24.06 © 24.

Pour obtenir le plafond d'un nombre, Transact-SQL fournit la fonction CEILING(). Sa syntaxe est la suivante :

CEILING (expression)

Cette fonction prend comme argument un nombre ou une expression qui peut évaluer à un nombre. Après la conversion, si la fonction réussit, il renvoie un nombre de double précision qui est supérieure ou égale à l'expression. Voici un exemple :

DECLARE @Number1 number(6, 2),
        @Nombre2 number(6, 2)
        SET @Numero1 = 12.155;
        SET @Nombre2 =-24.06;
        SELECT CEILING(@Number1) AS [plafond de 12.155],
        CEILING(@Number2), AS [plafond de © 24.06];
        GO

Cela donnerait :

Ceiling

Voici une autre façon d'afficher les résultats ci-dessus :

DECLARE @Number1 Numeric(6, 2), @nombre2  @ Numéro1 as
SET Numeric(6, 2) = 12.155 ;
SET @ nombre2 =-24.06 ;
PRINT 'est le plafond de la 12.155' + CONVERT(varchar(10), CEILING(@Number1));
PRINT ' le plafond de © est 24.06 ' + CONVERT(varchar(10), CEILING(@Number2));
GO

Cela donnerait :

The ceiling of a number

L'étage d'un nombre

Pensez à deux nombres décimaux tels que 128.44 et-36.72. Le nombre 128.44 est entre 128 et 129 avec 128 étant le plus bas. Le numéro © 36.72 est entre © 37 et © 36 avec © 37 étant le plus bas. La valeur de nombre entier le plus bas, mais plus proche d'un nombre est dénommée sa parole. Sur cette base, le plancher de 128.44 est de 128. Le plancher de © est 36.72 © 37.

Pour prendre en charge la parole d'un certain nombre de trouver, Transact-SQL fournit la fonction FLOOR(). Sa syntaxe est la suivante :

FLOOR (expression)

La fonction FLOOR() prend comme argument une valeur numérique ou une expression qui peut être évaluée à un nombre. Si la fonction aboutit au cours de sa conversion, il génère le nombre entier qui est la parole de l'argument. Voici un exemple :

DECLARE @ Numéro1 en numérique (6, 2),
@Nombre2 en numérique (6, 2);
SET @Numéro1 = 128.44 ;
SET @ nombre2 = -36.72 ;
SELECT FLOOR(@Number1) AS [Floor of 128.44],
       FLOOR(@Number2), AS [Floor of © 36.72];
GO

Cela donnerait :

The floor of a number

L'Exposant d'u Numéro

Pour calculer la valeur d'un nombre exponentielle, Transact-SQL fournit la fonction EXP(). Sa syntaxe est la suivante :

EXP (expression)

Cette fonction prend un argument comme un nombre ou une expression qui peut être évaluée à un nombre. Voici un exemple :

DECLARE @numéro en numérique (6, 2);
SET @numéro = 6.48 ;
SELECT EXP(@Number) AS [exposant de 6.48]; GO

Cela donnerait:

Exponentiation

La puissance d'un nombre

La puissance d'un nombre est la valeur de ce numéro lors de la portée à un autre numéro. Cette opération est effectuée à l'aide de la formule suivante :

ReturnValue = x y

Pour prendre en charge la recherche de la puissance d'un nombre, Transact-SQL fournit la fonction POWER(). Sa syntaxe est la suivante :

POWER (x, y)

Cette fonction prend deux arguments requis. Le premier argument, x, est utilisé comme numéro de base pour être évaluée. Le deuxième argument, y, également appelé l'exposant, soulèvera x à cette valeur.Voici un exemple :

DECLARE @x Decimal(6, 2),
        @y Decimal(6, 2) ;
SET @x = 20.38 ;
SET @y = 4.12 ;
SELECT POWER (@ x, y @) AS [Power of 20.38 soulevées à 4.12];
GO

Cela donnerait:

Evaluating the Power of a Number

Le logarithme népérien d'un nombre

Pour aider à trouver le logarithme népérien d'un nombre, Transact-SQL fournit la fonction LOG(). Sa syntaxe est la suivante :

LOG (expression)

Cette fonction prend un argument comme un nombre ou une expression qui peut évaluer à un nombre. Après le calcul, elle renvoie le logarithme naturel de l'argument. Voici un exemple :

DECLARE @ numéro AS DECIMAL (6, 2);
SET @ numéro = 48.16;
SELECT LOG(@Number) AS [logarithme naturel de 48.16]; GO

Cela donnerait :

Finding the Natural Logarithm of a Number

Le Logarithme en Base 10 d'un Nombre

Pour calculer le logarithme base 10 d'un nombre, Transact-SQL fournit la fonction LOG10().Sa syntaxe est la suivante :

LOG10(Expression)

Le nombre à évaluer est transmis comme argument X. La fonction renvoie le logarithme en base 10 à l'aide de la formule :

y = log10x

qui est l'équivalent de

x = 10 y

Voici un exemple :

DECLARE @numéro AS DECIMAL (6, 2);
SET @numéro = 48.16 ;
SELECT LOG10(@Number) AS [logarithme en base 10 de 48.16];
GO

Cela donnerait :

Log10

La racine carré

Pour prendre en charge le calcul d'une racine carrée, Transact-SQL fournit la fonction sqrt(). Sa syntaxe est la suivante :

SQRT (expression)

Cette fonction prend un argument sous la forme d'un nombre décimal positif. Si le nombre est positif, après le calcul, la fonction renvoie la racine carrée de x. Voici un exemple :

SET @nombre;
DECLARE @numéro As Decimal(6, 2) = 48.16;
SELECT SQRT(@Number) AS [est la racine carrée de 48.16];
GO

Cela donnerait :

Sqrt

Si le nombre est négatif, vous serait une erreur. Voici un exemple :

Sqrt

Dans ce cas, vous pouvez utiliser une instruction de contrôle pour savoir si l' expression est positif. Voici un exemple :

DECLARE @numéro AS DECIMAL (6, 2);
SET @ numéro = 258.4062 ;
IF SIGN(@Number) > 0
    PRINT N'La racine carrée de 258.4062 est ' + CONVERT(varchar(12),
     SQRT(@Number));
ELSE
PRINT N'Vous devez fournir un nombre positif';
GO

Voici un exemple de l'exécution de l'instruction :

Sqrt

Voici un autre exemple de l'exécution de l'instruction :

Sqrt

Fonctions de mesure-based

 

Introduction

Un cercle est qu'une série de distincts face points placés chacun à une même distance exacte d'un autre point dénommé le Centre. La distance entre le centre et C à l'un de ces points équidistants est appelée le rayon, r. La ligne qui relie tous les points qui sont équidistants au centre est appelée la circonférence du cercle. Le diamètre est la distance entre deux points de la périphérie vers le Centre. En d'autres termes, un diamètre est de doubler le rayon.

Pour gérer les mesures et les autres opérations connexes, la circonférence est divisée en 360 parties. Chacune de ces parties est appelée un degré. L'unité utilisée pour représenter le degré est le degré, écrit en tant que ˚. Par conséquent, un cercle contient 360 degrés, ce qui est 360˚. La mesure de deux points A et D de la circonférence pourraient avoir 15 portions de la circonférence. Dans ce cas, cette mesure serait représente comme 15˚.

La distance entre deux équidistants points A et B est une forme ronde géométriquement définie comme un arc. Un angle est le rapport entre la distance entre deux points A et B de la circonférence divisé par le rayon r. Cela peut être écrite comme :

PI

La lettre п, également écrit comme PI, est un numéro utilisé dans divers calculs mathématiques. Sa valeur approximative est 3.1415926535897932. Le calculateur de Microsoft Windows, il représente comme 3.1415926535897932384626433832795. Pour obtenir la valeur de PI, Transact-SQL fournit la fonction PI(). Sa syntaxe est tout simplement :

PI()

Radians

Arc

Un angle est le rapport entre un arc sur le rayon. Car un angle est un ratio et non un © physique © mesure, ce qui signifie un angle n'est pas une dimension, elle est indépendante de la taille d'un cercle. Il est évident que l'angle représente le nombre de portions couverts par les trois points. Une meilleure unité utilisée pour mesurer un angle est le radian ou rad.

Si vous connaissez la valeur d'un angle en degrés et que vous souhaitez obtenir les radians, Transact-SQL fournit la fonction RADIANS(). Sa syntaxe est la suivante :

RADIANS (expression)

Cette fonction prend comme argument une valeur en degrés. Si elle réussit dans son calcul, elle renvoie la valeur de radians.

Un cycle est une mesure de la rotation autour du cercle. Étant donné que la rotation n'est pas nécessairement complète, selon le scénario, une mesure est effectuée en fonction de l'angle qui était couvert pendant la rotation. Un cycle peut couvrir une partie du cercle, dans lequel cas la rotation ne serait pas ont été accomplies. Un cycle peut également couvrir l'ensemble 360˚ du cercle et continuer il après. Un cycle est équivalent à la radian divisé par 2 * pi.

Degrés

Si vous connaissez les radians mais que vous souhaitez obtenir les degrés d'un angle, vous pouvez utiliser la fonction DEGREES(). Sa syntaxe est la suivante :

DEGREES (expression)

Cette fonction prend comme argument une valeur en radians. Si elle réussit, elle renvoie la valeur équivalente en degrés.

Les fonctions trigonométriques

 

Le cosinus d'un paramètre

Trigonometry

Pensez à la longueur de A à B, également appelée l'hypoténuse AB. Également envisager AC la longueur de A à C qui est le côté adjacent à point a. Le cosinus de l'angle au point A est le ratio AC/AB. Autrement dit, le rapport de la longueur adjacent, AC, sur toute la longueur de l'hypoténuse, AB :

Cosine

La valeur renvoyée, le ratio, est un nombre de double précision entre © 1 et 1.

Pour obtenir le cosinus d'un angle, vous pouvez appeler la fonction COS(). Sa syntaxe est la suivante :

COS(Expression)

L'angle à considérer est transmis comme argument pour cette fonction. Ensuite, la fonction calcule et renvoie son cosinus. Voici un exemple :

DECLARE @Angle AS DECIMAL (6, 3);
SET @Angle = 270 ;
SELECT COS(@Angle) AS [cosinus de 270];
GO

Cela donnerait :

Cos

Le sine d'un paramètre

Sine

Envisagez AB la longueur de A à B, également appelé l'hypoténuse à point a. Également envisager CB à la longueur du C de la B, ce qui est du côté opposé au point a. Le sinus représente le ratio de CB/AB; autrement dit, le rapport entre le côté opposé, CB sur l'hypoténuse AB.

Pour obtenir le sinus d'un angle, vous pouvez utiliser la fonction SIN() dont la syntaxe est :

SIN (expression)

L'angle à considérer est transmis comme argument. Après son calcul, la fonction renvoie le sinus de l'angle entre © 1 et 1.

Voici un exemple :

DECLARE @angle AS DECIMAL (6, 3);
SET @angle = 270 ; 
SELECT SIN(@Angle) AS [sine de 270]; 
GO

Cela donnerait :

Sin

La tangente d'un paramètre

Tangent

En géométrie, envisagez AC, la longueur de A à c. Également envisager BC la longueur de B et c. La tangente est le résultat de BC/AC, c'est-à-dire, le ratio de la Colombie-Britannique via AC.

Pour obtenir la tangente d'un angle, vous pouvez utiliser la fonction TAN() de Transact-SQL.Sa syntaxe est la suivante :

TAN(Expression)

Voici un exemple :

DECLARE @angle AS DECIMAL (6, 3); 
SET @angle = 270 ; 
SELECT TAN(@Angle) AS [tangente de 270]; 
GO

Cela donnerait :

Tan

Date et heure sur des fonctions

 

Introduction

Valeurs de date et d'heure sont très utilisés dans les applications de base de données. Elles impliquent des ventes, les feuilles de temps, les taxes, heures supplémentaires, etc.. Selon cette utilité, leurs activités sont pris en charge par diverses bibliothèques que vous utiliserez lors de l'élaboration de votre application. Sans être le plus élaborés sur cette question, Transact-SQL fournit son propre niveau de support pour les valeurs de date et d'heure.

Avant d'utiliser une date ou une valeur de temps dans un calcul, n'oubliez pas que vous devez tout d'abord obtenir d'une manière ou d'une autre. Vous pouvez définir une date ou une constante de temps dans votre application. Un exemple serait ' 1992/10/28 '. Vous pouvez déclarer une variable datetime2 et initialisez-la comme bon vous semble. Vous pouvez obtenir une date ou une heure à partir d'une autre fonction. Comme la dernière alternative, vous pouvez obtenir une date ou une heure provenant d'une autre application ou d'un utilisateur. Une fois que vous avez une date appropriée, vous pouvez l'utiliser.

La date du système actuel ou le temps

Une des manières que vous pouvez aider l'utilisateur avec la date et l'heure est d'obtenir la date ou l'heure actuelle. Par exemple, si vous créez une feuille de temps, lorsque l'utilisateur commence à l'utiliser, il serait commode remplir la partie de la feuille de temps avec ces valeurs prévisibles.

Pour obtenir la date et l'heure actuelle de l'ordinateur qui est à l'aide d'un utilisateur, vous pouvez utiliser la fonction GETDATE() de Transact-SQL. Sa syntaxe est la suivante :

GETDATE()

Cette fonction renvoie simplement la date et l'heure actuelles du système d'exploitation.

Date et heure Ajout

Une des principales opérations vous souhaiterez peut-être effectuer sur une date ou une valeur temporelle comprendrait lui ajoutant une valeur. Pour prendre en charge cette opération, Transact-SQL fournit la DATEADD() fonction. Sa syntaxe est la suivante :

DATEADD (TypeOfValue, ValueToAdd, DateOrTimeReferenced)

Le troisième argument de cette fonction est la valeur d'une date ou une heure à laquelle l'opération sera effectuée. Il peut être une valeur constante sous la forme de 'année/mois/jour' pour une date ou ' heures : minutes AM/PM ' pour une heure.

Le deuxième argument est la valeur qui sera ajoutée. Il doit être une constante entière, comme la valeur 8, ou un nombre à virgule flottante, telles que 4.06.

Lors de l'appel de cette fonction, vous devez tout d'abord spécifier le type de valeur que vous souhaitez ajouter. Ce type est transmis comme premier argument. Elle est utilisée comme suit :

  • Si vous souhaitez ajouter un certain nombre d'années à une date, spécifiez le TypeOfValue comme année yy ou aaaa (n'oubliez pas que SQL est sensible à la casse). Voici un exemple :

    DECLARE @ anniversaire sous datetime2 ;
    SET @ anniversaire = N ' 2002/10/02 ';
    SELECT DATEADD(yy, 4, @Anniversary) AS anniversaire ; 
    GO
    DateAdd
  • Si vous souhaitez ajouter un certain nombre de trimestres de l'année à une date, spécifiez le TypeOfValue comme trimestre ou d ou qq. Voici un exemple :

    DECLARE @ NextVacation AS datetime2 ; 
    SET @ NextVacation = N ' 2002/10/02 '; 
    SELECT DATEADD (quartier, 2, @ NextVacation) AS [vacances suivant]; 
    GO
    Adding Quarters to a Date
  • Si vous souhaitez ajouter un certain nombre de mois à une date, spécifiez le TypeOfValue comme mois m ou mm. L'exemple suivant ajoute 5 mois à sa date :
     
    DECLARE @ SchoolStart en tant que datetime2 ; 
    SET @ SchoolStart = N ' 2004/05/12 '; 
    SELECT DATEADD (m, 5, @ SchoolStart) AS [Démarrer School]; 
    GO
    Adding Quarters to a Date

De la même façon, vous pouvez ajouter des valeurs comme suit :

Type de valeur Abréviation Comme un résultat
Année yy Un certain nombre d'années sera ajouté à la valeur de date
aaaa
trimestre q Un certain nombre de trimestres de l'année sera ajouté à la valeur de date
qq
Mois m Un certain nombre de mois sera ajouté à la valeur de date
mm
Dayofyear y Un nombre de jours de l'année sera ajouté à la valeur de date
DY
Journée d Un certain nombre de jours sera ajouté à la valeur de date
jj
Semaine semaine Un certain nombre de semaines sera ajouté à la valeur de date
WW
Heure HH Un certain nombre d'heures sera ajouté à la valeur de temps
minute n Un certain nombre de minutes sera ajouté à la valeur de temps
mi
seconde s Un certain nombre de secondes sera ajouté à la valeur de temps
SS
milliseconde MS Un certain nombre de millisecondes sera ajouté à la valeur de temps

Date et heure soustraction

Une autre opération régulière effectuées sur une date ou une valeur temporelle se compose d'obtenir le nombre d'unités écoulé dans la plage de deux dates ou les deux valeurs de temps. Pour prendre en charge cette opération, Transact-SQL fournit la fonction DATEDIFF(). Sa syntaxe est la suivante :

DATEDIFF (TypeOfValue, StartDate, EndDate)

Cette fonction accepte trois arguments. Le second argument est la date de début ou l'heure de début de la plage à considérer. Le troisième argument est la fin ou dernière date ou l'heure de la gamme considérée. Le premier argument vous permet de spécifier le type de valeur, vous souhaitez que la fonction de produire. Cet argument utilise la même valeur que ceux de la fonction DATEADD() :

Type de valeur Abréviation Comme un résultat
Année yy La fonction renvoie le nombre d'années écoulées entre le début et les dates de fin
aaaa
trimestre q La fonction renvoie le nombre de trimestres de l'année qui se sont écoulées entre le début et les dates de fin
qq
Mois m La fonction renvoie le nombre de mois qui se sont écoulées entre le début et les dates de fin
mm
Dayofyear y La fonction renvoie le nombre de jours de l'année qui se sont écoulées entre le début et les dates de fin
DY
Journée d La fonction renvoie le nombre de jours qui se sont écoulées entre le début et les dates de fin
jj
Semaine semaine La fonction renvoie le nombre de semaines écoulées entre le début et les dates de fin
WW
Heure HH La fonction renvoie le nombre d'heures écoulées entre le début et la fin ou aux dates
minute n La fonction renvoie le nombre de minutes écoulées entre le début et la fin ou aux dates
mi
seconde s La fonction renvoie le nombre de secondes écoulées entre le début et la fin ou aux dates
SS
milliseconde MS La fonction renvoie le nombre de millisecondes écoulées entre le début et la fin ou aux dates

Voici un exemple qui calcule le nombre d'années qu'un employés a été avec la société :

DECLARE @DateLoué As datetime2,
        @CurrentDate As datetime2;
SET @DateLoué = N'1996/10/04'; 
SET @CurrentDate = GETDATE() ;
SELECT DATEDIFF(year, @DateHired, @CurrentDate) AS [expérience actuelle];
GO

Cela donnerait :

DateDiff

Practical LearningFormation pratique : Fin de la leçon

  1. Fermez la fenêtre de requête sans enregistrer le fichier.
  2. Dans l'Explorateur d'objets, sous le nœud de bases de données, cliquez avec le bouton droit de la souris sur Exercise1, puis cliquez sur Supprimer
  3. Dans la boîte de dialogue, cliquez sur OK

Résumé de la leçon

 

Divers exercices

  1. Écrire une fonction nommée ProcessPayroll1 qui prend le nombre d'heures travaillées au cours d'une semaine. Ensuite, la fonction renvoie une valeur qui représente des heures supplémentaires. Si l'employé travaille moins de 40 heures, il n'y a aucun des heures supplémentaires. Si l'employé a travaillé pendant plus de 40 heures, le numéro de plus de 40 est assimilé à des heures supplémentaires
  2. Écrire qu'une fonction nommée GetWeekdayName qui, face à une date, peuvent trouver et afficher le nom de la semaine pour cette date
  3. Écrire une fonction nommée GetNumberDays qui prend deux dates et renvoie le nombre de jours entre eux
  4. Écrire une fonction nommée AddNumberDays qui prend une date et un entier, puis elle renvoie que la date ajouté ce numéro
   
 

Previous Copyright © 2010 Yevol Next