Utiliser des opérations mathématiques dans des requêtes

Découvrez les fonctions mathématiques prises en charge dans Oracle NoSQL Database Cloud Service.

Les fonctions mathématiques sont utilisées pour effectuer des calculs mathématiques sur les arguments d'entrée. Ici, les arguments fournis sont des expressions qui se résolvent en nombres.

Vous pouvez appeler les fonctions mathématiques à partir des clauses SELECT/WHERE, ainsi que d'autres instructions Oracle NoSQL dans lesquelles les appels de fonction sont autorisés dans la syntaxe. Par exemple, vous pouvez fournir des fonctions mathématiques en tant qu'arguments pour Utiliser des fonctions d'agrégation.

Les fonctions suivantes sont prises en charge dans Oracle NoSQL Database Cloud Service :

Tableau 1 - Fonctions mathématiques

Fonction	Description
abs(n)	Renvoie la valeur absolue de n.
acos(n)	Renvoie l'arc cosinus de n exprimé en radians.
asin(n)	Renvoie l'arc sinus de n (n exprimé en radians).
atan(n)	Renvoie l'arc tangente de n, exprimé en radians.
atan2(n1,n2)	Renvoie la tangente d'arc des arguments n1 et n2 exprimés en radians.
plafond(n)	Renvoie le plus petit entier qui est supérieur ou égal à n.
cos(n)	Renvoie le cosinus d'un angle n spécifié en radians.
cot(n)	Renvoie le cotangent d'un angle n spécifié en radians.
degrés(n)	Convertit n de radians en degrés.
e()	Renvoie la valeur du numéro Euler e.
exp(n)	Renvoie la valeur exponentielle de l'expression n.
étage(n)	Renvoie le plus grand entier inférieur ou égal à n.
ln(n)	Renvoie la valeur logarithmique naturelle (base e) de n.
log(n,b)	Renvoie la valeur de base logarithmique b de n.
log10(n)	Renvoie la valeur logarithmique de base 10 de n.
pi()	Renvoie la valeur de pi.
puissance(n2,n1)	Renvoie la valeur de n2 portée à l'alimentation n1.
radians(n)	Convertit n de degrés en radians.
Rand()	Renvoie un nombre pseudo-aléatoire compris entre zéro et un.
rond(n [,d])	Arrondit n à d à droite de la virgule.
signe(n)	Renvoie le signe de n.
sin(n)	Renvoie le sinus d'un angle n spécifié en radians.
qrt(n)	Renvoie la racine carrée de n.
bronzage(n)	Renvoie la tangente d'un angle n spécifié en radians.
trunc(n [,d])	Renvoie la valeur de n tronquée à d décimales.

Remarque :

• Les noms des fonctions mathématiques respectent la casse.

• Toutes les fonctions mathématiques attendent des types numériques (entier, long, float, double et nombre) comme arguments. Ces fonctions renvoient NULL dans les cas suivants. Ici, la valeur NULL fait référence à SQL NULL, sauf indication contraire.

  • Tous les arguments sont résolus en NULL.

  • L'un des arguments est un champ d'une colonne JSON dont la valeur est NULL, c'est-à-dire JSON NULL.

  • L'un des arguments est un champ d'une colonne JSON qui n'existe pas.

  • L'un des arguments est un champ de la collection JSON, qui n'existe pas.

  • Tous les arguments ne sont pas résolus en un type numérique.

• Lors de l'utilisation de fonctions trigonométriques telles que sin(n), cos(n), etc., vous devez spécifier la valeur d'entrée en radians. Vous pouvez convertir un angle de degrés en radians à l'aide de la fonction radians(n). De même, pour les fonctions trigonométriques inverses telles que asin(n), acos(n), etc., vous pouvez convertir la valeur radians résultante en degrés à l'aide de la fonction degrees(n).

Pour suivre les exemples des sections, vous pouvez créer les tables et charger les données comme décrit dans la section Exemples supplémentaires.

fonction abs

La fonction abs renvoie la valeur absolue de l'expression d'entrée.

Exemple 1 - fonction abs

SELECT abs(n) FROM Userstocks

Valeur de n	Sortie
10	10
-10	10
1,67	1,67
-1,67	1,67

fonction cosinus arc

La fonction acos est une fonction trigonométrique inverse. La fonction acos renvoie l'arc cosinus (inverse de cosinus) de l'expression d'entrée.

Exemple 1 - fonction arc cosinus

SELECT acos(n) FROM Archery

Valeur de n	Sortie
1	0
0	1,571
SQRt(3)/2	0,524
0,5	1,047
-1	3,142

fonction sinus arc

La fonction asin est une fonction trigonométrique inverse. La fonction asin renvoie l'arc sinusoïdal (inverse de sinus) de l'expression d'entrée.

Exemple 1 - fonction sinusoïdale arc

SELECT asin(n) FROM Archery

Valeur de n	Sortie
1	1,571
SQRt(3)/2	1,047
0,5	0,524
-1	-1,571

fonction arc tan

La fonction atan est une fonction trigonométrique inverse. La fonction atan renvoie l'arc tangent (inverse de la tangente) de l'expression d'entrée.

Exemple 1 - fonction arc tan

SELECT atan(n) FROM Archery

Valeur de n	Sortie
1	0,785
SQRt(3)	1,047

fonction arc tan2

La fonction atan2 est une fonction trigonométrique inverse. La fonction atan2 est une fonction de tangente d'arc à deux arguments (inverse de tan), qui renvoie la tangente d'arc d'une coordonnée ou d'un point dans l'espace bidimensionnel (n1, n2) calculé comme atan(n2/n1).

Exemple 1 - fonction arc tan2

SELECT atan2(n1,n2) FROM Archery

Valeur de n1	Valeur de n2	Sortie
1	1	0,785
1	SQRt(3)	1,047
2	0	1,571

fonction ceil

La fonction ceil renvoie le plus petit entier supérieur ou égal à l'expression indiquée.

Exemple 1 - fonction ceil

SELECT ceil(n) FROM Userstocks

Valeur de n	Sortie
1,34	2
-1,34	-1
pi()	4

fonction cosinus

La fonction cos est une fonction trigonométrique. La fonction cos renvoie le cosinus d'un angle spécifié en radians.

Exemple 1 - fonction cosinus

SELECT cos(n) FROM Archery

Valeur de n	Sortie
0	1
radians(90)	6.123233995736766E-17
pi()	-1

fonction cotangente

La fonction cot est une fonction trigonométrique. La fonction cot renvoie le cotangent d'un angle spécifié en radians.

Exemple 1 - fonction cotangente

SELECT cot(n) FROM Archery

Valeur de n	Sortie
0	Infini
radians(90)	6.123233995736766E-17
pi()/4	1

fonction degrés

La fonction degrees convertit l'expression indiquée de radians en degrés.

Exemple 1 - fonction degrés

SELECT degrees(n) FROM Archery

Valeur de n	Sortie
pi()/2	90
0	0

Fonction d'Euler

La fonction e renvoie la valeur du numéro Euler e, c'est-à-dire 2.718281828459045.

Exemple 1 - Fonction Euler

SELECT e() AS EULER FROM Archery

Sortie :

+-----------+-------------------+
| EULER     | 2.718281828459045 |
+-----------+-------------------+

fonction exp

La fonction exp renvoie la valeur exponentielle de l'expression donnée, c'est-à-dire e augmentée à la puissance de l'expression spécifiée. Ici, e est la base du logarithme naturel et a la valeur 2.718281828459045.

Exemple 1 - fonction exp

SELECT exp(n) FROM PHtable

Valeur de n	Sortie
0	1
2	7,389
-2	0,135

fonction plancher

La fonction floor renvoie le plus grand entier inférieur et égal à l'expression indiquée.

Exemple 1 - fonction plancher

SELECT floor(n) FROM Userstocks

Valeur de n	Sortie
1,34	1
-1,34	-2
pi()	3

fonction ln

La fonction ln renvoie la valeur logarithmique naturelle (base e) de l'expression indiquée.

Exemple 1 - fonction ln

SELECT ln(n) FROM PHtable

Valeur de n	Sortie
1	0
10	2,303
1.0E-7	-16,118

fonction log

La fonction log renvoie la valeur logarithmique avec la base indiquée pour l'expression donnée.

Exemple 1 : fonction de journal

SELECT log(n,b) FROM PHtable

Valeur de n	Valeur de b	Sortie
2	2	1
81	3	4
255	5	3,443

fonction log10

La fonction log10 renvoie la valeur logarithmique avec la base 10 pour l'expression indiquée.

Exemple 1 - fonction log10

SELECT log10(n) FROM PHtable

Valeur de n	Sortie
1	0
10	1
1.0E-7	-7

fonction pi

La fonction pi renvoie la valeur de pi, c'est-à-dire 3.141592653589793.

Exemple 1 - fonction pi

SELECT pi() AS PI FROM Archery

Sortie :

+-----------+-------------------+
| PI        | 3.141592653589793 |
+-----------+-------------------+

fonction d'alimentation

La fonction pow renvoie la valeur de la première expression augmentée à la puissance de la deuxième expression.

Exemple 1 - fonction d'alimentation

SELECT pow(n2,n1) FROM PHtable

Valeur de n	Valeur de b	Sortie
2	4	16
2	0	1
-0,5	4	0,062
0,5	-4	16

fonction radians

La fonction radians convertit l'expression indiquée de degrés en radians.

Exemple 1 - fonction radians

SELECT radians(n) FROM Archery

Valeur de n	Sortie
180	3,142
0	0

fonction aléatoire

La fonction rand renvoie un nombre pseudo-aléatoire positif. La valeur résultante peut être supérieure ou égale à zéro et inférieure à un.

Exemple 1 - fonction aléatoire

SELECT rand() AS RANDOM from Archery WHERE sim=1

Sortie :

+-----------+-------------------+
| RANDOM    | 0.891655403699787 |
+-----------+-------------------+

fonction Round

La fonction round arrondit la valeur d'une expression d'entrée à la décimale indiquée à droite de la décimale.

Exemple 1 - fonction ronde

SELECT round(n,d) FROM Userstocks

Valeur de n	Valeur de d	Sortie
100,331	2	100,33
100,367	2	100,37
111,567	0,5	112
111,567	4	111,567
10,361	0 ou non spécifié	10
111,331	-2	100
111,331	-4	0
-100,331	2	-100,33
-111,331	-2	-100

fonction sign

La fonction sign renvoie le signe de l'expression spécifiée, c'est-à-dire zéro si l'argument est zéro, 1 si l'argument est supérieur à zéro et -1 si l'argument est inférieur à zéro.

Exemple 1 - fonction de signe

SELECT sign(n) FROM PHtable

Valeur de n	Sortie
1,89	1
-1,89	-1
0	0
sin(3*pi()/2)	-1

fonction sinus

La fonction sin est une fonction trigonométrique. La fonction sin renvoie le sinus d'un angle spécifié en radians.

Exemple 1 - fonction sinusoïdale

SELECT sin(n) FROM Archery

Valeur de n	Sortie
radians(90)	1
pi()/4	0,707
3*pi()/2	-1

fonction de racine carrée

La fonction sqrt renvoie la racine carrée de l'expression indiquée.

Exemple 1 - fonction racine carrée

SELECT sqrt(n) FROM Archery

Valeur de n	Sortie
16	4
12.57/pi()	2

fonction tangente

La fonction tan est une fonction trigonométrique. La fonction tan renvoie la tangente d'un angle spécifié en radians.

Exemple 1 - fonction tangente

SELECT tan(n) FROM Archery

Valeur de n	Sortie
0	0
radians(90)	1,633123935319537E16
pi()/4	1

fonction truncate

La fonction trunc tronque la valeur d'une expression d'entrée à la décimale indiquée à droite de la virgule.

Exemple 1 : fonction de troncation

SELECT trunc(n,d) FROM Userstocks

Valeur de n	Valeur de d	Sortie
111,567	0 ou non spécifié	100
111,567	2	100,56
111,567	3	111,567
111,567	-2	100
111,567	-3	0
-111,567	2	-100,567
-111,567	-1	-110

Exemples utilisant l'API QueryRequest

Vous pouvez utiliser l'API QueryRequest et appliquer des fonctions SQL pour extraire des données d'une table NoSQL semblable aux fonctions d'horodatage et aux fonctions de chaîne.

Les fragments de code suivants montrent comment utiliser des fonctions mathématiques pour interroger une table Userstocks.

• Java
• Python
• Go
• Node.js
• C#

Pour exécuter la requête, utilisez l'API NoSQLHandle.query().

String queryStatement =
    "SELECT stock, " +
    "ceil(units * sellRate - units * buyRate) AS PROFIT, " +
    "abs(units * sellRate - units * buyRate) AS TURNOVER, " +
    "round(abs(units * sellRate - units * buyRate) * 0.5 / 100, 2) " +
    "AS BROKERAGE " +
    "FROM Userstocks";

try (QueryRequest request =
         new QueryRequest().setStatement(queryStatement);
     QueryIterableResult results = handle.queryIterable(request)) {

    for (MapValue row : results) {
        System.out.println(row);
    }
}

Pour exécuter votre requête, utilisez la méthode borneo.NoSQLHandle.query().

query_statement = '''
    SELECT stock,
           ceil(units * sellRate - units * buyRate) AS PROFIT,
           abs(units * sellRate - units * buyRate) AS TURNOVER,
           round(
               abs(units * sellRate - units * buyRate) * 0.5 / 100,
               2
           ) AS BROKERAGE
    FROM Userstocks
'''

request = QueryRequest().set_statement(query_statement)

while True:
    result = handle.query(request)

    for row in result.get_results():
        print(row)

    if request.is_done():
        break

Pour exécuter une requête, utilisez la fonction Client.Query.

queryStatement := `
    SELECT stock,
           ceil(units * sellRate - units * buyRate) AS PROFIT,
           abs(units * sellRate - units * buyRate) AS TURNOVER,
           round(
               abs(units * sellRate - units * buyRate) * 0.5 / 100,
               2
           ) AS BROKERAGE
    FROM Userstocks`

prepareRequest := &nosqldb.PrepareRequest{
    Statement: queryStatement,
}

prepareResult, err := client.Prepare(prepareRequest)
if err != nil {
    fmt.Println("Prepare failed:", err)
    return
}

queryRequest := &nosqldb.QueryRequest{
    PreparedStatement: &prepareResult.PreparedStatement,
}

for {
    queryResult, err := client.Query(queryRequest)
    if err != nil {
        fmt.Println("Query failed:", err)
        return
    }

    rows, err := queryResult.GetResults()
    if err != nil {
        fmt.Println("Unable to get results:", err)
        return
    }

    for _, row := range rows {
        fmt.Println(jsonutil.AsJSON(row.Map()))
    }

    if queryRequest.IsDone() {
        break
    }
}

Pour exécuter une requête, utilisez la méthode query.

const queryStatement = `
    SELECT stock,
           ceil(units * sellRate - units * buyRate) AS PROFIT,
           abs(units * sellRate - units * buyRate) AS TURNOVER,
           round(
               abs(units * sellRate - units * buyRate) * 0.5 / 100,
               2
           ) AS BROKERAGE
    FROM Userstocks`;

const options = {};

do {
    const result = await handle.query(queryStatement, options);

    for (const row of result.rows) {
        console.log(row);
    }

    options.continuationKey = result.continuationKey;
} while (options.continuationKey);

Pour exécuter une requête, vous pouvez appeler la méthode QueryAsync ou la méthode GetQueryAsyncEnumerable et itérer sur l'énumérable asynchrone obtenu.

private const string QueryStatement = @"
    SELECT stock,
           ceil(units * sellRate - units * buyRate) AS PROFIT,
           abs(units * sellRate - units * buyRate) AS TURNOVER,
           round(
               abs(units * sellRate - units * buyRate) * 0.5 / 100,
               2
           ) AS BROKERAGE
    FROM Userstocks";

var queryEnumerable =
    client.GetQueryAsyncEnumerable(QueryStatement);

await foreach (var result in queryEnumerable)
{
    foreach (var row in result.Rows)
    {
        Console.WriteLine(row.ToJsonString());
    }
}

Autres exemples

Apprendre à utiliser des fonctions mathématiques dans des applications.

Exemple 1 - Appliquer des fonctions mathématiques pour extraire des transactions intrajournalières d'une application de trading

Prenons un tableau Userstocks contenant les transactions intrajournalières d'un négociant en actions dans une application de négociation.

Le langage DDL de table se présente comme suit :

CREATE TABLE Userstocks (id INTEGER,
                     stock STRING,
                     units INTEGER,
                     buyRate DOUBLE,
                     sellRate DOUBLE,
PRIMARY KEY (id))

Le champ id contient l'ID de la société, le champ stock contient le nom de la société dans laquelle l'utilisateur dispose d'options d'achat d'actions, le champ units contient le nombre d'actions détenues par l'utilisateur, buyRate le prix auquel l'utilisateur a acheté les actions et sellRate le prix auquel l'utilisateur vend ses actions.

Insérez des exemples de lignes dans la table :

INSERT into Userstocks VALUES (1, "company1", 100, 10.2, 11.5)
INSERT into Userstocks VALUES (2, "company2", 20, 15, 14.7)

Vous pouvez utiliser la requête suivante pour appliquer des fonctions mathématiques et extraire les détails de transaction requis de la table :

SELECT stock,
ceil(units*sellRate-units*buyRate) AS PROFIT,
abs(units*sellRate-units*buyRate) AS TURNOVER,
round(abs(units*sellRate-units*buyRate)*0.5/100, 2) AS BROKERAGE
FROM Userstocks

Explication : dans la requête ci-dessus, vous extrayez les frais de rotation, de bénéfice/perte et de courtage du jour. Vous calculez le bénéfice/la perte à l'aide des expressions arithmétiques données et appliquez la fonction de plafond pour obtenir le résultat en tant que valeur entière la plus proche. Vous calculez le bénéfice/perte et appliquez la fonction d'onglets pour calculer la rotation de chaque transaction. Vous calculez les frais de courtage en appliquant 0,5 % à chaque rotation et arrondissez le résultat à deux décimales à l'aide de la fonction d'arrondi.

Sortie :

{"stock":"company2","PROFIT":-6.0,"TURNOVER":6.0,"BROKERAGE":0.03}
{"stock":"company1","PROFIT":131.0,"TURNOVER":130.0000000000001,"BROKERAGE":0.65}

Exemple 2 - Appliquer des fonctions mathématiques pour calculer la distance de prise de vue dans une application de jeu

Prenons l'exemple d'une table Archery contenant des données pour la prise de vue de cible dans une application de jeu.

Le langage DDL de table se présente comme suit :

CREATE TABLE Archery (sim INTEGER,
                     angle DOUBLE,
                     elevation DOUBLE,
PRIMARY KEY (sim) )

Le champ sim identifie le nombre de simulations, le champ angle inclut différents angles (en degrés) auxquels un joueur peut viser une cible, le champ elevation contient la hauteur (en mètres) à laquelle la cible est placée.

Insérez des exemples de lignes dans la table :

INSERT INTO Archery VALUES (1, 30, 50)
INSERT INTO Archery VALUES (2, 45, 50)
INSERT INTO Archery VALUES (3, 70, 95)

Vous pouvez appliquer des fonctions mathématiques dans la requête suivante pour calculer la distance de prise de vue pour différents angles et élévations de la cible.

SELECT sim, trunc(elevation/sin(radians(angle)),2) AS SLOPE FROM Archery ORDER BY
    sim

Explication : pour atteindre une cible placée à une certaine altitude, le joueur vise un angle et tire sur une certaine distance. Ces éléments forment un côté d'un triangle rectangle, un angle aigu et une hypoténuse. Dans cette requête, vous calculez la distance de prise de vue pour différentes combinaisons d'altitude et d'angles de cible en fonction de la position du joueur par rapport à la cible. La fonction radans permet de convertir les angles en radians et de calculer la valeur sinusoïdale à l'aide de la fonction sinusoïdale. Vous divisez l'altitude par la valeur sinusoïdale pour calculer la distance et tronquer le résultat à deux décimales à l'aide de la fonction tronquer.

Sortie :

{"sim":1,"SLOPE ":100.0}
{"sim":2,"SLOPE ":70.71}
{"sim":3,"SLOPE ":101.09}

Exemple 3 - Utiliser les fonctions mathématiques pour calculer la valeur PH pour une solution donnée

Considérons un PHtable contenant la concentration d'ions d'hydrogène pour différentes solutions.

Le langage DDL de table se présente comme suit :

CREATE TABLE PHtable (id INTEGER,
                    sampleName STRING,
                    hIons DOUBLE,
                    phValue DOUBLE,
PRIMARY KEY (id) )

Le champ id contient l'identificateur de l'échantillon de solution, le champ sampleName contient le nom de l'échantillon donné, le champ hIons est la concentration d'ions hydrogène en moles par litre de liquide et le champ phValue est la valeur PH de la solution. Vous pouvez utiliser la valeur hIons pour calculer la valeur phValue d'une solution. Vous initialisez la colonne phValue sur NULL lors de l'insertion de données dans la table.

Insérez des exemples de lignes dans la table :

INSERT INTO PHtable VALUES (1, "sample1", 0.0063095734448019, NULL)
INSERT INTO PHtable VALUES (2, "sample2", 5.0118723362727E-9, NULL)
INSERT INTO PHtable VALUES (3, "sample3", 1.0E-7, NULL)

Vous pouvez utiliser les fonctions mathématiques pour calculer la valeur PH d'une solution donnée et mettre à jour la table à l'aide de l'interrogation suivante :

UPDATE PHtable SET phValue=trunc((log10(1/hIons)),1) where id=1 RETURNING
    *

Explication : la valeur PH indique la force des acides ou des bases dans une solution. Dans cette requête, vous utilisez la fonction log10 pour calculer la valeur PH d'une solution à l'aide de la formule PH=log10(1/hIons). La valeur renvoyée par la fonction étant double, vous utilisez la fonction de troncation pour tronquer le résultat à une décimale. Vous utilisez l'instruction UPDATE pour définir la valeur PH résultante dans le champ phValue pour la solution spécifiée.

Sortie :

{"id":1,"sampleName":"sample1","hIons":0.0063095734448019,"phValue":2.2}

Vous pouvez également utiliser les fonctions mathématiques dans la clause WHERE. Dans cet exemple, vous trouverez les échantillons acides (PH < 7) à l'aide de la requête suivante :

SELECT sampleName AS ACIDIC FROM PHtable WHERE trunc((log10(1/hIons)),1) <
    7.0

Sortie :

{"ACIDIC":"sample1"}