自从Hadoop集群搭建以来，我们一直使用的是Gzip进行压缩

当时，我对gzip压缩过的文件和原始的log文件分别跑MapReduce测试，最终执行速度基本差不多

而且Hadoop原生支持Gzip解压，所以，当时就直接采用了Gzip压缩的方式

关于Lzo压缩，twitter有一篇文章，介绍的比较详细，见这里：

Lzo压缩相比Gzip压缩，有如下特点：

1. 压缩解压的速度很快
2. Lzo压缩是基于Block分块的，这样，一个大的文件（在Hadoop上可能会占用多个Block块），就可以由多个MapReduce并行来进行处理

虽然Lzo的压缩比没有Gzip高，不过由于其前2个特性，在Hadoop上使用Lzo还是能整体提升集群的性能的

我测试了12个log文件，总大小为8.4G，以下是Gzip和Lzo压缩的结果：

1. Gzip压缩，耗时480s，Gunzip解压，耗时180s，压缩后大小为2.5G
2. Lzo压缩，耗时160s，Lzop解压，耗时110s，压缩后大小为4G

以下为在Hadoop集群上使用Lzo的步骤：

1. 在集群的所有节点上安装Lzo库，可从这里下载

cd /opt/ysz/src/lzo-2.04

./configure –enable-shared

make

make install

#编辑/etc/ld.so.conf，加入/usr/local/lib/后，执行/sbin/ldconfig

或者cp /usr/local/lib/liblzo2.* /usr/lib64/

#如果没有这一步，最终会导致以下错误：

lzo.LzoCompressor: java.lang.UnsatisfiedLinkError: Cannot load liblzo2.so.2 (liblzo2.so.2: cannot open shared object file: No such file or directory)!

2. 编译安装Hadoop Lzo本地库以及Jar包，从这里下载

    export CFLAGS=-m64

    export CXXFLAGS=-m64

    ant compile-native tar

    #将本地库以及Jar包拷贝到hadoop对应的目录下，并分发到各节点上

    cp lib/native/Linux-amd64-64/* /opt/sohuhadoop/hadoop/lib/native/Linux-amd64-64/

    cp hadoop-lzo-0.4.10.jar /opt/sohuhadoop/hadoop/lib/

3. 设置Hadoop，启用Lzo压缩

vi core-site.xml

<property>     

<name>io.compression.codecs</name>     

<value>org.apache.hadoop.io.compress.GzipCodec,org.apache.hadoop.io.compress.DefaultCodec,com.hadoop.compression.lzo.LzoCodec,com.hadoop.compression.lzo.LzopCodec,org.apache.hadoop.io.compress.BZip2Codec</value>

</property>

<property>     

<name>io.compression.codec.lzo.class</name>     

<value>com.hadoop.compression.lzo.LzoCodec</value>

</property>

 

vi mapred-site.xml

<property>

<name>mapred.compress.map.output</name>     

<value>true</value>   

</property>   

<property>     

<name>mapred.map.output.compression.codec</name>      

<value>com.hadoop.compression.lzo.LzoCodec</value>   

</property>

4. 安装lzop，从这里下载

下面就是使用lzop压缩log文件，并上传到Hadoop上，执行MapReduce操作，测试的Hadoop是由3个节点组成集群

lzop -v 2011041309.log

hadoop fs -put *.lzo /user/pvlog

#给Lzo文件建立Index

hadoop jar /opt/sohuhadoop/hadoop/lib/hadoop-lzo-0.4.10.jar com.hadoop.compression.lzo.LzoIndexer /user/pvlog/

写一个简单的MapReduce来测试，需要指定InputForamt为Lzo格式，否则对单个Lzo文件仍不能进行Map的并行处理

job.setInputFormatClass(com.hadoop.mapreduce.LzoTextInputFormat.class);

可以通过下面的代码来设置Reduce的数目：

job.setNumReduceTasks(8);

最终，12个文件被切分成了36个Map任务来并行处理，执行时间为52s，如下图：

我们配置Hadoop默认的Block大小是128M，如果我们想切分成更多的Map任务，可以通过设置其最大的SplitSize来完成：

FileInputFormat.setMaxInputSplitSize(job, 64 *1024 * 1024);

最终，12个文件被切分成了72个Map来处理，但处理时间反而长了，为59s，如下图：

而对于Gzip压缩的文件，即使我们设置了setMaxInputSplitSize，最终的Map数仍然是输入文件的数目12，执行时间为78s，如下图：

从以上的简单测试可以看出，使用Lzo压缩，性能确实比Gzip压缩要好不少

最近在看《Hadoop:The Definitive Guide》，对其分布式文件系统HDFS的Streaming data access不能理解。基于流的数据读写，太抽象了，什么叫基于流，什么是流？Hadoop是Java语言写的，所以想理解好Hadoop的Streaming Data Access，还得从Java流机制入手。流机制也是JAVA及C++中的一个重要的机制，通过流使我们能够自由地操作包括文件，内存，IO设备等等中的数据。

首先，流是什么？

流是个抽象的概念，是对输入输出设备的抽象，Java程序中，对于数据的输入/输出操作都是以“流”的方式进行。设备可以是文件，网络，内存等。

流具有方向性，至于是输入流还是输出流则是一个相对的概念，一般以程序为参考，如果数据的流向是程序至设备，我们成为输出流，反之我们称为输入流。

可以将流想象成一个“水流管道”，水流就在这管道中形成了，自然就出现了方向的概念。

当程序需要从某个数据源读入数据的时候，就会开启一个输入流，数据源可以是文件、内存或网络等等。相反地，需要写出数据到某个数据源目的地的时候，也会开启一个输出流，这个数据源目的地也可以是文件、内存或网络等等。

流有哪些分类？

可以从不同的角度对流进行分类：

1. 处理的数据单位不同，可分为：字符流，字节流

2.数据流方向不同，可分为：输入流，输出流

3.功能不同，可分为：节点流，处理流

1. 和 2. 都比较好理解，对于根据功能分类的，可以这么理解：

节点流：节点流从一个特定的数据源读写数据。即节点流是直接操作文件，网络等的流，例如FileInputStream和FileOutputStream，他们直接从文件中读取或往文件中写入字节流。

处理流：“连接”在已存在的流（节点流或处理流）之上通过对数据的处理为程序提供更为强大的读写功能。过滤流是使用一个已经存在的输入流或输出流连接创建的，过滤流就是对节点流进行一系列的包装。例如BufferedInputStream和BufferedOutputStream，使用已经存在的节点流来构造，提供带缓冲的读写，提高了读写的效率，以及DataInputStream和DataOutputStream，使用已经存在的节点流来构造，提供了读写Java中的基本数据类型的功能。他们都属于过滤流。

举个简单的例子：

public static void main(String[] args) throws IOException {
        // 节点流FileOutputStream直接以A.txt作为数据源操作
        FileOutputStream fileOutputStream = new FileOutputStream("A.txt");
        // 过滤流BufferedOutputStream进一步装饰节点流，提供缓冲写
        BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(
                fileOutputStream);
        // 过滤流DataOutputStream进一步装饰过滤流，使其提供基本数据类型的写
        DataOutputStream out = new DataOutputStream(bufferedOutputStream);
        out.writeInt(3);
        out.writeBoolean(true);
        out.flush();
        out.close();
        // 此处输入节点流，过滤流正好跟上边输出对应，读者可举一反三
        DataInputStream in = new DataInputStream(new BufferedInputStream(
                new FileInputStream("A.txt")));
        System.out.println(in.readInt());
        System.out.println(in.readBoolean());
        in.close();
}

流结构介绍：

Java所有的流类位于java.io包中，都分别继承字以下四种抽象流类型。

1.继承自InputStream/OutputStream的流都是用于向程序中输入/输出数据，且数据的单位都是字节(byte=8bit)，如图，深色的为节点流，浅色的为处理流。

2.继承自Reader/Writer的流都是用于向程序中输入/输出数据，且数据的单位都是字符(2byte=16bit)，如图，深色的为节点流，浅色的为处理流。

常见流类介绍：

节点流类型常见的有：

对文件操作的字符流有FileReader/FileWriter，字节流有FileInputStream/FileOutputStream。

处理流类型常见的有：

缓冲流：缓冲流要“套接”在相应的节点流之上，对读写的数据提供了缓冲的功能，提高了读写效率，同事增加了一些新的方法。

　　字节缓冲流有BufferedInputStream/BufferedOutputStream，字符缓冲流有BufferedReader/BufferedWriter，字符缓冲流分别提供了读取和写入一行的方法ReadLine和NewLine方法。

　　对于输出地缓冲流，写出的数据，会先写入到内存中，再使用flush方法将内存中的数据刷到硬盘。所以，在使用字符缓冲流的时候，一定要先flush，然后再close，避免数据丢失。

转换流：用于字节数据到字符数据之间的转换。

　　仅有字符流InputStreamReader/OutputStreamWriter。其中，InputStreamReader需要与InputStream“套接”，OutputStreamWriter需要与OutputStream“套接”。

数据流：提供了读写Java中的基本数据类型的功能。

　　DataInputStream和DataOutputStream分别继承自InputStream和OutputStream，需要“套接”在InputStream和OutputStream类型的节点流之上。

对象流：用于直接将对象写入写出。

　　流类有ObjectInputStream和ObjectOutputStream，本身这两个方法没什么，但是其要写出的对象有要求，该对象必须实现Serializable接口，来声明其是可以序列化的。否则，不能用对象流读写。

　　还有一个关键字比较重要，transient，由于修饰实现了Serializable接口的类内的属性，被该修饰符修饰的属性，在以对象流的方式输出的时候，该字段会被忽略。

Hive:

利用squirrel-sql 连接hive

add driver -> name&example url(jdbc:hive2://xxx:10000)->extra class path ->Add

{hive/lib/hive-common-*.jar

hive/lib/hive-contrib-*.jar

hive/lib/hive-jdbc-*.jar

hive/lib/libthrift-*.jar

hive/lib/hive-service-*.jar

hive/lib/httpclient-*.jar

hive/lib/httpcore-*.jar

hadoop/share/hadoop/common/hadoop-common--*.jar

hadoop/share/hadoop/common/lib/common-configuration-*.jar

hadoop/share/hadoop/common/lib/log4j-*.jar

hadoop/share/hadoop/common/lib/slf4j-api-*.jar

hadoop/share/hadoop/common/lib/slf4j-log4j-*.jar}

->List Drivers(wait ..then class name will auto set org.apache.hive.jdbc/HiveDriver)->OK->Add aliases ->chose the hive driver->done

Hive数据迁移

1.导出表

EXPORT TABLE <table_name> TO 'path/to/hdfs';

2.复制数据到另一个hdfs

hadoop distcp hdfs://:8020/path/to/hdfs hdfs:///path/to/hdfs

3.导入表

IMPORT TABLE <table_name> FROM 'path/to/another/hdfs';

Hive 输出查询结果到文件

输出到本地文件：

insert overwrite local directory './test-04'
row format delimited
FIELDS TERMINATED BY '\t'
COLLECTION ITEMS TERMINATED BY ','
MAP KEYS TERMINATED BY ':'
select * from src;

输出到hdfs：

输出到hdfs好像不支持 row format，只能另辟蹊径了

INSERT OVERWRITE DIRECTORY '/outputable.txt'
select concat(col1, ',', col2, ',', col3) from myoutputtable;

当然默认的分隔符是\001

若要直接对文件进行操作课直接用stdin的形式

eg. hadoop fs -cat ../000000_0 |python doSomeThing.py

#!/usr/bin/env python

import sys

for line in sys.stdin:

    (a,b,c)=line.strip().split('\001')

Hive 语法：

hive好像不支持select dicstinct col1 as col1 from table group by col1

需要用grouping sets

select col1 as col1 from table group by col1 grouping sets((col1))

Beeline:

文档：https://cwiki.apache.org/confluence/display/Hive/HiveServer2+Clients

利用jdbc连接hive：

hive2='JAVA_HOME=/opt/java7 HADOOP_HOME=/opt/hadoop /opt/hive/bin/beeline -u jdbc:hive2://n1.hd2.host.dxy:10000 -n hadoop -p fake -d org.apache.hive.jdbc.HiveDriver --color=true --silent=false --fastConnect=false --verbose=true'

beeline利用jdbc连接hive若需要执行多条命令使用

hive2 -e "xxx" -e "yyy"  -e...