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鏈接中,發送請求和接收響應.