Comment puis-je vérifier si une valeur est un nombre entier dans MySQL?

Je vois que dans MySQL il y a Cast() et Convert() des fonctions pour créer des nombres entiers de valeurs, mais est-il possible de vérifier si une valeur est un nombre entier? Quelque chose comme is_int() en PHP est ce que je suis à la recherche d'.

donc, malheureusement, nous devons créer is_int() fonction Mysql

InformationsquelleAutor Craig Nakamoto | 2008-09-16

mysql

198

Je vais supposer que vous voulez vérifier une valeur de chaîne. Une belle façon est l'expression de l'opérateur, correspondant de la chaîne à une expression régulière. Tout simplement
```
select field from table where field REGEXP '^-?[0-9]+$';
```
c'est assez rapide. Si votre champ est numérique, il suffit de tester pour
```
ceil(field) = field
```
à la place.
- Le 'ceil(champ) = champ d'essai est une belle idée, mais comme @Jumpy l'a souligné, il échoue sur des données non numériques: SÉLECTIONNEZ ceil('quatre') = 'quatre'; -> 1
- Il a dit que si votre champ est numérique. C'est ainsi, vous pouvez tester si un nombre est un entier. Il ne fonctionnera pas sur les cordes, c'est pourquoi la première option est là.
- Si les données peuvent inclure des espaces, ce serait un échec. Envisager des essais de garniture(champ), éventuellement avec un supplément arg pour supprimer les retours à la ligne.
- les données sont numériques, peut le faire aussi: select ((champ % 1) = 0);
- Merci, mais pour la comparaison numérique, je pense que vous n'avez pas besoin(strcmp(ceil(champ),terrain)
InformationsquelleAutor Jumpy
13

Il correspond à une expression régulière.

c.f. http://forums.mysql.com/read.php?60,1907,38488#msg-38488 comme cité ci-dessous:

Re: IsNumeric() de la clause dans MySQL??

Posté par: kevinclark ()

Date: août 08, 2005 01:01PM

Je suis d'accord. Voici une fonction que j'ai créé pour MySQL 5:
```
CREATE FUNCTION IsNumeric (sIn varchar(1024)) RETURNS tinyint
RETURN sIn REGEXP '^(-|\\+){0,1}([0-9]+\\.[0-9]*|[0-9]*\\.[0-9]+|[0-9]+)$';
```
Il permet donc une option plus/signe moins au début, une option virgule, et le reste des caractères numériques.
- Merci, la solution prend soin de décimales aussi
InformationsquelleAutor JBB
10

Supposons que nous avons colonne de champ alphanumérique ayant des entrées comme
```
a41q
1458
xwe8
1475
asde
9582
.
.
.
.
.
qe84
```
et vous voulez la valeur numérique la plus élevée à partir de cette base de colonne (dans ce cas, il est 9582), alors cette requête va vous aider à
```
SELECT Max(column_name) from table_name where column_name REGEXP '^[0-9]+$'
```
- '10000' est plus élevé, mais votre requête serait encore de retour '9582'.
InformationsquelleAutor Tarun Sood
8

Ici est la solution la plus simple pour elle
en supposant que les données sont de type varchar
```
select * from calender where year > 0
```
Il retournera true si l'année est numérique sinon false
- Dans un varchar, ce sera aussi retourner true si le premier caractère est numérique.
- N'a pas remarqué. jusqu'à droit de vote de votre commentaire 🙂
InformationsquelleAutor
6

Cela fonctionne aussi:
```
CAST( coulmn_value AS UNSIGNED ) // will return 0 if not numeric string.
```
par exemple
```
SELECT CAST('a123' AS UNSIGNED) // returns 0
SELECT CAST('123' AS UNSIGNED) // returns 123 i.e. > 0
```
- qu'en est SELECT CAST('12a34' AS UNSIGNED), qui renvoie 12?
- Cela fonctionne parfaitement si vous avez besoin de test pour les non-numérique, il mérite plus d' +1s. Les autres réponses sont plus difficiles à inverser le test pour trouver le non-numérique des éléments.
- cela ne fonctionne pas pour le cas de Mike C décrit, par conséquent, est très peu fiable
- SELECT (CAST("1.1" AS UNSIGNED)); sera également imprimer 1 un flotteur n'est pas un int..
InformationsquelleAutor Riad
4

Pour vérifier si une valeur est de type Int dans Mysql, on peut utiliser la requête suivante.
Cette requête va donner des lignes avec des valeurs Int
```
SELECT col1 FROM table WHERE concat('',col * 1) = col;
```
- Cela permettra également de sélectionner des nombres non-entiers (par exemple. '3.5').
InformationsquelleAutor minhas23
3

Ce sujet:
```
WHERE table.field = "0" or CAST(table.field as SIGNED) != 0
```
de test pour le numérique et corrolary:
```
WHERE table.field != "0" and CAST(table.field as SIGNED) = 0
```
- CAST(tableau.champ) != 0 ne fonctionne pas comme il a besoin d'un type de lancer.
- Cela fonctionne parfaitement si vous avez besoin de test pour les non-numérique, il mérite plus d' +1s. Les autres réponses sont plus difficiles à inverser le test pour trouver le non-numérique des éléments.
- Cela ne fonctionne pas pour les nombres comme "0000", "0" (de l'espace) et "7x" (qui est considéré comme un nombre).
- Je suppose que vous pourriez faire une regexp pour les deux premiers cas. "7x" est considéré comme un nombre? "0x7" est un nombre, mais 7x?
- Auger: une Autre réponse couvert les regex type de solutions. Ce que je voulais dire par "7x est considéré comme un nombre" est que cette affirmation est vraie: sélectionnez 7 = '7q'
InformationsquelleAutor Tom Auger

Le meilleur que j'ai pu penser à une variable est de type int Est une combinaison avec MySQL fonctions CAST() et LENGTH().

Cette méthode fonctionne pour les chaînes de caractères, entiers, doubles, de flotteurs les types de données.

SELECT (LENGTH(CAST(<data> AS UNSIGNED))) = (LENGTH(<data>)) AS is_int

voir démo http://sqlfiddle.com/#!9/ff40cd/44

il échouera si la colonne a une valeur de caractère unique. si la colonne a
une valeur de 'A' puis Cast('A' non signés) permettra d'évaluer à 0 et
LONGUEUR(0) sera de 1. afin de LONGUEUR(Cast('A' non signés))=LONGUEUR(0)
évaluer à 1=1 => 1

Vrai Waqas Malik totalement fogotten pour tester cette affaire. le patch est.

SELECT <data>, (LENGTH(CAST(<data> AS UNSIGNED))) = CASE WHEN CAST(<data> AS UNSIGNED) = 0 THEN CAST(<data> AS UNSIGNED) ELSE (LENGTH(<data>)) END AS is_int;

Résultats

**Query #1**
SELECT 1, (LENGTH(CAST(1 AS UNSIGNED))) = CASE WHEN CAST(1 AS UNSIGNED) = 0 THEN CAST(1 AS UNSIGNED) ELSE (LENGTH(1)) END AS is_int;
| 1   | is_int |
| --- | ------ |
| 1   | 1      |
---
**Query #2**
SELECT 1.1, (LENGTH(CAST(1 AS UNSIGNED))) = CASE WHEN CAST(1.1 AS UNSIGNED) = 0 THEN CAST(1.1 AS UNSIGNED) ELSE (LENGTH(1.1)) END AS is_int;
| 1.1 | is_int |
| --- | ------ |
| 1.1 | 0      |
---
**Query #3**
SELECT "1", (LENGTH(CAST("1" AS UNSIGNED))) = CASE WHEN CAST("1" AS UNSIGNED) = 0 THEN CAST("1" AS UNSIGNED) ELSE (LENGTH("1")) END AS is_int;
| 1   | is_int |
| --- | ------ |
| 1   | 1      |
---
**Query #4**
SELECT "1.1", (LENGTH(CAST("1.1" AS UNSIGNED))) = CASE WHEN CAST("1.1" AS UNSIGNED) = 0 THEN CAST("1.1" AS UNSIGNED) ELSE (LENGTH("1.1")) END AS is_int;
| 1.1 | is_int |
| --- | ------ |
| 1.1 | 0      |
---
**Query #5**
SELECT "1a", (LENGTH(CAST("1.1" AS UNSIGNED))) = CASE WHEN CAST("1a" AS UNSIGNED) = 0 THEN CAST("1a" AS UNSIGNED) ELSE (LENGTH("1a")) END AS is_int;
| 1a  | is_int |
| --- | ------ |
| 1a  | 0      |
---
**Query #6**
SELECT "1.1a", (LENGTH(CAST("1.1a" AS UNSIGNED))) = CASE WHEN CAST("1.1a" AS UNSIGNED) = 0 THEN CAST("1.1a" AS UNSIGNED) ELSE (LENGTH("1.1a")) END AS is_int;
| 1.1a | is_int |
| ---- | ------ |
| 1.1a | 0      |
---
**Query #7**
SELECT "a1", (LENGTH(CAST("1.1a" AS UNSIGNED))) = CASE WHEN CAST("a1" AS UNSIGNED) = 0 THEN CAST("a1" AS UNSIGNED) ELSE (LENGTH("a1")) END AS is_int;
| a1  | is_int |
| --- | ------ |
| a1  | 0      |
---
**Query #8**
SELECT "a1.1", (LENGTH(CAST("a1.1" AS UNSIGNED))) = CASE WHEN CAST("a1.1" AS UNSIGNED) = 0 THEN CAST("a1.1" AS UNSIGNED) ELSE (LENGTH("a1.1")) END AS is_int;
| a1.1 | is_int |
| ---- | ------ |
| a1.1 | 0      |
---
**Query #9**
SELECT "a", (LENGTH(CAST("a" AS UNSIGNED))) = CASE WHEN CAST("a" AS UNSIGNED) = 0 THEN CAST("a" AS UNSIGNED) ELSE (LENGTH("a")) END AS is_int;
| a   | is_int |
| --- | ------ |
| a   | 0      |

voir démo

il échouera si la colonne a une valeur de caractère unique. si la colonne a une valeur 'A' puis Cast('A' non signés) permettra d'évaluer de 0 et de LONGUEUR(0) sera de 1. afin de LONGUEUR(Cast('A' non signés))=LONGUEUR(0) permettra d'évaluer à 1=1 => 1
Merci pour le commentaire que le cas était, en effet, non testé @WaqasMalik de travail et de test d'un droit de timbre maintenant.. quelque chose comme SELECT "a", (LENGTH(CAST("a" AS UNSIGNED))) = CASE WHEN CAST("a" AS UNSIGNED) = 0 THEN CAST("a" AS UNSIGNED) ELSE (LENGTH("a")) END AS is_int;

InformationsquelleAutor Raymond Nijland

2

J'ai essayé d'utiliser les expressions régulières énumérés ci-dessus, mais ils ne travaillent pas pour la suite:
```
SELECT '12 INCHES' REGEXP '^(-|\\+){0,1}([0-9]+\\.[0-9]*|[0-9]*\\.[0-9]+|[0-9]+)$' FROM ...
```
La ci-dessus sera de retour 1 (TRUE), ce qui signifie que le test de la chaîne "12 POUCES" à l'encontre de l'expression régulière ci-dessus, renvoie TRUE. Il ressemble à un nombre en fonction de l'expression régulière ci-dessus. Dans ce cas, parce que le 12 est au début de la chaîne, l'expression régulière interprète comme un nombre.

Le suivant sera le retour de la juste valeur (c'est à dire 0) parce que la chaîne commence avec des personnages au lieu de chiffres
```
SELECT 'TOP 10' REGEXP '^(-|\\+){0,1}([0-9]+\\.[0-9]*|[0-9]*\\.[0-9]+|[0-9]+)$' FROM ...
```
La ci-dessus sera de retour 0 (FALSE) parce que le début de la chaîne de texte et non pas numérique.

Toutefois, si vous traitez avec des chaînes qui ont un mélange de chiffres et de lettres qui commencent par un chiffre, vous n'obtiendrez pas les résultats que vous voulez. REGEXP va interpréter la chaîne comme un numéro valide, alors qu'en fait il ne l'est pas.
- Ceci est incorrect. Avez-vous tester? Quand je lance ton premier exemple, il renvoie FALSE, comme prévu, parce que la regex se termine avec $ ce qui signifie la fin de la chaîne, de sorte qu'il vérifie seulement des nombres, comme prévu par l'auteur.
InformationsquelleAutor Bill Kelly
0

Cela fonctionne bien pour les VARCHAR où il commence par un numéro ou pas..
```
WHERE concat('',fieldname * 1) != fieldname 
```
peuvent avoir des restrictions quand vous obtenez la plus grande NNNNE+- nombre

InformationsquelleAutor PodTech.io
0

pour moi, la seule chose qui fonctionne est:
```
CREATE FUNCTION IsNumeric (SIN VARCHAR(1024)) RETURNS TINYINT
RETURN SIN REGEXP '^(-|\\+){0,1}([0-9]+\\.[0-9]*|[0-9]*\\.[0-9]+|[0-9]+)$';
```
de kevinclark tous les autres de retour de trucs inutiles pour moi en cas de 234jk456 ou 12 inches

InformationsquelleAutor Tim

Vous devez vous connecter pour publier un commentaire.