Questa pagina descrive Calíope 1.6, la versione che sto costruendo adesso. La 1.5 è sull'App Store per Mac, iPad, iPhone, Apple Watch, Apple TV e Apple Vision Pro. Il changelog dice in quale versione è arrivata ogni funzione.
Aggiunge a ogni argomento un pulsante «Apri in Calíope». Funziona solo con l'app installata.
Come scorrere, leggere e modificare le chiavi di un server Redis.
Dove si trova: Workspace › Strumenti › Chiavi
Si applica a:Redis
L’esploratore mostra a sinistra le chiavi del database, raggruppate per prefisso, e a destra il dettaglio di quella che scegli.
Come vengono scorse le chiavi
Calíope le chiede con SCAN, a blocchi, e mai con KEYS: KEYS scorre tutto il database in un colpo solo e, poiché Redis esegue i comandi uno alla volta, finché dura non risponde a nessun altro. Il piè di pagina dice quante chiavi sono state scorse e se lo scorrimento è finito o restano chiavi; Carica altre chiavi chiede il blocco successivo. In un cluster si scorre ogni nodo primario e il piè di pagina dice quanti hanno risposto; se ne manca uno, lo nomina con il suo motivo.
Il campo in alto è un pattern di MATCH —app:*, *:1001—, non una ricerca per contenuto, e il server lo applica appena smetti di scrivere.
I gruppi li fa Calíope, non il server
Redis non ha cartelle: ogni chiave è un nome piatto. I gruppi nascono dal dividere i nomi con il carattere del menu Separatore della barra (:, /, ., | o Nessuno: elenco piatto), e il server non ne sa nulla. Il separatore si sceglie per ogni sessione, e ogni gruppo dice quante chiavi ne dipendono. Con la tastiera le frecce scorrono l’elenco e → e ← aprono e chiudono il gruppo scelto; sull’iPhone, toccare una chiave apre il suo dettaglio.
Tipo e scadenza
Ogni chiave porta il suo tipo, con il suo glifo e il suo nome, e la sua scadenza, che nel dettaglio conta alla rovescia. Nessuna scadenza e Non esiste più non sono la stessa cosa: la prima è una chiave che dura finché qualcuno non la elimina; la seconda, una che è scaduta, o che un altro client ha eliminato, dopo essere stata scorsa.
Il dettaglio
Sotto la chiave, il tipo e la scadenza vengono la dimensione —Lunghezza in byte, Campi o Elementi—, la Codifica interna e la Memoria, e poi il Valore. La dimensione si chiede prima del contenuto: un valore grande si legge a pezzi, e un pulsante carica il successivo. In una lista ogni elemento porta il suo Indice, perché in Redis la posizione fa parte del dato; un insieme avverte che non ha ordine; un insieme ordinato mostra ogni Membro accanto al suo Punteggio, dal più basso al più alto; e uno stream mostra prima i suoi dati —prima e ultima voce, ultimo id generato, id eliminato più alto—, poi i suoi gruppi di consumatori con le voci in sospeso e il ritardo, e infine le sue Voci. Un valore che non è UTF-8 si mostra in esadecimale, e i caratteri di controllo, con escape.
Cosa si può modificare
Sulla chiave scelta, dalla barra e dal menu contestuale dell’elenco: Scadenza… (o Rimuovi scadenza, se la chiave scade); Rinomina…, che avverte se il nome esiste già e sovrascrive l’altra chiave solo con Sostituisci; e Elimina chiave…, che chiede sempre conferma e nomina la chiave, il suo tipo e la sua dimensione. Alla stessa domanda portano il tasto di cancellazione e, su iPhone e iPad, lo scorrimento della riga verso sinistra.
Nel valore: Modifica valore… su una stringa, che conserva la sua scadenza; Aggiungi campo…, Modifica… e Rimuovi su un hash; Modifica… di una posizione in una lista; Aggiungi membro… e Rimuovi su un insieme; e Aggiungi membro…, Modifica… —che cambia il punteggio— e Rimuovi su un insieme ordinato. Togliere l’ultimo elemento avverte che Redis elimina la chiave quando resta vuota. Ogni modifica si vede al suo posto, senza ricaricare l’elenco, e resta nel registro di ciò che Calíope ha eseguito.
Non si modifica un valore binario, né uno di oltre 64 KiB, né uno stream. E non c’è lo svuotamento del database né l’eliminazione per pattern: si elimina una chiave alla volta, sapendo quale.
Profili aperti con Calíope 1.4
Un profilo Redis sincronizzato con un dispositivo che ha ancora Calíope 1.4 viene letto lì come MariaDB sulla stessa porta, perché quella versione non conosce Redis; se lo salvi da quel dispositivo, viene riscritto così su tutti i tuoi. Si recupera scegliendo di nuovo Redis nel profilo: né il server né la password vanno persi.
Che cosa mostra il pannello del server Redis e come leggere ogni cifra.
Dove si trova: Workspace › Strumenti › Server
Si applica a:Redis
Il pannello mostra lo stato del server Redis così come lo pubblica INFO. Si rilegge da solo ogni 2 secondi finché è in vista, e Aggiorna lo rilegge subito. Sotto ogni cifra c’è il campo di INFO da cui viene, così puoi confrontarla con redis-cli.
Le sei schede Memoria usata è used_memory, con il limite (maxmemory) e la percentuale, o senza limite se maxmemory vale 0; sotto, che cosa fa il server quando si riempie, e il picco.
Frammentazione è la memoria che il processo occupa nel sistema divisa per quella che usa. Sopra 1, il processo occupa più di quanto usa: buchi che l’allocatore di memoria non ha ancora restituito. Sotto 1 di solito significa che parte dei dati è nello swap, ed è peggio.
Tasso di successo e Chiavi scadute sono accumulate dall’avvio del server, non dall’ultima lettura: un tasso che si muove appena non dice che adesso non ci siano mancati. Le chiavi scadute hanno sotto quelle espulse per mancanza di memoria.
Client connessi si misura rispetto a maxclients, che non compare se il server non consente CONFIG. Se confronti con redis-cli, lì ne compare uno in più: lo stesso redis-cli.
Operazioni al secondo le calcola il server (instantaneous_ops_per_sec), non Calíope, e cambiano da un istante all’altro.
Quando la memoria o i client superano il 90 % del loro limite, la scheda dice Vicino al limite, con un glifo oltre al colore.
Persistenza
Dice se AOF è attivo, quali salvataggi RDB sono programmati (save), quando è stato l’ultimo salvataggio —con data, ora e fuso orario— e quante modifiche non sono ancora salvate; un salvataggio fallito compare come tale, con il suo glifo. Se AOF è spento e non ci sono salvataggi programmati, la scheda dice solo questo, perché il server perde tutti i dati se si riavvia. Se sta caricando il suo dump dal disco, lo dice per prima cosa: finché non ha finito, le cifre non sono quelle del server in funzione.
Pub/sub
Una foto scattata a ogni lettura, non un flusso: Calíope non si iscrive a nessun canale e non mostra messaggi. Elenca i canali che hanno iscritti adesso, con quanti, e le iscrizioni per pattern. Se il server non lascia usare PUBSUB alla connessione, la scheda lo dice.
Server
Il piè di pagina indica versione, modalità, ruolo, protocollo (RESP2 o RESP3) e tempo di attività. In un cluster il pannello riguarda un solo nodo, e il piè di pagina lo nomina.
Che cosa misura l’analizzatore di memoria, quanto costa al server e perché la sua somma non torna con used_memory.
Dove si trova: Workspace › Strumenti › Memoria
Si applica a:Redis
Analizza percorre le chiavi del database con SCAN, misura ciascuna con MEMORY USAGE e somma il misurato per prefisso, dividendo i nomi con lo stesso separatore dell’esploratore (: se non ne hai scelto un altro). Il server non conosce questi gruppi: li costruisce Calíope.
Quanto costa
Misurare è una lettura per chiave, e in un database grande è un carico reale per un server che esegue i comandi uno alla volta. Per questo il percorso procede a pagine, ha un tetto e si può fermare. Il tetto si sceglie prima di analizzare, nel menu del tetto accanto a Analizza: da 10.000 a 5.000.000 chiavi, e 500.000 se non lo cambi. Mentre gira, il pulsante diventa Ferma, che è anche nel pannello Attività, e chiudere la scheda o la sessione lo ferma. Finché non termina resta visibile l’analisi precedente. In un cluster percorre ogni primario e somma.
Una stima, non un conteggio esatto
Una stringa si misura esattamente. Una lista, un hash, un insieme, un insieme ordinato o uno stream si misurano per campionamento: il server guarda cinque elementi e stima il resto (SAMPLES 5). Se l’analisi si è fermata al tetto o l’hai fermata tu, lo schermo avverte che è un campione, con un glifo oltre al testo.
La griglia Prefisso, Memoria, Chiavi e Quota: la quota è del misurato, non del database. Il menu dell’ordine, lì accanto, ordina per memoria o per chiavi, dal più grande; sul Mac e sull’iPad largo si ordina anche toccando l’intestazione della colonna. I gruppi si aprono con la freccia, o con → e ← della tastiera. In alto, la cifra dice sempre di che cosa è —quanto occupano le chiavi misurate— e, sotto, se sono tutte quelle del database (DBSIZE).
Perché la somma non torna con used_memory
La somma delle chiavi è sempre minore della memoria che il server dice di usare (used_memory), e non è un errore di misura. used_memory conta anche ciò che il server occupa per sé —uno vuoto usa già quasi 1 MB (used_memory_startup)—, i buffer dei client e della replica, e le chiavi di tutti i database, mentre l’analisi percorre solo quello della sessione. La cifra più vicina è used_memory_dataset, che toglie la parte fissa, e anche quella include gli altri database. Con poche chiavi la differenza è enorme; con molte, la somma si avvicina.
Cosa annota il registro dei comandi lenti di Redis, perché la sua soglia è in microsecondi e cosa succede quando lo svuoti.
Dove si trova: Workspace › Strumenti › Comandi lenti
Si applica a:Redis
Il server annota ogni comando la cui esecuzione supera una soglia (SLOWLOG), e questa scheda mostra ciò che ha annotato. La durata è il tempo di lavoro del server: non conta la rete né l’attesa in coda. La scheda si rilegge da sola ogni 5 secondi finché è visibile, e Aggiorna la rilegge subito.
La soglia è in microsecondi
In Redis la soglia (slowlog-log-slower-than) si scrive in microsecondi, non nei secondi o millisecondi degli altri motori: 10.000 µs sono 10 ms, il valore con cui arriva Redis. In alto, la scheda Registro del server lo dice in una frase, insieme a quante voci conserva (slowlog-max-len, 128 se nessuno l’ha cambiato). Una soglia di 0 annota tutti i comandi, anche quelli veloci; una negativa spegne il registro, e allora l’elenco vuoto lo dice: non è la stessa cosa di «nessun comando ha superato la soglia». In un cluster la scheda nomina il nodo: ogni nodo tiene il proprio registro, e questo è quello del nodo del profilo.
Una finestra, non uno storico
Il registro conserva solo le ultime voci: quando ne arriva una nuova e il registro è pieno, esce la più vecchia. Quello che vedi è ciò che il server conserva ora, non tutto ciò che è stato lento da quando è partito.
Cambiare le impostazioni Modifica impostazioni… apre un foglio con Cosa si annota (Ciò che supera la soglia, Tutto o Niente), Soglia (µs) e Voci conservate. Si scrive con CONFIG SET e si rilegge, e ciò che si mostra dopo è quello che il server dice di avere. Non si salva nel suo file di configurazione: un riavvio riporta quello che dice quel file.
L’elenco
Sul Mac è una griglia con Inizio (orologio del server), Durata, Comando e Client — quest’ultima solo se il server invia il client —, ordinabile facendo clic sull’intestazione. Su iPhone e iPad è un elenco, e l’ordine si sceglie nel menu di ordinamento della barra: Più recenti o Più lenti. Il campo Filtra per comando o client filtra ciò che è già stato letto, senza tornare al server. Il server conserva al massimo 32 argomenti di ogni comando e taglia ciascuno a 128 byte, e lo dice dentro il comando stesso (... (N more arguments)): Calíope lo mostra così com’è. Un AUTH appare mascherato.
Il dettaglio di una voce
Scegliendo una voce — sul Mac compare sotto la griglia; su iPhone e iPad, toccandola, in un foglio — si vedono il comando intero, l’ora con il suo fuso (l’orologio è quello del server), la durata in ms e in µs, l’indirizzo e il nome del client e il numero della voce. Copia comando lo copia; Apri nella console lo lascia scritto nella console, senza eseguirlo. Entrambi sono anche nel menu contestuale, e sul Mac un doppio clic o Invio aprono la console.
Svuotare Svuota registro, nella barra, cancella tutte le voci del server (SLOWLOG RESET). Prima chiede, dicendo quante se ne vanno, contate in quel momento con SLOWLOG LEN. Non si può annullare.
Chi è connesso al server Redis, cosa significano connesso, inattivo e i flag, e cosa succede quando disconnetti un client.
Dove si trova: Workspace › Strumenti › Client
Si applica a:Redis
Questa scheda mostra ciò che risponde CLIENT LIST: ogni connessione aperta verso il server, che venga da un’applicazione, da redis-cli o da Calíope stesso. L’elenco si rilegge da solo ogni 5 secondi finché è visibile, e Aggiorna lo rilegge subito. Il campo Filtra per nome, indirizzo o comando filtra ciò che è già stato letto —nome, indirizzo, ultimo comando, utente, libreria e ID— senza tornare al server. In un cluster l’elenco è quello del nodo del profilo, e un avviso lo dice: ogni nodo ha i propri client.
Le colonne
Sul Mac è una griglia con Client, ID, Indirizzo, Connesso, Inattivo, Database, Ultimo comando, Flag e Memoria, che si ordina facendo clic sull’intestazione; Utente e Libreria compaiono solo se qualche connessione li riporta (l’utente ACL esiste da Redis 6; la libreria, da Redis 7.2 e solo se il client si è presentato). Su iPhone e iPad ogni client è una riga con gli stessi dati, etichettati, e l’ordine si sceglie nel menu di ordinamento della barra: Per ID, Più inattivi, Connessi più di recente o Più memoria.
Connesso e inattivo non sono la stessa cosa Connesso (age) conta i secondi da quando la connessione è stata aperta; Inattivo (idle), i secondi dal suo ultimo comando. Una connessione di un pool è connessa da ore e inattiva da pochi secondi; una inattiva da molto tempo è aperta senza fare nulla, e occupa comunque memoria sul server. Un client bloccato in attesa di dati —un BLPOP, per esempio— accumula anch’esso inattività mentre aspetta, e il suo ultimo comando lo dice. Memoria (tot-mem) è ciò che la connessione occupa sul server, buffer di ingresso e di uscita compresi.
I flag Flag (flags) compare così come lo scrive il server, una lettera per flag. I più comuni: N, nessuno in particolare (una connessione normale); b, bloccata in attesa di dati (BLPOP, XREAD BLOCK…); P, iscritta a pub/sub; x, dentro un MULTI non ancora eseguito; S, una replica connessa a questo server; M, il primario, sulla connessione che una replica mantiene con lui; e O, un client in MONITOR.
Le connessioni di Calíope sono nell’elenco
Anche Calíope è un client, quindi le sue connessioni compaiono nell’elenco, con il nome Caliope e la libreria caliope; il loro ultimo comando di solito è la lettura stessa (client|list). Sono segnate con un simbolo e l’etichetta Questa sessione, e non si possono disconnettere da qui: chiuderle chiuderebbe la sessione. Calíope le riconosce dal loro ID, non dal nome: un’altra istanza di Calíope connessa allo stesso server si chiama allo stesso modo, e quella è davvero un altro client.
Disconnettere Disconnetti… chiude la connessione del client selezionato (CLIENT KILL ID). Prima chiede sempre, nominando il client, il suo indirizzo, il suo ID e il suo ultimo comando, e avvisando che ciò che aveva a metà —una transazione, un’iscrizione o un comando bloccato— va perso; si conferma con Disconnetti. Sul Mac ci si arriva dalla barra e dal menu contestuale; su iPhone e iPad, dal menu contestuale e scorrendo la riga verso sinistra, che chiede e non disconnette. Dopo, la riga sparisce sul posto e un avviso lo dice. Il client può riconnettersi —molti pool lo fanno da soli—, e allora ricompare alla lettura successiva con un altro ID. Il menu contestuale ha anche Copia indirizzo.
Quando il server risponde 0
Se tra la lettura e la conferma il client se n’era già andato, il server risponde di aver chiuso 0 connessioni. Non è un errore: Calíope dice che non era più connesso e toglie la riga.
Come si scrive e si legge un comando nella console di Redis, quali comandi non esegue e perché, e quali chiedono di scriverne il nome prima di partire.
Dove si trova: Workspace › Strumenti › Console
Si applica a:Redis
La console manda a Redis il comando che scrivi, sulla stessa sessione delle altre schede. Esegui —o Invio— lo esegue; sul Mac, Opzione+Invio spezza la riga senza eseguirla —un comando lungo può stare su più righe, e l’a capo conta come uno spazio—, e su iPhone e iPad il tasto Invio esegue sempre. La riga si divide come in redis-cli: gli argomenti sono separati da spazi, e le virgolette semplici o doppie riuniscono in uno solo ciò che contiene spazi; tra virgolette doppie valgono \n, \t e \xHH. Una virgoletta lasciata aperta non viene inviata, e l’output dice perché.
La cronologia
La freccia su richiama il comando precedente quando il cursore è sulla prima riga, e la freccia giù il successivo quando è sull’ultima; i pulsanti Comando precedente della cronologia e Comando successivo della cronologia fanno lo stesso senza tastiera. Conserva le ultime 200 righe, anche quelle che la console non ha eseguito, senza ripetere due volte di fila la stessa. Pulisci svuota l’output, non la cronologia. L’output, la cronologia e ciò che stavi scrivendo restano lì quando cambi scheda e torni.
Come si legge una risposta
- Uno stato come OK o PONG appare così com’è.
- Un intero è preceduto da (intero).
- Un testo è sempre tra virgolette, con i caratteri di controllo scritti con l’escape come in redis-cli ("a\r\nb"); un testo che non è UTF-8 appare in esadecimale, con la sua lunghezza in byte.
- (nullo) indica l’assenza di valore, e non è la stessa cosa della stringa vuota, che appare come "".
- Una lista è numerata, e se è vuota appare (array vuoto). Una mappa —ciò che restituiscono HGETALL o CONFIG GET— appare in coppie numerate campo => valore. Un insieme ha un’intestazione che dice quanti membri ha e che non hanno ordine, e i suoi membri sono elencati con un punto, senza numero.
- Un errore appare in rosso, con un glifo e (errore) davanti, e con il prefisso che gli dà il server (WRONGTYPE, ERR…).
- Una risposta di più di 2000 righe viene tagliata, e l’avviso rimanda a «Chiavi», che percorre le chiavi pagina per pagina.
In un cluster, sotto ogni risposta si dice chi ha risposto: il primario dello slot della prima chiave o, se il comando non ha chiave, il nodo del profilo. Un comando senza chiave —DBSIZE, INFO— conta solo quel nodo.
Cosa la console non esegue, e perché
Ogni rifiuto appare nell’output con il suo motivo, e il comando non arriva al server. Sotto, «Cosa non fare» apre l’argomento del Manuale del DBA che spiega perché:
- KEYS percorre tutte le chiavi in una volta e blocca il server finché dura. Per cercare chiavi c’è «Chiavi», che le percorre pagina per pagina con SCAN.
- MONITOR degrada il server finché dura e non si può chiudere dall’esterno.
- SUBSCRIBE, PSUBSCRIBE e SSUBSCRIBE farebbero arrivare i messaggi del canale mescolati alle risposte degli altri comandi. I canali attivi e i loro iscritti sono in «Server».
- SHUTDOWN spegne il server.
- DEBUG ha sottocomandi che fermano o fanno cadere il server (DEBUG SLEEP, DEBUG SEGFAULT).
- RESET e HELLO cambiano il protocollo sotto la connessione che Calíope sta usando, e CLIENT REPLY OFF o SKIP smettono di rispondere: il comando successivo aspetterebbe la sua risposta per sempre. SYNC e PSYNC trasformano la connessione in un collegamento di replica, che riceve tutto ciò che si scrive sul server.
- SELECT lascerebbe l’interfaccia a mostrare un database e a leggerne un altro: il database si sceglie con il selettore dello strumento.
- MULTI, EXEC, DISCARD, WATCH e UNWATCH: una transazione vive su una sola connessione, e la console manda ogni riga su quella libera, quindi i comandi successivi potrebbero finire su un’altra e la transazione resterebbe aperta. Per più comandi eseguiti insieme, senza nulla in mezzo, c’è EVAL con uno script.
- Un comando che aspetta un dato —BLPOP, BRPOP, BLMOVE, BZPOPMIN, XREAD … BLOCK, WAIT…— con un tempo di 0, cioè un’attesa senza fine, o di più di 10 secondi (più di 10000 millisecondi in XREAD BLOCK, WAIT e WAITAOF): mentre aspetta trattiene una delle connessioni che usano tutti gli strumenti della sessione. Con un tempo più breve viene eseguito.
Quelli che chiedono di scriverne il nome FLUSHDB e FLUSHALL cancellano tutte le chiavi —del database, o di tutti i database— e non si possono annullare; REPLICAOF, SLAVEOF, CLUSTER RESET e CLUSTER FAILOVER cambiano la topologia, e altri client possono perdere l’accesso ai loro dati. Per questi compare sopra il campo una fascia che dice cosa verrà cancellato o cambiato e su quale server, con un campo dove si scrive il nome del comando —senza distinguere le maiuscole— e un pulsante che non si attiva finché non lo si scrive. Annulla lo lascia senza inviarlo, e l’output lo dice.
Tutto il resto si esegue, anche EVAL, CONFIG SET e CLIENT KILL. Ciò che si esegue finisce nel registro dei comandi, con la password di AUTH nascosta.
Questo elenco vive nel codice di Calíope, in un solo punto, e ogni percorso che esegue un comando scritto da te lo consulta: se cambia, questo argomento cambia con lui.
Cosa mostra la topologia di una sessione Redis: primari, repliche e frammenti, perché il ritardo si misura in byte, cosa sono gli slot, cosa vuol dire che il cluster è in errore e perché Sentinel non c’è.
Dove si trova: Workspace › Strumenti › Topologia
Si applica a:Redis
La topologia mostra com’è montato il server della sessione. Un cluster appare come Cluster; un nodo singolo con repliche, come Nodo singolo e la sua replica. In alto c’è un riepilogo: quanti nodi e quanti primari rispondono, e quelli che non rispondono, indicati per indirizzo. Sotto, Diagramma disegna un riquadro per nodo, raggruppati per frammento, con il primario in alto e le sue repliche sotto, e Nodi dà lo stesso in una tabella. Si rilegge da sola ogni 5 secondi finché è in vista, e Aggiorna la rilegge subito.
Il ritardo è in byte, non in secondi
Una replica Redis non conferma un orario: conferma fino a quale byte del flusso di replica ha ricevuto. Per questo la colonna Ritardo (byte) è la posizione del primario meno quella della replica. Calíope legge il primario due volte, prima di interrogare chiunque e alla fine: quanto è avanzato tra le due letture è la soglia, e sotto di essa la replica appare Allineata, perché quella differenza non si distingue dal tempo che serve a interrogare un’altra macchina. Solo sopra appare In ritardo. Il lag= che Redis scrive accanto a ogni replica in INFO replication è un’altra cosa: i secondi dalla sua ultima conferma.
Quando un primario si riavvia inizia un flusso nuovo, e la sua replica non ha un ritardo misurabile finché non si risincronizza: la tabella dice Su un flusso di replica diverso dal suo primario e il ritardo «non misurato (altro flusso)», invece di mostrare 0 byte. Se la replica ha perso il collegamento con il suo primario, appare Collegamento con il primario interrotto.
Gli slot
Un cluster distribuisce le chiavi su 16384 slot: ogni chiave finisce in uno secondo il CRC16 del suo nome, e ogni primario serve un intervallo. Il numero è fisso e piccolo di proposito: la mappa di quale primario serve ogni slot viaggia tra i nodi a ogni heartbeat, e deve restare piccola. La colonna Slot indica l’intervallo di ogni primario, e il riepilogo dice quanti dei 16384 hanno un proprietario.
Quando il cluster è in errore
«Stato del cluster: fail» vuol dire che il cluster ha smesso di accettare comandi: ci sono slot senza un primario vivo che li serva, perché è caduto un primario senza replica che lo sostituisca o ne sono caduti diversi insieme. Un nodo che non risponde appare Non risponde, con l’errore tecnico accanto, e di lui non si afferma altro: né il ruolo né il ritardo.
Sentinel non c’è
Una sessione aperta su Sentinel non mostra la topologia: Sentinel sorveglia i primari e decide il failover, ma non conserva dati e non ha repliche proprie. Per vedere un primario con le sue repliche, apri la sessione sul primario.
Con VoiceOver, la tabella è l’alternativa al diagramma: ogni riga viene letta una volta, con il nome di ogni colonna prima del suo valore.
Cos’è un report di Redis, quali campi ha e quanto costa al server: una scansione delle chiavi a ogni esecuzione.
Dove si trova: Workspace › Strumenti › Report
Si applica a:Redis
Un report di Redis non ha una query: è una scansione delle chiavi trasformata in tabella, con una riga per chiave. Si crea con Nuovo report in una sessione Redis, e al posto dell’editor di testo compaiono i suoi campi.
Cosa scegli Pattern è un glob sul nome della chiave (app:*, sessione:??, user:[ab]*); vuoto significa tutte. Tipo tiene solo le chiavi di quel tipo. Colonne accende key, type, ttl, memory, encoding e length, che escono nell’ordine in cui le accendi; in Campi di hash ogni campo, separato da virgole, è una colonna in più con il valore di quel campo di un hash, vuota su una chiave che non è un hash o che non ce l’ha. Tetto di righe dice quante righe al massimo; vuoto è il tetto del motore.
Quanto costa
Ogni volta che premi Esegui, Calíope percorre con SCANtutte le chiavi che corrispondono al pattern — in un cluster, su ogni primario — e solo dopo chiede le colonne delle righe che restano. Il tetto taglia le righe, non la scansione: con un pattern ampio su un database con milioni di chiavi, il report richiede tempo anche se ne chiede dieci. Ferma lo ferma prima della pagina successiva della scansione.
La tabella
Le righe escono ordinate per chiave, così due esecuzioni danno la stessa tabella; se ce ne sono più del tetto restano le prime in quell’ordine, e la tabella dice che è stata tagliata. memory è ciò che risponde MEMORY USAGE: su una collezione è una stima per campionamento. Una chiave o un campo che non sono UTF-8 escono come 0x… con la loro lunghezza, e la loro colonna è segnata come binaria.
Parametri
Un parametro si scrive $$nome dentro il pattern e si dichiara con Dichiara i parametri. Il suo valore si cerca così com’è: un * nel valore è un asterisco, non un carattere jolly. Si scrive secondo il tipo dichiarato, e un valore che non è di quel tipo viene rifiutato prima di eseguire.
Il resto Esporta lo salva in uno qualsiasi dei formati del menu, PDF compreso, e Cronologia conserva ogni esecuzione, con le sue righe o con il suo errore. Un report di Redis si esegue solo in una sessione Redis: in un’altra, lo strumento dice che il report non è di quella sessione e non lo lascia eseguire. Pianifica non serve con lui: si pianificano solo i report di un database relazionale, e a ogni giro quello di Redis resta nella cronologia come Saltato.