我需要检索由SQL Server 2005生成的标识字段。通常,我只会使用SCOPE_IDENTITY或向insert中添加OUTPUT子句,但是在这种情况下,这两种方法都没有帮助:因为有一个INSTEAD of触发器附加到表中。接下来,我考虑了@@IDENTITY,但因为表中还附加了另一个触发器,所以这也不好。所以我想我必须使用IDENT_CURRENT。但是,因为这不是会话安全的,所以我需要一些方法来确保在我检索到新的ID之前,没有其他会话可以插入到表中。我已经尝试使用TABLOCK和HOLDLOCK提示,这似乎是有效的,但我不是DBA。因此,我的问题是,在SQL Server 2005中
我相信Server中的每个SELECT语句都会导致放置共享锁或密钥锁。但是,当它在事务中时,它会放置相同类型的锁吗?共享锁或密钥锁是否允许其他进程读取相同的记录?
例如,我有以下逻辑
Begin Trans
-- select data that is needed for the next 2 statements
SELECT * FROM table1 where id = 1000; -- Assuming this returns 10, 20, 30
insert data that was read from the first query
INSERT INTO table2
使用MySQL5.7和存储引擎作为innodb。我有一张存储产品信息的桌子。该表在productId上具有唯一键,如下所示
| Field | Type | Null | Key | Default | Extra |
+-----------+--------------+------+-----+-------------------+-----------------------------+
| id | bigint(20) | NO | PRI | NULL
我在MySQL中有一个触发器:
CREATE DEFINER = CURRENT_USER TRIGGER `test`.`view_AFTER_INSERT` AFTER INSERT ON `views` FOR EACH ROW
BEGIN
UPDATE metrics SET met_nu_vie = met_nu_vie + 1 WHERE usp_id = NEW.usp_id;
END
基本上,当用户从web应用程序中的另一个用户接收到“视图”时,系统在表“视图”中创建一个新行,在插入后,在另一个表(度量)中增加一个计数器值。
我的问题是:如果用户收到来自10个不同用户的1
我有一个通过以下命令在PostgreSQL中创建和填充的表:
CREATE TABLE my_lock (
id integer,
CONSTRAINT id_pkey PRIMARY KEY (id)
) ;
INSERT INTO my_lock VALUES (1) ;
INSERT INTO my_lock VALUES (2) ;
此表由以下Django模型表示
from django.db import models
from django.db import transaction
class MyLock(models.Model):
class M
我正在尝试理解SQL Server中的隔离/锁。
在READ提交的隔离级别(默认)中有以下场景
我们有桌子。
create table Transactions(Tid int,amt int)
with some records
insert into Transactions values(1, 100)
insert into Transactions values(2, -50)
insert into Transactions values(3, 100)
insert into Transactions values(4, -100)
insert into Transacti
我试图弄清楚PostgreSQL中的可序列化隔离级别是如何工作的。理论上和根据PostgreSQL自己的文档,PostgreSQL应该足够聪明,能够检测序列化冲突并自动回滚违规事务。然而,当我自己尝试使用可序列化的隔离级别时,我偶然发现了许多错误,并开始怀疑我自己对序列化概念或PostgreSQL的实现的理解。下面你可以找到这样的假阳性的最简单的例子之一:
create table mytab(
class integer,
value integer not null
);
create index mytab_class_idx on mytab (class);
in
用户1 :
begin tran
select * from items with(nolock);
insert into orders (odate) values(getdate());
insert into OrderData values((select max(orderid) from Orders with(nolock)),1,1);
update Items set qih=qih-1 where item_id=1;
select * from OrderData where oid=(select max(orderid) from Orders with(nolo
文档显示,serializable事务一个接一个地执行。
但在实践中,这似乎不是事实。这里有两个几乎相等的事务,不同的是只有15秒的延迟。
#1:
set transaction isolation level serializable
go
begin transaction
if not exists (select * from articles where title like 'qwe')
begin
waitfor delay '00:00:15'
insert into articles (title) values ('qwe')
假设我在一个只有一个列CITY的表中执行以下一组SQL查询(伪代码
BEGIN TRANSACTION;
INSERT INTO MyTable VALUES( 'COOLCITY' );
SELECT * FROM MyTable WHERE ALL;
COMMIT TRANSACTION;
是否保证SELECT返回COOLCITY
我正在学习如何使用这个简短的脚本进行事务处理。
CREATE TABLE t_test (id INT NOT NULL PRIMARY KEY) ENGINE=InnoDB;
START TRANSACTION;
INSERT
INTO t_test
VALUES (1);
SELECT *
FROM t_test;
id
---
1
SAVEPOINT tran2;
INSERT
INTO t_test
VALUES (2);
SELECT *
FROM t_test;
id
---
1
2
ROLLBACK TO tran
如何确保下面的语句没有竞争条件?
IF NOT EXISTS (select col1 from Table1 where SomeId=@SomeId)
INSERT INTO Table1 values (@SomeId,...)
IF NOT EXISTS (select col1 from Table2 where SomeId=@SomeId)
INSERT INTO Table2 values (@SomeId,...)
这足够了吗?
SET TRANSACTION ISOLATION LEVEL SERIALIZABLE
BEGIN TRAN
IF NOT EXISTS (
如果并发用户在缺省隔离级别READ COMMITTED下执行以下事务,可能会出现什么问题?
BEGIN TRANSACTION
SELECT * FROM t WHERE pid = 10 and r between 40 and 60
-- ... this returns tid = 1, 3, 5
-- ... process returned data ...
DELETE FROM t WHERE tid in (1, 3, 5)
INSERT INTO t (tid, pid, r) VALUES (77, 10, 35)
INSERT INTO t (tid, pid, r)
pg_log:
2016-01-20 23:00:31 UTC ERROR: deadlock detected
2016-01-20 23:00:31 UTC DETAIL:
Process 2696 waits for RowShareLock on relation 1849109 of database 1847373; blocked by process 2919.
Process 2919 waits for AccessExclusiveLock on relation 1848698 of database 1847373; blocked by pro
我只读取了可序列化隔离级别块: insert、update、delete,但未读取。
我在一个窗口中运行:
SET TRANSACTION ISOLATION LEVEL SERIALIZABLE;
BEGIN TRANSACTION;
UPDATE [dbo].[Categories]
SET name = 'aaa'
WHERE categoryid = 4;
-- without commit
在第二个窗口中:
SELECT TOP (1000) [CategoryId]
,[Name]
FROM [dbo].[Categories]
并且上面的查
我有一张简单的桌子
CREATE TABLE test (
col INT,
data TEXT,
KEY (col)
);
和一个简单的交易
START TRANSACTION;
SELECT * FROM test WHERE col = 4 FOR UPDATE;
-- If no results, generate data and insert
INSERT INTO test SET col = 4, data = 'data';
COMMIT;
我试图确保这个事务的两个副本同时运行,不会导致重复的行和死锁。我也不想为col = 4生成一次以上的c
在阅读postgres文档之后,我有两个实验不像预期的那样工作。我用postgres 12
实验1
数据准备:
CREATE TABLE Test
(
id SERIAL primary key,
level int,
value int
);
INSERT INTO Test (
level,
value
)
SELECT 1, 10 UNION ALL
SELECT 1, 20 UNION all
SELECT 1, 30 UNION ALL
SELECT 2, 100;
然后,我打开两个查询窗口。
窗口1
BEGIN TRANSACTION I
关于如何区分PostgreSQL UPSERT语句(INSERT ... ON CONFLICT ... DO UPDATE ...)中插入的和更新的行,这里最近提出了几个问题。
下面是一个简单的例子:
create table t(i int primary key, x int);
insert into t values(1,1);
insert into t values(1,11),(2,22)
on conflict(i) do update set x = excluded.i*11
returning *, xmin, xmax;
╔═══╤════╤════
我试图使用rowlock来防止某些行在运行时被更新,但问题是我在运行以下代码时根本不能使用表:
set transaction isolation level repeatable read;
go
begin try
begin transaction;
insert into tableB with(rowlock)
select * from tableA with(rowlock) where status = 1
commit transaction;
end try
begi
我正在尝试使用将DELETE语句转换为截断
以下是我所尝试的,
-- Move recent records from Main table to a Temp table
-- TRUNCATE the Main table
-- Return back data from Temp table to Main table
在此期间,我希望停止在主表上运行的任何INSERT/UPDATE/DELETE语句(直到TRUNCATE语句运行),因为如果允许的话,我们可能会在截断期间丢失一些数据。
我正在从SQL Server数据库的表中读取一个参数,递增它,基于它进行一些其他计算,然后用这些新的计算值编写一些SQL查询。
SELECT TOP 1 fruitId
FROM fruits WITH (TABLOCK, HOLDLOCK)
WHERE fruitId LIKE '1978%'
ORDER BY fruitId DESC
在获得这个水果Id之后,执行一些数学运算,然后将数据写入几个表。
我在单个事务中写入这3个表。
SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED
BEGIN TRANSACTION
在我的应用程序中,我调用一些webservices来更新数据库。每个webservice调用都是在一个特定的线程中进行的,结果是多个线程“一次”更新数据库对象。
在每个线程中,我使用这样的事务:
Thread 1 (webservice 1)
beginTransaction()
insert a row in the table 1
update a row in the table 1
endTransaction()
Thread 2 (webservice 2)
beginTransaction()
update a row in the table 2
update a row i
我有一个复杂的查询,它创建一个可以运行5秒或更长时间的临时表。当同时在类似的表上运行另一个事务时,这似乎会导致死锁。我不能在当地复制,但在生产中,我可以让它每隔几天发生一次。(我记录了mysql错误)
查询相当复杂(如页面底部所示);但是您不需要理解逻辑;只是它从一堆表和联接中选择,运行起来可能需要一段时间。
我还有一个事务可以插入到许多相同的表中。我偶尔会收到mysql错误,1213: Deadlock found when trying to get lock; try restarting transaction.。
下面是事务的伪代码
START TRANSACTION
INSERT
SELECT查询可以阻止INSERT / ALTER查询吗?
我的从数据库中有以下内容(摘自ENGINE INNODB STATUS):
---TRANSACTION 26DA7060, not started
mysql tables in use 5, locked 12
MySQL thread id 516232, OS thread handle 0x7fcf8304a700, query id 350388626 event_scheduler Waiting for table metadata lock
ALTER TABLE xxxxxxxxxxxx REORGANIZE P
我在MS Sql Server2008 R2中有一个简单的队列实现。下面是队列的要点:
CREATE TABLE ToBeProcessed
(
Id BIGINT IDENTITY(1,1) PRIMARY KEY NOT NULL,
[Priority] INT DEFAULT(100) NOT NULL,
IsBeingProcessed BIT default (0) NOT NULL,
SomeData nvarchar(MAX) NOT null
)
我希望自动选择按优先级和id排序的前n行,其中IsBeingProcessed为false,并更新
我每隔30秒就会有一个大容量的插入,我在过去2周运行sp_whoisactive时看到了大量的阻塞,我们从2016年起升级到server 2017 (应用了最新的更新),我不确定这是否相关,或者数据库现在是否更繁忙。
从我的批次中我看到了这件事的报道
Delete from [dbo].[tblStagingTrackingData] Where ipkStagingTrackingID in(Select ifkStagingTrackingID from #AboutToInsert)
这个暂存表不被其他任何东西使用,并且阻塞发生在完全无关的表上。
以下是完整的批处理sql
ALTER P
我们的Java应用程序通过cron作业从日志表中清除数据。下面是为清理而执行的查询:
DELETE FROM AU_TRANSACTIONDATA
WHERE AU_ACTIVITYENDTIME != 0
AND AU_ACTIVITYENDTIME <= 1464570001151
这个表的AU_ACTIVITYENDTIME列有一个索引:
CREATE INDEX [IX_AU_TRANSDATA_ENDTIME]
ON [AU_TRANSACTIONDATA]([AU_ACTIVITYENDTIME]) ON [PRIMARY];
我们的应用程序将事务数据(在应
表:
create table properties
(
id int auto_increment primary key,
other_id int null
);
create index index_properties_on_other_id
on properties (other_id);
TX 1:
start transaction;
SET @last_id = 1;
delete from `properties` WHERE `properties`.`other_id` = @last_id;
I