Newsgroup: it.comp.lang.visual-basic
Titolo: SELECT TOP 10

Problemino con una select SQL ...
in una tabella ho cira 3000 record con un campo Peso, con una query vorrei
selezionare gli ultimi 10 e di questo mettere su una Txt il valore della
media di quest'ultimi.
Grazie anticipati !!
Ivano

 media di quest'ultimi.
dal momento che non ci dici nulla sul database, la tecnica di accesso dati,
etc... ti scrivo solo la query.
select avg(peso) from (select top 10 peso from miatabella order by peso asc)
as query1
dovrebbe funzionare sia in sql server che in access.
Su sql server metti avg(distinct peso) se vuoi una media effettiva dei
singoli valori, sennò la media viene effettuata sui valori raggruppati.
ciao
ugo

 con una query vorrei selezionare gli ultimi 10
che intendi con "gli ultimi 10"?
DisgustingAngel
-- 
questo articolo e` stato inviato via web dal servizio gratuito 
http://www.newsland.it/news
 segnala gli abusi ad 
ab...@newsland.it

se usa mysql non funziona, dato che non supporta le select annidate.....
quindi mi sa che bisogna fare a metà....
select top 10 peso from miatabella order by peso asc
così prendi i 10 record con peso più alto. poi calcoli la media con un
do...while
good coding!!!
-- 
Damiani Liborio Igor
ig...@igordamiani.it
 - 
soft...@igordamiani.it
 - 
idam...@hotmail.com
http://www.igordamiani.it
ICQ : 11847262

 annidate.....
Davvero??!!
Posso far tranquillamente a meno delle transazioni, ma non delle subquery.
Lascio perdere MySQL.

sì, è esattamente quello che ho pensato io quando ho letto questa
limitazione......
ti ricordi il tuo mega-post sulla possibilità di fare una sorta di
linguaggio franco per tutti i db, avendo un lato-server e un lato client, su
cui un po' tutti avevamo dibattuto? ecco, lungo il thread eravamo finiti
proprio per parlare di mysql.
avevo fatto notare questa cosa, e qualcuno mi aveva detto che era ben
scritto chiaramente all'inizio del manuale di mysql (che io un po' ho
letto), ma sinceramente 'sta cosa mi era sfuggita......
cmq, sì, è così.......è prevista l'implementazione delle sub-query nelle
prossime release....


 nelle prossime release....
Ok, ma facciamo un esempio e, premettendo che si può (ma con sintassi un po'
contorte e poco prestanti, almeno quelle che avevo trovato io, ben vengano
altre indicazioni), come faccio, in un'unica Select (peraltro banalissima e
"quotidiana"), a recuperare il codice (chiaramente univoco) dell'articolo
dalla tabella movimenti e la sua descrizione (ipotizzando, ovviamente, che
non sia duplicata/modificata nella tabella movimenti, come io normalmente
invece faccio) datta tabella articoli senza una Subquery e senza prevedere
nella clausola From sia la tabella movimenti che la tabella articoli (questo
rallenta non poco), ma solo ed esclusivamente la tabella movimenti?

 subquery. Lascio perdere MySQL.
http://www.mysql.com/doc/en/ANSI_diff_Subqueries.html
Dalla 4.1 supporta le subqueries... se è questo che intendevi...
Rayden.Paladino! :)

 Posso far tranquillamente a meno delle transazioni, ma non delle
Le transazioni sono supportate da un bel po' da mysql! Io le utilizzo! ;-)

beh, senza usare le JOIN e senza mettere le due tabelle nella clausola FROM,
beh, ecco....mumble...mumble....
non ne avrei proprio idea.....
ma vuoi saperne un'altra, che IMHO è ancora peggio?
mysql non permette di salvare all'interno del database le query/viste. Cioè,
voglio dire, mi sembra una mancanza grave!
Questa estate, seconda metà di agosto, volevo rendere compatibile la mia
applicazione che vendo qui al nord Italia con mysql (già funziona con
access, msde/sqlserver, oracle). il mio db fa un uso intensivo delle query,
e quando ho visto che un db mysql non può memorizzare query/viste ho perso
sinceramente stima nei confronti di questo db......


[*Lord Rayden*=
ray...@h.a.r.d.w.a.r.e.t.i.p.s.com
] ha scritto:

Forse ho letto superficialmente, ma non mi pare che si possa fare:
Select
    Mov.Codice_Articolo,
    Select(Art.Descrizione From Art Where
Art.Codice_Articolo=Mov.Codice_Articolo)
        As DesArt
From
    Mov
Mi sbaglio?

 query/viste. Cioč, voglio dire, mi sembra una mancanza grave!
Nei miei DB non utilizzo viste (per ovvi motivi) e ti assicuro che alla fine
non sono poi indispensabili. btw dovrebbero essere presto implementate!

 con access, msde/sqlserver, oracle).
Approfitterei, come ho spudoratamente fatto con Lord:
Un link che racconti un po', almeno a grandi linee, le differenze
sintattiche (ovviamente per il solo linguaggio SQL) fra SQL Server e Oracle,
via ADO?

le query memorizzate nel db non sono precompilate e quindi migliori dal
punto di vista delle prestazioni?
posso capire che access sia limitato sotto questo discorso, ma i vari
manuali di sqlserver e oracle consigliano, quando possibile, di usare le
viste/query, perchè il motore del db che lancia la query salta un mucchio di
passaggi, appunto perchè la vista è già compilata (quindi sa già quali
indici usare, come ottimizzare il tutto, etc.....)
sbaglio?


 sbaglio?
No, non mi pare, ma ho fatto una prova e, forse a parte il non trascurabile
fatto che (in ambiente Client/Server) vengono eseguite sul server (ma non ho
approfondito test di velocità in tal senso), quanto pesa la
"complilazione/validazione" di una query "importante" rispetto alla sua
effettiva esecuzione?
Secondo me uno 0,molti0equalcosa percento. O mi sbaglio io?
Senza contare le limitazioni, per esempio (vado a memoria), che una
StoredProcedure in SQL Server non accetti alcun Order By...

 Oracle, via ADO?
Oracle non so neanche come è fatto... però ho sulla scrivania un libro
generosamente fornitomi dall'azienda con cui collaboro intitolato "SQL guida
di riferimento" di Kevin Kline e Daniel Kline (Apogeo O'Reilly) che con
degli utili specchietti evidenzia le differenze tra SQL Server, MySQL,
Oracle e PostgreSQL. Prezzo di copertina 20,14?, circa 250 pagine.
Se lo trovi in libreria dagli un'occhiata... io l'ho letto solo parzialmente
ma in certi casi mi ha risparmiato un po' di tempo.

Secondo me uno 0,molti0equalcosa percento. O mi sbaglio io?
Ho fatto una prova con SQL Server su Northwind :
 
    Dim a As Single
    Dim b As Single
    Dim i As Long
    Dim rs As New ADODB.Recordset
    rs.ActiveConnection = gadoConnessione
    rs.CursorLocation = adUseClient
 
    rs.Source = "SELECT * FROM ""Orders Qry"";"
    a = Timer()
    For i = 0 To 200
        rs.Open
        rs.Close
    Next i
    b = Timer()
    Debug.Print b - a
 
    rs.Source = "SELECT Orders.OrderID, Orders.CustomerID,
Orders.EmployeeID, Orders.OrderDate, Orders.RequiredDate," & _
                "Orders.ShippedDate, Orders.ShipVia, Orders.Freight,
Orders.ShipName, Orders.ShipAddress, Orders.ShipCity," & _
                "Orders.ShipRegion, Orders.ShipPostalCode,
Orders.ShipCountry," & _
                "Customers.CompanyName , Customers.Address,
Customers.City, Customers.Region, Customers.PostalCode,
Customers.Country " & _
                "FROM Customers INNER JOIN Orders ON
Customers.CustomerID = Orders.CustomerID;"
    a = Timer()
    For i = 0 To 200
        rs.Open
        rs.Close
    Next i
    b = Timer()
    Debug.Print b - a
 
    Set rs = Nothing
Il risultato confermerebbe maggiori prestazioni per le viste :
 6,015625 
 6,03125 
 6,015625 
 6,015625 
 6,015625 
 6,078125 
 6 
 6,015625 
 6 
 6,03125 
 6,015625 
 6,03125 
 6 
 6,03125 
Spesso, la vista può essere modificata senza la necessità di dover
ricompilare ... a questo punto che vantaggi può offrire l'uso di una
select articolata all'interno del programma, anzichè l'uso di una
vista?
Ciao!

 vista?
Ora faccio il taccagno ;-) :
Quanto pesa comporre una stringa con variabili rispetto a (se ho ben capito)
passare parametri alla query precompilata?

passare parametri alla query precompilata?
Ok! Ti faccio notare comunque che la query viene composta una sola
volta prima del ciclo.
Ciao!

 volta prima del ciclo.
Anche una stringa (certo, ogni volta compilata), ma quel che mi interessava
mooolto è l'incidenza del "puro tempo di compilazione". Allo stato lo
definirei irrisorio, ininfluente, nemmeno da citare come una qualità (parlo
di M$ e SQL Server, non di te, chiaro?! - vedi altro mio topic in
parzial-proposito...)

provato/non provato.
Vedi sopra!
Ciao!

 Vedi sopra!
Beh (mi rendo conto, da 30 ho chiesto 31 e ora, spudoratamente, 32), per
questo fai alla svelta:
Modifichi solo il codice con CursorLocation=adUseServer e (introduci)
CursorType=adOpenStatic
Però, in questo caso e per ottenere risultati confrontabili, togli Order By
(che, da una parte sola, non può che impedire ogni confronto)
Grazie ancora (finchè ti va, ovviamente)

CursorType=adOpenStatic
Questo č il codice:
    Dim a As Single
    Dim b As Single
    Dim i As Long
    Dim rs As New ADODB.Recordset
    rs.ActiveConnection = gadoConnessione
    rs.CursorLocation = adUseServer
    rs.CursorType = adOpenStatic
 
    rs.Source = "SELECT * FROM ""Orders Qry"";"
    a = Timer()
    For i = 0 To 200
        rs.Open
        rs.Close
    Next i
    b = Timer()
    Debug.Print b - a
 
    rs.Source = "SELECT Orders.OrderID,
Orders.CustomerID,Orders.EmployeeID, Orders.OrderDate,
Orders.RequiredDate," & _
                "Orders.ShippedDate, Orders.ShipVia,
Orders.Freight,Orders.ShipName, Orders.ShipAddress, Orders.ShipCity,"
& _
                "Orders.ShipRegion,
Orders.ShipPostalCode,Orders.ShipCountry," & _
                "Customers.CompanyName ,
Customers.Address,Customers.City, Customers.Region,
Customers.PostalCode,Customers.Country " & _
                "FROM Customers INNER JOIN Orders ON
Customers.CustomerID = Orders.CustomerID;"
    a = Timer()
    For i = 0 To 200
        rs.Open
        rs.Close
    Next i
    b = Timer()
    Debug.Print b - a
 
    Set rs = Nothing
E questi i tempi:
 3,203125 
 2,84375 
 3,21875 
 2,890625 
 3,203125 
 2,453125 
 3,265625 
 2,453125 
 3,1875 
 2,46875 
A questo punto qualcosa non mi quadra! :-(
Facciamo anche 33 ;) ...
Questi sono i tempi che ottengo col codice riportato sopra e
connessione ad un database su server (non in locale):
 8,078125 
 6,15625 
 7,890625 
 6,078125 
 7,9375 
 6,046875 
 7,921875 
 6,046875 
 7,875 
 6,125 
????

 ????
Nessun ??? ;-) Confermano. Sono più alti perchè c'è di mezzo la rete che,
per veloce che sia (10/100/1000?) è sempre un collo di bottiglia rispetto ai
trasferimenti disco-memoria.
Salvo ulteriori dubbi (o contestazioni a quanto ho scritto), da parte tua o
di altri, io sono soddisfatto (e non tocco una virgola nei miei
applicativi).
Grazie infinite per la tua disponibilità, davvero!

Da un rapido sguardo alla guida di SQL Server:
"I dati accessibili tramite una vista non sono archiviati nel database
sotto forma di un oggetto distinto. Nel database è archiviata in
realtà solo un'istruzione SELECT."
Da qui mi chiedo se non sia del tutto fuori luogo parlare di  "query
precompilata"!
Inoltre, nella sezione Visual Database Tools\Confronto tra query e
viste, non viene mai fatto riferimento alle maggiori prestazioni delle
viste sulle query.
In altre parole il discorso che abbiamo fatto finora per le viste è
inutile.
Ciao!

 inutile.
No, non è inutile! E' teoricamente giusto fare questi discorso.
E' vero che le query/SP depositate sono più veloci.
Non è vero, IMHO, che si dica "usatele assolutamente, sono eccezionalmente
veloci". Sono balle!
Sono più veloci, non eccezionalmente veloci e, mi pare, si è avuta conferma.
Di qualche centesimo di secondo su 6 o 3 secondi, me ne faccio una pippa (di
fronte al lavoro per creare, gestire, parametrizzare, eseguire, ordinare,
etc. una query/SP), quando l'esecuzione impiega 10 secondi o 100 (o anche
più, dipende da quanti dati devo pistolare) e poi, eventualmente, ne devo
esporre i risultati su una griglia, con un Add per ogni riga, formatta,
allarga e stringi, centra, allinea, font-izza, ... menala.

certo tecnicamente perfetto.
Non rimango spiazzato dalla maggior velocità del lato server.
Partendo dall'ipotesi che una vista sia compilata tipo stored
procedure, sono rimasto sorpreso nel constatare che queste ultime
verifeche abbiano smentito l'ipotesi stessa.
La query da codice risulta più veloce della vista, ed è questo che mi
ha lasciato sorpreso. Mi è sempre stato detto che le viste sono più
performanti ...
A questo punto l'unico vantaggio certo che offrono, è di poterle
modificare senza dover ricompilare i sorgenti di un'applicazione.

 modificare senza dover ricompilare i sorgenti di un'applicazione.
Beh, sempre parlando di contesti, vero che molte query sono "cablate" nel
programma per le masturbazioni interne, è altrettanto vero che molte altre
dipendono dalle scelte (e dagli Order By) fatte estemporaneamente
dall'operatore in fase di consultazione/stampa

contestualmente. Toglilo e vedrai che ti torna.
Il punto è che le ultime prove che ho postato, come da codice, non
hanno il famigerato "Order"! Hanno però un cursore adOpenStatic ...
Tutto quanto torna a quadrare utilizzando un adForwardOnly.
Non avrebbe senso usare un adOpenStatic per dei dati che vanno "solo"
visualizzati, magari su una MSFlexGrid.

Tutto quanto torna a quadrare utilizzando un adForwardOnly.
Dimenticavo ...
Su db locale o con cursore lato client!

 visualizzati, magari su una MSFlexGrid.
E se uno (io, il mio utente che si muove sulla griglia) deve scorrere
all'indietro?
Preciso: Io non popolo la griglia per tutte le (supponiamo) 1000 righe del
recordset, ma a "pezzettoni" di 100 righe per volta. In funzione dello
scorrimento, vado a caricare ed esporre il blocco di 100 righe seguente o
precedente.
Io uso sempre e solo lato Server e Static, credo, dalle prove che a suo
tempo ho fatto, che sia la media giusta (fra ForwardOnly e Dynamic, questo
il più veloce in assoluto, ma dinamico ... altrettanto. Potentissimo, ma
pericolosissimo)

 wrote:
Se hai tempo di darci un'occhiata, gradirei dei commenti ...
DB LOCALE
Vista     -> SELECT * FROM "Orders Qry";
CLocation    adOpenForwardOnly  adOpenKeyset  adOpenDynamic
adOpenStatic
adUseServer  0.90625            1.625         0.171875       3.1875
adUseServer  0.875              1.5625        0.171875       3.21875
adUseServer  0.890625           1.5625        0.171875       3.1875
adUseServer  0.90625            1.5625        0.171875       3.296875
adUseServer  0.90625            1.671875      0.171875       3.5625
adUseServer  0.921875           1.578125      0.1875         3.203125
adUseServer  0.90625            1.546875      0.171875       3.203125
adUseServer  0.890625           1.546875      0.171875       3.21875
adUseServer  0.875              1.5625        0.171875       3.25
adUseServer  0.890625           1.5625        0.15625        3.234375
adUseClient  6.03125            6.0625        6.078125       6.09375
adUseClient  6.09375            6.078125      6.09375        6.09375
adUseClient  6.078125           6.09375       6.078125       6.109375
adUseClient  6.078125           6.09375       6.09375        6.078125
adUseClient  6.09375            6.171875      6.140625       6.078125
adUseClient  6.09375            6.109375      6.09375        6.09375
adUseClient  6.09375            6.109375      6.09375        6.09375
adUseClient  6.09375            6.09375       6.109375       6.09375
adUseClient  6.09375            6.109375      6.171875       6.171875
adUseClient  6.09375            6.09375       6.09375        6.109375
Query     -> SELECT Orders.OrderID,
Orders.CustomerID,Orders.EmployeeID,
                    Orders.OrderDate,
Orders.RequiredDate,Orders.ShippedDate,
                    Orders.ShipVia, Orders.Freight,Orders.ShipName,
Orders.ShipAddress,
                    Orders.ShipCity,Orders.ShipRegion,
Orders.ShipPostalCode,
Orders.ShipCountry,Customers.CompanyName,Customers.Address,Customers.City,
                    Customers.Region,
Customers.PostalCode,Customers.Country
            FROM Customers INNER JOIN Orders ON Customers.CustomerID =
Orders.CustomerID;
CLocation    adOpenForwardOnly  adOpenKeyset  adOpenDynamic
adOpenStatic
adUseServer  1.796875           1.484375      0.171875       3.28125
adUseServer  1.078125           1.546875      0.15625        3.1875
adUseServer  0.984375           1.546875      0.15625        3.171875
adUseServer  1.359375           1.5625        0.15625        3.171875
adUseServer  2.1875             1.5625        0.15625        3.265625
adUseServer  1                  1.5625        0.15625        3.171875
adUseServer  1.109375           1.546875      0.15625        3.265625
adUseServer  1.03125            1.546875      0.15625        3.171875
adUseServer  1.671875           1.53125       0.15625        3.171875
adUseServer  1.296875           1.546875      0.15625        3.265625
adUseClient  6.203125           5.90625       6.0625         6.015625
adUseClient  6.0625             6.015625      6.015625       6
adUseClient  5.96875            5.953125      5.953125       5.953125
adUseClient  5.953125           5.953125      5.953125       5.953125
adUseClient  5.953125           5.953125      5.953125       5.953125
adUseClient  5.953125           5.96875       5.953125       6
adUseClient  6                  5.96875       5.953125       5.96875
adUseClient  5.953125           5.96875       5.953125       5.96875
adUseClient  5.953125           5.96875       6              5.96875
adUseClient  5.96875            5.984375      6              5.96875
****
DB RETE
Vista     -> Vedi sopra.
CLocation    adOpenForwardOnly  adOpenKeyset  adOpenDynamic
adOpenStatic
adUseServer  16.71875           3.46875       0.53125        8.09375
adUseServer  13.84375           3.46875       0.421875       8.078125
adUseServer  14.859375          3.734375      0.46875        8.140625
adUseServer  12.109375          3.5           0.5            7.984375
adUseServer  9.359375           3.5           0.578125       7.921875
adUseServer  9.3125             3.421875      0.5            7.9375
adUseServer  8.890625           3.515625      0.390625       7.953125
adUseServer  12.5625            3.5           0.40625        8.078125
adUseServer  12.96875           3.546875      0.453125       7.921875
adUseServer  15.625             3.578125      0.578125       7.859375
adUseClient  7.953125           7.8125        7.890625       7.78125
adUseClient  8.375              7.9375        8.046875       8.078125
adUseClient  7.921875           7.828125      7.90625        8.03125
adUseClient  7.984375           7.921875      7.921875       7.890625
adUseClient  7.9375             7.765625      7.78125        7.78125
adUseClient  7.90625            7.8125        7.765625       7.78125
adUseClient  7.734375           7.84375       7.765625       7.859375
adUseClient  7.9375             8.015625      7.875          7.796875
adUseClient  7.828125           7.84375       7.921875       8
adUseClient  7.859375           7.859375      7.953125       7.828125
Query     -> Vedi sopra.
CLocation    adOpenForwardOnly  adOpenKeyset  adOpenDynamic
adOpenStatic
adUseServer  12.625             3.296875      0.484375       7.9375
adUseServer  7.203125           3.453125      0.515625       8.046875
adUseServer  7.625              3.5625        0.453125       8
adUseServer  6.515625           3.578125      0.59375        7.9375
adUseServer  9                  3.515625      0.4375         8
adUseServer  7.84375            3.5625        0.453125       7.96875
adUseServer  8.0625             3.59375       0.484375       8.078125
adUseServer  8.59375            3.515625      0.578125       8.0625
adUseServer  9.203125           3.53125       0.59375        7.953125
adUseServer  8.234375           3.515625      0.390625       7.96875
adUseClient  8.078125           8             8.1875         7.921875
adUseClient  8.125              7.953125      8.015625       7.921875
adUseClient  7.96875            8.140625      8.078125       8
adUseClient  7.890625           8.015625      7.984375       7.9375
adUseClient  7.921875           8.203125      7.875          7.984375
adUseClient  8.046875           7.953125      8.0625         7.9375
adUseClient  7.875              8.03125       8.109375       8
adUseClient  7.9375             7.96875       7.9375         8.046875
adUseClient  8                  7.921875      8.03125        8.03125
adUseClient  7.9375             8.03125       7.921875       8.03125
E questo è il codice:
Private Sub SalvaTempiTxt(ByRef rs As Recordset)
    Dim i As Long
    Dim n As Integer
    Dim s As String
 
    n = FreeFile()
    Open "C:\Temp\Tempi.txt" For Output As #n
 
    For i = 0 To rs.Fields.Count - 1
        s = s & vbTab & rs(i).Name
    Next i
    Print #n, s
 
    While Not rs.EOF
        Print #n, vbTab & rs.GetString(adClipString, 1, vbTab, "", "")
    Wend
 
    Close #n
End Sub
Private Sub VerificaPrestazioni(ByVal sql As String)
    '
    Dim a As Single
    Dim b As Single
    Dim d As Single
    '
    Dim cursorLocation As Long
    Dim cursorType As Long
    Dim iterazioniType As Long
    Dim iterazioniLocation As Long
    '
    Dim rs As New ADODB.Recordset
    Dim rsTempi As New ADODB.Recordset
 
    With rsTempi.Fields
        .Append "CLocation", adBSTR
        .Append "adOpenForwardOnly", adBSTR
        .Append "adOpenKeyset", adBSTR
        .Append "adOpenDynamic", adBSTR
        .Append "adOpenStatic", adBSTR
    End With
    rsTempi.Open
 
    rs.ActiveConnection = gadoConnessione
    rs.Source = sql
 
    '2 - adUseServer
    '3 - adUseClient
    For cursorLocation = 2 To 3
        rs.cursorLocation = cursorLocation
 
        For iterazioniLocation = 1 To 10
            rsTempi.AddNew
 
            '0 - adOpenForwardOnly
            '1 - adOpenKeyset
            '2 - adOpenDynamic
            '3 - adOpenStatic
            For cursorType = 0 To 3
                rs.cursorType = cursorType
 
                a = Timer()
                For iterazioniType = 1 To 200
                    rs.Open
                    rs.Close
                Next iterazioniType
                b = Timer()
                d = b - a
 
                Select Case cursorLocation
                    Case adUseServer
                        rsTempi("CLocation") = "adUseServer"
                    Case adUseClient
                        rsTempi("CLocation") = "adUseClient"
                End Select
                Select Case cursorType
                    Case adOpenForwardOnly
                        rsTempi("adOpenForwardOnly") = d
                    Case adOpenKeyset
                        rsTempi("adOpenKeyset") = d
                    Case adOpenDynamic
                        rsTempi("adOpenDynamic") = d
                    Case adOpenStatic
                        rsTempi("adOpenStatic") = d
                End Select
 
            Next cursorType
        Next iterazioniLocation
    Next cursorLocation
 
    Set rs = Nothing
 
    Set hfgTempi.DataSource = rsTempi
    rsTempi.Save "C:\Temp\Tempi.xml", adPersistXML
    Call SalvaTempiTxt(rsTempi)
    rsTempi.Close
    Set rsTempi = Nothing
End Sub
Private Sub VerificaQueryViste()
    'Call VerificaPrestazioni("SELECT * FROM ""Orders Qry"";")
    Call VerificaPrestazioni("SELECT Orders.OrderID,
Orders.CustomerID,Orders.EmployeeID, Orders.OrderDate,
Orders.RequiredDate," & _
                "Orders.ShippedDate, Orders.ShipVia,
Orders.Freight,Orders.ShipName, Orders.ShipAddress, Orders.ShipCity,"
& _
                "Orders.ShipRegion,
Orders.ShipPostalCode,Orders.ShipCountry," & _
                "Customers.CompanyName ,
Customers.Address,Customers.City, Customers.Region,
Customers.PostalCode,Customers.Country " & _
                "FROM Customers INNER JOIN Orders ON
Customers.CustomerID = Orders.CustomerID;")
End Sub
Ciao!

 Se hai tempo di darci un'occhiata, gradirei dei commenti ...
Lo farò senz'altro, nel primo pomeriggio. Intanto grazie!

 Se hai tempo di darci un'occhiata, gradirei dei commenti ...
-Precisiamo subito che (come dicono i sacri testi) un cursore lato Client
forzerà ogni tipo di apertura (a parte forse il ForwardOnly) a
adOpenStatic. Non può esservi, infatti, nulla di dinamico (puntatori) nei
confronti del server se i dati stanno (vengono trasportati) sul client.
Lo si può ben notare (a parte le inevitabili piccole differenze nella
rilevazione dei tempi) in tutti i casi in cui compare nel tuo schema
adUseClient. Le colonne (tutte, anche ForwardOnly, la prima a sinistra)
riportano tutte tempi simili, diciamo simili, appunto, alla colonna
adOpenStatic (l'ultima a destra)
-Notiamo anche che in tutti i casi in cui si una il lato Client i tempi sono
molto alti rispetto al lato Server. Questo è più che comprensibile (ma per
me assolutamente improponibile, nel senso che è troppo lento ed è per
questo che ho trovato la mia "media" in lato server e Static, fin da quel
progetto di prova sul SC col nome VBDAOADO). Occorre aggiungere che i tempi
non sono tanto alti per i tempi di esecuzione della vista o della query,
quanto per il trasporto completo dei risultati dal server al client (un po'
come avviene, per le tabelle interessate, con Access che Client/Server non
è, ma, non perdo occasione per sottolinearlo, DAO, fatto per Jet/Access, con
poche postazioni concorrenti, è molto più veloce di ADO e qualsiasi cosa,
Access compreso)
-Con lato server i cursori hanno un senso più attinente al loro nome:
Il ForwardOnly non consente lo scorrimento all'indietro e non è
aggiornabile.
Sinceramente non capisco, lato server, come mai sia così lento, sia per la
vista che per la query, ma, stranamente, solo in rete, non in locale. Come
se (ma approfondirò) in rete trasportasse i risultati come se fosse lato
client.
Il Dynamic si dimostra (ma, bada bene, non sempre, a volte basta un
Order By che "contrasta" un po' la struttura degli indici che rallenta,
anche parecchio) il più veloce in assoluto ed è ovvio (anche se non
immediato da capire, se non ... provando) perchè fa girare, dinamicamente
appunto, solo ed esclusivamente un puntatore, nessun dato.
E' potentissimo e velocissimo, ma, come dicevo, da usarsi con molta cautela.
Per esempio (ma vado a memoria, se il caso posso precisare con certezza), se
compongo un recordset e lo scorro, potrei incappare in un EOF pur testato
perchè un'altra postazione mi ha cancellato un record oppure (da non
credere, quasi nemmeno vedendolo!) sto lavorando sul record corrente che è,
supponiamo il
quarto, e questo diventa improvvisamente il quinto (o il terzo) "solo"
perchè è stato inserito (da altri) un record che riordina il mio set.
Insomma, credevo di aver risolto i miei (di tutti, direi) problemi di
velocità con ADO+SQL
Server, ma ho dovuto ripiegare sullo Static perchè il Dynamic è
"ingestibile" (chiaramente
in senso lato).
Il Keyset è simile al Dynamic (credo che non mostri qualcosa
come, forse, le eliminazioni) e ha "problemi di gestione" simili al Dynamic.
La sua velocità si piazza in mezzo. Insomma, è un "parziale dinamico".
Infine lo Static che garantisce la coerenza e la staticità dei dati e del
proprio puntatore (salvo, naturalmente quello che avviene nel frattempo, per
esempio l'accesso a un record che è stato eliminato). Insomma, la giusta,
ovviamente IMHO, via di mezzo, che, infatti, ho scelto.
-Per i tempi fra vista e query, direi che si conferma quel che abbiamo
considerato
ieri, sia in locale che in rete. le differenze dovute alla precompilazione
sono irrisorie.
Spedisco senza rileggere. Insomma, metto spudoratamente le mani avanti (o,
se preferite, mi paro il c.lo) e se
c'è qualche cappella, dirò che non ho avuto tempo di correggerla. Oppure che
volevo vedere se eravate attenti ;-)
Grazie ancora per tutto il tempo che hai impegnato.
Questo topic ha tutti i crismi per meritare il mio archivio personale.

Questo topic ha tutti i crismi per meritare il mio archivio personale.
La questione mi interessa parecchio, e mi dispiace che non abbiano
partecipato più persone.
Ciao!