J'ai un TABLE avec 9 champs et j'ai créé un rapport dans Ireport avec 9 paramètres à partir de ce TABLE mais parfois les utilisateurs remplissent certains paramètres, pas tous .
Donc, pour autant que vous le sachiez, je devrais les vérifier tous les uns avec les autres. IF est nul faites ceci et IF n'est pas nul faites cela.
alors, aidez-moi et dites-moi comment puis-je le gérer?
CREATE FUNCTION public.rep_staff(
parCol1 text,
parCol2 text,
parCol3 text,
parCol4 text,
parCol5 text,
parCol6 text,
parCol7 text,
parCol8 text,
parCol9 text,
OUT Col_1 character varying,
OUT Col_2 character varying,
OUT Col_3 character varying,
OUT Col_4 character varying,
OUT Col_5 character varying,
OUT Col_6 character varying,
OUT Col_7 character varying,
OUT Col_8 character varying,
OUT Col_9 character varying)
RETURNS SETOF record
LANGUAGE 'plpgsql'
AS $BODY$
DECLARE
parCol1_par text;
parCol2_par text;
parCol3_par text;
parCol4_par text;
parCol5_par text;
parCol6_par text;
parCol7_par text;
parCol8_par text;
parCol9_par text;
BEGIN
parCol1_par = parCol1 ;
parCol2_par = parCol2 ;
parCol3_par = parCol3 ;
parCol4_par = parCol4 ;
parCol5_par = parCol5 ;
parCol6_par = parCol6 ;
parCol7_par = parCol7 ;
parCol8_par = parCol8 ;
parCol9_par = parCol9 ;
IF ( parCol1_par is NOT null AND
parCol2_par is NOT null AND
parCol3_par is NOT null AND
parCol4_par is NOT null AND
parCol5_par is NOT null AND
parCol6_par is NOT null AND
parCol7_par is NOT null AND
parCol8_par is NOT null AND
parCol9_par is NOT null)
THEN
RETURN QUERY
SELECT
*
FROM
"public"."TABLE" T
WHERE T.parCol1 = parCol1_par AND
T.parCol2 = parCol2_par AND
T.parCol3 = parCol3_par AND
T.parCol4 = parCol4_par AND
T.parCol5 = parCol5_par AND
T.parCol6 = parCol6_par AND
T.parCol7 = parCol7_par AND
T.parCol8 = parCol8_par AND
T.parCol9 = parCol9_par;
ELSE IF ( parCol1_par is null AND
parCol2_par is NOT null AND
parCol3_par is NOT null AND
parCol4_par is NOT null AND
parCol5_par is NOT null AND
parCol6_par is NOT null AND
parCol7_par is NOT null AND
parCol8_par is NOT null AND
parCol9_par is NOT null)
THEN
RETURN QUERY
SELECT
*
FROM
"public"."TABLE" T
WHERE T.parCol2 = parCol2_par AND
T.parCol3 = parCol3_par AND
T.parCol4 = parCol4_par AND
T.parCol5 = parCol5_par AND
T.parCol6 = parCol6_par AND
T.parCol7 = parCol7_par AND
T.parCol8 = parCol8_par AND
T.parCol9 = parCol9_par;
ELSE IF (
.
.
.
.
.
.
.
ELSE IF (
ELSE IF (
ELSE IF (
END IF;
END
$BODY$;
et ma requête est la suivante
+-------+-------+-------+-------+-------+-------+-------+-------+-------+ | Col_1 | Col_2 | Col_3 | Col_4 | Col_5 | Col_6 | Col_7 | Col_8 | Col_9 | +-------+-------+-------+-------+-------+-------+-------+-------+-------+ | x | y | 3o | xT | y1 | k32 | xY | L | 3q | | s | u | 4t | xO | y3 | j34 | xO | K | 2a | | h | z | 33r | xH | y3 | h36 | xT | y | 6s | | t | t | 14r | xF | y5 | t31 | xP | J | 1d | | m | m | 77w | xS | y7 | o30 | xJ | O | 0f | +-------+-------+-------+-------+-------+-------+-------+-------+-------+
4 Réponses :
J'ai passé en revue votre exigence et j'ai pensé que vous pouvez utiliser la fonction COALESCE au lieu de tant de blocs if else. c'est la même chose que NVL dans oracle. Ci-dessous, j'écris un exemple de requête que vous pouvez utiliser dans votre fonction.
COALESCE (parcol1_par, t.parcol1, parcol1_par) - si parcol1_par est nul, il se comparera à la valeur d'origine de la colonne parcol1 , s'il n'est pas nul, il se comparera avec Valeur de parcol1_par .
SELECT
*
FROM
"public"."TABLE" t
WHERE
t.parcol1 = COALESCE(parcol1_par,t.parcol1,parcol1_par)
AND t.parcol2 = COALESCE(parcol2_par,t.parcol2,parcol2_par)
AND t.parcol3 = COALESCE(parcol3_par,t.parcol3,parcol3_par)
AND t.parcol4 = COALESCE(parcol4_par,t.parcol4,parcol4_par)
AND t.parcol5 = COALESCE(parcol5_par,t.parcol5,parcol5_par)
AND t.parcol6 = COALESCE(parcol6_par,t.parcol6,parcol6_par)
AND t.parcol7 = COALESCE(parcol7_par,t.parcol7,parcol7_par)
AND t.parcol8 = COALESCE(parcol8_par,t.parcol8,parcol8_par)
AND t.parcol9 = COALESCE(parcol9_par,t.parcol9,parcol9_par);
J'aime cette solution mais pourquoi avez-vous 3 paramètres à COALESCE alors que le premier et le dernier sont identiques?
Salut @JoakimDanielson, dans le premier paramètre il vérifie qu'en nul ou non, s'il est nul alors il prend le paramètre2 et s'il n'est pas nul alors il prend le paramètre 3. si ne donnez pas le paramètre 3 alors il prendra par valeur null par défaut.
Mais le premier et le troisième sont identiques, donc le dernier est redondant. Lorsque le premier est nul, le dernier sera également nul.
Salut @JoakimDanielson, oui vous avez raison, nous pouvons omettre le dernier paramètre.
vous pouvez utiliser COALESCE pour donner une valeur par défaut à votre colonne si elle est nulle,
IF COALESCE(parCol1_par, parCol2_par , parCol3_par , parCol4_par ,
parCol5_par , parCol6_par , parCol7_par , parCol8_par ,
parCol9_par ) IS NOT NULL THEN
....
END;
ou même vous pouvez l'utiliser à l'intérieur si
COALESCE(parcol2, '')
Le IF ci-dessus renvoie null si toutes les colonnes sont nulles et renvoie une valeur si tout / partie / tout n'est pas nul.
Cela pourrait être écrit en une seule requête, comme:
SELECT
*
FROM
"public"."TABLE" T
WHERE
T.parCol1 = COALESCE(parCol1_par, T.parCol1)
AND T.parCol2 = COALESCE(parCol2_par, T.parCol2)
...
Une autre option consiste à utiliser COALESCE , qui produit une syntaxe plus courte, bien que peut-être moins efficace:
SELECT
*
FROM
"public"."TABLE" T
WHERE
(parCol1_par IS NULL OR T.parCol1 = parCol1_par)
AND (parCol2_par IS NULL OR T.parCol2 = parCol2_par)
...
Vous pouvez utiliser des fonctions NVL spécifiques à la base de données (NVL dans ORACLE, IFNULL dans MYSQL, COALESCE dans POSTGRESQL, etc.) combinées avec la colonne de la table.
Exemple:
Supposons que parCol1_par est NULL.
La condition sera (dans POSTGRESQL):
SELECT * FROM "public"."TABLE" T WHERE T.parCol1 = COALESCE(parCol1_par, T.parCol1) AND T.parCol2 = COALESCE(parCol2_par, T.parCol2) AND T.parCol3 = COALESCE(parCol3_par, T.parCol3) AND T.parCol4 = COALESCE(parCol4_par, T.parCol4) AND T.parCol5 = COALESCE(parCol5_par, T.parCol5) AND T.parCol6 = COALESCE(parCol6_par, T.parCol6) AND T.parCol7 = COALESCE(parCol7_par, T.parCol7) AND T.parCol8 = COALESCE(parCol8_par, T.parCol8) AND T.parCol9 = COALESCE(parCol9_par, T.parCol9)
Donc, l'interrogation entière pourrait être
COALESCE(parCol1_par,T.parCol1)=T.parCol1
merci mon pote. mon problème résolu. Veuillez noter ma question si cela est utile.
L'une des neuf colonnes du tableau accepte-t-elle NULL ou sont-elles toutes obligatoires? Cela affectera votre requête.
@Joakim Danielson dans ma TABLE, la réponse n'est pas toutes les colonnes, mais dans mon paramètre, la réponse est oui en fait je veux créer un formulaire ... les utilisateurs peuvent remplir le paramètre ou non, s'ils n'ont pas rempli le paramètre, alors sélectionnez toute cette colonne
Si certaines colonnes peuvent être nulles, la requête doit être ajustée pour cela
@Joakim Danielson imagine que nous avons un paramètre sur le sexe (hommes / femmes) donc dans notre colonne du tableau, nous avons des hommes ou des femmes, donc si les utilisateurs sélectionnent Hommes, la requête doit filtrer sur les hommes et si les utilisateurs sélectionnent Femmes, la requête doit filtrer sur les femmes mais si les utilisateurs ne sélectionnent aucune requête doivent tous les afficher (hommes et femmes), je devrais donc créer une fonction avec ces aspects, mais j'ai 9 colonnes avec 9 paramètres, alors comment correspond-il à «SI» dont j'ai besoin pour cela !! :(
Il me semble que vous avez des exigences différentes pour vos colonnes et que vous devez ajuster individuellement la condition de chaque colonne.
@Joakim Danielson ouais exactement.