Could Not Create the Transaction

Transaction Identifier

Transaction Processing Abstractions

Philip A. Bernstein , Eric Newcomer , in Principles of Transaction Processing (2d Edition), 2009

Transaction Identifiers

As we explained in Chapter ane , each transaction has a unique transaction identifier (transaction ID), which is assigned when the transaction is started. The transaction ID is assigned by whichever component is responsible for creating the transaction in response to the Starting time command. That component could be a transaction director (encounter Section 1.4) or a transactional resource manager such equally a database organization, file organization, or queue managing director.

There are two major types of transaction IDs: global and local. The transaction manager assigns a global ID, which is needed when more than ane transactional resources participates in a transaction. If the transactional resources managers as well assign transaction IDs, and so these are local IDs that are correlated with the global transaction ID since they all refer to the same transaction.

Whenever a transaction accesses a transactional resource, it needs to supply its transaction ID, to tell the resource's managing director on which transaction's behalf the access is being made. The resource manager needs this information to enforce the Acid properties. In particular, it needs information technology for write accesses, so that it knows which write operations to permanently install or undo when the transaction commits or aborts.

When an application program invokes Commit or Abort, information technology needs to pass the transaction ID every bit a parameter. This tells the transaction manager which transaction it is supposed to commit or abort.

Since the awarding needs to supply its transaction ID to resource managers and the transaction managing director, it needs to manage its transaction ID. It could practise this explicitly. That is, the Start performance could return a transaction ID explicitly to the application, and the awarding could pass that transaction ID to every resource it accesses.

Most systems hide this complication from the awarding programmer. Instead of returning the transaction ID to the programme P that invokes Start, the system typically makes the transaction ID part of a hidden context, which is data that is associated with P simply is manipulated merely by the system, non by P. In item, using the context the system transparently attaches the transaction ID to all database operations and Commit and Abort operations. This is more convenient for application programmers—it's one less slice of bookkeeping for them to bargain with. It also avoids errors, because if the awarding passes the wrong transaction identifier, the system could malfunction.

Typically, the hidden context is associated with a thread, which is a sequential menstruum of command through a plan. A thread can take only 1 transaction ID in its context, so there is no ambivalence about which transaction should be associated with each database performance and Commit or Abort. Threads are discussed in particular in the adjacent section.

Notice that there are no transaction IDs in Figure 2.1 through Effigy two.3. The transaction ID is simply function of the subconscious program context. Throughout this chapter, we volition assume that transaction IDs are hidden in this way, although as nosotros will run into some programming models allow access to this transaction context.

Read full affiliate

URL:

https://www.sciencedirect.com/science/article/pii/B9781558606234000020

Distributed Concurrency Control

Gerhard Weikum , Gottfried Vossen , in Transactional Information Systems, 2002

In a path pushing algorithm, entire paths are circulated between transactions instead of single transaction identifiers, and individual sites can compose these in gild to somewhen obtain cyclic portions of a waits-for graph. In more than detail, the basic algorithm is as follows:

one

Each server that has a waits-for path from transaction t_i to transaction tj such that t_i has an incoming waits-for bulletin border and t_j has an outgoing waits-for message edge sends that path to the server forth the outgoing edge, provided the identifier (or timestamp) oft_j is smaller than that of t_j .

ii

Upon receiving a path, the server concatenates this with the local paths that already be, and forward the event along its outgoing edges again. If there exists a cycle among n servers, at least 1 of them volition detect that cycle in at most n such rounds.

Read full chapter

URL:

https://www.sciencedirect.com/scientific discipline/commodity/pii/B9781558605084500193

Computational Models

Gerhard Weikum , Gottfried Vossen , in Transactional Information Systems, 2002

2.4 The Object Model

This department introduces the object model as an alternative to or generalization of the page model. The reason why we explicitly carve up this model from the page model, although the latter is implicitly included here, is that many important foundational issues and also bones algorithms and implementation techniques tin be more hands understood in the simpler folio model first. The object model provides a framework for representing method invocations, or operations for brusk, on arbitrary kinds of objects. This will later let us to exploit some semantic backdrop of the invoked operations for the sake of improved performance. In add-on, the object model tin can capture cases where an performance on an object invokes other operations on the same or other objects. Indeed, often the implementation of an object and its operations requires calling operations of some lower-level types of objects.

For example, operations at the access layer of a database arrangement, such as index searches, demand to invoke page-oriented operations at the storage layer underneath. Similar invocation hierarchies may exist amid a collection of business objects that are made available every bit abstruse data type (ADT) instances inside a data server or an application server, for instance, a Bank business relationship object type forth with operations similar Deposit, Withdraw, Get_Balance, Get_History, Compute_Interests, and then on. Figures ii.ane and 2.2 depict two examples of transaction executions confronting such object model scenarios.

Figure two.1. Sample scenario for the object model: database system internal layers.

Figure two.ii. Sample scenario for the object model: business organisation objects.

Database system layers case

Effigy ii.1 shows a transaction, labeled t _one, which performs, during its execution, (1) an SQL Select command to retrieve, say, all records from a database of persons who live in Austin (i.e., whose Metropolis attribute has the value "Austin") and, after inspecting the event set up, (two) an SQL command to insert a record for a new person who happens to live in Austin, likewise. Since SQL commands are already translated into operations at the query processing layer at compile time (see Department ane.v for a brusque primer on such database arrangement bug), the operations invoked at run fourth dimension are those of the query processing layer. Because of the extremely simple nature of the example'southward SQL commands, the resulting operations are likewise very simple, and already partly resemble operations at the access layer (i.e., operations of the layer onto which the query processing layer translates its operations). We assume that the Select command is executed by first issuing a Search operation on an index that returns the RIDs (addresses) of the effect records. Side by side, these records, which we refer to every bit x and y in the effigy, are fetched by dereferencing their RIDs. The Search operation in turn invokes operations at the underlying storage layer, that is, read and write operations on pages. Here we presume that beginning the root of a B⁺ tree is read, labeled every bit page r in the figure, and and so we are pointed to a leaf page, labeled l, that contains the relevant RID listing for the search key "Austin." (And so, for simplicity, we presume that the B⁺ tree has height 2.) The subsequent Fetch operations to access the two result records 10 and y by their RIDs crave only ane folio admission each to pages p and q, respectively. Finally, the SQL Insert command is executed at the query processing layer equally a Store functioning, storing the new record and as well maintaining the index on the City attribute (assuming no other indexes are divers for the underlying table). This involves offset reading a storage layer metadata page, labeled f, that holds free space information in lodge to find a page p with sufficient empty space. Then that page is read and subsequently written afterwards the new record z has been placed in the page. The last thing to do on behalf of the Store operation is to add together the RID of the new record z to the RID list of the key "Austin" in the Urban center alphabetize; this requires reading the B⁺ tree root page r, reading the proper leaf folio l, and finally, writing folio l subsequently the addition of the new RID.

In Figure 2.1, this entire execution is represented in a graphical, meaty form, past connecting the calling operation and the called performance with an edge when operations invoke other operations. As a convention, the caller is always placed closer to the acme of the motion picture than the callee. Furthermore, nosotros stand for the club in which operations are invoked by placing them in "chronological" club from left to right. When giving a formal definition shortly, this ordering convention needs to be revised a bit, but the above statement reflects the essence.

The same approach to representing transaction executions in an object model tin can also exist applied to collections of business objects, as shown in the second example in Figure 2.2. The example contains a transaction, labeled t ₂, that withdraws coin from one bank account x past invoking a Withdraw functioning, and later on deposits money in another account y past ways of the functioning Deposit. Here x and y are instances of the object type (or ADT) Account, which provides amid its interface operations the mentioned Withdraw and Eolith methods. The implementation of these operations requires calling other operations. Assuming that the implementation is on top of a database system (e.g., inside a database server that supports ADTs), most of it is straightforward and could be directly translated into a sequence of Search, Fetch, and Modify operation invocations at the query processing layer. (The code for the ADT implementation would exist precompiled and accessible by the database server, too.) For the underlying storage layer, we assume that the records can be searched by an index on their AccountID attribute and that no other indexes are involved in the instance. Thus, the resulting page operations are straightforward and very like to those of Effigy 2.1; to help intuition, nosotros have even kept the labels of the previous example, such equally r for a B⁺ tree root page. To distinguish the account objects x and y from the respective stored records on which the Fetch operations are invoked, we label the records as $\widehat{\mathrm{ten}}$ and $\hat{y}$ , respectively.

A particularity of the case in Figure 2.ii is that the Withdraw operation also invokes another business organisation object method, labeled Suspend, in improver to the operations of the database system'southward query processing layer. This Append performance belongs to an object h of type History, which tin be viewed as a specialized way of capturing the recent cash flow history of the banking company account. For example, the last xx cash flows, or all cash flows of the concluding xxx days, could be kept in a small-scale history queue and this information made accessible past additional Get_History or Browse_History methods. The specific semantics of purging expired entries from the history queue would be congenital into the object, and this is why it makes sense to encapsulate the history data as an ADT object. In the transaction execution of Figure ii.2, the invoked Append functioning is assumed to fetch a header record a (on page s) that contains pointers to the head and tail of the history queue, assuming that the implementation uses a doubly linked list of records. Calculation an entry at the tail of the queue would then find the page t with the currently most recent entry, tape d. If this folio has sufficient empty space for the new record, then this is where the new entry could be placed equally record due east. Storing the new entry and irresolute the linked list to connect the previously terminal entry with the new ane results in further write operations on folio t. Finally, the queue's header record a in page s needs to be updated to point to the new tail.

The two examples and especially their graphical depiction already suggest a definition that essentially views transactions as trees with the invoked operations as tree nodes. Nevertheless, to ensure that such trees are sufficiently self-contained in that they reverberate all relevant aspects of the transaction execution and let usa to reason rigorously about concurrency betwixt transactions, we require that the leaf nodes of a transaction tree exist elementary operations in the sense of the folio model. So all tree leaves must be read and write operations on pages, or some other notion of abstract operations for which we can safely assume that each operation is indivisible. At this point, we only know virtually page operations having this property, at least with regard to concurrency furnishings. Thus, for the time being, you can always associate page operations with the leaves of a transaction tree. If all or some leafage nodes of a given transaction tree practice not correspond to page operations, all nosotros have to do is to further expand the operations at these leaves past making their invoked operations explicit at lower implementation levels until we cease up with uncomplicated read or write operations on pages. Notation that this kind of expansion is always possible, as all forms of data servers eventually shop their (permanent) information items in pages (also known as blocks). Further notation that the expansion is a dynamic one that tracks all operations invoked during the execution of a higher-level operation, as opposed to a hierarchy derived from the static structure of the operation's lawmaking.

Analogously to the introduction of the folio model, we still accept to brand some amendments to the in a higher place considerations, to capture the ordering of operations within a transaction. A elementary definition would crave a sequential ordering of all leaf nodes, matching their left-to-right order in the example figures. Nonetheless, equally in the page model, there are practiced reasons to require only a partial ordering among the leaf node operations. An additional constraint that arises from the requirement that leaf nodes exist elementary folio model operations is to enforce the ordering of performance pairs where ane or both of the 2 operations is a write. Equally in the page model, the statement for this constraint is to ensure an unambiguous interpretation of the transaction.

We are now ready to requite the following formal definition of an object model transaction.

DEFINITION two.three

Object Model Transaction

A transaction t is a (finite) tree of labeled nodes with

the transaction identifier as the label of the root node,

the names and parameters of invoked operations as labels of inner (i.e., nonleaf, nonroot) nodes,

page model read/write operations as labels of leaf nodes,

along with a partial lodge "<" on the leaf nodes such that for all leaf node operations p and q with p of the form w(x) and q of the grade r(x) or due west(x) or vice versa, nosotros have p < q v q < p.

Given this tree-based definition, we will from at present on utilize standard terminology for copse to refer to, for case, children, descendants, subtrees, ancestors, siblings, and and so on. Note that the definition allows for arbitrary types of operations as inner nodes and that information technology contains Definition ii.2 as a special example, that is, the object model generalizes the page model. These can be operations on an ADT object or some less stringent, only explicitly specified, form of operational interface (e.yard., the interface operations of a database system's query processing layer). Farther note that transaction trees do not have to exist counterbalanced in the sense that all leaf nodes have the aforementioned distance from the root. In Figure ii.2, for example, the leaf node descendants under the Append performance are farther away from the root than those of the Change operation, although these two inner nodes are at the same tree level as seen from the root. For clarity, still, nosotros will ordinarily attempt to place operations that vest to the same object blazon(s) or interface within 1 level of the graphical movie of a transaction tree. This is why we have placed, in Figure 2.2, all operations of the query processing layer adjacently and take decided to permit the Append functioning stick out. When we later utilise the object model to reason about concurrent executions, we will often deal with cases of perfectly counterbalanced transaction trees anyway. The class of transaction trees where all foliage nodes accept the aforementioned distance from the root is known by the name layered transactions or multilevel transactions— an important special instance of our model.

A specific point in our formal definition that could, perhaps, strike you as an accidental omission is that a partial order is defined but for the leaf nodes of the tree. So you lot may wonder why no ordering has been defined for inner nodes. The reply is that such an ordering is already implicitly defined, and we wanted to keep the definition equally concise as possible and avert producing an overspecification. Namely, for two inner node operations a and b, we say that a precedes b in the execution order if all leaf node descendants of a precede all leaf node descendants of b in the partial order < of the leafage nodes. In other words, we consider a every bit preceding b only if a terminates its execution before b begins; this is what ensures the required ordering betwixt the two sets of foliage node descendants. Otherwise, we would consider a and b as concurrent operations; and this is a feasible viewpoint as none of them is assumed to exist indivisible. If we want to find out their resulting effects on the permanently stored data, we tin resort to checking the interleaving of their children and further descendants until nosotros get in at the leaf nodes whose ordering ensures an unambiguous estimation.

To conclude this section, nosotros requite a cursory outlook on how nosotros will later use the introduced object model in laying a foundation for and reasoning most advanced concurrency command algorithms. Once we consider multiple transactions that execute in a concurrent or parallel way, all we take to practise is to form the spousal relationship of the involved transaction trees—that is, a woods of operations—and audit the partial execution order of leafage node operations (and the implicitly derived order for higher-level operations). The difference from the single transaction case is that the fractional order will so be divers on the union of the leafage nodes of all involved trees. Considering of the derivation of the inner node ordering from the leafage node society, this arroyo volition allow usa to study not but the interleavings at the leaf node level but also concurrency or sequential orderings among higher-level operations. This ability to reason about concurrency at unlike tree levels is indeed needed to properly exploit the object model for the sake of amend performance. The key to such performance enhancements lies in taking into consideration semantic properties of the higher-level, inner node operations.

By far the almost important one of such properties is the commutativity or noncommutativity of ii operations. For example, two Deposit operations on the same bank account are commutative in that both of the 2 possible sequential execution orders lead to identical results in terms of the resulting country of the data and the return parameters of the invoked operations, assuming that a Deposit functioning does not return the current residue of the account. Ii Withdraw operations on the aforementioned account, however, practice non generally commute because their ordering may be relevant if simply the first withdrawal succeeds and the second one is refused due to overdraft protection. In this situation the two possible sequential orderings would outcome in different return values (i.e., indicators of the withdrawal'southward success) and could besides pb to different concluding states of the account residual. The bespeak about commutativity or noncommutativity is that these considerations hold for pairs of operations from the same as well as unlike transactions, and then that we tin can also apply commutativity-based reasoning to concurrent executions of multiple transactions. Information technology volition be seen afterward that commutative operations allow us to tolerate interleaved access patterns that would have to exist disallowed if we only knew that the operations read and write the aforementioned data item.

Read total chapter

URL:

https://www.sciencedirect.com/scientific discipline/article/pii/B978155860508450003X

Crash Recovery: Notion of Correctness

Gerhard Weikum , Gottfried Vossen , in Transactional Information Systems, 2002

12.3 System Model

This section casts the system architecture we have introduced in the previous section into more rigorous definitions, which will then exist used as the ground for the correctness reasoning throughout Affiliate 13. Since our goal is to show that the recovered database preserves the furnishings of exactly all committed updates in the serialization order of the executed transactions, the system history is an of import reference point for the correctness of the recovery. Compared to earlier capacity, we demand some extensions in defining the arrangement history. In particular, caching actions are of involvement for the recovery and therefore are included in the history.

DEFINITION 12.ane

Extended History

The extended organization history of a transactional data server is a partially ordered woods of actions, with the set of deportment denoted past A, where

the roots are transaction identifiers or caching deportment (fetch or flush);

the leaves are read, write, or total-write actions or transaction actions (brainstorm, commit, rollback, …);

only exec deportment can appear equally intermediate nodes;

the ordering of deportment, denoted by <, is tree consequent (i.e., for a nonleaf node i and an arbitrary node j, the relationship $i<j\left(j<i\right)$ holds if $p<j\left(j<p\right)$ holds for all leaves p that are descendants of i).

A specialization that nosotros volition consider kickoff is the one for the page model, which is characterized by the absence of exec nodes. Then, an extended history specializes to a forest where all trees have depth 2. In the rest of the affiliate we always consider extended histories rather than "apparently" histories. Therefore, there is no need to distinguish the two notions explicitly, and we volition henceforth refer to extended histories simply as histories.

Since the stable log keeps accounting records about the system history, it tin be defined past its human relationship to the extended history as follows:

DEFINITION 12.2

Stable Log

For a given arrangement history, the stable log is a totally ordered subset of the history'southward action set such that the log ordering is compatible with the history lodge (i.e., does non contradict <). These logged actions are referred to as log entries.

Equally mentioned earlier, a log entry may contain information for both the undoing and the redoing of an update action, every bit an outcome of the corresponding transaction is commonly still unknown at the time the log entry is created. In the abstract model, even so, we do not explicitly distinguish the undo and redo parts of a log entry. Rather nosotros treat the logged activity itself every bit the redo information and assume that nosotros can ever infer from the log entry an changed action, in the sense of Chapter 11, which serves every bit the original action'southward undo information. We have to keep in mind, however, that the implementation of log entries needs to incorporate additional details; for example, input parameters of an inverse action may depend on issue parameters of the original action and accept to exist remembered explicitly in thelog entry.

Thus, the log is essentially a linearization of the system history. We assume that all logged actions deport sufficient information to identify their ancestors in the history. In particular, all log entries carry a transaction identifier. Well-nigh recovery algorithms restrict the log entries to certain activeness types, as nosotros will encounter in detail later. In particular, nigh all algorithms avert logging reads.

Now the log buffer tin can be defined simply as the "tail" of the history (or, actually, the logged role of the history) that captures the most recent actions that are non yet recorded on the stable log.

DEFINITION 12.iii

Log Buffer

For a given system history, the log buffer is a totally ordered subset of the history's action set such that the log ordering is compatible with the history order and all entries in the log buffer follow (with respect to the total social club) all entries in the stable log for that history.

Finally, as for the stable database and for the cached database, an important consideration is that we do not need to formalize all aspects of the data system itself. Rather, our focus is on tracking which updates are present or absent in the database, how these updates relate to the logged actions, and how the recovery advances the database state. To this end, it is appropriate to view the country of a database also as a fix of update actions, namely, those actions that have led to the state.

Obviously, the resulting state depends on the order in which the actions were performed on the database; so we demand to include some cognition about activeness ordering in our formal definition. To remain consistent with practical considerations, we have to consider that the exact order in which updates were performed cannot be inferred from a given database solitary. However, by including boosted data in the database itself, we tin obtain some partial knowledge of the social club. To this stop, we assume that each database page is tagged with a sequence number, by which we tin can proceed rail of the virtually recent action of certain types that were executed on that page. This page sequence number, or page state identifier, is causeless to be embedded in the page itself. Therefore, it is e'er carried forth when a page is fetched into the database cache or flushed back from the cache to the stable database. The being of such a page sequence number is a special assumption that nosotros are making, simply annotation that it is perfectly in line with all implemented systems that we are aware of. Indeed, page sequence numbers can be easily implemented with very picayune overhead as a field in the page header. Contrast this with believable assumptions on tagging all data records with a sequence number or transaction identifier, whose implementation would non be at all clear and would exist likely to incur high overhead.

Page sequence numbers as state identifiers

The key indicate of a page sequence number is that it can requite us some partial knowledge nigh the lodge of the write actions (including full-write deportment) that have been performed on information technology. Namely, for a folio with sequence number s, we know that all write actions on that page with a sequence number less than s must precede the write action with sequence number southward in the history club <. We even so practice not take whatever cognition near the ordering amongst those earlier actions, just nosotros will see that this cognition is non necessary for a recovery algorithm anyhow.

These considerations atomic number 82 to the following definitions of cached and stable databases, respectively. The only difference between the two is that the page sequence numbers of the cached database correspond to the virtually recent write actions in the history; whereas in the stable database the sequence number of a folio corresponds to the virtually recent write activeness before the well-nigh recent affluent action for that folio.

DEFINITION 12.iv

Buried Database

For a given system history, the cached database is a partially ordered prepare of all write actions in the history, including full-write actions, such that the ordering is a subset of the history order, and for each page number p, the maximum element among the write actions on p in the history is likewise the maximum element among all write actions on p in the cached database.

DEFINITION 12.five

Stable Database

For a given organization history, the stable database is a partially ordered subset of the history's write deportment, including full-write deportment, such that the ordering is a subset of the history order, and for each page number p,

all write actions on p that precede the nearly contempo flush(p) activity in the history are included in the stable database,

the maximum chemical element among all those included write actions in the history is as well the maximum chemical element amidst all write deportment on p in the stable database.

Past casting all system components into partially ordered sets of actions, these definitions allow usa to relate and direct compare the stable database to the stable log and the stable log in plow to the organization history. These cross-relationships atomic number 82 us to the definiteness criterion developed in the following section.

Read total chapter

URL:

https://www.sciencedirect.com/science/article/pii/B9781558605084500132

Update and Dispose Phases – Ongoing Data Stewardship

John R. Talburt , Yinle Zhou , in Entity Information Life Cycle for Big Information, 2015

Confirmation Assertions

Confirmation assertions are designed to label EIS as having been reviewed and confirmed as correct in order to preclude their continued review. The algorithms producing clerical review exceptions are non perfect. Some EIS called out for clerical review as potential false positives oftentimes plough out to exist truthful positives, i.e. correctly clustered. Similarly, some groups of EIS called out for clerical review equally false negatives are in fact true negatives. Without confirmation assertions, these EIS can exist repeatedly called out for review by the clerical review indicator logic even though they have previously been manually reviewed and found to be correct.

Still, it is important to notation EIS reviewed equally correct should only be excluded from subsequent reviews as long as they maintain the state they had at the fourth dimension of the review. Whatever changes to the EIS could alter their status from correct to wrong. The implementation of confirmation assertions also requires new functionality in the ER update logic that will remove confirmation labels from the EIS metadata whenever the ER process modifies the EIS.

Truthful Positive Assertion

The true positive confirmation exclamation pertains to a unmarried EIS. If an EIS is called out for clerical review, and if the reviewer finds all references in the EIS are for aforementioned entity, the EIS is a true positive and should be asserted as such. The truthful positive assertion of an EIS will add a metadata label showing the EIS is truthful positive.

The case shown in Figure v.6 is where the EIS with entity identifier ABC was called out for clerical review as a false positive, simply after inspection it was institute to exist correct. The true positive assertion transaction requires only 2 fields – a transaction identifier and the entity identifier of the true positive EIS. The action of the truthful positive exclamation is to add a metadata tag (shown equally <TP> in Figure v.vi) to the EIS. True positive assertion transaction T8 asserts ABC as a true positive EIS. The true positive tag inserted into ABC volition prevent the clerical review indicator logic from calling out ABC for review as long equally the tag is nowadays.

Figure 5.6. True positive assertion.

However, if a later update process results in new references being added to ABC, then the truthful positive tag volition be removed, and ABC may once again be called out for clerical review in later processing. The metadata added to the true positive EIS may also include other information for auditing and traceability such as an identifier for the person making the review decision, the date of review, and other relevant information. These additional metadata are important for proficient main data governance.

True Negative Exclamation

The true negative assertion confirms two or more EIS were called out for review equally potential false negatives have been confirmed as correct by an expert reviewer. Just every bit with the true positive assertion, the truthful negative assertion inserts metadata tags into the reviewed EIS. In the instance of true negative, additional metadata is required because a true negative state always exists between ii (or more than) EIS. Only labeling an EIS every bit a truthful negative does not brand sense by itself. A true negative assertion of an EIS must exist expressed in relation to another EIS. In improver to a true negative label, a true negative assertion must also insert the identifier of the EIS to which it is a true negative. These metadata must exist inserted into all of the EIS the review process determines to exist true negatives of each other.

The instance in Figure 5.7 is for two EIS with identifiers ABC and DEF. The true negative assertion transactions crave three fields – a transaction identifier, an entity identifier of one of the true negative EIS, and a grouping identifier. The group identifier is but a provided value identifying the EIS comprising the truthful negative group. The value of the grouping identifier is not as of import while information technology is the aforementioned in all transactions relating to the aforementioned true negative group and different from the identifier for any other true negative grouping. In this example, the group identifier is 76 for transactions T9 and T10. Considering transaction T11 has a different grouping identifier, it relates to another true negative group not shown.

Figure five.7. True negative assertion.

As shown in Figure 5.7, the true negative assertion of the EIS with identifiers ABC and DEF creates metadata cantankerous-referencing these EIS. The EIS with identifier ABC references the EIS with identifier DEF as a true negative, and conversely, the EIS with identifier DEF references the EIS with identifier ABC as a true negative. These tags volition prevent the clerical review logic from calling out the EIS identified as ABC and DEF as faux negatives in hereafter processes as long as they maintain the original state. Just as with the true positive exclamation, the metadata tags suppressing subsequent true negative review must exist removed if and when a later update process adds new references to any ane of the EIS in a true negative group.

Reference-to-Reference Assertion

Two special types of confirmation assertions are used to move external references into correctly configured EIS. They belong to the category of convenience assertions. Convenience assertions allow the user to directly create and manipulate EIS without using matching rules.

The first convenience assertion is a reference-to-reference assertion used to create a new EIS containing a specific set of source references. The reference-to-reference exclamation bypasses the matching rules and in some ways represents a special type of identity capture configuration. Reference-to-reference assertions are frequently used to migrate intact clusters of references from a legacy MDM system into a new MDM system.

Reference-to-reference assertion transactions crave three fields – a transaction identifier, a reference, and a group identifier. As with the truthful negative assertion, the grouping identifier serves to show which references are to create the same EIS. In the instance of migration from a legacy system, these group identifiers will simply exist the entity identifier assigned to the references by the legacy organization.

In Figure five.eight, the reference-to-reference exclamation transactions T12 and T13 are grouped by identifier 35 indicating references R1 and R2 are to form a new cluster. Depending upon the system, the identifier ABC of the new EIS can be a value automatically generated by the system, or information technology can be a value specified by the user, and again in the instance of legacy migration, could be the group identifier. In the instance where identifiers are provided, the MDM organization should foreclose the user from inadvertently creating indistinguishable identifiers.

Figure 5.8. Reference-to-reference assertion.

Reference-to-Structure Exclamation

The second type of convenience confirmation assertion is a reference-to-structure exclamation used to add ane or more references to an existing EIS. As with a reference-to-reference exclamation, a reference-to-structure exclamation bypasses the matching rules.

Every bit shown in Figure 5.9 , the reference-to-structure assertion transactions require three fields – a transaction identifier, a reference, and an EIS identifier. Grouping is unnecessary for reference-to-structure assertion transactions because each transaction names the specific EIS to which the transaction should be added.

Figure 5.9. Reference-to-construction exclamation.

In the instance of Effigy five.ix, reference-to-construction exclamation transactions T15 and T16 add references R2 and R3, respectively, to the EIS labeled DEF which is already in existence and contains reference R1.

Read full affiliate

URL:

https://www.sciencedirect.com/science/article/pii/B9780128005378000053

Automatic Assignment of IP Addresses with BOOTP and DHCP Objectives

In IP Addressing & Subnetting INC IPV6, 2000

BOOTP Procedure Details

The post-obit section will outline in detail the process betwixt the client and server. It includes a clarification of the bundle contents in each direction.

Client BOOTREQUEST

The client will create a bundle with the following settings:

▪

The IP destination address = 255.255.255.255.

▪

The IP source address and CIADDR = 0.0.0.0, if unknown, or client's address, if known.

▪

The UDP header length field is set to the length of the packet in bytes.

▪

The UDP source port = 68 (BOOTP Client).

▪

The UDP destination port = 67 (BOOTP Server).

▪

The OP field is set up to 1 (BOOTREQUEST).

▪

The HTYPE field is set to the hardware address type.

▪

The HLEN field is set to the length of the hardware address.

▪

The XID field is fix to a random value representing the transaction identifier.

▪

The SECS field is set to zero if this is the first boot request, otherwise information technology is gear up to the time since the start boot request.

▪

The FLAGS field has the loftier-order scrap ready to one if the client tin simply receive a circulate BOOTREPLY; all other bits are fix to zero.

▪

The GIADDR will exist set to 0.0.0.0.

▪

The CHADDR is set to the MAC address of the customer.

▪

The SNAME field may be filled in with the proper name of a server from which the customer wishes to kicking.

▪

The FILE field may be filled with the name of the kicking file from which the client wishes to boot.

▪

The VEND field may be filled with a listing of optional parameters the client is requesting.

If the client does not receive a reply to a BOOTREQUEST later on a certain time period, the client will retransmit the packet with an updated SECS field, showing the elapsed time since the first BOOTP request.

Server BOOTREPLY

When a server receives a BOOTREQUEST message, information technology will perform the following checks:

▪

The SNAME field is checked, to run into if the client requested a specific server. If it did, and the server does non match the current server, the packet may be forwarded using a BOOTP Relay agent function, and the GIADDR will exist updated with the server's address, if it is not already filled in. Alternatively, it may be just discarded, depending on the server.

▪

The CIADDR field volition exist checked. If it is cipher, the server volition bank check the HTYPE, HLEN, and CHADDR fields and will utilize them to identify a record for this client in the database. If it finds a record, it puts the customer'due south assigned address in the YIADDR field. If no record is institute in the BOOTP server's database, the parcel is discarded.

▪

The server will now check the FILE field. If a filename is specified, the server will check it confronting its database. If a match is found, the server will put the complete path to the filename in this field. If the filename doesn't match the database, the serve assumes the customer is asking for a file this server does not know almost, and information technology drops the packet.

▪

The VEND field is now checked for any special information or instructions that the client wishes to convey to the server. The list of vendor options volition be covered later in this chapter.

The server then creates its reply packet with the following settings:

▪

The IP destination address = See Table 7.iii to determine the IP destination address.

Table 7.3. Values in Client Fields and Corresponding Addressing Strategy for Server

BOOTREQUEST Package			BOOTREPLY PACKET
CIADDR	GIADDR	Broadcast Flag	UDP Destination	IP Destination	Data-Link Destination
nonzero	0.0.0.0	X	BOOTPC (68)	CIADDR	Client MAC address
0.0.0.0	nonzero	X	BOOTPS (67)	GIADDR	Client MAC address
0.0.0.0	0.0.0.0	0	BOOTPC (68)	YIADDR	CHADDR
0.0.0.0	0.0.0.0	1	BOOTPC (68)	255.255.255 .255	Broadcast

Tabular array 7.3 outlines the behavior of the server in passing back the BOOTREPLY packet, based on the field contents of the BOOTREQUEST packet from the customer.

Read total chapter

URL:

https://www.sciencedirect.com/science/article/pii/B9781928994015500103

Replication

Philip A. Bernstein , Eric Newcomer , in Principles of Transaction Processing (Second Edition), 2009

1-Copy Serializability

On possible goal of replication is to take replicas behave functionally like nonreplicated servers. This goal tin can be stated precisely past the concept of one-re-create serializability, which extends the concept of serializability to a arrangement where multiple replicas are present. An execution is one-copy serializable if information technology has the same upshot equally a serial execution on a i-copy database. Nosotros would like a system to ensure that its executions are 1-re-create serializable. In such a system, the user is unaware that data is replicated.

In a system that produces serializable executions, what can go wrong that would crusade it to violate ane-copy serializability? The answer is simple, though perhaps not obvious: a transaction might read a copy of a information item, say x, that was non written by the concluding transaction that wrote other copies of ten. For instance, consider a organization that has ii copies of 10, stored at locations A and B, denoted x _A and ten _B. Suppose we express execution histories using the notation of Section 6.i, where r, west, and c correspond read, write, and commit operations, respectively, and subscripts are transaction identifiers. Consider the following execution history:

$\text{H}={\text{r}}_{\mathrm{one}}[x_A]{\text{ w}}_1[x_{\text{A}}]{\text{ w}}_1[x_{\text{B}}]{\text{ c}}_{\mathrm{ane}}{\text{ r}}_2[x_{\text{B}}]{\text{ w}}_2[x_{\text{B}}]{\text{ c}}_{\mathrm{ii}}{\text{ r}}_{\mathrm{three}}[{\mathrm{ten}}_{\text{A}}]{\text{ due west}}_{\mathrm{three}}[{\mathrm{10}}_{\text{A}}]{\text{ due west}}_3[x_{\text{B}}]{\text{ c}}_3\text{undefined}$

This is a serial execution. Each transaction reads but one re-create of x; since the copies are supposed to be identical, any copy volition do. The only difficulty with it is that transaction T_two did non write into copy x _A. This might have happened considering re-create x _A was unavailable when T₂ executed. Rather than delaying the execution of T₂ until after x _A recovered, the system immune T₂ to cease and commit. Since we encounter r₃[10 _A] executed subsequently c₂, obviously x _A recovered before T₃ started. Withal, r_three[10 _A] read a stale value of x _A, the one written by T₁, not T_two.

When x _A recovered, it should have been refreshed with the newly updated value of x that is stored in 10 _B. However, we do not see a write functioning into x _A later on T₂ committed and before r_three[x _A] executed. Nosotros therefore conclude that when r_three[x _A] executed, x _A however had the value that T₁ wrote.

Conspicuously, the behavior of H is not what nosotros would look in a one-copy database. In a ane-re-create database, T₃ would read the value of ten written by T₂, not T_i. There is no other series execution of T₁, T_two, and T₃ that has the same effect every bit H. Therefore, H does not accept the same outcome as any serial execution on a ane-re-create database. Thus, it is not one-copy serializable.

One obvious implication of 1-re-create serializability is that each transaction that writes into a data item 10 should write into all copies of 10. However, when replication is used for improved availability, this isn't ever possible. The whole point is to be able to continue to operate even when some copies are unavailable. Therefore, the non-so-obvious implication of 1-copy serializability is that each transaction that reads a data item x must read a re-create of 10 that was written by the most recent transaction earlier information technology that wrote into whatever re-create of x. This sometimes requires careful synchronization.

Notwithstanding, during normal operation, each transaction's updates should exist applied to all replicas. There are two ways to arrange this: replicate update operations or replicate requests. In the first case, each request causes ane transaction to execute. That transaction generates update operations, each of which is applied to all replicas. In the second example, the request message is sent to all replicas and causes a carve up transaction to execute at each replica. We discuss each case, in plough.

Read full chapter

URL:

https://world wide web.sciencedirect.com/science/commodity/pii/B9781558606234000093

Application Recovery

Gerhard Weikum , Gottfried Vossen , in Transactional Data Systems, 2002

Exercises

17.i

Extend the pseudocode for stateless queued transactions in a two-tier compages, given in Section 17.ii, to include the case of testable output devices such as automated teller machines. The extended pseudocode should have the value-added holding that, once a user input is successfully enqueued, the respective output message is delivered exactly once.

17.2

State an explicit definiteness theorem, similar to the ones given in Sections 17.two and 17.3, for workflows whose country transitions are "protected" by queued transactions as explained in Section 17.4.

17.3

Consider a conversational customer application such equally the travel reservation scenario of Section 17.3. Compare the number and data volume of forced log I/Os for running this application equally a pseudo-conversational queued transaction concatenation versus using the general server respond logging method of Department 17.five, to provide application recovery. Assume that the queue managing director resides on the data server, and forced logging is required merely upon the commit of a transaction.

17.iv

Construct a concrete example, with concrete transaction identifiers, page numbers, and so on, that shows the necessity for the information server to log data read operations on behalf of client requests for the general client-server application recovery, based on the server reply logging method of Department 17.5.

Hint: Consider, for instance, a client asking that invokes a stored procedure on the data server whose execution consists of a sequence of transactions.

17.5

Discuss possible generalizations of the server respond logging method for general client-server applications in the following settings:

(a)

customer applications that interact with more than one data server;

(b)

a data server that itself invokes requests on another information server, for example, to resolve a higher-level data view or wrapped ADT-style object interface past collecting some of the underlying data from a remote site, or to propagate high-level updates onto the underlying base data (e.one thousand., past firing remote triggers), including the important case of maintaining replicated data at multiple sites;

(c)

a three-tier compages where the applications run on the middle-tier application server.

Hint: Lomet and Weikum (1998) provide some high-level ideas nearly possible generalizations and as well point out difficulties in specific kinds of extensions.

Bibliographic Notes

Queued transactions, including the variant of pseudo-conversational transactions, accept been implemented in TP monitors and used in OLTP applications for almost three decades. These developments are documented in not bad detail in the textbooks by Gray and Reuter (1993) and Bernstein and Newcomer (1997). Probably the first scientific paper that explains transactional queues in a systematic, production-independent manner was by Bernstein et al. (1990). The use of transactional guarantees and, particularly, queued transactions for workflow management has been proposed and investigated by Reuter et al. (1992), Alonso et al. (1995), Salzberg and Tombroff (1996), Muth et al. (1998), and Weikum (1999).

Awarding recovery based on recoverable processes and letters was pioneered around 1980 for error-tolerant computer architectures, as documented in the papers past Bartlett (1981), Borr (1981, 1984), and Borg et al. (1983, 1989). Kim (1984) gave a survey on this generation of fault-tolerant systems, which were typically used for extremely mission-critical high-end OLTP-fashion applications just. Freytag et al. (1987) fabricated an early proposal on how to generalize such approaches. Gray (1986) and Härder (1987) have provided insightful discussions on how error-tolerant computer architectures can be combined with the transaction paradigm. Application recovery as a "commodity" option for modern applications has been revived past Lomet (1998a). Our exposition on general-purpose client-server application recovery has followed Lomet and Weikum (1998). Bulletin logging and recovery for bulletin-passing computations has been intensively investigated in the distributed computing research community for many years, with major results contributed or reviewed in papers by Strom and Yemini (1985) as well equally Strom et al. (1988), Johnson and Zwaenepoel (1987, 1990), and Alvisi and Marzullo (1995). This piece of work has had niggling impact on deployed systems, however, for reasons related to impractical assumptions equally farther explained by Huang and Wang (1995).

Read total chapter

URL:

https://www.sciencedirect.com/science/article/pii/B9781558605084500181

Net Security

Jesse Walker , in Network and System Security (Second Edition), 2014

A Symmetric Key Mutual Authentication Method

Our one-time friend the message authentication code can exist used with a static, long-lived key to create a simple and robust mutual hallmark scheme. Earlier we stressed that the properties of message authentication are incompatible with the utilise of a static key to provide forgery detection of session-oriented messages. The incompatibility is due to the apply of sequence numbers for replay detection. We volition replace sequence numbers with unpredictable quantities in order to resocialize static keys. The cost of this resocialization attempt will be a requirement to exchange extra messages.

Suppose parties A and B desire to mutually authenticate. We will assume that ID _A is B'south proper name for the key it shares with A, whereas ID _B is A's name for the same key B. We will also assume that A and B share a long-lived bulletin authentication key M and that M is known merely to A and B. We volition presume that A initiates the authentication. A and B can mutually authenticate using a three-message commutation, equally follows: For message i, A generates a random number R _A and sends a message containing its identity ID _A and random number to B:

(seven.1) $\mathrm{A}\to \mathrm{B}:I{D}_A,R_A$

The notation A→B: 1000 means that A sends message one thousand to B. Here the message beingness passed is specified equally ID _A , R _A , pregnant it conveys A's identity ID _A (or, more precisely, the proper name of the key One thousand) and A'due south random number R _A . This bulletin asserts B'due south proper noun for A, to tell B which is the right long-lived primal it should use in this instance of the authentication protocol. The random number R _A plays the role of the sequence number in the session-oriented case. It is random in guild to provide an unpredictable claiming. If B responds correctly, then this proves that the response is live and was non pre-recorded. R _A too acts as a transaction identifier for the response to A's bulletin 1 (it allows A to recognize which response goes with which bulletin 1). This is important in itself, considering without the power to interleave different instances of the protocol A would have to wait forever for any lost message in club to obtain a correct theory.

If B is willing to accept a chat with A at this fourth dimension, it fetches the correct message authentication key K, generates its own random number R _B , and computes a message authentication code tag T over the message ID _B , ID _A , R _A , R _B , that is, over the message consisting of both names and both random numbers. B appends the tag to the message, which it then sends to A in response to message 1:

(7.2) $\mathrm{B}\to A:I{D}_{B,}I{D}_{A,}{R}_{A,}{R}_{B,}T$

B includes A's name in the message to tell A which key to use to authenticate the message. It includes A's random number R _A in the bulletin to point the protocol case to which this message responds.

The magic begins when A validates the message authentication code tag T. Since independently generated random numbers are unpredictable, A knows that the second message could not have been produced before A sent the first, because it returns R _A to A. Since the authentication code tag T was computed over the ii identities ID _B and ID _A and the two random numbers R _A and R _B using the primal G known only to A and B, and since A did not create the 2d bulletin itself, A knows that B must have created message 2. Hence, message 2 is a response from B to A'southward message 1 for this instance of the protocol. If the message were to contain another random number than R _A , A would know the bulletin is not a response to its message 1.

If A verifies message 2, it responds by calculating a message hallmark code tag T' computed over ID _A and B's random number RB, which it includes in message 3:

(7.3) $\mathrm{A}\to B:I{D}_{A,}{R}_{B,}T\prime$

Reasoning as earlier, B knows A produced message 3 in response to its message 2, because message 3 could non have been produced prior to message 2 and only A could have produced the correct tag T'. Thus, after message 3 is delivered, A and B both have been assured of each other's identity, and they as well hold on the session instance, which is identified past the pair of random numbers R _A and R _B .

A deeper assay of the protocol reveals that bulletin ii must convey both identities and both random numbers protected from forgery by the tag T. This structure binds A's view of the session with B's, and this is providing A with B's view of what they know in common. This bounden prevents interleaving or homo-in-the-middle attacks. Every bit an example, without this binding, a third party, C, could masquerade equally B to A and as A to B. Similarly, bulletin three confirms the mutual knowledge: A knows that B knows that A knows ID _A , ID _B , R _A , and R _B if B verifies the third bulletin; similarly, if B verifies message 3, B knows that A knows that B knows the same parameters.

It is worth noting that message 1 is not protected from either forgery or replay. This lack of any protection is an intrinsic function of the trouble statement. During the protocol, A and B must transition from a state where they are unsure virtually the other's identity and have no communication example instantiating the long-term relationship signified by the encryption key K to a state where they fully agree on each other's identities and a common instance of communication expressing their long-lived human relationship. A makes the transition upon verifying message two, and there are no known ways to reassure it nearly B until this point of the protocol. B makes the state transition once it has completed verification of bulletin three. The signal of the protocol is to transition from a mutually suspicious state to a mutually trusted state.

Read full chapter

URL:

https://world wide web.sciencedirect.com/science/article/pii/B9780124166899000071

Special Issues of Recovery

Gerhard Weikum , Gottfried Vossen , in Transactional Data Systems, 2002

Exercises

15.1

Reconsider the ii-level activeness history in Figure xv.7, which was already discussed in Exercise xiv.three. It contains operations on records (store, alter) and index keys (insert, delete); for the latter operations, the first parameterdenotes a key and the 2nd parameter the RID (i.east., accost) of a stored record. Assume that the insert(f, @ x, t ₁) operation initiates a separate of foliage page fifty creating the new leaf folio one thousand and posting the split to the parent node n. Discuss to what extent logica1 log entries for the higher-level operations are feasible for redo purposes. (For undo, such log entries are needed anyhow.) Tin can nosotros avert creating physiological log entries altogether? Which flush-lodge dependencies need to exist observed for the execution?

Figure fifteen.7. Ii-level history for Exercise 15.one.

xv.2

Requite all log entries and their proper NextUndoSeqNo astern chains for the nested transaction scenario of Figure 15.five. Assume that all of t ₁₁ is executed sequentially in the sense that a new subtransaction begins merely afterward its previously initiated siblings are terminated, and that t ₁₂ is spawned after the termination of t _xi. Within t ₁₂ assume that all subtransactions are spawned asynchronously in separate threads; so at the stop of the scenario all subtransactions of t ₁₂ are simultaneously agile. Draw the necessary steps to abort subtransaction t ₁₂.

xv.3

Revise the pseudocode for the undo laissez passer of the page model redo-history algorithm given at the end of Chapter 13 so that it processes unlike loser transactions in parallel. Use advisable primitives for spawning new threads, suspending a thread to expect for an event, and raising an event to resume waiting threads.

fifteen.4

Develop pseudocode for the lock conflict exam of new transactions that are admitted during the redo pass of a restart, assuming that the Oldest-UndoLSN and the DirtyPages data structures have been determined by the assay pass and serve as an guess test for "uncritical" pages that require neither redo nor undo steps. Assume that page locking is used, but no explicit locks are reacquired during the restart, to keep the overhead low.

fifteen.5

Reconsider and streamline the pseudocode for the analysis and redo pass of the page model redo-history algorithm given at the end of Chapter 13 so that it is particularly suitable for a master-memory database.

15.6

Design a scenario, with physical page numbers, transaction identifiers, log sequence numbers, and and so on, that shows the need for synchronizing the local log sequence numbers created at different servers of a data-sharing cluster. Construct anomalies that would arise if the global sequence numbers merely were local numbers padded with server identifiers.

15.7

Develop pseudocode for the crash recovery in a data-sharing cluster, based on the algorithms outlined in Section 15.6. Assume that all undo-related log entries for the same transaction are confined to a single private log, simply redo log entries for the same folio may be dispersed beyond multiple logs. Further presume that pages tin can be directly transferred between the caches of different servers, without having to be flushed to disk. Distinguish ii cases:

(a)

recovery from a single server crash, where one of the other servers takes over the failed server'southward role,

(b)

recovery from a software failure that brings down the unabridged cluster (which is unlikely, only still possible), bold that none of the disks is damaged.

Bibliographic Notes

Recovery for index structures has been described in great detail by Mohan and Levine (1992) as well every bit Mohan (1996), based on the object model recovery principles from Chapter 14. Generalizations to other kinds of alphabetize trees, including R trees, accept been described by Kornacker et al. (1997). For the logging optimizations presented here we have mostly followed Lomet (1998a, b) as well as Lomet and Salzberg (1997). Lomet and Tuttle (1995, 1999) developed the method for logical redo with proper handling of flush dependencies; this work has been the footing for our presentation of how logging costs for large-object operations tin can be reduced. Other approaches to efficient logging and recovery for large objects, mostly based on shadowing (i.e., a pageoriented grade of versioning, run into Affiliate 12), have been discussed by Lehman and Lindsay (1989) as well as Panagos and Biliris (1997). Low-level optimizations for storage-layer metadata, particularly free space management, have been described by Mohan and Haderle (1994).

Our word of intra-transaction savepoints and fractional rollbacks has followed the seminal work past Mohan, Haderle, et al. (1992) on the ARIES recovery method. Rollback for explicitly structured nested transactions has been incorporated in the recovery algorithms by Moss (1987), Härder and Rothermel (1987), Rothermel and Mohan (1989), and Lomet (1992). Full-fledged implementations of nested transactions have been described by Eppinger et al. (1991) and Liskov et al. (1987).

The section on exploiting parallelism during restart and assuasive new transactions before the restart is consummate is based on Mohan, Haderle, et al. (1992) and Mohan (1993b). Early work on parallelizing logging and recovery can be traced back to R. Agrawal (1985) equally well as R. Agrawal and DeWitt (1985b). DeWitt and Gray (1992) give an introduction to parallel database applied science in full general. Early piece of work about recovery for main-retentivity databases goes back to DeWitt et al. (1984), Hagman (1986), and Lehmann and Carey (1987), and overviews nigh the subject take been given by Salem and Garcia-Molina (1990), Garcia-Molina and Salem (1992), and Dunham et al. (1998). State-of-the-art object model techniques for fast, incremental restart accept been described in detail past Levy and Silberschatz (1992), Jagadish et al. (1993), and Rastogi et al. (1998). A specialized approach to main-retention data servers with sequential execution of (brusk) transactions has been described by Whitney et al. (1997).

Our presentation of recovery for information-sharing clusters has generally followed Mohan and Narang (1991, 1992a, b). Other methods along these lines have been adult past Rahm (1991) and Lomet (1990). Molesky and Ramamritham (1995) accept discussed extensions to and optimizations for cache-coherent shared memory multiprocessors. The scheme for coordinating sequence numbers across dissimilar servers is substantially a Lamport clock, named later on Leslie Lamport (1978). A mathematical assay of the expected restart fourth dimension in a cluster has been carried out by Dan et al. (1997). A more general account of the benefits and problems of cluster architectures has been given past Vogels et al. (1998). Recovery issues for the highly related client caching compages accept been discussed by Franklin et al. (1992), Mohan and Narang (1994), besides equally Panagos and Biliris (1997).

Read full chapter

URL:

https://world wide web.sciencedirect.com/science/article/pii/B9781558605084500168

mullinsiturettem72.blogspot.com

Source: https://www.sciencedirect.com/topics/computer-science/transaction-identifier

Share this post