Last week we released a new product, TMS MQTT. MQTT is a standard lightweight machine 2 machine messaging protocol. This enables the instant exchange of binary or text messages between code running on various operating systems. To fully take advantage of this, we developed our TMS MQTT client to work in VCL Windows applications, FMX Windows, macOS, iOS and Android applications and also on Linux desktop or Linux variants such as Raspbian on Raspberry Pi via FPC/Lazarus.

On this 22th birthday of Delphi, I wanted to show you how our TMS MQTT component allows you to develop a messaging application in a real RAD way. I'll do this by implementing a chat application that allows you to chat between clients running on desktops or mobile devices. This effectively takes less than 40 lines of code using the TMS MQTT component of which 15 lines already go to inserting the chat text left and right in items of an FMX listbox and another +/- 10 lines detecting the origin of the chat text that is received to decide whether to show it left or right in the listbox. So, I'd say only about 15 lines of code effectively concern using the MQTT client to do the messaging.

For this demo, we use the Mosquitto MQTT test broker and connect to it with 2 lines of code:

begin
  TMSMQTTClient1.BrokerHostName := 'test.mosquitto.org';
  TMSMQTTClient1.Connect();
end;

procedure TForm1.TMSMQTTClient1ConnectedStatusChanged(ASender: TObject;
  const AConnected: Boolean);
begin
  if AConnected then
    TMSMQTTClient1.Subscribe('/tms/chat/');
end;

  TMSMQTTClient1.Publish('/tms/chat/', TMSMQTTClient1.ClientID+'!'+ memo1.Lines.Text);

procedure TForm1.TMSMQTTClient1PublishReceived(ASender: TObject;
  APacketID: Word; ATopic: string; APayload: TArray);
var
  msg,orig: string;
  vp: integer;
  alright: boolean;
begin
  msg := TEncoding.UTF8.GetString(APayload);

  vp := pos('!', msg);

  if vp > 0 then
  begin
    orig := copy(msg,1,vp-1);
    alright := orig <> TMSMQTTClient1.ClientID;

    msg := copy(msg, vp + 1, Length(msg));
    AddMessage(msg, alright);
  end;
end;

procedure TForm1.AddMessage(AMessage: string; AlignRight: boolean);
var
  li: Tlistboxitem;
begin
  li := Tlistboxitem.Create(self);
  li.StyledSettings := li.StyledSettings - [TStyledSetting.ssOther];
  li.Text := AMessage;
  li.Height := 22;
    li.VertTextAlign := TTextAlign.taTrailing;

  if AlignRight then
    li.TextAlign := TTextAlign.taTrailing
  else
    li.TextAlign := TTextAlign.taLeading;

  listbox1.AddObject(li);
end;

How to talk about object-oriented programming and not consider inheritance? In my opinion is a basic "feature" of OOP. And how to talk about an ORM without supporting inheritance? I consider it so important that the simply fact that Aurelius supports it makes it my #3 of My Top 10 Aurelius Features.



It's really nice to be able to model classes and build a class hierarchy, reference classes in that hierarchy from other properties, have a true model that is not just a bunch of plain classes that map properties to database columns. Inheritance support allows you to really think in an OOP way when using an ORM.

TMS Aurelius supports two ways of persisting objects in a class hierarchy in the database:

Joined-tables strategy
Where data from each class is saved in a different database. This is the more normalized way.

Single-table strategy
Where data from all classes are saved in a single table. This is the simplest and often offers better performance.

Regardless of your choice, the facts is that Aurelius allows you to do so! Watch the video above to see how class inheritance works with TMS Aurelius, and if you want to get notified about upcoming videos, subscribe to our YouTube channel!

With the many positive responses on our Facebook post about #ILoveDelphi and thanks to the inspiration given by Szabó about 'the cup and can', we came up with the idea to bring the love between Delphi and TMS alive in a coffee cup!

As promised in the blog about building a chat application with MQTT, here is a follow-up article on using the TMS MQTT client, this time to setup messaging between a Raspberry Pi and a Windows PC. The TMS MQTT client fully supports Lazarus and thus also targetting Linux and its variant Raspbian, so we can use the TMS MQTT Client from Raspberry Pi. For this short demo, we setup Lazarus on Raspberry Pi and installed the TMS MQTT client component in the IDE as well as our free Raspberry Pi hardware lib.

We'll use the component TMSLCLAdaADC12b to be able to use the 12bit ADC connected via i2c to the Raspberry Pi. The goal of the setup is to read-out noise meter values via the ADC and send the measurements via messaging to the channel 'tms/raspi'. A Windows Delphi application will then listen through this same MQTT client to the messages on channel 'tms/raspi' and will display the values in our TMS Instrumentation Workshop component TvrScope. Best of all, with the help of these components, this is not much more than a 15 minute project where most of the time will be spent to properly connect the ADC breakout board via a breadboard to the Raspberry Pi i2c port.



For the code, we use the same setup in the Windows Delphi application as on the Raspberry Pi Lazarus application to connect our client to the Mosquitto test broker:

begin
  TMSMQTTClient1.BrokerHostName := 'test.mosquitto.org';
  TMSMQTTClient1.Connect;
end;

var
  i: integer;
begin
  // get value from the 4 channel ADC channel 0 to which the analog noise meter output is connected
  i := TMSLCLAdaADC12B1.ReadChannel(0);
  // send the value as text over MQTT
  TMSMQTTClient1.Publish('tms/raspi', inttostr(i)); 
end;

procedure TForm1.FormCreate(Sender: TObject);
begin
  // make sure to start the Raspberry Pi app with sufficient permissions to be able to open access to i2c
  if not TMSLCLAdaADC12B1.Open then
  begin  
    ShowMessage('error opening i2c');
    Exit;
  end;
end;

procedure TForm1.FormClose(Sender: TObject; var CloseAction: TCloseAction);
begin
  TMSLCLAdaADC12B1.Close;
end;

procedure TForm1.TMSMQTTClient1PublishReceived(ASender: TObject;
  APacketID: Word; ATopic: string; APayload: TArray<System.Byte>);
var
  s:string;
begin
  s := TEncoding.UTF8.GetString(APayload);
  LastVal := Round(100 * strtoint(s) / 1024);
end;

procedure TForm1.VrScope1NeedData(Sender: TObject; Channel: Integer;
  var Value: Integer);
begin
  Value := LastVal;
end;

SHA-1 is a hash function developed by NSA and standardized by NIST in 1994. It is implemented in many Internet protocols using cryptographic primitives, such as TLS. Last week the CWI Institute in Amsterdam and Google announced the first practical collision for SHA-1, meaning that they actually generated two files with the same cryptographic hash, something that should never happen with a hash function because collisions can be used to forge false messages in fraudulent activities.

TMS Software has been conservative with cryptographic algorithms and, while offering a wide variety of primitives in its comprehensive TMS Cryptography Pack, is committed to only supporting robust and secure algorithms. Therefore TMS Cryptography Pack never implemented deprecated algorithms such as SHA-1, MD5 or DES, but rather provides the Delphi and C++ Builder communities with the latest standards such as the AES, strong RSA, Elliptic Curve Cryptography, the SHA2 and SHA3 families and ARGON2 for key derivation and many other useful features packaged and ready to use for developers in all types of multi-platform applications.

Presentation of TMS Cryptography Pack at Bordeaux and Nantes

• Tuesday 14 March, 2017: RAD Studio 10.1 Berlin - BORDEAUX
• Thursday 16 March, 2017: RAD Studio 10.1 Berlin - NANTES

LINQ Projections is the runner-up feature of My Top 10 Aurelius Features. It's a sort of "sequel" of the #5 feature LINQ Expressions and Paging, and you can see it in action in the video below.



You could consider that "LINQ Expressions" and "LINQ Projections" are just sides of the same feature. That's not incorrect indeed. But LINQ is a so nice feature of TMS Aurelius that it deserved to be split in two parts. And the reason that projections (and not expression) is ranked higher is just because it's at the core of LINQ.

The coolness of LINQ is more due projections than expressions in my opinion. An expression is actually just a comparison of two projections. It's in the projections that all complexity lies in. And it allows beautiful and complex queries like the following to be written:

Get the unit price and quantity of each order detail, multiply them, and group the sum of it by the year of Order Date.

    Manager.Find<TOrder>
      .CreateAlias('OrderDetails', 'd')
      .Select(TProjections.ProjectionList
        .Add(Linq['OrderDate'].Year.Group.As_('Group'))
        .Add((Linq['d.UnitPrice'] * Linq['d.Quantity']).Sum.As_('Value'))
      )
      .Where(Linq['OrderDate'].Year._In([1997, 1998]))
      .OrderBy('Value')

Finally, My Top 10 Aurelius Features series has come to an end. And the number 1 of the list is Maturity.



Aurelius has been first released in early 2012. Since then, in five years, it has received 33 releases! With the user feedback received during all the time, I’m confident that Aurelius feature set is pretty extensive.

For example, you can build applications for all supported Delphi platforms: Windows, Mac OS X, iOS, Android and Linux. The number of supported database systems is impressive: Oracle, MySQL, SQL Server, PostgreSQL, DB2, Firebird, SQLite, NexusDB, ElevateDB and the list goes on. The same can be said about the component libraries you can use to access the database: the list of 15 options include FireDac, dbExpress, ADO, UniDac, among others.

Maturity also means that you can trust it, because it just works. Aurelius test suite includes hundreds of unique tests, which makes up thousands of tests because we make sure that they work in all the supported platforms and servers. This means that you can be sure it will work on Windows, using dbExpress to access an Oracle database, the same way it will work on Linux, using FireDac to access a MySQL database.

In the end, why I really like this maturity feature? Because it makes my life easier and happier. Lower support because there are no known bugs that stand for too long. And happier customers because they have the features they need.

We’d love to hear your comments about it. Do you agree with this list? What would be yours? Post your opinions and comments below, visit our website, download TMS Aurelius trial and let us know what you think. Don't forget to subscribe to our YouTube channel to get notified about upcoming videos!

The unique feature of Analytics library is symbolic derivatives calculation. The library provides the simplest way to get a symbolic derivative expression for almost any complicated expression. There are predefined derivative for all standard functions: trigonometric, hyperbolic, logarithmic and exponential, inverse trigonometric and hyperbolic, and other.

Another fine thing is that any developer can easily define derivative for any other function. Let us consider how to define derivative for special Gamma function (https://en.wikipedia.org/wiki/Gamma_function#General). Its derivative is defined via another special function – Digamma (Polygamma function of order 0, https://en.wikipedia.org/wiki/Polygamma_function). Hereafter the Gamma function denoted as ‘G’ and the Digamma (and Polygamma) as ‘Y’. Then, the derivative formula is: d(G(x))/dx = G(x)*Y(x).

To introduce new functional derivative new class must be implemented. In our case, the class is inherited from ‘TSimpleFunctionalDerivative’ because the function has one argument only. Here is the code of the realized class:

TGammaDerivative = class sealed(TSimpleFunctionalDerivative)
protected
  function GetFunctionName(): string; override;
  function BaseDerivative(argument: TBaseExpression): TBaseExpression; override;
public
  class function IsRealized: boolean; override;
end;

function TGammaDerivative.GetFunctionName: string;
begin
  result:= 'G';
end;

class function TGammaDerivative.IsRealized: boolean;
begin
  result:= true;
end;

function TGammaDerivative.BaseDerivative(argument: TBaseExpression): TBaseExpression;
var
  ge: TBaseExpression;
  dge: TBaseExpression;
begin
  ge:= TFunctionExpression.CreateSimple('G', argument);
  dge:= TFunctionExpression.CreateSimple('Y', argument);

  result:= TProductExpression.MakeProduct(ge, dge);
end;

Yesterday Embarcadero released Delphi, C++Builder and RAD Studio 10.2 Tokyo:
https://www.embarcadero.com/products/rad-studio/whats-new-in-10-2-tokyo

For our registered users, already several products are ready for this new RAD Studio version! So get started today with your Windows or cross-platform development in 10.2 Tokyo with TMS VCL, FMX and FNC components.

TMS rollout of components with RAD Studio 10.2 Tokyo support:

VCL Windows application development

• TMS Component Pack
• TMS VCL WebGMaps
• TMS VCL WebOSMaps
• TMS Maps Pack
• TMS VCL Cloud Pack
• TMS Cryptography Pack
• TMS Instrumentation Workshop
• TMS Async

FMX cross-platform application development

• TMS FMX UI Pack
• TMS FMX Chart
• TMS FMX WebGMaps
• TMS FMX WebOSMaps
• TMS FMX Cloud Pack

FNC cross-platform & cross-framework application development

• TMS FNC UI Pack
• TMS FNC Chart

Developer tools for Delphi developers

• TMS MQTT

We are excited to announce that Jens Fudge, Embarcadero MVP for Denmark, and TMS software are planning a TMS day in Denmark on May 18th.

All day, sessions will be spent on TMS VCL components, TMS FNC components and TMS Cloud components and with also sufficient session time allocated to handle your specific questions on TMS components. The sessions will be given by Bruno Fierens, Embarcadero MVP in Belgium and CTO from tmssoftware.com.

All sessions will be in English.

In tentative program

Location

Register now!

Embarcadero has just released RAD Studio 10.2 Tokyo, the latest version of the great Delphi/C++Builder development tools. And the greatest feature of this release is the ability to compile for Linux!

TMS software organizes a new training day on Thursday June 8th in Kortrijk - Belgium.

All day, sessions will be spent on TMS VCL components, TMS FNC components and TMS Cloud components with also sufficient session time allocated to handle your specific questions on TMS components. The sessions will be given by Bruno Fierens, Embarcadero MVP in Belgium and CTO from tmssoftware.com and Bernard Roussely, product manager of TMS Cryptography Pack. All sessions will be in English.

In tentative program

Location

• Hotel Ibis Styles Kortrijk Expo, Pres. Kennedypark 1, B-8500 Kortrijk
• Free parking
• Nearby highway (E17) exit
• Facilities for hotel rooms at the event are available for international attendees

Registrations until May 31st

The Delphi compiler allows functions and procedures to be tagged with the inline directive to improve performance. If the function or procedure meets certain criteria, the compiler will insert code directly, rather than generating a call. Embarcadero docwiki gives a list of conditions under which inlining does or does not occur.

One of basic conditions says: within a unit, the body for an inline function should be defined before calls to the function are made.

TMS FixInsight 2017.04 introduces rule O805 “Inline marked routine comes after its call in the same unit”. Let’s check FMX and VCL code to see if Embarcadero follows their own rules. Short answer: it doesn’t.

I will give a couple of examples from Delphi 10.1 Berlin (version 24.0.22858.6822).

Vcl.Controls.pas

//at line 8529 
procedure TWinControl.ReadState(Reader: TReader);
begin
  DisableAlign;
  try
    inherited ReadState(Reader);
  finally
    EnableAlign;
  end;
  FixupTabList;
  if FParent <> nil then Perform(CM_PARENTCTL3DCHANGED, 0, 0);
  UpdateControlState;
end;

//at line 9010
procedure TWinControl.AlignControl(AControl: TControl);
var
  Rect: TRect;
begin
  if not HandleAllocated or (csDestroying in ComponentState) then Exit;
  if FAlignLevel <> 0 then
    Include(FControlState, csAlignmentNeeded)
  else
  begin
    DisableAlign;
    try
      Rect := GetClientRect;
      AlignControls(AControl, Rect);
    finally
      Exclude(FControlState, csAlignmentNeeded);
      EnableAlign;
    end;
  end;
end;

//at line 9030 
procedure TWinControl.DisableAlign;
begin
  Inc(FAlignLevel);
end;

//at line 2430 
procedure TListViewBase.UpdateDeleteButtonLayout;
var
  RelRect: TRectF;
begin
  if (Adapter.Count < 1) or (FDeleteLayout = nil) or ((FDeleteButtonIndex = -1) and
    (FPrevDeleteButtonIndex = -1)) then
    Exit;
 
  if (FListingService <> nil) and (TListingTransitionFeature.DeleteButtonSlide in FListingService.GetTransitionFeatures) then
  begin
    FDeleteLayout.Width := DefaultDeleteButtonWidth * FDeleteModeTransitionAlpha;
    FDeleteButton.Opacity := 1;
  end
  else
  begin
    if FDeleteModeTransitionAlpha > 0 then
      FDeleteLayout.Width := DefaultDeleteButtonWidth
    else
      FDeleteLayout.Width := 0;
 
    FDeleteButton.Opacity := 0.5 + (FDeleteModeTransitionAlpha / 2);
  end;
 
  FDeleteLayout.Height := GetItemHeight(FDeleteButtonIndex);
  FDeleteLayout.Position.X := Width - FDeleteLayout.Width;
 
  if FDeleteButtonIndex = -1 then
    RelRect := GetItemRelRect(FPrevDeleteButtonIndex, LocalRect)
  else
    RelRect := GetItemRelRect(FDeleteButtonIndex, LocalRect);
 
  FDeleteLayout.Position.Y := (RelRect.Top + RelRect.Bottom - FDeleteLayout.Height) / 2;
end;

//at line 2868
function TListViewBase.GetItemRelRect(const Index: Integer; const LocRect: TRectF;
  const SideSpace: Integer = 0): TRectF;
begin
  Result := RectF(LocRect.Left + FSideSpace + SideSpace, LocRect.Top + FSideSpace + FHeightSums[Index] - FScrollViewPos,
    LocRect.Width - ((SideSpace + FSideSpace) * 2), GetItemHeight(Index));
 
  if (FScrollBar <> nil) and (not HasTouchTracking) and FScrollBar.Visible then
    Result.Right := Result.Right - FScrollBar.Width;
end;

Latest versions of TMS XData and TMS Sparkle have been just released with a major feature: Linux support. You can now deploy your XData/Sparkle server to Linux using Delphi 10.2 Tokyo, and in this video/blog post series, I will show you how to create and deploy such a server step-by-step. Since some Delphi users are mostly Windows users, I believe some of them are not very familiar with Linux and/or Apache, and because of that this tutorial is very basic and very detailed, covering it from the very beginning.

Here is the video with the first part: installing Linux on VirtualBox and connecting to it from Windows computer.



We will use Virtual Box to create our virtual machine, but you can choose any tool you want, if you are used to: VMWare, Parallels, Hyper-V, etc.

1. Download VirtualBox from https://www.virtualbox.org/wiki/Downloads and install it.

Just follow installer using default settings.

2. Download Ubuntu Linux Server from https://www.ubuntu.com/download/server

We will use the Server edition here (no GUI available by default). Save the ISO file in some folder, we will use it in step 3 below.

3. Create and configure VM

a) Create a new VM, name it, choose Linux as the guest OS
b) Just use default settings in the VM wizard, you can increase RAM or disk size if you want to
c) Once VM is created, change Network Adapter to Bridge (optional, I personally find it easier as it appears as another computer in the network)
b) Add the Ubuntu ISO file as a virtual disk in the VM storage

4. Launch VM and install Ubuntu

Launch VM and the Ubuntu installer will start from the ISO. Just use default settings for most of the install. You can follow the video for more details, but the installer will just ask for user name and password to be created, and several basic settings that you can just confirm what is presented.

5. Login and update OS

After install is complete, login and upgrade the system with the following commands on Linux terminal:

sudo apt-get update
sudo apt-get dist-upgrade

sudo apt-get install openssh-server samba

hostname -I

hostname

This is part 2 of the tutorial on how to create TMS XData and TMS Sparkle servers on Linux. On Part 1, we have installed Ubuntu and connected to it from Linux.

Here is video for second part: Installing PAServer on Linux and running our first "Hello, World" application on it.



To install PAServer, we need to send the tar.gz file containing PAServer files to Linux.

1. Download WinSCP from https://winscp.net/eng/download.php and install it.

To transfer files between Windows and Linux, we will use WinSCP tool. It's very convenient, just install it, and connect to Linux using same configuration/credentials we used when connecting with Putty (actually it even detects Putty is installed and asks if you want to import connection settings).

2. Transfer file LinuxPAServer19.0.tar.gz file to Linux

That file is located in the PAServer folder of your Delphi installation directory. If you used default settings, this should be in "C:Program Files (x86)\EmbarcaderoStudio\9.0\PAServer" folder.

To transfer, just drag that file and drop it in WinSCP in the Linux folder you want. I recommend transferring it to your Linux home folder (/home/yourusername) which should be the default folder displayed when WinSCP is open.

3. Decompress PAServer

On Linux terminal, type the following command to decompress PAServer:

tar -xvf LinuxPAServer19.0.tar.gz

cd PAServer-19.0
./paserver

WriteLn('Hello, Linux');

This is part 3 of the tutorial on how to create TMS XData and TMS Sparkle servers on Linux. On Part 2, we have installed PAServer and launched our first "Hello, World" console application on Linux.

Here is video for part 3: Create and deploy an Apache module to Linux.



We will use WebBroker to create an empty Apache module. But first we need to install Apache on Linux.

1. Install Apache on Linux

On Linux terminal, use the following command to install Apache:

sudo apt-get install apache2

http://ubuntu/

/home/user/PAServer/scratch-dir/User-Ubuntu/mod_xdata/libmod_xdata.so

cd /etc/apache2/mods-available

sudo touch xdata.conf
sudo touch xdata.load

sudo nano xdata.load

LoadModule xdata_module /home/user/PAServer/scratch-dir/User-Ubuntu/mod_xdata/libmod_xdata.so

sudo nano xdata.conf

<Location /tms>
    SetHandler libmod_xdata-handler
</Location>

sudo a2enmod xdata

sudo apache2ctl stop
sudo apache2ctl start

http://ubuntu/tms

This is part 4 of the tutorial on how to create TMS XData and TMS Sparkle servers on Linux. On Part 3, we have created and deployed our first Apache Module using WebBroker. Now we're going to add TMS Sparkle to it.

Here is video for part 4: Adding TMS Sparkle and using Sparkle modules in the Apache module.



Basically, what we need to do is "wrap" the WebBroker request/response objects into a Sparkle request/response objects. So any Sparkle module can process the requests and provide responses. This part is also described in the documentation, in this page: http://www.tmssoftware.biz/business/sparkle/doc/web/apache-based-server.html

1. In WebModuleUnit1 unit, add the units Sparkle.WebBroker.Server and Sparkle.WebBroker.Adapter to the uses clause:

uses {...},
  Sparkle.WebBroker.Server,
  Sparkle.WebBroker.Adapter,
   // just for the anonymous module example
  Sparkle.HttpServer.Module, Sparkle.HttpServer.Context;

var
  Server: TWebBrokerServer;

initialization
  Server := TWebBrokerServer.Create;
finalization
  Server.Free;
end.

procedure TWebModule1.WebModule1DefaultHandlerAction(Sender: TObject;
  Request: TWebRequest; Response: TWebResponse; var Handled: Boolean);
var
  Adapter: IWebBrokerAdapter;
begin
  Adapter := TWebBrokerAdapter.Create(Request, Response);
  Server.DispatchRequest(Adapter);
end;

initialization
  Server := TWebBrokerServer.Create;
  // add modules you want to use. This example assumes a simple Sparkle module,
  // but you can add your XData, RemoteDB or any other Sparkle module
  Server.Dispatcher.AddModule(TAnonymousServerModule.Create(
    'http://localhost/tms/hello',
    procedure(const C: THttpServerContext)
    begin
      C.Response.StatusCode := 200;
      C.Response.ContentType := 'text/plain'';
      C.Response.Close(TEncoding.UTF8.GetBytes('Hello from Sparkle!'));
    end
  ));
finalization
  Server.Free;
end.

sudo apache2ctl stop
sudo apache2ctl start

http://ubuntu/tms

This is part 5 of the tutorial on how to create TMS XData and TMS Sparkle servers on Linux. On Part 4, we have added Sparkle to our Apache module, preparing it to receive any modules we want to add. And in this final part we will add the TMS XData module to it.

Here is video for part 5: Adding the TMS XData module to Apache.



Now that we can add any Sparkle module we want, develop our XData server should be nothing different from when we use Windows. You can find more detailed information about it in other resources (blog posts, our TMS XData documentation, etc.). This tutorial will just cover the basics and deal with some final Linux specific things, like SQLite database permissions.

1. Create a new Aurelius connection for SQLite database

Go to Delphi menu item "File, New, Other...", then "Delphi Projects, TMS Business, TMS Aurelius DB Connection" to open the wizard. Choose "SQLite" for both driver and SQL dialect, and then confirm to create the new connection. Unit name created will be called "ConnectionModule".

2. Add XData Module to Sparkle server

Going back to WebModule1 unit, add the following units to the uses clause:

uses
   {...}, XData.Server.Module, ConnectionModule, Aurelius.Engine.DatabaseManager;

initialization
  Server := TWebBrokerServer.Create;
  TDatabaseManager.Update(TSQLiteSQLiteConnection.CreateConnection);
  Server.Dispatcher.AddModule(TXDataServerModule.Create(
    'http://ubuntu/tms', TSQLiteSQLiteConnection.CreateConnection
  ));
finalization
  Server.Free;
end.

class function TSQLiteSQLiteConnection.CreateConnection: IDBConnection;
begin
  Result := TSQLiteNativeConnectionAdapter.Create('/home/user/xdata/xdata.db');
end;

cd
mkdir xdata
touch xdata/xdata.db

sudo chgrp www-data xdata -R

sudo apt-get install libsqlite3-dev

sudo apache2ctl stop
sudo apache2ctl start