GDO.php

<?php
declare(strict_types=1);
namespace GDO\Core;

use GDO\Date\Time;
use GDO\DB\Cache;
use GDO\DB\Database;
use GDO\DB\Query;
use GDO\DB\Result;
use GDO\DBMS\Module_DBMS;
use GDO\UI\TextStyle;
use GDO\User\GDO_User;

/**
 * A data exchange object, and...
 *
 * A GDO is both, a table and an entity.
 * The table GDO just holds the caches and GDT instances.
 * The other entitites have $gdoVars. A DB row.
 *
 * An array of db vars, which values are backed by a database and caches.
 * DB vars are stored in the $gdoVars array.
 * When a GDT column is used, the $gdoVars are reference-copied into the GDT,
 * which make this framework tick fast with a low memory footprint.
 * It safes memory to only keep the GDTs once per Table.
 * Please note that all vars are considered string in GDOv7, the db representation.
 * The values, like a datetime, are generated by GDT->toValue()
 *
 * - Offers bulk operations
 *
 * @version 7.0.3
 * @since 6.0.0
 * @author gizmore@wechall.net
 * @see GDT
 * @see Cache
 * @see Database
 * @see Query
 * @see Result
 * @see WithTemp
 * @see WithModule
 * @license GDOv7-LICENSE
 */
abstract class GDO extends GDT
{

	use WithTemp; # @TODO the WithTemp trait should only be used on gdo_user and gdo_news, and others?

	#################
	### Constants ###
	#################
	final public const LICENSE = 'GDOv7';

	final public const TOKEN_LENGTH = 16; # length of gdoHashcode and GDT_Token

	# mysql
	final public const MYISAM = 'MyIsam'; # Faster writes

	final public const INNODB = 'InnoDB'; # Foreign keys

// 	final const MEMORY = 'Memory'; # Temp tables @TODO Temp memory tables not working? => remove

	# sqlite
	final public const SQL3_PERSIST = 'PERSIST';

	final public const SQL3_WAL = 'WAL';

	##############
	### Static ###
	##############
	/**
	 * @var int Total allocations
	 */
	public static int $GDO_COUNT = 0;

	/**
	 * @var int Total deallocations
	 */
	public static int $GDO_KILLS = 0;

	/**
	 * @var int Maximum simultanious allocations
	 */
	public static int $GDO_PEAKS = 0;

	#################
	### Construct ###
	#################
	public Cache $cache;

	/**
	 * @var bool @TODO move GDO->$recache to Cache to reduce GDO memory by one field.
	 */
	public bool $recache = false;

	private bool $persisted = false;


	/**
	 * Mark vars as dirty.
	 * Either true for all,
	 * false for none,
	 * or an assoc array with field mappings.
	 * One of the very few mixed fields.
	 */
	private mixed $dirty = false;


	/**
	 * DB entity vars.
	 *
	 * @var string[]
	 */
	protected array $gdoVars;


	public static function tableGDO(): static
	{
		return (new static());
	}

	public function __construct()
	{
		parent::__construct(); #PP#delete#
		$this->afterLoaded();  #PP#delete#
	}


	#############
	#PP#start####
	### DEBUG ###
	#############


	private function afterLoaded(): void
	{
		self::$GDO_COUNT++;
		$alive = self::$GDO_COUNT - self::$GDO_KILLS;
		if ($alive > self::$GDO_PEAKS)
		{
			self::$GDO_PEAKS = $alive;
		}
		if (self::$GDT_DEBUG)
		{
			$this->logDebug();
		}
	}

	private function logDebug(): void
	{
		Logger::log('gdo', sprintf('%d: %s', self::$GDO_COUNT, self::gdoClassNameS()));
		if (self::$GDT_DEBUG >= 2)
		{
			Logger::log('gdo', Debug::backtrace('Backtrace', false));
		}
	}

	#########
	#PP#end## # end of PP
	#########

	public static function escapeSearchS(string $var): string
	{
		return Module_DBMS::instance()->dbmsEscapeSearch($var);
	}

	public static function escapeS(string $var): string
	{
		return Module_DBMS::instance()->dbmsEscape($var);
	}

	/**
	 * Create a new entity instance.
	 */
	public static function blank(array $initial = null): static
	{
		return self::entity(self::getBlankData($initial))->dirty()->setPersisted(false);
	}

	public function dirty(mixed $dirty = true): self
	{
		$this->dirty = $dirty;
		return $this;
	}

	/**
	 * @param string[] $gdoVars
	 */
	public static function entity(array $gdoVars): static
	{
		$instance = new static();
		$instance->gdoVars = $gdoVars;
		return $instance;
	}

	################
	### Escaping ###
	################

	/**
	 * Raw initial string data.
	 */
	public static function getBlankData(array $initial = null): array
	{
		$table = self::table();

		$gdoVars = [];
		foreach ($table->gdoColumnsCache() as $gdt)
		{
			$gdt->inputs(null);
			# Pass 1) Plug initial var
			$name = $gdt->getName();
			if (isset($initial[$name]))
			{
				$gdt->var((string)$initial[$name]);
			}
			else
			{
				$gdt->reset();
			}

			# Pass 2) Loop over vars
			if ($data = $gdt->blankData())
			{
				foreach ($data as $k => $v)
				{
					if (isset($initial[$k]))
					{
						# override with initial
						$gdoVars[$k] = (string) $initial[$k];
					}
					else
					{
						# Use blank data as is
						$gdoVars[$k] = $v;
					}
				}
			}
		}
		return $gdoVars;
	}

	/**
	 * Get the table GDO for this class.
	 */
	public static function table(): ?static
	{
		return Database::tableS(static::class);
	}

	/**
	 * Get the table GDO for thie class.
	 */
	public function tbl(): static
	{
		return Database::tableS(static::class);
	}

	/**
	 * Get all GDT for a GDO.
	 *
	 * @return GDT[]
	 */
	public function &gdoColumnsCache(): array
	{
		return Database::columnsS(static::class);
	}

	public function getName(): ?string
	{
		return $this->renderName();
	}

	public function renderName(): string
	{
		return $this->gdoHumanName() . '#' . $this->getID();
	}

	#################
	### Persisted ###
	#################

	/**
	 * Get the ID for this entity.
	 */
	public function getID(): ?string
	{
		$id = '';
		foreach ($this->gdoPrimaryKeyColumnNames() as $name)
		{
			$id2 = $this->gdoVar($name);
			$id = $id ? "{$id}:{$id2}" : $id2;
		}
		return $id;
	}

	/**
	 * Get primary key column names.
	 *
	 * @return string[]
	 */
	public function gdoPrimaryKeyColumnNames(): array
	{
		$table = self::table();
		$cache = $table->cache;
		if (isset($cache->pkNames))
		{
			return $cache->pkNames;
		}
		$names = [];
		foreach ($this->gdoColumnsCache() as $column)
		{
			if ($column->isPrimary())
			{
				$names[] = $column->getName();
			}
			else
			{
				break; # Assume PKs are first until no more PKs (@XXX one of the quirky conventions!)
			}
		}

		if (empty($names))
		{
			foreach ($this->gdoColumnsCache() as $gdt)
			{
				if ($name = $gdt->getName())
				{
					$names[] = $name;
				}
			}
		}

		$cache->pkNames = $names;

		return $names;
	}

	public function gdoVar(string $key): ?string
	{
		return $this->gdoVars[$key] ?? null;
	}

	/**
	 * @TODO: Reset this GDO like it came from the cache (initial/var/dirty)
	 */
	public function reset(): static
	{
		foreach ($this->gdoColumnsCache() as $gdt)
		{
			$gdt->reset();
		}
		$this->dirty = false;
		return parent::reset();
	}

	##############
	### Render ###
	##############

	public function renderOption(): string
	{
		return $this->renderName();
	}

	public function __wakeup()
	{
		$this->recache = false;
		$this->afterLoaded();
	}

	public function renderJSON(): array|string|null|int|bool|float
	{
		return $this->toJSON();
	}

	/**
	 * @return GDT[]
	 */
	public function toJSON(): array
	{
		$values = [];
		foreach ($this->gdoColumnsCache() as $gdt)
		{
			if ($gdt->isSerializable())
			{
				$data = $gdt->gdo($this)->getGDOData();
				foreach ($data as $k => $v)
				{
					if ($v !== null)
					{
						$values[$k] = $v;
					}
				}
			}
		}
		return $values;
	}

	public function __destruct()
	{
		self::$GDO_KILLS++; #PP#delete#
	}

	public function renderCLI(): string
	{
		return $this->renderName();
	}

	public function renderVar(): string
	{
		return $this->renderName();
	}

	/**
	 * Get a row by a single column value.
	 * Throw exception if not found.
	 *
	 * @throws GDO_Exception
	 */
	public static function findBy(string $key, string $var): static
	{
		if (!($gdo = self::getBy($key, $var)))
		{
			self::notFoundException($var);
		}
		return $gdo;
	}

	/**
	 * Get a row by a single arbritary column value.
	 * Try caches first.
	 *
	 * @throws GDO_DBException
	 */
	public static function getBy(string $key, string $var): ?static
	{
		if ($gdo = self::getCachedBy($key, $var))
		{
			return $gdo;
		}
		return self::table()->getWhere($key . '=' . self::quoteS($var));
	}

	private static function getCachedBy(string $key, string $var): ?static
	{
		return self::table()->cache->getCachedBy($key, $var);
	}

	/**
	 * Get a row by condition.
	 *
	 * @throws GDO_DBException
	 */
	public function getWhere(string $condition): ?static
	{
		return $this->select()->where($condition)->
		first()->exec()->fetchObject();
	}

	public function select(string $columns = '*', bool $withHooks = true): Query
	{
		$query = $this->query()->select($columns)->from($this->gdoTableIdentifier());
		if ($withHooks)
		{
			$this->beforeRead($query);
		}
		return $query;
	}

	/**
	 * Create a new query for this GDO table.
	 */
	public function query(): Query
	{
		return new Query(self::table());
	}

	public function gdoTableIdentifier(): string { return $this->gdoTableName(); }


	public function gdoTableName(): string
	{
		return $this->tbl()->cache->tableName;
	}

	############
	### Vars ###
	############

	private function beforeRead(Query $query): void
	{
		$this->beforeEvent('gdoBeforeRead', $query);
	}

	private function beforeEvent(string $methodName, Query $query): self
	{
		foreach ($this->gdoColumnsCache() as $gdt)
		{
			call_user_func([$gdt->gdo($this), $methodName], $this, $query);
		}
		call_user_func([$this, $methodName], $this, $query);
		return $this;
	}

	public static function quoteS($var): string
	{
		if (is_string($var))
		{
			return Module_DBMS::instance()->dbmsQuote($var);
		}
		elseif ($var === null)
		{
			return 'NULL';
		}
		elseif (is_numeric($var))
		{
			return (string) $var;
		}
		else
		{
			return $var ? '1' : '0';
		}
	}

	/**
	 * @throws GDO_Exception
	 */
	public static function notFoundException(string $id): void
	{
		throw new GDO_Exception('err_gdo_not_found', [
			TextStyle::bold(self::gdoHumanNameS()),
			TextStyle::boldi(html($id)),
		]);
	}

	/**
	 * @param string[] $vars
	 *
	 * @throws GDO_DBException
	 */
	public static function getByVars(array $vars): ?static
	{
		$query = self::table()->select();
		foreach ($vars as $key => $value)
		{
			$query->where("{$key}=" . self::quoteS($value));
		}
		return $query->first()->exec()->fetchObject();
	}


	/**
	 * @throws GDO_Exception
	 */
	public static function findByGID(string $id): static
	{
		return self::findById(...explode(':', $id));
	}


	/**
	 * @throws GDO_Exception
	 */
	public static function findById(string...$id): static
	{
		if ($object = self::getById(...$id))
		{
			return $object;
		}
		self::notFoundException(implode(':', $id));
	}

	/**
	 * Get a row by ID(s).
	 * Tries GDO process cache first.
	 */
	public static function getById(string... $id): ?static
	{
		$table = self::table();
		if ((!$table->cached()) || (!($object = $table->cache->findCached(...$id))))
		{
			$i = 0;
			$query = $table->select();
			foreach ($table->gdoPrimaryKeyColumns() as $gdt)
			{
				$condition = sprintf('%s.%s=%s',
					$table->gdoTableName(), $gdt->getName(), self::quoteS($id[$i++]));
				$query->where($condition);
			}
			$object = $query->first()->exec()->fetchObject();
		}
		return $object;
	}

	/**
	 * Is this GDO backed by any cache means?
	 */
	public function cached(): bool { return $this->gdoCached() || $this->memCached(); }

	/**
	 * Is this GDO backed by the GDO process cache?
	 */
	public function gdoCached(): bool { return true; }

	/**
	 * Is this GDO backed by the Memcached cache?
	 */
	public function memCached(): bool { return $this->gdoCached() && GDO_MEMCACHE; }

	public function findCached(string...$ids): ?self
	{
		if (!($gdo = $this->tbl()->cache->findCached(...$ids)))
		{
			$gdo = self::getById(...$ids);
		}
		return $gdo;
	}

	/**
	 * Get the primary key columns for a table.
	 *
	 * @return GDT[]
	 */
	public function gdoPrimaryKeyColumns(): array
	{
		$cache = self::table()->cache;

		if (isset($cache->pkColumns))
		{
			return $cache->pkColumns;
		}

		$columns = [];
		foreach ($this->gdoColumnsCache() as $column)
		{
			if ($column->isPrimary())
			{
				$columns[$column->getName()] = $column;
			}
			else
			{
				break; # early break is possible because we start all tables with their PKs.
			}
		}

		if (empty($columns))
		{
			foreach ($this->gdoColumnsCache() as $column)
			{
				if (!$column->isVirtual())
				{
					$columns[] = $column;
				}
			}
		}

		$cache->pkColumns = $columns;

		return $columns;
	}

	/**
	 * Get the table GDO for a classname.
	 *
	 * @throws GDO_Exception
	 */
	public static function tableFor(string $className, bool $throw = true): ?self
	{
		$gdo = Database::tableS($className);
		if ($throw && (!$gdo))
		{
			throw new GDO_Exception('err_table_gdo', [html($className)]);
		}
		return $gdo;
	}

	#############
	### Dirty ###
	#############

	/**
	 * Mass insertion.
	 *
	 * @param GDT[] $fields
	 *
	 * @throws GDO_DBException
	 */
	public static function bulkReplace(array $fields, array $data, int $chunkSize = 200): void
	{
		self::bulkInsert($fields, $data, $chunkSize, 'REPLACE');
	}

	/**
	 * @throws GDO_DBException
	 */
	public static function bulkInsert(array $fields, array $data, $chunkSize = 200, string $insert = 'INSERT'): void
	{
		foreach (array_chunk($data, $chunkSize) as $chunk)
		{
			self::_bulkInsert($fields, $chunk, $insert);
		}
	}

	/**
	 * @throws GDO_DBException
     * @param GDT[] $fields
	 */
	private static function _bulkInsert(array $fields, array $data, string $insert = 'INSERT'): bool
	{
		$names = [];
		$table = self::table();
		foreach ($fields as $field)
		{
			$names[] = $field->getName();
		}
		$names = implode('`, `', $names);

		$values = [];
		foreach ($data as $row)
		{
			$brow = [];
			foreach ($row as $col)
			{
				$brow[] = self::quoteS($col);
			}
			$values[] = implode(',', $brow);
		}
		$values = implode("),\n(", $values);

		$query = "{$insert} INTO {$table->gdoTableIdentifier()} (`$names`)\nVALUES\n($values)";
		return Database::instance()->queryWrite($query);
	}

	/**
	 * @return GDT[]
	 */
	abstract public function gdoColumns(): array;

	###############
	### Columns ###
	###############

	/**
	 * Return the mysql storage engine for this gdo.
	 */
	public function gdoEngine(): string { return GDO_DB_ENGINE; }

	/**
	 * Is this GDO abstract? Required for inheritance hacks.
	 */
	public function gdoAbstract(): bool { return false; }

	/**
	 * Indicate that this GDO is only to transfer structured data.
	 * It is not abstract, yet still not persisted.
	 */
	public function gdoDTO(): bool { return false; }


	public function gdoDisplay(string $key): string
	{
		if ($this->hasColumn($key))
		{
			return $this->gdoColumn($key)->displayVar($this->gdoVar($key));
		}
		return $this->displayVar($this->gdoVar($key));
	}

	/**
	 * Get the GDT column for a key.
	 * Assign GDO vars to the GDTs.
	 */
	public function gdoColumn(string $key): ?GDT
	{
		$cache = $this->gdoColumnsCache();
		return $cache[$key]?->gdo($this);
	}

	#################
	### Column Of ###
	#################

	public function &getGDOVars(): array { return $this->gdoVars; }

	public function setGDOVars(array $vars, bool $dirty = false): self
	{
		$this->gdoVars = $vars;
		return $this->dirty($dirty);
	}

	public function hasVar(string $key): bool
	{
		if (isset($this->gdoVars))
		{
			return array_key_exists($key, $this->gdoVars);
		}
		return false;
	}

	public function gdoVars(array $keys): array
	{
		return array_combine($keys, array_map(function ($key)
		{
			return $this->gdoVar($key);
		}, $keys));
	}

	public function setValue(string $key, $value, bool $markDirty = true): self
	{
		$vars = $this->gdoColumn($key)->value($value)->getGDOData();
		$this->setVars($vars, $markDirty);
		return $this;
	}

	public function setVars(array $vars = null, $markDirty = true): self
	{
		foreach ($vars as $key => $var)
		{
			$this->setVar($key, $var, $markDirty);
		}
		return $this;
	}

	public function setVar(string $key, ?string $var, bool $markDirty = true): static
	{
		if (!$this->hasColumn($key))
		{
			$this->gdoVars[$key] = $var;
			return $this;
		}

		$d = false; # worthy?
		$gdt = $this->gdoColumn($key)->var($var);
		$data = $gdt->getGDOData();
		foreach ($data as $k => $v)
		{
			if (array_key_exists($k, $this->gdoVars))
			{
				if ($this->gdoVars[$k] !== $v)
				{
					$this->gdoVars[$k] = $v;
                    $d = true;
                }
            }
		}
		return ($markDirty && $d) ? $this->markDirty($key) : $this;
	}

	public function hasColumn(string $key): bool
	{
		return array_key_exists($key, $this->gdoColumnsCache());
	}

	public function markDirty(string $key): self
	{
		if ($this->dirty === false)
		{
			$this->dirty = [];
		}
		if ($this->dirty !== true)
		{
			$this->dirty[$key] = true;
		}
		return $this;
	}

	/**
	 * Get the value of a column.
	 */
	public function gdoValue(string $key): null|bool|int|float|string|array|object
	{
		return $this->gdoColumn($key)->getValue();
	}

	/**
	 * Break these GDT functions as they confuse you now.
	 *
	 * @throws GDO_Exception
	 */
	public function getValue(string $var = null): mixed
	{
		throw new GDO_Exception('err_gdo_no_gdt', ['getValue', $this->gdoHumanName()]);
	}

	public function inputs(?array $inputs): static
	{
		foreach ($this->gdoColumnsCache() as $gdt)
		{
			$gdt->inputs($inputs);
		}
		return $this;
	}

	##########
	### DB ###
	##########

	public static function make(string $name = null): static
	{
		return new static();
	}

	public function isDirty(): bool
	{
		return is_bool($this->dirty) ? $this->dirty : (count($this->dirty) > 0);
	}

	public function gdoPrimaryKeyValues(): array
	{
		$values = [];
		foreach ($this->gdoPrimaryKeyColumns() as $gdt)
		{
			$name = $gdt->getName();
			$values[$name] = $this->gdoVar($name);
		}
		return $values;
	}

	/**
	 * Get all columns of a type. Used to load users via two different GDT_Name fields.
	 * @return GDT[]
	 */
	public function gdoColumnsOf(string $className): array
	{
		$back = [];
		foreach ($this->gdoColumnsCache() as $gdt)
		{
			if (is_a($gdt, $className, true))
			{
				$back[$gdt->getName()] = $gdt->gdo($this);
			}
		}
		return $back;
	}

	public function gdoVarOf(string $className): ?string
	{
		return $this->gdoVar($this->gdoColumnOf($className)->getName());
	}

	/**
	 * Get the first column of a specified GDT.
	 * Useful to make GDTs more automated. E.g. The auto inc column syncs itself on gdoAfterCreate.
	 */
	public function gdoColumnOf(string $className): ?GDT
	{
		foreach ($this->gdoColumnsCache() as $gdt)
		{
			if (is_a($gdt, $className))
			{
				return $gdt->gdo($this);
			}
		}
		return null;
	}

	public function gdoValueOf(string $className): null|bool|int|float|string|object|array
	{
		return $this->gdoColumnOf($className)->getValue();
	}

	################
	### Validate ###
	################

	/**
	 * Get the GDOs AutoIncrement column, if any.
	 */
	public function gdoAutoIncColumn(): ?GDT
	{
		return $this->gdoColumnOf(GDT_AutoInc::class);
	}

	##############
	### Delete ###
	##############

	/**
	 * Get the GDOs name identifier column, if any.
	 */
	public function gdoNameColumn(): ?GDT
	{
		return $this->gdoColumnOf(GDT_Name::class);
	}

	/**
	 * Get a GDT column by name.
	 */
	public function getColumn(string $key): GDT
	{
		return $this->gdoColumnsCache()[$key];
	}

	/**
	 * Copy a GDT column and assign my values.
	 *
	 * @throws GDO_Exception
	 */
	public function gdoColumnCopy(string $key, bool $throw = true): ?GDT
	{
		if ($gdt = $this->gdoColumnsCache()[$key])
		{
			$column = clone $gdt;
			return $column->gdo($this);
		}
		elseif ($throw)
		{
			throw new GDO_Exception('err_unknown_gdo_column', [$this->renderName(), html($key)]);
		}
		return null;
	}

	/**
	 * Get only wanted GDT columns.
	 *
	 * @return GDT[]
	 */
	public function gdoColumnsOnly(string...$keys): array
	{
		return $this->gdoColumnsOnlyExcept($keys, true);
	}

	/**
	 * Get all GDT columns except those listed.
	 *
	 * @return GDT[]
	 */
	public function gdoColumnsExcept(string...$keys): array
	{
		return $this->gdoColumnsOnlyExcept($keys, false);
	}


	private function gdoColumnsOnlyExcept(array $keys, bool $negate): array
	{
		$columns = [];
		foreach (array_keys($this->gdoColumnsCache()) as $key)
		{
			if (in_array($key, $keys, true) === $negate)
			{
				$columns[$key] = $this->gdoColumn($key);
			}
		}
		return $columns;
	}

	###############
	### Replace ###
	###############

	/**
	 * Find a row by AutoInc Id.
	 *
	 * @throws GDO_Exception
	 * @throws GDO_Exception
	 */
	public function find(string $id): static
	{
		if ($gdo = self::getById($id))
		{
			return $gdo;
		}
		self::notFoundException(html($id));
	}

	/**
	 * @throws GDO_DBException
	 */
	public function countWhere(string $condition = 'true'): int
	{
		return (int) $this->select('COUNT(*)', false)->where($condition)->
		noOrder()->exec()->fetchVar();
	}

	/**
	 * Find a row by condition. Throws GDO::notFoundException.
	 *
	 * @throws GDO_Exception
	 */
	public function findWhere(string $condition): ?self
	{
		if (!($gdo = $this->getWhere($condition)))
		{
			self::notFoundException(html($condition));
		}
		return $gdo;
	}

	##############
	### Update ###
	##############

	public function isValid(): bool
	{
		$invalid = 0;
		foreach ($this->gdoColumnsCache() as $gdt)
		{
			$invalid += $gdt->gdo($this)->validated() ? 0 : 1;
		}
		return $invalid === 0;
	}

	/**
	 * Check if we are deleted.
	 */
	public function isDeleted(): bool
	{
		if ($gdt = $this->gdoColumnOf(GDT_DeletedAt::class))
		{
			return $gdt->getVar() !== null;
		}
		if ($gdt = $this->gdoColumnOf(GDT_DeletedBy::class))
		{
			return $gdt->getVar() !== null;
		}
		return !$this->isPersisted();
	}

	/**
	 * Break these GDT functions as they confuse you now.
	 *
	 * @throws GDO_Exception
	 */
	public function getVar(): string|array|null
	{
		throw new GDO_Exception('err_gdo_no_gdt', ['getVar', $this->gdoHumanName()]);
	}

	public function isPersisted(): bool { return $this->persisted; }

	########################
	### Var manipulation ###
	########################

	public function setPersisted(bool $persisted = true): static
	{
		$this->persisted = $persisted;
		return $this;
	}

	/**
	 * Mark this GDO as deleted, or delete physically.
	 *
	 * @throws GDO_DBException
	 */
	public function markDeleted(bool $withHooks = true): self
	{
		$change = false;
		if ($gdt = $this->gdoColumnOf(GDT_DeletedAt::class))
		{
			$this->setVar($gdt->getName(), Time::getDate());
			$change = true;
		}
		if ($gdt = $this->gdoColumnOf(GDT_DeletedBy::class))
		{
			$this->setVar($gdt->getName(), GDO_User::current()->getID());
			$change = true;
		}
		if ($change)
		{
			$this->save($withHooks);
			if ($withHooks)
			{
				$this->afterDelete(true);
			}
			return $this;
		}
		else
		{
			return $this->deleteB($withHooks);
		}
	}

	public function insert(bool $withHooks = true): static
	{
		$query = $this->query()->
		insert($this->gdoTableIdentifier())->
		values($this->getDirtyVars());
		return $this->insertOrReplace($query, $withHooks);
	}

	/**
	 * Save this entity.
	 *
	 * @throws GDO_DBException
	 */
	public function save(bool $withHooks = true): static
	{
		if (!$this->persisted)
		{
			return $this->insert($withHooks);
		}
		if ($setClause = $this->getSetClause())
		{
			$query = $this->updateQuery()->set($setClause);

			if ($withHooks)
			{
				$this->beforeUpdate($query);
			}

			$query->exec();

			$this->dirty = false;

			if ($withHooks)
			{
				$this->afterUpdate();
			}
		}
		return $this;
	}

	/**
	 * Get gdoVars that have been changed.
	 * Optionally ommit primary keys.
	 *
	 * @return string[]
	 */
	public function getDirtyVars(bool $withPrimaryKeys = true): array
	{
		if ($this->dirty === true)
		{
			$vars = [];
			foreach ($this->gdoColumnsCache() as $gdt)
			{
				if ($withPrimaryKeys || (!$gdt->isPrimary()))
				{
					$data = $gdt->gdo($this)->getGDOData();
					foreach ($data as $k => $v)
					{
						$vars[$k] = $v;
					}
				}
			}
			return $vars;
		}
		elseif ($this->dirty === false)
		{
			return GDT::EMPTY_ARRAY;
		}
		else
		{
			$vars = [];
			foreach (array_keys($this->dirty) as $name)
			{
				$gdt = $this->gdoColumn($name);
				if ($withPrimaryKeys || (!$gdt->isPrimary()))
				{
					$data = $gdt->gdo($this)->getGDOData();
					foreach ($data as $k => $v)
					{
						$vars[$k] = $v;
					}
				}
			}
			return $vars;
		}
	}

	private function insertOrReplace(Query $query, bool $withHooks): static
	{
//		try
//		{
			if ($withHooks)
			{
				$this->beforeCreate($query);
			}
			$query->exec();
			$this->dirty = false;
			$this->persisted = true;
			if ($withHooks)
			{
				$this->afterCreate();
			}
			$this->cache(); # not needed for new rows?
//		}
//		catch (GDO_DBException $ex)
//		{
//			Debug::debugException($ex);
//		}
		return $this;
	}

	private function beforeCreate(Query $query): void
	{
		$this->beforeEvent('gdoBeforeCreate', $query);
	}

	####################
	### Primary Keys ###
	####################

	private function afterCreate(): void
	{
		# Flags
		$this->dirty = false;
		$this->setPersisted();
		# Trigger event for GDT like AutoInc, EditedAt, CreatedBy, etc.
		$this->afterEvent('gdoAfterCreate');
	}

	private function afterEvent(string $methodName): void
	{
		foreach ($this->gdoColumnsCache() as $gdt)
		{
			call_user_func([$gdt->gdo($this), $methodName], $this);
		}
		call_user_func([$this, $methodName], $this);
	}

	################
	### Instance ###
	################

	public function cache(): void
	{
		if ($this->cached())
		{
			self::table()->cache->recache($this);
		}
	}

	/**
	 * This function triggers a recache, also over IPC, if IPC is enabled.
	 */
	public function recache(): self
	{
		return $this->cached() ? self::table()->cache->recache($this) : $this;
	}

	public function getSetClause(): string
	{
		$setClause = '';
		if ($this->dirty !== false)
		{
			foreach ($this->gdoColumnsCache() as $column)
			{
				if (!$column->isVirtual())
				{
					if (($this->dirty === true) || (isset($this->dirty[$column->getName()])))
					{
						foreach ($column->gdo($this)->getGDOData() as $k => $v)
						{
							if ($setClause !== '')
							{
								$setClause .= ',';
							}
							$setClause .= $k . '=' . self::quoteS($v);
						}
					}
				}
			}
		}
		return $setClause;
	}

	/**
	 * Build an entity update query.
	 */
	public function updateQuery(): Query
	{
		return $this->entityQuery()->update($this->gdoTableIdentifier());
	}

	/**
	 * Build a generic update query for the whole table.
	 *
	 * @return Query
	 */
	public function update(): Query
	{
		return $this->query()->update($this->gdoTableIdentifier());
	}

	##############
	### Get ID ###
	##############

	public function entityQuery(): Query
	{
		return $this->query()->where($this->getPKWhere());
	}

	/**
	 * Get the primary key where condition for this row.
	 */
	public function getPKWhere(): string
	{
		$where = '';
		foreach ($this->gdoPrimaryKeyColumns() as $column)
		{
			if ($where)
			{
				$where .= ' AND ';
			}
			$name = $column->getName();
			$where .=  "{$name}={$this->quoted($name)}";
		}
		return $where;
	}

	##############
	### Get by ###
	##############

	public function quoted($key): string
	{
		return self::quoteS($this->gdoVar($key));
	}

	private function beforeUpdate(Query $query): void
	{
		$this->beforeEvent('gdoBeforeUpdate', $query);
	}

	private function afterUpdate(): void
	{
		# Flags
		$this->dirty = false;
		$this->afterEvent('gdoAfterUpdate');
		$this->recache();
	}

	private function afterDelete(bool $persisted = false): void
	{
		# Flags
		$this->dirty = false;
		$this->persisted = $persisted;
		$this->afterEvent('gdoAfterDelete');
		$this->uncache();
	}

	/**
	 * @throws GDO_DBException
	 */
	private function deleteB(bool $withHooks = true): self
	{
		if ($this->persisted)
		{
			$query = $this->query()->delete($this->gdoTableIdentifier())->where($this->getPKWhere());
			if ($withHooks)
			{
				$this->beforeDelete($query);
			}
			$query->exec();
			$this->persisted = false;
			if ($withHooks)
			{
				$this->afterDelete();
			}
			$this->uncache();
		}
		return $this;
	}

	/**
	 * Delete this entity.
	 *
	 * @throws GDO_DBException
	 */
	public function delete(bool $withHooks = true): self
	{
		return $this->deleteB($withHooks);
	}

	private function beforeDelete(Query $query): void
	{
		$this->beforeEvent('gdoBeforeDelete', $query);
	}

	public function uncache(): void
	{
		if ($c = $this->tbl()->cache)
		{
			$c->uncache($this);
		}
	}

	/**
	 * Delete multiple rows, but one by one when using withHooks, to trigger events correctly.
	 * Mass deletions can be done without hooks.
	 *
	 * @return int - Number of deleted rows
	 */
	public function deleteWhere(string $condition, bool $withHooks = true): int
	{
		try
		{
			$deleted = 0;
			if ($withHooks)
			{
				$result = $this->tbl()->select()->where($condition)->exec();
				while ($gdo = $result->fetchObject())
				{
					$deleted++;
					$gdo->deleteB();
				}
				return $deleted;
			}
			else
			{
				$this->query()->delete($this->gdoTableIdentifier())->where($condition)->exec();
				return Database::instance()->affectedRows();
			}
		}
		catch (GDO_DBException $ex)
		{
			echo Debug::debugException($ex);
			return $deleted;
		}
	}

	/**
	 * Does an INSERT, ON DUPLICATE KEY UPDATE. Not all events are supported. I.e. we don't know what event to call before the query is fired.
	 *
	 * @throws GDO_DBException
	 */
	public function softReplace(bool $withHooks = true): self
	{
		if ($gdo = $this->tbl()->getWhere($this->getPKWhere()))
		{
			$gdo->persisted = true;
			$gdo->dirty = true;
			$gdo->gdoVars = $this->gdoVars;
			$gdo->dirty = array_keys($gdo->getDirtyVars(false));
			$gdo->dirty = array_combine($gdo->dirty, $gdo->dirty);
			return $gdo->save($withHooks);
		}
		else
		{
			return $this->insert($withHooks);
		}
	}

	#############
	### Cache ###
	#############

	public function replace(bool $withHooks = true): static
	{
		# Check for empty id.
		# Checking for $persisted is wrong, as replace rows can be constructed from scratch.
		$id = $this->getID();
		if ((!$id) || preg_match('#^[:0]+$#D', $id))
		{
			return $this->insert($withHooks);
		}

		$query = $this->query()->
		replace($this->gdoTableIdentifier())->
		values($this->getDirtyVars());

		return $this->insertOrReplace($query, $withHooks);
	}

	public function deleteQuery(): Query
	{
		return $this->query()->delete($this->gdoTableName());
	}

	/**
	 * @throws GDO_DBException
	 */
	public function increase(string $key, float $by = 1): self
	{
		return $this->saveVar($key, (string) ($this->gdoVar($key) + $by));
	}

	/**
	 * @throws GDO_DBException
	 */
	public function saveVar(string $key, ?string $var, bool $withHooks = true, bool &$worthy = false): self
	{
		return $this->saveVars([$key => $var], $withHooks, $worthy);
	}

	/**
	 * @param string[] $vars
	 *
	 * @throws GDO_DBException
	 */
	public function saveVars(array $vars, bool $withHooks = true, bool &$worthy = false): static
	{
		$worthy = false; # Anything changed?
		$query = $this->updateQuery();
		foreach ($vars as $key => $var)
		{
			if (array_key_exists($key, $this->gdoVars))
			{
				if ($var !== $this->gdoVars[$key])
				{
					$query->set("{$key}=" . self::quoteS($var));
					$this->markClean($key);
					$worthy = true; # We got a change
				}
			}
		}

		if (!$worthy)
		{
			return $this;
		}

		# Call hooks even when not needed. Because its needed on GDT_Files
		if ($withHooks)
		{
			$this->beforeUpdate($query); # Can do trickery here... not needed?
		}

		$query->exec();

		foreach ($vars as $key => $var)
		{
			$this->gdoVars[$key] = $var;
		}

		if ($withHooks)
		{
			$this->afterUpdate();
		}

		return $this;
	}

	public function markClean(string $key): self
	{
		if ($this->dirty === false)
		{
			$this->dirty = array_keys($this->gdoVars);
			unset($this->dirty[$key]);
		}
		elseif (is_array($this->dirty))
		{
			unset($this->dirty[$key]);
		}
		return $this;
	}

	/**
	 * @throws GDO_DBException
	 */
	public function saveValue(string $key, $value, bool $withHooks = true): self
	{
		$var = $this->gdoColumn($key)->toVar($value);
		return $this->saveVar($key, $var, $withHooks);
	}

	/**
	 * @throws GDO_DBException
	 */
	public function saveValues(array $values, bool $withHooks = true): self
	{
		$vars = [];
		foreach ($values as $key => $value)
		{
			$this->gdoColumn($key)->setGDOData($value);
			$vars[$key] = $this->gdoVar($key);
		}
		return $this->saveVars($vars, $withHooks);
	}

	public function fetchAll(Result $result): array
	{
		$back = [];
		while ($gdo = $this->fetch($result))
		{
			$back[] = $gdo;
		}
		return $back;
	}

	/**
	 * Fetch from result set as this table.
	 */
	public function fetch(Result $result): ?self
	{
		return $result->fetchAs($this);
	}

	public function initCache(): void
	{
		$this->cache = new Cache($this);
	}

	public function initCached(array $row, bool $useCache = true): self
	{
		return $this->memCached() ?
			$this->cache->initGDOMemcached($row, $useCache) :
			$this->cache->initCached($row, $useCache);
	}

	###########
	### All ###
	###########

	public function gkey(): string
	{
		return self::table()->cache->tableName . $this->getID();
	}

	/**
	 * @throws GDO_DBException
	 */
	public function reload($id): static
	{
		$table = self::table();
		if ($table->cached() && $table->cache->hasID($id))
		{
			$i = 0;
			$id = explode(':', $id);
			$query = $this->select();
			foreach ($this->gdoPrimaryKeyColumns() as $gdt)
			{
				$query->where($gdt->getName() . '=' . self::quoteS($id[$i++]));
			}
			$object = $query->uncached()->first()->exec()->fetchObject();
			return $table->cache->recache($object);
		}
		return $this;
	}

	public function recacheMemcached(): void
	{
		if ($this->memCached())
		{
			$this->tbl()->cache->recache($this);
		}
	}

	public function recaching(): self
	{
		$this->recache = true;
		return $this;
	}

	public function clearCache(): self
	{
		if ($this->cached())
		{
			$cache = self::table()->cache;
			$cache->clearCache();
			Cache::flush(); # @TODO Find a way to only remove memcached entries for this single GDO.
		}
		return $this;
	}

	/**
	 * @throws GDO_DBException
	 * @return static[]
	 */
	public function &all(string $order = null, bool $json = false): array
	{
		$order = $order ?: $this->gdoPrimaryKeyColumn()->getName();
		return self::allWhere('true', $order, $json);
	}

	/**
	 * Get the first primary key column
	 */
	public function gdoPrimaryKeyColumn(): ?GDT
	{
		foreach ($this->gdoColumnsCache() as $column)
		{
			if ($column->isPrimary())
			{
				return $column;
			}
		}
		return null;
	}

	##############
	###  Table ###
	##############

	/**
	 * @throws GDO_DBException
	 * @return static[]
	 */
	public function &allWhere($condition = 'true', $order = null, $json = false): array
	{
		return self::table()->select()->
		where($condition)->order($order)->
		exec()->fetchAllArray2dObject(null, $json);
	}

	public function uncacheAll(): self
	{
		unset($this->tbl()->cache->all);
		Cache::remove($this->cacheAllKey());
		return $this;
	}

	public function cacheAllKey(): string
	{
		return 'all_' . $this->gdoTableName();
	}

	public function allCachedExpiration(int $expire = GDO_MEMCACHE_TTL): void
	{
		$this->cache->expires = $expire;
	}

	/**
	 * Get all rows via allcache.
	 *
	 * @throws GDO_DBException
	 * @return static[]
	 */
	public function &allCached(string $order = null, bool $json = false): array
	{
		if ($this->cached())
		{
			# Already cached
			$cache = self::table()->cache;
			if (isset($cache->all))
			{
				return $cache->all;
			}
		}
		else
		{
			# No caching at all
			return $this->select()->order($order)->exec()->fetchAllArray2dObject(null, $json);
		}

		if (!$this->memCached())
		{
			# GDO cached
			$all = $this->select()->order($order)->exec()->fetchAllArray2dObject(null, $json);
		}
		else
		{
			# Memcached
			$key = $this->cacheAllKey();
			if (null === ($all = Cache::get($key)))
			{
				$all = $this->select()->order($order)->exec()->fetchAllArray2dObject(null, $json);
				Cache::set($key, $all);
			}
		}
		$cache->all = $all;
		return $all;
	}

	public function removeAllCache(): void
	{
		$key = 'all_' . $this->gdoTableName();
		Cache::remove($key);
	}

	/**
	 * Check if this gdo row entity is the table GDO.
	 * This is done via the always generated cache object and should be efficient. The memory cost for the old private $isTable was horrible!
	 */
	public function gdoIsTable(): bool
	{
		return $this->tbl()->cache->isTable($this);
	}

	public function createTable(): bool
	{
		$db = Database::instance();
		$db->createTable($this);
		return true;
	}

	public function truncate(): bool
	{
		Database::instance()->truncateTable($this);
		return true;
	}


	public function dropTable(): bool
	{
		return Database::instance()->dropTable($this);
	}

	/**
	 * @return GDT[]
	 */
	public function getGDOColumns(array $names): array
	{
		$columns = [];
		foreach ($names as $key)
		{
			$columns[$key] = $this->gdoColumn($key);
		}
		return $columns;
	}

	/**
	 * Generate a hashcode from gdo vars.
	 * This is often used in approval tokens or similar.
	 */
	public function gdoHashcode(): string
	{
		return self::gdoHashcodeS($this->gdoVars);
	}

	/**
	 * Generate a hashcode from an associative array.
	 */
	public static function gdoHashcodeS(array $gdoVars): string
	{
		return substr(sha1(GDO_SALT . json_encode($gdoVars)), 0, self::TOKEN_LENGTH);
	}

	public function getDefaultOrder(): ?string
	{
		foreach ($this->gdoColumnsCache() as $gdt)
		{
			if ($gdt->isOrderable())
			{
				if ($name = $gdt->getName())
				{
					return $name;
				}
			}
		}
		return null;
	}

}