Minn\Query

The clause for the posts an author's lists count, as the reader may see them.

ASC when asked for, DESC for anything else.

The ORDER BY body for the query's orderby and order ('' for none).

One orderby key as SQL, or '' when the reference does not take it: a column, the meta value (as a number when asked), a named meta clause's cast value, or the FIELD() list keeping comment__in's order.

LIMIT from number, and the offset (or the page when no offset is given). @param array<string, mixed> $qv

The week of a column as the reference counts it from the site's first day of the week.

Whether a clause's date values are valid, with a notice for each part out of range (week up to the given year's ISO weeks, 53 without one) and for a month and day that make no date (in a leap year when no year is given, and only once every part is in range); before and after given as parts are checked too (probes query-clauses, query-clause-internals). An empty clause is not valid.

Sanitises to the reference's shape: every level carries column, compare and relation.

Whether a date query is one clause rather than a group of them.

A column name as "table.column", the default for anything unknown.

Has the valid columns pass through a filter (WP_Date_Query hands it date_query_valid_columns).

The WHERE fragment for a date query.

A query or group as the reference's get_sql_for_query returns it, indented for its depth. @return array{join: string, where: string}

One clause's pieces, before they are joined: the bounds, the date parts in order (a part whose value builds to nothing, or to 0, is left out), then the time.

A value as the comparison wants it (build_value): a list of numbers for IN, exactly two for BETWEEN, one number otherwise; false when the value does not fit.

The time of day (build_time_query): listed or ranged parts each on their own; a single part by its function; an hour with a second and no minute not at all; otherwise the parts as one decimal, DATE_FORMAT( col, '%H.%i%s' ). False when no part is given.

A full datetime from a string or a parts array. A string as precise as a year, a month, a day or a minute is read as those parts, so an end bound reaches the end of its unit; any other string is read as a time in the site's zone. Missing parts start (or end) the unit.

A comparison upper-cased, = for anything the reference does not know.

Normalises a raw meta_query: clauses get key/value/compare/type defaults, a nested group its relation, and a "relation" key sits on every level. Named clauses keep their names.

A clause rather than a group: it names a key or a value.

The JOIN and WHERE fragments for a meta query.

The whole query's JOIN and WHERE (get_sql_clauses), each clause given its alias in place. @return array{join: string, where: string}

A group's JOIN and WHERE (get_sql_for_query), indented for its depth; each clause is given its alias in place, so its siblings can share it.

One clause's JOIN and WHERE pieces (get_sql_for_clause): the clause is settled in place (compare, compare_key, then its alias and cast), its alias shared with a compatible sibling or a new join.

Has every clause's shared alias (or false) pass through a filter (WP_Meta_Query hands it meta_query_find_compatible_table_alias).

The alias of a sibling the clause can share (find_compatible_table_alias): under OR, the first sibling already given an alias whose comparison, like the clause's, reads the same join; false otherwise.

The clauses the last build resolved, by name.

Whether any level of the query relates two or more clauses by OR.

The CAST target for a clause type; CHAR means no cast.

The clause for some mime types, against a table's column when one is named. @param string|list<string> $types

A site query's conditions, in the reference's order: the ids, the networks, domains, paths, the flags, the languages, then the search (across the columns asked for, as $columns lets plugins change them).

A network query's conditions: the ids, domains, paths, then the search.

A site query's search across columns, each a LIKE on the term anywhere, its stars wildcards.

A network query's search: the same LIKEs, its stars kept.

A site query's ORDER BY, or '' (an unknown column is passed over). @param array<string, mixed> $qv

One column a site query orders by, as written; null for one it does not. @param array<string, mixed> $qv

A network query's ORDER BY, or ''. @param array<string, mixed> $qv

One column a network query orders by, as written; null for one it does not. @param array<string, mixed> $qv

ASC when asked for, in any case; anything else is DESC.

The LIMIT for a number and an offset; none without a number. @param array<string, mixed> $qv

The request from its clauses, joined as the reference joins them.

The ids a request finds. @return list<int>

The count a counting request reads.

A table's row by its id, or null when there is none.

The rows a counted request found.

ASC when asked for, DESC for anything else.

The ORDER BY body for the query's orderby and order, settling both in $q as the reference leaves them (a random or a given-order sort has no direction; a string orderby is url-decoded and slashed).

One orderby key as SQL, or false when the reference does not take it: a column, RAND() (seeded when asked), the primary meta clause's value (cast when it has a type), a named meta clause's cast value, or the FIELD() list that keeps post__in, post_name__in or post_parent__in in the order given.

The terms a search string becomes and how many it was split into.

The terms worth searching: quotes trimmed (a quoted term keeps its inner spaces), and a single letter or dash, or a stopword, dropped.

The stopword list from its comma-separated (translated) form.

The searched columns: those given that the reference searches, or all three.

The search's WHERE fragment (no password clause; a visitor's search adds one) and the title matches its order ranks by. An exact search passes no wildcard, and asks for no title matches.

The relevance order: for several terms, the whole string in the title, then every term, then any term (up to six), then the whole string in the excerpt and the content (no sentence match when a term is negated); for one term, its title match.

A quoted string literal.

The reference's escaping: backslash, quotes, NUL, newlines, and the substitute character.

A LIKE operand with its wildcards escaped; quote() afterwards.

A comma list of quoted literals.

Clauses joined as the reference joins them at every depth (probe query-clauses): wrapped in parentheses, each clause and the relation on its own line, indented two spaces a level.

The query as the reference keeps it: each clause merged over the defaults (taxonomy, terms as a list, field term_id, operator IN, children included), a nested group given relation AND when it has none, an empty group dropped. The top level keeps a relation only when one was given.

Whether a query part is a clause (it names a clause key, or is empty) rather than a group.

The terms a sanitized query asks for, by taxonomy: the first terms and the first field each taxonomy's clauses give, NOT IN clauses aside.

The JOIN and WHERE fragments for a taxonomy query.

The whole query's JOIN and WHERE (get_sql_clauses), each clause settled in place. @return array{join: string, where: string}

A group's JOIN and WHERE (get_sql_for_query), indented for its depth. @return array{join: string, where: string}

One clause's JOIN and WHERE pieces (get_sql_for_clause). Its terms are turned into term_taxonomy_ids in place; an IN clause reads term_relationships under an alias it shares with a compatible sibling or joins anew, and keeps that alias. A term nobody has yields "0 = 1" (nothing at all for NOT IN).

The alias of an IN sibling the clause can share under OR (find_compatible_table_alias), or false.