001: /*
002:
003: Derby - Class org.apache.derby.impl.store.raw.xact.RowLocking1
004:
005: Licensed to the Apache Software Foundation (ASF) under one or more
006: contributor license agreements. See the NOTICE file distributed with
007: this work for additional information regarding copyright ownership.
008: The ASF licenses this file to you under the Apache License, Version 2.0
009: (the "License"); you may not use this file except in compliance with
010: the License. You may obtain a copy of the License at
011:
012: http://www.apache.org/licenses/LICENSE-2.0
013:
014: Unless required by applicable law or agreed to in writing, software
015: distributed under the License is distributed on an "AS IS" BASIS,
016: WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
017: See the License for the specific language governing permissions and
018: limitations under the License.
019:
020: */
021:
022: package org.apache.derby.impl.store.raw.xact;
023:
024: import org.apache.derby.iapi.services.locks.LockFactory;
025: import org.apache.derby.iapi.services.locks.C_LockFactory;
026: import org.apache.derby.iapi.services.locks.Latch;
027:
028: import org.apache.derby.iapi.services.sanity.SanityManager;
029:
030: import org.apache.derby.iapi.store.raw.ContainerHandle;
031: import org.apache.derby.iapi.store.raw.ContainerLock;
032: import org.apache.derby.iapi.store.raw.LockingPolicy;
033: import org.apache.derby.iapi.store.raw.RecordHandle;
034: import org.apache.derby.iapi.store.raw.RowLock;
035: import org.apache.derby.iapi.store.raw.Transaction;
036:
037: import org.apache.derby.iapi.error.StandardException;
038:
039: /**
040: A locking policy that implements row level locking with isolation degree 1.
041:
042: This is an implementation of Gray's degree 1 isolation, read uncommitted,
043: or often referred to as dirty reads. Basically read operations are
044: done with no locking.
045:
046: This locking policy is only to be used for read operations.
047:
048: The approach is to place all "write" container and row locks on the
049: transaction group lock list. Locks on this group will last until end
050: of transaction.
051:
052: This implementation will still get table level intent locks. This is to
053: prevent hard cases where the container otherwise could be deleted while
054: read uncommitted reader is still accessing it. In order to not get table
055: level intent locks some sort of other ddl level lock would have to be
056: implemented.
057:
058: All "read" row locks will be not be requested.
059:
060: Note that write operations extend from the RowLocking3 implementations.
061:
062: @see org.apache.derby.iapi.store.raw.LockingPolicy
063: */
064: public class RowLocking1 extends RowLocking2 {
065:
066: protected RowLocking1(LockFactory lf) {
067: super (lf);
068: }
069:
070: /**
071: * Obtain lock on record being read.
072: * <p>
073: * Assumes that a table level IS has been acquired. Will acquire a Shared
074: * or Update lock on the row, depending on the "forUpdate" parameter.
075: * <p>
076: * Read lock will be placed on separate group from transaction.
077: *
078: * @param t The transaction to associate the lock with.
079: * @param record The record to be locked.
080: * @param waitForLock Should lock request wait until granted?
081: * @param forUpdate Whether to open for read or write access.
082: *
083: * @return true if the lock was granted, false if waitForLock was false
084: * and the lock could not be granted.
085: *
086: * @exception StandardException Standard exception policy.
087: **/
088: public boolean lockRecordForRead(Transaction t,
089: ContainerHandle container_handle, RecordHandle record,
090: boolean waitForLock, boolean forUpdate)
091: throws StandardException {
092:
093: return (!forUpdate ? true : super .lockRecordForRead(t,
094: container_handle, record, waitForLock, forUpdate));
095: }
096:
097: /**
098: * Obtain lock on record being read while holding a latch.
099: * <p>
100: * Assumes that a table level IS has been acquired. Will acquire a Shared
101: * or Update lock on the row, depending on the "forUpdate" parameter.
102: * <p>
103: *
104: * @param latch The latch being held.
105: * @param record The record to be locked.
106: * @param forUpdate Whether to open for read or write access.
107: *
108: * @exception StandardException Standard exception policy.
109: **/
110: public void lockRecordForRead(Latch latch, RecordHandle record,
111: boolean forUpdate) throws StandardException {
112: if (forUpdate)
113: super .lockRecordForRead(latch, record, forUpdate);
114: }
115:
116: public void unlockRecordAfterRead(Transaction t,
117: ContainerHandle container_handle, RecordHandle record,
118: boolean forUpdate, boolean row_qualified)
119: throws StandardException {
120: if (forUpdate) {
121: super.unlockRecordAfterRead(t, container_handle, record,
122: forUpdate, row_qualified);
123: }
124: return;
125: }
126: }
|