Compare commits
5 Commits
dev74
...
wip74/upda
| Author | SHA1 | Date | |
|---|---|---|---|
| 5652d38073 | |||
| 96e046d5bf | |||
| 20c0cb2e0f | |||
| 2583ff70e5 | |||
| 1d9f9492a5 |
15
.idea/php-docker-settings.xml
generated
15
.idea/php-docker-settings.xml
generated
@ -17,6 +17,21 @@
|
||||
</DockerContainerSettings>
|
||||
</value>
|
||||
</entry>
|
||||
<entry key="38915385-b3ff-4f4b-8a9a-d5f3ecae559e">
|
||||
<value>
|
||||
<DockerContainerSettings>
|
||||
<option name="version" value="1" />
|
||||
<option name="volumeBindings">
|
||||
<list>
|
||||
<DockerVolumeBindingImpl>
|
||||
<option name="containerPath" value="/opt/project" />
|
||||
<option name="hostPath" value="$PROJECT_DIR$" />
|
||||
</DockerVolumeBindingImpl>
|
||||
</list>
|
||||
</option>
|
||||
</DockerContainerSettings>
|
||||
</value>
|
||||
</entry>
|
||||
</map>
|
||||
</list>
|
||||
</component>
|
||||
|
||||
80
.idea/php.xml
generated
80
.idea/php.xml
generated
@ -22,56 +22,56 @@
|
||||
</component>
|
||||
<component name="PhpIncludePathManager">
|
||||
<include_path>
|
||||
<path value="$PROJECT_DIR$/php/vendor/symfony/polyfill-ctype" />
|
||||
<path value="$PROJECT_DIR$/php/vendor/theseer/tokenizer" />
|
||||
<path value="$PROJECT_DIR$/php/vendor/symfony/deprecation-contracts" />
|
||||
<path value="$PROJECT_DIR$/php/vendor/symfony/yaml" />
|
||||
<path value="$PROJECT_DIR$/php/vendor/phpunit/php-text-template" />
|
||||
<path value="$PROJECT_DIR$/php/vendor/phpunit/php-file-iterator" />
|
||||
<path value="$PROJECT_DIR$/php/vendor/phpunit/php-timer" />
|
||||
<path value="$PROJECT_DIR$/php/vendor/composer" />
|
||||
<path value="$PROJECT_DIR$/php/vendor/dflydev/dot-access-data" />
|
||||
<path value="$PROJECT_DIR$/php/vendor/doctrine/instantiator" />
|
||||
<path value="$PROJECT_DIR$/php/vendor/league/commonmark" />
|
||||
<path value="$PROJECT_DIR$/php/vendor/league/config" />
|
||||
<path value="$PROJECT_DIR$/php/vendor/myclabs/deep-copy" />
|
||||
<path value="$PROJECT_DIR$/php/vendor/nette/schema" />
|
||||
<path value="$PROJECT_DIR$/php/vendor/nette/utils" />
|
||||
<path value="$PROJECT_DIR$/php/vendor/nikic/php-parser" />
|
||||
<path value="$PROJECT_DIR$/php/vendor/nulib/tests" />
|
||||
<path value="$PROJECT_DIR$/php/vendor/phar-io/manifest" />
|
||||
<path value="$PROJECT_DIR$/php/vendor/phar-io/version" />
|
||||
<path value="$PROJECT_DIR$/php/vendor/phpmailer/phpmailer" />
|
||||
<path value="$PROJECT_DIR$/php/vendor/phpunit/php-code-coverage" />
|
||||
<path value="$PROJECT_DIR$/php/vendor/sebastian/type" />
|
||||
<path value="$PROJECT_DIR$/php/vendor/sebastian/object-enumerator" />
|
||||
<path value="$PROJECT_DIR$/php/vendor/sebastian/version" />
|
||||
<path value="$PROJECT_DIR$/php/vendor/sebastian/global-state" />
|
||||
<path value="$PROJECT_DIR$/php/vendor/phpunit/php-file-iterator" />
|
||||
<path value="$PROJECT_DIR$/php/vendor/phpunit/php-invoker" />
|
||||
<path value="$PROJECT_DIR$/php/vendor/phpunit/php-text-template" />
|
||||
<path value="$PROJECT_DIR$/php/vendor/phpunit/php-timer" />
|
||||
<path value="$PROJECT_DIR$/php/vendor/phpunit/phpunit" />
|
||||
<path value="$PROJECT_DIR$/php/vendor/psr/cache" />
|
||||
<path value="$PROJECT_DIR$/php/vendor/psr/container" />
|
||||
<path value="$PROJECT_DIR$/php/vendor/psr/event-dispatcher" />
|
||||
<path value="$PROJECT_DIR$/php/vendor/psr/log" />
|
||||
<path value="$PROJECT_DIR$/php/vendor/sebastian/cli-parser" />
|
||||
<path value="$PROJECT_DIR$/php/vendor/sebastian/code-unit" />
|
||||
<path value="$PROJECT_DIR$/php/vendor/sebastian/code-unit-reverse-lookup" />
|
||||
<path value="$PROJECT_DIR$/php/vendor/sebastian/comparator" />
|
||||
<path value="$PROJECT_DIR$/php/vendor/sebastian/complexity" />
|
||||
<path value="$PROJECT_DIR$/php/vendor/sebastian/diff" />
|
||||
<path value="$PROJECT_DIR$/php/vendor/sebastian/environment" />
|
||||
<path value="$PROJECT_DIR$/php/vendor/sebastian/exporter" />
|
||||
<path value="$PROJECT_DIR$/php/vendor/sebastian/global-state" />
|
||||
<path value="$PROJECT_DIR$/php/vendor/sebastian/lines-of-code" />
|
||||
<path value="$PROJECT_DIR$/php/vendor/sebastian/object-enumerator" />
|
||||
<path value="$PROJECT_DIR$/php/vendor/sebastian/object-reflector" />
|
||||
<path value="$PROJECT_DIR$/php/vendor/sebastian/recursion-context" />
|
||||
<path value="$PROJECT_DIR$/php/vendor/sebastian/resource-operations" />
|
||||
<path value="$PROJECT_DIR$/php/vendor/sebastian/diff" />
|
||||
<path value="$PROJECT_DIR$/php/vendor/sebastian/cli-parser" />
|
||||
<path value="$PROJECT_DIR$/php/vendor/doctrine/instantiator" />
|
||||
<path value="$PROJECT_DIR$/php/vendor/sebastian/comparator" />
|
||||
<path value="$PROJECT_DIR$/php/vendor/sebastian/lines-of-code" />
|
||||
<path value="$PROJECT_DIR$/php/vendor/sebastian/code-unit-reverse-lookup" />
|
||||
<path value="$PROJECT_DIR$/php/vendor/sebastian/code-unit" />
|
||||
<path value="$PROJECT_DIR$/php/vendor/sebastian/object-reflector" />
|
||||
<path value="$PROJECT_DIR$/php/vendor/sebastian/exporter" />
|
||||
<path value="$PROJECT_DIR$/php/vendor/phpunit/phpunit" />
|
||||
<path value="$PROJECT_DIR$/php/vendor/phpunit/php-invoker" />
|
||||
<path value="$PROJECT_DIR$/php/vendor/phar-io/version" />
|
||||
<path value="$PROJECT_DIR$/php/vendor/phar-io/manifest" />
|
||||
<path value="$PROJECT_DIR$/php/vendor/nulib/tests" />
|
||||
<path value="$PROJECT_DIR$/php/vendor/myclabs/deep-copy" />
|
||||
<path value="$PROJECT_DIR$/php/vendor/nikic/php-parser" />
|
||||
<path value="$PROJECT_DIR$/php/vendor/composer" />
|
||||
<path value="$PROJECT_DIR$/php/vendor/league/config" />
|
||||
<path value="$PROJECT_DIR$/php/vendor/nette/schema" />
|
||||
<path value="$PROJECT_DIR$/php/vendor/league/commonmark" />
|
||||
<path value="$PROJECT_DIR$/php/vendor/dflydev/dot-access-data" />
|
||||
<path value="$PROJECT_DIR$/php/vendor/psr/event-dispatcher" />
|
||||
<path value="$PROJECT_DIR$/php/vendor/nette/utils" />
|
||||
<path value="$PROJECT_DIR$/php/vendor/psr/container" />
|
||||
<path value="$PROJECT_DIR$/php/vendor/psr/log" />
|
||||
<path value="$PROJECT_DIR$/php/vendor/psr/cache" />
|
||||
<path value="$PROJECT_DIR$/php/vendor/phpmailer/phpmailer" />
|
||||
<path value="$PROJECT_DIR$/php/vendor/symfony/expression-language" />
|
||||
<path value="$PROJECT_DIR$/php/vendor/sebastian/type" />
|
||||
<path value="$PROJECT_DIR$/php/vendor/sebastian/version" />
|
||||
<path value="$PROJECT_DIR$/php/vendor/symfony/cache" />
|
||||
<path value="$PROJECT_DIR$/php/vendor/symfony/cache-contracts" />
|
||||
<path value="$PROJECT_DIR$/php/vendor/symfony/deprecation-contracts" />
|
||||
<path value="$PROJECT_DIR$/php/vendor/symfony/expression-language" />
|
||||
<path value="$PROJECT_DIR$/php/vendor/symfony/polyfill-ctype" />
|
||||
<path value="$PROJECT_DIR$/php/vendor/symfony/polyfill-php73" />
|
||||
<path value="$PROJECT_DIR$/php/vendor/symfony/polyfill-php80" />
|
||||
<path value="$PROJECT_DIR$/php/vendor/symfony/service-contracts" />
|
||||
<path value="$PROJECT_DIR$/php/vendor/symfony/polyfill-php73" />
|
||||
<path value="$PROJECT_DIR$/php/vendor/symfony/var-exporter" />
|
||||
<path value="$PROJECT_DIR$/php/vendor/symfony/yaml" />
|
||||
<path value="$PROJECT_DIR$/php/vendor/theseer/tokenizer" />
|
||||
</include_path>
|
||||
</component>
|
||||
<component name="PhpProjectSharedConfiguration" php_language_level="7.4">
|
||||
|
||||
@ -923,4 +923,48 @@ class cl {
|
||||
A::usort($array, $keys, $assoc);
|
||||
return $array;
|
||||
}
|
||||
|
||||
#############################################################################
|
||||
|
||||
/**
|
||||
* Extraire d'un tableau les clés séquentielles et les clés associatives
|
||||
*
|
||||
* Retourner une liste [$list, $assoc] où $list est un tableau avec uniquement
|
||||
* les valeurs des clés séquentielles et $assoc est un tableau avec uniquement
|
||||
* les valeurs des clés associatives. S'il n'existe aucune clé séquentielle
|
||||
* (resp. aucune clé associative), $list (resp. $assoc) vaut null.
|
||||
*
|
||||
* Par exemple: split_assoc(["a", "b" => "c"]) retourne [["a"], ["b" => "c"]]
|
||||
*/
|
||||
static final function split_assoc(?array $array): array {
|
||||
$list = null;
|
||||
$assoc = null;
|
||||
if ($array !== null) {
|
||||
$i = 0;
|
||||
foreach ($array as $key => $value) {
|
||||
if ($key === $i) {
|
||||
$list[] = $value;
|
||||
$i++;
|
||||
} else {
|
||||
$assoc[$key] = $value;
|
||||
}
|
||||
}
|
||||
}
|
||||
return [$list, $assoc];
|
||||
}
|
||||
|
||||
/**
|
||||
* Joindre en un seul tableau un tableau avec des clés séquentielles et un
|
||||
* tableau avec des clés associatives.
|
||||
*
|
||||
* Si $list_first==true, les clés séquentielles arrivent d'abord, ensuite les
|
||||
* clés associatives. Sinon, ce sont les clés associatives qui arrivent d'abord
|
||||
*/
|
||||
static final function merge_assoc(?array &$array, ?array $list, ?array $assoc, bool $list_first=false): void {
|
||||
if ($list === null && $assoc === null) $array = [];
|
||||
elseif ($list === null) $array = $assoc;
|
||||
elseif ($assoc === null) $array = $list;
|
||||
elseif ($list_first) $array = array_merge($list, $assoc);
|
||||
else $array = array_merge($assoc, $list);
|
||||
}
|
||||
}
|
||||
|
||||
@ -3,215 +3,728 @@ namespace nulib\db;
|
||||
|
||||
use nulib\A;
|
||||
use nulib\cl;
|
||||
use nulib\cv;
|
||||
use nulib\db\_private\_migration;
|
||||
use nulib\php\func;
|
||||
use nulib\ValueException;
|
||||
use Traversable;
|
||||
|
||||
/**
|
||||
* Class Capacitor: un objet permettant d'attaquer un canal spécifique d'une
|
||||
* instance de {@link CapacitorStorage}
|
||||
* Class Capacitor: objet permettant d'accumuler des données pour les
|
||||
* réutiliser plus tard
|
||||
*/
|
||||
class Capacitor implements ITransactor {
|
||||
function __construct(CapacitorStorage $storage, CapacitorChannel $channel, bool $ensureExists=true) {
|
||||
$this->storage = $storage;
|
||||
$this->channel = $channel;
|
||||
$this->channel->setCapacitor($this);
|
||||
if ($ensureExists) $this->ensureExists();
|
||||
}
|
||||
|
||||
/** @var CapacitorStorage */
|
||||
protected $storage;
|
||||
|
||||
function getStorage(): CapacitorStorage {
|
||||
return $this->storage;
|
||||
}
|
||||
|
||||
function db(): IDatabase {
|
||||
return $this->getStorage()->db();
|
||||
}
|
||||
abstract class Capacitor {
|
||||
abstract function db(): IDatabase;
|
||||
|
||||
function ensureLive(): self {
|
||||
$this->getStorage()->ensureLive();
|
||||
$this->db()->ensure();
|
||||
return $this;
|
||||
}
|
||||
|
||||
/** @var CapacitorChannel */
|
||||
protected $channel;
|
||||
|
||||
function getChannel(): CapacitorChannel {
|
||||
return $this->channel;
|
||||
}
|
||||
|
||||
function getTableName(): string {
|
||||
return $this->getChannel()->getTableName();
|
||||
}
|
||||
|
||||
function getCreateSql(): string {
|
||||
$channel = $this->channel;
|
||||
return $this->storage->_getMigration($channel)->getSql(get_class($channel), $this->db());
|
||||
}
|
||||
|
||||
/** @var CapacitorChannel[] */
|
||||
protected ?array $subChannels = null;
|
||||
|
||||
protected ?array $subManageTransactions = null;
|
||||
|
||||
function willUpdate(...$channels): self {
|
||||
if ($this->subChannels === null) {
|
||||
# désactiver la gestion des transaction sur le channel local aussi
|
||||
$this->subChannels[] = $this->channel;
|
||||
function newChannel($channel): CapacitorChannel {
|
||||
if (!($channel instanceof CapacitorChannel)) {
|
||||
if (!is_array($channel)) $channel = ["name" => $channel];
|
||||
$channel = new CapacitorChannel($channel);
|
||||
}
|
||||
if ($channels) {
|
||||
foreach ($channels as $channel) {
|
||||
if ($channel instanceof Capacitor) $channel = $channel->getChannel();
|
||||
if ($channel instanceof CapacitorChannel) {
|
||||
$this->subChannels[] = $channel;
|
||||
} else {
|
||||
throw ValueException::invalid_type($channel, CapacitorChannel::class);
|
||||
}
|
||||
}
|
||||
return $channel->initCapacitor($this);
|
||||
}
|
||||
|
||||
# les définitions sont par défaut pour MariaDB/MySQL
|
||||
const CDATA_DEFINITION = "mediumtext";
|
||||
const CSUM_DEFINITION = "varchar(40)";
|
||||
const CTIMESTAMP_DEFINITION = "datetime";
|
||||
const GSERIAL_DEFINITION = "integer primary key auto_increment";
|
||||
const GLIC_DEFINITION = "varchar(80)";
|
||||
const GLIB_DEFINITION = "varchar(255)";
|
||||
const GTEXT_DEFINITION = "mediumtext";
|
||||
const GBOOL_DEFINITION = "integer(1) default 0";
|
||||
const GUUID_DEFINITION = "varchar(36)";
|
||||
|
||||
protected static function verifix_col($def): string {
|
||||
if (!is_string($def)) $def = strval($def);
|
||||
$def = trim($def);
|
||||
$parts = preg_split('/\s+/', $def, 2);
|
||||
if (count($parts) == 2) {
|
||||
$def = $parts[0];
|
||||
$rest = " $parts[1]";
|
||||
} else {
|
||||
$rest = null;
|
||||
}
|
||||
return $this;
|
||||
switch ($def) {
|
||||
case "serdata":
|
||||
case "Cdata": $def = static::CDATA_DEFINITION; break;
|
||||
case "sersum":
|
||||
case "Csum": $def = static::CSUM_DEFINITION; break;
|
||||
case "serts":
|
||||
case "Ctimestamp": $def = static::CTIMESTAMP_DEFINITION; break;
|
||||
case "genserial":
|
||||
case "Gserial": $def = static::GSERIAL_DEFINITION; break;
|
||||
case "genlic":
|
||||
case "Glic": $def = static::GLIC_DEFINITION; break;
|
||||
case "genlib":
|
||||
case "Glib": $def = static::GLIB_DEFINITION; break;
|
||||
case "gentext":
|
||||
case "Gtext": $def = static::GTEXT_DEFINITION; break;
|
||||
case "genbool":
|
||||
case "Gbool": $def = static::GBOOL_DEFINITION; break;
|
||||
case "genuuid":
|
||||
case "Guuid": $def = static::GUUID_DEFINITION; break;
|
||||
}
|
||||
return "$def$rest";
|
||||
}
|
||||
|
||||
function inTransaction(): bool {
|
||||
return $this->db()->inTransaction();
|
||||
}
|
||||
const PRIMARY_KEY_DEFINITION = [
|
||||
"id_" => "Gserial",
|
||||
];
|
||||
|
||||
function beginTransaction(?callable $func=null, bool $commit=true): void {
|
||||
$db = $this->db();
|
||||
if ($this->subChannels !== null) {
|
||||
# on gère des subchannels: ne débuter la transaction que si ce n'est déjà fait
|
||||
if ($this->subManageTransactions === null) {
|
||||
foreach ($this->subChannels as $channel) {
|
||||
$name = $channel->getName();
|
||||
$this->subManageTransactions ??= [];
|
||||
if (!array_key_exists($name, $this->subManageTransactions)) {
|
||||
$this->subManageTransactions[$name] = $channel->isManageTransactions();
|
||||
const COLUMN_DEFINITIONS = [
|
||||
"item__" => "Cdata",
|
||||
"item__sum_" => "Csum",
|
||||
"created_" => "Ctimestamp",
|
||||
"modified_" => "Ctimestamp",
|
||||
];
|
||||
|
||||
protected function getColumnDefinitions(CapacitorChannel $channel, bool $ignoreMigrations=false): array {
|
||||
$definitions = [];
|
||||
if ($channel->getPrimaryKeys() === null) {
|
||||
$definitions[] = static::PRIMARY_KEY_DEFINITION;
|
||||
}
|
||||
$definitions[] = $channel->getColumnDefinitions();
|
||||
$definitions[] = static::COLUMN_DEFINITIONS;
|
||||
# forcer les définitions sans clé à la fin (sqlite requière par exemple que
|
||||
# primary key (columns) soit à la fin)
|
||||
$tmp = cl::merge(...$definitions);
|
||||
$definitions = [];
|
||||
$constraints = [];
|
||||
$index = 0;
|
||||
foreach ($tmp as $col => $def) {
|
||||
if ($col === $index) {
|
||||
$index++;
|
||||
if (is_array($def)) {
|
||||
if (!$ignoreMigrations) {
|
||||
$mdefs = $def;
|
||||
$mindex = 0;
|
||||
foreach ($mdefs as $mcol => $mdef) {
|
||||
if ($mcol === $mindex) {
|
||||
$mindex++;
|
||||
} else {
|
||||
if ($mdef) {
|
||||
$definitions[$mcol] = self::verifix_col($mdef);
|
||||
} else {
|
||||
unset($definitions[$mcol]);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
$channel->setManageTransactions(false);
|
||||
} else {
|
||||
$constraints[] = $def;
|
||||
}
|
||||
if (!$db->inTransaction()) $db->beginTransaction();
|
||||
} else {
|
||||
$definitions[$col] = self::verifix_col($def);
|
||||
}
|
||||
} elseif (!$db->inTransaction()) {
|
||||
}
|
||||
return cl::merge($definitions, $constraints);
|
||||
}
|
||||
|
||||
/** sérialiser les valeurs qui doivent l'être dans $row */
|
||||
protected function serialize(CapacitorChannel $channel, ?array $row): ?array {
|
||||
if ($row === null) return null;
|
||||
$colDefs = $this->getColumnDefinitions($channel);
|
||||
$index = 0;
|
||||
$raw = [];
|
||||
foreach (array_keys($colDefs) as $col) {
|
||||
$key = $col;
|
||||
if ($key === $index) {
|
||||
$index++;
|
||||
} elseif ($channel->isSerialCol($key)) {
|
||||
[$serialCol, $sumCol] = $channel->getSumCols($key);
|
||||
if (array_key_exists($key, $row)) {
|
||||
$sum = $channel->getSum($key, $row[$key]);
|
||||
$raw[$serialCol] = $sum[$serialCol];
|
||||
if (array_key_exists($sumCol, $colDefs)) {
|
||||
$raw[$sumCol] = $sum[$sumCol];
|
||||
}
|
||||
}
|
||||
} elseif (array_key_exists($key, $row)) {
|
||||
$raw[$col] = $row[$key];
|
||||
}
|
||||
}
|
||||
return $raw;
|
||||
}
|
||||
|
||||
/** désérialiser les valeurs qui doivent l'être dans $values */
|
||||
protected function unserialize(CapacitorChannel $channel, ?array $raw): ?array {
|
||||
if ($raw === null) return null;
|
||||
$colDefs = $this->getColumnDefinitions($channel);
|
||||
$index = 0;
|
||||
$row = [];
|
||||
foreach (array_keys($colDefs) as $col) {
|
||||
$key = $col;
|
||||
if ($key === $index) {
|
||||
$index++;
|
||||
} elseif (!array_key_exists($col, $raw)) {
|
||||
} elseif ($channel->isSerialCol($key)) {
|
||||
$value = $raw[$col];
|
||||
if ($value !== null) $value = $channel->unserialize($value);
|
||||
$row[$key] = $value;
|
||||
} else {
|
||||
$row[$key] = $raw[$col];
|
||||
}
|
||||
}
|
||||
return $row;
|
||||
}
|
||||
|
||||
function getPrimaryKeys(CapacitorChannel $channel): array {
|
||||
$primaryKeys = $channel->getPrimaryKeys();
|
||||
if ($primaryKeys === null) $primaryKeys = ["id_"];
|
||||
return $primaryKeys;
|
||||
}
|
||||
|
||||
function getRowIds(CapacitorChannel $channel, ?array $row, ?array &$primaryKeys=null): ?array {
|
||||
$primaryKeys = $this->getPrimaryKeys($channel);
|
||||
$rowIds = cl::select($row, $primaryKeys);
|
||||
if (cl::all_n($rowIds)) return null;
|
||||
else return $rowIds;
|
||||
}
|
||||
|
||||
#############################################################################
|
||||
# Migration et metadata
|
||||
|
||||
abstract protected function tableExists(string $tableName): bool;
|
||||
|
||||
const METADATA_TABLE = "_metadata";
|
||||
const METADATA_COLS = [
|
||||
"name" => "varchar not null primary key",
|
||||
"value" => "varchar",
|
||||
];
|
||||
|
||||
protected function prepareMetadata(): void {
|
||||
if (!$this->tableExists(static::METADATA_TABLE)) {
|
||||
$db = $this->db();
|
||||
$db->exec([
|
||||
"create table",
|
||||
"table" => static::METADATA_TABLE,
|
||||
"cols" => static::METADATA_COLS,
|
||||
]);
|
||||
$db->exec([
|
||||
"insert",
|
||||
"into" => static::METADATA_TABLE,
|
||||
"values" => [
|
||||
"name" => "version",
|
||||
"value" => "1",
|
||||
],
|
||||
]);
|
||||
}
|
||||
}
|
||||
|
||||
protected function getCreateChannelSql(CapacitorChannel $channel): array {
|
||||
return [
|
||||
"create table if not exists",
|
||||
"table" => $channel->getTableName(),
|
||||
"cols" => $this->getColumnDefinitions($channel, true),
|
||||
];
|
||||
}
|
||||
|
||||
abstract function getMigration(CapacitorChannel $channel): _migration;
|
||||
|
||||
#############################################################################
|
||||
# Catalogue
|
||||
|
||||
const CATALOG_TABLE = "_channels";
|
||||
const CATALOG_COLS = [
|
||||
"name" => "varchar not null primary key",
|
||||
"table_name" => "varchar",
|
||||
"class_name" => "varchar",
|
||||
];
|
||||
|
||||
protected function getCreateCatalogSql(): array {
|
||||
return [
|
||||
"create table if not exists",
|
||||
"table" => static::CATALOG_TABLE,
|
||||
"cols" => static::CATALOG_COLS,
|
||||
];
|
||||
}
|
||||
|
||||
protected function addToCatalogSql(CapacitorChannel $channel): array {
|
||||
return [
|
||||
"insert",
|
||||
"into" => static::CATALOG_TABLE,
|
||||
"values" => [
|
||||
"name" => $channel->getName(),
|
||||
"table_name" => $channel->getTableName(),
|
||||
"class_name" => get_class($channel),
|
||||
],
|
||||
];
|
||||
}
|
||||
|
||||
function getCatalog(): iterable {
|
||||
return $this->db()->all([
|
||||
"select",
|
||||
"from" => static::CATALOG_TABLE,
|
||||
]);
|
||||
}
|
||||
|
||||
function isInCatalog(array $filter, ?array &$raw=null): bool {
|
||||
$raw = $this->db()->one([
|
||||
"select",
|
||||
"from" => static::CATALOG_TABLE,
|
||||
"where" => $filter,
|
||||
]);
|
||||
return $raw !== null;
|
||||
}
|
||||
|
||||
#############################################################################
|
||||
|
||||
protected function afterCreate(CapacitorChannel $channel): void {
|
||||
$db = $this->db();
|
||||
$db->exec($this->getCreateCatalogSql());
|
||||
$db->exec($this->addToCatalogSql($channel));
|
||||
}
|
||||
|
||||
function create(CapacitorChannel $channel): void {
|
||||
$this->prepareMetadata();
|
||||
$this->getMigration($channel)->migrate($this->db());
|
||||
$this->afterCreate($channel);
|
||||
}
|
||||
|
||||
function autocreate(CapacitorChannel $channel, bool $force=false): void {
|
||||
if ($force || !$channel->isCreated()) {
|
||||
$channel->ensureSetup();
|
||||
$this->create($channel);
|
||||
$channel->setCreated();
|
||||
}
|
||||
}
|
||||
|
||||
/** tester si le canal spécifié existe */
|
||||
function exists(CapacitorChannel $channel): bool {
|
||||
return $this->tableExists($channel->getTableName());
|
||||
}
|
||||
|
||||
protected function beforeReset(CapacitorChannel $channel): void {
|
||||
$db = $this->db;
|
||||
$name = $channel->getName();
|
||||
$db->exec([
|
||||
"delete",
|
||||
"from" => _migration::MIGRATION_TABLE,
|
||||
"where" => [
|
||||
"channel" => $name,
|
||||
],
|
||||
]);
|
||||
$db->exec([
|
||||
"delete",
|
||||
"from" => static::CATALOG_TABLE,
|
||||
"where" => [
|
||||
"name" => $name,
|
||||
],
|
||||
]);
|
||||
}
|
||||
|
||||
/** supprimer le canal spécifié */
|
||||
function reset(CapacitorChannel $channel, bool $recreate=false): void {
|
||||
$this->beforeReset($channel);
|
||||
$this->db()->exec([
|
||||
"drop table if exists",
|
||||
$channel->getTableName(),
|
||||
]);
|
||||
$channel->setCreated(false);
|
||||
if ($recreate) $this->autocreate($channel);
|
||||
}
|
||||
|
||||
/**
|
||||
* charger une valeur dans le canal
|
||||
*
|
||||
* Après avoir calculé les valeurs des clés supplémentaires
|
||||
* avec {@link CapacitorChannel::getItemValues()}, l'une des deux fonctions
|
||||
* {@link CapacitorChannel::onCreate()} ou {@link CapacitorChannel::onUpdate()}
|
||||
* est appelée en fonction du type d'opération: création ou mise à jour
|
||||
*
|
||||
* Ensuite, si $func !== null, la fonction est appelée avec la signature de
|
||||
* {@link CapacitorChannel::onCreate()} ou {@link CapacitorChannel::onUpdate()}
|
||||
* en fonction du type d'opération: création ou mise à jour
|
||||
*
|
||||
* Dans les deux cas, si la fonction retourne un tableau, il est utilisé pour
|
||||
* modifier les valeurs insérées/mises à jour. De plus, $row obtient la
|
||||
* valeur finale des données insérées/mises à jour
|
||||
*
|
||||
* Si $args est renseigné, il est ajouté aux arguments utilisés pour appeler
|
||||
* les méthodes {@link CapacitorChannel::getItemValues()},
|
||||
* {@link CapacitorChannel::onCreate()} et/ou
|
||||
* {@link CapacitorChannel::onUpdate()}
|
||||
*
|
||||
* @return int 1 si l'objet a été chargé ou mis à jour, 0 s'il existait
|
||||
* déjà à l'identique dans le canal
|
||||
*/
|
||||
function charge(CapacitorChannel $channel, $item, $func=null, ?array $args=null, ?array &$row=null): int {
|
||||
$channel->initCapacitor($this);
|
||||
|
||||
$tableName = $channel->getTableName();
|
||||
$db = $this->db();
|
||||
$args ??= [];
|
||||
|
||||
$row = func::call([$channel, "getItemValues"], $item, ...$args);
|
||||
if ($row === [false]) return 0;
|
||||
|
||||
if ($row !== null && array_key_exists("item", $row)) {
|
||||
$item = A::pop($row, "item");
|
||||
}
|
||||
|
||||
$raw = cl::merge(
|
||||
$channel->getSum("item", $item),
|
||||
$this->serialize($channel, $row));
|
||||
$praw = null;
|
||||
$rowIds = $this->getRowIds($channel, $raw, $primaryKeys);
|
||||
if ($rowIds !== null) {
|
||||
# modification
|
||||
$praw = $db->one([
|
||||
"select",
|
||||
"from" => $tableName,
|
||||
"where" => $rowIds,
|
||||
]);
|
||||
}
|
||||
|
||||
$now = date("Y-m-d H:i:s");
|
||||
$insert = null;
|
||||
if ($praw === null) {
|
||||
# création
|
||||
$raw = cl::merge($raw, [
|
||||
"created_" => $now,
|
||||
"modified_" => $now,
|
||||
]);
|
||||
$insert = true;
|
||||
$initFunc = func::with([$channel, "onCreate"], $args);
|
||||
$row = $this->unserialize($channel, $raw);
|
||||
$prow = null;
|
||||
} else {
|
||||
# modification
|
||||
# intégrer autant que possible les valeurs de praw dans raw, de façon que
|
||||
# l'utilisateur puisse voir clairement ce qui a été modifié
|
||||
if ($channel->_wasSumModified("item", $raw, $praw)) {
|
||||
$insert = false;
|
||||
$raw = cl::merge($praw, $raw, [
|
||||
"modified_" => $now,
|
||||
]);
|
||||
} else {
|
||||
$raw = cl::merge($praw, $raw);
|
||||
}
|
||||
$initFunc = func::with([$channel, "onUpdate"], $args);
|
||||
$row = $this->unserialize($channel, $raw);
|
||||
$prow = $this->unserialize($channel, $praw);
|
||||
}
|
||||
|
||||
$updates = $initFunc->prependArgs([$item, $row, $prow])->invoke();
|
||||
if ($updates === [false]) return 0;
|
||||
if (is_array($updates) && $updates) {
|
||||
if ($insert === null) $insert = false;
|
||||
if (!array_key_exists("modified_", $updates)) {
|
||||
$updates["modified_"] = $now;
|
||||
}
|
||||
$row = cl::merge($row, $updates);
|
||||
$raw = cl::merge($raw, $this->serialize($channel, $updates));
|
||||
}
|
||||
|
||||
if ($func !== null) {
|
||||
$updates = func::with($func, $args)
|
||||
->prependArgs([$item, $row, $prow])
|
||||
->bind($channel)
|
||||
->invoke();
|
||||
if ($updates === [false]) return 0;
|
||||
if (is_array($updates) && $updates) {
|
||||
if ($insert === null) $insert = false;
|
||||
if (!array_key_exists("modified_", $updates)) {
|
||||
$updates["modified_"] = $now;
|
||||
}
|
||||
$row = cl::merge($row, $updates);
|
||||
$raw = cl::merge($raw, $this->serialize($channel, $updates));
|
||||
}
|
||||
}
|
||||
|
||||
# aucune modification
|
||||
if ($insert === null) return 0;
|
||||
|
||||
# si on est déjà dans une transaction, désactiver la gestion des transactions
|
||||
$manageTransactions = $channel->isManageTransactions() && !$db->inTransaction();
|
||||
if ($manageTransactions) {
|
||||
$commited = false;
|
||||
$db->beginTransaction();
|
||||
}
|
||||
if ($func !== null) {
|
||||
$commited = false;
|
||||
try {
|
||||
func::call($func, $this);
|
||||
if ($commit) {
|
||||
$this->commit();
|
||||
$commited = true;
|
||||
$nbModified = 0;
|
||||
try {
|
||||
if ($insert) {
|
||||
$id = $db->exec([
|
||||
"insert",
|
||||
"into" => $tableName,
|
||||
"values" => $raw,
|
||||
]);
|
||||
if (count($primaryKeys) == 1 && $rowIds === null) {
|
||||
# mettre à jour avec l'id généré
|
||||
$row[$primaryKeys[0]] = $id;
|
||||
}
|
||||
$nbModified = 1;
|
||||
} else {
|
||||
# calculer ce qui a changé pour ne mettre à jour que le nécessaire
|
||||
$updates = [];
|
||||
foreach ($raw as $col => $value) {
|
||||
if (array_key_exists($col, $rowIds)) {
|
||||
# ne jamais mettre à jour la clé primaire
|
||||
continue;
|
||||
}
|
||||
if (!cv::equals($value, $praw[$col] ?? null)) {
|
||||
$updates[$col] = $value;
|
||||
}
|
||||
}
|
||||
if (count($updates) == 1 && array_key_first($updates) == "modified_") {
|
||||
# si l'unique modification porte sur la date de modification, alors
|
||||
# la ligne n'est pas modifiée. ce cas se présente quand on altère la
|
||||
# valeur de $item
|
||||
$updates = null;
|
||||
}
|
||||
if ($updates) {
|
||||
$db->exec([
|
||||
"update",
|
||||
"table" => $tableName,
|
||||
"values" => $updates,
|
||||
"where" => $rowIds,
|
||||
]);
|
||||
$nbModified = 1;
|
||||
}
|
||||
} finally {
|
||||
if ($commit && !$commited) $this->rollback();
|
||||
}
|
||||
if ($manageTransactions) {
|
||||
$db->commit();
|
||||
$commited = true;
|
||||
}
|
||||
return $nbModified;
|
||||
} finally {
|
||||
if ($manageTransactions && !$commited) $db->rollback();
|
||||
}
|
||||
}
|
||||
|
||||
protected function beforeEndTransaction(): void {
|
||||
if ($this->subManageTransactions !== null) {
|
||||
foreach ($this->subChannels as $channel) {
|
||||
$name = $channel->getName();
|
||||
$channel->setManageTransactions($this->subManageTransactions[$name]);
|
||||
/**
|
||||
* décharger les données du canal spécifié. seul la valeur de $item est
|
||||
* fournie
|
||||
*/
|
||||
function discharge(CapacitorChannel $channel, bool $reset=true): Traversable {
|
||||
$channel->initCapacitor($this);
|
||||
|
||||
$raws = $this->db()->all([
|
||||
"select item__",
|
||||
"from" => $channel->getTableName(),
|
||||
]);
|
||||
foreach ($raws as $raw) {
|
||||
yield unserialize($raw['item__']);
|
||||
}
|
||||
if ($reset) $this->reset($channel);
|
||||
}
|
||||
|
||||
protected function convertValue2row(CapacitorChannel $channel, array $filter, array $cols): array {
|
||||
$index = 0;
|
||||
$fixed = [];
|
||||
foreach ($filter as $key => $value) {
|
||||
if ($key === $index) {
|
||||
$index++;
|
||||
if (is_array($value)) {
|
||||
$value = $this->convertValue2row($channel, $value, $cols);
|
||||
}
|
||||
$fixed[] = $value;
|
||||
} else {
|
||||
$col = "${key}__";
|
||||
if (array_key_exists($col, $cols)) {
|
||||
# colonne sérialisée
|
||||
$fixed[$col] = $channel->serialize($value);
|
||||
} else {
|
||||
$fixed[$key] = $value;
|
||||
}
|
||||
}
|
||||
$this->subManageTransactions = null;
|
||||
}
|
||||
return $fixed;
|
||||
}
|
||||
|
||||
protected function verifixFilter(CapacitorChannel $channel, &$filter): void {
|
||||
if ($filter !== null && !is_array($filter)) {
|
||||
$primaryKeys = $this->getPrimaryKeys($channel);
|
||||
$id = $filter;
|
||||
$channel->verifixId($id);
|
||||
$filter = [$primaryKeys[0] => $id];
|
||||
}
|
||||
$cols = $this->getColumnDefinitions($channel);
|
||||
if ($filter !== null) {
|
||||
$filter = $this->convertValue2row($channel, $filter, $cols);
|
||||
}
|
||||
}
|
||||
|
||||
function commit(): void {
|
||||
$this->beforeEndTransaction();
|
||||
/** indiquer le nombre d'éléments du canal spécifié */
|
||||
function count(CapacitorChannel $channel, $filter): int {
|
||||
$channel->initCapacitor($this);
|
||||
$this->verifixFilter($channel, $filter);
|
||||
|
||||
return $this->db()->get([
|
||||
"select count(*)",
|
||||
"from" => $channel->getTableName(),
|
||||
"where" => $filter,
|
||||
]);
|
||||
}
|
||||
|
||||
/**
|
||||
* obtenir la ligne correspondant au filtre sur le canal spécifié
|
||||
*
|
||||
* si $filter n'est pas un tableau, il est transformé en ["id_" => $filter]
|
||||
*/
|
||||
function one(CapacitorChannel $channel, $filter, ?array $mergeQuery=null): ?array {
|
||||
$channel->initCapacitor($this);
|
||||
$this->verifixFilter($channel, $filter);
|
||||
|
||||
$raw = $this->db()->one(cl::merge([
|
||||
"select",
|
||||
"from" => $channel->getTableName(),
|
||||
"where" => $filter,
|
||||
], $mergeQuery));
|
||||
return $this->unserialize($channel, $raw);
|
||||
}
|
||||
|
||||
/**
|
||||
* obtenir les lignes correspondant au filtre sur le canal spécifié
|
||||
*
|
||||
* si $filter n'est pas un tableau, il est transformé en ["id_" => $filter]
|
||||
*/
|
||||
function all(CapacitorChannel $channel, $filter, ?array $mergeQuery=null): Traversable {
|
||||
$channel->initCapacitor($this);
|
||||
$this->verifixFilter($channel, $filter);
|
||||
|
||||
$raws = $this->db()->all(cl::merge([
|
||||
"select",
|
||||
"from" => $channel->getTableName(),
|
||||
"where" => $filter,
|
||||
], $mergeQuery), null, $this->getPrimaryKeys($channel));
|
||||
foreach ($raws as $key => $raw) {
|
||||
yield $key => $this->unserialize($channel, $raw);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* appeler une fonction pour chaque élément du canal spécifié.
|
||||
*
|
||||
* $filter permet de filtrer parmi les élements chargés
|
||||
*
|
||||
* $func est appelé avec la signature de {@link CapacitorChannel::onEach()}
|
||||
* si la fonction retourne un tableau, il est utilisé pour mettre à jour la
|
||||
* ligne
|
||||
*
|
||||
* @param int $nbUpdated reçoit le nombre de lignes mises à jour
|
||||
* @return int le nombre de lignes parcourues
|
||||
*/
|
||||
function each(CapacitorChannel $channel, $filter, $func=null, ?array $args=null, ?array $mergeQuery=null, ?int &$nbUpdated=null): int {
|
||||
$channel->initCapacitor($this);
|
||||
|
||||
if ($func === null) $func = CapacitorChannel::onEach;
|
||||
$onEach = func::with($func)->bind($channel);
|
||||
$db = $this->db();
|
||||
if ($db->inTransaction()) $db->commit();
|
||||
}
|
||||
|
||||
function rollback(): void {
|
||||
$this->beforeEndTransaction();
|
||||
$db = $this->db();
|
||||
if ($db->inTransaction()) $db->rollback();
|
||||
}
|
||||
|
||||
function exists(): bool {
|
||||
return $this->storage->_exists($this->channel);
|
||||
}
|
||||
|
||||
function ensureExists(): void {
|
||||
$this->storage->_ensureExists($this->channel);
|
||||
}
|
||||
|
||||
function reset(bool $recreate=false): void {
|
||||
$this->storage->_reset($this->channel, $recreate);
|
||||
}
|
||||
|
||||
function charge($item, $func=null, ?array $args=null, ?array &$row=null): int {
|
||||
if ($this->subChannels !== null) $this->beginTransaction();
|
||||
return $this->storage->_charge($this->channel, $item, $func, $args, $row);
|
||||
}
|
||||
|
||||
function chargeAll(?iterable $items, $func=null, ?array $args=null): int {
|
||||
# si on est déjà dans une transaction, désactiver la gestion des transactions
|
||||
$manageTransactions = $channel->isManageTransactions() && !$db->inTransaction();
|
||||
if ($manageTransactions) {
|
||||
$commited = false;
|
||||
$db->beginTransaction();
|
||||
$commitThreshold = $channel->getEachCommitThreshold();
|
||||
}
|
||||
$count = 0;
|
||||
if ($items !== null) {
|
||||
if ($func !== null) {
|
||||
$func = func::with($func, $args)->bind($this->channel);
|
||||
$nbUpdated = 0;
|
||||
$tableName = $channel->getTableName();
|
||||
try {
|
||||
$args ??= [];
|
||||
$rows = $this->all($channel, $filter, $mergeQuery);
|
||||
foreach ($rows as $row) {
|
||||
$rowIds = $this->getRowIds($channel, $row);
|
||||
$updates = $onEach->invoke([$row, ...$args]);
|
||||
if ($updates === [false]) {
|
||||
break;
|
||||
} elseif ($updates !== null) {
|
||||
if (!array_key_exists("modified_", $updates)) {
|
||||
$updates["modified_"] = date("Y-m-d H:i:s");
|
||||
}
|
||||
$nbUpdated += $db->exec([
|
||||
"update",
|
||||
"table" => $tableName,
|
||||
"values" => $this->serialize($channel, $updates),
|
||||
"where" => $rowIds,
|
||||
]);
|
||||
if ($manageTransactions && $commitThreshold !== null) {
|
||||
$commitThreshold--;
|
||||
if ($commitThreshold <= 0) {
|
||||
$db->commit();
|
||||
$db->beginTransaction();
|
||||
$commitThreshold = $channel->getEachCommitThreshold();
|
||||
}
|
||||
}
|
||||
}
|
||||
$count++;
|
||||
}
|
||||
foreach ($items as $item) {
|
||||
$count += $this->charge($item, $func);
|
||||
if ($manageTransactions) {
|
||||
$db->commit();
|
||||
$commited = true;
|
||||
}
|
||||
return $count;
|
||||
} finally {
|
||||
if ($manageTransactions && !$commited) $db->rollback();
|
||||
}
|
||||
return $count;
|
||||
}
|
||||
|
||||
function discharge(bool $reset=true): Traversable {
|
||||
return $this->storage->_discharge($this->channel, $reset);
|
||||
/**
|
||||
* supprimer tous les éléments correspondant au filtre et pour lesquels la
|
||||
* fonction retourne une valeur vraie si elle est spécifiée
|
||||
*
|
||||
* $filter permet de filtrer parmi les élements chargés
|
||||
*
|
||||
* $func est appelé avec la signature de {@link CapacitorChannel::onDelete()}
|
||||
* si la fonction retourne un tableau, il est utilisé pour mettre à jour la
|
||||
* ligne
|
||||
*
|
||||
* @return int le nombre de lignes parcourues
|
||||
*/
|
||||
function delete(CapacitorChannel $channel, $filter, $func=null, ?array $args=null): int {
|
||||
$channel->initCapacitor($this);
|
||||
|
||||
if ($func === null) $func = CapacitorChannel::onDelete;
|
||||
$onDelete = func::with($func)->bind($channel);
|
||||
$db = $this->db();
|
||||
# si on est déjà dans une transaction, désactiver la gestion des transactions
|
||||
$manageTransactions = $channel->isManageTransactions() && !$db->inTransaction();
|
||||
if ($manageTransactions) {
|
||||
$commited = false;
|
||||
$db->beginTransaction();
|
||||
$commitThreshold = $channel->getEachCommitThreshold();
|
||||
}
|
||||
$count = 0;
|
||||
$tableName = $channel->getTableName();
|
||||
try {
|
||||
$args ??= [];
|
||||
$rows = $this->all($channel, $filter);
|
||||
foreach ($rows as $row) {
|
||||
$rowIds = $this->getRowIds($channel, $row);
|
||||
$shouldDelete = boolval($onDelete->invoke([$row, ...$args]));
|
||||
if ($shouldDelete) {
|
||||
$db->exec([
|
||||
"delete",
|
||||
"from" => $tableName,
|
||||
"where" => $rowIds,
|
||||
]);
|
||||
if ($manageTransactions && $commitThreshold !== null) {
|
||||
$commitThreshold--;
|
||||
if ($commitThreshold <= 0) {
|
||||
$db->commit();
|
||||
$db->beginTransaction();
|
||||
$commitThreshold = $channel->getEachCommitThreshold();
|
||||
}
|
||||
}
|
||||
}
|
||||
$count++;
|
||||
}
|
||||
if ($manageTransactions) {
|
||||
$db->commit();
|
||||
$commited = true;
|
||||
}
|
||||
return $count;
|
||||
} finally {
|
||||
if ($manageTransactions && !$commited) $db->rollback();
|
||||
}
|
||||
}
|
||||
|
||||
function count($filter=null): int {
|
||||
return $this->storage->_count($this->channel, $filter);
|
||||
}
|
||||
|
||||
function one($filter, ?array $mergeQuery=null): ?array {
|
||||
return $this->storage->_one($this->channel, $filter, $mergeQuery);
|
||||
}
|
||||
|
||||
function all($filter, ?array $mergeQuery=null): Traversable {
|
||||
return $this->storage->_all($this->channel, $filter, $mergeQuery);
|
||||
}
|
||||
|
||||
function each($filter, $func=null, ?array $args=null, ?array $mergeQuery=null, ?int &$nbUpdated=null): int {
|
||||
if ($this->subChannels !== null) $this->beginTransaction();
|
||||
return $this->storage->_each($this->channel, $filter, $func, $args, $mergeQuery, $nbUpdated);
|
||||
}
|
||||
|
||||
function delete($filter, $func=null, ?array $args=null): int {
|
||||
if ($this->subChannels !== null) $this->beginTransaction();
|
||||
return $this->storage->_delete($this->channel, $filter, $func, $args);
|
||||
}
|
||||
|
||||
function dbAll(array $query, ?array $params=null): iterable {
|
||||
$primaryKeys = $this->channel->getPrimaryKeys();
|
||||
return $this->storage->db()->all(cl::merge([
|
||||
"select",
|
||||
"from" => $this->getTableName(),
|
||||
], $query), $params, $primaryKeys);
|
||||
}
|
||||
|
||||
function dbOne(array $query, ?array $params=null): ?array {
|
||||
return $this->storage->db()->one(cl::merge([
|
||||
"select",
|
||||
"from" => $this->getTableName(),
|
||||
], $query), $params);
|
||||
}
|
||||
|
||||
/** @return int|false */
|
||||
function dbUpdate(array $query, ?array $params=null) {
|
||||
return $this->storage->db()->exec(cl::merge([
|
||||
"update",
|
||||
"table" => $this->getTableName(),
|
||||
], $query), $params);
|
||||
}
|
||||
|
||||
function close(): void {
|
||||
$this->storage->close();
|
||||
}
|
||||
abstract function close(): void;
|
||||
}
|
||||
|
||||
@ -1,18 +1,23 @@
|
||||
<?php
|
||||
namespace nulib\db;
|
||||
|
||||
use nulib\app;
|
||||
use nulib\cl;
|
||||
use nulib\php\func;
|
||||
use nulib\str;
|
||||
use nulib\ValueException;
|
||||
use Traversable;
|
||||
|
||||
/**
|
||||
* Class CapacitorChannel: un canal d'une instance de {@link ICapacitor}
|
||||
* Class CapacitorChannel: un canal de données
|
||||
*/
|
||||
class CapacitorChannel implements ITransactor {
|
||||
const NAME = null;
|
||||
|
||||
const TABLE_NAME = null;
|
||||
|
||||
const AUTOCREATE = null;
|
||||
|
||||
protected function COLUMN_DEFINITIONS(): ?array {
|
||||
return static::COLUMN_DEFINITIONS;
|
||||
} const COLUMN_DEFINITIONS = null;
|
||||
@ -50,16 +55,21 @@ class CapacitorChannel implements ITransactor {
|
||||
return $eachCommitThreshold;
|
||||
}
|
||||
|
||||
function __construct(?string $name=null, ?int $eachCommitThreshold=null, ?bool $manageTransactions=null) {
|
||||
$name ??= static::NAME;
|
||||
$tableName ??= static::TABLE_NAME;
|
||||
function __construct(?array $params=null) {
|
||||
$this->capacitor = null;
|
||||
|
||||
$name = $params["name"] ?? static::NAME;
|
||||
$tableName = $params["tableName"] ?? static::TABLE_NAME;
|
||||
self::verifix_name($name, $tableName);
|
||||
$this->name = $name;
|
||||
$this->tableName = $tableName;
|
||||
$this->manageTransactions = $manageTransactions ?? static::MANAGE_TRANSACTIONS;
|
||||
$this->eachCommitThreshold = self::verifix_eachCommitThreshold($eachCommitThreshold);
|
||||
|
||||
#$autocreate = $params["autocreate"] ?? null;
|
||||
#$autocreate ??= !app::get()->isProductionMode();
|
||||
$autocreate = true; #XXX
|
||||
$this->created = !$autocreate;
|
||||
$this->setup = false;
|
||||
$this->created = false;
|
||||
|
||||
$columnDefinitions = $this->COLUMN_DEFINITIONS();
|
||||
$primaryKeys = cl::withn(static::PRIMARY_KEYS);
|
||||
$migration = cl::withn(static::MIGRATION);
|
||||
@ -117,6 +127,13 @@ class CapacitorChannel implements ITransactor {
|
||||
$this->columnDefinitions = $columnDefinitions;
|
||||
$this->primaryKeys = $primaryKeys;
|
||||
$this->migration = $migration;
|
||||
|
||||
$manageTransactions = $params["manageTransactions"] ?? static::MANAGE_TRANSACTIONS;
|
||||
$this->manageTransactions = $manageTransactions;
|
||||
|
||||
$eachCommitThreshold = $params["eachCommitThreshold"] ?? null;
|
||||
$eachCommitThreshold = self::verifix_eachCommitThreshold($eachCommitThreshold);
|
||||
$this->eachCommitThreshold = $eachCommitThreshold;
|
||||
}
|
||||
|
||||
protected string $name;
|
||||
@ -131,40 +148,6 @@ class CapacitorChannel implements ITransactor {
|
||||
return $this->tableName;
|
||||
}
|
||||
|
||||
/**
|
||||
* @var bool indiquer si les modifications de each doivent être gérées dans
|
||||
* une transaction. si false, l'utilisateur doit lui même gérer la
|
||||
* transaction.
|
||||
*/
|
||||
protected bool $manageTransactions;
|
||||
|
||||
function isManageTransactions(): bool {
|
||||
return $this->manageTransactions;
|
||||
}
|
||||
|
||||
function setManageTransactions(bool $manageTransactions=true): self {
|
||||
$this->manageTransactions = $manageTransactions;
|
||||
return $this;
|
||||
}
|
||||
|
||||
/**
|
||||
* @var ?int nombre maximum de modifications dans une transaction avant un
|
||||
* commit automatique dans {@link Capacitor::each()}. Utiliser null pour
|
||||
* désactiver la fonctionnalité.
|
||||
*
|
||||
* ce paramètre n'a d'effet que si $manageTransactions==true
|
||||
*/
|
||||
protected ?int $eachCommitThreshold;
|
||||
|
||||
function getEachCommitThreshold(): ?int {
|
||||
return $this->eachCommitThreshold;
|
||||
}
|
||||
|
||||
function setEachCommitThreshold(?int $eachCommitThreshold=null): self {
|
||||
$this->eachCommitThreshold = self::verifix_eachCommitThreshold($eachCommitThreshold);
|
||||
return $this;
|
||||
}
|
||||
|
||||
/**
|
||||
* initialiser ce channel avant sa première utilisation.
|
||||
*/
|
||||
@ -319,6 +302,40 @@ class CapacitorChannel implements ITransactor {
|
||||
return $sum !== $psum;
|
||||
}
|
||||
|
||||
/**
|
||||
* @var bool indiquer si les modifications de each doivent être gérées dans
|
||||
* une transaction. si false, l'utilisateur doit lui même gérer la
|
||||
* transaction.
|
||||
*/
|
||||
protected bool $manageTransactions;
|
||||
|
||||
function isManageTransactions(): bool {
|
||||
return $this->manageTransactions;
|
||||
}
|
||||
|
||||
function setManageTransactions(bool $manageTransactions=true): self {
|
||||
$this->manageTransactions = $manageTransactions;
|
||||
return $this;
|
||||
}
|
||||
|
||||
/**
|
||||
* @var ?int nombre maximum de modifications dans une transaction avant un
|
||||
* commit automatique dans {@link Capacitor::each()}. Utiliser null pour
|
||||
* désactiver la fonctionnalité.
|
||||
*
|
||||
* ce paramètre n'a d'effet que si $manageTransactions==true
|
||||
*/
|
||||
protected ?int $eachCommitThreshold;
|
||||
|
||||
function getEachCommitThreshold(): ?int {
|
||||
return $this->eachCommitThreshold;
|
||||
}
|
||||
|
||||
function setEachCommitThreshold(?int $eachCommitThreshold=null): self {
|
||||
$this->eachCommitThreshold = self::verifix_eachCommitThreshold($eachCommitThreshold);
|
||||
return $this;
|
||||
}
|
||||
|
||||
/**
|
||||
* méthode appelée lors du chargement avec {@link Capacitor::charge()} pour
|
||||
* créer un nouvel élément
|
||||
@ -400,24 +417,20 @@ class CapacitorChannel implements ITransactor {
|
||||
#############################################################################
|
||||
# Méthodes déléguées pour des workflows centrés sur le channel
|
||||
|
||||
/**
|
||||
* @var Capacitor|null instance de Capacitor par laquelle cette instance est
|
||||
* utilisée
|
||||
*/
|
||||
protected ?Capacitor $capacitor;
|
||||
|
||||
function getCapacitor(): ?Capacitor {
|
||||
return $this->capacitor;
|
||||
}
|
||||
|
||||
function setCapacitor(Capacitor $capacitor): self {
|
||||
$this->capacitor = $capacitor;
|
||||
function initCapacitor(Capacitor $capacitor, bool $autocreate=true): self {
|
||||
if ($this->capacitor === null) $this->capacitor = $capacitor;
|
||||
if ($autocreate) $this->capacitor->autocreate($this);
|
||||
return $this;
|
||||
}
|
||||
|
||||
function initStorage(CapacitorStorage $storage): self {
|
||||
new Capacitor($storage, $this);
|
||||
return $this;
|
||||
function db(): IDatabase {
|
||||
return $this->capacitor->db();
|
||||
}
|
||||
|
||||
function ensureLive(): self {
|
||||
@ -425,52 +438,117 @@ class CapacitorChannel implements ITransactor {
|
||||
return $this;
|
||||
}
|
||||
|
||||
function willUpdate(...$transactors): ITransactor {
|
||||
return $this->capacitor->willUpdate(...$transactors);
|
||||
function getCreateSql(): string {
|
||||
return $this->capacitor->getMigration($this)->getSql(get_class($this), $this->db());
|
||||
}
|
||||
|
||||
/** @var CapacitorChannel[] */
|
||||
protected ?array $subChannels = null;
|
||||
|
||||
protected ?array $subManageTransactions = null;
|
||||
|
||||
function willUpdate(...$channels): self {
|
||||
if ($this->subChannels === null) {
|
||||
# désactiver la gestion des transaction sur le channel local aussi
|
||||
$this->subChannels[] = $this;
|
||||
}
|
||||
if ($channels) {
|
||||
foreach ($channels as $channel) {
|
||||
if ($channel instanceof CapacitorChannel) {
|
||||
$this->subChannels[] = $channel;
|
||||
} else {
|
||||
throw ValueException::invalid_type($channel, CapacitorChannel::class);
|
||||
}
|
||||
}
|
||||
}
|
||||
return $this;
|
||||
}
|
||||
|
||||
function inTransaction(): bool {
|
||||
return $this->capacitor->inTransaction();
|
||||
return $this->db()->inTransaction();
|
||||
}
|
||||
|
||||
function beginTransaction(?callable $func=null, bool $commit=true): void {
|
||||
$this->capacitor->beginTransaction($func, $commit);
|
||||
$db = $this->db();
|
||||
if ($this->subChannels !== null) {
|
||||
# on gère des subchannels: ne débuter la transaction que si ce n'est déjà fait
|
||||
if ($this->subManageTransactions === null) {
|
||||
foreach ($this->subChannels as $channel) {
|
||||
$name = $channel->getName();
|
||||
$this->subManageTransactions ??= [];
|
||||
if (!array_key_exists($name, $this->subManageTransactions)) {
|
||||
$this->subManageTransactions[$name] = $channel->isManageTransactions();
|
||||
}
|
||||
$channel->setManageTransactions(false);
|
||||
}
|
||||
if (!$db->inTransaction()) $db->beginTransaction();
|
||||
}
|
||||
} elseif (!$db->inTransaction()) {
|
||||
$db->beginTransaction();
|
||||
}
|
||||
if ($func !== null) {
|
||||
$commited = false;
|
||||
try {
|
||||
func::call($func, $this);
|
||||
if ($commit) {
|
||||
$this->commit();
|
||||
$commited = true;
|
||||
}
|
||||
} finally {
|
||||
if ($commit && !$commited) $this->rollback();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
protected function beforeEndTransaction(): void {
|
||||
if ($this->subManageTransactions !== null) {
|
||||
foreach ($this->subChannels as $channel) {
|
||||
$name = $channel->getName();
|
||||
$channel->setManageTransactions($this->subManageTransactions[$name]);
|
||||
}
|
||||
$this->subManageTransactions = null;
|
||||
}
|
||||
}
|
||||
|
||||
function commit(): void {
|
||||
$this->capacitor->commit();
|
||||
$this->beforeEndTransaction();
|
||||
$db = $this->db();
|
||||
if ($db->inTransaction()) $db->commit();
|
||||
}
|
||||
|
||||
function rollback(): void {
|
||||
$this->capacitor->rollback();
|
||||
}
|
||||
|
||||
function db(): IDatabase {
|
||||
return $this->capacitor->getStorage()->db();
|
||||
$this->beforeEndTransaction();
|
||||
$db = $this->db();
|
||||
if ($db->inTransaction()) $db->rollback();
|
||||
}
|
||||
|
||||
function exists(): bool {
|
||||
return $this->capacitor->exists();
|
||||
}
|
||||
|
||||
function ensureExists(): void {
|
||||
$this->capacitor->ensureExists();
|
||||
return $this->capacitor->exists($this);
|
||||
}
|
||||
|
||||
function reset(bool $recreate=false): void {
|
||||
$this->capacitor->reset($recreate);
|
||||
$this->capacitor->reset($this, $recreate);
|
||||
}
|
||||
|
||||
function charge($item, $func=null, ?array $args=null, ?array &$row=null): int {
|
||||
return $this->capacitor->charge($item, $func, $args, $row);
|
||||
return $this->capacitor->charge($this, $item, $func, $args, $row);
|
||||
}
|
||||
|
||||
function chargeAll(?iterable $items, $func=null, ?array $args=null): int {
|
||||
return $this->capacitor->chargeAll($items, $func, $args);
|
||||
$count = 0;
|
||||
if ($items !== null) {
|
||||
if ($func !== null) {
|
||||
$func = func::with($func, $args)->bind($this);
|
||||
}
|
||||
foreach ($items as $item) {
|
||||
$count += $this->charge($item, $func);
|
||||
}
|
||||
}
|
||||
return $count;
|
||||
}
|
||||
|
||||
function discharge(bool $reset=true): Traversable {
|
||||
return $this->capacitor->discharge($reset);
|
||||
return $this->capacitor->discharge($this, $reset);
|
||||
}
|
||||
|
||||
/**
|
||||
@ -496,40 +574,50 @@ class CapacitorChannel implements ITransactor {
|
||||
|
||||
function count($filter=null): int {
|
||||
$this->verifixFilter($filter);
|
||||
return $this->capacitor->count($filter);
|
||||
return $this->capacitor->count($this, $filter);
|
||||
}
|
||||
|
||||
function one($filter, ?array $mergeQuery=null): ?array {
|
||||
$this->verifixFilter($filter);
|
||||
return $this->capacitor->one($filter, $mergeQuery);
|
||||
return $this->capacitor->one($this, $filter, $mergeQuery);
|
||||
}
|
||||
|
||||
function all($filter, ?array $mergeQuery=null): Traversable {
|
||||
$this->verifixFilter($filter);
|
||||
return $this->capacitor->all($filter, $mergeQuery);
|
||||
return $this->capacitor->all($this, $filter, $mergeQuery);
|
||||
}
|
||||
|
||||
function each($filter, $func=null, ?array $args=null, ?array $mergeQuery=null, ?int &$nbUpdated=null): int {
|
||||
$this->verifixFilter($filter);
|
||||
return $this->capacitor->each($filter, $func, $args, $mergeQuery, $nbUpdated);
|
||||
return $this->capacitor->each($this, $filter, $func, $args, $mergeQuery, $nbUpdated);
|
||||
}
|
||||
|
||||
function delete($filter, $func=null, ?array $args=null): int {
|
||||
$this->verifixFilter($filter);
|
||||
return $this->capacitor->delete($filter, $func, $args);
|
||||
return $this->capacitor->delete($this, $filter, $func, $args);
|
||||
}
|
||||
|
||||
function dbAll(array $query, ?array $params=null): iterable {
|
||||
return $this->capacitor->dbAll($query, $params);
|
||||
$primaryKeys = $this->getPrimaryKeys();
|
||||
return $this->capacitor->db()->all(cl::merge([
|
||||
"select",
|
||||
"from" => $this->getTableName(),
|
||||
], $query), $params, $primaryKeys);
|
||||
}
|
||||
|
||||
function dbOne(array $query, ?array $params=null): ?array {
|
||||
return $this->capacitor->dbOne($query, $params);
|
||||
return $this->capacitor->db()->one(cl::merge([
|
||||
"select",
|
||||
"from" => $this->getTableName(),
|
||||
], $query), $params);
|
||||
}
|
||||
|
||||
/** @return int|false */
|
||||
function dbUpdate(array $query, ?array $params=null) {
|
||||
return $this->capacitor->dbUpdate($query, $params);
|
||||
return $this->capacitor->db()->exec(cl::merge([
|
||||
"update",
|
||||
"table" => $this->getTableName(),
|
||||
], $query), $params);
|
||||
}
|
||||
|
||||
function close(): void {
|
||||
|
||||
@ -1,770 +0,0 @@
|
||||
<?php
|
||||
namespace nulib\db;
|
||||
|
||||
use nulib\A;
|
||||
use nulib\cl;
|
||||
use nulib\cv;
|
||||
use nulib\db\_private\_migration;
|
||||
use nulib\php\func;
|
||||
use nulib\ValueException;
|
||||
use Traversable;
|
||||
|
||||
/**
|
||||
* Class CapacitorStorage: objet permettant d'accumuler des données pour les
|
||||
* réutiliser plus tard
|
||||
*/
|
||||
abstract class CapacitorStorage {
|
||||
abstract function db(): IDatabase;
|
||||
|
||||
function ensureLive(): self {
|
||||
$this->db()->ensure();
|
||||
return $this;
|
||||
}
|
||||
|
||||
/** @var CapacitorChannel[] */
|
||||
protected $channels;
|
||||
|
||||
function addChannel(CapacitorChannel $channel): CapacitorChannel {
|
||||
$this->_create($channel);
|
||||
$this->channels[$channel->getName()] = $channel;
|
||||
return $channel;
|
||||
}
|
||||
|
||||
protected function getChannel(?string $name): CapacitorChannel {
|
||||
CapacitorChannel::verifix_name($name);
|
||||
$channel = $this->channels[$name] ?? null;
|
||||
if ($channel === null) {
|
||||
$channel = $this->addChannel(new CapacitorChannel($name));
|
||||
}
|
||||
return $channel;
|
||||
}
|
||||
|
||||
const PRIMARY_KEY_DEFINITION = [
|
||||
"id_" => "genserial",
|
||||
];
|
||||
|
||||
# les définitions sont par défaut pour MariaDB/MySQL
|
||||
const SERDATA_DEFINITION = "mediumtext";
|
||||
const SERSUM_DEFINITION = "varchar(40)";
|
||||
const SERTS_DEFINITION = "datetime";
|
||||
const GENSERIAL_DEFINITION = "integer primary key auto_increment";
|
||||
const GENLIC_DEFINITION = "varchar(80)";
|
||||
const GENLIB_DEFINITION = "varchar(255)";
|
||||
const GENTEXT_DEFINITION = "mediumtext";
|
||||
const GENBOOL_DEFINITION = "integer(1) default 0";
|
||||
const GENUUID_DEFINITION = "varchar(36)";
|
||||
|
||||
protected static function gencol($def): string {
|
||||
if (!is_string($def)) $def = strval($def);
|
||||
$def = trim($def);
|
||||
$parts = preg_split('/\s+/', $def, 2);
|
||||
if (count($parts) == 2) {
|
||||
$def = $parts[0];
|
||||
$rest = " $parts[1]";
|
||||
} else {
|
||||
$rest = null;
|
||||
}
|
||||
switch ($def) {
|
||||
case "serdata": $def = static::SERDATA_DEFINITION; break;
|
||||
case "sersum": $def = static::SERSUM_DEFINITION; break;
|
||||
case "serts": $def = static::SERTS_DEFINITION; break;
|
||||
case "genserial": $def = static::GENSERIAL_DEFINITION; break;
|
||||
case "genlic": $def = static::GENLIC_DEFINITION; break;
|
||||
case "genlib": $def = static::GENLIB_DEFINITION; break;
|
||||
case "gentext": $def = static::GENTEXT_DEFINITION; break;
|
||||
case "genbool": $def = static::GENBOOL_DEFINITION; break;
|
||||
case "genuuid": $def = static::GENUUID_DEFINITION; break;
|
||||
}
|
||||
return "$def$rest";
|
||||
}
|
||||
|
||||
const COLUMN_DEFINITIONS = [
|
||||
"item__" => "serdata",
|
||||
"item__sum_" => "sersum",
|
||||
"created_" => "serts",
|
||||
"modified_" => "serts",
|
||||
];
|
||||
|
||||
protected function ColumnDefinitions(CapacitorChannel $channel, bool $ignoreMigrations=false): array {
|
||||
$definitions = [];
|
||||
if ($channel->getPrimaryKeys() === null) {
|
||||
$definitions[] = static::PRIMARY_KEY_DEFINITION;
|
||||
}
|
||||
$definitions[] = $channel->getColumnDefinitions();
|
||||
$definitions[] = static::COLUMN_DEFINITIONS;
|
||||
# forcer les définitions sans clé à la fin (sqlite requière par exemple que
|
||||
# primary key (columns) soit à la fin)
|
||||
$tmp = cl::merge(...$definitions);
|
||||
$definitions = [];
|
||||
$constraints = [];
|
||||
$index = 0;
|
||||
foreach ($tmp as $col => $def) {
|
||||
if ($col === $index) {
|
||||
$index++;
|
||||
if (is_array($def)) {
|
||||
if (!$ignoreMigrations) {
|
||||
$mdefs = $def;
|
||||
$mindex = 0;
|
||||
foreach ($mdefs as $mcol => $mdef) {
|
||||
if ($mcol === $mindex) {
|
||||
$mindex++;
|
||||
} else {
|
||||
if ($mdef) {
|
||||
$definitions[$mcol] = self::gencol($mdef);
|
||||
} else {
|
||||
unset($definitions[$mcol]);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
} else {
|
||||
$constraints[] = $def;
|
||||
}
|
||||
} else {
|
||||
$definitions[$col] = self::gencol($def);
|
||||
}
|
||||
}
|
||||
return cl::merge($definitions, $constraints);
|
||||
}
|
||||
|
||||
protected function getMigration(CapacitorChannel $channel): ?array {
|
||||
return $channel->getMigration($this->db()->getPrefix());
|
||||
}
|
||||
|
||||
/** sérialiser les valeurs qui doivent l'être dans $row */
|
||||
protected function serialize(CapacitorChannel $channel, ?array $row): ?array {
|
||||
if ($row === null) return null;
|
||||
$cols = $this->ColumnDefinitions($channel);
|
||||
$index = 0;
|
||||
$raw = [];
|
||||
foreach (array_keys($cols) as $col) {
|
||||
$key = $col;
|
||||
if ($key === $index) {
|
||||
$index++;
|
||||
} elseif ($channel->isSerialCol($key)) {
|
||||
[$serialCol, $sumCol] = $channel->getSumCols($key);
|
||||
if (array_key_exists($key, $row)) {
|
||||
$sum = $channel->getSum($key, $row[$key]);
|
||||
$raw[$serialCol] = $sum[$serialCol];
|
||||
if (array_key_exists($sumCol, $cols)) {
|
||||
$raw[$sumCol] = $sum[$sumCol];
|
||||
}
|
||||
}
|
||||
} elseif (array_key_exists($key, $row)) {
|
||||
$raw[$col] = $row[$key];
|
||||
}
|
||||
}
|
||||
return $raw;
|
||||
}
|
||||
|
||||
/** désérialiser les valeurs qui doivent l'être dans $values */
|
||||
protected function unserialize(CapacitorChannel $channel, ?array $raw): ?array {
|
||||
if ($raw === null) return null;
|
||||
$cols = $this->ColumnDefinitions($channel);
|
||||
$index = 0;
|
||||
$row = [];
|
||||
foreach (array_keys($cols) as $col) {
|
||||
$key = $col;
|
||||
if ($key === $index) {
|
||||
$index++;
|
||||
} elseif (!array_key_exists($col, $raw)) {
|
||||
} elseif ($channel->isSerialCol($key)) {
|
||||
$value = $raw[$col];
|
||||
if ($value !== null) $value = $channel->unserialize($value);
|
||||
$row[$key] = $value;
|
||||
} else {
|
||||
$row[$key] = $raw[$col];
|
||||
}
|
||||
}
|
||||
return $row;
|
||||
}
|
||||
|
||||
function getPrimaryKeys(CapacitorChannel $channel): array {
|
||||
$primaryKeys = $channel->getPrimaryKeys();
|
||||
if ($primaryKeys === null) $primaryKeys = ["id_"];
|
||||
return $primaryKeys;
|
||||
}
|
||||
|
||||
function getRowIds(CapacitorChannel $channel, ?array $row, ?array &$primaryKeys=null): ?array {
|
||||
$primaryKeys = $this->getPrimaryKeys($channel);
|
||||
$rowIds = cl::select($row, $primaryKeys);
|
||||
if (cl::all_n($rowIds)) return null;
|
||||
else return $rowIds;
|
||||
}
|
||||
|
||||
protected function _createSql(CapacitorChannel $channel): array {
|
||||
return [
|
||||
"create table if not exists",
|
||||
"table" => $channel->getTableName(),
|
||||
"cols" => $this->ColumnDefinitions($channel, true),
|
||||
];
|
||||
}
|
||||
|
||||
abstract protected function tableExists(string $tableName): bool;
|
||||
|
||||
const METADATA_TABLE = "_metadata";
|
||||
const METADATA_COLS = [
|
||||
"name" => "varchar not null primary key",
|
||||
"value" => "varchar",
|
||||
];
|
||||
|
||||
protected function _prepareMetadata(): void {
|
||||
if (!$this->tableExists(static::METADATA_TABLE)) {
|
||||
$db = $this->db();
|
||||
$db->exec([
|
||||
"drop table if exists",
|
||||
"table" => self::CHANNELS_TABLE,
|
||||
]);
|
||||
$db->exec([
|
||||
"drop table if exists",
|
||||
"table" => _migration::MIGRATION_TABLE,
|
||||
]);
|
||||
$db->exec([
|
||||
"create table",
|
||||
"table" => static::METADATA_TABLE,
|
||||
"cols" => static::METADATA_COLS,
|
||||
]);
|
||||
$db->exec([
|
||||
"insert",
|
||||
"into" => static::METADATA_TABLE,
|
||||
"values" => [
|
||||
"name" => "version",
|
||||
"value" => "1",
|
||||
],
|
||||
]);
|
||||
}
|
||||
}
|
||||
|
||||
abstract function _getMigration(CapacitorChannel $channel): _migration;
|
||||
|
||||
const CHANNELS_TABLE = "_channels";
|
||||
const CHANNELS_COLS = [
|
||||
"name" => "varchar not null primary key",
|
||||
"table_name" => "varchar",
|
||||
"class_name" => "varchar",
|
||||
];
|
||||
|
||||
function channelExists(string $name, ?array &$raw=null): bool {
|
||||
$raw = $this->db()->one([
|
||||
"select",
|
||||
"from" => static::CHANNELS_TABLE,
|
||||
"where" => ["name" => $name],
|
||||
]);
|
||||
return $raw !== null;
|
||||
}
|
||||
|
||||
function getChannels(): iterable {
|
||||
return $this->db()->all([
|
||||
"select",
|
||||
"from" => static::CHANNELS_TABLE,
|
||||
]);
|
||||
}
|
||||
|
||||
protected function _createChannelsSql(): array {
|
||||
return [
|
||||
"create table if not exists",
|
||||
"table" => static::CHANNELS_TABLE,
|
||||
"cols" => static::CHANNELS_COLS,
|
||||
];
|
||||
}
|
||||
|
||||
protected function _addToChannelsSql(CapacitorChannel $channel): array {
|
||||
return [
|
||||
"insert",
|
||||
"into" => static::CHANNELS_TABLE,
|
||||
"values" => [
|
||||
"name" => $channel->getName(),
|
||||
"table_name" => $channel->getTableName(),
|
||||
"class_name" => get_class($channel),
|
||||
],
|
||||
];
|
||||
}
|
||||
|
||||
protected function _afterCreate(CapacitorChannel $channel): void {
|
||||
$db = $this->db();
|
||||
$db->exec($this->_createChannelsSql());
|
||||
$db->exec($this->_addToChannelsSql($channel));
|
||||
}
|
||||
|
||||
protected function _create(CapacitorChannel $channel): void {
|
||||
$channel->ensureSetup();
|
||||
if (!$channel->isCreated()) {
|
||||
$this->_prepareMetadata();
|
||||
$this->_getMigration($channel)->migrate($this->db());
|
||||
$this->_afterCreate($channel);
|
||||
$channel->setCreated();
|
||||
}
|
||||
}
|
||||
|
||||
/** tester si le canal spécifié existe */
|
||||
function _exists(CapacitorChannel $channel): bool {
|
||||
return $this->tableExists($channel->getTableName());
|
||||
}
|
||||
|
||||
function exists(?string $channel): bool {
|
||||
return $this->_exists($this->getChannel($channel));
|
||||
}
|
||||
|
||||
/** s'assurer que le canal spécifié existe */
|
||||
function _ensureExists(CapacitorChannel $channel): void {
|
||||
$this->_create($channel);
|
||||
}
|
||||
|
||||
function ensureExists(?string $channel): void {
|
||||
$this->_ensureExists($this->getChannel($channel));
|
||||
}
|
||||
|
||||
protected function _beforeReset(CapacitorChannel $channel): void {
|
||||
$db = $this->db;
|
||||
$name = $channel->getName();
|
||||
$db->exec([
|
||||
"delete",
|
||||
"from" => _migration::MIGRATION_TABLE,
|
||||
"where" => [
|
||||
"channel" => $name,
|
||||
],
|
||||
]);
|
||||
$db->exec([
|
||||
"delete",
|
||||
"from" => static::CHANNELS_TABLE,
|
||||
"where" => [
|
||||
"name" => $name,
|
||||
],
|
||||
]);
|
||||
}
|
||||
|
||||
/** supprimer le canal spécifié */
|
||||
function _reset(CapacitorChannel $channel, bool $recreate=false): void {
|
||||
$this->_beforeReset($channel);
|
||||
$this->db()->exec([
|
||||
"drop table if exists",
|
||||
$channel->getTableName(),
|
||||
]);
|
||||
$channel->setCreated(false);
|
||||
if ($recreate) $this->_ensureExists($channel);
|
||||
}
|
||||
|
||||
function reset(?string $channel, bool $recreate=false): void {
|
||||
$this->_reset($this->getChannel($channel), $recreate);
|
||||
}
|
||||
|
||||
/**
|
||||
* charger une valeur dans le canal
|
||||
*
|
||||
* Après avoir calculé les valeurs des clés supplémentaires
|
||||
* avec {@link CapacitorChannel::getItemValues()}, l'une des deux fonctions
|
||||
* {@link CapacitorChannel::onCreate()} ou {@link CapacitorChannel::onUpdate()}
|
||||
* est appelée en fonction du type d'opération: création ou mise à jour
|
||||
*
|
||||
* Ensuite, si $func !== null, la fonction est appelée avec la signature de
|
||||
* {@link CapacitorChannel::onCreate()} ou {@link CapacitorChannel::onUpdate()}
|
||||
* en fonction du type d'opération: création ou mise à jour
|
||||
*
|
||||
* Dans les deux cas, si la fonction retourne un tableau, il est utilisé pour
|
||||
* modifier les valeurs insérées/mises à jour. De plus, $row obtient la
|
||||
* valeur finale des données insérées/mises à jour
|
||||
*
|
||||
* Si $args est renseigné, il est ajouté aux arguments utilisés pour appeler
|
||||
* les méthodes {@link CapacitorChannel::getItemValues()},
|
||||
* {@link CapacitorChannel::onCreate()} et/ou
|
||||
* {@link CapacitorChannel::onUpdate()}
|
||||
*
|
||||
* @return int 1 si l'objet a été chargé ou mis à jour, 0 s'il existait
|
||||
* déjà à l'identique dans le canal
|
||||
*/
|
||||
function _charge(CapacitorChannel $channel, $item, $func, ?array $args, ?array &$row=null): int {
|
||||
$this->_create($channel);
|
||||
$tableName = $channel->getTableName();
|
||||
$db = $this->db();
|
||||
$args ??= [];
|
||||
|
||||
$row = func::call([$channel, "getItemValues"], $item, ...$args);
|
||||
if ($row === [false]) return 0;
|
||||
|
||||
if ($row !== null && array_key_exists("item", $row)) {
|
||||
$item = A::pop($row, "item");
|
||||
}
|
||||
|
||||
$raw = cl::merge(
|
||||
$channel->getSum("item", $item),
|
||||
$this->serialize($channel, $row));
|
||||
$praw = null;
|
||||
$rowIds = $this->getRowIds($channel, $raw, $primaryKeys);
|
||||
if ($rowIds !== null) {
|
||||
# modification
|
||||
$praw = $db->one([
|
||||
"select",
|
||||
"from" => $tableName,
|
||||
"where" => $rowIds,
|
||||
]);
|
||||
}
|
||||
|
||||
$now = date("Y-m-d H:i:s");
|
||||
$insert = null;
|
||||
if ($praw === null) {
|
||||
# création
|
||||
$raw = cl::merge($raw, [
|
||||
"created_" => $now,
|
||||
"modified_" => $now,
|
||||
]);
|
||||
$insert = true;
|
||||
$initFunc = func::with([$channel, "onCreate"], $args);
|
||||
$row = $this->unserialize($channel, $raw);
|
||||
$prow = null;
|
||||
} else {
|
||||
# modification
|
||||
# intégrer autant que possible les valeurs de praw dans raw, de façon que
|
||||
# l'utilisateur puisse voir clairement ce qui a été modifié
|
||||
if ($channel->_wasSumModified("item", $raw, $praw)) {
|
||||
$insert = false;
|
||||
$raw = cl::merge($praw, $raw, [
|
||||
"modified_" => $now,
|
||||
]);
|
||||
} else {
|
||||
$raw = cl::merge($praw, $raw);
|
||||
}
|
||||
$initFunc = func::with([$channel, "onUpdate"], $args);
|
||||
$row = $this->unserialize($channel, $raw);
|
||||
$prow = $this->unserialize($channel, $praw);
|
||||
}
|
||||
|
||||
$updates = $initFunc->prependArgs([$item, $row, $prow])->invoke();
|
||||
if ($updates === [false]) return 0;
|
||||
if (is_array($updates) && $updates) {
|
||||
if ($insert === null) $insert = false;
|
||||
if (!array_key_exists("modified_", $updates)) {
|
||||
$updates["modified_"] = $now;
|
||||
}
|
||||
$row = cl::merge($row, $updates);
|
||||
$raw = cl::merge($raw, $this->serialize($channel, $updates));
|
||||
}
|
||||
|
||||
if ($func !== null) {
|
||||
$updates = func::with($func, $args)
|
||||
->prependArgs([$item, $row, $prow])
|
||||
->bind($channel)
|
||||
->invoke();
|
||||
if ($updates === [false]) return 0;
|
||||
if (is_array($updates) && $updates) {
|
||||
if ($insert === null) $insert = false;
|
||||
if (!array_key_exists("modified_", $updates)) {
|
||||
$updates["modified_"] = $now;
|
||||
}
|
||||
$row = cl::merge($row, $updates);
|
||||
$raw = cl::merge($raw, $this->serialize($channel, $updates));
|
||||
}
|
||||
}
|
||||
|
||||
# aucune modification
|
||||
if ($insert === null) return 0;
|
||||
|
||||
# si on est déjà dans une transaction, désactiver la gestion des transactions
|
||||
$manageTransactions = $channel->isManageTransactions() && !$db->inTransaction();
|
||||
if ($manageTransactions) {
|
||||
$commited = false;
|
||||
$db->beginTransaction();
|
||||
}
|
||||
$nbModified = 0;
|
||||
try {
|
||||
if ($insert) {
|
||||
$id = $db->exec([
|
||||
"insert",
|
||||
"into" => $tableName,
|
||||
"values" => $raw,
|
||||
]);
|
||||
if (count($primaryKeys) == 1 && $rowIds === null) {
|
||||
# mettre à jour avec l'id généré
|
||||
$row[$primaryKeys[0]] = $id;
|
||||
}
|
||||
$nbModified = 1;
|
||||
} else {
|
||||
# calculer ce qui a changé pour ne mettre à jour que le nécessaire
|
||||
$updates = [];
|
||||
foreach ($raw as $col => $value) {
|
||||
if (array_key_exists($col, $rowIds)) {
|
||||
# ne jamais mettre à jour la clé primaire
|
||||
continue;
|
||||
}
|
||||
if (!cv::equals($value, $praw[$col] ?? null)) {
|
||||
$updates[$col] = $value;
|
||||
}
|
||||
}
|
||||
if (count($updates) == 1 && array_key_first($updates) == "modified_") {
|
||||
# si l'unique modification porte sur la date de modification, alors
|
||||
# la ligne n'est pas modifiée. ce cas se présente quand on altère la
|
||||
# valeur de $item
|
||||
$updates = null;
|
||||
}
|
||||
if ($updates) {
|
||||
$db->exec([
|
||||
"update",
|
||||
"table" => $tableName,
|
||||
"values" => $updates,
|
||||
"where" => $rowIds,
|
||||
]);
|
||||
$nbModified = 1;
|
||||
}
|
||||
}
|
||||
if ($manageTransactions) {
|
||||
$db->commit();
|
||||
$commited = true;
|
||||
}
|
||||
return $nbModified;
|
||||
} finally {
|
||||
if ($manageTransactions && !$commited) $db->rollback();
|
||||
}
|
||||
}
|
||||
|
||||
function charge(?string $channel, $item, $func=null, ?array $args=null, ?array &$row=null): int {
|
||||
return $this->_charge($this->getChannel($channel), $item, $func, $args, $row);
|
||||
}
|
||||
|
||||
/**
|
||||
* décharger les données du canal spécifié. seul la valeur de $item est
|
||||
* fournie
|
||||
*/
|
||||
function _discharge(CapacitorChannel $channel, bool $reset=true): Traversable {
|
||||
$this->_create($channel);
|
||||
$raws = $this->db()->all([
|
||||
"select item__",
|
||||
"from" => $channel->getTableName(),
|
||||
]);
|
||||
foreach ($raws as $raw) {
|
||||
yield unserialize($raw['item__']);
|
||||
}
|
||||
if ($reset) $this->_reset($channel);
|
||||
}
|
||||
|
||||
function discharge(?string $channel, bool $reset=true): Traversable {
|
||||
return $this->_discharge($this->getChannel($channel), $reset);
|
||||
}
|
||||
|
||||
protected function _convertValue2row(CapacitorChannel $channel, array $filter, array $cols): array {
|
||||
$index = 0;
|
||||
$fixed = [];
|
||||
foreach ($filter as $key => $value) {
|
||||
if ($key === $index) {
|
||||
$index++;
|
||||
if (is_array($value)) {
|
||||
$value = $this->_convertValue2row($channel, $value, $cols);
|
||||
}
|
||||
$fixed[] = $value;
|
||||
} else {
|
||||
$col = "${key}__";
|
||||
if (array_key_exists($col, $cols)) {
|
||||
# colonne sérialisée
|
||||
$fixed[$col] = $channel->serialize($value);
|
||||
} else {
|
||||
$fixed[$key] = $value;
|
||||
}
|
||||
}
|
||||
}
|
||||
return $fixed;
|
||||
}
|
||||
|
||||
protected function verifixFilter(CapacitorChannel $channel, &$filter): void {
|
||||
if ($filter !== null && !is_array($filter)) {
|
||||
$primaryKeys = $this->getPrimaryKeys($channel);
|
||||
$id = $filter;
|
||||
$channel->verifixId($id);
|
||||
$filter = [$primaryKeys[0] => $id];
|
||||
}
|
||||
$cols = $this->ColumnDefinitions($channel);
|
||||
if ($filter !== null) {
|
||||
$filter = $this->_convertValue2row($channel, $filter, $cols);
|
||||
}
|
||||
}
|
||||
|
||||
/** indiquer le nombre d'éléments du canal spécifié */
|
||||
function _count(CapacitorChannel $channel, $filter): int {
|
||||
$this->_create($channel);
|
||||
$this->verifixFilter($channel, $filter);
|
||||
return $this->db()->get([
|
||||
"select count(*)",
|
||||
"from" => $channel->getTableName(),
|
||||
"where" => $filter,
|
||||
]);
|
||||
}
|
||||
|
||||
function count(?string $channel, $filter=null): int {
|
||||
return $this->_count($this->getChannel($channel), $filter);
|
||||
}
|
||||
|
||||
/**
|
||||
* obtenir la ligne correspondant au filtre sur le canal spécifié
|
||||
*
|
||||
* si $filter n'est pas un tableau, il est transformé en ["id_" => $filter]
|
||||
*/
|
||||
function _one(CapacitorChannel $channel, $filter, ?array $mergeQuery=null): ?array {
|
||||
if ($filter === null) throw ValueException::null("filter");
|
||||
$this->_create($channel);
|
||||
$this->verifixFilter($channel, $filter);
|
||||
$raw = $this->db()->one(cl::merge([
|
||||
"select",
|
||||
"from" => $channel->getTableName(),
|
||||
"where" => $filter,
|
||||
], $mergeQuery));
|
||||
return $this->unserialize($channel, $raw);
|
||||
}
|
||||
|
||||
function one(?string $channel, $filter, ?array $mergeQuery=null): ?array {
|
||||
return $this->_one($this->getChannel($channel), $filter, $mergeQuery);
|
||||
}
|
||||
|
||||
/**
|
||||
* obtenir les lignes correspondant au filtre sur le canal spécifié
|
||||
*
|
||||
* si $filter n'est pas un tableau, il est transformé en ["id_" => $filter]
|
||||
*/
|
||||
function _all(CapacitorChannel $channel, $filter, ?array $mergeQuery=null): Traversable {
|
||||
$this->_create($channel);
|
||||
$this->verifixFilter($channel, $filter);
|
||||
$raws = $this->db()->all(cl::merge([
|
||||
"select",
|
||||
"from" => $channel->getTableName(),
|
||||
"where" => $filter,
|
||||
], $mergeQuery), null, $this->getPrimaryKeys($channel));
|
||||
foreach ($raws as $key => $raw) {
|
||||
yield $key => $this->unserialize($channel, $raw);
|
||||
}
|
||||
}
|
||||
|
||||
function all(?string $channel, $filter, $mergeQuery=null): Traversable {
|
||||
return $this->_all($this->getChannel($channel), $filter, $mergeQuery);
|
||||
}
|
||||
|
||||
/**
|
||||
* appeler une fonction pour chaque élément du canal spécifié.
|
||||
*
|
||||
* $filter permet de filtrer parmi les élements chargés
|
||||
*
|
||||
* $func est appelé avec la signature de {@link CapacitorChannel::onEach()}
|
||||
* si la fonction retourne un tableau, il est utilisé pour mettre à jour la
|
||||
* ligne
|
||||
*
|
||||
* @param int $nbUpdated reçoit le nombre de lignes mises à jour
|
||||
* @return int le nombre de lignes parcourues
|
||||
*/
|
||||
function _each(CapacitorChannel $channel, $filter, $func, ?array $args, ?array $mergeQuery=null, ?int &$nbUpdated=null): int {
|
||||
$this->_create($channel);
|
||||
if ($func === null) $func = CapacitorChannel::onEach;
|
||||
$onEach = func::with($func)->bind($channel);
|
||||
$db = $this->db();
|
||||
# si on est déjà dans une transaction, désactiver la gestion des transactions
|
||||
$manageTransactions = $channel->isManageTransactions() && !$db->inTransaction();
|
||||
if ($manageTransactions) {
|
||||
$commited = false;
|
||||
$db->beginTransaction();
|
||||
$commitThreshold = $channel->getEachCommitThreshold();
|
||||
}
|
||||
$count = 0;
|
||||
$nbUpdated = 0;
|
||||
$tableName = $channel->getTableName();
|
||||
try {
|
||||
$args ??= [];
|
||||
$rows = $this->_all($channel, $filter, $mergeQuery);
|
||||
foreach ($rows as $row) {
|
||||
$rowIds = $this->getRowIds($channel, $row);
|
||||
$updates = $onEach->invoke([$row, ...$args]);
|
||||
if ($updates === [false]) {
|
||||
break;
|
||||
} elseif ($updates !== null) {
|
||||
if (!array_key_exists("modified_", $updates)) {
|
||||
$updates["modified_"] = date("Y-m-d H:i:s");
|
||||
}
|
||||
$nbUpdated += $db->exec([
|
||||
"update",
|
||||
"table" => $tableName,
|
||||
"values" => $this->serialize($channel, $updates),
|
||||
"where" => $rowIds,
|
||||
]);
|
||||
if ($manageTransactions && $commitThreshold !== null) {
|
||||
$commitThreshold--;
|
||||
if ($commitThreshold <= 0) {
|
||||
$db->commit();
|
||||
$db->beginTransaction();
|
||||
$commitThreshold = $channel->getEachCommitThreshold();
|
||||
}
|
||||
}
|
||||
}
|
||||
$count++;
|
||||
}
|
||||
if ($manageTransactions) {
|
||||
$db->commit();
|
||||
$commited = true;
|
||||
}
|
||||
return $count;
|
||||
} finally {
|
||||
if ($manageTransactions && !$commited) $db->rollback();
|
||||
}
|
||||
}
|
||||
|
||||
function each(?string $channel, $filter, $func=null, ?array $args=null, ?array $mergeQuery=null, ?int &$nbUpdated=null): int {
|
||||
return $this->_each($this->getChannel($channel), $filter, $func, $args, $mergeQuery, $nbUpdated);
|
||||
}
|
||||
|
||||
/**
|
||||
* supprimer tous les éléments correspondant au filtre et pour lesquels la
|
||||
* fonction retourne une valeur vraie si elle est spécifiée
|
||||
*
|
||||
* $filter permet de filtrer parmi les élements chargés
|
||||
*
|
||||
* $func est appelé avec la signature de {@link CapacitorChannel::onDelete()}
|
||||
* si la fonction retourne un tableau, il est utilisé pour mettre à jour la
|
||||
* ligne
|
||||
*
|
||||
* @return int le nombre de lignes parcourues
|
||||
*/
|
||||
function _delete(CapacitorChannel $channel, $filter, $func, ?array $args): int {
|
||||
$this->_create($channel);
|
||||
if ($func === null) $func = CapacitorChannel::onDelete;
|
||||
$onDelete = func::with($func)->bind($channel);
|
||||
$db = $this->db();
|
||||
# si on est déjà dans une transaction, désactiver la gestion des transactions
|
||||
$manageTransactions = $channel->isManageTransactions() && !$db->inTransaction();
|
||||
if ($manageTransactions) {
|
||||
$commited = false;
|
||||
$db->beginTransaction();
|
||||
$commitThreshold = $channel->getEachCommitThreshold();
|
||||
}
|
||||
$count = 0;
|
||||
$tableName = $channel->getTableName();
|
||||
try {
|
||||
$args ??= [];
|
||||
$rows = $this->_all($channel, $filter);
|
||||
foreach ($rows as $row) {
|
||||
$rowIds = $this->getRowIds($channel, $row);
|
||||
$shouldDelete = boolval($onDelete->invoke([$row, ...$args]));
|
||||
if ($shouldDelete) {
|
||||
$db->exec([
|
||||
"delete",
|
||||
"from" => $tableName,
|
||||
"where" => $rowIds,
|
||||
]);
|
||||
if ($manageTransactions && $commitThreshold !== null) {
|
||||
$commitThreshold--;
|
||||
if ($commitThreshold <= 0) {
|
||||
$db->commit();
|
||||
$db->beginTransaction();
|
||||
$commitThreshold = $channel->getEachCommitThreshold();
|
||||
}
|
||||
}
|
||||
}
|
||||
$count++;
|
||||
}
|
||||
if ($manageTransactions) {
|
||||
$db->commit();
|
||||
$commited = true;
|
||||
}
|
||||
return $count;
|
||||
} finally {
|
||||
if ($manageTransactions && !$commited) $db->rollback();
|
||||
}
|
||||
}
|
||||
|
||||
function delete(?string $channel, $filter, $func=null, ?array $args=null): int {
|
||||
return $this->_delete($this->getChannel($channel), $filter, $func, $args);
|
||||
}
|
||||
|
||||
abstract function close(): void;
|
||||
}
|
||||
@ -1,5 +1,11 @@
|
||||
# db
|
||||
|
||||
# db/Capacitor
|
||||
|
||||
La source peut être un iterable
|
||||
|
||||
---
|
||||
|
||||
charge() permet de spécifier la clé associée avec la valeur chargée, et
|
||||
discharge() retourne les valeurs avec la clé primaire
|
||||
|
||||
|
||||
@ -25,14 +25,11 @@ class conds {
|
||||
|
||||
/**
|
||||
* retourner une condition "like" si la valeur s'y prête
|
||||
*
|
||||
* - si la valeur fait moins de $likeThreshold caractères, faire une recherche
|
||||
* exacte en retournant ["=", $value]
|
||||
*
|
||||
*
|
||||
* - les espaces sont remplacés par %
|
||||
*
|
||||
* si $partial
|
||||
* - si $partial et que $value ne contient pas d'espaces, rajouter un % à la
|
||||
* fin
|
||||
*/
|
||||
static function like($value, bool $partial=false, ?int $likeThreshold=null) {
|
||||
if ($value === false || $value === null) return $value;
|
||||
|
||||
@ -3,12 +3,12 @@ namespace nulib\db\mysql;
|
||||
|
||||
use nulib\cl;
|
||||
use nulib\db\CapacitorChannel;
|
||||
use nulib\db\CapacitorStorage;
|
||||
use nulib\db\Capacitor;
|
||||
|
||||
/**
|
||||
* Class MysqlStorage
|
||||
*/
|
||||
class MysqlStorage extends CapacitorStorage {
|
||||
class MysqlCapacitor extends Capacitor {
|
||||
function __construct($mysql) {
|
||||
$this->db = Mysql::with($mysql);
|
||||
}
|
||||
@ -36,21 +36,21 @@ class MysqlStorage extends CapacitorStorage {
|
||||
"value" => "varchar(255)",
|
||||
];
|
||||
|
||||
function _getMigration(CapacitorChannel $channel): _mysqlMigration {
|
||||
function getMigration(CapacitorChannel $channel): _mysqlMigration {
|
||||
$migrations = cl::merge([
|
||||
"0init" => [$this->_createSql($channel)],
|
||||
"0init" => [$this->getCreateChannelSql($channel)],
|
||||
], $channel->getMigration($this->db->getPrefix()));
|
||||
return new _mysqlMigration($migrations, $channel->getName());
|
||||
}
|
||||
|
||||
const CHANNELS_COLS = [
|
||||
const CATALOG_COLS = [
|
||||
"name" => "varchar(255) not null primary key",
|
||||
"table_name" => "varchar(64)",
|
||||
"class_name" => "varchar(255)",
|
||||
];
|
||||
|
||||
protected function _addToChannelsSql(CapacitorChannel $channel): array {
|
||||
return cl::merge(parent::_addToChannelsSql($channel), [
|
||||
protected function addToCatalogSql(CapacitorChannel $channel): array {
|
||||
return cl::merge(parent::addToCatalogSql($channel), [
|
||||
"suffix" => "on duplicate key update name = name",
|
||||
]);
|
||||
}
|
||||
@ -3,16 +3,16 @@ namespace nulib\db\pgsql;
|
||||
|
||||
use nulib\cl;
|
||||
use nulib\db\CapacitorChannel;
|
||||
use nulib\db\CapacitorStorage;
|
||||
use nulib\db\Capacitor;
|
||||
|
||||
class PgsqlStorage extends CapacitorStorage {
|
||||
const SERDATA_DEFINITION = "text";
|
||||
const SERSUM_DEFINITION = "varchar(40)";
|
||||
const SERTS_DEFINITION = "timestamp";
|
||||
const GENSERIAL_DEFINITION = "serial primary key";
|
||||
const GENTEXT_DEFINITION = "text";
|
||||
const GENBOOL_DEFINITION = "boolean default false";
|
||||
const GENUUID_DEFINITION = "uuid";
|
||||
class PgsqlCapacitor extends Capacitor {
|
||||
const CDATA_DEFINITION = "text";
|
||||
const CSUM_DEFINITION = "varchar(40)";
|
||||
const CTIMESTAMP_DEFINITION = "timestamp";
|
||||
const GSERIAL_DEFINITION = "serial primary key";
|
||||
const GTEXT_DEFINITION = "text";
|
||||
const GBOOL_DEFINITION = "boolean default false";
|
||||
const GUUID_DEFINITION = "uuid";
|
||||
|
||||
function __construct($pgsql) {
|
||||
$this->db = Pgsql::with($pgsql);
|
||||
@ -41,15 +41,15 @@ class PgsqlStorage extends CapacitorStorage {
|
||||
return $found !== null;
|
||||
}
|
||||
|
||||
function _getMigration(CapacitorChannel $channel): _pgsqlMigration {
|
||||
function getMigration(CapacitorChannel $channel): _pgsqlMigration {
|
||||
$migrations = cl::merge([
|
||||
"0init" => [$this->_createSql($channel)],
|
||||
"0init" => [$this->getCreateChannelSql($channel)],
|
||||
], $channel->getMigration($this->db->getPrefix()));
|
||||
return new _pgsqlMigration($migrations, $channel->getName());
|
||||
}
|
||||
|
||||
protected function _addToChannelsSql(CapacitorChannel $channel): array {
|
||||
return cl::merge(parent::_addToChannelsSql($channel), [
|
||||
protected function addToCatalogSql(CapacitorChannel $channel): array {
|
||||
return cl::merge(parent::addToCatalogSql($channel), [
|
||||
"suffix" => "on conflict (name) do nothing",
|
||||
]);
|
||||
}
|
||||
@ -3,13 +3,13 @@ namespace nulib\db\sqlite;
|
||||
|
||||
use nulib\cl;
|
||||
use nulib\db\CapacitorChannel;
|
||||
use nulib\db\CapacitorStorage;
|
||||
use nulib\db\Capacitor;
|
||||
|
||||
/**
|
||||
* Class SqliteStorage
|
||||
*/
|
||||
class SqliteStorage extends CapacitorStorage {
|
||||
const GENSERIAL_DEFINITION = "integer primary key autoincrement";
|
||||
class SqliteCapacitor extends Capacitor {
|
||||
const GSERIAL_DEFINITION = "integer primary key autoincrement";
|
||||
|
||||
function __construct($sqlite) {
|
||||
$this->db = Sqlite::with($sqlite);
|
||||
@ -31,30 +31,30 @@ class SqliteStorage extends CapacitorStorage {
|
||||
return $found !== null;
|
||||
}
|
||||
|
||||
function _getMigration(CapacitorChannel $channel): _sqliteMigration {
|
||||
function getMigration(CapacitorChannel $channel): _sqliteMigration {
|
||||
$migrations = cl::merge([
|
||||
"0init" => [$this->_createSql($channel)],
|
||||
"0init" => [$this->getCreateChannelSql($channel)],
|
||||
], $channel->getMigration($this->db->getPrefix()));
|
||||
return new _sqliteMigration($migrations, $channel->getName());
|
||||
}
|
||||
|
||||
protected function _addToChannelsSql(CapacitorChannel $channel): array {
|
||||
$sql = parent::_addToChannelsSql($channel);
|
||||
protected function addToCatalogSql(CapacitorChannel $channel): array {
|
||||
$sql = parent::addToCatalogSql($channel);
|
||||
$sql[0] = "insert or ignore";
|
||||
return $sql;
|
||||
}
|
||||
|
||||
protected function _afterCreate(CapacitorChannel $channel): void {
|
||||
protected function afterCreate(CapacitorChannel $channel): void {
|
||||
$db = $this->db;
|
||||
if (!$this->tableExists(static::CHANNELS_TABLE)) {
|
||||
if (!$this->tableExists(static::CATALOG_TABLE)) {
|
||||
# ne pas créer si la table existe déjà, pour éviter d'avoir besoin d'un
|
||||
# verrou en écriture
|
||||
$db->exec($this->_createChannelsSql());
|
||||
$db->exec($this->getCreateCatalogSql());
|
||||
}
|
||||
if (!$this->channelExists($channel->getName())) {
|
||||
if (!$this->isInCatalog(["name" => $channel->getName()])) {
|
||||
# ne pas insérer si la ligne existe déjà, pour éviter d'avoir besoin d'un
|
||||
# verrou en écriture
|
||||
$db->exec($this->_addToChannelsSql($channel));
|
||||
$db->exec($this->addToCatalogSql($channel));
|
||||
}
|
||||
}
|
||||
|
||||
@ -5,7 +5,7 @@ use nulib\cl;
|
||||
use nulib\db\Capacitor;
|
||||
use nulib\db\CapacitorChannel;
|
||||
use nulib\db\mysql\Mysql;
|
||||
use nulib\db\mysql\MysqlStorage;
|
||||
use nulib\db\mysql\MysqlCapacitor;
|
||||
use nulib\output\msg;
|
||||
use nulib\output\std\StdMessenger;
|
||||
|
||||
@ -35,7 +35,7 @@ class MyChannel extends CapacitorChannel {
|
||||
}
|
||||
}
|
||||
|
||||
new Capacitor(new MysqlStorage($db), $channel = new MyChannel());
|
||||
new Capacitor(new MysqlCapacitor($db), $channel = new MyChannel());
|
||||
|
||||
$channel->charge("hello world");
|
||||
$channel->charge(["bonjour monde"]);
|
||||
|
||||
@ -5,7 +5,7 @@ use nulib\cl;
|
||||
use nulib\db\Capacitor;
|
||||
use nulib\db\CapacitorChannel;
|
||||
use nulib\db\pgsql\Pgsql;
|
||||
use nulib\db\pgsql\PgsqlStorage;
|
||||
use nulib\db\pgsql\PgsqlCapacitor;
|
||||
|
||||
$db = new Pgsql([
|
||||
"host" => "pegase-dre.self",
|
||||
@ -34,7 +34,7 @@ class MyChannel extends CapacitorChannel {
|
||||
}
|
||||
}
|
||||
|
||||
new Capacitor(new PgsqlStorage($db), $channel = new MyChannel());
|
||||
new Capacitor(new PgsqlCapacitor($db), $channel = new MyChannel());
|
||||
|
||||
$channel->charge("hello world");
|
||||
$channel->charge(["bonjour monde"]);
|
||||
|
||||
@ -5,7 +5,7 @@ use nulib\cl;
|
||||
use nulib\db\Capacitor;
|
||||
use nulib\db\CapacitorChannel;
|
||||
use nulib\db\sqlite\Sqlite;
|
||||
use nulib\db\sqlite\SqliteStorage;
|
||||
use nulib\db\sqlite\SqliteCapacitor;
|
||||
|
||||
$db = new Sqlite(__DIR__.'/test_sqlite.db');
|
||||
|
||||
@ -27,7 +27,7 @@ class MyChannel extends CapacitorChannel {
|
||||
}
|
||||
}
|
||||
|
||||
new Capacitor(new SqliteStorage($db), $channel = new MyChannel());
|
||||
new Capacitor(new SqliteCapacitor($db), $channel = new MyChannel());
|
||||
|
||||
$channel->charge("hello world");
|
||||
$channel->charge(["bonjour monde"]);
|
||||
|
||||
@ -30,23 +30,23 @@ class ChannelMigrationTest extends TestCase {
|
||||
}
|
||||
|
||||
function testMigration() {
|
||||
$storage = new SqliteStorage(__DIR__.'/capacitor.db');
|
||||
$capacitor = new SqliteCapacitor(__DIR__.'/capacitor.db');
|
||||
$data = [
|
||||
["first", "premier", new DateTime(), new DateTime(), 15],
|
||||
["second", "deuxieme", new DateTime(), new DateTime(), 15],
|
||||
];
|
||||
|
||||
new Capacitor($storage, $channel = new MyChannel());
|
||||
$capacitor->newChannel($channel = new MyChannel());
|
||||
$channel->reset(true);
|
||||
$this->addData($channel, $data);
|
||||
|
||||
new Capacitor($storage, $channel = new MyChannelV2());
|
||||
$capacitor->newChannel($channel = new MyChannelV2());
|
||||
$this->addData($channel, $data);
|
||||
|
||||
new Capacitor($storage, $channel = new MyChannelV3());
|
||||
$capacitor->newChannel($channel = new MyChannelV3());
|
||||
$this->addData($channel, $data);
|
||||
|
||||
$sql = $channel->getCapacitor()->getCreateSql();
|
||||
$sql = $channel->getCreateSql();
|
||||
$class = MyChannelV3::class;
|
||||
$expected = <<<EOT
|
||||
-- -*- coding: utf-8 mode: sql -*- vim:sw=4:sts=4:et:ai:si:sta:fenc=utf-8
|
||||
@ -75,17 +75,17 @@ EOT;
|
||||
}
|
||||
|
||||
function testMigrationIndex() {
|
||||
$storage = new SqliteStorage(__DIR__.'/capacitor.db');
|
||||
$capacitor = new SqliteCapacitor(__DIR__.'/capacitor.db');
|
||||
$data = [
|
||||
["un", "premier", "first"],
|
||||
["deux", "deuxieme", "second"],
|
||||
];
|
||||
|
||||
new Capacitor($storage, $channel = new MyIndexChannel());
|
||||
$capacitor->newChannel($channel = new MyIndexChannel());
|
||||
$channel->reset(true);
|
||||
$channel->chargeAll($data);
|
||||
|
||||
$sql = $channel->getCapacitor()->getCreateSql();
|
||||
$sql = $channel->getCreateSql();
|
||||
$class = MyIndexChannel::class;
|
||||
$expected = <<<EOT
|
||||
-- -*- coding: utf-8 mode: sql -*- vim:sw=4:sts=4:et:ai:si:sta:fenc=utf-8
|
||||
|
||||
@ -6,38 +6,48 @@ use nulib\cl;
|
||||
use nulib\db\Capacitor;
|
||||
use nulib\db\CapacitorChannel;
|
||||
|
||||
class SqliteStorageTest extends TestCase {
|
||||
class SqliteCapacitorTest extends TestCase {
|
||||
static function Txx(...$values): void {
|
||||
foreach ($values as $value) {
|
||||
var_export($value);
|
||||
}
|
||||
}
|
||||
|
||||
function _testChargeStrings(SqliteStorage $storage, ?string $channel) {
|
||||
$storage->reset($channel);
|
||||
$storage->charge($channel, "first");
|
||||
$storage->charge($channel, "second");
|
||||
$storage->charge($channel, "third");
|
||||
$items = cl::all($storage->discharge($channel, false));
|
||||
function _testChargeStrings(SqliteCapacitor $capacitor, CapacitorChannel $channel) {
|
||||
$capacitor->reset($channel);
|
||||
$capacitor->charge($channel, "first");
|
||||
$capacitor->charge($channel, "second");
|
||||
$capacitor->charge($channel, "third");
|
||||
$items = cl::all($capacitor->discharge($channel, false));
|
||||
self::assertSame(["first", "second", "third"], $items);
|
||||
}
|
||||
|
||||
function _testChargeArrays(SqliteStorage $storage, ?string $channel) {
|
||||
$storage->reset($channel);
|
||||
$storage->charge($channel, ["id" => 10, "name" => "first"]);
|
||||
$storage->charge($channel, ["name" => "second", "id" => 20]);
|
||||
$storage->charge($channel, ["name" => "third", "id" => "30"]);
|
||||
function _testChargeArrays(SqliteCapacitor $capacitor, CapacitorChannel $channel) {
|
||||
$capacitor->reset($channel);
|
||||
$capacitor->charge($channel, ["id" => 10, "name" => "first"]);
|
||||
$capacitor->charge($channel, ["name" => "second", "id" => 20]);
|
||||
$capacitor->charge($channel, ["name" => "third", "id" => "30"]);
|
||||
}
|
||||
|
||||
function testChargeStrings() {
|
||||
$storage = new SqliteStorage(__DIR__.'/capacitor.db');
|
||||
$this->_testChargeStrings($storage, null);
|
||||
$storage->close();
|
||||
$capacitor = new SqliteCapacitor(__DIR__.'/capacitor.db');
|
||||
|
||||
$channel = $capacitor->newChannel(null);
|
||||
$this->_testChargeStrings($capacitor, $channel);
|
||||
self::Txx(cl::all($capacitor->discharge($channel, false)));
|
||||
|
||||
$channel = $capacitor->newChannel("strings");
|
||||
$this->_testChargeStrings($capacitor, $channel);
|
||||
self::Txx(cl::all($capacitor->discharge($channel, false)));
|
||||
|
||||
$capacitor->close();
|
||||
self::assertTrue(true);
|
||||
}
|
||||
|
||||
function testChargeArrays() {
|
||||
$storage = new SqliteStorage(__DIR__.'/capacitor.db');
|
||||
$storage->addChannel(new class extends CapacitorChannel {
|
||||
$capacitor = new SqliteCapacitor(__DIR__.'/capacitor.db');
|
||||
|
||||
$channel = $capacitor->newChannel(new class extends CapacitorChannel {
|
||||
const NAME = "arrays";
|
||||
const COLUMN_DEFINITIONS = ["id" => "integer"];
|
||||
|
||||
@ -45,15 +55,16 @@ class SqliteStorageTest extends TestCase {
|
||||
return ["id" => $item["id"] ?? null];
|
||||
}
|
||||
});
|
||||
$this->_testChargeArrays($capacitor, $channel);
|
||||
self::Txx(cl::all($capacitor->discharge($channel, false)));
|
||||
|
||||
$this->_testChargeStrings($storage, "strings");
|
||||
$this->_testChargeArrays($storage, "arrays");
|
||||
$storage->close();
|
||||
$capacitor->close();
|
||||
self::assertTrue(true);
|
||||
}
|
||||
|
||||
function testEach() {
|
||||
$storage = new SqliteStorage(__DIR__.'/capacitor.db');
|
||||
$capacitor = new Capacitor($storage, new class extends CapacitorChannel {
|
||||
$capacitor = new SqliteCapacitor(__DIR__.'/capacitor.db');
|
||||
$each = $capacitor->newChannel(new class extends CapacitorChannel {
|
||||
const NAME = "each";
|
||||
const COLUMN_DEFINITIONS = [
|
||||
"age" => "integer",
|
||||
@ -67,11 +78,11 @@ class SqliteStorageTest extends TestCase {
|
||||
}
|
||||
});
|
||||
|
||||
$capacitor->reset();
|
||||
$capacitor->charge(["name" => "first", "age" => 5]);
|
||||
$capacitor->charge(["name" => "second", "age" => 10]);
|
||||
$capacitor->charge(["name" => "third", "age" => 15]);
|
||||
$capacitor->charge(["name" => "fourth", "age" => 20]);
|
||||
$capacitor->reset($each);
|
||||
$capacitor->charge($each, ["name" => "first", "age" => 5]);
|
||||
$capacitor->charge($each, ["name" => "second", "age" => 10]);
|
||||
$capacitor->charge($each, ["name" => "third", "age" => 15]);
|
||||
$capacitor->charge($each, ["name" => "fourth", "age" => 20]);
|
||||
|
||||
$setDone = function ($row, $suffix=null) {
|
||||
$item = $row["item"];
|
||||
@ -82,17 +93,18 @@ class SqliteStorageTest extends TestCase {
|
||||
}
|
||||
return $updates;
|
||||
};
|
||||
$capacitor->each(["age" => [">", 10]], $setDone, ["++"]);
|
||||
$capacitor->each(["done" => 0], $setDone);
|
||||
$capacitor->each($each, ["age" => [">", 10]], $setDone, ["++"]);
|
||||
$capacitor->each($each, ["done" => 0], $setDone);
|
||||
|
||||
self::Txx(cl::all($capacitor->discharge($each, false)));
|
||||
|
||||
self::Txx(cl::all($capacitor->discharge(false)));
|
||||
$capacitor->close();
|
||||
self::assertTrue(true);
|
||||
}
|
||||
|
||||
function testPrimayKey() {
|
||||
$storage = new SqliteStorage(__DIR__.'/capacitor.db');
|
||||
$capacitor = new Capacitor($storage, new class extends CapacitorChannel {
|
||||
$capacitor = new SqliteCapacitor(__DIR__.'/capacitor.db');
|
||||
$channel = $capacitor->newChannel(new class extends CapacitorChannel {
|
||||
const NAME = "pk";
|
||||
const COLUMN_DEFINITIONS = [
|
||||
"id_" => "varchar primary key",
|
||||
@ -106,21 +118,23 @@ class SqliteStorageTest extends TestCase {
|
||||
}
|
||||
});
|
||||
|
||||
$capacitor->charge(["numero" => "a", "name" => "first", "age" => 5]);
|
||||
$capacitor->charge(["numero" => "b", "name" => "second", "age" => 10]);
|
||||
$capacitor->charge(["numero" => "c", "name" => "third", "age" => 15]);
|
||||
$capacitor->charge(["numero" => "d", "name" => "fourth", "age" => 20]);
|
||||
$capacitor->charge($channel, ["numero" => "a", "name" => "first", "age" => 5]);
|
||||
$capacitor->charge($channel, ["numero" => "b", "name" => "second", "age" => 10]);
|
||||
$capacitor->charge($channel, ["numero" => "c", "name" => "third", "age" => 15]);
|
||||
$capacitor->charge($channel, ["numero" => "d", "name" => "fourth", "age" => 20]);
|
||||
sleep(2);
|
||||
$capacitor->charge(["numero" => "b", "name" => "second", "age" => 100]);
|
||||
$capacitor->charge(["numero" => "d", "name" => "fourth", "age" => 200]);
|
||||
$capacitor->charge($channel, ["numero" => "b", "name" => "second", "age" => 100]);
|
||||
$capacitor->charge($channel, ["numero" => "d", "name" => "fourth", "age" => 200]);
|
||||
|
||||
self::Txx(cl::all($capacitor->discharge($channel, false)));
|
||||
|
||||
$capacitor->close();
|
||||
self::assertTrue(true);
|
||||
}
|
||||
|
||||
function testSum() {
|
||||
$storage = new SqliteStorage(__DIR__.'/capacitor.db');
|
||||
$capacitor = new Capacitor($storage, new class extends CapacitorChannel {
|
||||
$capacitor = new SqliteCapacitor(__DIR__.'/capacitor.db');
|
||||
$channel = $capacitor->newChannel(new class extends CapacitorChannel {
|
||||
const NAME = "sum";
|
||||
const COLUMN_DEFINITIONS = [
|
||||
"a__" => "varchar",
|
||||
@ -136,19 +150,17 @@ class SqliteStorageTest extends TestCase {
|
||||
}
|
||||
});
|
||||
|
||||
$capacitor->reset();
|
||||
$capacitor->charge(["a" => null, "b" => null]);
|
||||
$capacitor->charge(["a" => "first", "b" => "second"]);
|
||||
$capacitor->reset($channel);
|
||||
$capacitor->charge($channel, ["a" => null, "b" => null]);
|
||||
$capacitor->charge($channel, ["a" => "first", "b" => "second"]);
|
||||
|
||||
self::Txx("=== all");
|
||||
/** @var Sqlite $sqlite */
|
||||
$sqlite = $capacitor->getStorage()->db();
|
||||
self::Txx(cl::all($sqlite->all([
|
||||
self::Txx(cl::all($capacitor->db()->all([
|
||||
"select",
|
||||
"from" => $capacitor->getChannel()->getTableName(),
|
||||
"from" => $channel->getTableName(),
|
||||
])));
|
||||
self::Txx("=== each");
|
||||
$capacitor->each(null, function ($row) {
|
||||
$capacitor->each($channel, null, function ($row) {
|
||||
self::Txx($row);
|
||||
});
|
||||
|
||||
@ -158,8 +170,8 @@ class SqliteStorageTest extends TestCase {
|
||||
|
||||
function testEachValues() {
|
||||
# tester que values contient bien toutes les valeurs de la ligne
|
||||
$storage = new SqliteStorage(__DIR__.'/capacitor.db');
|
||||
$capacitor = new Capacitor($storage, new class extends CapacitorChannel {
|
||||
$capacitor = new SqliteCapacitor(__DIR__.'/capacitor.db');
|
||||
$channel = $capacitor->newChannel(new class extends CapacitorChannel {
|
||||
const NAME = "each_values";
|
||||
const COLUMN_DEFINITIONS = [
|
||||
"name" => "varchar primary key",
|
||||
@ -176,8 +188,8 @@ class SqliteStorageTest extends TestCase {
|
||||
}
|
||||
});
|
||||
|
||||
$capacitor->reset();
|
||||
$capacitor->charge(["name" => "first", "age" => 5], function($item, ?array $row, ?array $prow) {
|
||||
$capacitor->reset($channel);
|
||||
$capacitor->charge($channel, ["name" => "first", "age" => 5], function($item, ?array $row, ?array $prow) {
|
||||
self::assertSame("first", $item["name"]);
|
||||
self::assertSame(5, $item["age"]);
|
||||
self::assertnotnull($row);
|
||||
@ -189,7 +201,7 @@ class SqliteStorageTest extends TestCase {
|
||||
], cl::select($row, ["name", "age", "item"]));
|
||||
self::assertNull($prow);
|
||||
});
|
||||
$capacitor->charge(["name" => "first", "age" => 10], function($item, ?array $row, ?array $prow) {
|
||||
$capacitor->charge($channel, ["name" => "first", "age" => 10], function($item, ?array $row, ?array $prow) {
|
||||
self::assertSame("first", $item["name"]);
|
||||
self::assertSame(10, $item["age"]);
|
||||
self::assertnotnull($row);
|
||||
@ -211,7 +223,7 @@ class SqliteStorageTest extends TestCase {
|
||||
], cl::select($prow, ["name", "age", "done", "notes", "item"]));
|
||||
});
|
||||
|
||||
$capacitor->each(null, function(array $row) {
|
||||
$capacitor->each($channel, null, function(array $row) {
|
||||
$item = $row["item"];
|
||||
self::assertSame("first", $item["name"]);
|
||||
self::assertSame(10, $item["age"]);
|
||||
@ -229,7 +241,7 @@ class SqliteStorageTest extends TestCase {
|
||||
"notes" => "modified",
|
||||
];
|
||||
});
|
||||
$capacitor->charge(["name" => "first", "age" => 10], function($item, ?array $row, ?array $prow) {
|
||||
$capacitor->charge($channel, ["name" => "first", "age" => 10], function($item, ?array $row, ?array $prow) {
|
||||
self::assertSame("first", $item["name"]);
|
||||
self::assertSame(10, $item["age"]);
|
||||
self::assertnotnull($row);
|
||||
@ -251,7 +263,7 @@ class SqliteStorageTest extends TestCase {
|
||||
], cl::select($prow, ["name", "age", "done", "notes", "item"]));
|
||||
});
|
||||
|
||||
$capacitor->charge(["name" => "first", "age" => 20], function($item, ?array $row, ?array $prow) {
|
||||
$capacitor->charge($channel, ["name" => "first", "age" => 20], function($item, ?array $row, ?array $prow) {
|
||||
self::assertSame("first", $item["name"]);
|
||||
self::assertSame(20, $item["age"]);
|
||||
self::assertnotnull($row);
|
||||
@ -276,8 +288,8 @@ class SqliteStorageTest extends TestCase {
|
||||
|
||||
function testSetItemNull() {
|
||||
# tester le forçage de $îtem à null pour économiser la place
|
||||
$storage = new SqliteStorage(__DIR__.'/capacitor.db');
|
||||
$capacitor = new Capacitor($storage, new class extends CapacitorChannel {
|
||||
$capacitor = new SqliteCapacitor(__DIR__.'/capacitor.db');
|
||||
$channel = $capacitor->newChannel(new class extends CapacitorChannel {
|
||||
const NAME = "set_item_null";
|
||||
const COLUMN_DEFINITIONS = [
|
||||
"name" => "varchar primary key",
|
||||
@ -294,8 +306,8 @@ class SqliteStorageTest extends TestCase {
|
||||
}
|
||||
});
|
||||
|
||||
$capacitor->reset();
|
||||
$nbModified = $capacitor->charge(["name" => "first", "age" => 5], function ($item, ?array $row, ?array $prow) {
|
||||
$capacitor->reset($channel);
|
||||
$nbModified = $capacitor->charge($channel, ["name" => "first", "age" => 5], function ($item, ?array $row, ?array $prow) {
|
||||
self::assertSame([
|
||||
"name" => "first", "age" => 5,
|
||||
"item" => $item,
|
||||
@ -306,7 +318,7 @@ class SqliteStorageTest extends TestCase {
|
||||
sleep(1);
|
||||
# nb: on met des sleep() pour que la date de modification soit systématiquement différente
|
||||
|
||||
$nbModified = $capacitor->charge(["name" => "first", "age" => 10], function ($item, ?array $row, ?array $prow) {
|
||||
$nbModified = $capacitor->charge($channel, ["name" => "first", "age" => 10], function ($item, ?array $row, ?array $prow) {
|
||||
self::assertSame([
|
||||
"name" => "first", "age" => 10,
|
||||
"item" => $item, "item__sum_" => "9181336dfca20c86313d6065d89aa2ad5070b0fc",
|
||||
@ -321,7 +333,7 @@ class SqliteStorageTest extends TestCase {
|
||||
sleep(1);
|
||||
|
||||
# pas de modification ici
|
||||
$nbModified = $capacitor->charge(["name" => "first", "age" => 10], function ($item, ?array $row, ?array $prow) {
|
||||
$nbModified = $capacitor->charge($channel, ["name" => "first", "age" => 10], function ($item, ?array $row, ?array $prow) {
|
||||
self::assertSame([
|
||||
"name" => "first", "age" => 10,
|
||||
"item" => $item, "item__sum_" => "9181336dfca20c86313d6065d89aa2ad5070b0fc",
|
||||
@ -335,7 +347,7 @@ class SqliteStorageTest extends TestCase {
|
||||
self::assertSame(0, $nbModified);
|
||||
sleep(1);
|
||||
|
||||
$nbModified = $capacitor->charge(["name" => "first", "age" => 20], function ($item, ?array $row, ?array $prow) {
|
||||
$nbModified = $capacitor->charge($channel, ["name" => "first", "age" => 20], function ($item, ?array $row, ?array $prow) {
|
||||
self::assertSame([
|
||||
"name" => "first", "age" => 20,
|
||||
"item" => $item, "item__sum_" => "001b91982b4e0883b75428c0eb28573a5dc5f7a5",
|
||||
Loading…
x
Reference in New Issue
Block a user