KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > hsqldb > Row


1 /* Copyright (c) 1995-2000, The Hypersonic SQL Group.
2  * All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions are met:
6  *
7  * Redistributions of source code must retain the above copyright notice, this
8  * list of conditions and the following disclaimer.
9  *
10  * Redistributions in binary form must reproduce the above copyright notice,
11  * this list of conditions and the following disclaimer in the documentation
12  * and/or other materials provided with the distribution.
13  *
14  * Neither the name of the Hypersonic SQL Group nor the names of its
15  * contributors may be used to endorse or promote products derived from this
16  * software without specific prior written permission.
17  *
18  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
19  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
20  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
21  * ARE DISCLAIMED. IN NO EVENT SHALL THE HYPERSONIC SQL GROUP,
22  * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
23  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
24  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
25  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
26  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
28  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29  *
30  * This software consists of voluntary contributions made by many individuals
31  * on behalf of the Hypersonic SQL Group.
32  *
33  *
34  * For work added by the HSQL Development Group:
35  *
36  * Copyright (c) 2001-2005, The HSQL Development Group
37  * All rights reserved.
38  *
39  * Redistribution and use in source and binary forms, with or without
40  * modification, are permitted provided that the following conditions are met:
41  *
42  * Redistributions of source code must retain the above copyright notice, this
43  * list of conditions and the following disclaimer.
44  *
45  * Redistributions in binary form must reproduce the above copyright notice,
46  * this list of conditions and the following disclaimer in the documentation
47  * and/or other materials provided with the distribution.
48  *
49  * Neither the name of the HSQL Development Group nor the names of its
50  * contributors may be used to endorse or promote products derived from this
51  * software without specific prior written permission.
52  *
53  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
54  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
55  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
56  * ARE DISCLAIMED. IN NO EVENT SHALL HSQL DEVELOPMENT GROUP, HSQLDB.ORG,
57  * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
58  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
59  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
60  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
61  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
62  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
63  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
64  */
65
66
67 package org.hsqldb;
68
69 import org.hsqldb.lib.IntLookup;
70 import org.hsqldb.lib.java.JavaSystem;
71 import org.hsqldb.persist.CachedObject;
72 import org.hsqldb.rowio.RowOutputInterface;
73
74 // fredt@users 20020221 - patch 513005 by sqlbob@users (RMP)
75 // fredt@users 20020920 - patch 1.7.1 - refactoring to cut mamory footprint
76 // fredt@users 20021215 - doc 1.7.2 - javadoc comments
77
78 /**
79  * Base class for a database row object implementing rows for
80  * memory resident tables.<p>
81  *
82  * Subclass CachedRow implements rows for CACHED and TEXT tables
83  *
84  * @author Thomas Mueller (Hypersonic SQL Group)
85  * @version 1.8.0
86  * @since Hypersonic SQL
87  */
88 public class Row implements CachedObject {
89
90     int tableId;
91     int iPos;
92     protected Object JavaDoc[] oData;
93     protected Node nPrimaryNode;
94
95     /**
96      * Default constructor used only in subclasses.
97      */
98     protected Row() {}
99
100     /**
101      * Constructor for MEMORY table Row. The result is a Row with Nodes that
102      * are not yet linked with other Nodes in the AVL indexes.
103      */
104     Row(Table t, Object JavaDoc[] o) throws HsqlException {
105
106         int index = t.getIndexCount();
107
108         nPrimaryNode = Node.newNode(this, 0, t);
109
110         Node n = nPrimaryNode;
111
112         for (int i = 1; i < index; i++) {
113             n.nNext = Node.newNode(this, i, t);
114             n = n.nNext;
115         }
116
117         tableId = t.getId();
118         oData = o;
119     }
120
121     /**
122      * Returns the Node for a given Index, using the ordinal position of the
123      * Index within the Table Object.
124      */
125     Node getNode(int index) {
126
127         Node n = nPrimaryNode;
128
129         while (index-- > 0) {
130             n = n.nNext;
131         }
132
133         return n;
134     }
135
136     /**
137      * Returns the Node for the next Index on this database row, given the
138      * Node for any Index.
139      */
140     Node getNextNode(Node n) {
141
142         if (n == null) {
143             n = nPrimaryNode;
144         } else {
145             n = n.nNext;
146         }
147
148         return n;
149     }
150
151     /**
152      * Returns the Row Object that currently represents the same database row.
153      * In current implementations of Row, this is always the same as the this
154      * Object for MEMORY tables, but could be a different Object for CachedRow
155      * or CachedDataRow implementation. For example the Row Object that
156      * represents a given database row can be freed from the Cache when other
157      * rows need to be loaded into the Cache. getUpdatedRow() returns a
158      * currently valid Row object that is in the Cache.
159      */
160     Row getUpdatedRow() throws HsqlException {
161         return this;
162     }
163
164     /**
165      * Returns the array of fields in the database row.
166      */
167     public Object JavaDoc[] getData() {
168         return oData;
169     }
170
171     /**
172      * Is used only when the database row is deleted, not when it is freed
173      * from the Cache.
174      */
175     void delete() throws HsqlException {
176
177         JavaSystem.memoryRecords++;
178
179         nPrimaryNode = null;
180     }
181
182     void clearNodeLinks() {
183
184         Node last;
185         Node temp;
186
187         last = nPrimaryNode;
188
189         while (last.nNext != null) {
190             temp = last.nNext;
191             last.nNext = null;
192             last = temp;
193         }
194
195         nPrimaryNode = null;
196     }
197
198     boolean isCascadeDeleted() {
199         return nPrimaryNode == null;
200     }
201
202     public int getRealSize(RowOutputInterface out) {
203         return 0;
204     }
205
206     public void setStorageSize(int size) {
207         ;
208     }
209
210     public int getStorageSize() {
211         return 0;
212     }
213
214     public long getId() {
215         return ((long) tableId << 32) + ((long) iPos);
216     }
217
218     public static long getId(Table table, int pos) {
219         return ((long) table.getId() << 32) + ((long) pos);
220     }
221
222     public int getPos() {
223         return iPos;
224     }
225
226     public void setPos(int pos) {
227         iPos = pos;
228     }
229
230     public boolean hasChanged() {
231         return false;
232     }
233
234     public boolean isKeepInMemory() {
235         return true;
236     }
237
238     public void keepInMemory(boolean keep) {}
239
240     public boolean isInMemory() {
241         return true;
242     }
243
244     public void setInMemory(boolean in) {}
245
246     public void write(RowOutputInterface out) {}
247
248     public void write(RowOutputInterface out, IntLookup lookup) {}
249
250     /**
251      * Lifetime scope of this method depends on the operations performed on
252      * any cached tables since this row or the parameter were constructed.
253      * If only deletes or only inserts have been performed, this method
254      * remains valid. Otherwise it can return invalid results.
255      *
256      * @param obj row to compare
257      * @return boolean
258      */
259     public boolean equals(Object JavaDoc obj) {
260
261         if (obj == this) {
262             return true;
263         }
264
265         if (obj instanceof Row) {
266             return ((Row) obj).iPos == iPos;
267         }
268
269         return false;
270     }
271
272     /**
273      * Hash code is valid only until a modification to the cache
274      *
275      * @return file position of row
276      */
277     public int hashCode() {
278         return iPos;
279     }
280 }
281
Popular Tags