Ya he tratado casi en su totalidad las funciones más básicas de PHPCassa y Cassandra, con lo que ya tendrás un conocimiento suficientemente amplio de lo que se puede hacer con ellos, el resto dependerá de la evolución de la BD y de las librerías (y de la experiencia que tengas xP).
Hoy trataré varios temas que por las consultas realizadas por varios usuarios se merece un post aparte en el que se pueda tratar de una forma más amplia. Estos temas son: ordenar registros, crear keys para los registros y contar registros.
ORDENAR REGISTROS
Cassandra dispone de varios tipos de comparadores y subcomparadores para ordenar los registros. El más habitual es UTF-8 pero hay varios más. Si vamos a Cassandra Cluster Admin y accedemos al formulario de creación de columns family, podremos pasar el ratón por los interrogantes que hay a la izquierda de los campos para poder ver los diferentes tipos de comparadores:
Como puedes ver, estos comparadores le dicen a Cassandra como ordenar los registros. Si has seguido este tutorial ya conocerás al menos uno de los comparadores (utf-8) por tanto vamos a ver como ordena Cassandra los registros con este comparador.
Para este primer ejemplo vamos a crear una column family llamada column_family_order_utf8 de tipo standard y el tipo de comparador UTF8Type.
Vamos a nuestro archivo test.php y escribimos el siguiente código:
[codesyntax lang=»php»]
<?php
$data = array();
$data[5] = array(
'title' => 'Apache Cassandra',
'license' => 'Open Source',
'category' => 'no-sql',
);
$data[3] = array(
'title' => 'MongoDB',
'license' => 'Open Source',
'category' => 'no-sql'
);
$data[1] = array(
'title' => 'Neo4j',
'license' => 'Open Source',
'category' => 'no-sql',
);
$data[4] = array(
'title' => 'MySQL',
'license' => 'Open Source',
'category' => 'sql'
);
$data[2] = array(
'title' => 'MariaDB',
'license' => 'Open Source',
'category' => 'sql',
);
foreach($data as $key => $value){
$cass->guardar('column_family_order_utf8', $key, $value);
}[/codesyntax]
Este código guardará un array desordenado en nuestra column family. Una vez ejecutado el script accedemos a Cassandra Cluster Admin y visualizamos los registros de column_family_order_utf8, nos mostrará el siguiente resultado:
Como puedes observar los registros no se han ordenado, sin embargo cada una de las columns de cada registro sí están ordenadas por orden alfabético. Esto sucede porque los comparadores no ordenan por keys o claves de los registros sino por columns, aunque hay un caso especial, si la column family es super los registros si estarán ordenados. Veamoslo.
Creamos una column family llamada column_family_utf8_super con el tipo de comparador UTF8Type y el tipo de column family como super. En nuestro archivo test.php añadimos el siguiente código:
[codesyntax lang=»php»]
<?php
$data = array();
$data[5] = array(
'title' => 'Apache Cassandra',
'license' => 'Open Source',
'category' => 'no-sql',
);
$data[3] = array(
'title' => 'MongoDB',
'license' => 'Open Source',
'category' => 'no-sql'
);
$data[1] = array(
'title' => 'Neo4j',
'license' => 'Open Source',
'category' => 'no-sql',
);
$data[4] = array(
'title' => 'MySQL',
'license' => 'Open Source',
'category' => 'sql'
);
$data[2] = array(
'title' => 'MariaDB',
'license' => 'Open Source',
'category' => 'sql',
);
$cass->guardar('column_family_order_utf8_super', 'databases', $data);[/codesyntax]
Una vez ejecutado este script nos vamos a nuestra column family y nos mostrará lo siguiente:
Como puedes observar ahora sí están ordenados los registros, pero claro ahora están dentro de una super column.
En Cassandra la ordenación se realiza a las columnas del registro o los registros dentro de las super columns, si creasemos otra super column, esta no se ordenaría con respecto a la ya creada, ‘databases’.
Aunque esta ordenación puede ser útil y totalmente funcional, para los desarrolladores que vengan de las bases de datos relacionales les puede resultar confuso. Por ejemplo, para guardar los comentarios de un post de un blog podríamos utilizar este tipo de ordenación perfectamente, ya que podemos utilizar el id del post como key de la super column (el ‘databases’ de la imagen anterior se sustituiría por el id del post) y el timestamp (como este 1337787675.32246500) para la key de los registros. De esta forma tendríamos ordenados los comentarios por tiempo y por post. Si quisieramos recuperar los comentarios de un post concreto solo tendríamos que pasarle al método correspondiente el id del post como key de la super column.
¿Y si quisieramos guardar los post del blog? En este caso una column family super nos lo podría resolver indicando como key de la super column ‘posts‘ y utilizando como key en los registros el timestamp. Pero si quisieramos hacer busquedas utilizando indices secundarios una column family super no nos valdría, ya que los indices secundarios no funcionan en ellas.
Para ello habría que crear una column family standard para los post, que nos permitirá usar los indices secundarios, y una column family super para guardar las keys de los post dentro de una super column con key, por ejemplo, ‘key_posts‘. Para hacer la consulta habría que recuperar las keys de los posts a mostrar en primer lugar, y después, utilizando un método de PHPCassa que aun no hemos usado recuperar los registros correspondientes a esas keys.
El método que deberíamos añadir a nuestro archivo cassandra.php sería el siguiente:
[codesyntax lang=»php»]
<?php
function obtenerMultiplesRegistros($name_columnFamily, $multiKeys, $super_column = ''){
if (!empty($super_column)){
$column_family = new SuperColumnFamily($this->conexion, $name_columnFamily);
$result = $column_family->multiget_super_column($multiKeys, $super_column);
}
else{
$column_family = new ColumnFamily($this->conexion, $name_columnFamily);
$result = $column_family->multiget($multiKeys);
}
return $result;
}[/codesyntax]
A este método le pasamos el nombre de la column family standard donde hemos guardado los posts y un array con las keys a recuperar, nos devolverá un array con los datos de cada uno de los posts que le hemos pedido… y en el orden en el que le hayamos pasado las keys a recuperar.
Existe otra forma de ordenar registros, pero además de que en versiones posteriores de Cassandra desaparecerá y provoca problemas de rendimiento, yo no la recomiendo, ya que pierdes todos los beneficios que ofrece Cassandra. Aun así os dejo un link para que le echéis un ojo xD:
http://ria101.wordpress.com/2010/02/22/cassandra-randompartitioner-vs-orderpreservingpartitioner/
Y os dejo otro link para que tengais algo más de información respecto a ordenar registros en Cassandra:
http://ayogo.com/blog/2010/04/09/sorting-in-cassandra/
CREAR CLAVES O KEYS PARA LOS REGISTROS
Como has podido ver en el apartado anterior, para ordenar los registros es muy importante tener una key de cada registro que sea única y siempre vaya en orden. Esto las bases de datos relacionales nos lo dan ya hecho, sin embargo en las bases de datos no-sql esto no es así.
Las bases de datos no-sql se crearon para optimizar la lectura y escritura de los registros en la base de datos, esto provocó que algunas funcionalidades muy útiles en las bases relaciones no tuvieran cabida en las no-sql. Por tanto para mantener en orden los registros debemos crear nosotros nuestras propias claves.
PHPCassa dispone de un método para crear una clave aleatoria basada en el timestamp.
Para utilizarla primero añadiremos la clase a nuestra lista:
[codesyntax lang=»php» highlight_lines=»11″]
<?php use phpcassa\Connection\ConnectionPool; use phpcassa\ColumnFamily; use phpcassa\SuperColumnFamily; use phpcassa\ColumnSlice; use phpcassa\SystemManager; use phpcassa\Schema\StrategyClass; use phpcassa\Index\IndexExpression; use phpcassa\Index\IndexClause; use phpcassa\UUID;
[/codesyntax]
Ahora crearemos un nuevo método en nuestro archivo cassamdra.php que devolverá la clave:
[codesyntax lang=»php»]
<?php
public function obtenerUuid(){
$util = new UUID;
return $util->import($util->uuid1());
}[/codesyntax]
Como me está quedando un post muy largo os voy a dejar algo de deberes xD. Sería interesante probarlo tanto con column families standard y super, además de con un tipo de comparador UTF8Type y TimeUUIDType.
Como el chorro de letras y números que devuelve es muy poco legible yo suelo utilizar mi propio sistema de claves, normalmente utilizo el microtime() de php y un par de ids de lo que se esté guardando: el id del usuario, el id de lo que se ha creado, etc. Algo que lo diferencie del resto. Para la clave primero pongo los segundos que devuelve microtime() y después los microsegundos. Para que os hagais una idea sería algo así:
$key = $segundos . ‘.’ . $microsegundos . ‘_’ . $id_post . ‘_’ . $id_usuario;
De esta forma le estamos dando una clave para los ejemplos del anterior apartado, más concretamente para los comentarios en un post.
CONTAR REGISTROS
El último apartado de este post. Contar registros. Esto es algo que Cassandra no lleva muy bien, sobre todo con grandes cantidades de información.
Cassandra cuando recibe una petición de lectura/escritura utiliza unas tablas en memoria llamadas memtables (el que le puso el nombre de rompió la cabeza pensando). Cuantas más peticiones reciba Cassandra más memtables creará, de esta forma permitirá una cierta consistencia de la información almacenada en la base de datos.
Cuando le pedimos a phpCassa que nos devuelva el número de registros en una column family o en una super column concreta, lo que está haciendo en realidad es hacer una petición a Cassandra de todos los registros que haya en la column family o en la super column. Cuando esto ocurre Cassandra guardará estos registros en la RAM del servidor antes de enviarlos a phpCassa, y sí Cassandra no cuenta los registros, porque no está pensada para eso, es phpCassa la que cuenta los registros y te devuelve el número concreto.
El método que utiliza phpCassa para contar registros es el que os muestro a continuación, dentro de un método para añadir al archivo cassandra.php:
[codesyntax lang=»php»]
<?php
public function contar_registros($name_columnFamily, $key, $super_column='', $range_start='', $range_end=''){
$column_slice = new ColumnSlice($range_start, $range_end);
if (!empty($super_column)){
$column_family = new SuperColumnFamily($this->conexion, $name_columnFamily);
$result = $column_family->get_subcolumn_count($key, $super_column, $column_slice);
}
else{
$column_family = new ColumnFamily($this->conexion, $name_columnFamily);
$result = $column_family->get_count($key, $column_slice);
}
return $result;
}[/codesyntax]
Esta forma de contar registros provoca que Cassandra consuma todos los recursos de RAM del servidor, con lo que no os la recomiendo.
La mejor manera de contar registros con Cassandra es utilizar una column family con contadores, de tal forma que en nuestro código cada vez que se guarde un registro en la bd se aumente el contador que lleva la cuenta de los registros guardados. En el caso de que se eliminen, habría que disminuirlo. Y en el caso de que el registro se esté actualizando controlar que no aumente el contador xD.
Cualquier duda que tengais intentaré responderla lo mejor posible en los comentarios.
