Manuel de référence

# La base de données

Ce chapitre décrit les principales tables utilisées dans la base de données. Il décrit le stockage des Smart Elements, des fichiers, des droits, des comptes et des applications.

# Accès à la base de données

L'accès à la base de données est défini à l'aide d'un service Postgresql.
Les coordonnées du service sont obtenues avec la fonction getDbAccess().

<?php
use Anakeen\Core\DbManager;

$dbAccess = DbManager::getDbAccess();
printf("Database [%s]\n", $dbAccess);
  • Résultat:

Database [service='platform']

L'accès est réalisé avec la fonction PHP pg_connect. Une seule connexion est utilisée par requête. Tous les accès à la base de données utilisent la même ressource pour une même requête.

Cette ressource partagée est fournie par la méthode DbManager::getDbid().

<?php
use Anakeen\Core\DbManager;

$pgResource = DbManager::getDbid();
pg_query($pgResource, "select title from docfam where id = '1'");

Les classes héritées de DbObj, notamment la classe SmartElement, utilisent une abstraction qui permet de gérer l'accès et l'enregistrement des données en base.
L'accès à la base de données de manière explicite est à réserver pour des besoins spécifiques. La manipulation des Smart Elements et autres objets de Anakeen Platform doit être faite à travers leurs classes PHP respectives.

Pour des besoins plus particulier, la méthode DbManager::query() permet d'interroger la base de données en simplifiant l'accès et le contrôle d'erreur.

# La méthode DbManager::query()

Cette fonction permet d'envoyer une requête sur la base de données.

# Description

namespace Anakeen\Core;
class DbManager {
 /**
     * send simple query to database
     *
     * @param string            $query        sql query
     * @param string|bool|array &$result      query result
     * @param bool              $singlecolumn set to true if only one field is return
     * @param bool              $singleresult set to true is only one row is expected (return the first row).
     *                          If is combined with singlecolumn return the value not an array, if no
     *                          results and $singlecolumn is true then $results is false
     *
     * @throws \Anakeen\Database\Exception
     * @return void
     */
    public static function query($query, &$result = array(), $singlecolumn = false, $singleresult = false)
}

Cette fonction permet de récupérer facilement les données directement depuis la base de données.

Avertissements

La requête est exécutée directement. Il est de la responsabilité du développeur de s'assurer de la validité de la requête et d'éviter les injections.

# Liste des paramètres

  • query (string)

    La requête SQL à exécuter.

  • result (array|string|bool)

    La forme du résultat dépend des paramètres singlecolumn et singleresult:

    • singlecolumn = false et singleresult = false
      • Le résultat est un tableau à deux dimensions,
      • Chaque rangée de premier niveau contient un tableau indexé avec les noms des colonnes retournées,
      • Si aucun résultat pour la requête n'est trouvé, le résultat est un tableau vide.
    • singlecolumn = false et singleresult = true
      • Le résultat est un tableau indexé,
      • L'index correspond aux noms des colonnes retournées,
      • Si aucun résultat pour la requête n'est trouvé, le résultat est un tableau vide.
    • singlecolumn = true et singleresult = false
      • Le résultat est un tableau,
      • Chaque élément du tableau contient la valeur de la première colonne du select,
      • Si aucun résultat pour la requête n'est trouvé, le résultat est un tableau vide.
    • singlecolumn = true et singleresult = true
      • Le résultat est une chaîne de caractères,
      • Contient la valeur de la première colonne du premier résultat trouvé,
      • Si aucun résultat pour la requête n'est trouvé, la valeur retournée est false.
  • singlecolumn (bool)

    Mettre à true si une seule colonne doit être retournée.

  • singleresult (bool)

    Mettre à true si un seul résultat doit être retourné.

# Valeur de retour

Aucune.

# Erreurs/Exceptions

Une exception Anakeen\Database\Exception est déclenchée si la requête échoue,

# Exemples

# Requête générale

  • Récupération des identifiants login des 3 premiers comptes trouvés.
<?php
use Anakeen\Core\DbManager;
$sql = sprintf("SELECT id, login FROM users LIMIT 3");
DbManager::query($sql, $result);
print_r($result);
  • Résultat:
Array(
    [0] => Array(
        [id] => 3
        [login] => anonymous
    )
    [1] => Array(
        [id] => 41
        [login] => cpl
    )
    [2]=>Array(
        [id] => 1351
        [login] => john.doe
    )
)

# Requête un seul résultat et plusieurs colonnes

  • Récupérer le login et l'adresse de courriel de l'utilisateur n°1351
<?php
use Anakeen\Core\DbManager;
$idUser = 1351;
$sql = sprintf("SELECT login, mail FROM users WHERE id=%d", $idUser);
DbManager::query($sql, $results, false, true);
print_r($results);
  • Résultat
Array(
    [login] => john.doe
    [mail] => flneau@sfr.fr
)

# Requête plusieurs résultats et une seule colonne

  • Récupération des références des groupes d'utilisateurs:
<?php
use Anakeen\Core\DbManager;
$sql = sprintf("SELECT login FROM users WHERE accounttype='G'");
DbManager::query($sql, $results, true, false);
print_r($results);
  • Résultat
Array
(
    [0] => all
    [1] => gadmin
    [2] => security
    [3] => care
)

# Description des tables de Smart Elements

# La table SmartElement

Toutes les informations des Smart Elements sont enregistrées dans les tables héritées de la table SmartElement.
La table SmartElement définit les propriétés des Smart Elements; c'est à dire tout ce qui est commun à tout type de Smart Element.

Colonne Type Définition
allocated integer Identifiant système de l'utilisateur auquel le Smart Element est affecté
atags text Balises applicatives
cdate timestamp without time zone Date de création de la révision
mdate timestamp without time zone Date de la dernière modification du Smart Element ( de la dernière révision)
classname text Nom de la classe PHP associé au Smart Element
confidential integer Indique si le Smart Element est confidentiel (>0)
cvid integer Identifiant du Smart Element contrôle de vue associé à ce Smart Element
doctype character(1) Type de Smart Element
dprofid integer Identifiant du profil dynamique associé à ce Smart Element
fromid integer Identifiant de la Smart Structure d'appartenance
id integer Identifiant unique du Smart Element
icon text Référence au fichier icône du Smart Element
initid integer Identifiant du premier Smart Element de la lignée de Smart Elements
lmodify character(1) Tag de modification
locked integer Indique l'identifiant système de l'utilisateur qui a verrouillé le Smart Element
name text Nom logique du Smart Element
owner integer Identifiant système de l'utilisateur ayant créé le Smart Element
postitid text Identifiant du Smart Element post-it associé
prelid integer Identifiant du Smart Element (dossier) de relation primaire
profid integer Identifiant du profil de Smart Element
revision integer Numéro d'ordre du Smart Element dans sa lignée de Smart Elements
state text Étape du Smart Element
title character varying (256) Titre du Smart Element
usefor text Type d'utilisation du Smart Element
version text Libellé de la version: vide par défaut
views integer[] Liste des identifiants de comptes qui ont accès au Smart Element
wid integer Identifiant du Smart Element cycle de vie associé à ce Smart Element
fallid integer Identifiant de la liste des accès aux Smart Fields
ldapdn text Nom utilisé pour LDAP

# Les tables des Smart Elements

Pour chacune des Smart Structures enregistrées, une table associée est créée. Cette table est nommée doc<famid> où famid est l'identifiant numérique de la Smart Structure.
Une même Smart Structure peut avoir un nom de table différent sur différentes installations suivant l'identifiant qui lui a été attribué au moment de la création. De même, si la Smart Structure est détruite, une nouvelle table avec un nom différent lui est attribuée.

Exemple:

Héritage des tables de Smart Elements
Héritage des tables de Smart Elements

Les tables de Smart Elements sont créées avec le schéma public. Pour chacune des Smart Structures, une vue est créée avec le nom logique de la Smart Structure en même temps que la table réelle. Toutes les vues de Smart Elements sont créées sous le schéma family.

SELECT * FROM public.doc1098;
-- équivalent à
SELECT * FROM family.mySmartStructure;

Important

Ces vues ne sont utilisables qu'en lecture seule. A partir de postgresql 9.3, ces vues sont utilisables en mise à jour.

Note

Les noms des tables en postgresql ne sont pas sensibles à la casse.

La table de Smart Element doc propre ne comprend aucune donnée.

SELECT COUNT(id) FROM ONLY doc; -- aucun Smart Element
 count
-------
     0
(1 row)


SELECT COUNT(id) FROM doc; -- tous les Smart Element
 count
-------
 81079
(1 row)

Chacune des tables de Smart Elements contiennent en plus des propriétés héritées de la table doc, une colonne par Smart Fields pouvant contenir une valeur. Cela exclut les Smart Fields de type tab, frame, array et menu. Le nom de ces colonnes sont les identifiants des Smart Fields. Le type de ces colonnes est fonction du type de Smart Field. Le type correspondant en base est indiqué dans chacun des chapitres décrivants les Smart Fields.

Pour plus de détails sur le mécanisme d'héritage de PostgreSQL: PostgreSQL: Documentation 9.1 : Inheritance.

# Table de recherche générale

La table docread a les mêmes colonnes que la table doc mais elle n'en hérite pas. Cette table contient une réplication de l'ensemble des Smart Elements qui sont disséminés dans l'ensemble des tables doc<famid>.
Cette table répliquée a ses propres index globaux et permet dans le cas d'une recherche globale, c'est à dire non liée une Smart Structure particulière, d'être plus rapide.

SELECT id, title FROM doc WHERE id = 1098;
id  |           title
------+---------------------------
 1098 | lecteur de Premier espace
(1 row)
Temps : 24,690 ms

SELECT id, title FROM docread WHERE id = 1098;
  id  |           title
------+---------------------------
 1098 | lecteur de Premier espace
(1 ligne)
Temps : 1,037 ms

Cette table est maintenue synchronisée avec le contenu des tables doc<famid> par des triggers, et ne doit donc être utilisée qu'en lecture seule. Seules les tables doc<famid> peuvent être utilisées en modification.

# Description de la table des Smart Structures de Smart Element

La table docfam contient les caractéristiques des Smart Structures. Cette table hérite de la table doc.
Colonnes spécifiques de la table docfam:

Colonne Type Définition
cprofid integer Indique le profil utilisé pour les Smart Elements créés de cette Smart Structure
dfldid integer Identifiant du dossier principal
cfldid integer Identifiant de la recherche principale
ccvid integer Indique le contrôle de vue qui sera associé aux Smart Elements créés avec cette Smart Structure
ddocid integer Obsolète - non utilisé
methods text Liste des fichiers méthodes (METHOD)
defaultvalues jsonb Valeurs par défaut
schar character(1) Indique les modalités de révision
param jsonb Liste des valeurs des paramètres
genversion float
maxrev integer Nombre maximum de révisions pour les Smart Elements de cette Smart Structure
tagable text Spécifique module Anakeen Platform tags
configuration text
Relation d'héritage entre docfam et doc
Relation d'héritage entre docfam et doc

# Description de la table des Smart Fields

La table docattr contient les caractéristiques des Smart Fields des Smart Structures. Lors de l'importation de Smart Structures, cette table est mise à jour. Elle sert à produire les classes PHP associées aux Smart Structures de Smart Elements.

Composition de la table docattr:

Colonne Type Définition
id name Identifiant du Smart Field
docid integer Identifiant numérique de la Smart Structure
frameid name Identifiant du Smart Field encadrant (tab,frame ou array)
labeltext text Libellé du Smart Field
title character(1) Indicateur d'appartenance au titre du Smart Element [Y|N]
abstract character(1) Indicateur d'appartenance au résumé du Smart Element [Y|N]
type text Type de Smart Field (avec format) : frame,array,text,docid("MYSS"),etc...
ordered integer Ordre de présentation
accessibility text Droits sur le Smart Field (None,Read,Write,Readwrite)
needed character(1) Indicateur de Smart Field obligatoire [Y|N]
link text Définition de l'hyperlien affiché sur la valeur du Smart Field
phpfile text Nom du fichier PHP utilisé pour l'aide à la saisie
phpfunc text Déclaration de l'appel à l'aide à la saisie ou au calcul de la valeur du Smart Field
elink text Définition de l'hyperlien mis sur le bouton supplémentaire affiché sur l'interface de modification de Smart Element
phpconstraint text Déclaration de l'appel à la méthode de contrainte d'enregistrement
usefor character(1) Catégorie de Smart Field : N: normal, Q: paramètre de Smart Structure
options text Liste des options de Smart Fields
properties jsonb Liste de propriétés

Cette table n'est pas utilisée par la méthode SmartElement::getAttribute() car la définition des Smart Fields par les classes PHP est faite lors de l'importation des Smart Structures. Les modifications sur cette table ne seront prises en compte que lors de la régénération des Smart Structures.

Relation entre docattr et docfam
Relation entre docattr et docfam

# Description des tables des comptes utilisateurs

Les tables users et groups sont les tables qui contiennent les données systèmes des comptes utilisateurs.
La table users contient la définition des utilisateurs, groupes et rôles utilisés par le système.

Composition de la table users:

Colonne Type Définition
id integer Identifiant unique
lastname text Nom
firstname text Prénom
login text Identifiant de connexion
password text Mot de passe crypté
substitute integer Identifiant du compte qui est suppléant de ce compte (restreint aux utilisateurs)
accounttype character(1) U: Utilisateur, G: Groupe, R: Rôle
memberof integer[] Liste des identifiants des groupes et rôles du compte (calculée à partir de la table groups)
expires integer Obsolète
passdelay integer Obsolète
status character(1) A: Actif, D: Désactivé
mail text Adresse principale de courriel
fid integer Identifiant du Smart Element associé (pointe vers doc128(Utilisateurs), doc130(Rôles) ou doc127(Groupes))

Les identifiants inférieurs à 10 sont réservés au système.

Identifiant Login Définition Nom logique
1 admin Identifiant administrateur USER_ADMIN
2 all groupe "Utilisateur" GDEFAULT
3 anonymous Identifiant accès anonyme USER_GUEST
4 gadmin groupe "Administrateur" GADMIN

Les comptes sont liés à un Smart Element associé. Ce Smart Element constitue l'interface entre les interfaces d'administration et le compte système. Lorsqu'un Smart Element de compte (Smart Structure IUSER,IGROUP ou ROLE) est modifié, le compte système est alors modifié en conséquence.

L'appartenance d'un utilisateur à un groupe ou à un rôle, ou l'appartenance d'un groupe à un autre groupe ou à un autre rôle, est définie dans la table groups.

Composition de la table groups:

Colonne Type Définition
iduser integer Identifiant d'utilisateur ou de groupe (table users)
idgroup integer Identifiant de groupe ou de rôle appartenant à iduser (table users)
Lien entre les tables users et doc
Lien entre les tables users et doc

# Description des tables des droits Smart Elements et actions

# Table docperm

Les droits des profils de Smart Elements sont enregistrés dans la table docperm.

Composition de la table docperm:

Colonne Type Définition
docid integer Identifiant du profil
userid integer Identifiant du compte (utilisateur, groupe ou rôle) ou Smart Field de Smart Element (table vgroup)
upacl integer Droits du compte pour le profil

La colonne upacl contient un masque binaire (int4: 32bits) indiquant les droits.

31 ... 11 10 9 8 7 6 5 4 3 2 1 0
confidential unlock modacl viewacl modify/icreate open/create/execute send delete edit view

Les droits 11 à 31 peuvent être utilisés pour indiquer des droits spécifiques.
Extrait de la table docperm:

SELECT docid,userid,upacl::bit(32) FROM docperm;
 docid | userid  |              upacl
-------+---------+----------------------------------
 83966 |      63 | 00000000000000000000000000000100
 71551 |      21 | 00000000000000000000010000010000
 71551 |      22 | 00000000000000000000000000001110
 71551 |      36 | 00000000000000000000000000000010

Dans cet extrait, la première ligne montre que le compte 63, pour le profil 83966 a le droit d'éditer la recherche.
Cette table ne permet pas de savoir directement si un utilisateur a tel ou tel droit sur un Smart Element car il faut aussi corréler le résultat au groupe d'appartenance et aux rôles affectés à l'utilisateur.

Pour connaître l'ensemble des Smart Elements que l'utillisateur peut voir, il est possible d'utiliser la colonnne views de la table doc ou docread.

SELECT docread.id, docread.title, users.memberof
FROM docread, users
WHERE docread.views && (users.memberof || '{0}'::INT[])
AND users.login = 'john.doe';

Note

L'ajout du zéro dans la liste permet à la condition de récupérer aussi les Smart Elements sans profil. Les Smart Elements sans profil ont {0} dans la colonne views.

Pour connaître l'ensemble des Smart Elements que l'utilisateur peut modifier, il faut s'appuyer sur le contrôle du droit edit (position 2, masque 0x04) et utiliser la fonction hasaprivilege(userMemberOf, Profid, AccessBinaryMask).

SELECT docread.id, docread.title, profid
FROM docread, users
WHERE hasaprivilege(users.memberof, docread.profid, 2<<1)
AND users.login='john.doe';

# Table docpermext

La table docpermext indique les droits étendus. Ces droits sont utilisés lorsque la liste des droits est variable.
Les cycles de vie et les contrôles de vues utilisent les droits étendus.
Le nom des droits pour les cycles est le nom de la transition. Le nom des droits pour les contrôles de vues est l'identifiant de la vue.

Composition de la table docpermext

Colonne Type Définition
docid integer Identifiant du profil (Smart Element cycle ou contrôle de vue)
userid integer Identifiant du compte (utilisateur, groupe ou rôle) ou Smart Field de Smart Element ( table vgroup)
acl text Nom du droit

# Table permission

La table permission indique les droits applicatifs posés. Ce sont ces droits qui sont utilisés pour vérifier l'accès à l'exécution d'une action.

Composition de la table permission

Colonne Type Définition
id_user integer Identifiant du compte (utilisateur, groupe ou rôle) (table users)
id_acl integer Identifiant de l'acl applicative (table acl)
computed boolean Cache valeur calculée - vrai si c'est un droit déduit

Des droits calculés (computed=true) sont enregistrés pour accélérer le calcul du droit lors des prochaines requêtes.

# Table acl

La table acl contient la définition des droits utilisés par les routes.

Colonne Type Définition
id integer Identifiant de l'acl
name text Nom de l'acl
description text Texte descriptif du droit
group_default character(1) Indique si cet acl est posé par défaut sur le groupe all. Valeurs possibles [Y|N]
Relations entre les tables mises en œuvre pour la vérification des droits d'accès
Relations entre les tables mises en œuvre pour la vérification des droits d'accès

# Description de la table historique de Smart Element

La table dochisto contient les informations notées dans l'historique des Smart Elements.

Colonne Type Définition
id integer Identifiant du Smart Element (pour une révision donnée)
initid integer Identifiant initial du Smart Element
uid integer Identifiant de l'utilisateur ayant créé l'entrée
uname text Nom et prénom de l'utilisateur ayant créé l'entrée
date timestamp without time zone Date de l'entrée
level integer Niveau: Notice 1, Information 2, Message 4, Avertissement 8, Erreur16`
code text Code de l'entrée. Permet de catégoriser le message
comment text Message de l'entrée
Relation entre dochisto et doc
Relation entre dochisto et doc

# Description de la table log de Smart Element

La table doclog contient les informations notées dans le log des Smart Elements.
Les entrées sont ajoutées avec la méthode SmartElement::addLog().

Colonne Type Définition
id integer Identifiant du Smart Element (pour une révision donnée)
initid integer Identifiant initial du Smart Element
title text Message du log
uid integer Identifiant de l'utilisateur ayant créé le log
uname text Nom et prénom de l'utilisateur ayant créé le log
date timestamp without time zon Date du log
level integer Niveau: Notice 1, Information 2, Message 4, Avertissement 8, Erreur16`
code text Code de l'entrée. Permet de catégoriser le message
data jsonb Données json associé au log
comment text Commentaire du log
Relation entre doclog et doc
Relation entre doclog et doc

# Description des tables du coffre de fichiers

Ce chapitre définit les tables qui gèrent l'accès aux fichiers attachés aux Smart Elements.

# Table vaultdiskfsstorage

La table vaultdiskfsstorage indique les différents coffres enregistrés.

Colonne Type Définition
id_fs integer Identifiant de coffre (issue de la séquence seq_id_vaultdiskfsstorage)
fsname text Nom du coffre
max_size int8 Capacité maximum du coffre (en octets)
r_path character varying(2048) Chemin absolu d'accès au coffre

Le répertoire r_path doit être accessible en lecture/écriture à l'utilisateur du server web.

# Table vaultdiskdirstorage

La table vaultdiskdirstorage indique les différents répertoires utilisés par les coffres.
Chaque répertoire peut contenir jusqu'à 1000 fichiers.
Quand le nombre de fichiers dans un répertoire arrive à 1000, alors un nouveau répertoire est créé, et sa capacité nominale (free_entries) repart à 1000.
Chaque répertoire ne peut avoir que 100 sous-répertoires. Lorsque tous les répertoires d'un même niveau sont pleins, alors un nouveau répertoire de niveau inférieur est créé.

Colonne Type Définition
id_dir integer Identificateur de répertoire (issue de la séquence sed_id_vaultdiskdirstorage)
id_fs integer Identificateur du coffre lié au répertoire
isfull boolean Indique si le répertoire est plein
size bigint Taille du fichier (en octets)
l_path character varying(2048) Chemin du répertoire relatif à r_path

# Table vaultdiskstorage

La table vaultdiskstorage stocke les chemins d'accès et les propriétés des fichiers du coffre.
Les fichiers physiques sont nommés <id_file>.<extension>.
Si id_file =123 et name="mon test.pdf" alors le nom physique est 123.pdf.
Le fichier est placé dans le répertoire r_path/l_path. r_path provient du coffre lié (id_fs) et l_path provient du répertoire lié (id_dir).

Colonne Type Définition
id_file bigint Identificateur de fichier (issue de la séquence seq_id_vaultdiskstorage)
id_fs integer Identificateur du coffre lié au fichier
id_dir integer Identificateur du répertoire lié au fichier
public_access boolean Si vrai, l'accès au fichier est possible sans contrôle du droit d'accès au Smart Element
size int Taille du fichier (en octets)
name text Nom du fichier original(basename)
id_tmp text Indique si le fichier est un fichier temporaire
mime_t text Type mime (humainement lisible, e.g. PDF document, version 1.4)
mime_s text Type mime système (e.g. application/pdf)
cdate timestamp without time zone Date d'insertion dans le coffre
mdate timestamp without time zone Date de modification dans le coffre
adate timestamp without time zone Date de dernier accès depuis le coffre
teng_state integer État du fichier converti
teng_lname text Nom du fichier converti
teng_id_file bigint Identifiant du fichier converti
teng_comment text Message de conversion

Les Smart Fields de Smart Element de type file et image référencent l'identifiant du fichier. La valeur d'un tel Smart Field dans un Smart Element est :<Type Mime>|<Identifiant Fichier>|<Nom du fichier>.
L'identifiant fichier référence la colonne id_file de la table vaultdiskstorage.

N.B.

Sur un serveur 32bits, l'ensemble possible d'un identifiant de fichier est limité [1 - 2^31].

Relation entre les tables des coffres de fichiers
Relation entre les tables des coffres de fichiers

# Description des tables de paramètres applicatifs

Ce chapitre décrit les tables qui définissent où sont enregistrées les définitions et les valeurs des paramètres applicatifs.

# Table paramv

La table paramv contient les valeurs des paramètres applicatifs. Elle contient notamment les valeurs des paramètres applicatifs de référence.
Les valeurs des paramètres sont gérés à travers la classe de gestion des paramètres.

Colonne Type Définition
name character varying(50) Nom du paramètre
type character varying(21) Type du paramètre : G(global), A(applicatif),U<uid>(utilisateur)
val text Valeur du paramètre

Un paramètre, s'il est global et non utilisateur, ne peut avoir qu'une seule valeur.
Si le paramètre est applicatif et non utilisateur, il ne peut avoir qu'une seule valeur par application.
Si le paramètre est utilisateur, il peut avoir une valeur par utilisateur. Dans ce cas, le type est composé du caractère U suivi de l'identifiant de l'utilisateur (id table users).

# Table paramdef

La table paramdef contient les définitions des paramètres applicatifs.

Colonne Type Définition
name text Nom du paramètre
isuser character(1) Valeurs possibles: Y (paramètre utilisateur), N(paramètre non utilisateur)
category test Catégorie auquel appartient le paramètre
descr text Description du paramètre
kind text Type text,enum,color,password,static ou readonly
Relation entre les tables définissant les paramètres
Relation entre les tables définissant les paramètres

# Pose d'index spécifiques sur les tables des Smart Element

La classe Anakeen\Database\SmartIndex permet de placer des index supplémentaires sur les tables contenant les données des Smart Element. Par défaut cinq index sont déjà créés : (l'<ID> est l'identifiant numérique de structure)

  1. "doc<ID>_pkey" PRIMARY KEY, btree (id)
  2. "doc_name<ID>" UNIQUE, btree (name, revision, doctype)
  3. "doc_initid<ID>" btree (initid)
  4. "doc_profid<ID>" btree (profid)
  5. "doc_title<ID>" btree (title)

Le constructeur prend en entrée la structure sur laquelle on veut poser l'index.

Méthode Description
setColumns(array $columns) ( obligatoire) Liste les Smart Fields et les propriétés sur lesquels l'index est calculé
setUnique(bool $unique) Indique si l'index calculé doit être unique dans la table
setUsing(string $using) Méthode de calcul pour l'index (par défaut btree)
setId(string $using) Permet d'indiquer un identifiant spécifique - Sinon il est calculé à partir des colonnes
setCascade(bool $cascade) Indique si l'index doit aussi être posé sur les tables des structures filles
create() Enregistre l'index s'il n'existe pas déjà (les index en mode cascade)
drop() Supprime l'index s'il existe (les index en mode cascade)
reindex() Recalcule l'index (les index en mode cascade)
exists(): bool Retourne true si l'index existe dans la base de donnée (cela ne concerne que l'index la structure principale - pas les sous-index)
getId(): string Retourne l'identifiant de l'index principal qui sera utilisé pour la base de donnée
getInfo()::string[] Retourne les informations systèmes des index utilisés dans la base de données

Exemple :

use Anakeen\Database\SmartIndex;
use Anakeen\Core\SEManager;
use SmartStructure\Fields\File as FileFields;

$index = new SmartIndex(SEManager::getFamily("FILE"));
$index->setColumns([FileFields::fi_titlew, FileFields::fi_title]);
$index->create();

Le getInfo de cet index retourne le résultat suivant :

Array
(
    [0] => Array
        (
            [schemaname] => public
            [tablename] => doc7
            [indexname] => fi_titlew_fi_title7
            [tablespace] =>
            [indexdef] => CREATE INDEX fi_titlew_fi_title7 ON public.doc7 USING btree (fi_titlew, fi_title)
        )
)

Tables héritées

L'index posé ne concerne que la table de la Smart Structure en question. L'option cascade permet de poser aussi le même index sur les tables filles. Cela est souvent nécessaire si on réalise des requêtes sur les tables mères.

En mode cascade :

<?php
use SmartStructure\Fields\Dir as DirFields;

$index = new \Anakeen\Database\SmartIndex(\Anakeen\Core\SEManager::getFamily("DIR"));
$index->setColumns([DirFields::ba_desc]);
$index->setCascade(true);
print $index . "\n";
$index->create();

La requête utilisée lors de l'appel à la méthode "create" sera :

create index if not exists "ba_desc2" on doc2("ba_desc");
create index if not exists "ba_desc129" on doc129("ba_desc");
create index if not exists "ba_desc127" on doc127("ba_desc");
create index if not exists "ba_desc1109" on doc1109("ba_desc");

Le getInfo de cet index retourne le résultat suivant :

Array
(
    [0] => Array
        (
            [schemaname] => public
            [tablename] => doc2
            [indexname] => ba_desc2
            [tablespace] =>
            [indexdef] => CREATE INDEX ba_desc2 ON public.doc2 USING btree (ba_desc)
        )

    [1] => Array
        (
            [schemaname] => public
            [tablename] => doc129
            [indexname] => ba_desc129
            [tablespace] =>
            [indexdef] => CREATE INDEX ba_desc129 ON public.doc129 USING btree (ba_desc)
        )

    [2] => Array
        (
            [schemaname] => public
            [tablename] => doc127
            [indexname] => ba_desc127
            [tablespace] =>
            [indexdef] => CREATE INDEX ba_desc127 ON public.doc127 USING btree (ba_desc)
        )

    [3] => Array
        (
            [schemaname] => public
            [tablename] => doc1109
            [indexname] => ba_desc1109
            [tablespace] =>
            [indexdef] => CREATE INDEX ba_desc1109 ON public.doc1109 USING btree (ba_desc)
        )

)

← Manipulation des comptes utilisateur →