Estos contenidos se han traducido de forma automática para su comodidad, pero Huawei Cloud no garantiza la exactitud de estos. Para consultar los contenidos originales, acceda a la versión en inglés.

Centro de ayuda/ GaussDB(DWS)/ Guía de gestión/ Conexión de clústeres/ Uso de la biblioteca de Python PyGreSQL para conectarse a un clúster

Actualización más reciente 2024-06-12 GMT+08:00

Ver PDF

Uso de la biblioteca de Python PyGreSQL para conectarse a un clúster

Después de crear un clúster de almacén de datos y usar la biblioteca de funciones de terceros PyGreSQL para conectarse al clúster, puede usar Python para acceder a GaussDB(DWS) y realizar varias operaciones en tablas de datos.

Preparativos antes de conectarse a un clúster

Se ha vinculado una EIP al clúster del almacén de datos.
Ha obtenido el nombre de usuario y la contraseña del administrador para iniciar sesión en la base de datos en el clúster del almacén de datos.
Los algoritmos MD5 pueden ser vulnerables a ataques de colisión y no se pueden usar para la verificación de contraseñas. Actualmente, GaussDB(DWS) utiliza el diseño de seguridad predeterminado. De forma predeterminada, la verificación de contraseñas MD5 está deshabilitada y esto puede causar fallos en las conexiones de clientes de código abierto. Le aconsejamos que establezca password_encryption_type en 1. Para obtener más información, consulte Modificación de parámetros de base de datos.
- Por motivos de seguridad, GaussDB(DWS) ya no usa MD5 para almacenar resúmenes de contraseñas de forma predeterminada. Como resultado, las unidades de código abierto y los clientes pueden no conectarse a la base de datos. Para utilizar el algoritmo MD5 utilizado en un protocolo de código abierto, debe modificar la política de contraseñas y crear un nuevo usuario, o cambiar la contraseña de un usuario existente.
- La base de datos almacena el resumen hash de las contraseñas en lugar del texto de la contraseña. Durante la verificación de contraseña, el sistema compara el resumen de hash con el resumen de contraseña enviado desde el cliente (están involucradas las operaciones de sal). Si cambia la política de algoritmo criptográfico, la base de datos no puede generar un nuevo resumen hash para la contraseña existente. Para fines de conectividad, debe cambiar manualmente su contraseña o crear un nuevo usuario. La nueva contraseña se cifrará usando el algoritmo hash y se almacenará para la autenticación en la próxima conexión.
Ha obtenido la dirección de red pública, incluida la dirección de IP y el número de puerto en el clúster del almacén de datos. Para obtener más información, véase Obtención de la dirección de conexión de clúster.
Ha instalado la biblioteca de funciones de terceros PyGreSQL.
Dirección de descarga: http://www.pygresql.org/download/index.html

Para obtener más información sobre las operaciones de instalación e despliegue, consulte http://www.pygresql.org/contents/install.html

En CentOS y Red Hat OS, ejecute el siguiente comando de yum:

          
               yum install PyGreSQL

PyGreSQL depende de la biblioteca dinámica libpq de PostgreSQL (versión de 32 bits o 64 bits, la que coincida con la versión de bits de PyGreSQL). En Linux, puede ejecutar el comando yum y no necesita instalar la biblioteca. Antes de usar PyGreSQL en Windows, necesita instalar libpq de cualquiera de las siguientes maneras:
- Instale PostgreSQL y configure las bibliotecas dinámicas libpq, ssl y crypto en la variable de entorno PATH.
- Instale psqlodbc y utilice las librerías dinámicas libpq, ssl y crypto que lleva el controlador ODBC de PostgreSQL.

Restricciones

PyGreSQL es una interfaz de cliente basada en PostgreSQL, y sus funciones no son totalmente compatibles con GaussDB(DWS). Para obtener más información, véase Tabla 1.

Las siguientes API son compatibles basadas en Python 3.8.5 y PyGreSQL 5.2.4.

**Tabla 1** API de PyGreSQL soportadas por DWS
PyGreSQL		Sí	Observaciones
Module functions and constants	connect – Abrir una conexión PostgreSQL	S	-
	get_pqlib_version - obtener la versión de libpq	S	-
	get/set_defhost - host de servidor predeterminado [DV]	S	-
	get/set_defport – puerto de servidor predeterminado [DV]	S	-
	get/set_defopt - opciones de conexión predeterminadas [DV]	S	-
	get/set_defbase – nombre de base de datos predeterminada [DV]	S	-
	get/set_defuser - usuario de base de datos predeterminado [DV]	S	-
	get/set_defpasswd - contraseña de base de datos predeterminada [DV]	S	-
	escape_string – escapar una cadena para su uso dentro de SQL	S	-
	escape_bytea - escape de datos binarios para su uso en SQL	S	-
	unescape_bytea – unescape datos que han sido recuperados como texto	S	-
	get/set_namedresult - conversión a tuplas con nombre	S	-
	get/set_decimal - tipo decimal que se utilizará para los valores numéricos	S	-
	get/set_decimal_point - marca decimal utilizada para los valores monetarios	S	-
	get/set_bool - si los valores booleanos se devuelven como objetos bool	S	-
	get/set_array - si las matrices se devuelven como objetos de lista	S	-
	get/set_bytea_escaped - si los datos bytea se devuelven escapados	S	-
	get/set_jsondecode – decodificación del formato JSON	S	-
	get/set_cast_hook - función de fallback typecast	S	-
	get/set_datestyle – asumir un estilo de fecha fijo	S	-
	get/set_typecast - Tipografía personalizada	S	-
	cast_array/record - analizadores rápidos de matrices y registros	S	-
	Type helpers	S	-
	Module constants	S	-
Connection – The connection object	query – ejecutar una cadena de comando de SQL	S	-
	send_query - ejecuta una cadena de comandos SQL de forma asincrónica	S	-
	query_prepared – ejecutar una sentencia preparada	S	-
	prepare – crear una sentencia preparada	S	-
	describir_prepared - describir una sentencia preparada	S	-
	reset – restablecer la conexión	S	-
	poll - completa una conexión asincónica	S	-
	cancelar - abandonar el procesamiento del comando SQL actual	S	-
	close – cerrar la conexión de base de datos	S	-
	transacción - obtener el estado actual de la transacción	S	-
	parámetro: obtener una configuración de parámetro de servidor actual	S	-
	date_format – obtener el formato de fecha utilizado actualmente	S	-
	fileno – obtener el socket utilizado para conectarse a la base de datos	S	-
	set_non_blocking - establecer el estado de no bloqueo de la conexión	S	-
	is_non_blocking - reportar el estado de bloqueo de la conexión	S	-
	getnotify - obtener la última notificación desde el servidor	N	La base de datos no es compatible con listen/notify.
	inserttable – insertar una lista en una tabla	S	Utilice comillas dobles ("") para comillas \n en el comando copy.
	get/set_notice_receiver - Receptor de aviso personalizado	S	-
	putline – escribir una línea en el socket de servidor [DA]	S	-
	getline - obtener una línea desde el socket de servidor [DA]	S	-
	endcopy - sincronizar cliente y servidor [DA]	S	-
	locreate – crear un objeto grande en la base de datos [LO]	N	Operaciones relacionadas con objetos grandes
	getlo – construir un objeto grande a partir de oid dado [LO]	N	Operaciones relacionadas con objetos grandes
	loimport – importar un archivo a un objeto grande [LO]	N	Operaciones relacionadas con objetos grandes
	Object attributes	S	-
La clase de envoltura de BD	Initialization	S	-
	pkey – devolver la clave principal de una tabla	S	-
	get_databases - obtener una lista de bases de datos en el sistema	S	-
	get_relations - obtener una lista de relaciones en la base de datos conectada	S	-
	get_tables - obtener una lista de tablas en la base de datos conectada	S	-
	get_attnames - obtener los nombres de atributo de una tabla	S	-
	has_table_privilege – comprobar privilegio de tabla	S	-
	get/set_parameter - obtener o establecer parámetros de tiempo de ejecución	S	-
	begin/commit/rollback/savepoint/release – gestión de transacciones	S	-
	get – obtener una fila de una tabla o vista de base de datos	S	-
	insert – insertar una fila en una tabla de base de datos	S	-
	update – actualizar una fila en una tabla de base de datos	S	-
	upsert – insertar una fila con resolución de conflictos	S	-
	query – ejecutar una cadena de comandos de SQL	Y	-
	Query_formatted – ejecutar una cadena de comando SQL formateada	S	-
	query_prepared – ejecutar una sentencia preparada	S	-
	prepare – crear una sentencia preparada	S	-
	describir_prepared - describir una sentencia preparada	S	-
	delete_prepared - eliminar una sentencia preparada	S	-
	clear – borrar valores de fila en la memoria	S	-
	delete – eliminar una fila de una tabla de base de datos	S	Una tupla debe tener clave única o clave primaria.
	truncate – vaciar rápidamente tablas de bases de datos	S	-
	get_as_list/dict - leer una tabla como una lista o diccionario	S	-
	escape_literal/identifier/string/bytea - escape para SQL	S	-
	unescape_bytea - datos unescape recuperados de la base de datos	S	-
	encode/decode_json – codificar y decodificar datos JSON	S	-
	use_regtypes - determinar el uso de nombres de tipo regulares	S	-
	notification_handler: crear un controlador de notificaciones	N	La base de datos no es compatible con listen/notify.
	Atributos de la clase envoltura de base de datos	S	-
Métodos de consulta	getresult - obtener valores de consulta como lista de tuplas	S	-
	dictresult/dictiter – obtener valores de consulta como diccionarios	S	-
	nameresult/namediter – obtener los valores de consulta como tuplas con nombre	S	-
	scalarresult/scalariter – obtener valores de consulta como escalares	S	-
	one/onedict/onenamed/onescalar – obtener un resultado de una consulta	S	-
	single/singledict/singlenamed/singlescalar – obtener un único resultado de una consulta	S	-
	campos de lista - campos de lista nombres del resultado de la consulta anterior	S	-
	fieldname, fieldnum - conversión de nombre/número de campo	S	-
	fieldinfo – información detallada sobre los campos de resultados de consulta	S	-
	ntuples - devolver el número de tuplas en el objeto de consulta	S	-
	memsize - devolver el número de bytes asignados por el resultado de la consulta	S	-
LargeObject - Objetos grandes	open – abrir un objeto grande	N	Operaciones relacionadas con objetos grandes
	close – cerrar un objeto grande	N	Operaciones relacionadas con objetos grandes
	read, write, tell, seek, unlink – manejo de objetos grandes como archivos	N	Operaciones relacionadas con objetos grandes
	size – obtener el tamaño de objeto grande	N	Operaciones relacionadas con objetos grandes
	export – guardar un objeto grande en un archivo	N	Operaciones relacionadas con objetos grandes
	Object attributes	N	Operaciones relacionadas con objetos grandes
El controlador de notificaciones	Instalar el controlador de notificaciones	N	La base de datos no es compatible con listen/notify.
	Invocar el controlador de notificaciones	N	La base de datos no es compatible con listen/notify.
	Envío de notificaciones	N	La base de datos no es compatible con listen/notify.
	Métodos auxiliares	N	La base de datos no es compatible con listen/notify.
pgdb
Funciones y constantes del módulo	connect – Abrir una conexión PostgreSQL	S	-
	get/set/reset_typecast - Controlar las funciones globales de tipocast	S	-
	Constantes del módulo	S	-
	Errores generados por este módulo	S	-
Conexión - El objeto de conexión	close – cerrar la conexión	S	-
	commit – confirmar la conexión	S	-
	rollback – revertir la conexión	S	-
	cursor - devolver un nuevo objeto cursor	S	-
	Atributos que no forman parte del estándar	S	-
Cursor - El objeto cursor	description - detalles sobre las columnas de resultados	S	-
	rowcount – número de filas del resultado	S	-
	close – cerrar el cursor	S	-
	execute – ejecutar una operación de base de datos	S	-
	executemany – ejecutar muchas operaciones de base de datos similares	S	-
	callproc – Invocar a un procedimiento almacenado	S	-
	fetchone – acceder a siguiente fila del resultado de la consulta	S	-
	fetchmany – acceder al siguiente conjunto de filas del resultado de la consulta	S	-
	fetchall – acceder a todas las filas del resultado de consulta	S	-
	arraysize - el número de filas que se van a recuperar a la vez	S	-
	Métodos y atributos que no forman parte del estándar	S	-
Tipo – Tipo de objetos y constructores	Constructores de tipo	S	-
Tipo – Tipo de objetos y constructores	Escribir objetos	S	-

Uso de la biblioteca de funciones de terceros PyGreSQL para conectarse a un clúster (Linux)

Inicie sesión en el entorno de Linux como usuario root.

Ejecute el siguiente comando para crear el archivo python_dws.py:

      
           vi python_dws.py

Copie y pegue el siguiente contenido en el archivo python_dws.py:

      
       
         
         
           #!/usr/bin/env python3
# _*_ encoding:utf-8 _*_
from __future__ import print_function
import pg
def create_table(connection):
    print("Begin to create table")
    try:
        connection.query("drop table if exists test;"
                         "create table test(id int, name text);")
    except pg.InternalError as e:
        print(e)
    else:
        print("Table created successfully")
def insert_data(connection):
    print("Begin to insert data")
    try:
        connection.query("insert into test values(1,'number1');")
        connection.query("insert into test values(2,'number2');")
        connection.query("insert into test values(3,'number3');")
    except pg.InternalError as e:
        print(e)
    else:
        print("Insert data successfully")
def update_data(connection):
    print("Begin to update data")
    try:
        result = connection.query("update test set name = 'numberupdated' where id=1;")
        print("Total number of rows updated :", result)
        result = connection.query("select * from test order by 1;")
        rows = result.getresult()
        for row in rows:
            print("id = ", row[0])
            print("name = ", row[1], "\n")
    except pg.InternalError as e:
        print(e)
    else:
        print("After Update, Operation done successfully")
def delete_data(connection):
    print("Begin to delete data")
    try:
        result = connection.query("delete from test where id=3;")
        print("Total number of rows deleted :", result)
        result = connection.query("select * from test order by 1;")
        rows = result.getresult()
        for row in rows:
            print("id = ", row[0])
            print("name = ", row[1], "\n")
    except pg.InternalError as e:
        print(e)
    else:
        print("After Delete,Operation done successfully")
def select_data(connection):
    print("Begin to select data")
    try:
        result = connection.query("select * from test order by 1;")
        rows = result.getresult()
        for row in rows:
            print("id = ", row[0])
            print("name = ", row[1])
    except pg.InternalError as e:
        print(e)
        print("select failed")
    else:
        print("Operation done successfully")
if __name__ == '__main__':
    try:
        conn = pg.DB(host='10.154.70.231',
                     port=8000,
                     dbname='gaussdb', # Database to be connected
                     user='dbadmin',
                     passwd='password')  # Database user password
    except pg.InternalError as ex:
        print(ex)
        print("Connect database failed")
    else:
        print("Opened database successfully")
        create_table(conn)
        insert_data(conn)
        select_data(conn)
        update_data(conn)
        delete_data(conn)
        conn.close()

          

        

      
     

Alternativamente, utilice la interfaz dbapi.

      
       
         
         
           #!/usr/bin/python
# -*- coding: UTF-8 -*-
from __future__ import print_function
import pg
import pgdb
def create_table(connection):
    print("Begin to create table")
    try:
        cursor = connection.cursor()
        cursor.execute("drop table if exists test;"
                       "create table test(id int, name text);")
        connection.commit()
    except pg.InternalError as e:
        print(e)
    else:
        print("Table created successfully")
        cursor.close()
def insert_data(connection):
    print("Begin to insert data")
    try:
        cursor = connection.cursor()
        cursor.execute("insert into test values(1,'number1');")
        cursor.execute("insert into test values(2,'number2');")
        cursor.execute("insert into test values(3,'number3');")
        connection.commit()
    except pg.InternalError as e:
        print(e)
    else:
        print("Insert data successfully")
        cursor.close()
def update_data(connection):
    print("Begin to update data")
    try:
        cursor = connection.cursor()
        cursor.execute("update test set name = 'numberupdated' where id=1;")
        connection.commit()
        print("Total number of rows updated :", cursor.rowcount)
        cursor.execute("select * from test;")
        rows = cursor.fetchall()
        for row in rows:
            print("id = ", row[0])
            print("name = ", row[1], "\n")
    except pg.InternalError as e:
        print(e)
    else:
        print("After Update, Operation done successfully")
def delete_data(connection):
    print("Begin to delete data")
    try:
        cursor = connection.cursor()
        cursor.execute("delete from test where id=3;")
        connection.commit()
        print("Total number of rows deleted :", cursor.rowcount)
        cursor.execute("select * from test;")
        rows = cursor.fetchall()
        for row in rows:
            print("id = ", row[0])
            print("name = ", row[1], "\n")
    except pg.InternalError as e:
        print(e)
    else:
        print("After Delete,Operation done successfully")
def select_data(connection):
    print("Begin to select data")
    try:
        cursor = connection.cursor()
        cursor.execute("select * from test;")
        rows = cursor.fetchall()
        for row in rows:
            print("id = ", row[0])
            print("name = ", row[1], "\n")
    except pg.InternalError as e:
        print(e)
        print("select failed")
    else:
        print("Operation done successfully")
        cursor.close()
if __name__ == '__main__':
    try:
        conn = pgdb.connect(host='10.154.70.231',
                                      port='8000',
                                      database='gaussdb', # Database to be connected
                                      user='dbadmin',
                                      password='password') # Database user password
    except pg.InternalError as ex:
        print(ex)
        print("Connect database failed")
    else:
        print("Opened database successfully")
        create_table(conn)
        insert_data(conn)
        select_data(conn)
        update_data(conn)
        delete_data(conn)
        conn.close()

          

        

      
     

Cambie la dirección de red pública, el número de puerto del clúster, el nombre de la base de datos, el nombre de usuario de la base de datos y la contraseña de la base de datos en el archivo python_dws.py basándose en la información real del clúster.

La API de PyGreSQL no proporciona la capacidad de reintento de conexión. Es necesario implementar el procesamiento de reintentos en el código de servicio.

      
                   conn = pgdb.connect(host='10.154.70.231',
                                      port='8000',
                                      database='gaussdb', # Database to be connected
                                      user='dbadmin',
                                      password='password') # Database user password

Ejecute el siguiente comando para conectarse al clúster mediante la biblioteca de funciones de terceros PyGreSQL:
1

python python_dws.py

Uso de la biblioteca de funciones de terceros PyGreSQL para conectarse a un clúster (Windows)

En el sistema operativo Windows, haga clic en el botón Start, escriba cmd en el cuadro de búsqueda y haga clic en cmd.exe en la lista de resultados para abrir la interfaz de línea de comandos (CLI).

En la CLI, ejecute el siguiente comando para crear el archivo python_dws.py:

      
           type nul> python_dws.py

Copie y pegue el siguiente contenido en el archivo python_dws.py:

      
       
         
         
           #!/usr/bin/env python3
# _*_ encoding:utf-8 _*_
from __future__ import print_function
import pg
def create_table(connection):
    print("Begin to create table")
    try:
        connection.query("drop table if exists test;"
                         "create table test(id int, name text);")
    except pg.InternalError as e:
        print(e)
    else:
        print("Table created successfully")
def insert_data(connection):
    print("Begin to insert data")
    try:
        connection.query("insert into test values(1,'number1');")
        connection.query("insert into test values(2,'number2');")
        connection.query("insert into test values(3,'number3');")
    except pg.InternalError as e:
        print(e)
    else:
        print("Insert data successfully")
def update_data(connection):
    print("Begin to update data")
    try:
        result = connection.query("update test set name = 'numberupdated' where id=1;")
        print("Total number of rows updated :", result)
        result = connection.query("select * from test order by 1;")
        rows = result.getresult()
        for row in rows:
            print("id = ", row[0])
            print("name = ", row[1], "\n")
    except pg.InternalError as e:
        print(e)
    else:
        print("After Update, Operation done successfully")
def delete_data(connection):
    print("Begin to delete data")
    try:
        result = connection.query("delete from test where id=3;")
        print("Total number of rows deleted :", result)
        result = connection.query("select * from test order by 1;")
        rows = result.getresult()
        for row in rows:
            print("id = ", row[0])
            print("name = ", row[1], "\n")
    except pg.InternalError as e:
        print(e)
    else:
        print("After Delete,Operation done successfully")
def select_data(connection):
    print("Begin to select data")
    try:
        result = connection.query("select * from test order by 1;")
        rows = result.getresult()
        for row in rows:
            print("id = ", row[0])
            print("name = ", row[1])
    except pg.InternalError as e:
        print(e)
        print("select failed")
    else:
        print("Operation done successfully")
if __name__ == '__main__':
    try:
        conn = pg.DB(host='10.154.70.231',
                     port=8000,
                     dbname='gaussdb', # Database to be connected
                     user='dbadmin',
                     passwd='password')  # Database user password
    except pg.InternalError as ex:
        print(ex)
        print("Connect database failed")
    else:
        print("Opened database successfully")
        create_table(conn)
        insert_data(conn)
        select_data(conn)
        update_data(conn)
        delete_data(conn)
        conn.close()

          

        

      
     

Alternativamente, utilice la interfaz dbapi.

      
       
         
         
           #!/usr/bin/python
# -*- coding: UTF-8 -*-
from __future__ import print_function
import pg
import pgdb
def create_table(connection):
    print("Begin to create table")
    try:
        cursor = connection.cursor()
        cursor.execute("drop table if exists test;"
                       "create table test(id int, name text);")
        connection.commit()
    except pg.InternalError as e:
        print(e)
    else:
        print("Table created successfully")
        cursor.close()
def insert_data(connection):
    print("Begin to insert data")
    try:
        cursor = connection.cursor()
        cursor.execute("insert into test values(1,'number1');")
        cursor.execute("insert into test values(2,'number2');")
        cursor.execute("insert into test values(3,'number3');")
        connection.commit()
    except pg.InternalError as e:
        print(e)
    else:
        print("Insert data successfully")
        cursor.close()
def update_data(connection):
    print("Begin to update data")
    try:
        cursor = connection.cursor()
        cursor.execute("update test set name = 'numberupdated' where id=1;")
        connection.commit()
        print("Total number of rows updated :", cursor.rowcount)
        cursor.execute("select * from test;")
        rows = cursor.fetchall()
        for row in rows:
            print("id = ", row[0])
            print("name = ", row[1], "\n")
    except pg.InternalError as e:
        print(e)
    else:
        print("After Update, Operation done successfully")
def delete_data(connection):
    print("Begin to delete data")
    try:
        cursor = connection.cursor()
        cursor.execute("delete from test where id=3;")
        connection.commit()
        print("Total number of rows deleted :", cursor.rowcount)
        cursor.execute("select * from test;")
        rows = cursor.fetchall()
        for row in rows:
            print("id = ", row[0])
            print("name = ", row[1], "\n")
    except pg.InternalError as e:
        print(e)
    else:
        print("After Delete,Operation done successfully")
def select_data(connection):
    print("Begin to select data")
    try:
        cursor = connection.cursor()
        cursor.execute("select * from test;")
        rows = cursor.fetchall()
        for row in rows:
            print("id = ", row[0])
            print("name = ", row[1], "\n")
    except pg.InternalError as e:
        print(e)
        print("select failed")
    else:
        print("Operation done successfully")
        cursor.close()
if __name__ == '__main__':
    try:
        conn = pgdb.connect(host='10.154.70.231',
                                      port='8000',
                                      database='gaussdb', # Database to be connected
                                      user='dbadmin',
                                      password='password') # Database user password
    except pg.InternalError as ex:
        print(ex)
        print("Connect database failed")
    else:
        print("Opened database successfully")
        create_table(conn)
        insert_data(conn)
        select_data(conn)
        update_data(conn)
        delete_data(conn)
        conn.close()

          

        

      
     

La API de PyGreSQL no proporciona la capacidad de reintento de conexión. Es necesario implementar el procesamiento de reintentos en el código de servicio.

      
                   conn = pgdb.connect(host='10.154.70.231',
                                      port='8000',
                                      database='gaussdb', # Database to be connected
                                      user='dbadmin',
                                      password='password') # Database user password