O WH tout n'est pas nul

Comment puis-je exécuter une requête MySQL qui sélectionne tout ce qui n'est pas nulle? Il serait quelque chose comme

SELECT * FROM schedule WHERE ((all)) IS NOT NULL

Dois-je enlever le tout et aller..?

SELECT * FROM schedule WHERE IS NOT NULL

source d'informationauteur Sam

mysql sql

Vous devrez explicitement l'état de chaque colonne, si par exemple la

SELECT *
FROM schedule 
WHERE id IS NOT NULL
  AND foo IS NOT NULL
  AND bar IS NOT NULL; -- and so on..

10

Vous pouvez concaténer les champs dans l'ordre pour écrire seulement un où la condition:
```
SELECT *
  FROM SCHEDULE
 WHERE ID || FOO || BAR IS NOT NULL;
```
5

Il dépend de ce que vous entendez exactement par "tout ce qui n'est pas nulle":
- toutes les colonnes ne doivent pas être null
  
  select * from schedule where col1 is not null AND col2 is not null AND ..
- au moins une colonne doit être non-null
  
  select * from schedule where col1 is not null OR col 2 is not null OR ..
Au moins c'est comment vous le feriez en général "sql". Je ne sais pas si MySql a une syntaxe spéciale pour cela.
4

Vous avez besoin pour obtenir une liste des colonnes de votre table, en regardant la base de données information_schema.

Supposons que votre base de données est appelée mydata et votre table en question est nommé mytable. Vous pouvez obtenir la liste de la table nullable colonnes par la délivrance de la déclaration suivante:
```
SELECT `COLUMN_NAME`
FROM `information_schema`.`COLUMNS`
WHERE `TABLE_SCHEMA` = 'mydata'
    AND `TABLE_NAME` = 'mytable'
    AND `IS_NULLABLE` = 'YES'
```
Notre requête finale ressemblera à ceci:
```
SELECT * FROM `mydata`.`mytable`
WHERE CONCAT(<list of columns>) IS NOT NULL
```
Tout ce qui nous manque maintenant, c'est la liste de nullable colonnes, séparées par des virgules. Nous allons utiliser la GROUP_CONCAT fonction de produire la déclaration finale, qui nous l'exécuterons comme ceci:
```
SET @query = CONCAT(
    'SELECT * FROM `mydata`.`mytable` WHERE CONCAT(',
    (SELECT GROUP_CONCAT(COLUMN_NAME)
        FROM `information_schema`.`COLUMNS`
        WHERE `TABLE_SCHEMA` = 'mydata' AND
        `TABLE_NAME` = 'mytable'
        AND `IS_NULLABLE` = 'YES'),
    ') IS NOT NULL');

PREPARE stmt_name FROM @query;

EXECUTE stmt_name;
```
Références:

http://dev.mysql.com/doc/refman/5.0/en/group-by-functions.html#function_group-concat

http://dev.mysql.com/tech-resources/articles/4.1/prepared-statements.html
3

J'ai juste regardé votre lié à la question et d'accord avec Guffa de la réponse que vous devriez normaliser votre base de données.

Ci-dessus ressemble plus à une feuille de calcul, puis quelque chose qui appartient à un SGBDR.

Pour répondre à vos préoccupations sur ce qui est la façon dont vous voulez qu'il s'affiche. Vous pourriez écrire un pivot de la requête et de le mettre dans une vue pour imiter votre structure actuelle de la table et de les utiliser pour votre requête d'affichage.

Cela permettra d'éviter la nécessité d'une horrible 24 colonnes clause where chaque fois que vous voulez la recherche de données ou de savoir si elle est NULLE comme dans cette question.
0

Si vous utilisez un autre langage de programmation combinée avec sql, vous pouvez accélérer ce processus en boucle au travers d'une liste de noms de colonnes et de l'aide d'un paramètre à faire si ce n'null vérifier plutôt que d'avoir à les taper tous individuellement.e.g
```
**code SQL**

Select *
FROM Schedule
WHERE @ColumnName IS NOT NULL

**code c#**

for(int i =0; i<parameterArray[].length; i++)
{
command.Parameters.Add(new SqlParameter("ColumnName", parameterArray[i]));
command.Execute();
}
```
Je suggère l'utilisation de transactions de sorte que vous pouvez le faire ci-dessus dans un lot après la boucle for a course à travers.

D'utiliser le format XML de sorte que vous n'avez pas à parcourir tous vos colonnes:

--Your Source Table
CREATE TABLE [dbo].[schedule](
[id] [nchar](10) NULL,
[col1] [nchar](10) NULL,
[col2] [nchar](10) NULL,
[col3] [nchar](10) NULL
) ON [PRIMARY]
--I know my result should show items NOT NULL, like id:2,col1,val:'a'
INSERT INTO [schedule](id,col1,col2,col3)
values 
(1,null,null,null),
(2,'a',null,null),
(3,null,'b',null),
(4,null,null,null),
(5,null,null,'c')
--temp placeholder table 
CREATE TABLE #tempsch (id VARCHAR(max) not null, schColumns XML) 
--Load temp table with XML version of your table
INSERT INTO #tempsch (id, schColumns)
SELECT  s.id,
(   SELECT * 
FROM    [schedule] AS x
WHERE   x.id = s.id
FOR XML PATH('bar'), TYPE, ROOT('foo')
) AS xml_format_string
FROM [schedule] AS s
--This select should return all values Where all is NOT NULL
SELECT id,
sd.c.value('local-name(.)', 'VARCHAR(MAX)') AS elementName, 
sd.c.value('.', 'VARCHAR(MAX)') AS elementValue
FROM #tempsch s
CROSS APPLY schColumns.nodes('/foo/bar/*') sd(c)
WHERE 
sd.c.value('local-name(.)', 'VARCHAR(MAX)') <> 'id'

0

cela fonctionne uniquement avec les types char et varchar type. Si vous rencontrez d'autres types de données, il déclenche une erreur.
```
SELECT *
FROM SCHEDULE
WHERE coa
lesce(ID, FOO, BAR) IS NOT NULL;
```
incompatible types de données: attendu CHAR ai DATE
Remarque: ici, FOO est de type date.
-1

Je pas ce faire, mais pour remplacer quelqu'un d'autre idée horrible.surtout ne pas le faire -- c'est ce qu'ils suggèrent:
```
SELECT *
  FROM SCHEDULE
 WHERE ID || FOO || BAR IS NOT NULL;
```
Ne pas le faire, mais au moins, il n'est pas si mauvais...
```
SELECT *
FROM SCHEDULE
WHERE coalesce(ID, FOO, BAR) IS NOT NULL;
```
Au moins fonctionne sur d'autres versions de SQL, et certains compilateurs de l'étendre à une série de IS NOT NULL.

Juste faire ce que l'on a accepté de répondre à dit

Vous devez vous connecter pour publier un commentaire.