Corriger les données sérialisées brisées à cause de la modification de la base de données MySQL dans un éditeur de texte?

J'ai ce même problème après avoir essayé de changer le domaine de localhost pour l'URL réelle. Après quelques recherches, j'ai trouvé la réponse dans la documentation de WordPress:

https://codex.wordpress.org/Moving_WordPress

Je vais citer ce qui y est écrit:

Pour éviter que la sérialisation de problème, vous disposez de trois options:

• Utilisation la Meilleure de Recherche, de Remplacer ou de Velours Blues de mise à Jour des Url plugins si vous pouvez > accéder à votre tableau de bord.
• Utiliser WP-CLI de chercher-remplacer si votre fournisseur d'hébergement (ou vous) avez installé WP-CLI.
• Lancez une recherche et remplacer requête manuellement sur votre base de données. Remarque: effectuer une recherche et de remplacement sur la table wp_posts.

J'ai fini par utiliser WP-CLI qui est en mesure de remplacer les choses dans la base de données sans se casser la sérialisation: http://wp-cli.org/commands/search-replace/

Je sais que c'est une vieille question, mais mieux vaut tard que jamais, je suppose. J'ai rencontré ce problème récemment, après avoir hérité d'une base de données qui avait fait un rechercher/remplacer exécutées sur les données sérialisées. Après de nombreuses heures de recherches, j'ai découvert que c'était parce que la chaîne les chiffres étaient hors tension. Malheureusement, il y avait beaucoup de données avec beaucoup de s'échapper et de retours à la ligne et je ne sais pas comment compter, dans certains cas, et j'ai eu tellement de données que j'ai besoin de quelque chose d'automatisé.

Le long du chemin, je suis tombé sur cette question et Benubird post a aidé à me mettre sur le droit chemin. Son exemple de code ne fonctionne pas dans une utilisation en production sur des données complexes, contenant de nombreux caractères spéciaux et HTML, avec de très profondes niveaux d'imbrication, et il n'a pas de traiter correctement certains caractères d'échappement et d'encodage. J'ai donc modifié un peu et passé d'innombrables heures de travail par le biais de bugs supplémentaires pour obtenir ma version de "réparer" les données sérialisées.

// do some DB query here
while($res = db_fetch($qry)){
    $str = $res->data;
    $sCount=1; // don't try to count manually, which can be inaccurate; let serialize do its thing
    $newstring = unserialize($str);
    if(!$newstring) {
        preg_match_all('/s:([0-9]+):"(.*?)"(?=;)/su',$str,$m);
#           preg_match_all("/s:([0-9]+):(\"[^\"\\\\]*(?:\\\\.[^\"\\\\]*)*\")(?=;)/u",$str,$m); //alternate: almost works but leave quotes in $m[2] output
#           print_r($m); exit;
        foreach($m[1] as $k => $len) {
            /*** Possibly specific to my case: Spyropress Builder in WordPress ***/
            $m_clean = str_replace('\"','"',$m[2][$k]); //convert escaped double quotes so that HTML will render properly
            //if newline is present, it will output directly in the HTML
            //nl2br won't work here (must find literally; not with double quotes!)
            $m_clean = str_replace('\n', '<br />', $m_clean); 
            $m_clean = nl2br($m_clean);  // but we DO need to convert actual newlines also
            /*********************************************************************/
            if($sCount){
                $m_new = $m[0][$k].';'; // we must account for the missing semi-colon not captured in regex!
                // NOTE: If we don't flush the buffers, things like <img src="http://whatever" can be replaced with <img src="//whatever" and break the serialize count!!!                  
                ob_end_flush(); //not sure why this is necessary but cost me 5 hours!!
                $m_ser = serialize($m_clean);
                if($m_new != $m_ser) {
                    print "Replacing: $m_new\n";
                    print "With: $m_ser\n";
                    $str = str_replace($m_new, $m_ser, $str);
                }
            }
            else{
                $m_len = (strlen($m[2][$k]) - substr_count($m[2][$k],'\n'));
                if($len != $m_len) {
                    $newstr='s:'.$m_len.':"'.$m[2][$k].'"';
                    echo "Replacing: {$m[0][$k]}\n";
                    echo "With: $newstr\n\n";
                    $str = str_replace($m_new, $newstr, $str);
                }
            }
        }
        print_r($str); // this is your FIXED serialized data!! Yay!
    }
}

Un peu geek explication sur mes modifications:

• J'ai trouvé que le fait d'essayer de compter avec Benubird code sert de base était trop imprécises pour de grands ensembles de données, j'ai donc fini par juste en utilisant sérialiser pour être sûr que le comte était exact.
• J'ai évité le try/catch parce que, dans mon cas, l'essayer serait un succès, mais juste de rentrer une chaîne vide. Donc, j'ai vérifier les données vide à la place.
• J'ai essayé de nombreuses regex, mais seulement un mod sur Benubird de traiter correctement tous les cas. Plus précisément, j'ai dû modifier la partie qui a vérifié pour le ";" parce qu'il correspond sur le CSS de type "width:100%; height:25px;" et s'est cassé la sortie. Donc, j'ai utilisé une anticipation positif seulement quand le ";" est en dehors de l'ensemble de guillemets doubles.
• Mon cas eu beaucoup de retours à la ligne, HTML, et s'est échappé des guillemets, j'ai donc dû ajouter un bloc à nettoyer.
• Il y avait un couple de situations étranges où les données seraient remplacés de façon incorrecte par le regex et puis le sérialiser serait prise en compte de manière incorrecte. Je n'ai RIEN trouvé sur les sites d'aider avec cela et enfin pensé qu'il pourrait être lié à la mise en cache ou quelque chose comme ça et essayé de vider la mémoire tampon de sortie (ob_end_flush()), qui a travaillé, dieu merci!

Espère que cela aide quelqu'un... m'a fallu près de 20 heures, y compris la recherche et de traiter avec des problèmes bizarres! 🙂

Personnellement, je n'aime pas travailler en PHP, ou en plaçant ma DB informations d'identification dans un dossier public. J'ai créé un script ruby pour fixer serializations que vous pouvez exécuter localement:

https://github.com/wsizoo/wordpress-fix-serialization

Contexte Edit:
Je me suis approché de la fixation de la sérialisation en déterminant d'abord la sérialisation via des regex, puis à recalculer la taille en octets de la chaîne de données.

$content_to_fix.gsub!(/s:([0-9]+):\"((.|\n)*?)\";/) {"s:#{$2.bytesize}:\"#{$2}\";"}

Je puis mettre à jour les données spécifiées par le biais d'un échappé de la requête sql update.

escaped_fix_content = client.escape($fixed_content)

query = client.query("UPDATE #{$table} SET #{$column} = '#{escaped_fix_content}' WHERE #{$column_identifier} LIKE '#{$column_identifier_value}'")