Redis in python, come si chiude la connessione?

Question

https://github.com/andymccurdy/redis-py

So che in ruby ​​usiamo il metodo quit(). Non riesco a trovare nulla qui per Python

pitone:

import redis 
r = redis.StrictRedis(host='localhost', port=6379, db=0) 
r.set('foo', 'bar') 
print r.get('foo') 
#r.close() doesn't work 

rubino

require "redis" 
redis = Redis.new 
redis.set("mykey", "hello world") 
puts redis.get("mykey") 
redis.quit() 

Answer 1

Basta usare redis.Redis. Utilizza un pool di connessioni sotto il cofano, quindi non devi preoccuparti di gestire a quel livello.

Se è assolutamente necessario utilizzare una connessione di basso livello, è necessario eseguire la gestione della risposta che viene normalmente eseguita per lo redis.Redis.

Ecco un esempio di esecuzione di un singolo comando utilizzando la connessione a basso livello:

def execute_low_level(command, *args, **kwargs): 
    connection = redis.Connection(**kwargs) 
    try: 
     connection.connect() 
     connection.send_command(command, *args) 

     response = connection.read_response() 
     if command in redis.Redis.RESPONSE_CALLBACKS: 
      return redis.Redis.RESPONSE_CALLBACKS[command](response) 
     return response 

    finally: 
     del connection 

Esempio utilizzo:

response = execute_low_level(
     'HGET', 'redis:key', 'hash:key', host='localhost', port=6379) 

Ma, come ho detto prima, redis.Redis è la strada da percorrere nel 99,9% dei casi.

Answer 2

StrictRedis non implementa connessione semantica stessa, usa invece un pool di connessioni, che è disponibile come una proprietà di un'istanza StrictRedis: S.connection_pool. L'oggetto connection_pool ha un metodo disconnect per forzare una disconnessione immediata di tutte le connessioni nel pool, se necessario, tuttavia quando l'oggetto StrictRedis esce dall'ambito, le singole connessioni nel pool si puliscono da sole senza l'intervento dell'utente (vedere redis/connessione. py: 392-396)

Answer 3

non avete bisogno di preoccuparsi quando si utilizza ConnectionPool.look il codice sorgente:

def execute_command(self, *args, **options): 
    "Execute a command and return a parsed response" 
    pool = self.connection_pool 
    command_name = args[0] 
    connection = pool.get_connection(command_name, **options) 
    try: 
     connection.send_command(*args) 
     return self.parse_response(connection, command_name, **options) 
    except (ConnectionError, TimeoutError) as e: 
     connection.disconnect() 
     if not connection.retry_on_timeout and isinstance(e, TimeoutError): 
      raise 
     connection.send_command(*args) 
     return self.parse_response(connection, command_name, **options) 
    finally: 
     pool.release(connection) 

infine, ogni connessione rilascerà alla piscina, non importa quello che fai, e assegnerà ad altri client .