Libros gratuitos

 Me llegaron ests libros de web code geeks :

Get Schooled By Web Code Geeks

Download FREE IT Guides!   Starting with Kotlin Cheatsheet Welcome to the Kotlin Cheatsheet! This document aims to provide you with a quick reference guide to Kotlin programming language. Whether you are a beginner getting started with Kotlin or...     Querying Graphs with Neo4j Cheatsheet This cheatsheet is your guide to effectively querying graphs using Neo4j. Whether you’re a seasoned database professional looking to expand your skills or a curious enthusiast eager to...     Getting Started with GraphQL Cheatsheet In this cheatsheet, we will embark on a journey to explore the core principles of GraphQL and its ecosystem. We'll cover topics such as schema design, querying and mutation operations,...     Starting with Windows PowerShell Cheatsheet This cheatsheet provides an overview of the most commonly used PowerShell commands, grouped by category. Whether you’re new to PowerShell or an experienced user, this cheatsheet will...     Core Python Cheatsheet This cheatsheet is intended to serve as a quick reference guide for Python programming. It covers some of the most commonly used syntax and features of the language, including data types,...     Starting with Docker Cheatsheet This guide aims to provide an overview of the key concepts and features of Docker, along with practical examples and tips for using it effectively. It covers topics such as Docker...

NoSQL Database Adoption Trends

InfoQ se le ocurrió una gran idea hacer una encuesta sobre bases de datos NoSQL y ya tiempo ha pasado desde que las bases NoSQL se convirtieron de una moda a algo de todos los días. InfoQ organizo la encuesta como una matriz de 2 dimensiones: propósito y adopción. Eso esta bueno, una base puede ser fácil de adoptar pero la mejora no es significativa.

Por ahorra va ganando MongoDB en adopción y Redis en propósito.

A votar!

 http://www.infoq.com/research/nosql-databases?utm_source=infoqEmail&utm_medium=WeeklyNL_ResearchContent&utm_campaign=072313news

Los últimos avances en Neo4j

Leyendo InfoQ me encontré con un articulo sobre los avances de Neo4j. Neo4j anuncio su versión 1.9 y 2.0; y también anuncio un nuevo proyecto, Neo4j para Android.

Que trae de nuevo Neo4j 1.9?

• Mejora en tolerancia de fallos.
• El Cypher (Lenguaje de consulta de Neo4j) creo nuevas funciones: manejo de cadenas, REDUCE y TIMESTAMP.
• Mejor copia de seguridad para la versión empresarial, que ahora detecta si el total o una copia de seguridad incremental es necesaria.
• Mejora de la capacidad de memoria y el rendimiento.

Neo4j 1.9 necesita el jre 1.7 para correr.

Es grandioso ver como va creciendo esta base de datos NoSQL.

Dejo link:
http://www.infoq.com/news/2013/05/neo4j-1-9-2-0
http://blog.neo4j.org/2013/05/neo4j-19-general-availability.html
https://github.com/neo4j-contrib/neo4j-mobile-android

7 base de datos en 7 días

Se acuerdan que hable de un libro muy bueno llamado 7 lenguajes en 7 días, bueno Eric Redmond y Jim R. Wilson lanzaron un nuevo libro llamado 7 base de datos en 7 días. En el recorre base de datos relacionales y NoSQL. Las bases que se muestran son Redis, Neo4J, CouchDB, MongoDB, HBase, Riak, y Postgres. La idea es no saber todas, pero si sus particularidades y porque elegir una o la otra.

Dejo el link:
http://pragprog.com/book/rwdata/seven-databases-in-seven-weeks

Spring Data, accediendo fácilmente a cualquier almacén de datos

Spring Data es un proyecto SpringSource cuyo propósito es unificar y facilitar el acceso a diferentes tipos de almacenes de persistencia, tanto en los sistemas de bases de datos relacionales y almacenes de datos NoSQL.

Cada subtipo de proyecto dependiente del alamacen de datos se caracterizan por ofrecer CRUD (Create-Read-Update-Delete), métodos de búsqueda, clasificación y paginación. Spring Data proporciona interfaces genéricas para estos aspectos (CrudRepository, PagingAndSortingRepository), así como implementaciones de persistencia específica.

Podemos extender las interfaces como lo hacemos para nuestros daos de hibernate o jpa:


public interface UserRepository extends MongoRepository<User, String> {
        @Query("{ fullName: ?0 }")
        List<User> findByTheUsersFullName(String fullName);
        List<User> findByFullNameLike(String fullName, Sort sort);
}
...

Para los proyectos Neo4J y MongoDB; spring data nos ofrece Templates. Que nos permiten hacer operaciones de CRUD, busquedas Pero todos estos métodos funcionan sólo para el almacén de datos configurado. Spring Data JPA no ofrece Templates dado que EntityManager es como un template.

Para configurar un template lo podemos hacer de este modo:

Dependiente de la tecnología que utilicemos para almancenar datos podemos anotar nuestros objetos. Cada tipo de almacén de datos viene con su propio conjunto de anotaciones para proporcionar la meta información necesaria para la asignación. Vamos a ver cómo un usuario de dominio objeto simple se pueden asignar a los almacenes de datos:

JPA	MongoDB	Neo4j
@Entity @Table(name="TUSR") public class User {   @Id   private String id;   @Column(name="fn")   private String name;   private Date lastLogin; ... }	@Document( collection="usr") public class User {   @Id   private String id;   @Field("fn")   private String name;   private Date lastLogin;  ... }	@NodeEntity public class User {   @GraphId   Long id;   private String name;   private Date lastLogin; ... }

Todo aquel que este familiarizado con las anotaciones de de JPA puede, utilizar sin problemas las anotaciones de los otros almacenes de datos. 

Algo muy importante es que Spring Data provee QueryDsl para las consultas a repositorios JPA, MongoDb y Neo4J. QueryDsl permite generar consultas por medio de un dsl de forma muy fácil.

No hay ninguna API general a todos los almacenes de persistencia. Las diferencias son demasiado fundamentales. Pero el proyecto de datos Spring proporciona un modelo de programación común para acceder a sus datos.

Dejo link:

http://www.infoq.com/articles/spring-data-intro
http://www.springsource.org/spring-data

Queres aprender Neo4j?

Si queres aprender sobre la base orientada a grafos más popular te dejo unos link del sitio oficial:

http://neo4j.org/learn/
http://neo4j.org/resources/

Con Heroku, Neo4J se va a las nubes!

Una base de datos NoSQL que esta haciendo su camino hacia la nube, es Neo4J, una base de datos gráfica; de la cual ya hablamos. Además de otras mejoras como Cypher (el motor de consulta), web de administración, actualización Lucene. Neo4J 1.6 ahora se puede acceder desde Heroku actualmente a través de un add-on beta a través de una interfaz REST. Hay un número de clientes REST Neo4J permitidos; y como es REST se puede consultar de diferentes lenguajes como: .NET, Python, Django, PHP, Ruby y Java. 

Heroku adds-on permite a los usuarios que puedan ampliar la funcionalidad básica, añadir características o conectarse a servicios externos, el último de ellos el caso de cómo se accede desde Heroku a Neo4J.

Dejo links:
http://blog.neo4j.org/2011/12/neo4j-labs-heroku-neo4j-and-google.html
http://addons.heroku.com/neo4j
http://devcenter.heroku.com/articles/neo4j

Bio4j

Bio4j seria como grafo bioinformatico basado en base de dato que incluye la mayor cantidad de datos de UniProt KB(SwissProt + Trembl), Gene Ontology (GO), UniRef (50,90,100), RefSeq, and NCBI taxonomy. (Manuscript in preparation). La verdad es que esto es chino básico para mi pero creo que mi hermano que es bioinformatico le va interesar.

Bio4j  usa neo4j para representar la información.

Lo interesante es que utiliza licencia AGPL 3 .

Dejo links:

http://www.bio4j.com/
http://blog.bio4j.com/

Spring Data Neo4j

Neo4j es una base de datos basada en grafos. De la cual ya hablamos:

http://emanuelpeg.blogspot.com/2009/09/neo4j.html

Neo4j permite acceder a un nodo mediante una clave la cual contiene un valor. También tenemos una API para acceder a los datos y un lenguaje de consulta llamado Cypher.

Una de las características de Neo4j es que es una base transaccional y por lo tanto soporta ACID. Esto es bastante inusual para una base de datos NoSQL.

Podemos agregar a un estro proyecto Neo4j (si utilizamos maven) con la siguiente entrada en el pom:

  
   org.neo4j
   neo4j
   1.5
  

Trabajar con la Api de Neo4j puede ser un trabajo duro por lo tanto Spring framework nos provee un modulo que nos permite trabajar con Neo4j de forma más fácil y elegante.

Primero agregamos la siguiente entrada al pom:

 
org.springframework.data 
spring-data-neo4j 
2.0.0.RC1 
 

Y ahora vamos a agregar la siguiente entrada al applicationContext.xml :

 
... 
 
... 
 

La idea es hacer una aplicación que mantenga la relación de amistad entre personas. Primero creamos el proyecto con maven:

mvn archetype:generate

Luego configuramos como un proyecto normalito de maven.

Y el pom debería tener las siguientes dependencias:

 4.0.0

 org.assembly
 friend
 1.0-SNAPSHOT
 jar

 friend
 http://maven.apache.org

 
  UTF-8
  3.0.6.RELEASE
 

 
  
   
    maven-compiler-plugin
    
     1.6
     1.6
    
   
   
    org.apache.maven.plugins
    maven-eclipse-plugin
    2.7
    
     2.0
     true
    
   
   
    org.apache.maven.plugins
    maven-javadoc-plugin
   
   
    org.apache.maven.plugins
    maven-project-info-reports-plugin
   
  
 

 
  
   spring-snapshot
   Spring Maven SNAPSHOT Repository
   http://s3.amazonaws.com/maven.springframework.org/snapshot
  
 

 

  
   org.springframework.data
   spring-data-neo4j
   2.0.0.BUILD-SNAPSHOT
  

  
   org.springframework
   spring-core
   ${spring.version}
  

  
   org.springframework
   spring-context
   ${spring.version}
  

  
   org.springframework
   spring-aop
   ${spring.version}
  

  
   org.springframework
   spring-aspects
   ${spring.version}
  

  
   org.springframework
   spring-tx
   ${spring.version}
  

  
   org.neo4j
   neo4j
   1.5
  

  
   junit
   junit
   4.10
   test
  

  
   org.springframework
   spring-test
   ${spring.version}
   test
  


 

Luego hacen mvn clean install y luego eclipse:eclipse.

Luego importamos el proyecto a eclipse, ahora veamos la clase persona:

/**
 * 
 */
package org.assembly.model;

import java.util.HashSet;
import java.util.Set;

import org.springframework.data.neo4j.annotation.GraphId;
import org.springframework.data.neo4j.annotation.Indexed;
import org.springframework.data.neo4j.annotation.NodeEntity;

/**
 * @author emanuel
 *
 */
@NodeEntity
public class Person {
 
 @GraphId
 private Long id;
 
 @Indexed //nos permite buscar por ejemplo por nombre. 2 personas no deberian llamarse igual
 private String name;
 
 private String lastName;
 
 private Set friends = new HashSet();

 public Person() { }
 
 public Person(String name, String lastName) {
  super();
  this.name = name;
  this.lastName = lastName;
 }

 public Person(String name, String lastName, HashSet friends) {
  super();
  this.name = name;
  this.lastName = lastName;
  this.friends = friends;
 }

 public void makeAFriend(Person friend) {
  this.getFriends().add(friend);
  friend.getFriends().add(this);
 }
 
//geters , seters, hashcode and equal
 

}

Con esas anotaciones le decimos a spring cual es el id de nuestro nodo y que puede usar como indice para buscar. Ahora hagamos un dao:

package org.assembly.dao;
//La interfaz
import org.assembly.model.Person;

public interface PersonDAO {
 
 void save(Person person);

 Person get(Long id);
 
 Person findByName(String name);
 
}

package org.assembly.dao;

import java.util.List;

import org.assembly.model.Person;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.neo4j.repository.GraphRepository;
import org.springframework.data.neo4j.support.Neo4jTemplate;
//La implementacion
public class PersonDAOImpl implements PersonDAO {
 
 @Autowired
 private Neo4jTemplate template;
 
 public void setTemplate(Neo4jTemplate template) {
  this.template = template;
 }

 @Override
 public void save(Person person) {
  this.template.save(person);
 }

 @Override
 public Person get(Long id) {
  return this.template.findOne(id, Person.class);
 }

 @Override
 public Person findByName(String name) {
  GraphRepository movieRepository =
    template.repositoryFor(Person.class);
  
  return movieRepository.findByPropertyValue("name", name);
 }


}

Vamos a configurar el applicationContext.xml:

Vamos a probar todo con un test:

package org.assembly.dao;

import static org.junit.Assert.assertEquals;

import javax.annotation.Resource;

import org.assembly.model.Person;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.transaction.annotation.Transactional;

@ContextConfiguration(locations = "classpath:applicationContext.xml")
@RunWith(SpringJUnit4ClassRunner.class)
public class PersonDAOTest {

 @Resource
 private PersonDAO dao;
 
 public void setDao(PersonDAO dao) {
  this.dao = dao;
 }
 
 @Test 
 @Transactional
 public void save() {
  Person person = new Person("Pablo", "Goette");
  
  dao.save(person);
  
  Person personSaved = dao.get(person.getId());
  
  assertEquals(person, personSaved);
 }
 
 @Test 
 @Transactional
 public void saveFriendly() {
  Person person = new Person("Pablo", "Goette");
  
  person.getFriends().add(new Person("Mercedez","Benz"));
  person.getFriends().add(new Person("Al","Colico"));
  person.getFriends().add(new Person("Barry","Gota"));
  person.getFriends().add(new Person("Mercedez","Benz"));
  dao.save(person);
  
  Person personSaved = dao.get(person.getId());
  
  assertEquals(person, personSaved);
 }

 @Test 
 @Transactional
 public void findByName() {
  Person person = new Person("Aquiles", "Canto");
  
  dao.save(person);
  
  Person personSaved = dao.findByName("Aquiles");
  
  assertEquals(person, personSaved);
 }
}

Y listo, verán por ahí la carpeta data con la base de neo4j.

Si todo salio bien los test terminaron exitosos.

Dejo el repositorio subversion:
svn checkout http://spring-neo4j.googlecode.com/svn/trunk/ spring-neo4j-read-only

Dejo links:

http://www.springsource.org/spring-data/neo4j
http://neo4j.org/
http://video.neo4j.org/YbYN/webinar-introduction-to-spring-data-neo4j/
http://youtu.be/9qVs9vxx8lk
http://www.infoq.com/presentations/Introduction-to-Spring-Data-Neo4j

Y dejo un video:

Spring Data

Spring Data hace fácil la construcción de aplicaciones que usan nuevas formas de almacenar datos como por ejemplo base de datos no relacionales, servicios de datos en la nube, bases clave-valor, etc. 


La idea es introducir una capa de abstracción que permita generalizar el acceso a dato a almacenes de datos tan dispares. Este proyecto fue desarrollado gracias al trabajo conjunto con un conjunto de compañías y desarrolladores. 


Spring data esta dividido en diferentes subproyectos dependiendo los almacenes de datos que tenga que interactuar:

Categoría	Sub-proyecto
Relational Databases	JPA
	JDBC Extensions
Big Data	Hadoop
Data-Grid	Gemfire
Key Value Stores	Redis
	Riak
Document Stores	MongoDB
	CouchDB (planned)
Graph Databases	Neo4j
Column Stores	HBase (planned)
	Cassandra (planned)
Blob-Stores	Blob
Common Infrastructure	Commons
	Grails Mapping

NoSQL

Hoy en día ya paso la furia por NoSQL, podemos decir que esta en un crecimiento constante. NoSQL es un movimiento que surgió dado requerimientos no funcionales de aplicaciones que no podian ser subsanados con bases relacionales. Las bases NoSQL sacrificaron requerimientos de integridad de datos por requerimientos de escalabilidad y performance.
NoSQL es una etiqueta en la cual entran todas las bases no relacionales. Existen gran cantidad de diferentes soluciones etiquetadas como NoSQL,

• Bases orientadas a grafos (Neo4j) orientada a busquedas en grafos.
• Bases documentales (MongoDb, Apache CouchDB) guardan estructuras complejas de datos; y pueden guardar diferentes estructuras.
• Bases Clave-Valor (Voldemort): se guardan los datos por clave-valor.
• Bases basadas en columnas (Apache Cassandra, BigTable, HBase)
• Y hasta bases orientadas a objeto como db4o son llamadas NoSQL.

Antes de utilizar un producto NoSQL debe tener en cuenta que cada producto fue hecho para una realidad diferente y para atacar un problema particular; es menos generico que las bases relacionales. Por lo tanto debe ser cuidadoso y analizar bien sus requerimientos no funcionales para dar justo en la tecla.

No hay que tener miedo de mezclar bases NoSQL con base de datos relacionales dado que en una misma aplicación podemos tener problemas diferentes y por lo tanto soluciones diferentes.
Las Bases NoSQL funcionan y han solucionado muchos problemas, es hora de probarlas y utilizarlas si se justifica.  

Neo4j

Neo4j es una graph database. Es un motor de persistencia transaccional que guarda las estructuras de datos en graph. Graph en la jerga de red es una estructura flexible que permite más agilidad y flexibilidad al desarrollador.

Podemos pensar en neo4j como un motor de persistencia de alta performance con todas las características de una base de datos robusta. Al ser más flexible que las tablas permite a los desarrolladores más libertad a la hora de diseñar sus objetos con la tranquilidad de ser soportado por una motor de persistencia con las características de una dase de datos.

Neo4j es un producto open source aun que cuenta con una licencia comercial.

Entre las características de neo4j podemos citar: transacciones ACID, control de concurrencia y todo lo que una base de datos empresarial.

Veamos un ejemplo que nos proporciona el sitio oficial:

package org.neo4j.example.helloworld;

import org.neo4j.api.core.*;

/**
* Example class that constructs a simple node space with message attributes and then prints them.
*/
public class NeoTest {

public enum MyRelationshipTypes implements RelationshipType {
KNOWS
}

public static void main(String[] args) {
NeoService neo = new EmbeddedNeo("var/base");


Transaction tx = neo.beginTx();
try {
Node firstNode = neo.createNode();
Node secondNode = neo.createNode();
Relationship relationship = firstNode.createRelationshipTo(secondNode, MyRelationshipTypes.KNOWS);

firstNode.setProperty("message", "Hello, ");
secondNode.setProperty("message", "world!");
relationship.setProperty("message", "brave Neo ");
tx.success();

System.out.print(firstNode.getProperty("message"));
System.out.print(relationship.getProperty("message"));
System.out.print(secondNode.getProperty("message"));
}
finally {
tx.finish();
neo.shutdown();
}
}
}