linux-qt5.yml

# MySQL and PostgreSQL
# ---
# Both use the default unencrypted database connections.

name: Linux GCC/Clang Qt5.15

on:
  workflow_dispatch:
  push:
    branches:
      - main

jobs:

  build:
    name: cmake build / ctest

    runs-on: ubuntu-22.04

    strategy:
      matrix:
        compiler:
          - key: clang18
            apt: [ clang-18, lld-18 ]
            command: clang++-18

          - key: gcc12
            apt: [ g++-12 ]
            command: g++-12

    steps:
    - uses: actions/checkout@v4

    - name: TinyORM prepare environment
      run: |
        runnerWorkPath=$(realpath '${{ runner.workspace }}/..')
        echo "TinyRunnerWorkPath=$runnerWorkPath" >> $GITHUB_ENV

        sqlitePath="$runnerWorkPath/SQLite/$DB_SQLITE_DATABASE"
        echo "TinySQLitePath=$sqlitePath" >> $GITHUB_ENV
      env:
        DB_SQLITE_DATABASE: ${{ secrets.DB_SQLITE_DATABASE }}

    - name: PostgreSQL service start
      run: |
        sudo systemctl start postgresql.service

    - name: PostgreSQL service check status
      run: |
        sudo systemctl status postgresql.service
        pg_isready

    - name: PostgreSQL create TinyORM user
      run: >-
        sudo --user=postgres --
        psql --command="create user \"$DB_PGSQL_USERNAME\"
        with createdb password '$DB_PGSQL_PASSWORD';"
      env:
        DB_PGSQL_PASSWORD: ${{ secrets.DB_PGSQL_PASSWORD }}
        DB_PGSQL_USERNAME: ${{ secrets.DB_PGSQL_USERNAME }}

    - name: PostgreSQL create TinyORM database
      run: |
        sudo --user=postgres -- createdb --owner=$DB_PGSQL_USERNAME $DB_PGSQL_DATABASE
      env:
        DB_PGSQL_DATABASE: ${{ secrets.DB_PGSQL_DATABASE }}
        DB_PGSQL_USERNAME: ${{ secrets.DB_PGSQL_USERNAME }}

    - name: MySQL initialize crystal_mysqld.cnf configuration
      working-directory: .github/resources/linux
      run: |
        sudo mv --target-directory=/etc/mysql/mysql.conf.d/ ./crystal_mysqld.cnf

    - name: MySQL initialize crystal_client.cnf configuration (global)
      working-directory: .github/resources/linux
      run: >-
        cat ./crystal_client.template.cnf |
        sed "s/{MYSQL_HOST}/$DB_MYSQL_HOST/" |
        sudo tee /etc/mysql/conf.d/crystal_client.cnf > /dev/null
      env:
        DB_MYSQL_HOST: ${{ secrets.DB_MYSQL_HOST }}

    - name: MySQL service start
      run: |
        sudo systemctl start mysql.service

    - name: MySQL change ${{ secrets.DB_MYSQL_ROOT_USERNAME }} password
      run: >-
        echo "
        alter user '$DB_MYSQL_ROOT_USERNAME'@'localhost'
        identified with caching_sha2_password by '$DB_MYSQL_ROOT_PASSWORD';" |
        mysql --user="$DB_MYSQL_ROOT_USERNAME" --password="$DB_MYSQL_ROOT_PASSWORD_DEFAULT"
      env:
        DB_MYSQL_ROOT_PASSWORD: ${{ secrets.DB_MYSQL_ROOT_PASSWORD }}
        DB_MYSQL_ROOT_PASSWORD_DEFAULT: ${{ secrets.DB_MYSQL_ROOT_PASSWORD_DEFAULT }}
        DB_MYSQL_ROOT_USERNAME: ${{ secrets.DB_MYSQL_ROOT_USERNAME }}

    - name: MySQL populate time zone tables 👌
      run: >-
        mysql_tzinfo_to_sql /usr/share/zoneinfo |
        mysql --user="$DB_MYSQL_ROOT_USERNAME" --password="$DB_MYSQL_ROOT_PASSWORD" mysql

        sudo systemctl restart mysql.service
      env:
        DB_MYSQL_ROOT_PASSWORD: ${{ secrets.DB_MYSQL_ROOT_PASSWORD }}
        DB_MYSQL_ROOT_USERNAME: ${{ secrets.DB_MYSQL_ROOT_USERNAME }}

    - name: MySQL service check status
      run: |
        echo '::group::Service status'
        systemctl status mysql.service
        echo '::endgroup::'

        echo '::group::Service is-active check'
        systemctl is-active --quiet mysql.service
        echo '::endgroup::'

        echo '::group::Ping'
        mysqladmin --user="$DB_MYSQL_ROOT_USERNAME" --password="$DB_MYSQL_ROOT_PASSWORD" ping
        echo '::endgroup::'
      env:
        DB_MYSQL_ROOT_PASSWORD: ${{ secrets.DB_MYSQL_ROOT_PASSWORD }}
        DB_MYSQL_ROOT_USERNAME: ${{ secrets.DB_MYSQL_ROOT_USERNAME }}

    - name: MySQL create TinyORM database
      run: >-
        echo "
        create database if not exists \`$DB_MYSQL_DATABASE\`
        default character set $DB_MYSQL_CHARSET
        default collate $DB_MYSQL_COLLATION;" |
        mysql --user="$DB_MYSQL_ROOT_USERNAME" --password="$DB_MYSQL_ROOT_PASSWORD"
      env:
        DB_MYSQL_CHARSET: ${{ secrets.DB_MYSQL_CHARSET }}
        DB_MYSQL_COLLATION: ${{ secrets.DB_MYSQL_COLLATION }}
        DB_MYSQL_DATABASE: ${{ secrets.DB_MYSQL_DATABASE }}
        DB_MYSQL_ROOT_PASSWORD: ${{ secrets.DB_MYSQL_ROOT_PASSWORD }}
        DB_MYSQL_ROOT_USERNAME: ${{ secrets.DB_MYSQL_ROOT_USERNAME }}

    - name: MySQL create TinyORM user
      run: >-
        echo "
        create user '$DB_MYSQL_USERNAME'@'%'
        identified with caching_sha2_password by '$DB_MYSQL_PASSWORD';
        grant all privileges on \`tinyorm\\_%\`.* to '$DB_MYSQL_USERNAME'@'%';
        grant select on \`mysql\`.\`time_zone_name\` to '$DB_MYSQL_USERNAME'@'%';
        flush privileges;" |
        mysql --user="$DB_MYSQL_ROOT_USERNAME" --password="$DB_MYSQL_ROOT_PASSWORD"
      env:
        DB_MYSQL_PASSWORD: ${{ secrets.DB_MYSQL_PASSWORD }}
        DB_MYSQL_ROOT_PASSWORD: ${{ secrets.DB_MYSQL_ROOT_PASSWORD }}
        DB_MYSQL_ROOT_USERNAME: ${{ secrets.DB_MYSQL_ROOT_USERNAME }}
        DB_MYSQL_USERNAME: ${{ secrets.DB_MYSQL_USERNAME }}

    - name: SQLite create TinyORM database
      run: |
        mkdir --parents "$(dirname "${{ env.TinySQLitePath }}")"

        touch '${{ env.TinySQLitePath }}'

    - name: Print MySQL, SQLite, PostgreSQL database versions
      run: |
        mysql --version
        pg_config --version
        sqlite3 --version

    - name: add-apt-repository Clang 18
      if: matrix.compiler.key == 'clang18'
      run: >-
        wget -O- https://apt.llvm.org/llvm-snapshot.gpg.key |
        sudo tee /etc/apt/trusted.gpg.d/llvm-18.asc > /dev/null

        sudo add-apt-repository --yes
        --sourceslist 'deb http://apt.llvm.org/jammy/ llvm-toolchain-jammy-18 main'

    - name: apt update
      run: |
        sudo apt update

    - name: apt install ${{ join(matrix.compiler.apt, ', ') }}, and Qt 5.15.3 base
      run: >-
        sudo apt install --yes ${{ join(matrix.compiler.apt, ' ') }}
        qtbase5-dev libqt5sql5-mysql libqt5sql5-sqlite libqt5sql5-psql

    - name: Ninja install latest version
      uses: seanmiddleditch/gha-setup-ninja@master
      with:
        destination: ${{ env.TinyRunnerWorkPath }}/ninja-build

    - name: Ccache initialize download
      id: downloads-initialize-ccache
      run: |
        filename=$(basename "$URL_CCACHE_LINUX_X64")
        echo "Filename=$filename" >> $GITHUB_OUTPUT

        filepath="${{ runner.temp }}/$filename"
        echo "Filepath=$filepath" >> $GITHUB_OUTPUT

        hash=$(wget "$URL_CACHE_HASH_LINUX" -O- --no-verbose --quiet)
        echo "Hash=$hash" >> $GITHUB_OUTPUT
      env:
        URL_CACHE_HASH_LINUX: ${{ secrets.URL_CACHE_HASH_LINUX }}
        URL_CCACHE_LINUX_X64: ${{ secrets.URL_CCACHE_LINUX_X64 }}

    - name: Ccache restore cache (download)
      uses: actions/cache@v3
      id: downloads-cache-ccache
      with:
        path: ${{ env.archive_filepath }}
        key: ${{ runner.os }}-caches-${{ env.cache_name }}-${{ env.cache_hash }}
      env:
        archive_filepath: ${{ steps.downloads-initialize-ccache.outputs.Filepath }}
        cache_hash: ${{ steps.downloads-initialize-ccache.outputs.Hash }}
        cache_name: ccache

    - name: Ccache download
      if: steps.downloads-cache-ccache.outputs.cache-hit != 'true'
      run: |
        wget "$URL_CCACHE_LINUX_X64" --output-document="$archive_filepath" --no-verbose
      env:
        archive_filepath: ${{ steps.downloads-initialize-ccache.outputs.Filepath }}
        URL_CCACHE_LINUX_X64: ${{ secrets.URL_CCACHE_LINUX_X64 }}

    - name: Ccache install
      run: |
        echo '::group::Extract archive'
        tar xJvf "$archive_filepath" --directory '${{ runner.temp }}'
        echo '::endgroup::'

        echo '::group::Install'
        extractedFolder=$(basename --suffix='.tar.xz' "$archive_filename")
        cd "${{ runner.temp }}/$extractedFolder"
        sudo make install
        echo '::endgroup::'

        echo '::group::Print version'
        ccache --version
        echo '::endgroup::'
      env:
        archive_filename: ${{ steps.downloads-initialize-ccache.outputs.Filename }}
        archive_filepath: ${{ steps.downloads-initialize-ccache.outputs.Filepath }}

    - name: Ccache initialize
      id: ccache-initialize-cache
      run: |
        cachePath=$(ccache --get-config cache_dir)
        echo "CachePath=$cachePath" >> $GITHUB_OUTPUT

        echo "ImageOS=$ImageOS" >> $GITHUB_OUTPUT

    - name: Ccache restore cache 🕺
      uses: actions/cache@v3
      with:
        path: ${{ env.cache_path }}
        key: ${{ runner.os }}-${{ env.image_os }}-ccache-${{ env.cache_name }}-${{ github.run_id }}
        restore-keys: |
          ${{ runner.os }}-${{ env.image_os }}-ccache-${{ env.cache_name }}-
      env:
        cache_name: ${{ matrix.compiler.key }}-qt5
        cache_path: ${{ steps.ccache-initialize-cache.outputs.CachePath }}
        image_os: ${{ steps.ccache-initialize-cache.outputs.ImageOS }}

    - name: Ccache prepare configuration 🥳
      run: |
        # gcc: ~ 115 * 3 + 100 ; clang: ~ 90 * 3 + 100
        ccache --set-config max_size=${{ matrix.compiler.key == 'gcc12' && '450M' || '380M' }}
        ccache --set-config sloppiness=pch_defines,time_macros
        ccache --show-config

    - name: Ccache print version and configuration
      run: |
        echo '::group::Print version'
        ccache --version
        echo '::endgroup::'

        echo '::group::Print ccache config'
        ccache --show-config
        echo '::endgroup::'

    - name: vcpkg prepare environment
      run: |
        echo "VCPKG_ROOT=$VCPKG_INSTALLATION_ROOT" >> $GITHUB_ENV
        echo 'VCPKG_DEFAULT_TRIPLET=x64-linux-dynamic' >> $GITHUB_ENV
        echo 'VCPKG_MAX_CONCURRENCY=2' >> $GITHUB_ENV

    - name: CMake print version
      run: |
        cmake --version

    - name: TinyORM create build folder (${{ matrix.compiler.key }}-cmake-debug)
      run: |
        mkdir --parents '../TinyORM-builds-cmake/build-${{ matrix.compiler.key }}-cmake-debug'

    - name: Ccache clear statistics
      run: |
        ccache --zero-stats

    - name: TinyORM cmake configure (${{ matrix.compiler.key }}-cmake-debug)
      run: >-
        cmake
        -S .
        -B ../TinyORM-builds-cmake/build-${{ matrix.compiler.key }}-cmake-debug
        -G Ninja
        -D CMAKE_CXX_COMPILER_LAUNCHER:FILEPATH=/usr/local/bin/ccache
        -D CMAKE_CXX_COMPILER:FILEPATH='/usr/bin/${{ matrix.compiler.command }}'
        -D CMAKE_TOOLCHAIN_FILE:FILEPATH="$VCPKG_INSTALLATION_ROOT/scripts/buildsystems/vcpkg.cmake"
        -D CMAKE_DISABLE_PRECOMPILE_HEADERS:BOOL=ON
        -D CMAKE_EXPORT_PACKAGE_REGISTRY:BOOL=OFF
        -D CMAKE_BUILD_TYPE:STRING=Debug
        -D CMAKE_CXX_SCAN_FOR_MODULES:BOOL=OFF
        -D VCPKG_APPLOCAL_DEPS:BOOL=OFF
        -D VERBOSE_CONFIGURE:BOOL=ON
        -D BUILD_TREE_DEPLOY:BOOL=OFF
        -D MATCH_EQUAL_EXPORTED_BUILDTREE:BOOL=OFF
        -D STRICT_MODE:BOOL=OFF
        -D MYSQL_PING:BOOL=ON
        -D BUILD_TESTS:BOOL=ON
        -D ORM:BOOL=ON
        -D TOM:BOOL=ON
        -D TOM_EXAMPLE:BOOL=ON
        -D BUILD_DRIVERS:BOOL=OFF

    - name: TinyORM cmake build ✨ (${{ matrix.compiler.key }}-cmake-debug)
      run: >-
        cmake --build ../TinyORM-builds-cmake/build-${{ matrix.compiler.key }}-cmake-debug
        --target all --parallel 2

    - name: Ccache print statistics
      run: |
        ccache --show-stats -vv

    - name: Create and Seed tables for unit tests 🎉
      working-directory: ../TinyORM-builds-cmake/build-${{ matrix.compiler.key }}-cmake-debug/tests/testdata_tom
      run: >-
        export LD_LIBRARY_PATH=../..${LD_LIBRARY_PATH:+:}"$LD_LIBRARY_PATH"

        ./tom_testdata migrate
        --database=tinyorm_testdata_tom_mysql,tinyorm_testdata_tom_postgres,tinyorm_testdata_tom_sqlite
        --seed --no-ansi
      env:
        DB_MYSQL_CHARSET: ${{ secrets.DB_MYSQL_CHARSET }}
        DB_MYSQL_COLLATION: ${{ secrets.DB_MYSQL_COLLATION }}
        DB_MYSQL_DATABASE: ${{ secrets.DB_MYSQL_DATABASE }}
        DB_MYSQL_HOST: ${{ secrets.DB_MYSQL_HOST }}
        DB_MYSQL_PASSWORD: ${{ secrets.DB_MYSQL_PASSWORD }}
        DB_MYSQL_USERNAME: ${{ secrets.DB_MYSQL_USERNAME }}
        DB_PGSQL_CHARSET: ${{ secrets.DB_PGSQL_CHARSET }}
        DB_PGSQL_DATABASE: ${{ secrets.DB_PGSQL_DATABASE }}
        DB_PGSQL_HOST: ${{ secrets.DB_PGSQL_HOST }}
        DB_PGSQL_PASSWORD: ${{ secrets.DB_PGSQL_PASSWORD }}
        DB_PGSQL_SEARCHPATH: ${{ secrets.DB_PGSQL_SEARCHPATH }}
        DB_PGSQL_USERNAME: ${{ secrets.DB_PGSQL_USERNAME }}
        DB_SQLITE_DATABASE: ${{ env.TinySQLitePath }}
        TOM_TESTDATA_ENV: ${{ vars.TOM_TESTDATA_ENV }}

    - name: TinyORM execute ctest 🔥
      working-directory: ../TinyORM-builds-cmake/build-${{ matrix.compiler.key }}-cmake-debug
      run: |
        ctest --output-on-failure
      env:
        DB_MYSQL_CHARSET: ${{ secrets.DB_MYSQL_CHARSET }}
        DB_MYSQL_COLLATION: ${{ secrets.DB_MYSQL_COLLATION }}
        DB_MYSQL_DATABASE: ${{ secrets.DB_MYSQL_DATABASE }}
        DB_MYSQL_HOST: ${{ secrets.DB_MYSQL_HOST }}
        DB_MYSQL_PASSWORD: ${{ secrets.DB_MYSQL_PASSWORD }}
        DB_MYSQL_USERNAME: ${{ secrets.DB_MYSQL_USERNAME }}
        DB_PGSQL_CHARSET: ${{ secrets.DB_PGSQL_CHARSET }}
        DB_PGSQL_DATABASE: ${{ secrets.DB_PGSQL_DATABASE }}
        DB_PGSQL_HOST: ${{ secrets.DB_PGSQL_HOST }}
        DB_PGSQL_PASSWORD: ${{ secrets.DB_PGSQL_PASSWORD }}
        DB_PGSQL_SEARCHPATH: ${{ secrets.DB_PGSQL_SEARCHPATH }}
        DB_PGSQL_USERNAME: ${{ secrets.DB_PGSQL_USERNAME }}
        DB_SQLITE_DATABASE: ${{ env.TinySQLitePath }}
        TOM_TESTS_ENV: ${{ vars.TOM_TESTS_ENV }}

    - name: Tom example test some commands (MySQL) 🚀
      working-directory: ../TinyORM-builds-cmake/build-${{ matrix.compiler.key }}-cmake-debug/examples/tom
      run: |
        export LD_LIBRARY_PATH=../..${LD_LIBRARY_PATH:+:}"$LD_LIBRARY_PATH"

        ./tom migrate:fresh --database=tinyorm_tom_mysql --no-ansi
        ./tom migrate:uninstall --reset --database=tinyorm_tom_mysql --no-ansi
        ./tom migrate:install --database=tinyorm_tom_mysql --no-ansi
        ./tom migrate --database=tinyorm_tom_mysql --seed --no-ansi
        ./tom migrate:status --database=tinyorm_tom_mysql --no-ansi
        ./tom migrate:refresh --database=tinyorm_tom_mysql --seed --no-ansi
        ./tom migrate:reset --database=tinyorm_tom_mysql --no-ansi
        ./tom migrate:uninstall --database=tinyorm_tom_mysql --no-ansi
      env:
        DB_MYSQL_CHARSET: ${{ secrets.DB_MYSQL_CHARSET }}
        DB_MYSQL_COLLATION: ${{ secrets.DB_MYSQL_COLLATION }}
        DB_MYSQL_DATABASE: ${{ secrets.DB_MYSQL_DATABASE }}
        DB_MYSQL_HOST: ${{ secrets.DB_MYSQL_HOST }}
        DB_MYSQL_PASSWORD: ${{ secrets.DB_MYSQL_PASSWORD }}
        DB_MYSQL_USERNAME: ${{ secrets.DB_MYSQL_USERNAME }}
        TOM_EXAMPLE_ENV: ${{ vars.TOM_EXAMPLE_ENV }}

    - name: Tom example test some commands (PostgreSQL) 🙌
      working-directory: ../TinyORM-builds-cmake/build-${{ matrix.compiler.key }}-cmake-debug/examples/tom
      run: |
        export LD_LIBRARY_PATH=../..${LD_LIBRARY_PATH:+:}"$LD_LIBRARY_PATH"

        ./tom migrate:fresh --database=tinyorm_tom_postgres --no-ansi
        ./tom migrate:uninstall --reset --database=tinyorm_tom_postgres --no-ansi
        ./tom migrate:install --database=tinyorm_tom_postgres --no-ansi
        ./tom migrate --database=tinyorm_tom_postgres --seed --no-ansi
        ./tom migrate:status --database=tinyorm_tom_postgres --no-ansi
        ./tom migrate:refresh --database=tinyorm_tom_postgres --seed --no-ansi
        ./tom migrate:reset --database=tinyorm_tom_postgres --no-ansi
        ./tom migrate:uninstall --database=tinyorm_tom_postgres --no-ansi
      env:
        DB_PGSQL_CHARSET: ${{ secrets.DB_PGSQL_CHARSET }}
        DB_PGSQL_DATABASE: ${{ secrets.DB_PGSQL_DATABASE }}
        DB_PGSQL_HOST: ${{ secrets.DB_PGSQL_HOST }}
        DB_PGSQL_PASSWORD: ${{ secrets.DB_PGSQL_PASSWORD }}
        DB_PGSQL_SEARCHPATH: ${{ secrets.DB_PGSQL_SEARCHPATH }}
        DB_PGSQL_USERNAME: ${{ secrets.DB_PGSQL_USERNAME }}
        TOM_EXAMPLE_ENV: ${{ vars.TOM_EXAMPLE_ENV }}

    - name: Tom example test some commands (SQLite) 🏁
      working-directory: ../TinyORM-builds-cmake/build-${{ matrix.compiler.key }}-cmake-debug/examples/tom
      run: |
        export LD_LIBRARY_PATH=../..${LD_LIBRARY_PATH:+:}"$LD_LIBRARY_PATH"

        ./tom migrate:fresh --database=tinyorm_tom_sqlite --no-ansi
        ./tom migrate:uninstall --reset --database=tinyorm_tom_sqlite --no-ansi
        ./tom migrate:install --database=tinyorm_tom_sqlite --no-ansi
        ./tom migrate --database=tinyorm_tom_sqlite --seed --no-ansi
        ./tom migrate:status --database=tinyorm_tom_sqlite --no-ansi
        ./tom migrate:refresh --database=tinyorm_tom_sqlite --seed --no-ansi
        ./tom migrate:reset --database=tinyorm_tom_sqlite --no-ansi
        ./tom migrate:uninstall --database=tinyorm_tom_sqlite --no-ansi
      env:
        DB_SQLITE_DATABASE: ${{ env.TinySQLitePath }}
        TOM_EXAMPLE_ENV: ${{ vars.TOM_EXAMPLE_ENV }}