Comment puis-je calculer le nombre de décimales dans SQL?

J'ai une colonne de X qui est plein de flotte avec des décimales de lieux allant de 0 (pas de décimales) à 6 (maximum). Je peux compter sur le fait qu'il n'existe pas de flotte avec plus de 6 décimales. Étant donné que, comment puis-je faire une nouvelle colonne telle qu'il me dit combien de chiffres viennent après la virgule?

J'ai vu des fils de suggérer que j'ai utiliser CAST pour convertir le flotteur à une chaîne de caractères, puis analyser la chaîne de compter la longueur de la chaîne qui vient après la virgule. Est-ce la meilleure façon de procéder?

regardez votre marquage. Vous venez de recréer float, j'ai passé les dernières 48 heures nukiung ... encore une fois. :p
Désolé Charles... va garder les deux yeux ouverts la prochaine fois! 🙂

OriginalL'auteur phan | 2013-02-05

18

Vous pouvez utiliser quelque chose comme ceci:
```
declare @v sql_variant

set @v=0.1242311

select SQL_VARIANT_PROPERTY(@v, 'Scale') as Scale
```
Ce sera le retour de 7.

J'ai essayé de faire la requête ci-dessus travailler avec un float colonne, mais ne pouvait pas le faire fonctionner comme prévu. Il ne fonctionne qu'avec un sql_variant colonne comme vous pouvez le voir ici: http://sqlfiddle.com/#!6/5c62c/2

Donc, j'ai essayé de trouver une autre façon et de construction sur ce réponse, j'ai obtenu ceci:
```
SELECT value,
LEN(
    CAST(
         CAST(
              REVERSE(
                      CONVERT(VARCHAR(50), value, 128)
                     ) AS float
             ) AS bigint
        )
   ) as Decimals
FROM Numbers
```
Voici un SQL Violon de tester ceci: http://sqlfiddle.com/#!6/23d4f/29

De compte pour ce petit caprice, voici une version modifiée qui va gérer le cas lorsque le flotteur de la valeur n'a pas de partie décimale:
```
SELECT value,
       Decimals = CASE Charindex('.', value)
                    WHEN 0 THEN 0
                    ELSE
           Len (
            Cast(
             Cast(
              Reverse(CONVERT(VARCHAR(50), value, 128)) AS FLOAT
                 ) AS BIGINT
                )
               )
                    END
FROM   numbers
```
Voici l'accompagnement SQL Violon: http://sqlfiddle.com/#!6/10d54/11

Truc génial, même si je pense que tu veux dire Scale, pas Precision.
Vous avez raison. Scale.
Pouvez-vous l'utiliser sur une colonne de flotter?
Autant que je sache, non pas avec un simple requête SQL, la set sera de définir la variante de type numérique avec 7 décimales (c'est à dire le minimum requis pour stocker la valeur), et Scale sera de retour à la précision de la type, et non pas la valeur. Lorsque vous sélectionnez une colonne de table, vous aurez l'Échelle de la colonne type, et non pas à l'échelle de la réalité.
Je viens de trouver un petit caprice. Si j'ai ZÉRO décimales comme mentionné dans ma question, alors que les valeurs 1, 12, 123, et 1234 donnera 1, 2, 3, 4, résultats, alors qu'en fait le résultat doit être de 0. Fondamentalement, l'inversion et coulée de type bigint couper chiffres ne fonctionne pas si il y a 0 décimales comme mentionné dans la question. Suis-je le droit? Je vous remercie.

OriginalL'auteur Leniel Maccaferri
3

Un flotteur est seulement de représenter un nombre réel. Il n'y a pas de sens pour le nombre de décimales d'un nombre réel. En particulier, le nombre réel de 3 peut avoir six décimales, 3.000000, c'est juste que toutes les décimales sont à zéro.

Vous pouvez avoir une conversion d'affichage qui ne montre pas le droit de la plupart des valeurs zéro décimal.

Remarque aussi que la raison pour laquelle il y a un maximum de 6 chiffres après la virgule, c'est que la septième est imprécis, de sorte que la conversion d'affichage ne s'engagera pas à un septième décimale de la valeur.

Notez également que les flotteurs sont stockés en binaire, et en fait ils ont binaire places vers la droite d'un binaire point. L'affichage des décimales est une approximation de la binaire rationnelle dans le flotteur de stockage qui est à son tour une approximation d'un nombre réel.

De sorte que le point est, il n'y a vraiment aucune idée du nombre de décimales d'une valeur flottante. Si vous ne la conversion d'une chaîne de caractères (en utilisant la FONTE), vous pouvez compter le nombre de décimales. Qui serait vraiment la meilleure approche pour ce que vous essayez de faire.

Vous ne pouvez pas vraiment trouver le nombre de chiffres après la virgule si vous faites la conversion en chaîne de caractères. La Conversion sera arrondi ou tronqué le nombre de décimales.
Je suis venu avec une meilleure façon de l'expliquer. Dans la console ruby, en tapant "1.1 - 1.0" résultats dans 0.10000000000000009. Alors, combien de décimales? @ARS est droit, généralement conversion en chaîne de caractères fonctions de tronquer le nombre de décimales à ne pas dépasser la précision qui peut être stockée. Alors, peut-être la chaîne de routine tronque 0.10000000000000009 à 0.1000000, puis les garnitures les zéros de fin pour vous donner 0,1, ce qui peut être plus proche de ce que vous voulez. Cependant, qui peut dire combien de décimales cette valeur.
Donc, en conclusion, il y a des valeurs numériques, comme 1/3, qui ont à la fois infini de décimales et infini binaire lieux, qui sont approchées en raison de stockage finie. Il y a aussi la précision problèmes introduits par la conversion entre décimal et binaire, avec 0,1. Les fonctions de chaîne d'arrondir à tronquer la précision au-delà de ce que le fini de stockage peut vraiment représenter. Dans ces cas, la seule chose raisonnable à faire est de les convertir en chaîne de caractères et le prendre de suite que le nombre de décimales.

OriginalL'auteur Marlin Pierce
3

Ce fil est également à l'aide de PLÂTRE, mais j'ai trouvé une réponse intéressante:

http://www.sqlservercentral.com/Forums/Topic314390-8-1.aspx
```
DECLARE @Places INT
 SELECT TOP 1000000 @Places = FLOOR(LOG10(REVERSE(ABS(SomeNumber)+1)))+1
   FROM dbo.BigTest
```
et dans ORACLE:
```
SELECT FLOOR(LOG(10,REVERSE(CAST(ABS(.56544)+1 as varchar(50))))) + 1 from DUAL
```
Idée intéressante, mais malheureusement se décompose en raison d'arrondi par défaut dans TSQL (float varchar coupes à 6 chiffres), Un manuel en fonte peut corriger cela, mais complique la requête plus loin.

OriginalL'auteur vbaranov
1

J'ai répondu avant, mais je peux dire d'après les commentaires que c'est un peu moins clair. Au fil du temps j'ai trouvé une meilleure façon de l'exprimer.

Envisager pi comme
```
(a) 3.141592653590
```
Cette montre pi 11 décimales. Cependant, cela a été arrondi à 12 décimales, comme pi, à 14 chiffres est
```
(b) 3.1415926535897932
```
Un ordinateur ou base de données stocke les valeurs en binaire. Pour une simple précision float pi est stockée en tant que
```
(c) 3.141592739105224609375
```
C'est en fait en arrondissant à la valeur que de simple précision peut stocker, comme nous l'avons arrondi (un). La prochaine nombre le plus faible d'un simple précision peut stocker est
```
(d) 3.141592502593994140625
```
Donc, quand vous êtes à essayer de compter le nombre de décimales, vous essayez de trouver combien de décimales, après quoi tous les autres décimales serait de zéro. Cependant, puisque le nombre devrez peut-être arrondie à stocker, il ne représente pas la valeur correcte.

Numéros aussi introduire d'erreur d'arrondi, comme des opérations mathématiques sont faites, y compris la conversion de décimal à binaire lorsque vous entrez le numéro, et la conversion de binaire en décimal lors de l'affichage de la valeur.

Vous ne pouvez pas trouver de manière fiable le nombre de décimales d'un nombre dans une base de données, parce qu'elle est approchée pour le tour de stocker un nombre limité de stockage. La différence entre la valeur réelle, ou même la valeur binaire exacte dans la base de données sera arrondi à la représenter en décimal. Il pourrait toujours plus de chiffres décimaux qui sont absents de l'arrondissement, donc vous ne savez pas quand les zéros n'aurait plus de non-zéro chiffres suivants.

OriginalL'auteur Marlin Pierce
1

Solution pour Oracle, mais vous avez l'idée. trunc() supprime la partie décimale dans Oracle.
```
select *
from your_table
where (your_field*1000000 - trunc(your_field*1000000)) <> 0;
```
L'idée de la requête: il n'y Aura aucune décimales à gauche après vous multipliez par 1 000 000.

OriginalL'auteur DenisS
0

Voici un autre Oracle exemple. Comme je l'ai toujours avertir les non-Oracle utilisateurs avant qu'ils se mettent à crier à moi et downvoting etc... la sous-CHAÎNE et INSTRING sont la norme SQL ANSI fonctions et peut être utilisé dans n'importe quel SQL. La Double table peut être remplacé par tout autre tableau ou créé. Voici le lien vers SQL SERVER blog whre j'ai copié la double table de code à partir de: http://blog.sqlauthority.com/2010/07/20/sql-server-select-from-dual-dual-equivalent/
```
CREATE TABLE DUAL
(
 DUMMY VARCHAR(1)
)
GO
INSERT INTO DUAL (DUMMY)
VALUES ('X')
GO
```
La longueur après le point ou la virgule est retourné par cette requête.
Le str peut être converti to_number(str) si nécessaire. Vous pouvez également obtenir la longueur de la chaîne avant le point-virgule - changement de code de LONGUEUR(SUBSTR(str, 1, dot_pos))-1 et supprimer +1 INSTR partie:
```
SELECT str, LENGTH(SUBSTR(str, dot_pos)) str_length_after_dot FROM
(
 SELECT '000.000789' as str
      , INSTR('000.000789', '.')+1 dot_pos 
   FROM dual
)
/

SQL>

STR           STR_LENGTH_AFTER_DOT
----------------------------------
000.000789    6
```
Vous avez déjà des réponses et des exemples sur le casting etc...

OriginalL'auteur Art

Vous devez vous connecter pour publier un commentaire.