助力Greenplum數據庫開發之接口篇（上）——Golang，C、Python和Perl

時間 2021-06-16

標籤 html python git github 正則表達式 sql shell 數據庫編程 vim 欄目 SQL 简体版

原文原文鏈接

得到Greenplum更多幹貨內容，歡迎前往Greenplum中文社區網站
Greenplum 做爲一款強大的 HTAP 數據庫，針對大多數流行語言都有相應的鏈接庫。大部分均是與 PostgreSQL 採用相同的接口，可是也有部分接口是 Greenplum 專門優化後用於自身使用的。今天，咱們將給你們分享一系列語言接口的鏈接庫及使用方式。html

1. Golang

Golang 做爲 Google 開源的一款編譯型開發語言，通過多年發展，在開發界佔據了很大的份額，市面上針對 Greenplum 的 Golang 鏈接庫也有不少，可是最著名的仍是 github.com/lib/pq。python

Golang 爲鏈接數據庫專門提供了一個公共包叫 database/sql，在進行數據庫鏈接時，只須要遵循該庫的註冊方式將 lib/pq（https://github.com/lib/pq）註冊爲 postgres 驅動便可。git

支持列表

目前該包支持全系列 Greenplum 產品，提供的一些功能以下：github

支持數據庫增刪改查
支持在數據庫中直接執行DDL或維護語句（VACUUM等）
支持全部普通數據類型
支持 bytea
支持 hstore
支持 SSL
支持 COPY FROM
支持 pgpass

安裝方法

與其餘的 Go 包安裝方式同樣，只須要在 go/src 目錄下執行 go get 命令便可將須要的包下載。go get github.com/lib/pq 若是網絡條件有限，不能直接 go get 聯網下載，也能夠直接在外網機器上用 go get 或者 git 下載好，而後將代碼複製到對應格式的目錄下（放到 go 文件夾下的 src 文件夾下的 github.com 文件夾下的 lib 文件夾下的 pq 下）。正則表達式

使用方法

下面展現一段 Golang 鏈接數據庫查詢的代碼，進行簡單分析。sql

package main

import (
    "database/sql"
    "fmt"
    _ "github.com/lib/pq"
    "log"
)

func main() {
    db, err := sql.Open("postgres", "user=chris password=123 dbname=postgres host=127.0.0.1 port=5432 sslmode=disable")
    if err != nil {
        log.Fatal(err)
    }
    defer db.Close()

    //查詢數據
    rows, err := db.Query("select version()")

    for rows.Next() {
        var version string
        rows.Scan(&version)
        fmt.Println(version)
    }
}

從上面代碼能夠看到，咱們須要首先導入 database/sql 和 lib/pq 兩個包。shell

import ("database/sql""fmt"_ "github.com/lib/pq""log")注意這裏在導入 lib/pq 時，前面加了下劃線（_），由於一般來講，不直接使用驅動所提供的方法，而是應該使用 database 中的 sql.DB，所以在導入 lib/pq 驅動時，這裏使用了匿名導入的方式(在包路徑前添加 _)，當導入了一個數據庫驅動後，此驅動會自行初始化並註冊本身到 Golang 的 database/sql 上下文中，所以咱們就能夠經過 database/sql 包提供的方法訪問數據庫了。數據庫

database/sql 默認提供了 MySQL、PostgreSQL 和 SQLite 的支持，不須要手工註冊。編程

接下來就是在函數中構造鏈接 url 而後進行查詢了vim

如下就是具體的鏈接使用邏輯，一般的邏輯通常爲：

打開數據庫鏈接
執行增刪改查操做
掃描結果集而後處理（查詢操做）
錯誤處理
關閉數據庫鏈接數據源的鏈接字符串一般拼接成「user=chris password=123
dbname=postgres host=127.0.0.1 port=5432 sslmode=disable」的形式，字符串中分別對應了 Greenplum 數據庫的用戶名、密碼、數據庫名、主機ip、Greenplum 端口號和 sslmode。

db, err := sql.Open("postgres", "user=chris password=123 dbname=postgres host=127.0.0.1 port=5432 sslmode=disable")
除了上面的數據源鏈接串形式，也能夠下面這種方式鏈接（不太經常使用，做用是同樣的）：「postgres://chris:password@127.0.0.1:5432/postgres?sslmode=verify-full」。

數據庫的操做支持開發語言中常見的兩種處理方式：

直接查詢
prepare statement

下面給你們展現全部可能涉及的增刪改查操做的語法，能夠直接在數據庫中測試使用。

package main

import (
    "database/sql"
    "fmt"
    _ "github.com/lib/pq"
    "time"
)

var db *sql.DB

func sqlOpen() {
    var err error
    db, err = sql.Open("postgres", "user=gpadmin password=123 dbname=postgres host=172.16.142.191 port=5432 sslmode=disable")
    //port是數據庫的端口號，默認是5432，若是改了，這裏必定要自定義；
    //user就是你數據庫的登陸賬號;
    //dbname就是你在數據庫裏面創建的數據庫的名字;
    //sslmode就是安全驗證模式;
    checkErr(err)

}

func sqlCreate() {
    //建立表
    _, err := db.Exec("drop table t_user")
    checkErr(err)
    _, err1 := db.Exec("create table t_user(uname text,dptname text,create_time timestamp)")
    checkErr(err1)
}

func sqlInsert() {
    //插入數據
    stmt, err := db.Prepare("INSERT INTO t_user(uname,dptname,create_time) VALUES($1,$2,$3)")
    checkErr(err)

    _, err = stmt.Exec("chris", "軟件1部", "2020-01-08")
    //這裏的三個參數就是對應上面的$1,$2,$3了

    checkErr(err)
}

func sqlDelete() {
    //刪除數據
    stmt, err := db.Prepare("delete from t_user where uname=$1")
    checkErr(err)

    res, err := stmt.Exec("chris")
    checkErr(err)

    affect, err := res.RowsAffected()
    checkErr(err)

    fmt.Println("rows affect:", affect)
}

func sqlSelect() {
    //查詢數據
    rows, err := db.Query("SELECT * FROM t_user")
    checkErr(err)

    println("-----------")
    for rows.Next() {
        var uname string
        var dptname string
        var create_time string
        err = rows.Scan(&uname, &dptname, &create_time)
        checkErr(err)
        fmt.Println( "name = ", uname, "\ndep = ", dptname, "\ncreated = ", create_time, "\n")
    }
}

func sqlUpdate() {
    //更新數據
    stmt, err := db.Prepare("update t_user set dptname=$1 where uname=$2")
    checkErr(err)

    res, err := stmt.Exec("軟件1部","jenny")
    checkErr(err)

    affect, err := res.RowsAffected()
    checkErr(err)

    fmt.Println("rows affect:", affect)
}
func sqlClose() {
    db.Close()
}

func checkErr(err error) {
    if err != nil {
        panic(err)
    }
}

func main() {
    sep := "----------\n"
    sqlOpen()
    println(sep, "*sqlOpen")

    sqlCreate()
    println(sep, "*sqlCreate")
    time.Sleep(time.Second*2)

    sqlSelect()
    println(sep, "*sqlSelect")
    time.Sleep(time.Second*2)

    sqlInsert()
    sqlSelect()
    println(sep, "*sqlInsert")
    time.Sleep(time.Second*5)

    sqlUpdate()
    sqlSelect()
    println(sep, "*sqlUpdate")
    time.Sleep(time.Second*2)

    sqlDelete()
    sqlSelect()
    println(sep, "*sqlDelete")
    time.Sleep(time.Second*2)

    sqlClose()
    println(sep, "*sqlClose")
}

2. C語言

C語言是比較偏基礎的語言，如今大多數開發人員可能不怎麼會用C語言進行開發。可是在2020年1月份發佈的2019年度編程語言（
https://www.tiobe.com/tiobe-i... ）中，C語言打敗衆多對手，王者歸來，足見C語言的地位。

也確實如上所說，C語言可能影響到軟件開發的方方面面，但並不必定爲你我所熟知。在 PostgreSQL/Greenplum 領域中，libpq 是 PostgreSQL/Greenplum 的C應用程序接口，這個C接口同時也是 C++、Perl、Python、Tcl 和 ECPG 應用接口的驅動引擎。今天就來簡單看看這個C接口是如何使用的。

示例

能夠將以下代碼編輯到 gpadmin 用戶下的 testlibpq.c 文件中，下面會介紹簡單的編譯和使用

/*
 * src/test/examples/testlibpq.c
 * testlibpq.c
 *      注意：下面須要引入libpq-fe.h頭文件
 */
#include <stdio.h>
#include <stdlib.h>
#include "libpq-fe.h"

static void
exit_nicely(PGconn *conn)
{
    PQfinish(conn);
    exit(1);
}

int
main(int argc, char **argv)
{
    const char *conninfo;
    PGconn     *conn;
    PGresult   *res;
    int         nFields;
    int         i,
                j;

    /* 
     * 若是用戶在命令行定義了參數，那麼這裏解析爲conninfo，做爲鏈接參數；
     * 若是沒有定義，則會選用環境變量定義的鏈接參數或採用默認值。
     */
    if (argc > 1)
        conninfo = argv[1];
    else
        conninfo = "dbname = postgres";

    /* 建立一個數據庫鏈接 */
    conn = PQconnectdb(conninfo);

    /* 檢查鏈接是否成功開啓 */
    if (PQstatus(conn) != CONNECTION_OK)
    {
        fprintf(stderr, "Connection to database failed: %s",
                PQerrorMessage(conn));
        exit_nicely(conn);
    }

    /* Set always-secure search path, so malicious users can't take control. */
    res = PQexec(conn,
                 "SELECT pg_catalog.set_config('search_path', '', false)");
    if (PQresultStatus(res) != PGRES_TUPLES_OK)
    {
        fprintf(stderr, "SET failed: %s", PQerrorMessage(conn));
        PQclear(res);
        exit_nicely(conn);
    }

    /*
     * 當完成操做後，執行清理操做，避免內存泄漏。
     */
    PQclear(res);

    /*
     * Our test case here involves using a cursor, for which we must be inside
     * a transaction block.  We could do the whole thing with a single
     * PQexec() of "select * from pg_database", but that's too trivial to make
     * a good example.
     */

    /* 開始一個事務塊 */
    res = PQexec(conn, "BEGIN");
    if (PQresultStatus(res) != PGRES_COMMAND_OK)
    {
        fprintf(stderr, "BEGIN command failed: %s", PQerrorMessage(conn));
        PQclear(res);
        exit_nicely(conn);
    }
    PQclear(res);

    /*
     * 從pg_database表中獲取數據
     */
    res = PQexec(conn, "DECLARE myportal CURSOR FOR select * from pg_database");
    if (PQresultStatus(res) != PGRES_COMMAND_OK)
    {
        fprintf(stderr, "DECLARE CURSOR failed: %s", PQerrorMessage(conn));
        PQclear(res);
        exit_nicely(conn);
    }
    PQclear(res);

    res = PQexec(conn, "FETCH ALL in myportal");
    if (PQresultStatus(res) != PGRES_TUPLES_OK)
    {
        fprintf(stderr, "FETCH ALL failed: %s", PQerrorMessage(conn));
        PQclear(res);
        exit_nicely(conn);
    }

    /* 打印列名 */
    nFields = PQnfields(res);
    for (i = 0; i < nFields; i++)
        printf("%-15s", PQfname(res, i));
    printf("\n\n");

    /* 打印數據 */
    for (i = 0; i < PQntuples(res); i++)
    {
        for (j = 0; j < nFields; j++)
            printf("%-15s", PQgetvalue(res, i, j));
        printf("\n");
    }

    PQclear(res);

    /* 關閉上面定義的cursor */
    res = PQexec(conn, "CLOSE myportal");
    PQclear(res);

    /* end the transaction */
    res = PQexec(conn, "END");
    PQclear(res);

    /* 關閉數據庫鏈接 */
    PQfinish(conn);

    return 0;
}

編譯

[gpadmin@gp1 ~]$ gcc -I /usr/local/greenplum-db/include/ -L /usr/local/greenplum-db/lib -lpq testlibpq.c -o testlibpq
這裏採用 gcc 編譯器，指定頭文件(-I)和庫文件(-L)，編譯完成後，會生成二進制可執行文件 testlibpq。

「實戰」助力數據庫開發之接口篇 - C 鏈接 Greenplum
運行此時能夠執行該文件，查看是否能正常訪問數據庫。

[gpadmin@gp1 ~]$ ./testlibpq
datname datdba encoding datcollate datctype datistemplate datallowconn datconnlimit datlastsysoid datfrozenxid datminmxid dattablespace datacl

template1 10 6 en_US.utf8 en_US.utf8 t t -1 12813 725 1 1663 {=c/gpadmin,gpadmin=CTc/gpadmin}
template0 10 6 en_US.utf8 en_US.utf8 t f -1 12813 725 1 1663 {=c/gpadmin,gpadmin=CTc/gpadmin}
postgres 10 6 en_US.utf8 en_US.utf8 t t -1 12813 725 1 1663
上面代碼採用默認的鏈接信息，若是要特別指定，能夠經過定義以下字符串信息來訪問數據庫。

[gpadmin@gp1 ~]$ ./testlibpq "host=172.16.142.191 port=5432 user=gpadmin dbname=postgres"
datname datdba encoding datcollate datctype datistemplate datallowconn datconnlimit datlastsysoid datfrozenxid datminmxid dattablespace datacl

template1 10 6 en_US.utf8 en_US.utf8 t t -1 12813 725 1 1663 {=c/gpadmin,gpadmin=CTc/gpadmin}
template0 10 6 en_US.utf8 en_US.utf8 t f -1 12813 725 1 1663 {=c/gpadmin,gpadmin=CTc/gpadmin}
postgres 10 6 en_US.utf8 en_US.utf8 t t -1 12813 725 1 1663
在嘗試鏈接過程當中，可能會報以下錯誤，此時須要修改 pg_hba.conf 文件並 gpstop -u 生效便可。

[gpadmin@gp1 ~]$ ./testlibpq
Connection to database failed: FATAL: no pg_hba.conf entry for host "[local]", user "gpadmin", database "postgres", SSL off

參考文章

[1] https://www.postgresql.org/do...

3. Python

如今咱們再來看一下，在這幾年火的一塌糊塗的 Python 語言如何鏈接 Greenplum。

Python 鏈接 Greenplum 數據庫較經常使用的庫有 PyGreSQL 和 Psycopg2 兩個。Greenplum 的不少腳本都是採用 PyGreSQL 爲基礎開發的，可見 PyGreSQL 確定有其獨到之處，可是 Psycopg2 這幾年彷佛在 Postgres 體系中更加流行。本文將會分別介紹這兩個庫的使用。

PyGreSQL

PyGreSQL 是鏈接 PostgreSQ L的 Python 庫，目前最新版本爲 PyGreSQL 5.1，支持 PostgreSQL 9.0到11版本，能夠對應到 Greenplum 6.x 的版本，若是要支持 Greenplum 4.x 和 5.x 版本，能夠選用 PyGreSQL 4.x 版本。

安裝

pip install PyGreSQL

示例

#!/usr/bin/env python

import pg


def operate_postgre_tbl_product():
    try:
        #pgdb_conn = pg.connect(dbname = 'tpc', host = '192.168.103.31', user = 'gpadmin', passwd = '')
        pgdb_conn = pg.connect("host=192.168.103.31 port=5432 dbname=tpc user=gpadmin")

    except Exception, e:
         print e.args[0]
         return


    sql_desc = "select * from call_center limit 5;"
    for row in pgdb_conn.query(sql_desc).dictresult():
        print row


    pgdb_conn.close()


if __name__ == '__main__':
    operate_postgre_tbl_product()

參考文章

http://www.pygresql.org/about...

Psycopg2

Psycopg2 庫的底層是由C語言封裝 PostgreSQL 的標準庫C接口庫 libpq 實現的，運行速度很是快，它支持大型多線程應用的大量併發 Insert 和 Update 操做，另外它徹底兼容 DB API 2.0。

安裝

pip install psycopg2

示例

一、簡單的增長，查詢記錄

import psycopg2
import psycopg2.extras
import time
 
'''
    鏈接數據庫
    returns:db
'''
def gp_connect():
    try:
        db = psycopg2.connect(dbname="testdb",
                              user="gpadmin",
                              password="gpadmin",
                              host="10.1.208.42",
                              port="5432")
        # connect()也可使用一個大的字符串參數,
        # 好比」host=localhost port=5432 user=postgres password=postgres dbname=test」
        return db
    except psycopg2.DatabaseError as e:
        print("could not connect to Greenplum server",e)
 
 
if __name__ == '__main__':
    conn = gp_connect()
    print(conn)
    cur = conn.cursor(cursor_factory=psycopg2.extras.RealDictCursor)
    # 這裏建立的是一個字典Cursor, 這樣返回的數據, 都是字典的形式, 方便使用
    ret = cur.execute("CREATE TABLE public.gp_test (id serial PRIMARY KEY, num integer, data varchar);")
    conn.commit()
    # 提交到數據庫中
    print(ret)
    ret = cur.execute("INSERT INTO public.gp_test (num, data) VALUES (%s, %s);",(300, "abc'def"))
 
    conn.commit()
    # 提交到數據庫中
    print(cur.rowcount)  # 1
    # 返回數據庫中的行的總數已修改，插入或刪除最後 execute*().
 
    ret_sql = cur.mogrify("select * from pg_tables where tablename = %s;", ('gp_test',))
    # 返回生成的sql腳本, 用以查看生成的sql是否正確.
    # sql腳本必須以;結尾, 不能夠省略.其次, 無論sql中有幾個參數, 都須要用 % s代替, 只有 % s, 無論值是字符仍是數字, 一概 % s.
    # 最後, 第二個參數中, 必定要傳入元組, 哪怕只有一個元素, 像我剛纔的例子同樣, ('gp_test')這樣是不行的.
    print(ret_sql.decode('utf-8'))  # select * from pg_tables where tablename = E'gp_test';
 
    cur.execute("select * from gp_test where num = %s;", (300,))
    pg_obj = cur.fetchone()
    print(pg_obj) # {'id': 1, 'num': 300, 'data': "abc'def"}
 
    conn.close() # 關閉鏈接

二、批量插入，查詢

conn = gp_connect()
print(conn)
cur = conn.cursor(cursor_factory=psycopg2.extras.RealDictCursor)
# # 這裏建立的是一個字典Cursor, 這樣返回的數據, 都是字典的形式, 方便使用
# ret = cur.execute("CREATE TABLE public.gp_test (id serial PRIMARY KEY, num integer, data varchar);")
# conn.commit()
# # 提交到數據庫中
# print(ret)
gp_list = []
for i in range(200):
    gp_list.append((i,'abc%s'%i))
# print(gp_list)
# 批量提交數據
ret = cur.executemany("INSERT INTO public.gp_test (num, data) VALUES (%s, %s);", gp_list)
conn.commit()
# 提交到數據庫中
print(cur.query)  # 查看上一條執行的腳本
print(cur.rowcount)  # 200
# 返回數據庫中的行的總數已修改，插入或刪除最後 execute*().
cur.execute("select  count(*) num from gp_test")
pg_obj = cur.fetchone()
print(pg_obj)  # {'num': 200}
 
conn.close()  # 關閉鏈接

三、使用鏈接池，執行高性能的批量插入與查詢

import psycopg2
import psycopg2.extras
import psycopg2.pool
from datetime import datetime
 
'''
    鏈接數據庫
    使用數據庫鏈接池
    returns:db
'''
def gp_connect():
    try:
        simple_conn_pool = psycopg2.pool.SimpleConnectionPool(minconn=1, maxconn=5,dbname="testdb",
                              user="gpadmin",
                              password="gpadmin",
                              host="10.1.208.42",
                              port="5432")
        # connect()也可使用一個大的字符串參數,
        # 好比」host=localhost port=5432 user=postgres password=postgres dbname=test」
        # 從數據庫鏈接池獲取鏈接
        conn = simple_conn_pool.getconn()
        return conn
    except psycopg2.DatabaseError as e:
        print("could not connect to Greenplum server",e)
 
 
if __name__ == '__main__':
    conn = gp_connect()
    print(conn)
    cur = conn.cursor()
    # 批量查詢大小
    batch_size = 1000
    gp_list = []
    for i in range(2000, 100000):
        gp_list.append((i,'abc%s'%i))
    # print(gp_list)
 
    # 開始時間
    start_time = datetime.now()
    # 批量提交數據execute_values性能大於executemany
    psycopg2.extras.execute_values(cur, "INSERT INTO public.gp_test (num, data) VALUES %s", gp_list)
    conn.commit()
    # 提交到數據庫中
    cur.execute("select  *  from gp_test order by id")
    count = 0
 
    while True:
        count = count + 1
        # 每次獲取時會從上次遊標的位置開始移動size個位置，返回size條數據
        data = cur.fetchmany(batch_size)
        # 數據爲空的時候中斷循環
        if not data:
            break
        else:
            print(data[-1])  # 獲得最後一條(經過元祖方式返回)
        print('獲取%s到%s數據成功' % ((count - 1) * batch_size, count * batch_size))
    print('insert到fetchmany獲取全量數據所用時間:', (datetime.now() - start_time).seconds) # 16s
conn.close()  # 關閉鏈接

四、執行高性能的批量更新與查詢

import psycopg2
import psycopg2.extras
import psycopg2.pool
from datetime import datetime

'''
    鏈接數據庫
    使用數據庫鏈接池
    returns:db
'''
def gp_connect():
    ……略

if __name__ == '__main__':
    conn = gp_connect()
    print(conn)
    cur = conn.cursor()
    # 批量查詢大小
    batch_size = 1000
    gp_uplist = [] # 更新列表
    for i in range(2000, 10000):
        gp_uplist.append((i,'def%s'%i))
    print(gp_uplist)

    # 開始時間
    start_time = datetime.now()
    # 批量提交數據execute_values性能大於executemany

    sql = "UPDATE public.gp_test SET data = TEST.data  " \
          "FROM (VALUES %s) AS TEST(num, data) " \
          "WHERE public.gp_test.num = TEST.num"
    # 批量更新語句模版 UPDATE TABLE SET TABLE.COL = XX.col
    # FROM (VALUES %s) AS XX(id_col,col)
    # WHERE TABLE.id_col = XX.id_col 
    # XX爲別名
    psycopg2.extras.execute_values(cur, sql, gp_uplist, page_size=100)
    print(cur.query)
    conn.commit()
    # 提交到數據庫中
    cur.execute("select  *  from gp_test order by id")
    count = 0

    while True:
        count = count + 1
        # 每次獲取時會從上次遊標的位置開始移動size個位置，返回size條數據
        data = cur.fetchmany(batch_size)
        # 數據爲空的時候中斷循環
        if not data:
            break
        else:
            print(data[-1])  # 獲得最後一條(經過元祖方式返回)
        print('獲取%s到%s數據成功' % ((count - 1) * batch_size, count * batch_size))
    print('update到fetchmany獲取全量數據所用時間:', (datetime.now() - start_time).seconds) # 16s
conn.close()  # 關閉鏈接

五、使用服務端遊標

#1 逐條處理
with psycopg2.connect(database_connection_string) as conn:
    with conn.cursor(name='name_of_cursor') as cursor:

        cursor.itersize = 20000

        query = "SELECT * FROM ..."
        cursor.execute(query)

        for row in cursor:
         # process row

#2 一次處理多條
while True:
    rows = cursor.fetchmany(100)
    if len(rows) > 0:
        for row in rows:
            # process row
    else:
        break

參考文章

http://initd.org/psycopg/docs...
https://www.cnblogs.com/xiao-...

4. Perl

Perl 是一種功能豐富的計算機編程語言。借取了 C、sed、awk、shell 腳本語言以及不少其餘程序語言的特性，其中最重要的特性是它內部集成了正則表達式的功能。它就像 C 同樣強大，像 awk、sed 等腳本描述語言同樣方便，被 Perl 語言愛好者稱之爲「一種擁有各類語言功能的夢幻腳本言」、「Unix中的王牌工具」。

Perl 語言鏈接 Greenplum 也是經過底層 C 接口 libpq 進行交互，若是咱們要使用 Perl 作數據庫交互，首先咱們須要安裝 Perl 的數據庫標準模塊 Perl DBI，而後再安裝相應的 DBD 驅動，這裏鏈接 Greenplum 採用的是 DBD::pg (
https://metacpan.org/pod/DBD::Pg ) 模塊。

安裝

這裏採用較爲簡單的 RPM 安裝方式。

rpm -ivh postgresql-libs-9.2.24-1.el7_5.x86_64.rpm
rpm -ivh perl-DBI-1.627-4.el7.x86_64.rpm
rpm -ivh perl-version-0.99.07-3.el7.x86_64.rpm
rpm -ivh perl-DBD-Pg-2.19.3-4.el7.x86_64.rpm

Perl 鏈接 Greenplum

鏈接總體比較簡單，DBI驅動已經將鏈接方式抽象爲易於理解的格式，下面經過幾個例子來展現，讀者能夠關注如何配置鏈接方式、如何建立鏈接、如何增刪改查等操做。

示例

一、建表

該示例主要演示鏈接字符串定義，數據庫鏈接打開關閉幾在數據庫中建立表。

#!/usr/bin/perl

use DBI;
use strict;

my $driver   = "Pg";
my $database = "postgres";
my $dsn = "DBI:$driver:dbname=$database;host=172.16.142.192;port=5432";
my $userid = "gpadmin";
my $password = "gpadmin";
my $dbh = DBI->connect($dsn, $userid, $password, { RaiseError => 1 })
                      or die $DBI::errstr;
print "Opened database successfully\n";
my $stmt = qq(CREATE TABLE TC(ID INT, NAME TEXT););
my $rv = $dbh->do($stmt);
if($rv < 0){
   print $DBI::errstr;
} else {
   print "Table created successfully\n";
}
$dbh->disconnect();

執行結果以下：

[root@gp1 ~]# ./create.pl
Opened database successfully
NOTICE:  Table doesn't have 'DISTRIBUTED BY' clause -- Using column named 'id' as the Greenplum Database data distribution key for this table.
HINT:  The 'DISTRIBUTED BY' clause determines the distribution of data. Make sure column(s) chosen are the optimal data distribution key to minimize skew.
Table created successfully

二、插入數據

#!/usr/bin/perl

use DBI;
use strict;

my $driver   = "Pg";
my $database = "postgres";
my $dsn = "DBI:$driver:dbname=$database;host=172.16.142.192;port=5432";
my $userid = "gpadmin";
my $password = "gpadmin";
my $dbh = DBI->connect($dsn, $userid, $password, { RaiseError => 1 })
                      or die $DBI::errstr;
print "Opened database successfully\n";

my $stmt = qq(INSERT INTO TC (ID,NAME)
      VALUES (1, 'Chris'));
my $rv = $dbh->do($stmt) or die $DBI::errstr;

$stmt = qq(INSERT INTO TC (ID,NAME)
      VALUES (2, 'Jenny'));
$rv = $dbh->do($stmt) or die $DBI::errstr;

print "Records created successfully\n";
$dbh->disconnect();

執行結果以下：

[root@gp1 ~]# vim insert.pl
[root@gp1 ~]# chmod +x insert.pl
[root@gp1 ~]# ./insert.pl
Opened database successfully
Records created successfully

三、查詢數據

!/usr/bin/perl

use DBI;
use strict;

my $driver   = "Pg";
my $database = "postgres";
my $dsn = "DBI:$driver:dbname=$database;host=172.16.142.192;port=5432";
my $userid = "gpadmin";
my $password = "gpadmin";
my $dbh = DBI->connect($dsn, $userid, $password, { RaiseError => 1 })
                      or die $DBI::errstr;
print "Opened database successfully\n";

my $stmt = qq(SELECT id, name from TC;);
my $sth = $dbh->prepare( $stmt );
my $rv = $sth->execute() or die $DBI::errstr;
if($rv < 0){
   print $DBI::errstr;
}
while(my @row = $sth->fetchrow_array()) {
      print "ID = ". $row[0] . "\n";
      print "NAME = ". $row[1] ."\n";
}
print "Operation done successfully\n";
$dbh->disconnect();

執行結果以下：

[gpadmin@gp1 ~]$ vim select.pl
[gpadmin@gp1 ~]$ chmod +x select.pl
[gpadmin@gp1 ~]$ ./select.pl
Opened database successfully
ID = 2
NAME = Jenny
ID = 1
NAME = Chris
Operation done successfully

有關修改和刪除的操做，基本與上面例子一致，只須要將代碼中 qq() 中的內容替換爲 DELETE 和 UPDATE 語句便可。