标签: isolation-level

我使用SQL Server 2012.

我写了两个查询但是NOLOCK和之间有什么不同UnCommitted？

SELECT lastname, firstname
FROM HR.Employees with (READUNCOMMITTED)

SELECT lastname, firstname 
FROM HR.Employees with (NoLock)

我有一个使用hibernate版本3.6.4和c3p0版本0.9.1.2的应用程序用于连接池.我的底层RDBMS是MySql版本5.0.67.

我的MySql安装表明默认事务隔离级别为"REPEATABLE-READ"(4):

mysql> select @@GLOBAL.tx_isolation, @@tx_isolation;
+-----------------------+-----------------+
| @@GLOBAL.tx_isolation | @@tx_isolation  |
+-----------------------+-----------------+
| REPEATABLE-READ       | REPEATABLE-READ |
+-----------------------+-----------------+

我没有在hibernate.cfg.xml或我的应用程序中的任何地方更改或配置事务隔离级别.从应用程序,我使用以下代码来打印配置:

DatabaseMetaData meta = getSession().connection().getMetaData();
System.out.println("Default Tx Isolation: " + meta.getDefaultTransactionIsolation());
System.out.println("Current Tx Isolation: " + getSession().connection().getTransactionIsolation());

我得到以下结果:

Default Tx Isolation: 2 (=READ_COMMITTED)
Current Tx Isolation: 4 (=REPEATABLE_READ)

所以,我的问题如下:

1. "2"值来自何处？由于默认值是REPEATABLE_READ,为什么getDefaultTransactionIsolation()返回READ_COMMITTED？
2. 毕竟,hibernate使用的隔离级别是多少？REPEATABLE_READ还是READ_COMMITTED？
3. 我认为当没有设置隔离级别时,hibernate应该使用底层数据库的默认值.这是真的？也许jbdc驱动程序实现自己设置一个默认值,而hibernate使用它？

以下方法应该在打开的连接上进行脏读.没有交易.我在哪里设置IsolationLevel？

public string DoDirtyRead(string storedProcName, SqlConnection connection)
{
    using (SqlCommand command = new SqlCommand(storedProcName, connection))
    {
        command.CommandType = CommandType.StoredProcedure;
        // HOW TO SET IsolationLevel to READ_UNCOMMITTED here?
        command.ExecuteNonQuery();
    }
}

如何确定给定查询的隔离级别？在执行查询(由第三方应用程序)之后,我想知道使用了哪个隔离级别(例如,读取未提交).

为了清楚起见,我目前正在开发一个使用EF4运行mysql 5.1的应用程序.我尝试测试不同的编码模式以更改特定EF4查询的隔离级别.我需要能够测试并确保正确设置隔离级别.

使用"可重复读取"应该可以产生幻像读取,但是如何？我需要它作为一个教学CS学生的例子.

我认为我必须在非索引字段x上创建"SELECT ... WHERE x <= 888",上限888不存在,然后在另一个连接上插入一个值低于888的新行.

除了它不起作用.我需要一张非常大的桌子吗？或者是其他东西？

希望这是一个简单的问题,但我还没有找到一个像样的答案.我可靠地告知PostgreSQL(特别是版本9.0.4)中的存储过程(用户定义的DB函数)本质上是事务性的,因为它们是通过SELECT语句调用的,而SELECT语句本身就是一个事务.那么如何选择存储过程的隔离级别呢？我相信在其他DBMS中,所需的事务块将被包装在START TRANSACTION块中,其中所需的隔离级别是可选参数.

作为一个具体的例子,说我想这样做:

CREATE FUNCTION add_new_row(rowtext TEXT)
RETURNS VOID AS 
$$
BEGIN
        INSERT INTO data_table VALUES (rowtext);
        UPDATE row_counts_table SET count=count+1;
END;
$$  
LANGUAGE plpgsql
SECURITY DEFINER;

并且想象一下,我想确保此函数始终作为可序列化事务执行(是的,是的,PostgreSQL SERIALIZABLE不是可正确序列化的,但这不是重点).我不想要求它被称为

START TRANSACTION ISOLATION LEVEL SERIALIZABLE;
SELECT add_new_row('foo');
COMMIT;

那么如何将所需的隔离级别下移到函数中呢？我相信我不能像BEGIN报告手册那样将隔离级别放在声明中

重要的是不要混淆使用BEGIN/END将PL/pgSQL中的语句分组与用于事务控制的类似命名的SQL命令.PL/pgSQL的BEGIN/END仅用于分组; 他们不会开始或结束交易.函数和触发器过程总是在一个由外层查询建立起来的事务中执行 - 他们不能开始或者提交该事务,因为不会有什么背景让他们在执行.

对我来说最明显的方法是SET TRANSACTION在函数定义中的某处使用,例如:

CREATE FUNCTION add_new_row(rowtext TEXT)
RETURNS VOID AS 
$$
BEGIN
        SET TRANSACTION ISOLATION LEVEL SERIALIZABLE;
        INSERT INTO data_table VALUES (rowtext);
        UPDATE row_counts_table SET count=count+1;
END;
$$  
LANGUAGE plpgsql
SECURITY DEFINER;

虽然这是可以接受的,但我不能完全依赖它来工作.该 …

我在服务层有一个方法,它对数据库执行更新功能.

@Transactional(propagation = Propagation.REQUIRES_NEW)
public void update(final Object obj){
    // some code here
}

现在我想知道Spring框架设置的这个方法的隔离级别是什么？

我是Spring的新手,只是想让自己适应交易.

请分享一些最佳实践和方法来设置隔离级别以避免死锁,从而防止同一用户尝试从不同的浏览器更新其记录.

如何设置MySQL 5.1 InnoDB的隔离级别？

输入:

mysql>显示'%isola%'等变量;

InnoDB的默认级别是可重复读取.
如何更改隔离级别？

我在Spring Batch中的JobRepository上使用SERIALIZED隔离级别获取此异常:

org.springframework.dao.CannotSerializeTransactionException: PreparedStatementCallback; SQL [INSERT into DATAFEED_APP.BATCH_JOB_INSTANCE(JOB_INSTANCE_ID, JOB_NAME, JOB_KEY, VERSION) values (?, ?, ?, ?)]; ORA-08177: can't serialize access for this transaction

; 嵌套异常是java.sql.SQLException:ORA-08177:无法序列化此事务的访问权限

at org.springframework.jdbc.support.SQLErrorCodeSQLExceptionTranslator.doTranslate(SQLErrorCodeSQLExceptionTranslator.java:269)
at org.springframework.jdbc.support.AbstractFallbackSQLExceptionTranslator.translate(AbstractFallbackSQLExceptionTranslator.java:72)
at org.springframework.jdbc.core.JdbcTemplate.execute(JdbcTemplate.java:603)
at org.springframework.jdbc.core.JdbcTemplate.update(JdbcTemplate.java:812)
at org.springframework.jdbc.core.JdbcTemplate.update(JdbcTemplate.java:868)
at org.springframework.jdbc.core.JdbcTemplate.update(JdbcTemplate.java:872)
at org.springframework.batch.core.repository.dao.JdbcJobInstanceDao.createJobInstance(JdbcJobInstanceDao.java:105)
at org.springframework.batch.core.repository.support.SimpleJobRepository.createJobExecution(SimpleJobRepository.java:135)
at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:39)
at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:25)
at java.lang.reflect.Method.invoke(Method.java:597)
at org.springframework.aop.support.AopUtils.invokeJoinpointUsingReflection(AopUtils.java:317)
at org.springframework.aop.framework.ReflectiveMethodInvocation.invokeJoinpoint(ReflectiveMethodInvocation.java:183)
at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:150)
at org.springframework.transaction.interceptor.TransactionInterceptor.invoke(TransactionInterceptor.java:110)
at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:172)
at org.springframework.batch.core.repository.support.AbstractJobRepositoryFactoryBean$1.invoke(AbstractJobRepositoryFactoryBean.java:172)
at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:172)
at org.springframework.aop.framework.JdkDynamicAopProxy.invoke(JdkDynamicAopProxy.java:204)
at $Proxy27.createJobExecution(Unknown Source)
at org.springframework.batch.core.launch.support.SimpleJobLauncher.run(SimpleJobLauncher.java:124)
at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:39)
at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:25)
at java.lang.reflect.Method.invoke(Method.java:597) …

简单的问题？

为什么READ_COMMITTED_SNAPSHOT默认情况下不启用？

我猜是向后兼容性,性能还是两者兼而有之？

[编辑]请注意,我对与READ_COMMITTED隔离级别有关的效果感兴趣,而不是快照隔离级别.

为什么这会是一个突破性的变化,因为它拥有较少的锁,并且仍然不会读取非提交的行？