Persistencia simple, moderna, robusta y transparente de estructuras de datos para Perl

Question

Estoy buscando una solución transparente persisten las estructuras de datos Perl (ni siquiera los objetos, pero el soporte de objeto sería un plus) sin referencias circulares. No me importa mucho el back-end, pero prefiero JSON. La cantidad de objetos sería relativamente baja (unos pocos miles de hashrefs con aproximadamente 5 claves cada uno). Con la persistencia "transparente" quiero decir que no quiero tener que realizar cambios en el backend de almacenamiento cada vez que actualizo la estructura de datos en memoria.

Así es como el código lo ideal sería el siguiente aspecto:

my $ds; 

... 
# load the $ds data structure from 'myfile' 

print $ds->{foo}->{bar}; # baz 
$ds->{foo}->{bar} = 'quux'; 

... program dies, but the updated %hash has been persisted automatically in 'myfile' 

# in another invocation 
print $ds->{foo}->{bar}; # quux 

Hasta ahora he visto: Perl Object-Oriented Persistence compilación de módulos de

• de Dave Rolsky - sin cambios desde 2003
• Brian d foy's MasteringPerl - Chapter 14. Data Serialization - habla sobre DBM :: Deep, un buen candidato. Ojalá hubiera una diferencia más clara entre la serialización y la persistencia transparente.
• Persistent - sin cambios desde el año 2000
• SPOPS - abandonada desde 2004
• SLOOPS sólo tiene una versión en CPAN, de 2005
• Tangram - parece abandonado demasiado
• Tie::File::AsHash qué persistencia transparente, pero sólo es compatible con single-level hashes
• MooseX::Storage, Storable y JSON se ven bien, pero solo son de serialización, no persisten marcos de ENCE
• DBIx::Class, Class::DBI, Fey::ORM, ORM, Rose::DB son creadores de mapas OO-RDBM, y I'd rather not use a database backend
• DB_File requiere BerkeleyDB
• KiokuDB parece demasiado complejo para la tarea

sólo he encontrado uno módulo prometedor, DBM::Deep. El código es como en el ejemplo, y puede cargar la estructura de datos con

my $ds = DBM::Deep->new("myfile.db"); 

Sin embargo, el formato es binario. No es un gran problema, ya que puedo usar JSON para exportarlo en un formato legible para las personas.

Entonces, ¿me falta un módulo y me estoy acercando al problema correctamente?

Answer 1

para lograr su objetivo "transparencia", vas a tener que o bien abstracta en un marco (como se sugirió chambwez) o utilizar tie d variables que se guardarán en el disco cada vez que se actualicen. Los algoritmos hash de DBM usan tie de esta forma, por lo que DBM::Deep es probablemente su mejor opción; todo lo demás que conozco requiere que explícitamente diga cuándo escribir datos y/o escrituras en caché en nombre del rendimiento.

Answer 2

¿Por qué no utilizar JSON? Es bastante fácil (a menos que no he entendido bien su pregunta), todo lo que se hacer es esto:

use JSON; 
# serialize to file 
open(my $fh, ">myfile"); 
print $fh encode_json($ds); 
close $fh; 
# deserialize from file 
open(my $fh, "<myfile"); 
local $/ = undef; 
my $content = <$fh>; 
$ds = decode_json($content); 
close $fh; 

Otra cosa fácil que puede hacer es utilizar Data::Dumper.

Answer 3

No creo que la persistencia transparente sea una muy buena idea. Supongamos que tiene una implementación hipotética que vincula la estructura de datos perl al mundo exterior. Para ser transparente, cada escritura en la estructura debe ser detectada y los datos actualizados.Es probable que esto sea bastante costoso y termine con mucha actividad de disco a menos que tenga un back-end sofisticado con acceso aleatorio rápido. No puedo imaginar que las actualizaciones del archivo JSON sean eficientes.

Algunas opciones:

• base de datos backend uso (DBM :: profundo, DB_File o KiokuDB)
• utilización clave-valor Store como backend (Memcached, Redis)
• definen el flujo de trabajo consistente en los datos y serializar/deserializar en buen momento