T-SQL Store Procedure costrutto variabile SELECT

[eporz]

Salve a tutti,
premesso che è da poco che mi sto imbattendo con T-SQL e le store
procedure,
avrei la necessità di costruire un costrutto select condizionato dai
parametri di input.
Potreste aiutarmi a capire come fare ?
Ho visto sulla documentazione ma non ho trovato nulla che mi possa
aiutare.
Nel caso specifico dovrei impostare le condizioni where in base ai
parametri di input.

Se ho in input @parm1, @parm2 e @parm3
che corrispondono a tre campi della tabella
la select dovrebbe avere come condizione WHERE solo i campi i cui
parametri non sono null
Esempio:
Se passo @parm1=123 e @parm3=456
SELECT .... FROM .... WHERE campo1=@parm1 AND campo3=@parm3
oppure
se @parm2=678
SELECT .... FROM .... WHERE campo2=@parm2

e cosi per tutte le altre combinazioni.

Grazie fin d'ora.

[Albe V°]

eporz ha pensato forte :

Io in genere uso il normale coalesce:
SELECT <COLONNE>
FROM TABELLA
WHERE
CAMPO1 = COALESCE(@PARM1, CAMPO1)
AND
CAMPO2 = COALESCE(@PARM2, CAMPO2)
AND
CAMPO3 = COALESCE(@PARM3, CAMPO3)


Alberto

[eporz]

Grazie per la risposta,
ma cosi sono obbligato ad usare tutti i parametri.
Il problema mio è quello che in un form ho tre campi,
e la condizione WHERE deve essere composta solo sui campi compilati.
Esempio:
Il form contiene:
text1
text2
text3

Se compilo solo Campo1 allora la condizione WHERE dovrà essere
SELECT ........ FROM .... WHERE Campo1=text1
Se compilo text1 e text2 allora
SELECT .... FROM ... WHERE Campo1=text1 AND Campo2=text2

Comunque per ora ho trovato questa soluzione:
Alla sp passo un parametro che contiene la condizione WHERE come
nvarchar.
Se null allora eseguo SELECT senza WHERE
Altrimenti eseguo
SELECT @sqlString = ' SELECT Campo1,Campo2,Campo3,Campo4 FROM
TableName ' + @CondWhere
exec (@sqlstring)

Altre soluzioni sono ben accettate

[Albe V°]

Il 13/02/2012, eporz ha detto :

Se vuoi la riscrivo uguale.
Tu hai scritto che la select deve verificare solo i parametri non null,
e questo è quello che fa la select che ti ho postato.


Bellissimo quando la gente ha un problema, gli dai la soluzione, non la
prova e te la contesta.


Alberto

[gian...@gmail.com]

Ciao Alberto,

ma usando coalesce come mostri tu non ne soffre l'efficienza della query?

Ipotizzando di dover considerare solo @PARAM1,
non c'è differenza fra queste due query?

Query A:

SELECT <COLONNE> FROM TABELLA
WHERE
CAMPO1 = COALESCE(@PARM1, CAMPO1)
AND
CAMPO2 = COALESCE(@PARM2, CAMPO2)
AND
CAMPO3 = COALESCE(@PARM3, CAMPO3)

Query B:

SELECT <COLONNE> FROM TABELLA
WHERE CAMPO1 = @PARM1

Gianni

[Albe V°]

gian...@gmail.com ha spiegato il 14/02/2012 :

> Ciao Alberto,
>
> ma usando coalesce come mostri tu non ne soffre l'efficienza della query?

Beh, diciamo che è comunque infinitamente meglio di una costruzione con
operatori logici e dei check IS NULL sui parametri, quelle cose tipo
WHERE
(@PARM1 IS NULL OR CAMPO1=@PARM1)
AND
(@PARM2 IS NULL OR CAMPO2=@PARM2)
AND
(@PARM3 IS NULL OR CAMPO3=@PARM3)

che oltretutto quel = su una cosa che può essere NULL mi mette i
brividi.

>
> Ipotizzando di dover considerare solo @PARAM1,
> non c'è differenza fra queste due query?
>
> Query A:
>
> SELECT <COLONNE> FROM TABELLA
> WHERE
> CAMPO1 = COALESCE(@PARM1, CAMPO1)
> AND
> CAMPO2 = COALESCE(@PARM2, CAMPO2)
> AND
> CAMPO3 = COALESCE(@PARM3, CAMPO3)
>
> Query B:
>
> SELECT <COLONNE> FROM TABELLA
> WHERE CAMPO1 = @PARM1

C'è sicuramente molta differenza.

Ma se hai n colonne che puoi voler testare, le possibilità sono solo 3:
Col coalesce
Con le strutture logiche che citavo sopra
Con una batteria di IF che fanno eseguire una cosa o l'altra (che però
devi farlo per tutte le combinazioni possibili).

Secondo me, più semplice, leggibile, manutenibile ed efficiente del
Coalesce, per un caso come questo, c'è poco.

Alberto

[eporz]

Grazie Alberto,
non devi arrabbiarti, ma come ho premesso sono nuovo (porta
pazienza :-) ).
Avevo provato, perciò ho postato.
Comunque ho riprovato nuovamente ed adesso funziona perfettamente.
Mi ero dimenticato di assegnare il valore Null di default a parametri.
Grazie di nuovo.

[gian...@gmail.com]

Con Visual Foxpro sono abituato a costruire così le espressioni variabili, che siano eseguite con baze dati nativa DBF oppure SQL-Server:

PROCEDURE MIA_PROCEDURA
parameters m.parm1, m.parm2, m.parm3

local m.filter
m.filter = ""

if ! empty(m.parm1)
m.filter = m.filter + " and CAMPO1 = ?m.parm1"
endif

if ! empty(m.parm2)
m.filter = m.filter + " and CAMPO2 = ?m.parm2"
endif

if ! empty(m.parm3)
m.filter = m.filter + " and CAMPO3 = ?m.parm3"
endif

if ! empty(m.filter)
m.filter = "where " + substr(m.filter, 6)
endif

text to m.sql_command

select COLONNA1, COLONNA2, COLONNA3
from TABELLA
&filter

endtext

SQLExec(m.sql_handle, m.sql_command, "TMP_RESULT")

Non pretendo che conosciate Visual Foxpro e non serve soffermarsi sulle differenze fra empty e null:
in sintesi quello che avviene è che nella query risultano solo le espressioni significative e niente altro.

Non esiste modo di utilizzare una costruzione simile su SQL-Server?

L'unica maniera è (come mostra eporz) utilizzare exec ?

Presto dovrò cominciare ad utilizzare le stored procedure e sapere come gestire al meglio un numero variabile di parametri non potrà che tornarmi utile.

Gianni

[Albe V°]

gian...@gmail.com scriveva il 14/02/2012 :

Certo, ma è Sql dinamico.

Quindi, se ne facevi un discorso di performance, siamo agli antipodi.

Alberto