sidebar_position

sidebar_label

hide_table_of_contents

description

keywords

0

TinyORM

true

How to compile the TinyORM C++ library on Windows and Linux.

c++ orm

building

tinyorm

import APITable from '@theme/APITable' import CodeBlock from '@theme/CodeBlock' import TabItem from '@theme/TabItem' import Tabs from '@theme/Tabs'

import RootFolder from '@theme/RootFolder' import RootFolderInput from '@theme/RootFolderInput' import { shell, application, bash, pwsh, application_label, bash_label, pwsh_label } from '@theme/constants' import { applicationFolder, applicationFolderPath, convertToCmakeEnvVariable, rootFolderPath } from '@theme/utils/rootFolderUtils'

Building: TinyORM

Introduction
- Common Prerequisites
- Windows Prerequisites
Folders structure
Getting started
vcpkg
C preprocessor macros
Building with CMake
Building with qmake
Ccache support

Introduction

The build systems supported out of the box are CMake and qmake.

:::caution All examples below assume that pwsh runs on Windows and bash runs on Linux. :::

Common Prerequisites

Before beginning, install required dependencies.

Windows Prerequisites

Build environment scripts

The Visual Studio does not provide vcvars scripts for pwsh, you can use vcvars64.ps1 provided by TinyORM in the tools/ folder. Place them on the $env:Path user/system path and they will be available system-wide.

The same is true for the Qt Framework, it doesn't provide qtenv scripts for pwsh too. You can create your own script, place it on the $env:Path user/system path and it will be available system-wide.

Here is one simple example for pwsh.

Write-Host 'Setting up environment for Qt 6.2.4 usage...' -ForegroundColor Magenta
$env:Path = 'C:\Qt\6.2.4\msvc2019_64\bin;' + $env:Path
. E:\dotfiles\bin\vcvars64.ps1

Write-Host 'Setting up environment for Qt 5.15.2 usage...' -ForegroundColor Magenta
$env:Path = 'C:\Qt\5.15.2\msvc2019_64\bin;' + $env:Path
. E:\dotfiles\bin\vcvars64.ps1

Allow symbolic links unprivileged

Open Local Security Policy, go to Local Policies - User Rights Assignment, open Create symbolic links and add your user account or user group, restart when it doesn't apply immediately.

Folders structure

All tinyorm.org examples are based on the following folders structure. The tom folder will contain a migrations console application.

:::tip You can set the root and application folder paths in the form below and they will be used across the whole www.tinyorm.org website. 🥳 The pwsh shell is supposed to use on Windows and the bash shell on Linux, but it is not a requirement. :::

Current pwsh path




├──
│   ├── HelloWorld/
│   |   ├── HelloWorld/
│   |   ├── HelloWorld-builds-cmake/
│   |   |   └── build-debug/
│   |   └── HelloWorld-builds-qmake/
│   |       └── build-debug/
│   ├── TinyORM/
│   |   ├── TinyORM/
│   |   ├── TinyORM-builds-cmake/
│   |   │   ├── build-gcc-debug/
│   |   │   ├── build-gcc-release/
│   |   │   └── build-clang-debug/
│   |   └── TinyOrm-builds-qmake/
│   |       ├── build-debug/
│   |       ├── build-TinyOrm-Desktop_Qt_5_15_2_MSVC2019_64bit-Debug/
│   |       └── build-TinyOrm-Desktop_Qt_5_15_2_MSYS2_UCRT64_64bit-Release/
│   └── tom/
│       ├── tom/
│       │   └── database/
│       │       ├── migrations/
│       │       ├── seeders/
│       │       ├── migrations.pri
│       │       └── seeders.pri
│       ├── tom-builds-cmake/
│       │   └── build-TinyOrm-Desktop_Qt_6_3_1_MSVC2019_64bit-Debug/
│       └── tom-builds-qmake/
│           ├── build-TinyOrm-Desktop_Qt_5_15_3_MSYS2_UCRT64_64bit-Release/
│           └── build-TinyOrm-Desktop_Qt_6_3_1_MSVC2019_64bit-Debug/
├── tmp/
└── vcpkg/

Current bash path




├──
│   ├── HelloWorld/
│   |   ├── HelloWorld/
│   |   ├── HelloWorld-builds-cmake/
│   |   |   └── build-debug/
│   |   └── HelloWorld-builds-qmake/
│   |       └── build-debug/
│   ├── TinyORM/
│   |   ├── TinyORM/
│   |   ├── TinyORM-builds-cmake/
│   |   │   ├── build-gcc-debug/
│   |   │   ├── build-gcc-release/
│   |   │   └── build-clang-debug/
│   |   └── TinyOrm-builds-qmake/
│   |       ├── build-debug/
│   |       ├── build-TinyOrm-Desktop_Qt_5_15_2_GCC_64bit-Debug/
│   |       └── build-TinyOrm-Desktop_Qt_5_15_2_clang13_64bit_ccache-Release/
│   └── tom/
│       ├── tom/
│       │   └── database/
│       │       ├── migrations/
│       │       ├── seeders/
│       │       ├── migrations.pri
│       │       └── seeders.pri
│       ├── tom-builds-cmake/
│       │   └── build-TinyOrm-Desktop_Qt_6_3_1_clang14_64bit_ccache-Debug/
│       └── tom-builds-qmake/
│           ├── build-TinyOrm-Desktop_Qt_6_3_1_GCC_64bit-Debug/
│           └── build-TinyOrm-Desktop_Qt_6_3_1_clang14_64bit_ccache-Release/
├── tmp/
└── vcpkg/

:::danger Avoid paths with spaces with the qmake build system, it will not compile. :::

Getting started

Prepare compilation environment, we need to put the Qt Framework and Visual Studio MSVC compiler on the path on Windows. The Qt Framework and compiler are already on the path on Linux.

{`mkdir ${rootFolderPath(pwsh)} cd ${rootFolderPath(pwsh)} $env:Path = 'E:\\Qt\\5.15.2\\msvc2019_64\\bin;' + $env:Path vcvars64.ps1`} {`mkdir -p ${rootFolderPath(bash)} cd ${rootFolderPath(bash)}`}

vcpkg

Installing the vcpkg is highly recommended, it simplifies installation of the range-v3 and tabulate dependencies.

git clone git@github.com:microsoft/vcpkg.git
cd vcpkg
.\bootstrap-vcpkg.bat

git clone git@github.com:microsoft/vcpkg.git
cd vcpkg
./bootstrap-vcpkg.sh

Add vcpkg on the system path, add the following to the .bashrc or .zshrc on Linux.

{`export PATH=${rootFolderPath(bash)}/vcpkg\${PATH:+:}$PATH`}

On Windows, open the Environment variables dialog and add vcpkg on the PATH.

Or you can export it for the current session only.

{`$env:Path = "${rootFolderPath(pwsh, false)}\\vcpkg;" + $env:Path`} {`export PATH=${rootFolderPath(bash)}/vcpkg\${PATH:+:}$PATH`}

C preprocessor macros

The following table summarizes all the C preprocessor macros defined in the TinyORM library. These C macros are configured by CMake or qmake build systems. They are not sorted alphabetically, but they are sorted by how significant they are.

In the CMake build system, all the C macros are auto-detected / auto-configured or controlled by CMake build options, so you don't have to care too much about them.

In the qmake build is important whether you are building TinyORM library or you are building your application and linking against TinyORM library. When you are building the TinyORM library, all the C macros are auto-detected / auto-configured or controlled by qmake build options, so you don't have to care too much about them.

But a special situation is when you are building your application / library and you are linking against TinyORM library. In this particular case, you must configure all these C macros manually! For this reason, the TinyOrm.pri has been created, so that's not a big deal. Little more info here.

C Macro Name	Description
`TINYORM_LINKING_SHARED`	Must be defined when you are linking against `TinyORM` shared build (`dll` library), exported classes and functions will be tagged with `__declspec(dllimport)` on `msvc` and `visibility("default")` on `GCC >= 4`.
`TINYORM_BUILDING_SHARED`	Defined when `TinyORM` is built as a `dll` library (shared build).
`TINYORM_DEBUG`	Defined in the debug build.
`TINYORM_NO_DEBUG`	Defined in the release build.
`TINYORM_DEBUG_SQL`	Defined in the debug build.
`TINYORM_NO_DEBUG_SQL`	Defined in the release build.
`TINYORM_MYSQL_PING`	Enable `Orm::MySqlConnection::pingDatabase()` method. Defined when `mysql_ping` (qmake) / `MYSQL_PING` (cmake) configuration `build option` is enabled.
`TINYORM_DISABLE_ORM`	Controls the compilation of all `ORM-related` source code, when this macro is `defined`, then only the `query builder` without `ORM` is compiled. Also excludes `ORM-related` unit tests. Defined when `disable_orm` (qmake) / `ORM` (cmake) configuration `build option` is enabled (qmake) / disabled (cmake).
`TINYORM_EXTERN_CONSTANTS`	Defined when extern constants are used. Described at `qmake` / `CMake` how it works.
`TINYORM_INLINE_CONSTANTS`	Defined when global inline constants are used. Defined when `inline_constants` (qmake) / `INLINE_CONSTANTS` (cmake) configuration `build option` is enabled.
`TINYORM_TESTS_CODE`	Enable code needed by unit tests, eg. connection overriding in the `Orm::Tiny::Model`. Defined when `build_tests` (qmake) / `BUILD_TESTS` (cmake) configuration `build option` is enabled.
`TINYORM_DISABLE_THREAD_LOCAL`	Remove all `thread_local` storage duration specifiers, it disables threading support. Defined when `disable_thread_local` (qmake) / `DISABLE_THREAD_LOCAL` (cmake) configuration `build option` is enabled.
`TINYTOM_MIGRATIONS_DIR`	Default migrations path for the `make:migration` command, can be an absolute or relative path (to the pwd). Default value: `database/migrations` (relative to the pwd) Defined by `TOM_MIGRATIONS_DIR` (cmake) configuration build option. (qmake note) You can use `DEFINES += TINYTOM_MIGRATIONS_DIR="\"database/migrations\""` on the command-line or set it in the main `conf.pri` file.
`TINYTOM_MODELS_DIR`	Default models path for the `make:model` command, can be an absolute or relative path (to the pwd). Default value: `database/models` (relative to the pwd) Defined by `TOM_MODELS_DIR` (cmake) configuration build option. (qmake note) You can use `DEFINES += TINYTOM_MODELS_DIR="\"database/models\""` on the command-line or set it in the main `conf.pri` file.
`TINYTOM_SEEDERS_DIR`	Default seeders path for the `make:seeder` command, can be an absolute or relative path (to the pwd). Default value: `database/seeders` (relative to the pwd) Defined by `TOM_SEEDERS_DIR` (cmake) configuration build option. (qmake note) You can use `DEFINES += TINYTOM_SEEDERS_DIR="\"database/seeders\""` on the command-line or set it in the main `conf.pri` file.
`TINYORM_USING_PCH`	Defined if building with precompiled headers. Controlled by `qmake` / `CMake`.

Building with CMake

:::tip If something is not clear, you can still look at GitHub Action workflows how a building is done. :::

First, create a basic folder structure and then clone the TinyORM project.

{`cd ${rootFolderPath(pwsh)} mkdir ${applicationFolder()}/TinyORM/TinyORM-builds-cmake/build-debug\n cd ${applicationFolder()}/TinyORM git clone git@github.com:silverqx/TinyORM.git`} {`cd ${rootFolderPath(bash)} mkdir -p ${applicationFolder()}/TinyORM/TinyORM-builds-cmake/build-debug\n cd ${applicationFolder()}/TinyORM git clone git@github.com:silverqx/TinyORM.git`}

Configure & Build (cmake) {#configure-and-build-cmake}

Now you are ready to configure the TinyORM library.

cd TinyORM-builds-cmake/build-debug

{`cmake.exe \` -S "${applicationFolderPath(pwsh)}/TinyORM/TinyORM" \` -B "${applicationFolderPath(pwsh)}/TinyORM/TinyORM-builds-cmake/build-debug" \` -G 'Ninja' \` -D CMAKE_BUILD_TYPE:STRING='Debug' \` -D CMAKE_TOOLCHAIN_FILE:FILEPATH="${rootFolderPath(pwsh)}/vcpkg/scripts/buildsystems/vcpkg.cmake" \` -D CMAKE_INSTALL_PREFIX:PATH="${rootFolderPath(pwsh)}/tmp/TinyORM" \` -D BUILD_TESTS:BOOL=OFF \` -D MATCH_EQUAL_EXPORTED_BUILDTREE:BOOL=ON \` -D MYSQL_PING:BOOL=OFF \` -D TOM:BOOL=ON \` -D TOM_EXAMPLE:BOOL=OFF \` -D VERBOSE_CONFIGURE:BOOL=ON`} {`cmake \\ -S "${applicationFolderPath(bash)}/TinyORM/TinyORM" \\ -B "${applicationFolderPath(bash)}/TinyORM/TinyORM-builds-cmake/build-debug" \\ -G 'Ninja' \\ -D CMAKE_BUILD_TYPE:STRING='Debug' \\ -D CMAKE_TOOLCHAIN_FILE:FILEPATH="${rootFolderPath(bash)}/vcpkg/scripts/buildsystems/vcpkg.cmake" \\ -D CMAKE_INSTALL_PREFIX:PATH="${rootFolderPath(bash)}/tmp/TinyORM" \\ -D VERBOSE_CONFIGURE:BOOL=ON \\ -D BUILD_TESTS:BOOL=OFF \\ -D MYSQL_PING:BOOL=OFF \\ -D TOM:BOOL=ON \\ -D TOM_EXAMPLE:BOOL=OFF \\ -D MATCH_EQUAL_EXPORTED_BUILDTREE:BOOL=ON`}

Build TinyORM

And build. You don't have to install it, you can use the build tree directly if you want.

cmake --build . --target all
cmake --install .

Or build and install in one step.

cmake --build . --target install

:::info CMake multi-config generators like Ninja Multi-Config or Visual Studio 16 2019 are also supported. :::

CMake build options

Option Name	Default	Description
`BUILD_SHARED_LIBS`	`ON`	Build as a shared/static library.
`BUILD_TESTS`	`OFF`	Build TinyORM unit tests.
`INLINE_CONSTANTS`	`OFF`	Use inline constants instead of extern constants in the `shared build`. `OFF` is highly recommended for the `shared build`; is always `ON` for the `static build`. Available when: `BUILD_SHARED_LIBS`
`MSVC_RUNTIME_DYNAMIC`	`ON`	Use MSVC dynamic runtime library (`-MD`) instead of static (`-MT`), also considers a Debug configuration (`-MTd`, `-MDd`). Available when: `MSVC AND NOT DEFINED CMAKE_MSVC_RUNTIME_LIBRARY`
`MYSQL_PING`	`OFF`	Enable `Orm::MySqlConnection::pingDatabase()` method.
`ORM`	`ON`	Controls the compilation of all `ORM-related` source code, when this option is `disabled`, then only the `query builder` without `ORM` is compiled. Also excludes `ORM-related` unit tests.
`TOM`	`ON`	Controls the compilation of all `Tom-related` source code, when this option is `disabled`, then it also excludes `Tom-related` unit tests.
`TOM_EXAMPLE`	`OFF`	Build the `Tom` command-line application example (console application).
`TOM_MIGRATIONS_DIR`	`-`	Default migrations path for the `make:migration` command, can be an absolute or relative path (to the pwd). Default value: `database/migrations` (relative to the pwd)
`TOM_MODELS_DIR`	`-`	Default models path for the `make:model` command, can be an absolute or relative path (to the pwd). Default value: `database/models` (relative to the pwd)
`TOM_SEEDERS_DIR`	`-`	Default seeders path for the `make:seeder` command, can be an absolute or relative path (to the pwd). Default value: `database/seeders` (relative to the pwd)
`VERBOSE_CONFIGURE`	`OFF`	Show information about `PACKAGES_FOUND` / `PACKAGES_NOT_FOUND` in the CMake configure output.

Advanced TinyORM options.

Option Name	Default	Description
`DISABLE_THREAD_LOCAL`	`OFF`	Remove all `thread_local` storage duration specifiers, it disables threading support.
`MATCH_EQUAL_EXPORTED_BUILDTREE`	`OFF`	Exported package configuration from the build tree is considered to match only when `the build type` of application/library that is linking against the TinyORM library is equal. Available when: `CMAKE_EXPORT_PACKAGE_REGISTRY AND NOT TINY_IS_MULTI_CONFIG`

Important CMake options.

Option Name	Default	Description
`CMAKE_DISABLE_PRECOMPILE_HEADERS`	`OFF`	Disable precompiled headers.
`CMAKE_CXX_COMPILER`	`auto`	The full path to the `C++` compiler.
`CMAKE_CXX_COMPILER_LAUNCHER`	`-`	Default compiler launcher to use for the `C++` compiler. Can be used to enable `ccache`, eg. `ccache.exe` on `MinGW` or `/usr/bin/ccache` on `Linux`.
`CMAKE_EXPORT_PACKAGE_REGISTRY`	`ON`	Enable the `export(TinyOrm)` command. `TinyORM` sets this variable to `ON` by default.
`CMAKE_VERBOSE_MAKEFILE`	`OFF`	Enable verbose output from Makefile builds.

Consume TinyOrm library (cmake) {#consume-tinyorm-library-cmake}

In your application or library CMakeLists.txt file add following find_package() call.

find_package(TinyOrm 0.16.0 CONFIG REQUIRED)

If the TinyORM build tree is not exported to the CMake's User Package Registry then also add the TinyORM build tree or CMAKE_INSTALL_PREFIX folder to the CMAKE_PREFIX_PATH, so CMake can find TinyORM's package configuration file during find_package(TinyOrm) call.

{`# build tree list(APPEND CMAKE_PREFIX_PATH "${convertToCmakeEnvVariable(pwsh, applicationFolderPath(pwsh))}/TinyORM/TinyORM-builds-cmake/build-debug")\n # installation folder - CMAKE_INSTALL_PREFIX list(APPEND CMAKE_PREFIX_PATH "${convertToCmakeEnvVariable(pwsh, rootFolderPath(pwsh))}/tmp/TinyORM")`} {`# build tree list(APPEND CMAKE_PREFIX_PATH "${convertToCmakeEnvVariable(bash, applicationFolderPath(bash))}/TinyORM/TinyORM-builds-cmake/build-debug")\n # installation folder - CMAKE_INSTALL_PREFIX list(APPEND CMAKE_PREFIX_PATH "${convertToCmakeEnvVariable(bash, rootFolderPath(bash))}/tmp/TinyORM")`}

Or as an alternative, you can set CMAKE_PREFIX_PATH environment variable.

As the last thing, do not forget to add TinyOrm0d.dll on the path on Windows and on the LD_LIBRARY_PATH on Linux, so your application can find it during execution.

{`$env:Path = "${applicationFolderPath(pwsh, false)}\\TinyORM\\TinyORM-builds-cmake\\build-debug;" + $env:Path`} {`export LD_LIBRARY_PATH=${applicationFolderPath(bash)}/TinyORM/TinyORM-builds-cmake/build-debug\${PATH:+:}$PATH`}

Now you can try the HelloWorld CMake example.

Building with qmake

First, create a basic folder structure and then clone the TinyORM project.

{`cd ${rootFolderPath(pwsh)} mkdir ${applicationFolder()}/TinyORM/TinyOrm-builds-qmake\n cd ${applicationFolder()}/TinyORM git clone git@github.com:silverqx/TinyORM.git`} {`cd ${rootFolderPath(bash)} mkdir -p ${applicationFolder()}/TinyORM/TinyOrm-builds-qmake\n cd ${applicationFolder()}/TinyORM git clone git@github.com:silverqx/TinyORM.git`}

Install dependencies

With the qmake build system, you have to install TinyORM dependencies manually. We will use the vcpkg package manager.

cd ../../vcpkg

vcpkg search range-v3
vcpkg search tabulate
vcpkg install range-v3 tabulate
vcpkg list

On Linux, you can install the range-v3 library and some other dependencies with the package manager.

Configure & Build (qmake) {#configure-and-build-qmake}

Open QtCreator IDE

:::tip I recommend creating a new Session in the QtCreator, this way you will have all the examples in one place and as a bonus, everything will be in the same place when you close and reopen QtCreator IDE. You can name it tinyorm.org or TinyORM examples, it is up to you. :::

:::tip If you are using sessions, you can use a single clangd instance for all projects in this session in the QtCreator IDE. One significant advantage of this method is that the .qtc_clangd/ folder will not be created in the build folder, but will be stored globally in the Roaming profile. You can enable it in the Settings - C++ - Clangd - Sessions with a single clangd instance. :::

Configure TinyORM

Now you are ready to configure the TinyORM library. The qmake does not support auto-configuration of dependencies out of the box, to configure TinyORM's qmake build dependencies you have to copy the conf.pri.example file to the conf.pri and manually edit the INCLUDEPATH and LIBS. This way you can override any qmake build options or variables.

conf.pri files are nicely commented, so is clearly visible what has to be modified.

{`cd ${applicationFolderPath(pwsh)}/TinyORM/TinyORM\n cp conf.pri.example conf.pri cp tests/conf.pri.example tests/conf.pri cp examples/tom/conf.pri.example examples/tom/conf.pri`} {`cd ${applicationFolderPath(bash)}/TinyORM/TinyORM\n cp conf.pri.example conf.pri cp tests/conf.pri.example tests/conf.pri cp examples/tom/conf.pri.example examples/tom/conf.pri`}

Now you can open the TinyOrm.pro project in the QtCreator IDE.

This will open the Configure Project tab, select some kit and update build folder paths to meet our folders structure or like you want.

You are ready to configure build options, hit Ctrl+5 to open Project Settings tab and select Build in the left sidebar to open the Build Settings, it should look similar to the following picture.

Disable QML debugging and profiling and Qt Quick Compiler, they are not used.

If you want to change some TinyORM build options, you can pass them to the Build Steps - qmake TinyOrm.pro - Additional arguments input field. It can look like this.

Build TinyORM

Everything is ready for build, you can press Ctrl+b to build the project.

qmake build options

`CONFIG` Option Name	Default	Description
`build_tests`	`OFF`	Build TinyORM unit tests.
`disable_thread_local`	`OFF`	Remove all `thread_local` storage duration specifiers, it disables threading support.
`disable_orm`	`OFF`	Controls the compilation of all `ORM-related` source code, when this option is `enabled`, then only the `query builder` without `ORM` is compiled. Also excludes `ORM-related` unit tests.
`disable_tom`	`OFF`	Controls the compilation of all `Tom-related` source code, when this option is `disabled`, then it also excludes `Tom-related` unit tests.
`inline_constants`	`OFF`	Use inline constants instead of extern constants in the `shared build`. `OFF` is highly recommended for the `shared build`; is always `ON` for the `static build`. Available when: `CONFIG(shared\|dll)`
`link_pkgconfig_off`	`OFF`	Link against `libmariadb` with `PKGCONFIG`. Used only in the `MinGW` shared build (exactly `win32-g++\|win32-clang-g++`) and when `mysql_ping` is also defined to link against `libmariadb`, source code. Available when: `(win32-g++\|win32-clang-g++):mysql:!static:!staticlib`
`mysql_ping`	`OFF`	Enable `Orm::MySqlConnection::pingDatabase()` method.
`tiny_ccache`	`ON`	Enable compiler cache. Homepage It works only on Windows systems. It works well with the MSYS2 `g++`, `clang++`, `msvc`, and `clang-cl` with `msvc`. It disables `precompile_header` as they are not supported on Windows and changes the `-Zi` compiler option to the `-Z7` for debug builds as the `-Zi` compiler option is not supported (link to the issue).
`tom_example`	`OFF`	Build the `Tom` command-line application example (console application).

Advanced TinyORM options.

Option Name	Default	Description
`ubsan`	`OFF`	Allows to enable UBSan sanitizer (Clang only).

Important qmake options.

`CONFIG` Option Name	Default	Description
`ccache`	`OFF`	Enable compiler cache. Homepage It works only on the Unix systems. It works well with the `g++` and `clang++` and also supports precompiled headers.
`precompile_header`	`-`	Enable precompiled headers, you can disable them with: `CONFIG-=precompile_header`. The `precompile_header` is enabled by default on `msvc`, `g++`, `clang++`, `clang-cl` on `Windows` and disabled by default on `linux`.
`static` `staticlib`	`OFF`	Build as a static library (lib only).

Consume TinyOrm library (qmake) {#consume-tinyorm-library-qmake}

The TinyOrm.pri file is available to simplify the integration of the TinyORM library into your application. This file sets up all the qmake variables that are needed by TinyORM. You can use it to configure the TinyORM library.

TINY_MAIN_DIR = $$clean_path(<your_path>)
# Name of this qmake variable is crucial
TINYORM_BUILD_TREE = $$quote($$TINY_MAIN_DIR/TinyOrm-builds-qmake/build-TinyOrm-Desktop_Qt_6_3_1_MSVC2019_64bit-Debug)

include($$TINY_MAIN_DIR/TinyORM/qmake/TinyOrm.pri)

You will have to link against the TinyORM library manually if you don't set the TINYORM_BUILD_TREE qmake variable before the inclusion of the TinyOrm.pri file. The INCLUDEPATH is autodetected every time.

# Link against TinyORM library
# ---
TINY_MAIN_DIR = $$clean_path(<your_path>)
TINY_TINYORM_BUILDS_DIR = $$quote($$TINY_MAIN_DIR/TinyOrm-builds-qmake)

# Configure TinyORM library
include($$TINY_MAIN_DIR/TinyORM/qmake/TinyOrm.pri)

# TinyORM library path
LIBS += $$quote(-L$$TINY_TINYORM_BUILDS_DIR/build-TinyOrm-Desktop_Qt_5_15_2_MSVC2019_64bit-Debug/src/debug/)
LIBS += -lTinyOrm

# Link against TinyORM library
# ---
TINY_MAIN_DIR = $$clean_path(<your_path>)
TINY_TINYORM_BUILDS_DIR = $$quote($$TINY_MAIN_DIR/TinyOrm-builds-qmake)

# Configure TinyORM library
include($$TINY_MAIN_DIR/TinyORM/qmake/TinyOrm.pri)

# TinyORM library path
LIBS += $$quote(-L$$TINY_TINYORM_BUILDS_DIR/build-TinyOrm-Desktop_Qt_5_15_2_GCC_64bit-Debug/src/debug/)
LIBS += -lTinyOrm

The last thing is to set up the INCLUDEPATH for the vcpkg that provides the range-v3 and tabulate header files.

# vcpkg - range-v3 and tabulate
# ---
INCLUDEPATH += $$quote(<your_path>/vcpkg/installed/x64-windows/include/)

# vcpkg - range-v3 and tabulate
# ---
QMAKE_CXXFLAGS += -isystem $$shell_quote(<your_path>/vcpkg/installed/x64-linux/include/)

Do not forget to add TinyOrm0d.dll on the path on Windows and on the LD_LIBRARY_PATH on Linux, so your application can find it during execution.

{`$env:Path = "${applicationFolderPath(pwsh, false)}\\TinyORM\\TinyORM-builds-qmake\\build-debug;" + $env:Path`} {`export LD_LIBRARY_PATH=${applicationFolderPath(bash)}/TinyORM/TinyORM-builds-qmake/build-debug\${PATH:+:}$PATH`}

:::tip On Linux -isystem marks the directory as a system directory, it prevents warnings. :::

:::tip On Windows you can use QMAKE_CXXFLAGS_WARN_ON = -external:anglebrackets -external:W0, it applies a warning level 0 to the angel bracket includes, #include <file>. :::

Ccache support

The TinyORM supports the ccache out of the box for all supported compilers. For qmake you can enable it using the CONFIG+=ccache on Linux or CONFIG+=tiny_ccache on Windows. For CMake you can set the CMAKE_CXX_COMPILER_LAUNCHER=ccache.

On Linux it's clear, the ccache is fully supported and works also with the precompiled headers. But was necessary to add some workarounds to the qmake/CMake build systems to make out of the box support on Windows. When you enable the ccache on Windows then the build system disables precompiled headers and replaces the -Zi compiler option with the -Z7 (link to the issue).

:::tip You can install the ccache using the scoop install ccache command on Windows. :::

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

tinyorm.mdx

tinyorm.mdx

Building: TinyORM

Introduction

Common Prerequisites

Windows Prerequisites

Build environment scripts

Allow symbolic links unprivileged

Folders structure

Getting started

vcpkg

C preprocessor macros

Building with CMake

Configure & Build (cmake) {#configure-and-build-cmake}

Build TinyORM

CMake build options

Consume TinyOrm library (cmake) {#consume-tinyorm-library-cmake}

Building with qmake

Install dependencies

Configure & Build (qmake) {#configure-and-build-qmake}

Open QtCreator IDE

Configure TinyORM

Build TinyORM

qmake build options

Consume TinyOrm library (qmake) {#consume-tinyorm-library-qmake}

Ccache support

Files

tinyorm.mdx

Latest commit

History

tinyorm.mdx

File metadata and controls

Building: TinyORM

Introduction

Common Prerequisites

Windows Prerequisites

Build environment scripts

Allow symbolic links unprivileged

Folders structure

Getting started

vcpkg

C preprocessor macros

Building with CMake

Configure & Build (cmake) {#configure-and-build-cmake}

Build TinyORM

CMake build options

Consume TinyOrm library (cmake) {#consume-tinyorm-library-cmake}

Building with qmake

Install dependencies

Configure & Build (qmake) {#configure-and-build-qmake}

Open QtCreator IDE

Configure TinyORM

Build TinyORM

qmake build options

Consume TinyOrm library (qmake) {#consume-tinyorm-library-qmake}

Ccache support