PostgreSQL学习笔记(更新ing)+c# 使用ef连接数据库postgreSQL
目录
- PostgreSQL学习笔记
-
- 一、PostgreSQL创建、删除数据库（表）、架构
-
- 1、创建数据库 CREATE DATABASE
- 2、查看数据库
- 3、删除数据库
- 4、创建表
- 5、删除表
- 6、架构
- 二、PostgreSQL数据类型
-
- 1、数值数据类型
- 2、字符串数据类型
- 3、日期/时间数据类型
- 4、 一些其他数据类型
- 三、PostgreSQL查询工具
-
- 1、插入INSERT
- 2、查询SELECT
- 4、删除 DELETE
- 5、 ORDER BY子句
- 6、 分组（GROUP BY子句）
- 7、Having字句
- 四、PostgreSQL条件查询
-
- 1、AND 条件
- 2、OR 条件
- 3、AND & OR 条件
- 4、NOT 条件
- 5、LIKE 条件
- 6、IN 条件
- 7、NOT IN 条件
- 8、BETWEEN 条件
- 五、PostgreSQL连接(内连接)
-
- 1、内连接(INNER JOIN)
- 2、左外连接(LEFT OUTER JOIN)
- 3、右外连接(RIGHT OUTER JOIN)
- 4、全连接(FULL OUTER JOIN)
- 5、跨连接(CROSS JOIN)
- 六、PostgreSQL高级
-
- 1、视图CREATE/DROP VIEW
-
- PostgreSQL创建视图
- PostgreSQL 删除视图
- 2、 函数(存储过程)
- 3、触发器CREATE TRIGGER
-
- 3.1 触发器的重点知识
- 3.2 PostgreSQL创建触发器
- 3.3 触发器例子
- 4、PostgreSQL别名
-
- 4.1 PostgreSQL列别名语法：
- 4.2 PostgreSQL表别名语法：
- 5、 PostgreSQL索引 CREATE INDEX
-
- 5.1 PostgreSQL创建索引CREATE
- 6、PostgreSQL日期和时间函
-
- 6.1 AGE()函数例子
- 6.2 函数AGE(timestamp)
- 6.3 当前DATE/TIME()
- 7、UNIONS子句
- 8、NULL值
- 9、修改表ALTER TABLE
- 10、截断表TRUNCATE TABLE语句
- 11、事务
-
- 11.1 BEGIN TRANSACTION命令
- 11.2 COMMIT命令
- 11.3 ROLLBACK命令
- 12、锁LOCK
-
- 12.1 死锁ROLLBACK
- 12.2 咨询锁
- 13、子查询
-
- 13.1 带SELECT语句的子查询
- 13.2 带INSERT语句的子查询
- 13.3 带UPDATE语句的子查询
- 13.4 带有DELETE语句的子查询
- 14、自动递增
- 15、权限
-
- 15.1 GRANT的语法
- 15.2 REVOKE的语法
- 七、Python链接PostgreSQL
-
- 1、python安装psycopg2
- 2、连接数据库
- 3、创建表
- 八、c# 连接pgsql数据库
-
- 1、安装插件NPGSql
- 2、连接数据库并查询
- 九、c# 使用ef连接数据库postgreSQL
-
- 1、简单版本
- 2、增删改查语句
- 3、 反向工程
-
- 3.1 基本概念
- 3.2 demo03例子
- 十、问题处理
-
- 1、连接本地PostgreSQL数据库时报错
- 2、如何使用中文数据库
PostgreSQL学习笔记
一、PostgreSQL创建、删除数据库（表）、架构
1、创建数据库 CREATE DATABASE
在PostgreSQL中，可以使用CREATE DATABASE命令创建数据库。
语法：
CREATE DATABASE database_name;
这里，database_name是指定要创建的数据库的名称。
PostgreSQL使用查询工具创建数据库
打开SQL Shell(psql)，执行以下创建语句
CREATE DATABASE database_name;
2、查看数据库
postgres=# \l
3、删除数据库
postgres=# drop database testdb;
4、创建表
在PostgreSQL中，CREATE TABLE语句用于在任何给定的数据库中创建一个新表。
语法：
CREATE TABLE table_name(
column1 datatype,
column2 datatype,
column3 datatype,
.....
columnN datatype,
PRIMARY KEY( one or more columns )
);
PostgreSQL使用UI创建表 -
首先选择要创建表的数据库。
左键单击与所选数据库关联的框类型结构,将看到目录和模式(架构)。
左键单击与模式(架构)关联的框类型结构。现在可以看到 public 。
左键单击与公共( public )关联的框类型结构，就可以看到有数据表。
选择数据表，右键单击数据表，会得到一个新的弹出表框，创建所需的表。
示例：
CREATE TABLE public.student2
(
id integer NOT NULL,
name character(100),
subjects character(1),
CONSTRAINT student2_pkey PRIMARY KEY (id)
)
WITH (
OIDS=FALSE
);
ALTER TABLE public.student2
OWNER TO postgres;
COMMENT ON TABLE public.student2
IS '这是一个学生信息表2';
5、删除表
postgres=#
postgres=# drop table student2;
DROP TABLE
postgres=#
6、架构
模式(也叫架构)是指定的表集合。 它还可以包含视图，索引，序列，数据类型，运算符和函数。
创建模式
在PostgreSQL中，CREATE SCHEMA语句用于创建模式。 模式不能嵌套。
语法：
CREATE SCHEMA schema_name;
通过SQL命令行直接创建 -
CREATE SCHEMA myschema;
示例:
-- Table: myschema.tb_test
-- DROP TABLE myschema.tb_test;
CREATE TABLE myschema.tb_test
(
id integer,
name character(254)
)
WITH (
OIDS=FALSE
);
ALTER TABLE myschema.tb_test
OWNER TO postgres;
二、PostgreSQL数据类型
PostgreSQL中主要有三种类型的数据类型：
数值数据类型
字符串数据类型
日期/时间数据类型
1、数值数据类型
decimal(size,d)
numeric(size,d)
容纳带有小数的数字。
“size” 规定数字的最大位数。“d” 规定小数点右侧的最大位数。
2、字符串数据类型
3、日期/时间数据类型
4、 一些其他数据类型
三、PostgreSQL查询工具
插入INSERT
查询SELECT
更新UPDATE
删除 DELETE
ORDER BY子句
分组（GROUP BY子句）
Having字句
1、插入INSERT
在PostgreSQL中， INSERT 查询用于在表中插入新行。 您可以一次插入单行或多行到表中。
语法：
INSERT INTO TABLE_NAME (column1, column2, column3,...columnN)
VALUES (value1, value2, value3,...valueN);
注意：column1, column2, column3,…columnN是要插入数据的表中的列的名称。
示例：
CREATE TABLE public.table01
(
ID integer NOT NULL,
NAME character(100),
AGE integer,
ADDRESS character(100),
SALARY decimal
);
INSERT INTO public.table01( ID, NAME, AGE, ADDRESS, SALARY)
VALUES
(1, 'Maxsu', 25, '海口市人民大道2880号', 109990.00 ),
(2, 'minsu', 25, '广州中山大道 ', 125000.00 ),
(3, '李洋', 21, '北京市朝阳区', 185000.00),
(4, 'Manisha', 24, 'Mumbai', 65000.00),
(5, 'Larry', 21, 'Paris', 85000.00);
2、查询SELECT
在PostgreSQL中，SELECT语句用于从数据库表中检索数据。 数据以结果表格的形式返回。 这些结果表称为结果集。
语法：
SELECT "column1", "column2".."column" FROM "table_name";
这里，column1，column2，… columnN指定检索哪些数据的列。 如果要从表中检索所有字段，则必须使用以下语法：
SELECT * FROM "table_name";
示例：
执行以下查询从表中检索指定字段：
SELECT id,name FROM table01;
3、更新UPDATE
在PostgreSQL中，UPDATE语句用于修改表中现有的记录。 要更新所选行，您必须使用WHERE子句，否则将更新所有行。
语法：
以下是 update 语句的基本语法：
UPDATE table_name
SET column1 = value1, column2 = value2...., columnN = valueN
WHERE [condition];
示例
将ID为1的员工(“EMPLOYEES”表)记录更新AGE的值为29和SALARY的值为9800。
UPDATE public.EMPLOYEES_test
SET age = 29, salary = 9800
WHERE id=1;
更改前：
SELECT * FROM public.employees_test
更改后：
您可以看到ID为1的记录的已更新：AGE和SALARY列。
4、删除 DELETE
DELETE语句用于从表中删除现有记录。 “WHERE”子句用于指定删除所选记录的条件，如是不指定条件则将删除所有记录。
语法：
以下是DELETE语句的基本语法：
DELETE FROM table_name
WHERE [condition];
示例：
DELETE FROM public.EMPLOYEES_test
WHERE ID = 1;
注意：如果不使用“WHERE”条件，整个表中的记录都将被删除。
5、 ORDER BY子句
ostgreSQL ORDER BY 子句用于按升序或降序对数据进行排序。数据在一列或多列的基础上进行排序。
语法：
SELECT column-list
FROM table_name
[WHERE condition]
[ORDER BY column1, column2, .. columnN] [ASC | DESC];
参数说明：
column_list：它指定要检索的列或计算。
table_name：它指定要从中检索记录的表。FROM子句中必须至少有一个表。
WHERE conditions：可选。 它规定必须满足条件才能检索记录。
ASC：升序。也是可选的。它通过表达式按升序排序结果集(默认，如果没有修饰符是提供者)。
DESC：降序。也是可选的。 它通过表达式按顺序对结果集进行排序。
示例：
SELECT *
FROM public.EMPLOYEES_test
ORDER BY AGE ASC;
6、 分组（GROUP BY子句）
PostgreSQL GROUP BY 子句用于将具有相同数据的表中的这些行分组在一起。 它与SELECT语句一起使用。
GROUP BY 子句通过多个记录收集数据，并将结果分组到一个或多个列。 它也用于减少输出中的冗余。
语法：
SELECT column-list
FROM table_name
WHERE [conditions ]
GROUP BY column1, column2....columnN
ORDER BY column1, column2....columnN
注意：在 GROUP BY 多个列的情况下，您使用的任何列进行分组时，要确保这些列应在列表中可用。
示例：
SELECT AGE, SUM(SALARY)
FROM public.EMPLOYEES_test
GROUP BY AGE;
如何减少冗余数据：
再来看看下面这个例子：
我们在“EMPLOYEES”表中插入一些重复的记录。添加以下数据：
INSERT INTO public.EMPLOYEES_test VALUES (6, '李洋', 24, '深圳市福田区中山路', 135000);
INSERT INTO public.EMPLOYEES_test VALUES (7, 'Manisha', 19, 'Noida', 125000);
INSERT INTO public.EMPLOYEES_test VALUES (8, 'Larry', 45, 'Texas', 165000);
INSERT INTO public.EMPLOYEES_test( ID, NAME, AGE, ADDRESS, SALARY)
VALUES
(6, '李洋', 24, '深圳市福田区中山路', 135000),
(7, 'Manisha', 19, 'Noida', 125000),
(8, 'Larry', 45, 'Texas', 165000);
SELECT * FROM public.EMPLOYEES_test; //检索所有字段
执行以下查询以消除冗余：
SELECT NAME, SUM(SALARY)
FROM public.EMPLOYEES_test
GROUP BY NAME;
上面的SQL语句是按名字 ( NAME ) 执行分组统计每个名字的薪水总额，如：两个名字叫作李洋的薪水总额是：320000等等，得到结果如下 -
7、Having字句
在PostgreSQL中，HAVING子句与GROUP BY子句组合使用，用于选择函数结果满足某些条件的特定行。
语法：
SELECT column1, column2
FROM table1, table2
WHERE [ conditions ]
GROUP BY column1, column2
HAVING [ conditions ]
ORDER BY column1, column2
示例1:
在这个例子中，它将显示名称(name)数量小于2的记录。
执行以下查询：
SELECT NAME
FROM public.EMPLOYEES_test
GROUP BY NAME HAVING COUNT (NAME) < 2;
示例2:
执行以下查询表“EMPLOYEES”中name字段值计数大于1的名称。
SELECT NAME,COUNT (NAME)
FROM public.EMPLOYEES_test
GROUP BY NAME HAVING COUNT (NAME) > 1;
四、PostgreSQL条件查询
AND 条件
OR 条件
AND & OR 条件
NOT 条件
LIKE 条件
IN 条件
NOT IN 条件
BETWEEN 条件
检索所有字段
SELECT * FROM public.EMPLOYEES_test;
1、AND 条件
PostgreSQL AND条件与WHERE子句一起使用，以从表中的多个列中选择唯一的数据。
语法：
SELECT column1, column2, ..... columnN
FROM table_name
WHERE [search_condition]
AND [search_condition];
示例:
下面来查询所有ID小于4并且薪水大于120000的员工数据信息，执行以下查询语句：
SELECT *
FROM public.EMPLOYEES_test
WHERE SALARY > 120000
AND ID <= 4;
2、OR 条件
PostgreSQL OR条件与WHERE子句一起使用，以从表中的一列或多列列中选择唯一数据。
语法：
SELECT column1, column2, ..... columnN
FROM table_name
WHERE [search_condition]
OR [search_condition];
示例：
查询名字是李洋或者地址为Noida员工信息，执行以下查询：
SELECT *
FROM public.EMPLOYEES_test
WHERE NAME = '李洋'
OR ADDRESS = 'Noida';
3、AND & OR 条件
PostgreSQL AND＆OR条件在仅一个查询中提供了AND和OR条件的优点。
语法：
SELECT column1, column2, ..... columnN
FROM table_name
WHERE [search_condition] AND [search_condition]
OR [search_condition];
示例：
查询名字的值为李洋和地址的值为’北京市朝阳区‘，或者ID值大于等7的记录信息，执行以下查询：
SELECT *
FROM public.EMPLOYEES_test
WHERE (NAME = '李洋' AND ADDRESS = '北京市朝阳区')
OR (ID>= 7);
4、NOT 条件
PostgreSQL NOT条件与WHERE子句一起使用以否定查询中的条件。
语法：
SELECT column1, column2, ..... columnN
FROM table_name
WHERE [search_condition] NOT [condition];
示例：
查询那些年龄不是21和24的所有记录，执行以下查询：
SELECT *
FROM public.EMPLOYEES_test
WHERE age NOT IN(21,24);
5、LIKE 条件
PostgreSQL LIKE条件与WHERE子句一起用于从指定条件满足LIKE条件的表中获取数据。
语法：
SELECT column1, column2, ..... columnN
FROM table_name
WHERE [search_condition] LIKE [condition];
示例1：
查询名字以Ma开头的数据记录，如下查询语句：
SELECT *
FROM public.EMPLOYEES_test
WHERE NAME LIKE 'Ma%';
‘Ma%’——以Ma开头
‘%su’——以su结尾
%大道% ’——含有大道
6、IN 条件
PostgreSQL IN条件与WHERE子句一起使用，从指定条件满足IN条件的表中获取数据。
语法：
SELECT column1, column2, ..... columnN
FROM table_name
WHERE [search_condition] IN [condition];
示例：
SELECT *
FROM public.EMPLOYEES_test
WHERE AGE IN (19, 21);
7、NOT IN 条件
PostgreSQL NOT IN条件与WHERE子句一起使用，以从指定条件否定 IN 条件的表中获取数据。
语法：
SELECT column1, column2, ..... columnN
FROM table_name
WHERE [search_condition] NOT IN [condition];
示例：
SELECT *
FROM public.EMPLOYEES_test
WHERE name NOT IN ('Maxsu', 'minsu');
8、BETWEEN 条件
PostgreSQL BETWEEN条件与WHERE子句一起使用，以从两个指定条件之间的表中获取数据。
语法：
SELECT column1, column2, ..... columnN
FROM table_name
WHERE [search_condition] BETWEEN [condition];
示例：
查询employees表中年龄在24~27之间(含24，27)的数据信息，执行以下查询：
SELECT *
FROM public.EMPLOYEES_test
WHERE AGE BETWEEN 24 AND 27;
五、PostgreSQL连接(内连接)
在PostgreSQL中，有以下类型的连接：
内连接(INNER JOIN)
左外连接(LEFT OUTER JOIN)
右外连接(RIGHT OUTER JOIN)
全连接(FULL OUTER JOIN)
跨连接(CROSS JOIN)
1、内连接(INNER JOIN)
此连接返回满足连接条件的多个表中的所有行。
语法：
SELECT table1.columns, table2.columns
FROM table1
INNER JOIN table2
ON table1.common_filed = table2.common_field;
示例：
检索所有字段
SELECT * FROM public.EMPLOYEES_test;
创建另一个表“DEPARTMENT”并插入以下值。
-- Table: public.department
-- DROP TABLE public.department;
CREATE TABLE public.department
(
id integer, dept text, fac_id integer
)
WITH (
OIDS=FALSE
);
ALTER TABLE public.department
OWNER TO postgres;
– 插入数据
INSERT INTO department( id,dept,fac_id)
VALUES
(1,'IT', 1),
(2,'Engineering', 2),
(3,'HR', 7);
查表
SELECT * FROM public.department
执行以下查询内连接两个表：
SELECT EMPLOYEES_test.ID, EMPLOYEES_test.NAME, DEPARTMENT.DEPT
FROM EMPLOYEES_test
INNER JOIN DEPARTMENT
ON EMPLOYEES_test.ID = DEPARTMENT.ID;
SELECT *
FROM EMPLOYEES_test
INNER JOIN DEPARTMENT
ON EMPLOYEES_test.ID = DEPARTMENT.ID;
2、左外连接(LEFT OUTER JOIN)
左外连接返回从“ON”条件中指定的左侧表中的所有行，只返回满足条件的另一个表中的行。
如下图中所表示：
语法：
SELECT table1.columns, table2.columns
FROM table1
LEFT OUTER JOIN table2
ON table1.common_filed = table2.common_field;
示例：
执行以下左连接查询：
SELECT EMPLOYEES_test.ID, EMPLOYEES_test.NAME, DEPARTMENT.DEPT
FROM EMPLOYEES_test
LEFT OUTER JOIN DEPARTMENT
ON EMPLOYEES_test.ID = DEPARTMENT.ID;
从上面图中可以看到，左表 ( EMPLOYEES ) 全部列出来，而右表 ( DEPARTMENT ) 没有匹配上的项全留为空值。
3、右外连接(RIGHT OUTER JOIN)
右外连接返回从“ON”条件中指定的右侧表中的所有行，只返回满足条件的另一个表中的行。
如下图中所表示：
语法：
SELECT table1.columns, table2.columns
FROM table1
RIGHT OUTER JOIN table2
ON table1.common_filed = table2.common_field;
如下图所示(蓝色部分) -
示例：
SELECT EMPLOYEES_test.ID, EMPLOYEES_test.NAME, DEPARTMENT.DEPT
FROM EMPLOYEES_test
RIGHT OUTER JOIN DEPARTMENT
ON EMPLOYEES_test.ID = DEPARTMENT.ID;
从上面图中可以看到，右表(DEPARTMENT)全部列出来，而左表(EMPLOYEES)没有匹配上的项全留为空值。
4、全连接(FULL OUTER JOIN)
全外连接从左表和左表中返回所有行。 它将NULL置于不满足连接条件的位置。
语法：
SELECT table1.columns, table2.columns
FROM table1
FULL OUTER JOIN table2
ON table1.common_filed = table2.common_field;
如下图所示(蓝色部分) -
– 插入数据
INSERT INTO department VALUES(10,'Market', 10);
示例：
SELECT EMPLOYEES_test.ID, EMPLOYEES_test.NAME, DEPARTMENT.DEPT
FROM EMPLOYEES_test
FULL OUTER JOIN DEPARTMENT
ON EMPLOYEES_test.ID = DEPARTMENT.ID;
5、跨连接(CROSS JOIN)
PostgreSQL跨连接 (CROSS JOIN) 将第一个表的每一行与第二个表的每一行相匹配。 它也被称为笛卡尔积。 如果table1具有“ x ”行，而table2具有“ y ”行，则所得到的表将具有( x * y )行。
语法：
SELECT coloums
FROM table1
CROSS JOIN table2
示例：
SELECT NAME, DEPT
FROM EMPLOYEES_test
CROSS JOIN DEPARTMENT;
六、PostgreSQL高级
视图CREATE/DROP VIEW
函数（存储过程）
触发器
别名
索引
日期和时间函
UNIONS字句
NULL值
修改表
截断表
事务
锁
子查询
自动递增
权限
1、视图CREATE/DROP VIEW
在PostgreSQL中，视图(VIEW)是一个伪表。 它不是物理表，而是作为普通表选择查询。
视图也可以表示连接的表。 它可以包含表的所有行或来自一个或多个表的所选行。
视图便于用户执行以下操作：
它以自然和直观的方式构建数据，并使其易于查找。
它限制对数据的访问，使得用户只能看到有限的数据而不是完整的数据。
它归总来自各种表中的数据以生成报告。
PostgreSQL创建视图
可以使用CREATE VIEW语句来在PostgreSQL中创建视图。 您可以从单个表，多个表以及另一个视图创建它。
语法：
CREATE [TEMP | TEMPORARY] VIEW view_name AS
SELECT column1, column2.....
FROM table_name
WHERE [condition];
示例:
我们从“EMPLOYEES”表创建一个视图。 此视图将仅包含EMPLOYEES表中的几个列：
执行以下查询语句：
CREATE VIEW current_employees AS
SELECT NAME, ID, SALARY
FROM EMPLOYEES_test;
现在，您可以从视图“current_employees”中使用简单的查询语句检索数据。会看到下表：
SELECT * FROM current_employees;
PostgreSQL 删除视图
语法
DROP VIEW view_name;
示例：
要删除上面的例子中创建的视图，可执行以下SQL语句：
DROP VIEW current_employees;
2、 函数(存储过程)
PostgreSQL函数也称为PostgreSQL存储过程。 PostgreSQL函数或存储过程是存储在数据库服务器上并可以使用SQL界面调用的一组SQL和过程语句(声明，分配，循环，控制流程等)。 它有助于您执行通常在数据库中的单个函数中进行多次查询和往返操作的操作。
您可以在许多语言(如SQL，PL/pgSQL，C，Python等)中创建PostgreSQL函数。
语法：
CREATE [OR REPLACE] FUNCTION function_name (arguments)
RETURNS return_datatype AS $variable_name$
DECLARE
declaration;
[...]
BEGIN
< function_body >
[...]
RETURN { variable_name | value }
END; LANGUAGE plpgsql;
参数说明
- function_name：指定函数的名称。 [OR REPLACE]：是可选的，它允许您修改/替换现有函数。
- RETURN：它指定要从函数返回的数据类型。它可以是基础，复合或域类型，或者也可以引用表列的类型。
- function_body：function_body包含可执行部分。 plpgsql：它指定实现该函数的语言的名称。
示例1:
在EMPLOYEES表上创建一个名为total records()的函数。
函数的定义如下：
CREATE OR REPLACE FUNCTION totalRecords ()
RETURNS integer AS $total$
declare
total integer;
BEGIN
SELECT count(*) into total FROM EMPLOYEES_test;
RETURN total;
END;
$total$ LANGUAGE plpgsql;
可以看到一个名为“totalrecords”的函数被创建。
现在，来执行一个调用这个函数并检查EMPLOYEES表中的记录
select totalRecords();
3、触发器CREATE TRIGGER
PostgreSQL触发器是一组动作或数据库回调函数，它们在指定的表上执行指定的数据库事件(即，INSERT，UPDATE，DELETE或TRUNCATE语句)时自动运行。 触发器用于验证输入数据，执行业务规则，保持审计跟踪等。
3.1 触发器的重点知识
PostgreSQL在以下情况下执行/调用触发器：在尝试操作之前(在检查约束并尝试INSERT，UPDATE或DELETE之前)。或者在操作完成后(在检查约束并且INSERT，UPDATE或DELETE完成后)。或者不是操作(在视图中INSERT，UPDATE或DELETE的情况下)
对于操作修改的每一行，都会调用一个标记为FOR EACH ROWS的触发器。 另一方面，标记为FOR EACH STATEMENT的触发器只对任何给定的操作执行一次，而不管它修改多少行。
您可以为同一事件定义同一类型的多个触发器，但条件是按名称按字母顺序触发。
当与它们相关联的表被删除时，触发器被自动删除。
3.2 PostgreSQL创建触发器
CREATE TRIGGER语句用于在PostgreSQL表中创建一个新的触发器。 当表发生特定事件(即INSERT，UPDATE和DELETE)时，它被激活。
语法
CREATE TRIGGER trigger_name [BEFORE|AFTER|INSTEAD OF] event_name
ON table_name
[
-- Trigger logic goes here....
];
在这里，event_name可以是INSERT，UPDATE，DELETE和TRUNCATE数据库操作上提到的表table_name。
可以选择在表名后指定FOR EACH ROW。
下面来看看看如何在INSERT操作中创建触发器的语法。
CREATE TRIGGER trigger_name AFTER INSERT ON column_name
ON table_name
[
-- Trigger logic goes here....
];
3.3 触发器例子
下面举个例子来演示PostgreSQL在INSERT语句之后创建触发器。在以下示例中，我们对每个记录插入到COMPANY表中进行审核(审计)。
使用以下查询创建一个名为COMPANY的表：
CREATE TABLE COMPANY(
ID INT PRIMARY KEY NOT NULL,
NAME TEXT NOT NULL,
AGE INT NOT NULL,
ADDRESS CHAR(50),
SALARY REAL
);
为了保存审计/审核，我们将创建一个名为AUDIT的新表，只要在COMPANY表中有一个新记录的条目，就会插入日志消息。
使用以下查询语句创建另一个表Audit：
CREATE TABLE AUDIT(
EMP_ID INT NOT NULL,
ENTRY_DATE TEXT NOT NULL
);
在COMPANY表上创建触发器之前，首先创建一个名为auditlogfunc()的函数/过程。
我们对每个记录插入到COMPANY表中进行审核(审计).
执行以下查询语句来创建函数/过程：
CREATE OR REPLACE FUNCTION auditlogfunc() RETURNS TRIGGER AS $example_table$
BEGIN
INSERT INTO AUDIT(EMP_ID, ENTRY_DATE) VALUES (new.ID, current_timestamp);
RETURN NEW;
END;
$example_table$ LANGUAGE plpgsql;
现在通过使用以下查询语句在COMPANY表上创建一个触发器：
CREATE TRIGGER example_trigger AFTER INSERT ON COMPANY
FOR EACH ROW EXECUTE PROCEDURE auditlogfunc();
向COMPANY表中插入一些数据记录，以验证触发器执行情况。
INSERT INTO COMPANY VALUES(1, '小米科技', 8, '北京市朝阳区', 9999);
INSERT INTO COMPANY VALUES(2, '京东中科', 6, '广州市天河区', 8999);
在执行上面两条插入语句后，现我们来看AUDIT表是否有自动插入两条审核记录。
PostgreSQL触发器的使用
目的：
验证输入数据。
执行业务规则。
为不同文件中新插入的行生成唯一值。
写入其他文件以进行审计跟踪。
从其他文件查询交叉引用目的。
访问系统函数。
将数据复制到不同的文件以实现数据一致性。
优点：
它提高了应用程序的开发速度。 因为数据库存储触发器，所以您不必将触发器操作编码到每个数据库应用程序中。
全局执法业务规则。定义触发器一次，然后将其重用于使用数据库的任何应用程序。更容易维护 如果业务策略发生变化，则只需更改相应的触发程序，而不是每个应用程序。
提高客户/服务器环境的性能。 所有规则在结果返回之前在服务器中运行。
4、PostgreSQL别名
您可以使用PostgreSQL别名为列或表创建一个临时名称。通常来说，当您执行自联接时，会创建一个临时表。
4.1 PostgreSQL列别名语法：
SELECT column_name AS alias_name
FROM table_name
conditions... ;
参数说明
column_name: 它指定要进行别名的列的原始名称。
alias_name: 它指定分配给列的临时名称。
table_name：它指定表的名称。
AS：这是可选的。大多数程序员将在对列名进行别名时指定AS关键字，但在别名表名时不指定。
注意：
如果alias_name包含空格，则必须将alias_name包含在引号中。
在别名列名时，可以使用空格。 但是使用表名时，使用空格通常不是一个好习惯。
alias_name仅在SQL语句的范围内有效。
示例-1
我们来看一下表“EMPLOYEES_test”，具有以下数据。
select * from EMPLOYEES_test
执行以下查询使用别名的语句：
SELECT NAME, MAX(SALARY) AS PACKAGE
FROM EMPLOYEES_test
GROUP BY NAME;
4.2 PostgreSQL表别名语法：
SELECT column1, column2....
FROM table_name AS alias_name
conditions.... ;
另有一个表department
SELECT * FROM department
查看表department
执行以下查询使用别名的语句：
SELECT E.ID, E.NAME, E.AGE, D.DEPT
FROM EMPLOYEES_test AS E, DEPARTMENT AS D
WHERE E.ID = D.ID;
5、 PostgreSQL索引 CREATE INDEX
索引是用于加速从数据库检索数据的特殊查找表。数据库索引类似于书的索引(目录)。 索引为出现在索引列中的每个值创建一个条目。
数据库索引的重要特点
- 索引使用SELECT查询和WHERE子句加速数据输出，但是会减慢使用INSERT和UPDATE语句输入的数据。
- 您可以在不影响数据的情况下创建或删除索引。 可以通过使用CREATE INDEX语句创建索引，指定创建索引的索引名称和表或列名称。
- 还可以创建一个唯一索引，类似于唯一约束，该索引防止列或列的组合上有一个索引重复的项。
5.1 PostgreSQL创建索引CREATE
- INDEX语句用于创建PostgreSQL索引。
语法
CREATE INDEX index_name ON table_name;
索引类型
PostgreSQL中有几种索引类型，如B-tree，Hash，GiST，SP-GiST和GIN等。
每种索引类型根据不同的查询使用不同的算法。
默认情况下，CREATE INDEX命令使用B树索引。
单列索引
如果仅在一个表列中创建索引，则将其称为单列索引。
语法：
CREATE INDEX index_name
ON table_name (column_name);
示例我们有一个名为“EMPLOYEES”的表
在表“EMPLOYEES”的“name”列上创建一个名为“employees_index”的索引。
执行以下创建语句：
CREATE INDEX employees_index
ON EMPLOYEES_test (name);
在这里，您可以看到在该表上创建了一个名为“employees_index”的索引 -
多列索引
如果通过使用表的多个列创建索引，则称为多列索引。
语法：
CREATE INDEX index_name
ON table_name (column1_name, column2_name);
让我们在同一个表“EMPLOYEES_test”上创建一个名为“multicolumn_index”的多列索引
执行以下创建查询语句：
CREATE INDEX multicolumn_index
ON EMPLOYEES_test (name, salary);
执行结果如下 -
唯一索引
创建唯一索引以获取数据的完整性并提高性能。它不允许向表中插入重复的值，或者在原来表中有相同记录的列上也不能创建索引。
语法：
CREATE UNIQUE INDEX index_name
on table_name (column_name);
例如，在employees表的name字段上创建一个唯一索引，将会提示错误 -
CREATE UNIQUE INDEX unique_on_name
on employees_test (name);
如下所示(name字段中有两个Minsu的值) -//
6、PostgreSQL日期和时间函
6.1 AGE()函数例子
按Ctrl + E打开查询编辑器，执行此查询示例：
SELECT AGE(timestamp '2017-01-26', timestamp '1951-08-15');
6.2 函数AGE(timestamp)
示例它用于生产当前年龄。
执行上面语句得到以下结果 -
SELECT AGE(timestamp '1994-08-18');
6.3 当前DATE/TIME()
以下是返回与当前日期和时间相关的值的函数的列表。
获取当前时间：
SELECT CURRENT_TIME;
7、UNIONS子句
PostgreSQL UNION子句/运算符用于组合两个或多个SELECT语句的结果，而不返回任何重复的行。
要使用UNION，每个SELECT必须具有相同的列数，相同数量的列表达式，相同的数据类型，并且具有相同的顺序，但不一定要相同。
**语法：**UNION的基本语法如下：
SELECT column1 [, column2 ]
FROM table1 [, table2 ]
[WHERE condition]
UNION
SELECT column1 [, column2 ]
FROM table1 [, table2 ]
[WHERE condition]
SELECT EMP_ID, NAME, DEPT FROM COMPANY INNER JOIN DEPARTMENT
ON COMPANY.ID = DEPARTMENT.EMP_ID
UNION
SELECT EMP_ID, NAME, DEPT FROM COMPANY LEFT OUTER JOIN DEPARTMENT
ON COMPANY.ID = DEPARTMENT.EMP_ID;
UNION ALL运算
符用于组合两个SELECT语句(包括重复行)的结果。 适用于UNION的相同规则也适用于UNION ALL运算符。
SELECT column1 [, column2 ]
FROM table1 [, table2 ]
[WHERE condition]
UNION ALL
SELECT column1 [, column2 ]
FROM table1 [, table2 ]
[WHERE condition]
8、NULL值
PostgreSQL NULL是用于表示缺少值的术语。 表中的NULL值是一个字段中的值，显示为空白。
具有NULL值的字段是没有值的字段。
使用UPDATE语句将几个可空值设置为NULL，如下所示：
UPDATE COMPANY SET ADDRESS = NULL, SALARY = NULL where ID IN(6,7);
9、修改表ALTER TABLE
PostgreSQL ALTER TABLE命令用于添加，删除或修改现有表中的列。您还可以使用ALTER TABLE命令在现有表上添加和删除各种约束。
语法：使用ALTER TABLE语句在现有表中添加新列的基本语法如下：
ALTER TABLE table_name ADD column_name datatype;
现有表中ALTER TABLE到DROP COLUMN(删除某个字段)的基本语法如下：
ALTER TABLE table_name DROP COLUMN column_name;
ALTER TABLE更改表中列的DATA TYPE(修改字段类型)的基本语法如下：
ALTER TABLE table_name ALTER COLUMN column_name TYPE datatype;
ALTER TABLE向表中的列添加NOT NULL约束的基本语法如下：
ALTER TABLE table_name MODIFY column_name datatype NOT NULL;
ALTER TABLE添加唯一约束ADD UNIQUE CONSTRAINT到表中的基本语法如下：
ALTER TABLE table_name
ADD CONSTRAINT MyUniqueConstraint UNIQUE(column1, column2...);
ALTER TABLE将“检查约束”添加到表中的基本语法如下所示：
ALTER TABLE table_name
ADD CONSTRAINT MyUniqueConstraint CHECK (CONDITION);
ALTER TABLE添加主键ADD PRIMARY KEY约束的基本语法如下：
ALTER TABLE table_name
ADD CONSTRAINT MyPrimaryKey PRIMARY KEY (column1, column2...);
使用ALTER TABLE从表中删除约束(DROP CONSTRAINT)的基本语法如下：
ALTER TABLE table_name
DROP CONSTRAINT MyUniqueConstraint;
SQL
使用ALTER TABLE从表中删除主键约束(DROP PRIMARY KEY)约束的基本语法如下：
ALTER TABLE table_name
DROP CONSTRAINT MyPrimaryKey;
10、截断表TRUNCATE TABLE语句
PostgreSQL TRUNCATE TABLE命令用于从现有表中删除完整的数据。您也可以使用DROP TABLE命令删除完整的表，但会从数据库中删除完整的表结构，如果希望存储某些数据，则需要重新创建此表。
它和在每个表上使用DELETE语句具有相同的效果，但由于实际上并不扫描表，所以它的速度更快。 此外，它会立即回收磁盘空间，而不需要后续的VACUUM操作。 这在大表上是最有用的。
语法：TRUNCATE TABLE的基本语法如下：
TRUNCATE TABLE table_name;
11、事务
事务是对数据库执行的工作单元。事务是以逻辑顺序完成的工作的单位或顺序，无论是用户手动的方式还是通过某种数据库程序自动执行。
事务控制以下命令用于控制事务：
- BEGIN TRANSACTION：开始事务。
- COMMIT：保存更改，或者您可以使用END TRANSACTION命令。
- ROLLBACK：回滚更改。
事务控制命令仅用于DML命令INSERT，UPDATE和DELETE。 创建表或删除它们时不能使用它们，因为这些操作会在数据库中自动提交。
11.1 BEGIN TRANSACTION命令
可以使用BEGIN TRANSACTION或简单的BEGIN命令来开始事务。 这样的事务通常会持续下去，直到遇到下一个COMMIT或ROLLBACK命令。 但如果数据库关闭或发生错误，则事务也将ROLLBACK。
以下是启动/开始事务的简单语法：
BEGIN;
or
BEGIN TRANSACTION;
11.2 COMMIT命令
COMMIT命令是用于将事务调用的更改保存到数据库的事务命令。COMMIT命令自上次的COMMIT或ROLLBACK命令后将所有事务保存到数据库。COMMIT命令的语法如下：
COMMIT;
or
END TRANSACTION;
11.3 ROLLBACK命令
ROLLBACK命令是用于还原尚未保存到数据库的事务的事务命令。自上次发出COMMIT或ROLLBACK命令以来，ROLLBACK命令只能用于撤销事务。ROLLBACK命令的语法如下：
ROLLBACK;
例如：
BEGIN;
DELETE FROM COMPANY WHERE AGE = 25;
ROLLBACK;
让我们开始另一个事务，并从表中删除age = 25的记录，最后使用COMMIT命令提交所有的更改。如果查看COMPANY表应该看到删除后剩下的记录：。
BEGIN;
DELETE FROM COMPANY WHERE AGE = 25;
COMMIT;
12、锁LOCK
在UPDATE和DELETE修改的行在事务的持续时间内被自动独占锁定。 这将阻止其他用户更改行，直到事务被提交或回退。
用户必须等待其他用户当他们都尝试修改同一行时。 如果他们修改不同的行，不需要等待。 SELECT查询不必等待。
数据库自动执行锁定。 然而，在某些情况下，必须手动控制锁定。 手动锁定可以通过使用LOCK命令完成。 它允许指定事务的锁类型和范围。
LOCK命令的语法
LOCK命令的基本语法如下：
LOCK [ TABLE ]
name
IN
lock_mode
- name：要锁定的现有表的锁名称(可选模式限定)。 如果在表名之前指定了ONLY，则仅该表被锁定
如果未指定ONLY，则表及其所有后代表(如果有)被锁定。 - lock_mode：锁模式指定此锁与之冲突的锁。
如果未指定锁定模式，则使用最严格的访问模式ACCESS EXCLUSIVE。 可能的值是：ACCESS SHARE，ROW
SHARE，ROW EXCLUSIVE，SHARE UPDATE EXCLUSIVE，SHARE，SHARE ROW
EXCLUSIVE，EXCLUSIVE，ACCESS EXCLUSIVE。
12.1 死锁ROLLBACK
当两个事务正在等待彼此完成操作时，可能会发生死锁。 虽然PostgreSQL可以检测到它们并使用ROLLBACK结束，但死锁仍然可能不方便。 为了防止您的应用程序遇到此问题，请确保以这样的方式进行设计，以使其以相同的顺序锁定对象。
12.2 咨询锁
PostgreSQL提供了创建具有应用程序定义含义的锁的方法。这些称为咨询锁(劝告锁,英文为：advisory locks)。 由于系统不强制使用它，因此应用程序正确使用它们。 咨询锁可用于锁定针对MVCC模型策略。
例如，咨询锁的常见用途是模拟所谓的“平面文件”数据管理系统的典型的悲观锁定策略。 虽然存储在表中的标志可以用于相同的目的，但是建议锁更快，避免了表的膨胀，并且在会话结束时被服务器自动清除。
例子：
在ACCESS EXCLUSIVE模式下将COMPANY表锁定在yiibai_db数据库中。 LOCK语句仅在事务模式下工作：
BEGIN;
LOCK TABLE company1 IN ACCESS EXCLUSIVE MODE;
13、子查询
子查询或内部查询或嵌套查询是一个PostgreSQL查询中的查询，它可以嵌入到WHERE子句中。子查询用于返回将在主查询中使用的数据作为进一步限制要检索的数据的条件。子查询可以与SELECT，INSERT，UPDATE和DELETE语句以及运算符(如**=，<，>，>=，<=，IN**等)一起使用。
子查询必须遵循以下规则：
- 子查询必须括在括号中。 子查询在SELECT子句中只能有一列，除非主查询中有多个列用于比较其所选列的子查询。
- ORDER BY不能用于子查询，尽管主查询可以使用ORDER BY。
- GROUP BY可用于执行与子查询中的ORDER BY相同的功能。
- 返回多行的子查询只能与多个值运算符一起使用，例如：IN，EXISTS，NOT IN，ANY / SOME，ALL运算符。
- BETWEEN运算符不能与子查询一起使用; 但是，BETWEEN可以在子查询中使用。
13.1 带SELECT语句的子查询
子查询最常用于SELECT语句。基本语法如下：
SELECT column_name [, column_name ]
FROM table1 [, table2 ]
WHERE column_name OPERATOR
(SELECT column_name [, column_name ]
FROM table1 [, table2 ]
[WHERE])
例如:
SELECT * FROM COMPANY
WHERE ID IN (
SELECT ID FROM COMPANY WHERE SALARY > 45000) ;
13.2 带INSERT语句的子查询
子查询也可以用于INSERT语句。INSERT语句使用从子查询返回的数据插入另一个表。可以使用任何字符，日期或数字函数修改子查询中选定的数据。
基本语法如下：
INSERT INTO table_name [ (column1 [, column2 ]) ]
SELECT [ *|column1 [, column2 ]
FROM table1 [, table2 ]
[ WHERE VALUE OPERATOR ]
13.3 带UPDATE语句的子查询
子查询可以与UPDATE语句一起使用。当使用具有UPDATE语句的子查询时，可以更新表中的单列或多列。
UPDATE table
SET column_name = new_value
[ WHERE OPERATOR [ VALUE ]
(SELECT COLUMN_NAME
FROM TABLE_NAME)
[ WHERE) ]
UPDATE COMPANY
SET SALARY = SALARY * 0.50
WHERE AGE IN (SELECT AGE FROM COMPANY_BKP
WHERE AGE >= 27 );
13.4 带有DELETE语句的子查询
子查询可以与DELETE语句一起使用，就像上面提到的任何其他语句一样。
基本语法如下：
DELETE FROM TABLE_NAME
[ WHERE OPERATOR [ VALUE ]
(SELECT COLUMN_NAME
FROM TABLE_NAME)
[ WHERE) ]
DELETE FROM COMPANY
WHERE AGE IN (SELECT AGE FROM COMPANY_BKP
WHERE AGE >= 27 );
14、自动递增
PostgreSQL具有数据类型smallserial，serial和bigserial; 这些不是真正的类型，而只是在创建唯一标识符列的标志以方便使用。 这些类似于一些其他数据库支持的AUTO_INCREMENT属性。
如果您希望某列具有唯一的约束或是主键，则必须使用其他数据类型进行指定。
类型名称serial用于创建整数列。 类型名称bigserial创建一个bigint类型的列。 如果您期望在表的使用期限内使用超过2^31个标识符，则应使用bigserial。 类型名称smallserial创建一个smallint列。
语法：SERIAL数据类型的基本用法如下：
CREATE TABLE tablename (
colname SERIAL
);
示例：考虑要创建的COMPANY表如下：
CREATE TABLE COMPANY_new(
ID SERIAL PRIMARY KEY,
NAME TEXT NOT NULL,
AGE INT NOT NULL,
ADDRESS CHAR(50),
SALARY REAL
);
现在，将以下记录插入COMPANY表：
INSERT INTO COMPANY_new
(NAME,AGE,ADDRESS,SALARY)
VALUES ( 'Paul', 32, 'California', 20000.00 );
INSERT INTO COMPANY_new (NAME,AGE,ADDRESS,SALARY)
VALUES ('Allen', 25, 'Texas', 15000.00 );
INSERT INTO COMPANY_new (NAME,AGE,ADDRESS,SALARY)
VALUES ('Teddy', 23, 'Norway', 20000.00 );
INSERT INTO COMPANY_new (NAME,AGE,ADDRESS,SALARY)
VALUES ( 'Mark', 25, 'Rich-Mond ', 65000.00 );
INSERT INTO COMPANY_new (NAME,AGE,ADDRESS,SALARY)
VALUES ( 'David', 27, 'Texas', 85000.00 );
INSERT INTO COMPANY_new (NAME,AGE,ADDRESS,SALARY)
VALUES ( 'Kim', 22, 'South-Hall', 45000.00 );
INSERT INTO COMPANY_new (NAME,AGE,ADDRESS,SALARY)
VALUES ( 'James', 24, 'Houston', 10000.00 );
这将在表中插入7个元组，COMPANY表将具有以下记录：
15、权限
在数据库中创建对象时，都会为其分配所有者。 所有者通常是执行创建语句的用户。 对于大多数类型的对象，初始状态是只有所有者(或超级用户)可以修改或删除对象。 要允许其他角色或用户使用它，必须授予权限或权限。
PostgreSQL中的不同类型的权限是：
- SELECT,INSERT,UPDATE,DELETE,TRUNCATE,REFERENCES,TRIGGER,CREATE,CONNECT,TEMPORARY,EXECUTE
和 USAGE。
根据对象的类型(表，函数等)，权限将应用于对象。 要为用户分配权限，使用GRANT命令。
15.1 GRANT的语法
GRANT命令的基本语法如下：
GRANT privilege [, …]
ON object [, …]
TO { PUBLIC | GROUP group | username }
SQL
- privilege值可以是：SELECT，INSERT，UPDATE，DELETE，RULE，ALL。
- object：要向其授予访问权限的对象的名称。 可能的对象是：表，视图，序列
- PUBLIC：表示所有用户的简短形式。
- GROUP group：授予权限的组。
- username：授予权限的用户的名称。 PUBLIC是表示所有用户的简短形式。
15.2 REVOKE的语法
REVOKE命令的基本语法如下：
REVOKE privilege [, ...]
ON object [, ...]
FROM { PUBLIC | GROUP groupname | username }
- privilege值可以是：SELECT，INSERT，UPDATE，DELETE，RULE，ALL。
- object: 授予访问权限的对象的名称。 可能的对象是：表，视图，序列。
- PUBLIC：表示所有用户的简短形式。
- GROUP group：授予权限的组。
- username：授予权限的用户的名称。 PUBLIC是表示所有用户的简短形式。
示例
我们先创建一个USER，如下所示：
CREATE USER manisha WITH PASSWORD 'password';
语句CREATE ROLE 表示创建了一个用户名为manisha。
考虑 COMPANY 表有以下记录：
select * from company_new
接下来，让我们给予用户“manisha”在表COMPANY_new上授予所有权限，如下所示：
GRANT ALL ON COMPANY_new TO manisha;
语句GRANT指示所有在COMPANY表上的权限都分配给用户“manisha”。
接下来，让我们从用户“manisha”中撤销权限，如下所示：
REVOKE ALL ON COMPANY FROM manisha;
REVOKE表示从用户“manisha”撤消所有权限。甚至可以删除用户，如下所示：
DROP USER manisha;
DROP ROLE表示从数据库中删除用户“manisha”。
七、Python链接PostgreSQL
PostgreSQL可以使用psycopg2模块与Python集成。sycopg2是用于Python编程语言的PostgreSQL数据库适配器。 psycopg2是非常小，快速，稳定的。
1、python安装psycopg2
直接运行
pip install psycopg2 -i https://pypi.tuna.tsinghua.edu.cn/simple
报错pg_config executable not found
先
pip install libpq-dev -i https://pypi.tuna.tsinghua.edu.cn/simple
再
pip install gcc -i https://pypi.tuna.tsinghua.edu.cn/simple
最后`
pip install psycopg2 -i https://pypi.tuna.tsinghua.edu.cn/simple
成功
要使用psycopg2模块，必须首先创建一个表示数据库的Connection对象，然后可以选择创建可以帮助您执行所有SQL语句的游标对象。
2、连接数据库
以下Python代码显示了如何连接到现有的数据库。 如果数据库不存在，那么它将自动创建，最后将返回一个数据库对象。
import psycopg2
conn = psycopg2.connect(database="testdb", user="postgres", password="pass123", host="127.0.0.1", port="5432")
print "Opened database successfully"
3、创建表
以下Python程序将用于在先前创建的数据库(testdb)中创建一个表：
#!/usr/bin/python
import psycopg2
conn = psycopg2.connect(database="testdb", user="postgres", password="pass123", host="127.0.0.1", port="5432")
print "Opened database successfully"
cur = conn.cursor()
cur.execute('''CREATE TABLE COMPANY
(ID INT PRIMARY KEY NOT NULL,
NAME TEXT NOT NULL,
AGE INT NOT NULL,
ADDRESS CHAR(50),
SALARY REAL);''')
print "Table created successfully"
conn.commit()
conn.close()
八、c# 连接pgsql数据库
1、安装插件NPGSql
点击扩展–>>管理扩展 -->>安装PGSql所使用的扩展工具NPGSql PostgreSql Integration扩展工具，安装时需要关闭vs
2、连接数据库并查询
using Npgsql;
using System;
using System.Configuration;
using System.Data;
using System.Runtime.Remoting.Messaging;
using System.Text;
namespace ConsoleApp_pgsql
{
internal class Program
{
private static int i;
static void Main(string[] args)
{
/* 用指定的connectionString，去实例化一个NpsqlConnection的对象*/
string connectionString = "Server=localhost;Port=5432;User Id=sde;Password=123456;Database=testDemo01;";
NpgsqlConnection conn = new NpgsqlConnection(connectionString);
// 打开一个数据库连接，在执行相关SQL之前调用
// conn.Open();
//关闭一个数据库连接，在执行完相关SQL之后调用
//conn.Close();
try
{
string sql = "SELECT * FROM demo01";
conn.Open();
Console.WriteLine("打开数据库");
NpgsqlCommand objCommand = new NpgsqlCommand(sql, conn);
NpgsqlDataReader dr = objCommand.ExecuteReader();
while (dr.Read())
{
Console.WriteLine(" \t");
for (i = 0; i < dr.FieldCount; i++)
{
Console.WriteLine("{0} \t", dr[i]); //获得字段名
// Console.WriteLine();
}
// int testId = (int)dr["id"]; // 获得指定字段的值。
}
}
finally
{
conn.Close();
Console.WriteLine("关闭数据库");
}
Console.ReadLine();
}
}
}
九、c# 使用ef连接数据库postgreSQL
1、简单版本
拓展：Npgsql PostgreSQL Integration
Nuget包：Npgsql.EntityFrameworkCore.PostgreSQL
新建控制台项目
代码如下：
using Microsoft.EntityFrameworkCore;
namespace EFCore.Demo;
public class Program
{
static async Task Main(params string[] args)
{
Console.WriteLine("第一步");
using(var context=new MyDbContext())
{
context.Add(new Table_1 { Content = "新增第二条数据",Id=2 });
await context.SaveChangesAsync();//保存后执行数据库
}
Console.WriteLine("第三步");
}
}
//建立和表名一样的模型 Table_1
public class Table_1
{
public int Id { get; set; }
public string? Content { get; set; }
}
public class MyDbContext : DbContext
{
public DbSet<Table_1> Table_1 { get; set; }
protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
{
//连哪个数据库
optionsBuilder.UseNpgsql("server=localhost;user id=postgres;password=123456;database=EF");
Console.WriteLine("第二步");
}
}
结果如图：
2、增删改查语句
using Microsoft.EntityFrameworkCore;
using System.ComponentModel.DataAnnotations.Schema;
using System.Runtime.InteropServices;
namespace EFCore.Demo;
public class Program
{
static async Task Main(params string[] args)
{
Console.WriteLine("-------------- 开始 --------------");
using var context = new MyDbContext();
int number = await context.Table_1.CountAsync();//
Console.WriteLine($"数据库有{number}条数据");
await Add();
//await takeQuery();
await whereQuery();
//await Update();
//await Delete();
Console.WriteLine("-------------- 完成 --------------");
}
/// 3、 反向工程
3.1 基本概念
反向工程是基于数据库架构搭建实体类型类和 DbContext 类基架的过程。 可使用 EF Core 包管理器控制台 (PMC) 工具的 Scaffold-DbContext 命令或 .NET 命令行接口 (CLI) 工具的 dotnet ef dbcontext scaffold 命令执行这一过程。
需要安装插件：
拓展：
- Npgsql PostgreSQL Integration
Nuget包：
- Npgsql.EntityFrameworkCore.PostgreSQL
- Microsoft.EntityFrameworkCore.Design
- Microsoft.EntityFrameworkCore.Tools
参考教程1：Entity Framework Entity Framework Core 管理数据库架构
参考教程2：EF Core使用Scaffold-DbContext从数据库生成模型
新建控制台项目程序，安装好扩展、Nuget包
程序包管理器控制台中执行：
Scaffold-DbContext "server=localhost;user id=postgres;password=123456;database=EF" Npgsql.EntityFrameworkCore.PostgreSQL
如果是其他数据库可以参考以下代码
Scaffold-DbContext "server=localhost;user id=postgres;password=123456;database=EF" Microsoft.EntityFrameworkCore.SqlServer
自动生成了 几个cs文件
直接执行数据库查询功能：
using EfCore.Demo02;
using Microsoft.EntityFrameworkCore;
using System.ComponentModel.DataAnnotations.Schema;
using System.Runtime.InteropServices;
using static EFCore.Demo02.Program;
/*
拓展： Npgsql PostgreSQL Integration
Nuget包： Npgsql.EntityFrameworkCore.PostgreSQL
Microsoft.EntityFrameworkCore
Microsoft.EntityFrameworkCore.Design
Microsoft.EntityFrameworkCore.Tools
程序包管理器控制台中执行：
Scaffold-DbContext "server=localhost;user id=postgres;password=123456;database=EF" Npgsql.EntityFrameworkCore.PostgreSQL
ef本身，查询，命令。不属于EF，它是C#的一个核心功能。 LINQ ，Lambda表达式 掌握
*/
namespace EFCore.Demo02;
public class Program
{
static async Task Main(params string[] args)
{
using(var context =new EfContext())
{
foreach(var item in context.Table1s)
{
Console.WriteLine($"id:{item.Id},content:{item.Content}");
}
}
}
}
3.2 demo03例子
新建数据库EF3，新建表TestTable3
自动生成：
Ef3Context.cs、TestTable3.cs
Ef3Context.cs
using System;
using System.Collections.Generic;
using Microsoft.EntityFrameworkCore;
namespace EfCore.Demo3;
public partial class Ef3Context : DbContext
{
public Ef3Context()
{
}
public Ef3Context(DbContextOptions<Ef3Context> options)
: base(options)
{
}
public virtual DbSet<TestTable3> TestTable3s { get; set; }
protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
#warning To protect potentially sensitive information in your connection string, you should move it out of source code. You can avoid scaffolding the connection string by using the Name= syntax to read it from configuration - see https://go.microsoft.com/fwlink/?linkid=2131148. For more guidance on storing connection strings, see http://go.microsoft.com/fwlink/?LinkId=723263.
=> optionsBuilder.UseNpgsql("server=localhost;user id=postgres;password=123456;database=EF3");
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
modelBuilder.Entity<TestTable3>(entity =>
{
entity.HasKey(e => e.Id).HasName("TestTable3_pkey");
entity.ToTable("TestTable3");
entity.Property(e => e.Id)
.ValueGeneratedNever()
.HasColumnName("ID");
entity.Property(e => e.Adress)
.HasMaxLength(100)
.IsFixedLength()
.HasColumnName("ADRESS");
entity.Property(e => e.Age).HasColumnName("AGE");
entity.Property(e => e.Name)
.HasMaxLength(100)
.IsFixedLength()
.HasColumnName("NAME");
});
OnModelCreatingPartial(modelBuilder);
}
partial void OnModelCreatingPartial(ModelBuilder modelBuilder);
}
TestTable3.cs
using System;
using System.Collections.Generic;
using System.Reflection.Metadata;
namespace EfCore.Demo3;
public partial class TestTable3
{
public int Id { get; set; }
public string? Name { get; set; }
public int? Age { get; set; }
public string? Adress { get; set; }
//添加部分
public override string ToString()
{
return $"Id:{Id},Name:{Name},Age:{Age},Adress:{Adress}";
}
}
Program.cs
/*
备注：
Scaffold-DbContext "server=localhost;user id=postgres;password=123456;database=EF3" Npgsql.EntityFrameworkCore.PostgreSQL
*/
using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.Metadata.Internal;
using EfCore.Demo3;
using System;
using System.Data;
namespace EFCore.Demo3;
public class Program
{
static async Task Main(params string[] args)
{
/*
using (var context = new MyDbContext())
{
context.Add(new Table_1 { Content = "新增第二条数据", Id = 2 });
await context.SaveChangesAsync();//保存后执行数据库
}
Console.WriteLine("第三步");
*/
Console.WriteLine("-------------------- 开始 -----------------------------");
//await Add();
//await Query();
//await whereQuery();
//await Update();
await Delete();
Console.WriteLine("-------------------- 结束 -----------------------------");
}
/// 十、问题处理
1、连接本地PostgreSQL数据库时报错
（1）问题
（2）对策
首先检查一下是不是没有启动PostgreSQL服务，因为没启动服务可能会报这个错误（我就是）；
方法如下：
win+R打开输入命令框，输入services.msc打开服务列表。右键“启动”
2、如何使用中文数据库
打开左上角file 如图所示
