Newsgroup: it.comp.lang.visual-basic
Titolo: [SQL] Differenze su date in SQL-server ADO\Access DAO

Fino a qualche mese fa ho sempre programmato con Access97 e DAO.
Ora sto scrivendo un programma con SQL-Server2000 e ADO.
In Access\DAO per fare ricerche su campi data usavo una query così:
"SELECT * FROM Tabella WHERE Campo = #" & _
   Format(Data, "mm\/dd\/yyyy hh\:nn\:ss") & "#"
e pensavo che il formato americano racchiuso tra # fosse lo standard.
Ora invece ho scoperto che sotto SQL-Server\ADO benchè questa funzioni:
"SELECT * FROM Tabella WHERE Campo = #" & _
   Format(Data, "mm\/dd\/yyyy") & "#"
quella precedente non ne vuol sapere, mi da errore sullo spazio dopo
l'anno.
Dopo un lungo viaggio nella guida in linea (dove le cose che ti
interessano sono sempre ben nascoste) ho trovato il seguente formato,
definito come standard ansi (potrei sbagliare le sigle, vado a memoria):
"SELECT * FROM Tabella WHERE Campo = { dt '" & _
   Format(Data, "yyyy\-mm\-dd hh\-nn\-ss") & "'}"
Ma allora mi chiedo, qual è il vero foramto standard?
-- 
Samuele Battarra
prova il mio newsreader:
http://digilander.iol.it/battarsa/programmi/news/

 ha scritto
| Ma allora mi chiedo, qual č il vero foramto standard?
Se hai trovato l'ANSI, QUELLO e' il formato standard.

Se hai trovato l'ANSI, QUELLO e' il formato standard.
Quindi "yyyy-mm-dd" :
Searching on Dates
The format you use to enter dates depends on the database you are using and in what pane 
of the Query Designer you are entering the date. 
The Query Designer can work with the following date formats: 
Locale-specific   
The format specified for dates in the Windows Regional Settings Properties dialog box.
Database-specific   
Any format understood by the database.
ANSI standard date  
A format that uses curly brackets, the marker ‘d’ to designate the date, and a date string, 
as in the following example:
{ d '1990-12-31' }
ANSI standard datetime   Similar to ANSI-standard date, but uses ‘ts’ instead of ‘d’ 
and adds hours, minutes, and seconds to the date (using a 24-hour clock), 
as in this example for December 31, 1990:
{ ts '1990-12-31 00:00:00' }
In general, the ANSI standard date format is used with databases that represent dates 
using a true date data type. In contrast, the datetime format is used with databases 
that support a datetime data type. 
-- 
ciao, hal

 
[cut]
Questa spiegazione l'avevo già letta (tra l'altro in italiano).
Poi però ho fatto un po di esperimenti e ho scoperto quanto segue.
Se faccio una ricerca usando SQL, scrivendo ad esempio
SELECT * FROM Tabella WHERE Data = " & ....
la data la riconosce se è nel formato ANSI.
Se invece faccio la ricerca col metodo find di ADO
rsDati.Find "Data = " & ....
la data la riconosce se è nel formato con #.
Per risolvere alla funzione che esegue la formattazione,
in uno dei due casi cambio segno al parametro che indica il tipo di dato
così riesco a distinguere i due casi.
Ora però ho un altro problema con il formato booleano,
che però vi spiego domani, ora vado a letto :-)


che però vi spiego domani, ora vado a letto :-)
Buona notte :-)
-- 
ciao, hal

 
Se devo cercare nel campo b una data contenuta nella txtB faccio:
rsDati.Find "b = " & Cercato(txtB, adDate)
oppure
SQL = "SELECT * FROM tabella WHERE b = " & Cercato(txtB, -adDate)
rsDati.Open SQL, StringaConnessione
dove Cercato è così definito:
'------------------------------------------------------------------
' Procedura : Cercato
' DataOra   : 15/11/2001 18.16
' Autore    : Samuele Battarra
' Scopo     : Formatta una stringa da cercare
'             per metterla nell'SQL o nel metodo find.
'             Se eTipo < 0 vuol dire che è una query SQL.
'------------------------------------------------------------------
Public Function Cercato(ByRef vCerca As Variant, _
   ByVal eTipo As DataTypeEnum) As String
   Dim bDaQuery As Boolean
 
   bDaQuery = (eTipo < 0)
   If bDaQuery Then eTipo = -eTipo
   Do While Len(Cercato) = 0
      Select Case eTipo
         Case adDate, adDBTimeStamp, adFileTime, adDBFileTime
            If bDaQuery Then
               Cercato = "{ ts '" & Format(vCerca, "yyyy\-mm\-dd hh\:nn\:ss") & "' }"
            Else
               Cercato = "#" & Format(vCerca, "mm\/dd\/yyyy hh\:nn\:ss") & "#"
            End If
         Case adChar, adVarChar
            Cercato = "'" & Apici(vCerca) & "'"
         Case adBoolean
            Cercato = "xxxx"
            If IsNumeric(vCerca) And vCerca <> 0 Then Cercato = 1
            If IsNumeric(vCerca) And vCerca = 0 Then Cercato = 0
            If UCase(vCerca) = "SI" Then Cercato = 1
            If UCase(vCerca) = "NO" Then Cercato = 0
            If UCase(vCerca) = "VERO" Then Cercato = 1
            If UCase(vCerca) = "FALSO" Then Cercato = 0
            If UCase(vCerca) = "TRUE" Then Cercato = 1
            If UCase(vCerca) = "FALSE" Then Cercato = 0
         Case adVariant
            Select Case VarType(vCerca)
               Case vbDate: eTipo = adDate
               Case vbString: eTipo = adChar
               Case vbBoolean: eTipo = adBoolean
               Case Else: eTipo = adError
            End Select
         Case Else
            Cercato = CStr(vCerca)
      End Select
   Loop
End Function
'------------------------------------------------------------------
' Procedura : Apici
' DataOra   : 13/11/2001 09.02
' Autore    : Samuele Battarra
' Scopo     : Quando si esegue una query i nomi vanno racchiusi
'             tra apici. Se questi contengono già apici questi
'             vanno raddoppiati.
'             Questa funzione serve per raddoppiare gli apici.
'------------------------------------------------------------------
Public Function Apici(ByVal sStr As String) As String
   Apici = Replace(sStr, "'", "''")
End Function
Per quanto riguarda il problema a cui ho accennato la volta scorsa...
La funzione Cercato vorrei generalizzarla per poterla usare sia con
SQLServer che con Access.
Problema con i campi di tipo Boolean.
.Find "campo = 0" mi restituisce tutti i falsi.
.Find "campo = 1" o .Find "campo = -1" mi restituisce tutti i veri.
SELECT * FROM tabella WHERE campo = 0 mi restitutisce tutti i falsi.
Ora vengono i problemi.
SELECT * FROM tabella WHERE campo = 1
con SQL restituisce tutti i veri, con Access non restituisce niente.
SELECT * FROM tabella WHERE campo = -1
con Access restituisce tutti i veri, con SQL non restituisce niente.
Bisognerebbe poter distinguere su che db si sta lavorando, ma non mi
viene in mente nessuna idea che non sia il parsing della stringa di
connessione.
