Nessa postagem, iremos explicar a teoria e como consolidou-se o Hive. Juntamente com o ferramenteiro remoto Moba. Também mais para o final da postagem, iremos desenvolver um case semi-real da área financeira utilizando o Hive.
Apache Hive é um projeto de software de data warehouse construído sobre o Apache Hadoop para fornecer consulta e análise de dados. O Hive fornece uma interface semelhante a SQL para consultar dados armazenados em vários bancos de dados e sistemas de arquivos que se integram ao Hadoop. As consultas SQL tradicionais devem ser implementadas na API Java MapReduce para executar aplicativos SQL e consultas sobre dados distribuídos. O Hive fornece a abstração SQL necessária para integrar consultas do tipo SQL (HiveQL) no Java subjacente sem a necessidade de implementar consultas na API Java de baixo nível. Como a maioria dos aplicativos de armazenamento de dados funciona com linguagens de consulta baseadas em SQL, o Hive auxilia na portabilidade de aplicativos baseados em SQL para o Hadoop. Embora inicialmente desenvolvido pelo Facebook , o Apache Hive é usado e desenvolvido por outras empresas, como a Netflix e a Financial Industry Regulatory Authority (FINRA). A Amazon mantém um fork de software do Apache Hive incluído no Amazon Elastic MapReduce no Amazon Web Services.
+
Apache ORC (Optimized Row Columnar) é um formato de armazenamento de dados orientado a colunas gratuito e de código aberto. É semelhante a outros formatos de arquivo de armazenamento colunar disponíveis no ecossistema Hadoop , como RCFile e Parquet. Ele é usado pela maioria das estruturas de processamento de dados Apache Spark, Apache Hive, Apache Flink e Apache Hadoop .
Em fevereiro de 2013, o formato de arquivo Optimized Row Columnar (ORC) foi anunciado pela Hortonworks em colaboração com o Facebook. Um mês depois, foi anunciado o formato Apache Parquet, desenvolvido pela Cloudera e Twitter.
Continuando para o Apache Hive...
Características
O Apache Hive oferece suporte à análise de grandes conjuntos de dados armazenados no HDFS do Hadoop e sistemas de arquivos compatíveis, como o sistema de arquivos Amazon S3 e Alluxio . Ele fornece uma linguagem de consulta semelhante a SQL chamada HiveQL com esquema em leitura e converte consultas de forma transparente para trabalhos MapReduce , Apache Tez e Spark . Todos os três mecanismos de execução podem ser executados no negociador de recursos do Hadoop , YARN (Yet Another Resource Negotiator). Para acelerar as consultas, ele forneceu índices, mas esse recurso foi removido na versão 3.0. Outros recursos do Hive incluem:
• Diferentes tipos de armazenamento, como texto simples, RCFile , HBase , ORC e outros.
• Armazenamento de metadados em um sistema de gerenciamento de banco de dados relacional , reduzindo significativamente o tempo para realizar verificações semânticas durante a execução de consultas.
• Operando em dados compactados armazenados no ecossistema Hadoop usando algoritmos como DEFLATE, BWT, snappy, etc.
• Funções definidas pelo usuário (UDFs) integradas para manipular datas, strings e outras ferramentas de mineração de dados. O Hive oferece suporte à extensão do conjunto de UDFs para lidar com casos de uso não suportados por funções internas.
• Consultas do tipo SQL (HiveQL), que são convertidas implicitamente em trabalhos MapReduce ou Tez ou Spark.
Por padrão, o Hive armazena metadados em um banco de dados Apache Derby incorporado e outros bancos de dados cliente/servidor, como MySQL , podem ser usados opcionalmente.
Os primeiros quatro formatos de arquivo suportados no Hive foram texto simples, arquivo de sequência, formato colunar de linha otimizado (ORC) e RCFile. O Apache Parquet pode ser lido via plugin em versões posteriores a 0.10 e nativamente a partir de 0.13. Plugins Hive adicionais suportam a consulta do Bitcoin Blockchain.
Arquitetura
Os principais componentes da arquitetura Hive são:
• Metastore: armazena metadados para cada uma das tabelas, como seu esquema e local. Ele também inclui os metadados da partição que ajudam o driver a rastrear o progresso de vários conjuntos de dados distribuídos pelo cluster. Os dados são armazenados em um formato RDBMS tradicional . Os metadados ajudam o motorista a acompanhar os dados e são cruciais. Assim, um servidor de backup replica regularmente os dados que podem ser recuperados em caso de perda de dados.
• Driver: Atua como um controlador que recebe as instruções HiveQL. Ele inicia a execução da instrução criando sessões e monitora o ciclo de vida e o progresso da execução. Ele armazena os metadados necessários gerados durante a execução de uma instrução HiveQL. O driver também atua como um ponto de coleta de dados ou resultados de consultas obtidos após a operação Reduzir.
• Compilador: Executa a compilação da consulta HiveQL, que converte a consulta em um plano de execução. Esse plano contém as tarefas e etapas necessárias a serem executadas pelo Hadoop MapReduce para obter a saída conforme traduzida pela consulta. O compilador converte a consulta em uma árvore de sintaxe abstrata (AST). Depois de verificar erros de compatibilidade e tempo de compilação, ele converte o AST em um gráfico acíclico direcionado (DAG). O DAG divide os operadores em estágios e tarefas MapReduce com base na consulta de entrada e nos dados.
• Otimizador: Executa várias transformações no plano de execução para obter um DAG otimizado. As transformações podem ser agregadas, como a conversão de um pipeline de junções em uma única junção, para melhor desempenho. Também pode dividir as tarefas, como aplicar uma transformação nos dados antes de uma operação de redução, para fornecer melhor desempenho e escalabilidade. No entanto, a lógica de transformação usada para otimização usada pode ser modificada ou canalizada usando outro otimizador.
• Executor: Após a compilação e otimização, o executor executa as tarefas. Ele interage com o rastreador de tarefas do Hadoop para agendar tarefas a serem executadas. Ele cuida do pipeline das tarefas, garantindo que uma tarefa com dependência seja executada somente se todos os outros pré-requisitos forem executados.
• CLI, UI e Thrift Server : Uma interface de linha de comando (CLI) fornece uma interface de usuário para um usuário externo interagir com o Hive enviando consultas, instruções e monitorando o status do processo. O servidor Thrift permite que clientes externos interajam com o Hive em uma rede, semelhante aos protocolos JDBC ou ODBC.
HiveQL
Embora baseado em SQL, o HiveQL não segue estritamente o padrão SQL-92 completo . O HiveQL oferece extensões que não estão em SQL, incluindo inserções de várias tabelas e criação de tabela como select. O HiveQL não tinha suporte para transações e visualizações materializadas e apenas suporte limitado a subconsultas. O suporte para inserir, atualizar e excluir com funcionalidade ACID completa foi disponibilizado com a versão 0.14.
Internamente, um compilador converte instruções HiveQL em um gráfico acíclico direcionado de trabalhos MapReduce, Tez ou Spark, que são enviados ao Hadoop para execução.
Exemplo
O programa de contagem de palavras conta o número de vezes que cada palavra ocorre na entrada. A contagem de palavras pode ser escrita em HiveQL como:
DROP TABLE IF EXISTS docs;
CREATE TABLE docs (line STRING);
LOAD DATA INPATH 'input_file' OVERWRITE INTO TABLE docs;
CREATE TABLE word_counts AS
SELECT word, count(1) AS count FROM
(SELECT explode(split(line, '\s')) AS word FROM docs) temp
GROUP BY word
ORDER BY word;
Segue uma breve explicação de cada uma das afirmações:
DROP TABLE IF EXISTS docs;CREATE TABLE docs (line STRING);
Verifica se a tabela docs existe e a descarta se existir. Cria uma nova tabela chamada docscom uma única coluna do tipo STRING chamada line.
LOAD DATA INPATH 'input_file' OVERWRITE INTO TABLE docs;
Carrega o arquivo ou diretório especificado (neste caso “input_file”) na tabela. OVERWRITEespecifica que a tabela de destino na qual os dados estão sendo carregados deve ser regravada; Caso contrário, os dados seriam anexados.
CREATE TABLE word_counts AS
SELECT word, count(1) AS count FROM
(SELECT explode(split(line, '\s')) AS word FROM docs) temp
GROUP BY word
ORDER BY word;
A consulta CREATE TABLE word_counts AS SELECT word, count(1) AS countcria uma tabela chamada word_countscom duas colunas: worde count. Essa consulta extrai sua entrada da consulta interna . Essa consulta serve para dividir as palavras de entrada em diferentes linhas de uma tabela temporária com o alias . Os grupos os resultados com base em suas chaves. Isso resulta na coluna contendo o número de ocorrências para cada palavra da coluna. O ordena as palavras em ordem alfabética. (SELECT explode(split(line, '\s')) AS word FROM docs) temp"temp GROUP BY WORD count word ORDER BY WORDS
Comparação com bancos de dados tradicionais
As operações de armazenamento e consulta do Hive se assemelham muito às dos bancos de dados tradicionais. Embora o Hive seja um dialeto SQL, há muitas diferenças na estrutura e no funcionamento do Hive em comparação com os bancos de dados relacionais. As diferenças são principalmente porque o Hive é construído sobre o ecossistema do Hadoop e precisa cumprir as restrições do Hadoop e do MapReduce .
Um esquema é aplicado a uma tabela em bancos de dados tradicionais. Nesses bancos de dados tradicionais, a tabela normalmente impõe o esquema quando os dados são carregados na tabela. Isso permite que o banco de dados certifique-se de que os dados inseridos seguem a representação da tabela conforme especificado pela definição da tabela. Esse design é chamado de esquema na gravação . Em comparação, o Hive não verifica os dados em relação ao esquema de tabela na gravação. Em vez disso, ele subsequentemente faz verificações de tempo de execução quando os dados são lidos. Esse modelo é chamado de esquema na leitura . As duas abordagens têm suas próprias vantagens e desvantagens. A verificação de dados em relação ao esquema de tabela durante o tempo de carregamento adiciona sobrecarga extra, e é por isso que os bancos de dados tradicionais demoram mais para carregar os dados. As verificações de qualidade são realizadas nos dados no momento do carregamento para garantir que os dados não estejam corrompidos. A detecção precoce de dados corrompidos garante o tratamento antecipado de exceções. Como as tabelas são forçadas a corresponder ao esquema após/durante o carregamento de dados, ele tem melhor desempenho no tempo de consulta. O Hive, por outro lado, pode carregar dados dinamicamente sem qualquer verificação de esquema, garantindo um carregamento inicial rápido, mas com a desvantagem de um desempenho comparativamente mais lento no momento da consulta. O Hive tem uma vantagem quando o esquema não está disponível no momento do carregamento, mas é gerado posteriormente dinamicamente.
As transações são operações-chave em bancos de dados tradicionais. Como qualquer RDBMS típico , o Hive suporta todas as quatro propriedades de transações (ACID): Atomicidade, Consistência, Isolamento e Durabilidade. As transações no Hive foram introduzidas no Hive 0.13, mas foram limitadas apenas ao nível de partição. A versão recente do Hive 0.14 teve essas funções totalmente adicionadas para suportar propriedades ACID completas. O Hive 0.14 e posterior fornece diferentes transações em nível de linha, como INSERT, DELETE e UPDATE. Habilitando INSERT, UPDATE, DELETEas transações requerem a definição de valores apropriados para propriedades de configuração, como hive.support.concurrency, hive.enforce.bucketinge hive.exec.dynamic.partition.mode.
Segurança
O Hive v 0.7.0 adicionou integração com a segurança do Hadoop. O Hadoop começou a usar o suporte de autorização Kerberos para fornecer segurança. Kerberos permite autenticação mútua entre cliente e servidor. Nesse sistema, a solicitação de ticket do cliente é passada junto com a solicitação. As versões anteriores do Hadoop tinham vários problemas, como os usuários poderem falsificar seu nome de usuário definindo a hadoop.job.ugipropriedade e também as operações MapReduce sendo executadas sob o mesmo usuário: hadoop ou mapred. Com a integração do Hive v 0.7.0 com a segurança do Hadoop, esses problemas foram amplamente corrigidos. Os trabalhos do TaskTracker são executados pelo usuário que os iniciou e o nome de usuário não pode mais ser falsificado definindo a hadoop.job.ugipropriedade. As permissões para arquivos recém-criados no Hive são ditadas pelo HDFS. O modelo de autorização do sistema de arquivos distribuído do Hadoop usa três entidades: usuário, grupo e outras com três permissões: leitura, gravação e execução. As permissões padrão para arquivos recém-criados podem ser definidas alterando o valor umask para a variável de configuração do Hive hive.files.umask.value.
Ferramenta de aplicação MobaXterm
Servidor MobaXterm X e cliente SSH
MobaXterm é sua caixa de ferramentas definitiva para computação remota . Em um único aplicativo do Windows, ele fornece muitas funções personalizadas para programadores, webmasters, administradores de TI e praticamente todos os usuários que precisam lidar com seus trabalhos remotos de maneira mais simples.
O MobaXterm fornece todas as ferramentas de rede remota importantes (SSH, X11, RDP, VNC, FTP, MOSH, ...) e comandos Unix (bash, ls, cat, sed, grep, awk, rsync, ...) para a área de trabalho do Windows , em um único arquivo exe portátil que funciona imediatamente. Mais informações sobre protocolos de rede suportados
Há muitas vantagens em ter um aplicativo de rede All-In-One para suas tarefas remotas, por exemplo, quando você usa SSH para se conectar a um servidor remoto, um navegador gráfico SFTP aparecerá automaticamente para editar diretamente seus arquivos remotos. Seus aplicativos remotos também serão exibidos perfeitamente na área de trabalho do Windows usando o servidor X incorporado . Ver demonstração
Você pode baixar e usar o MobaXterm Home Edition gratuitamente. Se você quiser usá-lo dentro de sua empresa, considere assinar o MobaXterm Professional Edition: isso lhe dará acesso a muito mais recursos e ao software "Customizer". Comparação de funcionalidades
Ao desenvolver o MobaXterm, focamos em um objetivo simples: propor uma interface de usuário intuitiva para que você acesse servidores remotos de forma eficiente através de diferentes redes ou sistemas. Capturas de tela
O MobaXterm está sendo desenvolvido ativamente e atualizado com frequência pela Mobatek.
Link de acesso e download da ferramenta: https://mobaxterm.mobatek.net/
The CentOS Project - Linux
CentOS Community Enterprise Operating System ; também conhecido como CentOS Linux ) é uma distribuição Linux que fornece uma plataforma de computação gratuita e de código aberto suportada pela comunidade, funcionalmente compatível com sua fonte upstream , Red Hat Enterprise Linux (RHEL). Em janeiro de 2014, o CentOS anunciou a união oficial com a Red Hat, mantendo-se independente do RHEL, sob um novo conselho administrativo do CentOS.
A primeira versão do CentOS em maio de 2004, numerada como CentOS versão 2, foi bifurcada do RHEL versão 2.1AS. Desde a versão 8, o CentOS suporta oficialmente as arquiteturas x86-64, ARM64 e POWER8 , e os lançamentos até a versão 6 também suportam a arquitetura IA-32. A partir de dezembro de 2015 , as versões AltArch do CentOS 7 estão disponíveis para a arquitetura IA-32, Power ISA e para as variantes ARMv7hl e AArch64 da arquitetura ARM. O CentOS 8 foi lançado em 24 de setembro de 2019.
Em dezembro de 2020, a Red Hat encerrou unilateralmente o desenvolvimento do CentOS. Em resposta, o fundador do CentOS Gregory Kurtzer criou o projeto Rocky Linux como um sucessor da missão original do CentOS. Em março de 2021, o Cloud Linux (fabricante do CloudLinux OS) lançou um novo derivado do RHEL chamado AlmaLinux.
Embora a distribuição tenha sido descontinuada no final de 2021, o desenvolvimento do CentOS Stream, sua variante midstream, continua.
Arquiteturas
A partir da versão 8, o CentOS suporta totalmente x86-64 , POWER8 e arquiteturas ARM de 64 bits , [196] enquanto as seguintes arquiteturas não são suportadas:
• IA-32 em todas as variantes, sem suporte desde o CentOS 7;
• IA-32 sem extensão de endereço físico (PAE), não suportado desde o CentOS 6;
• IA-64 (arquitetura Intel Itanium ), foi suportado no CentOS 3 e 4;
• PowerPC de 32 bits ( Apple Macintosh e PowerMac executando o processador G3 ou G4;
• PowerPC), suporte beta estava disponível no CentOS 4;
• IBM Mainframe ( eServer zSeries e S/390 ), não suportado desde o CentOS 5;
• Alpha , o suporte estava disponível no CentOS 4;
• SPARC , suporte beta estava disponível no CentOS 4;
A partir de dezembro de 2015, as versões AltArch do CentOS 7 estão disponíveis para as variantes ARMv7hl e AArch64 da arquitetura ARM, e existem planos para suportar outras variantes da arquitetura ARM. O suporte ARM é um esforço da comunidade coordenado por meio do AltArch SIG. As versões AltArch do CentOS 7 também estão disponíveis para a arquitetura IA-32 e Power ISA ( chips POWER7 e POWER8).
Uma versão Live CD do CentOS está disponível em mirror.centos.org . Uma imagem USB inicializável do CentOS pode ser criada manualmente ou com UNetbootin .
As imagens do CentOS também estão disponíveis na nuvem EC2 da Amazon , na forma de Amazon Machine Images (AMIs) pré-construídas e já publicadas.
Repositórios
• base : contém pacotes que formam versões pontuais do CentOS e é atualizado quando a versão pontual real é formalmente disponibilizada na forma de imagens ISO;
• updates : contém pacotes que servem como atualizações de segurança, correção de bugs ou aprimoramentos, emitidos entre os conjuntos de atualizações regulares para lançamentos pontuais. As atualizações de correções de bugs e melhorias lançadas desta forma são apenas aquelas inadequadas para serem lançadas através do CentOS-Fasttrackrepositório descrito abaixo;
• addons : fornece os pacotes necessários para construir os pacotes que compõem a distribuição principal do CentOS, mas não são fornecidos pelo upstream;
O Projeto CentOS fornece vários repositórios adicionais que contêm pacotes de software não fornecidos pelo padrão basee pelos updatesrepositórios. Esses repositórios incluem o seguinte:
• CentOS Extras : contém pacotes que fornecem funcionalidade adicional ao CentOS sem quebrar sua compatibilidade upstream ou atualizar os componentes básicos;
• CentOSPlus : contém pacotes que realmente atualizam certos componentes básicos do CentOS, alterando o CentOS para que não seja exatamente igual ao conteúdo do provedor upstream;
• CentOS-Testing : serve como campo de testes para pacotes a caminho de CentOSPluse CentOS Extras. Os pacotes oferecidos podem ou não substituir os pacotes centrais do CentOS e não há garantia de que funcionem corretamente;
• CentOS-Fasttrack : contém correções de bugs e atualizações de aprimoramento emitidas de tempos em tempos, entre os conjuntos de atualizações regulares para lançamentos pontuais. Os pacotes lançados dessa forma servem como candidatos próximos para a inclusão no próximo lançamento pontual. Este repositório não fornece atualizações de segurança e não contém pacotes inadequados para inclusão incerta em lançamentos pontuais;
• CR(Continuous Release) : disponibiliza pacotes geralmente disponíveis que aparecerão na próxima versão pontual do CentOS. Os pacotes são disponibilizados em uma base de teste e hotfix, até que o lançamento pontual real seja formalmente lançado na forma de imagens ISO;
• debuginfo : Contém pacotes com símbolos de depuração gerados quando os pacotes primários foram compilados;
• contrib : contém pacotes contribuídos por usuários do CentOS que não se sobrepõem a nenhum dos pacotes de distribuição principais;
• Software Collections : Fornece versões de software mais recentes do que as fornecidas pela distribuição base, consulte acima para obter mais detalhes.
__________________________________________________________________________________
Case em Apache Hive
Nesse case abordaremos sobre um script em Hive da área financeira de uma empresa fictícia. Esse case foi extraído de um case real, porém transformado em case fictício com uma base modificada em base de dados e arquitetura, por questões didáticas e demonstrativas.
Comissionamento
Comissionamento é o processo de assegurar que os sistemas e componentes de uma edificação ou unidade industrial estejam projetados, instalados, testados, operados e mantidos de acordo com as necessidades e requisitos operacionais do proprietário.
__________________________________________________________________________________
Desenvolvimento...
--------------------------------------------------------------------------------------------------
-- CARGA TABELAS TEMPORARIAS
--------------------------------------------------------------------------------------------------
-- Função: CARGA DAS TABELAS TEMPORARIAS COM OS DADOS DO FINANCIALPROJ COM DT_FOTO D-1 PARA B2B > ALTA
--------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------
INSERT INTO h_bigd_db.tmp_tbgdt_financialproj_bsv_sbscrp
SELECT
a.sbscrp_id,
a.cust_id,
a.sbscrp_svc_eff_dt,
a.sbscrp_svc_expr_dt,
a.access_nbr,
current_date
FROM p_bigd_db.tbgdt_financialproj_bsv_sbscrp a
INNER JOIN h_bigd_db.v_pagamentos_tipada b
ON b.id_subs = a.sbscrp_id
WHERE a.dt_foto = regexp_replace(date_add(current_date, -1), "-", "")
AND b.valor <> 0
AND b.cod_tipo_carteira in ('2','5')
AND b.cod_tipo_comissao <> '50' -- Saldo do mes anterior
AND b.dt_ref_pagamento = '2021-01-01';
--------------------------------------------------------------------------------------------------
INSERT INTO h_bigd_db.tmp_tbgdt_financialproj_bsv_cust_idntfc
SELECT
c.cust_id,
c.cust_id_text,
c.prim_cust_idntfc_flag,
current_date
FROM p_bigd_db.tbgdt_financialproj_bsv_cust_idntfc c
INNER JOIN h_bigd_db.tmp_tbgdt_financialproj_bsv_sbscrp a
ON a.cust_id = c.cust_id
WHERE prim_cust_idntfc_flag = 'Y' -- Filtra por Y para obter apenas documento principal e atual
AND dt_foto = regexp_replace(date_add(current_date, -1), "-", "");
--------------------------------------------------------------------------------------------------
INSERT INTO h_bigd_db.tmp_tbgdt_financialproj_bsv_svc_agrmnt_line_item
SELECT
d.sbscrp_id,
d.svc_name,
d.svc_agrmnt_seq_nbr,
d.svc_type_cd,
d.access_svc_flag,
d.svc_agrmnt_eff_dt,
d.svc_agrmnt_trmntn_dt,
current_date
FROM p_bigd_db.tbgdt_financialproj_bsv_svc_agrmnt_line_item d
INNER JOIN h_bigd_db.v_pagamentos_tipada b
ON b.id_subs = d.sbscrp_id
WHERE dt_foto = regexp_replace(date_add(current_date, -1), "-", "");
AND d.svc_name = b.desc_servico
--------------------------------------------------------------------------------------------------
INSERT INTO h_bigd_db.tmp_tbgdt_financialproj_bsv_sbscrp_asgm
SELECT
e.sbscrp_id,
e.acct_nbr,
e.sbscrp_seq_nbr,
e.sbscrp_asgm_eff_dt,
e.sbscrp_asgm_expr_dt,
current_date
FROM p_bigd_db.tbgdt_financialproj_bsv_sbscrp_asgm e
INNER JOIN h_bigd_db.v_pagamentos_tipada b
ON b.id_subs = e.sbscrp_id
WHERE dt_foto = regexp_replace(date_add(current_date, -1), "-", "");
--------------------------------------------------------------------------------------------------
INSERT INTO h_bigd_db.tmp_tbgdt_financialproj_bsv_charge_cr_item
SELECT
f.acct_nbr,
f.sbscrp_id,
f.svc_name,
f.svc_agrmnt_seq_nbr,
f.last_bill_dt,
f.charge_cr_amt,
f.svc_price_seq_nbr,
f.charge_type_cd,
current_date,
cycle_cd
FROM p_bigd_db.tbgdt_financialproj_bsv_charge_cr_item f
INNER JOIN h_bigd_db.v_pagamentos_tipada b
ON b.id_subs = f.sbscrp_id
WHERE dt_foto = regexp_replace(date_add(current_date, -1), "-", "");
AND f.acct_nbr = e.acct_nbr
AND f.svc_name = d.svc_name
AND f.svc_agrmnt_seq_nbr= d.svc_agrmnt_seq_nbr
-----
INSERT INTO h_bigd_db.tmp_tbgdt_financialproj_bsv_charge_cr_item_I
SELECT
f.acct_nbr,
f.sbscrp_id,
f.svc_name,
f.svc_agrmnt_seq_nbr,
f.last_bill_dt,
f.charge_cr_amt,
f.svc_price_seq_nbr,
f.charge_type_cd,
f.current_date,
f.cycle_cd
FROM h_bigd_db.tmp_tbgdt_financialproj_bsv_charge_cr_item f;
--------------------------------------------------------------------------------------------------
INSERT INTO h_bigd_db.tmp_tbgdt_financialproj_bsv_charge_cr_item_II
SELECT
f.acct_nbr,
f.sbscrp_id,
f.svc_name,
f.svc_agrmnt_seq_nbr,
f.last_bill_dt,
f.charge_cr_amt,
f.svc_price_seq_nbr,
f.charge_type_cd,
f.current_date,
f.cycle_cd
FROM h_bigd_db.tmp_tbgdt_financialproj_bsv_charge_cr_item f;
--------------------------------------------------------------------------------------------------
INSERT INTO h_bigd_db.tmp_tbgdt_financialproj_bsv_charge_cr_item_III
SELECT
f.acct_nbr,
f.sbscrp_id,
f.svc_name,
f.svc_agrmnt_seq_nbr,
f.last_bill_dt,
f.charge_cr_amt,
f.svc_price_seq_nbr,
f.charge_type_cd,
current_date,
cycle_cd
FROM h_bigd_db.tmp_tbgdt_financialproj_bsv_charge_cr_item f
limit 100;
--------------------------------------------------------------------------------------------------
INSERT INTO h_bigd_db.tmp_tbgdt_financialproj_DOC_INFO
SELECT
h.doc_type_cd,
h.fncl_pbln_id,
h.acct_nbr,
h.person_id,
h.ver_nbr,
h.doc_refdt,
h.doc_due_amt,
h.doc_seq_nbr,
h.doc_due_dt,
h.doc_rmng_amt,
h.doc_past_due_dt,
h.smp_rmtnc_rqstd_flag,
current_date
FROM h_bigd_db.tmp_tbgdt_financialproj_DOC_INFO h
INNER JOIN h_bigd_db.tmp_tbgdt_financialproj_bsv_charge_cr_item f
ON f.acct_nbr = h.acct_nbr
WHERE dt_foto = regexp_replace(date_add(current_date, -1), "-", "");
--------------------------------------------------------------------------------------------------
INSERT INTO h_bigd_db.tmp_tbgdt_financialproj_DOC_INFO_I
SELECT
h.doc_type_cd,
h.fncl_pbln_id,
h.acct_nbr,
h.person_id,
h.ver_nbr,
h.doc_refdt,
h.doc_due_amt,
h.doc_seq_nbr,
h.doc_due_dt,
h.doc_rmng_amt,
h.doc_past_due_dt,
h.smp_rmtnc_rqstd_flag,
h.current_date
FROM h_bigd_db.tmp_tbgdt_financialproj_DOC_INFO h;
--------------------------------------------------------------------------------------------------
INSERT INTO h_bigd_db.tmp_tbgdt_financialproj_DOC_INFO_II
SELECT
h.doc_type_cd,
h.fncl_pbln_id,
h.acct_nbr,
h.person_id,
h.ver_nbr,
h.doc_refdt,
h.doc_due_amt,
h.doc_seq_nbr,
h.doc_due_dt,
h.doc_rmng_amt,
h.doc_past_due_dt,
h.smp_rmtnc_rqstd_flag,
h.current_date
FROM h_bigd_db.tmp_tbgdt_financialproj_DOC_INFO h;
--------------------------------------------------------------------------------------------------
INSERT INTO h_bigd_db.tmp_tbgdt_financialproj_DOC_INFO_III
SELECT
h.doc_type_cd,
h.fncl_pbln_id,
h.acct_nbr,
h.person_id,
h.ver_nbr,
h.doc_refdt,
h.doc_due_amt,
h.doc_seq_nbr,
h.doc_due_dt,
h.doc_rmng_amt,
h.doc_past_due_dt,
h.smp_rmtnc_rqstd_flag,
h.current_date
FROM h_bigd_db.tmp_tbgdt_financialproj_DOC_INFO h;
--------------------------------------------------------------------------------------------------
INSERT INTO h_bigd_db.tmp_tbgdt_financialproj_bsv_pymt
SELECT
i.acct_nbr,
i.recv_dt,
i.total_pymt_amt,
i.last_bill_dt,
i.pymt_recv_amt,
i.pymt_amt,
i.bill_pymt_appld_caldt,
i.pymt_type_cd,
i.doc_refdt,
current_date
FROM p_bigd_db.tbgdt_financialproj_bsv_pymt
WHERE dt_foto = regexp_replace(date_add(current_date, -1), "-", "");
--------------------------------------------------------------------------------------------------
INSERT INTO h_bigd_db.tmp_tbgdt_financialproj_bsv_pymt_I
SELECT
i.acct_nbr,
i.recv_dt,
i.total_pymt_amt,
i.last_bill_dt,
i.pymt_recv_amt,
i.pymt_amt,
i.bill_pymt_appld_caldt,
i.pymt_type_cd,
i.doc_refdt,
current_date
FROM h_bigd_db.tmp_tbgdt_financialproj_bsv_pymt;
--------------------------------------------------------------------------------------------------
INSERT INTO h_bigd_db.tmp_tbgdt_financialproj_bsv_pymt_II
SELECT
i.acct_nbr,
i.recv_dt,
i.total_pymt_amt,
i.last_bill_dt,
i.i.pymt_recv_amt,
i.pymt_amt,
i.bill_pymt_appld_caldt,
i.pymt_type_cd,
i.doc_refdt,
current_date
FROM h_bigd_db.tmp_tbgdt_financialproj_bsv_pymt;
-----
INSERT INTO h_bigd_db.tmp_tbgdt_financialproj_bsv_pymt_III
SELECT
i.acct_nbr,
i.recv_dt,
i.total_pymt_amt,
i.last_bill_dt,
i.pymt_recv_amt,
i.pymt_amt,
i.bill_pymt_appld_caldt,
i.pymt_type_cd,
i.doc_refdt,
current_date
FROM h_bigd_db.tmp_tbgdt_financialproj_bsv_pymt;
--------------------------------------------------------------------------------------------------
INSERT INTO h_bigd_db.tmp_tbgd_totalizador_charge_cr_item
SELECT
j.acct_nbr,
j.sbscrp_id,
j.last_bill_dt,
SUM(charge_cr_amt) as charge_cr_amt
current_date
FROM h_bigd_db.tmp_tbgdt_financialproj_bsv_charge_cr_item j
INNER JOIN h_bigd_db.tmp_tbgdt_financialproj_bsv_charge_cr_item f
ON f.acct_nbr = j.acct_nbr
GROUP BY acct_nbr,sbscrp_id,last_bill_dt;
AND j.sbscrp_id = f.sbscrp_id
AND j.last_bill_dt = f.last_bill_dt
--------------------------------------------------------------------------------------------------
INSERT INTO h_bigd_db.tmp_tbgd_totalizador_charge_cr_item_I
SELECT
j.acct_nbr,
j.sbscrp_id,
j.last_bill_dt,
SUM(charge_cr_amt) as charge_cr_amt
current_date
FROM h_bigd_db.tmp_tbgd_totalizador_charge_cr_item
GROUP BY acct_nbr,sbscrp_id,last_bill_dt;
--------------------------------------------------------------------------------------------------
INSERT INTO h_bigd_db.tmp_tbgd_totalizador_charge_cr_item_II
SELECT
j.acct_nbr,
j.sbscrp_id,
j.last_bill_dt,
SUM(charge_cr_amt) as charge_cr_amt
current_date
FROM h_bigd_db.tmp_tbgd_totalizador_charge_cr_item
GROUP BY acct_nbr,sbscrp_id,last_bill_dt;
--------------------------------------------------------------------------------------------------
INSERT INTO h_bigd_db.tmp_tbgd_totalizador_charge_cr_item_III
SELECT
j.acct_nbr,
j.sbscrp_id,
j.last_bill_dt,
SUM(charge_cr_amt) as charge_cr_amt
current_date
FROM h_bigd_db.tmp_tbgd_totalizador_charge_cr_item
GROUP BY acct_nbr,sbscrp_id,last_bill_dt;
--------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------
__________________________________________________________________________________
Conclusivo do Caso de Uso
Otimização de desempenho em processamento de consulta MapReduce é um tópico de pesquisa bastante investigado atualmente. Soluções como o Starfish e AutoConf fornecem mecanismos para ajustar a execução de consultas MapReduce através da alteração de parâmetros de configuração. Neste minicurso serão apresentadas soluções de tuning para processadores de consulta baseados em MapReduce com foco principal numa solução baseada em Hadoop, Hive e AutoConf. Além disso, iremos discutir como um sistema de aprendizado de máquina não supervisionado pode ser utilizado como uma poderosa ferramenta na tarefa de configuração de parâmetros do sistema.
A implantação de ferramentas de big data está sendo retida pela falta de padrões nas áreas listadas. O desenvolvimento desses padrões não impediria a inovação ou que fornecedores oferecessem soluções exclusivas. Pelo contrário, o caso do ANSI SQL mostra como uma padronização facilitou o crescimento substancial de um grande número de soluções de banco de dados.
Um aspecto importante dos padrões é garantir compliance. O Instituto Nacional de Padrões e Tecnologia (NIST) do Departamento de Comércio dos EUA fez isso com o SQL. Embora o padrão SQL tenha uma adoção admiravelmente ampla, isso não garante uma interoperabilidade tranquila. Em primeiro lugar, o SQL evoluiu e os fornecedores podem escolher qual versão do padrão querem seguir. Mesmo assim, o quanto da versão eles aderem não é claro sem uma certificação. Em segundo lugar, são oferecidos vários aprimoramentos fora do padrão.
Algumas das áreas listadas podem fornecer mais valor para usuários e provedores. Uma definição de prioridades para determinar qual padrão forneceria o maior valor, com base na contribuição de usuários e da comunidade de fornecedores, poderia ajudar na orientação dos esforços para desenvolver padrões.
Esses esforços poderiam ser facilitados por meio de novos órgãos de padronização ou com cooperação e tutela de órgãos existentes – ANSI, ISO, TPC e W3C. Os membros do comitê dessas organizações têm uma tremenda experiência no desenvolvimento de excelentes padrões. Eles sabem lidar habilidosamente com a obtenção de consenso entre participantes que, de outra forma, competiriam. Entretanto, Jain afirma que usuários finais e fornecedores são figuras centrais na pressão que pode culminar no estabelecimento dessas padronizações.
__________________________________________________________________________________
Notas e Relacionados
> Inicialmente o nosso propósito com o Blog é efetuar postagens diversas, porém teremos a área separada para as postagens relacionadas ao Constructor SO, que é o nosso Portfólio de Projetos, Agiles e Scrum, em que cada membro do Constructor SO possui a sua área para os seus desenvolvimentos. Dessa forma, cada atualização da área do Constructor SO é seguida de uma postagem no blog do profissional, informando os nossos leitores e criando assim um panorama extensivo de tal trabalho lançado ou versionado;
> A priori em relação aos desenvolvimentos da Space_One Labs, a nossa ideia é lançar e trabalhar de forma aleatória vários projetos da área específica relacionada, não nos tornando assim limitados por apps ou softwares específicos;
> Todos os casos aqui descritos e desenvolvidos, para este blog, no qual me pertence, que seja da categoria "BI Case", são casos de empresas fictícias, criadas e inventadas, para contextualizar e deixar o trabalho mais vivo e realista possível.
#BlogdeMembros #BlogSOLabs / #ApacheHive #ApacheORC #Cloud #HQL #HiveQL #BigData #Tecnologia #BI #BusinessIntelligence #ConstructorSO
__________________________________________________________________________________
Daniel Sanches
Engenheiro de Produção, Universo - Universidade Salgado de Oliveira, especializado em Analytics e Data, Business e Tecnologia.
SO Labs Developer Member of Research, Business Intelligence Analyst, Data Analyst and Business Analyst, Data Engineer, Blogger DS Space_One Labs | Space Members
Membro SO Labs Desenvolvedor de Pesquisas, Business Intelligence, Data Engineer, Data Analyst e Negócios
Comments