postgresql retour 0 si la valeur retournée est null

J'ai une requête qui retourne avg(prix)

  select avg(price)
  from(
      select *, cume_dist() OVER (ORDER BY price desc) from web_price_scan
      where listing_Type='AARM'
        and u_kbalikepartnumbers_id = 1000307
        and (EXTRACT(Day FROM (Now()-dateEnded)))*24 < 48
        and price>( select avg(price)* 0.50
                    from(select *, cume_dist() OVER (ORDER BY price desc)
                         from web_price_scan
                         where listing_Type='AARM'
                           and u_kbalikepartnumbers_id = 1000307
                           and (EXTRACT(Day FROM (Now()-dateEnded)))*24 < 48
                        )g
                   where cume_dist < 0.50
                 )
        and price<( select avg(price)*2
                    from( select *, cume_dist() OVER (ORDER BY price desc)
                          from web_price_scan
                          where listing_Type='AARM'
                            and u_kbalikepartnumbers_id = 1000307
                            and (EXTRACT(Day FROM (Now()-dateEnded)))*24 < 48
                        )d
                    where cume_dist < 0.50)
     )s

  having count(*) > 5

comment rendre renvoyer 0 si aucune valeur n'est disponible?

Êtes-vous sûr que vous êtes à la requête est bien formé ?
Il ne peut pas être un bien formée requête. ("avoir" clause sans une clause "group by".)
tout fonctionne correctement, sauf que parfois, lorsque les règles ne sont pas respectées, il ne retourne rien. En outre, comment puis-je gorup en moyenne, je ne pense pas que c'est possible||quel est le point? Plusieurs sélectionne from web_price_scan sont séparés choisit; pas sûr de ce que la question ici?
C'est Ok pour utiliser un having clause sans group by (qui, par défaut, un seul groupe). Il agit comme un where clause sur l'ensemble des résultats. Dans ce cas, les lignes sont retournés uniquement si plus de 5 lignes sont renvoyées par le 1er niveau de sous-requête.

InformationsquelleAutor Andrew | 2012-06-13

postgresql sql

159

utilisation fusionner

COALESCE(value [, ...])

The COALESCE function returns the first of its arguments that is not null.  
Null is returned only if all arguments are null. It is often
used to substitute a default value for null values when data is
retrieved for display.

Modifier

Voici un exemple de COALESCE avec votre requête:

SELECT AVG( price )
FROM(
SELECT *, cume_dist() OVER ( ORDER BY price DESC ) FROM web_price_scan
WHERE listing_Type = 'AARM'
AND u_kbalikepartnumbers_id = 1000307
AND ( EXTRACT( DAY FROM ( NOW() - dateEnded ) ) ) * 24 < 48
AND COALESCE( price, 0 ) > ( SELECT AVG( COALESCE( price, 0 ) )* 0.50
FROM ( SELECT *, cume_dist() OVER ( ORDER BY price DESC )
FROM web_price_scan
WHERE listing_Type='AARM'
AND u_kbalikepartnumbers_id = 1000307
AND ( EXTRACT( DAY FROM ( NOW() - dateEnded ) ) ) * 24 < 48
) g
WHERE cume_dist < 0.50
)
AND COALESCE( price, 0 ) < ( SELECT AVG( COALESCE( price, 0 ) ) *2
FROM( SELECT *, cume_dist() OVER ( ORDER BY price desc )
FROM web_price_scan
WHERE listing_Type='AARM'
AND u_kbalikepartnumbers_id = 1000307
AND ( EXTRACT( DAY FROM ( NOW() - dateEnded ) ) ) * 24 < 48
) d
WHERE cume_dist < 0.50)
)s
HAVING COUNT(*) > 5

À mon humble avis COALESCE ne doit pas être utiliser avec AVG car il modifie la valeur. NULL un moyen encore inconnu et rien d'autre. Ce n'est pas comme à l'utiliser dans SUM. Dans cet exemple, si on remplace AVG par SUM, le résultat n'est pas déformée. L'ajout de 0 à un montant qui n'a pas fait de mal à personne mais le calcul de la moyenne, 0 pour les valeurs inconnues, vous n'obtenez pas la vraie moyenne.

Dans ce cas, je voudrais ajouter price IS NOT NULL dans WHERE clause pour éviter ces valeurs inconnues.

Je ne pouvais pas le faire fonctionner; exemple de l'aide
J'ai essayé de vous donner un exemple d'utilisation de votre requête. Mais je me suis perdu. Je doute que cette requête fonctionne. from web_price_scan... semble répétées...
Pour ceux qui se demandent, NULLIF(v1, v2) fait à peu près le contraire de COALESCE en ce qu'il renvoie NULL si v1 est égal à v2.

InformationsquelleAutor Luc M

20

(cette réponse a été ajoutée pour fournir plus courte et plus générique des exemples à la question sans y compris tous les cas spécifiques de détails dans la question d'origine).

Il y a deux distincts des "problèmes" ici, la première est de savoir si une table ou une sous-requête ne comporte pas de lignes, la seconde est de savoir si il y a des valeurs NULL dans la requête.

Pour toutes les versions que j'ai testé, postgres et mysql ignore toutes les valeurs NULL lorsque la moyenne, et il va retourner la valeur NULL si il n'y a rien pour la moyenne plus de. En général, cela est logique, car la valeur NULL est pour être considéré comme "inconnu". Si vous souhaitez éviter cela, vous pouvez utiliser fusionnent (comme suggéré par Luc M).
```
$ create table foo (bar int);
CREATE TABLE
$ select avg(bar) from foo;
avg 
-----
(1 row)
$ select coalesce(avg(bar), 0) from foo;
coalesce 
----------
0
(1 row)
$ insert into foo values (3);
INSERT 0 1
$ insert into foo values (9);
INSERT 0 1
$ insert into foo values (NULL);
INSERT 0 1
$ select coalesce(avg(bar), 0) from foo;
coalesce      
--------------------
6.0000000000000000
(1 row)
```
bien sûr, "de foo" peut être remplacé par "de (... compliquée logique ici ...) comme foo"

Maintenant, devrait le NUL de la ligne dans la table, être compté comme le 0? Puis fusionnent doit être utilisé à l'intérieur de l'avg appel.
```
$ select coalesce(avg(coalesce(bar, 0)), 0) from foo;
coalesce      
--------------------
4.0000000000000000
(1 row)
```
InformationsquelleAutor tobixen

Je peux penser de 2 façons d'y parvenir:

IFNULL():

La IFNULL() renvoie une valeur spécifiée si l'expression est NULL.Si l'expression n'est PAS NULLE, cette fonction renvoie l'expression.

Syntaxe:

IFNULL(expression, alt_value)

Exemple de IFNULL() avec votre requête:

SELECT AVG( price )
FROM(
SELECT *, cume_dist() OVER ( ORDER BY price DESC ) FROM web_price_scan
WHERE listing_Type = 'AARM'
AND u_kbalikepartnumbers_id = 1000307
AND ( EXTRACT( DAY FROM ( NOW() - dateEnded ) ) ) * 24 < 48
AND IFNULL( price, 0 ) > ( SELECT AVG( IFNULL( price, 0 ) )* 0.50
FROM ( SELECT *, cume_dist() OVER ( ORDER BY price DESC )
FROM web_price_scan
WHERE listing_Type='AARM'
AND u_kbalikepartnumbers_id = 1000307
AND ( EXTRACT( DAY FROM ( NOW() - dateEnded ) ) ) * 24 < 48
) g
WHERE cume_dist < 0.50
)
AND IFNULL( price, 0 ) < ( SELECT AVG( IFNULL( price, 0 ) ) *2
FROM( SELECT *, cume_dist() OVER ( ORDER BY price desc )
FROM web_price_scan
WHERE listing_Type='AARM'
AND u_kbalikepartnumbers_id = 1000307
AND ( EXTRACT( DAY FROM ( NOW() - dateEnded ) ) ) * 24 < 48
) d
WHERE cume_dist < 0.50)
)s
HAVING COUNT(*) > 5

FUSIONNENT()

Les FUSIONNER() renvoie la première valeur non nulle dans une liste.

Syntaxe:

COALESCE(val1, val2, ...., val_n)

Exemple de FUSIONNER() avec votre requête:

SELECT AVG( price )
FROM(
SELECT *, cume_dist() OVER ( ORDER BY price DESC ) FROM web_price_scan
WHERE listing_Type = 'AARM'
AND u_kbalikepartnumbers_id = 1000307
AND ( EXTRACT( DAY FROM ( NOW() - dateEnded ) ) ) * 24 < 48
AND COALESCE( price, 0 ) > ( SELECT AVG( COALESCE( price, 0 ) )* 0.50
FROM ( SELECT *, cume_dist() OVER ( ORDER BY price DESC )
FROM web_price_scan
WHERE listing_Type='AARM'
AND u_kbalikepartnumbers_id = 1000307
AND ( EXTRACT( DAY FROM ( NOW() - dateEnded ) ) ) * 24 < 48
) g
WHERE cume_dist < 0.50
)
AND COALESCE( price, 0 ) < ( SELECT AVG( COALESCE( price, 0 ) ) *2
FROM( SELECT *, cume_dist() OVER ( ORDER BY price desc )
FROM web_price_scan
WHERE listing_Type='AARM'
AND u_kbalikepartnumbers_id = 1000307
AND ( EXTRACT( DAY FROM ( NOW() - dateEnded ) ) ) * 24 < 48
) d
WHERE cume_dist < 0.50)
)s
HAVING COUNT(*) > 5

InformationsquelleAutor Joish

Vous devez vous connecter pour publier un commentaire.