COM+ Transactions Writing Components In Visual Basic ® Brian A. Randell DevelopMentor 1-304

COM+ TransactionsCOM+ TransactionsWriting Components In Visual BasicWriting Components In Visual Basic®®

Brian A. RandellBrian A. RandellDevelopMentorDevelopMentor

1-3041-304

developmentormentor Hands-on training for hardcore Hands-on training for hardcore

developersdevelopers Guerrilla training courses:Guerrilla training courses:

Guerrilla VB & Guerrilla COM (C++)Guerrilla VB & Guerrilla COM (C++) COM courses with banker’s hours:COM courses with banker’s hours:

Essential COM+ for VB programmersEssential COM+ for VB programmers Essential COM+ for C++ programmersEssential COM+ for C++ programmers

Lots of other Lots of other courses too!courses too!

AgendaAgenda

OLTP ConceptsOLTP Concepts The ACID rules, isolation & lockingThe ACID rules, isolation & locking Writing transactionsWriting transactions

Distributed TransactionsDistributed Transactions Transaction managers & the 2-phase Transaction managers & the 2-phase

commit protocolcommit protocol COM+ TransactionsCOM+ Transactions

Creating objects inside a transactionCreating objects inside a transaction Controlling a distributed transaction’s Controlling a distributed transaction’s

outcomeoutcome

Transaction FundamentalsTransaction Fundamentals

Most business applications use data in Most business applications use data in some waysome way Some apps are concerned with querying & Some apps are concerned with querying &

analyzing dataanalyzing data Other apps are primarily concerned with Other apps are primarily concerned with

modifying datamodifying data Apps that modify data and have many Apps that modify data and have many

users are commonly referred to as users are commonly referred to as on-line transaction processing (OLTP) on-line transaction processing (OLTP) systemssystems

What Is A Transaction?What Is A Transaction?

Imagine an application that Imagine an application that processes purchase ordersprocesses purchase orders Each order requires 3 database Each order requires 3 database

modificationsmodifications1)1) Order quantity must be deducted from inventoryOrder quantity must be deducted from inventory

2)2) Purchase price must be charged to customerPurchase price must be charged to customer

3)3) Order record must be inserted in Orders table Order record must be inserted in Orders table

These three modifications make up These three modifications make up one transaction (TX)one transaction (TX) These modifications represent a These modifications represent a

single unit of worksingle unit of work

The ACID RulesThe ACID Rules

A transaction must meet 4 basic A transaction must meet 4 basic requirementsrequirements

It must be It must be atomicatomic A transaction must be an all-or-nothing A transaction must be an all-or-nothing

propositionpropositioneverything must be successfully written everything must be successfully written or nothing should be writtenor nothing should be written

It must be It must be consistentconsistent The data used by an application is never The data used by an application is never

left in an invalid state after a transaction left in an invalid state after a transaction has completedhas completed

The ACID RulesThe ACID Rules

It must be It must be isolatedisolated The uncommitted changes of one user are The uncommitted changes of one user are

never seen by another user. Systems that never seen by another user. Systems that run concurrent transactions require run concurrent transactions require blockingblocking

It must be It must be durabledurable Once a transaction has committed, the Once a transaction has committed, the

data source has stored all changes in data source has stored all changes in persistent storage and these changes can persistent storage and these changes can be recovered in the event of a system be recovered in the event of a system failurefailure

Isolation & LockingIsolation & Locking

A transaction has one of two outcomesA transaction has one of two outcomes Successful transactions are committedSuccessful transactions are committed Unsuccessful transactions are abortedUnsuccessful transactions are aborted

Isolation is required during a Isolation is required during a transactionstransactions Uncommitted changes might be rolled backUncommitted changes might be rolled back Reading uncommitted changes can lead to Reading uncommitted changes can lead to

inconsistent datainconsistent data TX2 cannot see the uncommitted changes TX2 cannot see the uncommitted changes

of other TX1of other TX1

Potential Concurrency ProblemsPotential Concurrency Problems

Naïve concurrent execution of Naïve concurrent execution of transactions would yield the following transactions would yield the following problems:problems: Lost UpdatesLost Updates Dirty ReadsDirty Reads Unrepeatable ReadsUnrepeatable Reads PhantomsPhantoms

Properly isolated transactions do not Properly isolated transactions do not exhibit any of these problemsexhibit any of these problems

Degrees Of IsolationDegrees Of Isolation

Whether or not these problems occur Whether or not these problems occur depends on a transaction’s depends on a transaction’s degree of degree of isolationisolation

Common NameCommon Name

11 2200 33DegreeDegree

Read Read UncommittedUncommitted

Read Read CommittedCommittedChaosChaos SerializableSerializable

AKAAKA BrowseBrowse Cursor Cursor StabilityStability IsolatedIsolated

NoNoYesYes NoNo

YesYesYesYes NoNo

Lost Updates?Lost Updates? NoNo

Dirty Reads?Dirty Reads? NoNo

Unrepeatable Reads?Unrepeatable Reads? YesYes YesYesYesYes NoNo

Phantoms?Phantoms? YesYes YesYes YesYes NoNo

2.9992.999

RepeatableRepeatableReadRead

NoNo

NoNo

NoNo

YesYes

Isolation & LockingIsolation & Locking

Isolation is provided by a lock managerIsolation is provided by a lock manager A data source such as DBMS provides a A data source such as DBMS provides a

lock managerlock manager Uncommitted changes are isolated with Uncommitted changes are isolated with

write lockswrite locks write locks are also known as exclusive lockswrite locks are also known as exclusive locks

Additional consistency is provided Additional consistency is provided through read locksthrough read locks read locks are also known as shared locksread locks are also known as shared locks

Locks are placed on data itemsLocks are placed on data items Could be a file, a table, a page or a recordCould be a file, a table, a page or a record

Locking BasicsLocking Basics Many concurrent systems use locks to Many concurrent systems use locks to

implement isolation levelsimplement isolation levels Model relies on two types of locks to avoid Model relies on two types of locks to avoid

“problems” but allow maximum concurrency“problems” but allow maximum concurrency Read (shared) locks allow multiple Read (shared) locks allow multiple

transactions to read a piece of state transactions to read a piece of state concurrentlyconcurrently

Write (exclusive) locks allow exactly one Write (exclusive) locks allow exactly one transaction to write to a piece of statetransaction to write to a piece of state Requires that no read locks are outstandingRequires that no read locks are outstanding Classic Win32 synchronization primitives (e.g., Classic Win32 synchronization primitives (e.g.,

Mutex, Critical Section) are write locksMutex, Critical Section) are write locks

Lock Managers & BlockingLock Managers & Blocking

Write locks block all other locksWrite locks block all other locks One transaction blocks all other One transaction blocks all other

transactionstransactions Read locks only block write locksRead locks only block write locks

Many transactions can read the same data Many transactions can read the same data item at the same timeitem at the same time

Here’s how it worksHere’s how it works

Attempt Read LockAttempt Read Lock

Attempt Write LockAttempt Write Lock

Read Lock HeldRead Lock Held Write Lock HeldWrite Lock HeldNo Lock HeldNo Lock Held

Lock GrantedLock Granted Lock GrantedLock Granted Request BlockedRequest Blocked

Lock GrantedLock Granted Request BlockedRequest Blocked Request BlockedRequest Blocked

Isolation LevelsIsolation Levels How long are locks held?How long are locks held?

Write locks are always held until the end Write locks are always held until the end of the transactionof the transaction

Read locks might or might not be held Read locks might or might not be held until the end of the transactionuntil the end of the transaction

The isolation level adjusts the duration The isolation level adjusts the duration and behavior of read locksand behavior of read locks Higher isolation provides better Higher isolation provides better

consistencyconsistency Lower isolation provides better Lower isolation provides better

concurrencyconcurrency

Adjusting Isolation LevelsAdjusting Isolation Levels

Occasionally useful to loosen isolation Occasionally useful to loosen isolation requirements to increase overall requirements to increase overall system throughputsystem throughput Must tolerate one or more problems!!Must tolerate one or more problems!!

Adjustment of isolation levels is not Adjustment of isolation levels is not always possiblealways possible Some data managers don’t allow itSome data managers don’t allow it

As we’ll see, COM+ has a specific As we’ll see, COM+ has a specific setting in mind!setting in mind!

Running Local TransactionsRunning Local Transactions

Local transactions are managed by a Local transactions are managed by a DBMS’s transaction managerDBMS’s transaction manager The transaction manager works together The transaction manager works together

with the lock managerwith the lock manager How do you run a local transaction?How do you run a local transaction?

You write explicit commands to start, You write explicit commands to start, commit and rollback the transactioncommit and rollback the transaction

Transaction logic is usually embedded in Transaction logic is usually embedded in a SQL batch or a stored procedurea SQL batch or a stored procedure

Running Local TransactionsRunning Local Transactions

DBMSDBMSSQLSERVR.EXESQLSERVR.EXECOM+ ApplicationCOM+ Application

ActivityActivity

ADOADOConnConn

VB VB ObjectObject

ActivityActivity

ADOADOConnConn

VB VB ObjectObject

ActivityActivity

ADOADOConnConn

VB VB ObjectObject

Client 1Client 1

Client 2Client 2

Client NClient N

Transaction Transaction ManagerManager

LockLockManagerManager

DataData

Programming Local Tx’s #1Programming Local Tx’s #1

This examples uses an ADO This examples uses an ADO connectionconnection ADO connection object provides ADO connection object provides

transaction controltransaction control This technique can be used with any This technique can be used with any

ODBC or OLE-DB data source that ODBC or OLE-DB data source that supports transactionssupports transactions

Controlling transactions from an ADO Controlling transactions from an ADO connection can be expensive due to the connection can be expensive due to the need to use use extra round trips to DBMS need to use use extra round trips to DBMS to start/commit/abortto start/commit/abort

ADO ExampleADO Example

Dim conn As ConnectionDim conn As ConnectionSet conn = New ConnectionSet conn = New Connectionconn.Open "DSN=Market;UID=sa;PWD="conn.Open "DSN=Market;UID=sa;PWD="conn.IsolationLevel = adXactSerializableconn.IsolationLevel = adXactSerializableconn.BeginTransconn.BeginTrans ' SQL statements omitted for clarity' SQL statements omitted for clarity conn.Execute SQL_DecrementInventoryconn.Execute SQL_DecrementInventory conn.Execute SQL_ChargeCustomerconn.Execute SQL_ChargeCustomer conn.Execute SQL_AddOrderconn.Execute SQL_AddOrderconn.CommitTransconn.CommitTrans

Programming Local Tx’s #2Programming Local Tx’s #2

Control the transaction using SQLControl the transaction using SQL SQL logic is embedded into a SQL batch SQL logic is embedded into a SQL batch

or stored procedureor stored procedure Isolation level can be adjusted on a Isolation level can be adjusted on a

statement-by-statement statement-by-statement basis using hintsbasis using hints

This approach usually requires SQL that This approach usually requires SQL that is specific to a particular DBMSis specific to a particular DBMS

Writing fast OLTP code works across Writing fast OLTP code works across DBMS’s is usually impossibleDBMS’s is usually impossible

T-SQL ExampleT-SQL Example

-- set isolation level to serializable-- set isolation level to serializableSET TRANSACTION ISOLATION LEVEL SERIALIZABLESET TRANSACTION ISOLATION LEVEL SERIALIZABLE-- run transaction to purchase a product-- run transaction to purchase a productBEGIN TRANSACTIONBEGIN TRANSACTION -- decrement product quantity from inventory-- decrement product quantity from inventory UPDATE Products UPDATE Products SET Quantity = Quantity - 1SET Quantity = Quantity - 1 WHERE Product = 'Dog'WHERE Product = 'Dog' -- charge price to customer account-- charge price to customer account UPDATE Customers UPDATE Customers SET AccountBalance = AccountBalance + 20SET AccountBalance = AccountBalance + 20 WHERE Customer = 'Bob'WHERE Customer = 'Bob' -- add order record-- add order record INSERT Orders(Customer, Product, Quantity, Price)INSERT Orders(Customer, Product, Quantity, Price) VALUES('Bob', 'Dog', 1, 20)VALUES('Bob', 'Dog', 1, 20)COMMIT TRANSACTIONCOMMIT TRANSACTION

Distributed TransactionsDistributed Transactions

Local transactions only work when all Local transactions only work when all the data lives in one placethe data lives in one place For example, all the data lives in a single For example, all the data lives in a single

DBMSDBMS The transaction manager inside the DBMS The transaction manager inside the DBMS

enforces ACID rulesenforces ACID rules What if the data lives in multiple data What if the data lives in multiple data

sources?sources? The problem is much more difficultThe problem is much more difficult Commit/Abort logic must be coordinated Commit/Abort logic must be coordinated

across multiple data sourcesacross multiple data sources

2-Phase Commit Protocol2-Phase Commit Protocol

Many vendors offer products that solve Many vendors offer products that solve the problems of distributed the problems of distributed transactions in the same waytransactions in the same way

CICS from IBM, TUXEDO from BEA CICS from IBM, TUXEDO from BEA System and COM+ from Microsoft all System and COM+ from Microsoft all use similar high-level architecturesuse similar high-level architectures

Architecture uses an abstraction called Architecture uses an abstraction called the transaction manager and a protocol the transaction manager and a protocol called called 2-phase commit2-phase commit

The Microsoft DTCThe Microsoft DTC

The DTC is the Distributed Transaction The DTC is the Distributed Transaction CoordinatorCoordinator It is Microsoft's transaction managerIt is Microsoft's transaction manager

It coordinates distributed transactions It coordinates distributed transactions and enforces the ACID rulesand enforces the ACID rules

It executes the 2-phase commit It executes the 2-phase commit protocolprotocol

Originally released as a part Originally released as a part of SQL Serverof SQL Server Now an integrated part of MTS & COM+Now an integrated part of MTS & COM+

Computer 3Computer 3

RM3 - ORACLERM3 - ORACLE

Participating DTCParticipating DTC


RM2 -SQL ServerRM2 -SQL Server



The Coordinating DTC The Coordinating DTC

RM1 - RM1 - MSMQMSMQ

A Distributed TransactionA Distributed Transaction

DataData

DataData

Your Tx COM+ ApplicationYour Tx COM+ Application

QueueQueue

RM ProxyRM Proxy

RM ProxyRM ProxyRM ProxyRM Proxy

COM+ TransactionsCOM+ Transactions

COM+ transactions make your COM+ transactions make your life much easierlife much easier COM+ provides a programming model COM+ provides a programming model

with declarative transactionswith declarative transactions COM+ transaction represents a set of COM objectsCOM+ transaction represents a set of COM objects

You create your objects inside an COM+ You create your objects inside an COM+ transactiontransaction

Your objects establish and enlist Your objects establish and enlist connections to resource managersconnections to resource managers

Your objects read and write data inside Your objects read and write data inside the scope of a DTC transactionthe scope of a DTC transaction

COM+ TransactionsCOM+ Transactions

What’s different about this model?What’s different about this model? You never explicitly start a transactionYou never explicitly start a transaction You never explicitly commit a transactionYou never explicitly commit a transaction You never explicitly abort a transactionYou never explicitly abort a transaction

So how does it work?So how does it work? A COM+ transaction is a friendly wrapper A COM+ transaction is a friendly wrapper

around a DTC transactionaround a DTC transaction

A Tale Of Two TransactionsA Tale Of Two Transactions

There are really two transactionsThere are really two transactions MTS/COM+ creates a MTS/COM+ creates a logical transaction logical transaction when an object is when an object is

created from a component marked created from a component marked Requires Requires or or Requires NewRequires New MTS/COM+ creates a MTS/COM+ creates a physical transactionphysical transaction by calling to DTC by calling to DTC

transaction dispenser and invoking transaction dispenser and invoking BeginTransactionBeginTransaction MTS delays start of DTC transaction until object activation timeMTS delays start of DTC transaction until object activation time COM+ further delays start of DTC transaction until first COM+ further delays start of DTC transaction until first

"interesting" call"interesting" call DTC transaction is created with isolation level of DTC transaction is created with isolation level of serializableserializable DTC transaction has a default time out interval of DTC transaction has a default time out interval of 60 seconds60 seconds

The MTS/COM+ runtime controls the physical DTC The MTS/COM+ runtime controls the physical DTC transactiontransaction MTS/COM+ calls Commit or Abort when the root object is MTS/COM+ calls Commit or Abort when the root object is

deactivateddeactivated You can change things in the logical transaction to affect what You can change things in the logical transaction to affect what

goes on with the physical transactiongoes on with the physical transaction

Creating Objects In A TransactionCreating Objects In A Transaction

A transaction must exist within the scope of an activityA transaction must exist within the scope of an activity This eliminates problems with concurrency and reentrancyThis eliminates problems with concurrency and reentrancy Secondary objects should be created with CreateInstance in Secondary objects should be created with CreateInstance in

MTSMTS Secondary objects should be created with CreateObject in Secondary objects should be created with CreateObject in

COM+COM+ Every configured component has a Transaction Support Every configured component has a Transaction Support

propertyproperty Configured components can be marked as...Configured components can be marked as...

Requires a transaction: inherits transaction of creator, COM+ Requires a transaction: inherits transaction of creator, COM+ creates one if necessary creates one if necessary

Requires a new transaction: never inherits transaction of Requires a new transaction: never inherits transaction of creator, COM+ always creates onecreator, COM+ always creates one

Supports transactions: inherits transaction of creator if present, Supports transactions: inherits transaction of creator if present, otherwise runs withoutotherwise runs without

Does not support transactions: never inherits transaction of Does not support transactions: never inherits transaction of creator, always runs withoutcreator, always runs without

' root object is set to: Requires Transaction' root object is set to: Requires Transaction' this code assumes COM+ as opposed to MTS' this code assumes COM+ as opposed to MTSPublic Sub CreateOtherObjects()Public Sub CreateOtherObjects() Dim Joe As CJoe, Brian As CBrianDim Joe As CJoe, Brian As CBrian Dim Jason As CJason, Ted As CTedDim Jason As CJason, Ted As CTed Set Joe = Set Joe = CreateObject("MyDll.CJoe")CreateObject("MyDll.CJoe") Set Brian = Set Brian = CreateObject("MyDll.CBrian")CreateObject("MyDll.CBrian") Set Jason = Set Jason = CreateObject("MyDll.CJason")CreateObject("MyDll.CJason") Set Ted = Set Ted = CreateObject("MyDll.CTed")CreateObject("MyDll.CTed")End SubEnd Sub

CJoe: CJoe: Requires Requires CBrian: CBrian: Requires newRequires newCJason: CJason: supportssupportsCTed: CTed: does not supportdoes not support

Creating Secondary ObjectsCreating Secondary Objects

Creating Secondary ObjectsCreating Secondary Objects

COM+ RuntimeCOM+ Runtime

Transaction 1Transaction 1

TedTed

ClientClient

Transaction 2Transaction 2

RootRoot

JasonJasonJoeJoe

BrianBrian

Activity boundaryActivity boundary

COM+ TransactionCOM+ Transaction

DoomedDoomed FALSEFALSE

Commit/Abort BehaviorCommit/Abort Behavior

When the root object is deactivated…When the root object is deactivated… The MTS/COM+ runtime calls either Commit or AbortThe MTS/COM+ runtime calls either Commit or Abort There are 3 flags you need to know aboutThere are 3 flags you need to know about

Context AContext A

HappyHappy TRUETRUE

DoneDone FALSEFALSE

RootRootObjectObject

COM+COM+ProxyProxy

ClientClient

Controlling A Declarative Controlling A Declarative TransactionTransaction The ObjectContext interface allows objects to voteThe ObjectContext interface allows objects to vote

Any object that dies unhappy will doom transaction to failureAny object that dies unhappy will doom transaction to failure An secondary object which doesn't vote gives passive An secondary object which doesn't vote gives passive

consent to commit changesconsent to commit changes Root object MUST call SetComplete to commit changesRoot object MUST call SetComplete to commit changes

Important methods in the ObjectContext interfaceImportant methods in the ObjectContext interface DisableCommitDisableCommit:: object is saying "I'm unhappy but I’m not object is saying "I'm unhappy but I’m not

done - someone could still make me happy."done - someone could still make me happy." EnableCommitEnableCommit:: object is saying "I'm happy but I’m not done. object is saying "I'm happy but I’m not done.

Someone could still change my mind."Someone could still change my mind." SetCompleteSetComplete:: object is saying "I'm happy and I’m done. I am object is saying "I'm happy and I’m done. I am

now ready to be deactivated."now ready to be deactivated." SetAbortSetAbort:: object is saying "I'm unhappy and I’m done. I will object is saying "I'm unhappy and I’m done. I will

now deactivate and doom transaction"now deactivate and doom transaction"

The IContextState InterfaceThe IContextState Interface ObjectContext methods set both DONE bit and HAPPY ObjectContext methods set both DONE bit and HAPPY

bitbit SetComplete, SetAbort, DisableCommit, EnableCommitSetComplete, SetAbort, DisableCommit, EnableCommit

COM+ introduces the IConstextState interfaceCOM+ introduces the IConstextState interface SetMyTransactionVoteSetMyTransactionVote GetMyTransactionVoteGetMyTransactionVote SetDeactivateOnReturnSetDeactivateOnReturn GetDeactivateOnReturnGetDeactivateOnReturn

How does IContextState differ from ObjectContextHow does IContextState differ from ObjectContext You can read the value of the done bit and the happy bitYou can read the value of the done bit and the happy bit The methods raise errors if the object isn't in a transactionThe methods raise errors if the object isn't in a transaction

Should you use IContextState instead of ObjectContextShould you use IContextState instead of ObjectContext No real need – unless you want to read the happy or done bitNo real need – unless you want to read the happy or done bit

Multi-Object Transaction IssuesMulti-Object Transaction Issues

Creating secondary objects in a transactionCreating secondary objects in a transaction Each transaction has a Each transaction has a root object root object

the root is created by a base client in the simplest scenariothe root is created by a base client in the simplest scenario All objects in a transaction must share the same activityAll objects in a transaction must share the same activity

This eliminates issues with concurrency and synchronizationThis eliminates issues with concurrency and synchronization Transaction Support property must be set properlyTransaction Support property must be set properly In COM+, the root should create secondary objects by calling In COM+, the root should create secondary objects by calling

CreateObjectCreateObject In MTS, the root should create secondary objects by calling In MTS, the root should create secondary objects by calling

CreateInstanceCreateInstance Remember the Remember the New New operator can get you into trouble on either operator can get you into trouble on either

platformplatform Secondary objects usually connect to RM to access dataSecondary objects usually connect to RM to access data

MTS/COM+ automatically enlists connections in current MTS/COM+ automatically enlists connections in current transaction when made to a valid resource manager (RM) through transaction when made to a valid resource manager (RM) through a RM proxya RM proxy

Each secondary object gets to vote on the transaction's outcomeEach secondary object gets to vote on the transaction's outcome

How Does Voting Work?How Does Voting Work? Any object can prevent the transaction from Any object can prevent the transaction from

committingcommitting If If a secondary object is deactivated in an unhappy statea secondary object is deactivated in an unhappy state

ThenThen MTS/COM+ sets the transaction's doomed flag to true MTS/COM+ sets the transaction's doomed flag to true Setting the doomed flag to true is irreversibleSetting the doomed flag to true is irreversible

COM+ TransactionCOM+ TransactionDoomedDoomed True/False True/False

ClientClient

SecondarySecondaryObject 1Object 1




proxyproxyHappyHappy DoneDone




Writing Commit/Abort LogicWriting Commit/Abort Logic Each transaction must have a root objectEach transaction must have a root object

This usually defines the client's entry point into the packageThis usually defines the client's entry point into the package Root should always call Root should always call SetComplete SetComplete or or SetAbort SetAbort to release txto release tx

Secondary objects can also vote in transaction outcomeSecondary objects can also vote in transaction outcome If any secondary object can vote to rollback the transactionIf any secondary object can vote to rollback the transaction MTS/COM+ sets doomed flag to true when deactivating an MTS/COM+ sets doomed flag to true when deactivating an

unhappy objectunhappy object

Root must somehow discover transaction is doomedRoot must somehow discover transaction is doomed No way for root to discover this through ObjectContext interfaceNo way for root to discover this through ObjectContext interface Calling Calling SetCompleteSetComplete in root after a secondary object has set the in root after a secondary object has set the

doomed flag will result in a runtime errordoomed flag will result in a runtime error An attempt to activate an object in a doomed transaction results An attempt to activate an object in a doomed transaction results

in an errorin an error Secondary objects should raise errors when voting to rollbackSecondary objects should raise errors when voting to rollback

Watch Out When Calling Watch Out When Calling SetAbort In COM+SetAbort In COM+ There's an ugly bug in COM+ that isn’t in MTSThere's an ugly bug in COM+ that isn’t in MTS

Secondary objects should not raise an error after setting the Secondary objects should not raise an error after setting the done bitdone bit

The bug steps on the error message and the root gets the The bug steps on the error message and the root gets the infamous error message infamous error message "method '~' of object '~' failed""method '~' of object '~' failed"

This bug breaks MTS code when you move your application This bug breaks MTS code when you move your application to Win2Kto Win2K

The bug will be fixed in Win2K service pack1The bug will be fixed in Win2K service pack1 Here's a workaround until the bug is fixedHere's a workaround until the bug is fixed

Secondary objects should avoid calling SetAbort before Secondary objects should avoid calling SetAbort before raising an errorraising an error

Secondary objects should call SetMyTransactionVote or Secondary objects should call SetMyTransactionVote or DisableCommit instead – DisableCommit instead – just don’t set the done bit to truejust don’t set the done bit to true

What are the worst things about is this bug a problemWhat are the worst things about is this bug a problem MTS code will break when run under COM+MTS code will break when run under COM+ You can’t really create a component that can act as either the You can’t really create a component that can act as either the

root or as a secondary objectroot or as a secondary object

Remote Computer 2Remote Computer 2

ORACLE (RM2)ORACLE (RM2)


Remote Computer 1Remote Computer 1

SQL Server (RM1)SQL Server (RM1)


COM+ ComputerCOM+ Computer

Coordinating DTCCoordinating DTC

COM+ ApplicationCOM+ Application

COM+ RuntimeCOM+ Runtime

User’s ComputerUser’s Computer

Base ClientBase Client

COM+ TransactionCOM+ Transaction

DataData

DataData

DTC Proxy LayerDTC Proxy Layer

RootRoot

SecondarySecondary

SecondarySecondary

Enlisting Resource Enlisting Resource ManagersManagers

Going StatelessGoing Stateless Transactional objects typically die after each method Transactional objects typically die after each method

callcall Calling Calling SetComplete SetComplete or or SetAbortSetAbort on ObjectContext tells on ObjectContext tells

MTS/COM+ that the object's work is done and it can be MTS/COM+ that the object's work is done and it can be deactivated (i.e. destroyed)deactivated (i.e. destroyed)

Object destruction occurs in interception layer in method post-Object destruction occurs in interception layer in method post-processingprocessing

MTS/COM+ hides object destruction from clientsMTS/COM+ hides object destruction from clients The client holds a persistent connection to system-supplied The client holds a persistent connection to system-supplied

proxyproxy MTS/COM+ uses just-in-time activation to create a new object MTS/COM+ uses just-in-time activation to create a new object

for each method called from the clientfor each method called from the client How does this affect the way you program?How does this affect the way you program?

It helps you to release your transactions ASAPIt helps you to release your transactions ASAP It discards state acquired from RMs before locks are releasedIt discards state acquired from RMs before locks are released

this is required to enforce the ACID rulesthis is required to enforce the ACID rules This can make design more difficult because objects cannot This can make design more difficult because objects cannot

hold statehold state

Stateless Versus Stateful Stateless Versus Stateful ComponentsComponents Statelessness is a strange side-effect of declarative Statelessness is a strange side-effect of declarative

transactionstransactions You must design around the assumption that state is lost on You must design around the assumption that state is lost on

every method call to a transactional objectevery method call to a transactional object Many misinformed authorities have suggested that the point of Many misinformed authorities have suggested that the point of

calling SetComplete is aggressive memory reclamation (calling SetComplete is aggressive memory reclamation (this is this is totally untruetotally untrue))

Deactivation and JIT reactivation is only for transactional Deactivation and JIT reactivation is only for transactional objects and poolable objects (objects and poolable objects (there is no reason to set the done there is no reason to set the done bit in any other casebit in any other case))

Objects that need transactions can hold stateObjects that need transactions can hold state Many designs require that state is held across method callsMany designs require that state is held across method calls

losing state implies that object must be recreated & reinitialized on a per call losing state implies that object must be recreated & reinitialized on a per call basisbasis

Many advantages of MTS/COM+ apply to non-transactional Many advantages of MTS/COM+ apply to non-transactional objects as wellobjects as wellstateful objects benefit from thread pooling, COM+ security, stateful objects benefit from thread pooling, COM+ security, configuration mgmt, etc.configuration mgmt, etc.

Consider Using The Lower Consider Using The Lower Design ApproachDesign Approach It’s often advantageous to place a a It’s often advantageous to place a a

non-transactional object between a non-transactional object between a transactional object and the clienttransactional object and the client Client can hold server-side state and still Client can hold server-side state and still

run declarative transactionsrun declarative transactions Non-transaction object can shield client Non-transaction object can shield client

from errors thrown by the DTCfrom errors thrown by the DTC

Consider Using The Lower Consider Using The Lower Design ApproachDesign Approach

Client Application 1Client Application 1

COM+ ApplicationCOM+ Application


Happy BitHappy Bit TRUETRUE

Context AContext A

StubStub

Done BitDone Bit TRUETRUE

ProxyProxyClientClient

Client Application 2Client Application 2 Context BContext B

StubStubProxyProxy

ClientClient RootRootObjectObject

Happy BitHappy Bit TRUETRUE

Context CContext C

Done BitDone Bit TRUETRUE

Non-TXNon-TXObjectObject

ProxyProxy

When Should You Use When Should You Use Transactions?Transactions? You should use transactions only when you need to You should use transactions only when you need to

enforce the ACID rulesenforce the ACID rules They're expensive and reduce scalability when used They're expensive and reduce scalability when used

unnecessarily unnecessarily Only run transactions when you need acquire locks across a set Only run transactions when you need acquire locks across a set

of operationsof operations You don’t need an explicit transaction for an individual SQL You don’t need an explicit transaction for an individual SQL

statementstatementthe DBMS runs each SQL statement as an individual transaction automaticallythe DBMS runs each SQL statement as an individual transaction automatically

How do you decide between local and distributed How do you decide between local and distributed transactions?transactions? Local transaction are always faster (no DTC & fewer roundtrips)Local transaction are always faster (no DTC & fewer roundtrips) Distributed transactions are required when your data lives in Distributed transactions are required when your data lives in

many RMsmany RMs Distributed transaction can make your designs and Distributed transaction can make your designs and

programming easierprogramming easierbut they do so at the expense of response times and overall system throughputbut they do so at the expense of response times and overall system throughput

SummarySummary OLTP ConceptsOLTP Concepts

The ACID rulesThe ACID rules Isolation and lockingIsolation and locking Writing local transactionsWriting local transactions

Distributed TransactionsDistributed Transactions The transaction manager and two phase commitThe transaction manager and two phase commit The Distributed Transaction CoordinatorThe Distributed Transaction Coordinator Writing distributed transactionsWriting distributed transactions

MTS/COM+ TransactionsMTS/COM+ Transactions Creating objects inside a transactionCreating objects inside a transaction Controlling the transactions outcomeControlling the transactions outcome

Documents

COM+ Transactions Writing Components In Visual Basic ® Brian A. Randell DevelopMentor 1-304