001: /* Copyright (c) 2001-2005, The HSQL Development Group
002: * All rights reserved.
003: *
004: * Redistribution and use in source and binary forms, with or without
005: * modification, are permitted provided that the following conditions are met:
006: *
007: * Redistributions of source code must retain the above copyright notice, this
008: * list of conditions and the following disclaimer.
009: *
010: * Redistributions in binary form must reproduce the above copyright notice,
011: * this list of conditions and the following disclaimer in the documentation
012: * and/or other materials provided with the distribution.
013: *
014: * Neither the name of the HSQL Development Group nor the names of its
015: * contributors may be used to endorse or promote products derived from this
016: * software without specific prior written permission.
017: *
018: * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
019: * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
020: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
021: * ARE DISCLAIMED. IN NO EVENT SHALL HSQL DEVELOPMENT GROUP, HSQLDB.ORG,
022: * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
023: * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
024: * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
025: * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
026: * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
027: * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
028: * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
029: */
030:
031: package org.hsqldb;
032:
033: import java.io.IOException;
034:
035: import org.hsqldb.rowio.RowInputInterface;
036: import org.hsqldb.rowio.RowOutputInterface;
037:
038: // fredt@users 20021205 - path 1.7.2 - enhancements
039: // fredt@users 20021215 - doc 1.7.2 - javadoc comments
040:
041: /**
042: * Implementation of rows for tables with memory resident indexes and
043: * disk-based data, such as TEXT tables.
044: *
045: * @version 1.7.2
046: */
047: class CachedDataRow extends CachedRow {
048:
049: /**
050: * Constructor for new rows.
051: */
052: CachedDataRow(Table t, Object[] o) throws HsqlException {
053:
054: super (t, o);
055:
056: hasDataChanged = true;
057: }
058:
059: /**
060: * Constructor when read from the disk into the Cache. The link with
061: * the Nodes is made separetly.
062: */
063: CachedDataRow(Table t, RowInputInterface in) throws IOException,
064: HsqlException {
065:
066: tTable = t;
067: iPos = in.getPos();
068: storageSize = in.getSize();
069: oData = in.readData(tTable.getColumnTypes());
070: hasDataChanged = false;
071: }
072:
073: /**
074: * As the indexes are in-memory, this passes the existing primary node
075: * for the construction of the new Row
076: */
077: Row getUpdatedRow() throws HsqlException {
078: return tTable.getRow(iPos, nPrimaryNode);
079: }
080:
081: /**
082: * Used when data is read from the disk into the Cache the first time.
083: * New Nodes are created which are then indexed.
084: */
085: void setNewNodes() {
086:
087: int index = tTable.getIndexCount();
088:
089: nPrimaryNode = Node.newNode(this , 0, tTable);
090:
091: Node n = nPrimaryNode;
092:
093: for (int i = 1; i < index; i++) {
094: n.nNext = Node.newNode(this , i, tTable);
095: n = n.nNext;
096: }
097: }
098:
099: /**
100: * Used when data is re-read from the disk into the Cache. The Row is
101: * already indexed so it is linked with the Node in the primary index.
102: * the Nodes is made separetly.
103: */
104: void setPrimaryNode(Node primary) {
105: nPrimaryNode = primary;
106: }
107:
108: /**
109: * returned size does not include the row size written at the beginning
110: */
111: public int getRealSize(RowOutputInterface out) {
112: return out.getSize(this );
113: }
114:
115: /**
116: * Writes the data to disk. Unlike CachedRow, hasChanged is never set
117: * to true when changes are made to the Nodes. (Nodes are in-memory).
118: * The only time this is used is when a new Row is added to the Caches.
119: */
120: public void write(RowOutputInterface out) {
121:
122: out.writeSize(storageSize);
123: out.writeData(oData, tTable);
124: out.writeEnd();
125:
126: hasDataChanged = false;
127: }
128:
129: public boolean hasChanged() {
130: return hasDataChanged;
131: }
132:
133: /**
134: * Sets the file position for the row and registers the row with
135: * the table.
136: *
137: * @param pos position in data file
138: */
139: public void setPos(int pos) {
140:
141: iPos = pos;
142:
143: Node n = nPrimaryNode;
144:
145: while (n != null) {
146: ((PointerNode) n).iData = iPos;
147: n = n.nNext;
148: }
149: }
150:
151: /**
152: * With the current implementation of TEXT table updates and inserts,
153: * the lifetime scope of this method extends until redefinition of table
154: * data source or shutdown.
155: *
156: * @param obj the reference object with which to compare.
157: * @return <code>true</code> if this object is the same as the obj argument;
158: * <code>false</code> otherwise.
159: */
160: public boolean equals(Object obj) {
161:
162: if (obj == this ) {
163: return true;
164: }
165:
166: if (obj instanceof CachedDataRow) {
167: return ((CachedDataRow) obj).iPos == iPos
168: && ((CachedDataRow) obj).tTable == tTable;
169: }
170:
171: return false;
172: }
173: }
|