IBM Cloud Docs
Operatori IBM Cloudant

Operatori IBM Cloudant

Gli operatori sono identificati dall'utilizzo del prefisso del simbolo del dollaro ($) nel campo del nome.

La sintassi del selettore ha due tipi principali di operatori:

  • Operatori di combinazioni
  • Operatori delle condizioni

In generale, gli operatori di combinazione vengono applicati al livello più alto di selezione. Sono utilizzati per combinare le condizioni, o per creare combinazioni di condizioni, in un unico selettore.

Ogni operatore esplicito ha il formato:

{
	"$operator": "argument"
}

Un selettore senza un operatore esplicito è considerato come un operatore implicito. L'operatore implicito esatto è determinato dalla struttura dell'espressione del selettore.

Operatori impliciti

I due operatori impliciti sono riportati nel seguente elenco:

  • "Uguaglianza"
  • "E"

In un selettore, qualsiasi campo che contiene un valore JSON, ma che non contiene alcun operatore, viene considerato come una condizione di uguaglianza. Il test di uguaglianza implicita si applica anche ai campi e ai campi secondari.

Qualsiasi oggetto JSON che non è l'argomento di un operatore di condizione è un operatore $and implicito su ciascun campo.

Fare riferimento al seguente selettore di esempio che utilizza un operatore per la corrispondenza con qualsiasi documento, dove il campo year ha un valore maggiore di 2010:

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

Nel seguente esempio, un documento corrispondente deve avere un campo denominato director, e il campo deve avere un valore esattamente uguale a Lars von Trier.

Consultare il seguente esempio di operatore di uguaglianza implicito:

{
	"director": "Lars von Trier"
}

È anche possibile rendere esplicito l'operatore di uguaglianza, come mostrato nel seguente esempio.

Consultare il seguente esempio di operatore di uguaglianza esplicito:

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

Nel seguente esempio che utilizza campi secondari, il campo imdb in un documento corrispondente deve avere anche un campo secondario rating, e il campo secondario devono avere un valore uguale a 8.

Consultare il seguente esempio di operatore implicito applicato a un test del campo secondario:

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

È possibile rendere esplicito l'operatore di uguaglianza.

Consultare il seguente esempio di operatore di uguaglianza esplicito:

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

Consultare il seguente esempio di un operatore $eq utilizzato con l'indicizzazione full text:

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

Consultare il seguente esempio di operatore $eq utilizzato con un database indicizzato nel campo year:

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

Nel seguente esempio, il campo director deve essere presente e contenere il valore Lars von Trier e il campo year devono esistere e avere il valore 2003.

Consultare il seguente esempio di operatore $and implicito:

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

È possibile rendere espliciti sia l'operatore $and che l'operatore di uguaglianza.

Consultare il seguente esempio che utilizza gli operatori $and e $eq espliciti:

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

Operatori espliciti

Tutti gli operatori, ad eccezione degli operatori $eq (uguaglianza) e $and (e), devono essere indicati esplicitamente.

Operatori di combinazioni

Gli operatori di combinazione vengono utilizzati per combinare i selettori. Tre operatori di combinazione ($all, $allMatch e $elemMatch) ti aiutano a lavorare con gli array JSON, in aggiunta agli operatori booleani comuni trovati nella maggior parte dei linguaggi di programmazione.

Un operatore di combinazione utilizza un singolo argomento. L'argomento è un altro selettore o un array di selettori.

Operatori combinati
Operatore Argomento Scopo
$all Array Corrisponde a un valore di array se contiene tutti gli elementi dell'array di argomenti.
$allMatch Selettore Mette in corrispondenza e restituisce tutti i documenti che contengono un campo array, dove tutti gli elementi corrispondono a tutti i criteri di query specificati.
$and Array Corrisponde se tutti i selettori nell'array corrispondono.
$elemMatch Selettore Associa e restituisce tutti i documenti che contengono un campo array con almeno un elemento che corrisponde a tutti i criteri di interrogazione specificati.
$nor Array Corrisponde se nessuno dei selettori nell'array corrisponde.
$not Selettore Corrisponde se il selettore non corrisponde.
$or Array Corrisponde se uno dei selettori nell'array corrisponde. Tutti i selettori devono utilizzare lo stesso indice.

Esempi di operatori di combinazioni

L'operatore $all

L'operatore $all corrisponde a un valore di array se contiene tutti gli elementi dell'array di argomento.

Consultare il seguente esempio che utilizza l'operatore $all :

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

L'operatore $allMatch

L'operatore $allMatch corrisponde e restituisce tutti i documenti che contengono un campo array, dove tutti gli elementi nel campo array corrispondono ai criteri di query forniti.

Consultare il seguente esempio che utilizza l'operatore $allMatch :

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

L'operatore $and

L'operatore $and corrisponde se tutti i selettori nell'array corrispondono.

Consultare il seguente esempio che utilizza l'operatore $and :

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

L'operatore $elemMatch

L'operatore $elemMatch mette in corrispondenza e restituisce tutti i documenti che contengono un campo array con almeno un elemento che corrisponde ai criteri di query forniti.

Consultare il seguente esempio che utilizza l'operatore $elemMatch :

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

L'operatore $nor

L'operatore $nor corrisponde se il selettore non corrisponde.

Consultare il seguente esempio che utilizza l'operatore $nor :

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

L'operatore $not

L'operatore $not corrisponde se il selettore non si risolve in un valore true.

Consultare il seguente esempio che utilizza l'operatore $not :

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

L'operatore $or

L'operatore $or corrisponde se uno dei selettori nell'array corrisponde.

Consultare il seguente esempio che utilizza l'operatore $or :

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

Operatori delle condizioni

Gli operatori condizione sono specifici di un campo e vengono utilizzati per valutare il valore memorizzato in tale campo. Ad esempio, l'operatore $eq corrisponde quando il campo specificato contiene un valore uguale all'argomento fornito.

Sono supportati gli operatori di uguaglianza e disuguaglianza di base comuni alla maggior parte dei linguaggi di programmazione. Sono disponibili anche alcuni operatori di condizione "meta".

Alcuni operatori di condizione accettano qualsiasi contenuto JSON valido come argomento. Gli altri operatori di condizione richiedono che l'argomento sia in un formato JSON specifico.

Requisiti degli argomenti dell'operatore di condizione
Tipo di operatore Operatore Argomento Scopo
(In) uguaglianza $lt Qualsiasi JSON Il campo è inferiore all'argomento.
$lte Qualsiasi JSON Il campo è minore o uguale all'argomento.
$eq Qualsiasi JSON Il campo è uguale all'argomento.
$ne Qualsiasi JSON Il campo non è uguale all'argomento.
$gte Qualsiasi JSON Il campo è maggiore o uguale all'argomento.
$gt Qualsiasi JSON Il campo è maggiore dell'argomento.
Oggetto $exists Booleano Verificare se il campo esiste o meno, indipendentemente dal suo valore.
$type Stringa Verificare il tipo di campo documento. I valori accettati sono null, boolean, number, string, array e object.
Array $in Array di valori JSON Il campo del documento deve esistere nell'elenco fornito.
$nin Array di valori JSON Il campo del documento non deve esistere nell'elenco fornito.
$size Numero intero Condizione speciale per la corrispondenza della lunghezza di un campo schiera in un documento. I campi non array non possono corrispondere a questa condizione.
Miscellaneous $mod [Divisore, resto] Divisor e Remainder sono entrambi numeri interi positivi o negativi. I valori non interi risultano in uno stato 404. Corrisponde ai documenti in cui l'espressione (field % Divisor == Remainder) è true e solo quando il campo del documento è un numero intero.
$regex Stringa Un modello di espressione regolare da confrontare con il campo del documento. Corrisponde solo quando il campo è un valore stringa e corrisponde all'espressione regolare fornita.

Le espressioni regolari non funzionano con gli indici, pertanto non devono essere utilizzati per filtrare dataset di grandi dimensioni. Tuttavia, possono essere utilizzati per limitare un partial index <find/partial_indexes>.

Esempi di operatori di condizioni

L'operatore $lt

L'operatore $lt corrisponde se il contenuto del campo specificato è inferiore all'argomento.

Consultare il seguente esempio che utilizza l'operatore $lt con l'indicizzazione full text:

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

Vedere il seguente esempio che utilizza l'operatore $lt con un database indicizzato nel campo year:

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

L'operatore $lte

L'operatore $lte corrisponde se il contenuto del campo specificato è minore o uguale all'argomento.

Consultare il seguente esempio che utilizza l'operatore $lte con l'indicizzazione full text:

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

Vedere il seguente esempio che utilizza l'operatore $lte con un database indicizzato nel campo year:

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

L'operatore $eq

L'operatore $eq corrisponde se il contenuto del campo specificato è uguale all'argomento fornito.

Consultare il seguente esempio che utilizza l'operatore $eq con l'indicizzazione full text:

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

Vedere il seguente esempio che utilizza l'operatore $eq con un database indicizzato nel campo year:

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

L'operatore $ne

L'operatore $ne corrisponde se il contenuto del campo specificato non è uguale all'argomento fornito.

L'operatore $ne non può essere l'elemento di base (livello più basso) in un selettore quando si utilizza un indice di tipo json.

Consultare il seguente esempio che utilizza l'operatore $ne con l'indicizzazione full text:

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

Vedere il seguente esempio che utilizza l'operatore $ne con un indice primario:

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

L'operatore $gte

L'operatore $gte corrisponde se il contenuto del campo specificato è maggiore o uguale all'argomento.

Consultare il seguente esempio che utilizza l'operatore $gte con l'indicizzazione full text:

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

Vedere il seguente esempio che utilizza l'operatore $gte con un database indicizzato nel campo year:

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

L'operatore $gt

L'operatore $gt corrisponde se il contenuto del campo specificato è maggiore dell'argomento.

Consultare il seguente esempio che utilizza l'operatore $gt con l'indicizzazione full text:

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

Vedere il seguente esempio che utilizza l'operatore $gt con un database indicizzato nel campo year:

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

L'operatore $exists

L'operatore $exists corrisponde se il campo esiste, indipendentemente dal suo valore.

Consultare il seguente esempio che utilizza l'operatore $exists :

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

L'operatore $type

L'operatore $type richiede che il campo del documento specificato sia del tipo corretto.

Consultare il seguente esempio che utilizza l'operatore $type :

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

L'operatore $in

L'operatore $in richiede che il campo del documento deve sia presente nell'elenco fornito.

Consultare il seguente esempio che utilizza l'operatore $in :

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

L'operatore $nin

L'operatore $nin richiede che il campo del documento non esista nell'elenco fornito.

Consultare il seguente esempio che utilizza l'operatore $nin :

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

L'operatore $size

L'operatore $size corrisponde alla lunghezza di un campo array in un documento.

Consultare il seguente esempio che utilizza l'operatore $size :

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

L'operatore $mod

L'operatore $mod corrisponde ai documenti in cui l'espressione (field % Divisor == Remainder) è true e solo quando il campo del documento è un numero intero. Divisor e Remainder devono essere numeri interi. Possono essere numeri interi positivi o negativi. Una query in cui Divisor o Remainder non è un numero intero restituisce uno stato 404.

Quando si utilizzano valori interi negativi per il Divisore o il resto, l'operatore IBM® Cloudant® for IBM Cloud® $mod utilizza divisione troncata. Sia l'operatore Erlang rem modulo, che l'operatore % in C, si comportano in modo simile.

Consultare il seguente esempio che utilizza l'operatore $mod :

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

L'operatore $regex

L'operatore $regex corrisponde quando il campo è un valore stringa e corrisponde all'espressione regolare fornita.

Consultare il seguente esempio che utilizza l'operatore $regex :

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