DB::nchar() - Code Metrics - Inspection of "tmp workaround" - fisharebest/webtrees - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Push — dbal ( e2fd69...784ce7 )

by Greg
created 2023-09-17 19:02 UTC
DB::nchar() A

↳ Parent: DB
Complexity

Conditions	1
Paths	1
Size

Total Lines	8
Code Lines	6
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
cc	1
eloc	6
c	0
b	0
f	0
nc	1
nop	2
dl	0
loc	8
rs	10
<?php

/**
 * webtrees: online genealogy
 * Copyright (C) 2023 webtrees development team
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <https://www.gnu.org/licenses/>.
 */

declare(strict_types=1);

namespace Fisharebest\Webtrees;

use Doctrine\DBAL\Configuration;
use Doctrine\DBAL\Connection;
use Doctrine\DBAL\Driver as DBALDriver;
use Doctrine\DBAL\Query\Expression\ExpressionBuilder;
use Doctrine\DBAL\Query\QueryBuilder;
use DomainException;
use Fisharebest\Webtrees\DB\Column;
use Fisharebest\Webtrees\DB\ColumnType;
use Fisharebest\Webtrees\DB\Drivers\DriverInterface;
use Fisharebest\Webtrees\DB\Drivers\MySQLDriver;
use Fisharebest\Webtrees\DB\Drivers\PostgreSQLDriver;
use Fisharebest\Webtrees\DB\Drivers\SQLiteDriver;
use Fisharebest\Webtrees\DB\Drivers\SQLServerDriver;
use Fisharebest\Webtrees\DB\ForeignKey;
use Fisharebest\Webtrees\DB\Index;
use Fisharebest\Webtrees\DB\PrimaryKey;
use Fisharebest\Webtrees\DB\UniqueIndex;
use Illuminate\Database\Capsule\Manager;
use PDO;

use function array_key_first;
use function count;
use function str_starts_with;

/**
 * Static access to doctrine/dbal and laravel database
 */
class DB extends Manager
{
    private static Connection $connection;

    private static string $prefix;

    private static DBALDriver&DriverInterface $driver;

    public static function connect(PDO $pdo, string $prefix): void
    {
        $configuration = new Configuration();
        $configuration->setSchemaAssetsFilter(static fn (string $name): bool => str_starts_with($name, $prefix));

        $driver_name = $pdo->getAttribute(attribute: PDO::ATTR_DRIVER_NAME);

        self::$driver = match ($driver_name) {
            'mysql'    => new MySQLDriver(pdo: $pdo),
            'postgres' => new PostgreSQLDriver(pdo: $pdo),
            'sqlite'   => new SQLiteDriver(pdo: $pdo),
            'sqlsrv'   => new SQLServerDriver(pdo: $pdo),
            default    => throw new DomainException(message: 'No driver available for ' . $driver_name),
        };

        self::$connection = new Connection(params: [], driver: self::$driver, config: $configuration);
        self::$prefix     = $prefix;
    }

    /**
     * @todo - better function names are used by laravel, and we need them for the time being.
     */
    public static function getTheConnection()
    {
        return self::$connection;
    }

    public static function prefix(string $identifier = ''): string
    {
        return self::$prefix . $identifier;
    }

    public static function select(string ...$expressions): QueryBuilder
    {
        return self::$connection
            ->createQueryBuilder()
            ->select(...$expressions);
    }

    public static function update(string $table): QueryBuilder
    {
        return self::$connection->update(DB::prefix($table));
        return self::$connection->/** @scrutinizer ignore-call */ update(DB::prefix($table));
    }

    /**
     * @param string                                                $table
     * @param array<array-key,array<string,int|float|string|null>>  $rows

     */
    public static function insert(string $table, array $rows): void
    {
        foreach ($rows as $row) {
            DB::getTheConnection()->insert(DB::prefix($table), $row);
        }
    }

    public static function delete(string ...$expressions): QueryBuilder
    {
        return self::$connection
            ->createQueryBuilder()
            ->delete(...$expressions);
            ->delete(/** @scrutinizer ignore-type */ ...$expressions);
    }

    public static function expression(): ExpressionBuilder
    {
        return self::$connection->createExpressionBuilder();
    }


    public static function char(string $name, int $length): Column
    {
        return new Column(
            name: $name,
            type: ColumnType::Char,
            length: $length,
            fixed: true,
            collation: self::$driver->collationASCII(),
        );
    }

    public static function varchar(string $name, int $length): Column
    {
        return new Column(
            name: $name,
            type: ColumnType::Char,
            length: $length,
            collation: self::$driver->collationASCII(),
        );
    }

    public static function nchar(string $name, int $length): Column
    {
        return new Column(
            name: $name,
            type: ColumnType::NChar,
            length: $length,
            fixed: true,
            collation: self::$driver->collationUTF8(),
        );
    }

    public static function nvarchar(string $name, int $length): Column
    {
        return new Column(
            name: $name,
            type: ColumnType::NVarChar,
            length: $length,
            collation: self::$driver->collationUTF8(),
        );
    }

    public static function integer(string $name): Column
    {
        return new Column(name: $name, type: ColumnType::Integer);
    }

    public static function float(string $name): Column
    {
        return new Column(name: $name, type: ColumnType::Float);
    }

    public static function text(string $name): Column
    {
        return new Column(
            name: $name,
            type: ColumnType::Text,
            collation: self::$driver->collationUTF8(),
        );
    }

    public static function timestamp(string $name, int $precision = 0): Column
    {
        return new Column(name: $name, type: ColumnType::Timestamp, precision: $precision);
    }

    /**
     * @param array<array-key,string> $columns

     *
     * @return PrimaryKey
     */
    public static function primaryKey(array $columns): PrimaryKey
    {
        return new PrimaryKey(columns: $columns);
    }

    /**
     * @param array<array-key,string> $columns

     *
     * @return Index
     */
    public static function index(array $columns): Index
    {
        return new Index(columns: $columns);
    }

    /**
     * @param array<array-key,string> $columns

     *
     * @return UniqueIndex
     */
    public static function uniqueIndex(array $columns): UniqueIndex
    {
        return new UniqueIndex(columns: $columns);
    }

    /**
     * @param array<array-key,string> $local_columns

     * @param string                  $foreign_table
     * @param array<array-key,string> $foreign_columns
     *
     * @return ForeignKey
     */
    public static function foreignKey(array $local_columns, string $foreign_table, array $foreign_columns = null): ForeignKey
    {
        return new ForeignKey(
            local_columns: $local_columns,
            foreign_table: $foreign_table,
            foreign_columns: $foreign_columns ?? $local_columns,
        );
    }

    /**
     * @internal
     */
    public static function caseInsensitiveLikeOperator(): string
    {
        if (DB::getTheConnection()->getDriverName() === 'pgsql') {
        if (DB::getTheConnection()->/** @scrutinizer ignore-call */ getDriverName() === 'pgsql') {
            return 'ILIKE';
        }

        if (DB::getTheConnection()->getDriverName() === 'sqlsrv') {
            return 'COLLATE SQL_UTF8_General_CI_AI LIKE';
        }

        return 'LIKE';
    }
}

fisharebest / webtrees

Push — dbal ( e2fd69...784ce7 )

DB::nchar() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
