IBM Cloud Docs
IBM Cloudant Operadores

IBM Cloudant Operadores

Los operadores se identifican mediante el uso de un prefijo de signo de dólar ($) en el campo del nombre.

La sintaxis del selector tiene dos tipos principales de operadores:

  • Operadores de combinación
  • Operadores de condición

En general, los operadores de combinación se aplican en el nivel superior de selección. Se utilizan para combinar condiciones o para crear combinaciones de condiciones en un selector.

Cada operador explícito tiene el formato:

{
	"$operator": "argument"
}

Se considera que un selector sin un operador explícito tiene un operador implícito. El operador implícito exacto viene determinado por la estructura de la expresión del selector.

Operadores implícitos

Los dos operadores implícitos son los siguientes:

  • "Equality"
  • "Y"

En un selector, cualquier campo que contenga un valor JSON, pero que no tenga ningún operador en el mismo, se considera una condición de igualdad. La prueba de igualdad implícita también se aplica a los campos y subcampos.

Cualquier objeto JSON que no sea el argumento para un operador de condición es un operador $and implícito en cada campo.

Consulte el siguiente selector de ejemplo que utiliza un operador para que coincida con cualquier documento, donde el campo year tiene un valor mayor que 2010:

{
	"selector": {
		"year": {
			"$gt": 2010
		}
	}
}

En el ejemplo siguiente, un documento coincidente debe tener un campo llamado director, y el campo debe tener un valor exactamente igual a Lars von Trier.

Consulte el ejemplo siguiente de operador de igualdad implícito:

{
	"director": "Lars von Trier"
}

También puede hacer que el operador de igualdad sea explícito, tal como se muestra en el ejemplo siguiente.

Consulte el ejemplo siguiente de un operador de igualdad explícito:

{
	"director": {
		"$eq": "Lars von Trier"
	}
}

En el ejemplo siguiente que utiliza subcampos, el campo imdb de un documento coincidente debe también tener un subcampo rating y el subcampo debe tener un valor igual a 8.

Consulte el ejemplo siguiente de operador implícito que se aplica a una prueba de subcampo:

{
	"imdb": {
		"rating": 8
	}
}

Puede hacer que el operador de igualdad sea explícito.

Consulte el ejemplo siguiente de un operador de igualdad explícito:

{
	"selector": {
		"imdb": {
			"rating": { "$eq": 8 }
		}
	}
}

Consulte el ejemplo siguiente de un operador $eq que se utiliza con indexación de texto completo:

{
	"selector": {
		"year": {
			"$eq": 2001
		}
	},
	"sort": [
		"title:string"
	],
	"fields": [
		"title"
	]
}

Consulte el ejemplo siguiente de un operador $eq que se utiliza con una base de datos que está indexada en el campo year:

{
	"selector": {
		"year": {
			"$eq": 2001
		}
	},
	"sort": [
		"year"
	],
	"fields": [
		"year"
	]
}

En el siguiente ejemplo el campo director debe estar presente y contener el valor Lars von Trier y el campo year debe existir y tener el valor 2003.

Consulte el ejemplo siguiente de un operador $and implícito:

{
	"director": "Lars von Trier",
	"year": 2003
}

Puede hacer que tanto el operador $and como el operador de igualdad sean explícitos.

Consulte el ejemplo siguiente que utiliza operadores $and y $eq explícitos:

{
	"$and": [
		{
			"director": {
				"$eq": "Lars von Trier"
			}
		},
		{
			"year": {
				"$eq": 2003
			}
		}
	]
}

Operadores explícitos

Todos los operadores, aparte de los operadores $eq (igualdad) y $and (y), deben indicarse de forma explícita.

Operadores de combinación

Los operadores de combinación se utilizan para combinar selectores. Tres operadores de combinación ($all, $allMatch y $elemMatch) le ayudan a trabajar con matrices JSON, además de los operadores booleanos comunes que se encuentran en la mayoría de los lenguajes de programación.

Un operador de combinación toma un solo argumento. El argumento es otro selector o una matriz de selectores.

Operadores de combinación
Operador Argumento Finalidad
$all Matriz Coincide con un valor de matriz si contiene todos los elementos de la matriz de argumentos.
$allMatch Selector Coincide y devuelve todos los documentos que contienen un campo de matriz, donde todos los elementos coinciden con todos los criterios de consulta especificados.
$and Matriz Coincide si todos los selectores de la matriz coinciden.
$elemMatch Selector Coincide y devuelve todos los documentos que contienen un campo de matriz con al menos un elemento que coincida con todos los criterios de consulta especificados.
$nor Matriz Coincide si ninguno de los selectores de la matriz coincide.
$not Selector Coincide si el selector no coincide.
$or Matriz Coincide si alguno de los selectores de la matriz coincide. Todos los selectores deben utilizar el mismo índice.

Ejemplos de operadores de combinación

El operador $all

El operador $all coincide con un valor de matriz si contiene todos los elementos de la matriz de argumentos.

Consulte el ejemplo siguiente que utiliza el operador $all:

{
	"selector": {
		"genre": {
			"$all": ["Comedy","Short"]
		}
	},
	"fields": [
		"title",
		"genre"
	],
	"limit": 10
}

El operador $allMatch

El operador $allMatch coincide y devuelve todos los documentos que contienen un campo de matriz, donde todos los elementos del campo de matriz coinciden con los criterios de consulta especificados.

Consulte el ejemplo siguiente que utiliza el operador $allMatch:

{
    "genre": {
        "$allMatch": {
          "$eq": "Horror"
        }
    }
}

El operador $and

El operador $and coincide si todos los selectores de la matriz coinciden.

Consulte el ejemplo siguiente que utiliza el operador $and:

{
    "selector": {
        "$and": [
            {
                "year": {
                    "$in": [2014, 2015]
                }
            },
            {
                "genre": {
                     "$all": ["Comedy","Short"]
                 }
            }
        ]
    },
    "fields": [
        "year",
        "_id",
        "title"
    ],
    "limit": 10
}

El operador $elemMatch

El operador $elemMatch coincide y devuelve todos los documentos que contienen un campo de matriz con al menos un elemento que coincida con los criterios de consulta especificados.

Consulte el ejemplo siguiente que utiliza el operador $elemMatch:

{
	"selector": {
		"genre": {
			"$elemMatch": {
				"$eq": "Horror"
			}
		}
	},
	"fields": [
		"title",
		"genre"
	],
	"limit": 10
}

El operador $nor

El operador $nor coincide si el selector no coincide.

Consulte el ejemplo siguiente que utiliza el operador $nor:

{
	"selector": {
		"year": {
			"$gte": 1900,
			"$lte": 1910
		},
		"$nor": [
			{ "year": 1901 },
			{ "year": 1905 },
			{ "year": 1907 }
		]
	},
	"fields": [
		"title",
		"year"
	]
}

El operador $not

El operador $not coincide si el selector no se resuelve en el valor true.

Consulte el ejemplo siguiente que utiliza el operador $not:

{
	"selector": {
		"year": {
			"$gte": 1900,
			"$lte": 1903
		},
		"$not": {
			"year": 1901
		}
	},
	"fields": [
		"title",
		"year"
	]
}

El operador $or

El operador $or coincide si alguno de los selectores de la matriz coincide.

Consulte el ejemplo siguiente que utiliza el operador $or:

{
	"selector": {
		"year": 1977,
		"$or": [
			{ "director": "George Lucas" },
			{ "director": "Steven Spielberg" }
		]
	},
	"fields": [
		"title",
		"director",
		"year"
	]
}

Operadores de condición

Los operadores de condición son específicos de un campo y se utilizan para evaluar el valor almacenado en dicho campo. Por ejemplo, el operador $eq coincide cuando el campo especificado contiene un valor que es igual al argumento proporcionado.

Se da soporte a los operadores básicos de igualdad y desigualdad comunes a la mayoría de los lenguajes de programación. También están disponibles algunos operadores de condición "meta".

Algunos operadores de condición aceptan cualquier contenido JSON válido como argumento. Otros operadores de condición requieren que el argumento esté en un formato JSON específico.

Requisitos del argumento del operador de condición
Tipo de operador Operador Argumento Finalidad
(In) igualdad $lt Cualquier JSON El campo es menor que el argumento.
$lte Cualquier JSON El campo es menor o igual que el argumento.
$eq Cualquier JSON El campo es igual que el argumento.
$ne Cualquier JSON El campo no es igual que el argumento.
$gte Cualquier JSON El campo es mayor o igual que el argumento.
$gt Cualquier JSON El campo es mayor que el argumento.
Objecto $exists Boolean Comprobar si el campo existe o no, independientemente de su valor.
$type Serie Comprobar el tipo del campo del documento. Los valores aceptados son null, boolean, number, string, array y object.
Matriz $in Matriz de valores JSON El campo del documento debe existir en la lista especificada.
$nin Matriz de valores JSON El campo del documento no debe existir en la lista especificada.
$size Entero Condición especial para que coincida con la longitud de un campo de matriz de un documento. Los campos que no son de matriz no pueden coincidir con esta condición.
Otros $mod [Divisor, Remainder] Divisor y Remainder son ambos enteros positivos o negativos. Los valores no enteros dan lugar a un estado 404. Coincide con los documentos en los que la expresión (field % Divisor == Remainder) es verdadera y solo cuando el campo del documento es un entero.
$regex Serie Un patrón de expresión regular que se compara con el campo del documento. Solo coincide cuando el campo es un valor de tipo serie y coincide con la expresión regular especificada.

Las expresiones regulares no funcionan con índices, por lo que no se deben utilizar para filtrar conjuntos de datos grandes. Sin embargo, se pueden utilizar para restringir un partial index <find/partial_indexes>.

Ejemplos de operadores de condición

El operador $lt

El operador $lt coincide si el contenido del campo especificado es menor que el argumento.

Consulte el ejemplo siguiente que utiliza el operador $lt con indexación de texto completo:

{
	"selector": {
		"year": {
			"$lt": 1900
		}
	},
	"sort": [
		"year:number",
		"title:string"
	],
	"fields": [
		"year",
		"title"
	]
}

Consulte el ejemplo siguiente que utiliza el operador $lt con una base de datos que se indexa en el campo year:

{
	"selector": {
		"year": {
			"$lt": 1900
		}
	},
	"sort": [
		"year"
	],
	"fields": [
		"year"
	]
}

El operador $lte

El operador $lte coincide si el contenido del campo especificado es menor o igual que el argumento.

Consulte el ejemplo siguiente que utiliza el operador $lte con indexación de texto completo:

{
	"selector": {
		"year": {
			"$lte": 1900
		}
	},
	"sort": [
		"year:number",
		"title:string"
	],
	"fields": [
		"year",
		"title"
	]
}

Consulte el ejemplo siguiente que utiliza el operador $lte con una base de datos que se indexa en el campo year:

{
	"selector": {
		"year": {
			"$lte": 1900
		}
	},
	"sort": [
		"year"
	],
	"fields": [
		"year"
	]
}

El operador $eq

El operador $eq coincide si el contenido del campo especificado es igual al argumento especificado.

Consulte el ejemplo siguiente que utiliza el operador $eq con indexación de texto completo:

{
	"selector": {
		"year": {
			"$eq": 2001
		}
	},
	"sort": [
		"title:string"
	],
	"fields": [
		"title"
	]
}

Consulte el ejemplo siguiente que utiliza el operador $eq con una base de datos que se indexa en el campo year:

{
	"selector": {
		"year": {
			"$eq": 2001
		}
	},
	"sort": [
		"year"
	],
	"fields": [
		"year"
	]
}

El operador $ne

El operador $ne coincide si el contenido del campo especificado no es igual al argumento especificado.

El operador $ne no puede ser el elemento básico (nivel inferior) en un selector cuando se utiliza un índice de tipo json.

Consulte el ejemplo siguiente que utiliza el operador $ne con indexación de texto completo:

{
	"selector": {
		"year": {
			"$ne": 1892
		}
	},
	"fields": [
		"year"
	],
	"sort": [
		"year:number"
	]
}

Consulte el ejemplo siguiente que utiliza el operador $ne con un índice primario:

{
	"selector": {
	"year": {
			"$ne": 1892
		}
	},
	"fields": [
		"year"
	],
	"limit": 10
}

El operador $gte

El operador $gte coincide si el contenido del campo especificado es mayor o igual que el argumento.

Consulte el ejemplo siguiente que utiliza el operador $gte con indexación de texto completo:

{
	"selector": {
		"year": {
			"$gte": 2001
		}
	},
	"sort": [
		"year:number",
		"title:string"
	],
	"fields": [
		"year",
		"title"
	]
}

Consulte el ejemplo siguiente que utiliza el operador $gte con una base de datos que se indexa en el campo year:

{
	"selector": {
		"year": {
			"$gte": 2001
		}
	},
	"sort": [
		"year"
	],
	"fields": [
		"year"
	]
}

El operador $gt

El operador $gt coincide si el contenido del campo especificado es mayor que el argumento.

Consulte el ejemplo siguiente que utiliza el operador $gt con indexación de texto completo:

{
	"selector": {
		"year": {
			"$gt": 2001
		}
	},
	"sort": [
		"year:number",
		"title:string"
	],
	"fields": [
		"year",
		"title"
	]
}

Consulte el ejemplo siguiente que utiliza el operador $gt con una base de datos que se indexa en el campo year:

{
	"selector": {
		"year": {
			"$gt": 2001
		}
	},
	"sort": [
		"year"
	],
	"fields": [
		"year"
	]
}

El operador $exists

El operador $exists coincide si el campo existe, independientemente de su valor.

Consulte el ejemplo siguiente que utiliza el operador $exists:

{
	"selector": {
		"year": 2015,
		"title": {
			"$exists": true
		}
	},
	"fields": [
		"year",
		"_id",
		"title"
	]
}

El operador $type

El operador $type requiere que el campo del documento especificado sea del tipo correcto.

Consulte el ejemplo siguiente que utiliza el operador $type:

{
	"selector": {
		  "year": {
			"$type": "number"
		}
	},
	"fields": [
		"year",
		"_id",
		"title"
	]
}

El operador $in

El operador $in requiere que el campo del documento exista en la lista especificada.

Consulte el ejemplo siguiente que utiliza el operador $in:

{
	"selector": {
		  "year": {
			"$in": [2010, 2015]
		}
	},
	"fields": [
		"year",
		"_id",
		"title"
	],
	"limit": 10
}

El operador $nin

El operador $nin requiere que el campo del documento no exista en la lista proporcionada.

Consulte el ejemplo siguiente que utiliza el operador $nin:

{
	"selector": {
		  "year": {
			"$nin": [2010, 2015]
		}
	},
	"fields": [
		"year",
		"_id",
		"title"
	],
	"limit": 10
}

El operador $size

El operador $size compara la longitud de un campo de matriz de un documento.

Consulte el ejemplo siguiente que utiliza el operador $size:

{
	"selector": {
		  "genre": {
			"$size": 4
		}
	},
	"fields": [
		"title",
		"genre"
	],
	"limit": 25
}

El operador $mod

El operador $mod coincide con los documentos en los que la expresión (field % Divisor == Remainder) tiene el valor true y solo cuando el campo del documento es un entero. Los valores Divisor y Remainder deben ser enteros. Pueden ser enteros positivos o negativos. Una consulta en la que el Divisor o el Resto es un no entero devuelve un estado 404.

Cuando se utilizan valores enteros negativos para el Divisor o el Resto, el operador IBM® Cloudant® for IBM Cloud® $mod utiliza división truncada. Tanto el operador rem modulo de Erlang, como el operador % de C, se comportan de manera similar.

Consulte el ejemplo siguiente que utiliza el operador $mod:

{
	"selector": {
          "year": {
			"$mod": [100,0]
		}
	},
	"fields": [
		"title",
		"year"
	],
	"limit": 50
}

El operador $regex

El operador $regex coincide cuando el campo es un valor de serie y coincide con la expresión regular especificada.

Consulte el ejemplo siguiente que utiliza el operador $regex:

{
	"selector": {
		   "cast": {
			"$elemMatch": {
				"$regex": "^Robert"
			}
		}
	},
	"fields": [
		"title",
		"cast"
	],
	"limit": 10
}