Redis e PHP: installazione, configurazione ed esempi di utilizzo per effettuare le operazioni CRUD (Create, Read, Update, Delete)

di Giulio di Bari :: 28 settembre 2020

Redis è un database di tipo NoSQL, che salva i dati nella RAM anzichè su disco, come un insieme di coppie chiave-valore.

Ci siamo già occupati dettagliatamente dell'installazione di Redis in una distribuzione Centos 8, e dell'utilizzo di Redis da riga di comando

In breve, tramite yum, abbiamo installato il pacchetto Redis, disponibile nelle repo ufficiali di Centos

# yum install redis

Effettuata l'installazione, come visto nell'articolo precedente, nel file di configurazione "/etc/redis.conf" abbiamo impostato una password di accesso a Redis.

requirepass pipp@1234p!uto

Fatta questa premessa occupiamoci adesso di come utilizzare Redis in PHP, replicando tutti gli esempi visti nell'articolo dedicato all'utilizzo di Redis da riga di comando.

Redis supporta la maggior parte dei linguaggi di programmazione tra cui PHP.

Per utilizzare Redis in PHP dobbiamo installare l'estensione php-redis non disponibile nei repositori ufficiali di CentOS 8, per questo motivo dobbiamo abilitare i noti repo "epel" e "remi".

# yum install epel-release
# yum install https://rpms.remirepo.net/enterprise/remi-release-8.rpm

Centos 8 dispone di varie versioni di PHP, che possiamo evidenziare con il seguente comando

# yum module list php

Ecco i possibili PHP disponibili sulla repo ufficiale di Centos (AppStream) e su Remi. Sul nostro server è installata la versione 7.2 evidenziata con una "d".

CentOS-8 - AppStream
Name                   Stream                        Profiles                                    Summary
php                    7.2 [d]                       common [d], devel, minimal                  PHP scripting language
php                    7.3                           common [d], devel, minimal                  PHP scripting language

Remi's Modular repository for Enterprise Linux 8 - x86_64
Name                   Stream                        Profiles                                    Summary
php                    remi-7.2 [e]                  common [d], devel, minimal                  PHP scripting language
php                    remi-7.3                      common [d], devel, minimal                  PHP scripting language
php                    remi-7.4                      common [d], devel, minimal                  PHP scripting language
php                    remi-8.0                      common [d], devel, minimal                  PHP scripting language

Volendo possiamo modificare la versione di PHP installata, ad esempio alla versione 7.4 presente sul repo Remi, in tal caso la procedura da seguire è la seguente

# yum module reset php
# yum module enable php:remi-7.4

Adesso che epel e remi repo sono installati, ed abbiamo definito la versione PHP da usare, procediamo con l'installazione dell'estensione per utilizzare Redis

# yum install php-pecl-redis5

Nota: se non fosse disponibile il pacchetto "php-pecl-redis5" installate "php-pecl-redis"

Riavviamo il webserver Apache (o Nginx) e verifichiamo che sia l'estensione sia effettivamente installata.

Possiamo verificarlo in due modi: o da linea di comando "php -m" che elenca tutti i moduli installati.

# php -m

In questa lista dobbiamo sarà presente la voce Redis. Per restringere la ricerca andiamo a concatenare il comando con grep

# php -m | grep redis

Un'altra via per verificare la corretta installazione è quella di creare un file php, ad esempio info.php, con dentro questo codice

<?php
phpinfo();
?>

Apriamo il file nel browser web, e se l'installazione è avvenuta correttamente troveremo la sezione dedicata a Redis

Bene, adesso che il modulo Redis per PHP è installato proviamo la connessione al servizio Redis da un file PHP .

Creiamo una istanza (un oggetto) di classe Redis, e colleghiamoci al server locale 127.0.0.1, porta 6379.

<?php 
   $redis = new Redis();
   $redis->connect('127.0.0.1', 6379);
   echo "Connessione avvenuta con successo!";
?>

Apire il file su browser web: se la connessione ha avuto successo apparirà la scritta "Connessione avvenuta con successo"

Adesso, grazie all'istanza creata, possiamo accedere alle proprietà e metodi della classe, che ci consentiranno, ad esempio, di memorizzare, recuperare e cancellare i dati.

Per adesso facciamo un semplice "ping" per verificare che il server Redis sia attivo, come avevamo fatto nell'articolo precedente utilizzando l'interfaccia da terminale "Redis cli"

<?php 
   $redis = new Redis();
   $redis->connect('127.0.0.1', 6379);
   echo "Connessione avvenuta con successo!<br />";
   echo "Server is running: " . $redis->ping();
?>

Apri il file sempre da browser web...

Appare questo errore

Fatal error: Uncaught RedisException: NOAUTH Authentication required. 
in /var/www/html/test.php:5 Stack trace: #0 /var/www/html/test.php(5): Redis->ping() #1 {main} thrown in /var/www/html/test.php on line 5

Signfica semplicemente che, avendo impostato la password di accesso a Redis nel file di configurazione, adesso non l'abbiamo indicata.
Sempre nell'articolo precedente, da riga di comando, avevamo utilizzato il metodo "auth" seguito dalla password. In PHP non è molto differente.

<?php 
   $redis = new Redis();
   $redis->connect('127.0.0.1', 6379);
   echo "Connessione avvenuta con successo!<br />";
   $redis->auth('pipp@1234p!uto');
   echo "Server is running: " . $redis->ping();
?>

Da questo momento Redis è utilizzabile!

Vediamo adesso dei semplici esempi di creazione di una chiave / valore, e del recupero della stessa.

STRINGHE

Vediamo come gestire delle stringhe. Per stringhe in Redis non intendiamo solo stringhe di testo, ma anche stringhe numeriche, che vedremo nel prossimo paragrafo. Adesso occupiamoci di stringhe testuali.

Creiamo una chiave "name" con valore "Pippo".

Utilizziamo il metodo "set" per creare la chiave/valore, e "get" per recuperare il valore della chiave.

<?php 
   $redis = new Redis();
   $redis->connect('127.0.0.1', 6379);
   $redis->auth('pipp@1234p!uto');

   // creiamo la chiave
   $redis->set("name", "Pippo"); 
   // recuperiamo il valore
   echo "Il valore salvato nella chiave \"nome\" è ".$redis->get("name"); 
?>

Bingo!! Abbiamo creato la chiave "name" e poi abbiamo recuperato il valore salvato

VALORI NUMERICI

Nelle stringhe possiamo considerare anche i valor numerici.

Creiamo la key "contatore" e la impostiamo a valore 0.

Utilizzando i metodi "incr" e "decr" possiamo aumentare e diminuire il valore di una unità.

<?php 
   $redis = new Redis();
   $redis->connect('127.0.0.1', 6379);
   $redis->auth('pipp@1234p!uto');

   // creiamo la chiave
   $redis->set("contatore", 0); 

   // incrementiamo
   $redis->incr("contatore");
   $redis->incr("contatore");
   $redis->incr("contatore");

   // decrementiamo
   $redis->decr("contatore");

   // recuperiamo il valore
   echo "Il valore salvato nella chiave \"contatore\" è ".$redis->get("contatore"); 
?>

Per incrementare o decrementare di valori superiori all'unità utilizziamo i metodi "incrby" e "decryby"

<?php 
   $redis = new Redis();
   $redis->connect('127.0.0.1', 6379);
   $redis->auth('pipp@1234p!uto');

   // creiamo la chiave
   $redis->set("contatore", 0); 

   // incrementiamo di 7
   $redis->incrby("contatore",7);

   // decrementiamo di 2
   $redis->decrby("contatore", 2);

   // recuperiamo il valore
   echo "Il valore salvato nella chiave \"contatore\" è ".$redis->get("contatore"); 
?>

LISTA CHIAVI SALVATE: KEYS

Negli esempi precedenti abbiamo salvate le chiavi "name", "esempi-database", "contatore". Per conoscere tutte le chiavi salvate utilizziamo il metodo "keys" seguito dall'asterisco.

<?php
  $redis = new Redis();
  $redis->connect('127.0.0.1', 6379);
  $redis->auth('pipp@1234p!uto');

  $kList=$redis->keys('*');
  print_r($kList);
?>

Otteniamo una array con la lista delle keys salvate in Redis, in ordine decrescente (dall'ultimo salvato, al primo)

Array (
[0] => contatore
[1] => name
)

CANCELLARE UNA CHIAVE: DELETE

Utilizziamo il metodo "delete", ad esempio per cancellare la chiave "contatore":

<?php
  $redis = new Redis();
  $redis->connect('127.0.0.1', 6379);
  $redis->auth('pipp@1234p!uto');

  $redis->delete('contatore');

  $kList=$redis->keys('*');
  print_r($kList);
?>

CANCELLARE TUTTE LE CHIAVI: FLUSHALL

Per rimuovere tutte le chiavi utilizziamo il metodo "flushall"

<?php
  $redis = new Redis();
  $redis->connect('127.0.0.1', 6379);
  $redis->auth('pipp@1234p!uto');

  // cancelliamo tutte le chiavi
  $redis->flushall();

  // verifichiamo se le chiavi sono state cancellate
  $kList=$redis->keys('*');
  print_r($kList);
?>

VERIFICARE ESISTENZA DI UNA CHIAVE: EXISTS

Per verificare l'esistenza di una chiave usiamo il metodo "exists". Se ad esempio voglio verificare se esite la chiave "contatore"

<?php
  $redis = new Redis();
  $redis->connect('127.0.0.1', 6379);
  $redis->auth('pipp@1234p!uto');

  if($redis->exists('contatore')){
     echo "la chiave contatore esiste";
  }
  else {
     echo "la chiave contatore non esiste";
  }
?>

LISTE

Dopo aver visto le stringhe, occupiamoci delle liste.

Creiamo una chiave, ad esempio "esempi-database" e dentro, invece che salvare una stringa, salviamo una lista di valori.

In questo caso non usiamo "set" e "get" , bensì "lpush" e "lrange"

Ad esempio

<?php 
   $redis = new Redis();
   $redis->connect('127.0.0.1', 6379);
   $redis->auth('pipp@1234p!uto');

   // creiamo la lista
   $redis->lpush("esempi-database", "MariaDB"); 
   $redis->lpush("esempi-database", "Oracle");
   $redis->lpush("esempi-database", "Redis"); 
   $redis->lpush("esempi-database", "Mysql"); 
   $redis->lpush("esempi-database", "Mongodb"); 
   $redis->lpush("esempi-database", "DynamoDB"); 

   // recuperiamo i valori
   $arList = $redis->lrange("esempi-database", 0 ,2); 
   print_r($arList); 
?>

Il metodo "lpush" aggiunge un elemento all'inizio della lista. Questo significa che "DynamoDB" sarà il primo elemento della lista.

Per recuperare i valori della lista abbiamo utilizzato "lrange" che si aspetta 3 parametri:

"key": il nome della chiave da recuperare
"start": è l'elemento da cui iniziare l'estrazione: 0 è primo valore cioè "DynamoDB". Avessi indicato 1, il primo valore estratto sarebbe stato "Mongodb"
"stop": è l'elemento finale dell'estrazione: abbiamo indicato "2", per cui andiamo ad estrarre gli elementi "0 1 2" cioè "DynamoDB MongoDB MySQL". Avessi indicato "1" avremmo estratto solo i primi 2 elementi cioè "DynamoDB MongoDB". Indicando "-1" estraiamo tutti i records.

Otteniamo un array di valori.

Se il primo elemento, "start", è superiore agli elementi presenti nella lista (ad es. 8) verrà restituita una lista vuota.

Se lo "stop" è maggiore del numero di elementi della lista, verrà semplicemente considerato come l'ultimo elemento della lista.

Altri metodi relativi alle liste sono i seguenti

"rpush": se vogliamo salvare un elemento della lista, anzichè come primo elemento come avviene con "lpush", come ultimo elemento.
"llen": fornisce il numero di elementi della lista
"lpop": elimina il primo elemento della lista
"rpop": elimina l'ultimo elemento della lista

Vediamo un esempio completo con tutti questi metodi

<?php 
   $redis = new Redis();
   $redis->connect('127.0.0.1', 6379);
   $redis->auth('pipp@1234p!uto');

   // cancello la lista creata in precedenza, se presente
   if($redis->exists("esempi-database")){
      $redis->delete("esempi-database");
   }

   // aggiungo l'elemento all'inizio della lista
   $redis->lpush("esempi-database", "MariaDB"); 
   // aggiungo l'elemento all'inizio della lista
   $redis->lpush("esempi-database", "Oracle");
   // aggiungo l'elemento all'inizio della lista
   $redis->lpush("esempi-database", "Redis"); 
   // aggiungo l'elemento all'inizio della lista
   $redis->lpush("esempi-database", "Mysql"); 
   // aggiungo l'elemento all'inizio della lista
   $redis->lpush("esempi-database", "Mongodb"); 

   // recuperiamo i valori
   // $arList = $redis->lrange("esempi-database", 0, -1); 
   // print_r($arList); 

   // aggiungo l'elemento alla fine della lista
   $redis->rpush("esempi-database", "DynamoDB"); 

   // recuperiamo i valori
   // $arList = $redis->lrange("esempi-database", 0, -1); 
   // print_r($arList); 

   // elimino il primo elemento della lista, cioè Mongodb
   $redis->lpop("esempi-database");
   // elimino l'ultimo elemento della lista, cioè DynamoDB
   $redis->rpop("esempi-database");

   // contiamo gli elementi della lista
   $conta = $redis->llen("esempi-database");
   echo "Sono presenti ".$conta." elementi nella lista<br />";

   // recuperiamo i valori
   $arList = $redis->lrange("esempi-database", 0, -1); 
   print_r($arList); 
?>

HASHES

Simili alle stringhe, gli hashes contentono di salvare non una semplice coppia chiave/valore, bensì una chiave (la chiave dell'hash), una o più sottochiavi (entries) ed il loro valori (i valori della entries). Potete pensarlo simile ad un array associativo in PHP.

Ad esempio, utilizziamo questa struttura per redigere una classifica di calcio. La chiave sarà "classifica-seriea" le sottochiavi le squadre di calcio e i relativi valori i punti in classifica.

Utilizziamo i metodi "hset" per creare una sottochiave/valore della chiave "classifica-seriea", mentre utilizziamo il metodo "hget" per recuperare questo valore.

<?php 
   $redis = new Redis();
   $redis->connect('127.0.0.1', 6379);
   $redis->auth('pipp@1234p!uto');

   $key="calendario-seriea";

   $redis->hset($key, 'juve';, 18);
   $redis->hset($key, 'napoli', 15);
   $redis->hset($key, 'inter', 13);
   $redis->hset($key, 'milan', 12);
   $redis->hset($key, 'lazio', 12);

?>

Nota: se aggiungiamo nuovamente una sottochiave già esistente, il suo valore verrà sovrascritto. per cui se aggiungiamo questa riga, alla sottochiave "inter" verrà assegnato il nuovo valore 16

$redis->hset($key, 'inter', 16);

Mentre se volessimo incrementare il valore della sottochiave, utilizziamo il metodo "hincrby": ad esempio vogliamo aumentare il valore di "inter" di due unità indicheremo

$redis->hincrby($key, 'inter', 2);

Così facendo "inter" avrà come nuovo valore "18".

Questo sarà possibile solo per valori numerici, sia interi che di tipo float. Per i tipi float utilizziamo il metodo "hincrbfloat"

Per cancellare una sottochiave utilizziamo il metodo "hdel". Ad esempio per eliminare la sottochiave "inter" utilizziamo questa riga.

$redis->hdel($key, 'inter');

E' anche possibile assegnare all'hash più sottochiavi/valori nella stessa azione, utilizzando il metodo "hmset", come in questo esempio

$redis->hset($key, 'inter', 16);

$redis->hmset($key, [
    'inter' => 17,
    'juve' => 20,
    'milan' => 18,
]);

Per conoscere tutte le sottochiavi/valori di una hash utilizziamo il metodo "hgetall".

Questo esempio ritornerà tutte le squadre di campo presenti nell'hash "classifica-seriea" con il relativo valore

$redis->hgetall($key);

Per estrarre le sole sottochiavi utilizziamo il metodo "hkeys"

$redis->hkeys($key);

Per estrarre i soli valori utilizziamo il metodo "hvals"

$redis->hvals($key);

Per verificare l'esistenza di una sottochiave utilizziamo il metodo "hexists", come in questo esempio

if($redis->hexists($key,'juve)){echo "la juve è presente nella classifica";}
else{echo "la juve non è presente nella classifica";}

Per conoscere il numero di sottochiavi di un hash utilizziamo il metodo "hlen", come in questo esempio

echo $redis->hlen($key);

SETS

Rappresenta un insieme (una collezione) non ordinata di dati stringa unici, non ordinati, chiamati membri.

Spiegamo meglio questo concetto con un esempio.

Creiamo un insieme di elementi, composto da studenti iscritti ad un mio corso di PHP

La chiave, cioè il nome dell'insieme, sarà ad esempio "allievi_php": questo insieme conterrà stringhe composte dai nome di ogni alllievo iscritto al corso, ad esempio 5 allievi.

L'insieme non ammette duplicati per cui non possiamo inserire due volte lo stesso allievo.

Per creare questo insieme utilizziamo il metodo "sadd" come segue

<?php 
   $redis = new Redis();
   $redis->connect('127.0.0.1', 6379);
   $redis->auth('pipp@1234p!uto');

   $key="allievi-php";
   $redis->sadd($key, 'andrea');
   $redis->sadd($key, 'elisa');
   $redis->sadd($key, 'luca');
   $redis->sadd($key, 'stefano');
   $redis->sadd($key, 'maria');
?>

Abbiamo così popolato l’insieme con cinque elementi (membri).

Per ottenere l'elenco dei membri utlizziamo il metodo "smembers" come segue

   $redis->smembers($key);

Per eliminare un elemento dalla collezione utilizziamo il metodo "srem" come segue

   $redis->srem($key,'stefano');

Per eliminare più elementi, passiamo l'array di elementi come segue

   $redis->srem($key,['maria','luca']);

Per verificare se un elemento esiste utilizziamo il metodo "sismember" come segue: restituirà true se esiste o false se non esiste

   $redis->sismember($key,'luca');

Per contare il numero di elementi esiste il metodo "scard" come segue

   $redis->scard($key);

Bene, adesso mettiamo tutto assieme in uno script php

<?php 
   $redis = new Redis();
   $redis->connect('127.0.0.1', 6379);
   $redis->auth('pipp@1234p!uto');

   $key="allievi-php";

   // aggiungiamo studenti
   $redis->sadd($key, 'andrea');
   $redis->sadd($key, 'elisa');
   $redis->sadd($key, 'luca');
   $redis->sadd($key, 'stefano');
   $redis->sadd($key, 'maria');

   // conto gli studenti inseriti
   echo "sono presenti ".$redis->scard($key). " allievi<br />";

   // estraggo gli studenti inseriri
   $allievi=$redis->smembers($key);
   print_r($allievi);

   // rimuoviamo due allievi
   $redis->srem('maria');
   $redis->srem('luca');

   // verifico se l'allieva "maria" è presente
   if($redis->sismember($key,'maria')){echo "Maria è presente<br />";}
   else{echo "Maria non è presente<br />";}
   
   // se provo ad inserire nuovamente stefano, non verrà nuovamenta inserito
   // il metodo "sadd" renderà "false"
   if($redis->sadd($key, 'stefano')){echo "Stefano è stato inserito<br />";}
   else {echo "Stefano non è stato inserito perchè già presente<br />";}
?>

Se abbiamo più insiemi possiamo svolgere tra loro varie operazioni tra le quali l'unione, l'intersezione e la differenza.

A titolo di esempio, creiamo un altro insieme che raccolga allievi per un corso di Linux, alcuni dei quali (stefano ed elisa) frequentano anche il corso di PHP. Chiamiamo questo insieme "allievi_linux"

   $key="allievi-linux";
   $redis->sadd($key, 'stefano');
   $redis->sadd($key, 'giuseppe');
   $redis->sadd($key, 'elisa');
   $redis->sadd($key, 'mario');

Con il metodo "sdiff" verifichiamo la differenza tra due insiemi, cioè tutti gli allievi che sono presenti solo in un corso.

$redis->sdiff('allievi-php','allievi-linux');

Il risultato sarà un array con dentro: maria, andrea, luca

Con il metodo "sinter" effettuiamo l’operazione di intersezione tra i due insiemi, cioè otteniamo l’elenco di tutti quelli che sono iscritti ad entrambi i costi

$redis->sinter('allievi-php','allievi-linux');

Il risultato sarà elisa e stefano

Per ottenere tutti gli allievi, quindi l'unione dei due insiemi utilizziamo il metodo "sunion"

$redis->sunion('allievi-php','allievi-linux');

Il risultato sarà: mario, elisa, maria, andrea, giuseppe, luca, stefano

SORTED SET

Simile al caso precedente, ma in questo caso ad ogni elemento dell'insieme è associato a un valore numerico mobile, chiamato score (punteggio), che utilizziamo per ordinare gli elementi. Quindi è un insieme ordinato di elementi.

Per aggiungere un elemento nell'insieme utilizziamo il metodo "zadd" seguito dalla chiave dell'insieme il punteggio associato e la stringa da memorizzare.

Ad esempio creiamo una chiave "allievi-html" ed al suo interno salviamo gli allievi del corso con il voto ottenuto all'esame.

<?php 
   $redis = new Redis();
   $redis->connect('127.0.0.1', 6379);
   $redis->auth('pipp@1234p!uto');

   $key="allievi-html";
   $redis->zadd($key, 5, 'andrea');
   $redis->sadd($key, 8, 'elisa');
   $redis->sadd($key, 6, 'luca');
   $redis->sadd($key, 4, 'stefano');
   $redis->sadd($key, 7, 'maria');
?>

Se un elemento è già presente verrà semplicemente aggiornato con il nuovo punteggio.

Per ottenere il numero di elementi presenti nella chiave utilizziamo il metodo "zcard", mentre se vogliamo conoscere il numero di elementi con un punteggio interno ad un certo range utilizziamo "zcont".

Per incrementare un punteggio utlizziamo il metodo "zincrby", per eliminare un elemento "zrem, per recuperare il punteggio di un elemento utilizziamo il metodo "zscore".

Vediamo questi metodi con un esempio

<?php 
   $redis = new Redis();
   $redis->connect('127.0.0.1', 6379);
   $redis->auth('pipp@1234p!uto');

   $key="allievi-html";
 
   // aggiungiamo gli allievi del corso con i relativi punteggi
   $redis->zadd($key, 5, 'andrea');
   $redis->zadd($key, 8, 'elisa');
   $redis->zadd($key, 6, 'luca');
   $redis->zadd($key, 4, 'stefano');
   $redis->zadd($key, 7, 'maria');

   // contiamo gli allievi inseriti
   echo "Gli allievi inseriti sono ".$redis->zcard($key)."<br />";
   // contiamo gli allievi con punteggio sufficiente
   echo "Gli allievi insufficienti sono ".$redis->zcount($key, 4, 5)."<br />";

   // incrementiamo il punteggio di stefano di 6 punti
   $redis->zincrby($key, 6, 'stefano');

   // conteggio di stefano
   echo "Stefano adesso ha un punteggio di :".$redis->zscore($key,'stefano')."<br />";

   // eliminiamo luca dall'insieme
   $redis->zrem($key, 'luca');

   // contiamo gli allievi inseriti
   echo "Gli allievi presenti sono ".$redis->zcard($key)."<br />";
?>

Infine vediamo come recuperare dei sottoinsiemi della nostra chiave.

Per estrarre un sottoinsieme di elementi ordinati, dal punteggio minore al maggiore, utilizziamo il metodo "zrange": dobbiamo indicare la posizione inziale e quella finale da estrarre.

Nota: Redis utilizza la notazione Unix standard, il che significa che il primo elemento in un elenco è il numero 0, il secondo elemento è il numero 1 e così via.

Quindi, per estrarre i 3 allievi con il punteggio più basso indichiamo

$redis->zrange($key,0,2);

Il risultato sarà: andrea, maria, elisa

Per estrarre tutti i records indichiamo le posizioni da 0 a -1

$redis->zrange($key,0,-1);

Il risultato sarà: andrea, maria, elisa, stefano

Aggiungendo "true" dopo la posizione finale, abilitiamo l'opzione "withscores" cioè otteniamo anche i punteggi degli allievi

Per ottenere i 3 allievi con punteggio minore

$redis->zrange($key,0,2,true);

Il risultato sarà: andrea => 5, maria => 7, elisa => 8

Per estrarre gli allievi con un punteggio interno ad un certo range utilizziamo il metodo "zrangebyscore", indicando l'intervallo dei punteggi da cercare

Ad esempio se vogliamo conoscere gli allievi con punteggio tra 4 e 6

$redis->zrangebyscore($key,4,6);

Per recuperare la posizione di un elemento utilizziamo il metodo "zrank".

Ad esempio, per ottenere la posizione dell'allieva "elisa" indichiamo

$redis->zrank($key,'elisa');

Il risultato sarà: 2

Nota: le posizioni vengono contate a partire da 0 e i punteggi vengono ordinati in senso crescente cioè dal più basso al più alto.

Per invertire l'ordine, dal punteggio maggiore al minore, utilizziamo i metodi "zrevrange", "zrevrangebyscore" e "zrevrank"

Ad esempio, per indicare i 3 allievi con punteggio maggiore indichiamo

$redis->zrevrange($key,0,2);

Il risultato sarà: stefano, elisa, maria

E per ottenere anche i punteggi

$redis->zrevrange($key,0,2,true);

SCADENZA CHIAVI

Redis, come sappiamo, salva i dati in memoria, ed è probabile che non vogliamo lasciare i dati memorizzati in eterno.

Vediamo alcuni metodi tramite i quali possiam impostare la scadenza delle chiavi.

Il metodo "expire": imposta un tempo di scadenza di una chiave in secondi.

Il metodo "expireat": imposta un tempo di scadenza di una chiave ultilizzando lo unix timestamp.

Il metodo "ttl": fornisce il tempo di vita rimanente di una chiave

Il metodo "persist": fa durare una chiave per sempre rimuovendo l'eventuale scadenza impostata

<?php 
   $redis = new Redis();
   $redis->connect('127.0.0.1', 6379);
   $redis->auth('pipp@1234p!uto');

   // creo la chiave
   $key="cognome";
   $redis->set($key, "disney");

   // impostiamo la scadenza tra 3 minuti (180 secondi)
   $redis->expire($key, 180);
   // impostiamo la scadenza tra 3 minuti utlizzando la unix timestamp
   // $redis->expire($key, time() + 180);

   // mettiamo uno spleep di 10 secondi così da verificare la vita rimanente della chiave
   sleep(10);

   // verifichiamo tra quanto scade la chiave
   echo "La chiave scade tra ".$redis->ttl($key)."secondi <br />";

   // rendiamo la scadenza infintita
   $redis->persist($key);

   // verifichiamo nuovamente tra quanto scade la chiave
   echo "La nuova scadenza è: ".$redis->ttl($key);
?>

Lanciamo lo script ed attendiamo i 10 secondi previsti dallo sleep.
L'output sarà "La chiave scade tra 170 secondi", cioè i secondi ancora mancanti rispetto ai "180" previsti, e poi "La nuova scadenza è -1" dove "-1" sta ad indicare una scadenza infinita