Scheda Sostituzione, comando Rimpiazza Campi
Scheda SelezioneRimpiazza Campi
Sostituire il valore del campo:
Presenta una griglia la quale evidenzia le seguenti colonne:
- Descrizione = Evidenzia la descrizione relativa al campo.
 - Tipo = Specifica uno dei seguenti caratteri:
 
M = Memo N = Numero
D = Data L = Logico
- Dim = Specifica la dimensione del campo in numero di byte.
 - Dec = Evidenzia il numero di cifre decimali.
 
Con
- Tutto maiuscolo = Consente di rendere tutti i caratteri del campo selezionato maiuscoli. E' possibile utilizzare questa opzione solo per i campi di tipo "C" (stringa).
 - Tutto minuscolo = Consente di rendere tutti i caratteri del campo selezionato minuscoli. E' possibile utilizzare questa opzione solo per i campi di tipo "C" (stringa).
 - Prima lettera maiuscola = Consente di trasformare la prima lettera del campo selezionato maiuscola. E' possibile utilizzare questa opzione solo per i campi di tipo "C" (stringa).
 - Valore inserito = E' possibile inserire un valore stringa, numero, valore logico e data a seconda del tipo di campo selezionato.
 - Formula = E' possibile inserire una formula che permette di calcolare il valore da sostituire. Nell'espressione di calcolo compaiono Operandi, Operatori e Funzioni.
 
OPERANDI
Si distinguono in costanti e variabili.
- Costanti: possono essere numeriche, stringhe (o costanti alfanumeriche), logiche e date.
 - Numeriche : si dividono in numeri interi ( -11 ) o in numeri decimali ( 11.12 ) in cui la virgola del numero decimale è sostituita con un punto.
 - Stringhe : occorre inserire i caratteri alfanumerici tra due virgolette ( " ).
 
Attenzione I caratteri maiuscoli sono considerati diversi da quelli minuscoli.
- Logiche : specificare .T. = Vero, .F. = Falso
 - Date : per ottenere una costante di tipo data ad esempio 31/12/1997 occorre utilizzare la seguente sintassi [date("31/12/1987")].
 
Nota Occorre specificare l'anno per intero.
- Variabili campo
 
- 'N'> Numerico
 - 'C'> Stringa
 - 'L'> Logico
 - 'D'> Data
 
Nota I campi 'Memo' non possono essere utilizzati nelle formule.
- Variabili di servizio
 - 'COUNT'>Variabile numerica di servizio con valore iniziale uguale a zero
 
OPERATORI
| Sintassi | 
                                                    Descrizione | 
                                                    Esempio | 
                                                
                                                        
  | 
                                                    Consente la moltiplicazione solo tra numeri. | 
                                                    12*2=24 | 
                                                
| + Somma numerica | 
                                                    Consente la sommatoria tra numeri. | 
                                                    12+2=14 | 
                                                
| + Unisci caratteri | 
                                                    Somma valori alfanumerici. | 
                                                    "ABC"+"CDE" = "ABCDE" | 
                                                
| + Data + numero gg. | 
                                                    Consente la sommatoria tra un operando di sinistra con un operando di destra. | 
                                                    Date ("12/12/1997")+365=12/12/1998 | 
                                                
| - Sottrazione numerica | 
                                                    Sottrazione tra valori numerici. | 
                                                    12-2=10 | 
                                                
| - Unisci caratteri | 
                                                    Somma valori alfanumerici. | 
                                                    "ABC"+"CDE" = "ABCDE" | 
                                                
| - Data - numero gg. | 
                                                    Consente la sottrazione tra un operando di sinistra con un operando di destra. | 
                                                    Date ("12/12/1997")-365 (sottrazione di un numero di giorni da una data)=12/12/1996 | 
                                                
| - Sottrazione tra 2 date | 
                                                    Permette di ottenere il numero di giorni trascorsi tra le due date. | 
                                                    Date("12/12/1997")-Date("12/12/1998")=729370 | 
                                                
| / Divisione numerica | 
                                                    Divisione tra due numeri. | 
                                                    12/2=6 | 
                                                
| <> Diverso | 
                                                    E' possibile applicare questo operatore ad operandi eterogenei: numero con numero, data con data, logico con logico, stringa con stringa e fornisce come risultato un valore booleano (.T.=vero, .F.=falso). | 
                                                    "ABC"<>"CDE"=.T., 11<>11=.F. | 
                                                
| < Minore di | 
                                                    E' possibile applicare questo operatore ad operandi eterogenei: numero con numero, data con data, logico con logico, stringa con stringa e fornisce come risultato un valore booleano (.T.=vero, .F.=falso). | 
                                                    11<12=.T. | 
                                                
| <= Minore di o uguale a | 
                                                    E' possibile applicare questo operatore ad operandi eterogenei: numero con numero, data con data, logico con logico, stringa con stringa e fornisce come risultato un valore booleano (.T.=vero, .F.=falso). | 
                                                    11<=12=.T. | 
                                                
| $ Sottostringa | 
                                                    Il risultato è vero (.T.) se il valore di sinistra è sottostringa del valore di destra, il contrario è falso. | 
                                                    "AB"$"CDEFABG"=.T. | 
                                                
| .AND. | 
                                                    Si può applicare a due operandi di tipo booleano, il risultato è un valore booleano determinato dall'operatore AND. | 
                                                    .T..AND..T.=.T. | 
                                                
| .OR. | 
                                                    Si può applicare a due operandi di tipo booleano, il risultato è un valore booleano determinato dall'operatore OR. | 
                                                    .T..OR..T.=.T. | 
                                                
| >= Maggiore di o uguale a | 
                                                    E' possibile applicare questo operatore ad operandi eterogenei: numero con numero, data con data, logico con logico, stringa con stringa e fornisce come risultato un valore booleano (.T.=vero, .F.=falso). | 
                                                    12>=11=.T. | 
                                                
| > Maggiore di | 
                                                    E' possibile applicare questo operatore ad operandi eterogenei: numero con numero, data con data, logico con logico, stringa con stringa e fornisce come risultato un valore booleano (.T.=vero, .F.=falso). | 
                                                    12>5=.T. | 
                                                
| () | 
                                                    Indicatore di funzione o raggruppatore di operazioni. | 
                                                    (4+5)*20= 180 mentre 4+4*20=84 | 
                                                
FUNZIONI SUI CARATTERI (c = stringa, i = numero intero)
| Sintassi | 
                                                    Descrizione | 
                                                    Esempio | 
                                                
| LEFT(c,i) | 
                                                    Prende i primi "i" caratteri partendo da sinistra. | 
                                                    LEFT("ABCDEF",4)="ABCD" | 
                                                
| RIGHT (c,i) | 
                                                    Prende i primi "i" caratteri partendo da destra. | 
                                                    RIGHT("ABCDEF",4)="CDEF" | 
                                                
| LOWER (c) | 
                                                    Trasforma tutti i caratteri della stringa (c) in minuscolo. | 
                                                    LOWER("ABCD")="abcd" | 
                                                
| UPPER (c) | 
                                                    Trasforma tutti i caratteri della stringa (c) in maiuscolo. | 
                                                    UPPER("abcd")="ABCD" | 
                                                
| SUBSTR (c,i1,i2) | 
                                                    Copia "i2" caratteri della stringa (c) partendo da "i1". | 
                                                    SUBST("AbCDefg",2,3)="bCD" | 
                                                
| PADC (c,i) | 
                                                    Posiziona al centro la stringa (c) rispetto a "i" caratteri impostati. | 
                                                    PADC("AbcDef",10)=" ABcDef " | 
                                                
| PADL (c,i) | 
                                                    Allinea la stringa (c) a destra rispetto a "i" caratteri impostati. Se la stringa è troppo lunga viene troncata. | 
                                                    [PADL("123", 7)= " 123"] [PADL("ABCdefG",6)=''ABCdef'']. | 
                                                
| PADR (c,i) | 
                                                    Allinea la stringa (c) a sinistra rispetto a "i" caratteri impostati. Se la stringa è troppo lunga viene tagliata. | 
                                                    PADR("abc",7)= "abc " | 
                                                
| REPLICATE (c,i) | 
                                                    Copia "i" volte la stringa (c). | 
                                                    REPLICATE("ABCDEF",2)="ABCDEFABCDEF" | 
                                                
| TRIM (c) | 
                                                    Elimina tutti gli spazi vuoti a destra e a sinistra della stringa (c). | 
                                                    TRIM(" ABC ")="ABC" | 
                                                
| LTRIM (c) | 
                                                    Elimina gli spazi vuoti a sinistra della stringa (c). | 
                                                    LTRIM(" ABC")="ABC" | 
                                                
| RTRIM (c) | 
                                                    Elimina gli spazi vuoti a destra della stringa (c). | 
                                                    RTRIM(" ABC ")=" ABC" | 
                                                
FUNZIONI SULLE DATE (d = corrisponde ad una data, i = numero intero)
| Sintassi | 
                                                    Descrizione | 
                                                    Esempio | 
                                                
| CDOW(d) | 
                                                    Restituisce un valore di tipo stringa che equivale al giorno della settimana della data "d" (Lunedì, Martedì....). | 
                                                    CDOW(DATE("12/12/1997"))="venerdì" | 
                                                
| CMONTH (d) | 
                                                    Restituisce un valore di tipo stringa che equivale al mese della data "d" (Gennaio, febbraio...). | 
                                                    CMONTH(DATE("12/12/1997"))="Dicembre" | 
                                                
| MONTH (d) | 
                                                    Restituisce un valore intero da 1 a 12 pari al numero del mese della data "d". | 
                                                    MONTH(DATE("12/12/1997"))=12 | 
                                                
| DATE () | 
                                                    Restituisce un valore di tipo data che equivale alla data odierna. | 
                                                    DATE()=24/11/1997 | 
                                                
| DAY (d) | 
                                                    Restituisce un valore di tipo numerico che equivale al giorno del mese (da 1 a 31) della data "d".. | 
                                                    DAY(DATE("12/12/1997"))=12 | 
                                                
| YEAR (d) | 
                                                    Restituisce un valore di tipo numerico che equivale all'anno della data "d".. | 
                                                    YEAR(DATE("12/12/1997"))=1997 | 
                                                
| DATCAL (d,i) | 
                                                    Restituisce un valore di tipo data ottenuto dalla somma della data con i giorni, mentre se "i" è negativo sottrae la data con i giorni. | 
                                                    DATCAL(DATE("12/12/1997"),2)=DATE("14/12/1997") | 
                                                
FUNZIONI NUMERICHE ( i = numero intero, n = numero decimale o intero)
| Sintassi | 
                                                    Descrizione | 
                                                    Esempio | 
                                                
| ABS (n) | 
                                                    Trasforma n nel valore assoluto. | 
                                                    ABS(-2)=2, ABS(5.4)=5.4 | 
                                                
| MOD (i1,i2) | 
                                                    Ha la funzione di resto nella divisione tra numeri interi. | 
                                                    MOD(5,3)=2 | 
                                                
| ROUND (n1,n2) | 
                                                    Arrotonda n1 a n2 cifre decimali. | 
                                                    ROUND(1.267,2)=1,27 | 
                                                
| PERC (i1,i2) | 
                                                    Calcola i2 per cento con i1. | 
                                                    PERC(100,20)=20. | 
                                                
| POW (i1,i2) | 
                                                    i1 elevato a i2. | 
                                                    POW(2,2)=4 | 
                                                
| SQRT (i1) | 
                                                    Rappresenta la radice quadrata di i1. | 
                                                    SQRT(4)=2 | 
                                                
| SQR (i1) | 
                                                    Rappresenta il quadrato di i1. | 
                                                    SQR(4)=16 | 
                                                
FUNZIONI LOGICHE ( b = parametro booleano o logico, corrisponde a vero .T. o a falso .F.)
| Sintassi | 
                                                    Descrizione | 
                                                    Esempio | 
                                                
| NOT (b) | 
                                                    Negazione. | 
                                                    NOT(.T.)=.F. | 
                                                
FUNZIONI
DI TRASFORMAZIONE DI TIPO
| Sintassi | 
                                                    Descrizione | 
                                                    Esempio | 
                                                
| NUM (v) | 
                                                    Trasforma la stringa in numero. | 
                                                    NUM("1.23")=1.23 | 
                                                
| BOOLEAN (v) | 
                                                    Se v=0 il risultato è falso altrimenti se v è diverso da 0 è vero. | 
                                                    BOOLEAN (1)=.T. BOOLEAN (0)=.F.  | 
                                                
| INT (v) | 
                                                    Trasforma il numero decimale in numero intero o una stringa in numero intero. La trasformazione avviene troncando il numero e non arrotondando. | 
                                                    INT(12.4)=12 , INT("123")=123 | 
                                                
| STR (v) | 
                                                    Trasforma in stringa un valore intero, una data, un valore logico o un numero decimale. | 
                                                    STR(1.2)=''1.2'' | 
                                                
| DATE (v) | 
                                                    Trasforma una stringa in data. | 
                                                    DATE("12/12/1997")=12/12/1997 | 
                                                
VARI
| Sintassi | 
                                                    Descrizione | 
                                                    Esempio | 
                                                
| IIF (b,v1,v2) | 
                                                    Ritorna v1 se b è vera altrimenti ritorna v2 se b è falsa. | 
                                                    IIF(.T.,DATE("12/12/1997"),DATE())=DATE("12/12/1997") | 
                                                
| EMPTY (v) | 
                                                    Verifica se v è un valore vuoto. | 
                                                    EMPTY ("")=.T. EMPTY (0)=.T.  | 
                                                
| MAX (v1,v2...) | 
                                                    Fa il massimo di tot valori v1, v2, v3... | 
                                                    MAX(3,4)=4, MAX(DATE("01/01/1994"),DATE("02/02/1995"))=DATE("02/02/95") | 
                                                
| MIN (v1,v2....) | 
                                                    Fa il minimo di tot valori v1, v2, v3.... | 
                                                    MIN(5,6,3)=3, MIN(DATE("01/01/1994"),DATE("02/02/1995"))=DATE("01/01/94") | 
                                                
| SET (n1,n2) | 
                                                    Assegna a n1 il valore di n2 e ritorna a n2 ( può essere utilizzato solo con la variabile di servizio COUNT). | 
                                                    SET(COUNT,COUNT+1)=1,2,3,4,5... 49+SET(COUNT,COUNT+3)=52,55,58,... 
  | 
                                                
Importante Prima di rimpiazzare definitivamente i campi si consiglia di verificare l'operazione eseguendo una Simulazione.
Nota Se il risultato di una formula presenta una stringa o un numero più lungo del campo selezionato, la stringa o il numero viene troncato. Solo nella Simulazione viene evidenziato il taglio della stringa o del numero.
 Pulsanti disponibili
                                        
- Simulazione Si apre una finestra che presenta un'anteprima di stampa che consente di controllare la sostituzione selezionata al fine di decidere se attuarla premendo il pulsante Esegui o modificarla.
 - Esegui Consente di apportare la modifica al contenuto del campo dell'archivio selezionato.