oracle中dbms_托马斯在DBMS中写规则

川长思鸟来 2023-03-05 09:54 8阅读 0赞

oracle中dbms

**Thomas Write Rule** is a rule in timestamp-based concurrency control which enables the action of the functioning of some unexceptionable functions and is a change made on the Basic Timestamp Ordering protocol. In **Thomas Write Rule** user **ignore outdated writes**.

**托马斯写入规则**是基于时间戳的并发控制中的规则，该规则可启用某些异常功能的功能，并且是对基本时间戳排序协议进行的更改。 在**Thomas Write Rule中，**用户**忽略过时的写入** 。

A timestamp is a distinct identifier created by the DBMS to identify a process of the transaction. They are generally allocated in the arrangement in which they are submitted to the system, so a timestamp may be look-alike show as the beginning time of transaction.

时间戳是由DBMS创建的唯一标识符，用于标识事务处理过程。 它们通常按提交给系统的安排进行分配，因此时间戳看起来像是交易的开始时间。

In **Thomas Write Rule**, the most significant enhancement is the user can successfully attain Concurrency with View Serializable schedules. Furthermore, of all the Concurrency Protocols have been discussed, Concurrency is enforced on Schedules which are Conflict Serializable.

在**Thomas Write Rule中** ，最重要的增强是用户可以通过View Serializable计划成功实现并发。 此外，在所有并发协议中都进行了讨论，并发是在可序列化冲突的计划上执行的。

The **Thomas write Rule** is applied in a set of circumstances where a pre clarified analytical order is allocated to transactions when they begin to perform.

**托马斯写规则**适用于在交易开始执行时为交易分配了预先确定的分析顺序的一组情况。

For example, a transaction might be allocated a monotonically expanding timestamp when it is generated. The rule averts changes in the arrangement in which the transactions are implemented from generating distinct outputs: The outputs will always be compatible with the pre clarified analytical order.

例如，一个事务可能在生成时被分配一个单调扩展的时间戳。 该规则避免了产生不同输出的实现交易安排的变化：输出将始终与预先阐明的分析顺序兼容。

Let's understand the points followed in Thomas Write Rule and then what are the moderation, adaptation, and enhancement it succeeds over the Basic TO protocol.

让我们了解托马斯写入规则中的要点，然后是什么超越基本TO协议进行的调节，调整和增强。

**Thomas Write Rule** does not impose Conflict Serializability but dismisses a small number of Write action of functioning by moderating and changing the check action of functioning for **W\_item (P)**.

**托马斯写入规则**不强加冲突可序列**化性** ， **而是**通过调节和更改**W\_item(P)**的功能检查动作来**消除**少量的功能写入动作。

1.  If **R\_TS (P) > TS (Q)**, then terminate and rollback **Q** and dismiss the action of functioning.
    
    如果**R\_TS(P)> TS(Q)** ，则终止并回滚**Q**并取消运行功能。
2.  If **W\_TS (P) > TS (Q)**, then don't implement the Write Operation and persist in processing. This is a case of Outdated or Obsolete Writes. Remember, obsolete writes are disregarded in **Thomas Write Rule** but a Transaction following Basic TO protocol will terminate such a Transaction.
    
    如果**W\_TS(P)> TS(Q)** ，则不要执行写操作并继续处理。 这是一种过时或过时的写入。 请记住， **Thomas Write Rule**中忽略了过时的写入，但是遵循基本TO协议的事务将终止此类事务。
3.  If neither the condition in 1 or 2 takes place, then and only then implement the **W\_item (P)** action of functioning **Q** and set **W\_TS(P)** to **TS(Q)**.
    
    如果1或2中的条件均未发生，则然后仅执行功能**Q**的**W\_item(P)**动作并将**W\_TS(P)**设置为**TS(Q)** 。

### 过期写的例子 **(**Examples of Obsolete Write**)** ###

The main reform in Thomas Write Rule is disregarding the Obsolete Write actions of functioning. This process is completed because with a timestamp greater than **TS (T)** (i.e., a transaction after **T** in **TS** arrangement) has already written the value of **P** in some transaction. As a consequence, logically user can disregard the Write (**P**) operation of **T** which becomes obsolete. Let's check out an example to see,

托马斯写作规则的主要改革是无视过时的写作行为。 因为具有大于**TS(T)**的时间戳(即**TS**排列中**T**之后的事务)已经在某些事务中写入了**P**的值，所以该过程得以完成。 结果，从逻辑上讲，用户可以忽略过时的**T**的Write( **P** )操作。 我们来看一个例子，

**Example 1:**

**范例1：**

Let's assume there are two transactions **F1** and **F2** are happening, which are scheduled by the user.

假设发生了两个事务**F1**和**F2** ，它们是由用户安排的。

**Now, TS (F1) < TS (F2)**

**现在，TS(F1)<TS(F2)**

This shows that **F1** appeared after **F2** and as a consequence has a larger **TS** value than **F1**. This indicates that serializability of schedule enabled is **F2 → F1**.

这表明**F1**在**F2**之后出现，因此具有比**F1**大的**TS**值。 这表明启用的计划的可序列化性是**F2→F1** 。

Obsolete Writes are as a consequence disregard this rule which is in a manner conforming to the second protocol. It appears to be more logical as user bypass an unneeded procedure of again beginning the entire transaction. This protocol is just moderation and adaptation to Basic to protocol.

因此，过时的写入将不遵守该规则，该规则以符合第二协议的方式进行。 当用户绕过不需要的重新启动整个事务的过程时，这似乎更加合乎逻辑。 该协议只是适度的，并且适应于基本协议。

**Example 2:**

**范例2：**

Let's suppose, there is a database which contains three variables (P, Q, R), and two atomic actions of functioning R = P (F1), and R = Q (F2). Each transaction includes a read (P or Q), and a write (R). The only dispute between these transactions is the write-on R. For the operations of the functioning of these transactions which are happening between both these tables, the possibility is a single schedule which is shown in the following tables,

假设有一个数据库，其中包含三个变量(P，Q，R)，以及两个功能为R = P(F1)和R = Q(F2)的原子动作。 每个事务包括一个读取(P或Q)和一个写入(R)。 这些事务之间的唯一争议是写入R。对于在这两个表之间发生的这些事务的功能操作，可能是单个时间表，如下表所示，

**Table 1:**

**表格1：**

<table> 
 <tbody> 
  <tr> 
   <th></th> 
   <th>F1</th> 
   <th>F2</th> 
  </tr> 
  <tr> 
   <td>1</td> 
   <td></td> 
   <td>Read(P)</td> 
  </tr> 
  <tr> 
   <td>2</td> 
   <td>Read(Q)</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>3</td> 
   <td></td> 
   <td>Write(R)</td> 
  </tr> 
  <tr> 
   <td>4</td> 
   <td>Write(R)</td> 
   <td></td> 
  </tr> 
 </tbody> 
</table>

**Transactions happening between table 1 and table 2.**

**表1和表2之间发生事务。**

**Table 2:**

**表2：**

<table> 
 <tbody> 
  <tr> 
   <th></th> 
   <th>F1</th> 
   <th>F2</th> 
  </tr> 
  <tr> 
   <td>1</td> 
   <td></td> 
   <td>Read (P)</td> 
  </tr> 
  <tr> 
   <td>2</td> 
   <td>Read (Q)</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>3</td> 
   <td></td> 
   <td>Write (R)</td> 
  </tr> 
  <tr> 
   <td>4</td> 
   <td></td> 
   <td></td> 
  </tr> 
 </tbody> 
</table>

If F1 is allocated a timestamp that comes before F2, then only F2's write should be able to be seen. On the other hand, if F1's write is implemented after F2's write, then we require a way to identify the presence of this and eliminate the write.

如果为F1分配了一个时间戳，该时间戳早于F2，则应该只能看到F2的写入。 另一方面，如果F1的写操作在F2的写操作之后执行，则我们需要一种方法来识别此操作的存在并消除写操作。

One practical proceeding towards this is to tag each value with a write timestamp (WTS) that implies the timestamp of the last transaction to moderate the value. Imposing the Thomas Write Rule only needs an examination to observe whether the write timestamp of the object is greater than the timestamp of the transaction performing a write. If so, the write is eliminated.

一个实际可行的方法是用写入时间戳(WTS)标记每个值，该时间戳表示最后一个事务的时间戳以缓和该值。 实施托马斯写规则仅需进行检查即可观察对象的写时间戳是否大于执行写操作的事务的时间戳。 如果是这样，则消除写操作。

In the above example, if we call TS (T) the timestamp of transaction T, and WTS (O) the write timestamp of object O, then F2's write sets WTS(R) to TS (F2). When F1 tries to write R, it sees that TS (F1) < WTS(R), and eliminates the write. If a third transaction F3 (with TS (F3) > TS (F2)) where to then write to R, it would get TS (F3) > WTS(R), and the write would be enabled.

在上面的示例中，如果我们将事务T的时间戳记为TS(T)，将对象O的写时间戳记为WTS(O)，则F2的写操作将WTS(R)设置为TS(F2)。 当F1尝试写入R时，它将看到TS(F1)<WTS(R)，并消除了写入。 如果第三个事务F3(其中TS(F3)> TS(F2))在哪里写入R，它将获得TS(F3)> WTS(R)，并且将启用写入。

> 翻译自: [https://www.includehelp.com/dbms/thomas-write-rule-in-dbms.aspx][https_www.includehelp.com_dbms_thomas-write-rule-in-dbms.aspx]

oracle中dbms

[https_www.includehelp.com_dbms_thomas-write-rule-in-dbms.aspx]: https://www.includehelp.com/dbms/thomas-write-rule-in-dbms.aspx