精华内容
下载资源
问答
  • python 事务

    2019-03-09 23:47:00
    事务命令 事务指逻辑上的一组操作,组成这组操作的各个单元,要不全部成功,要不全部不成功。 数据库开启事务命令 -- start transaction 开启事务 -- Rollback 回滚事务,即撤销指定的sql语句(只能回退...

    事务命令

    事务指逻辑上的一组操作,组成这组操作的各个单元,要不全部成功,要不全部不成功。

    数据库开启事务命令     

    --        start transaction 开启事务
    --        Rollback 回滚事务,即撤销指定的sql语句(只能回退insert delete update语句),回滚到上一次commit的位置
    --        Commit 提交事务,提交未存储的事务
    -- 
    --        savepoint 保留点 ,事务处理中设置的临时占位符 你可以对它发布回退(与整个事务回退不同)     

    转账实例:

    1
    2
    UPDATE account set balance=balance-5000 WHERE name=”yuan”;
    UPDATE account set balance=balance+5000 WHERE name=”xialv”;
    复制代码
    create table test2(id int PRIMARY KEY auto_increment,name VARCHAR(20)) engine=innodb;
    INSERT INTO test2(name) VALUE ("alvin"),
                                  ("yuan"),
                                  ("xialv");
    
    
    
    start transaction;
    insert into test2 (name)values('silv');
    select * from test2;
    commit;
    
    
    -- 保留点
    
    start transaction;
    insert into test2 (name)values('wu');
    savepoint insert_wu;
    select * from test2;
    
    
    
    delete from test2 where id=4;
    savepoint delete1;
    select * from test2;
    
    
    delete from test2 where id=1;
    savepoint delete2;
    select * from test2;
    
    rollback to delete1;
    
    
    select * from test2;
    复制代码

    python中调用数据库启动事务的方式

    复制代码
    import pymysql
    
    #添加数据
    
    conn = pymysql.connect(host='127.0.0.1', port=3306, user='root', passwd='', db='yyy')
    
    cursor = conn.cursor()
    
    
    try:
        insertSQL0="INSERT INTO ACCOUNT2 (name,balance) VALUES ('oldboy',4000)"
        insertSQL1="UPDATE account2 set balance=balance-30 WHERE name='yuan'"
        insertSQL2="UPDATE account2 set balance=balance+30 WHERE name='xialv'"
    
        cursor = conn.cursor()
    
        cursor.execute(insertSQL0)
        conn.commit()
    
        cursor.execute(insertSQL1)
        raise Exception
        cursor.execute(insertSQL2)
        cursor.close()
        conn.commit()
    
    except Exception as e:
    
        conn.rollback()
        conn.commit()
    
    
    cursor.close()
    conn.close()
    复制代码

    事务特性

    <1> 原子性(Atomicity):原子性是指事务是一个不可分割的工作单位,事务中的操作要么都发生,要么都不发生。

    <2> 一致性(Consistency):事务前后数据的完整性必须保持一致。在事务执行之前数据库是符合数据完整性约束的,无论事务是否执行成功,事务结束后的数据库中的数据也应该是符合完整性约束的。在某一时间点,如果数据库中的所有记录都能保证满足当前数据库中的所有约束,则可以说当前的数据库是符合数据完整性约束的。
    比如删部门表前应该删掉关联员工(已经建立外键),如果数据库服务器发生错误,有一个员工没删掉,那么此时员工的部门表已经删除,那么就不符合完整性约束了,所以这样的数据库也就性能太差啦!

    <3>隔离性(Isolation):事务的隔离性是指多个用户并发访问数据库时,一个用户的事务不能被其它用户的事务所干扰,多个并发事务之间数据要相互隔离。

    <4>持久性(Durability):持久性是指一个事务一旦被提交,它对数据库中数据的改变就是永久性的,接下来即使数据库发生故障也不应该对其有任何影响。

    三、隔离性:
    将数据库设计为串行化程的数据库,让一张表在同一时间内只能有一个线程来操作。如果将数据库设计为这样,那数据库的效率太低了。所以数据库的设计这没有直接将数据库设计为串行化,而是为数据库提供多个隔离级别选项,使数据库的使用者可以根据使用情况自己定义到底需要什么样的隔离级别。

    不考虑隔离性可能出现的问题:

    脏读

    复制代码
    --一个事务读取到了另一个事务未提交的数据,这是特别危险的,要尽力防止。
            a 1000
            b 1000
            a:
                start transactionupdate set money=money+100 where name=b;
            b:
                start transaction;
                select * from account where name=b;--1100
                commit;
            a:
                rollback;
            b:  start transaction;
                select * from account where name=b;--1000
    复制代码

    不可重复读

    复制代码
    --在一个事务内读取表中的某一行数据,多次读取结果不同。(一个事务读取到了另一个事务已经提交
    -- 的数据--增加记录、删除记录、修改记录),在某写情况下并不是问题,在另一些情况下就是问题。
    
    a:
    start transaction;
    select 活期账户 from account where name=b;--1000    活期账户:1000
    select 定期账户 from account where name=b;--1000   定期账户:1000
    select 固定资产 from account where name=b;--1000   固定资产:1000
    ------------------------------
    b:
    start transaction;
    update set money=0 where name=b;
    commit;
    ------------------------------
    select 活期+定期+固定 from account where name=b; --2000 总资产: 2000
    复制代码

    虚读

    复制代码
    是指在一个事务内读取到了别的事务插入的数据,导致前后读取不一致。(一个事务读取到了另一个事务已经提交的数据---增加记录、删除记录),在某写情况下并不是问题,在另一些情况下就是问题。
    
    b 1000
    c 2000
    d 3000
    a:
    start transaction
    select sum(money) from account;---3000       3000
    -------------------
    d:start transaction;
    insert into account values(d,3000);
    commit;
    -------------------
    select count(*)from account;---3                         3
    3000/3 = 1000                                            1000   
    复制代码

    四个隔离级别:
    Serializable:可避免脏读、不可重复读、虚读情况的发生。(串行化)
    Repeatable read:可避免脏读、不可重复读情况的发生。(可重复读)不可以避免虚读
    Read committed:可避免脏读情况发生(读已提交)
    Read uncommitted:最低级别,以上情况均无法保证。(读未提交)

    安全性考虑:Serializable>Repeatable read>Read committed>Read uncommitted
    数据库效率:Read uncommitted>Read committed>Repeatable read>Serializable

    一般情况下,我们会使用Repeatable read、Read committed mysql数据库默认的数据库隔离级别Repeatable read

    mysql中设置数据库的隔离级别语句:

    1
    set [global/session] transaction isolation level xxxx;

    如果使用global则修改的是数据库的默认隔离级别,所有新开的窗口的隔离级别继承自这个默认隔离级别如果使用session修改,则修改的是当前客户端的隔离级别,和数据库默认隔离级别无关。当前的客户端是什么隔离级别,就能防止什么隔离级别问题,和其他客户端是什么隔离级别无关。
    mysql中设置数据库的隔离级别语句:

    1
    select @@tx_isolation;

     

     

     

     

    cp :https://www.cnblogs.com/yuanchenqi/articles/6437362.html

    转载于:https://www.cnblogs.com/icemonkey/p/10503766.html

    展开全文
  • python 事务操作

    2020-07-04 17:47:28
    python事务操作需求背景实现思路 需求背景 自己在写flask项目时,一个接口要对数据库进行多次操作,在项目使用过程中,发现用户进行操作后,在代码执行过程中会报错,但是数据库没有回滚,导致部分功能没有完全...

    需求背景

    自己在写flask项目时,一个接口要对数据库进行多次操作,在项目使用过程中,发现用户进行操作后,在代码执行过程中会报错,但是数据库没有回滚,导致部分功能没有完全执行

    实现思路

    获取数据库的链接,捕获该接口对数据的操作逻辑
    如果在这其中有部分逻辑出了问题,则在expect中回滚

    代码实现

    try:
        insertSQL0="INSERT INTO ACCOUNT2 (name,balance) VALUES ('oldboy',4000)"
        insertSQL1="UPDATE account2 set balance=balance-30 WHERE name='yuan'"
        insertSQL2="UPDATE account2 set balance=balance+30 WHERE name='xialv'"
    
        cursor = conn.cursor()
    
        cursor.execute(insertSQL0)
        conn.commit()
    
        cursor.execute(insertSQL1)
        raise Exception
        cursor.execute(insertSQL2)
        cursor.close()
        conn.commit()
    
    except Exception as e:
    
        conn.rollback()
        conn.commit()
    
    
    展开全文
  • python 事务执行10w+插入更新代码 之前一条条插入更新10w+大概执行了四五十分钟,后面组合sql语句,一次插入200条节省了十几分钟而已,后面用事物,大概两分钟,效率好了很多。这是主要逻辑代码,数据修改成自己的...

    python 事务执行10w+插入更新代码

     之前一条条插入更新10w+大概执行了四五十分钟,后面组合sql语句,一次插入200条节省了十几分钟而已,后面用事物,大概两分钟,效率好了很多。这是主要逻辑代码,数据修改成自己的就可以了,如果不行,可以微信加我li1236li。
    

    代码块

    #!/usr/bin/env python
    # -*- coding: utf-8 -*-
    import MySQLdb
    
    import time
    import datetime
    
    connection = MySQLdb.connect(host='127.0.0.1',
                                port='3306',
                                user='root',
                                passwd='123456',
                                db='test')
    
    def merge_sql(table,symbol,src,data):
        sql = """ insert into %s set symbol='%s',close_pri=%f,
                        open_pri=%f,max_pri=%f,min_pri=%f,total_vol=%f,
                        update_time=%d, source='%s' on duplicate key update symbol='%s',close_pri=%f,
                        open_pri=%f,max_pri=%f,min_pri=%f,total_vol=%f
                        """ % (table, symbol, data['close']),  data['open'],  data['high'],  data['low'], data['total'], int(data['ts'],src, symbol,  data['close'],  data['open'],  data['high'],  data['low'], data['total'])
        return sql
    
    
    def handle_binance():
        try:
            cursor = connection.cursor()
            start_time = time.time()  
            temp_list = []
            for i in range(0,1500): 
                temp_list = symbol_list[i:i+40] 
                print temp_list  
                for j in range(0,100):
                    symbol = 'binance'
                    sql = '' 
                    #数据   
                    data = {'ts':1,'close':i,'open':j,'high':1,'low':1,'total':1}
                        sql = merge_sql('tableName', symbol, 'binance', data) + ';'        
                        if sql == '':
                            continue        
                        cursor.execute(sql)
            connection.commit()
            connection.close()
            end_time = time.time()
            total_time = end_time - start_time
            print '数据花费总时间为:' + str(total_time) + '秒'
        except Exception as e:
            print e            
    
    def main():
        try:
            handle_binance()
        except Exception as e:
            print e
    if __name__ == '__main__':
        main()           
    
    
    
    展开全文
  • 通过 Python 管理数据事务、处理大型对象 事务包含一组 SQL 语句,这组 SQL 语句构成数据库中的一个逻辑操作,如转帐或信用卡支付操作。将 SQL 语句聚合到一个逻辑组中,其效果完全取决于事务的成败,事务成功则...

    通过 Python 管理数据事务、处理大型对象

    事务包含一组 SQL 语句,这组 SQL 语句构成数据库中的一个逻辑操作,如转帐或信用卡支付操作。将 SQL 语句聚合到一个逻辑组中,其效果完全取决于事务的成败,事务成功则提交更改,事务失败则撤销内部 SQL 的结果(整体撤消)。通过 Python,您可以利用 Oracle 数据库所提供的原子性、一致性、孤立性和持久性优势。

    利用大型对象,可在一列中保存大量数据(从 Oracle Databaase 11g 起该数量可达到 128TB),但这种灵活性是要付出代价的 — 用于访问和操作 LOB 的方法不同于常规查询方法。

    注意:Python 的 2.x 版本已升级到 2.6,cx_Oracle 模块已发展到 5.0。从现在起,在 MO+P 中将使用这些版本。此外,本教程依旧基于可用于 Oracle Database 10g 第 2 版快捷版中的 HR 模式。

    这就是 ACID

    一个数据库事务是一些语句组成的一个逻辑组,具有以下四个特征:

    • 原子性:所有操作要么全部成功,要么全部失败
    • 一致性:提交事务不会导致数据损坏
    • 孤立性:其他事务始终不知道此事务的执行
    • 持久性:即使在数据库崩溃的情况下,事务中提交的操作也将持续有效。

    Python Oracle 数据库 API 提供了一种处理事务的自然方式,可将对数据的逻辑操作存储在数据库回滚段中以等待最终的决定:是提交还是回滚整组语句。

    当第一条 SQL 语句通过 cursor.execute() 方法传给数据库时,一个事务就启动了。当没有其他事务已从该会话启动时,可以使用 db.begin() 方法显式启动一个新事务。为了获得最高一致性,当连接对象被关闭或删除时,cx_Oracle 会默认回滚所有事务。

    cx_Oracle.Connection.autocommit 属性仍可设置为 1,从而使 Oracle 可提交通过 cursor.execute* 系列方法发出的每条语句。开发人员还应知道,由于 Oracle 的 DDL 不是事务性的,所有 DDL 语句都会隐式提交。最后,与 SQL*Plus 相反,用 db.close() 关闭连接不会提交正在进行的事务。

    有一些 Oracle 事务语句包装在 cx_Oracle 中,如 db.begin()、db.commit() 和 db.rollback(),但您可通过显式地调用 SET TRANSACTION 语句来使用其余事务语句。无论如何,新的事务从会话中的首个 DML 开始,因此没必要显式进行,除非您需要利用特定的事务属性,如 SET TRANSACTION [ READ ONLY | ISOLATION LEVEL SERIALIZABLE ]。

    我们来看一个执行具有事务特征的 HR 操作的类:

    import cx_Oracle
     
    class HR:
      def __enter__(self):
        self.__db = cx_Oracle.Connection("hr/hrpwd@localhost:1521/XE")
        self.__cursor = self.__db.cursor()
        return self 
      
      def __exit__(self, type, value, traceback): 
        self.__db.close()
      
      def swapDepartments(self, employee_id1, employee_id2):
        assert employee_id1!=employee_id2
        
        select_sql = """select employee_id, department_id from employees
          where employee_id in (:1, :2)"""
        update_sql = "update employees set department_id=:1 where employee_id=:2"
    
        self.__db.begin()
        self.__cursor.execute(select_sql, (employee_id1, employee_id2))
        D = dict(self.__cursor.fetchall())
        self.__cursor.execute(update_sql, (D[employee_id2], employee_id1))
        self.__cursor.execute(update_sql, (D[employee_id1], employee_id2))
        self.__db.commit()
     
      def raiseSalary(self, employee_ids, raise_pct):
        update_sql = "update employees set salary=salary*:1 where employee_id=:2"
        
        self.__db.begin()
    
        for employee_id in employee_ids:
          try:
            self.__cursor.execute(update_sql, [1+raise_pct/100, employee_id])
            assert self.__cursor.rowcount==1
          except AssertionError:
            self.__db.rollback()
            raise Warning, "invalid employee_id (%s)" % employee_id
    
        self.__db.commit()
     
    if __name__ == "__main__":
      with HR() as hr:
        hr.swapDepartments(106, 116)
        hr.raiseSalary([102, 106, 116], 20)
    

    上述代码中定义了两个方法:一个方法可在指定的员工之间互换部门,另一个方法可为任意数量的员工加薪。为了安全起见,此类操作只能通过事务实现。为确保不会发生其他事务,这两个方法中显式调用了 self.__db.begin()(否则会引发 DatabaseError ORA-01453 错误)。双下划线前缀在 Python 中具有特殊含义,因为该语言实际上不允许您声明私有变量(类中一切皆为公有),从而增加了变量的访问难度:变量是通过 _Class__Member 语法(上例中的 _HR__db 和 _HR_cursor)公开的。同时,我们在该类中声明 __enter__ 和 __exit__ 方法,这样我们可以使用 WITH 语句,在 WITH 代码块结束时会自动关闭连接。

    除了通过 db.commit() 和 db.rollback() 语句执行 DCL 语句的标准方式外,还可使用 cursor.execute() 方法运行原始的 SQL 命令(例如,为了能够使用保存点)。使用 cursor.execute('ROLLBACK') 和 db.rollback() 除以下之外并无任何不同:前者可以带额外的参数,如 cursor.execute('ROLLBACK TO SAVEPOINT some_savepoint')。SQL 方法还需要对命令像一般 SQL 语句一样解析和执行,而 db.commit() 和 db.rollback() 方法映射到一个低级 API 调用并允许 cx_Oracle 驱动程序跟踪事务状态。

    大型对象 (LOB)

    提到 Oracle 数据库的表列可用的数据类型,VARCHAR2 最多只能存储 4000 个字节的值。大型对象以其存储大型数据(如文本、图像、视频和其他多媒体格式)的能力而适用于大容量存储的情况。并且以您几乎不能称之为有限的存储能力而适用于这种情况 — 一个 LOB 的最大容量可高达 128 TB(自 11g 第 2 版开始)。

    在 Oracle 数据库中可以使用几种类型的 LOB:二进制大型对象 (BLOB)、字符大型对象 (CLOB)、国家字符集大型对象 (NCLOB) 和外部二进制文件 (BFILE)。最后这种 LOB 用于以只读模式访问外部操作系统文件,而所有其他类型的 LOB 能以永久模式或临时模式在数据库中存储大量数据。每个 LOB 包含一个实际值和一个指向该值的小型定位器。传递 LOB 通常只是意味着传递 LOB 定位器。

    在任何给定时间,一个 LOB 只能处于以下三种已定义状态之一:NULL、empty 或 populated。这类似于其他 RDBMS 引擎中常规 VARCHAR 列的行为(empty 字符串不等同于 NULL)。最后,对 LOB 有几个限制,其中的主要限制是:

    • LOB 不能是主键
    • LOB 不能是集群的一部分
    • LOB 不能与 DISTINCT、ORDER BY 和 GROUP BY 子句一起使用

    Oracle Database Application Developer's Guide 中提供了有关大型对象的大量文档资料。

    Python 的 cx_Oracle 模块支持对所有类型 LOB 的访问:

    >>> [i for i in dir(cx_Oracle) if i.endswith('LOB') or i=='BFILE'] 
    ['BFILE', 'BLOB', 'CLOB', 'LOB', 'NCLOB'] 
    

    cx_Oracle 中针对所有那些不能自动断定其长度或类型的 Oracle 类型提供了一种特殊的数据类型。该数据类型专门用于处理存储过程的 IN/OUT 参数。我们来看一个变量对象,它填充了 1 MB 的数据(将一个哈希字符重复 2 的 20 次方):

     
    >>> db = cx_Oracle.Connection('hr/hrpwd@localhost:1521/XE') 
    >>> cursor = db.cursor() 
    >>> clob = cursor.var(cx_Oracle.CLOB) 
    >>> clob.setvalue(0, '#'*2**20) 
    

    为了在 Python 中创建一个 LOB 对象,我们将一个 cx_Oracle.CLOB 类型传递给了该 Variable 对象的构造函数,该对象提供两个基本方法(另外还有别的方法):

    • getvalue(pos=0) 用于获取给定位置(默认为 0)的值
    • setvalue(pos, value) 用于在给定位置设置值

    为了进行一些 LOB 试验,我们使用下面的 DDL 创建如下所列的一些对象:

     
    CREATE TABLE lobs (
      c CLOB,
      nc NCLOB,
      b BLOB,
      bf BFILE
    );
    
      
    CREATE VIEW v_lobs AS
    SELECT
      ROWID id,
      c,
      nc,
      b,
      bf,
      dbms_lob.getlength(c) c_len,
      dbms_lob.getlength(nc) nc_len,
      dbms_lob.getlength(b) b_len,
      dbms_lob.getlength(bf) bf_len
    FROM lobs;
    

    在本示例中,BFILE 定位器将指向 /tmp 目录中的一个文件。以 SYSTEM 用户身份运行:

     
    create directory lob_dir AS '/tmp';
    grant read on directory lob_dir to HR;
    

    最后,使用编辑器创建 /tmp/example.txt 文件,其中包含您所选的任何虚拟文本。

    为了深入了解用于 LOB 表的默认的表创建选项,试着用 DBMS_METADATA.GET_DDL 过程生成全部 DDL:

    SET LONG 5000
    SELECT 
      DBMS_METADATA.GET_DDL('TABLE', TABLE_NAME)
    FROM USER_TABLES
    WHERE TABLE_NAME = 'LOBS';
    

    输出结果中有两个有趣的参数值得一瞧:

    • ENABLE STORAGE IN ROW 指示 Oracle 在 LOB 数据不超过 4000 个字节减去系统元数据这个大小时,尝试将该 LOB 数据与表数据放在一起(相反的参数是 DISABLE STORAGE IN ROW)。
    • CHUNK 确定处理 LOB 时分配的字节数(在 Python 中可通过 cx_Oracle.LOB.getchunksize() 方法访问该信息)。

    创建表时可使用这些选项对其行为和性能进行调优。

    以下代码是使用大型对象的一个更为完整的示例。其中显示了四种不同类型的 LOB 以及用于将 LOB 插入数据库或从数据库选择 LOB 的四个方法。

    # -*- coding: utf8 -*- 
    import cx_Oracle
    import operator
    import os
    from hashlib import md5
    from random import randint 
      
    class LobExample:
      def __enter__(self):
        self.__db = cx_Oracle.Connection("hr/hrpwd@localhost:1521/XE")
        self.__cursor = self.__db.cursor()
        return self 
      
      def __exit__(self, type, value, traceback):
        # calling close methods on cursor and connection -
        # this technique can be used to close arbitrary number of cursors
        map(operator.methodcaller("close"), (self.__cursor, self.__db)) 
      
      def clob(self):
        # populate the table with large data (1MB per insert) and then
        # select the data including dbms_lob.getlength for validating assertion
        self.__cursor.execute("INSERT INTO lobs(c) VALUES(:1)", ["~"*2**20])
        self.__cursor.execute("SELECT c, c_len FROM v_lobs WHERE c IS NOT NULL") 
        c, c_len = self.__cursor.fetchone()
        clob_data = c.read()
        assert len(clob_data)==c_len
        self.__db.rollback()
         
      def nclob(self):
        unicode_data = u"€"*2**20
        # define variable object holding the nclob unicode data
        nclob_var = self.__cursor.var(cx_Oracle.NCLOB)
        nclob_var.setvalue(0, unicode_data) 
        self.__cursor.execute("INSERT INTO lobs(nc) VALUES(:1)", [nclob_var])
        self.__cursor.execute("SELECT nc, nc_len FROM v_lobs WHERE nc IS NOT NULL") 
        nc, nc_len = self.__cursor.fetchone()
        # reading only the first character just to check if encoding is right
        nclob_substr = nc.read(1, 1)
        assert nclob_substr==u"€"
        self.__db.rollback() 
      
      def blob(self):
        # preparing the sample binary data with random 0-255 int and chr function
        binary_data = "".join(chr(randint(0, 255)) for c in xrange(2**2))
        binary_md5 = md5(binary_data).hexdigest()
        binary_var = self.__cursor.var(cx_Oracle.BLOB)
        binary_var.setvalue(0, binary_data) 
        self.__cursor.execute("INSERT INTO lobs(b) VALUES(:1)", [binary_var])
        self.__cursor.execute("SELECT b FROM v_lobs WHERE b IS NOT NULL") 
        b, = self.__cursor.fetchone()
        blob_data = b.read()
        blob_md5 = md5(blob_data).hexdigest()
        # data par is measured in hashes equality, what comes in must come out
        assert binary_md5==blob_md5
        self.__db.rollback() 
      
      def bfile(self):
        # to insert bfile we need to use the bfilename function
        self.__cursor.execute("INSERT INTO lobs(bf) VALUES(BFILENAME(:1, :2))",
          ["LOB_DIR", "example.txt"])
        self.__cursor.execute("SELECT bf FROM v_lobs WHERE bf IS NOT NULL") 
        # selecting is as simple as reading other types of large objects
        bf, = self.__cursor.fetchone()
        bfile_data = bf.read()
        assert bfile_data
        self.__db.rollback() 
      
    if __name__ == "__main__":
      with LobExample() as eg:
        eg.clob()
        eg.nclob()
        eg.blob()
        eg.bfile()
    

    该文件包含 UTF-8 字符,因此第一行包含 Python 的源代码编码声明 (PEP-0263)。为确保以该编码方式将数据传输给数据库,应将环境变量 NLS_LANG 设置为“.AL32UTF8”。这向 Oracle Client 库指明了应使用哪个字符集。该变量的设置应在 Oracle Client 初始化其内部数据结构之前进行,但不能保证发生在程序的哪个特定点。为安全起见,最好在调用该程序的 shell 环境中设置该变量。源代码中包含了其他一些解释和注释。 

    这里要注意几点。就 NCLOB 示例而言,unicode_data 不能用作绑定变量,因为如果它超过 4000 个字符,会引发“ValueError:unicode data too large”异常。BLOB 示例中将出现类似的问题。如果我们不使用 binary_var,则会引发“DatabaseError:ORA-01465:invalid hex number”异常,因为必须显式地声明绑定的内容。

    通过 LOB 参数(IN 或者 OUT)调用存储过程还需要使用 cx_Oracle 的 Variable 对象,但这是本系列另一部分要讨论的内容。

    总结

    在本教程中,您已经了解 Python 环境中有关事务处理和大型对象处理的各个方面。现在您应该已经熟悉了 cx_Oracle 模块在事务封装和访问所有四种 LOB 以及应对 UTF-8 编码需求这些方面的特点。

    展开全文
  • 准备工作安装好Python,本例使用Python 2.7版本。安装本地Oracle客户端,配置数据库连接,本例使用Oracle 11g。下载和安装cx_Oracle下载时注意Oracle数据库版本及本地Python版本。下载后,直接安装即可。简单查询...
  • python事务

    2018-12-16 10:51:45
    python中的事务 为什么要有事务 事务广泛的运用于订单系统、银行系统等多种场景 例如: A用户和B用户是银行的储户,现在A要给B转账500元,那么需要做以下几件事: 检查A的账户余额&gt;500元; A 账户中扣除...
  • 本文实例讲述了Python事务操作实现方法。分享给大家供大家参考,具体如下: #coding=utf-8 import sys import MySQLdb class TransferMoney(object): def __init__(self,conn): self.conn = conn #检查账户是否...
  • 主要介绍了python django事务transaction源码分析详解的相关资料,需要的朋友可以参考下
  • Python Django 事务管理

    2020-03-02 20:42:13
  • 主要介绍了Python sqlite3事务处理方法,结合具体实例形式分析了Python针对sqlite3事务处理的操作技巧,代码中包含详尽的注释,需要的朋友可以参考下
  • 写接口的时候,一个请求需要修改多张表,这些修改要么一起成功,要么一起失败,所以就遇到了一个事务的概念 ,比如: 在提交订单的时候,一:修改订单的状态 ,二:修改库存,三:在库存表变动里新增一条记录,这几...
  • python-mysql事务

    2018-01-05 11:38:00
    MySQL 事务 MySQL 事务主要用于处理操作量大,复杂度高的数据。简单的理解就是:完成一件事情的多个mysql语句的集合就是一个事务了,可能有人会想,我的mysql本来就是一句一句语句执行的啊,为什么要弄什么事务呢?...
  • python脚本处理事务例子

    万次阅读 2020-06-30 17:28:07
    如果手动下载的话需要每个链接进行手动更改,对于链接手动更改的话容易看的头晕眼花,并且对于大批量压缩包下载的话效率很低,所以我想到将该项多重复机械化的操作用python完成。
  • python中的事务

    2018-07-13 10:04:00
    1. 为什么要有事务 事务广泛的运用于订单系统、银行系统等多种场景 例如: A用户和B用户是银行的储户,现在A要给B转账500元,那么需要做以下几件事: 检查A的账户余额>500元; A 账户中扣除500元; B ...
  • Python 异常处理 事务

    2020-10-17 17:26:50
    写注释: 函数的功能 传入什么参数 返回什么结构 异常处理 程序中出现了异常,没有进行处理,整个项目会退出 1.解决程序异常退出的问题:需要捕获异常 执行流程: 如果try子句中出现了异常 try子句中 异常后面的代码不...
  • python 链接mysql 事务

    2019-10-04 00:34:23
    import mysql.connectortry: con = mysql.connector.connect( host="localhost", port="3306", user="root", password="", database="demo" ) con.start_transaction() curs...
  • 2019独角兽企业重金招聘Python工程师标准>>> ...
  • python-sqlite3事务

    2017-02-18 16:09:00
    sqlite3事务总结: 在connect()中不传入 isolation_level .../usr/bin/env python # -*- coding:utf-8 -*- '''sqlite3事务总结: 在connect()中不传入 isolation_level 事务处理: 使用connection...
  • 给大家介绍了Python中MySQLdb的事务处理功能,对大家学习python操作数据具有一定参考借鉴价值,有需要的朋友们可以参考借鉴。
  • python分布式事务方案(一)tcc

    千次阅读 2018-11-09 18:33:46
    python分布式事务方案(一)tcc 随着单体应用的拆分以及服务化的流行,现在分布式事务已经比较常见,分布式事务理论ACID、CAP、BASE等我就不说了,现在就直接说一下一种常见的解决方案-tcc TCC 其实就是采用的补偿...
  • redis in python事务的取消

    千次阅读 2017-03-15 11:51:46
    python redis事物的取消使用reset()函数。
  • python3 Mysql事务框架

    2018-09-18 14:01:35
    mysql 事务框架 import pymysql import logging class MysqlHandler: &quot;&quot;&quot; Mysql事务框架 &quot;&quot;&quot; # 创建mysql客户端连接 __mysql_client = ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 4,445
精华内容 1,778
关键字:

python事务

python 订阅