helper.php

<?php

/**
 * @noinspection SqlNoDataSourceInspection
 * @noinspection SqlDialectInspection
 * @noinspection PhpComposerExtensionStubsInspection
 */

use dokuwiki\Extension\Plugin;
use dokuwiki\plugin\sqlite\SQLiteDB;
use dokuwiki\plugin\sqlite\Tools;

// phpcs:disable PSR1.Files.SideEffects.FoundWithSymbols, PSR1.Classes.ClassDeclaration.MultipleClasses
// phpcs:disable PSR1.Methods.CamelCapsMethodName.NotCamelCaps

/**
 * For compatibility with previous adapter implementation.
 */
if (!defined('DOKU_EXT_PDO')) define('DOKU_EXT_PDO', 'pdo');
class helper_plugin_sqlite_adapter_dummy
{
    public function getName()
    {
        return DOKU_EXT_PDO;
    }

    public function setUseNativeAlter($set)
    {
    }
}

/**
 * DokuWiki Plugin sqlite (Helper Component)
 *
 * @license GPL 2 http://www.gnu.org/licenses/gpl-2.0.html
 * @author  Andreas Gohr <gohr@cosmocode.de>
 * @deprecated 2023-03-15
 */
class helper_plugin_sqlite extends Plugin
{
    /** @var SQLiteDB|null */
    protected $adapter;

    /** @var array result cache */
    protected $data;

    /**
     * constructor
     */
    public function __construct()
    {
        if (!$this->existsPDOSqlite()) {
            msg('PDO SQLite support missing in this PHP install - The sqlite plugin will not work', -1);
        }
        $this->adapter = new helper_plugin_sqlite_adapter_dummy();
    }

    /**
     * Get the current Adapter
     * @return SQLiteDB|null
     */
    public function getAdapter()
    {
        return $this->adapter;
    }

    /**
     * Keep separate instances for every call to keep database connections
     */
    public function isSingleton()
    {
        return false;
    }

    /**
     * check availabilty of PHP PDO sqlite3
     */
    public function existsPDOSqlite()
    {
        if (class_exists('pdo')) {
            return in_array('sqlite', \PDO::getAvailableDrivers());
        }
        return false;
    }

    /**
     * Initializes and opens the database
     *
     * Needs to be called right after loading this helper plugin
     *
     * @param string $dbname
     * @param string $updatedir - Database update infos
     * @return bool
     */
    public function init($dbname, $updatedir)
    {
        if (!defined('DOKU_UNITTEST')) { // for now we don't want to trigger the deprecation warning in the tests
            dbg_deprecated(SQLiteDB::class);
        }

        try {
            $this->adapter = new SQLiteDB($dbname, $updatedir, $this);
        } catch (Exception $e) {
            msg('SQLite: ' . $e->getMessage(), -1);
            return false;
        }
        return true;
    }

    /**
     * This is called from the adapter itself for backwards compatibility
     *
     * @param SQLiteDB $adapter
     * @return void
     */
    public function setAdapter($adapter)
    {
        $this->adapter = $adapter;
    }

    /**
     * Registers a User Defined Function for use in SQL statements
     */
    public function create_function($function_name, $callback, $num_args)
    {
        $this->adapter->getPdo()->sqliteCreateFunction($function_name, $callback, $num_args);
    }

    // region query and result handling functions

    /**
     * Convenience function to run an INSERT OR REPLACE operation
     *
     * The function takes a key-value array with the column names in the key and the actual value in the value,
     * build the appropriate query and executes it.
     *
     * @param string $table the table the entry should be saved to (will not be escaped)
     * @param array $entry A simple key-value pair array (only values will be escaped)
     * @return bool
     */
    public function storeEntry($table, $entry)
    {
        try {
            $this->adapter->saveRecord($table, $entry);
        } catch (\Exception $e) {
            msg('SQLite: ' . $e->getMessage(), -1);
            return false;
        }

        return true;
    }

    /**
     * Execute a query with the given parameters.
     *
     * Takes care of escaping
     *
     *
     * @param string ...$args - the arguments of query(), the first is the sql and others are values
     */
    public function query(...$args)
    {
        // clear the cache
        $this->data = null;

        try {
            $sql = $this->prepareSql($args);
            return $this->adapter->query($sql);
        } catch (\Exception $e) {
            msg('SQLite: ' . $e->getMessage(), -1);
            return false;
        }
    }

    /**
     * Prepare a query with the given arguments.
     *
     * Takes care of escaping
     *
     * @param array $args
     *    array of arguments:
     *      - string $sql - the statement
     *      - arguments...
     * @return bool|string
     * @throws Exception
     */
    public function prepareSql($args)
    {

        $sql = trim(array_shift($args));
        $sql = rtrim($sql, ';');

        if (!$sql) {
            throw new \Exception('No SQL statement given', -1);
        }

        $argc = count($args);
        if ($argc > 0 && is_array($args[0])) {
            $args = $args[0];
            $argc = count($args);
        }

        // check number of arguments
        $qmc = substr_count($sql, '?');
        if ($argc < $qmc) {
            throw new \Exception('Not enough arguments passed for statement. ' .
                'Expected ' . $qmc . ' got ' . $argc . ' - ' . hsc($sql));
        } elseif ($argc > $qmc) {
            throw new \Exception('Too much arguments passed for statement. ' .
                'Expected ' . $qmc . ' got ' . $argc . ' - ' . hsc($sql));
        }

        // explode at wildcard, then join again
        $parts = explode('?', $sql, $argc + 1);
        $args  = array_map([$this->adapter->getPdo(), 'quote'], $args);
        $sql   = '';

        while (($part = array_shift($parts)) !== null) {
            $sql .= $part;
            $sql .= array_shift($args);
        }

        return $sql;
    }


    /**
     * Closes the result set (and it's cursors)
     *
     * If you're doing SELECT queries inside a TRANSACTION, be sure to call this
     * function on all your results sets, before COMMITing the transaction.
     *
     * Also required when not all rows of a result are fetched
     *
     * @param \PDOStatement $res
     * @return bool
     */
    public function res_close($res)
    {
        if (!$res) return false;

        return $res->closeCursor();
    }

    /**
     * Returns a complete result set as array
     *
     * @param \PDOStatement $res
     * @return array
     */
    public function res2arr($res, $assoc = true)
    {
        if (!$res) return [];

        // this is a bullshit workaround for having res2arr and res2count work on one result
        if (!$this->data) {
            $mode = $assoc ? PDO::FETCH_ASSOC : PDO::FETCH_NUM;
            $this->data = $res->fetchAll($mode);
        }
        return $this->data;
    }

    /**
     * Return the next row from the result set as associative array
     *
     * @param \PDOStatement $res
     * @param int $rownum will be ignored
     */
    public function res2row($res, $rownum = 0)
    {
        if (!$res) return false;

        return $res->fetch(\PDO::FETCH_ASSOC);
    }

    /**
     * Return the first value from the next row.
     *
     * @param \PDOStatement $res
     * @return mixed
     */
    public function res2single($res)
    {
        if (!$res) return false;

        $data = $res->fetch(PDO::FETCH_NUM, PDO::FETCH_ORI_ABS, 0);
        if (empty($data)) {
            return false;
        }
        return $data[0];
    }

    /**
     * fetch the next row as zero indexed array
     *
     * @param \PDOStatement $res
     * @return array|bool
     */
    public function res_fetch_array($res)
    {
        if (!$res) return false;

        return $res->fetch(PDO::FETCH_NUM);
    }

    /**
     * fetch the next row as assocative array
     *
     * @param \PDOStatement $res
     * @return array|bool
     */
    public function res_fetch_assoc($res)
    {
        if (!$res) return false;

        return $res->fetch(PDO::FETCH_ASSOC);
    }

    /**
     * Count the number of records in result
     *
     * This function is really inperformant in PDO and should be avoided!
     *
     * @param \PDOStatement $res
     * @return int
     */
    public function res2count($res)
    {
        if (!$res) return 0;

        // this is a bullshit workaround for having res2arr and res2count work on one result
        if (!$this->data) {
            $this->data = $this->res2arr($res);
        }

        return count($this->data);
    }

    /**
     * Count the number of records changed last time
     *
     * @param \PDOStatement $res
     * @return int
     */
    public function countChanges($res)
    {
        if (!$res) return 0;

        return $res->rowCount();
    }

    // endregion

    // region quoting/escaping functions

    /**
     * Join the given values and quote them for SQL insertion
     */
    public function quote_and_join($vals, $sep = ',')
    {
        $vals = array_map([$this->adapter->getPdo(), 'quote'], $vals);
        return implode($sep, $vals);
    }

    /**
     * Quotes a string, by escaping it and adding quotes
     */
    public function quote_string($string)
    {
        return $this->adapter->getPdo()->quote($string);
    }

    /**
     * Similar to quote_string, but without the quotes, useful to construct LIKE patterns
     */
    public function escape_string($str)
    {
        return trim($this->adapter->getPdo()->quote($str), "'");
    }

    // endregion

    // region speciality functions

    /**
     * Split sql queries on semicolons, unless when semicolons are quoted
     *
     * Usually you don't need this. It's only really needed if you need individual results for
     * multiple queries. For example in the admin interface.
     *
     * @param string $sql
     * @return array sql queries
     * @deprecated
     */
    public function SQLstring2array($sql)
    {
        if (!DOKU_UNITTEST) { // for now we don't want to trigger the deprecation warning in the tests
            dbg_deprecated(Tools::class . '::SQLstring2array');
        }
        return Tools::SQLstring2array($sql);
    }

    /**
     * @deprecated needs to be fixed in stuct and structpublish
     */
    public function doTransaction($sql, $sqlpreparing = true)
    {
        throw new \Exception(
            'This method seems to never have done what it suggests. Please use the query() function instead.'
        );
    }

    // endregion
}