La tabla core_url_rewrite de Magento es demasiado grande

He notado una gran cantidad de informes de que esta tabla en sí misma puede llegar a estar extremadamente desordenada, estoy ejecutando un sitio con ~ 5000 SKU y ~ 250 categorías (tienda única) y una core_url_rewritetabla resultante de más de 600,000 líneas y más de 500 MB de tamaño que es una locura

Esto puede ralentizar el rendimiento del sitio y generar una base de datos muy voluminosa. Investigué un poco y encontré algunas publicaciones al respecto, sobre todo:

• Error de Core_url_rewrite: cantidad masiva de URL duplicadas para cada producto generado en el índice
• Magento Commerce - Seguimiento de errores - Problema # 29020

// Estos enlaces se han eliminado desde la implementación de los nuevos tableros

Ahora entiendo que la tabla se puede truncar y volver a indexar, pero esto no resuelve el problema, solo prolonga el problema de que vuelva a suceder.

Por lo que entiendo, parte del problema son los productos que tienen la misma clave de URL basada en el nombre del producto, lo que resulta en enlaces indexados.

Una solución mencionada es:

app/code/core/Mage/Catalog/Model/Url.php en línea ~ 807:

Cambio:

 if ($product->getUrlKey() == '' && !empty($requestPath)
       && strpos($existingRequestPath, $requestPath) === 0
 ) 

A:

 if (!empty($requestPath)
       && strpos($existingRequestPath, $requestPath) === 0
 ) 

Pero incluso esto no resuelve completamente el problema.

Mi pregunta es la siguiente:

Si ha experimentado este problema, ¿ha logrado establecer un algoritmo eficaz, lógico y eficiente que no implique "gestionar" el problema repetidamente, sino que en realidad lo resuelva de una vez por todas?

Sería realmente apreciar una idea de esto.

Por cierto: hazte un favor y comprueba cómo se ve tu mesa en este momento, es posible que estés experimentando este problema y el impacto en el rendimiento como resultado sin siquiera saberlo, no lo hice.

Editar: He estado en contacto con www.Nexcess.net (un socio de hosting platino de Magento) y han confirmado que han tenido clientes que solicitan que su core_url_rewritemesa requiera truncamiento como resultado de ser demasiado voluminosa.

Una gran preocupación mía es el impacto de SEO que esto puede tener, por lo que me gustaría una solución en lugar de postergar el problema.

Actualización: Nexcess mencionó que con los productos duplicados dentro de la tabla en realidad puede estar dañando el SEO tal como está.

He logrado estabilizar el problema de la siguiente manera:

Paso 1: reescriba el modelo de URL del catálogo (usando su propio módulo: cómo hacerlo )

Nota: Si sobrescribe el archivo principal sin utilizar una reescritura, esto hará que su instancia de Magento sea incapaz de futuras actualizaciones.

Según la solución de Jahnni en los tableros de MagentoCommerce(ya no está activo con el nuevo tablero), app/code/core/Mage/Catalog/Model/Url.php[alrededor de la línea 807 Mage_Catalog_Model_Url::getProductRequestPath()]

De:

if ($product->getUrlKey() == '' && !empty($requestPath)
   && strpos($existingRequestPath, $requestPath) === 0
) 

A:

if (!empty($requestPath)
           && strpos($existingRequestPath, $requestPath) === 0
) 

Paso 2: truncar

Truncar la core_url_rewritemesa

Paso 3: reindexar y vaciar cachés

Inicie el proceso de re-indexación en Core URL Rewrites. A partir de entonces, querrá vaciar el caché de Magento y el caché de almacenamiento.

System→ Cache Management→Flush Magento Cache

System→ Cache Management→Flush Cache Storage

Voila, estás listo. Notará que si vuelve a ejecutar el indexador, la tabla debe permanecer constante en tamaño (a menos que haya agregado más productos intermedios o si tiene nombres de categoría duplicados).

Si bien espero que alguien presente una respuesta, no sé si la encontrarás. Esta tabla se vuelve voluminosa por muchas razones diferentes. Los errores en versiones anteriores (y posiblemente actuales) de Magento son uno. Otra es que hay lógica en esta tabla que intenta rastrear los cambios en el valor de la clave URL para que las reescrituras 301/302 se configuren para productos antiguos. Debido a esto, y complicando las cosas, truncar la tabla y volver a generarla puede hacer que las reescrituras de URL existentes desaparezcan, y esto tendrá un efecto desconocido en su listado de motores de búsqueda (no necesariamente malo, solo difícil de predecir).

Mi consejo general para los clientes que preguntan es

1. Deje la tabla de crecimiento gigante como está si no tiene un buen manejo de su situación de URL / SEO

2. Hasta que el tamaño de la tabla comience a ser un problema (por ejemplo, generar mapas del sitio). Cuando eso suceda, controle su situación de URL / SEO.

3. Una vez que tenga una idea de su situación de URL / SEO, haga una copia de seguridad de la tabla, luego trunque la tabla y vuelva a generarla. Aborde cualquier problema de URL / SEO causado por el truncamiento.

4. Automatizar el paso 3

Intentar arreglar esto en el nivel de código de Magento es admirable, pero estarás nadando río arriba. A veces es mejor aceptar que "Eso es solo Magento siendo Magento", y resolver el problema con un proceso externo.

Me gustaría agregar una solución para este error del indexador de reescritura de URL que se desarrolló en el bugathon en marzo de 2013 y que se ha mejorado aún más después. Debería resolver este problema. Como referencia, aquí está el archivo de parche del enlace:

diff -rupN mage_org/app/code/core/Mage/Catalog/Model/Url.php src_shop/app/code/core/Mage/Catalog/Model/Url.php
--- mage_org/app/code/core/Mage/Catalog/Model/Url.php   2013-11-19 00:48:25.679009391 +0100
+++ src_shop/app/code/core/Mage/Catalog/Model/Url.php   2013-11-19 00:49:24.188005601 +0100
@@ -643,13 +643,24 @@ class Mage_Catalog_Model_Url
                 $this->_rewrite = $rewrite;
                 return $requestPath;
             }
+
+            // avoid unnecessary creation of new url_keys for duplicate url keys
+            $noSuffixPath = substr($requestPath, 0, -(strlen($suffix)));
+            $regEx = '#^('.preg_quote($noSuffixPath).')(-([0-9]+))?('.preg_quote($suffix).')#i';
+            $currentRewrite = $this->getResource()->getRewriteByIdPath($idPath, $storeId);
+            if ($currentRewrite && preg_match($regEx, $currentRewrite->getRequestPath(), $match)) {
+                $this->_rewrite = $currentRewrite;
+                return $currentRewrite->getRequestPath();
+            }
+
             // match request_url abcdef1234(-12)(.html) pattern
             $match = array();
             $regularExpression = '#^([0-9a-z/-]+?)(-([0-9]+))?('.preg_quote($suffix).')?$#i';
             if (!preg_match($regularExpression, $requestPath, $match)) {
                 return $this->getUnusedPath($storeId, '-', $idPath);
             }
-            $match[1] = $match[1] . '-';
+            $match[1] = $noSuffixPath . '-'; // always use full prefix of url_key
+            unset($match[3]); // don't start counting with a possible number in the url_key
             $match[4] = isset($match[4]) ? $match[4] : '';

             $lastRequestPath = $this->getResource()

Además, me gustaría agregar el parche EE PATCH_SUPEE-389_EE_1.12.0.2_v2.sh, que ahora está disponible en GitHub :

#!/bin/bash
# Patch apllying tool template
# v0.1.2
# (c) Copyright 2013. Magento Inc.
#
# DO NOT CHANGE ANY LINE IN THIS FILE.

# 1. Check required system tools
_check_installed_tools() {
    local missed=""

    until [ -z "$1" ]; do
        type -t $1 >/dev/null 2>/dev/null
        if (( $? != 0 )); then
            missed="$missed $1"
        fi
        shift
    done

    echo $missed
}

REQUIRED_UTILS='sed patch'
MISSED_REQUIRED_TOOLS=`_check_installed_tools $REQUIRED_UTILS`
if (( `echo $MISSED_REQUIRED_TOOLS | wc -w` > 0 ));
then
    echo -e "Error! Some required system tools, that are utilized in this sh script, are not installed:\nTool(s) \"$MISSED_REQUIRED_TOOLS\" is(are) missed, please install it(them)."
    exit 1
fi

# 2. Determine bin path for system tools
CAT_BIN=`which cat`
PATCH_BIN=`which patch`
SED_BIN=`which sed`
PWD_BIN=`which pwd`
BASENAME_BIN=`which basename`

BASE_NAME=`$BASENAME_BIN "$0"`

# 3. Help menu
if [ "$1" = "-?" -o "$1" = "-h" -o "$1" = "--help" ]
then
    $CAT_BIN << EOFH
Usage: sh $BASE_NAME [--help] [-R|--revert] [--list]
Apply embedded patch.

-R, --revert    Revert previously applied embedded patch
--list          Show list of applied patches
--help          Show this help message
EOFH
    exit 0
fi

# 4. Get "revert" flag and "list applied patches" flag
REVERT_FLAG=
SHOW_APPLIED_LIST=0
if [ "$1" = "-R" -o "$1" = "--revert" ]
then
    REVERT_FLAG=-R
fi
if [ "$1" = "--list" ]
then
    SHOW_APPLIED_LIST=1
fi

# 5. File pathes
CURRENT_DIR=`$PWD_BIN`/
APP_ETC_DIR=`echo "$CURRENT_DIR""app/etc/"`
APPLIED_PATCHES_LIST_FILE=`echo "$APP_ETC_DIR""applied.patches.list"`

# 6. Show applied patches list if requested
if [ "$SHOW_APPLIED_LIST" -eq 1 ] ; then
    echo -e "Applied/reverted patches list:"
    if [ -e "$APPLIED_PATCHES_LIST_FILE" ]
    then
        if [ ! -r "$APPLIED_PATCHES_LIST_FILE" ]
        then
            echo "ERROR: \"$APPLIED_PATCHES_LIST_FILE\" must be readable so applied patches list can be shown."
            exit 1
        else
            $SED_BIN -n "/SUP-\|SUPEE-/p" $APPLIED_PATCHES_LIST_FILE
        fi
    else
        echo "<empty>"
    fi
    exit 0
fi

# 7. Check applied patches track file and its directory
_check_files() {
    if [ ! -e "$APP_ETC_DIR" ]
    then
        echo "ERROR: \"$APP_ETC_DIR\" must exist for proper tool work."
        exit 1
    fi

    if [ ! -w "$APP_ETC_DIR" ]
    then
        echo "ERROR: \"$APP_ETC_DIR\" must be writeable for proper tool work."
        exit 1
    fi

    if [ -e "$APPLIED_PATCHES_LIST_FILE" ]
    then
        if [ ! -w "$APPLIED_PATCHES_LIST_FILE" ]
        then
            echo "ERROR: \"$APPLIED_PATCHES_LIST_FILE\" must be writeable for proper tool work."
            exit 1
        fi
    fi
}

_check_files

# 8. Apply/revert patch
# Note: there is no need to check files permissions for files to be patched.
# "patch" tool will not modify any file if there is not enough permissions for all files to be modified.
# Get start points for additional information and patch data
SKIP_LINES=$((`$SED_BIN -n "/^__PATCHFILE_FOLLOWS__$/=" "$CURRENT_DIR""$BASE_NAME"` + 1))
ADDITIONAL_INFO_LINE=$(($SKIP_LINES - 3))p

_apply_revert_patch() {
    DRY_RUN_FLAG=
    if [ "$1" = "dry-run" ]
    then
        DRY_RUN_FLAG=" --dry-run"
        echo "Checking if patch can be applied/reverted successfully..."
    fi
    PATCH_APPLY_REVERT_RESULT=`$SED_BIN -e '1,/^__PATCHFILE_FOLLOWS__$/d' "$CURRENT_DIR""$BASE_NAME" | $PATCH_BIN $DRY_RUN_FLAG $REVERT_FLAG -p0`
    PATCH_APPLY_REVERT_STATUS=$?
    if [ $PATCH_APPLY_REVERT_STATUS -eq 1 ] ; then
        echo -e "ERROR: Patch can't be applied/reverted successfully.\n\n$PATCH_APPLY_REVERT_RESULT"
        exit 1
    fi
    if [ $PATCH_APPLY_REVERT_STATUS -eq 2 ] ; then
        echo -e "ERROR: Patch can't be applied/reverted successfully."
        exit 2
    fi
}

REVERTED_PATCH_MARK=
if [ -n "$REVERT_FLAG" ]
then
    REVERTED_PATCH_MARK=" | REVERTED"
fi

_apply_revert_patch dry-run
_apply_revert_patch

# 9. Track patch applying result
echo "Patch was applied/reverted successfully."
ADDITIONAL_INFO=`$SED_BIN -n ""$ADDITIONAL_INFO_LINE"" "$CURRENT_DIR""$BASE_NAME"`
APPLIED_REVERTED_ON_DATE=`date -u +"%F %T UTC"`
APPLIED_REVERTED_PATCH_INFO=`echo -n "$APPLIED_REVERTED_ON_DATE"" | ""$ADDITIONAL_INFO""$REVERTED_PATCH_MARK"`
echo -e "$APPLIED_REVERTED_PATCH_INFO\n$PATCH_APPLY_REVERT_RESULT\n\n" >> "$APPLIED_PATCHES_LIST_FILE"

exit 0


SUPEE-389 | EE_1.12.0.2 | v1 | 53c8ca52583358953b143aaa1a78cf409e8dd846 | Thu Jun 20 10:36:39 2013 +0300 | v1.12.0.2..HEAD

__PATCHFILE_FOLLOWS__
diff --git app/code/core/Mage/Catalog/Model/Url.php app/code/core/Mage/Catalog/Model/Url.php
index fa55fc5..a755b46 100644
--- app/code/core/Mage/Catalog/Model/Url.php
+++ app/code/core/Mage/Catalog/Model/Url.php
@@ -609,6 +609,23 @@ class Mage_Catalog_Model_Url
      */
     public function getUnusedPath($storeId, $requestPath, $idPath)
     {
+        $urlKey = '';
+        return $this->getUnusedPathByUrlkey($storeId, $requestPath, $idPath, $urlKey);
+    }
+
+    /**
+     * Get requestPath that was not used yet.
+     *
+     * Will try to get unique path by adding -1 -2 etc. between url_key and optional url_suffix
+     *
+     * @param int $storeId
+     * @param string $requestPath
+     * @param string $idPath
+     * @param string $urlKey
+     * @return string
+     */
+    public function getUnusedPathByUrlkey($storeId, $requestPath, $idPath, $urlKey = '')
+    {
         if (strpos($idPath, 'product') !== false) {
             $suffix = $this->getProductUrlSuffix($storeId);
         } else {
@@ -645,21 +662,22 @@ class Mage_Catalog_Model_Url
             }
             // match request_url abcdef1234(-12)(.html) pattern
             $match = array();
-            $regularExpression = '#^([0-9a-z/-]+?)(-([0-9]+))?('.preg_quote($suffix).')?$#i';
+            $regularExpression = '#(?P<prefix>(.*/)?' . preg_quote($urlKey) . ')(-(?P<increment>[0-9]+))?(?P<suffix>'
+                . preg_quote($suffix) . ')?$#i';
             if (!preg_match($regularExpression, $requestPath, $match)) {
-                return $this->getUnusedPath($storeId, '-', $idPath);
+                return $this->getUnusedPathByUrlkey($storeId, '-', $idPath, $urlKey);
             }
-            $match[1] = $match[1] . '-';
-            $match[4] = isset($match[4]) ? $match[4] : '';
+            $match['prefix'] = $match['prefix'] . '-';
+            $match['suffix'] = isset($match['suffix']) ? $match['suffix'] : '';

             $lastRequestPath = $this->getResource()
-                ->getLastUsedRewriteRequestIncrement($match[1], $match[4], $storeId);
+                ->getLastUsedRewriteRequestIncrement($match['prefix'], $match['suffix'], $storeId);
             if ($lastRequestPath) {
-                $match[3] = $lastRequestPath;
+                $match['increment'] = $lastRequestPath;
             }
-            return $match[1]
-                . (isset($match[3]) ? ($match[3]+1) : '1')
-                . $match[4];
+            return $match['prefix']
+                . (isset($match['increment']) ? ($match['increment']+1) : '1')
+                . $match['suffix'];
         }
         else {
             return $requestPath;
@@ -699,7 +717,7 @@ class Mage_Catalog_Model_Url
     {
         $storeId = $category->getStoreId();
         $idPath  = $this->generatePath('id', null, $category);
-        $suffix  = $this->getCategoryUrlSuffix($storeId);
+        $categoryUrlSuffix = $this->getCategoryUrlSuffix($storeId);

         if (isset($this->_rewrites[$idPath])) {
             $this->_rewrite = $this->_rewrites[$idPath];
@@ -713,27 +731,27 @@ class Mage_Catalog_Model_Url
             $urlKey = $this->getCategoryModel()->formatUrlKey($category->getUrlKey());
         }

-        $categoryUrlSuffix = $this->getCategoryUrlSuffix($category->getStoreId());
         if (null === $parentPath) {
             $parentPath = $this->getResource()->getCategoryParentPath($category);
         }
         elseif ($parentPath == '/') {
             $parentPath = '';
         }
-        $parentPath = Mage::helper('catalog/category')->getCategoryUrlPath($parentPath,
-                                                                           true, $category->getStoreId());
+        $parentPath = Mage::helper('catalog/category')->getCategoryUrlPath($parentPath, true, $storeId);

-        $requestPath = $parentPath . $urlKey . $categoryUrlSuffix;
-        if (isset($existingRequestPath) && $existingRequestPath == $requestPath . $suffix) {
+        $requestPath = $parentPath . $urlKey;
+        $regexp = '/^' . preg_quote($requestPath, '/') . '(\-[0-9]+)?' . preg_quote($categoryUrlSuffix, '/') . '$/i';
+        if (isset($existingRequestPath) && preg_match($regexp, $existingRequestPath)) {
             return $existingRequestPath;
         }

-        if ($this->_deleteOldTargetPath($requestPath, $idPath, $storeId)) {
+        $fullPath = $requestPath . $categoryUrlSuffix;
+        if ($this->_deleteOldTargetPath($fullPath, $idPath, $storeId)) {
             return $requestPath;
         }

-        return $this->getUnusedPath($category->getStoreId(), $requestPath,
-                                    $this->generatePath('id', null, $category)
+        return $this->getUnusedPathByUrlkey($storeId, $fullPath,
+            $this->generatePath('id', null, $category), $urlKey
         );
     }

@@ -798,7 +816,8 @@ class Mage_Catalog_Model_Url
             $this->_rewrite = $this->_rewrites[$idPath];
             $existingRequestPath = $this->_rewrites[$idPath]->getRequestPath();

-            if ($existingRequestPath == $requestPath . $suffix) {
+            $regexp = '/^' . preg_quote($requestPath, '/') . '(\-[0-9]+)?' . preg_quote($suffix, '/') . '$/i';
+            if (preg_match($regexp, $existingRequestPath)) {
                 return $existingRequestPath;
             }

@@ -836,7 +855,7 @@ class Mage_Catalog_Model_Url
         /**
          * Use unique path generator
          */
-        return $this->getUnusedPath($storeId, $requestPath.$suffix, $idPath);
+        return $this->getUnusedPathByUrlkey($storeId, $requestPath.$suffix, $idPath, $urlKey);
     }

     /**
@@ -891,8 +910,8 @@ class Mage_Catalog_Model_Url
                 $parentPath = Mage::helper('catalog/category')->getCategoryUrlPath($parentPath,
                     true, $category->getStoreId());

-                return $this->getUnusedPath($category->getStoreId(), $parentPath . $urlKey . $categoryUrlSuffix,
-                    $this->generatePath('id', null, $category)
+                return $this->getUnusedPathByUrlkey($category->getStoreId(), $parentPath . $urlKey . $categoryUrlSuffix,
+                    $this->generatePath('id', null, $category), $urlKey
                 );
             }

@@ -913,14 +932,14 @@ class Mage_Catalog_Model_Url
                 $this->_addCategoryUrlPath($category);
                 $categoryUrl = Mage::helper('catalog/category')->getCategoryUrlPath($category->getUrlPath(),
                     false, $category->getStoreId());
-                return $this->getUnusedPath($category->getStoreId(), $categoryUrl . '/' . $urlKey . $productUrlSuffix,
-                    $this->generatePath('id', $product, $category)
+                return $this->getUnusedPathByUrlkey($category->getStoreId(), $categoryUrl . '/' . $urlKey . $productUrlSuffix,
+                    $this->generatePath('id', $product, $category), $urlKey
                 );
             }

             // for product only
-            return $this->getUnusedPath($category->getStoreId(), $urlKey . $productUrlSuffix,
-                $this->generatePath('id', $product)
+            return $this->getUnusedPathByUrlkey($category->getStoreId(), $urlKey . $productUrlSuffix,
+                $this->generatePath('id', $product), $urlKey
             );
         }

Si desea utilizar este parche con CE, asegúrese de probarlo correctamente, ya que se ha desarrollado para EE.

Después de aplicar el parche publicado por Simon, puede usar la siguiente consulta para eliminar datos basura:

DELETE FROM core_url_rewrite
WHERE is_system <> 1 AND id_path REGEXP "^[0-9]+_[0-9]+$" AND
      (request_path REGEXP ".*-[0-9]*\.html" 
          OR target_path = request_path);

A diferencia de la consulta de Ashish Hira, esto solo afecta a las URL que tienen un número entero como la última parte, esta fue, en mi caso, la razón del desorden.

Intenta no tocar reescrituras válidas, que por ejemplo podrían haberse creado al actualizar una clave URL.

He implementado la respuesta aceptada con éxito. En otra instalación de Magento, necesitaba preservar algunas reescrituras personalizadas, así que eliminé todas las entradas que terminaban en - y luego un número de hasta 5 dígitos con:

DELETE FROM `core_url_rewrite` WHERE `request_path` REGEXP '\\-[0-9]{1,5}$';

Esto funcionó principalmente, pero todavía obtengo 2 filas más en cada reindexación. No estoy seguro de por qué. Pensé en compartir esta experiencia.

El cambio central que mencionó solo parece ser necesario si tiene productos sin url_keys, sin embargo, Magento siempre debe crear url_keys para usted. Si tiene algún importador que está creando productos sin url_keys, entonces este problema surgirá para esos productos. Intente ejecutar la siguiente consulta para encontrar dichos productos:

SELECT cpe.entity_id, cpe.sku, cpev.value
FROM catalog_product_entity cpe
LEFT JOIN catalog_product_entity_varchar cpev
ON cpe.entity_id = cpev.entity_id AND cpev.attribute_id = (
    SELECT attribute_id
    FROM eav_attribute
    WHERE `entity_type_id` = 4
    AND `attribute_code` = 'url_key'
)
WHERE cpev.value IS NULL OR cpev.value = ''

Si algún producto regresa de esa consulta, no tiene una url_key y será un problema.

Seguí la solución aprobada para evitar reescrituras de URL duplicadas, luego exporté core_url_rewritecomo archivo CSV. Pude abrir este CSV y eliminar todas las regrabaciones de URL creadas manualmente.

Luego trunqué la core_url_rewritetabla e importé mi CSV guardado con reescrituras de URL creadas manualmente.

Después de todos los cambios, pasó de 940K filas a 32K. Enorme mejora.

Aquí hay un parche (reescritura local) para Magento Community para corregir que https://github.com/biotech/Magento-URL-Rewrite De hecho, hace lo mismo que el parche EE PATCH_SUPEE-389_EE_1.12.0.2_v2.sh - verifique cada reescritura y Evitar la creación de registros duplicados. Funciona bien los últimos 2 meses en producción CE 1.9, 15k productos, 4 tiendas, reindexación completa todas las noches después de los cambios de importación de productos a granel.

Como esto aún no se menciona en este hilo, quería compartir la buena noticia de que este problema se soluciona en Magento 1.9.3.9 y versiones posteriores. Consulte las notas de la versión relacionadas :

Magento ya no realiza operaciones de escritura innecesarias en la tabla core_url_rewrite.

Por lo tanto, todas las soluciones para este problema mencionado aquí no son necesarias cuando se utiliza una versión de Magento mayor o igual que 1.9.3.9. Todavía sugiero eliminar los valores antiguos como se describe en la respuesta de Alex .

Ejecute esta consulta

DELETE FROM core_url_rewrite WHERE is_system <> 1 AND id_path REGEXP "^[0-9]+_[0-9]+$";

Esto seguramente lo ayudará a reducir el tamaño de la core_url_sizetabla eliminando datos basura.

Deshacerse de .html

1. No use sufijo .html

2. Establecer en .htaccess

   ## Redirect all htmls.
   RewriteRule (.+)\.html$ /$1 [L,R=301]

3. Borrar todos los .htmlredireccionamientos:

   DELETE FROM core_url_rewrite WHERE request_path LIKE '%.html'

La respuesta oficial debería ser instalar SUPEE-389. Simple como eso.

Funciona perfectamente con Magento CE ya que comparten el mismo código en esta área.

Puede encontrar el archivo de parche aquí, https://gist.github.com/piotrekkaminski/c348538ca91ba35773be#file-patch_supee-389_ee_1-12-0-2_v2-sh

Tuvimos este problema y generó miles de filas nuevas después de cada reindexación de URL de catálogo. Ahora el problema se ha ido ... excepto por el hecho de que tenemos que limpiar la base de datos.

El script proporcionado aquí parece un buen comienzo, pero no es una solución perfecta,

php shell / rewrites_doctor.php --remove_rewrites 4

Ver https://www.atwix.com/magento/duplicated-product-url-keys-in-community-edition/

También hay un módulo dedicado https://github.com/vladsmirnov/url-rewrites , por lo que no tiene que volver a aplicar el parche después de cada actualización de Magento. El módulo contiene dos partes: el módulo real, para evitar la duplicación de ahora en adelante y el script de shell para limpiar la base de datos existente.