EMMA Coverage Report (generated Wed Jun 28 22:15:27 PDT 2006)
[all classes][org.apache.derby.impl.store.raw.log]

COVERAGE SUMMARY FOR SOURCE FILE [LogRecord.java]

nameclass, %method, %block, %line, %
LogRecord.java100% (1/1)88%  (21/24)71%  (227/321)80%  (56.8/71)

COVERAGE BREAKDOWN BY CLASS AND METHOD

nameclass, %method, %block, %line, %
     
class LogRecord100% (1/1)88%  (21/24)71%  (227/321)80%  (56.8/71)
<static initializer> 100% (1/1)100% (4/4)100% (1/1)
LogRecord (): void 100% (1/1)100% (3/3)100% (2/2)
formatOverhead (): int 100% (1/1)100% (2/2)100% (1/1)
getLoggable (): Loggable 100% (1/1)76%  (39/51)90%  (9.9/11)
getRePreparable (): RePreparable 100% (1/1)100% (4/4)100% (1/1)
getStoredSize (int, TransactionId): int 100% (1/1)93%  (14/15)96%  (1.9/2)
getTransactionId (): TransactionId 100% (1/1)97%  (28/29)99%  (7/7)
getTypeFormatId (): int 100% (1/1)100% (2/2)100% (1/1)
getUndoable (): Undoable 100% (1/1)100% (16/16)100% (5/5)
group (): int 0%   (0/1)0%   (0/3)0%   (0/1)
isAbort (): boolean 0%   (0/1)0%   (0/30)0%   (0/3)
isCLR (): boolean 100% (1/1)100% (9/9)100% (1/1)
isChecksum (): boolean 100% (1/1)100% (9/9)100% (1/1)
isCommit (): boolean 0%   (0/1)0%   (0/30)0%   (0/3)
isComplete (): boolean 100% (1/1)100% (9/9)100% (1/1)
isFirst (): boolean 100% (1/1)100% (9/9)100% (1/1)
isPrepare (): boolean 100% (1/1)100% (9/9)100% (1/1)
maxGroupStoredSize (): int 100% (1/1)100% (2/2)100% (1/1)
maxTransactionIdStoredSize (TransactionId): int 100% (1/1)100% (3/3)100% (1/1)
readExternal (ObjectInput): void 100% (1/1)100% (14/14)100% (5/5)
requiresPrepareLocks (): boolean 100% (1/1)100% (9/9)100% (1/1)
setValue (TransactionId, Loggable): void 100% (1/1)100% (11/11)100% (4/4)
skipLoggable (): void 100% (1/1)50%  (17/34)50%  (6/12)
writeExternal (ObjectOutput): void 100% (1/1)100% (14/14)100% (4/4)

1/*
2 
3   Derby - Class org.apache.derby.impl.store.raw.log.LogRecord
4 
5   Copyright 1997, 2004 The Apache Software Foundation or its licensors, as applicable.
6 
7   Licensed under the Apache License, Version 2.0 (the "License");
8   you may not use this file except in compliance with the License.
9   You may obtain a copy of the License at
10 
11      http://www.apache.org/licenses/LICENSE-2.0
12 
13   Unless required by applicable law or agreed to in writing, software
14   distributed under the License is distributed on an "AS IS" BASIS,
15   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16   See the License for the specific language governing permissions and
17   limitations under the License.
18 
19 */
20 
21package org.apache.derby.impl.store.raw.log;
22 
23import org.apache.derby.iapi.reference.SQLState;
24 
25import org.apache.derby.iapi.services.sanity.SanityManager;
26import org.apache.derby.iapi.services.io.FormatIdUtil;
27import org.apache.derby.iapi.services.io.StoredFormatIds;
28import org.apache.derby.iapi.services.io.Formatable;
29 
30import org.apache.derby.iapi.error.StandardException;
31 
32import org.apache.derby.iapi.store.raw.Loggable;
33import org.apache.derby.iapi.store.raw.Compensation;
34import org.apache.derby.iapi.store.raw.RePreparable;
35import org.apache.derby.iapi.store.raw.Undoable;
36 
37import org.apache.derby.iapi.store.raw.xact.TransactionId;
38 
39import org.apache.derby.iapi.services.io.CompressedNumber;
40 
41import java.io.ObjectOutput;
42import java.io.ObjectInput;
43import java.io.IOException;
44 
45 
46/**
47        The log record written out to disk. This log record includes:
48        <P>
49    The is a holder object that may be setup using the setValue() and re-used
50        rather than creating a new object for each actual log record.
51 
52        <P>        <PRE>
53        The format of a log record is
54 
55        @format_id LOG_RECORD
56                the formatId is written by FormatIdOutputStream when this object is
57                written out by writeObject
58        @purpose        The log record described every change to the persistent store
59        @upgrade
60        @disk_layout
61                loggable group(CompressedInt)        the loggable's group value
62                xactId(TransactionId)                        The Transaction this log belongs to
63                op(Loggable)                                        the log operation
64        @end_format
65        </PRE>
66 
67*/
68public class LogRecord implements Formatable {
69 
70        private TransactionId        xactId;        // the transaction Id
71        private Loggable                op;                // the loggable
72        private int                                group;        // the loggable's group value
73 
74        // the objectInput stream that contains the loggable object.  The
75        // objectification of the transaction Id and the the loggable object is
76        // delayed from readExternal time to getTransactionId and getLoggable time
77        // to give the log scan an opportunity to discard the loggable based on
78        // group value and xactId.
79        transient ObjectInput input;   
80 
81        private static final int formatLength = FormatIdUtil.getFormatIdByteLength(StoredFormatIds.LOG_RECORD);
82 
83        public LogRecord() {
84        }
85 
86        /*
87         * Formatable methods
88         */
89 
90        /**
91                Write this out.
92                @exception IOException error writing to log stream
93        */
94        public void writeExternal(ObjectOutput out) throws IOException
95        {
96                CompressedNumber.writeInt(out, group);
97                out.writeObject(xactId);
98                out.writeObject(op);
99        }
100 
101        /**
102                Read this in
103                @exception IOException error reading from log stream
104                @exception ClassNotFoundException corrupted log stream
105        */
106        public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
107        {
108                group = CompressedNumber.readInt(in);
109                input = in;                                // tie the input to this logRecord
110 
111                xactId = null;                        // delay reading these until later
112                op = null;
113        }
114 
115        /**
116                Return my format identifier.
117        */
118        public int getTypeFormatId() {
119                return StoredFormatIds.LOG_RECORD;
120        }
121 
122        /*
123         * class specific methods
124         */
125        public void setValue(TransactionId xactId, Loggable op)
126        {
127                this.xactId = xactId;
128                this.op = op;
129 
130                this.group = op.group();
131        }
132 
133        public static int formatOverhead()
134        {
135                return formatLength;
136        }                
137 
138        public static int maxGroupStoredSize()
139        {
140                return CompressedNumber.MAX_INT_STORED_SIZE;
141        }        
142 
143        public static int maxTransactionIdStoredSize(TransactionId tranId)
144        {
145                return tranId.getMaxStoredSize();
146        }
147 
148        
149        public static int getStoredSize(int group, TransactionId xactId)
150        {
151                
152                if (SanityManager.DEBUG)
153                {
154                        SanityManager.ASSERT(xactId == null, 
155                                                                 "size calculation are based on xactId being  null"); 
156                }
157 
158                return         formatLength +         CompressedNumber.sizeInt(group) + 
159                        FormatIdUtil.getFormatIdByteLength(StoredFormatIds.NULL_FORMAT_ID);
160        }
161 
162 
163        public TransactionId getTransactionId() 
164                 throws IOException, ClassNotFoundException 
165        {
166                if (xactId != null)
167                        return xactId;
168 
169                if (SanityManager.DEBUG)
170                        SanityManager.ASSERT(input != null, 
171                                         "xactId not objectified but object input is not set"); 
172 
173                Object obj = input.readObject();
174        if (SanityManager.DEBUG)
175        {
176                    SanityManager.ASSERT(obj instanceof TransactionId,
177                                                    "log record not getting expected TransactionId");
178            }
179                xactId = (TransactionId)obj;
180 
181                return xactId;
182        }
183 
184    public Loggable getLoggable() throws IOException, ClassNotFoundException {
185 
186                if (op != null)                        // If log operation is already objectified,
187                        return op;                        // then just return it.
188 
189                if (SanityManager.DEBUG)
190                        SanityManager.ASSERT(input != null, 
191                                         "logop not objectified but object input is not set");
192 
193                if (xactId == null)                // xactId is not read off yet
194                {
195                        xactId = (TransactionId)input.readObject();
196                }
197 
198                Object obj = input.readObject();
199 
200                if (SanityManager.DEBUG) {
201                        if ( ! (obj instanceof Loggable))
202                                SanityManager.THROWASSERT(
203                                        "log record not getting expected Loggable: got : " +
204                                        obj.getClass().getName());
205                }
206                op = (Loggable)obj;
207 
208                input = null;
209 
210                return op;
211        }
212 
213    public RePreparable getRePreparable() 
214        throws IOException, ClassNotFoundException 
215    {
216        return((RePreparable) getLoggable());
217        }
218 
219        /**
220                Skip over the loggable.  Set the input stream to point ot after the
221                loggable as if the entire log record has been sucked in by the log
222                record
223 
224                @exception StandardException if the loggable is not found, log is corrupt
225        */
226        public void skipLoggable() throws StandardException
227        {
228                if (op != null)                // loggable already read off
229                        return;
230 
231                try
232                {
233                        if (xactId == null)
234                                xactId = (TransactionId)input.readObject();        // get rid of the transactionId
235 
236                        if (op == null)
237                                op = (Loggable)input.readObject();        // get rid of the loggable
238                }
239                catch(ClassNotFoundException cnfe)
240                {
241                        throw StandardException.newException(SQLState.LOG_CORRUPTED, cnfe);
242                }
243                catch(IOException ioe)
244                {
245                        throw StandardException.newException(SQLState.LOG_CORRUPTED, ioe);
246                }
247        }
248 
249        public Undoable getUndoable() throws IOException, ClassNotFoundException
250        {
251                if (op == null)
252                        getLoggable();                // objectify it
253 
254                if (op instanceof Undoable)
255                        return (Undoable) op;
256                else
257                        return null;
258        }
259 
260        public boolean isCLR()        {
261                return ((group & Loggable.COMPENSATION) != 0);
262        }
263 
264        public boolean isFirst()        {
265                return ((group & Loggable.FIRST) != 0);
266        }
267 
268        public boolean isComplete()        {
269                return ((group & Loggable.LAST) != 0);
270        }
271 
272        public boolean isPrepare()        {
273                return ((group & Loggable.PREPARE) != 0);
274        }
275 
276        public boolean requiresPrepareLocks()        {
277                return ((group & Loggable.XA_NEEDLOCK) != 0);
278        }
279 
280        public boolean isCommit()
281        {
282                if (SanityManager.DEBUG)
283                {
284                        SanityManager.ASSERT((group & Loggable.LAST) == Loggable.LAST,
285                                 "calling isCommit on log record that is not last");
286                        SanityManager.ASSERT((group & (Loggable.COMMIT | Loggable.ABORT)) != 0,
287                                 "calling isCommit on log record before commit status is recorded");
288                }
289                return ((group & Loggable.COMMIT) != 0);
290        }
291 
292        public boolean isAbort()
293        {
294                if (SanityManager.DEBUG)
295                {
296                        SanityManager.ASSERT((group & Loggable.LAST) == Loggable.LAST,
297                                 "calling isAbort on log record that is not last");
298                        SanityManager.ASSERT((group & (Loggable.COMMIT | Loggable.ABORT)) != 0,
299                                 "calling isAbort on log record before abort status is recorded");
300                }
301                return ((group & Loggable.ABORT) != 0);
302        }
303 
304        public int group()
305        {
306                return group;
307        }
308 
309 
310        public boolean isChecksum()        {
311                return ((group & Loggable.CHECKSUM) != 0);
312        }
313}

[all classes][org.apache.derby.impl.store.raw.log]
EMMA 2.0.5312 (C) Vladimir Roubtsov