Con il comando SET DATABASE PARAMETER e il parametro Circular log limitation si può gestire il massimo numero di file di log dia tenere in rotazione automatica per tipo di log.

Il numero passato limita il numero di file presenti, con la cancellazione automatica del più vecchio. Si applica a:

- request logs (selectors 28 and 45),
- debug log (selector 34),
- events log (selector 79)
- Web request logs and Web debug logs (selectors 29 and 84 of the WEB SET OPTION command).

Il default è 0 che registra tutti i file senza limiti (finché c'è spazio su disco...)

Per 4DTEXT, 4DHTML, 4DEVAL c'è una sintassi alternativa veramente comoda.

Con la v16 è possibile usare per questi tag la forma con il $:
$4dtag (espressione) al posto del solito

Questo va bene solo per questi tag:
4DTEXT
4DHTML
4DEVAL

Quindi ad esempio:
$4DTEXT(UserName)

invece di:
<!--#4DTEXT UserName-->

Nelle stringhe JSON i caratteri da filtrare sono:

virgolette (quote) -> \"
barra a destra (slash) -> \/
barra a sinistra (backslash) -> \\
backspace -> \b
formfeed -> \f
nuova linea (new line, char(10) ) -> \n
a capo (return, char(13) ) -> \r
tabulatore (tab, char(9) ) -> \t
tutti i caratteri da 0 a 31 esclusi quelli sopra devono diventare \x00-\x1F
un qualsiasi carattere unicode -> \u+4 cifre esadecimale


// web_jsonEncode

$risultato:=$1

$risultato:=Replace string($risultato;"\\";"\\\\")
$risultato:=Replace string($risultato;char(double quote);"\\\"")
$risultato:=Replace string($risultato;"/";"\\/")
$risultato:=Replace string($risultato;Char(Backspace);"\\b")
$risultato:=Replace string($risultato;Char(FF ASCII code);"\\f")
$risultato:=Replace string($risultato;Char(Line feed);"\\n")
$risultato:=Replace string($risultato;Char(Carriage return);"\\r")
$risultato:=Replace string($risultato;Char(Tab);"\\t")

$0:=$risultato

Nelle form impostando un oggetto di Variabile con il contenuto di un Object si ottiene:
1- la visualizzazione del Json corrispondente (senza dover usare JSON stringify)
2- il Json può essere modificato dall'utente e la variabile si aggiorna!

Quando si usa JSON Stringify o Selection to JSON i campi time vengono trasformati in un numero intero di millisecondi dalla mezzanotte.

Quindi le 10 del mattino diventano 10*3600*1000 = 36 000 000

Per recuperare l'orario originale si possono fare due cose:


$millisec:=36000000

Se mi serve una Stringa:
$testo:=Time String($millisec/1000)
-> $testo = "10:00:00"

Se mi serve un Time:
$ora:=Time($millisec/1000)
-> $ora = ?10:00:00?

COOKIE LAW
      1) Che cosa sono i cookie?
I cookie sono dei file di testo che i siti visitati inviano al browser dell'utente e che vengono memorizzati per poi essere ritrasmessi al sito alla visita successiva.

      2) A cosa servono i cookie?
I cookie possono essere usati per monitorare le sessioni, per autenticare un utente in modo che possa accedere a un sito senza digitare ogni volta nome e password e per memorizzare le sue preferenze.

      3) Cosa sono i cookie tecnici?
I cookie cosiddetti tecnici servono per la navigazione e per facilitare l'accesso e la fruizione del sito da parte dell'utente. I cookie tecnici sono essenziali per esempio per accedere a Google o a Facebook senza doversi loggare a tutte le sessioni. Lo sono anche in operazioni molto delicate quali quelle della home banking o del pagamento tramite carta di credito o per mezzo di altri sistemi.

      4) I cookie Analytics sono cookie tecnici?
In altri termini i cookie che vengono inseriti nel browser e ritrasmessi mediante Google Analytics o tramite il servizio Statistiche di Blogger o similari sono cookie tecnici?. Il Garante ha affermato che questi cookie possono essere ritenuti tecnici solo se "utilizzati a fini di ottimizzazione del sito direttamente dal titolare del sito stesso, che potrà raccogliere informazioni in forma aggregata sul numero degli utenti e su come questi visitano il sito. A queste condizioni, per i cookie analytics valgono le stesse regole, in tema di informativa e consenso, previste per i cookie tecnici."

      5) Che cosa sono i cookie di profilazione?
Sono cookie utilizzati per tracciare la navigazione dell'utente per creare profili sui suoi gusti, sulle sue preferenze, sui suoi interessi e anche sulle sue ricerche. Vi sarà certamente capitato di vedere dei banner pubblicitari relativi a un prodotto che poco prima avete cercato su internet. La ragione sta proprio nella profilazione dei vostri interessi e i server indirizzati opportunamente dai cookie vi hanno mostrato gli annunci ritenuti più pertinenti.

      6) È necessario il consenso dell'utente per l'installazione dei cookie sul suo terminale?
Per l'installazione dei cookie tecnici non è richiesto alcun consenso mentre i cookie di profilazione possono essere installati nel terminale dell'utente solo dopo che quest'ultimo abbia dato il consenso e dopo essere stato informato in modo semplificato.

      7) In che modo gli webmaster possono richiedere il consenso?
Il Garante per la Privacy ha stabilito che nel momento in cui l'utente accede a un sito web deve comparire un banner contenente una informativa breve, la richiesta del consenso e un link per l'informativa più estesa come quella visibile in questa pagina su che cosa siano i cookie di profilazione e sull'uso che ne viene fatto nel sito in oggetto.

      8) In che modo deve essere realizzato il banner?
Il banner deve essere concepito da nascondere una parte del contenuto della pagina e specificare che il sito utilizza cookie di profilazione anche di terze parti. Il banner deve poter essere eliminato solo con una azione attiva da parte dell'utente come potrebbe essere un click.

      9) Che indicazioni deve contenere il banner?
Il banner deve contenere l'informativa breve, il link alla informativa estesa e il bottone per dare il consenso all'utilizzo dei cookie di profilazione.

      10) Come tenere documentazione del consenso all'uso dei cookie?
È consentito che venga usato un cookie tecnico che tenga conto del consenso dell'utente in modo che questi non abbia a dover nuovamente esprimere il consenso in una visita successiva al sito.

      11) Il consenso all'uso dei cookie si può avere solo con il banner?
No. Si possono usare altri sistemi purché il sistema individuato abbia gli stessi requisiti. L'uso del banner non è necessario per i siti che utilizzano solo cookie tecnici.

      12) Che cosa si deve inserire nella pagina informativa più estesa?
Si devono illustrare le caratteristiche dei cookie installati anche da terze parti. Si devono altresì indicare all'utente le modalità con cui navigare nel sito senza che vengano tracciate le sue preferenze con la possibilità di navigazione in incognito e con la cancellazione di singoli cookie.

      13) Chi è tenuto a informare il Garante che usa cookie di profilazione?
Il titolare del sito ha tale onere. Se nel suo sito utilizza solo cokie di profilazione di terze parti non occorre che informi il Garante ma è tenuto a indicare quali siano questi cookie di terze parti e a indicare i link alle informative in merito.

      14) Quando entrerà in vigore questa normativa?
Il Garante ha dato un anno di tempo per mettersi in regola e la scadenza è il 2 Giugno 2015.

COOKIE UTILIZZATI IN QUESTO SITO
File di log: Come molti altri siti web anche questo fa uso di file di log registra cioè la cronologia delle operazioni man mano che vengono eseguite. Le informazioni contenute all'interno dei file di registro includono indirizzi IP, tipo di browser, Internet Service Provider (ISP), data, ora, pagina di ingresso e uscita e il numero di clic. Tutto questo per analizzare le tendenze, amministrare il sito, monitorare il movimento dell'utente dentro il sito e raccogliere dati demografici, indirizzi IP e altre informazioni. Tale dati non sono riconducibili in alcun modo all'identità dell'utente e sono cookie tecnici.

COOKIE DI TERZE PARTI PRESENTI NEL SITO

Cookie: www.sviluppo4d.it usa i cookie per memorizzare le informazioni sulle preferenze dei visitatori e sulle pagine visitate dall'utente e per personalizzare il contenuto della pagina web in basa al tipo di browser utilizzato e in funzione delle altre informazioni che appunto tale browser invia.

1) Cookie Google: tale cookie è stato introdotto da Google cinque anni fa e serve per pubblicare annunci Adsense su www.sviluppo4d.it in modo da mostrare all'utente della pubblicità più mirata in base alla loro cronologia. Gli utenti possono accettare tale cookie oppure disattivarlo nel loro browser visitando la pagina Privacy e Termini. Ulteriori informazioni sulle tipologie e sull'uso che fa Google dei cookie con finalità pubblicitarie possono essere trovate nella pagina web dei Tipi di cookie utilizzati. Anche alcuni partner pubblicitari di Google Adsense possono usare cookie e Web Beacons per tracciare gli utenti.

2) Cookie di Facebook: Questo sito ha alcuni plugin di Facebook che possono tracciare il comportamento dei lettori. Per avere maggiori informazioni si può consultare la pagina per la
Politica della Privacy di Facebook.

3) Google+ attraverso lo script plusone.js potrà trattare i dati personali secondo queste line guida
Google Cookie Policy Privacy

In questo blog hanno accesso server di terze parti o di rete pubblicitarie che usano tale tecnologia per inviare gli annunci nel tuo browser attraverso www.sviluppo4d.it. Tramite il rilevamento del tuo indirizzo IP mostrano la pubblicità più pertinente con i tuoi interessi. Tecnologie simili (quali cookie, web bacons e javascript) possono essere utilizzati dalle reti pubblicitarie di terze parti per misurare l'efficacia dei loro messaggi pubblicitari e per personalizzare il contenuto di tali messaggi.

Il sito www.sviluppo4d.it e il suo amministratore non hanno alcun controllo sui cookie che vengono utilizzati da terze parti quindi per approfondire il tema si consiglia di consultare le politiche della privacy di queste terze parti così come le opzioni per disattivare la raccolta di queste informazioni. L'amministratore di questo sito non può quindi controllare le attività degli inserzionisti di questo blog. È comunque possibile disabilitare i cookie direttamente dal proprio browser.

Queste disposizioni del Garante della Privacy non sono solo italiane ma sono comuni a gran parte del paesi europei. Si possono conoscere le regole di ciascuna giurisdizione consultando il sito Your Online Choices nella propria lingua.

UTILIZZO DI GOOGLE ANALYTICS IN QUESTO SITO
Come detto i cookie analytics sono considerati tecnici se utilizzati solo a fini di ottimizzazione e se gli IP degli utenti sono mantenuti anonimi. Informiamo l'utente che questo sito utilizza il servizio gratuito di Google Analytics. Ricordiamo che i dati vengono usati solo per avere i dati delle pagine più visitate, del numero di visitatori, i dati aggregati delle visite per sistema operativo, per browser, ecc. Gli IP di Google Analytics sono stati anonimizzati. Questi parametri vengono archiviati nei server di Google che ne disciplina la Privacy secondo queste linee guida.

Un utente può disattivare Google Analytics durante la navigazione utilizzando il componenete aggiuntivo disponibile per Chrome, Firefox, Internet Explorer, Opera e Safari.

Si possono inoltre
cancellare i cookie singolarmente per ciascun dominio,
nascondere le ricerche.
settare le impostazioni degli annunci di Google.

NAVIGAZIONE ANONIMA

Una navigazione senza l'utilizzo di cookie tecnici e di profilazione è possibile mediante quella che viene definita navigazione in incognito e che è fattibile con tutti i principali browser.
Ulteriori informazioni sulla disabilitazione dei cookie su Firefox, in inglese.
Ulteriori informazioni sulla disabilitazione dei cookie su Chrome, in inglese
Ulteriori informazioni sulla disabilitazione dei cookie su Internet Explorer, in inglese
Ulteriori informazioni sulla disabilitazione dei cookie su Safari , in inglese
Ulteriori informazioni sulla disabilitazione dei cookie su Opera, in inglese.

Le librerie OpenSSL usate da 4d e 4d server e il corrispondente supporto a TLS sono i seguenti:

4D openSSL TLS supportato
12.x : 0.9.8j : TLS v1.0
13.x : 1.0.0.d : TLS v1.0
14.x : 1.0.0.d : TLS v1.0

Dalla versione v12 queste sono le posizioni dei file di preferenza:

WINDOWS
C:\Users\\AppData\Roaming\4D\
C:\Users\\AppData\Roaming\4D Server\

MAC
erano per la v12:
/Users//Library/Preferences/4D/
adesso sono:
/Users//Library/Application Support/4D/ /Users//Library/Application Support/4D Server/


Le posizioni delle finestre e altre dimensioni si trovano:

WINDOWS
C:\Users\Administrator\AppData\Roaming\4D\4D Window Bounds v14\

MAC
/Users//Library/Application Support/4D/4D Window Bounds v14/

Dalla versione 13.5 4d non salverà più i record che hanno il flag di unico, ma che non hanno un indice assegnato.

Questa procedura permette l'estrazione dalla struttura dei campi unici non indicizzati
cfr http://kb.4d.com/assetid=77024


C_LONGINT($maxTableNumber_l;$currentTable_l)
C_LONGINT($maxFieldCount_l;$currentField_l)
C_LONGINT($dontCare_l) // Per valori GET FIELD PROPERTIES non usati.
C_BOOLEAN($dontCare_f;$isIndexed_f;$isUnique_f)
C_TEXT($logHeader_t;$logRecord_t;$logfile_t)
C_TEXT($delim_t;$lf_t)
C_TIME($logfile_h)
C_TEXT($tableName_t;$fieldName_t;$note_t)

$delim_t:=Char(Tab)
$lf_t:=Char(Carriage return)+Char(Line feed)

$logHeader_t:="Campi unici senza indice:"+$lf_t

$logfile_t:=Get 4D folder(Logs Folder)+"UniciNonIndicizzati"

$logfile_h:=Create document($logfile_t)

If (OK=1)

  SEND PACKET($logfile_h;$logHeader_t)

  $maxTableNumber_l:=Get last table number

  For ($currentTable_l;1;$maxTableNumber_l)
    If (Is table number valid($currentTable_l))
      $maxFieldCount_l:=Get last field number(Table($currentTable_l))
      For ($currentField_l;1;$maxFieldCount_l)
        If (Is field number valid($currentTable_l;$currentField_l))

           // Nota che la seguente riga è spezzata in due:
          GET FIELD PROPERTIES($currentTable_l;$currentField_l;$dontCare_l;\
           $dontCare_l;$isIndexed_f;$isUnique_f;$dontCare_f)

          If (($isUnique_f) & (Not($isIndexed_f)))

           $tableName_t:=Table name(Table($currentTable_l))
           $fieldName_t:=Field name(Field($currentTable_l;$currentField_l))

           $logRecord_t:="["+$tableName_t+"]"+$fieldName_t+$lf_t

           SEND PACKET($logfile_h;$logRecord_t)

          End if
        End if
      End for
    End if
  End for

  CLOSE DOCUMENT($logfile_h)
  SHOW ON DISK($logfile_t)
End if

Se si sceglie di effettuare manualmente il backup con il metodo:

CONFIRM("Eseguo il salvataggio automatico?";"Sì";"No")
If (OK=1)
  BACKUP
End if

Se la destinazione non è disponibile (ad esempio una pen drive) 4D modifica il percorso di backup con la cartella della struttura.
Se si salva in un file BackupSave.xml la copia della configurazione corretta, si può modificare il metodo precedente così:

CONFIRM("Eseguo il salvataggio automatico?";"Sì";"No")
If (OK=1)
  DELETE DOCUMENT(getPathname (Structure file)+"Preferences\\Backup\\Backup.xml")
  COPY DOCUMENT(getPathname (Structure file)+"Preferences\\Backup\\BackupSave.xml";u_PathnameOnly (Structure file)+"Preferences\\Backup\\Backup.xml")
  BACKUP
End if

Nelle installazioni Client/Server 4D registra in locale delle risorse che velocizzano i collegamenti successivi e che sono automaticamente aggiornati senza che l'utente debba intervenire.

Dalla v11 la posizione di queste risorse è in cartelle registrate in queste posizioni:

Windows XP:
{Disco:}\Documents and Settings\{nome_utente}\Local Settings\Application Data\Nomeprogramma_indirizzo

Windows Vista/7
{Disco:}\Users\{nome_utente}\AppData\Local\4D\Nomeprogramma_indirizzo

Mac
{Disco}Users\{nome_utente}\Libreria\Cache\4D\Nomeprogramma_indirizzo


Nel caso in cui il client è incorporato nell'applicazione, le cartelle locali sono:

Windows Vista/7
{Disk}:\Users\{nome_utente}\AppData\Local\Nomeprogramma

Mac OS X
{Disk}:Users:{nome_utente}:Library:Caches:Nomeprogramma Client


Nel caso ci fossero problemi di accesso a queste cartelle è sempre possibile creare una cartella "ClientLocal" vicino al 4d usato come client

Su installazioni Terminal Server/Citrix purtroppo le cartelle Local e Local Settings non possono essere inserite nel profilo, quindi ogni connessione richiederebbe di scaricare sempre le informazioni dal server. Se si vuole evitare questo è possibile integrare direttamente la cartella dell'applicazione (contenente una sottocartella ClientLocal) nel profilo di roaming. Ovviamente in questo caso deve esserci un 4d usato come client per ogni utente collegato.

Il file .4DLINK indica il percorso e le opzioni per aprire una struttura, sia per 4d Mono che Server.

Vengono creati automaticamente da 4D per mostrarli nei recenti, ma si possono recuperare, riutilizzare direttamente ed eventualmente modificare.

Per le versioni v11 e v12 il file si trovano nella cartella:

• Windows Vista: C:\Users\UserName\AppData\Roaming\4D\Favorites v11\
• Windows XP: C:\Documents and Settings\UserName\Application
Data\4D\Favorites v11\
• Mac OS: Users/UserName/Library/Preferences/4D/Favorites v11/


Per la versione v13:

• Windows: C:\Users\UserName\AppData\Roaming\4D\Favorites v13\

• Mac OS: /Users/UserName/Library/Application Support/4D/Favorites v13/

dove UserName è il nome dell'utente del sistema.

Quando predisponete una pagina web che deve essere visualizzata su device mobili con browser HTML5, tipo Safari Mobile su iPhone e iPad, è possibile utilizzare un metatag specifico che adatta il contenuto allo schermo.

La riga va inserita sotto il tag <head> :

<meta name="viewport" content="width=device-width, initial-scale=1, user-scalable=no">

Per ulteriori informazioni guarda la Safari Web Content Guide

A partire dalla versione 11 è possibile utilizzare il database in modalità Unicode.

In questa modalità, tre caratteri non possono essere memorizzati all'interno di un testo della base dati, e sono:
0
65534 (FFFE)
65535 (FFFF)

Sulla parte sinistra del nuovo Method Editor di 4D è possibile vedere, accanto al numero di linea, una piccola linea verticale colorata.

Il colore è verde per indicare che la riga non è stata modificata dall'ultimo salvataggio, giallo se la riga è stata modificata.

I lettori di barcode della Infinite Peripherals, Linea Pro per iPhone e iPod e Infinea Tab per iPad, sono quelli usati da Apple nei propri AppleStore.

Per utilizzarli con un nostro gestionale in 4d (a parte scrivere un'app nativa in IOS) potete usare una soluzione abbastanza semplice:
- da 4d pubblicate via web le pagine con le funzioni che vi servono
- scaricare l'app "Nexus Barcode" che è gia pubblicata su AppStore
- nelle impostazioni dell'app mettete l'indirizzo della vostra pagina di 4d

A questo punto quando aprite l'app si carica la pagina web del vostro gestionale:
- fate click (ops tap) sul campo da inserire
- premete il tasto del lettore di barcode che va a scrivere nel campo

Oppure:
- nella preparazione della pagina predisponete un javascript che si aspetta un solo parametro, tipo: function loadBarcode(codice) {}
- nelle impostazioni dell'app scrivete il nome della funzione: loadBarcode

In questa modalità non c'è bisogno di cliccare (tappare) il campo dove inserire il codice, basta usare il lettore del barcode; a parte la comodità di un passaggio in meno, l'altro vantaggio è che non serve far apparire la tastiera che sullo schermo dell'iPod significa guadagnare un bel po' di spazio

Per l'hardware dei lettori ci si può rivolgere al distributore italiano dei lettori barcode per iPhone, iPod, iPad Cidroid, divisione della Nexus.

Una delle prime FAQ pubblicate su Sviluppo4D riguardava la limitazione del numero di caratteri inseribili in un campo Alpha.

Eccone una versione aggiornata:
Case of
      : (Form event=On After Edit)
      If (Length(Get edited text)>=vLength)
           $textvariable:=Substring(Get edited text;1;vLength)
      End if
End case

A vLength può essere sostituita la lunghezza del campo, nei casi in cui è possibile.

A $textvariable potrebbe essere sostituito Self->, ma in questo caso il metodo non funziona ad esempio sugli elementi degli array di una listbox.

Utilizzando il metodo di Keisuke Miyako per l'esecuzione di un VB script, vediamo un esempio di conversione di un file utilizzando MS Word.

Ecco il testo di uno script che apre un file e lo salva in formato solo testo:


Set objWord = CreateObject("Word.Application")
Set objDoc = objWord.Documents.Open("C:\codici.doc")
Const wdFormatText = 2
objDoc.SaveAs "C:\codici.txt", wdFormatText
objWord.Quit




Ecco il metodo (lievemente modificato) di Keisuke Miyako:

C_TEXT($1;$0)
C_BLOB($2)

C_LONGINT($platform_l)
PLATFORM PROPERTIES($platform_l)

If ($platform_l=Windows)

$script_folder_path_t:=Get 4D folder(Current Resources folder)+"vbs\\"
$script_file_path_t:=$script_folder_path_t+Replace string($1;"/";"\\";*)

      If (Test path name($script_file_path_t)=Is a document)

           SET ENVIRONMENT VARIABLE("_4D_OPTION_HIDE_CONSOLE";"true")
           C_BLOB($standard_input_x;$standard_output_x;$standard_error_x)

           If (Count parameters=2)
           $standard_input_x:=$2
           //patch to counter data loss caused by CRLF's in input stream
           SET BLOB SIZE($standard_input_x;BLOB size($standard_input_x)+8166;0)
           End if

           LAUNCH EXTERNAL PROCESS("cscript //Nologo //U \""+$script_file_path_t+"\"";$standard_input_x;$standard_output_x;$standard_error_x)
           $standard_output_t:=Convert to text($standard_output_x;"UTF-16LE")

           If (BLOB size($standard_error_x)#0) & (BLOB size($standard_output_x)=0)
           $0:=Convert to text($standard_error_x;"UTF-16LE")
           Else
           $0:=$standard_output_t
           End if

      End if

End if

Ecco i risultati dei primi test con le versioni di 4d v12.4 e v13.1 su Mountain Lion.

Restano aperti solo quattro problemi, che saranno sicuramente fissati nelle prossime versioni (subito nelle prossime versioni Hotfix per i Partner):

2 problemi importanti riguardano un crash dopo:
- il cambio di stampante da codice
- la stampa dagli editor di Etcihette o dal Quick Report

2 solo cosmetici riguardano:
- il comando OBJECT SET ENABLE non mette in grigio il testo disabilitato
- il colore della selezione di record nelle maschere di tipo Lista

Inoltre 4d sas dovrà gestire in qualche modo la nuova gestione di Gatekeeper, per certificare le prossime versioni di 4d con Apple.

Da segnalare un problema con il web server Apache integrato in OS X: se la condivisione web era attiva prima di aggiornare a Mountain Lion, 4d non pèotrà accedere alla porta 80 con il suo Web server.
Purtroppo in Mountain Lion non c'è più la preferenza che stoppa Apache, per cui bisognerà interromperlo con il comando da terminale:
sudo apachectl stop

cfr http://www.4d.com/blog/information-4d-mountain-lion.html

I servizi webservice possono richiedere l'autenticazione in diversi modi:

1. lo standard http BASIC
-> si può usare il comando WEB SERVICE AUTHENTICATE ("nome", "password"; 1)

2. lo standard http DIGEST
-> si può usare il comando WEB SERVICE AUTHENTICATE ("nome", "password"; 2)

3. uno dei due standard http, ma con un proxy http intermedio:

-> si usa il doppio comando
WEB SERVICE AUTHENTICATE ("nome", "password", 0) `può essere BASIC o DIGEST
WEB SERVICE AUTHENTICATE ("nome2", "password2", *) `dati di accesso al proxy

4. può essere del tipo SOAP HEADER, cioè inclusa nel corpo della SOAP

$xml:=DOM Create XML Ref("auth")
$utente:=DOM Create XML element($xml;"username")
DOM SET XML ELEMENT VALUE($utente;"nome")
$password:=DOM Create XML element($xml;"password")
DOM SET XML ELEMENT VALUE($password;"password")
SET WEB SERVICE OPTION(Web Service SOAP Header,$xml)
DOM CLOSE XML($xml)

Sono eventualmente da verificare che i nodi siano "username" e "password"

I comandi Average, Max, Min, Std deviation, Sum, Sum squares e Variance che storicamente si usavano solo nella stampa dei rapporti (dopo un comando Accumulate) adesso funzionano anche sulla selezione corrente o su un array.

L'effetto sulla ottimizzazione del codice è immediato:
dove prima ad esempio per avere la somma di un array occorreva ciclare sui suoi elementi adesso basta scrivere $totale:=Sum($array).

Una inner join crea una griglia di dati combinando i valori delle due tabelle di partenza (A and B) basandosi su una certa regola di confronto: la query compara ogni riga della tabella A con ciascuna riga della tabella B cercando di soddisfare la regola di confronto definita.

Esempio, date queste due tabelle di dati:

Tabella Aziende

ID_Azienda	Ragione_Sociale
az1	Nexus
az2	Acme
az3	NewCo

Tabella Contatti

Cognome	ID_Azienda
Rossi	az1
Verdi	az2
Bianchi	-

Begin SQL
    SELECT Cognome,Aziende.Ragione_Sociale
    FROM Contatti
    INNER JOIN Aziende
    ON Contatti.ID_Azienda=Aziende.ID_Azienda
    INTO :ArrCognome,:ArrRagSociale;
End SQL

Risultato:

Cognome	Ragione_Sociale
Rossi	Nexus
Verdi	Acme

Una right outer join (o right join) semplicemente ricalca il funzionamento della left outer join, ma invertendo l'ordine delle tabelle interessate.
Il risultato di una query right outer join per le tabelle A e B contiene sempre tutti i record della tabella di destra ("right") B, mentre vengono estratti dalla tabella di sinistra ("left") A solamente le righe che trovano corrispondenza nella regola di confronto della join. Questo significa che se la clausola ON trova 0 (zero) righe in A, la join mostrerà una riga risultante con valore NULL in tutte le colonne corrispondenti al risultato per le colonne di A.

Esempio, date queste due tabelle di dati:

Tabella Aziende

ID_Azienda	Ragione_Sociale
az1	Nexus
az2	Acme
az3	NewCo

Tabella Contatti

Cognome	ID_Azienda
Rossi	az1
Verdi	az2
Bianchi	-

  Begin SQL
    SELECT Cognome,Aziende.Ragione_Sociale
    FROM Contatti
    RIGHT OUTER JOIN Aziende
    ON Contatti.ID_Azienda=Aziende.ID_Azienda
    INTO :ArrCognome,:ArrRagSociale;
End SQL

Risultato:

Cognome	Ragione_Sociale
NULL	NewCo
Rossi	Nexus
Verdi	Acme

Il risultato di una query left outer join (o semplicemente left join) per le tabelle A e B contiene sempre tutti i record della tabella di sinistra ("left") A, mentre vengono estratti dalla tabella di destra ("right") B solamente le righe che trovano corrispondenza nella regola di confronto della join. Questo significa che se la clausola ON trova 0 (zero) righe in B, la join mostrerà una riga risultante con valore NULL in tutte le colonne corrispondenti al risultato per le colonne di B.

Esempio, date queste due tabelle di dati:

Tabella Aziende

ID_Azienda	Ragione_Sociale
az1	Nexus
az2	Acme
az3	NewCo

Tabella Contatti

Cognome	ID_Azienda
Rossi	az1
Verdi	az2
Bianchi	-

  Begin SQL
    SELECT Cognome,Aziende.Ragione_Sociale
    FROM Contatti
    LEFT OUTER JOIN Aziende
    ON Contatti.ID_Azienda=Aziende.ID_Azienda
    INTO :ArrCognome,:ArrRagSociale;
End SQL

Risultato:

Cognome	Ragione_Sociale
Bianchi	NULL
Rossi	Nexus
Verdi	Acme

Una full outer join combina i risultati delle due tabelle A e B tenendo conto di tutte le righe delle tabelle, anche di quelle che non hanno corrispondenza tra di loro.
Il risultato di una query full outer join per le tabelle A e B contiene sempre tutti i record della tabella di sinistra ("left") A, estraendo dalla tabella di destra ("right") B solamente le righe che trovano corrispondenza nella regola di confronto della join; inoltre verranno estratti tutti i record della tabella di sinistra ("left") A che non trovano corrispondenza nella tabella di destra ("right") B impostando a NULL i valori di tutte le colonne della tabella B e tutti i record della tabella di destra ("right") B che non trovano corrispondenza nella tabella di sinistra ("left") A impostando a NULL i valori di tutte le colonne della tabella A.

Esempio, date queste due tabelle di dati:

Tabella Aziende

ID_Azienda	Ragione_Sociale
az1	Nexus
az2	Acme
az3	NewCo

Tabella Contatti

Cognome	ID_Azienda
Rossi	az1
Verdi	az2
Bianchi	-

Begin SQL
    SELECT Cognome,Aziende.Ragione_Sociale
    FROM Contatti
    FULL OUTER JOIN Aziende
    ON Contatti.ID_Azienda=Aziende.ID_Azienda
    INTO :ArrCognome,:ArrRagSociale;
End SQL

Risultato:

Cognome	Ragione_Sociale
NULL	NewCo
Bianchi	NULL
Rossi	Nexus
Verdi	Acme

Una cross join fornisce le basi attraverso cui tutti i tipi di inner join operano.
Il risultato di una cross join è il prodotto cartesiano di tutte le righe delle tabelle che concorrono alla query di join. E' come dire che stiamo facendo una inner join senza impostare la regola di confronto o in cui la regola di confronto ritorna sempre vero.


Esempio, date queste due tabelle di dati:

Tabella Aziende

ID_Azienda	Ragione_Sociale
az1	Nexus
az2	Acme
az3	NewCo

Tabella Contatti

Cognome	ID_Azienda
Rossi	az1
Verdi	az2
Bianchi	-

Begin SQL
    SELECT Cognome,Aziende.Ragione_Sociale
    FROM Contatti
    CROSS JOIN Aziende
    ON Contatti.ID_Azienda=Aziende.ID_Azienda
    INTO :ArrCognome,:ArrRagSociale;
End SQL

Risultato:

Cognome	Ragione_Sociale
Bianchi	Nexus
Bianchi	Acme
Bianchi	NewCo
Rossi	Nexus
Rossi	Acme
Rossi	NewCo
Verdi	Nexus
Verdi	Acme
Verdi	NewCo

Su Windows le librerie di Quicktime potrebbero non essere installate e alcune immagini registrate con un 4d precedente alla v11 potrebbero non vedersi:
  appare in questo caso un riquadro bianco con la scritta del tipo "Quicktime is required"

ARRAY TEXT($identificativi_at;0)
ARRAY TEXT($nomi_at;0)
PICTURE CODEC LIST($identificativi_at;$nomi_at)
If (Find in array($identificativi_at;".qtif")<0) // Tipo immagine QuickTime
  ALERT("QuickTime non è installato.")
End if

A partire dalla v11 le immagini in 4D non sono più salvate come PICT, ma nel loro formato originale.
Però se abbiamo convertito un db ci potrebbero essere delle immagini che richiedono Quicktime per essere viste su Windows.

Per eliminare la necessità di questa installazione è possibile usare il comando CONVERT PICTURE, come ad esempio:

ALL RECORDS([MieImmagini])
While (Not(End selection([MieImmagini])))
  CONVERT PICTURE([MieImmagini]Immagine;".jpg")
  SAVE RECORD([MieImmagini])
  NEXT RECORD([MieImmagini])
End while

Dalla v12 questo comando permette anche la compressione del JPEG con questa sintassi:
CONVERT PICTURE([MieImmagini]Immagine;".jpg"; 0.6)

NOTA: Ovviamente per essere eseguita questa procedura richiede Quicktime, la volta in cui viene eseguita.

cfr Verifica da codice se Quicktime è installato

Le alternative per utilizzare l'ipad o l'iphone collegandolo a 4d sono, partendo dalle più facili:

1. utilizzare un app tipo iSort
pro: l'app costa veramente poco ed è subito disponibile, su 4d serve la licenza web
contro: le possibilità di personalizzazione sono poche, e non si può programmare lato ipad (Apple vieta esecuzione di codice nelle app)

2. preparare delle pagine web servite da 4d, semplici senza usare ajax o framework
pro: sviluppo semplice, il safari di iPad è un browser vero e completo, compatibile con html5, css e javascript
contro: funziona bene se c'è sempre copertura, ad esempio usandolo in area coperta da wifi

3. preparare delle pagine web servite da 4d, utilizzando ajax o framework
pro: puoi usare degli oggetti più completi, come griglie di dati, se perdi il collegamento potresti usare i dati offline
contro: comunque serve la connessione internet attiva, una parte di programmazione si sposta su javascript

4. scrivere un programma in objective c
pro: puoi scriverti un'applicazione completa registrando in locale i dati sui cui lavorare, scaricando e inviando solo ogni tanto gli aggiornamenti
Il collegamento a 4d si può fare :
- via web utilizzando l'url speciale 4DSYNC che sfrutta la funzionalità di sincronizzazione inclusa in v12 (cfr iPhone, iPad, Android e l'url 4DSYNC
- via webservice o semplice chiamata GET (/4daction/metodo/parametro..); 4d può essere sia server che monoutenza con licenza web
- via file: l'app può scaricare un file postato in una directory web con autenticazione, può inviare i dati in formato POST; si perde il realtime, ma non serve licenza web

contro: è più lungo scrivere in obiettive e si devono valutare bene le modalità di distribuzione, che riporto:
- app ad hoc: si installa su un massimo di 100 ipad/iphone per sviluppatore (l'elenco si può resettare solo 1 volta all'anno)
- app enterprise: l'azienda cliente si registra come Enterprise a 299$ anno può installare su quanti ipad vuole
- app su appstore: i limiti sono quelli delle regole di approvazione Apple, i tempi di rilascio sono di 5-10 giorni per ogni aggiornamento

Questo codice è un esempio di SQL con cui è possibile modificare un valore in diversi record con un unico comando.

Presupponendo che abbiamo una Tabella in cui i record hanno un campo Codice e un campo Nome, il comando nel formato Begin SQL sarà così:

Begin SQL
  update [Tabella]
  set Nome = CASE Codice
  when 1 then 'NomeUno'
  when 2 then 'NomeDue'
  when 3 then 'NomeTre'
  end
  where codice in (1,2,3)
end sql

In pratica:
1) il WHERE campo IN (n,n,..) mi seleziona i record il cui Codice è nella lista
2) il CASE ritorna il valore desiderato al variare del campo Codice

Come si può facilmente vedere, dalla 4D v12 è stato radicalmente modificato il method editor. Una delle modifche più utili riguarda la possibilità di poter mandare a capo le righe in modo da avere un'istruzione più facilmente leggibile (si pensi, ad esempio, alle righe infinite di estesi SELECTION TO ARRAY).

Adesso basta far finire una riga col carattere "\" e ill testo della riga successiva verrà considerato come prosecuzione dell'attuale.

Utilizzando la nuova opzione "Execute in server" per i metodi, bisogna ricordare che:
- il processo sul server non è creato al momento, ma usa il processo "gemello" che gira sul server
- il metodo su server considera i record bloccati e le transazioni, ma non tiene conto dei valori delle variabili sul client e non mantiene la selezione corrente.
- le variabili processo del metodo sul server persistono (con valore) anche dopo la conclusione del processo stesso sul server
- se passi un puntatore ad una variabile o un array il valore puntato è inviato al server e ritornato al client se modificato

Sul server non possono essere eseguiti alcuni comandi: se provi a farlo apparirà una finestra di dialogo. Alcuni comandi non funzionanti nei metodi sono:

Comandi correlati all'interfaccia
ADD RECORD
ADD SUBRECORD
DISPLAY SELECTION
FILTER EVENT
GRAPH TABLE
Level
ON EVENT CALL
MODIFY RECORD
MODIFY SELECTION
MODIFY SUBRECORD
Open external window
QUERY BY EXAMPLE
QR REPORT

Comandi di struttura
CHANGE LICENSES
CREATE DATA FILE
EDIT ACCESS
OPEN DATA FILE
CALL PROCESS

Comandi sulle risorse
SET PICTURE TO LIBRARY
REMOVE PICTURE FROM LIBRARY
SET PICTURE TO LIBRARY

Comandi per la gestione dei menu
APPEND MENU ITEM
Count menu items
Count menus
DELETE MENU ITEM
DISABLE MENU ITEM
ENABLE MENU ITEM
Get menu item
Get menu item key
Get menu item mark
Get menu item style
Get menu title
INSERT MENU ITEM
Menu selected
SET MENU ITEM
SET MENU ITEM SHORTCUT
SET MENU ITEM MARK
SET MENU ITEM STYLE
SHOW MENU BAR

Comandi per la stampa
ACCUMULATE
BREAK LEVEL
PAGE BREAK
PAGE SETUP
PRINT SETTINGS
Printing page
Subtotal

Dovendo scaricare da Gmail gli aggiornamenti del gruppo Sviluppo4D su Facebook inviati da Umberto in occasione del summit di Boston, ecco il codice utilizzato all'uopo.

C_TEXT($msgText)
READ WRITE([Posta])
$error:=0
$sslPOPPort:=995
$Errore_l:=IT_SetPort (13;$sslPOPPort) //12 is for 'SMTP with SSL'
$error:=IMAP_Login ("pop.gmail.com";"indirizzo@gmail.com";"password";$imapID;1)
$error:=IMAP_SetCurrentMB ($imapID; "4D Summit 2011"; $msgNber; $newMsgNber; $customFlags; $permanentFlags; $mbUID)
For ($i;1;$msgNber)
      CREATE RECORD([Posta])
      msgDataItem:="INTERNALDATE"
      $Err:=IMAP_MsgFetch ($imapID;$i;msgDataItem;$text)
      $position:=Position(" ";$text)
      $text:=Delete string($text;1;$position)
      $error:=IMAP_GetMessage ($imapID;$i;0;31000;2;$msgText;1)

      $datrovare:="nel gruppo Sviluppo4D"
      $position:=Position($datrovare;$msgText)
      $msgText:=Delete string($msgText;1;$position+Length($datrovare)+2)

      $datrovare:="Per commentare"
      $position:=Position($datrovare;$msgText)
      $msgText:=Delete string($msgText;$position-2;Length($msgText))
      [Posta]msg_body:=$msgText
      [Posta]msg_ID:=$i
      SAVE RECORD([Posta])
      UNLOAD RECORD([Posta])

End for


$error:=IMAP_Logout($imapID)

Sin dalla versione v11, anche la struttura di 4d è un database e gli aggiornamenti fatti in fase di sviluppo seguono le stesse regole delle modifiche ai dati.

Se 4d si chiude inaspettatamente si potrebbero perdere le ultime modifiche fatti (modifiche al codice o ai form, ad esempio).

Per forzare il salvataggio si può:
- compilare
- passare da Design mode ad Application mode (e viceversa)
- eseguire il comando FLUSH BUFFERS

Con la versione 12 è possibile copiare le definizioni dei campi da una tabella ad un'altra.

Nella maschera "Structure" prendi la tabella di partenza, selezioni i campi che ti servono nella nuova tabella.
Effettui il copia (mela+c o ctrl+c).

Selezioni la tabella di destinazione ed effettui incolla (mela+v o ctrl+v).

4D ti genera nella nuova tabella i campo con nomi e proprietà identiche ai campi selezionati nella tabella di partenza.

Per il collegamento da un Client a 4D Server le porte TCP di default sono:

19813 - Application server
19814 - DB4D server
19812 - SQL server

Sulla porta DB4D sono veicolate tutte le chiamate al database, un socket per ogni processo divise poi sul server in thread differenti.

La variabile che indica la posizione attuale in un array è automaticamente dichiarata come Integer, tipo che ha il limite di 32767.
Questo significa che il codice:

ARRAY TEXT($largeArray_at;33000)
For ($i;1;33000)
        $largeArray_at{$i}:=String($i)
End for

$largeArray_at:=32768
$element:=$largeArray_at{$largeArray_at} `errore

produce errore poiché la variabile $largeArray_at non è stato dichiarato.

La soluzione è quindi dichiarare come Longint le variabili da usare come indici di puntatori ad array di grandi dimensioni.

I seguenti nomi di variabili sono riservati a 4D:

C1, C2, C3, C4, C5, ecc. (usate nei report)
OK
Document
Error
KeyCode
Modifiers
MouseDown
MouseProc
MouseX
MouseY
FldDelimit
RecDelimit

Non devono dunque essere usate se non nel contesto cui si riferiscono: ad esempio Document contiene il percorso del documento dopo aver usato Open document, Create document o Append document ed è stato scelto un file mostrando la dialog di sistema per l'apertura o il salvataggio di un file.

Il method editor di 4D nella v12 è stato completamente riscritto.

Tra le novità, una molto utile è la possibilità di visualizzare un help tip per i comandi di 4D, con definizione e una breve descrizione.

Possiamo però fare la stessa cosa anche con i nostri metodi:
  infatti, portando il mouse su un nostro metodo, non abbiamo bisogno di aprirlo per vedere cosa faceva perché come help tip vengono visualizzate tutte le righe iniziali del metodo che siano commento (e che non siano quindi codice).

Prendendo quindi l'abitudine di commentare i metodi nella loro parte iniziale con la loro definizione e descrizione, diventerà agevole conoscere le info sul nostro codice.

Se all'interno della stessa area di testo SVG devo inserire diversi stili (ad esempio una parola in tondo, una seconda in grassetto e una terza in corsivo), il comando da utilizzare è SVG_New_tspan.

A differenza della gran parte dei comandi SVG, SVG_New_tspan prende come parametro l'ID dell'area di testo (definita da un precedente SVG_New_text o SVG_New_tspan) a cui il nuovo testo deve essere collegato.
Quindi:

$textID:=SVG_New_text($SVG;"Scrivere ";10;10;"arial";12)
SVG_SET_FONT_SIZE(SVG_New_tspan($textID;"con ");14)
SVG_SET_FONT_SIZE(SVG_New_tspan($textID;"SVG ");18)
SVG_SET_FONT_SIZE(SVG_New_tspan($textID;"è ");24)
SVG_SET_FONT_SIZE(SVG_New_tspan($textID;"facile");36)

definisce l'area di testo, quindi inserisce il testo aggiuntivo, modificandone al volo la dimensione.

Ecco un elenco dei vari standard:

• esecuzione diretta script PHP 5.3 con interprete compilato FastCGI
  
• supporto XML versione 1.0 con la libreria Xerces di Apache Foundation:
  • standard DOM (Document Object Model)
  • il SAX (Simple API XML)
  • la notazione XPath (per il DOM)
  • le trasformazioni tramite XSL style sheets (eXtended Stylesheet Language)
  
  
• gestione di quattro tipi di Metadati per le immagini: EXIF, GPS, IPTC e TIFF
  
• gestione del forma SVG ((Scalable Vector Graphics), sia come visualizzazione che creazione e modifica
  
• supporto dell'architettura standard XLIFF (XML Localization Interchange File Format) per la localizzazione dell'interfaccia
  
• supporto dei WebService, sia come server che come client
  • generazione automatica del WSDL (Web Service Description Language) come server e interpretazione degli stessi per la generazione del codice client
  • protocolli SOAP (versione 1.1 e versione 1.2)
  • RPC (Remote Procedure Call)
  • DOC (Document-oriented)
  
  
• il Web Server è compatibile HTML 1.1, supporta documenti XML, la tecnologia WML (Wireless Markup Language), il protocollo SSL (Secured Socket Layer)
  
• supporta le CGI e può essere chiamato tramite CGI da altri web server
  
• utilizzando il web server sui client è possibile realizzare facilmente il Load Balancing
  
• disponibilità di un 4D AJAX Framework, per creare pagine web collegate e distribuite dal server 4D
  
• disponibilità di un 4D for Flex, che permette alle applicazioni Flex di collegarsi direttamente al server 4D
  
• supporta le chiamate via ODBC con driver nativo anche per Macintosh
  
• supporta le chiamate via PDO_4D da PHP
  
• supporta chiamate dirette server to server con altri server 4D
  
• può interrogare altri database via protocollo ODBC e OCI (Oracle Call Interface)
  
• comandi per interrogazione server posta POP3 e IMAP, Internet Message Access Protocol, Version 4 revision 1 (IMAP4rev1)
  
• comandi per l'invio di posta tramite server SMTP, con allegati, destinatari, destinatari in copia CC (Carbon Copy ) e in copia nascosti BCC (Blind Carbon Copy ), autenticazione (CRAM-MD5, LOGIN, PLAIN), commenti
  
• comandi per la gestione diretta dei server FTP (File Transfer Protocol)
  
• comandi di basso livello TCP/IP, UDP, utility come Ping e Name resolver

Il backup di solito viene lanciato in ore notturne o quando non ci sono normalmente utenti online; oppure il server non è facilmente accessibile... come fare a controllare che il backup sia andato a posto?

E' possibile utilizzare il metodo Database che si chiama "On Backup Shutdown Database Method"; questo metodo viene chiamato automaticamente alla fine del processo di backup, con parametro $1 = 0 se tutto è andato a posto o # 0 se ci sono stati problemi.

C_LONGINT($1;$backupStatus)
C_DATE($data)
C_TIME($ora)
C_REAL($num)
C_TEXT($status)
$backupStatus:=$1
If ($backupStatus#0)
  GET BACKUP INFORMATION(Last Backup Date ;$data;$ora)
  GET BACKUP INFORMATION(Last Backup Status ;$num;$status)
  $messaggio:="Errore nel backup numero "+string($backupStatus)+"\r\r"
  $messaggio:=$messaggio+"Ultimo Backup: "+String($data)+" alle "+String($ora)+"\r"
  $messaggio:=$messaggio+"Stato: "+$status
  $res:=smtp_quickSend(<>serverSmtp ; <>mailMittente ; <>mailDestinatario ; "Errore durante il backup"; $messaggio)
End if

Per maggior chiarezza e miglior controllo, alcuni tag HTML sono stati modificati in 4d v12.2:

• 4DHTMLVAR è sostituito da 4DHTML
• 4DVAR -> obsoleto, al suo posto usa:
  -> 4DHTML per inserire una variabile 4d o una espressione come codice Html
  -> 4DTEXT per inserie una variabile 4d o una espressione come testo

Note:
- Adesso 4DTEXT non accetta più il char(1) come primo carattere per interpretarlo come HTML, che era il primo vecchio meccanismo per supportare le due varianti di 4DVAR.
- Le vecchie varianti sono ancora supportate, ma essendo dichiarate obsolete dalla 12.2 sarà meglio cominciare ad usare la nuova nomenclatura

Quando si tenta di connettere un client a un server v11 e successivi e appaiono questi errori:
-10509 Can't open database
1024 Cannot open structure of database
1211 Cannot create connection
4 <<Localizator is not available.>>

Vuol dire che la porta precedente e quella successiva alla porta di comunicazione client/server non sono accessibili, normalmente a causa di un firewall-

La porta di default è la 19813: anche la 19812 e la 19814 dovrebbero essere aperte.

La v12 integra un comando molto utile per gestire le subform.

CALL SUBFORM CONTAINER(event)

invia un evento event (un longint) all'object method del "contenitore" della subform.
Il comando può trovarsi nel form method della subform o in uno degli oggetti della stessa.
L'evento event può essere o uno dei valori delle costanti 4D per i form events o un qualsiasi valore definito dall'utente (che viene gestito sempre nel metodo del contenitore).

Tale commistione di valori rende consigliabile l'uso di valori negativi per gli eventi "user defined" in modo che non vadano in conflitto con quelli predefiniti 4D.

Il comando RESTORE accetta adesso due parametri, entrambi opzionali:
- l'archivio da ripristinare;
- la cartella di destinazione per il ripristino.

Se il ripristino viene eseguito correttamente, la variabile OK viene settata ad uno e la variabile Document conterrà il percorso della cartella di ripristino; in caso contrario OK va a 0 e Document avrà come valore una stringa vuota.

4D v12 installa automaticamente i manuali in versione HTLM. Per i fan ("duri a morire" recita il sito di 4D) dei PDF, ecco dove trovare la documentazione nel formato Adobe:

Doc Center homepage

FTP site

In realtà, non si tratta di una reimpaginazione dei manuali: sono esattamente le pagine html in pdf.

Dalla versione 12.1 è possibile inviare e ricevere mail utilizzando l'SSL come protocollo di scambio dati.
L'uso del protocollo non richiede nessuna configurazione particolare: basta passare il nuovo parametro a 1 nei seguenti comandi:

• IMAP_Login
• SMTP_Send
• SMTP_QuickSen
• POP3_Login

Invece il comando IT_SetPort ora accetta 3 nuovi valori per l'impostazione delle porte:
12 = SMTP SSL
13 = POP3 SSL
14 = IMAP SSL

La tabella che si occupa di regolamentare gli accessi al database via SQL.

_USER_SCHEMAS
SCHEMA_ID - INT32 - Numero
SCHEMA_NAME - VARCHAR - Nome
READ_GROUP_ID - INT32 - Numero del gruppo in sola lettura
READ_GROUP_NAME - VARCHAR - Nome del gruppo in sola lettura
READ_WRITE_GROUP_ID - INT32 - Numero del gruppo in scrittura
READ_WRITE_GROUP_NAME - VARCHAR - Nome del gruppo in scrittura
ALL_GROUP_ID - INT32 - Numero del gruppo con tutti i diritti (anche modifica della struttura)
ALL_GROUP_NAME - VARCHAR - Nome del gruppo con tutti i diritti

Ecco un'altra coppia di tabelle di sistema accessibili via SQL, con l'elenco delle relazioni, dei campi definiti come chiave primaria e delle regole di integrità referenziale (se cancello la testata cancello le righe, oppure non posso cancellare un record finché ci sono record in relazione.

_USER_CONSTRAINTS
CONSTRAINT_ID - VARCHAR - Numero identificativo della regola
CONSTRAINT_NAME - VARCHAR - Nome
CONSTRAINT_TYPE - VARCHAR - Tipo
TABLE_NAME - VARCHAR - Nome della tabella dove si trova la regola
TABLE_ID - INT64 - Numero della tabella con la regola
DELETE_RULE - VARCHAR - Regola di cancellazione con regola di integrità referenziale – CASCADE or RESTRICT
RELATED_TABLE_NAME - VARCHAR - Nome della tabella in relazione
RELATED_TABLE_ID - INT64 - Numero della tabella in relazione

Tipi di Constrain (o Regole):
P=chiave primaria o primary key
R= integrità referenziale - foreign key
4DR=relazione 4D

_USER_CONS_COLUMNS
CONSTRAINT_ID - VARCHAR - Numero identificativo della regola
CONSTRAINT_NAME - VARCHAR - Nome
TABLE_NAME - VARCHAR - Nome della tabella dove si trova la regola
TABLE_ID - INT64 - Numero della tabella con la regola
COLUMN_NAME - VARCHAR - Nome del campo con la regola
COLUMN_ID - INT64 - Numero del campo con la regola
COLUMN_POSITION - INT32 - Posizione del campo
RELATED_COLUMN_NAME - VARCHAR - Nome del campo in relazione
RELATED_COLUMN_ID - INT32 - Numero del campo in relazione

Da notare che le relazioni Molti a uno di 4d non sono la stessa cosa delle relazioni creati via SQL Primary Key e Foreign Key; nella Struttura anche dal punto di vista grafico sono rappresentate in maniera diversa.

Relazioni 4d:


Primary Key e Foreign Key SQL:

La seguente coppia di tabelle accessibili da SQL contengono le informazioni sugli indici:

_USER_INDEXES
INDEX_ID - VARCHAR - Numero identificativo dell'indice
INDEX_NAME - VARCHAR - Nome (potrebbe essere vuoto)
INDEX_TYPE - INT32 - Tipo
TABLE_NAME - VARCHAR - Nome della tabella dove si trova l'indice
TABLE_ID - INT64 - Numero della tabella dove si trova l'indice
UNIQUENESS - BOOLEAN - Vero se l'indice prevede l'unicità

I Tipi di indice sono:
1 BTree / Composite
3 Cluster / Keyword
7 Auto


_USER_IND_COLUMNS
INDEX_ID - VARCHAR - Numero identificativo dell'indice
INDEX_NAME - VARCHAR - Nome (potrebbe essere vuoto)
TABLE_NAME - VARCHAR - Nome della tabella dove si trova l'indice
COLUMN_NAME - VARCHAR - Nome del campo dove si trova l'indice
COLUMN_POSITION - INT32 - Posizione del campo
TABLE_ID - INT64 - Numero della tabella
COLUMN_ID - INT64 - Numero del campo

Ecco per esempio il codice per cancellare tutti gli indici di un db:

ARRAY TEXT($identificativi;0)
Begin SQL
    select Index_Id from _User_Indexes into :$identificativi;
End SQL
For ($i;1;Size of array($identificativi))
        $id:=$identificativi{$i}
        $tablenum:=0
        $fieldnum:=0
        Begin SQL
           select table_id, column_Id from _User_Ind_Columns
           where Index_ID = :$id limit 1 into :$tablenum, :$fieldnum;
        End SQL
        If (($tablenum#0) & ($fieldnum#0))
           $puntCampo:=Field($tablenum;$fieldnum)
           DELETE INDEX($puntCampo;*)
        End if
End for

Questa tabella accessibile da SQL dà un elenco dei campi divisi per le tabelle del database:

_USER_COLUMNS
TABLE_NAME - VARCHAR - Nome della tabella
COLUMN_NAME - VARCHAR - Nome del campo
DATA_TYPE - INT32- Tipo del campo
DATA_LENGTH - INT32- Lunghezza del campo
NULLABLE- BOOLEAN - Vero se il campo accetta valori NULL
TABLE_ID - INT64 - Numero della Tabella
COLUMN_ID - INT64 - Numero del campo

Il campo Tipo contiene:

1 - Boolean
3 - Integer
4 - Long Integer
5 - Integer 64 Bits
6 - Real
7 - Float
8 - Date
9 - Time
10 - Alpha (DATA_LENGTH = ((dimensione del campo)*(2))+4
10 - Text (Lo distingui perché ha DATA_LENGTH = 0 )
12 - Picture
18 - BLOB

La più recente versione di 4D ha introdotto un nuovo metodo per il ripristino di una base dati danneggiata.

Oltre alla procedura standard (da usare quando indici o record sono danneggiati) è stato introdotto un "Recover by record headers" che permette il ripristino dei dati quando ad essere danneggiata è tabella degli indirizzamenti dei record, può essere utilizzato questo sistema assai più complesso.

Il procedimento è da utilizzare solo quando gli altri metodi non sono andati a buon fine. Al termine del processo non è garantita comunque l'unicità dei record (i record potrebbero comparire due volte) e il mantenimento della proprietà "Never null" dei campi. Infatti se nella tabella è stato deselezionato "Records definitively deleted" potrebbero ricomparire dei record eliminati.

Il sistema è diverso dal vecchio "Recover by tags" perché richiede l'intervento dell'operatore in quanto alcuni passi mostrano una finestra di richiesta conferma.

Ecco un elenco delle "Depercated features" che 4D ha segnalato come caratteristiche che verranno rimosse con le prossime versioni.

Cosa verrà rimpiazzato / Con cosa / da Quando
4D Chart (plug-in area) / SVG, webarea, PHP / Più avanti
4D Draw / SVG / (Rimosso dalla v11)
4D Open / Synchronization, WebServices, SQL Pass Thru / (Rimosso dalla v11)
PICT / Modern formats / Dipende dal Sistema
QuickDraw Patterns (form object property) / SVG, picture con “Replicated format” / Presto
Mac Resources / Usa “Resources” folder Sistema operativo
/ (Presto)
Old Looks / Usa System looks / Presto
Altura Mac2Win / Codice Windows nativo / Presto
SubTables / Usa tabelle N->1 / Più avanti
Web Contextual Mode / Usa il non-contextual mode / Presto
Non Unicode mode / Passa a Unicode / Presto

Ecco alcune impostazioni consigliate per l'uso di 4d su Windows Server 2003 e 2008:

Windows Processor Scheduling: settato a “Programs” invece di “background processes”.

Windows Memory: settato a “Programs” invece di “System Cache”.

Windows Page File: settato a “System Managed Size” invece di “Custom Size”.

La posizione di queste impostazioni varia da sistema a sistema, ma tipicamente si possono trovare in questo modo:

Fai clic su Start, poi Run, e scrivi "sysdm.cpl".

Nella finestra System Properties, fai clic sul tab Advanced, e poi clic su Settings sotto Performance.

Le raccomandazioni si applicano sia a 4d Monoutenza che Server, sia quando viene lanciato come servizio che in modalità utente.

In accordo con le specifiche SQL, 4th Dimension contiene delle tabelle di sistema che descrivono la struttura del database:

• _USER_TABLES
• _USER_COLUMNS
• _USER_INDEXES
• _USER_CONSTRAINTS
• _USER_IND_COLUMNS
• _USER _CONS_ COLUMNS
• _USER_SCHEMAS

.

La prima che andiamo ad analizzare è la _USER_TABLES, che contiene la descrizione delle tabelle del database. I campi che la compongono sono:

TABLE_NAME - VARCHAR - Il nome della tabella;
TEMPORARY - BOOLEAN - Vero se la tabella è temporanea, altrimenti Falso;
TABLE_ID - INT64 - Il numero della tabella;
SCHEMA_ID - INT32 - Il numero dello schema;

Così, come segnalato da Francesco Pandolfi sul NUG italiano, è possibile controllare se una tabella con un certo nome esiste usando il codice:

C_INTEGER($cnt)
C_TEXT($tabName)
$tabName:=$1

Begin SQL
        select count(*) from _user_tables
        where table_name = :$tabName
        into :$cnt;
End SQL

If ($cnt>0)
           `esiste
Else
           `non esiste
End if

Ecco di seguito un metodo per cercare un qualsiasi dato fra i campi alfanumerici di un database. Quando ogni dato viene trovato, restituisce un messaggio con tabella e campo in cui si trova il valore.


$quanti:=Get last table number
For ($i;1;$quanti)
  If (Is table number valid($i))
      For ($j;1;Get last field number($i))
        If (Is field number valid($i;$j))
           GET FIELD PROPERTIES($i;$j;$fieldType;$fieldLen;$indexed)
           If (($fieldType=Is Alpha Field ) | ($fieldType=Is Text ))
           $valoreSt:=$1
           $tabellaptr:=Table($i)
           $campoptr:=Field($i;$j)
           QUERY($tabellaptr->;$campoptr->=$valoreSt)
           If (Records in selection($tabellaptr->)>0)
           ALERT("["+Table name($i)+"]"+Field name($i;$j))
           End if
           End if
          End if
      End for
    End if
End for
ALERT("Finito")

Col seguente codice si può chiedere a 4D se una tabella esiste:



C_TEXT($1) ` Table name
C_BOOLEAN($0)

C_LONGINT($i)

$i:=1
$0:=False
While(($i<=Get last table number)&(Not($0)))
If (Is table number valid($i))
If (Table name($i)=$1)
$0:=True
End if
End if
$i:=$i+1
End while



Una variante può permettere di sapere il numero di tabella, se non esiste restituisce -1:


C_TEXT($1) ` Table name
C_LONGINT($i;$0)

$i:=1
$0:=-1
While($i<=Get last table number)
If (Is table number valid($i))
If (Table name($i)=$1)
$0:=$i
$i:=Get last table number+1
End if
End if
$i:=$i+1
End while

Dalla versione v11 i manuali non vengono più installati con le applicazioni.

Questo è l'indirizzo dove trovare i manuali di 4d in inglese:
http://www.4d.com/support/documentation.html

Per chi vuole consultare la guida online, l'indirizzo è:
http://www.4d.com/docs/4DDOCUS.HTM

Per configurare il percorso dell'help richiamabile con il tasto F1 nelle preferenze va scritto questo:
http://www.4d.com/docs/

La particolarità di un campo NULL sta proprio nel suo valore "speciale". Per tale motivo, se viene eseguita una query cercando una stringa vuota, i campi alpha/text contenenti il valore NULL non saranno presi in considerazione: questo significa che per trovare tali record è necessario scrivere del codice aggiuntivo.
Per evitare tali problematiche è possibile attivare nelle proprietà del campo l'opzione Map NULL values to blank values; questa, infatti, agisce a un livello molto basso del database, poiché assimila i valori NULL ai valori di default (stringa vuota, data 00/00/00, ecc.) del relativo campo.
Questa opzione è sempre attiva in automatico per ogni campo.

Quando si gestiscono dei valori NULL, 4D esegue in automatico delle conversioni quando questi valori vengono usati.
Se viene infatti eseguita l'istruzione:

miaAlphavar:=[table1]MioAlphafield

la variabile miaAlphavar prenderà il valore "".
In generale, le conversioni a tali valori di default vengono eseguite secondo questo schema:

• Per Alpha e Text: ""
• Per Real, Integer e Long Integer: 0
• Per Date: 00/00/00
• Per Time: 00:00:00
• Per Boolean: False
• Per Picture: immagine vuota
• Per Blob: blob vuoto

E' possibile spegnere automaticamente il computer utilizzando il comando LAUNCH EXTERNAL PROCESS.
Il comando deve essere eseguito nel "On Exit" (se serve distinguere fra versioni monoutente, client o server, e in caso usare "On Server Shutdown") così:

LAUNCH EXTERNAL PROCESS("shutdown -s -t 100";$tIn;$tOut)

attendendo 100 secondi prima di spegnere la macchina (un tempo ragionevole per pensare che 4D sia uscito). Se si aggiunge il parametro -f:

LAUNCH EXTERNAL PROCESS("shutdown -s -t 100 -f";$tIn;$tOut)

Windows forzerà la chiusura dei processi.


Se mentre il sistema si sta chiudendo ci si ricorda che c'era qualcos'altro da fare, nel database method "On Sturtup" si può inserire:

LAUNCH EXTERNAL PROCESS("shutdown -a";$tIn;$tOut)

per annullare un precedente spegnimento avviato.

Il formato è la stringa di testo del tipo "###.###,00" con cui puoi modificare la modalità di visualizzazione di un numero (c'è anche per data, ora, booleano)

Mentre fino alla versione 2004 nel formato il punto e la virgola rispecchiavano le impostazioni del sistema corrente, nella versione v11 (finalmente!) il punto sta sempre per la posizione dei decimali e la virgola per il separatore delle migliaia.

Cioé rende il programma facilmente utilizzabile anche in quegli ambienti dove si usano impostazioni 'americane' pur trovandosi in italia, ad esempio.

Questa impostazione è di default per le strutture create con la v11, mentre per quelle convertite dalle versioni precedenti esiste l'opzione Use period and comma as placeholders in numeric formats in Preferenze - Design Compatibility.

Se nella v11SQL viene eseguito il codice

OUTPUT FORM([Tabella];"Output")

e il form non esiste, 4D restituisce errore, a differenza della versione 2004, dove il form poteva anche non esistere.

Sarà pure una cosa scontata, ma ordinando un campo booleano in maniera crescente vengono visualizzati prima i valori "False" e poi i "True"

Due grosse novità:

1) si può stampare la listbox, anche su più pagine


2) posizionamento per coordinate degli oggetti in fase di stampa

La sequenza da fare è:

- OPEN PRINTING JOB
- seleziono una maschera con OPEN PRINTING FORM
- stampo il singolo oggetto con Print Object

Ecco alcune delle novità del nuovo Code Editor:

• uso del // per il commento
• zoom sul testo
• autocompletamento dei comandi Sql, delle tabelle e campi anche in sql
• autocompletamento delle variabili locali, proposte automaticamente nelle dichiarazioni
• il Selection to array (fino a 128 parametri) può essere splittato su più righe con il backslash
• si possono impostare bookmark con il ctrl-tasto di funzione
• evidenziazione delle modifiche in giallo, in verde quando sono salvate
• il breakpoint segue la riga dove è stato messo
• modalità di correzione delle maiuscole delle variabili (ad es in camelCase
• collapse di codice selezionato, tag con anteprima

Il file .4DLINK è il nuovo tipo che di file che consente di aprire i database 4D.
In linea generale sostituisce il file .PTH che consentiva di aprire un 4D Client con le opzioni utente memorizzate, ma in realtà contiene un numero molto maggiore di opzioni.

Il file si trova nella cartella:

• Windows Vista: C:\Users\UserName\AppData\Roaming\4D\Favorites v11\
• Windows XP: C:\Documents and Settings\UserName\Application
Data\4D\Favorites v11\
• Mac OS: Users/UserName/Library/Preferences/4D/Favorites v11/

dove UserName è il nome dell'utente del sistema.

Il file 4DLINK è un file XML che nella sua forma più semplice si presenta così:

<?xml version="1.0" encoding="UTF-8"?>
<database_shortcut structure_file="file:///C:/mio.4DB"
data_file="file:///C:/mio.4DD"/>

All'interno del file è possibile inserire tutta una serie di attributi, come ad esempio nome utente e passoword:

<?xml version="1.0" encoding="UTF-8" standalone="no" ?>
<database_shortcut is_remote="true" password="123"
server_database_name="Contabilità" server_path="contabilita.dominio.it"
user_name="Steve"/>

Dalla versione 11.5 è presente un documento vicino alla struttura chiamato nome_database.Match .

Il nuovo file è creato per collegare i numeri delle tabelle e il loro corrispondente UUID; è richiesto per ripristinare un database danneggiato. Non cancellarlo, è aggiornato ogni volta che c'è una modifica alla struttura.

E' ovviamente il caso di aggiungere questo documento alla lista dei file che saranno automaticamente salvati durante il backup automatico.

La novità che ha richiesto il maggior tempo di sviluppo nella v12 SQL è la possibilità di utilizzare php all'interno di 4D col comando il cui nome provvisorio è PHP Execute.

4D integra (a momento) il motore PHP versione 5.3, ma è possibile anche utilizzare anche un interprete PHP esterno.

Molte delle librerie standard sono già incluse e già utilizzabili (l'elenco delle librerie built-in sarà descritto sul manuale).

Questo permette di passare da sistemi MAMP (Mac, Apache, MySQL e PHP) o WAMP (Windows, Apache, MySQL e PHP) a sistemi M4^DP o W4^D, in cui 4D evita l'installazione e manutenzione di tre componenti.

Quando viene eseguito il trigger per l'evento On saving new record, se si usa il comando Record number la v11 SQL restituisce il record number assegnato al record, a differenza della 2004 che restituiva come record number "-3".

Una delle funzioni della v11 che facilmente può sfuggire è il fatto che agli oggetti oltre ad assegnare una variabile è possibile assegnare un'espressione.

Cosa significa? Ad esempio, in una lista l'oggetto potrebbe al posto della variabile contenere [tabella]cognome+" "+[tabella]nome per andare a sostituire i due campi relativi.

Oppure, sempre in una lista l'oggetto potrebbe essere un termometro e si può scrivere qualcosa del genere [tabella]quantità/vTotale".

Per cose più complesse, del tipo in funzione di un valore numerico cambiare una descrizione, si può accoppiare con il comando Choose, anch'esso probabilmente sfuggito ai più; esempio:
Choose(Day number([tabella]giorno);"Dom";"Lun";"Mar";"Mer";"Gio";"Ven";"Sab").

Con la v11 SQL i comandi QUERY BY FORMULA e QUERY SELECTION BY FORMULA richiedono obbligatoriamente come parametro la tabella su cui eseguire la query.

Come già detto, per migliorare le prestazioni questi comandi vengono eseguiti sul Server quando vengono eseguiti da un Client. Inoltre è stato implementato un sistema di ottimizzazione delle QUERY BY FORMULA per migliorarne ulteriormente le prestazioni.

Se ho un testo molto lungo e voglio tagliarlo su più righe di massimo 80 caratteri, ma tagliate dove c'è un separatore tipo spazio o punteggiatura, si può usare questo codice:

$Pat_T:="(?:[^\\p{C}]{1,72})(?:$|\\p{Z})"
ARRAY TEXT($Fold_aT;0)
$Start_L:=1
$FoundAt_L:=0
$Length_L:=0
$Bool_B:=Match regex($Pat_T;$Buf_T;$Start_L;$FoundAt_L;$Length_L)
While ($Bool_B)
  APPEND TO ARRAY($Fold_aT;Substring($Buf_T;$FoundAt_L;$Length_L))
  $Start_L:=$FoundAt_L+$Length_L
  $Bool_B:=Match regex($Pat_T;$Buf_T;$Start_L;$FoundAt_L;$Length_L)
End while

cfr Use Match regex to fold or split text into strings of a maximum length

Prima della disponibilità dei campi di tipo Blob era usuale registrare nel campo Picture anche dati che non fossero immagini.

Però registrando delle immagini 4D accodava 6 byte con la posizione e la modalità di visualizzazione dell'immagine: durante l'aggiornamento della base dati alla v11, 4D elimina questi 6 byte in fondo ai dati registrati nei campi Picture.

Nel caso in cui non si tratta di immagini questo costituisce sicuramente un problema: per risolverlo basta cambiare il tipo del campo da Picture a Blob.

Dalla versione v11 è stato aggiunto un ulteriore parametro al comando CALL WEB SERVICE; la sintassi adesso è:

CALL WEB SERVICE (accessURL; soapAction; methodName; namespace{; complexType{; *}})

L'* finale può essere usato per ottimizzare le chiamate. Quando viene passato, il comando non chiude la connessione usata dal processo alla fine dell'esecuzione. In questo modo la successiva chiamata CALL WEB SERVICE riutilizzera la stessa connessione, finché verrà usato l'* finale.

Il meccanismo accelererà in modo notevole le sequenze di chiamata allo stesso server, soprattutto via Internet, sempre che il Web Server chiamato abbia attivo il "keep-alive".

Se il server non ha l'opzione attiva o se si raggiunge il limite massimo di chiamate nella connessione, 4d si occuperà automaticamente di riaprire una nuova connessione quando serve.

Come già citato, il file Catalog.xml permette di mantenere durante la conversione da 2004 a v11 gli stessi codic identificativi usati nella base dati.

Il file è generato automaticamente durante la conversione e andrebbe salvato per poter riutilizzare.. Nel caso si fosse perso, per rigenerarlo basta:

- Andare in Design nella struttura già convertita in v11
- Scegliere dal menù File il comando "Export Structure to xml"
- Rinominare il file così creato in Catalog.xml

Per utilizzarlo basta metterlo allo stesso livello della struttura in 2004 da convertire.

Esporta in un file di testo con la descrizione della struttura corrente; include il numero di record, le relazioni con indicazioni se automatiche Molti a Uno o Uno a Molti.

C_LONGINT($TabellaNumero;$tabella;$campo;$lunghezza;$tipo)

$cr:=Char(Carriage return )
$doc:=Create document("")
If (ok=1)
  GET TABLE TITLES($Tabelle_nomi;$Tabelle_numeri)
  SORT ARRAY($Tabelle_nomi;$Tabelle_numeri)
  For ($tabella;1;Size of array($Tabelle_nomi))
    $TabellaNome:=$Tabelle_nomi{$tabella}
    $TabellaNumero:=$Tabelle_numeri{$tabella}
    SEND PACKET($doc;$cr+"TABLE "+$TabellaNome+" ("+String(Records in table(Table($TabellaNumero)->))+")"+$cr)
    For ($campo;1;Count fields($TabellaNumero))
      GET FIELD PROPERTIES($TabellaNumero;$campo;$tipo;$lunghezza)
      Case of
        : (($tipo=Is LongInt ) | ($tipo=Is Integer ))
          $tipo:="Long"
        : ($tipo=Is Real )
          $tipo:="Real"
        : ($tipo=Is Alpha Field )
          $tipo:="Alfa "+String($lunghezza)
        : ($tipo=Is Text )
          $tipo:="Text"
        : ($tipo=Is Boolean )
          $tipo:="Bool"
        : ($tipo=Is Date )
          $tipo:="Date"
        : ($tipo=Is Time )
          $tipo:="Time"
        : ($tipo=Is Picture )
          $tipo:="Pict"
        Else
          $tipo:="blob "+String($tipo)
      End case
      GET RELATION PROPERTIES($TabellaNumero;$campo;$oneT;$oneF;$cf;$autoOne;$autoMany)
      If ($oneT=0)
        $relazione:=""
      Else
        $relazione:="-> ["+Table name($oneT)+"]"+Field name($oneT;$oneF)+(Num($autoOne)*"A1")+" "+(Num($autoOne)*"AM")
      End if
      SEND PACKET($doc;Char(Tab )+$tipo+Char(Tab )+Field name($TabellaNumero;$campo)+Char(Tab )+$relazione+$cr)
      
    End for
  End for
  CLOSE DOCUMENT($doc)
  ALERT("finito")
End if

Usa questo comando per mostrare la finestra standard del sistema operativo di scelta del colore.



Un primo parametro serve a preimpostare un colore nella finestra (il default è il nero), mentre il secondo permette di indicare una stringa come titolo (il default è "Colors")

A partire da Windows Vista e quindi su tutte le versioni successive di Windows (ad esempio Windows Server 2008) non è possibile interagire con un applicativo lanciato in modalità servizio (cfr. Service Changes for Windows Vista )

La soluzione (da 4d v11 in poi) è lanciare il Client sulla stessa macchina e usare la finestra di Amministrazione per controllare il server.

Oppure per non usare 4d come servizio è possibile fare in modo che sia lanciato all'avvio in modalità normale seguendo queste istruzioni:

1. impostare il login automatico di un utente

2. creare un file autostart.4DLink
<?xml version="1.0" encoding="UTF-8"?><database_shortcut structure_file="file:///C:/4D/miaApp.4DB" data_file="file:///C:/4D/miaApp.4DD"/>

3. creare un file .bat che lanci il 4d Server e il relativo .4DLink
"C:\4D v11 SQL Release 4 Custom\4D Server\4D Server.exe" "C:\autostart.4Dlink"

Con l'ultima versione di 4D non è più disponibile 4d Open, molto utilizzato per scambiare i dati fra diversi server 4d.

Le opzioni disponibili oggi sono:

1. SQL Pass-trough, cioè diretto senza passare da driver odbc
2. Web Services, utilizzando il protocollo SOAP
3. HTTP, scambiando file XML

In linea generale il consiglio di 4d è di usare nell'ordine

Sincronizzazione -> SQL, XML, SOAP

Divisione di operatività -> SOAP, SQL, XML

Applicazioni distribuite -> SQL, SOAP, XML

Per maggiori informazioni, potete scaricare la White Paper 4D Data Exchange v11 nella sezione delle Brochure 4D

Quando si danneggia un indice della struttura 4d v11.x mostra una finestra con un messaggio "PR4D resource damaged and no previous version available!".

Gli indici della struttura sono conservati nel file .4dIndy, quindi per risolvere il rpoblema basta eliminare il file e farglielo ricostruire al prossimo riavvio di 4d.

Durante la creazione di un'immagine SVG, è molto importante per gli sviluppatori avere la possibilità di vedere velocemente l'immagine che stanno creando.

E' possibile salvare l'xml in una variabile o esportarlo in un file esterno (e poi visualizzarla usando ad esempio un browser moderno); oppure 4D mette a disposizione una finestra SGV Viewer dove vedere il risultato al volo.

Per vedere questa finestra bisogna chiamare il comando SVGTool_SHOW_IN_VIEWER del componente 4D SVG fornito con 4d SQL v11.

Supponiamo di fare il seguente assegnamento:

$stringa:="\"a\""

La variabile $stringa ha un comportamento al quale è necessario fare attenzione: se la si usa per fare un confronto o un assegnamento il suo valore sarà «"a"», ma il valore di Length($stringa) è 3 (perché formata da 3 caratteri) e non 5 come si potrebbe supporre.

Dalla versione 11.3 è stato implementato lo schema di sicurezza per l'accesso ai dati da SQL language; l'autenticazione è fatta nel metodo del database "On Sql Authentication" che però richiede necessariamente di eseguire il comando CHANGE CURRENT USER.

Il metodo seguente valida nome e password dalla lista degli utenti standard di 4d; in realtà si potrebbe creare un utente generico "utente_sql" e usare quello nel comando successivo.

C_TEXT($1;$2;$3)
C_BOOLEAN($0)

$nomeutente:=$1
$password:=$2
$0:=False

GET USER LIST($atListaUtenti;$alListaID)
$quale:=Find in array($atListaUtenti;$nomeutente)
If ($quale>0)
  If (Validate password($alListaID{$quale};$password)
    CHANGE CURRENT USER($nomeutente;$password)
    $0:=True
  End if
End if

Per i campi numerici interi (Integer, Long Integer e
Integer 64 bits) è possibile utilizzare un nuovo (dalla v11.2) flag "Autoincrement" che genera automaticamente un ID unico nei vari record. Il campo non è più modificabile o inseribile né dall'utente né da programma.

Il numero è sempre unico, mai riutilizzato, e se generato in una transazione poi annullata viene perso.

Da notare che se viene attivato su una tabella che abbia già dei record il numero parte dal numero totale dei record +1; in questo modo prima di applicarlo alla struttura è possibile rinumerare i record precedenti per avere una sequenza corretta.

In ambiente User (che nella v11 è integrato con l'ambiente Design ) premendo control-maiuscolo quando il puntatore si trova su un oggetto campo o variabile, appare un tip con alcune informazioni:

• il nome dell'oggetto
• il posizionamento fisico (alto, sinistra, larghezza, altezza)
• il nome della variabile o il numero di tabella e di campo

Per avere l'anteprima di stampa di un rapporto di statistica creato con i comandi di Quick Report, è necessario aggiungere il comando:

QR SET DOCUMENT PROPERTY($ID;1;1)

dove $ID è l'id dell'area Quick report, i due "1" rappresentano la proprietà "qr printing dialog" e la richiesta di mostrare la dialog stessa

Dovendo implementare una comunicazione fra un sito sviluppato con Joomla come CMS e dei dati memorizzati su un database 4D v11 SQL è possibile che i caratteri Unicode inviati da 4D al sito (tipo le lettere con accenti) non vengano visualizzati correttamente, malgrado il database mySQL interfacciato con Joomla sia UTF8 e nell'installazione la scelta della lingua sia stata italiano.

Per correggere il problema:
- entrare nella cartella "language" presente nella root di installazione di Joomla
- all'interno di ogni cartella riferita ad uno specifico linguaggio ("it-IT", "en-GB", ecc.) individuare il file "linguadiinterfaccia.xml", dove linguadiinterfaccia è una stringa identica al nome della cartella che lo contiene.
- individuare la riga "winCodePage" e sotituire il set "iso-8859-1" con "UTF-8"

A questo punto i caratteri speciali, tipo le lettere accentate, sono visualizzati correttamente.

Ecco una breve descrizione su com'è fatto Sviluppo4d.it:

Il software è un programma scritto in 4d SQL v11.

L'applicazione è una Monoutenza con la licenza Web Application Server; la versione non commerciale ha un costo di 106 Euro, ma questa ci è stata fornita da 4d con l'intercessione di Italsoftware (grazie a Dominique e Massimo!)

Le pagine web vengono servite e costruite direttamente da 4D e sono una decina di template in html e cinque include per testata, piede, colonne sinistra e destra e striscia di navigazione.

Le pagine robots.txt e sitemap.xml sono interamente dinamiche.

L'hardware è un MacMini G4 1.42GHz con Mac OS X.

Per un aggiornamento di quale versione di 4d è attiva usate l'url speciale 4dwebtest .

Nel caso in cui preparate un file in formato XML elaborandolo in formato testo (e quindi non utilizzando i comandi XML 4d) occorre verificare che i testi da utilizzare siano formattati in modo da evitare alcuni caratteri speciali.

  `metodo web_xmlEncode

$stringa:=$1

$risultato:=Replace string($stringa;"&";"&amp;")
$risultato:=Replace string($risultato;"'";"&apos;")
$risultato:=Replace string($risultato;"\"";"&quot;")
$risultato:=Replace string($risultato;">";"&gt;")
$risultato:=Replace string($risultato;"<";"&lt;")

$0:=$risultato

Volendo modificare il titolo di una colonna di una listbox, supponendo che il titolo si chiami "Header1", basta inserire questo codice nel form method:

Case of
  : (Form event=On Load )
    BUTTON TEXT(Header1;"ID Telematizzazione accise")
    BUTTON TEXT(Header2;"Codice Deposito commerciale")
End case

e così via.

Nella nota precedente sull'argomento e' stata intrapresa la strada di creare una nuova tabella e trasportarvi i dati della vecchia subtable assegnandogli la relazione nuova.

Secondo me molto difficile da realizzare in quanto bisgna crearsi una pocedura che converta tutte le vecchie subtable in tablelle e poi eventualmente cancelli quelle vecchie inutilizzate.

Io credo di aver trovato un sistema più veloce.

Ho notato che il centenuto del campo in relazione non è altro che il numero del record della tabella in relazione + 1

Eliminate la relazione di tipo subtable (non più ricreabile), i campi ora assumono valore di longint.
Ora con una query potrete ottenere i record correlati tipo

$recnum:=Record number([Tabella_principale])+1
query([Tabella_relazione];[Tabella_relazione]id_added_by_converter=recnum)

Oppure

Ricreare la relazione tra i due campi e nel campo dell'archivio principale inserire il valore del numero del record +1

Il comando Send Http Redirect in pratica dice al browser che la pagina cercata è stata "temporaneamente" spostato su un altro indirizzo: il browser in modo trasparente all'utente e anche abbastanza velocemente va a cercare il nuovo indirizzo.

Il codice seguente simula la chiamata Send Http Redirect con codice 4d:

`Metodo web_sendHttpRedirect

C_TEXT($1; nuovo_url)
$nuovo_url:=$1

ARRAY TEXT($atHeaders;3)
ARRAY TEXT($atValues;3)
$atHeaders{1}:="X-VERSION"
$atValues{1}:="HTTP/1.0"
$atHeaders{2}:="X-STATUS"
$atValues{2}:="302 Moved Temporarily"
$atHeaders{3}:="Location"
$atValues{3}:=$nuovo_url
SET HTTP HEADER($atHeaders;$atValues)

SEND HTML TEXT($nuovo_url)

4D v11 SQL ha introdotto la nuova caratteristica dello UUID per il database.

Eccone alcune caratteristiche.
- Una struttura può aprire più data file, purché tutti abbiano lo stesso UUID della struttura.
- Struttura e file dati possono essere convertiti separatamente (in questo ordine). Possiamo cioè convertire noi la struttura alla v11 SQL e inviarla al cliente; questi aprirà la struttura nuova con il file dati che aveva precedentemente (in versione 2004, 2003, ecc.) e anche questo verrà immediatamente alla v11 SQL senza problemi di UUID.

- Un file dati non può essere aperto da strutture diverse, dove per diverse è da intendere "che abbiano UUID diversi", non "differenti copie della stessa struttura": infatti queste hanno sempre lo stesso UUID.

Per allegare le immagini nelle mail bisogna guardare il protocollo di creazione delle mail ( cfr http://www.faqs.org/rfcs/rfc2557.html ).

Non è che sia semplicissimo, ma spiegazioni ed esempi si trovano molto facilmente in internet. Il nocciolo della questione è che le immagini devono essere trasformate in testo e aggiunte alla mail principale. Bisogna ricordare di aggiungere anche una versione in solo testo per chi usa un lettore di mail che non visualizzi l'html.

Il problema principale è che le mail in html vengono lette dai lettori di posta anche se non sono formattate bene seguendo gli standard; quindi occorre provarne più tipi (gmail, thunderbird, mail pre e post 10.4, outlook express, entourage.. )

C'è un'alternativa, mandi la mail in html e tieni le immagini su un sito.

Il vantaggio in questo caso è che la mail è piccola, lo svantaggio è che le immagini sul sito ci devono stare finché si pensa che l'utente possa riaprire la stessa mail.. quindi dipende molto dal tipo di mail.

Programmando sotto Windows, per aprire e chiudere le parentesi graffe, solitamente premo il tasto ALT a sinistra della barra spaziatrice e scrivo sul tastierino numerico in sequenza le cifre 123125.

Risulta comunque scomodo sui portatili, dove l'accesso ai NumPad è solitamente condizionato o dall'utilizzo di una "Function key" o dall'attivazione dell'emulazione NumPad sulla tastiera tradizionale.

Recentemente, usando un compilatore Java (linguaggio di programmazione che fa largo uso di graffe), ho scoperto che esiste un altro modo per ottenere lo stesso risultato:
premere il tasto AltGr a destra della barra spaziatrice, il maiuscolo e i due tasti indicanti le parentesi quadre: anche così si ottiene {}

Ecco un elenco completo.

graffa aperta	graffa chiusa	sistema
ALT_GR+7	ALT_GR+0	GNU Linux
ALT_GR+8	ALT_GR+9	GNU Linux
ALT+123	ALT+125	Microsoft Windows
ALT_GR+SHIFT+è	ALT_GR+SHIFT++	Microsoft Windows - GNU Linux
ALT+CTRL+SHIFT+è	ALT+CTRL+SHIFT++	Microsoft Windows
⌥⇧è	⌥⇧+	Mac OS (con il layout Italiano - Pro)

Quando importiamo dentro il nostro codice il codice generato in automatico dal "Build 4D Code" del Wizard del Quick report, sono due le modifiche solitamente da apportare

- Creare una offscreeen area per $ID con
$ID:=QR New offscreen area
e aggiungere dopo il QR Run un
QR DELETE OFFSCREEN AREA($ID)

- Se si sono inserite delle concatenazioni delle stringhe (tipo Codice_fornitore+"_"+Ragione)
il codice risultante sarà:

QR INSERT COLUMN($ID;1;"[Fornitori]Fornitore+\\\"_\\\"+[Fornitori]Ragione")
QR SET INFO COLUMN($ID;1;"Fornitori";"[Fornitori]Fornitore+\\\"_\\\"+[Fornitori]Ragione";0;-152;0;Char(0))

bisogna rimuovere la tripla "\" con una sola, così:

QR INSERT COLUMN($ID;1;"[Fornitori]Fornitore+\"_\"+[Fornitori]Ragione")
QR SET INFO COLUMN($ID;1;"Fornitori";"[Fornitori]Fornitore+\"_\"+[Fornitori]Ragione";0;-152;0;Char(0))

Abbiamo visto in varie faq l'uso di LAUNCH EXTERNAL PROCESS.

Ribadiamo che è utilizzabile non solo per l'esecuzione di applicazioni o file batch, ma per qualsiasi comando (anche con parametri) del Terminale Apple MacOSX o del Prompt dei comandi Windows.
Non può però eseguire comandi della shell (tipo il comando echo)

Possiamo quindi scrivere direttamente:

LAUNCH EXTERNAL PROCESS ("chmod +x /cartella/miofile.ese")

per cambiare i permessi ad un file MacOS X.

Il comando è di default Sincrono, cioè 4d aspetta che sia eseguito.
Se si volesseeseguirlo in modalità asincrona è necessario lanciare prima il comando
SET ENVIRONMENT VARIABLE con l'opzione _4D_OPTION_BLOCKING_EXTERNAL_PROCESS.

Ultimamente ho dovuto analizzare alcuni protocolli per la comunicazioni con i registratori fiscali.

Ho provato il protocollo XON-XOFF, uno standard per molte casse. La comunicazione si svolge utilizzando degli stream di testo con dei separatori che indicano il tipo di dato. Un protocollo di questo tipo, proprio perché standard, non gestisce però le caratteristiche proprietarie del singolo registratore.

Dovendo in particolare usare i registratori di cassa Kube F della Custom Engineering, ho potuto verificare come utilizzare il protocollo di comunicazione proprietario della cassa fiscale risulta più difficoltoso per la quantità di parametri da gestire, ma consente d'altra parte una gestione completa e accurata della transazione.

Sto ancora guardando se sia un bug o un problema del mio codice, intanto, per sicurezza, pubblico il workaround.

Mi capita, lavorando con file di testo Unicode, che il comando BLOB TO TEXT eseguito dopo il DOCUMENT TO BLOB mi restituisca un testo vuoto.

Per evitare questo problema, ho deciso di agire differentemente: in una offscreen area di 4DWrite apro il file; da qui trasferisco il testo nella variabile 4D che veniva lasciata vuota dal BLOB TO TEXT.

Capita in alcune comunicazioni seriali che il comando SEND PACKET non venga interpretato correttamente o restituisca risposte strane.
Una buona idea può essere quella di "pulire" la comunicazione seriale prima del SEND PACKET con un RECEIVE BUFFER. Il codice diventa:

RECEIVE BUFFER($buffer)  ` pulisci la seriale
SEND PACKET($Comando)

Un rapido esempio per misurare le prestazioni di un metodo contando il numero di millisecondi:

$vrMillisecondsStart:=Milliseconds

`qui fai qualsiasi cosa

ALERT("Tempo trascorso: "+String(Milliseconds-$vrMillisecondsStart))

Oltre a Milliseconds, si possono usare equivalentemente anche Current time o Tickcount.

Il pacchetto 4d Web 2.0 Pack contiene varie cose, fra le quali anche la libreria Ajax Framework ..

Per vedere una demo ben spiegata è possibile guardare gli esempi on line su questo sito, dove ci sono le tecniche da utilizzare:

http://demo.4d.com:8081/

Una demo di un'applicazione web 2.0 completa (con tecniche particolari come il drag & drop) si trova a questo indirizzo:

http://demo.4d.com:8081/demos/wow/personal_planner.html

Infine sono disponibili due modi per costruire applicazioni per iPhone/iPod touch.

1. Opzione Zero Codice: guarda questo esempio con iPhone/iPod touch su questo link:
   http://demo.4d.com:8081/ipe.html
   
   
2. Opzione personalizzabile: guarda questo esempio con iPhone/iPod touch su questo link:
   http://demo.4d.com:8081/ipedemo/index.html
   

In queste ultime demo si vede anche l'opzione Offline, perché sono incluse le tecniche per far funzionare tutto anche quando non si è collegati, usando Html 5 o le librerie Google Gears,

Safari 3 e Firefox 3 supportano HTML 5. Gli utenti di Internet Explorer 7 e Firefox 2+ devono installare Google Gears per andare offline.

4D dà le coordinate di un click sulle immagini nelle due variabili di sistema MouseX e MouseY: contengono il numero di pixel di distanza dal punto in alto a sinistra dell'immagine (0,0).

La cosa veramente interessante è che se l'immagine è mostrata con il formato "Truncated non-centered" le coordinate sono corrette automaticamente in funzione anche di eventuale zoom o spostamento dell'immagine nel riquadro che la ospita.

Le due variabili vanno valutate all'interno di un form event On Clicked oppure On Double Clicked.

Scritto in parole povere e per programmatori che vogliono sapere il succo della cosa:

Web 2.0 è in linea di massima il sistema di far funzionare una pagina del browser come se fosse un'applicazione senza doverla ricaricare, com'è normale nella navigazione web. Quindi l'utente rimane nella stessa finestra e la sensazione è più simile a quella di un applicativo in locale.

Ajax utilizza pagine html, css e javascript : le singole chiamate al sito sono processate all'interno del codice javascript con un comando che fa la richiesta al server e aspetta la risposta senza appunto cambiare pagina.

Flex è un sistema di Adobe per fare la stessa cosa in modo più veloce perché usa il Flash come se fosse un runtime; però bisogna usare actionscript e pagine mxml e compilare ogni volta che si fa una modifica producendo dei file swf. Il vantaggio oltre alla velocità di esecuzione è che il risultato è molto più browser indipendente.

Entrambe le soluzioni in teoria non costano niente, perché usano librerie software opensource. Anche l'SDK di flex è opensource e scaricabile gratuitamente, Adobe vende il sistema di editing (basato sul progetto opensource Eclipse) che rende più agevole il ciclo di produzione.

4d per entrambe le soluzioni ha preparato delle librerie o framework (che credo siano distribuite dentro 4d Web 2.0 Pack) che permettono di utilizzare nel modo più diretto possibile sia con la versione 2004 che con la v11.

Alcune info aggiuntive sugli indici della v11.
Il sistema di realizzazione del keyword index non è personalizzabile al momento, ma lo sarà.

Se si usa QUERY su un campo indicizzato sia normalmente che con keyword index, quest'ultimo indice ha la precedenza (la ricerca verrà fatta sulle parole).

Con il keyword index non si può usare la sintassi "@TESTO@", ma si può usare quella "TESTO@".

Al momento, se si sceglie come tipo di indice "Automatic", 4D userà il cluster per i booleani, il BTree per gli altri campi, ma nelle versioni future l'algoritmo di scelta dell'indice verrà raffinato.

Mi capitava spesso di assistere ad un comportamento strano di 4D. Facendo doppio clic sulla struttura da aprire, il programma restava per circa un minuto in uno stato di attesa senza alcun apparente motivo. Passata questa attesa il programma si apriva regolarmente. Allo stesso modo, l'apertura della finestra di impostazioni di stampa aveva gli stessi tempi d'attesa.

Il motivo è da ricercare nei driver di stampa delle stampanti in rete. Se la stampante predefinita del computer in questione è una stampante condivisa proveniente da un'altra macchina o da un print server, con alcuni driver si hanno i tempi di attesa descritti.

Una soluzione può essere quella di utilizzare come stampante predefinita una stampante "falsa", e poi scegliere la stampante corretta in funzione della stampa richiesta.

Il comando ONE RECORD SELECT usa la sintassi:

ONE RECORD SELECT {(table)}

e permette di ridurre la selezione della tabella table (se omessa è la default table) al record corrente. Se non esiste un record caricato in memoria o non esiste un record corrente il comando non ha effetto.

CT SET LABEL ATTRIBUTES permette di impostare la modalità di visualizzazione delle etichette.
La sintassi è:

CT SET LABEL ATTRIBUTES (area; object; axis; position; orientation; format{; frequency})

dove:
- area è l'area di Chart
- object è il grafico
- axis è l'asse su cui agire:
      0 = Category
      1 = Series
      2 = Values
- position è la posizione dell'etichetta:
      -1 = No modifica
      0 = Nessuna
      1 = Sopra
      2 = Sinistra
      3 = Sotto
      4 = Destra
- orientation è l'orientamento:
      -1 = No change
      0 = Normal
      1 = Vertical
      2 = Rotated right
      3 = Rotated left
      4 = Staggered
      5 = Wrap around
- format è una stringa che imposta il formato di visualizzazione
- frequency è un intero (opzionale) che specifica ogni quanti valori visualizzare l'etichetta; il parametro è molto utile per i grafici molto "densi".

Ecco ad esempio come visualizzare le etichette sull'asse X ogni 3 valori:

CT SET LABEL ATTRIBUTES (Area;$Chart;0;-1;-1;"";3)

Con la nuova versione di 4D sono scomparsi i file .RSR e .4DR.

Per essere più precisi, in realtà dei file di risorsa personalizzati possono essere creti e mantenuti all'interno della Cartella Resources presente sia nella cartella contenente la struttura che nella cartella dell'applicazione 4th Dimension.

Con la nuova verione di 4D il sistema di indicizzazione è cambiato radicalmente.

Gli indici sono memorizzati in due file separati:
- il file .INDX è il file che contiene gli indici per i dati;
- il file .INDY è il file che contiene gli indici per la struttura.

I file si trovano o nella cartella del database (su Windows) o nel package del database (su Mac).

Questo approccio ha dei vantaggi non indifferenti:
- non viene eseguito un backup degli ndici;
- un indice danneggiato non danneggia i dati;
- per ricreare tutti gli indici basta cancellare il file INDX: alla successiva apertura del database 4D cercherà il file e, non trovandolo, lo creerà nuovamente in autimatico.

Dalla versione v11 ci sono alcune novità nella distribuzione degli applicativi prodotti.
Innanzitutto non occorre più acquistare un engine, ma il runtime è incluso gratuitamente nel pacchetto di sviluppo.
Inoltre nel runtime Unlimited Desktop sono inclusi senza spese aggiuntive il 4D Write e il 4D View.

Ecco uno schema delle varie opzioni:

4D Interpreted Desktop
Questa licenza è inclusa nel pacchetto di sviluppo 4D Developer Standard e permette la distribuzione di applicazioni in monoutenza non compilate con il runtime 4D Desktop.

4D Unlimited Desktop
Questa licenza è inclusa nel pacchetto di sviluppo 4D Developer Professional e permette la distribuzione di applicazioni in monoutenza sia interpretati che compilati con 4D Desktop oltre che alla creazione di applicazioni incorporando la struttura nel runtime. Questa licenza include senza costi aggiuntivi le espansioni 4D Write e 4D View.

4D Web Application Server
Questa licenza permette agli sviluppatori di distribuire applicazioni compilate o interpretate con 4D Desktop che abbiano la funzionalità di Server Web e di Server Web Services.
Questa licenza include anche le funzionalità SQL Pass Through e ODBC Login per permettere al database di collegarsi ad altre fonti di dati. La licenza è venduta a postazione e non è inclusa nei pacchetti di sviluppo.

4D SQL Desktop
Anche questa licenza non è inclusa nei pacchetti di sviluppo: acquistandola gli sviluppatori possono distribuire applicazioni compilate o interpretate con 4D Desktop con la possibilità di collegarsi a fonti di dati esterne utilizzando le funzionalità SQL Pass Through e ODBC Login. Questa opzione include anche le espansioni 4D Write e 4D View.

Dalla versione 2004 il backup è stato integrato in 4D.

Quando c'è un problema, sulla schermata del Server è possibile vedere il codice dell'errore. Ecco una breve descrizione:

• 1404 : C'era una transazione aperta in un processo
  
• 1405 : Raggiunto il timeout in attesa della fine delle transazioni
  
• 1406 : Annullato dall'utente
  
• 1407 : Percorso di destinazione non valido
  
• 1408 : Errore durante il backup del file di log
  
• 1409 : Errore durante il backup di lettura dell'originale o di scrittura della copia
  
• 1410 : Non riesco a trovare la copia da verificare
  
• 1411 : Errore durante la verifica della copia
  
• 1412 : Non riesco a trovare la copia del file di log da verificare
  
• 1413 : Errore durante la verifica della copia del file di log
  
  
  
  

E' possibile accedere via ODBC a 4D, anche monoutenza, per utilizzarlo come SQL Server. Vi si può accedere da un programma come Crystal Report, Excel o anche un altro applicativo 4D.



La funzionalità può essere avviata e stoppata da menu o da linguaggio con i comandi START SQL SERVER e STOP SQL SERVER.
Comunque stoppando l'SQL Server l'engine SQL del linguaggio 4D continua a rispondere alle ricerche interne!

La porta TCP di accesso standard è la 1919, ma si può cambiare nelle preferenze.

Inoltre è possibile nello stesso pannello decidere i privilegi di accesso ai dati per gruppi di utenti:
Read Only =in sola lettura
Read/Write = in lettura e scrittura
Full = è possibile anche modificare la struttura del database

4D v11 SQL dovrebbe essere l'ultima versione di 4D in cui sarà ancora possibile utilizzare il comando del 4D Pack AP ShellExecute.

4D informa infatti che nelle future versioni di 4D non sarà più presente questo comando, egregiamente sostituito dal comando LAUNCH EXTERNAL PROCESS presente nel linguaggio di programmazione di 4th Dimension.

Per l'uso di LAUNCH EXTERNAL PROCESS rimandiamo a questa faq.

Usando Crystal Reports® con 4D è possibile avere dei problemi per i report che usano dati provenienti da più tabelle. Questo perché Crystal Reports® "non sa" come utilizzare le join all'interno e all'esterno di 4D.

Per risolvere questo problema basta cliccare, all'interno del DSN che gestisce l'origine ODBC per Crystal Reports, il pulsante "Crystal Reports® Compatibility setup...". Scelto "OK" e riavviata la macchina il problema sarà risolto.

Tale pulsante non fa altro che aggiungere alcune chiavi nel registro di sistema (del tipo NoOuterJoinEscSeq=ODBC4D).

Tali chiavi sono necessarie sia per Crystal Reports® v10 che per Crystal Reports® v11.

Ecco i limiti di 4D 2003 per i vari tipi di dati:

Date: dal 1/1/100 al 31/12/32.767;
Time: da 00:00:00 a 596.000:00:00;
Blob: fino a 2Gb;
Text: 32.000 caratteri;
Longint: da (-2^31) a (2^31)-1;
Real: ±1.7e±308 (15 cifre).

Nella versione v11 SQL sono modificati o aggiunti questi tipi:

Alpha: 255 caratteri;
Text: 2 miliardi di caratteri (2GB);
Integer 64 bit: da (-2^63) a (2^63)-1;
Float: numero reale senza arrotondamenti e conseguente perdita di precisione

Ecco elencati i limiti per una struttura 4D fino alla 2004:

Data file: 127 segmenti da 2Gb ciascuno;
Tabelle: 255;
Campi: 511 per tabella;
Record: 16 milioni di record per tabella;
Indici: 16 milioni di chiavi;
Forms; 32.000;
Metodi: 32.000 (fino a 2Gb per metodo);
Liste: 8.000 item per lista;
Sicurezza: 16.000 utenti e 16.000 gruppi;
Processi: 32.767 contemporaneamente.

Dalla versione v11 SQL i limiti aggiornati di cui abbiamo notizia sono i seguenti:

Data file: dimensione del file illimitata (il limite può dipendere dal sistema operativo)
Tabelle: 32.767;
Campi: 32.767 per tabella;
Record: 1 miliardo di record per tabella;
Indici: 128 miliardi di chiavi per tabella.

E' possibile personalizzare l'icona della finestra di login del database, dove si inserisce utente e password.

Per default, l'icona è il logo di 4D: per sostituirla, basta mettere un'immagine chiamata LoginImage.png nella cartella Resources del database, dentro la cartella .4dbase vicino alla struttura.

Il file deve essere nel formato "png" con una dimensione di 80x80 pixels

La versione di 4D v11 SQL è scaricabile principalmente tramite un installer di piccole dimensioni che scarica dai siti americano o francese l'ultima versione disponibile di quello che si seleziona.

Questa è la modalità consigliata e dovrebbe essere più sicura sia come aggiornamento che per velocità (alcune componenti interne ripetute sono scaricate una volta sola).

Gli Online installer si trovano qui:
http://www.4d.com/products/downloads/download-v11.html

Da notare che l'installer tiene in locale quello che è già stato scaricato.. quindi la sua dimensione dovrebbe automaticamente crescere. Alle successive installazioni dovrebbe scaricare solo le componenti eventualmente aggiornate nel frattempo.

Per chi invece volesse installare 4d su più macchine ottimizzando quindi il download, esiste la possibilità di scaricare i file completi, da qui:
http://www.4d.com/products/downloads/download-v11-FTP.html

I file completi sono circa 580MB nella versione Windows multilingua, e 180MB nella versione Inglese per Mac.

Ci sono tre possibilità di driver ODBC per Microsoft SQL Server per Mac OS X:

OpenLink Software dal costo di 99$

Actual Technologies dal costo di 29$

FreeTDS gratis, ma bisogna ricompilarlo su mac e la versione 0.64 ha qualche problema nell'esecuzione dei comandi tipo SQLTables (che ritorna la lista delle tabelle).

Questi driver sono tutti basati sulla libreria (o framework) chiamata iODBC, che si trova inclusa nelle installazioni dei primi due e deve essere installata a parte nel terzo caso oppure quando bisogna aggiornarla rispetto a quelle preinstallate.

Per ottenere la sola libreria iOdbc (che è gratuita) già compilata per Mac OS X si può scaricare dal sito OpenLink solo l'opzione SDK che ha appunto l'ultima versione, attualmente la 3.52.5.

Ad esempio, la versione attuale dell'Actual Technologies (v. 2.7), installi iOdbc 3.52.2 che dà degli errori durante l'uso del driver (dà la lista delle tabelle, ma non carica i dati).

Se si vuole impedire l'accesso via ODBC ad un particolare database 4th Dimension, ad esempio perché ci sono più server attivi, ma solo alcuni devono essere visibili via ODBC, è possibile negare questo tipo di connessione.

Per fare ciò bisogna deselezionare la voce "Allow 4D Open Connections" nelle database properties in questo modo:
- aprire il database via 4D Client;
- da Design aprire le proprietà del database;
- nella pagina "Data control and access" deselezionare "Allow 4D Open connection".

La modifica avrà effetto a partire dal successivo riavvio di 4D Server.

I file con estensione "PTH" (cioè PaTH, percorso) sono i file che contengono le informazioni di connessione ad un certo server. Se sulla nostra rete esistono più server è possibile creare collegamenti automatici tra un 4D Client e il file PTH da usare con quel client.
Per creare l'associazione correttamente:
- creare un collegamento al client da usare;
- aprire le proprietà del collegamento
- aggiungere alla riga "Destinazione" delle virgolette doppie prima e dopo il percorso del 4D client;
- alla riga così ottenuta aggiungere uno spazio e poi, sempre tra virgolette, il percorso del file PTH salvato.

Il collegamento così creato userà il file PTH impostato.

Usando LAUNCH EXTERNAL PROCESS per eseguire comandi esterni come ad esempio l'apertura di un file attraverso un'altra applicazione, è buona regola inserire i riferimenti ai file (l'applicazione e il file da aprire) tra doppi apici, soprattutto nel caso in cui i nomi degli stessi o delle cartelle contengano degli spazi, poiché altrimenti LAUNCH EXTERNAL PROCESS non troverà i percorsi richiesti.
Un esempio potrebbe essere:

$mydoc:="C:\\Programmi\\Microsoft Office\\Office11\\WINWORD.EXE \"C:\\Documents and Settings\\Amministratore\\Documenti\\test 2.doc\""

LAUNCH EXTERNAL PROCESS($mydoc;$tIn;$tOut)

Esiste la possibilità di abilitare la crittografia fra client e server 4d, ma in realtà le prestazioni calano notevolmente.

In linea generale le comunicazioni tra client e server 4d non sono facilmente intellegibili: mi spiego con un esempio specifico.

Su un classico sql, le query sono stringhe dove compaiono nomi di tabelle e campi, così come la risposta del server sql è sempre espressa in formato testo.

Su 4d invece il codice di comunicazione è tokenizzato e suddiviso in piccoli pacchetti per quanto riguarda i comandi (una query può essere spezzata anche in diverse righe di codice non consecutive) e i dati risultanti per quanto riguarda booleani, interi, reali, immagini e blob sono codificati e "affogati" nei singoli pacchetti.

Chiaramente il problema potrebbe comunque esserci in funzione dei dati che uno tratta: ad esempio se in un solo campo di testo tengo registrato il numero di carta di credito e il nome del proprietario allora questa informazione diventa intelleggibile (per quanto potrebbe essere spezzata su più pacchetti comunque).

Inoltre gli stessi pacchetti del protocollo interno 4d (non documentato pubblicamente) sono molto spezzettati rispetto alla normale comunicazione html; questo spiega il perchè la crittografia fra client e server diventa molto meno efficiente che nella normale navigazione su browser, appunto perché va a codificare-decodificare molti piccoli dati.

Le soluzioni più semplici per avere la sicurezza nella comunicazione dei dati su Wan sono:

- usare una vpn protetta fra i due router;
- dedicare, accanto al server, una macchina come terminal server (microsoft o citryx metaframe) dove aprire i client da remoto.

  La prima soluzione è molto meno costosa, la seconda è peraltro più efficiente perchè quasi indipendente dai cali di prestazione della rete (le uniche informazioni che passano sono alcuni dati sui pixel del video): l'unica controindicazione però del terminal server potrebbe essere il caso in cui si debba usare qualcosa di meno gestibile tramite questa tecnologia (per capirci, una seriale che controlla un registratore di cassa).

Utilizzando il comando QUERY WITH ARRAY, i record popolano la selezione SEMPRE seguendo come ordine il record number.

Il Quick Report usa il "Formula Editor" come interfaccia per metodi e comandi.
Nelle versioni precedenti era possibile utilizzare qualsiasi comando o metodo nelle formule. Con la versione 2004, con l'obiettivo di rendere più sicuri i dati, è necessario esplicitare quali sono i metodi che è consentitio inserire nelle formule, e i comandi 4D possono essere chiamati solo all'interno di metodi consentiti.

Per ammettere un metodo alla lista dei metodi utilizzabili nel formula editor si usa il comando:

SET ALLOWED METHODS($myarray)

dove myarray è un array di tipo string contenente i nomi dei metodi ammessi. E' consentito usare anche la @ come stringa joly per selezionare più metodi.

E' possibile controllare l'elenco degli array consentiti nel formula editor con GET ALLOWED METHODS(setMethodsArray). Se SET ALLOWED METHODS non è stato usato nel processo corrente, GET ALLOWED METHODS ritornerà un array di zero elementi.

I database che utilizzavano formule di vecchio tipo con le versioni precedenti dovranno essere aggiornati utilizzando i cambiamenti descritti.

Ai pulsanti dei form è possibile associare un metodo o un'azione automatica fra quelle definite da 4D.

Nel caso al pulsante vengano associati sia un metodo che un'azione automatica, verrà eseguito prima il metodo e solo dopo l'azione automatica; una possibilità comunque da tenere in considerazione in questo caso è quella di inserire il comando automatico direttamente nel metodo: ad esempio, se devo fare un Delete subrecord (nome dell'azione automatica che cancella i record selezionati in un form di output), ma prima (o anche dopo) devo eseguire del codice (ad esempio vedere se le schede sono bloccate da altri processi), si può togliere l'azione automatica dal pulsante "Cestino", e scrivere il metodo in modo che contenga, nel posto che serve, il controllo del LockedSet, l'uso dei record "highlighted" e il DELETE SELECTION.

Nel caso una base dati diventi inutilizzabile, col file log è possibile riportare una base dati alla situazione attuale in maniera "funzionante". Vediamo come fare.

- Intanto per sicurezza fare una copia della cartella contenente il programma (ad esempio, se il programma ha un link sul desktop/scrivania, basta fare tasto di destra sul collegamento, Proprietà, Trova destinazione / su Finder Archivio, Trova originale).
- Aprire 4D/4D Server e scegliere "Restore database"; utilizzare il backup più recente; i dati del backup verranno salvati in una cartella.
- Aprire il database in questa cartella. 4D chiederà di scegliere un file log. Scegliere il file log (.4DL) presente nella cartella originale del programma (o nella copia che avevamo fatto all'inizio).
- I dati del log verranno così integrati alla base dati. Chiudere 4D
- Sostituire i file dati (4DD e 4DR o .data) della cartella originale del programma con i dati presenti nella cartella di backup e il gioco è fatto.

Le cartelle Win4dx e Mac4dx nella versione 2004 continuano ad essere utilizzate per compatibilità, ma con la nuova versione la cartella che contiene i plugin è diventata unica e si chiama, guarda caso, "PlugIns".

Questa cartella può essere posizionata:
- al livello del file struttura: in questo caso i plugin installati saranno disponibili solo per quel database
- al livello dell'applicazione: in tal caso i plugin installati saranno disponibili per tutte le strutture.

Conoscendo IP del server e la porta di esecuzione, è possibile usare Telnet per conoscere il nome del database 4D in esecuzione.

Ricevendo un telnet, infatti, 4D Server risponde con il nome del database in esecuzione.

La ricerca "Find in database" permette di effettuare ricerche di stringhe anche in tutto il database (Form, Tabelle, methods, ecc.).

Su grandi database o con connessioni di rete lente (tipo wi-fi) la ricerca può essere assai lunga e durare più di quanto previsto.

Se ciò succede, la ricerca può essere interrotta molto semplicemente premendo il tasto ESC.

4D fornisce due comandi per far impostare il valore di una variabile in un processo diverso: SET PROCESS VARIABLE e VARIABLE TO VARIABLE. I due comandi, benché simili, presentano due sostanziali differenze:
- SET PROCESS VARIABLE permette di passare alla variabile di destinazione anche una espressione, invece di una variabile.
- SET PROCESS VARIABLE non permette di far passare fra i processi un array intero, ma solo elementi di array. Per far passare fra processi degli array bisogna usare VARIABLE TO VARIABLE (tranne array di puntatori e array bidimensionali, che non possono essere passati).

Entrambi i comandi non accettano inoltre:
- variabili locali come destinazione;
- elementi di array di puntatori;
- elementi di array bidimensionali.

Ecco un indice per consultare le faq di confronto su Access, FileMaker Pro e 4th Dimension

4th Dimension, MS Access e FileMaker Pro [1] NOMENCLATURA

4th Dimension, MS Access e FileMaker Pro [2] Creazione della struttura

4th Dimension, MS Access e FileMaker Pro [3] I form *

4th Dimension, MS Access e FileMaker Pro [4] La sicurezza *

4th Dimension, MS Access e FileMaker Pro [5] Inserimento nei campi **

4th Dimension, MS Access e FileMaker Pro [6] I report

4th Dimension, MS Access e FileMaker Pro [7] L'automazione

4th Dimension, MS Access e FileMaker Pro [8] Gli eventi

4th Dimension, MS Access e FileMaker Pro [9] Le variabili

4th Dimension, MS Access e FileMaker Pro [10] Programmare una multiutenza

4th Dimension, MS Access e FileMaker Pro [11] Mantenimento di un db multiutente

4th Dimension, MS Access e FileMaker Pro [12] Gestione delle transazioni

4th Dimension, MS Access e FileMaker Pro [13] Le ricerche

4th Dimension, MS Access e FileMaker Pro [14] I sistemi operativi

4th Dimension, MS Access e FileMaker Pro [15] Criteri di scelta

Quando ti colleghi ad un server con il 4D Client viene registrato un documento con il percorso nella cartella Favorites 2004.

Questa cartella si trova qui:

Windows = C:\\Documents and Settings\CurrentUser\Application Data\4D folder

Macintosh = Mac HD:Users:CurrentUser:Library:Application Support:4D
dove, il nome del disco di avvio può essere diverso da Mac HD, e al posto di CurrentUser ci sarà il nome dell'utente

Al prossimo collegamento a 4D Server, il 4D Client mostrerà prima l'elenco dei server il cui nome legge dai documenti nella cartella Favorites 2004.
Questi documenti contengono inoltre anche l'indirizzo ip del server.

Usando i comandi New process o Execute on server viene utilizzato un valore che rappresenta, in byte, la dimensione dello stack. Lo stack non è la memoria totale del processo. I processi condividono la memoria per quanto riguarda record, variabili interprocesso, ecc. Un processo usa della memoria aggiuntiva per memorizzare le variabili del processo.

Lo stack contiene il resto: la "pila" delle chiamate ricorsive, con il numero e la dimensione dei parametri e delle variabili locali, i form aperti dal processo prima della sua chiusura.

Passando database, possibilmente sviluppati inizialmente con versioni (e computer) assai datate di 4D, alla versione 2004.3 di 4th Dimension, potrebbe d'un tratto diventare assai frequente l'errore "Not enough stack space to complete the current method": cioè, nel creare il nuovo processo con New process o Execute on server, non gli si è dato abbastanza spazio nello stack.

Il problema è che nelle ultime versioni era consigliato aumentare lo stack dai vecchissimi 32K almeno a 64K o meglio 128K. In realtà le versioni precedenti alla 2004.3 aumentavano arbitrariamente la dimensione dello stack per evitare errori al programmatore dopo una conversione di struttura: questo però ha portato ad un minor controllo di quello che succede come occupazione della memoria.
Ora 4D obbedisce strettamente alle impostazioni fatte e quindi se si ha qualche chiamata con meno di 64K di stack è facile vedere questo mesaggio.

Ovvero: Statistica, rendere evidente la tendenza di una serie di valori in un grafico creato con 4D Chart

La graficazione di valori utilizzando le funzioni di 4D Chart ha lo scopo di permettere all’utente di valutare un fenomeno “a colpo d’occhio”.
Avviene spesso che i valori da rappresentare siano discontinui tanto da vanificare l’utilità del grafico, come in questo esempio che rappresenta la vendita giornaliera di un articolo



in casi come questo è indispensabile tracciare una linea di tendenza che renda evidente l’andamento dei valori, la stessa cosa che svolge la funzione “linee di tendenza” di Excel.
Una tra le più efficienti è la derivata polinomiale, ecco il risultato:



Solo ora si può apprezzare l’andamento e la tendenza dei valori.

L’equazione per il calcolo della derivata polinomiale, come è noto è

y = Ax^2 + Bx + C

dove A, B e C sono i coefficienti della parabola, che devono essere calcolati a partire dai valori noti.
Il calcolo dei tre coefficienti è la soluzione del sistema lineare di tre equazioni in tre incognite:




Il method Method_CalcoloCoefficienti che invio (in calce al presente messaggio) è l’implementazione in 4D della soluzione del sistema in tre incognite sopra enunciato e calcola i tre coefficienti a partire da un array di valori che viene passato in un puntatore.


Esempio d’uso

L’uso è molto semplice, faccio un esempio riferito ai valori di vendita giornaliera di un articolo.

Prima di tutto trasferire i valori delle vendite giornaliere in un array, per esempio vt_MioArrayVendite

chiamare il method passando il puntatore all’array dei valori Method_CalcoloCoefficienti (->vt_MioArrayVendite)

il method Method_CalcoloCoefficienti ritorna i tre coefficienti in tre variabili reali:

        vReal_Coefficiente_A
        vReal_Coefficiente_B
        vReal_Coefficiente_C

che permettono di calcolare i valori della curva di tendenza con l’equazione standard della parabola dei minimi quadrati.

Y = (vReal_Coefficiente_A*(X^2))+(vReal_Coefficiente_B*X)+vReal_Coefficiente_C

Nota bene: nel caso in cui i valori noti (passati al method) siano incongruenti e generino un sistema di equazioni indeterminato o impossibile, il valori dei tre coefficienti vengono ritornati tutti a zero. Quindi questa eventualità va prevista e gestita.

Ottenuti i coefficienti, calcoliamo i valori della curva e li memorizziamo in un nuovo array vt_Tendenza

If ((vReal_Coefficiente_A+vReal_Coefficiente_B+vReal_Coefficiente_C)#0) ` se è stato possibile calcolare i coefficienti (sistema determinato)

For ($X;1; Size of array(vt_MioArrayVendite))
        vt_Tendenza{$X):=(vReal_Coefficiente_A*($X^2))+(vReal_Coefficiente_B*$X)+vReal_Coefficiente_C
End for

Else
` non è possibile creare una linea di tendenza
End if

Ora possiamo rappresentare nel grafico sia i valori di vendita (array vt_MioArrayVendite) sia la curva di tendenza (array vt_Tendenza).

Naturalmente la curva così ottenuta premette anche di tracciare una teorica tendenza futura, prolungando i valori dell’asse X.



Clic qui per Metodo Calcolo Coefficienti Sistema lineare di 3 equazioni

Dalla versione 2004 è presente una nuova proprietà per i form, "With Constraints", che permette la gestione dei form ridimensionabili.

Nella conversione dalla versione 2003 alla 2004 tale proprietà risulta selezionata di default per i form.

Un problema che può capitare, in base alla poszione degli oggetti, è che il pulsante di chiusura venga nascosto dalla barra di scorrimento: per riportare tutto alla situazione originale basta disattivare tale proprietà.

Per chi vuole "trasportare" le proprie applicazioni ed i dati dal formato 4D Mac a Windows esiste il tool 4D Transporter.

Tuttavia, come forse qualcuno avra' gia' notato, per utilizzare questo prodotto in ambiente Mac OSX e' necessario aver installato il sottosistema Classic.

Per chi, come me, non voglia installare il sottosistema Classic e' disponibile il programma ResTransporter, rilasciato con licenza freeware.

Lo potete scaricare dalla pagina:

http://www.softrobots.de/dimension/restransporter/index.html

oppure direttamente attraverso il link:

http://www.softrobots.de/Dateien/ResTransporterX.sit

Buona conversione!

Tra le novità "nascoste", nel senso di poco segnalate, della versione 2004, ne esiste una piccolissima riguardante i form di output che può in certi rari casi diventare un problema: andiamo con ordine.

Fino alla versione 2003 le righe selezionate dei form di output venivano "colorate" di nero, utilizzando la tecnica della inversione per mostrare i colori.

Dalla versione 2004 è possibile invece utilizzare il colore di selezione di sistema: queste opportunità, se da un lato risulta molto elegante, dall'altro può rivelarsi infernale se il colore di selezione di sistema è lo stesso di quello delle scritte del form di output: in questo caso infatti il testo delle righe selezionate "scompare", poiché uniforme al colore di selezione.

Per poter utilizzare il sistema di "colorazione" precedente basta andare nelle proprietà del form, nella categoria "Form properties" e deselezionare la voce System Highlight Color

Una delle attività preferite degli smanettoni su Windows è sicuramente quella dell'overclocking, ovvero l'agire sui parametri (ma a volte anche in maniera fisica) della scheda madre.
Alcune delle tecniche più utilizzare sono la modifica dei voltaggi di funzionamento e la variazione delle frequenze di funzionamento insieme ai fattori moltiplicativi di queste frequenze.
Tali azioni sono effettuabili solo su hardware ad alta affidabilità e comportano problemi accessori, come lo stress a cui vengono sottoposti i vari componenti e il surriscaldamento che tali modifiche comportano, per non dire la possibile instabilità della macchina.
Ma allora quale vantaggio c'è nell'overclockare un computer?
Semplicemente nella possibilità di ottenere un aumento di prestazioni fino al 50% utilizzando la stessa componentistica.
Uno dei sistemi di valutazione più utilizzati per calcolare l'efficienza di un overclock è il calcolo di 1Mb o di 32MB di cifre decimali per "p greco".
Ecco il link dove scaricarlo.

Per testare la velocità di 4D con vari hardware uso solitamente il codice di questa faq su 500.000 record: ecco alcuni risultati.

Alcuni dati di partenza:
create 6361tick
withDialog 11911tick
export 1083tick

Sostituendo il processore con uno avente un 6% di MHz in più e la scheda madre con una avente un bus più veloce del 20% ecco l'incremento dei risultati:

create 5299tick
withDialog 10817tick
export 986tick

Da notare che questi dati sono praticamente identici a quelli ottenuti da un server di ultimissima generazione zeppo di RAM e doppio processore (certo, viene usato solo uno dei quattro processori visto dal sistema operativo, speriamo in 4D 2007...), meno che per il test "withDialog", visto che la scheda video non è dedicata al refresh dello schermo.

Ora, abbassando il fattore moltiplicativo del processore, alzandone di conseguenza l'FSB, e aumentando il voltaggio di memoria e scheda video, i risultati cambiano così:

GLOBAL mm:ss:tt [500000 Inter] 00:05:09, 18557tick
create 00:00:54, 3256tick
withDialog 00:01:35, 5708tick
export 00:00:13, 788tick
import 00:01:14, 4446tick
index 00:00:53, 3187tick
qryMedium 00:00:01, 61tick
qryLarge 00:00:01, 55tick
qryDouble 00:00:05, 309tick
orderSingle 00:00:00, 26tick
orderDouble 00:00:12, 721tick

Un incremento di prestazioni anche del 20% rispetto alla configurazione senza overclock!

Molto spesso, ad esempio per le comunicazioni via 4D Open, risulta necessario conoscere il numero di tabella al di fuori di un metodo.

Fra i sistemi possibili possiamo citare la possibilità di scrivere all'interno della voce Watch del Runtime Explorer "Table(->[Nome_tabella])"; oppure andare alla voce "Info su..." del menu "Help" in modalità Design, e alla voce "Database" vedere il numero delle varie tabelle.

Dalla versione 2004, il numero di tabella si trova anche nella struttura, nella finestra di Proprietà della Tabella.

Ilaria Giagnoni ha segnalato una interessante info per la stampa delle picture: per ottenere delle immagini con sfondo bianco basta che la variabile contenente l'immagine sia impostata come "enterable".

Molti sviluppatori hanno segnalato un baco della versione 2004 riguardante la tastiera su Windows: in certi casi i caratteri mostrati usando Shift+numero risultavano non coincidenti al risultato desiderato.

Il problema in realtà non esiste, in quanto si presenta solo perché la combinazione dei tasti che permette di passare in modalità User (Alt+Shift+Clic, per altre info vedere questa faq) è la stessa utilizzata dal sistema operativo per modificare in automatico, nei Servizi di testo e lingue di input, la lingua di keyboard input.

Basta dunque rimuovere le altre lingue o modificare/cancellare la combinazione di tasti di Windows per risolvere il "baco".

Vediamo qualche esempio di operatori binari, a partire dalla faq che ne descrive l'uso:

Quando si esegue un AND fra bit il risultato segue queste regole:
  1 & 1 --> 1
  0 & 1 --> 0
  1 & 0 --> 0
  0 & 0 --> 0

cioè, il risultato è 1 solo se entrabi i bit valgono 1.

Esempio: 0x0000FFFF & 0xFF00FF00 è uguale a 0x0000FF00


L'OR (inclusive) usa la seguente tabella:
  1 | 1 --> 1
  0 | 1 --> 1
  1 | 0 --> 1
  0 | 0 --> 0

cioè, il risultato è 1 se uno dei bit vale 1.

Esempio: 0x0000FFFF | 0xFF00FF00 è uguale a 0xFF00FFFF.


L'OR esclusivo invece si comporta così:
  1 ^| 1 --> 0
  0 ^| 1 --> 1
  1 ^| 0 --> 1
  0 ^| 0 --> 0

cioè, il risultato è 1 solo se UNO SOLO dei bit confrontati vale 1.

Esempio: 0x0000FFFF ^| 0xFF00FF00 restituisce 0xFF0000FF


Lo Shift a sinistra/destra sposta i bit verso sinistra/destra di un numero N di posti. I bit mancanti vengono rimpiazzati da zeri. Ciò significa che se il numero di bit da shiftare passato è maggiore di 31 il risultato dello shift sarà sempre 0x00000000 poiché tutti i bit vengono persi.
Lo Shift a sinistra/destra corrisponde a moltiplicare/dividere il numero passato per 2^N (con N numero di posti dello shift)

Esempi:
Bit Shift a sx: 0x0000FFFF << 8 restituisce 0x00FFFF00
Bit Shift a dx: 0x0000FFFF >> 8 restituisce 0x000000FF


Altri esempi sui bit operators:
Bit Set: 0x00000000 ?+ 16 restituisce 0x00010000
Bit Clear: 0x00010000 ?- 16 restituisce 0x00000000
Bit Test: 0x00010000 ?? 16 restituisce True

Il form editor della 2004 presenta molte funzioni interessanti; eccone una molto utile quando si lavora su un database disegnando o modificando molte maschere.

Quando si usa un oggetto esso presenta alcune impostazioni predefinite, come ad esempio lo stile del testo negli oggetti Label. Per cambiare queste impostazioni è possibile usare il comando "Use as Template" nel menu contestuale (control clic su Mac o tasto destro su Windows) che appare sull'oggetto che è stato definito a proprio piacere.

Con il comando SET ABOUT puoi specificare il nome del comando da menu e il corrispondente metodo da eseguire per la finestra di Informazioni standard sull'applicazione corrente.

Nel metodo si può usare il comando DIALOG; 4D aggiungerà in cima alla finestra altre informazioni come l'icona di 4D, il numero di versione di 4D e del compilatore.

Per non mostrare queste informazioni aggiuntive, basta mostrare la finestra di dialogo in un processo a parte. Se hai già il metodo che mostra la Dialog, basta aggiungere queste righe di codice:

Case of
  : (Count parameters=0)
    $Processo_l:=New process(Current method name;Maxint;Current method name;"ProcessoAParte")
  Else
    
    `Codice Originale
    $w:=Open Form Window([Tabella];"MiaAbout")
    DIALOG([Tabella];"MiaAbout")
    CLOSE WINDOW

End case

Con la versione 2004 è possibile modificare le preferenze di Database anche dall'ambiente Runtime: è possibile creare un elemento di menu e scegliere come azione automatica associata (Associated Standard action) "Preferences".

Da notare che i comandi da menu associati alle azioni Quit e Preferences sono automaticamente spostati nelle posizioni standard per il sistema operativo in cui ci si trova.

Quando si apre il 4D Client è possibile scegliere fra un elenco un degli ultimi server a cui si è fatto accesso. Questi server vengono registrati in un file che è possibile copare o eliminare da ogni singola macchina client (ad esempio eliminando quelli non più disponibili se diventano troppi).

Nella versione 2003 e 6.8 questa cartella si trovava nella cartella 4D principale, mentre nella 2004 si trova nella cartella 4D dell'utente corrente.

Windows
C:\documents and settings\(nome utente)\Application Data\4D\Favorites 2004

Mac
MacHD:Users/(nome utente)/Library/Application/4D/Favorites 2004

Gli oggetti cliccabili, quelli cioè su cui è possibile utilizzare gli eventi On Clicked e On Double Clicked, sono:

- Campi e variabili di tipo boolean
- Button, default button, radio button, check box, button grid
- 3D Button, 3D radio button, 3D check box
- Pop-up menu, hierarchical pop-up menu, picture menu
- Drop-down list, menus/drop-down list
- Scrollable area, liste gerarchiche, list box
- Invisible button, highlight button, radio picture
- Termometri, ruler
- Tab control
- Splitter

L'opzione Register Client at Startup è impostata per default nella pagina Client/Server delle preferenze di 4d.
Ma se non si deve usare il comando EXECUTE ON CLIENT, è meglio togliere questa opzione che migliora le prestazioni del Client e riduce il numero di processi sul server, specialmente nel caso di molti utenti contemporanei.

Un altro suggerimento per migliorare le performance è di tenere nascosta la finestra dei processi del 4d Server che viene continuamente aggiornata con l'elenco dei sigoli processi dei singoli utenti, anche se in realtà nessuno la sta guardando.

Se le applicazioni realizzate con 4D 2003.x appena lanciate si chiudono improvvisamente potrebbe essere colpa del DEP di Windows Server 2003 Service Pack 1.

La causa è il DEP (Data Execution Prevention) del Win 2003 SP1.
La soluzione:

1. Click su Start, click su Run, scrivere sysdm.cpl, e quindi click su OK.
2. Click sul tab Advanced, click su Performance, e quindi click su Settings.
3. In Performance Options, click sul tab Data Execution Prevention, e quindi click su Add.
4. Nella dialog box "Apri", scegliere il programma (4D Server).
5. Click su Open, click su Apply, e quindi click su OK. Quando viene richiesto di riavviare il computer, click su OK.

Tech note di MS agli indirizzi:
http://support.microsoft.com/default.aspx?scid=kb;en-us;875351
http://support.microsoft.com/kb/875351/it
http://support.microsoft.com/kb/899298/

Per motivi di sicurezza si può rendere necessaria la modifica della porta utilizzata da 4D per i servizi Web, la 443. Per modificarla, nelle Preferenze di 4D 2004, andare in "Configuration" sotto "Web" e in "Web Server Publishing" è possibile modificare il numero di porta utilizzata.

L'elenco completo delle porte TCP utilizzate da Internet Command si trova qui.

Dalla versione 2004 è possibile rendere alcuni form modificabili in parte dall'utente finale.

Quando un form viene segnalato come "Editable by user", questo diventa bloccato nel Design environment. Ciò significa che lo sviluppatore deve esplicitamente "sbloccare" il form per poterlo utilizzare. Tale operazione rende però obsolete le modifiche effettuate dall'utente al form, che dovranno essere ricreate.

Le mofiche che l'utente apporta ad un form vengono memoorizzate in un file di tipo .4DA che si troverà allo stesso livello della struttura. Tale approccio permettere di rendere "non obsoleti" i possibile aggiornamenti alla struttura installati dal programmatore.

Ci sono tre opzioni "Print Frame" per stampare un subform, cioè una maschera a lista contenuta all'interno di un altra maschera (form), come ad esempio le righe all'interno della fattura.

L'opzione "Fixed (Truncation)" stampa il form una volta sola, e stampa il massimo numero di elementi correlati nella subform che rientrano nello spazio definito. Il resto degli elementi non viene stampato; questo serve ad avere un numero di pagine stampate fisso per ogni record, a prescindere dal numero dei record in relazione collegati.

L'opzione "Fixed (Multiple Records)" non modifica la dimensione del subforn in stampa, ma ristampa l'intera form tante volte quanto sia necessario a stampare tutti i record correlati mostrati nella subform.
Per esempio, se nella subform si possono mostrare 5 righe per volta e il record padre ha collegati 20 record, in stampa si avranno 4 pagine con 5 sotto-record differenti; questo permette di avere tutte le informazioni del record padre ristampate in ogni pagina.

L'opzione "Variable" ridimensiona il subforn in stama in modo tale da mostrare tutti i record correlati. Il form padre è stampato una volta solo, il subform viene esteso fino alla fine della pagina e può riprendere nelle pagine successive, finché necessario a stampare tutti i record. Questa opzione serve a stampare tutti i record quando non si ha bisogno di ripetere le stesse informazioni del record padre su ogni pagina,

Capita (raramente, ma potrebbe capitare) che un metodo o una maschera (form) si danneggino e mandino in crash 4D quando vengono aperti. Ciò diventa realmente un problema quando, passando al Design, 4D cerca sempre di riaprire la finestra "danneggiata" perchè ricorda quale erano le finestre aperte dall'utente da una sessione all'altra.

Tenendo però premuto il tasto Alt (Option su Mac) quando si passa per la prima volta all'ambiente Design, 4D non aprirà nessuna delle finestre precedentemente aperte. Questo permette di selezionare poi l'oggetto nella finestra Explorer (avendo avuto cura di chiudere il pannello di Anteprima) e di eliminarlo.

Vediamo come si può lanciare un 4D Server usando un AppleScript. Supponiamo che:

- il disco di chiami "Titanium"
- la struttura si chiami "test"
- il data file is chiami "test.data"
- entrambi siano nella cartella "test"
- la cartella sia contenuta nella cartella "Documents" dell'utente "pierpaolo"

Laciare Script Editor e inserire questo codice, sostituendo al più i percorsi di 4D Server:

tell application "Finder"
    activate
    select file "Titanium:Users:pierpaolo:Documents:test:test"
    open selection using file "4D Server" of folder "4D Server" of folder "Applications" of startup disk
end tell

Salvare lo script e scegliere "Non mostrare all'avvio".
A questo punto aggiungere lo script agli elementi di avvio.

La prima versione di 4D di comprovata compatibilità col nuovo sistema operativo di casa Apple, Tiger, sarà la 2004.2.

Per quel che riguarda le altre versioni al momento non si hanno notizie ulteriori.

Se i comandi da menu sembrano non funzionare, una delle cose che più probabilmente è successa è che abbiamo dimenticato di associare la menu bar ad una maschera (o form).

Supponiamo infatti che la nostra applicazione parta usando il menu bar 1.

Quando apriamo il processo relativo ad una certa tabella usiamo il comando MENU BAR(2) per dire al processo di usare la menu bar numero 2, che viene correttamente visualizzata ma, se usata, non produce alcun risultato.

Ciò che manca è l'associazione della menu bar al form: andare sulle proprietà del form e alla voce Menu bar scegliere la menu bar #2

Da notare che nelle ultime versioni è possibile dare un nome alle Menu Bar: usando il nome ne guadagna molto la comprensibilità del codice.

Una delle informazioni che un form è in grado di memorizzare in fase di design è il formato di stampa in cui si desidera stampare, dove per formato di stampa non dobbiamo intendere semplicemente l'orientazione del foglio, orizzontale o verticale, ma anche la vera e propria dimensione del foglio, il che permette di utilizzare facilmente anche formati di carta non standard.

Esiste un problema di compatibilità fra alcuni driver PCL per stampanti HP sotto Windows e 4th Dimension. In questi casi, la cosa migliore è utilizzare un driver di tipo PostScript. Se la stampante non supportasse questo linguaggio, è consigliabile usare un driver Microsoft per stampanti HP invece del driver distribuito insieme alla stampante.

Qualsiasi sia la ragione, quando si decide di cambiare il nome di un metodo in una struttura, bisogna assicurarsi di averlo fatto dovunque.

Il sistema principale per trovare tutte le occorrenze in cui è usato un metodo è usare il comando "Find in Database..."; comunque non è del tutto completo.

Ecco un elenco di altri posti dove guardare:
- nella finestra dove si impostano i Menu
- nella finestra delle password di 4D (se ci sono metodi eseguiti all'avvio dell'utente)
- nelle Etichette (Label Editor), dove è possibile indicare un metodo da eseguire quano si stampa un'etichetta
- nelle Ricerche (Query By Formula), dove puoi inserire il metodo come una stringa ed eseguirlo durante la ricerca
- nei Rapporti (Report), dove è possibile inserire un metodo come formula di una colonna

Se si usa SSL con 4th Dimension o 4D Server come Web Server, i file key.pem e cert.pem dovranno essere posizionati nella cartella della struttura, allo stesso livello di questa.

Se si usa 4D Client come Web Server, invece, i file devono essere posizionati nella cartella di 4D Client su Win, all'interno del package 4D Client su Mac.

Con 4D 2004 è cambiato anche il modo di di associare l'immagine di partenza alla nostra struttura. Non è più necessario incollare l'immagine nell'anteprima, ma basta scegliere Design -> Toolbox -> Menus e nell'angolo in basso a destra cliccare per ottenere uno splash screen che chiede se vogliamo effettuare l'"Incolla" della clipboard:

4th Dimension mette in automatico una tabella in modalità Read-only quando vengono usati comandi che non richiedono accesso in scrittura alla tabella stessa. Questi comandi sono:

  DISPLAY SELECTION
  DISTINCT VALUES
  EXPORT DIF
  EXPORT SYLK
  EXPORT TEXT
  GRAPH TABLE
  PRINT SELECTION
  PRINT LABEL
  QR REPORT
  SELECTION TO ARRAY
  SELECTION RANGE TO ARRAY

È possibile controllare lo stato in lettura/scrittura di una tabella usando il comando Read only state

Il tipo Integer in 4D può avere valori fra -32.768 e 32.767. Se viene inserito un valore maggiore o minore di questi limiti, il numero sarà modificato automaticamente per rientrarci: questa operazione si chiama "overflow".
Per esempio se aggiungi 1 ad un intero 32.767 esso diventerà -32768. Così se togli 1 da -32.768 otterrai 32.767.

Però bisogna anche sapere che in 4D (dalla versione 3 in poi) in realtà sono interi veri i campi e gli array. In realtà le varibili sono dei Long integer (che hanno un limite molto più alto).

Per verificare la cosa, prova ad eseguire questo codice controllando nel debugger i valori ottenuti:

CREATE RECORD([Tabella])
[Tabella]Intero:=32766
[Tabella]Intero:=[Tabella]Intero+1 ` 32,767 = normale
[Tabella]Intero:=[Tabella]Intero+1 ` -32,768 = overflow
[Tabella]Intero:=[Tabella]Intero-1 ` 32,767 = overflow ancora!

ARRAY INTEGER(arrayInteger;1)
arrayInteger{1}:=32766
arrayInteger{1}:=arrayInteger{1}+1 ` 32,767 = normale
arrayInteger{1}:=arrayInteger{1}+1 ` -32,768 = overflow

C_INTEGER(variabile)
variabile:=32766
variabile:=variabile+1 ` 32,767 = normale
variabile:=variabile+1 ` 32,768 = non c'è l'overflow!!!!

If (Type(variabile)=Is LongInt ) `infatti se controllo... è un Long integer
  ALERT("variabile è di tipo long integer.")
End if

Le icone che si trovano accanto ai campi delle tabelle nella Structure window sono rintracciabili usando i numeri di pict a partire da 150, ad esempio:

- 150 restituisce l'icona del campo di tipo string;
- 151 restituisce l'icona del campo di tipo real;
- 152 restituisce l'icona del campo di tipo text;
- 158 restituisce l'icona del campo di tipo int;
- 159 restituisce l'icona del campo di tipo longint.

Supponiamo di avere un database creato su Mac (con i due file MioProgetto e MioProgetto.data) e volerlo utilizzare su Windows.

Posto che la partizione Windows deve essere NTFS, è necessario intanto creare una copia compressa sia della struttura che del file di dati (ciò previene che la parte delle risorse non venga danneggiata o addirittura non venga copiata, se il programma che utilizziamo per copiare i file non supporta le risorse).

Portati questi file compressi sulla partizione NTFS, scompattarli e chiamare la struttura MioProgetto.4DB e il file dati MioProgetto.4DD

Nella versione 2004 4D divide anche su Mac i file in 4DB e RSR (per le strutture), 4DD e 4DR (per le base dati).

Ecco un elenco degli errori che possono verificarsi nelle connessioni di rete:

-10001 La connessione corrente al database è stata interrotta.
-10002 La connessione per questo processo è stata interrotta.
-10003 Parametri di connesione non corretti.
-10020 Il server scelto con Select 4D server non è stato trovato.
-10021 Il server scelto con Find 4D server non è stato trovato.
-10030 E' avvenuta una desincronizzazione durante il ciclo di scrittura.
-10031 E' avvenuta una desincronizzazione durante il ciclo di lettura.
-10033 Dimensione dei dati errata durante il ciclo di lettura.
-10050 Opzione sconosciuta in Get/SetOption.
-10051 Valore errato in Get/SetOption.

Ecoo un elenco degli errori ritornati dal file manager del sistema oprativo, solitamente generati quando si usano i comandi della sezione System Documents:

-33 La cartella per il documento è piena. Non puoi creare un nuovo documento sul disco.
-34 Il disco è pieno. Non c'e altro spazio disponibile sul disco.
-35 Il volume specificato non esiste.
-36 Errore di I/O . Esiste probabilmente un blocco danneggiato sul disco.
-37 Nome del documento o del volume errato.
-38 Tentativo di leggere o scrivere un file non aperto.
-39 Richiesto un end-of-file logico durante l'operazione di lettura.
-40 Tentativo di accedere ad una posizione precedente all'inizio del file.
-41 Memoria insufficiente per aprire un nuovo documento sul disco.
-42 Troppi documenti aperti sullo stesso disco.
-43 Documento non trovato.
-44 Il volume è bloccato da una impostazione hardware.
-45 Il documento è bloccato.
-46 Il volume è bloccato da una applicazione.
-47 Tentativo di accedere ad un documento che è stato cancellato.
-48 Tentativo di rinominare un documento col nome di un documento cancellato.
-49 Tentativo di aprire un file già aperto in modalità di scrittura.
-51 Tentativo di accedere ad un documento con un document reference number non valido.
-52 Errore interno del file manager (posizione del file marker perduta).
-53 Volume non in linea.
-54 Tentativo di aprire un file bloccato per la scrittura.
-57 Tentativo di lavorare con un disco non-Macintosh.
-58 Errore nel file system esterno.
-60 Errore nel master directory block. Il disco è danneggiato.
-61 I permessi Read/write non consentono la scrittura.
-64 Problema hardware sul disco (cattiva installazione, formattazione non corretta...)
-84 Problema hardware sul disco (cattiva installazione, formattazione non corretta...)
-120 Tentativo di accedere ad un documento usando il percorso di una cartella che non esiste.
-121 Il percorso di accesso non può essere creato.
-124 Tentativo di accedere ad un volume condiviso disconnesso.

L'arrivo di Windows XP Service Pack 2 comporta vantaggi e svantaggi. Un vantaggio è che il problema dovuto al fix KB824141 sulle vecchie versioni non sembra più presente.

Lo svantaggio è che le porte per 4D Server devono essere controllate per poter pubblicare i database col firewall attivo (standard del client è 19813, standard del web è la 80)

Una domanda che ci si pone è: "Quale sistema scegliere?". Oppure: "Secondo quali criteri un sistema può essere preferibile ad un altro?".

La chiave attraverso la quale scegliere un sistema di sviluppo per database può essere l'equilibrio: l'equilibrio fra i bisogni dello sviluppatore e quelli dell'utente. Lo sviluppatore desidera un sistema semplice da sviluppare e flessibile. L'utente cerca un database con caratteristiche che lo rendano potente, ma di facile utilizzo e che costi poco.

FileMaker è davvero semplice, ma assai limitato: si arriva ai limiti dell'applicativo non appena si hanno delle richieste un po' complesse.
Access ha in alcuni aspetti grandi capacità, ma in altre risulta meno potente o assai complesso. In multiutenza ha un limite per numero di 4-5 utenti oltre il quale è necessario passare all'uso di un server SQL.
4th Dimension ha la facilità di sviluppo di FileMaker, ma possiede una grandissima varietà di caratteristiche aggiuntive rispetto agli agli altri due sistemi. Rispetto a FileMaker è più potente, rispetto ad Access è più facile e semplice da manutenere senza perdere in potenza.

Consulta da questo link l’indice delle faq su 4th Dimension, MS Access e FileMaker Pro

A partire dalla versione 6 si possono utilizzare gli operatori di confronto per ottenere il numero di menu scelto e il numero della relativa voce scelta in questo modo:

Menu := (Menu selected & 0xFFFF0000) >> 16
menu_command := Menu selected 0xFFFF

E' possibile modificare lo sfondo standard della finestra del database structure con una
immagine personalizzata.

IMPORTANTE: LA MODIFICA E' DEFINITIVA, nel senso
che non è possibile ritornare all'immagine di sfondo standard di 4D (quella
con gli ingranaggi, per intenderci).
Per effettuare la modifica:
- mettere negli appunti l'immagine che si vuole come sfondo;
- cliccare su un punto vuoto (senza tabelle o relazioni) della finestra
Database structure;
- incollare l'immagine.

Il percorso della cartella di sistema dove 4D posiziona le sue preferenze può essere ottenuto in due modi:
- usando il comando Get 4D folder;
- guardando la voce 4D folder nella pagina "Program" della dialog "About 4th Dimension".

A partire dalla versione 6.8:
On MacOS X:{Disk}:Library:Application Support:4D
Mac OS 9: Disk}:System folder:Application Support:4D
Windows NT: {Disk}:\{System folder}\Profiles\All Users\Application Data\4D
Windows 98/ME: {Disk}:\{System folder}\All users\Application Data\4D
Windows 2000/XP: {Disk}:\Documents and Settings\All Users\Application Data\4D
Windows 2000/XP con 4D Client:
{Disk}:\Documents and Settings\{Current user}\Application Data\4D

L'errore -9999, "No more room to save the record" segnala che tutti i segment del database sono pieni o non c'è più spazio per scrivere sul disco.

Tuttavia è molto più facile che questo errore sia in realtà dovuto al fatto che il file di dati è in modalità "locked" o sia bloccato il disco su cui il file si trova.

E' possibile controllare allo startup lo stato della base dati con il comando is data file locked.

Tra le preferenze gestibili con 4D Customizer Plus c'è la quantità di memoria allocata su Windows, la voce "Main Memory Application". Per i valori da inserire si può fare riferimento alla faq sulla gestione della memoria.

Una cosa importante da tenere presente è che il valore che viene impostato nelle "Preferences" della struttura molto spesso non viene preso in considerazione. Infatti 4D controlla innanzitutto se la preferenza "Main Memory" è impostata su uno dei file delle preferenze; i file delle preferenze si trovano nella 4D folder (la cartella All users\Application Data\4D all'interno di Documents and setting o della cartella di sistema) e sono (nella 2003):

- 4D Preferences 2003.RSR per 4D, 4D Server, 4D Client, 4D Tools;
- 4D Runtime Preferences 2003.RSR per 4D Runtime, 4D Runtime Classic;
- 4D Engine Preferences 2003.RSR per l'Engine

Quindi se la preferenza della memoria è impostata sia nell'applicazione che nel file delle preferenze, quest'ultimo ha precedenza. Si possono allora avere questi casi:

- Se si configura la memoria attraverso le preferenze di 4d, queste impostazioni verranno inserite nel file delle preferenze (se contiene la risorsa "Main memory").
- Se si apre col Customizer il file delle preferenze, fare doppio clic sulla voce "Main Memory". Impostando qui un valore, questo verrà utilizzato al posto di quello settato nell'applicazione.
- Per utilizzare il settaggio della memoria eseguito sull'applicazione il file delle preferenze relativo deve essere cancellato dalla 4D folder.
- Il settaggio della memoria della struttura viene utilizzato solo quando questa viene poi inserita nell'Engine, avendo però al solito cura di aver cancellato il file "4D Engine Preferences 2003.RSR", che altrimenti ha priorità nella creazione dell'eseguibile.

Una delle cosa di cui mi lamentavo del nuovo Quick Report della versione 2003 era la scomparsa della "Sorted" per le colonne: il che non era un problema per le colonne che contenessero dei campi del database (che potevano essere trascinate nella zona "Sort order"), ma lo diventava per i campi calcolati.

Ma mi sono ricavato uno stratagemma: prendo una colonna, la trascino nella zona "Sort order" e la colonna compare anche fra le colonne del report: un bel doppio clic sulla colonna e si apre l'Edit della stessa; inserisco il calcolo che voglio effettuare, premo OK e la colonna continua a risultare "ordinata". Posso quindi calcolare al solito break, subtotali, ecc...

Ecco alcune informazioni pratiche; occorre precisare che non sono ufficiali, per cui ci potrebbero essere errori o interpretazioni non corrette.

1. Per la registrazione del prodotto occorre un codice utente e la password registrati presso un sito di 4d ( in automatico porta al sito http://4dstore.4d.fr/ ). In teoria ogni utente dovrebbe registrarsi ma non credo ci siano problemi se si registra lo sviluppatore... almeno non tecnici. La registrazione per avere un proprio Account si può fare anche senza avere un prodotto da registrare.

2. Per ogni prodotto 4D esiste un Product Number unico.

3. Nella finestra di Unlock 4d devi scrivere: l'account, la relativa password e il Product Number (e un indirizzo email alternativo o ugale a quello dell'account)

4. Se la macchina non è collegata ad internet si può registrare sempre nella stessa schermata di Unlock4D un file da mandare sempre usando lo stesso sito http://4dstore.4d.fr/ ; il sito poi rimanda via mail un file di autorizzazione che letto sempre nella stessa finestra di 4d abilita il prodotto.

5. Il processo di abilitazione si può fare 3 volte; ovviamente dopo si può richiedere tramite il distributore Italsoftware lo sblocco.

6. Le licenze vengono registrate in un file nella cartella Licenses dentro la cartella 4D nel Sistema. L'informazione non è nascosta tanto che nella finestra di 4D Update License c'è proprio un pulsante che apre questa cartella. I file sono in formato HTML e presentano un elenco delle licenze attive.

7. Se ci si trova nei problemi l'Emergency mode attiva il prodotto solo inserendo il Product Number e senza bisogno di avere una connessione internet per 5 giorni, con l'unica limitazione di poterlo fare solo una volta al mese.

8. Invece la modalità Demo è sempre la stessa, cioè accesso in scrittura a max 20 metodi e 50 records.

Nota: link aggiornati, http://4dstore.4d.fr/ è più facile da usare.

Per installare nuovi numeri seriali per 4D, in particolare quando si sta usando il Runtime, basta premere contemporaneamente i tasti Ctrl+Shift+F8 su Win e Command+Shift+F8 su Mac.

Per gli utilizzatori della 2004 è inoltre possibile usare il nuovo comando CHANGE LICENSES.

E' possibile limitare l'accesso degli utenti ad un plugin utilizzando la finestra delle password di 4th Dimension: la funzione è utile soprattutto in installazioni client-server in cui il numero di licenze di un particolare plugin è inferiore al numero di client totali. Ad esempio, in un call center di 100 persone, potrei avere bisogno di solo 10 licenze write per i responsabili.

Entrando come Designer o Administrator nella dialog delle password creare un nuovo gruppo a cui assegnare gli utenti che avranno accesso al plugin. A questo punto scegliere dal menu Password la voce Plug-Ins Access per accedere alla finestra che permette di decidere quale gruppo (quello appena creato, ad esempio) può accedere a quale plugin.

Se l'ambiente password del database è rovinato o da ripristinare, è possibile crearne uno nuovo con 4D Insider, che permette di creare una nuova struttura senza password. Ecco le operazioni:
- aprire il database con l'Insider;
- creare un nuovo db;
- selezionare nel vecchio tutti gli elementi;
- trascinarli sul nuovo;
- salvare il nuovo database;
- impostare le nuove password con 4th Dimension.

Bisogna inoltre notare che:
- in relazione al numero di elementi del database, può essere necessario effettuare il trasferimento a piccoli pezzi;
- volendo esportare anche gli utenti, solo quelli creati dall'Administrator possono essere esportati.

Una soluzione semplice per chi ha poco tempo da dedicargli, sperimentata da me, è questa:

- fare una copia del db chiamarlo "Storico2003.db"

- da Storico2003.db togliere a tutti utenti il privilegio di scrittura, se il tuo db ha una gestione "personalizzata" dei privilegi. Altrimenti creare un gruppo "Consulta" e spostare gli utenti li dentro, creare un gruppo Admin dove c'è solo Designer ed Administrator. Dalla struttura per ogni tabella che ti interessa mantenere in sola lettura fare doppio clic e nella Table properties-Privileges : impstare le opzioni load Record gruppo Consulta, Save, Add, Delete: Gruppo Admin

- aprire (se non ci sono limitazioni dell' hardware: disco già troppo pieno, scarsa potenza della macchina server) "Storico2003.db" sulla stessa macchina server dove è il database originale ancora utilizzato in aggiornamento. (vedi la faq Eseguire più 4d Server sulla stessa macchina su questo sito)

- dall'originale si può fare una sorta di pulizia cancellando tutti i dati vecchi, compattando e rimettendo su un originale più snello.

Non è elegantissima ma permettere di non scrivere nessuna riga di codice e di avere la stessa interfaccia utente nello storico e nel db originale; inoltre l'utente quando apre il client può velocemente scegliere se consultare lo storico o lavorare sul db aggiornato.

La finestre standard di Importazione/Esportazione permettono di salvare le impostazioni scelte, registrando:
- il nome file e il suo percorso
- le tabelle e i campi selezionati
- il nome del layout se selezionato o le altre impostazioni come tipo di file, delimitatori di campo e di record, etc

Dopo aver impostato queste opzioni basta salvarle (su Windows l'estensione è .4SI) usando il pulsante di registrazione nella toolbar della finestra di dialogo. Questa impostazione può esere ricaricata con il pulsante di Load oppure da programma caricandole in un blob.

Per esempio:

C_BLOB($impostazioni_blb)
DOCUMENT TO BLOB("FileRegistrato";$impostazioni_blb) `qui le carico
IMPORT DATA("NomeFile";$impostazioni_blb) `qui le uso

Nella versione 2003.4 appena uscita ci sono due correzioni molto interessanti specialmente per gli svilupatori, che riguardano il method editor:
- inserendo un commento all'inizio di una riga, la riga commentata si spostava al rigo precedente;
- effettuando la selezione del testo di un metodo con maiuscolo+frecce, se si selezionava il testo al di fuori della zona attualmente selezionata, non veniva effettuato uno scroll contemporaneo per vedere fino a dove si eseguiva la selezione (come un qualsiasi editor di testo), ma la visualizzazione restava immutata.

Un Help in linea molto completo è quello in versione HTML consultabile con un browser. Questo tipo di Help si richiama premendo il tasto funzione F1 dopo aver selezionato un comando 4D (su Windows non dovrete aver installato 4d.HLP). Viene aperto il vostro browser e mostrata una pagina con la sintassi e tutte le informazioni utili sul comando scelto.
Da questa finestra utilizzando i vari link è possibile consultare tutti i comandi di 4D, in pratica il Language Reference, e tutte informazioni di maggior utilità sui vari programmi e Plugin che fanno parte delle soluzioni 4th Dimension.

Tutto ciò è contenuto nella cartella Documentation (di 54,9 Mb): i file si possono scaricare dall' ftp di 4D.com (versione Macintosh o Windows) oppure copiare dal CD di installazione.

Copiata la cartella sul disco (magari nella stessa folder dove avete messo l'applicativo), per poter richiamare in maniera veloce questo Help come sopra spiegato bisogna specificare a 4D dove si trovano i documenti HTML dal menu:

  4th Dimension | Preferences | Design mode | Documentation

qui scegliere Local folder e sfogliare il percorso fino alla vostra cartella Documentation.

Ipotizziamo di avere un archivio che contiene i movimenti di vendita. In questo archivio avremo il codice articolo, il codice cliente e il valore della vendita. Vorremmo ottenere un report che riporti nelle colonne i clienti, nelle righe gli articoli e nella cella di incrocio il valore del singolo articolo per il corrispondente cliente.

Aprendo il report e selezionando tabella si presenta l'editor dello stesso, che presenta 3 colonne e 3 righe. La prima cella serve solo per selezionare tutto il report. La prima cella della seconda colonna è quella in cui andremo a mettere il campo cliente. Per farlo tenete premuto il tasto control e all'apparire del menu selezionate "modifica". All'apertura del layout di modifica inserite il campo del file a cui si riferisce il cliente. La seconda cella della prima colonna è quella in cui andremo ad inserire il campo articolo, per inserirlo procedete come sopra. Nella seconda cella della seconda colonna dobbiamo inserire il campo che vogliamo totalizzare, per farlo procedete come sopra. Ora se vogliamo tutti i totali di riga e colonna selezionate la prima cella e cliccate sul bottone di totalizzazione. Il report è finito, provate a stampare e otterrete tante colonne quanti sono i clienti che hanno acquistato e tante righe quanti sono gli articoli venduti, con il totale per cliente/articolo e i relativi totali di righe e colonne.

Questo è un argomento su cui i tre sistemi differiscono molto.

Access lavoro solo in ambiente Windows, mentre sia FileMaker Pro che 4D lavorano sia sotto Windows che sotto Mac OS.

4D, oltre a permettere di usare client Mac anche collegati a server Windows e viceversa, prevede la possibilità di scegliere stili e controlli diversi a seconda della piattaforma usata, e genera codice compilato specifico per ogni piattaforma. Inoltre il sistema di registrazione degli oggetti, sia le maschere che i record (vedi I Tag dei record e l'opzione Completely Deleted), è ottimizzato nell'utilizzo sulla stessa piattaforma pur mantenendosi pienamente compatibile e trasparente all'utente.

Consulta da questo link l’indice delle faq su 4th Dimension, MS Access e FileMaker Pro

In ambiente di Utilizzo dei tre sistemi le ricerche sulla base dati si eseguono nei seguenti modi:

In Access le query sono degli oggetti definiti tramite una interfaccia dedicata prima del loro uso e memorizzati nella struttura. La versione SQL della query può essere visualizzata in una finestra a parte.

In FileMaker Pro le ricerche sono effettuate usando la modalità di ricerca, che mostra la stessa maschera di consultazione con i campi liberi all'utente e da riempire con i criteri necessari. Una volta effettuata la ricerca è possibile utilizzarla negli script.

In 4th Dimension, le ricerche sono effettuate sia come in FileMaker usando la modalità "Query by example" oppure definendo i vari criteri di ricerca con chiavi in And e Or tramite una maschera dedicata effettuando una "Query". I criteri di ricerca possono essere salvati in un file per essere richiamati quando necessario.

Consulta da questo link l’indice delle faq su 4th Dimension, MS Access e FileMaker Pro

Col termine transazione (transaction) definiamo la possibilità di raggruppare in un unico "blocco" una serie di modifiche apportate ai dati: tanto per dare un esempio, immaginiamo un classico schema con due tabelle, fatture e righe fatture: ovviamente se creo una fattura, aggiungo delle righe fattura e poi non registro la fattura, desidererei che neanche le righe venissero salvate: gestire queste operazioni in automatico come un'unica mega-operazione va proprio sotto il nome di transazione.

Ora, molto semplicemente, Access e 4th Dimension supportano le transazioni, FileMaker no.

Consulta da questo link l’indice delle faq su 4th Dimension, MS Access e FileMaker Pro

I tag si trovano nei primi 4 caratteri di ogni record salvato su disco e ne identificano il tipo:

- $4444: record creato su Mac, versione prima della 6.x
- $4447: record creato su Mac, versione 6.x e successive
- $5555: record creato su Windows
- $0000: record cancellato

Il tipo di record è importante perché viene mantenuto l'ordine dei byte come usato su ogni piattaforma; su Mac i byte sono scritti e letti da destra a sinistra, cioè a destra sta la parte meno significativa, per cui il numero esadecimale $0100 equivale al decimale 256, mentre su Windows la modalità è inversa lo stesso va letto invece come il decimale 1.

Il tag $0000 viene scritto quando il record è cancellato e viene lasciata nella definizione della tabella (in Struttura) l'opzione "Completely Deleted". Quando un record viene cancellato è segnalato innanzitutto in una lista ad accesso veloce (bit table), poi 4D va a cercare il record per cambiare il tag. Se in una tabella si prevede di fare molte cancellazioni, ad esempio si tratta di una tabella temporanea usata per importare ed esportare i record, è possibile avere una maggiore velocità di cancellazione togliendo l'opzione "Completely Deleted"; l'unico effetto negativo di questa operazione è che se per caso si fosse costretti a recuperare la base dati con l'opzione "recupera per tag", 4D non potrebbe riconoscere i record cancellati e li recupererà per intero.
Quindi per tutte le tabelle dove i dati sono fondamentali è meglio lasciare questa opzione selezionata.

Una delle differenze maggiori fra i tre sistemi presi in considerazione è il modo in cui vengono gestiti e memorizzati applicazione (tabelle, form, metodi/script/macro) e dati.

Nella configurazione classica, FileMaker Pro ha un file per ogni tabella dell'applicazione contenente tabella, form, script e dati. Questo sistema rende problematici gli aggiornamenti, poiché lo sviluppatore non può quindi effettuare modifiche al volo ma solo off-line, ed è costretto ad effettuare una esportazione/importazione dei dati per eseguire un aggiornamento.

Access può memorizzare applicazione e dati in file separati. Per migliorare le prestazioni, molti sviluppatori scelgono di posizionare il file dati su un file server e una copia della struttura sui computer di ogni utente. Così è possibile lavorare off-line e installare le nuove versioni senza dover esportare e importare, ma risulta necessario aggiornare tutte le macchine. Si usano così spesso dei pacchetti di distribuzione, che d'altra parte aumentano i costi. Access può anche essere usato come client di un database SQL, operazione comunque costosa e complessa ed in ogni caso non risparmia il programmatore e l'utente dell'aggiornamento della struttura Access ad ogni modifica.

Come Access, 4th Dimension mantiene in file separati struttura e dati, ma entrambi vengono serviti direttamente da 4D Server. 4D Server ha prestazioni nettamente superiori a quelle di un file server, poiché tutte le operazioni vengono svolte sul server, senza intasare così la rete.

Consulta da questo link l’indice delle faq su 4th Dimension, MS Access e FileMaker Pro


Unica installazione
Quando viene installata una nuova versione di un programma sul server, al primo login ogni utente sarà automaticamente aggiornato alla versione attuale. 4D usa in modo assolutamente trasparente per l'utente una cache locale quando l'utente accede ad una parte dell'applicazione: ciò aumenta le performance in maniera davvero considerevole.

Modifiche on line
Inoltre è possibile programmare su una struttura anche mentre viene utilizzata; ogni modifica fatta alla struttura viene subito riportata su tutti i client collegati.
E' cioè possibile ad esempio aggiungere un campo, modificarlo da numero Longint a tipo Stringa, visualizzarlo nelle maschere di inserimento o nelle liste e l'utente se lo ritroverà senza dover interrompere il suo lavoro!

Questa è l'argomento principale dove 4th Dimension mostra dei vantaggi e delle prestazioni nettamente migliori rispetto ad entrambe le altre due piattaforme.

Le transazioni rappresentano una serie di modifiche fatte al database all'interno di un processo. Una transazione non è salvata nel database in modo permanente finché non viene validata. Se una transazione non viene completata, sia perché è stata annullata o a causa di qualche evento esterno, le modifiche non sono salvate.

Durante una transazione, tutte le modifiche fatte al database all'interno di un processo sono salvate localmente in un buffer temporaneo. Se una transazione è accettata con VALIDATE TRANSACTION, le modifiche sono salvate in modo permanente. Se la transazione è annullata con CANCEL TRANSACTION, le modifiche non vengono salvate.

Visto che nelle transazioni i record sono selezionati temporaneamente o creati con indirizzi temporanei, quando questa viene validata o annullata, la selezione di ogni tabella per il processo corrente diventa vuota. Per questa ragione è necessario fare attenzione ad usare le Named selection: se sono state create prima o durante una transazione potrebbero contenere indirizzi che dopo la tansazione non sono più corretti; la stessa attenzione bisogna averla nell'utilizzare i set, che si basano su una tabella binaria (di vero/falso) corrispondente agli indirizzi dei record.

Non ci sono limiti teorici al numero di record che una transazione può contenere. Comunque, il primo limite che si può incontrare sarà quello della memoria disponibile. 4D prova a tenere le transazioni in cache; se diventano troppo grosse, 4D le salva in un file temporaneo. I file temporanei vengono salvati per default sul disco C: sotto Windows, sul disco con più spazio sotto Macintosh, oppure nella cartella indicata nelle preferenze del database (System Settings).

Occupiamoci della possibilità che un database debba essere utilizzato da più utenti contemporaneamente.
Access uilizza un approccio di tipo file/server, in cui l'applicazione e/o i dati e/o Access stesso sono piazzati su un file server accessibile dagli utenti: questo comporta ovviamente che maggiori sono le richieste al file server, più lento è l'accesso al server stesso; inoltre se un client va in crash si potrebbe bloccare l'accesso a tutti. Normalmente superando i 4-5 utenti il programmatore Access deve prendere in considerazione l'uso di un SQL Server.

Ogni copia di FileMaker Pro ha all'interno un protocollo di comunicazione proprietario punto-punto multiutente: in questo modo, per un numero ridotto di utenti e/o tabelle è possibile simulare un server senza che un server vi sia dedicato. D'altra parte, FileMaker Pro non è multiprocesso, e quindi la macchina che contiene il database può fare solo una operazione per volta: se un utente esegue una operazione lunga, gli altri utenti devono attendere che finisca prima di poter a loro volta agire. In queste situazioni risulta necessario FileMaker Server, che è realmente multiprocesso: sul server in questo caso vengono eseguite solo le operazioni sui dati.

La multiutenza con 4D viene gestita da 4D Server, che fa diventare una applicazione stand-alone di 4D la corrispondente versione in modalità client-server reale. E' possibile creare dei file di login automatico al server (a questo riguardo vedi la faq Usare 4D Client come fosse l'Engine).
Sul server di 4D è possibile lanciare delle Stored Procedure, cioè funzioni che sono eseguite solo sul server. Sono disponibili anche un certo numero di funzioni per scambiare variabili dal client al server, eseguire metodi da un client su un altro client, controllare che ogni singola connessione sia fatta da client, da odbc o da web.

Consulta da questo link l’indice delle faq su 4th Dimension, MS Access e FileMaker Pro

I set sono relativi ad una tabella e identificati da una stringa, che è meglio scegliere con accortezza; il set "miei" ha un nome poco significativo, mentre il set "Ordini Non Pagati" è già più chiaro. I set possono essere di vari tipi:
- Set di processo, disponibili solo all'interno del processo dove sono stati creati, come ad esempio il set automatico "LockedSet"
- Set interprocesso il cui nome inizia con i simboli <> o su Mac con il carattere ?; sono condivisi da tutti i processi
Questi primi due tipi di set quando sono creati e usati agiscono sempre sul server; passano sulla rete solo quando il client usa il comando SAVE SET, LOAD SET o il COPY SET da o verso un set locale.

- Set locali o Client il cui nome inizia con il simbolo del $ sono gli unici set conservati solo nel client e non sul server; il set UserSet è locale anche se non inizia per $: occorre fare attenzione perché non è possibile in situazione client-server combinarlo con un set di processo! Prima di utilizzarlo con i comandi INTERSECTION, UNION o DIFFERENCE farne una copia con COPY SET.

I componenti sono creati usando l'Insider per isolare gruppi di procedure con una funzione specifica all'interno di una normale struttura di 4d.

Dopo aver creato un componente è possibile distribuirlo come pacchetto a sé stante per installarlo in altre strutture..
I metodi possono essere impostati come:
- privati (e invisibili allo sviluppatore che installa il componente),
- protetti per i metodi che lo sviluppatore può richiamare ma non vederne il contenuto
- pubblici utilizzabili e il cui contenuto è accessibile (ad esempio per i metodi
che illustrano al programmatore come funziona il componente).

Per un uso interno non ci sono grossi problemi, se si vuole distribuirli bisogna
considerare con attenzione vari problemi di convivenza e specialmente se le procedure richiedono eventuali tabelle (il destinatario potrebbe essere restio ad avere nuove tabelle nella propria struttura) e i nomi delle variabili (con un buon prefisso si possono distinguere da eventuali altre variabili di processo o inteprocesso già esistenti nella struttura ospite).

4D fornisce uno strumento molto efficiente per manipolare le selezioni di record di una tabella considerandole come insiemi non ordinati; dal punto di vista pratico è possibile registrare in un oggetto Set un elenco di puntatori ai record nella selezione.

Li si usa per:
- tenere temporaneamente da parte una selezione particolare per ripristinarla successivamente
- per controllare cosa ha selezionato l'utente: in pratica ogni volta che 4d mostra una lista di record, sia in un form di output che in una subform viene automaticamente aggiornato un set "UserSet"
- per controllare se dopo un APPLY TO SELECTION, ARRAY TO SELECTION e DELETE SELECTION qualche record bloccato in scrittura non è stato modificato, guardando il set automatico "LockedSet"
- manipolare gli insiemi e quindi prendere l'unione, l'intersezione o fare la differenza fra due selezioni di record.

Rispetto ad una Selection il set non mantiene l'ordine della selezione perchè è costituito solo da bit (vero/falso) che indicano se il record n-esimo è selezionato; contemporanemante occupano pochissimo spazio, ad esempio una selezione in una tabella di 800.000 record occupa solo 100K.

I set si possono salvare su disco, ma non sono utilizzabili dopo molto tempo perchè conservano solo la selezione e non la ricerca fatta: ad esempio un set dei minori di 18 anni in una tabella anagrafica potrebbe essere da aggiornare già il giorno dopo.

Ecco un piccolo elenco delle poche informazioni necessarie ad un utente per generare i suoi report personalizzati con Quick Report:
- per aggiungere un campo al report fai doppio clic su un elemento dell'elenco dei campi;
- se i campi che vuoi inserire appartengono ad un altro archivio, scegli l'archivio relativo dopo aver scelto Related Tables;
- se vuoi che 4D non calcoli in automatico la larghezza della colonna seleziona la colonna e disattiva "Columns" "Automatic width" e scegli la larghezza che vuoi;
- puoi contare i campi di qualsiasi tipo, usando il tastino "N", mentre le funzioni di somma, minimo, massimo e media sono utilizzabili solo per i valori numerici;
- puoi ordinare i dati secondo uno o più dati trascinando il campo da ordinare nella colonna "Sort order";
- se vuoi che 4D mostri per ogni riga il valore secondo cui sta ordinando e non solo sulla prima riga che ha un certo valore scegli "Columns" "R epeated values";
- creando un ordinamento, è possibile sfruttare i break: un break viene generato quando il campo secondo cui hai ordinato cambia valore, quindi anche sui break puoi sfruttare le funzioni conta, somma, ecc.;
- per far ricomparire il valore che ha generato il break (il valore ordinato fino ad adesso elencato), inserisci un cancelletto (#) in corrispondenza del campo ordinato;
- su "File" - "Headers and footers" puoi modificare intestazione e piè di pagina del report, inserendo dati al centro o a destra o a sinistra, e in automatico puoi inserire data e ora di stampa e numero di pagina, il tutto inframmezzato da testo personalizzato;
- puoi personalizzare l'aspetto come credi o utilizzare l'opzione "Style" "Presentation" per delle combinazioni di font e colori già create;
- puoi salvare il report andando su "File" "Save" e richiamarlo quando vuoi andando su "File" "Open";
- imposti l'orientamento del foglio da "File" "Page setup";
- vedi l'anteprima del report da "File" "Print preview";
- stampi il report andando su "File" "Generate".

All'interno della finestra di method editor, dopo aver terminato di scrivere un comando di 4D, l' Explorer Help visualizza la sintassi del comando nella parte alta della finestra.
Perché questo funzioni deve essere installato un file, che fornisce le informazioni di aiuto, il suo nome è "4D Help" su Macintosh e "4D Help.RSR" su Windows.
Questo file di help non va confuso con il Menu di Help, che utilizza un altro file chiamato 4D.HLP.

"4D Help" per l'Explorer Help può essere comodamente scaricato dal sito ftp di 4D.com da questo indirizzo ed installato nella seguente cartella di sistema:

Macintosh = Library:Application Support:4D
Windows = C:\Document and Settings\All Users\Application Data\4D

Dopo l'installazione l'Explorer Help è fruibile su quel computer sia se utilizzate un 4D Client oppure una versione Desktop.

Con 4D versione 2003 è disponibile un formato DateTime per importare ed esportare data e ora.

Il formato corrisponde alla rapresentazione standard di data e ora XML, che usa il formato aaaa-mm-ggThh:mm:ss come ad esempio: 2000-10-12T16:30:00

Benché 4D non conservi data e ora in un unico campo, è possibile usare questo formato in entrambi i casi:
- da un campo data, 4d produrrà un testo del tipo 2000-10-12T00:00:00
- da un campo ora, 4d produrrà un testo del tipo 0000-00-00T16:30:00

D'altro canto da questo formato 4D leggerà l'informazione necessaria per importare in un campo di tipo data o di tipo ora.

Esiste anche un file chiamato 4D.HLP che è in formato Microsoft Help; ovviamente funziona facilmente con Window, mentre con Macintosh è compatibile con la 6.7 ed è necessario avere installato il Microsoft Help Application (presente nella versione di Office 98).

Si scarica dal sito ftp da questo indirizzo.

Questo file 4D.HLP (ed eventualmente anche altri file nello stesso formato) possono essere messi allo stesso livello dell'applicazione 4D o anche in una cartella Mac4DX o Win4DX: in questo caso il file viene scaricato automaticamente in una installazione Client-Server ed è disponibile in automatico nel menu Aiuto.

Su Mac OS X l'aiuto in linea di 4d si richiama dal barra del Menu. "Help" è l'ultima voce di menu sia che siate in ambiente User che in ambiente Designer. Utilizza per la visualizzazione Visore Aiuto (Help Viewer) del MacOsX: è molto completo e contiene tutto il Language Reference.
In questo caso tutti i files che servono sono in una cartella (che si scarica dall'ftp di 4d.com da questo indirizzo oppure si copia da CD) la cartella "4th Dimension Help" con tutto il suo contenuto va posizionata in:

Library:Documentation:Help

Per usufruire di questo aiutonon è necessario avere 4D aperto: è possibile aprire Aiuto Mac e andarlo a scegliere nel menu Libreria.

Se serve ricostruire il menu Edit (nella versione 2003), è possibile creare una nuova barra dei menu nel database esistente e copiare manualmente questo menu Edit su tutti i menu esistenti. L'Edit originale di 4D è riconoscibile dal fatto che "Edit" è in corsivo. Quando i menu e i loro elementi sono in corsivo, questo significa che si sta usando la versione del menu di 4D. Facendo Control-click sulla parola in corsivo nell'editor della barra dei menu verrà visualizzato il numero di riferimento associato. Per esempio:
- File: ":79,1"
- Edit: ":79,5"

Inserendo queste stringhe quando si aggiunge un menu o una voce di menu ci si assicurerà che verranno utilizzate le “versioni correnti” dei comandi. Quindi, per azioni come Taglia, Copia e Incolla, ecc. sarà necessario anche utilizzare i loro riferimenti appropriati. Ecco qualche esempio:

Annulla: 131,18
Taglia: 131,19
Copia: 131,20
Incolla: 131,21

Il menu Edit deve essere posizionato direttamente dopo il menu File, che dovrebbe essere il primo e anch’esso in corsivo. Appena fatto, si sarà in grado di utilizzare tutte le funzioni del menu Edit standard.

In 4D 2003 si ha la possibilità di creare il menu Edit. Nelle versioni precedenti, il menu Edit era impostato per default, non modificabile.

Quindi, aggiornando il database alla 2003 da una versione precedente, viene data la possibilità di usare il predefinito o il proprio. Di default, 4D utilizzerà l’ “Old Edit Menu Mechanism”, cioè il menu Edit dalle versioni precedenti. Tuttavia, se si decide di non utilizzare più questo, sarà poi necessario ricostruire il menu Edit per non perdere le funzionalità di Taglia, Copia e Incolla (e i relativi tasti di scelta rapida) nel Custom Environment.

Malgrado un database sia fatto per gestire dati, capita di dover gestire dei dati in maniera temporanea.

FileMaker usa il concetto dei campi globali associati ad ogni tabella. Ogni utente può avere differenti campi e il loro valore "dura" finché il file è aperto. Ognuno di questi campi contiene un singolo valore. Lo ScriptMaker non consente di dichiarare variabili.

Access usa gli oggetti dei form. Gli oggetti dei vari form sono indipendenti fra di loro e valgono finché il form è aperto. L'uso di VBA permette al programmatore di avere variabili indipendenti di vario tipo.

4th Dimension può inserire variabili dove è necessario (form o metodi). Le variabili differiscono solo nello scope che viene loro assegnato: locali (iniziano con il $, appartengono solo al metodo dove vengono usate), processo (appartengono al processo, con i suoi metodi e i suoi form, dove vengono usate), interprocesso (iniziano con <>, sono condivise da tutti i processi su una singola macchina).
Inoltre può gestire un insieme di variabili separato per 4D Server.

Consulta da questo link l’indice delle faq su 4th Dimension, MS Access e FileMaker Pro

Gli eventi

Col termine evento si può molto semplicisticamente definire la possibilità di eseguire qualche operazione quando succede o sta per succedere qualcosa.

FileMaker gestisce un numero davvero limitato di eventi, più ampio quello di Access e 4D; 4D inoltre, dei tre sistemi, è il solo in grado di gestire in automatico anche come eventi l'avvio e la chiusura del server, la connessione e la disconnessione del client.

Nello specifico, 4D gestisce:
- apertura e chiusura di un form;
- clic singolo o doppio;
- stampa;
- modifica di un campo;
- fuoco su un oggetto (in entrata o in uscita);
- drag degli oggetti e drop degli oggetti;
- inserimento di un carattere;
- resize di form e oggetti;
- eventi a tempo;
- errori;
- attivazione o disattivazione di un form (per cambio finestra);
- scelta di un menu;
- apertura del database;
- clic sul pulsante di chiusura;
- uscita dal database;
- apertura e chiusura del server;
- apertura e chiusura dei client;
- eventi web.

Degli eventi citati, Access non gestisce in automatico, oltre alla parte client/server, la scelta di un menu e il clic su pulsante di chiusura.

Gli unici eventi gestiti in automatico da FileMaker sono i clic sugli oggetti, gli eventi a tempo, la scelta di un menu, il pulsante di chiusura finestra, apertura e chiusura del database.

Consulta da questo link l’indice delle faq su 4th Dimension, MS Access e FileMaker Pro

L'automazione

Le applicazioni per database richiedono solitamente un certo grado di automazione per eseguire delle operazioni richieste dall'utente o necessarie per il funzionamento del sistema. Gli approcci fra i tre sistemi sono differenti.

Il sistema base per scrivere codice in Access è quello delle macro. Una macro viene creata in una finestra tipo foglio di calcolo in cui vengono inseriti i vari passaggi. E' un sistema simile agli script di FileMaker, ma meno potente. Per questo motivo molti sviluppatori preferiscono utilizzare Visual Basic for Application (VBA) per scrivere codice. VBA è l'ambiente di programmazione comune alla piattaforma Office e non solo (si può scrivere codice VBA anche per i software CAD) che consente di avere controllo sul database, offrendo nuove funonalità allo sviluppatore. D'altro canto è un sistema non adattato alle esigenze specifiche di un database.

L'approccio di FileMaker all'automazione viene effettuato con l'uso di campi calcolati e script. I campi calcolati vengono definiti durante la creazione della tabella e valutati in maniera automatica ogni qual volta uno dei valori usati nel campo viene modificato. La deifinizione degli script è simile alle macro di Access, ma non esistendo un vero e proprio linguaggio di programmazione in FileMaker, gli script sono più potenti. Questo tipo di approccio però di fatto impedisce alcune funzioni di editing, come ad esempio un copia/incolla diretto degli script.

L'automazione in 4D viene eseguita attraverso i metodi. Il tipo di programmazione è simile al sistema concettuale di VBA, ma il linguaggio, assai comprensibile, è molto adattato alle esigenze di un database. Essendo codice di tipo "testo" è possibile farne copia e incolla fra metodi diversi, come si fa con un normale editor di testi; esiste la possibilità di usare delle macro e di crearne di nuove, di avere un commento per ogni metodo aggiornato anche in automatico con la data, l'ora e l'utente per ogni modifica fatta.

Consulta da questo link l’indice delle faq su 4th Dimension, MS Access e FileMaker Pro

Controllo dell'inserimento nei campi

I filtri di inserimento controllano i caratteri che è consentito digitare in un campo (o in una variabile) da parte dell'utente.

Per esempio se voglio controllare l'inserimento di un codice fiscale posso mettere un filtro del tipo "˜A######&9##˜A#&9##˜A#&9###˜A#".
Dei tre sistemi solo Access e 4D possiedono questa caratteristica, non FileMaker.

Inoltre in FileMaker non è possibile controllare un evento del tipo "on data change" che permetta di eseguire del codice all'uscita da un campo a controllare i dati appena inseriti o modificati.

Consulta da questo link l’indice delle faq su 4th Dimension, MS Access e FileMaker Pro

La sicurezza

Sul versante sicurezza i tre sistemi risultano abbastanza differenti.
In FileMakerPro non esiste una combinazione utente - password come gli altri sistemi, ma supporta solo password. Inoltre le password sono definite a livello dei file, il che significa che per cambiare una password è necessario aprire tutte le tabelle.

Il modello di sicurezza di Access è abbastanza flessibile: possono essere definiti utenti, gruppi di utenti, e i privilegi possono essere assegnati ai singoli utenti o ai gruppi.

Anche 4D permette la creazione di utenti con password e gruppi di utenti e la gestione dei privilegi. Una differenza assai significativa sta nella possibilità di usare una protezione SSL nella comunicazione tra 4D Server e 4D Client: ciò comporta ovviamente una maggiore sicurezza delle comunicazioni, impedendo di fatto un loro intercettamento e/o alterazione.

Consulta da questo link l’indice delle faq su 4th Dimension, MS Access e FileMaker Pro

I form

Se da un lato tutti e tre i prodotti consentono una facile creazione di un form grazie ai wizard, d'altro canto il tipo di oggetti e la possibilità di personalizzarli risulta ben differente.

4D, ad esempio, possiede oggetti per i form che non sono presenti in Access o in FileMaker, come popup menu grafici o gerarchici, liste gerarchiche, splitter, matrici di pulsanti. FileMaker non possiede inoltre i Tab Control, utili ad esempio per gestire form multipagina.

FileMaker Pro 7 ha finalmente apportato delle cospicue migliorie nella personalizzazione dei form: a differenza delle versioni precedenti, infatti, risulta possibile indicare dimensione e coordinate delle finestre, nonché aprire più fineste della stessa tabella contemporaneamente, ognuna con una selezione differente. Continuano però a mancare, ad esempio, i tips al passaggio del mouse su un pulsante.

In Access, a differenza di 4D o FileMaker, un form non appartiene ad una tabella specifica: ciò significa che il form non sa, in partenza, quale è l'origine da cui prendere i dati.

4th Dimension permette una notevole personalizzazione dell'interfaccia, ad esempio:
- controllo su posizione, tipo e dimensione delle finestre;
- più form per la stessa tabella aperti contemporaneamente;
- visibilità controllabile degli oggetti;
- form multipagina;
- tips su tutti gli oggetti del form;
- stili personalizzati che controllano l'aspetto dell'applicazione a seconda del sistema operativo usato, e non solo windows-mac ma anche per le diverse versioni sulla stessa piattaforma;
- personalizzazione della corrispondenza fra combinazioni su tastiera e voci di menu, pulsanti, azioni.

Consulta da questo link l’indice delle faq su 4th Dimension, MS Access e FileMaker Pro

Creazione della struttura
Il primo passo passo da compiere nella progettazione di un database è la creazione della struttura, intesa come definizione di tabelle, campi e relazioni.

In Access la struttura viene creata attraverso un'interfaccia tipo foglio di calcolo, in cui ogni riga rappresenta un campo (colonna) della tabella. Per ogni campo possono essere definiti molti attributi. La definizione delle relazioni dovrà essere impostata in una finestra a parte.

Anche in FileMaker definizione della struttura e definizione delle relazioni avvengono in finestre separate: con la versione 7 è stato abbandonato il sistema ad elenco per passare ad una più moderna ed intuitiva visualizzazione grafica (nonché simile a quella degli altri due sistemi). Rispetto ad Access (e anche a 4D), FileMaker introduce un nuovo tipo di campo, il "campo calcolato", croce e delizia dei programmatori FMP. I campi calcolati vengono definiti usando un editor specifico e vengono trattati alla stessa stregua dei campi "standard": FileMaker si occupa di effettuare il calcolo quando ritiene necessario; se da un lato questo tipo di approccio può sembrare conveniente, esso in realtà nasconde dei problemi. Intanto, visto che il programmatore non ha controllo sull'esecuzione dei calcoli, le prestazioni possono abbassarsi irrimediabilmente. Inoltre, malgrado la versione 7 permetta di creare un file di dati separato dal file contenente script e layout, non risulta un'operazione semplice trasferire nel file della struttura i campi calcolati.

In 4th Dimension la creazione di tabelle, campi e relazioni avviene contemporaneamente nell'unica finestra "Database structure". Cliccando sul titolo di una tabella si inseriscono i dati relativi alla tabella, cliccando su un campo si personalizzano i dati del campo, eseguendo un trascinamento da un campo ad un altro si crea una relazione molti a uno dal campo di partenza a quello di destinazione del trascinamento, cliccando sulla linea che definisce una relazione si impostano le proprietà della relazione.

Consulta da questo link l’indice delle faq su 4th Dimension, MS Access e FileMaker Pro

Con questa faq iniziamo a trattare alcuni degli argomenti che possono aiutare gli sviluppatori che vengono da un altro sistema di sviluppo.

Premesso che ogni strumento di programmazione ha i propri pregi e i propri difetti, l'obiettivo che ci possiamo prefiggere è quello di aiutare chi conosce già MS Access o FileMaker Pro e desideri passare a 4th Dimension, sfruttando in una certa misura le conoscenze già acquisite sulle altre piattaforme, trovando e analizzando sia i punti comuni che le sostanziali differenze. Le informazioni saranno ovviamente più precise su 4D, perché è l'ambiente che conosciamo meglio e su cui siamo ovviamente più aggiornati: è possibile dunque ad esempio che alcune caratteristiche di FileMakerPro 7 non siano citate completamente e/o correttamente.
Dopo questa necessaria introduzione passiamo all'argomento vero e proprio della faq.

NOMENCLATURA: ognuno dei tre sistemi di sviluppo definisce in maniera propria le componenti standard di un database: vediamo di uniformare il linguaggio.

- Tabelle: solo in FileMaker assumono una definizione diversa, cioè File.
- Campi: solo in Access assumono una definizione diversa, cioè Colonne.
- Maschere: i termini maschera, form, layout sono variamente utilizzati.
- Automazione: 4D usa degli oggetti chiamati metodi; Access usa macro e script Visual Basic; FileMaker calcoli automatici e script.
- Struttura: una finestra di relazioni è presente in tutte le piattafome; la struttura di un database 4th Dimension visualizza e permette l'inserimento di tabelle e campi.
- Lista di records: ognuno dei tre sistemi ha il suo modo di chiamare la lista di records: ad esempio se per 4D è il layout di output, per Access è la visualizzazione per foglio di calcolo.
- Ricerche: per costruire le query Access usa un editor, FileMaker effettua la ricerca da form, 4D esegue entrambi i tipi di ricerca con Query by example (che permette la ricerca sul form di inserimento dei dati) e Query editor (un editor visuale che permette la costruzione di una query)
- Selezione di records: ognuna delle tre piattaforme permette di gestire l'insieme dei record attualmente scelti.

Consulta da questo link l’indice delle faq su 4th Dimension, MS Access e FileMaker Pro

I report

Col termine report solitamente si intende un output preparato per la stampa. Ne esistono prevalentemente di due tipi: quello sotto forma di lista o di griglia, per rappresentare un elenco di record, e quello di dettaglio di record, solitamente stampato come una pagina a record. Queste stampe possono avere totali, subtotali raggruppati e quant'altro.

I report in Access vengono creati con lo stesso sistema con cui vengono generati i form. Lo sviluppatore inserisce gli elementi utilizzando una interfaccia grafica e il risultato risulta essere parte integrante del database. Un report di Access può avere come origine dei dati sia un tabella che una query precedentemente creata, da cui prendere i record da stampare.

FileMaker usa il form editor come editor per i report: l'unica differenza tra form e report sta dunque semplicemente nello scopo per cui il layout viene disegnato. Come in Access, anche in FileMaker un form/report è parte integrante del database.

Anche 4D usa il form editor per la creazione dei report. La creazione di intestazioni e subtotali è assimilabile a quella delle altre piattaforme, anche se la mancanza di wizard complessi rende a prima vista meno potente la capacità di reporting di 4D. In realtà, con l'avvento della versione 2003, i programmatori 4th Dimension hanno iniziato ad usare in maniera intensiva un comando diventato potentissimo, PRINT FORM. Questo comando, usato insieme agli altri comandi di gestione di stampa di 4D, permette di avere pieno controllo di un layout: risulta così possibile scegliere quale parte di un form stampare o riempire delle variabili di un form a piacimento a seconda delle necessità, cambiando al volo, da linguaggio font, dimensioni, stili, colori; senza dimenticare la possibilità sempre da linguaggio di orientare il foglio o di conoscere in ogni momento quanti punti del foglio ho già stampato o mi restano da stampare. La differenza tra strumento complesso e strumento flessibile diventa così assai labile.

Come per gli altri strumenti, la creazione di un form rende necessario l'aggiornamento del database. Tuttavia lo sviluppatore può mettere a disposizione dell'utente 4D finale il Quick report editor, che permette all'utente di crearsi autonomamente report personalizzati che vengono salvati in file esterni al database e richiamabili in qualsiasi momento. Quick report editor non genera solo semplici stampe ma, a partire da un report, può generare anche dei grafici, dei file di testo o dei file html.

Consulta da questo link l’indice delle faq su 4th Dimension, MS Access e FileMaker Pro

Per visualizzare l'elenco dei processi e conoscere il processo a cui appartiene un certo form senza aprire il Runtime Explorer basta premere Alt+Shift su Win o Ctrl+Option+Command su Mac e cliccare sul form: viene visualizzato un menu contestuale con l'elenco dei processi (quelli non attivi sono visualizzati come voci disabilitate del menu), e il processo corrente ha accanto un check.

La funzione di questo menu è peraltro quella di entrare in modalità Trace per il processo desiderato.

In un form, se si vogliono creare e numerare automaticamente degli oggetti è possibile scegliere il comando da menu "Duplicate many" per duplicare gli oggetti con uno stile "matrice", avendo anche una numerazione automatica per i nomi degli oggetti e delle variabili.

Nel caso, invece, di oggetti "sparsi" si può seguire un'altra procedura:
- prendiamo un oggetto, ad esempio una variabile, da duplicare più volte;
- con Ctrl+D su Win o Command+D su Mac duplichiamo l'oggetto quante volte è necessario (è l'equivalente da tastiera del comando "Duplicate" del menu);
- selezioniamo tutti gli oggetti così creati e con Ctrl+Alt premuti (Command+Option su Mac) clicchiamo su uno degli oggetti;
- appare una finestra "Increment" che permette di impostare i parametri di numerazione automatica per i nomi delle variabili, che diventeranno così nomevariabile1, nomevariabile2, nomevariabile3, ecc...

Ecco elencati le limitazioni di 4D 2003 sul numero di caratteri dei nomi attribuibili ai vari oggetti del database:

Variabili: 31 (esclusi "$" o "<>");
Tabelle: 31;
Campi: 31;
Metodi: 31;
Form: 31;
Routine dei plug-in: 31;
Set: 80;
Named Selections: 80;
Processi: 31;
Titolo del menu: 15;
Elemento del Menu: 31;
Nome del menu: 31;
List items: 255.

Usando 4D in versione client - server, sulla macchina client vengono creati dei file locali (che evitano traffico ridondante sulla rete). Se 4D Client va in crash o ha dei comportamenti inaspettati, il primo tentativo da fare è sicuramente quello di cancellare questi file temporanei, in modo da costringere 4D Client, al prossimo avvio, a ricrearli.

Per effettuare la cancellazione manualmente bisogna chiudere 4D Client, quindi cercare una cartella sul disco che si chiama come la struttura che stiamo usando e cancellarla.

Alcuni dei posti dove cercare questa cartella possono essere:

HD:System Folder:Application Support: (OS9)
/Library/Application Support/4D/ (OSX)
C:\WINDOWS\4D\ (WIN)

Un'altra strada percorribile per ottenere lo stesso risultato è quella di modificare il valore della risorsa "4D4D" nella struttura: in questo caso sarà il server a forzare l'aggiornamento, poiché il valore di questa risorsa deve essere identico fra Server e Client, e 4D Server effettua questo controllo ad ogni connessione.
La modifica del valore presente in questa risorsa si può effettuare aprendo la struttura con 4D Customizer Plus e cliccando sull'icona "Update".

Usando 4D Engine 2003, per ottenere una applicazione con un'icona personalizzata è sufficiente:
- copiare l'icona nella cartella che contiene il database,
- dare all'icona lo stesso nome dell'applicazione (con l'estensione .ico su Win / .icns su Mac OSX)
- a questo punto, generare l'eseguibile.

Con Mac OS9 risulta invece necessario andare a modificare manualmente i quattro caratteri della application signature della risorsa di tipo BNDL (inserendone una unica rispetto a qualsiasi altra applicazione). Gli stessi quattro caratteri vanno poi scritti nella risorsa SIG*. A questo punto l'icona dell'applicazione è rimpiazzabile con quella personalizzata andando a modificare le icone nelle risorse icl8, icl4, ICN#, ics#, ics4 e ics8: in ognuna di queste risorse l'icone da aprire è quella con ID 128.

Da un colloquio avuto da poco con Anna Cernuschi di Italsoftware sono venuto a conoscenza di una caratteristica di 4D Server che volentieri condivido.

Se i vostri clienti si lamentano perché perché aprire un programma in versione server è troppo lungo (apri il client, scegli l'applicazione corretta, inserisci utente e password), potete creare un file di "scorciatoia" che eviti alcuni o tutti questi passaggi.

Aprite l'applicazione dal client e, dal design, andate nella finestra password. Selezionando un utente, si abiliteranno due voci di menu che permettono il salvataggio dell'utente con o senza password. Scegliamo ad esempio di salvare l'utente con password: dalla maschera standard di salvataggio diamo un nome e una posizione al file.
Il file creato è di tipo client connection: aprendolo con 4D Client l'utente farà accesso al programma senza dover eseguire la trafila precedentemente descritta, come se avesse l'eseguibile o la struttura in locale sulla sua macchina.

Sotto Windows succede sovente che 4D o 4D Server, benché ridotti ad icona, tornino improvvisamente visibili. Questo accade quando la cache viene scritta fisicamente sui dati (appaiono i famosi dischi in basso a sinistra).

Se questo comportamento risulta "fastidioso" è possibile disabilitare la visualizazione dell'indicatore di "Flush Buffers": basta aprire l'applicazione 4th Dimension o 4D Server col Customizer Plus e, andando in "Preferences", disabilitare la voce "Display flush window".

Una finestra di una applicazione 4D può essere spostata cliccandone un punto qualsiasi:
- su Mac, cliccando tenendo premuti i tasti Control e Command;
- su Win, cliccando con entrambi i tasti del mouse tenendo premuto il tasto Control.

Con la versione 2003 è stato introdotto il comando MULTI SORT ARRAY, per
permettere l'ordinamento multilivello di una serie di array sincronizzati.

Inizialmente la sintassi di questo comando prevedeva il passaggio di due
parametri, due array. Il primo array doveva contenere i puntatori agli
array da ordinare, il secondo dei numeri che indicavano il tipo di ordinamento.

A partire dalla versione 2003.2 la sintassi è stata notevolmente
semplificata.

Infatti ora è possibile usare una sintassi molto simile a
quella che si usa per il comando ORDER BY, e cioè
"nome_dell'array;{senso_di_orientamento};nome_dell'array2;{senso_di_orientamento};e_così_via",
dove senso di orientamento o viene omesso (il che signifiva nessun
ordinamento), oppure è uno dei due simboli ">" o "<"; con "ecc." indichiamo
ovviamente l'infinito numero di array che il comando accetta come parametro.

Il file dati è composto di singoli blocchi da 128 byte: in ogni blocco c'è un unico tipo di dati (record, indici, mappa dei blocchi stessi), anche se il blocco non è del tutto pieno; piuttosto un dato può occupare più blocchi.
Quindi un record occupa almeno 128 byte o un suo multiplo.

Ogni record è composto da:
1. Header, sempre 22 byte
a sua volta composto dal
TAG
- identificativo che il blocco è un record
- un checksum per controllare l'integrità del record
- data ultima registrazione dalla cache
- numero tabella
- numero record
e di seguito altre info:
- dimensione della parte fissa del record
- numero dei campi nel record
- dimensione totale del record
- indicatori di campi a dimensione variabile o subrecords
- altri dati riservati

2. Microstruttura del record
Scheletro della struttura del record quando è stato salvato l'ultima volta: per ogni campo ci sono 2 byte per tipo di dati e 2 byte per la posizione dell'inizio del dato vero e proprio. Questo permette la modifica della struttura in ogni momento: ogni record verrà aggiornato solo quando salvato di nuovo sia se è stato modificato il tipo di un campo o se ne sono stati creati altri.

3. Dati del record
I dati veri e propri vengono registrati uno di seguito all'altro senza separatori e occupando solo lo spazio usato.
Integer = 2 byte
Long Integer = 4 byte
Real = 10 byte
Date = 6 byte
Time = 4 byte
Boolean = 2 byte
Alpha = 1 byte di lunghezza + 0-80 byte di dati + 1 di parità (min 2 - max 82)
Text = 4 byte di lunghezza + 0-32000 byte di dati (min 4 - max 32004)
Picture = 4 byte di lunghezza + 0-2MB byte di dati (min 4 - max 2MB)
Blob = 4 byte di lunghezza + 0-2GB byte di dati (min 4 - max 2GB)
Subtable = 8 byte per record, 4 byte per campo + le dimensioni sopra, 2 per l'ultimo subrecord di un record (min 4 - max 2GB)

Maximum e Minimum Cache
C'è un area fissa, dove sta l'eseguibile di 4D che occupa dai 4 ai 6 MB e che non varia.
Nella memoria tampone (Cache) 4d tiene i record, gli indici, le normali selezioni e le named selection.
Nella memoria principale stanno le maschere, i metodi, i menu, i set, il contenuto delle variabili.
Quindi anche se va bene avere tanta cache, occorre bilanciare la cosa lasciando spazio anche alla memoria principale, ad esempio se si usano pesantemente gli array.

Windows Application Memory
Per impostare quantità e dimensione dei blocchi di memoria seguire questa regola molto semplificata: in funzione della memoria principale scelta definire 5 blocchi della dimensione più grande possibile. Considera che se imposti un blocco tropp grosso, ad esempio 20MB, 4d potrebbe non riuscire ad allocarlo se sono liberi solo 19MB.

Database Cache Memory
Il flag "Use New Memory Scheme on Macintosh" va preferibilmente attivato su Mac OS X e Windows: 4d richiede lo spazio da usare come area di memoria tampone al sistema operativo piuttosto che usare quella dell'applicazione stessa.
Su Mac OS 9 è invece più affidabile usare la memoria all'interno dell'applicazione, per evitare problemi causati da altre applicazioni che potrebbero scrivere sulla memoria condivisa. In questo caso va assegnata all'applicazione la memoria totale che gli si può dedicare sul particolare computer e poi con il Customizer la percentuale di Data Cache dovrebbe essere = data cache/(memoria assegnata - 5MB codice)

Flush Data Buffers
Il default è 15 minuti: occorre abbassare questo tempo solo se si prevede una grande quantità di inserimento dati: in questo modo diminuisce il rallentamento dovuto all'accesso al disco (più spesso registri meno dati hai ogni volta).

Le variabili a dimensione fissa occupano la memoria indicata anche se azzerate:
boolean, integer, longint e time = 4 byte in memoria
date = 6 byte
real = 8 byte (10 sui 68k, cioè i Mac pre-Powerpc)
puntatori = 16 byte
string ((dimensione dichiarata+2)\2)*2

Le variabili a dimensioni variabile occupano solo 4 byte come indirizzo se vuote, più la dimensione effettiva usata:
blob, picture, text = 4 byte + dimensione usata

Gli array usano spazio in funzione del numero di elementi (NE) e del tipo:
Array Boolean = (31+NE)\8 (cioè ogni 8 elementi sono i bit di 1 byte)
Array Date = (1+NE)*6
Array Integer = (1+NE)*2
Array Longint = (1+NE)*4
Array Picture = (1+NE)*4 + Somma delle dimensioni delle immagini
Array Pointer = (1+NE)*16
Array Real = (1+NE)*8 (10 sui 68k)
Array String = (1+NE)*(((dimensione dichiarata+2)\2)*2)
Array Text = (1+NE)*6 + Somma delle dimensioni di ogni testo
Array 2D = (1+NE)*12 + Somma delle dimensioni di ogni array