meta_query con valores meta como arrays serializados

También me encontré en esta situación. Esto es lo que hice:

$args = array(
    'post_type' => 'my-post-type',
    'meta_query' => array(
        array(
            'key' => 'latitude',
            'value' => sprintf(':"%s";', $value),
            'compare' => 'LIKE'
        )
    )
);

Espero que esto ayude

Realmente vas a perder la capacidad de consultar tus datos de manera eficiente cuando serialices entradas en la base de datos de WordPress.

El ahorro y la mejora de rendimiento general que crees estar logrando con la serialización no será notable en gran medida. Podrías obtener una base de datos ligeramente más pequeña, pero el costo de las transacciones SQL será alto si alguna vez consultas esos campos e intentas compararlos de manera útil y significativa.

En su lugar, reserva la serialización para datos que no pretendas consultar de esa manera, sino que solo accederías de forma pasiva mediante la llamada directa a la API de WordPress get_post_meta() - desde esa función, también puedes desempacar una entrada serializada para acceder a sus propiedades de array.

De hecho, asignar el valor true como en:

$meta = get_post_meta( $post->ID, 'key', true );

Devolverá los datos como un array, accesible para que puedas iterar sobre él como de costumbre.

Puedes enfocarte en otras optimizaciones de base de datos/sitio, como el almacenamiento en caché, la minificación de CSS y JS, y el uso de servicios como una CDN si lo requieres. Por mencionar algunos... El Codex de WordPress es un buen punto de partida para descubrir más sobre ese tema: AQUÍ

Creo que hay 2 soluciones que pueden intentar resolver el problema de los resultados almacenados como String y Enteros. Sin embargo, es importante mencionar, como otros han señalado, que no es posible garantizar la integridad de los resultados almacenados como Entero, ya que estos valores se guardan como arrays serializados, el índice y los valores se almacenan exactamente con el mismo patrón. Ejemplo:

array(37,87);

se almacena como un array serializado, así:

a:2:{i:0;i:37;i:1;i:87;}

Observa el i:0 como la primera posición del array y i:37 como el primer valor. El patrón es el mismo. Pero vayamos a las soluciones

1) Solución con REGEXP

Esta solución funciona para mí independientemente de que el valor meta se guarde como string o número/id. Sin embargo, utiliza REGEXP, que no es tan rápido como usar LIKE

$args = array(
    'post_type' => 'my-post-type',
    'meta_query' => array(
        array(
            'key' => 'latitude',
            'value' => '\;i\:' . $value . '\;|\"' . $value . '\";',
            'compare' => 'REGEXP'
        )
    )
);

2) Solución con LIKE

No estoy seguro de la diferencia en rendimiento, pero esta es una solución que usa LIKE y también funciona tanto para números como strings

$args = array(
    'post_type' => 'my-post-type',
    'meta_query' => array(
        'relation' => 'OR',
        array(
            'key' => 'latitude',
            'value' => sprintf(':"%s";', $value),
            'compare' => 'LIKE'
        ),
        array(
            'key' => 'latitude',
            'value' => sprintf(';i:%d;', $value),
            'compare' => 'LIKE'
        )
    )
);

Acabo de trabajar con campos serializados y pude consultarlos. No usando meta_query sino usando una consulta SQL.

global $wpdb; 

$search = serialize('latitude').serialize(50);

$query = $wpdb->prepare("SELECT `post_id`
FROM `wp_postmeta`
WHERE `post_id` IN (SELECT `ID` FROM `wp_posts` WHERE `post_type` = 'my-post-type')
AND `meta_key` = '_coordinates'
AND `meta_value` LIKE '%s'",'%'.$search.'%');

$ids = $wpdb->get_col($query);

$args = array(
    'post__in' => $ids
    'post_type' => 'team' //agrego el tipo porque por defecto será 'post'
);

$posts = get_posts($args);

La consulta primero busca posts con el post_type coincidente para que la cantidad de registros en wp_postmeta sea menor al filtrar. Luego agregué una condición WHERE para reducir aún más las filas filtrando por meta_key

Los IDs terminan ordenados en un array como se necesita para get_posts.

PD: Se necesita MySQL v5.6 o superior para un buen rendimiento de las subconsultas

Un truco sencillo para esta situación es usar la comparación LIKE con el formato serializado (longitud con tipo y el valor en sí) como se muestra a continuación:

$id = 123; // ID que se verificará en los datos serializados.
//(asumiendo que los números se almacenan como cadena. En mi caso así fue.)

$args = array(
    'post_type' => 'custom_post_type',
    'meta_query' => array(
        array(
            'key' => 'meta_key_to_check_from',
            'value' => 's:' . strlen($id) . ':"' . $id . '";',
            'compare' => 'LIKE'
        )
    )
);

$query = new WP_Query( $args );

Si es una taxonomía personalizada para buscar:

$id = 123; // ID que se verificará en los datos serializados.
//(asumiendo que los números se almacenan como cadena. En mi caso así fue.)

$args = array(
    'hide_empty' => false, // también recupera términos que aún no se han usado
    'meta_query' => array(
        array(
            'key' => 'meta_key_to_check_from',
            'value' => 's:' . strlen($id) . ':"' . $id . '";',
            'compare' => 'LIKE'
        )
    ),
    'taxonomy' => 'custom_taxonomy'
);

$terms = get_terms( $args );

Este ejemplo realmente me ayudó. Es específicamente para el plugin S2Members (que serializa los metadatos de usuario). Pero te permite consultar una porción de un arreglo serializado dentro de la meta_key.

Funciona utilizando la función REGEXP de MySQL.

Aquí está la fuente

Aquí está el código que consulta todos los usuarios que viven en EE.UU. Lo modifiqué fácilmente para consultar uno de mis campos de registro personalizados y lo tuve funcionando en poco tiempo.

  <?php
global $wpdb;
$users = $wpdb->get_results ("SELECT `user_id` as `ID` FROM `" . $wpdb->usermeta . 
          "` WHERE `meta_key` = '" . $wpdb->prefix . "s2member_custom_fields' AND 
           `meta_value` REGEXP '.*\"country_code\";s:[0-9]+:\"US\".*'");
if (is_array ($users) && count ($users) > 0)
    {
        foreach ($users as $user)
            {
                $user = /* Obtener el objeto de Usuario completo ahora. */ new WP_User ($user->ID);
                print_r($user); /* Obtener una lista completa de propiedades al depurar. */
            }
    }
?>

Después de leer varios consejos sobre cómo ejecutar una consulta WP_Query filtrando por arrays serializados, aquí está cómo finalmente lo resolví: creando un array de valores separados por comas usando implode junto con una consulta SQL personalizada utilizando $wpdb y la función FIND_IN_SET para buscar en la lista separada por comas el valor solicitado.

(esto es similar a la respuesta de Tomás, pero es un poco menos intensivo en rendimiento para la consulta SQL)

1. En functions.php:

En tu archivo functions.php (o donde estés configurando el meta box) dentro de la función yourname_save_post() usa:

update_post_meta($post->ID, 'checkboxArray', implode(",", $checkboxArray)); //añadiendo el implode

para crear el array conteniendo los valores separados por comas.

También querrás cambiar tu variable de salida en la función de construcción del meta box administrativo yourname_post_meta() a:

$checkboxArray = explode(",", get_post_custom($post->ID)["checkboxArray"][0]); //añadiendo el explode

2. En el archivo PHP de la plantilla:

Prueba: si ejecutas un get_post_meta( $id ); deberías ver checkboxArray como un array conteniendo tus valores separados por comas en lugar de un array serializado.

Ahora, construimos nuestra consulta SQL personalizada usando $wpdb.

global $wpdb;

$search = $post->ID;

$query = "SELECT * FROM wp_posts
          WHERE FIND_IN_SET( $search, (
              SELECT wp_postmeta.meta_value FROM wp_postmeta
              WHERE wp_postmeta.meta_key = 'blogLocations'
              AND wp_postmeta.post_id = wp_posts.ID )
          )
          AND ( wp_posts.post_type = 'post' )
          AND ( wp_posts.post_status = 'publish' );";

$posts = $wpdb->get_results($query);

foreach ($posts as $post) {
    //tu contenido del post aquí
}

Observa el FIND_IN_SET, ahí es donde ocurre la magia.

Ahora... dado que estoy usando SELECT * esto devuelve todos los datos del post y dentro del foreach puedes mostrar lo que quieras de eso (haz un print_r($posts); si no sabes qué está incluido. No configura "el loop" por ti (prefiero que sea así), pero puede modificarse fácilmente para configurar el loop si lo prefieres (echa un vistazo a setup_postdata($post); en el codex, probablemente necesitarás cambiar SELECT * para seleccionar solo IDs de posts y $wpdb->get_results al tipo correcto de $wpdb -- consulta el codex sobre $wpdb también para información sobre ese tema).

Bueno, requirió un poco de esfuerzo, pero dado que wp_query no soporta hacer 'compare' => 'IN' con valores serializados o separados por comas, ¡esta solución es tu mejor opción!

Espero que esto ayude a alguien.

Si utilizas el operador de comparación like en tu consulta meta, debería funcionar correctamente para buscar dentro de un array serializado.

$wp_user_search = new WP_User_Query(array(
    'meta_query' => array(
        array(
            'key'     => 'wp_capabilities',
            'value'   => 'subscriber',
            'compare' => 'not like'
            )
        )
    )
);

resulta en:

[query_where] => WHERE 1=1 AND (
  ( wp_usermeta.meta_key = 'wp_capabilities' 
  AND CAST(wp_usermeta.meta_value AS CHAR) NOT LIKE '%subscriber%' )

Si mis metadatos son de tipo array, uso este método para consultar por meta:

$args = array(
    'post_type' => 'fotobank',
    'posts_per_page' => -1,
    'meta_query' => array(
            array(
                   'key' => 'collections',
                   'value' => ':"'.$post->ID.'";',
                   'compare' => 'LIKE'
            )
     )
);
$fotos = new WP_Query($args);

Me llamó la atención las respuestas anteriores donde el meta_query apuntaba a la clave latitude en lugar de _coordinates. Tuve que ir y probar si realmente era posible en las meta queries apuntar a una clave específica dentro de un array serializado. :)

Obviamente ese no era el caso.

Así que, ten en cuenta que la clave correcta a la que apuntar es _coordinates en lugar de latitude.

$args = array(
     'post_type' => 'my-post-type',
     'meta_query' => array(
         array(
             'key' => '_coordinates',
             'value' => sprintf(':"%s";', $value),
             'compare' => 'LIKE'
         )
     )
 );

NOTAS:

1. Este enfoque solo permite apuntar a coincidencias exactas. Así que cosas como todas las latitudes mayores que 50 no son posibles.

2. Para incluir coincidencias de substrings, se podría usar 'value' => sprintf(':"%%%s%%";', $value),. (no lo he probado)

Puedes encerrar el valor con % para consultar el valor serializado:

$args = array(
    'post_type' => 'my-post-type',
    'meta_query' => array(
        array(
            'key' => 'latitude',
            'value' => '%' . 50 . '%',
            'compare' => '>'
        )
    )
 );
$query = new WP_Query( $args );

Tengo la misma pregunta. ¿Quizás necesites el parámetro 'type'? Echa un vistazo a esta pregunta relacionada: Consulta de Campos Personalizados - Meta Valor es un Array

Tal vez prueba con:

    $args = array(
    'post_type' => 'my-post-type',
    'meta_query' => array(
        array(
            'key' => 'latitude',
            'value' => '50',
            'compare' => '>',
            'type' => 'numeric'
        )
    )
    );

Me encontré con algo similar mientras usaba el plugin Magic Fields. Esto podría funcionar:

$values_serialized = serialize(array('50'));
$args = array(
    'post_type' => 'my-post-type',
    'meta_query' => array(
        array(
            'key' => 'latitude', // Clave del campo personalizado
            'value' => $values_serialized, // Valor serializado para comparar
            'compare' => '>' // Operador de comparación (mayor que)
        )
    )
);