Ciao a tutti,
sto terminando la riprogrammazione del mio sito di e-commerce (.NET+Sql Server 2005) e sto cercando di risolvere un problema prestazionale nella pagina che si occupa di visualizzare gli ordini ancora da evadere con la relativa disponibilità dei prodotti al loro interno (è una pagina composta da x righe che rappresentano gli x ordini attivi, ed ogni riga è colorata di verde o rosso a seconda che l'ordine sia evadibile).

Per il momento cerco di spiegare solo lo stretto necessario, altrimenti dovrei scrivere un papiro per spiegare tutto il
funzionamento, per vedere di risolvere il problema che ho.
Ho 1 tabella "tabProdotti" così costituita:
1)ID_Prodotto
2)DispVendita
3)DispMagazzino
4)OrdinatiDaRichiedere
5)DaConsegnare
+altra serie di campi che non interessano in questo ambito

Poi ho la tabella tabOrdini in cui salvo gli ordini:
1)ID_Ordine
2)ID_Utente
+altri campi

Per finire ho la tabella che mi contiene i prodotti degli ordini "tabProdottiOrdini":
1)ID_Prodotto
2)ID_Ordine
3)DataOrdine (in cui viene salvata la data nel momento in cui viene inserito il record in questa tabella)
3)Qta (rappresenta la qta del prodotto acquistata dall'utente)
Vorrei sapere se è possibile definire una vista, e qui mi sa che sto dicendo una cretinata ma le sto pensando un po' tutte per migliorare le prestazioni, così costituita:
1)ID_Prodotto
2)ID_Ordine
3)QtaSomma (questa Qta dovrebbe essere la somma delle Qta salvate nella tabella "tabProdottiOrdini" relative allo stesso ID_Prodotto e con DataOrdine <alla DataOrdine relativa al record elaborato)
mi spiego con un esempio

dati salvati nella tabProdottiOrdini:
a) ID_Prodotto=prod_1 - ID_Ordine=ord_1 - DataOrdine=data1 - Qta=1 ID_Prodotto=prod_2 - ID_Ordine=ord_1 - DataOrdine=data1 - Qta=1 c) ID_Prodotto=prod_1 - ID_Ordine=ord_2 - DataOrdine=data2 - Qta=3 d) ID_Prodotto=prod_3 - ID_Ordine=ord_3 - DataOrdine=data3 - Qta=1 e) ID_Prodotto=prod_1 - ID_Ordine=ord_4 - DataOrdine=data4 - Qta=2
La vista dovrebbe quindi essere questa:
a) ID_Prodotto=prod_1 - ID_Ordine=ord_1 - QtaSomma=0 (non ci sono altri con dataOrdine minore)
ID_Prodotto=prod_2 - ID_Ordine=ord_1 - QtaSomma=0 (stesso discorso di prima)
c) ID_Prodotto=prod_1 - ID_Ordine=ord_2 - QtaSomma=1 (1 solo prodotto con data minore)
d) ID_Prodotto=prod_3 - ID_Ordine=ord_3 - QtaSomma=0
e) ID_Prodotto=prod_1 - ID_Ordine=ord_4 - QtaSomma=4

Una volta che ho questi dati la disponibilità di un ordine è facilmente calcolabile.

Avete altre idea altrimenti di come risolvere il problema?

Dico solo che per il momento un calcolo simile lo effettuo con una stored e mediante una classe in .NET. il sistema da me adottato va benissimo per il calcolo delle disponibilità per un numero medio di ordini ancora da evadere salvati (circa 600-700) ma ora il numero di questi ordini sta crescendo quindi vorrei migliorare il sistema diminuendo il carico di lavoro sul server.

Grazie per la risposta Andrea.

Mi sa che non mi sono spiegato bene. Per il momento e per circa 1 anno almeno, tutte le elaborazioni stanno su un server web dedicato (sia parte utente che parte di amministrazione) per comodità visto che così possiamo gestire gli ordini da qualunque posto siamo. Il server è un dual xeon dual core da 3.0 con 4 Gb di memoria e HD SAS da 10.000 rpm (visto che sono quelli da 2.5 pollici).

Il problema è che noi gestiamo tutto sul server anche la generazione dei PDF (fatture e via dicendo)... quindi si ha un carico elevato sia sul comp che sulla banda.

Visto che mi sono messo a riprogrammare il sito (prima era in ASP con SQL Server) sto cercando di ottimizzare un po' tutto in modo da alleggerire se possibile il carico.

Server SQL e IIS stanno sulla stessa macchina. In questo caso, visto che le operazioni per gestire in tempo reale il calcolo della disponibilità di un ordine sono molto complesse, conviene far fare a sql server la maggior parte dei calcoli mediante una stored procedure o far elaborare la disponibilità in maniera mista con programmazione in C#? In definitiva è meglio una elaborazione completa su sql server senza apertura/chiusura connessioni e scambio dati con una
applicazione che si riduce solo allo scambio di informazioni finale (1 sola tabella)