Difference between revisions of "Lazarus Database Overview"

From Lazarus wiki
Jump to navigationJump to search
 
(253 intermediate revisions by 52 users not shown)
Line 1: Line 1:
= The Lazarus Database Tutorial =
+
{{Lazarus Database Overview}}
 +
 
 +
{{Infobox databases}}
  
 
== Overview ==
 
== Overview ==
 +
This article is an overview of which databases can work with Lazarus.
  
This tutorial is about getting Lazarus to work with a variety of existing databases.
+
Lazarus supports several databases out of the box (using e.g. the SQLDB framework), however the developer must install the required packages (client libraries) for each one.  
 
 
Please expand on this section.
 
  
== Lazarus and MySQL ==
+
You can access the database through code or by dropping components on a form. The data-aware components represent fields and are connected by setting the DataSource property to point to a [[TDataSource]]. The Datasource represents a table and is connected to the database components (examples: ''[[TPSQLDatabase]]'', ''[[TSQLiteDataSet]]'') by setting the DataSet property. The data-aware components are located on the [[Data Controls tab]]. The Datasource and the database controls are located on the "Data Access" tab.
  
 +
See the tutorials for Lazarus/FPC built in database access, suitable for Firebird, MySQL, SQLite, PostgreSQL etc:
 +
* [[SQLdb Tutorial0]]
 +
* [[SQLdb Tutorial1]]
 +
* [[SQLdb Tutorial2]]
 +
* [[SQLdb Tutorial3]]
 +
* [[SQLdb Tutorial4]]
  
=== 1 - Get MySQL working in Linux or Windows ===
+
== Lazarus and Interbase / Firebird ==
Follow the instructions in the MySQL User Manual.  Make sure that the mysqld daemon runs reliably, and that all potential users (including root, mysql, yourself and anybody else that may need it) have as many privileges as they need, from as many hosts as may be needed (including 'localhost', the local host's name, any other hosts on your network) as far as is consistent with security.  It is preferable that all users including root have passwords.  Test the action of the database system using the examples given in the manual, and check that all users really do have reliable access.
+
* Firebird is very well supported out of the box by FPC/Lazarus (using SQLDB); please see [[Firebird]] for details.
 +
* [[Other Firebird libraries]] has a list of alternative access libraries (e.g. PDO, Zeos, FBlib)
  
=== 2 - Get MySQL working for FPC in text mode ===
+
== Lazarus and MySQL ==
There is a directory with an example program in $(FreePascal_directory)/packages/base/mysql/ and this directory also contains the units mysql.pp, mysql_com.pp and mysql_version.pp.  Before running the test script, you need to create a database called testdb: do this by logging into the mysql monitor (as root with full privileges) and issuing the following SQL statement
+
* Please see [[mysql]] for details on various access methods, which include:
CREATE DATABASE testdb;
+
# Built-in [[SQLdb_Package|SQLdb]] support
then make sure that all relevant users have appropriate access privileges to it
+
# PDO
GRANT ALL ON testdb TO johnny-user IDENTIFIED BY 'johnnyspassword';
+
# [[ZeosDBO|Zeos]]
There is a script called mkdb which you should now try to run:
+
# [https://www.devart.com/mydac/ MySQL data access Lazarus components]
sh ./mkdb
 
This will probably fail, as the system will not allow an anonymous user to access the database.  So change the script using an editor so that the line invoking mysql reads:
 
mysql -u root -p  ${1-testdb} << EOF >/dev/null
 
and try running it again, entering your password when prompted. With luck you might have managed to create the test database:  test it (while logged in to the mysql monitor) by issuing the mysql statement
 
select * from FPdev;
 
You should see a table listing the ID, username and email address of some of the FPC developers.
 
  
Now try to run the test program testdb.pp (this may need to be compiled, and will almost certainly fail on the first attempt!!).
+
== Lazarus and MSSQL/Sybase ==
 +
You can connect to Microsoft SQL Server databases using
 +
# [https://www.devart.com/sdac/ SQL Server data access Lazarus components].They are working on Windows and macOS. Free to download.
 +
# The built-in '''SQLdb''' connectors '''TMSSQLConnection''' and '''TSybaseConnection''' (since Lazarus 1.0.8/FPC 2.6.2): see [[mssqlconn]].
 +
# '''Zeos''' component '''TZConnection''' (latest CVS, see links to Zeos elsewhere on this page)
 +
## On Windows you can choose between native library '''ntwdblib.dll''' (protocol '''mssql''') or FreeTDS libraries (protocol '''FreeTDS_MsSQL-nnnn''') where nnnn is one of four variants depending on the server version. For Delphi (not Lazarus) there is also another Zeos protocol '''ado''' for MSSQL 2005 or later. Using protocols mssql or ado generates code not platform independient.
 +
## On Linux the only way is with FreeTDS protocols and libraries (you should use '''libsybdb.so''').
 +
# '''ODBC''' (MSSQL and Sybase ASE) with SQLdb '''TODBCConnection''' (consider using '''TMSSQLConnection''' and '''TSybaseConnection''' instead)
 +
## See also [http://wiki.freepascal.org/ODBCConn#Connecting_to_Microsoft_SQL_Server]
 +
## On Windows it uses native ODBC Microsoft libraries (like sqlsrv32.dll for MSSQL 2000)
 +
## On Linux it uses unixODBC + FreeTDS (packages unixodbc or iodbc, and tdsodbc). Since 2012 there is also a Microsoft SQL Server ODBC Driver 1.0 for Linux which is a binary product (no open source) and provides native connectivity, but was released only for 64 bits and only for RedHat.
  
I found that the program could not connect to mysql for several reasons:
+
== Lazarus and ODBC ==
 +
ODBC is a general database connection standard which is available on Linux, Windows and macOS. You will need an ODBC driver from your database vendor and set up an ODBC "data source" (also known as DSN).
 +
You can use the SQLDB components ([[TODBCConnection]]) to connect to an ODBC data soruce.
 +
See [[ODBCConn]] for more details and examples.
  
* My system (SuSE Linux v9.0) installs mysql v4.0.15, not the version3 for which the package was designed. 
+
=== Microsoft Access ===
 +
You can use the ODBC driver on Windows as well as Linux to access Access databases; see [[MS Access]]
  
* The program needs to have user names and passwords to get access to the database.
+
== Lazarus and Oracle ==
 +
* See [[Oracle]]. Access methods include:
 +
# Built-in SQLDB support
 +
# Zeos
 +
# [https://www.devart.com/odac/ Oracle data access Lazarus component]
  
* The compiler needs to know where to find the mysql libraries (IF YOU HAVEN'T INSTALLED THE MYSQL DEVELOPMENT LIBRARIES, DO SO NOW!)
+
== Lazarus and PostgreSQL ==
 
+
* PostgreSQL is very well supported out of the box by FPC/Lazarus
I created a copy of testdb.pp called trydb.pp, rather than editing the original - this means that the original files still get fixed in subsequent CVS updates.
+
* Please see [[postgres]] for details on various access methods, which include:
I also copied the files found in the subdirectory mysql/ver40/ into the main mysql/ subdirectory, renaming them mysql_v4.pp, mysql_com_v4.pp and mysql_version_v4.pp, being sure to rename the units within each file correspondingly.  I changed the uses statement in trydb.pp to
+
# Built-in SQLdb support. Use component '''TPQConnection''' from the [[SQLdb tab]] of the [[Component Palette]]  
uses mysql_v4
+
# [[Zeos]]. Use component '''TZConnection''' with protocol 'postgresql' from palette '''Zeos Access'''
and the statement in mysql_v4.pp to
+
# [https://www.devart.com/pgdac/ PostgreSQL data access Lazarus component]
 
 
 
 
uses mysql_com_v4
 
 
 
I added a line to /etc/fpc.cfg to point to my libraries:
 
-Fl/lib;/usr/lib
 
and in the /usr/lib directory I had to find the real name of the mysqlclient library.  In my case I had to issue the shell command:
 
ln -s libmysqlclient.so.12.0.0 lmysqlclient
 
to make a symbolic link allowing FPC to find the library.  For good measure I also created the link
 
ln -s libmysqlclient.so.12.0.0 mysqlclient
 
and placed similar links in various other directories:  not strictly necessary, but just in case ...!
 
Some users might need to add the following link:
 
ln -s libmysqlclient.so.12.0.0 libmysqlclient.so
 
 
 
I modified trydb.pp to include user details, initially by adding host, user and password as constants:
 
 
 
const
 
  host : Pchar= 'localhost';
 
  user : Pchar= 'myusername';
 
  passwd: Pchar = 'mypassword';
 
 
 
I also found that I couldn't connect to mysql using the mysql_connect() call, but had to use mysql_real_connect() which has many more parameters.  To complicate things further, the number of parameters seems to have changed between version3 (where there are seven) and version4 (where there are eight).  Before using mysql_real_connect I had to use mysql_init() which is not found in the original mysql.pp but is found in mysql_v4.pp.
 
 
 
So the code for connection to the database is now:
 
 
 
{ a few extra variables}
 
var
 
  alloc : PMYSQL;
 
 
 
{main program fragment}
 
 
 
begin
 
  if paramcount=1 then
 
    begin
 
    Dummy:=Paramstr(1)+#0;
 
    DataBase:=@Dummy[1];
 
    end;
 
 
 
Writeln ('Allocating Space...');
 
  alloc := mysql_init(PMYSQL(@qmysql));
 
  Write ('Connecting to MySQL...');
 
  sock :=  mysql_real_connect(alloc, host, user, passwd, database, 0, nil, 0);
 
  if sock=Nil then
 
    begin
 
    Writeln (stderr,'Couldn''t connect to MySQL.');
 
    Writeln (stderr, 'Error was: ', mysql_error(@qmysql));
 
    halt(1);
 
    end;
 
  Writeln ('Done.');
 
  Writeln ('Connection data:');
 
{$ifdef Unix}
 
  writeln ('Mysql_port      : ',mysql_port);
 
  writeln ('Mysql_unix_port : ',mysql_unix_port);
 
{$endif}
 
  writeln ('Host info      : ',mysql_get_host_info(sock));
 
  writeln ('Server info    : ',mysql_stat(sock));
 
  writeln ('Client info    : ',mysql_get_client_info);
 
 
 
  Writeln ('Selecting Database ',DataBase,'...');
 
  if mysql_select_db(sock,DataBase) < 0 then
 
    begin
 
    Writeln (stderr,'Couldn''t select database ',Database);
 
    Writeln (stderr,mysql_error(sock));
 
    halt (1);
 
    end;
 
{... as original contents of testdb.pp}
 
 
 
 
 
Now - ready to start compiling trydb.pp?
 
  fpc trydb
 
success!  Now run it:
 
  ./trydb
 
whoopee!  I got the listing of the FPC developers!
 
 
 
A few extra refinements:  make the entry of user details and the mysql commands interactive, using variables rather than constants, and allow several SQL commands to be entered, until we issue the quit command: see the [[Lazarus Database Tutorial/TryDbpp|full program listing]], where user details are entered from the console, and the program goes into a loop where SQL commands are entered from the console (without the terminal semicolon) and the responses are printed out, until 'quit' is entered from the keyboard.
 
 
 
See [[Lazarus Database Tutorial/SampleListing|Sample Console Listing]].
 
 
 
=== 3 - Connecting to MySQL from a Lazarus Application ===
 
 
 
This tutorial shows how to connect Lazarus to the MySQL database, and execute simple queries, using only the basic Lazarus components; it uses no Data Aware components, but illustrates the principles of interfacing with the database.
 
 
 
Create a new project in Lazarus:
 
Project -> New Project -> Application
 
A new automatically generated Form will appear.
 
 
 
Enlarge the form to fill about half of the screen, then re-name the form and its caption to 'TryMySQL'.
 
 
 
From the Standard Component tab place three Edit Boxes on the upper left side of the Form, and immediately above each box place a label.  Change the names and captions to 'Host' (and HostLLabel,HostEdit), 'UserName' (and UserLabel, UserEdit) and 'Password' (with PasswdLabel and PasswdEdit).  Alternatively you could use LabelledEdit components from the Additional tab.
 
 
 
Select the Passwd Edit box and find the PasswordChar property:  change this to * or some other character, so that when you type in a password the characters do not appear on your screen but are echoed by a series of *s. Make sure that the Text property of each edit box is blank.
 
 
 
Now place another Edit box and label at the top of the right side of your form.  Change the label to 'Enter SQL Command' and name it CommandEdit.
 
 
 
Place three Buttons on the form:  two on the left under the Edit boxes, and one on the right under the command box.
 
 
 
Label the buttons on the left 'Connect to Database' (ConnectButton)and 'Exit' (ExitButton) and the one on the right 'Send Query' (QueryButton).
 
 
 
Place a large Memo Box labelled and named 'Results' (ResultMemo) on the lower right, to fill most of the available space. Find its ScrollBars property and select ssAutoBoth so that scroll bars appear automatically if text fills the space.  Make the WordWrap property True.
 
 
 
Place a Status Bar (from the Common Controls tab) at the bottom of the Form, and make its SimpleText property 'TryMySQL'.
 
 
 
A screenshot of the Form can be seen here: [http://lazarus-ccr.sourceforge.net/kbdata/trymysqldb.png Mysql Example Screenshot]
 
 
 
Now we need to write some event handlers.
 
 
 
The three Edit boxes on the left are for entry of hostname, username and password.  When these have been entered satisfactorily, the Connect Button is clicked.  The OnCLick event handler for this button is based on part of the text-mode FPC program above.
 
 
 
The responses from the database cannot now be written using the Pascal write or writeln statements: rather, the replies have to be converted into strings and displayed in the Memo box.  Whereas the Pascal write and writeln statements are capable of performing a lot of type conversion 'on the fly', the use of a memo box for text output necessitates the explicit conversion of data types to the correct form of string, so Pchar variables have to be converted to strings using StrPas, and integers have to be converted with IntToStr. 
 
 
 
Strings are displayed in the Memo box using
 
 
 
procedure ShowString (S : string);
 
(* display a string in a Memo box *)
 
begin
 
        trymysqlForm1.ResultsMemo.Lines.Add (S)
 
end;
 
 
 
The ConnectButton event handler thus becomes:
 
 
 
procedure TtrymysqlForm1.ConnectButtonClick(Sender: TObject);
 
(* Connect to MySQL using user data from Text entry boxes on Main Form *)
 
var strg: string;
 
 
 
begin
 
 
 
  dummy1 :=  trymysqlForm1.HostEdit.text+#0;
 
  host := @dummy1[1];
 
  dummy2 := trymysqlForm1.UserEdit.text+#0;
 
  user := @dummy2[1] ;
 
  dummy3 := trymysqlForm1.PasswdEdit.text+#0;
 
  passwd := @dummy3[1] ;
 
 
 
  alloc := mysql_init(PMYSQL(@qmysql));
 
  sock :=  mysql_real_connect(alloc, host, user, passwd, database, 0, nil, 0);
 
  if sock=Nil then
 
    begin
 
      strg :='Couldn''t connect to MySQL.'; showstring (strg);
 
      Strg :='Error was: '+ StrPas(mysql_error(@qmysql)); showstring (strg);
 
  end
 
    else
 
    begin
 
      trymysqlForm1.statusBar1.simpletext := 'Connected to MySQL';
 
      strg := 'Now choosing database : ' + database; showstring (strg);
 
{$ifdef Unix}
 
      strg :='Mysql_port      : '+ IntToStr(mysql_port); showstring (strg);
 
      strg :='Mysql_unix_port : ' + StrPas(mysql_unix_port); showstring (strg);
 
{$endif}
 
      Strg :='Host info      : ' + StrPas(mysql_get_host_info(sock));
 
      showstring (strg);
 
      Strg :='Server info    : ' + StrPas(mysql_stat(sock)); showstring (strg);
 
      Strg :='Client info    : ' + Strpas(mysql_get_client_info);  showstring (strg);
 
 
 
      trymysqlForm1.statusbar1.simpletext := 'Selecting Database ' + DataBase +'...';
 
  if mysql_select_db(sock,DataBase) < 0 then
 
  begin
 
    strg :='Couldn''t select database '+ Database; ShowString (strg);
 
    Strg := mysql_error(sock); ShowString (strg);
 
  end
 
  end;
 
end;
 
 
 
 
 
The Text Box on the right allows entry of a SQL statement, without a terminal semicolon;  when you are satisfied with its content or syntax, the SendQuery button is pressed, and the query is processed, with results being written in the ResultsMemo box.
 
 
 
The SendQuery event handler is again based on the FPC text-mode version, except that once again explicit type-conversion has to be done before strings are displayed in the box.
 
 
 
A difference from the text-mode FPC program is that if an error condition is detected, the program does not halt and MySQL is not closed;  instead, control is returned to the main form and an opportunity is given to correct the entry before the command is re-submitted.  The application finally exits (with closure of MySQL) when the Exit Button is clicked.
 
 
 
The code for SendQuery follows:
 
 
 
procedure TtrymysqlForm1.QueryButtonClick(Sender: TObject);
 
var
 
  dumquery, strg: string;
 
begin
 
      dumquery := TrymysqlForm1.CommandEdit.text;
 
      dumquery := dumquery+#0;
 
      query := @dumquery[1];
 
      trymysqlForm1.statusbar1.simpletext := 'Executing query : '+ dumQuery +'...';
 
      strg := 'Executing query : ' + dumQuery; showstring (strg);
 
      if (mysql_query(sock,Query) < 0) then
 
      begin
 
        Strg :='Query failed '+ StrPas(mysql_error(sock)); showstring (strg);
 
      end
 
      else
 
      begin
 
        recbuf := mysql_store_result(sock);
 
        if RecBuf=Nil then
 
        begin
 
          Strg :='Query returned nil result.'; showstring (strg);
 
        end
 
        else
 
        begin
 
          strg :='Number of records returned  : ' + IntToStr(mysql_num_rows (recbuf));
 
          Showstring (strg);
 
          Strg :='Number of fields per record : ' + IntToStr(mysql_num_fields(recbuf));
 
          showstring (strg);
 
          rowbuf := mysql_fetch_row(recbuf);
 
          while (rowbuf <>nil) do
 
          begin
 
              Strg :='(Id: '+ rowbuf[0]+', Name: ' + rowbuf[1]+ ', Email : ' +
 
                rowbuf[2] +')';
 
              showstring (strg);
 
              rowbuf := mysql_fetch_row(recbuf);
 
          end;
 
        end;
 
      end;
 
end;
 
 
 
 
 
Save your Project, and press Run -> Run
 
 
 
=== Download MYSQL Source Code ===
 
A full listing of the  program is available here [http://lazarus-ccr.sourceforge.net/kbdata/mysqldemo.tar.gz Sample Source Code]
 
 
 
== Lazarus and Postgresql ==
 
 
 
Please write me!
 
  
 
== Lazarus and SQLite ==
 
== Lazarus and SQLite ==
 +
SQLite is an embedded database; the database code can be distributed as a library (.dll/.so/.dylib) with your application to make it self-contained (comparable to Firebird embedded). SQLite is quite popular due to its relative simplicity, speed, small size and cross-platform support.
  
by Luiz Américo
+
Please see the [[SQLite]] page for details on various access methods, which include:
 
+
# Built-in SQLDb support. Use component '''TSQLite3Connection''' from palette '''SQLdb'''
===Introduction===
+
# Zeos
 
+
# SQLitePass
There are two TDataset descendants which access sqlite2.x databases: sqlitedataset.TSqlite and sqliteds.TSqliteDataset. The second is newer and has some advantages over the former: its faster, allows inserts, updates and deletes and can apply the updates to the database automatically. So the instructions found here are valid only for the TSlqiteDataset class which is found in unit sqliteds.pas 
+
# TSQLite3Dataset
 
+
# [https://www.devart.com/litedac/ SQLite data access Lazarus components]
===Requirements===
 
* fpc 1.9.8
 
* sqliteds.pas (get from fpc/fcl/db/sqlite at CVS) [Optional]
 
* sqlite runtime library 2.8.15 or above (get from www.sqlite.org)
 
 
 
'''Before initiating a lazarus projects, ensure that:'''
 
* the sqlite library is on the system PATH
 
* under linux, put cmem as the first unit in uses clause of the main program
 
  
===How to use===
+
== Lazarus and Firebird/Interbase ==
  
The sqlite package that comes with lazarus relies on the outdated sqlitedataset unit.
+
InterBase (and FireBird) Data Access Components (IBDAC) is a library of components that provides native connectivity to InterBase, Firebird and Yaffil from Lazarus (and Free Pascal) on Windows, macOS, iOS, Android, Linux, and FreeBSD for both 32-bit and 64-bit platforms. IBDAC-based applications connect to the server directly using the InterBase client. IBDAC is designed to help programmers develop faster and cleaner InterBase database applications.
A package that uses the new unit can be found [http://www.geocities.com/camara_luiz/sqliteds.zip link here]
 
  
At design time set the following properties:
+
IBDAC is a complete replacement for standard InterBase connectivity solutions. It presents an efficient alternative to InterBase Express Components, the Borland Database Engine (BDE), and the standard dbExpress driver for access to InterBase.
 
 
- FileName: path of the sqlite file [required]
 
- TableName: name of the table used in the sql statement [required]
 
- Sql: a SQL select statement [optional]
 
 
 
||Creating a Table (dataset)||
 
 
 
For now it's not possible to create the dataset at design time, so its necessary to create the dataset at run time if it not already exists, generally at OnCreate event of the main form.
 
 
 
The example bellow shows how it can be done (dsTest is a TSqliteDataSet instance):
 
  // Create a Table with all field types supported by TSqliteDataset
 
  with dsTest do
 
  begin
 
    if not TableExists then
 
    begin
 
      with FieldDefs do
 
      begin
 
        Clear;
 
        Add('Integer',ftInteger);
 
        Add('AutoInc',ftAutoInc);
 
        Add('String',ftString);
 
        Add('Memo',ftMemo);
 
        Add('Bool',ftBoolean);
 
        Add('Float',ftFloat);
 
        Add('Word',ftWord);
 
        Add('DateTime',ftDateTime);
 
        Add('Date',ftDate);
 
        Add('Time',ftTime);
 
      end;
 
      CreateTable;
 
    end;
 
  end;
 
 
 
||Retrieving the data||
 
 
 
After creating the table, open the dataset with Open method.
 
If the SQL property was not set then all records from all fields will be retrieved, the same as
 
 
 
  SQL:='Select * from TABLENAME';
 
But it's possible to retrieve a combination of the fields setting SQL as bellow:
 
 
 
  SQL:='Select Float from TABLENAME';
 
  SQL:='Select String,Date,Word from TABLENAME';
 
Remenber that the number of fields and the order of the fields that will be available after opening the dataset are determined by the select statement. In the previous examples the dataset would have 10, 1 and 3 fields respectively.
 
 
 
||Applying changes to the underlying datafile||
 
 
 
For now, it's necessary that the dataset have an AutoInc field or that FieldIndexName stores the name  of a field that acts like a Primary Key.
 
 
 
For example, if the Field 'Integer' stores values that are Unique and not Null, then setting
 
 
 
  FieldIndexName:='Integer';
 
 
 
will allow the data to be stored in the underlying database(file)
 
 
 
After this just call ApplyUpdates
 
 
 
===Remarks===
 
 
 
* Although tested with 10000 records and worked fine, TSqliteDataset keeps all the data in memory, so remenber to retrieve only the necessary data (principally with Memo Fields).
 
* The same datafile(filename property) can host several tables/datasets
 
* Several datasets (different combinations of fields) can be created using the same table simultaneously
 
* It's possible to filter the data using WHERE statements in the sql, closing and reopening the dataset (or calling RefetchData method). But in this case, the order and number of fields must remains the same
 
* It's also possible to use complexes SQL statements using aliases or joins in multiples tables (remenber that they must reside in the same datafile), but in this case ApplyUpdates won't work. If someone wants to use complexes queries and to apply the updates to the datafile, mail me and i will give some hints how to do that
 
* Setting filename to a sqlite2.x datafile not created by TSqliteDataset and opening it is allowed but some fields won't have the correct field type detected. These will be treated as string fields.
 
 
 
A generic examples can be found at fpc/fcl/sqlite CVS dir
 
 
 
Luiz Américo
 
pascalive(at)bol(dot)com(dot)br
 
 
 
== Lazarus and MSSQL ==
 
 
 
Please write me!
 
  
 +
[https://www.devart.com/ibdac/download.html Firebird data access components for Lazarus] are free to download.
  
 
== Lazarus and dBase ==
 
== Lazarus and dBase ==
  
[[user:Tonymaro|Tony Maro]]
+
FPC includes a simple database component that is derived from the Delphi TTable component called "TDbf" [http://tdbf.sourceforge.net/ TDbf Website]). It supports various DBase and Foxpro formats.
 
 
You might also want to visit the beginnings of the [[Lazarus Tdbf Tutorial|TDbf Tutorial page]]
 
 
 
FPC includes a simple database component that is similar in function to the Delphi TTable component called "TDbf" ([http://tdbf.sourceforge.net/ TDbf Website]) that supports a very basic subset of features for dBase files. It is not installed by default, so you will first need to install the Lazarus package from the "lazarus/components/tdbf" directory and rebuild your Lazarus IDE.  It will then appear next to the TDatasource in your component palette.
 
 
 
The TDbf component has an advantage over other database components in that it doesn't require any sort of runtime database engine, however it's not the best option for large database applications.
 
 
 
It's very easy to use.  Simply, put, drop a TDbf on your form, set the runtime path to the directory that your database files will be in, set the table name, and link it to your TDatasource component.
 
 
 
Real functionality requires a bit more effort, however.  If a table doesn't already exist, you'll need to create it programmatically, unless there's a compatible table designer I'm not familiar with.
 
 
 
Attempting to open a non-existant table will generate an error.  Tables can be created programmatically through the component after the runtime path and table name are set.
 
 
 
For instance, to create a table called "dvds" to store your dvd collection you would drop it on your form, set the runtime path, and set the table name to "dvds".  The resulting file will be called "dvds.dbf".
 
 
 
In your code, insert the following:
 
 
 
    Dbf1.FilePathFull = '/path/to/my/database';
 
    Dbf1.TableName = 'dvds';
 
    With Dbf1.FieldDefs do begin
 
        Add('Name', ftString, 80, True);
 
        Add('Description', ftMemo, 0, False);
 
        Add('Rating', ftString, 5, False);
 
    end;
 
    Dbf1.CreateTable;
 
 
 
When this code is run, your DVD collection table will be created.  After that, all data aware components linked through the TDatasource to this component will allow easy access to the data. 
 
 
 
=== Note: the index example only works with the CVS edition of FPC ===
 
 
 
Adding indexes is a little different from your typical TTable.  It must be done after the database is open.  It's also the same method you use to rebuild the indexes.  For instance:
 
 
 
    Dbf1.Exclusive := True;
 
    Dbf1.Open;
 
    Dbf1.AddIndex('dvdsname','Name',[ixPrimary, ixUnique, ixCaseInsensitive]);
 
    Dbf1.AddIndex('rating.ndx', 'Rating', [ixCaseInsensitive]);
 
    Dbf1.Close;
 
 
 
The first (primary) index will be a file called "dvdsname.mdx" and the second will be a file named "rating.ndx" so in a multiple table database you must be careful not to use the same file name again.
 
 
 
I will try to add a more detailed example at a later date, but hopefully this will get those old Delphi programmers up and running with databases in Lazarus!
 
 
 
=== Lazarus and dBase -- How to update your copy ===
 
[YoyongHernan|]
 
 
 
How to use TDbf in lazarus (Linux)
 
 
 
1. Update your copy of fcl. FPC verion 1.9.4 is known to work prorperly with this package.
 
 
 
Steps to update:
 
a. Assuming that the cvs files from FPC is located in repo. Then
 
  cd ~/repo
 
 
 
b. Login to cvs
 
  cvs -d :pserver:cvs@cvs.freepascal.org:/FPC/CVS login
 
  password is cvs
 
 
 
c. Now the actual update
 
  cvs -d :pserver:cvs@cvs.freepascal.org/FPC/CVS -z 3 update fpc/fcl
 
The above command will udpate your fcl source copy.
 
 
 
d. Delete some files in your fcl directory.
 
  su
 
  cd /usr/local/lib/fpc/1.9.4/units/linux/fcl
 
  rm db*.*
 
Note: Change to the directory specified in "cd" accordingly.
 
Note: To check the exact location of the units. Assuming of course that you have a working FPC configuration. Type
 
  fpc -vt bogus
 
And look for something that reads
 
Using unit path: /usr/local/lib/fpc/1.9.4/*
 
Note: In almost all systems, you need to be the root user to do this.
 
 
 
e. Compile the newest Tdbf sources.
 
Goto to your FPC FCL directory
 
  cd ~/repo/fpc/fcl/db
 
  make && make install
 
The above command will try to compile your sources in the db directory and install the units into /usr/local/bin/fpc/1.9.4/units/linux/fcl
 
Note: Must be root for make install to succeed.
 
 
 
f. Check if the units are there. Now the tricky part. As of this time, FPC compiler will search for your units based on two steps. First it will check if the unit can be found by using the uppercase of your units, i.e.,DB.PPU. If the compiler cannot find this it will try db.ppu. As you can see the files just compiled shows that the units starts with capital D??????. So this will fail your system to find the units for the tdbf. To remedy this just change all Db*.* to lowercase.
 
 
 
If you are lazy like me, you can use the perl script below to change the case to lowercase.
 
  #!/usr/bin/perl
 
  use Cwd;
 
  use File::Copy;
 
 
 
  #this script will rename the files to lower case. useful for FPC programming
 
 
 
  printf "This renames all the files to lower case found in the current directory\n";
 
 
 
  #create a directory containing the lowercase files
 
  if (length(`ls -d lcase`) > 0 ){
 
  print "directory exists\n";
 
  print "Deleting files located in lcase directory\n";
 
  `rm -d -r lcase`;
 
  }
 
  `mkdir lcase`;
 
 
 
  
  #get the current directory
+
'''TDbf''' does not accept SQL commands but you can use the dataset methods etc and you can also use regular databound controls such as the DBGrid.
  $dir = cwd();
 
  $source = $dir;
 
  #set to the source directory
 
  $source .= "/source";
 
  
  #open the directory
+
It doesn't require any sort of runtime database engine. However it's not the best option for large database applications.
  opendir(DIR, $source);
 
  #read the files/direcotry
 
  @dirlist = readdir(DIR);
 
  
  #process the files now
+
See the [[Lazarus Tdbf Tutorial|TDbf Tutorial page]] for the tutorial as well as documentation.
  chdir($source);
 
  foreach $myfile(@dirlist) {
 
  print "copying file $myfile\n";
 
  $newfile = $dir;
 
  $newfile .= "/lcase/";
 
  $newfile .= lc($myfile);
 
  copy($myfile,$newfile);
 
  }
 
  
 +
You can use e.g. OpenOffice/LibreOffice Base to visually create/edit dbf files, or create DBFs in code using [[TDbf]].
  
  #close the opened directory
+
== Lazarus and Paradox ==
  closedir(DIR);
+
Paradox was the default format for database files in old versions of Delphi.
 +
The concept is similar to DBase files/DBFs, where the "database" is a folder, and each table is a file inside that folder. Also, each index is a file too.
 +
To access this files from Lazarus we have these options:
  
I. Save the script in /home/yourdirectory/temp/renameme.pl
+
* '''[[TParadox]]''': Install package "lazparadox 0.0" included in the standard distribution. When you install this package, you will see a new component labeled "PDX" in the "Data Access" palette. This component is not standalone, it uses a "native" library, namely the [http://pxlib.sourceforge.net pdxlib library] which is available for Linux and Windows. For example, to install in Debian, you could get '''pxlib1''' from package manager. In Windows you need the pxlib.dll file.  
II. Change the mode of the file
 
    chmod 755 renameme.pl
 
III. Move all the Db*.* from /usr/local/lib/fpc/1.9.4/units/linux/fcl to /home/yourdirectory/temp/source.
 
IV. Run renameme.pl
 
    ./renameme.pl
 
V. Copy the files in /home/yourdirectory/temp/lcase to /usr/local/lib/fpc/1.9.4/units/linux/fcl
 
  
2. Run Lazarus.
+
* '''[[TPdx]]''': Paradox DataSet for Lazarus and Delphi from [http://tpdx.sourceforge.net/ this site]. This component is standalone (pure object pascal), not requiring any external library, but it can only read (not write) Paradox files. The package to install is "paradoxlaz.lpk" and the component should appear in the "Data Access" palette with PDX label (but orange colour).  
  
3. Install the TDbf package
+
* '''[[TParadoxDataSet]]''': is a [[TDataSet]] that can only read Paradox Files up to Version 7. The approach is similar to the TPdx component, the package to install is "lazparadox.lpk" and the component should also appear in the "Data Access" palette.
Compoenents->Open Package File->Browse to lazarus_directory/components/tdbf/dbflaz.lpk
 
  
4. Click on compile.
+
== TSdfDataset and TFixedDataset ==
 +
[[TSdfDataSet]] and [[TFixedFormatDataSet]] are two simple [[TDataSet]] descandants which offer a very simple textual storage format. These datasets are very convenient for small databases, because they are fully implemented as an Object Pascal unit, and thus require no external libraries. Also, their textual format allows them to be easily viewed/edited with a text editor.
  
5. Click on install. Upon lazarus restart the new component can be found in Data Access Page.
+
See [[CSV]] for example code.
  
== Translations of This Page ==
+
== Lazarus and Advantage Database Server ==
 +
* Please see [[Advantage Database Server]] for details on using Advantage Database Server
  
[[DbSpanishTutorial|Spanish]] by Eduardo Lopez (thanks! :)
+
==See also==
 +
(Sorted alphabetically)
 +
* [[Portal:Databases|Database Portal]]
 +
* [[Databases]]
 +
* [[Database_field_type]]
 +
* [[How to write in-memory database applications in Lazarus/FPC]]
 +
* [[Lazarus DB Faq]]
 +
* [[Lazarus Tdbf Tutorial]]
 +
* [[multi-tier_options_with_fpc|Multi-tier options with FPC]]
 +
* [[SQLdb Tutorial1]]
 +
* [[SqlDBHowto]]
 +
* [[tiOPF]] - a free and open source Object Persistence Framework.
 +
* [[Zeos tutorial]]
  
== Related Links ==
+
==External links==
[[Databases|Creating Databases Applications with Lazarus using the DB-unit]]
 
  
==Contributors and Changes==
+
* [http://pdo.sourceforge.net Pascal Data Objects] - a database API that worked for both FPC and Delphi and utilises native MySQL libraries for version 4.1 and 5.0 and Firebird SQL 1.5, and 2.0.  It's inspired by PHP's PDO class.
This page has been converted from the epikwiki [http://lazarus-ccr.sourceforge.net/index.php?wiki=LazarusDatabase version].
+
* [http://lazaruszeos.blogspot.com Zeos+SQLite Tutorial] - Good tutorial using screenshots and screencasts it explain how to use SQLite and Zeos, spanish (google translate does a good work in translating it to english)

Latest revision as of 02:31, 24 November 2021

English (en) español (es) français (fr) 日本語 (ja) polski (pl) русский (ru)

Databases portal

References:

Tutorials/practical articles:

Databases

Advantage - MySQL - MSSQL - Postgres - Interbase - Firebird - Oracle - ODBC - Paradox - SQLite - dBASE - MS Access - Zeos

Overview

This article is an overview of which databases can work with Lazarus.

Lazarus supports several databases out of the box (using e.g. the SQLDB framework), however the developer must install the required packages (client libraries) for each one.

You can access the database through code or by dropping components on a form. The data-aware components represent fields and are connected by setting the DataSource property to point to a TDataSource. The Datasource represents a table and is connected to the database components (examples: TPSQLDatabase, TSQLiteDataSet) by setting the DataSet property. The data-aware components are located on the Data Controls tab. The Datasource and the database controls are located on the "Data Access" tab.

See the tutorials for Lazarus/FPC built in database access, suitable for Firebird, MySQL, SQLite, PostgreSQL etc:

Lazarus and Interbase / Firebird

  • Firebird is very well supported out of the box by FPC/Lazarus (using SQLDB); please see Firebird for details.
  • Other Firebird libraries has a list of alternative access libraries (e.g. PDO, Zeos, FBlib)

Lazarus and MySQL

  • Please see mysql for details on various access methods, which include:
  1. Built-in SQLdb support
  2. PDO
  3. Zeos
  4. MySQL data access Lazarus components

Lazarus and MSSQL/Sybase

You can connect to Microsoft SQL Server databases using

  1. SQL Server data access Lazarus components.They are working on Windows and macOS. Free to download.
  2. The built-in SQLdb connectors TMSSQLConnection and TSybaseConnection (since Lazarus 1.0.8/FPC 2.6.2): see mssqlconn.
  3. Zeos component TZConnection (latest CVS, see links to Zeos elsewhere on this page)
    1. On Windows you can choose between native library ntwdblib.dll (protocol mssql) or FreeTDS libraries (protocol FreeTDS_MsSQL-nnnn) where nnnn is one of four variants depending on the server version. For Delphi (not Lazarus) there is also another Zeos protocol ado for MSSQL 2005 or later. Using protocols mssql or ado generates code not platform independient.
    2. On Linux the only way is with FreeTDS protocols and libraries (you should use libsybdb.so).
  4. ODBC (MSSQL and Sybase ASE) with SQLdb TODBCConnection (consider using TMSSQLConnection and TSybaseConnection instead)
    1. See also [1]
    2. On Windows it uses native ODBC Microsoft libraries (like sqlsrv32.dll for MSSQL 2000)
    3. On Linux it uses unixODBC + FreeTDS (packages unixodbc or iodbc, and tdsodbc). Since 2012 there is also a Microsoft SQL Server ODBC Driver 1.0 for Linux which is a binary product (no open source) and provides native connectivity, but was released only for 64 bits and only for RedHat.

Lazarus and ODBC

ODBC is a general database connection standard which is available on Linux, Windows and macOS. You will need an ODBC driver from your database vendor and set up an ODBC "data source" (also known as DSN). You can use the SQLDB components (TODBCConnection) to connect to an ODBC data soruce. See ODBCConn for more details and examples.

Microsoft Access

You can use the ODBC driver on Windows as well as Linux to access Access databases; see MS Access

Lazarus and Oracle

  • See Oracle. Access methods include:
  1. Built-in SQLDB support
  2. Zeos
  3. Oracle data access Lazarus component

Lazarus and PostgreSQL

  • PostgreSQL is very well supported out of the box by FPC/Lazarus
  • Please see postgres for details on various access methods, which include:
  1. Built-in SQLdb support. Use component TPQConnection from the SQLdb tab of the Component Palette
  2. Zeos. Use component TZConnection with protocol 'postgresql' from palette Zeos Access
  3. PostgreSQL data access Lazarus component

Lazarus and SQLite

SQLite is an embedded database; the database code can be distributed as a library (.dll/.so/.dylib) with your application to make it self-contained (comparable to Firebird embedded). SQLite is quite popular due to its relative simplicity, speed, small size and cross-platform support.

Please see the SQLite page for details on various access methods, which include:

  1. Built-in SQLDb support. Use component TSQLite3Connection from palette SQLdb
  2. Zeos
  3. SQLitePass
  4. TSQLite3Dataset
  5. SQLite data access Lazarus components

Lazarus and Firebird/Interbase

InterBase (and FireBird) Data Access Components (IBDAC) is a library of components that provides native connectivity to InterBase, Firebird and Yaffil from Lazarus (and Free Pascal) on Windows, macOS, iOS, Android, Linux, and FreeBSD for both 32-bit and 64-bit platforms. IBDAC-based applications connect to the server directly using the InterBase client. IBDAC is designed to help programmers develop faster and cleaner InterBase database applications.

IBDAC is a complete replacement for standard InterBase connectivity solutions. It presents an efficient alternative to InterBase Express Components, the Borland Database Engine (BDE), and the standard dbExpress driver for access to InterBase.

Firebird data access components for Lazarus are free to download.

Lazarus and dBase

FPC includes a simple database component that is derived from the Delphi TTable component called "TDbf" TDbf Website). It supports various DBase and Foxpro formats.

TDbf does not accept SQL commands but you can use the dataset methods etc and you can also use regular databound controls such as the DBGrid.

It doesn't require any sort of runtime database engine. However it's not the best option for large database applications.

See the TDbf Tutorial page for the tutorial as well as documentation.

You can use e.g. OpenOffice/LibreOffice Base to visually create/edit dbf files, or create DBFs in code using TDbf.

Lazarus and Paradox

Paradox was the default format for database files in old versions of Delphi. The concept is similar to DBase files/DBFs, where the "database" is a folder, and each table is a file inside that folder. Also, each index is a file too. To access this files from Lazarus we have these options:

  • TParadox: Install package "lazparadox 0.0" included in the standard distribution. When you install this package, you will see a new component labeled "PDX" in the "Data Access" palette. This component is not standalone, it uses a "native" library, namely the pdxlib library which is available for Linux and Windows. For example, to install in Debian, you could get pxlib1 from package manager. In Windows you need the pxlib.dll file.
  • TPdx: Paradox DataSet for Lazarus and Delphi from this site. This component is standalone (pure object pascal), not requiring any external library, but it can only read (not write) Paradox files. The package to install is "paradoxlaz.lpk" and the component should appear in the "Data Access" palette with PDX label (but orange colour).
  • TParadoxDataSet: is a TDataSet that can only read Paradox Files up to Version 7. The approach is similar to the TPdx component, the package to install is "lazparadox.lpk" and the component should also appear in the "Data Access" palette.

TSdfDataset and TFixedDataset

TSdfDataSet and TFixedFormatDataSet are two simple TDataSet descandants which offer a very simple textual storage format. These datasets are very convenient for small databases, because they are fully implemented as an Object Pascal unit, and thus require no external libraries. Also, their textual format allows them to be easily viewed/edited with a text editor.

See CSV for example code.

Lazarus and Advantage Database Server

See also

(Sorted alphabetically)

External links

  • Pascal Data Objects - a database API that worked for both FPC and Delphi and utilises native MySQL libraries for version 4.1 and 5.0 and Firebird SQL 1.5, and 2.0. It's inspired by PHP's PDO class.
  • Zeos+SQLite Tutorial - Good tutorial using screenshots and screencasts it explain how to use SQLite and Zeos, spanish (google translate does a good work in translating it to english)