Pagina 1 di 13 1 2 3 11 ... ultimoultimo
Visualizzazione dei risultati da 1 a 10 su 123
  1. #1

    [pillola] DATE/TIME e MySQL.

    PARTE PRIMA

    Gestione dati DATE/TIME con MySQL.

    Premessa.

    La fonte di riferimento e' il manuale ufficiale MySQL. Questa documentazione, e'
    utilizzata per on-the-job training su MySQL. E' una semplice documentazione
    della gestione DATE/TIME in MySQL. E' un documento che si rivolge a chi inizia,
    a chi ha difficolta' di traduzione, a chi utilizza MySQL ed ha necessita'
    di gestire DATE/TIME nelle sue tabelle. Gli utenti esperti sono cortesemente
    invitati a dare suggerimenti su come migliorare e integrare il documento.

    Tutte le query sono state testate e funzionanti su una suite composta da:
    Apache2.0.44 - PHP 4.3.1 - MySQL 4.0.12 - OS WIN 98/2000/xp. Sono possibili errori
    di copia incolla. Potete verificare le funzioni provando gli script php che
    troverete piu' avanti. Non necessita di db, ma solo della connessione a MySQL.
    MySQL e' conforme alle specifiche dell'anno 2000. (ecco fatto, l'ho detto)


    MySQL e la gestione dei campi formato DATE/TIME.

    Tutti i campi relativi a data/ora hanno una gamma di valori consentiti oppure
    una serie di zero se la data/ora non viene indicata oppure inserita con un formato
    non valido. Non ci sono segnalazioni di errore per inserimento data/ora non valida.

    I campi in formato data/ora su MySQL quindi NON sono mai EMPTY o NULL ma conterranno
    sempre una data/ora valida oppure degli 0 (zero) composti nel formato data/ora previsto
    nel campo. Se si cerca di estrarre da un campo dei dati esistenti ma non congruenti
    con la richiesta (es. cercare di estrarre un valore di data da campo formato time)
    la query restituira' un NULL, oppure un valore 00:00:00.

    Non fanno parte dei campi formato data/ora i formati campo numerici o char/varchar.
    Parrebbe banale, ma in realta' MySQL e' flessibile e, se i campi numerici o
    char/varchar contengono dei dati in formato compatibile ai campi data/time,
    permette di applicare con successo le funzioni data/ora anche su questi campi.
    Se il contenuto del campo non e' congruente al formato date/time richiesto
    la funzione data/time rendera' NULL oppure un risultato fantasioso.

    In altre parole: se i vari campi contengo dati in formato data/time compatibile,
    MySQL trattera' questi dati alla stregua di quelli inseriti nei campi con formato
    date/time. Il controllo dei valori avviene sul formato del dato inserito nel campo.
    Tanto vale quindi utilizzare dei campi dedicati e non i campi in formato numerico
    o char/varchar per gestire date/time. Quanto meno MySQL esegue su questi formati
    sommari controlli sui valori inseriti. Dei due: O son validi oppure sono zeri.

    Controlli sommari, perche'. MySQL non esegue il controllo della congruenza del
    giorno/mese. La data del 30 febbraio e' valida come le altre. MySQL ritiene validi
    i range: giorni 1-31, i mesi 1-12, gli anni 1000-9999. Per TIME: i secondi ed i
    minuti col canonico 00-59, mentre per le ore si oscilla tra -838:59:59 e 838:59:59.

    Il formato dei dati inseriti e' sempre YYYY-MM-DD hh:mm:ss oppure numerico se
    inserito in campo formato TIMESTAMP o in campo frm. numerico. MySQL riconosce,
    pero', anche altri tipi di separatori per data/time, come + ^ % & ed altri,
    compreso lo spazio e nessun separatore (formato numerico).Ma sempre memorizzera'
    nei formati descritti. Nel campo frm. char/varchar sara' una semplice stringa.

    Bisogna prestare attenzione ai separatori non standard e fare delle prove, alcuni
    separatori di data sono accettati senza che il valore sia racchiuso tra apici,
    altri separatoriinvece devono essere inseriti come se la data fosse una stringa:
    "2003/05/20". Verranno trasformati tutti in " - " per le date e in " : " per le ore.
    Se e' presente uno spazio es: 2003-05-20 12:00:00 la data deve essere tra apici
    cioe' "2003-05-20 12:00:00" o verra' generato un errore di query.

    Usando PhpMyAdmin si potrebbero avere (e si hanno) risultati inattesi utilizzando
    separatori fantasiosi. Bisogna inoltre, prima di eseguire un update guidato,
    cancellare nel form di immissione il vecchio valore, oppure la funzione applicata
    leggera' il campo esistente e lo passera' come argomento generando un errore.
    Altro incoveniente utilizzando PhpMyAdmin e' il caso di un update di un campo
    con valore identico all'esistente e con presenza nella tabella di un campo formato
    TIMESTAMP. Se non ci sono righe da modificare non si deve aggiornare il
    valore del campo frm. TIMESTAMP. PhpMyAdmin invece aggiorna il campo e restituisce
    una riga modificata. Questo non succede immettendo i valori dalla finestra QUERY.

    Nelle query di esempio utilizzeremo UPDATE, ovviamente lo stesso construtto di
    inserimento e' valido anche per INSERT.


    Vediamo DATE/TIME nel dettaglio dei formati di campo :

    Occupazione di memoria dei formati date/time:
    codice:
    +-------------------+
    | Tipo    | Memoria |
    |---------|---------|
    |YEAR     | 1 byte  |
    |DATE     | 3 bytes |
    |TIME     | 3 bytes |
    |DATETIME | 8 bytes |
    |TIMESTAMP| 4 bytes |
    +-------------------+
    YEAR(4) - Registra l'anno e occupa un solo byte. I valori validi oscillano tra
    il 1901 e il 2155. I valori possono essere specificati con 1, 2 oppure 4 cifre.
    In ogni caso i dati sono memorizzati con 4 cifre. Con 1 cifra si intendono gli anni
    dal 2000 al 2009. Con 2 cifre: da 00 a 69 verranno interpretati come dal 2000 al 2069,
    da 70 a 99 come anni dal 1970 al 1999. Per gli altri anni i valori ammessi (dal 1901
    al 1969 e dal 2069 al 2155) dovranno essere inseriti con 4 cifre esplicite.

    Le funzioni che permettono di inserire l'anno corrente sono NOW() SYSDATE(),
    CURRENT_TIMESTAMP che sono equivalenti tra loro e contengono i valori data/ora,
    oppure CURRENT_DATE, CURDATE() anche essi equivalenti tra di loro ma che contengono
    solo la data. CURRENT_TIMESTAMP e CURRENT_DATE possono avere o meno le parentesi().
    Il manuale non riporta parentesi ma non ci sono controindicazioni ad usarle. (VOID)

    Query:
    UPDATE tabella SET anno = NOW() where tua_condizione;
    UPDATE tabella SET anno = CURRENT_DATE where tua_condizione;
    UPDATE tabella SET anno = 2003 where tua_condizione;


    DATE - Registra l'evento come anno - mese - giorno. Non tiene conto
    dell'ora. I valori immessi possone essere dal 1000-01-01 al 9999-12-31.
    Si utilizza per memorizzare una data con l'immissione di una data esplicita, tramite
    una chiamata alla funzione NOW() o equivalenti, oppure a CURRENT_DATE, CURDATE().
    Nel menu' di PhpMyAdmin si trovano NOW() e CURDATE().
    La funzione NOW() porta in se anche hh:mm:ss che verranno omessi (ignorati).

    Attenzione: i dati espliciti andranno forniti nel formato previsto di yyyy-mm-dd.
    Inserendo la data nel formato dd-mm-yyyy si otterranno date impreviste. Esempio:
    Inserendo la data 18-05-2003 otterremo la data 2018-05-20 perche' verra' interpretato
    18 come anno a due cifre, 05 mese e 20 giorno, escludendo 03 perche' eccedente.
    Con questo ultimo esempio si e' chiarito che la data puo' essere immessa anche
    nel formato "yy-mm-dd", oppure anche 3-5-18 che diventeranno nel campo 2003-05-18.
    MySQL accetta anche il formato numerico "20030519" che diverra' 2003-05-19.
    In questo caso la italica data 19052003 (19-05-2003) diventera' invece 0000-00-00
    e non 1905-20-03 perche' la rappresentazione del mese (20) e' fuori range mese 1-12.

    Query:
    UPDATE tabella SET data = NOW() where tua_condizione;
    UPDATE tabella SET data = CURRENT_DATE() where tua_condizione;
    UPDATE tabella SET data = 2003-05-20 where tua_condizione;
    UPDATE tabella SET data = "2003/05/20" where tua_condizione;


    TIME - Il tipo di dato TIME si occupa di memorizzare l'ora senza occuparsi
    minimamente della data. Anche per l'ora si puo' utilizzare, come per date, dei
    formati espliciti hh:mm:ss oppure numerici hhmmss. Come detto in precedenza il
    range ammesso per le ore va da -838 a 838 mentre minuti e secondi da 00 a 59.

    Attenzione: MySQL legge le ore da destra verso sinistra se immettete l'ora senza
    separatori, mentre la legge da sinistra verso destra se ci sono i separatori.
    Quindi se mettete l'ora in questo modo (6 digit): 001224 troverete 00:12:24, ma
    se inserite l'ora con solo 4 digit: 1224 troverete 00:12:24, se invece inserite
    l'ora incompleta ma con il separatore es.: 12:24 troverete 12:24:00.

    Attenzione ad un altro particolare: se doveste utilizzare l'ora memorizzata nel
    database per i vostri scopi, sappiate che incontrando l'ora 00:00:00 non saprete
    mai se e' cosi' a causa di ora non valida o se perche' erano effettivamente le
    ore 00:00:00. A differenza della data 0000-00-00 non esistente, l'ora 00:00:00
    e' un'ora potenzialmente valida.
    Le funzioni che permettono di inserire l'ora di sistema sono NOW(), i suoi simili
    e CURRENT_TIME o CURTIME(). CURRENT_TIME puo' avere o meno le parentesi()

    UPDATE tabella SET time = NOW() where id=$id;
    UPDATE tabella SET time = CURRENT_TIME() where id=$id;
    UPDATE tabella SET time = 12:00:00 where id=$id;


    DATETIME - NON deve essere considerato l'unione di DATE e TIME appena
    visti, ma un formato diverso. (TIME potrebbe avere un valore non ammesso in
    DATETIME). Data e time hanno qui una valenza globale. Una somma di ore che superi
    le 24 incrementa di un giorno la data. In questo caso il range di valori ammessi
    va dall'anno 1000-01-01 00:00:00 al 9999-12-31 23:59:59.
    L'inserimento manuale dei dati deve rispettare il formato previsto per i tipi
    DATA e TIME gia' descritti.
    Le funzioni che permettono di inserire data/ora di sistema sono NOW() ed i suoi
    simili e CURRENT_DATE o CURDATE(). In questo ultimo caso, CURRENT_DATE e CURDATE()
    non possiedono i dati dell'ora corrente. Ora, minuti, secondi saranno 00:00:00,
    mentre invece CURTIME() generera' un errore cioe', tutti zero (0000-00-00 00:00:00).

    UPDATE tabella SET dataora = NOW() where id=$id;
    UPDATE tabella SET dataora = '2003-05-19 12:00:00' where id=$id;
    nota: in questo ultimo esempio serve raggruppare il valore con apici a causa
    dello spazio presente tra data e ora.


    TIMESTAMP - Per ultimo il campo formato TIMESTAMP.
    L'intervallo di tempo gestibile va dall'anno 1970-01-01 al 2037-12-31.
    con massima risoluzione al secondo. Vengono utilizzati sempre 4 bytes. Il dato viene
    memorizzato in modo numerico: yyyymmddhhmmss per un totale di 14 digit. E importante
    notare che il valore ricavato con TIMESTAMP e' SEMPRE di 14 digit, anche se nel campo
    abbiamo diversi modi per visualizzarlo. Vediamo:
    codice:
    +--------------+----------------+
    | Column type  | Display format |  
    |--------------+----------------|
    | TIMESTAMP(14)| YYYYMMDDHHMMSS | 
    | TIMESTAMP(12)| YYMMDDHHMMSS   |
    | TIMESTAMP(10)| YYMMDDHHMM     |
    | TIMESTAMP(8) | YYYYMMDD       | 
    | TIMESTAMP(6) | YYMMDD         | 
    | TIMESTAMP(4) | YYMM           |
    | TIMESTAMP(2) | YY             |
    +-------------------------------+
    Si puo' quindi ridurre la visibilita' della data secondo lo schema qui sopra
    riportato, ma questo non significa ridurre lo spazio di memoria occupato o eliminare
    i dati in eccesso alla visibilita' impostata. Se si imposta la colonna ad 8 digit si
    vedranno solo YYYYMMDD, ma operazioni su hhmmss saranno ugualmente effettuate.
    Allargando poi la visibilita' con ALTER TABLE da 8 a 14 digit ricompariranno i
    valori non visibili in precedenza.

    Il tipo di formato TIMESTAMP puo' essere aggiornato in modo esplicito con date/time
    rispettando il numero dei digit sopra indicati. Inserendo per es.: 20030512 verra'
    aggiornata solo la data, posizionando a 00:00:00 il tempo. Oppure puo' essere
    usata la funzione NOW() e suoi alias. Se il campo e' settato NULL e viene omesso
    nella query, verra' automaticamente aggiornato alla data/ora corrente in concomitanza
    di qualsiasi UPDATE che modifichi la tupla.

    Ci possono essere vari campi formato TIMESTAMP nella stesso record, ma solo il PRIMO
    in ordine di posizione nella tabella verra' automaticamente aggiornato con UPDATE.
    Gli altri campi se non esplicitamente indicati con ora/time o funzione NOW()
    verranno trascurati e rimarranno con la data, se presente, inalterata.
    Un UPDATE che ribatte un valore gia' esistente e quindi con risultato zero righe
    modificate, non aggiorna automaticamente il campo col formato dati TIMESTAMP.

    Predisponendo quindi due campi TIMESTAMP, es.:il primo "last_update"
    ed il secondo "data_insert", all'INSERT della tupla (compreso LOAD DATA
    INFILE) verranno automaticamente popolati entrambi dalla funzione NOW(), mentre i
    successivi UPDATE la funzione NOW() aggiornera' solo il primo campo TIMESTAMP
    incontrato lasciando inalterato il campo successivo.
    Ecco quindi funzionanti senza una riga di software due colonne molto significative.
    (Data ultimo aggiornamento - Data inserimento).


    Pag 1 - SEGUE ...

    Bibliografia:
    http://www.mysql.com/doc/en/index.html

    Il silenzio è spesso la cosa migliore. Pensa ... è gratis.

  2. #2
    PARTE SECONDA

    Riepilogo Parte Prima.

    Abbiamo visto le caratteristiche dei campi in formato data/ora di MySQL.
    MySQL e' molto flessibile nella gestione delle date. Permette di copiare, inserire
    calcolare anche al di fuori del formato date/time. Molta flessibilita' significa piu'
    controllo delle congruenze per il softwerista. Un formato errato si tradurra'
    in una sequenza di zeri. Se questo formato errato lo inserite, in un campo con
    formato INT, char/varchar questo verra' scritto, ma continuera' ad essere un formato
    errato e quindi inservibile alle funzioni MySQL.

    Da notare inoltre, che ogni formato ha un diverso range di validita', e' possibile
    copiare, calcolare dati tra un campo e l'altro mantenendo i valori iniziali,
    ma la congruenza del range e/o del tipo di formato la dovrete fare voi. Se non sara'
    corretto, MySQL non segnalera' errori, ma mettera' semplicemente una bella serie
    di zeri al posto di...

    MySQL possiede una buona scelta di funzioni date/time che e' possibile utilizzare
    nelle query alle sezioni INSERT, UPDATE, SELECT e WHERE.

    Un primo gruppo rappresenta le funzioni che rendono la data e/o l'ora senza alcuna
    manipolazione dei dati e con argomento della funzione = VOID.

    A)Funzioni di MySQL per l'estrazione di dati DATE/TIME (VOID).

    NOW()
    SYSDATE()
    CURRENT_TIMESTAMP


    Sono in pratica equivalenti. Vediamo, estensibili a tutti, le caratteristiche di NOW()
    che e' presente nel menu' PhpMyAdmin. La funzione NOW() acquisisce data/ora di sistema
    una sola volta all'inizio della query, quindi il valore ottenuto verra' utilizzato per
    soddisfare tutte le richieste della query stessa. Aggiorna automaticamente un solo
    campo formato TIMESTAMP, il primo in ordine di posizione nella lista dei campi della
    tabella. Gli altri campi presenti nello stesso record con formato TIMESTAMP verranno
    aggiornati solo su esplicita richiesta della query.

    Le tre funzioni sopra elencate, rendono sempre data/ora secondo il seguente formato:
    'YYYY-MM-DD HH:MM:SS' frm. stringa oppure YYYYMMDDHHMMSS frm. numerico. La forma
    dipendera' dal tipo di campo che ricevera' il dato. E' possibile forzare un formato
    numerico nella risposta sommando uno zero oppure moltiplicando * 1 la data richiesta.
    Se il campo non e' dimensionato a sufficienza oppure e' un campo con dati TIME o
    DATE i dati superflui o eccedenti il campo verranno persi. Fa eccezione il formato
    TIMESTAMP, come visto nella parte prima, che conserva sempre tutti i dati inseriti.

    SELECT NOW() => 2003-05-20 17:29:09
    SELECT NOW() + 0 => 20030520190137 Forzare una risposta numerica
    SELECT * FROM tabella WHERE nome_campo = NOW()
    UPDATE tabella SET data=NOW() where data < NOW() Aggiorna ad oggi un campo data.
    UPDATE tabella SET scadenza = data + INTERVAL 1 MONTH WHERE id = $id.
    Mettera' nel campo 'scadenza' la data memorizzata nel campo 'data' + un mese
    DELETE FROM tabella where scadenza < NOW() Cancella record scaduti



    CURRENT_DATE - CURDATE()
    CURRENT_TIME - CURTIME()


    Queste 4 (anzi 2) funzioni forniscono rispettivamente solo la data, e solo l'ora.
    Sono i fratelli minori delle funzioni viste prima. Vengono utilizzati quando serve
    avere o solo la data oppure soltanto l'ora.

    SELECT CURDATE() => 2003-05-20 abbiamo la data senza l'ora.
    SELECT CURTIME() => 22:19:50 abbiamo l'ora senza la data.
    SELECT CURDATE() + 0 => 20030520 data senza ora in formato numerico.
    SELECT CURTIME() * 1 => 221950 ora senza data in formato numerico.



    B)Funzioni di MySQL per l'estrazione mirata di dati DATE/TIME.

    Vediamo quali sono, a che servono e qualche esempio di applicazione.

    1) - Informazioni sul giorno.

    Se abbiamo bisogno di estrarre un giorno da una data, abbiamo disponibili ben 4
    specifiche funzioni:

    DAYOFYEAR(data)
    DAYOFMONTH(data)
    DAYOFWEEK(data)
    WEEKDAY(data)


    DAYOFYEAR - Da come risultato in formato numerico, il giorno dell'anno
    estraendolo da una data . Cioe' rende il numero dei giorni passati a partire dal
    1 Gennaio di un determinato anno.

    funziona cosi':
    SELECT DAYOFYEAR("2003-05-20") => 140 140° giorno dell'anno 2003
    SELECT DAYOFYEAR("2000/05/20") => 141 141° nel 2000 perche' bisestile.
    SELECT DAYOFYEAR("20030520") => 140 140° giorno dell'anno 2003
    SELECT DAYOFYEAR("00-05-20") => 141 141° giorno dell'anno 2000
    SELECT DAYOFYEAR(NOW()) => 140 140° alla data del 20-05-2003
    SELECT DAYOFYEAR(CURDATE()) => 140 140° giorno dell'anno 2003
    SELECT DAYOFYEAR(nome_campo) from tabella dove nome_campo contiene una data valida

    ma non cosi', anche se la query non dara' segnalazioni di errore:

    SELECT DAYOFYEAR("20-05-2003") as data => 141 interpreta 2020-05-20(03 eccedenti)
    SELECT DAYOFYEAR(CURTIME()) => NULL Perche' CURTIME contiene solo l'ora.
    SELECT DAYOFYEAR(2003-05-20) => NULL Perche' mancano gli apici all'argomento.

    Negli esempi che seguiranno si alterneranno le varie forme possibili di inserimento
    della data da analizzare. Si tenga presente che le regole sopra esposte sono
    applicabili per tutte le funzioni che vedremo.


    DAYOFMONTH - Da come risultato in formato numerico, il giorno del mese
    estraendolo da una data. Cioe' rende il numero dei giorni passati a partire dal
    giorno 1 di un determinato mese.

    SELECT DAYOFMONTH("2003-05-20") => 20 20° giorno del mese di Maggio/2003


    DAYOFWEEK - Da come risultato in formato numerico, il giorno della
    settimana estraendolo da una data. L'indice dei giorni che viene fornito e'
    conforme allo standard ODBC. L'indice inizia con:
    1 = domenica, 2 = lunedi', 3 = martedi'.... ecc.

    SELECT DAYOFWEEK("2003-05-20") => 3 martedi' 3° giorno della settimana
    SELECT * FROM order WHERE dayofweek(data_order)=2; =>Gli ordini del lunedì.


    WEEKDAY - E molto simile a DAYOFWEEK ma rende un indice diverso per
    i giorni della settimana, sempre estratti da una data:
    0 = Lunedi', 1= martedi',2 = martedi', 3= mercoledi' ....ecc.

    SELECT WEEKDAY("2003-05-20") => 1 indice 1 del giorno martedi'


    2) Estrazione Anni, Trimestri, Mesi, Settimane. Nome dei mesi e giorni.

    Anche queste funzioni lavorano a partire da una data.
    Data, ricordiamo, in qualsiasi formato ammesso.

    YEAR(date)
    QUARTER(date)
    MONTH(date)
    WEEK(date[, primogiorno])
    YEARWEEK(date[,primogiorno]
    MONTHNAME(date)
    DAYNAME(date)



    YEAR(date) - Estrae l'anno da una data in formato numerico di 4 digit.

    SELECT YEAR(NOW()); 2003 Anno corrente.
    SELECT * FROM tabella WHERE YEAR(campo_data) < 2003


    QUARTER(date) - Rende il n. del trimestre da una data inserita.
    Valori: 1=I° trimestre, 2=secondo, 3=terzo, 4=quarto.

    SELECT QUARTER(NOW()); => 2 Secondo TRIMESTRE 2003.
    SELECT * FROM tabella where QUARTER(campo_data) = 2 AND YEAR(campo_data)= 2003;
    Rendera' tutti i record con data inserita nel II trimestre 2003.


    MONTH(date) - Da come risultato il n. del mese estratto da una data,
    nell'intervallo 1-12.

    SELECT MONTH(NOW()); => 5 n. del mese di maggio.
    SELECT * FROM tabella WHERE MONTH(campo_data) = 5 AND YEAR(campo_data)= 2003;
    Rendera' tutti i record con data inserita nel maggio 2003.


    WEEK(date) - YEARWEEK(date) - Queste due funzioni rendono il numero della
    settimana da una data dell'anno. Il secondo parametro "first" serve ad indicare
    se la settimana inizia di domenica (0) oppure Lunedi'(1). Il comportamento differisce
    nel modo di presentare i dati. WEEK() ha un range 0-53 dove la settimana 0 sara'
    nei giorni che intercorrono dal giorno 1 Gennaio alla prima ricorrenza della
    domenica o lunedi' (dipende dalla scelta 0/1). YEARWEEK() invece rende anno
    e n. settimana in forma numerica. Il range delle settimane e' 1-52.
    Vediamo alcuni confronti: Il giorno 2000-01-01 era un sabato.

    select week("2000-01-01") => 0 -> settimana 0 (sabato)
    select week("2000-01-02") => 1 -> settimana 1 (domenica)
    select week("2000-01-02","1") => 0 -> [i]settimana 0 (domenica)
    select week("2000-01-03","1") => 1 -> settimana 1 (lunedi')

    select yearweek("2000-01-01") => 199952 -> Anno 1999 settimana 52 (sabato)
    select yearweek("2000-01-02") => 200001 -> Anno 2000 settimana 01 (domenica)
    select yearweek("2000-01-02","1") => 199952 -> Anno 1999 settimana 52 (domenica)
    select yearweek("2000-01-03","1") => 200001 -> Anno 2000 settimana 01 (lunedi')

    Si pone l'accento su queste funzioni perche' il numero della settimana e' molto
    usato nelle applicazioni aziendali (statistiche, pert, contabilita'...). Le agende in
    circolazione inoltre non rispondono ad un unico standard. Sicuramente la funzione
    YEARWEEK() non lascia adito a dubbi (no 0 - no 53).


    MONTHNAME - DAYNAME - Queste due funzioni estraggono i nomi del mese e del
    giorno da una data. Peccato siano in inglese. Si puo' facilmente convertire in
    italiano con una breve funzione PHP che vedremo in seguito:

    SELECT MONTHNAME(NOW()) as mese => May
    SELECT DAYNAME("2003-05-20") as giorno => Tuesday


    3) Estrazione di Ore, Minuti, Secondi.

    HOUR(time) - MINUTE(time) - SECOND(time) - Queste funzioni estraggono ore,
    minuti, secondi a partire da un dato che abbia nel contenuto ore, minuti secondi.
    Puo' essere quindi un campo o funzione con dati tipo TIMESTAMP o DATETIME o TIME.
    Ovviamente non potra' essere un campo con dati in formato YEAR o DATE.

    SELECT HOUR(CURTIME()) as hour, MINUTE(CURTIME()) as min, SECOND(CURTIME()) as sec;
    ed ecco l'equivalente di una funzione EXPLODE() con ora, minuti e secondi.


    Pag 2 - SEGUE ...

    Bibliografia:
    http://www.mysql.com/doc/en/index.html

    Il silenzio è spesso la cosa migliore. Pensa ... è gratis.

  3. #3
    PARTE TERZA

    Formattazione delle date e delle ore.

    DATE_FORMAT(date,format) - TIME_FORMAT(time,format) - DATE_FORMAT() e' una
    importante funzione per l'estrazione di uno qualsiasi dei valori descritti nella
    prossima tabella. L'argomento "date" puo' essere una funzione, un campo contenente
    una data valida, una data/ora esplicita sia in formato stringa che in formato numerico.
    L'argomento "format" va inserito tra apici e puo' contenere un numero a piacere di
    opzioni. Se il valore fornito nel primo argomento non contiene tutti i dati richiesti
    dall'argomento "format", i dati mancanti saranno resi con un valore di default oppure
    si ricevera' un NULL.

    Per estrarre l'ora esiste una funzione specifica: TIME_FORMAT(time,format).
    Quindi se vogliamo ricavare un formato solo orario dovremo utilizzare quest'ultima
    funzione. Torniamo a DATE_FORMAT().

    DATE_FORMAT() puo' essere utilizzato per l'inserimento dei dati nella tabella, ma
    se tenteremo di memorizzare un formato data italiano in un campo formato date/time,
    l'operazione verra' eseguita se il campo e' vuoto (cioe' 0000-00-00) ma inserira'
    la data nel formato standard. Se invece il campo gia' conteneva una data valida,
    questa non verra' sovrascritta.

    In cambio DATE_FORMAT() puo' essere profiquamente utilizzato per memorizzare in un
    campo formato VARCHAR una data col formato italiano. Potremo utilizzare la data
    come se fosse una stringa qualunque ma non avremo la possibilita' di fare operazioni
    date/time su di essa. Esempio: Abbiamo un campo data in formato VARCHAR(12):

    UPDATE tabella SET data= date_format(NOW(),"%d-%m-%Y") WHERE id = $id

    Verra' memorizzata la data odierna nel formato gg-mm-aaaa come stringa. Potra' essere
    estratta ed utilizzata come', ma non potra' essere argomento di funzioni data MySQL.

    Quindi la funzione DATE_FORMAT() estrae da un formato valido di DATE/TIME uno dei
    valori elencati nella seguente tabella utilizzando la chiave '%'.
    codice:
    ----------------------------------------------------------------
    | %M | Nome del Mese (in inglese) (January..December)  
    | %W | Nome del giorno (idem) (Sunday..Saturday)  
    | %D | Giorno del mese con suffisso all'inglese (1st, 2nd, 3rd, etc.)  
    | %Y | Anno, numerico, 4 digits  
    | %y | Anno, numerico, 2 digits  
    | %X | Settimana dell'anno, Domenica primo giorno della settimana, numerico, 
    |    | 4 digits, usato con '%V'  
    | %x | Settimana dell'anno, Lunedi' primo giorno della settimana, numerico, 
    |    | 4 digits, usato con '%v'  
    | %a | Nome del giorno abbreviato (Sun..Sat)  
    | %d | Giorno del mese, numerico (00..31)  ( ma il giorno 00 non esiste)
    | %e | Giorno del mese, numerico (0..31)   ( idem) 
    | %m | Mese, numerico (01..12)  
    | %c | Mese, numerico (1..12)  
    | %b | Nome del mese abbreviato (Jan..Dec)  
    | %j | Giorno dell'anno (001..366)  
    | %H | Ora (00..23)  
    | %k | Ora (0..23)  
    | %h | Ora (01..12)  
    | %I | Ora (01..12)  
    | %l | Ora (1..12)  
    | %i | Minuti, numerico (00..59)  
    | %r | Orario, Ora-12 (hh:mm:ss [AM/PM]  
    | %T | Orario, Ora-24 (hh:mm:ss)  
    | %S | Secondi (00..59)  
    | %s | Secondi (00..59)  
    | %p | AM or PM  
    | %w | Giorno della Settimana, numerico (0-6) (0=Domenica 1=Lunedì..6=Sabato)  
    | %U | Settimana (00..53), dove Domenica e' il primo giorno Settimana  
    | %u | Settimana (00..53), dove Lunedì e' il primo giorno Settimana  
    | %V | Settimana (01..53), dove Domenica e' il primo giorno Settimana.Usato con '%X'  
    | %v | Settimana (01..53), dove Lunedì e' il primo giorno Settimana. Usato con '%x'  
    | %% | Carattere wilcard. Stampera' qualunque carattere non in elenco.
    ----------------------------------------------------------------------
    Potete vedere molti esempi dell'uso di DATE_FORMAT() in varie parti del documento.

    SELECT DATE_FORMAT(NOW(), "%d-%m-%Y %H:%i:%s") as data => 26-06-2003 14:29:33


    EXTRACT(type FROM date) - Estrae da una data il tipo di valore descritto in
    type. Le opzioni a disposizione sono quelle della tabella associata alle operazioni
    possibili sulle date (vedi sotto) di cui condivide la tipologia.

    SELECT EXTRACT(YEAR_MONTH FROM "1999-07-02 01:02:03") AS DATA => 199907
    SELECT EXTRACT(DAY_MINUTE FROM NOW()) AS DATA => 230215 ddmmss


    Somma e sottrazione del tempo.

    Ci sono alcuni metodi per la somma e sottrazione di tempo in MySQL. Sono disponibili
    le seguenti funzioni a partire da MySQL 3.22. A partire da MySQL 3.23 e' possibile
    usare + e - invece delle funzioni DATA_ADD() e DATE_SUB. Anche EXTRACT e' disponibile
    solo dalla ver.3.23. Vediamo insieme.

    DATE_ADD(data, INTERVAL espressione tipo) funzione identica a:
    ADDDATE(data, INTERVAL espressione tipo)
    DATE_SUB(data, INTERVAL espressione tipo)
    funzione identica a:
    SUBDATE(data, INTERVAL espressione tipo)

    I valori dell'argomento "data" ammessi sono quelli di date, datetime o espliciti.

    Il valore di espressione e' un INT per TIPO = YEAR, MONTH, DAY, MINUTE, SECOND
    mentre per i TIPI multipli (es: DAY_MINUTE) sara' una stringa composta da piu'
    INT separati da uno spazio: es.: SUBDATE(NOW(),INTERVAL "2 12 30" DAY_MINUTE)
    cioe', sottrae alla data corrente 2 giorni, 12 ore e 30 minuti

    I valori ammessi in TIPO sono i seguenti:
    codice:
    +-------------------------------------------------+
    |  VALORE 'TIPO' |    FORMATO ATTESO              |
    |----------------+--------------------------------|
    |  SECOND        |  SECONDS                       |
    |  MINUTE        |  MINUTES                       |
    |  HOUR          |  HOURS                         | 
    |  DAY           |  DAYS                          | 
    |  MONTH         |  MONTHS                        | 
    |  YEAR          |  YEARS                         | 
    |  MINUTE_SECOND |  "MINUTES:SECONDS"             | 
    |  HOUR_MINUTE   |  "HOURS:MINUTES"               | 
    |  DAY_HOUR      |  "DAYS HOURS"                  | 
    |  YEAR_MONTH    |  "YEARS-MONTHS"                | 
    |  HOUR_SECOND   |  "HOURS:MINUTES:SECONDS"       | 
    |  DAY_MINUTE    |  "DAYS HOURS:MINUTES"          | 
    |  DAY_SECOND    |  "DAYS HOURS:MINUTES:SECONDS"  | 
    +----------------+--------------------------------+
    Come si potra' vedere usare le funzioni DATE_ADD(), DATE_SUB oppure + o - si
    otterra' lo stesso risultato (ripeto: a partire da MySQL 3.23).

    SELECT DATE_ADD(NOW(),INTERVAL 1 MONTH) AS DATA => DATA = 2003-06-26 15:49:13
    SELECT ADDDATE(NOW(),INTERVAL 1 MONTH) AS DATA => DATA = 2003-06-26 15:50:10
    SELECT NOW() + INTERVAL 1 MONTH AS DATA => DATA = 2003-06-26 15:51:11

    SELECT DATE_SUB(NOW(),INTERVAL 1 YEAR) AS DATA => DATA = 2002-05-26 15:52:43
    SELECT SUBDATE(NOW(),INTERVAL 1 DAY) AS DATA => DATA = 2003-05-25 15:54:13
    SELECT NOW() - INTERVAL 1 MONTH AS DATA => DATA = 2003-04-26 15:56:31

    Vediamo alcuni esempi di utilizzo:

    SELECT "2002-12-25" + INTERVAL 6 MONTH AS data => 2003-06-25
    SELECT ADDDATE("2002-12-25",INTERVAL "4 3" YEAR_MONTH)AS DATA => 2007-03-25
    SELECT "2002-12-25" + INTERVAL "4 3" YEAR_MONTH AS DATA => 2007-03-25
    SELECT DATE_FORMAT(NOW() + INTERVAL "10 12" DAY_HOUR,"%d-%m-%Y %H:%i:%s") as data
    => 06-06-2003 04:27:35 Sommare 10 giorni e mezzo alla data di oggi
    SELECT * FROM tabella WHERE data >= NOW() - INTERVAL "2 12" DAY_HOUR;
    Rendera' i records con data da due giorni e mezzo fa fino al momento attuale.


    TO_DAYS(data)
    FROM_DAYS(data)


    L'utilizzo di queste due funzioni deve essere inteso per le date seguenti
    l'introduzione del calendario gregoriano, cioe' dopo il 1582. E' molto comodo
    per il calcolo del numero dei giorni tra due date.

    TO_DAYS() prende in considerazione una data come paramentro e rende il numero dei
    giorni a partire dall'anno I d.C.

    FROM_DAYS() fa l'opposto: da un numero di giorni
    rende la data attuale, con lo stesso riferimento.

    SELECT TO_DAYS(NOW()) AS giorni => 731726 [i]N. dei giorni trascorsi dall'anno Id.C.
    SELECT FROM_DAYS(731726) AS data => 2003-05-26

    SELECT TO_DAYS("2003-12-25") - TO_DAYS("2003-05-24") AS natale => 215
    N. dei giorni che mancano a Natale.

    SELECT FROM_DAYS(TO_DAYS(NOW() - INTERVAL 1000 DAY)) AS DATA => 2000-08-29
    La data di 1000 giorni fa

    SELECT DATE_FORMAT(FROM_DAYS(TO_DAYS(NOW()- INTERVAL 1000 DAY)),"%d-%m-%Y") AS DATA
    => 29-08-2000 Ecco la stessa data in formato italiano

    SELECT DATE_FORMAT(FROM_DAYS(TO_DAYS(NOW()+ INTERVAL 1000 DAY)),"%d-%m-%Y") AS DATA
    => 20-02-2006 Ed ecco la data che avremo fra mille giorni



    UNIX_TIMESTAMP()
    UNIX_TIMESTAMP(date)
    FROM_UNIXTIME(unix_timestamp)
    FROM_UNIXTIME(unix_timestamp,format)


    Il TIMESTAMP UNIX e' il numero dei secondi intercorsi dal 1 gennaio 1970.
    Un controllo di base viene effettuato su anno (1970-2037), mese (01-12), giorno (01-31).
    Al di fuori di questi valori la funzione rende un valore nullo (zero).
    UNIX_TIMESTAMP() senza il parametro facoltativo "data" restituisce l'ora UNIX corrente.
    FROM_UNIXTIME() e l'opposto del primo. Da una ora UNIX rende una data. Anche per
    questa funzione possiamo ottenere il formato numerico della data sommando 0 oppure
    moltiplicando per 1 la data stessa. Con l'opzione format possiamo scegliere il
    formato di visualizzazione che piu' ci e' congeniale, utilizzando le stesse opzioni
    della funzione DATE_FORMAT.

    SELECT UNIX_TIMESTAMP(NOW()) AS DATA => 1053649881
    SELECT FROM_UNIXTIME(946897200) AS DATA => 2000-01-03 12:00:00
    SELECT FROM_UNIXTIME(946897200) * 1 AS DATA => 20000103120000
    SELECT FROM_UNIXTIME(UNIX_TIMESTAMP(),"%d %m %Y %h:%i:%s") AS DATA => 23 05 2003 03:58:57


    I seguenti due gruppi di funzioni non possono essere considerati vere funzioni di
    calcolo DATA/TIME. Il primo calcola esclusivamente mesi, il secondo gruppo somma o
    rende valori TIME senza tenere conto dei valori DATE. Le ore eccedenti alle 24 non
    verranno trasformate in giorni ma sommate/sottratte fino al range +/-838:59:59.


    PERIOD_ADD(P,N) - Somma al periodo P, N mesi. Accetta il formato YYMM o YYYYMM
    e ritorna un valore YYYYMM. Somma esclusivamente mesi.
    SELECT PERIOD_ADD(200211,2); => 200301 = YYYYMM

    PERIOD_DIFF(P1,P2) - Rende il numero dei mesi tra due date (P1 e P2).
    Accetta il formato YYMM o YYYYMM.
    SELECT PERIOD_DIFF(200305,197807); => 298 mesi

    Per entrambe le funzioni va annotato che non si tratta di un formato date valido,
    ma che hanno valenza INT. Sono funzioni di calcolo per mesi e nulla piu'.


    TIME_TO_SEC(ora) - SEC_TO_TIME(secondi) - Time_to_sec restituisce il numero
    dei secondi da un'ora indicata (inizio della conta ora 00:00:00).
    Sec_to_time fa l'opposto. Rende l'ora a partire da un numero di secondi.

    SELECT TIME_TO_SEC("01:00:00") => 3600 secondi
    SELECT TIME_TO_SEC(NOW()) => 39600 secondi ->(erano le ore 11:00:00)
    SELECT SEC_TO_TIME("39600") => 11:00:00
    SELECT SEC_TO_TIME("39600") + 0 => 110000 HHMMSS in formato numerico
    SELECT TIME_TO_SEC("-838:59:59") => -3020399 Count-Down

    Non si e' riusciti a stabilire il valore max di ore o secondi convertibili.
    Non sono ufficializzati range di valori. Nelle prove si sono raggiunti valori
    elevatissimi validi, per crollare senza apparente ragione a risposte con valori
    fantasiosi. Sempre valido il risultato invece, non superando il range orario del
    formato TIME (-838:59:59 up to 838:59:59).


    Segue uno script php con l'esempio di vari possibili utilizzi delle funzioni
    descritte. Puo' essere utile come memorandum e per provare rapidamente quale
    funzione sia piu' congeniale ad una data esigenza.

    Il secondo script php contiene alcuni esempi di come sia possibile raggruppare
    in funzioni la traformazione dei dati nelle forme a noi piu' congeniali.

    Ciao a tutti, Piero

    Ps: Sono graditi feedback.

    Bibliografia:
    http://www.mysql.com/doc/en/index.html

    Il silenzio è spesso la cosa migliore. Pensa ... è gratis.

  4. #4
    Codice PHP:
    <?
    /**********************************
    # Esempi di uso delle funzioni descritte nel documento.
    # Piccoli esempi facilmente adattabili, e comunque
    # valido come memo delle funzioni disponibili in MySQL.
    # Non serve una tabella, solo la connessione attiva a MySQL
    *************************************/

    $link mysql_connect('localhost','root','');  # <----- metti qui i tuoi dati

    Function Esegui($action,$id) {  
        global 
    $link;
        
    $query mysql_query($action,$link);
        
    $result mysql_result($query,0,'data');
        echo 
    "<pre>";
        echo 
    "$id => $action = [b]$result[/b]";
    }
    $action = ARRAY (1=>'SELECT NOW() AS DATA',
                     
    2=>'SELECT NOW() + 0 AS DATA',
                     
    3=>'SELECT CURRENT_TIMESTAMP + INTERVAL 2 MONTH AS DATA',
                     
    4=>'SELECT SYSDATE() - INTERVAL 1 MONTH AS DATA',
                     
    5=>'SELECT CURRENT_DATE() AS DATA',
                     
    6=>'SELECT CURDATE() + INTERVAL 1 YEAR AS DATA',
                     
    7=>'SELECT CURTIME() AS DATA',
                     
    8=>'SELECT CURRENT_TIME AS DATA',
                     
    9=>'SELECT DAYOFYEAR(CURDATE()) AS DATA',
                    
    10=>'SELECT DAYOFMONTH(NOW()) AS DATA',
                    
    11=>'SELECT DAYOFWEEK("2003-05-20") AS DATA',
                    
    12=>'SELECT WEEKDAY("2003-05-20") AS DATA',
                    
    13=>'SELECT YEAR(NOW()) AS DATA',
                    
    14=>'SELECT QUARTER("2003-05-20") AS DATA',
                    
    15=>'SELECT MONTH("2003-05-20") AS DATA',
                    
    16=>'SELECT WEEK("2000-01-02") AS DATA',
                    
    17=>'SELECT WEEK("2000-01-02","1") AS DATA',
                    
    18=>'SELECT YEARWEEK("2000-01-02") AS DATA',
                    
    19=>'SELECT YEARWEEK("2000-01-02","1") AS DATA',
                    
    20=>'SELECT MONTHNAME("2003-05-20") AS DATA',
                    
    21=>'SELECT DAYNAME("2003-05-20") AS DATA',
                    
    22=>'SELECT HOUR(NOW()) AS DATA',
                    
    23=>'SELECT MINUTE("12:23:00") AS DATA',
                    
    24=>'SELECT SECOND(CURTIME()) AS DATA',
                    
    25=>'SELECT TIME_TO_SEC("200:10:59") AS DATA',
                    
    26=>'SELECT SEC_TO_TIME("720659") AS DATA',
                    
    27=>'SELECT PERIOD_ADD("200211",2) AS DATA',
                    
    28=>'SELECT PERIOD_DIFF(200305,197807) AS DATA',
                    
    29=>'SELECT EXTRACT(YEAR_MONTH FROM "1999-07-02 01:02:03") AS DATA',
                    
    30=>'SELECT EXTRACT(DAY_MINUTE FROM NOW()) AS DATA' ,
                    
    31=>'SELECT UNIX_TIMESTAMP() AS DATA',
                    
    32=>'SELECT UNIX_TIMESTAMP("2000-01-03 12:00:00") AS DATA',
                    
    33=>'SELECT FROM_UNIXTIME(946897200) AS DATA',
                    
    34=>'SELECT FROM_UNIXTIME(946897200) * 1 AS DATA',
                    
    35=>'SELECT FROM_UNIXTIME(UNIX_TIMESTAMP(),"%d %m %Y %h:%i:%s") AS DATA',
                    
    36=>'SELECT DATE_FORMAT(NOW(),"%d-%m-%Y") AS DATA',
                    
    37=>'SELECT TIME_FORMAT(CURTIME(),"%H:%I:%S") AS DATA',
                    
    38=>'SELECT DATE_FORMAT(CURDATE(),"%D-%M-%Y") AS DATA',
                    
    39=>'SELECT DATE_FORMAT(CURRENT_TIMESTAMP(),"%d-%m-%y %H:%i:%s") AS DATA',
                    
    40=>'SELECT DATE_FORMAT(INTERVAL 1 MONTH + NOW(),"%d-%m-%Y %H:%i:%s") AS DATA',
                    
    41=>'SELECT DATE_FORMAT(DATE_ADD(NOW(),INTERVAL 1 MONTH),"%d-%m-%Y %H:%i:%s") AS DATA',
                    
    42=>'SELECT EXTRACT(YEAR_MONTH FROM CURDATE())AS DATA',
                    
    43=>'SELECT DATE_ADD(NOW(),INTERVAL 1 MONTH) AS DATA',
                    
    44=>'SELECT DATE_ADD("2000-01-01",INTERVAL "2 1 30" DAY_MINUTE) AS DATA',
                    
    45=>'SELECT DATE_FORMAT(FROM_DAYS(TO_DAYS(NOW()- INTERVAL 1000 DAY)),"%d-%m-%Y") AS DATA',
                    
    46=>'SELECT DATE_FORMAT(FROM_DAYS(TO_DAYS(NOW()+ INTERVAL 1000 DAY)),"%d-%m-%Y") AS DATA',
                    
    47=>'SELECT DATE_FORMAT(DATE_SUB(NOW(),INTERVAL 1 MONTH),"%d-%m-%Y %H:%i:%s") AS DATA');

    echo 
    "
    [b][i]Vediamo le varie risposte alle nostre query:[/i][/b]
    "
    ;
    foreach (
    $action as $id => $value){
    Esegui($value$id); 
    }
    ?>
    Esempio di utilizzo di alcune piccole funzioni:

    Codice PHP:
    <?
    /**********************************
    # Alcuni esempi di piccole funzioni per adattare la data al formato
    # italiano. Piccoli esempi facilmente adattabili utilizzando magari
    # il mixer delle funzioni PHP e Mysql per ottimizzare le 
    # prestazioni......
    *************************************/

    # Definiamo un array con associato il numero del giorno come estratto dalla funz DAYOFWEEK()

    $giorni=array(1=>'Domenica',2=>'Lunedì',3=>'Martedì',4=>'Mercoledì',
    5=>'Giovedì',6=>'Venerdì',7=>'Sabato');
    # vediamolo
    echo '
    [b][i]Vediamo il contenuto dell\'array [/i]$giorni[/b]
    '
    ;
    echo 
    "<pre>";
    foreach (
    $giorni as $id => $value){
    echo 
    "Chiave = $id; Valore = [b]$value[/b]
    "
    ;
    }

    #  definiamo anche i mesi mentre ci siamo come estratti dalla funz. MONTH()
    $mesi=array(1=>'Gennaio',2=>'Febbraio',3=>'Marzo',4=>'Aprile',5=>'Maggio',
    6=>'Giugno',7=>'Luglio',8=>'Agosto',9=>'Settembre',10=>'Ottobre',11=>'Novembre',12=>'Dicembre');
    echo 
    '</pre>
    [b][i]Vediamo ora il contenuto dell\'array [/i]$mesi[/b]
    <pre>'
    ;
    foreach (
    $mesi as $id => $value){
    echo 
    "Chiave = $id; Valore = [b]$value[/b]
    "
    ;}
    echo 
    "</pre>";

    # data odierna nel formato gg-mm-aaaa
    Function DataOggi() {
    global 
    $link$today;
    $query mysql_query("select date_format(now(),'%d-%m-%Y') as data");
    return 
    $today mysql_result($query,0,'data');
    }

    # data odierna estesa es: Lunedì gg Mese aaaa
    Function DataEstesa() {
    global 
    $giorni$mesi$link$today;
    $action  "select year(now()) as anno, month(now())as mese, ";
    $action .="dayofweek(now()) as day, date_format(now(),'%d') as giorno";
    $query  mysql_query($action,$link);
    $anno   mysql_result($query,0,'anno');
    $mese   mysql_result($query,0,'mese');
    $giorno mysql_result($query,0,'giorno');
    $day    mysql_result($query,0,'day');
    return 
    $today $giorni[$day]." ".$giorno." ".$mesi[$mese]." ".$anno;
    }

    # Nome del giorno odierno
    Function NomeOggi() {
    global 
    $oggi$giorni;
    $query1 mysql_query("select dayofweek(now()) as day");
    return 
    $oggi $giorni[mysql_result($query1,0,'day')];
    }

    # nome del giorno di domani
    Function NomeDomani() {
    global 
    $domani$giorni;
    $query mysql_query("select dayofweek(date_add(now(), interval 1 day)) as day");
    return 
    $domani $giorni[mysql_result($query,0,'day')];
    }

    # stampare una data di scadenza
    $period6;      # valore INT
    $val"day";    # puo' essere: year-month-day-hour-minute-second
    Function Scadenza() {
    global 
    $scadenza$period$val;
    $query mysql_query("select date_format(date_add(now(),interval $period $val),'%d-%m-%Y') as scade");
    return 
    $scadenza mysql_result($query,0,'scade');
    }

    # calcolare quanti giorni intercorrono tra la data di oggi e altra data. 
    # Numero giorni negativo per le date future
    $data "2000-01-01";  # metti la data da comparare in formato yyyy-mm-dd
    $data1 "01-01-2000";  # metti la data da stampare nella visualizzazione in frm. italiano
    Function QuantiGiorni() {
    global 
    $data$total;
    $query mysql_query("select to_days(NOW())-to_days('$data') as tot ");
    return 
    $total mysql_result($query,0,'tot');
    }

    # Conoscere una data futura dato uno spiazzamento di tempo da oggi (tipo=gg mm aa).
    # I tipi possono essere DAY - MONTH - YEAR - YEAR_MONTH.
    $interval "INTERVAL '5 6' YEAR_MONTH"#qui metti il valore.(5 anni 6 mesi YEAR_MONTH)
    Function QualeData() {
    global 
    $interval$giorni$next;
    $query mysql_query("SELECT NOW()+ $interval as tot");
    $tot mysql_result($query,0,'tot');
    $query1 mysql_query("select date_format('$tot','%d-%m-%Y') as data,dayofweek('$tot') as day ");
    $day $giorni[mysql_result($query1,0,'day')];
    $data =    mysql_result($query1,0,'data');
    return  
    $next $day." ".$data;
    }

    echo 
    "
    [b][i]Esempio di uso delle funzioni descritte del presente script:[/i][/b]
    "
    ;
    echo 
    "
    [b]Funz. DataOggi()[/b] - Oggi, [i]"
    .DataOggi().",[/i] nella nostra citta' bla bla ...";
    echo 
    "
    [b]Funz. DataEstesa()[/b] - Oggi, [i]"
    .DataEstesa().",[/i] nella nostra citta' bla bla ...";
    echo 
    "
    [b]Funz. NomeOggi()[/b] - Oggi e' [i]"
    .NomeOggi()."[/i]";
    echo 
    "
    [b]Funz. NomeDomani()[/b] - Hai tempo fino a domani, [i]"
    .NomeDomani()."[/i]";
    echo 
    "
    [b]Funz. Scadenza() [/b] - Ricorda che l'offerta scadra' fra "

    echo 
    "$period giorni, cioe'il [i]".Scadenza()."[/i]
    "
    ;
    echo 
    "
    [b]Funz. QuantiGiorni()[/b] - Tra il 
    $data1 ad oggi sono passati[i] ".QuantiGiorni()."[/i] giorni.
    "
    ;
    echo 
    "
    [b]Funz. QualeData()[/b] - Tra 5 anni e 6 mesi sara' [i] "
    .QualeData()."[/i].
    "
    ;
    Mysql_close($link);
    ?>

    Il silenzio è spesso la cosa migliore. Pensa ... è gratis.

  5. #5
    Complimenti piero.mac!!

    Una pillola chiara e completa
    :metallica :metallica :metallica

  6. #6
    Tenchiu verigrazie....


    Il silenzio è spesso la cosa migliore. Pensa ... è gratis.

  7. #7
    Sono fulminato dall'enorme mole di bit di informazioni proveniente da questo articolo

    proprio bello! Chi è daccordo con me metta una riga

    ___________________________________
    Occhiali da Sole www.OtticaGold.it
    Marche: Diesel, Dior, Emporio Armani, Gucci, Oakley, Oxydo, Police, Ray-Ban, Roberto Cavalli, Valentino, Vogue - Per le altre... cerca su google.it

  8. #8


    non ho etto ma bastano i 4 post! :metallica

    Ci vogliono un bel po' di pilloline su mysql.. c'è poca doc

    bravo

  9. #9
    Un pò lunghetta!

    Non ho avuto tempo di leggerla tutta cmq credo che dovrebbe essere molto completa. Tra l'altro l'argomeno è anche interessante

    Compliment
    E disse il tubo all'idraulico: "Lasciami perdere"

  10. #10
    :metallica :metallica :metallica
    :adhone: Chicco

Permessi di invio

  • Non puoi inserire discussioni
  • Non puoi inserire repliche
  • Non puoi inserire allegati
  • Non puoi modificare i tuoi messaggi
  •  
Powered by vBulletin® Version 4.2.1
Copyright © 2024 vBulletin Solutions, Inc. All rights reserved.