Utilisation des opérations mathématiques dans les interrogations

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 qu'à partir d'autres instructions NoSQL Oracle où les appels de fonction sont autorisés dans la syntaxe. Par exemple, vous pouvez fournir des fonctions mathématiques en tant qu'arguments à Utilisation 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)	Retourne la valeur absolue de n.
acos(n)	Retourne le cosinus de l'arc de n exprimé en radians.
asin(n)	Retourne le sinus de l'arc de n exprimé en radians.
atan(n)	Retourne la tangente inverse de n exprimée en radians.
atan2(n1,n2)	Retourne la tangente inverse des arguments n1 et n2 exprimés en radians.
plafond(n)	Retourne le plus petit nombre entier supérieur ou égal à n.
cos(n)	Retourne le cosinus d'un angle n spécifié en radians.
lit(n)	Retourne le cotangent d'un angle n spécifié en radians.
degrés(n)	Convertit n de radians en degrés.
e()	Retourne la valeur du numéro Euler e.
exp(n)	Retourne la valeur exponentielle de l'expression n.
étage(n)	Retourne le plus grand entier inférieur ou égal à n.
ln(n)	Retourne la valeur logarithmique naturelle (e de base) de n.
journal(n,b)	Retourne la valeur b de base logarithmique de n.
log10(n)	Retourne la valeur de base logarithmique 10 de n.
pi()	Retourne la valeur de pi.
puissance (n2,n1)	Retourne la valeur de n2 élevée à la puissance n1.
radians(n)	Convertit n de degrés en radians.
rand()	Renvoie un nombre pseudo-aléatoire compris entre zéro et un.
ronde(n [,d])	Arrondit n à d chiffres après la virgule décimale.
signe(n)	Retourne le signe de n.
sin(n)	Retourne le sinus d'un angle n spécifié en radians.
sqrt(n)	Retourne la racine carrée de n.
tan(n)	Retourne la tangente d'un angle n spécifié en radians.
trunc(n [,d])	Retourne la valeur de n tronquée à d décimales.

Note :

• Les noms de fonctions mathématiques sont sensibles à la casse.

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

  • L'un des arguments est résolu à 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.

  • Aucun des arguments ne se résout 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 de 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 retourne 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

arc cosinus

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

Exemple 1 - fonction cosinus arc

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 sinusoïdale d'arc

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

Exemple 1 - fonction sinusoïdale d'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 de bronzage d'arc

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

Exemple 1 - fonction de bronzage d'arc

SELECT atan(n) FROM Archery

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

arc tan2 fonction

La fonction atan2 est une fonction trigonométrique inverse. La fonction atan2 est une fonction à deux arguments arc tangent (inverse de tan), qui retourne l'arc tangent d'une coordonnée ou d'un point dans un 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 retourne le plus petit nombre entier supérieur ou égal à l'expression spécifiée.

Exemple 1 - fonction du plafond

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 retourne 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.1232333995736766E-17
pi()	-1

fonction cotangente

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

Exemple 1 - fonction cotangente

SELECT cot(n) FROM Archery

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

fonction degrés

La fonction degrees convertit l'expression spécifié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 retourne 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 retourne la valeur exponentielle de l'expression indiquée, c'est-à-dire e, élevé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 retourne le plus grand nombre entier inférieur ou égal à l'expression spécifiée.

Exemple 1 - Fonction plancher

SELECT floor(n) FROM Userstocks

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

Dans la fonction

La fonction ln retourne la valeur logarithmique naturelle (base e) de l'expression spécifié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 retourne la valeur logarithmique avec la base spécifiée pour l'expression indiquée.

Exemple 1 - Fonction log

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 retourne la valeur logarithmique avec la base 10 pour l'expression spécifié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 retourne la valeur pi, c'est-à-dire 3.141592653589793.

Exemple 1 - fonction pi

SELECT pi() AS PI FROM Archery

Sortie :

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

fonction de puissance

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

Exemple 1 - fonction de puissance

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 spécifié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 retourne 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 ronde

La fonction round arrondit la valeur d'une expression d'entrée aux décimales spécifiées à droite du point décimal.

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 de signe

La fonction sign retourne 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
péché(3*pi()/2)	-1

fonction sinusoïdale

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

Exemple 1 - fonction sinus

SELECT sin(n) FROM Archery

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

fonction racine carrée

La fonction sqrt retourne la racine carrée de l'expression spécifié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 retourne 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

tronquer la fonction

La fonction trunc tronque la valeur d'une expression d'entrée aux décimales spécifiées à droite du point décimal.

Exemple 1 - Tronquer la fonction

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 similaire aux fonctions d'horodatage et aux fonctions de chaîne.

Les extraits de code suivants montrent comment utiliser les fonctions mathématiques pour interroger la table Userstocks.

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

Pour exécuter une interrogation, 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 interrogation, 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 interrogation, 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 interrogation, 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 interrogation, vous pouvez appeler la méthode QueryAsync ou appeler la méthode GetQueryAsyncEnumerable et effectuer une itération sur l'énumérable asynchrone résultant.

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());
    }
}

Exemples supplémentaires

Apprenez à utiliser les fonctions mathématiques dans les applications.

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

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

L'énoncé LDD de la table est le suivant :

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 a des options d'achat d'actions, le champ units contient le nombre d'actions détenues par l'utilisateur, buyRate est le prix auquel l'utilisateur a acheté les actions et sellRate est le prix auquel l'utilisateur vend ses actions.

Insérez des exemples de ligne 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 l'interrogation 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 l'interrogation ci-dessus, vous extrayez le chiffre d'affaires, les profits et pertes et les frais de courtage du jour. Vous calculez les profits/pertes à l'aide des expressions arithmétiques indiquées et appliquez la fonction plafond pour obtenir le résultat en tant que valeur entière la plus proche. Vous calculez les profits et les pertes et vous appliquez la fonction d'onglets pour calculer le roulement pour chaque transaction. Vous calculez les frais de courtage en appliquant 0,5 % sur chaque chiffre d'affaires et arrondissez le résultat à deux décimales à l'aide de la fonction arrondir.

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 cible dans une application de jeu.

L'énoncé LDD de la table est le suivant :

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 ligne 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 l'interrogation 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, d'un angle aigu et d'une hypoténuse. Dans cette interrogation, vous calculez la distance de prise de vue pour diverses combinaisons d'élévation et d'angles de la cible en fonction de la position du joueur par rapport à la cible. Vous utilisez la fonction radians pour convertir les angles en radians et calculer la valeur sinusoïdale à l'aide de la fonction sinusoïdale. Vous divisez l'élévation 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 d'une solution donnée

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

L'énoncé LDD de la table est le suivant :

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 d'hydrogène en moles par litre du 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 à la valeur NULL lors de l'insertion de données dans la table.

Insérez des exemples de ligne 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 résistance des acides ou des bases dans une solution. Dans cette interrogation, vous utilisez la fonction log10 pour calculer la valeur PH d'une solution à l'aide de la formule PH=log10(1/hIons). Comme la valeur de retour de la fonction est double, vous utilisez la fonction tronquer pour tronquer le résultat à une décimale. Vous utilisez l'énoncé 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"}