Differenze

Queste sono le differenze tra la revisione selezionata e la versione attuale della pagina.

--- documentazione_3di:extraway:then [2009/11/26 15:32] – rtirabassi
+++ documentazione_3di:extraway:then [2012/07/23 15:42] (versione attuale) – eliminata rtirabassi
@@ Linea 1: / Linea 1: @@
-====== Le selezioni in cascata ======
-La funzionalità di selezione in cascata((Disponibile a partire dal server eXtraWay versione 23.0.0.0 e successive)) consiste nella possibilità di esprimere, con una sola espressione di ricerca, più selezioni da compiere in sequenza potendo riflettere sulle successive l'esito delle precedenti. Ciascuna di esse produce infatti un file di selezione, quindi un semilavorato della selezione complessiva che intendiamo compiere, che possiamo riutilizzare nelle selezioni successive.
-===== Perché si usa =====
-Lo scopo della selezione in cascata è quella di semplificare il compito del server quando le operazioni sono complesse e ridurre l'//overhead// dato dalla comunicazione //Client <-> Server//.
-Immaginiamo ad esempio di avere due unità informative distinte, //extension// e //container// in cui l'unità //container// abbia un riferimento ad un identificatore delle unità //extension//. Volendo selezionare tutti i documenti di //container// che hanno una certa descrizione o che fanno riferimento ad una certa //extension// avente un certo titolo dovremo:
-  * Selezionare tutte le unità informative //extension// aventi il titolo richiesto
-  * Selezionare tutte le unità informative //container// aventi la descrizione desiderata ovvero aventi un riferimento ad uno dei documenti di cui alla selezione precedente.
-In condizioni normali compiremmo la prima selezione di seguito esemplificata
-''[xml, /extension/@title]="test"''
-Questa selezione torna produce un semilavorato che è, ad esempio, ''3se123456789.tmp''. In seguito, utilizzeremo questo sottoprodotto per perfezionare la selezione successiva come nell'esempio seguente.
-''[xml,/container/@description]="test" OR [xml,/container/extension_ref/@id]={xml,/extension/@id;3se123456789.tmp}''
-Questo comporta l'esecuzione di due diverse operazioni da parte dell'applicazione. Lo stesso può ora essere eseguito con un operazione sola.
-===== Come su usa =====
-Abbiamo appena identificato le due diverse selezioni. Quello che ora ci serve sapere è che possiamo usare dei modificatori speciali della frase di ricerca che sono di seguito elencati:
-^ Modificatore ^ Descrizione ^
-^ <?THEN?> | E' il modificatore che consente di frazionare in parti distinte una frase di ricerca complessa. Le singole parti verranno prese in esame da sinistra verso destra ed eseguite in tale ordine.|
-^ <?SEL<sub>numero</sub>?> | Indica una selezione precedentemente eseguita. Va da se che non può essere utilizzata nella prima porzione della selezione((Non essendo presente alcun semilavorato pregresso)) ne si possono usare senza il dovuto ordine numerico. L'espressione è in base '0' quindi:\\ <?SEL0?> rappresenta il semilavorato della prima selezione\\ <?SEL1?> rappresenta il semilavorato della seconda selezione\\ ...e così via sino a <?SEL9?> che è il massimo valore ammesso. In sostanza, quindi, nell'ennesima porzione della selezione non potrò utilizzare le i modificatori che indicano semilavorati non appartenenti alle ''n-1'' selezioni precedenti. |
-<sub>(Il case con il quale vengono espressi questi modificatori non è importante, il server provvede a riconoscerli indipendentemente da esso)</sub>
-La precedente espressione verrà quindi tradotta come segue:
-''[xml, /extension/@title]="test" <color blue><?THEN?></color> [xml,/container/@description]="test" OR [xml,/container/extension_ref/@id]={xml,/extension/@id;<color blue><?SEL0?></color>}''
-In questo modo, il semilavorato della prima selezione viene automaticamente utilizzato per la risoluzione della seconda.
-<color black/yellow>__Il risultato finale delle operazioni svolte sarà l'esito della selezione di estrema destra. I semilavorati prodotti sino a quel momento non verranno messi a disposizione del //Cilent//__</color>
-===== Come si verifica =====
-L'esecuzione di una selezione come quelle indicate produce nel log una serie di registrazioni supplementari che consentono la verifica del comportamento delle singole parti della selezione in cascata.
-Rifecendoci ancora all'esempio precedente, ovvero alla selezione...
-''[xml, /extension/@title]="test" <color blue><?THEN?></color> [xml,/container/@description]="test" OR [xml,/container/extension_ref/@id]={xml,/extension/@id;<color blue><?SEL0?></color>}''
-Nel log si presenterànno le seguenti righe((Epurate dal //timestamp// e dal //Process Id//))...
-[Q]0x46-0x00<<<color grey>username</color>@0.0.0.0:/FIND>> <color grey>Archivio</color> (Sfffffffd:Ocd) [xml, /extension/@title]="test" <?THEN?>  [xml,/container/@description]="test" OR [xml,/container/extension_ref/@id]={xml,/extension/@id;<?SEL0?>}\\
-[D]SearchString: [xml, /extension/@title]="test"\\
-[I]Middle SeleFile <color red>3se4105785e0613801.tmp</color>, Docs <color grey>Numero Documenti Selezione 0</color>\\
-[D]SearchString:   [xml,/container/@description]="test" OR [xml,/container/extension_ref/@id]={xml,/extension\\ /@id;"<color red>3se4105785e0613801.tmp</color>"}\\
-[I]SeleFile 3se4105785e0f17701, Docs <color grey>Numero Documenti Selezione finale</color>\\
-[A]0 (<color gray>Tempi di esecuzione</color>)
-===== La modalità 'Union' =====
-Analogamente a quanto detto sino ad ora si è concepita una modalità <?UNION?>. Di fatto l'uso del separatore <?UNION?> al posto del separatore <?THEN?> sottintende un comportamento molto semplice.\\ In pratica esprimere...
-''<color brown>Espressione di ricerca '0'</color><color blue><?UNION?></color><color brown>Espressione di ricerca '1'</color>''
-...corrisponde in tutto e per tutto all'espressione...
-''<color brown>Espressione di ricerca '0'</color><color blue><?THEN?></color><color green>([SEL]=<?SEL0?>) OR (</color><color brown>Espressione di ricerca '1'</color><color green>)</color>''
-Di fatto usare la <?UNION?> in eXtraWay corrisponde al banale uso dell'operatore OR tra parti distinte ed isolate di una selezione quindi questo modificatore viene aggiunto solo per dovere di completezza.
-===== Esempi e Dettagli =====
-I dettagli della sintassi da usare possono essere più evidenti con alcuni esempi:
-==== Esempio 1 ====
-La frase di selezione...
-''[campo]=valore1 and valore2 <color blue><?THEN?></color> [?SEL]="<color blue><?SEL0?></color>" AND [campo]=valore2 or valore3''
-... può essere espressa anche come...
-''[campo]=valore1 and valore2 <color blue><?THEN?></color> [campo]=valore2 or valore3 <color blue><?THEN?></color> [?SEL]="<color blue><?SEL0?></color>" AND [?SEL]="<color blue><?SEL1?></color>"''
-...nel primo caso il semilavorato della prima selezione viene posto in AND con la seconda compiendone il raffinamento mentre nel secondo caso le due selezioni vengono compiute separatamente e poi combinate in AND portando, in sostanza allo stesso risultato.
-==== Esempio 2 ====
-Analogamente la selezione espressa di seguito...
-''[campo]=valore1 and valore2 <color blue><?THEN?></color> [?SEL]="<color red><?SEL1?></color>" AND [campo]=valore2 or valore3''
-...è errata in quanto nella seconda parte della selezione si possono usare solo i semilavorati delle selezioni già compiute((Nel nostro caso solo <?SEL0?>)).
-==== Esempio 3 ====
-In fine si noti come le espressioni...
-''<color blue>"<?SEL1?>"</color>''
-... e ...
-''<color blue><?SEL1?></color>''
-...siano di fatto corrispondenti in quanto il server provvede a //circondare// con i doppi apici l'identificatore della selezione che rappresenta il semilavorato.
-===== Considerazioni sulle performance =====
-==== Introduzione ====
-Risulta evidente sin dalla prima lettura, che questo sistema di selezione si applichi solo in casi piuttosto particolari ma no va esclusa la possibilità di farne uso per incrementare le performance di selezioni complesse.\\ Vale la pena di sottolineare alcuni aspetti:
-  * Le performance in selezione sono tanto migliore quando le ricerche prevedono solo ed esclusivamente operatori AND((Ovvero di adiacenza)) oppure solo ed esclusivamente operatori OR. In questi due casi la selezione è quanto più possibile rapida.
-  * Se la selezione non può essere espressa nel modo suddetto, la ricerca subisce un degrado prestazionale che è strettamente dipendente dal numero di chiavi coinvolte. Questo è vero sino a quando la ricerca non comprende operatori di negazione((NOT e NON)) o disuguaglianza((<>)).
-  * Quando la ricerca espressa presenta operatori di negazione o disuguaglianza si ricade nel peggiore dei casi, ovvero nella selezione più gravosa che il server possa compiere.
-Detto questo risulta evidente come la selezione...
-''[campo]=valore1 and valore2 or valore3''
-...ricade nel secondo dei casi. Ricorrendo alla forma in cascata, potremmo avere...
-''<color green>[campo]=valore1 and valore2</color> <color blue><?THEN?></color> <color brown>[?SEL]="</color><color blue><?SEL0?></color><color brown>" OR [campo]=valore3</color>''
-...che cambia completamente il proprio aspetto in quanto la <color green>prima porzione</color> è una ricerca che prevede esclusivamente operatori AND mentr la <color brown>seconda porzione</color> è espressa esclusivamente con operatori OR.\\ Questo non vuol dire che questa trasformazione nella selezione __debba__ rappresentare una miglioria nelle performance. Una delle selezioni intermedie di un'espressione così articolata, ad esempio, potrebbe produrre un semilavorato molto ampio e quindi avere una perdita di performance nella stesura del file temporaneo corrispondente.
-==== I casi più complessi ====
-Proviamo ora a vedere un caso lievemente differente, l'opposto del precedente, con la selezione...
-''[campo]=(valore1 or valore2) and valore3''
-...in questo caso, per poter frazionare la selezione secondo il criterio espresso avremmo...
-''[campo]=(valore1 or valore2) <color blue><?THEN?></color> [?SEL]="<color blue><?SEL0?></color>" AND [campo]=valore3''
-...che apparentemente è identico al caso precedente ma ciò non è vero. In questo caso viene prima compiuta una ricerca in OR che potrebbe utilizzare catene di riferimenti molto lunghe e giungere a selezionare un elevato numero di documenti. Questo semilavorato, poi, verrebbe posto in AND con un ulteriore valore. Se quest'ultimo avesse una catena di riferimenti molto breve avremmo una selezione che si conclude molto rapidamente ma solo dopo aver speso molto tempo con la prima.\\ In questo scenario, ovvero ammettendo che il termine ''valore3'' sia molto selettivo, anche se la cosa può apparire un po' poco intuitiva, la selezione potrebbe avere la seguente forma...
-''[campo]=(valore1 and valore3) <color blue><?THEN?></color> [campo]=(valore2 and valore3) <color blue><?THEN?></color> [?SEL]="<color blue><?SEL0?></color>" OR [?SEL]="<color blue><?SEL1?></color>"''
-In questo modo la prima e la seconda selezione verrebbero eseguite molto rapidamente((In virtù della brevità della catena dei riferimenti del termine ''valore3'' e dell'uso dell'opertore AND)) e la terza, questa volta tutta in OR, dovrebbe miscelare due sottoprodotti molto brevi.
-==== Conclusioni ====
-L'introduzione di questo nuovo sistema di selezione può risultare particolarmente utile per:
-  - Esprimere condizioni in cascata che non sarebbero altrimenti esprimibili se non con una maggiore necessità di elaborazione sul fronte applicativo.
-  - Esprimere selezioni che si potrebbero esprimere in modo //standard// per avvalersi di prestazioni migliorate.
-Se nel primo caso questa forma di selezione è senza dubbio la migliore, la più indicata, nel secondo è opportuno che lo sviluppatore abbia piena cognizione di ciò che sta facendo ed una conoscenza approfondita dell'archivio che gli consenta di valutare l'effettiva opportunità di adottare un simile stile.