FacturaScripts

Where
in package

FinalYes

Representa una cláusula WHERE de SQL y la traduce a un fragmento seguro de SQL para usarla con la conexión de FacturaScripts.

Cada instancia describe una condición simple (campo + operador + valor) o un grupo anidado (operador ( con subWhere). Las condiciones se construyen con los factory estáticos (Where::eq, Where::like, Where::in, Where::between, sus variantes or*, etc.) y se combinan con Where::multiSql() o Where::multiSqlLegacy(), esta última también acepta los antiguos DataBaseWhere para compatibilidad.

Detalles no triviales:

  • El campo admite varios nombres separados por | (FIELD_SEPARATOR): se generan condiciones sobre cada campo unidas con OR y agrupadas entre paréntesis.
  • Los nombres de campo se escapan con escapeColumn(), salvo si llevan paréntesis (se asume expresión SQL válida ya formada por el llamador) o si usan los prefijos integer: (cast a entero) o lower: (envuelve el campo en LOWER(...)).
  • Los valores se serializan con var2str(), así que las APIs estándar son seguras frente a inyección. El prefijo field: solo se interpreta como referencia a otra columna cuando se activa useField(); en caso contrario se trata como literal.
  • Con operador = o !=, un valor null se traduce automáticamente a IS NULL / IS NOT NULL.
  • LIKE y NOT LIKE aplican LOWER(...) a ambos lados y, si el patrón no contiene %, lo envuelven con %...% automáticamente.
  • XLIKE divide el valor por espacios y combina cada palabra con LIKE unidas por AND (búsqueda multipalabra).
  • IN / NOT IN aceptan array, lista separada por comas o, si el string empieza por SELECT, una subconsulta literal.

Table of Contents

Constants

FIELD_SEPARATOR  : mixed = '|'
Separador para indicar varios campos en `$fields`; produce condiciones unidas por OR.

Properties

$fields  : mixed
Nombre del campo (o varios separados por FIELD_SEPARATOR).
$operation  : mixed
Conector con la cláusula previa al concatenar: `AND` u `OR`.
$operator  : mixed
Operador SQL: `=`, `!=`, `<`, `>`, `LIKE`, `IN`, `BETWEEN`, `XLIKE`, ... o `(` para grupos.
$subWhere  : mixed
Cláusulas hijas cuando el operador es `(` (grupo anidado).
$useField  : mixed
Si es true, los valores con prefijo `field:` se interpretan como nombre de columna.
$value  : mixed
Valor a comparar; puede ser escalar, array (IN/BETWEEN) o null (se traduce a IS NULL).
$db  : mixed
Conexión compartida perezosa, instanciada en el primer uso.

Methods

__construct()  : mixed
Construye una cláusula simple. En general es preferible usar los factory estáticos (`eq`, `like`, `in`, ...) en lugar de instanciar directamente.
between()  : self
Crea `campo BETWEEN value1 AND value2`.
column()  : self
Factory genérico que permite especificar operador y conector arbitrarios.
eq()  : self
Crea `campo = value` (o `campo IS NULL` si value es null).
gt()  : self
Crea `campo > value`.
gte()  : self
Crea `campo >= value`.
in()  : self
Crea `campo IN (...)`.
isNotNull()  : self
Crea `campo IS NOT NULL`.
isNull()  : self
Crea `campo IS NULL`.
like()  : self
Crea `LOWER(campo) LIKE LOWER('%value%')`.
lt()  : self
Crea `campo < value`.
lte()  : self
Crea `campo <= value`.
multiSql()  : string
Convierte un array de cláusulas Where en el SQL combinado, sin el prefijo `WHERE`.
multiSqlLegacy()  : string
Variante de `multiSql()` para código legacy: acepta también instancias de `DataBaseWhere` y devuelve el SQL ya prefijado con ` WHERE ` (cadena vacía si el array está vacío).
notBetween()  : self
Crea `campo NOT BETWEEN value1 AND value2`.
notEq()  : self
Crea `campo != value` (o `campo IS NOT NULL` si value es null).
notIn()  : self
Crea `campo NOT IN (...)`. Mismas reglas de `$values` que `in()`.
notLike()  : self
Crea `LOWER(campo) NOT LIKE LOWER('%value%')` con el mismo manejo de comodines que `like()`.
or()  : self
Variante genérica con conector OR.
orBetween()  : self
Equivale a `between()` pero unido a la cláusula previa con OR.
orEq()  : self
Equivale a `eq()` pero unido a la cláusula previa con OR.
orGt()  : self
Equivale a `gt()` pero unido a la cláusula previa con OR.
orGte()  : self
Equivale a `gte()` pero unido a la cláusula previa con OR.
orIn()  : self
Equivale a `in()` pero unido a la cláusula previa con OR.
orIsNotNull()  : self
Equivale a `isNotNull()` pero unido a la cláusula previa con OR.
orIsNull()  : self
Equivale a `isNull()` pero unido a la cláusula previa con OR.
orLike()  : self
Equivale a `like()` pero unido a la cláusula previa con OR.
orLt()  : self
Equivale a `lt()` pero unido a la cláusula previa con OR.
orLte()  : self
Equivale a `lte()` pero unido a la cláusula previa con OR.
orNotBetween()  : self
Equivale a `notBetween()` pero unido a la cláusula previa con OR.
orNotEq()  : self
Equivale a `notEq()` pero unido a la cláusula previa con OR.
orNotIn()  : self
Equivale a `notIn()` pero unido a la cláusula previa con OR.
orNotLike()  : self
Equivale a `notLike()` pero unido a la cláusula previa con OR.
orRegexp()  : self
Equivale a `regexp()` pero unido a la cláusula previa con OR.
orSub()  : self
Equivale a `sub()` pero unido a la cláusula previa con OR.
orXlike()  : self
Equivale a `xlike()` pero unido a la cláusula previa con OR.
regexp()  : self
Crea `campo REGEXP value` (la sintaxis exacta depende del motor, vía `getOperator`).
sql()  : string
Renderiza esta cláusula simple como SQL (sin prefijo `WHERE` ni el conector `operation`).
sub()  : self
Agrupa varias cláusulas en una sub-condición que se renderizará entre paréntesis.
useField()  : self
Habilita la interpretación del prefijo `field:` en los valores para esta condición.
xlike()  : self
Crea una búsqueda multipalabra: divide `$value` por espacios y aplica un LIKE a cada palabra, combinándolos con AND (la fila debe contener todas las palabras).
db()  : DataBase
sqlColumn()  : string
sqlOperatorBetween()  : string
sqlOperatorIn()  : string
sqlOperatorLike()  : string
sqlOperatorXLike()  : string
sqlValue()  : string

Constants

FIELD_SEPARATOR

Separador para indicar varios campos en `$fields`; produce condiciones unidas por OR.

public mixed FIELD_SEPARATOR = '|'

Properties

$fields

Nombre del campo (o varios separados por FIELD_SEPARATOR).

public mixed $fields

@var string

$operation

Conector con la cláusula previa al concatenar: `AND` u `OR`.

public mixed $operation

@var string

$operator

Operador SQL: `=`, `!=`, `<`, `>`, `LIKE`, `IN`, `BETWEEN`, `XLIKE`, ... o `(` para grupos.

public mixed $operator

@var string

$subWhere

Cláusulas hijas cuando el operador es `(` (grupo anidado).

public mixed $subWhere

@var Where[]

$useField

Si es true, los valores con prefijo `field:` se interpretan como nombre de columna.

public mixed $useField

@var bool

$value

Valor a comparar; puede ser escalar, array (IN/BETWEEN) o null (se traduce a IS NULL).

public mixed $value

@var mixed

$db

Conexión compartida perezosa, instanciada en el primer uso.

private static mixed $db

@var DataBase

Methods

__construct()

Construye una cláusula simple. En general es preferible usar los factory estáticos (`eq`, `like`, `in`, ...) en lugar de instanciar directamente.

public __construct(string $fields, mixed $value[, string $operator = '=' ][, string $operation = 'AND' ][, bool $useField = false ]) : mixed
Parameters
$fields : string
$value : mixed
$operator : string = '='
$operation : string = 'AND'
$useField : bool = false

between()

Crea `campo BETWEEN value1 AND value2`.

public static between(string $fields, mixed $value1, mixed $value2) : self
Parameters
$fields : string
$value1 : mixed
$value2 : mixed
Return values
self

column()

Factory genérico que permite especificar operador y conector arbitrarios.

public static column(string $fields, mixed $value[, string $operator = '=' ][, string $operation = 'AND' ]) : self
Parameters
$fields : string
$value : mixed
$operator : string = '='
$operation : string = 'AND'
Return values
self

eq()

Crea `campo = value` (o `campo IS NULL` si value es null).

public static eq(string $fields, mixed $value) : self
Parameters
$fields : string
$value : mixed
Return values
self

gt()

Crea `campo > value`.

public static gt(string $fields, mixed $value) : self
Parameters
$fields : string
$value : mixed
Return values
self

gte()

Crea `campo >= value`.

public static gte(string $fields, mixed $value) : self
Parameters
$fields : string
$value : mixed
Return values
self

in()

Crea `campo IN (...)`.

public static in(string $fields, mixed $values) : self

$values puede ser un array, una lista separada por comas o un string que empiece por SELECT para incrustar una subconsulta literal.

Parameters
$fields : string
$values : mixed
Return values
self

isNotNull()

Crea `campo IS NOT NULL`.

public static isNotNull(string $fields) : self
Parameters
$fields : string
Return values
self

isNull()

Crea `campo IS NULL`.

public static isNull(string $fields) : self
Parameters
$fields : string
Return values
self

like()

Crea `LOWER(campo) LIKE LOWER('%value%')`.

public static like(string $fields, string $value) : self

Si $value ya contiene comodines %, se respetan tal cual; en caso contrario, se envuelve automáticamente con %...%.

Parameters
$fields : string
$value : string
Return values
self

lt()

Crea `campo < value`.

public static lt(string $fields, mixed $value) : self
Parameters
$fields : string
$value : mixed
Return values
self

lte()

Crea `campo <= value`.

public static lte(string $fields, mixed $value) : self
Parameters
$fields : string
$value : mixed
Return values
self

multiSql()

Convierte un array de cláusulas Where en el SQL combinado, sin el prefijo `WHERE`.

public static multiSql(array<string|int, mixed> $where) : string

El conector entre cláusulas (AND/OR) se toma del campo operation de cada elemento; el de la primera se ignora. Los grupos anidados (operador () se renderizan recursivamente entre paréntesis. Lanza Exception si algún elemento no es una instancia de Where.

Parameters
$where : array<string|int, mixed>
Return values
string

multiSqlLegacy()

Variante de `multiSql()` para código legacy: acepta también instancias de `DataBaseWhere` y devuelve el SQL ya prefijado con ` WHERE ` (cadena vacía si el array está vacío).

public static multiSqlLegacy(array<string|int, mixed> $where) : string

Como los antiguos DataBaseWhere no soportaban grupos explícitos, esta función agrupa automáticamente con paréntesis las secuencias consecutivas en las que el siguiente elemento usa operation = 'OR', replicando la precedencia que se asumía históricamente.

Parameters
$where : array<string|int, mixed>
Return values
string

notBetween()

Crea `campo NOT BETWEEN value1 AND value2`.

public static notBetween(string $fields, mixed $value1, mixed $value2) : self
Parameters
$fields : string
$value1 : mixed
$value2 : mixed
Return values
self

notEq()

Crea `campo != value` (o `campo IS NOT NULL` si value es null).

public static notEq(string $fields, mixed $value) : self
Parameters
$fields : string
$value : mixed
Return values
self

notIn()

Crea `campo NOT IN (...)`. Mismas reglas de `$values` que `in()`.

public static notIn(string $fields, mixed $values) : self
Parameters
$fields : string
$values : mixed
Return values
self

notLike()

Crea `LOWER(campo) NOT LIKE LOWER('%value%')` con el mismo manejo de comodines que `like()`.

public static notLike(string $fields, string $value) : self
Parameters
$fields : string
$value : string
Return values
self

or()

Variante genérica con conector OR.

public static or(string $fields, mixed $value[, string $operator = '=' ]) : self
Parameters
$fields : string
$value : mixed
$operator : string = '='
Return values
self

orBetween()

Equivale a `between()` pero unido a la cláusula previa con OR.

public static orBetween(string $fields, mixed $value1, mixed $value2) : self
Parameters
$fields : string
$value1 : mixed
$value2 : mixed
Return values
self

orEq()

Equivale a `eq()` pero unido a la cláusula previa con OR.

public static orEq(string $fields, mixed $value) : self
Parameters
$fields : string
$value : mixed
Return values
self

orGt()

Equivale a `gt()` pero unido a la cláusula previa con OR.

public static orGt(string $fields, mixed $value) : self
Parameters
$fields : string
$value : mixed
Return values
self

orGte()

Equivale a `gte()` pero unido a la cláusula previa con OR.

public static orGte(string $fields, mixed $value) : self
Parameters
$fields : string
$value : mixed
Return values
self

orIn()

Equivale a `in()` pero unido a la cláusula previa con OR.

public static orIn(string $fields, mixed $values) : self
Parameters
$fields : string
$values : mixed
Return values
self

orIsNotNull()

Equivale a `isNotNull()` pero unido a la cláusula previa con OR.

public static orIsNotNull(string $fields) : self
Parameters
$fields : string
Return values
self

orIsNull()

Equivale a `isNull()` pero unido a la cláusula previa con OR.

public static orIsNull(string $fields) : self
Parameters
$fields : string
Return values
self

orLike()

Equivale a `like()` pero unido a la cláusula previa con OR.

public static orLike(string $fields, string $value) : self
Parameters
$fields : string
$value : string
Return values
self

orLt()

Equivale a `lt()` pero unido a la cláusula previa con OR.

public static orLt(string $fields, mixed $value) : self
Parameters
$fields : string
$value : mixed
Return values
self

orLte()

Equivale a `lte()` pero unido a la cláusula previa con OR.

public static orLte(string $fields, mixed $value) : self
Parameters
$fields : string
$value : mixed
Return values
self

orNotBetween()

Equivale a `notBetween()` pero unido a la cláusula previa con OR.

public static orNotBetween(string $fields, mixed $value1, mixed $value2) : self
Parameters
$fields : string
$value1 : mixed
$value2 : mixed
Return values
self

orNotEq()

Equivale a `notEq()` pero unido a la cláusula previa con OR.

public static orNotEq(string $fields, mixed $value) : self
Parameters
$fields : string
$value : mixed
Return values
self

orNotIn()

Equivale a `notIn()` pero unido a la cláusula previa con OR.

public static orNotIn(string $fields, mixed $values) : self
Parameters
$fields : string
$values : mixed
Return values
self

orNotLike()

Equivale a `notLike()` pero unido a la cláusula previa con OR.

public static orNotLike(string $fields, string $value) : self
Parameters
$fields : string
$value : string
Return values
self

orRegexp()

Equivale a `regexp()` pero unido a la cláusula previa con OR.

public static orRegexp(string $fields, string $value) : self
Parameters
$fields : string
$value : string
Return values
self

orSub()

Equivale a `sub()` pero unido a la cláusula previa con OR.

public static orSub(array<string|int, mixed> $where) : self
Parameters
$where : array<string|int, mixed>
Return values
self

orXlike()

Equivale a `xlike()` pero unido a la cláusula previa con OR.

public static orXlike(string $fields, string $value) : self
Parameters
$fields : string
$value : string
Return values
self

regexp()

Crea `campo REGEXP value` (la sintaxis exacta depende del motor, vía `getOperator`).

public static regexp(string $fields, string $value) : self
Parameters
$fields : string
$value : string
Return values
self

sql()

Renderiza esta cláusula simple como SQL (sin prefijo `WHERE` ni el conector `operation`).

public sql() : string

Si $fields contiene varios campos separados por |, se generan condiciones por cada uno unidas con OR y rodeadas de paréntesis. Los grupos (operador () no se procesan aquí, sino en multiSql().

Return values
string

sub()

Agrupa varias cláusulas en una sub-condición que se renderizará entre paréntesis.

public static sub(array<string|int, mixed> $where[, string $operation = 'AND' ]) : self

Internamente devuelve una instancia con operador ( y subWhere apuntando al array de hijos; multiSql() la detecta y delega recursivamente. Lanza Exception si algún elemento del array no es Where.

Parameters
$where : array<string|int, mixed>
$operation : string = 'AND'
Return values
self

useField()

Habilita la interpretación del prefijo `field:` en los valores para esta condición.

public useField() : self

Sin activar este flag, un valor como 'field:otra_columna' se trata como string literal y se escapa; con el flag activo, se traduce a una referencia escapada a esa columna, permitiendo comparaciones campo-contra-campo.

Return values
self

xlike()

Crea una búsqueda multipalabra: divide `$value` por espacios y aplica un LIKE a cada palabra, combinándolos con AND (la fila debe contener todas las palabras).

public static xlike(string $fields, string $value) : self
Parameters
$fields : string
$value : string
Return values
self

sqlColumn()

private static sqlColumn(string $field) : string
Parameters
$field : string
Return values
string

sqlOperatorBetween()

private sqlOperatorBetween(string $field, mixed $values, string $operator) : string
Parameters
$field : string
$values : mixed
$operator : string
Return values
string

sqlOperatorIn()

private static sqlOperatorIn(string $field, mixed $values, string $operator) : string
Parameters
$field : string
$values : mixed
$operator : string
Return values
string

sqlOperatorLike()

private static sqlOperatorLike(string $field, string $value, string $operator) : string
Parameters
$field : string
$value : string
$operator : string
Return values
string

sqlOperatorXLike()

private static sqlOperatorXLike(string $field, string $value) : string
Parameters
$field : string
$value : string
Return values
string

sqlValue()

private sqlValue(mixed $value) : string
Parameters
$value : mixed
Return values
string
On this page

Search results