BDA - Aula 19 - 2013/1

Estudos

Título da Idéia

Hypertable

Objetivos

Realizar um estudo sobre a ferramenta Hypertable analisando o seu conceito e finalidade.

Conceito

O Hypertable é uma ferramente foi baseada no Bigdata que foi criado pela google e tem como finalidade de resolver o problema de escalabilidade em banco de dados. Esta solução utiliza o conceito de NoSql.

Escalabilidade

Hypertable foi concebido com o propósito expresso de resolver o problema de escalabilidade, um problema que não é tratado bem por um RDBMS tradicional. Embora seja possível projetar um sistema RDBMS distribuída por quebrar o conjunto de dados em cacos, esta solução exige uma enorme quantidade de esforço de engenharia eo sistema resultante terá fraquezas inerentes, porque o motor de banco de dados central não foi projetado para escalabilidade. Hypertable é baseado em um projeto desenvolvido pela Google para satisfazer as suas necessidades de escalabilidade e resolve o problema de escala melhor do que qualquer das outras soluções NoSQL.

Bom ajuste para ampla gama de aplicações

Muitas das ofertas de bancos de dados NoSQL escalável atuais são baseadas em um projeto tabela hash, o que significa que os dados que gerem não é mantido fisicamente ordenados por qualquer tecla significativa. Estes sistemas não se prestam bem para aplicações que requerem acesso rápido a intervalos de dados (por exemplo, análise, listas de URL classificadas, aplicativos de mensagens, etc.) Porque Hypertable mantém os dados fisicamente ordenados por uma chave primária, que é bem adequado para um amplo conjunto de aplicações.

Redução de Custos

Hypertable foi desenhado e implementado para o máximo de eficiência e um ótimo desempenho. Ao optar por fazer a implementação em uma linguagem compilada que não suportar os custos de coleta e interpretação de execução de desempenho e estabilidade, Hypertable pode oferecer capacidade do banco de dados equivalente a uma fração do hardware. Isso se traduz em menos equipamentos, menos consumo de energia e menos datacenter imóveis.

Performance

O outro benefício de um designe e implementação altamente eficiente do Hypertable é que ele oferece todas as vantagens que você tem a partir de um melhor desempenho. Para aplicações em tempo real, Hypertable pode ajudar a fornecer uma experiência de usuário muito mais ágil, reduzindo a latência total do pedido. Para aplicações offline, é alcançado um maior rendimento que significa que mais trabalho pode ser realizado em um determinado período de tempo.

Semântica limpas

Hypertable é um banco de dados consistente. Muitas das ofertas de bancos de dados NoSQL escaláveis ​​são projetados em torno do conceito de consistência eventual, que torna os bancos de dados mais difíceis de se trabalhar. Bases de dados consistentes, eventualmente, requerer reconciliadores sintáticas ou semânticas complexas e, em algumas circunstâncias, pode até mesmo perder dados. Quando um aplicativo grava dados em Hypertable e recebe uma resposta de sucesso, a modificação é durável e sempre será refletido nas operações subseqüentes.

Características 

• NoSQL

• Google's Bigtable Design
  • Um design escalável comprovado que mantêm centenas de serviços do Google.

• 100% Open Source.
  • Todos os benefícios do código aberto com uma comunidade forte e próspera.

• Alta Performance.
  • C++ implementação para um melhor desempenho.

• Suporte a varias linguagens.
  • Java, PHP, Python, Perl, Ruby, C++ e outras.

• Pode rodar em cima do Hadoop, pois ele contém todas as características arquitetônicas necessárias para suportar eficientemente o Hypertable.

• Aceita comando de sql básicos mas não aceita join de tabelas.
• Fácil instalação.
• Boa documentação.

Hypertable X Cassandra

• http://nosql.findthebest.com/compare/2-13/Cassandra-vs-Hypertable
  
  • O Hypertable garante consistência de dados e o cassandra não.
  • O Cassandra tem alta disponibilidade e o Hypertable não.
  • Cassandra em java Hypertable C++.

• http://db-engines.com/en/system/Cassandra%3BHypertable
  • Cassandra mais popular

Hypertable X Hbase

• http://hypertable.com/why_hypertable/hypertable_vs_hbase_2/
  • Hypertable com melhor performance

Quem utiliza

O Hypertable utilizado por uma grandes empresas como ebay e baidu, que é a maior ferramenta de busca da china.

http://hypertable.com/customers/

Arquivo:Hypertable customers.png

Estudo Dirigido

http://hypertable.com/why_hypertable

http://en.wikipedia.org/wiki/Hypertable

http://code.google.com/p/hypertable/wiki/ArchitecturalOverview

http://nosql.findthebest.com/l/13/Hypertable

http://hypertable.com/why_hypertable/hypertable_vs_hbase_2/

Comparação entre o Hypertable e o Apache:

http://nosql.findthebest.com/compare/2-13/Cassandra-vs-Hypertable

http://db-engines.com/en/system/Cassandra%3BHypertable

Caso de Negócio

Benefício para a Algar Telecom

• Armazenar grandes quantidades de informações com rápido poder de extração
• Um Banco de dados de alta performance para tratar uma grande quantidade de dados com respostas rápidas.
• Um Banco de dados NoSQL com consistência de dados.
• Um Banco de dados que pode ser facilmente escalado horizontalmente .
  
• Com BigData podemos aplicar BI e assim por exemplo, podemos analisar os sites que os clientes da CTBC estão acessando. E poderemos:
  • Verificar is videos mais assistido por um assinante e oferecer (Ex: via sms) o RBD deste video para o assinante.
  • Fazer promoções para os sites mais acessados.
  • Entre outra várias possibilidades.

Benefícios para o cliente

• Analise de mercado
• Publicidade para clientes de acordo com suas necessidades.
• Novas soluções para a Algar telecom

Direcionadores chave para esta iniciativa

• Conhecimento em ferramentas BigData
• Nosql

Possíveis modelos de negócios

• Publicidade diferenciada para o assinante de acordo com suas necessidades.
• Utilizar dados para BI

Business Case

Utilizar dados para BI

PoC

Instalação

A instalação da Ferramenta standalone é simples.  Foi apenas necessário baixar um arquivo .deb e instala ele.

http://hypertable.com/download

Start Stop

Para iniciar a aplicação é simples. Bem parecido com a maioria das aplicações no linux, basta executar o comando para iniciar

/opt/hypertable/current/bin/start-all-servers.sh 

local e para parar

'/opt/hypertable/current/bin/stop-servers.sh 

Cosole de Administração

O Hypertable possui uma ferramenta para admistrar o banco, ela é bem simila a do Mysql só que com menos recursos.

/opt/hypertable/current/bin/hypertable

Aplicação de Teste

No site do Hypertable possui exemplos de aplicações conectando no banco de dados em várias linguagens.

http://hypertable.com/documentation/code_examples/java

/**
* Copyright (C) 2007-2012 Hypertable, Inc.
*
* This file is distributed under the Apache Software License
* (http://www.apache.org/licenses/)
*/
package org.hypertable.thrift;

import java.nio.ByteBuffer;
import java.util.List;
import java.util.HashMap;
import java.util.Iterator;

import org.hypertable.thriftgen.*;

public class BasicClientTest {
  public static void main(String [] args) {
    ThriftClient client = null;
    long ns = -1;
    try {
      client = ThriftClient.create("localhost", 38080);
      ns = client.namespace_open("test");
      // HQL examples
      show(client.hql_query(ns, "show tables").toString());
      show(client.hql_query(ns, "select * from thrift_test").toString());
      // Schema example
      Schema schema = new Schema();
      schema = client.table_get_schema(ns, "thrift_test");

      Iterator ag_it = schema.access_groups.keySet().iterator();
      show("Access groups:");
      while (ag_it.hasNext()) {
        show("\t" + ag_it.next());
      }

      Iterator cf_it = schema.column_families.keySet().iterator();
      show("Column families:");
      while (cf_it.hasNext()) {
        show("\t" + cf_it.next());
      }

      // mutator examples
      long mutator = client.mutator_open(ns, "thrift_test", 0, 0);

      try {
        Cell cell = new Cell();
        Key key = new Key();
        key.setRow("java-k1");
        key.setColumn_family("col");
        cell.setKey(key);
        String vtmp = "java-v1";
        cell.setValue( ByteBuffer.wrap(vtmp.getBytes()) );
        client.mutator_set_cell(mutator, cell);
      }
      finally {
        client.mutator_close(mutator);
      }

      // shared mutator example
      {
        MutateSpec mutate_spec = new MutateSpec();
        mutate_spec.setAppname("test-java");
        mutate_spec.setFlush_interval(1000);
        Cell cell = new Cell();
        Key key;

        key = new Key();
        key.setRow("java-put1");
        key.setColumn_family("col");
        cell.setKey(key);
        String vtmp = "java-put-v1";
        cell.setValue( ByteBuffer.wrap(vtmp.getBytes()) );
        client.offer_cell(ns, "thrift_test", mutate_spec, cell);

        key = new Key();
        key.setRow("java-put2");
        key.setColumn_family("col");
        cell.setKey(key);
        vtmp = "java-put-v2";
        cell.setValue( ByteBuffer.wrap(vtmp.getBytes()) );
        client.shared_mutator_refresh(ns, "thrift_test", mutate_spec);
        client.shared_mutator_set_cell(ns, "thrift_test", mutate_spec, cell);
        Thread.sleep(2000);
      }

      // scanner examples
      System.out.println("Full scan");
      ScanSpec scanSpec = new ScanSpec(); // empty scan spec select all
      long scanner = client.scanner_open(ns, "thrift_test", scanSpec);

      try {
        List<Cell> cells = client.scanner_get_cells(scanner);

        while (cells.size() > 0) {
          for (Cell cell : cells) {
            byte[] tmp = cell.getValue();
            String s = new String(tmp);
            show(s);
          }
          cells = client.scanner_get_cells(scanner);
        }
      }
      finally {
        client.scanner_close(scanner);
      }
      // restricted scanspec
      scanSpec.addToColumns("col:/^.*$/");
      scanSpec.setRow_regexp("java.*");
      scanSpec.setValue_regexp("v2");
      scanner = client.scanner_open(ns, "thrift_test", scanSpec);
      System.out.println("Restricted scan");
      try {
        List<Cell> cells = client.scanner_get_cells(scanner);

        while (cells.size() > 0) {
          for (Cell cell : cells) {
            byte[] tmp = cell.getValue();
            String s = new String(tmp);
            show(s);
          }
          cells = client.scanner_get_cells(scanner);
        }
      }
      finally {
        client.scanner_close(scanner);
      }

      // asynchronous api
      long future=0;
      long mutator_async_1=0;
      long mutator_async_2=0;
      long color_scanner=0;
      long location_scanner=0;
      long energy_scanner=0;
      int expected_cells = 6;
      int num_cells = 0;

      try {
        System.out.println("Asynchronous mutator");
        future = client.future_open(0);
        mutator_async_1 = client.async_mutator_open(ns, "thrift_test", future, 0);
        mutator_async_2 = client.async_mutator_open(ns, "thrift_test", future, 0);
        Result result;

        Cell cell = new Cell();
        Key key;

        key = new Key();
        key.setRow("java-put1");
        key.setColumn_family("col");
        cell.setKey(key);
        String vtmp = "java-async-put-v1";
        cell.setValue( ByteBuffer.wrap(vtmp.getBytes()) );
        client.async_mutator_set_cell(mutator_async_1, cell);

        key = new Key();
        key.setRow("java-put2");
        key.setColumn_family("col");
        cell.setKey(key);
        vtmp = "java-async-put-v2";
        cell.setValue( ByteBuffer.wrap(vtmp.getBytes()) );
        client.async_mutator_set_cell(mutator_async_2, cell);

        client.async_mutator_flush(mutator_async_1);
        client.async_mutator_flush(mutator_async_2);

        int num_flushes=0;
        while (true) {
          result = client.future_get_result(future, 0);
          if (result.is_empty || result.is_error || result.is_scan)
            break;
          num_flushes++;
        }
        if (num_flushes > 2) {
          System.out.println("Expected 2 flushes, received " + num_flushes);
          System.exit(1);
        }
        if (client.future_is_cancelled(future) || client.future_is_full(future) ||
            !client.future_is_empty(future) || client.future_has_outstanding(future)) {
          System.out.println("Future object in unexpected state");
          System.exit(1);
        }
      }
      finally {
        client.async_mutator_close(mutator_async_1);
        client.async_mutator_close(mutator_async_2);
      }

      try {
        System.out.println("Asynchronous scan");
        ScanSpec ss = new ScanSpec();
        color_scanner = client.async_scanner_open(ns, "FruitColor", future, ss);
        location_scanner = client.async_scanner_open(ns, "FruitLocation", future, ss);
        energy_scanner = client.async_scanner_open(ns, "FruitEnergy", future, ss);
        Result result;
        while (true) {
          result = client.future_get_result(future, 0);
          if (result.is_empty || result.is_error || !result.is_scan)
            break;
          for (Cell cell : result.cells) {
            byte[] tmp = cell.getValue();
            String s = new String(tmp);
            show(s);
            num_cells++;
          }
          if (num_cells >= 6) {
            client.future_cancel(future);
            break;
          }
        }
        if (!client.future_is_cancelled(future)) {
          System.out.println("Expected future object to be cancelled");
          System.exit(1);
        }
      }
      finally {
        client.async_scanner_close(color_scanner);
        client.async_scanner_close(location_scanner);
        client.async_scanner_close(energy_scanner);
        client.future_close(future);
      }
      if (num_cells != 6) {
        System.out.println("Expected " + expected_cells + " cells got " + num_cells);
        System.exit(1);
      }


      // issue 497
      {
        Cell cell;
        Key key;
        String str;

        client.hql_query(ns, "drop table if exists java_thrift_test");
        client.hql_query(ns, "create table java_thrift_test ( c1, c2, c3 )");

        mutator = client.mutator_open(ns, "java_thrift_test", 0, 0);

        cell = new Cell();
        key = new Key();
        key.setRow("000");
        key.setColumn_family("c1");
        key.setColumn_qualifier("test");
        cell.setKey(key);
        str = "foo";
        cell.setValue( ByteBuffer.wrap(str.getBytes()) );
        client.mutator_set_cell(mutator, cell);

        cell = new Cell();
        key = new Key();
        key.setRow("000");
        key.setColumn_family("c1");
        cell.setKey(key);
        str = "bar";
        cell.setValue( ByteBuffer.wrap(str.getBytes()) );
        client.mutator_set_cell(mutator, cell);

        client.mutator_close(mutator);

        HqlResult result = client.hql_query(ns, "select * from java_thrift_test");
        List<Cell> cells = result.cells;
        int qualifier_count = 0;
        for(Cell c:cells) {
          if (c.key.isSetColumn_qualifier() && c.key.column_qualifier.length() == 0)
            qualifier_count++;
        }

        if (qualifier_count != 1) {
          System.out.println("ERROR: Expected qualifier_count of 1, got " + qualifier_count);
          client.namespace_close(ns);
          System.exit(1);
        }
      }

      client.namespace_close(ns);

    }
    catch (Exception e) {
      e.printStackTrace();
      try {
        if (client != null && ns != -1)
          client.namespace_close(ns);
      }
      catch (Exception ce) {
        System.err.println("Problen closing namespace \"test\" - " + e.getMessage());
      }
      System.exit(1);
    }
  }

  private static void show(String line) {
    System.out.println(line);
  }
}

Cronograma Macro

• Conceito:  29/03
  
• Ensino: 30/04
• Negócio: 30/05
• PoC:  28/06

Histórico

28/06/2013

• Finalização POC
• Finalização Wiki

26/06/2013

• POC
• Comparação Hypertable X Outros NoSQL

24/06/2013

• Estudos sobre Big data
• Estudos da Ferramenta
• Atualização da wiki
• Inicio do Prototipo

20/06/2013

• Instalação da Ferramenta
• testes da Ferramenta

06/05/2013

• Adicionado objetivo do P&D
• Adicionado conteudo no Conceito da Ferramento

Pesquisadores

• Bruno Oliveira