Sortare după valoarea meta, incluzând și postările care nu au una

Simplu și eficient, testat în 2018, folosit în producție în prezent.

Actualizare 2022: Modificat astfel încât interogarea NOT_EXISTS să fie înaintea interogării EXISTS și clarificat efectul pe care îl au mai multe chei asupra clauzei orderby.

$query->set( 'meta_query', array(
    'relation' => 'OR',
    array(
        'key' => 'custom_meta_key', 
        'compare' => 'NOT EXISTS'
    ),
    array(
        'key' => 'custom_meta_key', 
        'compare' => 'EXISTS'
    ),
) );
$query->set( 'orderby', 'meta_value title' ); 

Aceasta verifică toate elementele cu și fără cheia meta, fără a specifica o valoare. Interogarea meta furnizează cheia pentru orderby în mod fiabil. A fost testat. Clauza orderby cu meta_value/meta_value_num va folosi ultima chei din lanț.

Exemplu practic

/**
 * Modifică interogarea înainte de preluarea postărilor. Setează 
 * parametrii `meta_query` și `orderby` când niciun parametru `orderby` 
 * nu este setat (ordonare implicită).
 * 
 * @param   WP_Query  $query  Obiectul complet `WP_Query`.
 * @return  void
 */
function example_post_ordering( $query ) {
    
    // dacă nu suntem în wp-admin, 
    // și interogarea este interogarea principală, 
    // și interogarea nu este singulară, 
    // și interogarea nu are setat niciun parametru orderby...
    // Notă: verificați tipurile de postări, etc. aici după necesitate.
    if ( ! is_admin() 
    && $query->is_main_query() 
    && ! $query->is_singular() 
    && empty( $query->get( 'orderby' ) ) ) {
        
        // Setarea doar a `meta_key` nu este suficientă, deoarece aceasta 
        // va ignora postările care nu au încă sau nu vor avea niciodată 
        // o valoare pentru cheia specificată. Această interogare meta va 
        // înregistra `meta_key` pentru ordonare, dar nu va ignora acele postări fără o valoare pentru această cheie.
        $query->set( 'meta_query', array(
            'relation' => 'OR',
            array(
                'key' => 'custom_meta_key', 
                'compare' => 'NOT EXISTS'
            ),
            array(
                'key' => 'custom_meta_key', 
                'compare' => 'EXISTS'
            ),
        ) );

        // Ordonează după valoarea meta, apoi după titlu dacă mai multe 
        // postări au aceeași valoare pentru cheia meta furnizată.
        // Folosiți `meta_value_num` dacă valorile meta sunt numerice.
        $query->set( 'orderby', 'meta_value title' );
    }

}

add_action( 'pre_get_posts', 'example_post_ordering', 10 );

Aceasta va ordona postările după custom_meta_key în mod implicit și nu va ignora postările fără o valoare pentru acea cheie.

Această metodă va returna toate articolele, inclusiv cele cu și fără meta_key solicitat, dar va produce rezultate ciudate la sortare.

add_action('pre_get_posts', 'my_stuff');
function my_stuff ($qry) {
    $qry->set(
        'meta_query',
        array(
            'relation' => 'OR', # Potrivirile pentru acest meta_query ar trebui adăugate la cele care corespund interogării 'meta_key'
            array(
                'key' => 'item_price', 
                'value' => 'bug #23268', 
                'compare' => 'NOT EXISTS'
            )
        )
    );

    $qry->set('orderby', 'meta_value date'); # Sortarea funcționează cu meta_value precum și meta_value_num - am încercat pe ambele
    $qry->set('order', 'ASC DESC');
    $qry->set('meta_key', 'item_price');
}

Am descoperit acest lucru prin experimentarea diferitelor răspunsuri la această întrebare și analizând SQL-ul generat prin încercări și erori. Se pare că setarea array('meta_query' => array('relation' => 'OR')) produce un LEFT JOIN adecvat în loc de INNER JOIN, care este necesar pentru a include articolele care nu au metadatele. Specificarea NOT EXISTS previne clauza WHERE să filtreze articolele care nu au câmpul meta. Pentru această interogare WP_Query specifică, SQL-ul generat este (cu indentare și linii noi adăugate):

SELECT SQL_CALC_FOUND_ROWS
    wp_posts.ID
    FROM wp_posts
    INNER JOIN wp_term_relationships ON (wp_posts.ID = wp_term_relationships.object_id)
    INNER JOIN wp_postmeta ON wp_posts.ID = wp_postmeta.post_id
    LEFT JOIN wp_postmeta AS mt1 ON (wp_posts.ID = mt1.post_id AND mt1.meta_key = 'item_price')
    WHERE 1=1
    AND ( wp_term_relationships.term_taxonomy_id IN (2) )
    AND wp_posts.post_type = 'post'
    AND (wp_posts.post_status = 'publish'
        OR wp_posts.post_status = 'private')
    AND (wp_postmeta.meta_key = 'item_price'
        -- Uite, aici dăm permisiune SQL să aleagă un rând
        -- aleatoriu din wp_postmeta când acest articol nu are
        -- 'item_price':
        OR  mt1.post_id IS NULL )
    GROUP BY wp_posts.ID
    ORDER BY wp_postmeta.meta_value,wp_posts.post_date DESC
    LIMIT 0, 10

Rezultatul este o listă cu toate articolele care au meta_value pentru item_price și cele care nu au item_price. Toate articolele cu item_price vor fi sortate corect între ele, dar articolele fără item_price vor folosi o valoare meta aleatorie altă (de exemplu, _edit_last care pare să fie 1 destul de des în baza mea de date sau altă metadadă internă WordPress complet arbitrară) pentru wp_postmeta.meta_value în clauza ORDER BY. Deci, deși această metodă este aproape și poate părea să funcționeze pentru anumite date, este defectă. Așadar, tot ce pot spune este că, dacă valorile tale pentru item_price nu intră în conflict cu câmpurile meta aleatoare pe care MySQL le alege pentru articolele fără item_price, această metodă ar putea funcționa pentru tine. Dacă tot ce ai nevoie este să te asiguri că articolele tale cu item_price sunt sortate corect între ele, fără a ține cont de ordonarea celorlalte articole, poate fi OK. Dar cred că aceasta este o limitare în WordPress. Te rog corectează-mă, sper să greșesc și să existe o soluție ;-).

Se pare că pentru INNER JOIN wp_postmeta, MySQL alege un rând aleatoriu dintre multiplele rânduri postmeta asociate cu articolul atunci când meta_key lipsește din articolul respectiv. Din perspectiva SQL, trebuie să ne dăm seama cum să-i spunem WordPress să genereze ORDER BY mt1.meta_value. Această coloană este corect NULL când meta_key-ul nostru solicitat lipsește, spre deosebire de wp_postmeta.meta_value. Dacă am putea face asta, SQL ar sorta aceste intrări NULL (lipsă) înaintea oricărei alte valori, oferindu-ne o ordine bine definită: mai întâi toate articolele fără câmpul meta specificat, apoi cele care au câmpul. Dar aceasta este tocmai problema: 'orderby' => 'meta_value' se poate referi doar la 'meta_key' => 'item_price' și wp_postmeta fără alias este întotdeauna un INNER JOIN în loc de un LEFT JOIN, ceea ce înseamnă că wp_postmeta.meta_value și wp_postmeta.meta_key nu pot fi niciodată NULL.

Deci, cred că trebuie să spun că acest lucru nu este posibil cu WP_Query integrat în WordPress așa cum este documentat acum (în WordPress-3.9.1). Enervant. Deci, dacă chiar ai nevoie ca acest lucru să funcționeze corect, probabil că trebuie să te conectezi altundeva în WordPress și să modifici direct SQL-ul generat.

Problema pe care o are toată lumea aici are legătură cu ordinea interogărilor meta. Pentru a sorta corect, va trebui să plasați interogarea "NOT EXISTS" înainte de interogarea "EXISTS".

Motivul pentru aceasta este că WordPress utilizează meta_value din ultima instrucțiune "LEFT JOIN" din clauza "ORDER BY".

De exemplu:

$pageQuery = new WP_Query([
    'meta_query' => [
        'relation' => 'OR',
        ['key' => 'item_price', 'compare' => 'NOT EXISTS'], // aceasta vine primul!
        ['key' => 'item_price', 'compare' => 'EXISTS'],
    ],
    'order' => 'DESC',
    'orderby' => 'meta_value_num',
    'post_status' => 'publish',
    'post_type' => 'page',
    'posts_per_page' => 10,
]);

Am întâlnit și eu o problemă similară și următoarea soluție m-a ajutat:

$args = array(
'post_type' => 'kosh_products',
'posts_per_page' => -1,
'meta_query' => array(
    'relation' => 'OR',
    'category_sort_order' => array(
        'key' => '_sort_order',
        'compare' => 'EXISTS'
    ),
    'category_sort_order_not_exists' => array(
        'key' => '_sort_order',
        'compare' => 'NOT EXISTS'
    ), 
),
'orderby' => array( 
    'category_sort_order' => 'ASC',
    'date' => 'ASC'
));
$query = new WP_Query( $args );

Am găsit o descriere pe WordPress Codex cu titlul "'orderby' cu multiple 'meta_key'-uri": https://codex.wordpress.org/Class_Reference/WP_Query#Order_.26_Orderby_Parameters

Cred că am o soluție.

Poți folosi două meta_key-uri, unul pe care îl au toate articolele (cum ar fi "_thumbnail_id"), și meta_key-ul pe care dorești să-l folosești ca filtru.

Deci argumentele tale:

$qry->set(
    'meta_query',
    array(
        'relation' => 'OR',
        array(
            'key' => 'item_price', 
            'value' => '', 
            'compare' => 'EXISTS'
        ),
        array(
            'key' => 'item_price', 
            'value' => '', 
            'compare' => 'EXISTS'
        )
    )
);

$qry->set('orderby', 'meta_value date'); # Sortarea funcționează cu meta_value la fel ca și meta_value_num - am încercat ambele
$qry->set('order', 'ASC DESC');
$qry->set('meta_key', 'item_price');

Am avut aceeași problemă cu valorile meta numerice și am observat că ordinea interogării este importantă. Pentru mine, interogarea NOT EXISTS trebuie să fie prima.

Exemplu:

$query->set( 'orderby', 'meta_value_num' );
$query->set( 'meta_query', [
    'relation' => 'OR',
    [ 'key' => 'your_meta_name', 'compare' => 'NOT EXISTS' ],
    [
        'key' => 'your_meta_name',
        'compare' => 'EXISTS',
    ],
] );

De asemenea, pentru a obține direcția corectă pentru valorile numerice, este important ca ’orderby’ general să fie setat la ’meta_value_num’. Altfel, veți obține rezultate ciudate pentru valorile numerice, de exemplu:

1, 2, 20, 21, 3, 4, 5 …

În loc de:

1, 2, 3, 4, 5 … 20, 21

Interogarea meta OR care combină NOT EXISTS și EXISTS funcționează, dar a cauzat o interogare lentă.

Această soluție funcționează mult mai rapid.

Cheia principală a fost în clauza SQL order by: order by YOUR_FIELD is NULL, YOUR_FIELD

add_filter('posts_orderby', function (string $orderby, WP_Query $query) {
    if ('MY_CUSTOM_SORT' === $query->get('orderby')) {
        $orderby = "mta.meta_value is NULL, mta.meta_value ='', mta.meta_value ASC";
    }
    return $orderby;
}, 10, 2);

add_filter('posts_join', function (string $join, WP_Query $query) {
    if ('MY_CUSTOM_SORT' === $query->get('orderby')) {
        $join .= " LEFT JOIN wp_postmeta AS mta ON ( wp_posts.ID = mta.post_id AND mta.meta_key = 'SOME_META_KEY')";
    }
    return $join;
}, 10, 2);

Și în argumentele WP_Query:

$args['orderby'] = 'MY_CUSTOM_SORT';

Aceasta este o întrebare foarte veche, dar niciunul dintre răspunsuri nu a fost suficient de robust pentru mine să le folosesc și să fiu mulțumit de rezultate. Soluția de mai jos folosește în continuare WP_Query, dar manipulează instrucțiunile de join și order by.

Folosește o funcție MySQL numită ORDER BY IF, care îți permite să rulezi logică în timpul instrucțiunii ORDER BY. Acest lucru este important deoarece celelalte soluții de aici doar grupează rezultatele fără valoare, fie la început, fie la sfârșitul listei, ceea ce este inutil atunci când încerci să ordonezi după 2 chei.

În exemplul de mai jos am un CPT (Custom Post Type) numit 'businesses'. Vreau să le ordonez pe toate după titlu, dar cele care au is_premium să apară primele. Am comentat codul pentru a înțelege ce se întâmplă în fiecare parte.

<?php
$paged = ( get_query_var( 'paged' ) ) ? get_query_var( 'paged' ) : 1;
$args = [
    'post_type' => 'business',
    'posts_per_page' => 12,
    'meta_query' => [
        'relation' => 'OR',
        [
            'key' => 'is_premium', 
            'compare' => 'NOT EXISTS' // NOT EXISTS este important să fie primul
        ],
        [
            'key' => 'is_premium', 
            'compare' => 'EXISTS'
        ],
    ]
    ,
    'orderby' => [
        'meta_value' => 'DESC', // Acesta este câmpul is_premium
        'title' => 'ASC',
    ],
    'paged' => $paged
];

// Adăugăm propriul nostru join la interogare
function custom_join($join) {
    global $wpdb;

    if( ! is_admin() ) {
        $join .= $wpdb->prepare(
        ' LEFT JOIN ' . $wpdb->postmeta . ' cpm ON cpm.post_id = ' . $wpdb->posts . '.ID AND cpm.meta_key = %s'
        , 'is_premium' );
    }

    return $join;
}
add_filter('posts_join','custom_join');

// Adăugăm propriul nostru order by la interogare
function custom_orderby($orderby_statement){
    global $wpdb;

    if ( ! is_admin() ) {
        // Aici ordonăm după meta_value DOAR dacă este 1, altfel o ignorăm pentru acea instrucțiune de ordonare,
        // ceea ce înseamnă că va fi ordonată după următoarea instrucțiune (titlu), la fel ca celelalte rezultate
        $orderby_statement = "IF(cpm.meta_value = 1, 1, 0) DESC, wp_posts.post_title ASC ";
    }

    return $orderby_statement;
}
add_filter('posts_orderby','custom_orderby', 10, 2 ); 

// Interogare
$business = new WP_Query( $args );

// Eliminăm filtrele
remove_filter('posts_orderby','custom_orderby');
remove_filter('posts_join','custom_join');

Dacă este potrivit, poți adăuga o valoare meta implicită de fiecare dată când un articol este salvat sau actualizat, dacă valoarea meta nu există.

function addDefaultMetaValue($post_id) {
    add_post_meta($post_id, 'item_price', 0, true);
}
add_action('save_post', 'addDefaultMetaValue');

Dacă folosești un tip de postare personalizat, înlocuiește add_action('save_post', 'addDefaultMetaValue'); cu add_action('save_post_{post_type}', 'addDefaultMetaValue'); de exemplu add_action('save_post_product', 'addDefaultMetaValue');

Există o valoare posibilă pentru orderby și anume meta_value pentru aceasta.

$query = new WP_Query( array ( 
    'meta_key'   => 'numele_cheii_dvs',
    'orderby'    => 'meta_value',
    'order'      => 'DESC',
    'meta_query' => array( array(
         'key'     => 'cheia_meta_dvs',
         'value'   => '',
         'compare' => 'NOT EXISTS',
         // 'type'    => 'CHAR',
    ) )
) );

Dacă aveți valori numerice, folosiți meta_value_num în schimb.

Atenție: Acest cod nu a fost testat, dar ar trebui să funcționeze. Ideea este că trebuie să specificați valorile pentru meta_key și key. Altfel, nu puteți compara cu valori inexistente, ceea ce ar trebui să facă posibilă interogarea ambelor tipuri de articole. Este un pic hack-ish, dar atâta timp cât funcționează...

Această soluție a funcționat pentru mine:

add_action( 'pre_get_posts', 'orden_portfolio' );
function orden_portfolio( $query ) {

    if( ! is_admin() ) {

        $query->set( 'orderby', 'meta_value_num' );
        $query->set( 'order', 'ASC' );
        $query->set( 'meta_query', [
            'relation' => 'OR',
            [ 
                'key' => 'ce_orden', 
                'compare' => 'NOT EXISTS' ],
            [
                'key' => 'ce_orden',
                'compare' => 'EXISTS',
            ],
        ] );

        return $query;

    }

}

Cu toate acestea, această soluție afișează mai întâi înregistrările cu meta_value null. Această altă soluție afișează ordinea ASC și valorile null la sfârșit:

function custom_join($join) {
    global $wpdb;

    if( ! is_admin() ) {
        $join .= $wpdb->prepare(
        ' LEFT JOIN ' . $wpdb->postmeta . ' cpm ON cpm.post_id = ' . $wpdb->posts . '.ID AND cpm.meta_key = %s'
        , 'ce_orden' );
    }

    return $join;
}

add_filter('posts_join','custom_join');

function custom_orderby($orderby_statement){
    global $wpdb;

    if ( ! is_admin() ) {
        $orderby_statement = "CAST( COALESCE(cpm.meta_value,99999) as SIGNED INTEGER) ASC";
    }

    return $orderby_statement;
}

add_filter('posts_orderby','custom_orderby', 10, 2 ); 

Am reușit să rezolv această problemă folosind o singură interogare și argumentele corecte. WP 4.1+

$args = array( 
    'posts_per_page' => -1, 
    'post_status' => 'publish',
    'meta_query' => array(
        'relation' => 'OR',
        array(
            'key' => 'custom_sort',
            'compare' => 'EXISTS'
        ),
        array(
            'key' => 'custom_sort',
            'compare' => 'NOT EXISTS'
        )
    ),
    'orderby' => 'meta_value_num title',
    'order' => 'ASC',
));

$query = new WP_Query($args);

Vedeți răspunsul meu complet aici: https://wordpress.stackexchange.com/a/370841/15209

Am reușit să rezolv această problemă cu un mic hack (în opinia mea), dar a funcționat în cazul meu.

Poți folosi filtrele posts_join_paged și posts_orderby pentru a actualiza șirurile de join și orderby. Acest lucru îți va permite să sortezi după orice dorești, atâta timp cât faci join-ul mai întâi, în loc ca WP_Query să presupună că acel câmp trebuie să existe pentru acel post specific. Apoi poți elimina argumenții meta_key, orderby și `order din WP_Query.

Mai jos este un exemplu. La începutul fiecărei funcții a trebuit să adaug condiții de ieșire pentru anumite cazuri, deoarece acest cod se va aplica la tot ce folosește WP_Query. Poate va trebui să modifici asta pentru nevoile tale specifice.

Documentația pentru aceste două filtre este, din păcate, foarte limitată... noroc! :)

add_filter('posts_join_paged', 'edit_join', 999, 2);
add_filter('posts_orderby', 'edit_orderby', 999, 2);

/**
 * Modifică join-ul
 *
 * @param string $join_paged_statement
 * @param WP_Query $wp_query
 * @return string
 */
function edit_join($join_paged_statement, $wp_query)
{
    global $wpdb;
    if (
        !isset($wp_query->query)
        || $wp_query->is_page
        || $wp_query->is_admin
        || (isset($wp_query->query['post_type']) && $wp_query->query['post_type'] != 'my_custom_post_type')
    ) {
        return $join_paged_statement;
    }

    $join_to_add = "
        LEFT JOIN {$wpdb->prefix}postmeta AS my_custom_meta_key
            ON ({$wpdb->prefix}posts.ID = my_custom_meta_key.post_id
                AND my_custom_meta_key.meta_key = 'my_custom_meta_key')
    ";

    // Adaugă doar dacă nu există deja
    if (strpos($join_paged_statement, $join_to_add) === false) {
        $join_paged_statement = $join_paged_statement . $join_to_add;
    }

    return $join_paged_statement;
}

/** 
 * Modifică orderby
 *
 * @param string $orderby_statement
 * @param WP_Query $wp_query
 * @return string
 */
function edit_orderby($orderby_statement, $wp_query)
{
    if (
        !isset($wp_query->query)
        || $wp_query->is_page
        || $wp_query->is_admin
        || (isset($wp_query->query['post_type']) && $wp_query->query['post_type'] != 'my_custom_post_type')
    ) {
        return $orderby_statement;
    }

    $orderby_statement = "my_custom_meta_key.meta_value DESC";

    return $orderby_statement;
}

Am ajuns să utilizez filtrul 'get_meta_sql' pe care WordPress îl oferă

add_filter( 'get_meta_sql', 'adjust_the_meta_sql' ), 10, 2 );

Funcția arată astfel

function adjust_the_meta_sql( $sql, $queries ) {
            if ( 'my_post_type' === filter_input( INPUT_GET, 'post_type' )
                && '_my_key' === $queries[0]['key'] ) {
                $sql['join']  = preg_replace( '/INNER JOIN wp_postmeta ON \(([^)]+)\)/', 'LEFT JOIN wp_postmeta ON ($1 ' . $sql['where'] . ')', $sql['join'] );
                $sql['where'] = '';
            }
            return $sql;
        }

Acest cod rezolvă două probleme cu SQL-ul generat de WordPress.

1. Transformă INNER JOIN într-un LEFT JOIN
2. Mută clauza WHERE în clauza ON.

Interogarea ta poate fi diferită, așa că asigură-te să testezi și să ajustezi după caz.

Cred că @kaiser a încercat să spună că interogarea ar trebui să returneze toate articolele care au acea cheie meta prin aplicarea unei condiții de tip where pentru a nu filtra niciunul dintre acele articole. Deci, dacă știi că toate valorile pe care le pot lua câmpurile personalizate sunt x,y,z, ai putea spune "WHERE meta_key IN(x,y,z)", dar ideea este că poți evita această problemă spunând pur și simplu != (''):

$query = new WP_Query( array ( 
    'orderby'    => 'meta_value_num',
    'order'      => 'DESC',
    'meta_query' => array( array(
         'key'     => 'item_price',
         'value'   => '',
         'compare' => '!=',
    ) )
) );

De asemenea, nu am testat, dar pare că merită încercat :-).

Băieți, mulțumesc pentru toate răspunsurile valide, dar în prezent (2022), imbricarea este cheia:

$query->set( 'orderby', array(
     'meta_value_num' => 'DESC',
     'title' => 'ASC' )
); // ordonează prioritățile

$query->set( 'meta_query', array(
     'featured' => array(
          'relation' => 'OR',
          array(
               'key' => '_featured',
               'value' => '1', // afișează mai întâi postările cu valoarea = 1
          ),
          array( // aceste reguli imbricate au o prioritate mai mică pentru ordonare, dar ne asigură că afișăm toate celelalte postări
               'relation' => 'OR',
               array(
                    'key' => '_featured',
                    'compare' => 'NOT EXISTS', // se explică de la sine
               ),
               array(
                    'key' => '_featured',
                    'value' => '0', // cazul în care valoarea există, dar trebuie considerată ca inexistentă
               )
          )
     )
));

Caz bonus: Nu am testat acest lucru, dar dacă metadatele nu au o valoare 0/1, a treia regulă ar trebui să fie:

array(
      'key' => '_featured',
      'value' => '[valoare prioritară]',
      'compare' => '!='
)