python 操作 postgresql 数据库

本是古典何须时尚 2021-09-01 04:40 535阅读 0赞

**目录**

一 简介

历史

描述

特征

函数

索引

触发器

多版本并发控制

规则

数据类型

用户定义对象

二 数据库连接

2.1 安装 psycopg2

2.2 连接数据库

三 创建表

四 插入操作

4.1 插入数据姿势一

4.2 插入数据姿势二（参数分离）

4.3 插入数据姿势三（字典）

五 查询操作

5.1 查询一条数据

5.2 查询多条数据

5.3 查询全部数据

5.4 按条件查询

六 更新操作

七 删除操作

八 异常处理

九 打印sql

十 获取总条数

十一显示行号

十二 显示执行参数

十三 附录

--------------------

# 一 简介 #

**PostgreSQL** 是一个自由的对象-关系数据库服务器（数据库管理系统），它在灵活的 BSD-风格许可证下发行。它在其他开放源代码数据库系统（比如 MySQL 和 Firebird），和专有系统比如 Oracle、Sybase、IBM 的 DB2 和 Microsoft SQL Server之外，为用户又提供了一种选择。

PostgreSQL 不寻常的名字导致一些读者停下来尝试拼读它，特别是那些把SQL拼读为"sequel"的人。PostgreSQL 开发者把它拼读为 "post-gress-Q-L"。（Audio sample，5.6k MP3）。它也经常被简略唸为 "postgres"。

## 历史 ##

PostgreSQL 经历了长时间的演变，开始于在 UC Berkeley 的 Ingres 计划。这个计划的领导者 Michael Stonebraker 在1982年离开 Berkeley 去商业化 Ingres，但是最后还是返回了学术界。在1985年返回 Berkeley 之后，Stonebraker 开始了 post-Ingres 计划来致力于在 1980 年代早期变得日益清楚的、当代数据库系统的问题。Postgres 和 Ingres 的代码库开始（并保持）完全分离了。

结果的计划叫 **Postgres**，目标是介入增加对类型的完全支持所需要的最小数目的特征。这些特征包括定义类型的能力，还有完全描述至今广泛使用但由用户完全维护着的联系的能力。在 Postgres 中数据库"理解"联系，并可以使用*规则*以自然的方式在有关的表中检索信息。

从1986年开始项目组发表了一些描述系统基本原理的论文，并在1988年这项计划建成并运行了一个原型版本。项目组在1989年六月向少数用户发行了版本 1，随后在1990年六月发行了带有重写后的规则系统的版本 2。1991年的版本 3 再次重写了规则系统，并增加了对多个存储管理器和改进的查询引擎的支持。在1993年就有大量的用户存在了，并开始用对支持和特征的要求淹没这个计划。在发行了主要作为最后清理的版本 4 之后计划就终止了。

尽管 Postgres 计划正式的终止了，BSD许可证（Berkeley 在其下发行的 Postgres）确使开放源代码开发者获得复本并进一步开发系统。在1994年两个 UC Berkeley 大学的研究生，Andrew Yu 和 Jolly Chen，增加了一个 SQL 语言解释器来替代早先的基于 Ingres 的 QUEL 系统，建立了 Postgres95。代码随后被发行到 web 上来在世界上找寻它自己的出路。在1996年计划被重命名了：为了反映数据库的新 SQL 查询语言，Postgres95 变成了PostgreSQL。

第一次 PostgreSQL 发行形成了版本 6.0。随后来自世界各地的一组数据库开发者和志愿者，通过 Internet 协作起来，维护着这套软件。自从版本 6.0 之后，出现了很多后续发行，在系统中也出现了很多改进；在 2005年1月19日，版本 8.0 成为当前发行。由8.0后，PostgreSQL以原生（Native）的方式，执行于Windows视窗系统。

尽管许可证允许 Postgres 的商业化，Postgres 代码没有像 Ingres 那样快速的被商业开发-- 考虑到 Postgres 提供的好处这有些令人惊奇。主要分支起源于 Paula Hawthorn（从 Ingres 转移来的最初的 Ingres 项目组成员）和 Michael Stonebraker 组建 Illustra 信息技术公司来商业化 Postgres 的时候。

在 2005 年一月，PostgresQL 收到了它来自数据库厂商的第一份援助。Pervasive Software（\[1\]）宣布了商业支持和社区参与。

2000年，前Red Hat投資者籌組了一間名為 Great Bridge的公司來商業化PostgreSQL，以和其他商用資料庫廠商競爭。Great Bridge資助了好幾位PostgreSQL開發者，並且貢獻回饋了許多資源給社群。然而到了2001年末，Great Bridge終止了營運，因為像是Red Hat...等等公司面臨了嚴酷的競爭，且市場狀況不佳。

2001年，Command Prompt, Inc.釋出了Mammoth PostgreSQL，最老牌的Postgresql商業套件。他們透過對開發者的贊助和對如同 PL/Perl、PL/php、維護PostgreSQL Build Farm ...等等方式來支援PostgreSQL社群。

2005年1月，PostgreSQL接到了來自另一間資料庫廠商Pervasive Software的支持，他們以十分常見於Novell NetWare平台的Btrieve產品而聞名。他們宣布了進行商業支援和對社群的參與。在他們得到成功一段時間後的2006年7月， Pervasive Software離開了PostgreSQL的支援市場。

在2005年中，兩間其他的公司宣佈商業化PostgreSQL，分別進入不同的利基市場。EnterpriseDB宣布將專注於讓使用 Oracle的應用程式能更容易的在 PostgreSQL上運行。Greenplum則專注貢獻在資料倉儲和商業智慧的應用程式，尤其以BizGres專案著稱。

2005年10月， 昇陽的軟體部門執行副總裁John Loiacono談論到："我們不會去OEM微軟的產品，我們正關注著 PostgreSQL"，儘管當時並沒有任何規格釋出。到了2005年11月，昇陽宣布將支援 PostgreSQL。2006年6月，Solaris 10包含PostgreSQL一起發佈。

至於 PostgreSQL專案本身，他繼續著每年一個主要版本發佈，以及次要的除錯版本發佈，全都可以在BSD授權底下取得。這些都是基於商業化廠商、支援公司、和開放源碼駭客。

## 描述 ##

如果很粗略地观察 PostgreSQL，会觉得这个数据库系统和其它数据库很类似。因为 PostgreSQL 使用 SQL 语言来在执行资料的查询。这些资料通过连外键联系在一起，以一系列表格的形式存在。PostgreSQL 相对于竞争者的主要优势，主要的特征为*可编程性*：对于使用数据库资料的实际应用，PostgreSQL 让开发与使用的工作，变得更加容易。

SQL 数据在"平面表格"中存储简单的数据类型，需要用户使用查询把有关的信息收集在一起。这与应用和用户利用数据自身的方式相对立：典型的使用带有丰富数据类型的高级语言，在其中所有有关的数据作为它自己的一个完整单元来操作。典型的称呼为*记录*或*对象*（依据各自语言）。

转换来自 SQL 世界的信息到面向对象编程世界体现得很困难，因为两者有非常不同的数据组织的模型。工业界把这个问题称为阻抗不匹配：从一个模型映射到另一个要花费项目开发者 40% 的时间。一些映射解决方案，典型的称为对象-关系映射，致力于这个问题，但是它们花费很多并有自身的问题，导致糟糕的性能或强制所有的数据访问通过映射所支持的一种语言来进行。

PostgreSQL 可以直接在数据库中解决很多这种问题。PostgreSQL 允许用户定义基于正规的 SQL 类型的新类型，允许数据库自身理解复杂数据。例如，你可以定义一个 `address` 来组合一些事物如街道编号、城市和国度的字符串。从这一点上你可以轻易的建立把保存地址的所需要的所有字段包含在一个单一行列中的表。

PostgreSQL 还允许类型包括继承，这是在面向对象编程中的主要概念。例如，你可以定义 `post_code` 类型，并接着基于它建立 `us_zip_code` 和 `canadian_postal_code`。在数据库中的 address 就可以采用 `us_address` 或者 `canadian_address` 形式，而特定的规则可以在各自情况下验证数据。在 PostgreSQL 的早期版本中，实现新类型需要写 C 扩展并把它们编译到数据库服务器中；在版本 7.4 中，通过 `CREATE DOMAIN` 建立和使用定制类型变得很容易了。

数据库自身的编程可以从使用*函数*上获得巨大的利益。多数 SQL 系统允许用户写*存储过程*，它是其他 SQL 语句可以调用的一块 SQL 代码。但是 SQL 自身仍旧不适合作为编程语言，而且 SQL 用户在构造复杂逻辑时要经历巨大的困难。更糟糕的是，SQL 自身不支持很多的编程语言中最基本的操作，比如分支和循环。每个厂商都转而写它们自己对 SQL 语言的扩展来增加这些特征，而这种扩展不是必须跨越数据库平台操作。

在 PostgreSQL 中程序员可以用一组可观的支持语言中任何一种来写这种逻辑。

*  类似于 Oracle 的过程语言 PL/SQL 的叫做 PL/PgSQL 的内置语言，在处理查询密集的过程时提供了独特的优势。
 *  流行脚本语言比如 Perl，Python，Tcl，和 Ruby 的包装器，允许利用它们在字符串处理和连接到广阔的外部函数库的力量。
 *  需要把复杂逻辑编译到机器代码所能提供的高性能的过程可以利用 C 或 C++。
 *  在更加深奥的方面，R 统计语言的处理器允许数据库查询利用它的一组丰富的统计函数。

程序员可以把代码作为*函数*插入服务器中，它是使代码类似于存储过程的一个小包装器。以这种方式 SQL 代码可以调用（比如）C 代码或反之。

*  性能增进，因为数据库引擎在一个时间一个地方调用所有的逻辑，减少了在客户和服务器之间的来回往返的次数。
 *  可靠性增进，因为数据验证代码集中到一个地方，就在服务器上，而不用依赖在多个客户应用中的同步逻辑，它们甚至可能以多种编程语言写成。
 *  通过向服务器增加有用的抽象，客户代码可以变得更短小和简单。

这些优势合起来可以证实 PostgreSQL 从编程角度是最高级的数据库系统。使用 PostgreSQL 可以显著的减少很多项目的整体编程时间，这种优势随着项目复杂而增长。

## 特征 ##

### 函数 ###

通过函数，可以在数据库服务器端执行指令程序。仅管这样的指令程序可以使用基本的SQL语句写成，但是由于其缺乏流程控制等功能，所以在PostgreSQL中引入了使用其它程序语言编写函数的能力，包括：

*  一个内置的名为PL/pgSQL的过程语言，类似于Oracle的PL/SQL；
 *  包括PL/Perl，plPHP，PL/Python，PL/Ruby，PL/sh，PL/Tcl与 PL/Scheme在内的脚本语言；
 *  编译语言：C，C++，或Java（通过PL/Java）。
 *  R统计语言（PL/R）。

以上部分的语言，甚至可以在触发器内执行。PostgreSQL支持行返回函数：它们的输出是一系列行类型数据的集合，可以在查询中当作表来使用。函数也可以被定义成以创建者或者调用者的身份运行。在某些场合，或者其他的数据库产品中，函数也会被称为“存储过程”，但技术上这两者并未有太大分别。

###  索引 ###

在PostgreSQL中，用户可以自定义索引方法，或使用内置的B-tree，哈希表与GiST索引。PosrgreSQL的索引功能同时也具有以下功能：

*  反向索引检索：无须额外的索引就能实现类似`ORDER BY field DESC`的操作。
 *  **表达式索引**：可以建立基于表达式值而非数值或列的索引。
 *  **部分索引**：仅索引表的部分，可以通过在`CREATE INDEX`语句口添加`WHERE` 从句以创建更小的索引。
 *  **位图索引扫描**：从8.1版开始支持此功能。该功能将读取多个索引，生成表示它们之间符合查询标准的多元组交集的位图。这样解决了混合索引的问题。在一个具有20列的表中，理论上能创建 20! 个索引，在实际应用中已不现实。使用位图索引扫描后，在每次查询时，它将能把约束条件中所涉及列各自的索引进行任意的排列组合。

### 触发器 ###

触发器是由SQL语句查询所触发的事件。如：一个INSERT语句可能触发一个检查数据完整性的触发器。触发器通常由INSERT或UPDATE语句触发。

在PostgreSQL中，可在数据表上设置触发器，但无法在视图中设置（对视图的UPDATE或者INSERT操作可以使用规则（RULE）定义）。多个触发器可依据字母顺序依次执行。此外，除了使用内嵌的PL/PgSQL语言之外，触发器的函数也可以用PL/Perl，PL/Python等语言编写。

### 多版本并发控制 ###

PostgreSQL使用多版本并发控制（MVCC，Multiversion concurrency control）系统进行并发控制，该系统向每个用户提供了一个数据库的“快照”，用户在事务内所作的每个修改，对于其他的用户都不可见，直到该事务成功提交。这从很大程度上减少了对读取锁的依赖，同时保证了数据库高效地符合ACID原则。

### 规则 ###

规则（RULE）允许一个查询能被重写，通常被用作实现可更新的视图。

### 数据类型 ###

PostgreSQL内置丰富的数据类型，包括：

*  任意精度的数值
 *  无限制长度文本
 *  几何图元
 *  IP地址与IPv6地址
 *  无类域间路由地址块，MAC地址
 *  数组

此外，用户可以创建自定义数据类型，通常通过PostgreSQL的GiST机制，它们也能被很好得索引，比如PostGIS地理信息系统的数据类型。

### 用户定义对象 ###

用户可以为数据库内几乎所有的对象定义新的类型，包括：

*  索引
 *  操作符（可重载现有操作符。）
 *  聚合函数
 *  数据域
 *  数据类型转换
 *  会话（编码转换）

# 二 数据库连接 #

## 2.1 安装 psycopg2-binary ##

#  pip install psycopg2-binary

## 2.2 连接数据库 ##

每条完整的sql执行步骤如下，读者应谨记；

1.  建立连接获得 connect 对象
2.  获得游标对象，一个游标对象可以对数据库进行执行操作，非线程安全，多个应用会在同一个连接种创建多个光标；
3.  书写sql语句
4.  调用execute()方法执行sql
5.  抓取数据（可选操作）
6.  提交事物
7.  关闭连接

# -*- coding: utf-8 -*-
    import psycopg2
    # 获得连接
    conn = psycopg2.connect(database="python", user="postgres", password="123456", host="127.0.0.1", port="5432")
    # 获得游标对象
    cursor = conn.cursor()
    # sql语句
    sql = "SELECT VERSION()"
    # 执行语句
    cursor.execute(sql)
    # 获取单条数据.
    data = cursor.fetchone()
    # 打印
    print("database version : %s " % data)
    # 事物提交
    conn.commit()
    # 关闭数据库连接
    conn.close()

输出结果打印出数据库版本说明连接数据库成功：

database version : PostgreSQL 11.3, compiled by Visual C++ build 1914, 64-bit

# 三 创建表 #

创建学生表主要有字段`id` 唯一标识，字段 `num` 代表学号，字段 `name` 代表学生姓名；详细的建表默认规则转换见附录

# -*- coding: utf-8 -*-
    import psycopg2
    # 获得连接
    conn = psycopg2.connect(database="python", user="postgres", password="123456", host="127.0.0.1", port="5432")
    # 获得游标对象，一个游标对象可以对数据库进行执行操作
    cursor = conn.cursor()
    # sql语句 建表
    sql = """CREATE TABLE student (
    id serial4 PRIMARY KEY, 
    num int4,
    name varchar(25));"""
    # 执行语句
    cursor.execute(sql)
    print("student table created successfully")
    # 事物提交
    conn.commit()
    # 关闭数据库连接
    conn.close()

# 四 插入操作 #

## 4.1 插入数据姿势一 ##

知识追寻者提供的第一种防止sql注入的插入数据方式（具有占位符的预编译sql），重要程度不言而喻；美中不足是字符串类型必须带上单引号；

# -*- coding: utf-8 -*-
    import psycopg2
    # 获得连接
    conn = psycopg2.connect(database="python", user="postgres", password="123456", host="127.0.0.1", port="5432")
    # 获得游标对象，一个游标对象可以对数据库进行执行操作
    cursor = conn.cursor()
    # sql语句 建表
    sql ="INSERT INTO student (num, name) \
                        VALUES (%s, '%s')" % \
                        (100, 'zszxz')
    # 执行语句
    cursor.execute(sql)
    print("successfully")
    # 事物提交
    conn.commit()
    # 关闭数据库连接
    conn.close()

## 4.2 插入数据姿势二（参数分离） ##

知识追寻者认为下面参数与sql语句分离插入的姿势更简便帅气，也是防止sql注入问题；强烈推荐；

# -*- coding: utf-8 -*-
    import psycopg2
    # 获得连接
    conn = psycopg2.connect(database="python", user="postgres", password="123456", host="127.0.0.1", port="5432")
    # 获得游标对象，一个游标对象可以对数据库进行执行操作
    cursor = conn.cursor()
    # sql语句 建表
    sql ="""INSERT INTO student (num, name) VALUES (%s, %s)"""
    params = (101, 'zszxz')
    # 执行语句
    cursor.execute(sql,params)
    print("successfully")
    # 事物提交
    conn.commit()
    # 关闭数据库连接
    conn.close()

## 4.3 插入数据姿势三（字典） ##

第三种姿势也就是是支持字典映射关系插入，使用字典方式的插入数据是根据字典的key进行匹配占位符，强烈推荐；

# -*- coding: utf-8 -*-
    import psycopg2
    # 获得连接
    conn = psycopg2.connect(database="python", user="postgres", password="123456", host="127.0.0.1", port="5432")
    # 获得游标对象，一个游标对象可以对数据库进行执行操作
    cursor = conn.cursor()
    # sql语句 建表
    sql ="""INSERT INTO student (num, name) VALUES (%(num)s, %(name)s)"""
    params = {'num':102, 'name':'zszxz'}
    # 执行语句
    cursor.execute(sql,params)
    print("successfully")
    # 事物提交
    conn.commit()
    # 关闭数据库连接
    conn.close()

# 五 查询操作 #

## 5.1 查询一条数据 ##

使用`fetchone()`方法可以抓取一条数据, 返回的是元组；

# -*- coding: utf-8 -*-
    import psycopg2
    # 获得连接
    conn = psycopg2.connect(database="python", user="postgres", password="123456", host="127.0.0.1", port="5432")
    # 获得游标对象，一个游标对象可以对数据库进行执行操作
    cursor = conn.cursor()
    # sql语句 建表
    sql ="""SELECT * FROM student;"""
    # 执行语句
    cursor.execute(sql)
    # 抓取
    row = cursor.fetchone()
    print(row)
    # 事物提交
    conn.commit()
    # 关闭数据库连接
    cursor.close()
    conn.close()

输出结果：

(1, 100, 'zszxz')

## 5.2 查询多条数据 ##

1.  使用`fetchmany([size=cursor.arraysize])`方法可以抓取多条数据；
2.  此方法可以多次使用，直到数据库中没有数据，此时会返回空列表；
3.  如果不传参数，会限制查询条数，一般就是返回第一条；

# -*- coding: utf-8 -*-
    import psycopg2
    # 获得连接
    conn = psycopg2.connect(database="python", user="postgres", password="123456", host="127.0.0.1", port="5432")
    # 获得游标对象，一个游标对象可以对数据库进行执行操作
    cursor = conn.cursor()
    # sql语句 建表
    sql ="""SELECT * FROM student;"""
    # 执行语句
    cursor.execute(sql)
    # 抓取
    #row = cursor.fetchone()
    rows = cursor.fetchmany(2)
    print(rows)
    # 事物提交
    conn.commit()
    # 关闭数据库连接
    cursor.close()
    conn.close()

输出结果：

[(1, 100, 'zszxz'), (2, 101, 'zszxz')]

## 5.3 查询全部数据 ##

使用 `fetchall()` 方法会抓取所有数据；

# -*- coding: utf-8 -*-
    import psycopg2
    # 获得连接
    conn = psycopg2.connect(database="python", user="postgres", password="123456", host="127.0.0.1", port="5432")
    # 获得游标对象，一个游标对象可以对数据库进行执行操作
    cursor = conn.cursor()
    # sql语句 建表
    sql ="""SELECT * FROM student;"""
    # 执行语句
    cursor.execute(sql)
    # 抓取
    rows = cursor.fetchall()
    print(rows)
    # 事物提交
    conn.commit()
    # 关闭数据库连接
    cursor.close()
    conn.close()

输出结果：

[(1, 100, 'zszxz'), (2, 101, 'zszxz'), (3, 102, 'zszxz')]

## 5.4 按条件查询 ##

1.  带参查询读者应该谨记sql 与 参数 分离
2.  **参数的末尾必须加上逗号**
3.  如果知道返回的数据就一条使用fetchone()方法，如果无特殊要求，否则建议使用`fetchall()`方法

# -*- coding: utf-8 -*-
    import psycopg2
    # 获得连接
    conn = psycopg2.connect(database="python", user="postgres", password="123456", host="127.0.0.1", port="5432")
    # 获得游标对象，一个游标对象可以对数据库进行执行操作
    cursor = conn.cursor()
    # sql语句 建表
    sql ="""SELECT * FROM student where id = %s;"""
    params = (1,)
    # 执行语句
    cursor.execute(sql,params)
    # 抓取
    rows = cursor.fetchall()
    print(rows)
    # 事物提交
    conn.commit()
    # 关闭数据库连接
    cursor.close()
    conn.close()

输出结果：

[(1, 100, 'zszxz')]

# 六 更新操作 #

更新操作跟之前的查询，插入类似，参数对应的文章分清楚即可。

# -*- coding: utf-8 -*-
    import psycopg2
    # 获得连接
    conn = psycopg2.connect(database="python", user="postgres", password="123456", host="127.0.0.1", port="5432")
    # 获得游标对象，一个游标对象可以对数据库进行执行操作
    cursor = conn.cursor()
    # sql语句 建表
    sql ="""update student set name = %s where id = %s  """
    params = ('知识追寻者',3,)
    # 执行语句
    cursor.execute(sql,params)
    # 事物提交
    conn.commit()
    # 关闭数据库连接
    cursor.close()
    conn.close()

# 七 删除操作 #

删除操作很简单，看如下代码，与之前的代码流程没什么区别；

# -*- coding: utf-8 -*-
    import psycopg2
    # 获得连接
    conn = psycopg2.connect(database="python", user="postgres", password="123456", host="127.0.0.1", port="5432")
    # 获得游标对象，一个游标对象可以对数据库进行执行操作
    cursor = conn.cursor()
    # sql语句 建表
    sql ="""delete from  student where id = %s  """
    params = (3,)
    # 执行语句
    cursor.execute(sql,params)
    # 事物提交
    conn.commit()
    # 关闭数据库连接
    cursor.close()
    conn.close()

# 八 异常处理 #

处理 sql 的异常非常重要，知识追寻者这边使用psycopg2的 `Error` 进行异常捕获，能捕获到sql执行时期的所有异常；下面代码中表test是库中不存的表，执行sql后会报异常，经过异常捕获后非常美观，不影响程序运行；

# -*- coding: utf-8 -*-
    import psycopg2
    # 获得连接
    conn = psycopg2.connect(database="python", user="postgres", password="123456", host="127.0.0.1", port="5432")
    # 获得游标对象，一个游标对象可以对数据库进行执行操作
    cursor = conn.cursor()
    # sql语句 建表
    sql ="""select * from test"""
    params = (3,)
    try:
        # 执行语句
        cursor.execute(sql,params)
    except psycopg2.Error as e:
        print(e)
    # 事物提交
    conn.commit()
    # 关闭数据库连接
    cursor.close()
    conn.close()

执行结果

错误:  关系 "test" 不存在
    LINE 1: select * from test

# 九 打印sql #

使用`cursor.query` 可以查看执行的sql语句，方便排查；

# -*- coding: utf-8 -*-
    import psycopg2
    # 获得连接
    conn = psycopg2.connect(database="python", user="postgres", password="123456", host="127.0.0.1", port="5432")
    # 获得游标对象，一个游标对象可以对数据库进行执行操作
    cursor = conn.cursor()
    # sql语句 建表
    sql ="""select * from student"""
    try:
        # 执行语句
        cursor.execute(sql,)
        que = cursor.query
        print(que)
    except psycopg2.Error as e:
        print(e)
    # 事物提交
    conn.commit()
    # 关闭数据库连接
    cursor.close()
    conn.close()

执行结果：

b'select * from student'

# 十 获取总条数 #

使用cursor.rowcount 可以获得表中所有行总数；

# 获得连接
    conn = psycopg2.connect(database="python", user="postgres", password="123456", host="127.0.0.1", port="5432")
    # 获得游标对象，一个游标对象可以对数据库进行执行操作
    cursor = conn.cursor()
    # sql语句 建表
    sql ="""select * from student"""
    # 执行语句
    cursor.execute(sql)
    count = cursor.rowcount
    print(count)
    # 事物提交
    conn.commit()
    # 关闭数据库连接
    conn.close()

输出

# 十一显示行号 #

使用cursor.rownumber 可以显示当前查询sql获得数据的行号，每抓取一次光标的索引就会加1；

# 获得连接
    conn = psycopg2.connect(database="python", user="postgres", password="123456", host="127.0.0.1", port="5432")
    # 获得游标对象，一个游标对象可以对数据库进行执行操作
    cursor = conn.cursor()
    # sql语句 建表
    sql ="""select * from student """
    # 执行语句
    cursor.execute(sql)
    row_1 = cursor.fetchone()
    print(cursor.rownumber)
    row_2 = cursor.fetchone()
    print(cursor.rownumber)
    # 事物提交
    conn.commit()
    # 关闭数据库连接
    conn.close()

输出结果：

1
    2

# 十二 显示执行参数 #

使用 `mogrify`(*operation*\[, *parameters*\]) 能够显示执行语句的参数绑定结果，返回的是字符串形式；

# 获得连接
    conn = psycopg2.connect(database="python", user="postgres", password="123456", host="127.0.0.1", port="5432")
    # 获得游标对象，一个游标对象可以对数据库进行执行操作
    cursor = conn.cursor()
    # sql语句 建表
    sql ="""INSERT INTO student (num, name) VALUES (%s, %s)"""
    params = (102, '知识追寻者')
    # 执行语句
    result = cursor.mogrify(sql,params)
    print(result.decode('UTF-8'))
    cursor.execute(sql,params)
    # 事物提交
    conn.commit()
    # 关闭数据库连接
    conn.close()

执行结果：

INSERT INTO student (num, name) VALUES (102, '知识追寻者')

# 十三 附录 #

支持默认的类型转换如下,如果想要使用强制类型转换，详细的可以参照pgsql官网手册；

<table> 
 <thead> 
  <tr> 
   <th>Python</th> 
   <th>PostgreSQL</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>None</code></td> 
   <td><code>NULL</code></td> 
  </tr> 
  <tr> 
   <td><code>bool</code></td> 
   <td><code>bool</code></td> 
  </tr> 
  <tr> 
   <td><code>float</code></td> 
   <td><code>real</code>，<code>double</code></td> 
  </tr> 
  <tr> 
   <td><code>int</code>，<code>long</code></td> 
   <td><code>smallint</code>，<code>integer</code>，<code>bigint</code></td> 
  </tr> 
  <tr> 
   <td><code>Decimal</code></td> 
   <td><code>numeric</code></td> 
  </tr> 
  <tr> 
   <td><code>str</code>，<code>unicode</code></td> 
   <td><code>varchar</code>，<code>text</code></td> 
  </tr> 
  <tr> 
   <td><code>buffer</code>，<code>memoryview</code>，<code>bytearray</code>，<code>bytes</code>，<code>Buffer protocol</code></td> 
   <td><code>bytea</code></td> 
  </tr> 
  <tr> 
   <td><code>date</code></td> 
   <td><code>date</code></td> 
  </tr> 
  <tr> 
   <td><code>time</code></td> 
   <td><code>time</code>,<code>timetz</code></td> 
  </tr> 
  <tr> 
   <td><code>datetime</code></td> 
   <td><code>timestamp</code>,<code>timestamptz</code></td> 
  </tr> 
  <tr> 
   <td><code>timedelta</code></td> 
   <td><code>interval</code></td> 
  </tr> 
  <tr> 
   <td><code>list</code></td> 
   <td><code>ARRAY</code></td> 
  </tr> 
  <tr> 
   <td><code>tuple</code>,<code>namedtuple</code></td> 
   <td>Composite types<code>IN</code>&nbsp;syntax</td> 
  </tr> 
  <tr> 
   <td><code>dict</code></td> 
   <td><code>hstore</code></td> 
  </tr> 
  <tr> 
   <td><code>Range</code></td> 
   <td><code>range</code></td> 
  </tr> 
  <tr> 
   <td><code>UUID</code></td> 
   <td><code>uuid</code></td> 
  </tr> 
  <tr> 
   <td><code>Anything</code></td> 
   <td><code>json</code></td> 
  </tr> 
  <tr> 
   <td><code>ipaddress</code></td> 
   <td><code>inet</code></td> 
  </tr> 
 </tbody> 
</table>