pythonthrift教程
‘壹’ windows下怎么用python连接hive数据库
由于版本的不同，Python 连接 Hive 的方式也就不一样。
在网上搜索关键字 python hive 的时候可以找到一些解决方案。大部分是这样的，首先把hive 根目录下的$HIVE_HOME/lib/py拷贝到 python 的库中，也就是 site-package 中，或者干脆把新写的 python 代码和拷贝的 py 库放在同一个目录下，然后用这个目录下提供的 thrift 接口调用。示例也是非常简单的。类似这样：
import sys
from hive_service import ThriftHive
from hive_service.ttypes import HiveServerException
from thrift import Thrift
from thrift.transport import TSocket
from thrift.transport import TTransport
from thrift.protocol import TBinaryProtocol
def hiveExe(sql):
try:
transport = TSocket.TSocket('127.0.0.1', 10000)
transport = TTransport.TBufferedTransport(transport)
protocol = TBinaryProtocol.TBinaryProtocol(transport)
client = ThriftHive.Client(protocol)
transport.open()
client.execute(sql)
print "The return value is : "
print client.fetchAll()
print "............"
transport.close()
except Thrift.TException, tx:
print '%s' % (tx.message)
if __name__ == '__main__':
hiveExe("show tables")171819202122232425262728
或者是这样的：
#!/usr/bin/env python
import sys
from hive import ThriftHive
from hive.ttypes import HiveServerException
from thrift import Thrift
from thrift.transport import TSocket
from thrift.transport import TTransport
from thrift.protocol import TBinaryProtocol
try:
transport = TSocket.TSocket('14.18.154.188', 10000)
transport = TTransport.TBufferedTransport(transport)
protocol = TBinaryProtocol.TBinaryProtocol(transport)
client = ThriftHive.Client(protocol)
transport.open()
client.execute("CREATE TABLE r(a STRING, b INT, c DOUBLE)")
client.execute("LOAD TABLE LOCAL INPATH '/path' INTO TABLE r")
client.execute("SELECT * FROM test1")
while (1):
row = client.fetchOne()
if (row == None):
break
print rowve
client.execute("SELECT * FROM test1")
print client.fetchAll()
transport.close()
except Thrift.TException, tx:
print '%s' % (tx.message)
但是都解决不了问题，从 netstat 中查看可以发现 TCP 连接确实是建立了，但是不执行 hive 指令。也许就是版本的问题。
还是那句话，看各种中文博客不如看官方文档。
项目中使用的 hive 版本是0.13，此时此刻官网的最新版本都到了1.2.1了。中间间隔了1.2.0、1.1.0、1.0.0、0.14.0。但是还是参考一下官网的方法试试吧。
首先看官网的 setting up hiveserver2
可以看到启动 hiveserver2 可以配置最大最小线程数，绑定的 IP，绑定的端口，还可以设置认证方式。（之前一直不成功正式因为这个连接方式）然后还给了 python 示例代码。
import pyhs2
with pyhs2.connect(host='localhost',
port=10000,
authMechanism="PLAIN",
user='root',
password='test',
database='default') as conn:
with conn.cursor() as cur:
#Show databases
print cur.getDatabases()
#Execute query
cur.execute("select * from table")
#Return column info from query
print cur.getSchema()
#Fetch table results
for i in cur.fetch():
print
在拿到这个代码的时候，自以为是的把认证信息给去掉了。然后运行发现跟之前博客里介绍的方法结果一样，建立了 TCP 连接，但是就是不执行，也不报错。这是几个意思？然后无意中尝试了一下原封不动的使用上面的代码。结果可以用。唉。。。
首先声明一下，hive-site.xml中默认关于 hiveserver2的配置我一个都没有修改，一直是默认配置启动 hiveserver2。没想到的是默认配置是有认证机制的。
然后再写一点，在安装 pyhs2的时候还是遇到了点问题，其实还是要看官方文档的，我只是没看官方文档直接用 pip安装导致了这个问题。安装 pyhs2需要确定已经安装了几个依赖包。直接看在 github 上的 wiki 吧。哪个没安装就补上哪一个就好了。
To install pyhs2 on a clean CentOS 6.4 64-bit desktop....
(as root or with sudo)
get ez_setup.py from https://pypi.python.org/pypi/ez_setup
python ez_setup.py
easy_install pip
yum install gcc-c++
yum install cyrus-sasl-devel.x86_64
yum install python-devel.x86_64
pip install
写了这么多，其实是在啰嗦自己遇到的问题。下面写一下如何使用 python
连接 hive。
python 连接 hive 是基于 thrift 完成的。所以需要服务器端和客户端的配合才能使用。
在服务器端需要启动 hiveserver2 服务，启动方法有两种， 第二种方法只是对第一种方法的封装。
1. $HIVE_HOME/bin/hive --server hiveserver2
2. $HIVE_HOME/bin/hiveserver21212
默认情况下就是hiveserver2监听了10000端口。也可以通过修改 hive-site.xml 或者在启动的时候添加参数来实现修改默认配置。
另外一方面，在客户端需要安装 python 的依赖包 pyhs2。安装方法在上面也介绍了，基本上就是用 pip install pyhs2，如果安装不成功，安装上面提到的依赖包就可以了。
最后运行上面的示例代码就可以了，配置好 IP 地址、端口、数据库、表名称就可以用了，默认情况下认证信息不需要修改。
另外补充一点 fetch 函数执行速度是比较慢的，会把所有的查询结果返回来。可以看一下 pyhs2 的源码，查看一下还有哪些函数可以用。下图是 Curor 类的可以使用的函数。
一般 hive 表里的数据比较多，还是一条一条的读比较好，所以选择是哟功能 fetchone函数来处理数据。fetchone函数如果读取成功会返回列表，否则 None。可以把示例代码修改一下，把 fetch修改为：
count = 0
while (1):
row = cur.fetchone()
if (row is not None):
count += 1
print count, row
else:
print "it's over"
‘贰’ thrift c++ list 怎么用python客户端实例化
thrift做为跨语言调用的方案有高效，支持语言较多，成熟等优点；代码侵入较强是其弱点。
下面记录以C++做服务器，C++,java和python做客户端的示例，这个和本人现在工作环境吻合，使用多线程长连接的socket来建立高效分布式系统的跨语言调用平台。遗憾的是目前版本(0.7.0)的C语言还不支持Compact协议，导致在现在的环境中nginx c mole调用thrift要使用binary协议。thrift开发团队似乎对C语言不太感冒。
1.定义idl文件acsuser.thrift
1 struct User{
2 1: string uid,
3 2: string uname,
4 3: bool usex,
5 4: i16 uage,
6 }
7 service UserService{
8 void add(1: User u),
9 User get(1: string uid),
10 }
2.生成c++,java和python代码框架
1 thrift -r --gen cpp acsuser.thrift
2 thrift -r --gen java acsuser.thrift
3 thrift -r --gen py acsuser.thrift
这时生成子目录gen-cpp,gen-java,gen-py
3.生成C++服务端代码
cp gen-cpp/UserService_server.skeleton.cpp UserServer.cpp
修改UserServer.cpp
1 #include "UserService.h"
2 #include <config.h>
3 //#include <protocol/TBinaryProtocol.h>
4 #include <protocol/TCompactProtocol.h>
5 #include <server/TSimpleServer.h>
6 #include <transport/TServerSocket.h>
7 #include <transport/TBufferTransports.h>
8 #include <concurrency/ThreadManager.h>
9 #include <concurrency/PosixThreadFactory.h>
10 #include <server/TThreadPoolServer.h>
11 #include <server/TThreadedServer.h>
12
13 using namespace ::apache::thrift;
14 using namespace ::apache::thrift::protocol;
15 using namespace ::apache::thrift::transport;
16 using namespace ::apache::thrift::server;
17 using namespace ::apache::thrift::concurrency;
18
19 using boost::shared_ptr;
20
21 class UserServiceHandler : virtual public UserServiceIf {
22 public:
23 UserServiceHandler() {
24 // Your initialization goes here
25 }
26
27 void add(const User& u) {
28 // Your implementation goes here
29 printf("uid=%s uname=%s usex=%d uage=%d\n", u.uid.c_str(), u.uname.c_str(), u.usex, u.uage);
30 }
31
32 void get(User& _return, const std::string& uid) {
33 // Your implementation goes here
34 _return.uid = "leo1";
35 _return.uname = "yueyue";
36 _return.usex = 1;
37 _return.uage = 3;
38 printf("uid=%s uname=%s usex=%d uage=%d\n", _return.uid.c_str(), _return.uname.c_str(), _return.usex, _return.uage);
39 }
40
41 };
42
43 int main(int argc, char **argv) {
44 shared_ptr<UserServiceHandler> handler(new UserServiceHandler());
45 shared_ptr<TProcessor> processor(new UserServiceProcessor(handler));
46 shared_ptr<TProtocolFactory> protocolFactory(new TCompactProtocolFactory());
47 shared_ptr<TTransportFactory> transportFactory(new TBufferedTransportFactory());
48 shared_ptr<TServerTransport> serverTransport(new TServerSocket(9090));
49
50 shared_ptr<ThreadManager> threadManager = ThreadManager::newSimpleThreadManager(10);
51 shared_ptr<PosixThreadFactory> threadFactory = shared_ptr<PosixThreadFactory>(new PosixThreadFactory());
52 threadManager->threadFactory(threadFactory);
53 threadManager->start();
54 printf("start user server...\n");
55
56 TThreadPoolServer server(processor, serverTransport, transportFactory, protocolFactory, threadManager);
57 server.serve();
58 return 0;
59 }
注意这段代码使用TCompactProtocol，需要#include <config.h>
另外这个是Blocking的多线程服务器
4.生成C++的client文件UserClient.cpp
1 #include "UserService.h"
2 #include <config.h>
3 #include <transport/TSocket.h>
4 #include <transport/TBufferTransports.h>
5 #include <protocol/TCompactProtocol.h>
6
7 using namespace apache::thrift;
8 using namespace apache::thrift::protocol;
9 using namespace apache::thrift::transport;
10
11 using boost::shared_ptr;
12
13 int main(int argc, char **argv) {
14 boost::shared_ptr<TSocket> socket(new TSocket("localhost", 9090));
15 boost::shared_ptr<TTransport> transport(new TBufferedTransport(socket));
16 boost::shared_ptr<TProtocol> protocol(new TCompactProtocol(transport));
17
18 transport->open();
19
20 User u;
21 u.uid = "leo";
22 u.uname = "yueyue";
23 u.usex = 1;
24 u.uage = 3;
25
26 UserServiceClient client(protocol);
27 client.add(u);
28
29 User u1;
30 client.get(u1,"lll");
31
32 transport->close();
33 printf("uid=%s uname=%s usex=%d uage=%d\n", u1.uid.c_str(), u1.uname.c_str(), u1.usex, u1.uage);
34 return 0;
35 }
5.生成Makefile
1 BOOST_DIR = /usr/local/include/boost/
2 THRIFT_DIR = /usr/local/include/thrift
3 LIB_DIR = /usr/local/lib
4 GEN_SRC = ./gen-cpp/acsuser_types.cpp ./gen-cpp/acsuser_constants.cpp ./gen-cpp/UserService.cpp
5 default: server client
6 server: UserServer.cpp
7 g++ -g -o UserServer -I${THRIFT_DIR} -I${BOOST_DIR} -I./gen-cpp -L${LIB_DIR} -lthrift UserServer.cpp ${GEN_SRC}
8 client: UserClient.cpp
9 g++ -g -o UserClient -lm -pthread -lz -lrt -lssl -I${THRIFT_DIR} -I${BOOST_DIR} -I./gen-cpp -L${LIB_DIR} -lthrift UserClient.cpp ${GEN_SRC}
10 clean:
11 $(RM) -r UserServer UserClient
6.启动c++ server
1 ./UserServer
7.测试c++ client
1 ./UserClient
8.写java client文件UserClient.java
1 import org.apache.thrift.TException;
2 import org.apache.thrift.protocol.TCompactProtocol;
3 import org.apache.thrift.protocol.TProtocol;
4 import org.apache.thrift.transport.TFramedTransport;
5 import org.apache.thrift.transport.TNonblockingSocket;
6 import org.apache.thrift.transport.TSocket;
7 import org.apache.thrift.transport.TTransport;
8 import org.apache.thrift.transport.TTransportException;
9
10 //import UserService.Client;
11
12 public class UserClient {
13 private void start() {
14 try {
15 TTransport socket = new TSocket("localhost", 9090);
16 //TTransport transport = new TFramedTransport(socket);
17 TProtocol protocol = new TCompactProtocol(socket);
18
19 UserService.Client client = new UserService.Client(protocol);
20 socket.open();
21 System.out.println(client.get("lll"));
22
23 User u = new User();
24 u.uid="leojava";
25 u.uname="yueyue";
26 u.usex=true;
27 u.uage=3;
28 client.add(u);
29 socket.close();
30
31 } catch (TTransportException e) {
32 e.printStackTrace();
33 } catch (TException e) {
34 e.printStackTrace();
35 }
36 }
37
38 public static void main(String[] args) {
39 UserClient c = new UserClient();
40 c.start();
41
42 }
43 }
编译和运行java client
1 javac -classpath /usr/local/lib/libthrift-0.7.0.jar:/usr/local/lib/log4j-1.2.14.jar:/usr/local/lib/commons-logging-1.1.1.jar:/usr/local/lib/slf4j-api-1.5.8.jar UserClient.java ./gen-java/*.java
2 java -classpath .:./gen-java:/usr/local/lib/libthrift-0.7.0.jar:/usr/local/lib/log4j-1.2.14.jar:/usr/local/lib/commons-logging-1.1.1.jar:/usr/local/lib/slf4j-api-1.5.8.jar:/usr/local/lib/slf4j-log4j12-1.5.8.jar UserClient
9.写Python client文件PythonClient.py
1 #!/usr/bin/env python
2 import sys
3 sys.path.append('./gen-py')
4 from acsuser import UserService
5 from acsuser.ttypes import *
6 from thrift import Thrift
7 from thrift.transport import TSocket
8 from thrift.transport import TTransport
9 from thrift.protocol import TCompactProtocol
10
11 # Make socket
12 transport = TSocket.TSocket('localhost', 9090)
13 # Buffering is critical. Raw sockets are very slow
14 transport = TTransport.TBufferedTransport(transport)
15 # Wrap in a protocol
16 protocol = TCompactProtocol.TCompactProtocol(transport)
17 # Create a client to use the protocol encoder
18 client = UserService.Client(protocol)
19 # Connect!
20 transport.open()
21 # Call Server services
22 u = client.get('lll')
23 print 'uid=%s uname=%s usex=%d u.uage=%d' %(u.uid,u.uname,u.usex,u.uage)
24
25 u1 = User()
26 u1.uid='leo'
27 u1.uname='yueyue'
28 u1.usex=1
29 u1.uage=3
30 client.add(u1)
执行python client代码
1 chmod 777 PythonClient.py
2 ./PythonClient.py
‘叁’ thrift list 泛型 python 怎么使用
总结
1.首先要编写一个*.thrift文件，这个文件里面定义了结构体和方法
举例:
类似于Java中的属性体和接口
2.定义完这个文件之后，确定你要做哪一端，在客户端或者服务器端都要得到此文件，然后运行sudo thrift --gen py *.thrift（有时候文件夹生成不成功，有时候成功，很奇怪还在找原因）
3.此时在当前目录会生成gen-py文件
4.此时不用管这个文件夹，就可以在编写自己的客户端或者服务器端的py文件了，新建一个py文件，见下面例子：
注：此处引用别人的，客户端：
[html] view plain
#!/usr/bin/env python
import sys
sys.path.append('./gen-py')
from helloworld import HelloWorld
from thrift import Thrift
from thrift.transport import TSocket
from thrift.transport import TTransport
from thrift.protocol import TBinaryProtocol
try:
transport = TSocket.TSocket('localhost', 9090)
transport = TTransport.TBufferedTransport(transport)
protocol = TBinaryProtocol.TBinaryProtocol(transport)
client = HelloWorld.Client(protocol)
transport.open()
print "client - ping"
print "server - " + client.ping()
print "client - say"
msg = client.say("Hello!")
print "server - " + msg
transport.close()
except Thrift.TException, ex:
print "%s" % (ex.message)
服务器端：
[html] view plain
#!/usr/bin/env python
import socket
import sys
sys.path.append('./gen-py')
from helloworld import HelloWorld
from helloworld.ttypes import *
from thrift.transport import TSocket
from thrift.transport import TTransport
from thrift.protocol import TBinaryProtocol
from thrift.server import TServer
class HelloWorldHandler:
def ping(self):
return "pong"
def say(self, msg):
ret = "Received: " + msg
print ret
return ret
handler = HelloWorldHandler()
processor = HelloWorld.Processor(handler)
transport = TSocket.TServerSocket("localhost", 9090)
tfactory = TTransport.TBufferedTransportFactory()
pfactory = TBinaryProtocol.TBinaryProtocolFactory()
server = TServer.TSimpleServer(processor, transport, tfactory, pfactory)
print "Starting thrift server in python..."
server.serve()
print "done!"
1.Thrift有以下几个概念：
类型系统（typesystem）
Thrift定义了一套数据传输描述语言（有点类似IDL），它是“语言中性”的，这个就是它的类型系统。它分为五种类型（数据类型表达3种，预定义类/结构1种，接口表达1种）：
基本类型(basictype)，也就是bool、byte、i16、i32、i64、double、string，任何语言都有这些基本类型，比较有意思的是string，它即表达text，也表达binary bytes。另一个特点是整型没有unsigned，原因比较简单，因为有些语言不支持。
结构类型(struct)：就是C语言中的struct，将基本类型组合起来。
容器类型(container)：就是集合类型（list/set/map），其中的元素是任何Thrift可识别的基本、结构、容器类型。【不知道是否有不支持list/set/map的语言，那么Thrift如何处理呢？】
异常类型(exception)：从数据结构讲就是结构类型，可以认为是便于异常的处理而单独拿出来的、预定义的、有特殊意义的结构类型。
服务定义类型(service)：这个类型实际是用来定义接口的，Thrift代码生成器会根据这个定义，生成代码框架。
传输(transport)
也就是信息的传输渠道以及读写方式，例如，介质可以是socket、shared memory或file，Thrift规定了一些基本的操作（open/close/isOpen/read/write/flush，对server，再加上listen/accept）。特别的，针对Socket方式，有TScoket类，对file方式，有TFileTransport类，上面类比较底层，还有几个实用的类：TBufferedTransport，TFramedTransport，TMemoryBuffer等。
协议（protocol）
是对传输协议的封装，也就是传输采用二进制、XML或者text来表示信息，它的功能有两个：1.双向的消息队列；2.信息的编码和解码（也就是对上面类型的读/写）。关于流式格式，thrift数据类型是自我分割的，意思是说，thrift会自己在数据域的分割处插入标志，在解码的时候，即使没有数据域定义，thrift也能成功分割出各数据域。在若干篇文章中，都提到thrift的二进制流式编码有相当的效率（可以配合压缩），因此首选的协议应该是binary协议。
版本（versioning）
如果一个程序分开来开发，那版本问题就是绕不过去的问题。Thrift的版本是通过“field identifiers”来实现的，每个结构由其标识，结构中的每个域有其标识，这两个标识唯一决定了一个数据域。在解码的时候，数据域的标识被检查，如果不能识别，则该数据域被抛弃。Thrift也可以通过”Isset”机制来明确某些域的设置与否（发送端用来指明是否设置，接收端用来检测是否设置）。
四种情况：
添加了数据域, 旧客户端,新服务器端：客户端发送的数据中没有该域，服务器端能检测出来，可按缺省值处理。
删除了数据域, 旧客户端,新服务器端：客户端发送的数据中有该域，服务器端忽略该域。
添加了数据域, 新客户端,旧服务器端：客户端发送的数据中有该域，服务器端忽略该域。
删除了数据域, 新客户端,旧服务器端：客户端发送的数据中没有该域，服务器端可能不知道如何处理这种情况。
处理器（processor）
就是如何将各部分协调起来，形成代码（或用户代码的框架）。它有两个重要的类：TProcessor和TServer。TProcessor用来实现RPC调用，TServer是所有Server类的基类，TServer类主要处理连接和线程，而不管诸如传输、编码等。用户代码主要关注的一是.thrift文件，二就是这个接口。Thrift为此实现了TSimpleServer(单线程), TThreadedServer（每连接一个线程）和 TThreadPoolServer（线程池）等类。
下图是thrift生成代码的基本结构(C++)。
图中，ServiceIf是根据接口文件（.thrift）生成的虚接口类，用户的具体实现在ServiceHandler中。各种调用方式在TServer中实现。【详细的描述见实例】
2.Thrift实现上的几个考虑
目标语言
虽然有多种选择，但最常用的（可能也是支持最好的）是C++, Java, and Python。
生成的结构体
数据域成员都是公有的，没有set,get之类的东西，虽然建议采用isset，但也可以不用，系统足够强健来处理类似“FieldNotSetException”之类的问题，因而也没有涉及该异常。Read和write方面也是公有的，这样用户可以在固有的RPC之外来使用它们。
RPC方法标识：实现RPC时，建立函数名与函数指针之间的映射，大致如下（不同的语言表达方式不同，C++，map）:
std::map<std::string,函数指针> processMap_;
这样加快函数调用。
多线程
对C++实现，在开发过程中，thrift开发人员研究过boost，ACE中与thread,timer相关的东西，开发人员不想引入过多的第三方依赖，因此thrift中只有对boost::shared_ptr的引用是必须的，但为了跨平台或获得更多的功能，一般情况下，boost中thread，timer及其依赖库也是需要的。
ThreadManager和TimerManager
线程管理类用来管理线程池，定时器管理类可以定时触发Runnable的对象，开启一件事情（可以放到或不放到一个单独线程）。
NonblockingOperation
这个东西需要libevent的支持。
Compiler（代码生成器）
这个东西是用C++写的，依赖于lex/yacc。代码生成分两步：第一，检查包含的文件和类型定义文件，生成“解析树”（the parse tree）；第二，将各类型放到解析树中，根据解析树生成代码。
TFileTransport
这个类（及其继承类）可以将request消息记入文件，为提高性能，它先缓存记录，并存入磁盘。记录文件是分块的（文件固定大小），采用padding，记录不能跨块。
‘肆’ 在ubuntu环境下怎么利用python将数据批量导入数据hbase
能够单条导入就能够批量导入
配置 thrift
python使用的包 thrift
个人使用的python 编译器是pycharm community edition. 在工程中设置中，找到project interpreter， 在相应的工程下，找到package，然后选择 “+” 添加， 搜索 hbase-thrift (Python client for HBase Thrift interface),然后安装包。
安装服务器端thrift。
参考官网，同时也可以在本机上安装以终端使用。
thrift Getting Started
也可以参考安装方法 python 调用HBase 范例
首先，安装thrift
下载thrift，这里，我用的是thrift-0.7.0-dev.tar.gz 这个版本
tar xzf thrift-0.7.0-dev.tar.gz
cd thrift-0.7.0-dev
sudo ./configure –with-cpp=no –with-ruby=no
sudo make
sudo make install
然后，到HBase的源码包里，找到
src/main/resources/org/apache/hadoop/hbase/thrift/
执行
thrift –gen py Hbase.thrift
mv gen-py/hbase/ /usr/lib/python2.4/site-packages/ (根据python版本可能有不同)
获取数据示例 1
# coding:utf-8
from thrift import Thrift
from thrift.transport import TSocket
from thrift.transport import TTransport
from thrift.protocol import TBinaryProtocol
from hbase import Hbase
# from hbase.ttypes import ColumnDescriptor, Mutation, BatchMutation
from hbase.ttypes import *
import csv
def client_conn():
# Make socket
transport = TSocket.TSocket('hostname,like:localhost', port)
# Buffering is critical. Raw sockets are very slow
transport = TTransport.TBufferedTransport(transport)
# Wrap in a protocol
protocol = TBinaryProtocol.TBinaryProtocol(transport)
# Create a client to use the protocol encoder
client = Hbase.Client(protocol)
# Connect!
transport.open()
return client
if __name__ == "__main__":
client = client_conn()
# r = client.getRowWithColumns('table name', 'row name', ['column name'])
# print(r[0].columns.get('column name')), type((r[0].columns.get('column name')))
result = client.getRow("table name","row name")
data_simple =[]
# print result[0].columns.items()
for k, v in result[0].columns.items(): #.keys()
#data.append((k,v))
# print type(k),type(v),v.value,,v.timestamp
data_simple.append((v.timestamp, v.value))
writer.writerows(data)
csvfile.close()
csvfile_simple = open("data_xy_simple.csv", "wb")
writer_simple = csv.writer(csvfile_simple)
writer_simple.writerow(["timestamp", "value"])
writer_simple.writerows(data_simple)
csvfile_simple.close()
print "finished"
会基础的python应该知道result是个list，result[0].columns.items()是一个dict 的键值对。可以查询相关资料。或者通过输出变量，观察变量的值与类型。
说明：上面程序中 transport.open()进行链接，在执行完后，还需要断开transport.close()
目前只涉及到读数据，之后还会继续更新其他dbase操作。
‘伍’ python使用thrift调用hbase拿到数据怎么处理
Row Key
Row key行键 (Row key)可以是任意字符串(最大长度是 64KB，实际应用中长度一般为 10-100bytes)，在hbase内部，row key保存为字节数组。
列族 (column family)
hbase表中的每个列，都归属与某个列族。列族是表的chema的一部分(而列不是)，必须在使用表之前定义。列名都以列族作为前缀。例如courses:history ， courses:math 都属于 courses 这个列族。
时间戳
HBase中通过row和columns确定的为一个存贮单元称为cell。每个 cell都保存着同一份数据的多个版本。版本通过时间戳来索引。时间戳的类型是 64位整型。时间戳可以由hbase(在数据写入时自动 )赋值，此时时间戳是精确到毫秒的当前系统时间。时间戳也可以由客户显式赋值。如果应用程序要避免数据版本冲突，就必须自己生成具有唯一性的时间戳。每个 cell中，不同版本的数据按照时间倒序排序，即最新的数据排在最前面。
为了避免数据存在过多版本造成的的管理 (包括存贮和索引)负担，hbase提供了两种数据版本回收方式。一是保存数据的最后n个版本，二是保存最近一段时间内的版本（比如最近七天）。用户可以针对每个列族进行设置。
对Hbase而言，表结构设计会对系统的性能以及开销上造成很大的区别;
‘陆’ 关于python利用thrift远程连接hive的问题
你起的thrift服务确定启好了吗 你先在服务器上看下IP端口是不是开了，而且IP不是Localhost的 如果好了远程肯定可以连上。
‘柒’ python程序怎样调用thrift服务
thrift服务在python中有自己的库，导入这个库，
然后用socket方式连接，
然后发送就可以了
下面是个例子
fromthrift.transportimportTTransport
fromthrift.transportimportTSocket
fromthrift.transportimportTSSLSocket
fromthrift.transportimportTHttpClient
fromthrift.protocolimportTBinaryProtocol
fromthrift.
host=“”
port=“”
ssl=“”
framed=“”#以上都是引入一些必要的包，还有声明一些变量
classworkbench_client(object):
def__init__(self,host,port,ssl,framed):
socket=TSSLSocket.TSSLSocket(host,port,validate=False)ifsslelseTSocket.TSocket(host,port)
self.transport=TTransport.TFramedTransport(socket)
protocol=TCompactProtocol.TCompactProtocol(self.transport)
self.client=AntispamWorkbench.Client(protocol)
self.transport.open()
print"transport.open"#init是初始化了与thrift服务连接的情况
defmatchOrderEntry(self,orderId,passengerId,driverIdList,data):
cnt=self.client.matchOrderEntry(orderId,passengerId,driverIdList,data)
print"startmatchOrderEntry"
printcnt#这个函数是示例，如何调用thrift接口
‘捌’ python连接hive，怎么安装thrifthive
HiveServer2的启动
启动HiveServer2
HiveServer2的启动十分简便：
$ $HIVE_HOME/bin/hiveserver2
或者
$ $HIVE_HOME/bin/hive --service hiveserver2
默认情况下，HiverServer2的Thrift监听端口是10000，其WEB UI端口是10002。可通过http://localhost:10002来查看HiveServer2的Web UI界面，这里显示了Hive的一些基本信息。如果Web界面不能查看，则说明HiveServer2没有成功运行。
使用beeline测试客户端连接
HiveServer2成功运行后，我们可以使用Hive提供的客户端工具beeline连接HiveServer2。
$ $HIVE_HOME/bin/beeline
beeline > !connect jdbc:hive2://localhost:10000
如果成功登录将出现如下的命令提示符，此时可以编写HQL语句。
0: jdbc:hive2://localhost:10000>
报错：User: xxx is not allowed to impersonate anonymous
在beeline使用!connect连接HiveServer2时可能会出现如下错误信息：
Caused by: org.apache.hadoop.ipc.RemoteException:
User: xxx is not allowed to impersonate anonymous
这里的xxx是我的操作系统用户名称。这个问题的解决方法是在hadoop的core-size.xml文件中添加xxx用户代理配置：
<property> <name>hadoop.proxyuser.xxx.groups</name> <value>*</value></property><property> <name>hadoop.proxyuser.xxx.hosts</name> <value>*</value></property>
重启HDFS后，再用beeline连接HiveServer2即可成功连接。
常用配置
HiveServer2的配置可以参考官方文档《Setting Up HiveServer2》
这里列举一些hive-site.xml的常用配置：
hive.server2.thrift.port：监听的TCP端口号。默认为10000。
hive.server2.thrift.bind.host：TCP接口的绑定主机。
hive.server2.authentication：身份验证方式。默认为NONE（使用 plain SASL），即不进行验证检查。可选项还有NOSASL, KERBEROS, LDAP, PAM and CUSTOM.
hive.server2.enable.doAs：是否以模拟身份执行查询处理。默认为true。
Python客户端连接HiveServer2
python中用于连接HiveServer2的客户端有3个：pyhs2，pyhive，impyla。官网的示例采用的是pyhs2，但pyhs2的官网已声明不再提供支持，建议使用impyla和pyhive。我们这里使用的是impyla。
impyla的安装
impyla必须的依赖包括：
six
bit_array
thriftpy(python2.x则是thrift)
sasl
thrift_sasl
- from impala.dbapi import connect
- conn = connect(host='127.0.0.1', port=10000, database='default', auth_mechanism='PLAIN')
- cur = conn.cursor()
- cur.execute('SHOW DATABASES')print(cur.fetchall())
- cur.execute('SHOW Tables')print(cur.fetchall())
为了支持Hive还需要以下两个包：
可在Python PI中下载impyla及其依赖包的源码。
impyla示例
以下是使用impyla连接HiveServer2的示例：
‘玖’ 为什么要用python thrift 服务端使用
这里的TestThriftService.Processor就是这里提到的Processor类，包括尖括号里面的接口TestThriftService.Iface也是由thrift编译器自动生成。
‘拾’ thrift struct怎么实现继承的效果
Apache Thrift 是一个跨语言的服务框架,本质上为RPC;当我们开发的service需要开放出去的时候,就会遇到跨语言调用的问题,JAVA语言开发了一个UserService用来提供获取用户信息的服务,如果服务消费端有PHP/Python/C++等,我们不可能为所有的语言都适配出相应的调用方式,有时候我们会很无奈的使用Http来作为访问协议;但是如果服务消费端不能使用HTTP,而且更加倾向于 以操作本地API的方式 来使用服务,那么我们就需要Thrift来提供支持.
本文以UserService为例,描述一下使用thrift的方式,以及其原理..
一. service.thrift
struct User{
1:i64 id,
2:string name,
3:i64 timestamp,
4:bool vip
}
service UserService{
User getById(1:i64 id)
}
二. 生成API文件
首先下载和安装thrift客户端,比如在windows平台下,下载thrift.exe,不过此处需要提醒,不同的thrift客户端版本生成的API可能不兼容.本例使用thrift-0.9.0.exe;通过"--gen"指定生成API所适配的语言.本实例为生成java客户端API.
//windows平台下,将API文件输出在service目录下(此目录需要存在)
> thrift.exe --gen java -o service service.thrift
三. UserService实现类
public class UserServiceImpl implements UserService.Iface {
@Override
public User getById(long id){
System.out.println("invoke...id:" + id);
return new User();//for test
}
}
四.原理简析
1. User.java : thrift生成API的能力还是非常的有限,比如在struct中只能使用简单的数据类型(不支持Date,Collection<?>等),不过我们能从User中看出,它生成的类实现了"Serializable"接口和"TBase"接口.
其中Serializable接口表明这个类的实例是需要序列化之后在网络中传输的,为了不干扰JAVA本身的序列化和反序列化机制,它还重写了readObject和writeObject方法.不过这对thrift本身并没有帮助.
TBase接口是thrift序列化和反序列化时使用的,它的两个核心方法:read和write.在上述的thrift文件中,struct定义的每个属性都有一个序号,比如:1:id,那么thrift在序列化时,将会根据序号的顺序依次将属性的"名称 + 值"写入inputStream中,反序列化也是如此.(具体参见read和write的实现).
因为thrift的序列化和反序列化实例数据时,是根据"属性序号"进行,这可以保证数据在inputstream和outputstream中顺序是严格的.这一点也要求API开发者,如果更改了thrift文件中的struct定义,需要重新生成客户端API,否则服务将无法继续使用(可能报错,也可能数据错误).thrift序列化/反序列化的过程和JAVA自带的序列化机制不同,它将不会携带额外的class结构,此外thrift这种序列化机制更加适合网络传输,而且性能更加高效.
2. UserService.Client: 在生成的UserService中,有个Client静态类,这个类就是一个典型的代理类,此类已经实现了UserService的所有方法.开发者需要使用Client类中的API方法与Thrift server端交互,它将负责与Thrift server的Socket链接中,发送请求和接收响应.