Optimisez vos imports de données avec Migrate

Optimisez vos imports de
données avec Migrate

Qui suis-je ?

Matthieu Guillermin
• Consultant chez Clever Age
• Java, PHP, Symfony, Play!,... et ... Drupal

@mguillermin

Drupal Camp Lyon - Optimisez vos imports de données avec Migrate 2
Matthieu Guillermin - Mai 2012

Agenda

• Contexte
• Solutions d’import de données dans Drupal
• Anatomie d’une tâche Migrate
• Gestion des références entre contenus
• Stratégies d’optimisation


Imports de données


Imports de données

• Problème récurrent
• Récupération de contenu initial
• Afﬁchage de données depuis sources externes
• Agrégation de données
• ...


Imports de données

• Problématiques variées
• Sources : BDD, ﬁchiers, ﬂux,...
• Structures de donnée : plat, relationnel,...
• Fréquences d’imports : one-shot, quotidient,...
• Cibles : Nodes, Files, Users, Taxonomy,...


Solutions d’import de
données dans Drupal


« A la main »
• Transfert direct vers la base
• Via des scripts
• En utilisant un ETL
• Schéma cible difﬁcile à appréhender
• Encore + depuis Drupal 7
• Risque d’erreurs important


« A la main »
• En utilisant l’API Drupal pour enregistrer les
données
• Développement d’un module
• Implémentation de la lecture des données
• Construction de la structure du node
• Utilisation de node_save() pour
l’enregistrement


« A la main »
• Les +
• Souplesse totale sur la source et les
traitements
• Les -
• Beaucoup de travail
• On va « réinventer la roue »
• Difﬁcile de construire la structure « node »


Feeds

• Module « historique » pour l’import de
données
• Au départ, plutôt dédié aux ﬂux XML (RSS)
• Conﬁguration UI + API
• Connecteurs disponibles : XML, CSV, LDAP,...


Feeds
• Les +
• Rapide à mettre en place
• Conﬁguration via l’interface
• Connecteurs disponibles
• Les -
• Peu adapté aux gros volumes de données
• Difﬁcile de gérer les cas « particuliers »
• Références entre les contenus

Migrate
• Module dédié à l’import de données
• Interface graphique minimale
• Nécessite de « coder » les imports
• Fournit des outils clés en main (lancement de
tâches, ...)
• Peut faire peur de prime abord


Migrate
• Les +
• Connecteurs fournis
• Performances sur de gros volumes
• Gestion des références entre contenus
• Les -
• Nécessite d’écrire du code
• ça pourrait être un + !

En résumé
• Feeds
• Si vous voulez une interface simple
• Si il sufﬁt à votre besoin
• Et si vous aimez cliquer
• Sinon, Migrate
• Pas si compliqué que ça


Anatomie d’une tâche
Migrate


Source
• Gère le requêtage des données
• SQL : MySQL, Oracle, MSSQL,..
• Fichiers : CSV, XML, ...
• Fournit une série d’enregistrements
• Avec les valeurs des champs
• S’occupe du parcours des données
• Extensible en cas de besoin


Source
$query = Database::getConnection('myDb', 'myDbKey')
->select('article', 'a');
$query->innerJoin(‘article_category’, ‘ac’,
‘a.category_id = ac.id’);

$query->fields(‘a’, ‘id’);
$query->fields(‘a’, ‘title’);
$query->fields(‘a’, ‘content’);
$query->fields(‘ac’, ‘name’, ‘cat_name’);

$this->source = new MigrateSourceSQL($query, array(),
NULL, array('map_joinable' => FALSE));


Source
$this->source = new MigrateSourceCSV($source_file,
$this->csvcolumns(), array('header_rows' => 1),
array());

function csvcolumns() {
$columns[0] = array('title', 'Title');
$columns[2] = array('desc', 'Description');
return $columns;
}


Source

$items_url = $xml_folder . 'positions.xml';
$item_xpath = '/producers/producer';
$item_ID_xpath = 'sourceid';

$this->source = new MigrateSourceXML($items_url,
$item_xpath, $item_ID_xpath, $fields);


Destination
• Gère l’enregistrement des données
• Types fournis par Migrate :
• User, Role, Node, Comment, Term, File,...
• Utilise l’API pour enregistrer : node_save,
user_save(),...
• Extensible
• on peut créer ses propres types de
destinations

Destination
// Node
$this->destination = new MigrateDestinationNode(
'article', array('text_format' => 'full_html'));

// Taxonomy
$this->destination = new MigrateDestinationTerm(
‘voc_name’);

// User
$this->destination = new MigrateDestinationUser();


Mapping
• Associations champs
• Source => Destination
• Peuvent être simples ou + complexes
• Transformation de données
• Conversion de formats
• ...


Mapping

SRC DEST
SRC_ID DEST_ID
SRC_1 Transfo. DEST_1
SRC_2 DEST_2


Mapping
• Transformations de données
• Chaîne ➞ tableau (explode)
• Appel de « Callbacks »
• Arguments
• A utiliser suivant les types de champs
• cf les « Migrate*FieldHandler »


Mapping
// Default value
$this->addFieldMapping('language', 'lang')
->defaultValue('fr');

// Multiple
$this->addFieldMapping('field_auteur', 'auteurs')
->separator(',');

// Callbacks
$this->addFieldMapping('title', 'titre')
->callbacks(
'strip_tags',
array($this, 'trimTitle'),
array($this, 'convertToUtf8')
);


Mapping
• « Sous le capot »
• les FieldHandlers s’occupent de
convertir les valeurs
• Construction des structures en fonction des
types de champs
• Utilise les arguments pour savoir comment les
générer


FieldHandlers
// Before
string(2) "C1"

// After
["field_numero"]=>
array(1) {
["und"]=>
array(1) {
[0]=>
array(3) {
["value_format"]=>
string(10) "plain_text"
["format"]=>
string(10) "plain_text"
["value"]=>
string(2) "C1"
}
}
}


Mapping
// Arguments Date
$date_args =
DateMigrateFieldHandler::arguments('Europe/Paris');
$this->addFieldMapping('field_pub_date', 'pub')
->arguments($date_args);

// Arguments Term Reference
$this->addFieldMapping('field_categorie', 'categorie')
->arguments(array(
'source_type' => 'tname',
'create_term' => TRUE
));


Map

• Correspondance entre ID source et ID
destination
• Stockée dans une table dédiée
• Permet de relancer une tâche en « update »
• Permet les « rollbacks »
• Permet les références entre contenus


Map
MAP
ID Src 1 ID Dest 1

ID Src 2 ID Dest 2

SRC DEST
SRC_ID DEST_ID
SRC_2 DEST_2


Map

$this->map = new MigrateSQLMap($this->machineName,
array(
'id' => array(
'type' => 'int',
'unsigned' => TRUE,
'description' => 'Content ID',
)
),
MigrateDestinationNode::getKeySchema()
);


Anatomie d’une tâche

• En résumé :
• Source
• Destination
• Mapping
• Map


Migration

• 1 Migration = 1 Classe PHP
• Doit étendre Migration

• Conﬁguration de
• Source, Destination, Field Mapping, Map
• Effectuée dans __construct()


Migration
• Offre des points d’entrée pour
• Altérer les données en lecture
• prepareRow($row)
• Altérer les entités en écriture
• prepare($entity, $row)
• Possibilité d’héritage
• Mutualisation de conﬁguration


Lancement des tâches

• Pour lancer les tâches
• Ligne de commande
• Drush
• Interface graphique
• Disponible dans le BackOfﬁce


Lancement des tâches

• Drush
• Différentes commandes : mi, ms, mr, mrs
• Paramètres intéressants :
• «limit» : permet de limiter le nombre d’éléments
à importer (ou le temps d’import)
• «feedback» : notiﬁcations de l’avancement


Lancement tâches
$ drush ms
Name Total Imported Unimported Status Last imported
LyonMetroLigneTypes 4 4 0 Idle 2012-05-23 13:49:35
LyonMetroLignes 154 154 0 Idle 2012-05-23 14:08:29
LyonMetroArrets 4036 4036 0 Idle 2012-05-23 13:58:16

$ drush mi LyonMetroLignes --update --feedback="50 items"
Processed 50 (0 created, 50 updated, 0 failed, 0 ignored) in 1.4 sec (2156/min) -
continuing with 'LyonMetroLignes'
Processed 4 (0 created, 4 updated, 0 failed, 0 ignored) in 0.3 sec (899/min) - done
with 'LyonMetroLignes'


Lancement tâches


En pratique...


Gestion des références
entre contenus


Références entre contenus
• Prérequis
• Mécanisme de dépendances entre tâches
• Si B est dépendant de A
• La tâche A devra être lancée avant la tâche B

$this->dependencies = array('MigrationA');


• Tables ‘Map’
• Correspondances entre ID src. & dest.
• Permet à Migrate de gérer les références
• Dans le mapping :

$this->addFieldMapping('field_a_dest', 'field_a_src')
->sourceMigration('MigrationA');


• Lors de l’import de ce champ dans B :
• L’Id source va être « converti » en Id
Destination en utilisant la table Map de la
Migration A

SELECT destid1 /* nid/tid/uid/fid */
FROM migrate_map_A /* Map table for ‘A‘ */
WHERE sourceid1 = :id_src /* id in ‘A’ src table */

• C’est l’Id « converti » qui sera enregistré dans
le contenu

• Import de A

SRC_A MAP_A NODE
1023 378
SRC_ID NID
1029 379
... ... ... ...


• Import de B

SRC_B MAP_B NODE_B
4204 455
SRC_ID 4605 456 NID
... ...
A_ID A_REF

MAP_A
1023 378

1029 379

... ...


En pratique...


Stratégies
d’optimisation


Requêtage
• Comme dans tout import, le requêtage est
essentiel
• Limiter le nombre de requêtes
• Eviter de faire une requête pour chaque ligne
source
• INNER JOIN / LEFT JOIN /...
• Optimiser la source (si possible)
• ajout d’indexes
• conﬁguration DB (innodb_buffer_pool_size,...)

Modules « gourmands »

• Désactivation de traitements lors de l’import
• Pathauto : il faut mieux construire l’url « à la
main »
• ‘migrate_extras’ fournit un moyen de le
désactiver pour une migration donnée


Highwater Field
• Pour les imports réguliers
• N’importer que les données mises à jour
depuis le dernier import

$this->highwaterField = array(
'name' => 'last_changed',
'alias' => 'w',
'type' => 'int',
);

$query->orderBy('last_changed');


Highwater Field
• Avec le Highwater Field
• Migrate ajoutera automatiquement une
condition sur la requête source
• Restriction des enregistrements sources à
traiter
• Ne fonctionne automatiquement que pour les
sources : SQL, Oracle & MSSQL


preImport()
• En cas de structure de base trop « tordue »
• On peut être amené à faire une première
passe pour charger des éléments en mémoire
• Ces éléments seront réinjectés dans chaque
contenu cible
• Pour cela on peut utilise la méthode
preImport()


// Called once during the migration process
public function preImport()
{
parent::preImport();
$query = Database::getConnection('myDB')
->select('metas', 'm');
$query->fields('m', array(
'id_doc', 'id_meta', 'valeur'));

/* ... */
$result = $query->execute();
while ($row = $result->fetchObject()) {

if ($row->id_meta == self::ID_META_TITRE) {
$this->metas[$row->id_doc]['titre'] = $row->valeur;
}
if ($row->id_meta == self::ID_META_DATE) {
$this->metas[$row->id_doc]['date'] = $row->valeur;
}
}
}
Drupal Camp Lyon - Optimisez vos imports de données avec Migrate

// Called for each source row
public function prepareRow($row)
{
if (isset($this->metas[$row->id_doc]['titre'])) {
$row->titre = $this->metas[$row->id_doc]['titre'];
}

if (isset($this->metas[$row->id_doc]['date'])) {
$row->titre = $this->metas[$row->id_doc]['date'];
}

return parent::prepareRow($row);
}

Drupal Camp Lyon - Optimisez vos imports de données avec Migrate

En cas de besoin
• Attention à la mémoire
• On peut être amené à ajuster la
memory_limit
• Séparation en 2 migrations
• Utilisation de «system of record»
• Seuls les champs «mappés» seront écrasés

$this->systemOfRecord = Migration::DESTINATION;


Des questions ?


Merci pour votre attention !
@mguillermin

Optimisez vos imports de données avec Migrate

Contenu connexe

En vedette

Optimisez vos imports de données avec Migrate