KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > apache > derby > impl > store > raw > data > StoredPage


1 /*
2
3    Derby - Class org.apache.derby.impl.store.raw.data.StoredPage
4
5    Licensed to the Apache Software Foundation (ASF) under one or more
6    contributor license agreements. See the NOTICE file distributed with
7    this work for additional information regarding copyright ownership.
8    The ASF licenses this file to you under the Apache License, Version 2.0
9    (the "License"); you may not use this file except in compliance with
10    the License. You may obtain a copy of the License at
11
12       http://www.apache.org/licenses/LICENSE-2.0
13
14    Unless required by applicable law or agreed to in writing, software
15    distributed under the License is distributed on an "AS IS" BASIS,
16    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
17    See the License for the specific language governing permissions and
18    limitations under the License.
19
20 */

21
22 package org.apache.derby.impl.store.raw.data;
23
24 import org.apache.derby.iapi.reference.SQLState;
25
26 import org.apache.derby.impl.store.raw.data.BasePage;
27
28 import org.apache.derby.impl.store.raw.data.LongColumnException;
29 import org.apache.derby.impl.store.raw.data.OverflowInputStream;
30 import org.apache.derby.impl.store.raw.data.PageVersion;
31 import org.apache.derby.impl.store.raw.data.RecordId;
32 import org.apache.derby.impl.store.raw.data.RawField;
33 import org.apache.derby.impl.store.raw.data.ReclaimSpace;
34 import org.apache.derby.impl.store.raw.data.StoredFieldHeader;
35 import org.apache.derby.impl.store.raw.data.StoredRecordHeader;
36
37 import org.apache.derby.iapi.services.io.FormatIdUtil;
38 import org.apache.derby.iapi.services.io.FormatIdInputStream;
39 import org.apache.derby.iapi.services.io.FormatIdOutputStream;
40 import org.apache.derby.iapi.services.io.StoredFormatIds;
41 import org.apache.derby.iapi.services.io.StreamStorable;
42 import org.apache.derby.iapi.services.io.TypedFormat;
43 import org.apache.derby.iapi.services.sanity.SanityManager;
44
45 import org.apache.derby.iapi.store.access.conglomerate.LogicalUndo;
46 import org.apache.derby.iapi.store.access.Qualifier;
47 import org.apache.derby.iapi.store.access.RowUtil;
48
49 import org.apache.derby.iapi.store.raw.ContainerHandle;
50 import org.apache.derby.iapi.store.raw.FetchDescriptor;
51 import org.apache.derby.iapi.store.raw.Page;
52 import org.apache.derby.iapi.store.raw.PageKey;
53 import org.apache.derby.iapi.store.raw.PageTimeStamp;
54 import org.apache.derby.iapi.store.raw.RawStoreFactory;
55 import org.apache.derby.iapi.store.raw.RecordHandle;
56 import org.apache.derby.iapi.store.raw.log.LogInstant;
57 import org.apache.derby.iapi.store.raw.xact.RawTransaction;
58
59 import org.apache.derby.iapi.error.StandardException;
60
61 import org.apache.derby.iapi.types.DataValueDescriptor;
62
63 import org.apache.derby.iapi.types.Orderable;
64
65 import org.apache.derby.iapi.services.io.ArrayInputStream;
66 import org.apache.derby.iapi.services.io.ArrayOutputStream;
67 import org.apache.derby.iapi.services.io.FormatableBitSet;
68 import org.apache.derby.iapi.util.ByteArray;
69 import org.apache.derby.iapi.services.io.CompressedNumber;
70 import org.apache.derby.iapi.services.io.DynamicByteArrayOutputStream;
71 import org.apache.derby.iapi.services.io.DynamicByteArrayOutputStream;
72 import org.apache.derby.iapi.services.io.LimitObjectInput;
73 import org.apache.derby.iapi.services.io.ErrorObjectInput;
74
75
76 import java.util.zip.CRC32 JavaDoc;
77
78 import java.io.IOException JavaDoc;
79 import java.io.EOFException JavaDoc;
80 import java.io.Externalizable JavaDoc;
81 import java.io.InvalidClassException JavaDoc;
82
83 import java.io.ObjectOutput JavaDoc;
84 import java.io.ObjectInput JavaDoc;
85 import java.io.DataInput JavaDoc;
86 import java.io.DataOutput JavaDoc;
87 import java.io.InputStream JavaDoc;
88 import java.io.OutputStream JavaDoc;
89 import java.io.ByteArrayInputStream JavaDoc;
90 import java.io.ByteArrayOutputStream JavaDoc;
91
92
93 /**
94     StoredPage is a sub class of CachedPage that stores page data in a
95     fixed size byte array and is designed to be written out to a file
96     through a DataInput/DataOutput interface. A StoredPage can exist
97     in its clean or dirty state without the FileContainer it was created
98     from being in memory.
99
100   <P><B>Page Format</B><BR>
101   The page is broken into five sections
102   <PRE>
103   +----------+-------------+-------------------+-------------------+----------+
104   | formatId | page header | records | slot offset table | checksum |
105   +----------+-------------+-------------------+-------------------+----------+
106   </PRE>
107   <BR><B>FormatId</B><BR>
108   The formatId is a 4 bytes array, it contains the format Id of this page.
109   <BR><B>Page Header</B><BR>
110   The page header is a fixed size, 56 bytes
111   <PRE>
112   1 byte boolean is page an overflow page
113   1 byte byte page status (a field maintained in base page)
114   8 bytes long pageVersion (a field maintained in base page)
115   2 bytes unsigned short number of slots in slot offset table
116   4 bytes integer next record identifier
117   4 bytes integer generation number of this page (Future Use)
118   4 bytes integer previous generation of this page (Future Use)
119   8 bytes bipLocation the location of the beforeimage page (Future Use)
120   2 bytes unsigned short number of deleted rows on page. (new release 2.0)
121   2 bytes unsigned short % of the page to keep free for updates
122   2 bytes short spare for future use
123   4 bytes long spare for future use (encryption uses to write
124                                                   random bytes here).
125   8 bytes long spare for future use
126   8 bytes long spare for future use
127
128   </PRE>
129
130   Note that spare space has been guaranteed to be writen with "0", so
131   that future use of field should not either not use "0" as a valid data
132   item or pick 0 as a valid default value so that on the fly upgrade can
133   assume that 0 means field was never assigned.
134
135   <BR><B>Records</B>
136   The records section contains zero or more records, the format of each record
137   follows.
138   minimumRecordSize is the minimum user record size, excluding the space we
139   use for the record header and field headers. When a record is inserted, it
140   is stored in a space at least as large as the sum of the minimumRecordSize
141   and total header size.
142         For example,
143             If minimumRecordSize is 10 bytes,
144             the user record is 7 bytes,
145             we used 5 bytes for record and field headers,
146             this record will take (10 + 5) bytes of space, extra 3 bytes is
147             put into reserve.
148
149             If minimumRecordSize is 10 bytes,
150             user record is 17 bytes,
151             we used 5 bytes for record and field headers,
152             this record will take (17 + 5) bytes of space, no reserve space
153             here.
154
155   minimumRecordSize is defined by user on per container basis.
156   The default for minimumRecordSize is set to 1.
157
158   This implementation always keeps occupied bytes at the low end of the record
159   section. Thus removing (purging) a record moves all other records down, and
160   their slots are also moved down.
161   A page has no empty slot (an empty page has no slot)
162
163    <BR><B>Record & Field Format</B>
164
165   Record Header format is defined in the StoredRecordHeader class.
166   
167 <PRE>
168   <BR><B>Fields</B>
169
170   1 byte Boolean - is null, if true no more data follows.
171   4 bytes Integer - length of field that follows (excludes these four bytes).
172
173   StoredPage will use the static method provided by StoredFieldHeader
174   to read/write field status and field data length.
175
176   Field Header format is defined in the StoredFieldHeader class.
177   <data>
178
179   </PRE>
180     <BR><B>Slot Offset Table</B><BR>
181     The slot offset table is a table of 6 or 12 bytes per record, depending on
182     the pageSize being less or greater than 64K:
183     2 bytes (unsigned short) or 4 bytes (int) page offset for the record that
184     is assigned to the slot, and 2 bytes (unsigned short) or 4 bytes (int)
185     for the length of the record on this page.
186     2 bytes (unsigned short) or 4 bytes (int) for the length of the reserved
187     number of bytes for this record on this page.
188     First slot is slot 0. The slot table grows backwards. Slots are never
189     left empty.
190     <BR><B>Checksum</B><BR>
191     8 bytes of a java.util.zip.CRC32 checksum of the entire's page contents
192     without the 8 bytes representing the checksum.
193
194     <P><B>Page Access</B>
195     The page data is accessed in this class by one of three methods.
196     <OL>
197     <LI>As a byte array using pageData (field in cachedPage). This is the
198     fastest.
199     <LI>As an ArrayInputStream (rawDataIn) and ArrayOutputStream (rawDataOut),
200     this is used to set limits on any one reading the page logically.
201     <LI>Logically through rawDataIn (ArrayInputStream) and
202     logicalDataOut (FormatIdOutputStream), this provides the methods to write
203     logical data (e.g. booleans and integers etc.) and the ObjectInput
204     and ObjectOutput interfaces for DataValueDescriptor's. These logical
205     streams are constructed using the array streams.
206     </OL>
207
208     @see java.util.zip.CRC32
209     @see ArrayInputStream
210     @see ArrayOutputStream
211  **/

212
213
214
215     /**************************************************************************
216      * Public Methods of This class:
217      **************************************************************************
218      */

219
220     /**************************************************************************
221      * Public Methods of XXXX class:
222      **************************************************************************
223      */

224
225 public class StoredPage extends CachedPage
226 {
227     /**************************************************************************
228      * static final Fields of the class
229      **************************************************************************
230      */

231
232     /*
233      * typed format
234      */

235
236     public static final int FORMAT_NUMBER =
237         StoredFormatIds.RAW_STORE_STORED_PAGE;
238
239     /**
240      * Return my format identifier.
241      **/

242     public int getTypeFormatId()
243     {
244         return StoredFormatIds.RAW_STORE_STORED_PAGE;
245     }
246
247
248     /**
249      * Constants used to find different portions of data on the page.
250      * <p>
251      * The page is laid out as follows:
252      * The page is broken into five sections
253      * +----------+-------------+---------+-------------------+----------+
254      * | formatId | page header | records | slot offset table | checksum |
255      * +----------+-------------+---------+-------------------+----------+
256      *
257      * offset size section
258      * ------ ------------------- --------------------------
259      * 0 PAGE_FORMAT_ID_SIZE formatId
260      * PAGE_FORMAT_ID_SIZE: PAGE_HEADER_SIZE (56) page header
261      * RECORD_SPACE_OFFSET: variable records
262      **/

263
264
265     /**
266      * Start of page, formatId must fit in 4 bytes.
267      * <p>
268      * where the page header starts - page format is mandated by cached page
269      **/

270     protected static final int PAGE_HEADER_OFFSET = PAGE_FORMAT_ID_SIZE;
271
272
273     /**
274      * Fixed size of the page header
275      **/

276     protected static final int PAGE_HEADER_SIZE = 56;
277
278
279     /**
280         Start of the record storage area
281     */

282     /**
283      * Start of the record storage area.
284      * <p>
285      * Note: a subclass may change the start of the record storage area.
286      * Don't always count on this number.
287      **/

288     protected static final int RECORD_SPACE_OFFSET =
289         PAGE_HEADER_OFFSET + PAGE_HEADER_SIZE;
290
291     /**
292      * offset of the page version number
293      **/

294     protected static final int PAGE_VERSION_OFFSET = PAGE_HEADER_OFFSET + 2;
295
296     /**
297      * SMALL_SLOT_SIZE are for pages smaller than 64K,
298      * LARGE_SLOT_SIZE is for pages bigger than 64K.
299      **/

300     protected static final int SMALL_SLOT_SIZE = 2;
301     protected static final int LARGE_SLOT_SIZE = 4;
302
303     /**
304      * Size of the checksum stored on the page.
305      *
306      * The checksum is stored in the last 8 bytes of the page, the slot table
307      * grows backward up the page starting at the end of the page just before
308      * the checksum.
309      **/

310     protected static final int CHECKSUM_SIZE = 8;
311
312     /**
313      * OVERFLOW_POINTER_SIZE - Number of bytes to reserve for overflow pointer
314      *
315      * The overflow pointer is the pointer that the takes the place of the
316      * last column of a row if the row can't fit on the page. The pointer
317      * then points to another page where the next column of the row can be
318      * found. The overflow pointer can be bigger than a row, so when
319      * overflowing a row the code must overflow enough columns so that there
320      * is enough free space to write the row. Note this means that the
321      * minimum space a row can take on a page must allow for at least the
322      * size of the overflow pointers so that if the row is updated it can
323      * write the over flow pointer.
324      *
325      **/

326     protected static final int OVERFLOW_POINTER_SIZE = 12;
327
328     /**
329      * OVERFLOW_PTR_FIELD_SIZE - Number of bytes of an overflow field
330      *
331      * This is the length to reserve for either an column or row overflow
332      * pointer field. It includes the size of the field header plus the
333      * maxium length of the overflow pointer (it could be shorter due to
334      * compressed storage).
335      *
336      * The calcualtion is:
337      *
338      * OVERFLOW_PTR_FIELD_SIZE =
339      * OVERFLOW_POINTER_SIZE +
340      * sizeof(status byte) +
341      * sizeof(field length field for a field which is just an overflow ptr)
342      *
343      *
344      **/

345     protected static final int OVERFLOW_PTR_FIELD_SIZE =
346         OVERFLOW_POINTER_SIZE + 1 + 1;
347
348     /**
349      * In memory buffer used as scratch space for streaming columns.
350      **/

351     ByteHolder bh = null;
352
353     /**************************************************************************
354      * Fields of the class
355      **************************************************************************
356      */

357
358
359     /**
360      * Constants used in call to logColumn.
361      * <p>
362      * Action taken in this routine is determined by the kind of column as
363      * specified in the columnFlag:
364      * COLUMN_NONE - the column is insignificant
365      * COLUMN_FIRST - this is the first column in a logRow() call
366      * COLUMN_LONG - this is a known long column, therefore we will
367      * store part of the column on the current page and
368      * overflow the rest if necessary.
369      **/

370     protected static final int COLUMN_NONE = 0;
371     protected static final int COLUMN_FIRST = 1;
372     protected static final int COLUMN_LONG = 2;
373
374
375     /**
376      * maxFieldSize is a worst case calculation for the size of a record
377      * on an empty page, with a single field, but still allow room for
378      * an overflow pointer if another field is to be added. See initSpace().
379      * maxFieldSize is a worst case calculation for the size of a record
380      *
381      * This is used as the threshold for a long column.
382      *
383      * maxFieldSize =
384      * totalSpace * (1 - spareSpace/100) -
385      * slotEntrySize * - 16 - OVERFLOW_POINTER_SIZE;
386      **/

387     protected int maxFieldSize;
388
389
390     /**
391      * The page header is a fixed size, 56 bytes, following are variables used
392      * to access the fields in the header:
393      * <p>
394      * 1 byte boolean isOverflowPage is page an overflow page
395      * 1 byte byte pageStatus page status (field in base page)
396      * 8 bytes long pageVersion page version (field in base page)
397      * 2 bytes ushort slotsInUse number of slots in slot offset table
398      * 4 bytes integer nextId next record identifier
399      * 4 bytes integer generation generation number of this page(FUTURE USE)
400      * 4 bytes integer prevGeneration previous generation of page (FUTURE USE)
401      * 8 bytes long bipLocation the location of the BI page (FUTURE USE)
402      * 2 bytes ushort deletedRowCount number of deleted rows on page.(rel 2.0)
403      * 2 bytes long spare for future use
404      * 4 bytes long spare (encryption writes random bytes)
405      * 8 bytes long spare for future use
406      * 8 bytes long spare for future use
407      *
408      * Note that spare space has been guaranteed to be writen with "0", so
409      * that future use of field should not either not use "0" as a valid data
410      * item or pick 0 as a valid default value so that on the fly upgrade can
411      * assume that 0 means field was never assigned.
412      *
413      **/

414     private boolean isOverflowPage; // is page an overflow page?
415
private int slotsInUse; // number of slots in slot offset table.
416
private int nextId; // next record identifier
417
private int generation; // (Future Use) generation number of this page
418
private int prevGeneration; // (Future Use) previous generation of page
419
private long bipLocation; // (Future Use) the location of the BI page
420
private int deletedRowCount; // number of deleted rows on page.
421

422     /**
423      * Is the header in the byte array out of date wrt the fields.
424      * <p>
425      * this field must be set to true whenever one of the above header fields
426      * is modified. Ie any of (isOverflowPage, slotsInUse, nextId, generation,
427      * prevGeneration, bipLocation, deletedRowCount)
428      **/

429     private boolean headerOutOfDate;
430
431     /**
432      * holder for the checksum.
433      **/

434     private CRC32 JavaDoc checksum;
435
436     /**
437      * Minimum space to reserve for record portion length of row.
438      * <p>
439      * minimumRecordSize is stored in the container handle. It is used to
440      * reserved minimum space for recordPortionLength. Default is 1. To
441      * get the value from the container handle:
442      * myContainer.getMinimumRecordSize();
443      *
444      * minimumRecordSize is the minimum user record size, excluding the space we
445      * use for the record header and field headers. When a record is inserted,
446      * it is stored in a space at least as large as the sum of the
447      * minimumRecordSize and total header size.
448      *
449      * For example,
450      * If minimumRecordSize is 10 bytes,
451      * the user record is 7 bytes,
452      * we used 5 bytes for record and field headers,
453      * this record will take (10 + 5) bytes of space, extra 3 bytes is
454      * put into reserve.
455      *
456      * If minimumRecordSize is 10 bytes,
457      * user record is 17 bytes,
458      * we used 5 bytes for record and field headers,
459      * this record will take (17 + 5) bytes of space, no reserve space
460      * here.
461      *
462      * minimumRecordSize is defined by user on per container basis.
463      * The default for minimumRecordSize is set to 1.
464      *
465      **/

466     protected int minimumRecordSize;
467
468     /**
469      * scratch variable used to keep track of the total user size for the row.
470      * the information is used by logRow to maintain minimumRecordSize
471      * on Page. minimumRecordSize is only considered for main data pages,
472      * therefore, the page must be latched during an insert operation.
473      **/

474     private int userRowSize;
475     
476     /**
477      * slot field and slot entry size.
478      * <p>
479      * The size of these fields is dependant on the page size.
480      * These 2 variables should be set when pageSize is determined, and should
481      * not be changed for that page.
482      *
483      * Each slot entry contains 3 fields (slotOffet, recordPortionLength and
484      * reservedSpace) for the record the slot is pointing to.
485      * slotFieldSize is the size for each of the slot field.
486      * slotEntrySize is the total space used for a single slot entry.
487      **/

488     private int slotFieldSize;
489     private int slotEntrySize;
490
491     /**
492      * Offset of the first entry in the slot table.
493      * <p>
494      * Offset table is located at end of page, just before checksum. It
495      * grows backward as an array from this point toward the middle of the
496      * page.
497      * <p>
498      * slotTableOffsetToFirstEntry is the offset to the beginning of the
499      * first entry (slot[0]) in the slot table. This allows the following
500      * math to get to the offset of N'th entry in the slot table:
501      *
502      * offset of slot[N] = slotTableOffsetToFirstEntry + (N * slotEntrySize)
503      **/

504     private int slotTableOffsetToFirstEntry;
505
506     /**
507      * Offset of the record length entry in the 1st slot table entry.
508      * <p>
509      * Offset table is located at end of page, just before checksum. It
510      * grows backward as an array from this point toward the middle of the
511      * page. The record length is stored as the second "field" of the
512      * slot table entry.
513      * <p>
514      * slotTableOffsetToFirstRecordLengthField is the offset to the beginning
515      * of the record length field in the first entry (slot[0]) in the slot
516      * table. This allows the following
517      * math to get to the record length field of N'th entry in the slot table:
518      *
519      * offset of record length of slot[N] slot entry =
520      * slotTableOffsetToFirstRecordLengthField + (N * slotEntrySize)
521      **/

522     private int slotTableOffsetToFirstRecordLengthField;
523
524
525     /**
526      * Offset of the reserved space length entry in the 1st slot table entry.
527      * <p>
528      * Offset table is located at end of page, just before checksum. It
529      * grows backward as an array from this point toward the middle of the
530      * page. The reserved space length is stored as the third "field" of the
531      * slot table entry.
532      * <p>
533      * slotTableOffsetToFirstReservedSpaceField is the offset to the beginning
534      * of the reserved space field in the first entry (slot[0]) in the slot
535      * table. This allows the following
536      * math to get to the reserved space field of N'th entry in the slot table:
537      *
538      * offset of reserved space of slot[N] slot entry =
539      * slotTableOffsetToFirstReservedSpaceField + (N * slotEntrySize)
540      **/

541     private int slotTableOffsetToFirstReservedSpaceField;
542
543     /**
544      * total usable space on a page.
545      * <p>
546      * This is the space not taken by page hdr, page table, and existing
547      * slot entries/rows.
548      **/

549     protected int totalSpace; // total usable space on a page
550

551     // freeSpace and firstFreeByte are initliazed to a minimum value.
552
protected int freeSpace = Integer.MIN_VALUE; // free space on the page
553
private int firstFreeByte = Integer.MIN_VALUE; // 1st free byte on page
554

555
556     /**
557      * % of page to keep free for updates.
558      * <p>
559      * How much of a head page should be reserved as "free" so that the space
560      * can be used by update which expands the row without needing to overflow
561      * it. 1 means save 1% of the free space for expansion.
562      **/

563     protected int spareSpace;
564
565     /**
566      * Scratch variable used when you need a overflowRecordHeader. Declared
567      * globally so that object is only allocated once per page.
568      **/

569     private StoredRecordHeader overflowRecordHeader;
570
571     /**
572      * Input streams used to read/write bytes to/from the page byte array.
573      **/

574     protected ArrayInputStream rawDataIn;
575     protected ArrayOutputStream rawDataOut;
576     protected FormatIdOutputStream logicalDataOut;
577
578
579     /**************************************************************************
580      * Constructors for This class:
581      **************************************************************************
582      */

583
584
585     /**
586      * Simple no-arg constructor for StoredPage.
587      **/

588     public StoredPage()
589     {
590         super();
591     }
592
593     /**************************************************************************
594      * Private/Protected methods of This class:
595      **************************************************************************
596      */

597
598     /**
599      * get scratch space for over flow record header.
600      * <p>
601      *
602      * @exception StandardException Standard exception policy.
603      **/

604     
605     private StoredRecordHeader getOverFlowRecordHeader()
606         throws StandardException
607     {
608         return(
609             overflowRecordHeader != null ?
610                 overflowRecordHeader :
611                 (overflowRecordHeader = new StoredRecordHeader()));
612     }
613
614     /**
615      * Initialize the StoredPage.
616      * <p>
617      * Initialize the object, ie. perform work normally perfomed in constructor.
618      * Called by setIdentity() and createIdentity() - the Cacheable interfaces
619      * which are used to move a page in/out of cache.
620      **/

621     protected void initialize()
622     {
623         super.initialize();
624
625         if (rawDataIn == null)
626         {
627             rawDataIn = new ArrayInputStream();
628             checksum = new CRC32 JavaDoc();
629         }
630
631         if (pageData != null)
632             rawDataIn.setData(pageData);
633     }
634
635
636     /**
637      * Create the output streams.
638      * <p>
639      * Create the output streams, these are created on demand
640      * to avoid creating unrequired objects for pages that are
641      * never modified during their lifetime in the cache.
642      * <p>
643      *
644      * @exception StandardException Standard exception policy.
645      **/

646     private void createOutStreams()
647     {
648         rawDataOut = new ArrayOutputStream();
649         rawDataOut.setData(pageData);
650
651         logicalDataOut = new FormatIdOutputStream(rawDataOut);
652     }
653
654     /**
655      * Tie the logical output stream to a passed in OutputStream.
656      * <p>
657      * Tie the logical output stream to a passed in OutputStream with
658      * no limit as to the number of bytes that can be written.
659      **/

660     private void setOutputStream(OutputStream out)
661     {
662         if (rawDataOut == null)
663             createOutStreams();
664
665         logicalDataOut.setOutput(out);
666     }
667
668     /**
669      * Reset the logical output stream.
670      * <p>
671      * Reset the logical output stream (logicalDataOut) to be attached
672      * to the page array stream as is the norm, no limits are placed
673      * on any writes.
674      *
675      **/

676     private void resetOutputStream()
677     {
678
679         logicalDataOut.setOutput(rawDataOut);
680     }
681
682     /**************************************************************************
683      * Protected Methods of CachedPage class: (create, read and write a page.)
684      **************************************************************************
685      */

686
687     /**
688      * use this passed in page buffer as this object's page data.
689      * <p>
690      * The page content may not have been read in from disk yet.
691      * For pagesize smaller than 64K:
692      * Size of the record offset stored in a slot (unsigned short)
693      * Size of the record portion length stored in a slot (unsigned short)
694      * Size of the record portion length stored in a slot (unsigned short)
695      * For pagesize greater than 64K, but less than 2gig:
696      * Size of the record offset stored in a slot (int)
697      * Size of the record portion length stored in a slot (int)
698      * Size of the record portion length stored in a slot (int)
699      * <p>
700      *
701      * @param pageBuffer The array of bytes to use as the page buffer.
702      **/

703     protected void usePageBuffer(byte[] pageBuffer)
704     {
705         pageData = pageBuffer;
706
707         int pageSize = pageData.length;
708         if (rawDataIn != null)
709             rawDataIn.setData(pageData);
710
711         initSpace();
712
713         if (pageSize >= 65536)
714             slotFieldSize = LARGE_SLOT_SIZE;
715         else
716             slotFieldSize = SMALL_SLOT_SIZE;
717         
718         slotEntrySize = 3 * slotFieldSize;
719
720         // offset of slot table entry[0]
721
slotTableOffsetToFirstEntry =
722             (pageSize - CHECKSUM_SIZE - slotEntrySize);
723
724         // offset of record length field in slot table entry[0]
725
slotTableOffsetToFirstRecordLengthField =
726             slotTableOffsetToFirstEntry + slotFieldSize;
727
728         // offset of reserved space field in slot table entry[0]
729
slotTableOffsetToFirstReservedSpaceField =
730             slotTableOffsetToFirstEntry + (2 * slotFieldSize);
731
732         if (rawDataOut != null)
733             rawDataOut.setData(pageData);
734     }
735
736
737     /**
738      * Create a new StoredPage.
739      * <p>
740      * Make this object represent a new page (ie. a page that never existed
741      * before, as opposed to reading in an existing page from disk).
742      * <p>
743      *
744      * @param newIdentity The key describing page (segment,container,page).
745      * @param args information stored about the page, once in the
746      * container header and passed in through the array.
747      *
748      * @exception StandardException Standard exception policy.
749      **/

750     protected void createPage(
751     PageKey newIdentity,
752     int[] args)
753          throws StandardException
754     {
755         // arg[0] is the formatId of the page
756
// arg[1] is whether to sync the page to disk or not
757

758         int pageSize = args[2];
759         spareSpace = args[3];
760         minimumRecordSize = args[4];
761
762         setPageArray(pageSize);
763
764         cleanPage(); // clean up the page array
765

766         setPageVersion(0); // page is being created for the first time
767

768         nextId = RecordHandle.FIRST_RECORD_ID; // first record Id
769
generation = 0;
770         prevGeneration = 0; // there is no previous generation
771
bipLocation = 0L;
772
773         createOutStreams();
774     }
775
776     /**
777      * Initialize the page from values in the page buffer.
778      * <p>
779      * Initialize in memory structure using the buffer in pageData. This
780      * is how a StoredPage object is intialized to represent page read in
781      * from disk.
782      * <p>
783      *
784      * @param myContainer The container to read the page in from.
785      * @param newIdentity The key representing page being read in (segment,
786      * container, page number)
787      *
788      * @exception StandardException If the page cannot be read correctly,
789      * or is inconsistent.
790      **/

791     protected void initFromData(
792     FileContainer myContainer,
793     PageKey newIdentity)
794          throws StandardException
795     {
796         if (myContainer != null)
797         {
798             // read in info about page stored once in the container header.
799

800             spareSpace = myContainer.getSpareSpace();
801             minimumRecordSize = myContainer.getMinimumRecordSize();
802         }
803
804         // if it is null, assume spareSpace and minimumRecordSize is the
805
// same. We would only call initFromData after a restore then.
806

807         try
808         {
809             readPageHeader();
810             initSlotTable();
811         }
812         catch (IOException JavaDoc ioe)
813         {
814             // i/o methods on the byte array have thrown an IOException
815
throw dataFactory.markCorrupt(
816                 StandardException.newException(
817                     SQLState.DATA_CORRUPT_PAGE, ioe, newIdentity));
818         }
819
820         try
821         {
822             validateChecksum(newIdentity);
823         }
824         catch (StandardException se)
825         {
826             if (se.getMessageId().equals(SQLState.FILE_BAD_CHECKSUM))
827             {
828                 // it is remotely possible that the disk transfer got garbled,
829
// i.e., the page is actually fine on disk but the version we
830
// got has some rubbish on it. Double check.
831
int pagesize = getPageSize();
832                 byte[] corruptPage = pageData;
833                 pageData = null; // clear this
834

835                 // set up the new page array
836
setPageArray(pagesize);
837
838                 try
839                 {
840                     myContainer.readPage(newIdentity.getPageNumber(), pageData);
841                 }
842                 catch (IOException JavaDoc ioe)
843                 {
844                     throw dataFactory.markCorrupt(
845                         StandardException.newException(
846                             SQLState.DATA_CORRUPT_PAGE, ioe, newIdentity));
847                 }
848
849                 if (SanityManager.DEBUG)
850                 {
851                     SanityManager.DEBUG_CLEAR("TEST_BAD_CHECKSUM");
852                 }
853                 
854                 // see if this read confirms the checksum error
855
try
856                 {
857                     validateChecksum(newIdentity);
858                 }
859                 catch (StandardException sse)
860                 {
861                     // really bad
862
throw dataFactory.markCorrupt(se);
863                 }
864
865                 // If we got here, this means the first read is bad but the
866
// second read is good. This could be due to disk I/O error or
867
// a bug in the way the file pointer is mis-managed.
868
String JavaDoc firstImage = pagedataToHexDump(corruptPage);
869                 String JavaDoc secondImage =
870                     (SanityManager.DEBUG) ?
871                         toString() : pagedataToHexDump(corruptPage);
872
873                 throw StandardException.newException(
874                         SQLState.FILE_IO_GARBLED, se,
875                         newIdentity, firstImage, secondImage);
876             }
877             else
878             {
879                 throw se;
880             }
881         }
882     
883
884     }
885
886     /**
887      * Validate the check sum on the page.
888      * <p>
889      * Compare the check sum stored in the page on disk with the checksum
890      * calculated from the bytes on the page.
891      * <p>
892      *
893      * @param id The key that describes the page.
894      *
895      * @exception StandardException Standard exception policy.
896      **/

897     protected void validateChecksum(PageKey id)
898         throws StandardException
899     {
900         long onDiskChecksum;
901
902         try
903         {
904             // read the checksum stored on the page on disk. It is stored
905
// in the last "CHECKSUM_SIZE" bytes of the page, and is a long.
906

907             rawDataIn.setPosition(getPageSize() - CHECKSUM_SIZE);
908             onDiskChecksum = rawDataIn.readLong();
909         }
910         catch (IOException JavaDoc ioe)
911         {
912
913             // i/o methods on the byte array have thrown an IOException
914
throw dataFactory.markCorrupt(
915                 StandardException.newException(
916                     SQLState.DATA_CORRUPT_PAGE, ioe, id));
917         }
918
919         // Force the checksum to be recalculated based on the current page.
920
checksum.reset();
921         checksum.update(pageData, 0, getPageSize() - CHECKSUM_SIZE);
922         
923         // force a bad checksum error
924
if (SanityManager.DEBUG)
925         {
926             if (SanityManager.DEBUG_ON("TEST_BAD_CHECKSUM"))
927             {
928                 // set on disk checksum to wrong value
929
onDiskChecksum = 123456789;
930             }
931         }
932
933         if (onDiskChecksum != checksum.getValue())
934         {
935             // try again using new checksum object to be doubly sure
936
CRC32 JavaDoc newChecksum = new CRC32 JavaDoc();
937             newChecksum.reset();
938             newChecksum.update(pageData, 0, getPageSize()-CHECKSUM_SIZE);
939             if (onDiskChecksum != newChecksum.getValue())
940             {
941                 throw StandardException.newException(
942                     SQLState.FILE_BAD_CHECKSUM,
943                     id,
944                     new Long JavaDoc(checksum.getValue()),
945                     new Long JavaDoc(onDiskChecksum),
946                     pagedataToHexDump(pageData));
947             }
948             else
949             {
950                 // old one is bad, get rid of it
951
if (SanityManager.DEBUG)
952                     SanityManager.THROWASSERT("old checksum gets wrong value");
953
954                 checksum = newChecksum;
955             }
956         }
957     }
958
959     /**
960      * Recalculate checksum and write it to the page array.
961      * <p>
962      * Recalculate the checksum of the page, and write the result back into
963      * the last bytes of the page.
964      *
965      * @exception IOException if writing to end of array fails.
966      **/

967     protected void updateChecksum() throws IOException JavaDoc
968     {
969         checksum.reset();
970         checksum.update(pageData, 0, getPageSize() - CHECKSUM_SIZE);
971
972         rawDataOut.setPosition(getPageSize() - CHECKSUM_SIZE);
973         logicalDataOut.writeLong(checksum.getValue());
974     }
975
976     /**
977      * Write information about page from variables into page byte array.
978      * <p>
979      * This routine insures that all information about the page is reflected
980      * in the page byte buffer. This involves moving information from local
981      * variables into encoded version on the page in page header and checksum.
982      * <p>
983      *
984      * @param identity The key of this page.
985      *
986      * @exception StandardException Standard exception policy.
987      **/

988     protected void writePage(PageKey identity)
989         throws StandardException
990     {
991         if (SanityManager.DEBUG)
992         {
993             // some consistency checks on fields of the page, good to check
994
// before we write them into the page.
995

996             if ((freeSpace < 0) ||
997                 (firstFreeByte + freeSpace) != (getSlotOffset(slotsInUse - 1)))
998             {
999                 // make sure free space is not negative and does not overlap
1000
// used space.
1001

1002                SanityManager.THROWASSERT("slotsInUse = " + slotsInUse
1003                    + ", firstFreeByte = " + firstFreeByte
1004                    + ", freeSpace = " + freeSpace
1005                    + ", slotOffset = " + (getSlotOffset(slotsInUse - 1))
1006                    + ", page = " + this);
1007            }
1008
1009            if ((slotsInUse == 0) &&
1010                (firstFreeByte != (getPageSize() - totalSpace - CHECKSUM_SIZE)))
1011            {
1012                SanityManager.THROWASSERT("slotsInUse = " + slotsInUse
1013                    + ", firstFreeByte = " + firstFreeByte
1014                    + ", freeSpace = " + freeSpace
1015                    + ", slotOffset = " + (getSlotOffset(slotsInUse - 1))
1016                    + ", page = " + this);
1017            }
1018
1019        }
1020
1021        try
1022        {
1023            if (headerOutOfDate)
1024            {
1025                updatePageHeader();
1026            }
1027            else
1028            {
1029                // page version always need to be updated if page is dirty,
1030
// either do it in updatePageHeader or by itself
1031
updatePageVersion();
1032            }
1033
1034            updateChecksum();
1035
1036        }
1037        catch (IOException JavaDoc ioe)
1038        {
1039            // i/o methods on the byte array have thrown an IOException
1040
throw dataFactory.markCorrupt(
1041                StandardException.newException(
1042                    SQLState.DATA_CORRUPT_PAGE, ioe, identity));
1043        }
1044
1045    }
1046
1047    /**
1048     * Write out the format id of this page
1049     *
1050     * @param identity The key of this page.
1051     *
1052     * @exception StandardException Standard exception policy.
1053     **/

1054    protected void writeFormatId(PageKey identity) throws StandardException
1055    {
1056        try
1057        {
1058            if (rawDataOut == null)
1059                createOutStreams();
1060
1061            rawDataOut.setPosition(0);
1062
1063            FormatIdUtil.writeFormatIdInteger(
1064                logicalDataOut, getTypeFormatId());
1065
1066        }
1067        catch (IOException JavaDoc ioe)
1068        {
1069            // i/o methods on the byte array have thrown an IOException
1070
throw dataFactory.markCorrupt(
1071                StandardException.newException(
1072                    SQLState.DATA_CORRUPT_PAGE, ioe, identity));
1073        }
1074    }
1075
1076
1077    /**************************************************************************
1078     * Protected Methods of Cacheable Interface:
1079     **************************************************************************
1080     */

1081
1082    /**************************************************************************
1083     * Protected OverRidden Methods of BasePage:
1084     **************************************************************************
1085     */

1086
1087    /**
1088     * Ensure that the page is released from the cache when it is unlatched.
1089     *
1090     * @see org.apache.derby.impl.store.raw.data.BasePage#releaseExclusive
1091     *
1092     **/

1093    protected void releaseExclusive()
1094    {
1095        super.releaseExclusive();
1096
1097        pageCache.release(this);
1098    }
1099
1100
1101    /**
1102     * Return the total number of bytes used, reserved, or wasted by the
1103     * record at this slot.
1104     * <p>
1105     * The amount of space the record on this slot is currently taking on the
1106     * page.
1107     *
1108     * If there is any reserve space or wasted space, count that in also
1109     * Do NOT count the slot entry size
1110     * <p>
1111     *
1112     * @return The number of bytes used by the row at slot "slot".
1113     *
1114     * @param slot look at row at this slot.
1115     *
1116     * @exception StandardException Standard exception policy.
1117     **/

1118    public int getTotalSpace(int slot)
1119        throws StandardException
1120    {
1121        try
1122        {
1123            // A slot entry looks like the following:
1124
// 1st field: offset of the record on the page
1125
// 2nd field: length of the record on the page
1126
// 3rd field: amount of space reserved for the record to grow.
1127

1128            // position the read at the beginning of the 2nd field.
1129
rawDataIn.setPosition(getSlotOffset(slot) + slotFieldSize);
1130
1131            // return the size of the record + size of the reserved space.
1132
// the size of the fields to read is determined by slotFieldSize.
1133

1134            return(
1135                ((slotFieldSize == SMALL_SLOT_SIZE) ?
1136                    (rawDataIn.readUnsignedShort() +
1137                     rawDataIn.readUnsignedShort()) :
1138                    (rawDataIn.readInt() +
1139                     rawDataIn.readInt())));
1140                
1141        }
1142        catch (IOException JavaDoc ioe)
1143        {
1144            throw dataFactory.markCorrupt(
1145                StandardException.newException(
1146                    SQLState.DATA_CORRUPT_PAGE, ioe, getPageId()));
1147        }
1148    }
1149
1150    /**
1151     * Is there minimal space for insert?
1152     * <p>
1153     * Does quick calculation to see if average size row on this page could
1154     * be inserted on the page. This is done because the actual row size
1155     * being inserted isn't known until we actually copy the columns from
1156     * their object form into their on disk form which is expensive. So
1157     * we use this calculation so that in the normal case we only do one
1158     * copy of the row directly onto the page.
1159     * <p>
1160     *
1161     * @return true if we think the page will allow an insert, false otherwise.
1162     *
1163     * @exception StandardException Standard exception policy.
1164     **/

1165    public boolean spaceForInsert()
1166        throws StandardException
1167    {
1168        // is this an empty page
1169
if (slotsInUse == 0)
1170            return(true);
1171
1172        if (!allowInsert())
1173            return(false);
1174
1175        int usedSpace = totalSpace - freeSpace;
1176        int bytesPerRow = usedSpace / slotsInUse;
1177
1178        return(bytesPerRow <= freeSpace);
1179    }
1180
1181    /**
1182     * Is row guaranteed to be inserted successfully on this page?
1183     * <p>
1184     * Return true if this record is guaranteed to be inserted successfully
1185     * using insert() or insertAtSlot(). This guarantee is only valid while
1186     * the row remains unchanged and the page latch is held.
1187     * <p>
1188     *
1189     * @return bolean indicating if row can be inserted on this page.
1190     *
1191     * @param row The row to check for insert.
1192     * @param validColumns bit map to interpret valid columns in row.
1193     * @param overflowThreshold The percentage of the page to use for the
1194     * insert. 100 means use 100% of the page,
1195     * 50 means use 50% of page (ie. make sure
1196     * 2 rows fit per page).
1197     *
1198     * @exception StandardException Standard exception policy.
1199     **/

1200    public boolean spaceForInsert(
1201    Object JavaDoc[] row,
1202    FormatableBitSet validColumns,
1203    int overflowThreshold)
1204        throws StandardException
1205    {
1206
1207        // is this an empty page
1208
if (slotsInUse == 0)
1209            return true;
1210        
1211        // does the estimate think it won't fit, if not return false to avoid
1212
// cost of calling logRow() just to figure out if the row will fit.
1213
if (!allowInsert())
1214            return false;
1215
1216        DynamicByteArrayOutputStream out = new DynamicByteArrayOutputStream();
1217
1218        try
1219        {
1220            // This is a public call, start column is rawstore only.
1221
// set the starting Column for the row to be 0.
1222
logRow(
1223                0, true, nextId, row, validColumns, out,
1224                0, Page.INSERT_DEFAULT, -1, -1, overflowThreshold);
1225
1226        }
1227        catch (NoSpaceOnPage nsop)
1228        {
1229            return false;
1230        }
1231        catch (IOException JavaDoc ioe)
1232        {
1233            throw StandardException.newException(
1234                SQLState.DATA_UNEXPECTED_EXCEPTION, ioe);
1235        }
1236
1237        return true;
1238    }
1239
1240    /**
1241     * Is row guaranteed to be inserted successfully on this page?
1242     * <p>
1243     * Return true if this record is guaranteed to be inserted successfully
1244     * using insert() or insertAtSlot(). This guarantee is only valid while
1245     * the row remains unchanged and the page latch is held.
1246     * <p>
1247     * This is a private call only used when calculating whether an overflow
1248     * page can be used to insert part of an overflow row/column.
1249     *
1250     * @return bolean indicating if row can be inserted on this page.
1251     *
1252     * @param row The row to check for insert.
1253     * @param validColumns bit map to interpret valid columns in row.
1254     * @param overflowThreshold The percentage of the page to use for the
1255     * insert. 100 means use 100% of the page,
1256     * 50 means use 50% of page (ie. make sure
1257     * 2 rows fit per page).
1258     *
1259     * @exception StandardException Standard exception policy.
1260     **/

1261    private boolean spaceForInsert(
1262    Object JavaDoc[] row,
1263    FormatableBitSet validColumns,
1264    int spaceNeeded,
1265    int startColumn,
1266    int overflowThreshold)
1267        throws StandardException
1268    {
1269        if (!(spaceForInsert() && (freeSpace >= spaceNeeded)))
1270            return false;
1271
1272        DynamicByteArrayOutputStream out = new DynamicByteArrayOutputStream();
1273
1274        try
1275        {
1276            logRow(
1277                0, true, nextId, row, validColumns, out, startColumn,
1278                Page.INSERT_DEFAULT, -1, -1, overflowThreshold);
1279
1280        }
1281        catch (NoSpaceOnPage nsop)
1282        {
1283            return false;
1284        }
1285        catch (IOException JavaDoc ioe)
1286        {
1287            throw StandardException.newException(
1288                SQLState.DATA_UNEXPECTED_EXCEPTION, ioe);
1289        }
1290
1291        return true;
1292    }
1293
1294    /**
1295     * Is this page unfilled?
1296     * <p>
1297     * Returns true if page is relatively unfilled,
1298     * which means the page is < 1/2 full and has enough space to insert an
1299     * "average" sized row onto the page.
1300     * <p>
1301     *
1302     * @return true if page is relatively unfilled.
1303     **/

1304    public boolean unfilled()
1305    {
1306        return (allowInsert() && (freeSpace > (getPageSize() / 2)));
1307    }
1308
1309    /**
1310     * Is there enough space on the page to insert a minimum size row?
1311     * <p>
1312     * Calculate whether there is enough space on the page to insert a
1313     * minimum size row. The calculation includes maintaining the required
1314     * reserved space on the page for existing rows to grow on the page.
1315     * <p>
1316     *
1317     * @return boolean indicating if a minimum sized row can be inserted.
1318     **/

1319    public boolean allowInsert()
1320    {
1321        // is this an empty page
1322
if (slotsInUse == 0)
1323            return true;
1324
1325        int spaceAvailable = freeSpace;
1326
1327        spaceAvailable -= slotEntrySize; // need to account new slot entry
1328

1329        if (spaceAvailable < minimumRecordSize)
1330            return false;
1331
1332        // see that we reserve enough space for existing rows to grow on page
1333
if (((spaceAvailable * 100) / totalSpace) < spareSpace)
1334            return false;
1335
1336        return true;
1337    }
1338
1339    /**
1340     * Does this page have enough space to insert the input rows?
1341     * <p>
1342     * Can the rows with lengths spaceNeeded[0..num_rows-1] be copied onto
1343     * this page?
1344     * <p>
1345     *
1346     * @return true if the sum of the lengths will fit on the page.
1347     *
1348     * @param num_rows number of rows to check for.
1349     * @param spaceNeeded array of lengths of the rows to insert.
1350     **/

1351    public boolean spaceForCopy(int num_rows, int[] spaceNeeded)
1352    {
1353        // determine how many more bytes are needed for the slot entries
1354
int bytesNeeded = slotEntrySize * num_rows;
1355
1356        for (int i = 0; i < num_rows; i++)
1357        {
1358            if (spaceNeeded[i] > 0)
1359            {
1360                // add up the space needed by the rows, add in minimumRecordSize
1361
// if length of actual row is less than minimumRecordSize.
1362

1363                bytesNeeded +=
1364                    (spaceNeeded[i] >= minimumRecordSize ?
1365                         spaceNeeded[i] : minimumRecordSize);
1366            }
1367        }
1368
1369        return((freeSpace - bytesNeeded) >= 0);
1370    }
1371
1372    protected boolean spaceForCopy(int spaceNeeded)
1373    {
1374        // add up the space needed by the rows, add in minimumRecordSize
1375
// if length of actual row is less than minimumRecordSize.
1376
int bytesNeeded = slotEntrySize +
1377            (spaceNeeded >= minimumRecordSize ?
1378                 spaceNeeded : minimumRecordSize);
1379
1380        return((freeSpace - bytesNeeded) >= 0);
1381    }
1382
1383    /**
1384     * Read the record at the given slot into the given row.
1385     * <P>
1386     * This reads and initializes the columns in the row array from the raw
1387     * bytes stored in the page associated with the given slot. If validColumns
1388     * is non-null then it will only read those columns indicated by the bit
1389     * set, otherwise it will try to read into every column in row[].
1390     * <P>
1391     * If there are more columns than entries in row[] then it just stops after
1392     * every entry in row[] is full.
1393     * <P>
1394     * If there are more entries in row[] than exist on disk, the requested
1395     * excess columns will be set to null by calling the column's object's
1396     * restoreToNull() routine (ie. ((Object) column).restoreToNull() ).
1397     * <P>
1398     * If a qualifier list is provided then the row will only be read from
1399     * disk if all of the qualifiers evaluate true. Some of the columns may
1400     * have been read into row[] in the process of evaluating the qualifier.
1401     * <p>
1402     * This routine should only be called on the head portion of a row, it
1403     * will call a utility routine to read the rest of the row if it is a
1404     * long row.
1405     *
1406     *
1407     * @param slot the slot number
1408     * @param row (out) filled in sparse row
1409     * @param fetchDesc Information describing fetch, including what
1410     * columns to fetch and qualifiers.
1411     * @param recordToLock the record handle for the row at top level,
1412     * and is used in OverflowInputStream to lock the
1413     * row for Blobs/Clobs.
1414     * @param isHeadRow The row on this page includes the head record
1415     * handle. Will be false for the overflow portions
1416     * of a "long" row, where columns of a row span
1417     * multiple pages.
1418     *
1419     * @return false if a qualifier_list is provided and the row does not
1420     * qualifier (no row read in that case), else true.
1421     *
1422     * @exception StandardException Standard Cloudscape error policy
1423     **/

1424    protected boolean restoreRecordFromSlot(
1425    int slot,
1426    Object JavaDoc[] row,
1427    FetchDescriptor fetchDesc,
1428    RecordHandle recordToLock,
1429    StoredRecordHeader recordHeader,
1430    boolean isHeadRow)
1431        throws StandardException
1432    {
1433        try
1434        {
1435            int offset_to_row_data =
1436                getRecordOffset(slot) + recordHeader.size();
1437
1438            if (SanityManager.DEBUG)
1439            {
1440                if (getRecordOffset(slot) <
1441                        (PAGE_HEADER_OFFSET + PAGE_HEADER_SIZE))
1442                {
1443                    SanityManager.THROWASSERT(
1444                        "Incorrect offset. offset = " +
1445                            getRecordOffset(slot) +
1446                        ", offset should be < " +
1447                        "(PAGE_HEADER_OFFSET + PAGE_HEADER_SIZE) = " +
1448                            (PAGE_HEADER_OFFSET + PAGE_HEADER_SIZE) +
1449                        ", current slot = " + slot +
1450                        ", total slotsInUse = " + slotsInUse);
1451                }
1452
1453                SanityManager.ASSERT(
1454                    isHeadRow, "restoreRecordFromSlot called on a non-headrow");
1455                SanityManager.ASSERT(
1456                    !isOverflowPage(),
1457                    "restoreRecordFromSlot called on an overflow page.");
1458            }
1459
1460            // position the array reading stream at beginning of row data just
1461
// past the record header.
1462
ArrayInputStream lrdi = rawDataIn;
1463            lrdi.setPosition(offset_to_row_data);
1464
1465            if (!recordHeader.hasOverflow())
1466            {
1467                if (isHeadRow)
1468                {
1469                    if (fetchDesc != null &&
1470                        fetchDesc.getQualifierList() != null)
1471                    {
1472                        fetchDesc.reset();
1473
1474                        if (!qualifyRecordFromSlot(
1475                                row,
1476                                offset_to_row_data,
1477                                fetchDesc,
1478                                recordHeader,
1479                                recordToLock))
1480                        {
1481                            return(false);
1482                        }
1483                        else
1484                        {
1485                            // reset position back for subsequent record read.
1486
lrdi.setPosition(offset_to_row_data);
1487                        }
1488                    }
1489                }
1490
1491                // call routine to do the real work. Note that
1492
// readRecordFromStream() may return false for non-overflow
1493
// record, this is in the case where caller requests more
1494
// columns than exist on disk. In that case we still return
1495
// true at this point as there are no more columns that we
1496
// can return.
1497
if (fetchDesc != null)
1498                {
1499                    readRecordFromArray(
1500                        row,
1501                        (fetchDesc.getValidColumns() == null) ?
1502                            row.length -1 : fetchDesc.getMaxFetchColumnId(),
1503                        fetchDesc.getValidColumnsArray(),
1504                        fetchDesc.getMaterializedColumns(),
1505                        lrdi,
1506                        recordHeader,
1507                        (ErrorObjectInput) null /* always null */,
1508                        recordToLock);
1509                }
1510                else
1511                {
1512                    readRecordFromArray(
1513                        row,
1514                        row.length - 1,
1515                        (int[]) null,
1516                        (int[]) null,
1517                        lrdi,
1518                        recordHeader,
1519                        (ErrorObjectInput) null /* always null */,
1520                        recordToLock);
1521                }
1522
1523                return(true);
1524            }
1525            else
1526            {
1527                if (fetchDesc != null)
1528                {
1529                    if (fetchDesc.getQualifierList() != null)
1530                    {
1531                        fetchDesc.reset();
1532                    }
1533
1534                    readRecordFromArray(
1535                        row,
1536                        (fetchDesc.getValidColumns() == null) ?
1537                            row.length - 1 : fetchDesc.getMaxFetchColumnId(),
1538                        fetchDesc.getValidColumnsArray(),
1539                        fetchDesc.getMaterializedColumns(),
1540                        lrdi,
1541                        recordHeader,
1542                        (ErrorObjectInput) null /* always null */,
1543                        recordToLock);
1544                }
1545                else
1546                {
1547                    readRecordFromArray(
1548                        row,
1549                        row.length - 1,
1550                        (int[]) null,
1551                        (int[]) null,
1552                        lrdi,
1553                        recordHeader,
1554                        (ErrorObjectInput) null /* always null */,
1555                        recordToLock);
1556                }
1557
1558                // call routine to loop through all the overflow portions of
1559
// the row, reading it into "row".
1560
while (recordHeader != null)
1561                {
1562                    // The record is a long row, loop callng code to read the
1563
// pieces of the row located in a linked list of rows on
1564
// overflow pages.
1565
StoredPage overflowPage =
1566                        getOverflowPage(recordHeader.getOverflowPage());
1567                     
1568                    if (SanityManager.DEBUG)
1569                    {
1570                        if (overflowPage == null)
1571                            SanityManager.THROWASSERT(
1572                                "cannot get overflow page");
1573                    }
1574
1575                    // This call reads in the columns of the row that reside
1576
// on "overflowPage", and if there is another piece it
1577
// returns the recordHeader of the row on overFlowPage,
1578
// from which we can find the next piece of the row. A
1579
// null return means that we have read in the entire row,
1580
// and are done.
1581
recordHeader =
1582                        overflowPage.restoreLongRecordFromSlot(
1583                            row,
1584                            fetchDesc,
1585                            recordToLock,
1586                            recordHeader);
1587
1588                    overflowPage.unlatch();
1589                    overflowPage = null;
1590                }
1591
1592                // for overflow rows just apply qualifiers at end for now.
1593

1594                if ((fetchDesc != null) &&
1595                    (fetchDesc.getQualifierList() != null))
1596                {
1597                    if (!qualifyRecordFromRow(
1598                            row, fetchDesc.getQualifierList()))
1599                    {
1600                        return(false);
1601                    }
1602                }
1603
1604                return(true);
1605            }
1606        }
1607        catch (IOException JavaDoc ioe)
1608        {
1609
1610            if (SanityManager.DEBUG)
1611            {
1612                if (pageData == null)
1613                {
1614                    SanityManager.DEBUG_PRINT("DEBUG_TRACE",
1615                        "caught an IOException in restoreRecordFromSlot " +
1616                        (PageKey)getIdentity() + " slot " + slot +
1617                        ", pageData is null");
1618                }
1619                else
1620                {
1621                    SanityManager.DEBUG_PRINT("DEBUG_TRACE",
1622                        "caught an IOException in reestoreRecordFromSlot, " +
1623                        (PageKey)getIdentity() + " slot " + slot +
1624                        ", pageData.length = " +
1625                        pageData.length + " pageSize = " + getPageSize());
1626                    SanityManager.DEBUG_PRINT("DEBUG_TRACE",
1627                        "Hex dump of pageData \n " +
1628                        "--------------------------------------------------\n" +
1629                        pagedataToHexDump(pageData) +
1630                        "--------------------------------------------------\n");
1631                    SanityManager.DEBUG_PRINT("DEBUG_TRACE",
1632                        "Attempt to dump page " + this.toString());
1633                }
1634            }
1635
1636            // i/o methods on the byte array have thrown an IOException
1637
throw dataFactory.markCorrupt(
1638                StandardException.newException(
1639                    SQLState.DATA_CORRUPT_PAGE, ioe, getPageId()));
1640        }
1641    }
1642
1643    private StoredRecordHeader restoreLongRecordFromSlot(
1644    Object JavaDoc[] row,
1645    FetchDescriptor fetchDesc,
1646    RecordHandle recordToLock,
1647    StoredRecordHeader parent_recordHeader)
1648        throws StandardException
1649    {
1650
1651        int slot =
1652            findRecordById(
1653                parent_recordHeader.getOverflowId(), Page.FIRST_SLOT_NUMBER);
1654
1655        StoredRecordHeader recordHeader = getHeaderAtSlot(slot);
1656
1657        try
1658        {
1659            int offset_to_row_data =
1660                getRecordOffset(slot) + recordHeader.size();
1661
1662            if (SanityManager.DEBUG)
1663            {
1664                if (getRecordOffset(slot) <
1665                        (PAGE_HEADER_OFFSET + PAGE_HEADER_SIZE))
1666                {
1667                    SanityManager.THROWASSERT(
1668                        "Incorrect offset. offset = " +
1669                            getRecordOffset(slot) +
1670                        ", offset should be < " +
1671                        "(PAGE_HEADER_OFFSET + PAGE_HEADER_SIZE) = " +
1672                            (PAGE_HEADER_OFFSET + PAGE_HEADER_SIZE) +
1673                        ", current slot = " + slot +
1674                        ", total slotsInUse = " + slotsInUse);
1675                }
1676            }
1677
1678            // position the array reading stream at beginning of row data
1679
// just past the record header.
1680
ArrayInputStream lrdi = rawDataIn;
1681            lrdi.setPosition(offset_to_row_data);
1682
1683            if (fetchDesc != null)
1684            {
1685                if (fetchDesc.getQualifierList() != null)
1686                {
1687                    fetchDesc.reset();
1688                }
1689
1690                readRecordFromArray(
1691                    row,
1692                    (fetchDesc.getValidColumns() == null) ?
1693                        row.length - 1 : fetchDesc.getMaxFetchColumnId(),
1694                    fetchDesc.getValidColumnsArray(),
1695                    fetchDesc.getMaterializedColumns(),
1696                    lrdi,
1697                    recordHeader,
1698                    (ErrorObjectInput) null /* always null */,
1699                    recordToLock);
1700            }
1701            else
1702            {
1703                readRecordFromArray(
1704                    row,
1705                    row.length - 1,
1706                    (int[]) null,
1707                    (int[]) null,
1708                    lrdi,
1709                    recordHeader,
1710                    (ErrorObjectInput) null /* always null */,
1711                    recordToLock);
1712            }
1713
1714            return(recordHeader.hasOverflow() ? recordHeader : null);
1715        }
1716        catch (IOException JavaDoc ioe)
1717        {
1718            if (SanityManager.DEBUG)
1719            {
1720                if (pageData == null)
1721                {
1722                    SanityManager.DEBUG_PRINT("DEBUG_TRACE",
1723                        "caught an IOException in restoreRecordFromSlot " +
1724                        (PageKey)getIdentity() + " slot " + slot +
1725                        ", pageData is null");
1726                }
1727                else
1728                {
1729                    SanityManager.DEBUG_PRINT("DEBUG_TRACE",
1730                        "caught an IOException in reestoreRecordFromSlot, " +
1731                        (PageKey)getIdentity() + " slot " + slot +
1732                        ", pageData.length = " +
1733                        pageData.length + " pageSize = " + getPageSize());
1734                    SanityManager.DEBUG_PRINT("DEBUG_TRACE",
1735                        "Hex dump of pageData \n " +
1736                        "--------------------------------------------------\n" +
1737                        pagedataToHexDump(pageData) +
1738                        "--------------------------------------------------\n");
1739                    SanityManager.DEBUG_PRINT("DEBUG_TRACE",
1740                        "Attempt to dump page " + this.toString());
1741                }
1742            }
1743
1744            // i/o methods on the byte array have thrown an IOException
1745
throw dataFactory.markCorrupt(
1746                StandardException.newException(
1747                    SQLState.DATA_CORRUPT_PAGE, ioe, getPageId()));
1748        }
1749    }
1750
1751    /**
1752     * Create a new record handle.
1753     * <p>
1754     * Return the next record id for allocation. Callers of this interface
1755     * expect the next id to get bumped some where else - probably by
1756     * storeRecordForInsert().
1757     * <p>
1758     *
1759     * @return The next id to assing to a row.
1760     **/

1761    public int newRecordId()
1762    {
1763        return nextId;
1764    }
1765
1766    /**
1767     * Create a new record handle, and bump the id.
1768     * <p>
1769     * Create a new record handle, and bump the id while holding the latch
1770     * so that no other user can ever see this record id. This will lead
1771     * to unused record id's in the case where an insert fails because there
1772     * is not enough space on the page.
1773     * <p>
1774     *
1775     * @return The next id to assing to a row.
1776     **/

1777    public int newRecordIdAndBump()
1778    {
1779        // headerOutOfDate must be bumped as nextId is changing, and must
1780
// eventually be updated in the page array.
1781
headerOutOfDate = true;
1782                            
1783        return nextId++;
1784    }
1785
1786
1787    /**
1788     * Create a new record id based on current one passed in.
1789     * <p>
1790     * This interface is used for the "copy" insert interface of raw store
1791     * where multiple rows are inserted into a page in a single logged
1792     * operation. We don't want to bump the id until the operation is logged
1793     * so we just allocated each id in order and then bump the next id at
1794     * the end of the operation.
1795     * <p>
1796     *
1797     * @return the next id based on the input id.
1798     *
1799     * @param recordId The id caller just used, return the next one.
1800     *
1801     **/

1802    protected int newRecordId(int recordId)
1803    {
1804        if (SanityManager.DEBUG)
1805        {
1806            SanityManager.ASSERT(
1807                recordId >= nextId,
1808                "should not create a record Id that is already given out");
1809        }
1810
1811        return recordId + 1;
1812    }
1813
1814    public boolean isOverflowPage()
1815    {
1816        return isOverflowPage;
1817    }
1818
1819
1820
1821    /**************************************************************************
1822     * Public Methods specific to StoredPage:
1823     **************************************************************************
1824     */

1825
1826    /**
1827     * Get the full size of the page.
1828     **/

1829    public final int getPageSize()
1830    {
1831        return pageData.length;
1832    }
1833
1834
1835    /**
1836     * Zero out a portion of the page.
1837     * <p>
1838     **/

1839    protected final void clearSection(int offset, int length)
1840    {
1841        int endOffset = offset + length;
1842
1843        while (offset < endOffset)
1844            pageData[offset++] = 0;
1845    }
1846
1847    /**
1848     * The maximum free space on this page possible.
1849     * <p>
1850     * The the maximum amount of space that can be used on the page
1851     * for the records and the slot offset table.
1852     * NOTE: subclass may have overwitten it to report less freeSpace
1853     *
1854     * @return the maximum free space on this page possible.
1855     *
1856     **/

1857    protected int getMaxFreeSpace()
1858    {
1859        return getPageSize() - RECORD_SPACE_OFFSET - CHECKSUM_SIZE;
1860    }
1861
1862    /**
1863     * The current free space on the page.
1864     **/

1865    protected int getCurrentFreeSpace()
1866    {
1867        return freeSpace;
1868    }
1869
1870    /**************************************************************************
1871     * Page header routines
1872     **************************************************************************
1873     */

1874
1875    /**
1876     * Read the page header from the page array.
1877     * <p>
1878     * Read the page header from byte form in the page array into in memory
1879     * variables.
1880     **/

1881    private void readPageHeader()
1882        throws IOException JavaDoc
1883    {
1884        // these reads are always against the page array
1885
ArrayInputStream lrdi = rawDataIn;
1886
1887        lrdi.setPosition(PAGE_HEADER_OFFSET);
1888        long spare;
1889
1890        isOverflowPage = lrdi.readBoolean();
1891        setPageStatus (lrdi.readByte());
1892        setPageVersion (lrdi.readLong());
1893        slotsInUse = lrdi.readUnsignedShort();
1894        nextId = lrdi.readInt();
1895        generation = lrdi.readInt(); // page generation (Future Use)
1896
prevGeneration = lrdi.readInt(); // previous generation (Future Use)
1897
bipLocation = lrdi.readLong(); // BIPage location (Future Use)
1898

1899        // number of deleted rows on page, we start to store this release 2.0.
1900
// for upgrade reasons, a 0 on disk means -1, so, we subtract one here.
1901
deletedRowCount = lrdi.readUnsignedShort() - 1;
1902
1903        // the next 4 (total 22 bytes) are reserved for future
1904
spare = lrdi.readUnsignedShort();
1905        spare = lrdi.readInt(); // used by encryption
1906
spare = lrdi.readLong();
1907        spare = lrdi.readLong();
1908    }
1909
1910
1911    /**
1912     * Update the page header in the page array.
1913     * <p>
1914     * Write the bytes of the page header, taking the values from those
1915     * in the in memory variables.
1916     **/

1917    private void updatePageHeader()
1918        throws IOException JavaDoc
1919    {
1920        rawDataOut.setPosition(PAGE_HEADER_OFFSET);
1921
1922        logicalDataOut.writeBoolean(isOverflowPage);
1923        logicalDataOut.writeByte(getPageStatus());
1924        logicalDataOut.writeLong(getPageVersion());
1925        logicalDataOut.writeShort(slotsInUse);
1926        logicalDataOut.writeInt(nextId);
1927        logicalDataOut.writeInt(generation); // page generation (Future Use)
1928
logicalDataOut.writeInt(prevGeneration); // previous generation (Future Use)
1929
logicalDataOut.writeLong(bipLocation); // BIPage location (Future Use)
1930

1931        // number of deleted rows on page, we start to store this release 2.0.
1932
// for upgrade reasons, a 0 on disk means -1, so, we add one when we
1933
// write it to disk.
1934
logicalDataOut.writeShort(deletedRowCount + 1);
1935
1936        logicalDataOut.writeShort(0); // reserved for future
1937
logicalDataOut.writeInt(
1938                dataFactory.random()); // random bytes for encryption
1939
logicalDataOut.writeLong(0); // reserved for future
1940
logicalDataOut.writeLong(0); // reserved for future
1941

1942        // we put a random value int into the page if the database is encrypted
1943
// so that the checksum will be very different even with the same
1944
// page image, when we encrypt or decrypt the page, we move the
1945
// checksum to the front so that the encrypted page will look very
1946
// different even with just the one int difference. We never look at
1947
// the value of the random number and we could have put it anywhere in
1948
// the page as long as it doesn't obscure real data.
1949

1950        headerOutOfDate = false;
1951    }
1952
1953    /**
1954     * Update the page version number in the byte array
1955     **/

1956    private void updatePageVersion()
1957        throws IOException JavaDoc
1958    {
1959        rawDataOut.setPosition(PAGE_VERSION_OFFSET);
1960        logicalDataOut.writeLong(getPageVersion());
1961    }
1962
1963    /**************************************************************************
1964     * Slot Offset & Length table manipulation
1965     **************************************************************************
1966     */

1967
1968    /**
1969     * Get the page offset of a given slot entry.
1970     * <p>
1971     * Get the page offset of a slot entry, this is not the offset of
1972     * the record stored in the slot, but the offset of the actual slot.
1973     *
1974     * @return The page offset of a given slot entry.
1975     *
1976     * @param slot The array entry of the slot to find.
1977     **/

1978    private int getSlotOffset(int slot)
1979    {
1980        // slot table grows backward from the spot at the end of the page just
1981
// before the checksum which is located in the last 8 bytes of the page.
1982

1983        return(slotTableOffsetToFirstEntry - (slot * slotEntrySize));
1984    }
1985
1986    /**
1987     * Get the page offset of the record associated with the input slot.
1988     * <p>
1989     * This is the actual offset on the page of the beginning of the record.
1990     *
1991     * @return The page offset of the record associated with the input slot.
1992     *
1993     * @param slot The array entry of the slot to find.
1994     **/

1995    private int getRecordOffset(int slot)
1996    {
1997        byte[] data = pageData;
1998        int offset = slotTableOffsetToFirstEntry - (slot * slotEntrySize);
1999
2000        // offset on the page of the record is stored in the first 2 or 4 bytes
2001
// of the slot table entry. Code has been inlined for performance
2002
// critical low level routine.
2003
//
2004
// return(
2005
// (slotFieldSize == SMALL_SLOT_SIZE) ?
2006
// readUnsignedShort() : readInt());
2007

2008        return(
2009            (slotFieldSize == SMALL_SLOT_SIZE) ?
2010
2011             ((data[offset++] & 0xff) << 8) |
2012              (data[offset] & 0xff) :
2013
2014             (((data[offset++] & 0xff) << 24) |
2015              ((data[offset++] & 0xff) << 16) |
2016              ((data[offset++] & 0xff) << 8) |
2017              ((data[offset] & 0xff) )));
2018    }
2019
2020    /**
2021     * Set the page offset of the record associated with the input slot.
2022     * <p>
2023     * This is the actual offset on the page of the beginning of the record.
2024     *
2025     * @param slot The array entry of the slot to set.
2026     * @param recordOffset the new offset to set.
2027     **/

2028    private void setRecordOffset(int slot, int recordOffset)
2029        throws IOException JavaDoc
2030    {
2031        rawDataOut.setPosition(getSlotOffset(slot));
2032
2033        if (slotFieldSize == SMALL_SLOT_SIZE)
2034            logicalDataOut.writeShort(recordOffset);
2035        else
2036            logicalDataOut.writeInt(recordOffset);
2037    }
2038
2039    /**
2040     * Return length of row on this page.
2041     * <p>
2042     * Return the total length of data and header stored on this page for
2043     * this record. This length is stored as the second "field" of the
2044     * slot table entry.
2045     *
2046     * @return The length of the row on this page.
2047     *
2048     * @param slot the slot of the row to look up the length of.
2049     *
2050     **/

2051    protected int getRecordPortionLength(int slot)
2052        throws IOException JavaDoc
2053    {
2054        if (SanityManager.DEBUG)
2055        {
2056            SanityManager.ASSERT(getRecordOffset(slot) != 0);
2057        }
2058
2059        // these reads are always against the page array
2060
ArrayInputStream lrdi = rawDataIn;
2061
2062        lrdi.setPosition(
2063            slotTableOffsetToFirstRecordLengthField - (slot * slotEntrySize));
2064
2065        return(
2066            (slotFieldSize == SMALL_SLOT_SIZE) ?
2067                lrdi.readUnsignedShort() : lrdi.readInt());
2068    }
2069
2070    /**
2071     * Return reserved length of row on this page.
2072     * <p>
2073     * Return the reserved length of this record.
2074     * This length is stored as the third "field" of the slot table entry.
2075     *
2076     * @return The reserved length of the row on this page.
2077     *
2078     * @param slot the slot of the row to look up the length of.
2079     *
2080     **/

2081    public int getReservedCount(int slot) throws IOException JavaDoc
2082    {
2083        if (SanityManager.DEBUG)
2084        {
2085            SanityManager.ASSERT(getRecordOffset(slot) != 0);
2086        }
2087
2088        // these reads are always against the page array
2089
ArrayInputStream lrdi = rawDataIn;
2090
2091        lrdi.setPosition(
2092            slotTableOffsetToFirstReservedSpaceField - (slot * slotEntrySize));
2093
2094        return(
2095            (slotFieldSize == SMALL_SLOT_SIZE) ?
2096                lrdi.readUnsignedShort() : lrdi.readInt());
2097    }
2098
2099
2100    /**
2101        Update the length of data stored on this page for this record
2102    */

2103    /**
2104     * Update the length of data stored on this page for this record
2105     * <p>
2106     * Update both the record length "field" and the reserved space "field"
2107     * of the slot table entry associated with "slot". This length is stored
2108     * as the second "field" of the slot table entry. The changes to these
2109     * 2 fields are represented as the delta to apply to each field as input
2110     * in "delta" and "reservedDelta."
2111     * <p>
2112     *
2113     * @param slot the slot of the record to set.
2114     * @param delta The amount the record length changed.
2115     * @param reservedDelta The amount the reserved length changed.
2116     *
2117     * @exception StandardException Standard exception policy.
2118     **/

2119    private void updateRecordPortionLength(
2120    int slot,
2121    int delta,
2122    int reservedDelta)
2123        throws IOException JavaDoc
2124    {
2125        if (SanityManager.DEBUG)
2126        {
2127            SanityManager.ASSERT(getRecordOffset(slot) != 0);
2128
2129            if ((delta + reservedDelta) < 0)
2130                SanityManager.THROWASSERT(
2131                    "total space of record is not allowed to shrink, delta == "
2132                    + delta + " reservedDelta = " + reservedDelta);
2133
2134            if ((getRecordPortionLength(slot) + delta) < 0)
2135                SanityManager.THROWASSERT(
2136                    "record portion length cannot be < 0.recordPortionLength = "
2137                    + getRecordPortionLength(slot) + " delta = " + delta);
2138
2139            if ((getReservedCount(slot) + reservedDelta) < 0)
2140                SanityManager.THROWASSERT(
2141                    "reserved space for record cannot be < 0. reservedCount = "
2142                    + getReservedCount(slot) + " reservedDelta = "
2143                    + reservedDelta);
2144        }
2145
2146        // position the stream to beginning of 2nd field of slot entry.
2147
rawDataOut.setPosition(
2148            slotTableOffsetToFirstRecordLengthField - (slot * slotEntrySize));
2149
2150        // write the new record length to 2nd field
2151
if (slotFieldSize == SMALL_SLOT_SIZE)
2152            logicalDataOut.writeShort(getRecordPortionLength(slot) + delta);
2153        else
2154            logicalDataOut.writeInt(getRecordPortionLength(slot) + delta);
2155
2156        // if necessary, write the 3rd field - above write has positioned the
2157
// stream to the 3rd field.
2158
if (reservedDelta != 0)
2159        {
2160            if (slotFieldSize == SMALL_SLOT_SIZE)
2161            {
2162                logicalDataOut.writeShort(
2163                    getReservedCount(slot) + reservedDelta);
2164            }
2165            else
2166            {
2167                logicalDataOut.writeInt(
2168                    getReservedCount(slot) + reservedDelta);
2169            }
2170        }
2171    }
2172
2173    /**
2174     * Initialize the in-memory slot table.
2175     * <p>
2176     * Initialize the in-memory slot table, ie. that of our super-class
2177     * BasePage. Go through all the records on the page and set the
2178     * freeSpace and firstFreeByte on page.
2179     * <p>
2180     *
2181     * @exception StandardException Standard exception policy.
2182     **/

2183    private void initSlotTable()
2184        throws StandardException
2185    {
2186        int localSlotsInUse = slotsInUse;
2187
2188        // must initialize the header now
2189
initializeHeaders(localSlotsInUse);
2190
2191        // mark all the space on the page as free
2192
clearAllSpace();
2193        
2194        // first count the space occupied by the slot table
2195
freeSpace -= localSlotsInUse * slotEntrySize;
2196
2197        int lastSlotOnPage = -1;
2198        int lastRecordOffset = -1;
2199        
2200        try
2201        {
2202            for (int slot = 0; slot < localSlotsInUse; slot++)
2203            {
2204                if (SanityManager.DEBUG)
2205                {
2206                    if (!isOverflowPage() &&
2207                        minimumRecordSize > getTotalSpace(slot))
2208                    {
2209                        SanityManager.THROWASSERT(
2210                            " slot " + slot +
2211                            " minimumRecordSize = " + minimumRecordSize +
2212                            " totalSpace = " + getTotalSpace(slot) +
2213                            "recordPortionLength = " +
2214                                getRecordPortionLength(slot)
2215                            + " reservedCount = " + getReservedCount(slot));
2216                    }
2217                }
2218
2219                int recordOffset = getRecordOffset(slot);
2220
2221                // check that offset points into the record space area.
2222
if ((recordOffset < RECORD_SPACE_OFFSET) ||
2223                    (recordOffset >= (getPageSize() - CHECKSUM_SIZE)))
2224                {
2225                    throw dataFactory.markCorrupt(
2226                        StandardException.newException(
2227                            SQLState.DATA_CORRUPT_PAGE, getPageId()));
2228                }
2229
2230                if (recordOffset > lastRecordOffset)
2231                {
2232                    lastRecordOffset = recordOffset;
2233                    lastSlotOnPage = slot;
2234                }
2235            }
2236
2237            bumpRecordCount(localSlotsInUse);
2238
2239            if (lastSlotOnPage != -1)
2240            {
2241                // Calculate the firstFreeByte for the page,
2242
// and the freeSpace on Page
2243

2244                firstFreeByte =
2245                    lastRecordOffset + getTotalSpace(lastSlotOnPage);
2246                freeSpace -= firstFreeByte - RECORD_SPACE_OFFSET;
2247            }
2248
2249            if (SanityManager.DEBUG)
2250            {
2251                if ((freeSpace < 0) ||
2252                    ((firstFreeByte + freeSpace) !=
2253                         (getSlotOffset(slotsInUse - 1))))
2254                {
2255                    SanityManager.THROWASSERT(
2256                        "firstFreeByte = " + firstFreeByte
2257                        + ", freeSpace = " + freeSpace
2258                        + ", slotOffset = " + (getSlotOffset(slotsInUse - 1))
2259                        + ", slotsInUse = " + localSlotsInUse);
2260                }
2261
2262                if (localSlotsInUse == 0)
2263                {
2264                    SanityManager.ASSERT(
2265                        firstFreeByte ==
2266                            (getPageSize() - totalSpace - CHECKSUM_SIZE));
2267                }
2268            }
2269
2270            // upgrade issue. Pre 1.5 release, we do not store deletedRowCount
2271
// therefore, if we are accessing an older database,
2272
// we need to calculate the deletedRowCount here.
2273
if (deletedRowCount == -1)
2274            {
2275                int count = 0;
2276                int maxSlot = slotsInUse;
2277                for (int slot = FIRST_SLOT_NUMBER ; slot < maxSlot; slot++)
2278                {
2279                    if (isDeletedOnPage(slot))
2280                        count++;
2281                }
2282                deletedRowCount = count;
2283            }
2284
2285        }
2286        catch (IOException JavaDoc ioe)
2287        {
2288            // i/o methods on the byte array have thrown an IOException
2289
throw dataFactory.markCorrupt(
2290                StandardException.newException(
2291                    SQLState.DATA_CORRUPT_PAGE, ioe, getPageId()));
2292        }
2293    }
2294
2295    
2296    /**
2297     * Set up a new slot entry.
2298     * <p>
2299     *
2300     * @param slot the slot to initialize.
2301     * @param recordOffset the offset on the page to find the record.
2302     * @param recordPortionLength the actual length of record+hdr on page.
2303     * @param reservedSpace the reserved length associated with record.
2304     *
2305     * @exception StandardException Standard exception policy.
2306     **/

2307    private void setSlotEntry(
2308    int slot,
2309    int recordOffset,
2310    int recordPortionLength,
2311    int reservedSpace)
2312        throws IOException JavaDoc
2313    {
2314        rawDataOut.setPosition(getSlotOffset(slot));
2315
2316        if (SanityManager.DEBUG)
2317        {
2318            if ((recordPortionLength < 0) ||
2319                (reservedSpace < 0) ||
2320                (recordPortionLength >= getPageSize()) ||
2321                (reservedSpace >= getPageSize()))
2322            {
2323                SanityManager.THROWASSERT(
2324                    "recordPortionLength and reservedSpace must " +
2325                    "be > 0, and < page size."
2326                    + " slot = " + slot
2327                    + ", in use = " + slotsInUse
2328                    + ", recordOffset = " + recordOffset
2329                    + ", recordPortionLength = " + recordPortionLength
2330                    + ", reservedSpace = " + reservedSpace);
2331            }
2332
2333            if (recordOffset < (PAGE_HEADER_OFFSET + PAGE_HEADER_SIZE))
2334            {
2335                SanityManager.THROWASSERT(
2336                    "Record offset must be after the page header."
2337                    + " slot = " + slot
2338                    + ", in use = " + slotsInUse
2339                    + ", recordOffset = " + recordOffset
2340                    + ", recordPortionLength = " + recordPortionLength
2341                    + ", reservedSpace = " + reservedSpace);
2342            }
2343        }
2344
2345        if (slotFieldSize == SMALL_SLOT_SIZE)
2346        {
2347            logicalDataOut.writeShort(recordOffset);
2348            logicalDataOut.writeShort(recordPortionLength);
2349            logicalDataOut.writeShort(reservedSpace);
2350        }
2351        else
2352        {
2353            logicalDataOut.writeInt(recordOffset);
2354            logicalDataOut.writeInt(recordPortionLength);
2355            logicalDataOut.writeInt(reservedSpace);
2356        }
2357    }
2358
2359    /**
2360     * Insert a new slot entry into the current slot array.
2361     * <p>
2362     * Shift the existing slots from slot to (slotsInUse - 1) up by one.
2363     * Up here means from low slot to high slot (e.g from slot 2 to slot 3).
2364     * Our slot table grows backward so we have to be careful here.
2365     *
2366     * @param slot Position the new slot will take
2367     * @param recordOffset Offset of the record for the new slot
2368     * @param recordPortionLength Length of the record stored in the new slot
2369     * @param reservedSpace Length of reserved space of record in slot
2370     *
2371     **/

2372    private void addSlotEntry(
2373    int slot,
2374    int recordOffset,
2375    int recordPortionLength,
2376    int reservedSpace)
2377        throws IOException JavaDoc
2378    {
2379        if (SanityManager.DEBUG)
2380        {
2381            if ((slot < 0) || (slot > slotsInUse))
2382                SanityManager.THROWASSERT("invalid slot " + slot);
2383            
2384            if ((recordPortionLength < 0) || (reservedSpace < 0))
2385                SanityManager.THROWASSERT(
2386                    "recordPortionLength and reservedSpace must be > 0." +
2387                    "recordPortionLength = " + recordPortionLength +
2388                    " reservedSpace = " + reservedSpace);
2389
2390            if (recordOffset < (PAGE_HEADER_OFFSET + PAGE_HEADER_SIZE))
2391            {
2392                SanityManager.THROWASSERT(
2393                    "Record offset must be after the page header."
2394                        + " slot = " + slot
2395                        + ", in use = " + slotsInUse
2396                        + ", recordOffset = " + recordOffset
2397                        + ", recordPortionLength = " + recordPortionLength
2398                        + ", reservedSpace = " + reservedSpace);
2399            }
2400        }
2401
2402        int newSlotOffset;
2403
2404        // TODO - (mikem) - I think the math below could be slightly optimized.
2405

2406        if (slot < slotsInUse)
2407        {
2408            // inserting a slot into the middle of array so shift all the
2409
// slots from "slot" logically up by one
2410

2411            int startOffset =
2412                getSlotOffset(slotsInUse - 1);
2413
2414            int length =
2415                (getSlotOffset(slot) + slotEntrySize) - startOffset;
2416
2417            newSlotOffset = getSlotOffset(slotsInUse);
2418
2419            System.arraycopy(
2420                pageData, startOffset, pageData, newSlotOffset, length);
2421        }
2422        else
2423        {
2424            // We are adding at end of slot table, so no moving necessary.
2425
newSlotOffset = getSlotOffset(slot);
2426        }
2427
2428        freeSpace -= slotEntrySize;
2429
2430        slotsInUse++;
2431        headerOutOfDate = true; // headerOutOfDate must be set after setDirty
2432
// because isDirty may be called unlatched
2433

2434        setSlotEntry(slot, recordOffset, recordPortionLength, reservedSpace);
2435    }
2436
2437    /**
2438     * Remove slot entry from slot array.
2439     * <p>
2440     * Remove a storage slot at slot. Shift the existing slots from
2441     * slot+1 to (slotsInUse - 1) down by one..
2442     * Down here means from high slot to low slot (e.g from slot 3 to slot 2)
2443     *
2444     * @param slot The slot to delete.
2445     *
2446     **/

2447    private void removeSlotEntry(int slot)
2448        throws IOException JavaDoc
2449    {
2450        if (SanityManager.DEBUG)
2451        {
2452            if ((slot < 0) || (slot >= slotsInUse))
2453                SanityManager.THROWASSERT("invalid slot " + slot);
2454        }
2455
2456        int oldEndOffset = getSlotOffset(slotsInUse - 1);
2457        int newEndOffset = getSlotOffset(slotsInUse - 2);
2458
2459        if (slot != slotsInUse - 1)
2460        {
2461            // if not removing the last slot, need to shift
2462

2463            // now shift all the slots logically down by one
2464
// from (slot+1 to slotsInUse-1) to (slot and slotsInUse-2)
2465
int length = getSlotOffset(slot) - oldEndOffset;
2466
2467            System.arraycopy(
2468                pageData, oldEndOffset, pageData, newEndOffset, length);
2469        }
2470
2471        // clear out the last slot
2472
clearSection(oldEndOffset, slotEntrySize);
2473
2474        // mark the space as free after we have removed the slot
2475
// no need to keep the space reserved for rollback as this is only
2476
// called for purge.
2477
freeSpace += slotEntrySize;
2478
2479        slotsInUse--;
2480
2481        headerOutOfDate = true; // headerOutOfDate must be set after setDirty
2482
// because isDirty maybe called unlatched
2483
}
2484
2485    /**
2486     * create the record header for the specific slot.
2487     * <p>
2488     * Create a new record header object, initialize it, and add it
2489     * to the array of cache'd record headers on this page. Finally return
2490     * reference to the initialized record header.
2491     *
2492     * @return The record header for the specific slot.
2493     *
2494     * @param slot return record header of this slot.
2495     *
2496     * @exception StandardException Standard exception policy.
2497     **/

2498    public StoredRecordHeader recordHeaderOnDemand(int slot)
2499    {
2500        StoredRecordHeader recordHeader =
2501            new StoredRecordHeader(pageData, getRecordOffset(slot));
2502
2503        setHeaderAtSlot(slot, recordHeader);
2504
2505        return recordHeader;
2506    }
2507
2508    /**************************************************************************
2509     * Record based routines.
2510     **************************************************************************
2511     */

2512
2513    /**
2514     * Is entire record on the page?
2515     * <p>
2516     *
2517     * @return true if the entire record at slot is on this page,
2518     * i.e, no overflow row or long columns.
2519     *
2520     * @param slot Check record at this slot.
2521     *
2522     * @exception StandardException Standard exception policy.
2523     **/

2524    public boolean entireRecordOnPage(int slot)
2525         throws StandardException
2526    {
2527        if (SanityManager.DEBUG)
2528        {
2529            SanityManager.ASSERT(isLatched());
2530        }
2531
2532        StoredRecordHeader recordHeader = getHeaderAtSlot(slot);
2533
2534        if (recordHeader.hasOverflow())
2535            return false;
2536
2537        // the row chain does not overflow, we need to walk all the fields to
2538
// make sure they are not long columns.
2539

2540        try
2541        {
2542
2543            int offset = getRecordOffset(slot);
2544        
2545            if (SanityManager.DEBUG)
2546            {
2547                if (offset < (PAGE_HEADER_OFFSET + PAGE_HEADER_SIZE))
2548                {
2549                    SanityManager.THROWASSERT(
2550                        "Incorrect offset. offset = " + offset +
2551                        ", offset should be < " +
2552                        "(PAGE_HEADER_OFFSET + PAGE_HEADER_SIZE) = " +
2553                             (PAGE_HEADER_OFFSET + PAGE_HEADER_SIZE) +
2554                        ", current slot = " + slot +
2555                        ", total slotsInUse = " + slotsInUse);
2556                }
2557
2558                SanityManager.ASSERT(recordHeader.getFirstField() == 0,
2559                     "Head row piece should start at field 0 but is not");
2560            }
2561
2562            int numberFields = recordHeader.getNumberFields();
2563
2564            // these reads are always against the page array
2565
ArrayInputStream lrdi = rawDataIn;
2566
2567            // position after the record header, at 1st column.
2568
lrdi.setPosition(offset + recordHeader.size());
2569        
2570            for (int i = 0; i < numberFields; i++)
2571            {
2572                int fieldStatus = StoredFieldHeader.readStatus(lrdi);
2573                if (StoredFieldHeader.isOverflow(fieldStatus))
2574                    return false;
2575
2576                int fieldLength =
2577                    StoredFieldHeader.readFieldDataLength(
2578                        lrdi, fieldStatus, slotFieldSize);
2579
2580                if (fieldLength != 0)
2581                    lrdi.setPosition(lrdi.getPosition() + fieldLength);
2582            }
2583        }
2584        catch (IOException JavaDoc ioe)
2585        {
2586            throw dataFactory.markCorrupt(
2587                StandardException.newException(
2588                    SQLState.DATA_CORRUPT_PAGE, ioe, getPageId()));
2589        }
2590
2591        // we have examined all the fields on this page and none overflows
2592
return true;
2593    }
2594
2595    /**
2596     * Purge one row on an overflow page.
2597     * <p>
2598     * HeadRowHandle is the recordHandle pointing to the head row piece.
2599     * <p>
2600     *
2601     * @param slot slot number of row to purge.
2602     * @param headRowHandle recordHandle of the head row piece.
2603     * @param needDataLogged when true data is logged for purges otherwise just headers.
2604     *
2605     * @exception StandardException Standard exception policy.
2606     **/

2607    protected void purgeOverflowAtSlot(
2608    int slot,
2609    RecordHandle headRowHandle,
2610    boolean needDataLogged)
2611         throws StandardException
2612    {
2613        if (SanityManager.DEBUG)
2614        {
2615            SanityManager.ASSERT(isLatched());
2616            SanityManager.ASSERT(isOverflowPage());
2617        }
2618
2619        if ((slot < 0) || (slot >= slotsInUse))
2620        {
2621            throw StandardException.newException(
2622                    SQLState.DATA_SLOT_NOT_ON_PAGE);
2623        }
2624
2625        // TODO (mikem) - should a global scratch variable be used?
2626

2627        // this is an overflow page purge, no need to lock the head row (it
2628
// has already been locked, hopefully). No need to check for long rows
2629
// (they have already been deleted, hopefully).
2630
RawTransaction t = owner.getTransaction();
2631        int[] recordId = new int[1];
2632
2633        recordId[0] = getHeaderAtSlot(slot).getId();
2634
2635        owner.getActionSet().actionPurge(t, this, slot, 1, recordId, needDataLogged);
2636    }
2637
2638    /**
2639     * Purge the column chain that starts at overflowPageId, overflowRecordId
2640     * <p>
2641     * Purge just the column chain that starts at the input address.
2642     * The long column chain is pointed at by a field in a row. The long
2643     * column is then chained as a sequence of "rows", the last column then
2644     * points to the next segment of the chain on each page.
2645     * Long columns chains currently are only one row per page so the next
2646     * slot of a row in a long row chain should always be the first slot.
2647     * <p>
2648     *
2649     * @param overflowPageId The page where the long column chain starts.
2650     * @param overflowRecordId The record id where long column chain starts.
2651     *
2652     * @exception StandardException Standard exception policy.
2653     **/

2654    private void purgeOneColumnChain(
2655    long overflowPageId,
2656    int overflowRecordId)
2657         throws StandardException
2658    {
2659        StoredPage pageOnColumnChain = null;
2660        boolean removePageHappened = false;
2661
2662        try
2663        {
2664            while (overflowPageId != ContainerHandle.INVALID_PAGE_NUMBER)
2665            {
2666
2667                // Now loop over the column chain and get all the column pieces.
2668
pageOnColumnChain = getOverflowPage(overflowPageId);
2669                removePageHappened = false;
2670
2671                if (pageOnColumnChain == null)
2672                {
2673                    if (SanityManager.DEBUG)
2674                        SanityManager.THROWASSERT(
2675                              "got null page following long column chain. " +
2676                                "Head column piece at " + getIdentity() +
2677                                " null page at " + overflowPageId);
2678
2679                    break; // Don't know what to do here, the column chain
2680
// is broken. Don't bomb, go to the next field.
2681
}
2682                    
2683                int overflowSlotId = FIRST_SLOT_NUMBER;
2684                if (SanityManager.DEBUG)
2685                {
2686                    int checkSlot =
2687                        pageOnColumnChain.findRecordById(
2688                                overflowRecordId, FIRST_SLOT_NUMBER);
2689
2690                    if (overflowSlotId != checkSlot)
2691                    {
2692                        SanityManager.THROWASSERT(
2693                            "Long column is not at the expected " +
2694                            FIRST_SLOT_NUMBER + " slot, instead at slot " +
2695                            checkSlot);
2696                    }
2697
2698                    SanityManager.ASSERT(pageOnColumnChain.recordCount() == 1,
2699                         "long column page has > 1 record");
2700                }
2701
2702                // Hold on to the pointer to next page on the chain before
2703
// we remove the long column page.
2704
RecordHandle nextColumnPiece =
2705                    pageOnColumnChain.getNextColumnPiece(overflowSlotId);
2706
2707                if (pageOnColumnChain.recordCount() == 1)
2708                {
2709                    removePageHappened = true;
2710                    owner.removePage(pageOnColumnChain);
2711                }
2712                else
2713                {
2714                    if (SanityManager.DEBUG)
2715                        SanityManager.THROWASSERT(
2716                          "page on column chain has more then one record" +
2717                          pageOnColumnChain.toString());
2718
2719                    pageOnColumnChain.unlatch();
2720                    pageOnColumnChain = null;
2721                }
2722
2723                // Chase the column chain pointer.
2724
if (nextColumnPiece != null)
2725                {
2726                    overflowPageId = nextColumnPiece.getPageNumber();
2727                    overflowRecordId = nextColumnPiece.getId();
2728                }
2729                else
2730                {
2731                    // terminate the loop
2732
overflowPageId = ContainerHandle.INVALID_PAGE_NUMBER;
2733                }
2734            }
2735        }
2736        finally
2737        {
2738            // if we raised an exception before the page is removed, make sure
2739
// we unlatch the page
2740

2741            if (!removePageHappened && pageOnColumnChain != null)
2742            {
2743                pageOnColumnChain.unlatch();
2744                pageOnColumnChain = null;
2745            }
2746        }
2747    }
2748
2749    /**
2750     * purge long columns chains which eminate from this page.
2751     * <p>
2752     * Purge all the long column chains emanating from the record on this slot
2753     * of this page. The headRowHandle is the record handle of the head row
2754     * piece of this row - if this page is the head row, then headRowHandle is
2755     * the record handle at the slot. Otherwise, headRowHandle points to a
2756     * row on a different page, i.e., the head page.
2757     * <p>
2758     *
2759     * @param t The raw transaction doing the purging.
2760     * @param slot The slot of the row to purge.
2761     * @param headRowHandle The RecordHandle of the head row.
2762     *
2763     *
2764     * @exception StandardException Standard exception policy.
2765     **/

2766    private void purgeColumnChains(
2767    RawTransaction t,
2768    int slot,
2769    RecordHandle headRowHandle)
2770         throws StandardException
2771    {
2772        try
2773        {
2774            StoredRecordHeader recordHeader = getHeaderAtSlot(slot);
2775
2776            int numberFields = recordHeader.getNumberFields();
2777
2778            // these reads are always against the page array
2779
ArrayInputStream lrdi = rawDataIn;
2780
2781            // position the stream to just after record header.
2782
int offset = getRecordOffset(slot) + recordHeader.size();
2783            lrdi.setPosition(offset);
2784
2785            for (int i = 0; i < numberFields; i++)
2786            {
2787                int fieldStatus = StoredFieldHeader.readStatus(lrdi);
2788                int fieldLength =
2789                    StoredFieldHeader.readFieldDataLength(
2790                        lrdi, fieldStatus, slotFieldSize);
2791
2792                if (!StoredFieldHeader.isOverflow(fieldStatus))
2793                {
2794                    // skip this field, it is not an long column
2795
if (fieldLength != 0)
2796                        lrdi.setPosition(lrdi.getPosition() + fieldLength);
2797                    continue;
2798                }
2799                else
2800                {
2801
2802                    // Got an overflow field. The column value is the
2803
// <pageId, recordId> pair where the next column piece is
2804
// residing
2805

2806                    long overflowPageId =
2807                        CompressedNumber.readLong((InputStream)lrdi);
2808                    int overflowRecordId =
2809                        CompressedNumber.readInt((InputStream)lrdi);
2810
2811                    purgeOneColumnChain(overflowPageId, overflowRecordId);
2812                }
2813            }
2814        }
2815        catch (IOException JavaDoc ioe)
2816        {
2817            throw dataFactory.markCorrupt(
2818                StandardException.newException(
2819                    SQLState.DATA_CORRUPT_PAGE, ioe, getPageId()));
2820        }
2821    }
2822
2823    /**
2824     * Purge all the overflow columns and overflow rows of the record at slot.
2825     * <p>
2826     * Purge all the overflow columns and overflow rows of the record at slot.
2827     * This is called by BasePage.purgeAtSlot, the head row piece is purged
2828     * there.
2829     * <p>
2830     *
2831     * @param t The raw transaction doing the purging.
2832     * @param slot The slot of the row to purge.
2833     * @param headRowHandle The RecordHandle of the head row.
2834     * @param needDataLogged when true data is logged for purges otherwise just headers.
2835     *
2836     * @exception StandardException Standard exception policy.
2837     **/

2838    protected void purgeRowPieces(
2839    RawTransaction t,
2840    int slot,
2841    RecordHandle headRowHandle,
2842    boolean needDataLogged)
2843         throws StandardException
2844    {
2845        if (SanityManager.DEBUG)
2846            SanityManager.ASSERT(isOverflowPage() == false,
2847                 "not expected to call purgeRowPieces on a overflow page");
2848
2849        // purge the long columns which start on this page.
2850
purgeColumnChains(t, slot, headRowHandle);
2851
2852        // drive this loop from the head page. Walk each "long" row piece in
2853
// the row chain.
2854
StoredRecordHeader recordHeader = getHeaderAtSlot(slot);
2855
2856        while (recordHeader.hasOverflow())
2857        {
2858
2859            // nextPageInRowChain, is the page with the next row piece
2860
StoredPage nextPageInRowChain =
2861                getOverflowPage(recordHeader.getOverflowPage());
2862
2863            if (nextPageInRowChain == null)
2864            {
2865                if (SanityManager.DEBUG)
2866                {
2867                    SanityManager.THROWASSERT(
2868                            "got null page following long row chain. " +
2869                            "Head row piece at " + getIdentity() + " slot " +
2870                            slot + " headRecord " + headRowHandle +
2871                            ". Broken row chain at " +
2872                            recordHeader.getOverflowPage() + ", " +
2873                            recordHeader.getOverflowId());
2874
2875                }
2876
2877                break; // Don't know what to do here, the row chain is
2878
// broken. Don't bomb, just return.
2879
}
2880
2881            try
2882            {
2883
2884                int nextPageSlot =
2885                    getOverflowSlot(nextPageInRowChain, recordHeader);
2886
2887                // First get rid of all long columns from the next row piece.
2888
nextPageInRowChain.purgeColumnChains(
2889                    t, nextPageSlot, headRowHandle);
2890
2891                // Before we purge the next row piece, get the row header to
2892
// see if we need to continue the loop.
2893
recordHeader = nextPageInRowChain.getHeaderAtSlot(nextPageSlot);
2894
2895                // Lastly, purge the next row piece. If the next row piece is
2896
// the only thing in the entire page, just deallocate the page.
2897
// We can do this because the page is deallocated in this
2898
// transaction. If we defer this to post commit processing,
2899
// then we have to first purge the row piece and also remember
2900
// the page time stamp.
2901

2902                if (nextPageSlot == 0 && nextPageInRowChain.recordCount() == 1)
2903                {
2904                    // This is an overflow page and we just purged the last row.
2905
// Free the page. Cannot do it in post commit because the
2906
// head row is gone and cannot be locked at post commit to
2907
// stablelize the row chain.
2908

2909                    try
2910                    {
2911                        owner.removePage(nextPageInRowChain);
2912                    }
2913                    finally
2914                    {
2915                        // Remove Page guarantees to unlatch the page even
2916
// if an exception is thrown, need not unlatch it
2917
// again.
2918
nextPageInRowChain = null;
2919                    }
2920                }
2921                else
2922                {
2923                    nextPageInRowChain.purgeOverflowAtSlot(
2924                        nextPageSlot, headRowHandle, needDataLogged);
2925
2926                    nextPageInRowChain.unlatch();
2927                    nextPageInRowChain = null;
2928                }
2929            }
2930            finally
2931            {
2932                // Unlatch the next row piece before getting the next page in
2933
// the row chain.
2934
if (nextPageInRowChain != null)
2935                {
2936                    nextPageInRowChain.unlatch();
2937                    nextPageInRowChain = null;
2938                }
2939            }
2940        }
2941    }
2942
2943
2944    /**
2945     * Remove a column chain that may have been orphaned by an update.
2946     * <p>
2947     * Remove a column chain that may have been orphaned by an update. This
2948     * is executed as a post commit operation. This page is the head page of
2949     * the row which used to point to the column chain in question. The
2950     * location of the orphaned column chain is in the ReclaimSpace record.
2951     * <BR>
2952     * MT - latched. No lock will be gotten, the head record must already be
2953     * locked exclusive with no outstanding changes that can be rolled back.
2954     * <p>
2955     *
2956     * @param work object describing the chain to remove.
2957     * @param containerHdl open container handle to use to remove chain.
2958     *
2959     * @exception StandardException Standard exception policy.
2960     **/

2961    /* package */
2962    void removeOrphanedColumnChain(
2963    ReclaimSpace work,
2964    ContainerHandle containerHdl)
2965         throws StandardException
2966    {
2967        // First we need to make sure that this is the first and only time
2968
// this long column is begin reclaimed, to do this we get the first
2969
// page on the long column chain and compare its page time stamp.
2970
// If it is different, don't do anything.
2971
//
2972
// Next we need to make sure the update operation commits - we do
2973
// this by finding the row headed by headRecord, go to the column
2974
// in question and see if it points to the first page of the long
2975
// column chain we want to reclaim. If it does then the update
2976
// operation has rolled back and we don't want to reclaim it.
2977
//
2978
// After we do the above 2 checks, we can reclaim the column
2979
// chain.
2980
StoredPage headOfChain =
2981            (StoredPage)containerHdl.getPageNoWait(work.getColumnPageId());
2982
2983        // If someone has it latched, not reclaimable
2984
if (headOfChain == null)
2985            return;
2986
2987        // If the column has been touched, it is not orphaned. Not reclaimable.
2988
boolean pageUnchanged =
2989            headOfChain.equalTimeStamp(work.getPageTimeStamp());
2990
2991        headOfChain.unlatch(); // unlatch it for now.
2992

2993        if (pageUnchanged == false)
2994            return;
2995
2996        // Now get to the column in question and make sure it is no longer
2997
// pointing to the column chain.
2998

2999        RecordHandle headRowHandle = work.getHeadRowHandle();
3000
3001        if (SanityManager.DEBUG)
3002        {
3003            // System.out.println("Executing in removeOrphanedColumnChain.");
3004
// System.out.println("work = " + work);
3005
// System.out.println("head = " + headOfChain);
3006
// System.out.println("this = " + this);
3007

3008            SanityManager.ASSERT(isLatched());
3009            SanityManager.ASSERT(
3010                headRowHandle.getPageNumber() == getPageNumber(),
3011                "got wrong head page");
3012        }
3013
3014        // First get the row.
3015
int slot =
3016            findRecordById(
3017                headRowHandle.getId(), headRowHandle.getSlotNumberHint());
3018
3019        // If slot < 0, it means the whole record is gone, the column chain is
3020
// definitely orphaned.
3021

3022        if (slot >= 0)
3023        {
3024            if (SanityManager.DEBUG)
3025            {
3026                if (isOverflowPage())
3027                {
3028                    SanityManager.THROWASSERT(
3029                        "Page " + getPageNumber() + " is overflow " +
3030                        "\nwork = " + work +
3031                        "\nhead = " + headOfChain +
3032                        "\nthis = " + this);
3033                }
3034            }
3035
3036            // Find the page with the column in question on it.
3037
StoredPage pageInRowChain = this; // Start with the head page.
3038

3039            try
3040            {
3041
3042                int columnId = work.getColumnId();
3043                StoredRecordHeader recordHeader = getHeaderAtSlot(slot);
3044
3045                if (SanityManager.DEBUG)
3046                    SanityManager.ASSERT(recordHeader.getFirstField() == 0,
3047                        "Head row piece should start at field 0 but is not");
3048
3049                // See if columnId is on pageInRowChain.
3050
while ((recordHeader.getNumberFields() +
3051                        recordHeader.getFirstField()) <= columnId)
3052                {
3053                    // The column in question is not on pageInRowChain.
3054

3055                    if (pageInRowChain != this)
3056                    {
3057                        // Keep the head page latched.
3058
pageInRowChain.unlatch();
3059                        pageInRowChain = null;
3060                    }
3061
3062                    if (recordHeader.hasOverflow())
3063                    {
3064                        // Go to the next row piece
3065
pageInRowChain =
3066                            getOverflowPage(recordHeader.getOverflowPage());
3067                        recordHeader =
3068                            pageInRowChain.getHeaderAtSlot(
3069                                getOverflowSlot(pageInRowChain, recordHeader));
3070                    }
3071                    else
3072                    {
3073                        // Don't know why, but this is the last column.
3074
// Anyway, the column chain is definite orphaned.
3075
// This can happen if the update, or subsequent
3076
// updates, shrink the number of columns in the row.
3077
break;
3078                    }
3079                }
3080
3081                if ((recordHeader.getNumberFields() +
3082                            recordHeader.getFirstField()) > columnId)
3083                {
3084                    // RecordHeader is the record header of the row piece on
3085
// pageInRowChain. The column in question exists and is in
3086
// that row piece.
3087
if (!pageInRowChain.isColumnOrphaned(
3088                            recordHeader, columnId,
3089                            work.getColumnPageId(), work.getColumnRecordId()))
3090                    {
3091                        // The column is not orphaned, row still points to it.
3092
if (pageInRowChain != this)
3093                        {
3094                            // Keep the head page latched.
3095
pageInRowChain.unlatch();
3096                            pageInRowChain = null;
3097                        }
3098                        return;
3099                    }
3100                }
3101
3102            }
3103            catch (IOException JavaDoc ioe)
3104            {
3105                throw StandardException.newException(
3106                        SQLState.DATA_UNEXPECTED_EXCEPTION, ioe);
3107            }
3108            finally
3109            {
3110                if (pageInRowChain != this && pageInRowChain != null)
3111                    pageInRowChain.unlatch();
3112            }
3113        }
3114
3115        // If we get this far, we have verified that the column chain is indeed
3116
// orphaned. Get rid of the column chain.
3117

3118        long nextPageId = work.getColumnPageId();
3119        int nextRecordId = work.getColumnRecordId();
3120
3121        purgeOneColumnChain(nextPageId, nextRecordId);
3122    }
3123
3124    /**
3125     * See if there is a orphaned long colum chain or not.
3126     * <p>
3127     * See if there is a orphaned long colum chain or not. This is a helper
3128     * function for removeOrphanedChain. This page, which may be a head page
3129     * or overflow page, contains the column specified in columnId. It used to
3130     * point to a long column chain at oldPageId and oldRecordId. Returns true
3131     * if it no longer points to that long column chain.
3132     * <p>
3133     *
3134     * @return true if page no longer points to the long column chain.
3135     *
3136     * @param recordHeader record header which used to point at the long column
3137     * @param columnId column id of the long column in head.
3138     * @param oldPageId the page id where the long column used to be.
3139     * @param oldRecordId the record id where the long column used to be.
3140     *
3141     * @exception StandardException Standard exception policy.
3142     **/

3143    private boolean isColumnOrphaned(
3144    StoredRecordHeader recordHeader,
3145    int columnId,
3146    long oldPageId,
3147    long oldRecordId)
3148         throws StandardException, IOException JavaDoc
3149    {
3150        int slot = findRecordById(recordHeader.getId(), Page.FIRST_SLOT_NUMBER);
3151
3152        if (SanityManager.DEBUG)
3153        {
3154            SanityManager.ASSERT(slot >= 0, "overflow row chain truncated");
3155
3156            SanityManager.ASSERT(
3157                columnId >= recordHeader.getFirstField(),
3158                "first column on page > expected");
3159        }
3160
3161        // these reads are always against the page array
3162
ArrayInputStream lrdi = rawDataIn;
3163
3164        // set read position to data portion of record to check.
3165
int offset = getRecordOffset(slot);
3166        lrdi.setPosition(offset + recordHeader.size());
3167
3168        // skip until you get to the record in question.
3169
for (int i = recordHeader.getFirstField(); i < columnId; i++)
3170            skipField(lrdi);
3171
3172        // read in the info of the column we are interested in.
3173
int fieldStatus = StoredFieldHeader.readStatus(lrdi);
3174        int fieldLength = StoredFieldHeader.readFieldDataLength
3175                (lrdi, fieldStatus, slotFieldSize);
3176
3177        if (StoredFieldHeader.isOverflow(fieldStatus))
3178        {
3179            // it is still an overflow field, check if it still points to
3180
// overflow column in question.
3181

3182            long ovflowPage = CompressedNumber.readLong((InputStream) lrdi);
3183            int ovflowRid = CompressedNumber.readInt((InputStream) lrdi);
3184
3185            if (ovflowPage == oldPageId && ovflowRid == oldRecordId)
3186            {
3187                // This field still points to the column chain, the
3188
// update must have rolled back.
3189
return false;
3190            }
3191        }
3192
3193        // Else, either the field is no longer a long column, or it doesn't
3194
// point to oldPageId, oldRecordId. The column chain is orphaned.
3195
return true;
3196    }
3197
3198    /**
3199        @return a recordHandle pointing to the next piece of the column chain.
3200        This page must be an overflow page that is in a column chain. If this
3201        is the last piece of the overflow colum, return null.
3202
3203        @param slot the slot number where the current piece of overflow column
3204        is at.
3205        @exception StandardException Cloudscape Standard Error Policy
3206     */

3207    /**
3208     * Return the next recordHandle in a long column chain.
3209     * <p>
3210     * Return a recordHandle pointing to the next piece of the column chain.
3211     * This page must be an overflow page that is in a column chain. If this
3212     * is the last piece of the overflow colum, return null.
3213     * <p>
3214     *
3215     * @return The next record handle in a long column chain.
3216     *
3217     * @param slot The slot of the current long column piece.
3218     *
3219     * @exception StandardException Standard exception policy.
3220     **/

3221    private RecordHandle getNextColumnPiece(int slot)
3222        throws StandardException
3223    {
3224        if (SanityManager.DEBUG)
3225        {
3226            SanityManager.ASSERT(isLatched());
3227            SanityManager.ASSERT(isOverflowPage(),
3228                "not expected to call getNextColumnPiece on non-overflow page");
3229
3230            if (recordCount() != 1)
3231            {
3232                SanityManager.THROWASSERT(
3233                    "getNextColumnPiece called on a page with " +
3234                    recordCount() + " rows");
3235            }
3236        }
3237
3238        try
3239        {
3240            StoredRecordHeader recordHeader = getHeaderAtSlot(slot);
3241            int numberFields =
3242                recordHeader.getNumberFields();
3243
3244            if (SanityManager.DEBUG)
3245            {
3246                if ((numberFields > 2) || (numberFields < 1))
3247                {
3248                    SanityManager.THROWASSERT(
3249                        "longColumn record header must have 1 or 2 fields." +
3250                        " numberFields = " + numberFields);
3251                }
3252            }
3253
3254            if (numberFields != 2) // End of column chain.
3255
return null;
3256
3257            // these reads are always against the page array
3258
ArrayInputStream lrdi = rawDataIn;
3259
3260            // The 2nd field is the pointer to the next page in column chain.
3261

3262            int offset = getRecordOffset(slot) + recordHeader.size();
3263            lrdi.setPosition(offset);
3264
3265            // skip the first field
3266
skipField(lrdi);
3267
3268            // the 2nd field should be <pageId, recordId> pair, return the
3269
// pageId part and skip over the length.
3270
int fieldStatus = StoredFieldHeader.readStatus(lrdi);
3271            int fieldLength = StoredFieldHeader.readFieldDataLength
3272                (lrdi, fieldStatus, slotFieldSize);
3273
3274            long ovflowPage = CompressedNumber.readLong((InputStream) lrdi);
3275            int ovflowRid = CompressedNumber.readInt((InputStream) lrdi);
3276
3277            if (SanityManager.DEBUG)
3278            {
3279                if (!StoredFieldHeader.isOverflow(fieldStatus))
3280                {
3281                    // In version 1.5, the first field is overflow and the
3282
// second is not. In version 2.0 onwards, the first field
3283
// is not overflow and the second is overflow (the overflow
3284
// bit goes with the overflow pointer). Check first field
3285
// to make sure its overflow bit is set on.
3286
// Offset still points to the first column.
3287
lrdi.setPosition(offset);
3288                    fieldStatus = StoredFieldHeader.readStatus(lrdi);
3289                    SanityManager.ASSERT(
3290                            StoredFieldHeader.isOverflow(fieldStatus));
3291                }
3292            }
3293
3294            // RESOLVE : this new can get expensive if the column chain is very
3295
// long. The reason we do this is because we need to return the
3296
// page number and the rid, if we assume that the long column is
3297
// always at slot 0, we can return only the page.
3298

3299            return owner.makeRecordHandle(ovflowPage, ovflowRid);
3300
3301        }
3302        catch (IOException JavaDoc ioe)
3303        {
3304            throw dataFactory.markCorrupt(
3305                StandardException.newException(
3306                    SQLState.DATA_CORRUPT_PAGE, ioe, getPageId()));
3307        }
3308    }
3309     
3310
3311    /**************************************************************************
3312     * Page space usage
3313     **************************************************************************
3314     */

3315
3316    /**
3317     * initialize the in memory variables associated with space maintenance.
3318     * <p>
3319     * Get the total available space on an empty page.
3320     * initSlotTable() must be called after the page has been read in.
3321     **/

3322    private void initSpace()
3323    {
3324        // NOTE: subclass may have overwitten it to report less freeSpace,
3325
// always call getMaxFreeSpace() to get total space.
3326
totalSpace = getMaxFreeSpace();
3327
3328        // estimate RH will be about 16 bytes:
3329
// (1 - status, 1 - id, 1 - #fields, 1 - 1stField, 12 - overflow ptr)
3330

3331        // RESOLVED: track# 3370, 3368
3332
// In the old code below, spareSpace/100 is integer division. This means
3333
// that you get a value of 0 for it as long as spareSpace is between 0
3334
// and 99. But if spareSpace is 100 you get a value of 1. This resulted
3335
// in a negative value for maxFieldSize. This caused e.g. the isLong
3336
// method to behave incorrectly when spareSpace is 100.
3337
//
3338
// RESOLVED: track# 4385
3339
// maxFieldSize is a worst case calculation for the size of a record
3340
// on an empty page, with a single field, but still allow room for
3341
// an overflow pointer if another field is to be added. If you don't
3342
// account for the overflow pointer then you can get into the situation
3343
// where the code puts the field on the page (not making it a long
3344
// column), then runs out of space on next column but can't fit overflow
3345
// pointer, so backs up and removes the column from page, and tries
3346
// again on next overflow page - looping forever.
3347
//
3348
// maxFieldSize =
3349
// totalSpace * (1 - spareSpace/100) - slotEntrySize
3350
// - 16 - OVERFLOW_POINTER_SIZE;
3351

3352        maxFieldSize = totalSpace - slotEntrySize - 16 - OVERFLOW_POINTER_SIZE;
3353
3354        if (SanityManager.DEBUG)
3355            SanityManager.ASSERT(maxFieldSize >= 0);
3356    }
3357
3358    /**
3359     * Initialize the freeSpace count and set the firstFreeByte on page
3360     **/

3361    private void clearAllSpace()
3362    {
3363        freeSpace = totalSpace;
3364        firstFreeByte = getPageSize() - totalSpace - CHECKSUM_SIZE;
3365    }
3366
3367    /**
3368     * Compress out the space specified by startByte and endByte.
3369     * <p>
3370     * As part of moving rows, updating rows, purging rows compact the space
3371     * left between rows.
3372     * <p>
3373     *
3374     * @param startByte compress out space starting at startByte offset
3375     * @param endByte compress out space ending at endByte offset
3376     *
3377     **/

3378    private void compressPage(
3379    int startByte,
3380    int endByte)
3381        throws IOException JavaDoc
3382    {
3383        if (SanityManager.DEBUG)
3384        {
3385            if (((endByte + 1) > firstFreeByte) || (startByte > firstFreeByte))
3386            {
3387                SanityManager.THROWASSERT(
3388                    "startByte = " + startByte + " endByte = " + endByte +
3389                    " firstFreeByte = " + firstFreeByte);
3390            }
3391        }
3392
3393        int lengthToClear = endByte + 1 - startByte;
3394
3395        // see if these were not the last occupied record space on the page
3396
if ((endByte + 1) != firstFreeByte)
3397        {
3398            // Shift everything down the page.
3399
int moveLength = (firstFreeByte - endByte - 1);
3400
3401            System.arraycopy(
3402                pageData, (endByte + 1), pageData, startByte, moveLength);
3403
3404            // fix the page offsets of the rows further down the page
3405
for (int slot = 0; slot < slotsInUse; slot++)
3406            {
3407                int offset = getRecordOffset(slot);
3408
3409                if (offset >= (endByte + 1))
3410                {
3411                    offset -= lengthToClear;
3412                    setRecordOffset(slot, offset);
3413                }
3414            }
3415        }
3416        
3417        freeSpace += lengthToClear;
3418        firstFreeByte -= lengthToClear;
3419
3420        clearSection(firstFreeByte, lengthToClear);
3421    }
3422
3423    /**
3424     * Free up required bytes by shifting rows "down" the page.
3425     * <p>
3426     * Expand page, move all the data from start Offset down the page by
3427     * the amount required to free up the required bytes.
3428     *
3429     * @param startOffset offset on page to begin the shift
3430     * @param requiredBytes the number of bytes that must be freed.
3431     *
3432     * @exception IOException If IOException is raised during the page mod.
3433     **/

3434    protected void expandPage(
3435    int startOffset,
3436    int requiredBytes)
3437        throws IOException JavaDoc
3438    {
3439        if (SanityManager.DEBUG)
3440        {
3441            SanityManager.ASSERT(requiredBytes <= freeSpace);
3442            SanityManager.ASSERT(startOffset <= firstFreeByte);
3443        }
3444
3445        int totalLength = firstFreeByte - startOffset;
3446
3447        if (totalLength > 0)
3448        {
3449            System.arraycopy(
3450                pageData, startOffset,
3451                pageData, startOffset + requiredBytes, totalLength);
3452
3453            // fix the page offsets of the rows further down the page
3454
for (int slot = 0; slot < slotsInUse; slot++)
3455            {
3456                int offset = getRecordOffset(slot);
3457                if (offset >= startOffset)
3458                {
3459                    offset += requiredBytes;
3460                    setRecordOffset(slot, offset);
3461                }
3462            }
3463        }
3464
3465        freeSpace -= requiredBytes;
3466        firstFreeByte += requiredBytes;
3467    }
3468
3469    /**
3470     * Shrink page.
3471     * <p>
3472     * move all the data from start Offset up the page by the amount shrunk.
3473     *
3474     *
3475     * @param startOffset offset on page to begin the shift
3476     * @param shrinkBytes the number of bytes that must be moved.
3477     *
3478     * @exception IOException some IOException is raised during the page mod,
3479     * (unlikely as this is just writing to array).
3480     **/

3481    private void shrinkPage(int startOffset, int shrinkBytes)
3482         throws IOException JavaDoc
3483    {
3484        // the number of bytes that needs to be moved up.
3485
int totalLength = firstFreeByte - startOffset;
3486
3487        if (SanityManager.DEBUG)
3488        {
3489            SanityManager.DEBUG(
3490                "shrinkPage", "page " + getIdentity() +
3491                " shrinking " + shrinkBytes +
3492                " from offset " + startOffset +
3493                " to offset " + (startOffset-shrinkBytes) +
3494                " moving " + totalLength +
3495                " bytes. FirstFreeByte at " + firstFreeByte);
3496
3497            SanityManager.ASSERT(
3498                totalLength >= 0, "firstFreeByte - startOffset <= 0");
3499
3500            SanityManager.ASSERT(
3501                (startOffset-shrinkBytes) > RECORD_SPACE_OFFSET ,
3502                "shrinking too much ");
3503
3504            if (startOffset != firstFreeByte)
3505            {
3506                // make sure startOffset is at the beginning of a record
3507
boolean foundslot = false;
3508                for (int slot = 0; slot < slotsInUse; slot++)
3509                {
3510                    if (getRecordOffset(slot) == startOffset)
3511                    {
3512                        foundslot = true;
3513                        break;
3514                    }
3515                }
3516
3517                if (!foundslot)
3518                {
3519                    SanityManager.THROWASSERT(
3520                        "startOffset " + startOffset +
3521                        " not at the beginning of a record");
3522                }
3523            }
3524        }
3525
3526        if (totalLength > 0)
3527        {
3528            System.arraycopy(
3529                pageData, startOffset,
3530                pageData, startOffset-shrinkBytes , totalLength);
3531
3532            // fix the page offsets of the rows further down the page
3533
for (int slot = 0; slot < slotsInUse; slot++)
3534            {
3535                int offset = getRecordOffset(slot);
3536                if (offset >= startOffset)
3537                {
3538                    offset -= shrinkBytes;
3539                    setRecordOffset(slot, offset);
3540                }
3541            }
3542        }
3543
3544        freeSpace += shrinkBytes;
3545        firstFreeByte -= shrinkBytes;
3546    }
3547
3548    public int getRecordLength(int slot) throws IOException JavaDoc
3549    {
3550        return getRecordPortionLength(slot);
3551    }
3552    protected boolean getIsOverflow(int slot) throws IOException JavaDoc
3553    {
3554        return getHeaderAtSlot(slot).hasOverflow();
3555    }
3556
3557    /**
3558        Log a row into the StoreOuput stream.
3559
3560        <P>
3561
3562        @exception StandardException Standard Cloudscape error policy
3563        @exception IOException RESOLVE
3564
3565    */

3566    /**
3567     * Log a row into the StoreOuput stream.
3568     * <p>
3569     * Write the row in its record format to the stream. Record format is a
3570     * record header followed by each field with its field header. See this
3571     * class's description for the specifics of these headers.
3572     *
3573     * startColumn is used to specified which column for this logRow to
3574     * start logging. When realStartColumn is specified, that means part of
3575     * the row has already been logged. startColumn here indicates that the
3576     * first column was logged in the logBuffer, need to continue log the rest
3577     * of the row starting at realStartColumn.
3578     *
3579     * This is used when a longColumn is encountered during a long row.
3580     * After done logging the long column, we need to continue logging the
3581     * rest of the row.
3582     * A -1 value for realStartColumn, means that it is not significant.
3583     *
3584     * logRow will not throw an noSpaceOnPage exception, if it is an overflow
3585     * page, and the record we are inserting is the only record on the page.
3586     * We are supporting rows expanding multiple pages through this mechanism.
3587     *
3588     * logRow expects row to be a sparse row.
3589     * <p>
3590     *
3591     * @return the "realStartColumn" value, -1 if not a long row.
3592     *
3593     * @param slot the slot of the row being logged.
3594     * @param forInsert this is logging an insert (not update/delete).
3595     * @param recordId record id of the row being logged.
3596     * @param row actual data of row in object form. If row is
3597     * null then we are logging an overflow pointer.
3598     * @param validColumns bit map describing valid columns in row.
3599     * @param out stream to log to.
3600     * @param startColumn what column to start with (see above for detail)
3601     * @param insertFlag flag indicating mode we are in,
3602     * INSERT_DEFAULT - default insert
3603     * INSERT_SPLIT - splitting a row/column
3604     * across pages.
3605     * @param realStartColumn If -1 ignore variable, else part of row has
3606     * already been logged, and should continue with
3607     * this column.
3608     * @param realSpaceOnPage Use this as space on page if realStartColumn
3609     * is not -1.
3610     * @param overflowThreshold How much of the page to use before deciding
3611     * to overflow a row.
3612     *
3613     * @exception IOException RESOLVE
3614     * @exception StandardException Standard exception policy.
3615     *
3616     * @see BasePage#logRow
3617     **/

3618    public int logRow(
3619    int slot,
3620    boolean forInsert,
3621    int recordId,
3622    Object JavaDoc[] row,
3623    FormatableBitSet validColumns,
3624    DynamicByteArrayOutputStream out,
3625    int startColumn,
3626    byte insertFlag,
3627    int realStartColumn,
3628    int realSpaceOnPage,
3629    int overflowThreshold)
3630        throws StandardException, IOException JavaDoc
3631    {
3632        // Is this an update that just went through handleIncompleteLogRow
3633
// and handleIncompleteLogRow threw an excepiton. In this case the
3634
// buffer is already finished.
3635
if (!forInsert)
3636        {
3637            if ((realStartColumn != -1) && (realSpaceOnPage == -1))
3638            {
3639                return realStartColumn;
3640            }
3641        }
3642
3643        int spaceAvailable = freeSpace;
3644        setOutputStream(out);
3645        int beginPosition = out.getPosition();
3646
3647        // if we are inserting in the headPage,
3648
// we need to make sure that there is enough room
3649
// on the page for the reserve space.
3650
userRowSize = 0;
3651        boolean calcMinimumRecordSize = false;
3652
3653        if (realStartColumn != (-1))
3654        {
3655            // in the middle of logging a long row/column.
3656

3657            spaceAvailable = realSpaceOnPage;
3658            beginPosition = out.getBeginPosition();
3659        }
3660        else
3661        {
3662            // logging row part that is on head page.
3663

3664            if (!forInsert)
3665            {
3666                // an update can use the total space of the record,
3667
// even if not all of the fields are being updated.
3668
// If the updated columns will not fit then some
3669
// columns will move off the page to a new chunk.
3670
spaceAvailable += getTotalSpace(slot);
3671
3672            }
3673            else
3674            {
3675                // need to account for the slot table using extra space...
3676
spaceAvailable -= slotEntrySize;
3677
3678                if (startColumn == 0)
3679                    calcMinimumRecordSize = true;
3680            }
3681
3682            // <= is ok here as we know we want to write at least one more byte
3683
if (spaceAvailable <= 0)
3684                throw new NoSpaceOnPage(isOverflowPage());
3685        }
3686
3687        try
3688        {
3689            if (row == null)
3690            {
3691                // if the row is null, we must be writing an overflow pointer.
3692

3693                return(logOverflowRecord(slot, spaceAvailable, out));
3694            }
3695
3696            int numberFields = 0;
3697            StoredRecordHeader recordHeader;
3698
3699            if (forInsert)
3700            {
3701                recordHeader = new StoredRecordHeader();
3702            }
3703            else
3704            {
3705                // Get a full copy of the record header since we might change
3706
// it, and we can't modify the one on the page
3707
recordHeader =
3708                    new StoredRecordHeader(getHeaderAtSlot(slot));
3709
3710                // an update always starts at the first column on this page
3711
startColumn = recordHeader.getFirstField();
3712            }
3713
3714            if (validColumns == null)
3715            {
3716                // all columns in row[] are valid, we will be logging them all.
3717

3718                numberFields = row.length - startColumn;
3719            }
3720            else
3721            {
3722                // RESOLVE (mikem) - counting on validColumns.length may be bad
3723
// for performance.
3724

3725                for (int i = validColumns.getLength() - 1;
3726                     i >= startColumn;
3727                     i--)
3728                {
3729                    if (validColumns.isSet(i))
3730                    {
3731                        numberFields = i + 1 - startColumn;
3732                        break;
3733                    }
3734                }
3735            }
3736
3737            int onPageNumberFields = -1; // only valid for update
3738

3739            if (forInsert)
3740            {
3741                recordHeader.setId(recordId);
3742                recordHeader.setNumberFields(numberFields);
3743            }
3744            else
3745            {
3746                // an update
3747

3748                onPageNumberFields = recordHeader.getNumberFields();
3749
3750                if (numberFields > onPageNumberFields)
3751                {
3752                    // number of fields *might* be increasing
3753
if (recordHeader.hasOverflow())
3754                    {
3755                        // other fields will be handled in next portion update
3756

3757                        numberFields = onPageNumberFields;
3758                    }
3759                    else
3760                    {
3761                        // number of fields is increasing
3762

3763                        recordHeader.setNumberFields(numberFields);
3764                    }
3765                }
3766                else if (numberFields < onPageNumberFields)
3767                {
3768                    if (validColumns == null)
3769                    {
3770                        // number of fields is decreasing,
3771
// but only allowed when the complete
3772
// row is being updated.
3773
recordHeader.setNumberFields(numberFields);
3774
3775                        // RESOLVE -
3776
// need some post commit work if row has overflow
3777

3778                        // if (recordHeader.hasOverflow()) {
3779
// remove overflow portion after commit.
3780
// }
3781

3782                    }
3783                    else
3784                    {
3785                        // we process all the fields, the unchanged ones
3786
// at the end will have a single byte written out
3787
// indicating they are unchanged (nonexistent)
3788
numberFields = onPageNumberFields;
3789                    }
3790                }
3791            }
3792
3793            int endFieldExclusive = startColumn + numberFields;
3794
3795            if (realStartColumn >= endFieldExclusive)
3796            {
3797                // The realStartColumn is greater than the last column we need
3798
// to log, so we are done.
3799
return (-1);
3800            }
3801
3802            if ((insertFlag & Page.INSERT_DEFAULT) != Page.INSERT_DEFAULT)
3803            {
3804                // if this is not logging the part of the row being inserted
3805
// on the main page, then use startColumn as first field.
3806
recordHeader.setFirstField(startColumn);
3807            }
3808
3809            // what column to start with?
3810

3811            int firstColumn = realStartColumn;
3812            if (realStartColumn == (-1))
3813            {
3814                // logging on the head page.
3815

3816                int recordHeaderLength = recordHeader.write(logicalDataOut);
3817
3818                spaceAvailable -= recordHeaderLength;
3819                if (spaceAvailable < 0)
3820                {
3821                    // ran out of space just writing the record header.
3822
throw new NoSpaceOnPage(isOverflowPage());
3823                }
3824
3825                firstColumn = startColumn;
3826            }
3827
3828
3829            boolean monitoringOldFields = false;
3830            int validColumnsSize =
3831                (validColumns == null) ? 0 : validColumns.getLength();
3832            
3833            if (validColumns != null)
3834            {
3835                if (!forInsert)
3836                {
3837                    // we monitor the length of the old fields by skipping them
3838
// but only on a partial update.
3839
if ((validColumns != null) &&
3840                        (firstColumn < (startColumn + onPageNumberFields)))
3841                    {
3842                        rawDataIn.setPosition(
3843                            getFieldOffset(slot, firstColumn));
3844
3845                        monitoringOldFields = true;
3846                    }
3847                }
3848            }
3849
3850            int lastSpaceAvailable = spaceAvailable;
3851            int recordSize = 0;
3852            int lastColumnPositionAllowOverflow = out.getPosition();
3853            int lastColumnAllowOverflow = startColumn;
3854
3855            if (spaceAvailable > OVERFLOW_POINTER_SIZE)
3856                lastColumnPositionAllowOverflow = -1;
3857            int columnFlag = COLUMN_FIRST;
3858
3859            for (int i = firstColumn; i < endFieldExclusive; i++)
3860            {
3861                Object JavaDoc ref = null;
3862                boolean ignoreColumn = false;
3863
3864
3865                // should we log this column or not?
3866
if ((validColumns == null) ||
3867                    (validColumnsSize > i && validColumns.isSet(i)))
3868                {
3869                    if (i < row.length)
3870                        ref = row[i];
3871                }
3872                else if (!forInsert)
3873                {
3874                    // field is not supplied, log as non-existent
3875
ignoreColumn = true;
3876                }
3877
3878                if (spaceAvailable > OVERFLOW_POINTER_SIZE)
3879                {
3880                    lastColumnPositionAllowOverflow = out.getPosition();
3881                    lastColumnAllowOverflow = i;
3882                }
3883
3884                lastSpaceAvailable = spaceAvailable;
3885
3886                if (ignoreColumn)
3887                {
3888                    if (SanityManager.DEBUG)
3889                    {
3890                        SanityManager.ASSERT(
3891                            ref == null,
3892                            "ref should be null for an ignored column");
3893
3894                        SanityManager.ASSERT(
3895                            validColumns != null,
3896                            "validColumns should be non-null for ignored col");
3897                    }
3898
3899                    if (i < (startColumn + onPageNumberFields))
3900                    {
3901                        if (SanityManager.DEBUG)
3902                        {
3903                            SanityManager.ASSERT(
3904                                monitoringOldFields,
3905                                "monitoringOldFields must be true");
3906                        }
3907
3908                        // need to keep track of the old field lengths
3909
// as they are remaining in the row.
3910
int oldOffset = rawDataIn.getPosition();
3911                        skipField(rawDataIn);
3912                        int oldFieldLength =
3913                            rawDataIn.getPosition() - oldOffset;
3914
3915                        if (oldFieldLength <= spaceAvailable)
3916                        {
3917                            // if field doesn't fit,
3918
// spaceAvailable must be left unchanged.
3919

3920                            logColumn(
3921                                null, 0, out, Integer.MAX_VALUE,
3922                                COLUMN_NONE, overflowThreshold);
3923
3924                            spaceAvailable -= oldFieldLength;
3925                        }
3926
3927                    }
3928                    else
3929                    {
3930                        // this is an update that is increasing the number of
3931
// columns but not providing any value, strange ...
3932

3933                        spaceAvailable =
3934                            logColumn(
3935                                null, 0, out, spaceAvailable,
3936                                columnFlag, overflowThreshold);
3937                    }
3938
3939                }
3940                else
3941                {
3942                    // ignoreColumn is false, we are logging this column.
3943

3944                    if (monitoringOldFields &&
3945                        (i < (startColumn + onPageNumberFields)))
3946                    {
3947                        // skip the old version of the field so that
3948
// rawDataIn is correctly positioned.
3949
skipField(rawDataIn);
3950                    }
3951
3952
3953                    try
3954                    {
3955                        if (ref == null)
3956                        {
3957                            // no new value to provide, use the on page value.
3958
spaceAvailable =
3959                                logColumn(
3960                                    null, 0, out, spaceAvailable,
3961                                    columnFlag, overflowThreshold);
3962                        }
3963                        else
3964                        {
3965                            // log the value provided in the row[i]
3966
spaceAvailable =
3967                                logColumn(
3968                                    row, i, out, spaceAvailable,
3969                                    columnFlag, overflowThreshold);
3970                        }
3971
3972                    }
3973                    catch (LongColumnException lce)
3974                    {
3975                        // logColumn determined that the column would not fit
3976
// and that the column length exceeded the long column
3977
// threshold so turn this column into a long column.
3978

3979
3980                        if ((insertFlag & Page.INSERT_DEFAULT) ==
3981                                Page.INSERT_DEFAULT)
3982                        {
3983                            // if default insert, just throw no space exception.
3984

3985                            // if the lce has throw the column as an InputStream,
3986
// in the following 2 situations
3987
// 1. If column came in 'row[i]' as InputStream
3988
// 2. If the object stream of 'row[i]' is not
3989
// null, which means that the object state of
3990
// the column is null.
3991
//
3992
// we need to set the original InputStream column to
3993
// the column that has been thrown by lce. It is a
3994
// store formated InputStream which remembers all
3995
// the bytes that has been read, but not yet stored.
3996
// Therefore, we will not lose any bytes.
3997
//
3998
// In any other situation, we should not change the
3999
// state of the column,
4000
// i.e. if 'row[i]' has an object state, it should
4001
// not be turned into an InputStream.
4002

4003                            if ((lce.getColumn() instanceof InputStream)
4004                                    && (row[i] instanceof StreamStorable) )
4005                            {
4006                                if ((row[i] instanceof InputStream) ||
4007                                    (((StreamStorable) row[i]).returnStream()
4008                                         != null) )
4009                                {
4010                                    // change state of stream so that it uses
4011
// the stream just created by the lce -
4012
// which is remembering the bytes it has
4013
// already read from the stream but couldn't
4014
// log as there was not enough room on
4015
// current page.
4016

4017                                    ((StreamStorable) row[i]).setStream(
4018                                                (InputStream) lce.getColumn());
4019                                }
4020                            }
4021
4022                            throw new NoSpaceOnPage(isOverflowPage());
4023                        }
4024
4025                        // When one of the following two conditions is true,
4026
// we will allow the insert of the long column:
4027
//
4028
// 1. if this is the last field,
4029
// and overflow field header fits on page.
4030
// 2. if it is not the last field,
4031
// and overflow field header fits on page (for col)
4032
// and another overflow ptr fits (for row).
4033
//
4034
//
4035

4036                        if (((spaceAvailable >= OVERFLOW_PTR_FIELD_SIZE) &&
4037                             (i == (endFieldExclusive - 1))) ||
4038                            ((spaceAvailable >= (OVERFLOW_PTR_FIELD_SIZE * 2))&&
4039                             (i < (endFieldExclusive - 1))))
4040                        {
4041                            // If the column is a long column, it must be a
4042
// InputStream. We have made the input stream into
4043
// a RememberBytesInputStream, have to set the
4044
// column to that, in order to preserve the bytes
4045
// we already read off the stream.
4046

4047                            // caught a long column exception,
4048
// set the variables, and rethrow the error
4049
out.setBeginPosition(beginPosition);
4050                            lce.setExceptionInfo(out, i, spaceAvailable);
4051                            throw (lce);
4052                        }
4053                    }
4054                }
4055
4056                int nextColumn;
4057
4058                recordSize += (lastSpaceAvailable - spaceAvailable);
4059                boolean recordIsLong =
4060                    (overflowThreshold == 100) ?
4061                        false : isLong(recordSize, overflowThreshold);
4062
4063                // get the no overflow case out of the way asap
4064
if ((lastSpaceAvailable == spaceAvailable) || recordIsLong)
4065                {
4066                    if ((insertFlag & Page.INSERT_DEFAULT) ==
4067                            Page.INSERT_DEFAULT)
4068                    {
4069                        throw new NoSpaceOnPage(isOverflowPage());
4070                    }
4071
4072                    if (recordIsLong)
4073                    {
4074                        // if the record is long because of threshold,
4075
// then, we need to reset the logicalOut.
4076
// set position to the end of the previous field
4077

4078                        out.setPosition(out.getPosition() - recordSize);
4079                    }
4080
4081                    // did not write this column
4082
nextColumn = i;
4083                }
4084                else
4085                {
4086                    // assume that all fields will be written to this page.
4087
nextColumn = endFieldExclusive;
4088                }
4089
4090                // See if we have enough room to write an overflow field if the
4091
// row needs to overflow. We need overflow if we need to
4092
// write another portion or another portion already exists and
4093
// we will need to point to it.
4094

4095                if ((lastSpaceAvailable == spaceAvailable) ||
4096                    ((insertFlag & Page.INSERT_FOR_SPLIT) ==
4097                         Page.INSERT_FOR_SPLIT))
4098                {
4099                    // The current row has filled the page.
4100

4101                    if (spaceAvailable <= OVERFLOW_POINTER_SIZE)
4102                    {
4103                        if ((i == startColumn) ||
4104                            (lastColumnPositionAllowOverflow < 0))
4105                        {
4106                            // not enough room for the overflow recordheader,
4107
// and this is the first column on this page so
4108
// need to try another page.
4109
throw new NoSpaceOnPage(isOverflowPage());
4110                        }
4111                        else
4112                        {
4113                            // we need to go back to the last column
4114
// that left enough room for an overflow pointer.
4115

4116                            out.setPosition(lastColumnPositionAllowOverflow);
4117                            nextColumn = lastColumnAllowOverflow;
4118                        }
4119                    }
4120                }
4121
4122                if (nextColumn < endFieldExclusive)
4123                {
4124                    // If the number of cols has been reduced.
4125

4126                    int actualNumberFields = nextColumn - startColumn;
4127
4128                    // go back and update that numberFields in recordHeader.
4129
// no need to update spaceAvailable here, because if we are
4130
// here, we will be returning any way, and spaceAvailable
4131
// will be thrown away.
4132

4133                    int oldSize = recordHeader.size();
4134                    recordHeader.setNumberFields(actualNumberFields);
4135
4136                    int newSize = recordHeader.size();
4137                    
4138                    // now we are ready to write the new record header.
4139
int endPosition = out.getPosition();
4140
4141                    if (oldSize > newSize)
4142                    {
4143                        // if the old size is bigger than the new size, then
4144
// leave extra bytes at the beginning of byte stream.
4145

4146                        int delta = oldSize - newSize;
4147                        out.setBeginPosition(beginPosition + delta);
4148                        out.setPosition(beginPosition + delta);
4149                    }
4150                    else if (newSize > oldSize)
4151                    {
4152                        out.setPosition(beginPosition);
4153
4154                    }
4155                    else
4156                    {
4157                        out.setBeginPosition(beginPosition);
4158                        out.setPosition(beginPosition);
4159                    }
4160
4161                    int realLen = recordHeader.write(logicalDataOut);
4162                    if (SanityManager.DEBUG)
4163                    {
4164                        if ((realLen + (oldSize - newSize)) != oldSize)
4165                        {
4166                            SanityManager.THROWASSERT(
4167                                "recordHeader size incorrect. realLen = " +
4168                                realLen + ", delta = " +
4169                                (oldSize - newSize) + ", oldSize = " + oldSize);
4170                        }
4171                    }
4172
4173                    out.setPosition(endPosition);
4174
4175                    if (!forInsert)
4176                    {
4177                        // The update is incomplete, fields beyond this
4178
// point will have to move off the page. For any fields
4179
// that are not being updated we have to save their
4180
// values from this page to insert into an overflow
4181
// portion.
4182
//
4183
// When the complete row is being updated there is no
4184
// need to save any fields so just return.
4185
if (validColumns != null)
4186                        {
4187                            handleIncompleteLogRow(
4188                                slot, nextColumn, validColumns, out);
4189                        }
4190                    }
4191
4192                    return (nextColumn);
4193                }
4194                
4195                columnFlag = COLUMN_NONE;
4196            }
4197
4198            out.setBeginPosition(beginPosition);
4199            startColumn = -1;
4200
4201            if ((calcMinimumRecordSize) &&
4202                (spaceAvailable < (minimumRecordSize - userRowSize)))
4203            {
4204                throw new NoSpaceOnPage(isOverflowPage());
4205            }
4206
4207        }
4208        finally
4209        {
4210            resetOutputStream();
4211        }
4212
4213        return (startColumn);
4214    }
4215
4216    /**
4217     * Handle an update of a record portion that is incomplete.
4218     * <p>
4219     * Handle an update of a record portion that is incomplete.
4220     * Ie. Columns have expanded that require other columns to move
4221     * off the page into a new portion.
4222     * <P>
4223     * This method works out of the columns that need to be moved which are not
4224     * being updated and makes a copy of their data. It then throws an
4225     * exception with this data, much like the long column exception which will
4226     * then allow the original insert to complete.
4227     * <P>
4228     * If no columns need to be saved (ie all the ones that would move are
4229     * being updated) then no exception is thrown, logRow() will return and the
4230     * update completes normally.
4231     * <p>
4232     *
4233     * @param slot slot of the current update.
4234     * @param startColumn column to start at, handles start in middle of row
4235     * @param columnList bit map indicating which columns are being updated.
4236     * @param out place to lot to.
4237     *
4238     * @exception StandardException Standard exception policy.
4239     **/

4240    private void handleIncompleteLogRow(
4241    int slot,
4242    int startColumn,
4243    FormatableBitSet columnList,
4244    DynamicByteArrayOutputStream out)
4245        throws StandardException
4246    {
4247        if (SanityManager.DEBUG)
4248            SanityManager.ASSERT(columnList != null);
4249
4250        StoredRecordHeader rh = getHeaderAtSlot(slot);
4251
4252        int endFieldExclusive = rh.getFirstField() + rh.getNumberFields();
4253
4254        // first see if any fields are not being modified
4255
boolean needSave = false;
4256        int columnListSize = columnList.size();
4257        for (int i = startColumn; i < endFieldExclusive; i++)
4258        {
4259            if (!(columnListSize > i && columnList.get(i)))
4260            {
4261                needSave = true;
4262                break;
4263            }
4264        }
4265        if (!needSave)
4266            return;
4267
4268        Object JavaDoc[] savedFields =
4269            new Object JavaDoc[endFieldExclusive - startColumn];
4270
4271        ByteArrayOutputStream fieldStream = null;
4272
4273        for (int i = startColumn; i < endFieldExclusive; i++)
4274        {
4275            // row is being updated - ignore
4276
if (columnListSize > i && columnList.get(i))
4277                continue;
4278
4279            // save the data
4280

4281            try
4282            {
4283                // use the old value - we use logField to ensure that we
4284
// get the raw contents of the field and don't follow
4285
// any long columns. In addition we save this as a RawField
4286
// so that we preserve the state of the field header.
4287
if (fieldStream == null)
4288                    fieldStream = new ByteArrayOutputStream();
4289                else
4290                    fieldStream.reset();
4291
4292                logField(slot, i, fieldStream);
4293
4294                savedFields[i - startColumn] =
4295                    new RawField(fieldStream.toByteArray());
4296
4297            }
4298            catch (IOException JavaDoc ioe)
4299            {
4300                throw dataFactory.markCorrupt(
4301                    StandardException.newException(
4302                        SQLState.DATA_CORRUPT_PAGE, ioe, getPageId()));
4303            }
4304        }
4305
4306        // Use a long column exception to notify the caller of the need
4307
// to perform an insert of the columns that need to move
4308

4309        LongColumnException lce = new LongColumnException();
4310        lce.setExceptionInfo(
4311            out, startColumn, -1 /* indicates not actual long column */);
4312        lce.setColumn(savedFields);
4313
4314        throw lce;
4315    }
4316
4317    /**
4318
4319        @param row (IN/OUT) the row that is to be restored (sparse representation)
4320        @param limitInput the limit input stream
4321        @param objectInput the object input stream
4322
4323        @exception StandardException Standard Cloudscape error policy
4324        @exception IOException I/O exception in reading meta data.
4325    */

4326
4327    /**
4328     * Restore a storable row from a LimitInputStream.
4329     * <p>
4330     * Restore a storable row from an LimitInputStream - user must supply two
4331     * streams on top of the same data, one implements ObjectInput interface
4332     * that knows how to restore the object, the other one implements
4333     * LimitInputStream.
4334     * <p>
4335     * @param in the limit input stream
4336     * @param row (IN/OUT) row that is to be restored
4337     * (sparse representation)
4338     *
4339     * @exception StandardException Standard exception policy.
4340     **/

4341    public void restoreRecordFromStream(
4342    LimitObjectInput in,
4343    Object JavaDoc[] row)
4344        throws StandardException, IOException JavaDoc
4345    {
4346
4347        StoredRecordHeader recordHeader = new StoredRecordHeader();
4348        recordHeader.read(in);
4349        readRecordFromStream(
4350            row,
4351            row.length - 1,
4352            (int[]) null,
4353            (int[]) null,
4354            in,
4355            recordHeader,
4356            (ErrorObjectInput) null /* always null */, null);
4357    }
4358
4359    /**
4360     * Process the qualifier list on the row, return true if it qualifies.
4361     * <p>
4362     * A two dimensional array is to be used to pass around a AND's and OR's in
4363     * conjunctive normal form. The top slot of the 2 dimensional array is
4364     * optimized for the more frequent where no OR's are present. The first
4365     * array slot is always a list of AND's to be treated as described above
4366     * for single dimensional AND qualifier arrays. The subsequent slots are
4367     * to be treated as AND'd arrays or OR's. Thus the 2 dimensional array
4368     * qual[][] argument is to be treated as the following, note if
4369     * qual.length = 1 then only the first array is valid and it is and an
4370     * array of and clauses:
4371     *
4372     * (qual[0][0] and qual[0][0] ... and qual[0][qual[0].length - 1])
4373     * and
4374     * (qual[1][0] or qual[1][1] ... or qual[1][qual[1].length - 1])
4375     * and
4376     * (qual[2][0] or qual[2][1] ... or qual[2][qual[2].length - 1])
4377     * ...
4378     * and
4379     * (qual[qual.length - 1][0] or qual[1][1] ... or qual[1][2])
4380     *
4381     *
4382     * @return true if the row qualifies.
4383     *
4384     * @param row The row being qualified.
4385     * @param qual_list 2 dimensional array representing conjunctive
4386     * normal form of simple qualifiers.
4387     *
4388     * @exception StandardException Standard exception policy.
4389     **/

4390    private boolean qualifyRecordFromRow(
4391    Object JavaDoc[] row,
4392    Qualifier[][] qual_list)
4393         throws StandardException
4394    {
4395        boolean row_qualifies = true;
4396
4397        if (SanityManager.DEBUG)
4398        {
4399            SanityManager.ASSERT(row != null);
4400        }
4401
4402        // First do the qual[0] which is an array of qualifer terms.
4403

4404        if (SanityManager.DEBUG)
4405        {
4406            // routine should not be called if there is no qualifier
4407
SanityManager.ASSERT(qual_list != null);
4408            SanityManager.ASSERT(qual_list.length > 0);
4409        }
4410
4411        for (int i = 0; i < qual_list[0].length; i++)
4412        {
4413            // process each AND clause
4414

4415            row_qualifies = false;
4416
4417            // process each OR clause.
4418

4419            Qualifier q = qual_list[0][i];
4420
4421            // Get the column from the possibly partial row, of the
4422
// q.getColumnId()'th column in the full row.
4423
DataValueDescriptor columnValue =
4424                    (DataValueDescriptor) row[q.getColumnId()];
4425
4426            row_qualifies =
4427                columnValue.compare(
4428                    q.getOperator(),
4429                    q.getOrderable(),
4430                    q.getOrderedNulls(),
4431                    q.getUnknownRV());
4432
4433            if (q.negateCompareResult())
4434                row_qualifies = !row_qualifies;
4435
4436            // Once an AND fails the whole Qualification fails - do a return!
4437
if (!row_qualifies)
4438                return(false);
4439        }
4440
4441        // all the qual[0] and terms passed, now process the OR clauses
4442

4443        for (int and_idx = 1; and_idx < qual_list.length; and_idx++)
4444        {
4445            // loop through each of the "and" clause.
4446

4447            row_qualifies = false;
4448
4449            if (SanityManager.DEBUG)
4450            {
4451                // Each OR clause must be non-empty.
4452
SanityManager.ASSERT(qual_list[and_idx].length > 0);
4453            }
4454
4455            for (int or_idx = 0; or_idx < qual_list[and_idx].length; or_idx++)
4456            {
4457                // Apply one qualifier to the row.
4458
Qualifier q = qual_list[and_idx][or_idx];
4459                int col_id = q.getColumnId();
4460
4461                if (SanityManager.DEBUG)
4462                {
4463                    SanityManager.ASSERT(
4464                        (col_id < row.length),
4465                        "Qualifier is referencing a column not in the row.");
4466                }
4467
4468                // Get the column from the possibly partial row, of the
4469
// q.getColumnId()'th column in the full row.
4470
DataValueDescriptor columnValue =
4471                    (DataValueDescriptor) row[q.getColumnId()];
4472
4473                if (SanityManager.DEBUG)
4474                {
4475                    if (columnValue == null)
4476                        SanityManager.THROWASSERT(
4477                            "1:row = " + RowUtil.toString(row) +
4478                            "row.length = " + row.length +
4479                            ";q.getColumnId() = " + q.getColumnId());
4480                }
4481
4482                // do the compare between the column value and value in the
4483
// qualifier.
4484
row_qualifies =
4485                    columnValue.compare(
4486                            q.getOperator(),
4487                            q.getOrderable(),
4488                            q.getOrderedNulls(),
4489                            q.getUnknownRV());
4490
4491                if (q.negateCompareResult())
4492                    row_qualifies = !row_qualifies;
4493
4494                // SanityManager.DEBUG_PRINT("StoredPage.qual", "processing qual[" + and_idx + "][" + or_idx + "] = " + qual_list[and_idx][or_idx] );
4495

4496                // SanityManager.DEBUG_PRINT("StoredPage.qual", "value = " + row_qualifies);
4497

4498                // processing "OR" clauses, so as soon as one is true, break
4499
// to go and process next AND clause.
4500
if (row_qualifies)
4501                    break;
4502
4503            }
4504
4505            // The qualifier list represented a set of "AND'd"
4506
// qualifications so as soon as one is false processing is done.
4507
if (!row_qualifies)
4508                break;
4509        }
4510
4511        return(row_qualifies);
4512    }
4513
4514    /**
4515     * Read just one column from stream into row.
4516     * <p>
4517     * The routine reads just one column from the row, it is mostly code
4518     * taken from readRecordFromStream, but highly optimized to just get
4519     * one column from a non-overflow row. It can only be called to read
4520     * a row from the pageData array as it directly accesses the page array
4521     * to avoid the Stream overhead while processing non-user data which
4522     * does not need the limit functionality.
4523     * <p>
4524     * It is expected that this code will be called to read in a column
4525     * associated with a qualifiers which are applied one column at a time,
4526     * and has been specialized to proved the greatest peformance for
4527     * processing qualifiers. This kind of access is done when scanning
4528     * large datasets while applying qualifiers and thus any performance
4529     * gain at this low level is multiplied by the large number of rows that
4530     * may be iterated over.
4531     * <p>
4532     * The column is read into the object located in row[qual_colid].
4533     *
4534     * @param row col is read into object in row[qual_colid].
4535     * @param offset_to_field_data offset in bytes from top of page to field
4536     * @param colid the column id to read, colid N is row[N]
4537     * @param recordHeader record header of row to read column from.
4538     * @param recordToLock record handle to lock,
4539     * used by overflow column code.
4540     *
4541     * @exception StandardException Standard exception policy.
4542     **/

4543    private final void readOneColumnFromPage(
4544    Object JavaDoc[] row,
4545    int colid,
4546    int offset_to_field_data,
4547    StoredRecordHeader recordHeader,
4548    RecordHandle recordToLock)
4549         throws StandardException, IOException JavaDoc
4550    {
4551        ErrorObjectInput inUserCode = null;
4552
4553        // Reads in this routine are always against the raw data in the
4554
// pageData array, thus it can assume array access to page data array.
4555
ArrayInputStream lrdi = rawDataIn;
4556
4557        try
4558        {
4559            if (SanityManager.DEBUG)
4560            {
4561                if (colid >= row.length)
4562                    SanityManager.THROWASSERT(
4563                        "colid = " + colid +
4564                        ";row length = " + row.length);
4565
4566                // currently this routine will not work on long rows.
4567
if (recordHeader.getFirstField() != 0)
4568                {
4569                    SanityManager.THROWASSERT(
4570                        "recordHeader.getFirstField() = " +
4571                        recordHeader.getFirstField());
4572                }
4573            }
4574
4575            Object JavaDoc column = row[colid];
4576
4577            // if the column id exists on this page.
4578
if (colid <= (recordHeader.getNumberFields() - 1))
4579            {
4580                // skip the fields before colid, the column in question
4581
// existent on this page.
4582

4583                for (int columnId = colid; columnId > 0; columnId--)
4584                {
4585                    offset_to_field_data +=
4586                        StoredFieldHeader.readTotalFieldLength(
4587                            pageData, offset_to_field_data);
4588                }
4589
4590
4591
4592                // read the field header
4593

4594                // read the status byte.
4595
int fieldStatus =
4596                    StoredFieldHeader.readStatus(
4597                        pageData, offset_to_field_data);
4598
4599                // read the field data length, and position on 1st byte of data.
4600
int fieldDataLength =
4601                    StoredFieldHeader.readFieldLengthAndSetStreamPosition(
4602                        pageData,
4603                        offset_to_field_data +
4604                            StoredFieldHeader.STORED_FIELD_HEADER_STATUS_SIZE,
4605                        fieldStatus,
4606                        slotFieldSize,
4607                        lrdi);
4608
4609                if (SanityManager.DEBUG)
4610                {
4611                    SanityManager.ASSERT(
4612                        !StoredFieldHeader.isExtensible(fieldStatus),
4613                        "extensible fields not supported yet");
4614                }
4615
4616                // SRW-DJD code assumes non-extensible case ...
4617

4618                if (!StoredFieldHeader.isNonexistent(fieldStatus))
4619                {
4620                    boolean isOverflow =
4621                        StoredFieldHeader.isOverflow(fieldStatus);
4622
4623                    OverflowInputStream overflowIn = null;
4624
4625                    if (isOverflow)
4626                    {
4627                        // A fetched long column is returned as a stream
4628
long overflowPage =
4629                            CompressedNumber.readLong((InputStream) lrdi);
4630
4631                        int overflowId =
4632                            CompressedNumber.readInt((InputStream) lrdi);
4633
4634                        // Prepare the stream for results...
4635
// create the byteHolder the size of a page, so, that it
4636
// will fit the field Data that would fit on a page.
4637
MemByteHolder byteHolder =
4638                            new MemByteHolder(pageData.length);
4639
4640                        overflowIn = new OverflowInputStream(
4641                            byteHolder, owner, overflowPage,
4642                            overflowId, recordToLock);
4643                    }
4644
4645                    // Deal with Storable columns
4646
if (column instanceof DataValueDescriptor)
4647                    {
4648                        DataValueDescriptor sColumn =
4649                            (DataValueDescriptor) column;
4650
4651                        // is the column null ?
4652
if (StoredFieldHeader.isNull(fieldStatus))
4653                        {
4654                            sColumn.restoreToNull();
4655                        }
4656                        else
4657                        {
4658                            // set the limit for the user read
4659
if (!isOverflow)
4660                            {
4661                                // normal, non-overflow column case.
4662

4663                                lrdi.setLimit(fieldDataLength);
4664                                inUserCode = lrdi;
4665                                sColumn.readExternalFromArray(lrdi);
4666                                inUserCode = null;
4667                                int unread = lrdi.clearLimit();
4668                                if (unread != 0)
4669                                    lrdi.skipBytes(unread);
4670                            }
4671                            else
4672                            {
4673                                // fetched column is a Storable long column.
4674

4675                                FormatIdInputStream newIn =
4676                                    new FormatIdInputStream(overflowIn);
4677
4678                                if ((sColumn instanceof StreamStorable))
4679                                {
4680                                    ((StreamStorable)sColumn).setStream(newIn);
4681                                }
4682                                else
4683                                {
4684                                    inUserCode = newIn;
4685                                    sColumn.readExternal(newIn);
4686                                    inUserCode = null;
4687                                }
4688                            }
4689                        }
4690                    }
4691                    else
4692                    {
4693                        // At this point only non-Storable columns.
4694

4695                        if (StoredFieldHeader.isNull(fieldStatus))
4696                        {
4697                            // Only Storables can be null ...
4698

4699                            throw StandardException.newException(
4700                                    SQLState.DATA_NULL_STORABLE_COLUMN,
4701                                    Integer.toString(colid));
4702                        }
4703
4704                        // This is a non-extensible field, which means the
4705
// caller must know the correct type and thus the
4706
// element in row is the correct type or null. It must
4707
// be Serializable.
4708
//
4709
// We do not support Externalizable here.
4710

4711                        lrdi.setLimit(fieldDataLength);
4712                        inUserCode = lrdi;
4713                        // RESOLVE (no non-storables?)
4714
row[colid] = (Object JavaDoc) lrdi.readObject();
4715                        inUserCode = null;
4716                        int unread = lrdi.clearLimit();
4717                        if (unread != 0)
4718                            lrdi.skipBytes(unread);
4719                    }
4720
4721                }
4722                else
4723                {
4724                    // column does not exist in the row, return null.
4725

4726                    // field is non-existent
4727

4728                    if (column instanceof DataValueDescriptor)
4729                    {
4730                        // RESOLVE - This is in place for 1.2. In the future
4731
// we may want to return this column as non-existent
4732
// even if it is a storable column, or maybe use a
4733
// supplied default.
4734

4735                        ((DataValueDescriptor) column).restoreToNull();
4736                    }
4737                    else
4738                    {
4739                        row[colid] = null;
4740                    }
4741                }
4742            }
4743            else
4744            {
4745                // field does not exist on this page.
4746

4747                if (column instanceof DataValueDescriptor)
4748                {
4749                    // RESOLVE - This is in place for 1.2. In the future
4750
// we may want to return this column as non-existent
4751
// even if it is a storable column, or maybe use a
4752
// supplied default.
4753
((DataValueDescriptor) column).restoreToNull();
4754                }
4755                else
4756                {
4757                    row[colid] = null;
4758                }
4759            }
4760        }
4761        catch (IOException JavaDoc ioe)
4762        {
4763            // an exception during the restore of a user column, this doesn't
4764
// make the database corrupt, just that this field is inaccessable
4765

4766            if (inUserCode != null)
4767            {
4768                lrdi.clearLimit();
4769
4770                if (ioe instanceof EOFException JavaDoc)
4771                {
4772                    if (SanityManager.DEBUG)
4773                    {
4774                        SanityManager.DEBUG_PRINT("DEBUG_TRACE",
4775                            "StoredPage.readOneColumnFromPage - EOF while restoring record: " +
4776                                recordHeader +
4777                            "Page dump = " + this);
4778                        SanityManager.showTrace(ioe);
4779                    }
4780
4781                    // going beyond the limit in a DataInput class results in
4782
// an EOFException when it sees the -1 from a read
4783
throw StandardException.newException(
4784                            SQLState.DATA_STORABLE_READ_MISMATCH,
4785                            ioe, inUserCode.getErrorInfo());
4786                }
4787
4788                // some SQLData error reporting
4789
Exception JavaDoc ne = inUserCode.getNestedException();
4790                if (ne != null)
4791                {
4792                    if (ne instanceof InstantiationException JavaDoc)
4793                    {
4794                        throw StandardException.newException(
4795                            SQLState.DATA_SQLDATA_READ_INSTANTIATION_EXCEPTION,
4796                            ne, inUserCode.getErrorInfo());
4797                    }
4798
4799                    if (ne instanceof IllegalAccessException JavaDoc)
4800                    {
4801                        throw StandardException.newException(
4802                            SQLState.DATA_SQLDATA_READ_ILLEGAL_ACCESS_EXCEPTION,
4803                            ne, inUserCode.getErrorInfo());
4804                    }
4805
4806                    if (ne instanceof StandardException)
4807                    {
4808                        throw (StandardException) ne;
4809                    }
4810                }
4811
4812                throw StandardException.newException(
4813                        SQLState.DATA_STORABLE_READ_EXCEPTION,
4814                        ioe, inUserCode.getErrorInfo());
4815            }
4816
4817            // re-throw to higher levels so they can put it in correct context.
4818
throw ioe;
4819
4820        }
4821        catch (ClassNotFoundException JavaDoc cnfe)
4822        {
4823            lrdi.clearLimit();
4824
4825            // an exception during the restore of a user column, this doesn't
4826
// make the database corrupt, just that this field is inaccessable
4827
throw StandardException.newException(
4828                    SQLState.DATA_STORABLE_READ_MISSING_CLASS,
4829                    cnfe, inUserCode.getErrorInfo());
4830
4831        }
4832        catch (LinkageError JavaDoc le)
4833        {
4834            // Some error during the link of a user class
4835
if (inUserCode != null)
4836            {
4837                lrdi.clearLimit();
4838
4839                throw StandardException.newException(
4840                        SQLState.DATA_STORABLE_READ_EXCEPTION,
4841                        le, inUserCode.getErrorInfo());
4842            }
4843            throw le;
4844        }
4845
4846    }
4847
4848
4849
4850    /**
4851     * Process the list of qualifiers on the row in the stream.
4852     * <p>
4853     * The rawDataIn stream is expected to be positioned after the record
4854     * header. The inUserCode parameter here is only to get around a
4855     * JDK 1.1.x (at least 1.1.7) JIT bug. If inUserCode was a local variable
4856     * then it is not correctly set on an exception, the only time we care
4857     * about its value. It seems to work when its a parameter. Null should
4858     * always be passed in. This bug is fixed in the JDK 1.2 JIT.
4859     * <p>
4860     * Check all qualifiers in the qualifier array against row. Return true
4861     * if all compares specified by the qualifier array return true, else
4862     * return false.
4863     * <p>
4864     * This routine assumes client caller has already checked if the row
4865     * is deleted or not. The row that it get's is expected to match
4866     * the partial column list of the scan.
4867     * <p>
4868     * On entering this routine the stream should be positioned to the
4869     * beginning of the row data, just after the row header. On exit
4870     * the stream will also be positioned there.
4871     *
4872     * A two dimensional array is to be used to pass around a AND's and OR's in
4873     * conjunctive normal form. The top slot of the 2 dimensional array is
4874     * optimized for the more frequent where no OR's are present. The first
4875     * array slot is always a list of AND's to be treated as described above
4876     * for single dimensional AND qualifier arrays. The subsequent slots are
4877     * to be treated as AND'd arrays or OR's. Thus the 2 dimensional array
4878     * qual[][] argument is to be treated as the following, note if
4879     * qual.length = 1 then only the first array is valid and it is and an
4880     * array of and clauses:
4881     *
4882     * (qual[0][0] and qual[0][0] ... and qual[0][qual[0].length - 1])
4883     * and
4884     * (qual[1][0] or qual[1][1] ... or qual[1][qual[1].length - 1])
4885     * and
4886     * (qual[2][0] or qual[2][1] ... or qual[2][qual[2].length - 1])
4887     * ...
4888     * and
4889     * (qual[qual.length - 1][0] or qual[1][1] ... or qual[1][2])
4890     *
4891     * @return Whether or not the row input qualifies.
4892     *
4893     * @param row restore row into this object array.
4894     * @param offset_to_row_data offset in bytes from top of page to row
4895     * @param fetchDesc Description of fetch including which cols
4896     * and qualifiers.
4897     * @param recordHeader The record header of the row, it was read
4898     * in from stream and dataIn is positioned
4899     * after it.
4900     * @param recordToLock The head row to use for locking, used to
4901     * lock head row of overflow columns/rows.
4902     *
4903     * @exception StandardException Standard exception policy.
4904     **/

4905    private final boolean qualifyRecordFromSlot(
4906    Object JavaDoc[] row,
4907    int offset_to_row_data,
4908    FetchDescriptor fetchDesc,
4909    StoredRecordHeader recordHeader,
4910    RecordHandle recordToLock)
4911         throws StandardException, IOException JavaDoc
4912    {
4913        boolean row_qualifies = true;
4914        Qualifier[][] qual_list = fetchDesc.getQualifierList();
4915        int[] materializedCols = fetchDesc.getMaterializedColumns();
4916
4917        if (SanityManager.DEBUG)
4918        {
4919            SanityManager.ASSERT(qual_list != null, "Not coded yet!");
4920        }
4921
4922        if (SanityManager.DEBUG)
4923        {
4924            SanityManager.ASSERT(row != null);
4925        }
4926
4927        // First process the initial list of AND's in the 1st array
4928

4929        for (int i = 0; i < qual_list[0].length; i++)
4930        {
4931            // process each AND clause
4932

4933            row_qualifies = false;
4934
4935            // Apply one qualifier to the row.
4936
Qualifier q = qual_list[0][i];
4937            int col_id = q.getColumnId();
4938
4939            if (SanityManager.DEBUG)
4940            {
4941                SanityManager.ASSERT(
4942                    (col_id < row.length),
4943                    "Qualifier is referencing a column not in the row.");
4944            }
4945
4946            // materialize the column object if we haven't done it yet.
4947
if (materializedCols[col_id] == 0)
4948            {
4949                // materialize just this column from the row, no qualifiers
4950
readOneColumnFromPage(
4951                    row,
4952                    col_id,
4953                    offset_to_row_data,
4954                    recordHeader,
4955                    recordToLock);
4956
4957                // mark offset, indicating the row has been read in.
4958
//
4959
// RESOLVE (mikem) - right now value of entry is useless, it
4960
// is an int so that in the future we could cache the offset
4961
// to fields to improve performance of getting to a column
4962
// after qualifying.
4963
materializedCols[col_id] = offset_to_row_data;
4964            }
4965
4966            // Get the column from the possibly partial row, of the
4967
// q.getColumnId()'th column in the full row.
4968

4969            if (SanityManager.DEBUG)
4970            {
4971                if (row[col_id] == null)
4972                    SanityManager.THROWASSERT(
4973                        "1:row = " + RowUtil.toString(row) +
4974                        "row.length = " + row.length +
4975                        ";q.getColumnId() = " + q.getColumnId());
4976            }
4977
4978            // do the compare between the column value and value in the
4979
// qualifier.
4980
row_qualifies =
4981                ((DataValueDescriptor) row[col_id]).compare(
4982                        q.getOperator(),
4983                        q.getOrderable(),
4984                        q.getOrderedNulls(),
4985                        q.getUnknownRV());
4986
4987            if (q.negateCompareResult())
4988                row_qualifies = !row_qualifies;
4989
4990            // Once an AND fails the whole Qualification fails - do a return!
4991
if (!row_qualifies)
4992                return(false);
4993        }
4994
4995        // Now process the Subsequent OR clause's, beginning with qual_list[1]
4996

4997        for (int and_idx = 1; and_idx < qual_list.length; and_idx++)
4998        {
4999            // loop through each of the "and" clause.
5000

5001            row_qualifies = false;
5002
5003            for (int or_idx = 0; or_idx < qual_list[and_idx].length; or_idx++)
5004            {
5005                // Apply one qualifier to the row.
5006
Qualifier q = qual_list[and_idx][or_idx];
5007                int col_id = q.getColumnId();
5008
5009                if (SanityManager.DEBUG)
5010                {
5011                    SanityManager.ASSERT(
5012                        (col_id < row.length),
5013                        "Qualifier is referencing a column not in the row.");
5014                }
5015
5016                // materialize the column object if we haven't done it yet.
5017
if (materializedCols[col_id] == 0)
5018                {
5019                    // materialize just this column from the row, no qualifiers
5020
readOneColumnFromPage(
5021                        row,
5022                        col_id,
5023                        offset_to_row_data,
5024                        recordHeader,
5025                        recordToLock);
5026
5027                    // mark offset, indicating the row has been read in.
5028
//
5029
// RESOLVE (mikem) - right now value of entry is useless, it
5030
// is an int so that in the future we could cache the offset
5031
// to fields to improve performance of getting to a column
5032
// after qualifying.
5033
materializedCols[col_id] = offset_to_row_data;
5034                }
5035
5036                // Get the column from the possibly partial row, of the
5037
// q.getColumnId()'th column in the full row.
5038

5039                if (SanityManager.DEBUG)
5040                {
5041                    if (row[col_id] == null)
5042                        SanityManager.THROWASSERT(
5043                            "1:row = " + RowUtil.toString(row) +
5044                            "row.length = " + row.length +
5045                            ";q.getColumnId() = " + q.getColumnId());
5046                }
5047
5048                // do the compare between the column value and value in the
5049
// qualifier.
5050
row_qualifies =
5051                    ((DataValueDescriptor) row[col_id]).compare(
5052                            q.getOperator(),
5053                            q.getOrderable(),
5054                            q.getOrderedNulls(),
5055                            q.getUnknownRV());
5056
5057
5058                if (q.negateCompareResult())
5059                    row_qualifies = !row_qualifies;
5060
5061                // SanityManager.DEBUG_PRINT("StoredPage.qual", "processing qual[" + and_idx + "][" + or_idx + "] = " + qual_list[and_idx][or_idx] );
5062

5063                // SanityManager.DEBUG_PRINT("StoredPage.qual", "value = " + row_qualifies);
5064

5065                // processing "OR" clauses, so as soon as one is true, break
5066
// to go and process next AND clause.
5067
if (row_qualifies)
5068                    break;
5069
5070            }
5071
5072            // The qualifier list represented a set of "AND'd"
5073
// qualifications so as soon as one is false processing is done.
5074
if (!row_qualifies)
5075                break;
5076        }
5077
5078        return(row_qualifies);
5079    }
5080
5081    /**
5082     * restore a record from a stream.
5083     * <p>
5084     * The rawDataIn stream is expected to be positioned after the record
5085     * header. The inUserCode parameter here is only to get around a
5086     * JDK 1.1.x (at least 1.1.7) JIT bug. If inUserCode was a local variable
5087     * then it is not correctly set on an exception, the only time we care
5088     * about its value. It seems to work when its a parameter. Null should
5089     * always be passed in. This bug is fixed in the JDK 1.2 JIT.
5090     * <p>
5091     *
5092     * @return The identifier to be used to open the conglomerate later.
5093     *
5094     * @param row restore row into this object array.
5095     * @param max_colid The maximum numbered column id that will be
5096     * requested by caller. It should be:
5097     * min(row.length - 1, maximum bit set in vCols)
5098     * It is used to stop the inner most loop from
5099     * looking at more columns in the row.
5100     * @param vCols If not null, bit map indicates valid cols.
5101     * @param mCols If not null, int array indicates columns already
5102     * read in from the stream. A non-zero entry
5103     * means the column has already been read in.
5104     * @param dataIn restore row from this stream.
5105     * @param recordHeader The record header of the row, it was read in
5106     * from stream and dataIn is positioned after it.
5107     * @param inUserCode see comments above about jit bug.
5108     * @param recordToLock The head row to use for locking, used to lock
5109     * head row of overflow columns/rows.
5110     *
5111     * @exception StandardException Standard exception policy.
5112     **/

5113    private final boolean readRecordFromStream(
5114    Object JavaDoc[] row,
5115    int max_colid,
5116    int[] vCols,
5117    int[] mCols,
5118    LimitObjectInput dataIn,
5119    StoredRecordHeader recordHeader,
5120    ErrorObjectInput inUserCode,
5121    RecordHandle recordToLock)
5122         throws StandardException, IOException JavaDoc
5123    {
5124        try
5125        {
5126            // Get the number of columns in the row.
5127
int numberFields = recordHeader.getNumberFields();
5128
5129            int startColumn = recordHeader.getFirstField();
5130
5131            if (startColumn > max_colid)
5132            {
5133                // done if the startColumn is higher than highest column.
5134
return true;
5135            }
5136
5137            // For each column in the row, restore the column from
5138
// the corresponding field in the record. If the field
5139
// is missing or not set, set the column to null.
5140

5141            int highestColumnOnPage = numberFields + startColumn;
5142
5143            int vColsSize = (vCols == null ) ? 0 : vCols.length;
5144
5145            for (int columnId = startColumn; columnId <= max_colid; columnId++)
5146            {
5147                // skip any "existing" columns not requested, or requested cols
5148
// that have already been read.
5149
if (((vCols != null) &&
5150                     (!(vColsSize > columnId && (vCols[columnId] != 0)))) ||
5151                    ((mCols != null) && (mCols[columnId] != 0)))
5152                {
5153                    if (columnId < highestColumnOnPage)
5154                    {
5155                        // If the field exists in the row on the page, but the
5156
// partial row being returned does not include it,
5157
// skip the field ...
5158

5159                        skipField(dataIn);
5160                    }
5161
5162                    continue;
5163                }
5164
5165                // See if the column identifier is beyond the number of fields
5166
// that this record has
5167
if (columnId >= highestColumnOnPage)
5168                {
5169                    // field is non-existent
5170
Object JavaDoc column = row[columnId];
5171
5172                    if (column instanceof DataValueDescriptor)
5173                    {
5174                        // RESOLVE - This is in place for 1.2. In the future
5175
// we may want to return this column as non-existent
5176
// even if it is a storable column, or maybe use a
5177
// supplied default.
5178

5179                        ((DataValueDescriptor) column).restoreToNull();
5180                    }
5181                    else
5182                    {
5183                        row[columnId] = null;
5184                    }
5185                    continue;
5186                }
5187
5188                // read the field header
5189
int fieldStatus =
5190                    StoredFieldHeader.readStatus(dataIn);
5191
5192                int fieldDataLength =
5193                    StoredFieldHeader.readFieldDataLength(
5194                        dataIn, fieldStatus, slotFieldSize);
5195
5196                if (SanityManager.DEBUG)
5197                {
5198                    SanityManager.ASSERT(
5199                        !StoredFieldHeader.isExtensible(fieldStatus),
5200                        "extensible fields not supported yet");
5201                }
5202
5203                Object JavaDoc column = row[columnId];
5204
5205                OverflowInputStream overflowIn = null;
5206
5207                // SRW-DJD code assumes non-extensible case ...
5208

5209                // field is non-existent, return null
5210
if (StoredFieldHeader.isNonexistent(fieldStatus))
5211                {
5212
5213                    if (column instanceof DataValueDescriptor)
5214                    {
5215                        // RESOLVE - This is in place for 1.2. In the future
5216
// we may want to return this column as non-existent
5217
// even if it is a storable column, or maybe use a
5218
// supplied default.
5219
((DataValueDescriptor) column).restoreToNull();
5220                    }
5221                    else
5222                    {
5223                        row[columnId] = null;
5224                    }
5225                    continue;
5226                }
5227
5228                boolean isOverflow = StoredFieldHeader.isOverflow(fieldStatus);
5229
5230                if (isOverflow)
5231                {
5232
5233                    // A fetched long column needs to be returned as a stream
5234
//
5235
long overflowPage =
5236                        CompressedNumber.readLong((InputStream) dataIn);
5237
5238                    int overflowId =
5239                        CompressedNumber.readInt((InputStream) dataIn);
5240
5241                    // Prepare the stream for results...
5242
// create the byteHolder the size of a page, so, that it
5243
// will fit the field Data that would fit on a page.
5244
MemByteHolder byteHolder =
5245                        new MemByteHolder(pageData.length);
5246
5247                    overflowIn = new OverflowInputStream(
5248                        byteHolder, owner, overflowPage,
5249                        overflowId, recordToLock);
5250                }
5251
5252                // Deal with Object columns
5253
if (column instanceof DataValueDescriptor)
5254                {
5255                    DataValueDescriptor sColumn = (DataValueDescriptor) column;
5256
5257                    // is the column null ?
5258
if (StoredFieldHeader.isNull(fieldStatus))
5259                    {
5260                        sColumn.restoreToNull();
5261                        continue;
5262                    }
5263
5264                    // set the limit for the user read
5265
if (!isOverflow)
5266                    {
5267                        // normal, non-overflow column case.
5268

5269                        dataIn.setLimit(fieldDataLength);
5270                        inUserCode = dataIn;
5271                        sColumn.readExternal(dataIn);
5272                        inUserCode = null;
5273                        int unread = dataIn.clearLimit();
5274                        if (unread != 0)
5275                            dataIn.skipBytes(unread);
5276                    }
5277                    else
5278                    {
5279                        // column being fetched is a Object long column.
5280

5281                        FormatIdInputStream newIn =
5282                            new FormatIdInputStream(overflowIn);
5283
5284                        // if a column is a long column, store recommends user
5285
// fetch it as a stream.
5286
boolean fetchStream = true;
5287
5288                        if (!(sColumn instanceof StreamStorable))
5289                        {
5290                            fetchStream = false;
5291                        }
5292
5293                        if (fetchStream)
5294                        {
5295                            ((StreamStorable)sColumn).setStream(newIn);
5296                        }
5297                        else
5298                        {
5299                            inUserCode = newIn;
5300                            sColumn.readExternal(newIn);
5301                            inUserCode = null;
5302                        }
5303
5304                    }
5305
5306                    continue;
5307                }
5308
5309                // At this point only non-Storable columns.
5310

5311                if (StoredFieldHeader.isNull(fieldStatus))
5312                {
5313                    // Only Storables can be null ...
5314

5315                    throw StandardException.newException(
5316                            SQLState.DATA_NULL_STORABLE_COLUMN,
5317                            Integer.toString(columnId));
5318                }
5319
5320                // This is a non-extensible field, which means the caller must
5321
// know the correct type and thus the element in row is the
5322
// correct type or null. It must be Serializable.
5323
//
5324
// We do not support Externalizable here.
5325

5326                dataIn.setLimit(fieldDataLength);
5327                inUserCode = dataIn;
5328                row[columnId] = (Object JavaDoc) dataIn.readObject();
5329                inUserCode = null;
5330                int unread = dataIn.clearLimit();
5331                if (unread != 0)
5332                    dataIn.skipBytes(unread);
5333
5334                continue;
5335            }
5336
5337            // if the last column on this page is bigger than the highest
5338
// column we are looking for, then we are done restoring the record.
5339

5340            if ((numberFields + startColumn) > max_colid)
5341                return true;
5342            else
5343                return false;
5344
5345        }
5346        catch (IOException JavaDoc ioe)
5347        {
5348            // an exception during the restore of a user column, this doesn't
5349
// make the database corrupt, just that this field is inaccessable
5350

5351            if (inUserCode != null)
5352            {
5353                dataIn.clearLimit();
5354
5355                if (ioe instanceof EOFException JavaDoc)
5356                {
5357                    if (SanityManager.DEBUG)
5358                    {
5359                        SanityManager.DEBUG_PRINT("DEBUG_TRACE",
5360                            "StoredPage - EOF while restoring record: " +
5361                                recordHeader +
5362                            "Page dump = " + this);
5363                    }
5364
5365                    // going beyond the limit in a DataInput class results in
5366
// an EOFException when it sees the -1 from a read
5367
throw StandardException.newException(
5368                            SQLState.DATA_STORABLE_READ_MISMATCH,
5369                            ioe, inUserCode.getErrorInfo());
5370                }
5371
5372                // some SQLData error reporting
5373
Exception JavaDoc ne = inUserCode.getNestedException();
5374                if (ne != null)
5375                {
5376                    if (ne instanceof InstantiationException JavaDoc)
5377                    {
5378                        throw StandardException.newException(
5379                            SQLState.DATA_SQLDATA_READ_INSTANTIATION_EXCEPTION,
5380                            ne, inUserCode.getErrorInfo());
5381                    }
5382
5383                    if (ne instanceof IllegalAccessException JavaDoc)
5384                    {
5385                        throw StandardException.newException(
5386                            SQLState.DATA_SQLDATA_READ_ILLEGAL_ACCESS_EXCEPTION,
5387                            ne, inUserCode.getErrorInfo());
5388                    }
5389
5390                    if (ne instanceof StandardException)
5391                    {
5392                        throw (StandardException) ne;
5393                    }
5394                }
5395
5396                throw StandardException.newException(
5397                        SQLState.DATA_STORABLE_READ_EXCEPTION,
5398                        ioe, inUserCode.getErrorInfo());
5399            }
5400
5401            // re-throw to higher levels so they can put it in correct context.
5402
throw ioe;
5403
5404        }
5405        catch (ClassNotFoundException JavaDoc cnfe)
5406        {
5407            dataIn.clearLimit();
5408
5409            // an exception during the restore of a user column, this doesn't
5410
// make the database corrupt, just that this field is inaccessable
5411
throw StandardException.newException(
5412                    SQLState.DATA_STORABLE_READ_MISSING_CLASS,
5413                    cnfe, inUserCode.getErrorInfo());
5414
5415        }
5416        catch (LinkageError JavaDoc le)
5417        {
5418            // Some error during the link of a user class
5419
if (inUserCode != null)
5420            {
5421                dataIn.clearLimit();
5422
5423                throw StandardException.newException(
5424                        SQLState.DATA_STORABLE_READ_EXCEPTION,
5425                        le, inUserCode.getErrorInfo());
5426            }
5427            throw le;
5428        }
5429
5430    }
5431
5432    private final boolean readRecordFromArray(
5433    Object JavaDoc[] row,
5434    int max_colid,
5435    int[] vCols,
5436    int[] mCols,
5437    ArrayInputStream dataIn,
5438    StoredRecordHeader recordHeader,
5439    ErrorObjectInput inUserCode,
5440    RecordHandle recordToLock)
5441         throws StandardException, IOException JavaDoc
5442    {
5443        try
5444        {
5445            // Get the number of columns in the row.
5446
int numberFields = recordHeader.getNumberFields();
5447
5448            int startColumn = recordHeader.getFirstField();
5449
5450            if (startColumn > max_colid)
5451            {
5452                // done if the startColumn is higher than highest column.
5453
return true;
5454            }
5455
5456            // For each column in the row, restore the column from
5457
// the corresponding field in the record. If the field
5458
// is missing or not set, set the column to null.
5459

5460            int highestColumnOnPage = numberFields + startColumn;
5461
5462            int vColsSize = (vCols == null ) ? 0 : vCols.length;
5463
5464            int offset_to_field_data = dataIn.getPosition();
5465
5466            for (int columnId = startColumn; columnId <= max_colid; columnId++)
5467            {
5468                // skip any "existing" columns not requested, or requested cols
5469
// that have already been read.
5470
if (((vCols != null) &&
5471                     (!(vColsSize > columnId && (vCols[columnId] != 0)))) ||
5472                    ((mCols != null) && (mCols[columnId] != 0)))
5473                {
5474                    if (columnId < highestColumnOnPage)
5475                    {
5476                        // If the field exists in the row on the page, but the
5477
// partial row being returned does not include it,
5478
// skip the field ...
5479

5480                        offset_to_field_data +=
5481                            StoredFieldHeader.readTotalFieldLength(
5482                                pageData, offset_to_field_data);
5483                    }
5484
5485                    continue;
5486                }
5487                else if (columnId < highestColumnOnPage)
5488                {
5489                    // the column is on this page.
5490

5491                    // read the field header
5492

5493                    // read the status byte.
5494
int fieldStatus =
5495                        StoredFieldHeader.readStatus(
5496                            pageData, offset_to_field_data);
5497
5498                    // read the field data length, position on 1st byte of data
5499
int fieldDataLength =
5500                        StoredFieldHeader.readFieldLengthAndSetStreamPosition(
5501                            pageData,
5502                            offset_to_field_data +
5503                              StoredFieldHeader.STORED_FIELD_HEADER_STATUS_SIZE,
5504                            fieldStatus,
5505                            slotFieldSize,
5506                            dataIn);
5507
5508
5509                    if (SanityManager.DEBUG)
5510                    {
5511                        SanityManager.ASSERT(
5512                            !StoredFieldHeader.isExtensible(fieldStatus),
5513                            "extensible fields not supported yet");
5514                    }
5515
5516                    Object JavaDoc column = row[columnId];
5517
5518                    OverflowInputStream overflowIn = null;
5519
5520                    // SRW-DJD code assumes non-extensible case ...
5521

5522                    if ((fieldStatus & StoredFieldHeader.FIELD_NONEXISTENT) !=
5523                                            StoredFieldHeader.FIELD_NONEXISTENT)
5524                    {
5525                        // normal path - field exists.
5526

5527                        boolean isOverflow =
5528                            ((fieldStatus &
5529                                  StoredFieldHeader.FIELD_OVERFLOW) != 0);
5530
5531                        if (isOverflow)
5532                        {
5533
5534                            // A fetched long column is returned as a stream
5535

5536                            long overflowPage =
5537                                CompressedNumber.readLong((InputStream) dataIn);
5538
5539                            int overflowId =
5540                                CompressedNumber.readInt((InputStream) dataIn);
5541
5542                            // Prepare the stream for results...
5543
// create the byteHolder the size of a page, so,
5544
// that it will fit the field Data that would fit
5545
// on a page.
5546

5547                            MemByteHolder byteHolder =
5548                                new MemByteHolder(pageData.length);
5549
5550                            overflowIn = new OverflowInputStream(
5551                                byteHolder, owner, overflowPage,
5552                                overflowId, recordToLock);
5553                        }
5554
5555                        // Deal with Object columns
5556
if (column instanceof DataValueDescriptor)
5557                        {
5558                            DataValueDescriptor sColumn =
5559                                (DataValueDescriptor) column;
5560
5561                            // is the column null ?
5562
if ((fieldStatus &
5563                                        StoredFieldHeader.FIELD_NULL) == 0)
5564                            {
5565                                // the field is not null.
5566

5567                                // set the limit for the user read
5568
if (!isOverflow)
5569                                {
5570                                    // normal, non-overflow column case.
5571

5572                                    dataIn.setLimit(fieldDataLength);
5573                                    inUserCode = dataIn;
5574                                    sColumn.readExternalFromArray(dataIn);
5575                                    inUserCode = null;
5576                                    int unread = dataIn.clearLimit();
5577                                    if (unread != 0)
5578                                        dataIn.skipBytes(unread);
5579                                }
5580                                else
5581                                {
5582                                    // column being fetched is a long column.
5583

5584                                    FormatIdInputStream newIn =
5585                                        new FormatIdInputStream(overflowIn);
5586
5587                                    // long columns are fetched as a stream.
5588

5589                                    boolean fetchStream = true;
5590
5591                                    if (!(sColumn instanceof StreamStorable))
5592                                    {
5593                                        fetchStream = false;
5594                                    }
5595
5596                                    if (fetchStream)
5597                                    {
5598                                        ((StreamStorable) sColumn).setStream(
5599                                                                         newIn);
5600                                    }
5601                                    else
5602                                    {
5603                                        inUserCode = newIn;
5604                                        sColumn.readExternal(newIn);
5605                                        inUserCode = null;
5606                                    }
5607                                }
5608                            }
5609                            else
5610                            {
5611                                sColumn.restoreToNull();
5612                            }
5613
5614                        }
5615                        else
5616                        {
5617
5618                            // At this point only non-Storable columns.
5619

5620                            if (StoredFieldHeader.isNull(fieldStatus))
5621                            {
5622                                // Only Storables can be null ...
5623

5624                                throw StandardException.newException(
5625                                        SQLState.DATA_NULL_STORABLE_COLUMN,
5626                                        Integer.toString(columnId));
5627                            }
5628
5629                            // This is a non-extensible field, which means the
5630
// caller must know the correct type and thus the
5631
// element in row is the correct type or null. It
5632
// must be Serializable.
5633
//
5634
// We do not support Externalizable here.
5635

5636                            dataIn.setLimit(fieldDataLength);
5637                            inUserCode = dataIn;
5638                                    // RESOLVE (no non-storables?)
5639
row[columnId] = (Object JavaDoc) dataIn.readObject();
5640                            inUserCode = null;
5641                            int unread = dataIn.clearLimit();
5642                            if (unread != 0)
5643                                dataIn.skipBytes(unread);
5644                        }
5645                    }
5646                    else
5647                    {
5648                        // column is non-existent.
5649

5650                        if (column instanceof DataValueDescriptor)
5651                        {
5652                            // RESOLVE - This is in place for 1.2. In the future
5653
// we may want to return this column as non-existent
5654
// even if it is a storable column, or maybe use a
5655
// supplied default.
5656
((DataValueDescriptor) column).restoreToNull();
5657                        }
5658                        else
5659                        {
5660                            row[columnId] = null;
5661                        }
5662                    }
5663
5664                    // move the counter to point to beginning of next field.
5665
offset_to_field_data = dataIn.getPosition();
5666                }
5667                else
5668                {
5669                    // field is non-existent
5670
Object JavaDoc column = row[columnId];
5671
5672                    if (column instanceof DataValueDescriptor)
5673                    {
5674                        // RESOLVE - This is in place for 1.2. In the future
5675
// we may want to return this column as non-existent
5676
// even if it is a storable column, or maybe use a
5677
// supplied default.
5678

5679                        ((DataValueDescriptor) column).restoreToNull();
5680                    }
5681                    else
5682                    {
5683                        row[columnId] = null;
5684                    }
5685                }
5686            }
5687
5688            // if the last column on this page is bigger than the highest
5689
// column we are looking for, then we are done restoring the record.
5690

5691            if ((numberFields + startColumn) > max_colid)
5692                return true;
5693            else
5694                return false;
5695
5696        }
5697        catch (IOException JavaDoc ioe)
5698        {
5699            // an exception during the restore of a user column, this doesn't
5700
// make the database corrupt, just that this field is inaccessable
5701

5702            if (inUserCode != null)
5703            {
5704                dataIn.clearLimit();
5705
5706                if (ioe instanceof EOFException JavaDoc)
5707                {
5708                    if (SanityManager.DEBUG)
5709                    {
5710                        SanityManager.DEBUG_PRINT("DEBUG_TRACE",
5711                            "StoredPage - EOF while restoring record: " +
5712                                recordHeader +
5713                            "Page dump = " + this);
5714                    }
5715
5716                    // going beyond the limit in a DataInput class results in
5717
// an EOFException when it sees the -1 from a read
5718
throw StandardException.newException(
5719                            SQLState.DATA_STORABLE_READ_MISMATCH,
5720                            ioe, inUserCode.getErrorInfo());
5721                }
5722
5723                // some SQLData error reporting
5724
Exception JavaDoc ne = inUserCode.getNestedException();
5725                if (ne != null)
5726                {
5727                    if (ne instanceof InstantiationException JavaDoc)
5728                    {
5729                        throw StandardException.newException(
5730                            SQLState.DATA_SQLDATA_READ_INSTANTIATION_EXCEPTION,
5731                            ne, inUserCode.getErrorInfo());
5732                    }
5733
5734                    if (ne instanceof IllegalAccessException JavaDoc)
5735                    {
5736                        throw StandardException.newException(
5737                            SQLState.DATA_SQLDATA_READ_ILLEGAL_ACCESS_EXCEPTION,
5738                            ne, inUserCode.getErrorInfo());
5739                    }
5740
5741                    if (ne instanceof StandardException)
5742                    {
5743                        throw (StandardException) ne;
5744                    }
5745                }
5746
5747                throw StandardException.newException(
5748                        SQLState.DATA_STORABLE_READ_EXCEPTION,
5749                        ioe, inUserCode.getErrorInfo());
5750            }
5751
5752            // re-throw to higher levels so they can put it in correct context.
5753
throw ioe;
5754
5755        }
5756        catch (ClassNotFoundException JavaDoc cnfe)
5757        {
5758            dataIn.clearLimit();
5759
5760            // an exception during the restore of a user column, this doesn't
5761
// make the database corrupt, just that this field is inaccessable
5762
throw StandardException.newException(
5763                    SQLState.DATA_STORABLE_READ_MISSING_CLASS,
5764                    cnfe, inUserCode.getErrorInfo());
5765
5766        }
5767        catch (LinkageError JavaDoc le)
5768        {
5769            // Some error during the link of a user class
5770
if (inUserCode != null)
5771            {
5772                dataIn.clearLimit();
5773
5774                throw StandardException.newException(
5775                        SQLState.DATA_STORABLE_READ_EXCEPTION,
5776                        le, inUserCode.getErrorInfo());
5777            }
5778            throw le;
5779        }
5780
5781    }
5782
5783    /**
5784     * Restore a portion of a long column.
5785     * <p>
5786     * Restore a portion of a long column - user must supply two streams on top
5787     * of the same data, one implements ObjectInput interface that knows how to
5788     * restore the object, the other one implements LimitInputStream.
5789     *
5790     * @param fetchStream the stream to read the next portion of long col from
5791     *
5792     * @exception StandardException Standard exception policy.
5793     **/

5794    public void restorePortionLongColumn(
5795    OverflowInputStream fetchStream)
5796        throws StandardException, IOException JavaDoc
5797    {
5798        int slot =
5799            findRecordById(fetchStream.getOverflowId(), FIRST_SLOT_NUMBER);
5800
5801        StoredRecordHeader recordHeader = getHeaderAtSlot(slot);
5802
5803        int offset = getRecordOffset(slot);
5804        int numberFields = recordHeader.getNumberFields();
5805
5806        if (SanityManager.DEBUG)
5807        {
5808            if ((numberFields > 2) || (numberFields < 1))
5809            {
5810                SanityManager.THROWASSERT(
5811                    "longColumn record header must have 1 or 2 fields." +
5812                    "numberFields = " + numberFields);
5813            }
5814        }
5815
5816        rawDataIn.setPosition(offset + recordHeader.size());
5817
5818        int fieldStatus =
5819            StoredFieldHeader.readStatus(rawDataIn);
5820        int fieldDataLength =
5821            StoredFieldHeader.readFieldDataLength(
5822                rawDataIn, fieldStatus, slotFieldSize);
5823
5824        // read the data portion of this segment from the stream.
5825

5826        ByteHolder bh = fetchStream.getByteHolder();
5827        bh.write(rawDataIn, fieldDataLength);
5828        fetchStream.setByteHolder(bh);
5829
5830        // set the next overflow pointer in the stream...
5831
if (numberFields == 1)
5832        {
5833            // this is the last bit of the long column
5834
fetchStream.setOverflowPage(-1);
5835            fetchStream.setOverflowId(-1);
5836        }
5837        else
5838        {
5839            int firstFieldStatus = fieldStatus; // for DEBUG check
5840

5841            // get the field status and data length of the overflow pointer.
5842
fieldStatus =
5843                StoredFieldHeader.readStatus(rawDataIn);
5844            fieldDataLength =
5845                StoredFieldHeader.readFieldDataLength(
5846                    rawDataIn, fieldStatus, slotFieldSize);
5847
5848            if (SanityManager.DEBUG)
5849            {
5850                if (!StoredFieldHeader.isOverflow(fieldStatus))
5851                {
5852                    // In version 1.5, the first field is overflow and the
5853
// second is not. In version 2.0 onwards, the first
5854
// field is not overflow and the second is overflow
5855
// (the overflow bit goes with the overflow pointer).
5856
// Check first field to make sure its overflow bit is
5857
// set on.
5858
SanityManager.ASSERT(
5859                        StoredFieldHeader.isOverflow(firstFieldStatus));
5860                }
5861            }
5862
5863            long overflowPage =
5864                CompressedNumber.readLong((InputStream) rawDataIn);
5865            int overflowId =
5866                CompressedNumber.readInt((InputStream) rawDataIn);
5867
5868            // there is more after this chunk.
5869
fetchStream.setOverflowPage(overflowPage);
5870            fetchStream.setOverflowId(overflowId);
5871        }
5872    }
5873
5874
5875    /**
5876     * Log a Storable to a stream.
5877     * <p>
5878     * Log a Storable into a stream. This is used by update field operations
5879     * <P>
5880     * Write the column in its field format to the stream. Field format is a
5881     * field header followed the data of the column as defined by the data
5882     * itself. See this class's description for the specifics of the header.
5883     *
5884     * @exception StandardException Standard Cloudscape error policy
5885     * @exception IOException RESOLVE
5886     **/

5887    public void logColumn(
5888    int slot,
5889    int fieldId,
5890    Object JavaDoc column,
5891    DynamicByteArrayOutputStream out,
5892    int overflowThreshold)
5893        throws StandardException, IOException JavaDoc
5894    {
5895        // calculate the space available on the page, it includes
5896
// the free space
5897
// the space the record has reserved but not used
5898
// the length of the old field itself
5899

5900        // free space
5901
int bytesAvailable = freeSpace;
5902        int beginPosition = -1;
5903
5904        // space reserved, but not used by the record
5905
bytesAvailable += getReservedCount(slot);
5906
5907        // The size of the old field is also available for the new field
5908
rawDataIn.setPosition(getFieldOffset(slot, fieldId));
5909
5910        int fieldStatus =
5911            StoredFieldHeader.readStatus(rawDataIn);
5912        int fieldDataLength =
5913            StoredFieldHeader.readFieldDataLength(
5914                rawDataIn, fieldStatus, slotFieldSize);
5915
5916        bytesAvailable +=
5917            StoredFieldHeader.size(fieldStatus, fieldDataLength, slotFieldSize)
5918                + fieldDataLength;
5919
5920        try
5921        {
5922            setOutputStream(out);
5923            beginPosition = rawDataOut.getPosition();
5924
5925            Object JavaDoc[] row = new Object JavaDoc[1];
5926            row[0] = column;
5927            if (bytesAvailable == logColumn(
5928                                        row, 0, out, bytesAvailable,
5929                                        COLUMN_NONE, overflowThreshold))
5930            {
5931                throw new NoSpaceOnPage(isOverflowPage());
5932            }
5933
5934        }
5935        finally
5936        {
5937            rawDataOut.setPosition(beginPosition);
5938            resetOutputStream();
5939        }
5940    }
5941
5942    /**
5943     * Log a long column into a DataOuput.
5944     * <p>
5945     * Log a long column into a DataOuput. This is used by insert operations
5946     * <P>
5947     * Write the column in its field format to the stream. Field format is a
5948     * field header followed the data of the column as defined by the data
5949     * itself. See this class's description for the specifics of the header.
5950     *
5951     * @param slot slot of the row with the column
5952     * @param recordId record id of the
5953     * @param column the object form of the column to log
5954     * @param out where to log to the column to.
5955     *
5956     * @exception StandardException Standard Cloudscape error policy
5957     * @exception IOException I/O exception from writing to an array.
5958     *
5959     * @see BasePage#logColumn
5960     **/

5961    public int logLongColumn(
5962    int slot,
5963    int recordId,
5964    Object JavaDoc column,
5965    DynamicByteArrayOutputStream out)
5966        throws StandardException, IOException JavaDoc
5967    {
5968        int spaceAvailable = freeSpace;
5969
5970        // need to account for the slot table using extra space...
5971
spaceAvailable -= slotEntrySize;
5972
5973        // <= is ok here as we know we want to write at least one more byte
5974
if (spaceAvailable <= 0)
5975            throw new NoSpaceOnPage(isOverflowPage());
5976
5977        setOutputStream(out);
5978        int beginPosition = out.getPosition();
5979
5980        try
5981        {
5982            // in the long column portion on the new page there will be 1 field
5983
// if the portion fits on the page (2 if it needs another pointer
5984
// to continue to yet another page).
5985
int numberFields = 1;
5986
5987            StoredRecordHeader recordHeader =
5988                new StoredRecordHeader(recordId, numberFields);
5989
5990            int recordHeaderLength = recordHeader.write(logicalDataOut);
5991
5992            spaceAvailable -= recordHeaderLength;
5993
5994            if (spaceAvailable < 0)
5995            {
5996                // this part of long column won't totally fit on page, it
5997
// needs to be linked to another page. Throw exception and
5998
// caller will handle logging an overflow column portion
5999
// with a forward pointer.
6000

6001                throw new NoSpaceOnPage(isOverflowPage());
6002            }
6003            else
6004            {
6005                // the rest of the long column fits on the page!
6006

6007                Object JavaDoc[] row = new Object JavaDoc[1];
6008                row[0] = column;
6009                return logColumn(row, 0, out, spaceAvailable, COLUMN_LONG, 100);
6010            }
6011
6012        }
6013        finally
6014        {
6015            resetOutputStream();
6016        }
6017    }
6018
6019    /**
6020     * Log column from input row to the given output stream.
6021     * <p>
6022     * Read data from row[arrayPosition], and write the column data in
6023     * raw store page format to the given column. Along the way determine
6024     * if the column will fit on the current page.
6025     * <p>
6026     * Action taken in this routine is determined by the kind of column as
6027     * specified in the columnFlag:
6028     * COLUMN_NONE - the column is insignificant
6029     * COLUMN_FIRST - this is the first column in a logRow() call
6030     * COLUMN_LONG - this is a known long column, therefore we will
6031     * store part of the column on the current page and
6032     * overflow the rest if necessary.
6033     * <p>
6034     * Upon entry to this routine logicalDataOut is tied to the
6035     * DynamicByteArrayOutputStream out.
6036     * <BR>
6037     * If a column is a long column and it does not totally fit on the current
6038     * page, then a LongColumnException is thrown. We package up info about
6039     * the current long column in the partially filled in exception so that
6040     * callers can take correct action. The column will now be set a as a
6041     * stream.
6042     *
6043     * @return The spaceAvailable after accounting for space for this column.
6044     *
6045     * @param row array of column from which to read the column from.
6046     * @param arrayPosition The array position of column to be reading from row.
6047     * @param out The stream to write the raw store page format of the
6048     * the column to.
6049     * @param spaceAvailable The number of bytes available on the page for
6050     * this column, this may differ from current page
6051     * as it may include bytes used by previous
6052     * columns.
6053     * @param columnFlag one of: COLUMN_NONE, COLUMN_FIRST, or COLUMN_LONG.
6054     *
6055     * @exception StandardException Standard exception policy.
6056     * @exception LongColumnException Thrown if column will not fit on a
6057     * single page. See notes above
6058     **/

6059    private int logColumn(
6060    Object JavaDoc[] row,
6061    int arrayPosition,
6062    DynamicByteArrayOutputStream out,
6063    int spaceAvailable,
6064    int columnFlag,
6065    int overflowThreshold)
6066        throws StandardException, IOException JavaDoc
6067    {
6068        // RESOLVE (mikem) - why will row be null?
6069
Object JavaDoc column = (row != null ? row[arrayPosition] : null);
6070
6071        // Check to see if the data comes from a page, if it is, then the field
6072
// header is already formatted.
6073
if (column instanceof RawField)
6074        {
6075            // field data is raw, no need to set up a field header etc.
6076

6077            byte[] data = ((RawField) column).getData();
6078
6079            if (data.length <= spaceAvailable)
6080            {
6081                out.write(data);
6082                spaceAvailable -= data.length;
6083            }
6084            return spaceAvailable;
6085        }
6086
6087        // If this is a long column, it may fit in this page or it may not.
6088
boolean longColumnDone = true;
6089
6090
6091        // default field status.
6092
int fieldStatus =
6093            StoredFieldHeader.setFixed(StoredFieldHeader.setInitial(), true);
6094
6095        int beginPosition = out.getPosition();
6096        int columnBeginPosition = 0;
6097        int headerLength;
6098        int fieldDataLength = 0;
6099
6100        if (column instanceof StreamStorable)
6101        {
6102            StreamStorable stream_storable_column = (StreamStorable) column;
6103
6104            if (stream_storable_column.returnStream() != null)
6105            {
6106                column =
6107                    (Object JavaDoc) stream_storable_column.returnStream();
6108            }
6109        }
6110
6111        if (column == null)
6112        {
6113            fieldStatus = StoredFieldHeader.setNonexistent(fieldStatus);
6114            headerLength =
6115                StoredFieldHeader.write(
6116                    logicalDataOut, fieldStatus,
6117                    fieldDataLength, slotFieldSize);
6118        }
6119        else if (column instanceof InputStream)
6120        {
6121            RememberBytesInputStream bufferedIn = null;
6122            int bufferLen = 0;
6123
6124            int estimatedMaxDataSize =
6125                getMaxDataLength(spaceAvailable, overflowThreshold);
6126
6127            // if column is already instanceof RememberBytesInputStream, then we
6128
// need to find out how many bytes have already been stored in the
6129
// buffer.
6130
if (column instanceof RememberBytesInputStream)
6131            {
6132                // data is already RememberBytesInputStream
6133

6134                bufferedIn = (RememberBytesInputStream) column;
6135                bufferLen = bufferedIn.numBytesSaved();
6136
6137            }
6138            else
6139            {
6140                // data comes in as an inputstream
6141
bufferedIn = new RememberBytesInputStream(
6142                    (InputStream) column, new MemByteHolder(maxFieldSize + 1));
6143
6144                // always set stream of InputStream to RememberBytesInputStream
6145
// so that all future access to this column will be able to
6146
// get at the bytes drained from the InputStream, and copied
6147
// into the RememberBytesInputStream.
6148
if (row[arrayPosition] instanceof StreamStorable)
6149                    ((StreamStorable)row[arrayPosition]).setStream(bufferedIn);
6150                
6151                // set column to the RememberBytesInputStream so that
6152
// all future access to this column will be able to get
6153
// at bytes that have been already read. This assignment
6154
// is needed to ensure that if long column exception is
6155
// thrown, the column is set correctly
6156
column = bufferedIn;
6157            }
6158
6159            // read the buffer by reading the max we can read.
6160
if (bufferLen < (estimatedMaxDataSize + 1))
6161            {
6162                bufferLen +=
6163                    bufferedIn.fillBuf(estimatedMaxDataSize + 1 - bufferLen);
6164            }
6165
6166            if ((bufferLen <= estimatedMaxDataSize))
6167            {
6168                // we will be able to fit this into the page
6169

6170                fieldDataLength = bufferLen;
6171                fieldStatus = StoredFieldHeader.setFixed(fieldStatus, true);
6172                headerLength = StoredFieldHeader.write(
6173                                        logicalDataOut, fieldStatus,
6174                                        fieldDataLength, slotFieldSize);
6175    
6176                // if the field is extensible, then we write the serializable
6177
// formatId. if the field is non-extensible, we don't need to
6178
// write the formatId. but at this point, how do we know
6179
// whether the field is extensible or not??? For Plato release,
6180
// we do not support InputStream on extensible types,
6181
// therefore, we ignore the formatId for now.
6182
bufferedIn.putBuf(logicalDataOut, fieldDataLength);
6183            }
6184            else
6185            {
6186                // current column will not fit into the current page.
6187

6188                if (columnFlag == COLUMN_LONG)
6189                {
6190                    // column is a long column and the remaining portion does
6191
// not fit on the current page.
6192
longColumnDone = false;
6193                   
6194                    // it's a portion of a long column, and there is more to
6195
// write reserve enough room for overflow pointer, then
6196
// write as much data as we can leaving an extra 2 bytes
6197
// for overflow field header.
6198
fieldDataLength =
6199                        estimatedMaxDataSize - OVERFLOW_POINTER_SIZE - 2;
6200                    fieldStatus =
6201                        StoredFieldHeader.setFixed(fieldStatus, true);
6202
6203                    headerLength =
6204                        StoredFieldHeader.write(
6205                            logicalDataOut, fieldStatus,
6206                            fieldDataLength, slotFieldSize);
6207                    bufferedIn.putBuf(logicalDataOut, fieldDataLength);
6208
6209                    // now, we need to adjust the buffer, move the unread
6210
// bytes to the beginning position the cursor correctly,
6211
// so, next time around, we can read more into the buffer.
6212
int remainingBytes = bufferedIn.available();
6213
6214                    // move the unread bytes to the beginning of the byteHolder.
6215
int bytesShifted = bufferedIn.shiftToFront();
6216
6217                }
6218                else
6219                {
6220                    // column not a long column and does not fit on page.
6221
int delta = maxFieldSize - bufferLen + 1;
6222
6223                    if (delta > 0)
6224                        bufferLen += bufferedIn.fillBuf(delta);
6225                    fieldDataLength = bufferLen;
6226
6227                    // the data will not fit on this page make sure the new
6228
// input stream is passed back to the upper layer...
6229
column = (Object JavaDoc) bufferedIn;
6230                }
6231            }
6232        
6233        }
6234        else if (column instanceof DataValueDescriptor)
6235        {
6236            DataValueDescriptor sColumn = (DataValueDescriptor) column;
6237
6238            boolean isNull = sColumn.isNull();
6239            if (isNull)
6240            {
6241                fieldStatus = StoredFieldHeader.setNull(fieldStatus, true);
6242            }
6243
6244            // header is written with 0 length here.
6245
headerLength =
6246                StoredFieldHeader.write(
6247                    logicalDataOut, fieldStatus,
6248                    fieldDataLength, slotFieldSize);
6249
6250            if (!isNull)
6251            {
6252                // write the field data to the log
6253
try
6254                {
6255                    columnBeginPosition = out.getPosition();
6256                    sColumn.writeExternal(logicalDataOut);
6257                }
6258                catch (IOException JavaDoc ioe)
6259                {
6260                    // SQLData error reporting
6261
if (logicalDataOut != null)
6262                    {
6263                        Exception JavaDoc ne = logicalDataOut.getNestedException();
6264                        if (ne != null)
6265                        {
6266                            if (ne instanceof StandardException)
6267                            {
6268                                throw (StandardException) ne;
6269                            }
6270                        }
6271                    }
6272
6273
6274                    throw StandardException.newException(
6275                            SQLState.DATA_STORABLE_WRITE_EXCEPTION, ioe);
6276                }
6277
6278                fieldDataLength =
6279                    (out.getPosition() - beginPosition) - headerLength;
6280            }
6281        }
6282        else if (column instanceof RecordHandle)
6283        {
6284            // we are inserting an overflow pointer for a long column
6285

6286            // casted reference to column to avoid repeated casting.
6287
RecordHandle overflowHandle = (RecordHandle) column;
6288
6289            fieldStatus = StoredFieldHeader.setOverflow(fieldStatus, true);
6290            headerLength =
6291                StoredFieldHeader.write(
6292                    logicalDataOut, fieldStatus,
6293                    fieldDataLength, slotFieldSize);
6294
6295            fieldDataLength +=
6296                CompressedNumber.writeLong(out, overflowHandle.getPageNumber());
6297            fieldDataLength +=
6298                CompressedNumber.writeInt(out, overflowHandle.getId());
6299
6300        }
6301        else
6302        {
6303            // Serializable/Externalizable/Formattable
6304
// all look the same at this point.
6305

6306            // header is written with 0 length here.
6307
headerLength =
6308                StoredFieldHeader.write(
6309                    logicalDataOut, fieldStatus,
6310                    fieldDataLength, slotFieldSize);
6311
6312            logicalDataOut.writeObject(column);
6313            fieldDataLength =
6314                (out.getPosition() - beginPosition) - headerLength;
6315        }
6316
6317        // calculate the size of the field on page with compresed field header
6318

6319        fieldStatus = StoredFieldHeader.setFixed(fieldStatus, false);
6320        int fieldSizeOnPage =
6321            StoredFieldHeader.size(fieldStatus, fieldDataLength, slotFieldSize)
6322            + fieldDataLength;
6323
6324        userRowSize += fieldDataLength;
6325
6326        boolean fieldIsLong = isLong(fieldSizeOnPage, overflowThreshold);
6327       
6328        // Do we have enough space on the page for this field?
6329
if (((spaceAvailable < fieldSizeOnPage) || (fieldIsLong)) &&
6330            (columnFlag != COLUMN_LONG))
6331        {
6332            // Column was not long before getting here and does not fit.
6333

6334            if (fieldIsLong)
6335            {
6336                // long column, and this first time we have figured out this
6337
// column is long.
6338

6339                if (!(column instanceof InputStream))
6340                {
6341                    // Convert already written object to an InputStream.
6342
ByteArray fieldData =
6343                        new ByteArray(
6344                            ((DynamicByteArrayOutputStream)out).getByteArray(),
6345                            (columnBeginPosition), fieldDataLength);
6346
6347                    ByteArrayInputStream JavaDoc columnIn =
6348                        new ByteArrayInputStream JavaDoc(
6349                            fieldData.getArray(), columnBeginPosition,
6350                            fieldDataLength);
6351
6352                    MemByteHolder byteHolder =
6353                        new MemByteHolder(fieldDataLength + 1);
6354
6355                    RememberBytesInputStream bufferedIn =
6356                        new RememberBytesInputStream(columnIn, byteHolder);
6357 
6358                    // the data will not fit on this page make sure the new
6359
// input stream is passed back to the upper layer...
6360
column = bufferedIn;
6361                }
6362
6363                out.setPosition(beginPosition);
6364
6365                // This exception carries the information for the client
6366
// routine to continue inserting the long row on multiple
6367
// pages.
6368
LongColumnException lce = new LongColumnException();
6369                lce.setColumn(column);
6370                throw lce;
6371
6372            }
6373            else
6374            {
6375                // Column does not fit on this page, but it isn't a long column.
6376

6377                out.setPosition(beginPosition);
6378                return(spaceAvailable);
6379            }
6380        }
6381 
6382        // Now we go back to update the fieldDataLength in the field header
6383
out.setPosition(beginPosition);
6384
6385        // slotFieldSize is set based on the pageSize.
6386
// We are borrowing this to set the size of our fieldDataLength.
6387
fieldStatus = StoredFieldHeader.setFixed(fieldStatus, true);
6388        headerLength = StoredFieldHeader.write(
6389                            out, fieldStatus, fieldDataLength, slotFieldSize);
6390
6391        // set position to the end of the field
6392
out.setPosition(beginPosition + fieldDataLength + headerLength);
6393
6394        spaceAvailable -= fieldSizeOnPage;
6395
6396        // YYZ: revisit
6397
if (columnFlag == COLUMN_LONG)
6398        {
6399            // if we are logging a long column, we don't care how much space
6400
// is left on the page, instead, we care whether we are done with
6401
// the column or not. So, here, we want to return 1. if we are
6402
// not done, and return -1 if we are done.
6403
// If logColumn returns -1, that flag is returned all the way to
6404
// BasePage.insertLongColumn to signal end of loop.
6405
if (longColumnDone)
6406                return -1;
6407            else
6408                return 1;
6409        } else
6410        {
6411            return (spaceAvailable);
6412        }
6413    }
6414
6415    /**
6416     * Create and write a long row header to the log stream.
6417     * <p>
6418     * Called to log a new overflow record, will check for space available
6419     * and throw an exception if the record header will not fit on the page.
6420     * <p>
6421     *
6422     * @return -1
6423     *
6424     * @param slot slot of record to log.
6425     * @param spaceAvailable spaceAvaliable on page.
6426     * @param out stream to log the record to.
6427     *
6428     * @exception StandardException Standard exception policy.
6429     **/

6430    private int logOverflowRecord(
6431    int slot,
6432    int spaceAvailable,
6433    DynamicByteArrayOutputStream out)
6434        throws StandardException, IOException JavaDoc
6435    {
6436        setOutputStream(out);
6437        
6438        StoredRecordHeader pageRecordHeader = getHeaderAtSlot(slot);
6439                
6440        StoredRecordHeader overflow_rh = getOverFlowRecordHeader();
6441        overflow_rh.setOverflowFields(pageRecordHeader);
6442
6443        if (SanityManager.DEBUG)
6444        {
6445            SanityManager.ASSERT(overflow_rh.getOverflowPage() != 0);
6446        }
6447
6448        /*
6449        // #1 situation,
6450        // we want to update the header to just an overflow pointer with no data
6451        // so, update the recordHeader, and we are done...
6452        if (!overflow_rh.isPartialOverflow()) {
6453            // this recordHeader becomes just a overflow pointer,
6454            // we need to make sure that the number of fields is set to 0.
6455            overflow_rh.setNumberFields(0);
6456            
6457            spaceAvailable -= overflow_rh.write(logicalDataOut);
6458
6459            if (spaceAvailable < 0) {
6460                throw new NoSpaceOnPage(isOverflowPage());
6461            }
6462
6463            resetOutputStream();
6464
6465            return (-1);
6466        }
6467        */

6468
6469        // #2 situation,
6470
// we want to only update the recordheader of the page, while leaving
6471
// the data of the record on the page. Just update the header part and
6472
// then arrange for the data part to move to after the new header.
6473

6474        int oldSize = pageRecordHeader.size();
6475        int newSize = overflow_rh.size();
6476
6477        if (oldSize < newSize)
6478        {
6479            // need extra room...
6480
int delta = newSize - oldSize;
6481            if (spaceAvailable < delta)
6482            {
6483                throw new NoSpaceOnPage(isOverflowPage());
6484            }
6485        }
6486
6487        // write the new overflow_rh for the record.
6488
overflow_rh.write(logicalDataOut);
6489
6490        // now, log the data
6491
logRecordDataPortion(
6492            slot, LOG_RECORD_DEFAULT, pageRecordHeader,
6493            (FormatableBitSet) null, logicalDataOut, (RecordHandle)null);
6494
6495        return (-1);
6496    }
6497
6498    private int logOverflowField(
6499    DynamicByteArrayOutputStream out,
6500    int spaceAvailable,
6501    long overflowPage,
6502    int overflowId)
6503        throws StandardException, IOException JavaDoc
6504    {
6505        int fieldStatus =
6506            StoredFieldHeader.setOverflow(
6507                StoredFieldHeader.setInitial(), true);
6508
6509        int fieldSizeOnPage =
6510            CompressedNumber.sizeLong(overflowPage) +
6511            CompressedNumber.sizeInt(overflowId);
6512
6513        int fieldDataLength = fieldSizeOnPage;
6514
6515        fieldSizeOnPage +=
6516            StoredFieldHeader.size(fieldStatus, fieldDataLength, slotFieldSize);
6517
6518        // need to check that we have room on the page for this.
6519
spaceAvailable -= fieldSizeOnPage;
6520
6521        // what if there is not enough room for the overflow pointer?
6522
if (spaceAvailable < 0)
6523            throw new NoSpaceOnPage(isOverflowPage());
6524
6525        // write the field to the page:
6526
StoredFieldHeader.write(
6527            logicalDataOut, fieldStatus, fieldDataLength, slotFieldSize);
6528        CompressedNumber.writeLong(out, overflowPage);
6529        CompressedNumber.writeInt(out, overflowId);
6530
6531        // return the available bytes
6532
return(spaceAvailable);
6533    }
6534
6535    /**
6536     * Log a record to the ObjectOutput stream.
6537     * <p>
6538     * Write out the complete on-page record to the store stream. Data is
6539     * preceeded by a compressed int that gives the length of the following
6540     * data.
6541     *
6542     * @exception StandardException Standard Cloudscape error policy
6543     * @exception IOException on error writing to log stream.
6544     *
6545     * @see BasePage#logRecord
6546     **/

6547    public void logRecord(
6548    int slot,
6549    int flag,
6550    int recordId,
6551    FormatableBitSet validColumns,
6552    OutputStream out,
6553    RecordHandle headRowHandle)
6554        throws StandardException, IOException JavaDoc
6555    {
6556        StoredRecordHeader recordHeader = getHeaderAtSlot(slot);
6557
6558        if (recordId != recordHeader.getId())
6559        {
6560            // the record is being logged under a different identifier,
6561
// write it out with the correct identifier
6562
StoredRecordHeader newRecordHeader =
6563                new StoredRecordHeader(recordHeader);
6564
6565            newRecordHeader.setId(recordId);
6566
6567            newRecordHeader.write(out);
6568            newRecordHeader = null;
6569        }
6570        else
6571        {
6572            // write the original record header
6573
recordHeader.write(out);
6574        }
6575
6576        logRecordDataPortion(
6577            slot, flag, recordHeader, validColumns, out, headRowHandle);
6578
6579    }
6580
6581    private void logRecordDataPortion(
6582    int slot,
6583    int flag,
6584    StoredRecordHeader recordHeader,
6585    FormatableBitSet validColumns,
6586    OutputStream out,
6587    RecordHandle headRowHandle)
6588        throws StandardException, IOException JavaDoc
6589    {
6590        int offset = getRecordOffset(slot);
6591
6592        // now skip over the original header before writing the data
6593
int oldHeaderLength = recordHeader.size();
6594        offset += oldHeaderLength;
6595
6596        // write out the record data (FH+data+...) from the page data
6597
int startField = recordHeader.getFirstField();
6598        int endField = startField + recordHeader.getNumberFields();
6599        int validColumnsSize = (validColumns == null) ? 0 : validColumns.getLength();
6600
6601        for (int fieldId = startField; fieldId < endField; fieldId++) {
6602
6603            rawDataIn.setPosition(offset);
6604
6605            // get the field header information from the page
6606
int fieldStatus = StoredFieldHeader.readStatus(rawDataIn);
6607            int fieldDataLength = StoredFieldHeader.readFieldDataLength(rawDataIn, fieldStatus, slotFieldSize);
6608
6609            // see if this field needs to be logged
6610
// no need to write the data portion if the log is getting written
6611
// for purges unless the field is overflow pointer for a long column.
6612
if (((validColumns != null) && !(validColumnsSize > fieldId && validColumns.isSet(fieldId))) ||
6613                ((flag & BasePage.LOG_RECORD_FOR_PURGE)!=0 && !StoredFieldHeader.isOverflow(fieldStatus)))
6614            {
6615                // nope, move page offset along
6616
offset += StoredFieldHeader.size(fieldStatus, fieldDataLength, slotFieldSize);
6617                offset += fieldDataLength;
6618
6619                // write a non-existent field
6620
fieldStatus = StoredFieldHeader.setInitial();
6621                fieldStatus = StoredFieldHeader.setNonexistent(fieldStatus);
6622                StoredFieldHeader.write(out, fieldStatus, 0, slotFieldSize);
6623                continue;
6624            }
6625
6626            // If this field is to be updated, and it points to a long column
6627
// chain, the entire long column chain will be orphaned after the
6628
// update operation. Therefore, need to queue up a post commit
6629
// work to reclaim the long column chain. We cannot do any clean
6630
// up in this transaction now because we are underneath a log
6631
// action and cannot interrupt the transaction log buffer.
6632
// HeadRowHandle may be null if updateAtSlot is called to update a
6633
// non-head row piece. In that case, don't do anything.
6634
// If temp container, don't do anything.
6635
if (((flag & BasePage.LOG_RECORD_FOR_UPDATE) != 0) &&
6636                headRowHandle != null &&
6637                StoredFieldHeader.isOverflow(fieldStatus) &&
6638                owner.isTemporaryContainer() == false)
6639            {
6640
6641                int saveOffset = rawDataIn.getPosition(); // remember the page offset
6642
long overflowPage = CompressedNumber.readLong((InputStream) rawDataIn);
6643                int overflowId = CompressedNumber.readInt((InputStream) rawDataIn);
6644
6645                // Remember the time stamp on the first page of the column
6646
// chain. This is to prevent the case where the post commit
6647
// work gets fired twice, in that case, the second time it is
6648
// fired, this overflow page may not part of this row chain
6649
// that is being updated.
6650
Page firstPageOnColumnChain = getOverflowPage(overflowPage);
6651                PageTimeStamp ts = firstPageOnColumnChain.currentTimeStamp();
6652                firstPageOnColumnChain.unlatch();
6653
6654                RawTransaction rxact = (RawTransaction)owner.getTransaction();
6655
6656                ReclaimSpace work =
6657                    new ReclaimSpace(ReclaimSpace.COLUMN_CHAIN,
6658                                headRowHandle,
6659                                fieldId, // long column about to be orphaned by update
6660
overflowPage, // page where the long column starts
6661
overflowId, // record Id of the beginning of the long column
6662
ts,
6663                                rxact.getDataFactory(), true);
6664
6665                rxact.addPostCommitWork(work);
6666
6667                rawDataIn.setPosition(saveOffset); // Just to be safe, reset data stream
6668
}
6669
6670
6671            // write the field header for the log
6672
offset += StoredFieldHeader.write(out, fieldStatus, fieldDataLength, slotFieldSize);
6673
6674            if (fieldDataLength != 0) {
6675
6676                // write the actual data
6677
out.write(pageData, offset, fieldDataLength);
6678
6679                offset += fieldDataLength;
6680            }
6681        }
6682    }
6683
6684    /**
6685        Log a field to the ObjectOutput stream.
6686        <P>
6687        Find the field in the record and then write out the complete
6688        field, i.e. header and data.
6689
6690        @exception StandardException Standard Cloudscape error policy
6691        @exception IOException RESOLVE
6692
6693        @see BasePage#logField
6694    */

6695
6696    public void logField(int slot, int fieldNumber, OutputStream out)
6697        throws StandardException, IOException JavaDoc
6698    {
6699        int offset = getFieldOffset(slot, fieldNumber);
6700
6701        // these reads are always against the page array
6702
ArrayInputStream lrdi = rawDataIn;
6703
6704        // now write out the field we are interested in ...
6705
lrdi.setPosition(offset);
6706        int fieldStatus = StoredFieldHeader.readStatus(lrdi);
6707        int fieldDataLength = StoredFieldHeader.readFieldDataLength(lrdi, fieldStatus, slotFieldSize);
6708
6709        StoredFieldHeader.write(out, fieldStatus, fieldDataLength, slotFieldSize);
6710        
6711        if (fieldDataLength != 0) {
6712            // and then the data
6713
out.write(pageData, lrdi.getPosition(), fieldDataLength);
6714        }
6715    }
6716
6717    /*
6718    ** Overidden methods of BasePage
6719    */

6720
6721    /**
6722        Override insertAtSlot to provide long row support.
6723        @exception StandardException Standard Cloudscape error policy
6724    */

6725    public RecordHandle insertAtSlot(
6726    int slot,
6727    Object JavaDoc[] row,
6728    FormatableBitSet validColumns,
6729    LogicalUndo undo,
6730    byte insertFlag,
6731    int overflowThreshold)
6732        throws StandardException
6733    {
6734        try {
6735
6736            return super.insertAtSlot(slot, row, validColumns, undo, insertFlag, overflowThreshold);
6737
6738        } catch (NoSpaceOnPage nsop) {
6739
6740            // Super class already handle the case of insert that allows overflow.
6741
// If we get here, we know that the insert should not allow overflow.
6742
// Possibles causes:
6743
// 1. insert to an empty page, row will never fit (ie long row)
6744
// 2. insert to original page
6745
// we will do:
6746
// return a null to indicate the insert cannot be accepted ..
6747
return null;
6748
6749        }
6750    }
6751    
6752
6753    /**
6754        Update field at specified slot
6755        @exception StandardException Standard Cloudscape error policy
6756    */

6757    public RecordHandle updateFieldAtSlot(
6758    int slot,
6759    int fieldId,
6760    Object JavaDoc newValue,
6761    LogicalUndo undo)
6762        throws StandardException
6763    {
6764        try {
6765
6766            return super.updateFieldAtSlot(slot, fieldId, newValue, undo);
6767
6768        } catch (NoSpaceOnPage nsop) {
6769
6770
6771            // empty page apart from the record
6772
if (slotsInUse == 1)
6773            {
6774                throw StandardException.newException(
6775                    SQLState.DATA_NO_SPACE_FOR_RECORD);
6776            }
6777            throw StandardException.newException(
6778                    SQLState.DATA_NO_SPACE_FOR_RECORD);
6779
6780/*
6781// djd if (isOverflowPage()) {
6782            }
6783
6784            return XXX;
6785*/

6786        }
6787
6788    }
6789
6790    /**
6791        Get the number of fields on the row at slot
6792        @exception StandardException Standard Cloudscape error policy
6793    */

6794    public int fetchNumFieldsAtSlot(int slot) throws StandardException
6795    {
6796
6797        StoredRecordHeader recordHeader = getHeaderAtSlot(slot);
6798
6799        if (!recordHeader.hasOverflow())
6800            return super.fetchNumFieldsAtSlot(slot);
6801
6802        BasePage overflowPage = getOverflowPage(recordHeader.getOverflowPage());
6803        int count = overflowPage.fetchNumFieldsAtSlot(getOverflowSlot(overflowPage, recordHeader));
6804        overflowPage.unlatch();
6805        return count;
6806    }
6807
6808    /**
6809     * Move record to a page toward the beginning of the file.
6810     * <p>
6811     * As part of compressing the table records need to be moved from the
6812     * end of the file toward the beginning of the file. Only the
6813     * contiguous set of free pages at the very end of the file can
6814     * be given back to the OS. This call is used to purge the row from
6815     * the current page, insert it into a previous page, and return the
6816     * new row location
6817     * Mark the record identified by position as deleted. The record may be
6818     * undeleted sometime later using undelete() by any transaction that sees
6819     * the record.
6820     * <p>
6821     * The interface is optimized to work on a number of rows at a time,
6822     * optimally processing all rows on the page at once. The call will
6823     * process either all rows on the page, or the number of slots in the
6824     * input arrays - whichever is smaller.
6825     * <B>Locking Policy</B>
6826     * <P>
6827     * MUST be called with table locked, not locks are requested. Because
6828     * it is called with table locks the call will go ahead and purge any
6829     * row which is marked deleted. It will also use purge rather than
6830     * delete to remove the old row after it moves it to a new page. This
6831     * is ok since the table lock insures that no other transaction will
6832     * use space on the table before this transaction commits.
6833     *
6834     * <BR>
6835     * A page latch on the new page will be requested and released.
6836     *
6837     * @param slot slot of original row to move.
6838     * @param row a row template to hold all columns of row.
6839     * @param old_handle An array to be filled in by the call with the
6840     * old handles of all rows moved.
6841     * @param new_handle An array to be filled in by the call with the
6842     * new handles of all rows moved.
6843     *
6844     * @return the number of rows processed.
6845     *
6846     * @exception StandardException Standard Cloudscape error policy
6847     *
6848     **/

6849    public int moveRecordForCompressAtSlot(
6850    int slot,
6851    Object JavaDoc[] row,
6852    RecordHandle[] old_handle,
6853    RecordHandle[] new_handle)
6854        throws StandardException
6855    {
6856        long src_pageno = getPageNumber();
6857
6858        try
6859        {
6860            fetchFromSlot(
6861                null,
6862                slot,
6863                row,
6864                (FetchDescriptor) null, // all columns retrieved
6865
false);
6866
6867            int row_size = getRecordPortionLength(slot);
6868
6869            // first see if row will fit on current page being used to insert
6870
StoredPage dest_page =
6871                (StoredPage) owner.getPageForCompress(0, src_pageno);
6872
6873            if (dest_page != null)
6874            {
6875                if ((dest_page.getPageNumber() >= getPageNumber()) ||
6876                    (!dest_page.spaceForCopy(row_size)))
6877                {
6878                    // page won't work
6879
dest_page.unlatch();
6880                    dest_page = null;
6881                }
6882            }
6883
6884            if (dest_page == null)
6885            {
6886                // last page did not work, try unfilled page
6887
dest_page = (StoredPage)
6888                    owner.getPageForCompress(
6889                        ContainerHandle.GET_PAGE_UNFILLED, src_pageno);
6890
6891                if (dest_page != null)
6892                {
6893                    if ((dest_page.getPageNumber() >= getPageNumber()) ||
6894                        (!dest_page.spaceForCopy(row_size)))
6895                    {
6896                        // page won't work
6897
dest_page.unlatch();
6898                        dest_page = null;
6899                    }
6900                }
6901            }
6902
6903            if (dest_page == null)
6904            {
6905                // last and unfilled page did not work, try getting a free page
6906
dest_page = (StoredPage) owner.addPage();
6907
6908                if (dest_page.getPageNumber() >= getPageNumber())
6909                {
6910                    owner.removePage(dest_page);
6911                    dest_page = null;
6912                }
6913            }
6914
6915            if (dest_page !=