Código fuente de implementación de Stdmove
Introducción a LevelDB
1. Introducción a LevelDB
LevelDB es la base de datos independiente KV persistente de código abierto de Google, que tiene un alto nivel de escritura aleatoria y lectura/lectura secuencial. Rendimiento de escritura, pero el rendimiento de lectura aleatoria es muy promedio, lo que significa que LevelDB es muy adecuado para escenarios con pocas consultas pero muchas escrituras. LevelDB aplica la estrategia LSM (fusión estructurada de registros). lsm_tree retrasa y agrupa los cambios de índice y migra eficientemente las actualizaciones al disco de una manera similar a la ordenación por fusión, lo que reduce la sobrecarga de inserción de índice. Con respecto a LSM, también se mencionará brevemente más adelante en este artículo.
Según la descripción en el sitio web oficial de LevelDB, las características y limitaciones de LevelDB son las siguientes:
Características:
1. matrices de bytes de longitud arbitraria;
2. De forma predeterminada, las entradas (es decir, registros K-V) se almacenan en el orden de claves del diccionario. Por supuesto, los desarrolladores también pueden sobrecargar esta función de clasificación.
3. Interfaces de operación básicas proporcionadas: Put(), Delete(), Get(), lote()
4. Admite operaciones por lotes con operaciones atómicas.
5. Puede crear una instantánea del panorama de datos y permitirle encontrar datos en la instantánea;
6. Puede recorrer los datos a través de un iterador directo (o inverso) (el iterador lo hará). implícitamente para crear instantáneas);
7. Usar Snappy automáticamente para comprimir datos;
8. Portabilidad;
Limitaciones:
1. , Modelo de datos no relacional (Nosql), no admite sentencias o índices sql;
2. Solo se permite que un proceso acceda a una base de datos específica a la vez; No existe una arquitectura C/S incorporada, pero los desarrolladores pueden usar la biblioteca LevelDB para empaquetar un servidor.
LevelDB en sí es solo una biblioteca lib, que se puede compilar en el directorio fuente make y luego incluirse en el archivo de encabezado leveldb/include/db.h, y se puede incluir directamente en nuestra aplicación.
El archivo de encabezado tiene varias interfaces básicas de operación de base de datos. El siguiente es un ejemplo de prueba:
# include ltiostream gt
# include lt string gt
# include ltassert. .h gt
#Contiene "leveldb/db.h"
Usa el espacio de nombres std
int main(void)
{
nivel DB::DB * DB;
leveldb::Options;
opciones create_if_missing = true;
//Abrir<. /p>
nivel DB::Estado Estado = nivel DB::DB::Open(opciones, "/tmp/testdb ", ampdb);
assert( estado .ok());
clave de cadena = " nombre
valor de cadena = "Chen Qi";
//escribir
estado = d B- gt ; Put(leveldb:: WriteOptions(), clave, valor
assert(status . ok()
//Read
status =); d B- gt; Get(leveldb:: ReadOptions(), clave y valor);
assert(status . ok()
cout lt lt valor lt ltendl<); /p>
//Eliminar
estado = d B- gt; Eliminar(leveldb::WriteOptions(), clave);
afirmar(estado . ok()) ;
estado = d B- gt; Get(leveldb::ReadOptions(), clave y valor);
If (!status. ok()) {
cerr lt ltkey lt lt" " " lt lt estado. ToString() lt; ltendl
}else {
cout lt ltkey lt lt" = = = " lt ltvalue lt ltendl
}
//Cerrar
Eliminar db;
Devolver 0;
}
El ejemplo anterior demuestra cómo insertar y obtener y eliminar registros y cómo compilar el código:
g -o test test .CPP libleveldb.-LP thread-Iinclude
Después de la ejecución. /test, se generará un directorio testdb en /tmp, que contiene varios archivos:
-
LevelDB es la biblioteca del motor de almacenamiento clave-valor de código abierto de Google, similar al código abierto Biblioteca de índice Lucene. Otros desarrolladores de software pueden utilizar esta biblioteca para el desarrollo secundario y satisfacer las necesidades de personalización. LevelDB utiliza escrituras de registros para mejorar el rendimiento de escritura a expensas del rendimiento de lectura. Para compensar el rendimiento de lectura sacrificado, algunas personas han propuesto utilizar SSD como medio de almacenamiento.
Para los motores de almacenamiento de valores clave localizados, el uso simple generalmente se divide en tres pasos básicos: (1) Abrir la instancia de la base de datos (2) Insertar, modificar y consultar la instancia de la base de datos; Después del uso, cierre la base de datos. Estos tres pasos se analizan en detalle a continuación:
Primero, abra una instancia de base de datos
El nombre de la base de datosleveldb corresponde a un directorio del sistema de archivos. Todo el contenido de la base de datos se almacena en este directorio. El siguiente código describe cómo abrir una base de datos o crear una nueva base de datos.
# include ltassert.h gt
#Include "leveldb/db.h"
nivel DB::DB * DB;
niveldb::Opciones;
opciones.create_if_missing = true;
nivel DB::Estado Estado = nivel DB::DB::Open(opciones, " /tmp/testdb " , ampdb);
assert(status . ok());
Si abre una base de datos existente, debe generar un error. Inserte el siguiente código antes del métodoleveldb::DB::Open:
options.error _ if _ existe = true
Segundo, operaciones simples de lectura y escritura en la base de datos
LevelDB proporciona tres métodos: Put, Delete y Get para modificar y consultar la base de datos. Por ejemplo, el siguiente fragmento de código describe cómo mover el valor correspondiente a la clave1 al valor correspondiente a la clave2.
std::Valor de cadena;
nivel db::Estado s = d B- gt; Get(leveldb::ReadOptions(), clave1, valor de amplificador);
p>
if(s . ok())s = d B- gt; Put(leveldb::WriteOptions(), clave2, valor
if(s . ok); ())s = d B- gt; Delete(leveldb::WriteOptions(), key 1);
Tercero, cierra la base de datos
Después de realizar una serie de operaciones en el base de datos, debe cerrar la base de datos. Esta operación es relativamente simple:
...Abrir la base de datos como arriba...
...Hacer algo en la base de datos...
Eliminar the db ;
Lo anterior básicamente presenta el uso simple de levelDB, y el siguiente paso es cómo escribir un ejemplo completo y operable.
1. Descargue el clon fuente de git /p/leveldb/
2. Compile el código fuente a nivel de CD y todo lo producido
3. .cpp
# incluir ltassert.h gt
# incluir ltstring.h gt
# incluir ltlevel db/db .h gt;
# incluir ltiostream gt
int main(){
nivel DB::DB * DB;
leveldb::opción Opciones;
options.create_if_missing = true;
nivel DB::Status Estado = nivel DB::DB::Open(opciones, "/tmp/testdb", ampdb);
assert(status . ok());
//Escribir clave1, valor1
STD::cadena clave = "clave";
STD :: valor de cadena = " valor ";
estado = d B- gt; Put(leveldb::WriteOptions(), clave, valor);
assert(status . ok( )) ;
estado = d B- gt; Get(leveldb::ReadOptions(), clave amp; valor);
assert(status . ok());
p>
STD::cout lt; ltvaluelt ltSTD::endl;
STD::string key 2 = "key 2";
//Descargar el key Mueve el valor a key2
status = d B- gt; Put(leveldb::WriteOptions(), key2, value);
assert(status . ok());
estado = d B- gt; Eliminar(leveldb::WriteOptions(), clave);
assert(status . ok());
estado = d B- gt; Get(leveldb::ReadOptions(), clave 2 amp; valor
assert(status . ok()); ltkey2 lt lt" = = = " lt ltvalue lt ltstd::endl;
estado = d B- gt; niveldb::ReadOptions(), clave y valor);
Si(! estado .ok())STD::cerr lt; ltkey lt lt" " " lt lt estado.
ToString() lt; ltstd::endl;
else std::cout lt; ltkey lt" = = = " lt ltvaluelt ltstd::endl; /p>
Devuelve 0;
}
4. Compile y vincule G -otesttest.cpp../level db/libre veldb . ./leveldb/include.
Tenga en cuenta que las rutas a libleveldb.a yleveldb incluyen.
5. Resultados de ejecución. /prueba:
valor
clave2 = = =valor
Clave no encontrada: