Java > Open Source Codes > org > hsqldb > Log


1 /* Copyrights and Licenses
2  *
3  * This product includes Hypersonic SQL.
4  * Originally developed by Thomas Mueller and the Hypersonic SQL Group.
5  *
6  * Copyright (c) 1995-2000 by the Hypersonic SQL Group. All rights reserved.
7  * Redistribution and use in source and binary forms, with or without modification, are permitted
8  * provided that the following conditions are met:
9  * - Redistributions of source code must retain the above copyright notice, this list of conditions
10  * and the following disclaimer.
11  * - Redistributions in binary form must reproduce the above copyright notice, this list of
12  * conditions and the following disclaimer in the documentation and/or other materials
13  * provided with the distribution.
14  * - All advertising materials mentioning features or use of this software must display the
15  * following acknowledgment: "This product includes Hypersonic SQL."
16  * - Products derived from this software may not be called "Hypersonic SQL" nor may
17  * "Hypersonic SQL" appear in their names without prior written permission of the
18  * Hypersonic SQL Group.
19  * - Redistributions of any form whatsoever must retain the following acknowledgment: "This
20  * product includes Hypersonic SQL."
21  * This software is provided "as is" and any expressed or implied warranties, including, but
22  * not limited to, the implied warranties of merchantability and fitness for a particular purpose are
23  * disclaimed. In no event shall the Hypersonic SQL Group or its contributors be liable for any
24  * direct, indirect, incidental, special, exemplary, or consequential damages (including, but
25  * not limited to, procurement of substitute goods or services; loss of use, data, or profits;
26  * or business interruption). However caused any on any theory of liability, whether in contract,
27  * strict liability, or tort (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  * This software consists of voluntary contributions made by many individuals on behalf of the
30  * Hypersonic SQL Group.
31  *
32  *
33  * For work added by the HSQL Development Group:
34  *
35  * Copyright (c) 2001-2002, The HSQL Development Group
36  * All rights reserved.
37  *
38  * Redistribution and use in source and binary forms, with or without
39  * modification, are permitted provided that the following conditions are met:
40  *
41  * Redistributions of source code must retain the above copyright notice, this
42  * list of conditions and the following disclaimer, including earlier
43  * license statements (above) and comply with all above license conditions.
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, including earlier
48  * license statements (above) and comply with all above license conditions.
49  *
50  * Neither the name of the HSQL Development Group nor the names of its
51  * contributors may be used to endorse or promote products derived from this
52  * software without specific prior written permission.
53  *
54  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
55  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
56  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
57  * ARE DISCLAIMED. IN NO EVENT SHALL HSQL DEVELOPMENT GROUP, HSQLDB.ORG,
58  * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
59  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
60  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
61  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
62  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
63  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
64  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
65  */
66
67
68 package org.hsqldb;
69
70 import org.hsqldb.lib.HsqlArrayList;
71 import org.hsqldb.lib.HsqlHashMap;
72 import org.hsqldb.lib.HsqlStringBuffer;
73 import java.io.IOException ;
74 import java.io.BufferedWriter ;
75  import java.io.ByteArrayInputStream ;
76  import java.io.ByteArrayOutputStream ;
77 import java.io.File ;
78 import java.io.FileInputStream ;
79 import java.io.FileOutputStream ;
80 import java.io.FileReader ;
81 import java.io.FileWriter ;
82  import java.io.InputStreamReader ;
83 import java.io.LineNumberReader ;
84  import java.io.OutputStreamWriter ;
85 import java.io.Writer ;
86 import java.sql.SQLException ;
87 import java.util.Enumeration ;
88
89 //import java.util.zip.
90 import java.util.zip.Deflater ;
91 import java.util.zip.DeflaterOutputStream ;
92 import java.util.zip.Inflater ;
93 import java.util.zip.InflaterInputStream ;
94
95 // fredt@users 20020215 - patch 1.7.0 by fredt
96 // to move operations on the database.properties files to new
97 // class HsqlDatabaseProperties
98 // fredt@users 20020220 - patch 488200 by xclay@users - throw exception
99 // throw addded to all methods relying on file io
100 // fredt@users 20020221 - patch 513005 by sqlbob@users (RMP)
101 // fredt@users 20020405 - patch 1.7.0 by fredt - no change in db location
102 // because important information about the database is now stored in the
103 // *.properties file, all database files should be in the same folder as the
104 // *.properties file
105 // tony_lai@users 20020820 - export hsqldb.log_size to .properties file
106 // tony_lai@users 20020820 - Modification to shutdown compact process to save memory usage
107
108 /**
109  * This class is responsible for most file handling. A HSQL database
110  * consists of a .properties file, a .script file (contains a SQL script),
111  * a .data file (contains data of cached tables) and a .backup file
112  * (contains the compressed .data file) <P>
113  *
114  * This is an example of the .properties file. The version and the modified
115  * properties are automatically created by the database and should not be
116  * changed manually: <pre>
117  * modified=no
118  * version=1.43
119  * </pre> The following lines are optional, this means they are not created
120  * automatically by the database, but they are interpreted if they exist in
121  * the .script file. They have to be created manually if required. If they
122  * don't exist the default is used. This are the defaults of the database
123  * 'test': <pre>
124  * readonly=false
125  * </pre>
126  *
127  * @version 1.7.0
128  */
129 class Log implements Runnable {
130
131     // block size for copying data
132 private static final int COPY_BLOCK_SIZE = 1 << 16;
133     private HsqlDatabaseProperties pProperties;
134     private String sName;
135     private Database dDatabase;
136     private Session sysSession;
137     private Writer wScript;
138     private String sFileScript;
139     private String sFileCache;
140     private String sFileBackup;
141     private boolean bRestoring;
142     private boolean bReadOnly;
143     private int iLogSize;
144     private int iLogCount;
145     private Thread tRunner;
146     private volatile boolean bNeedFlush;
147     private volatile boolean bWriteDelay;
148     private int mLastId;
149     private Cache cCache;
150
151 // boucherb@users - comment - FIXME
152 // boolean stopped;
153
154     /**
155      * Constructor declaration
156      *
157      * @param db
158      * @param system
159      * @param name
160      * @exception SQLException Description of the Exception
161      */
162     Log(Database db, Session system, String name) throws SQLException {
163
164         dDatabase = db;
165         sysSession = system;
166         sName = name;
167         pProperties = db.getProperties();
168         tRunner = new Thread (this);
169
170         // boucherb@users - FIXME:
171 // standard VM behaviour is to shut down only after all
172 // non-daemon threads exit. Therefor, tRunner shuld be
173 // daemon. Consider the case of:
174 /*
175          public void main(String[] args) {
176          ...
177          try {
178          // fails due to bad user/password...must then connect with valid combo
179          // again to *really* shutdown database, or explicitly call System.exit(...)
180          DriverManager.getConnection("jdbc:hsqldb:filespec,"user","password");
181          ...
182          } catch (...) {
183          }
184          ...
185          }
186          */
187
188         // the VM will not exit, since tRunner is still running and
189 // no shutdown is issued to close the database.
190 //
191 // - setDaemon(false) may require flush in finalization
192 // CB
193 // tRunner.setDaemon(false);
194 tRunner.start();
195     }
196
197     /**
198      * Method declaration
199      */
200     public void run() {
201
202         // boucherb@users - FIXME
203 // while (!stopped) {
204 while (tRunner != null) {
205             try {
206                 tRunner.sleep(1000);
207
208                 if (bNeedFlush) {
209                     wScript.flush();
210
211                     bNeedFlush = false;
212                 }
213
214                 // todo: try to do Cache.cleanUp() here, too
215 } catch (Exception e) {
216
217                 // ignore exceptions; may be InterruptedException or IOException
218 }
219         }
220     }
221
222     /**
223      * Method declaration
224      *
225      * @param delay
226      */
227     void setWriteDelay(boolean delay) {
228         bWriteDelay = delay;
229     }
230
231     /**
232      * When opening a database, the hsqldb.compatible_version property is
233      * used to determine if this version of the engine is equal to or greater
234      * than the earliest version of the engine capable of opening that
235      * database.<p>
236      *
237      * @return
238      * @throws SQLException
239      */
240     boolean open() throws SQLException {
241
242         if (Trace.TRACE) {
243             Trace.trace();
244         }
245
246         if (!pProperties.checkFileExists()) {
247             create();
248             open();
249
250             // this is a new database
251 return true;
252         }
253
254         // todo: some parts are not necessary for ready-only access
255 pProperties.load();
256
257         sFileScript = sName + ".script";
258         sFileCache = sName + ".data";
259         sFileBackup = sName + ".backup";
260
261         // tony_lai@users 20020820
262 // Allows the user to modify log size from the properties file.
263 iLogSize = pProperties.getIntegerProperty("hsqldb.log_size",
264                 iLogSize);
265
266         String version = pProperties.getProperty("hsqldb.compatible_version");
267
268 // fredt@users 20020428 - patch 1.7.0 by fredt
269 int check = version.substring(0, 5).compareTo(jdbcDriver.VERSION);
270
271         Trace.check(check <= 0, Trace.WRONG_DATABASE_FILE_VERSION);
272
273         // save the current version
274 pProperties.setProperty("hsqldb.version", jdbcDriver.VERSION);
275
276         if (pProperties.isPropertyTrue("readonly")) {
277             bReadOnly = true;
278
279             dDatabase.setReadOnly();
280
281             if (cCache != null) {
282                 cCache.open(true);
283             }
284
285             reopenAllTextCaches();
286             runScript();
287
288             return false;
289         }
290
291         boolean needbackup = false;
292         String state = pProperties.getProperty("modified");
293
294         if (state.equals("yes-new-files")) {
295             renameNewToCurrent(sFileScript);
296             renameNewToCurrent(sFileBackup);
297         } else if (state.equals("yes")) {
298             if (isAlreadyOpen()) {
299                 throw Trace.error(Trace.DATABASE_ALREADY_IN_USE);
300             }
301
302             // recovering after a crash (or forgot to close correctly)
303 restoreBackup();
304
305             needbackup = true;
306         }
307
308         pProperties.setProperty("modified", "yes");
309         pProperties.save();
310
311         if (cCache != null) {
312             cCache.open(false);
313         }
314
315         reopenAllTextCaches();
316         runScript();
317
318         if (needbackup) {
319             close(false);
320             pProperties.setProperty("modified", "yes");
321             pProperties.save();
322
323             if (cCache != null) {
324                 cCache.open(false);
325             }
326
327             reopenAllTextCaches();
328         }
329
330         openScript();
331
332         // this is an existing database
333 return false;
334     }
335
336     Cache getCache() throws SQLException {
337
338         if (cCache == null) {
339             cCache = new Cache(sFileCache, pProperties);
340
341             cCache.open(bReadOnly);
342         }
343
344         return (cCache);
345     }
346
347     /**
348      * Method declaration
349      */
350     void /* synchronized */ stop() {
351
352         //boucherb@users - FIXME:
353 /*
354          if (!stopped)
355          stopped = true;
356          tRunner.interrupt();
357          tRunner = null;
358          }
359          */
360         tRunner = null;
361     }
362
363     /**
364      * Method declaration
365      *
366      * @param compact
367      * @throws SQLException
368      */
369     void close(boolean compact) throws SQLException {
370
371         if (Trace.TRACE) {
372             Trace.trace();
373         }
374
375         if (bReadOnly) {
376             return;
377         }
378
379         // no more scripting
380 closeScript();
381
382         // create '.script.new' (for this the cache may be still required)
383 writeScript(compact);
384
385         // flush the cache (important: after writing the script)
386 if (cCache != null) {
387             cCache.flush();
388         }
389
390         closeAllTextCaches(compact);
391
392         // create '.backup.new' using the '.data'
393 backup();
394
395         // we have the new files
396 pProperties.setProperty("modified", "yes-new-files");
397         pProperties.save();
398
399         // old files can be removed and new files renamed
400 renameNewToCurrent(sFileScript);
401         renameNewToCurrent(sFileBackup);
402
403         // now its done completely
404 pProperties.setProperty("modified", "no");
405         pProperties.setProperty("version", jdbcDriver.VERSION);
406         pProperties.setProperty("hsqldb.compatible_version", "1.7.0");
407         pProperties.save();
408         pProperties.close();
409
410         if (compact) {
411
412             // stop the runner thread of this process (just for security)
413 stop();
414
415             // delete the .data so then a new file is created
416 (new File (sFileCache)).delete();
417             (new File (sFileBackup)).delete();
418
419             // tony_lai@users 20020820
420 // The database re-open and close has been moved to
421 // Database#close(int closemode) for saving memory usage.
422 }
423     }
424
425     /**
426      * Method declaration
427      *
428      * @throws SQLException
429      */
430     void checkpoint() throws SQLException {
431
432         close(false);
433         pProperties.setProperty("modified", "yes");
434         pProperties.save();
435
436         if (cCache != null) {
437             cCache.open(false);
438         }
439
440         reopenAllTextCaches();
441         openScript();
442     }
443
444     /**
445      * Method declaration
446      *
447      * @param mb
448      */
449     void setLogSize(int mb) {
450
451         iLogSize = mb;
452
453         pProperties.setProperty("hsqldb.log_size", iLogSize);
454     }
455
456     /**
457      * Method declaration
458      *
459      * @param c
460      * @param s
461      * @throws SQLException
462      */
463     void write(Session c, String s) throws SQLException {
464
465         if (bRestoring || s == null || s.length() == 0) {
466             return;
467         }
468
469         if (!bReadOnly) {
470             int id = 0;
471
472             if (c != null) {
473                 id = c.getId();
474             }
475
476             if (id != mLastId) {
477                 s = "/*C" + id + "*/" + s;
478                 mLastId = id;
479             }
480
481             try {
482                 writeLine(wScript, s);
483
484                 if (bWriteDelay) {
485                     bNeedFlush = true;
486                 } else {
487                     wScript.flush();
488                 }
489             } catch (IOException e) {
490                 throw Trace.error(Trace.FILE_IO_ERROR, sFileScript);
491             }
492
493             // fredt@users - todo - eliminate new File() calls
494 if (iLogSize > 0 && iLogCount++ > 100) {
495                 iLogCount = 0;
496
497                 if ((new File (sFileScript)).length()
498                         > iLogSize * 1024 * 1024) {
499                     checkpoint();
500                 }
501             }
502         }
503     }
504
505     /**
506      * Method declaration
507      *
508      * @throws SQLException
509      */
510     void shutdown() throws SQLException {
511
512         tRunner = null;
513
514         if (cCache != null) {
515             cCache.shutdown();
516
517             cCache = null;
518         }
519
520         shutdownAllTextCaches();
521         closeScript();
522         pProperties.close();
523     }
524
525     /**
526      * Method declaration
527      *
528      * @param db
529      * @param file
530      * @param full
531      * @param session
532      * @throws SQLException
533      */
534     static void scriptToFile(Database db, String file, boolean full,
535                              Session session) throws SQLException {
536
537         if ((new File (file)).exists()) {
538
539             // there must be no such file; overwriting not allowed for security
540 throw Trace.error(Trace.FILE_IO_ERROR, file);
541         }
542
543         try {
544             long time = System.currentTimeMillis();
545
546             // only ddl commands; needs not so much memory
547 Result r;
548
549             if (full) {
550
551                 // no drop, no insert, and no positions for cached tables
552 r = db.getScript(false, false, false, session);
553             } else {
554
555                 // no drop, no insert, but positions for cached tables
556 r = db.getScript(false, false, true, session);
557             }
558
559             Record n = r.rRoot;
560             FileWriter w = new FileWriter (file);
561
562             while (n != null) {
563                 writeLine(w, (String ) n.data[0]);
564
565                 n = n.next;
566             }
567
568             // inserts are done separetely to save memory
569 HsqlArrayList tables = db.getTables();
570
571             for (int i = 0; i < tables.size(); i++) {
572                 Table t = (Table) tables.get(i);
573
574 // cached tables have the index roots set in the ddl script
575 if ((full ||!t.isCached()) &&!t.isTemp() &&!t.isView()
576                         && (!t.isText() ||!t.isDataReadOnly())) {
577                     Index primary = t.getPrimaryIndex();
578                     Node x = primary.first();
579
580                     while (x != null) {
581                         writeLine(w, t.getInsertStatement(x.getData()));
582
583                         x = primary.next(x);
584                     }
585                 }
586
587 // fredt@users 20020221 - patch 513005 by sqlbob@users (RMP)
588 if (t.isDataReadOnly() &&!t.isTemp() &&!t.isText()) {
589                     HsqlStringBuffer a = new HsqlStringBuffer("SET TABLE ");
590
591                     a.append(t.getName().statementName);
592                     a.append(" READONLY TRUE");
593                     writeLine(w, a.toString());
594                 }
595             }
596
597             w.close();
598
599             time = System.currentTimeMillis() - time;
600
601             if (Trace.TRACE) {
602                 Trace.trace(time);
603             }
604         } catch (IOException e) {
605             throw Trace.error(Trace.FILE_IO_ERROR, file + " " + e);
606         }
607     }
608
609
610
611      /**
612       * Called internally by replication to generate initial state to be sent to new replica
613       * Returns null if the generation fails, or throws an exception
614       */
615      static byte[] scriptToBuffer(Database db, boolean full,
616                   Session session) throws SQLException {
617
618      ByteArrayOutputStream bos=null;
619      OutputStreamWriter w=null;
620
621      try {
622          long time = System.currentTimeMillis();
623
624          // only ddl commands; needs not so much memory
625 Result r;
626
627          if (full) {
628
629          // no drop, no insert, and no positions for cached tables
630 r = db.getScript(false, false, false, session);
631          } else {
632
633          // no drop, no insert, but positions for cached tables
634 r = db.getScript(false, false, true, session);
635          }
636
637          Record n = r.rRoot;
638          // FileWriter w = new FileWriter(file);
639 bos=new ByteArrayOutputStream (0xff);
640          w=new OutputStreamWriter (bos);
641
642          while (n != null) {
643          writeLine(w, (String ) n.data[0]);
644
645          n = n.next;
646          }
647
648          // inserts are done separetely to save memory
649 HsqlArrayList tables = db.getTables();
650
651          for (int i = 0; i < tables.size(); i++) {
652          Table t = (Table) tables.get(i);
653
654  // cached tables have the index roots set in the ddl script
655 if ((full ||!t.isCached()) &&!t.isTemp() &&!t.isView()
656              && (!t.isText() ||!t.isDataReadOnly())) {
657              Index primary = t.getPrimaryIndex();
658              Node x = primary.first();
659
660              while (x != null) {
661              writeLine(w, t.getInsertStatement(x.getData()));
662
663              x = primary.next(x);
664              }
665          }
666
667  // fredt@users 20020221 - patch 513005 by sqlbob@users (RMP)
668 if (t.isDataReadOnly() &&!t.isTemp() &&!t.isText()) {
669              HsqlStringBuffer a = new HsqlStringBuffer("SET TABLE ");
670
671              a.append(t.getName().statementName);
672              a.append(" READONLY TRUE");
673              writeLine(w, a.toString());
674          }
675          }
676
677          w.close(); // flushes as well
678
679          time = System.currentTimeMillis() - time;
680
681          if (Trace.TRACE) {
682          Trace.trace(time);
683          }
684
685          return bos != null? bos.toByteArray() : null;
686
687      } catch (IOException e) {
688          throw Trace.error(Trace.FILE_IO_ERROR, e.toString());
689      }
690      }
691
692
693
694
695
696
697
698
699
700     /**
701      * Method declaration
702      *
703      * @param file
704      */
705     private void renameNewToCurrent(String file) {
706
707         // even if it crashes here, recovering is no problem
708 if ((new File (file + ".new")).exists()) {
709
710             // if we have a new file
711 // delete the old (maybe already deleted)
712 (new File (file)).delete();
713
714             // rename the new to the current
715 new File (file + ".new").renameTo(new File (file));
716         }
717     }
718
719     private void create() throws SQLException {
720
721         if (Trace.TRACE) {
722             Trace.trace(sName);
723         }
724
725         pProperties.setProperty("version", jdbcDriver.VERSION);
726         pProperties.save();
727     }
728
729     /**
730      * Method declaration
731      *
732      * @return
733      * @throws SQLException
734      */
735     private boolean isAlreadyOpen() throws SQLException {
736
737         // reading the last modified, wait 3 seconds, read again.
738 // if the same information was read the file was not changed
739 // and is probably, except the other process is blocked
740 if (Trace.TRACE) {
741             Trace.trace();
742         }
743
744         File f = new File (sName + ".lock");
745         long l1 = f.lastModified();
746
747         try {
748             Thread.sleep(3000);
749         } catch (Exception e) {}
750
751         long l2 = f.lastModified();
752
753         if (l1 != l2) {
754             return true;
755         }
756
757         return pProperties.isFileOpen();
758     }
759
760     /**
761      * Method declaration
762      *
763      * @throws SQLException
764      */
765     private void backup() throws SQLException {
766
767         if (Trace.TRACE) {
768             Trace.trace();
769
770             // if there is no cache file then backup is not necessary
771 }
772
773         if (!(new File (sFileCache)).exists()) {
774             return;
775         }
776
777         try {
778             long time = System.currentTimeMillis();
779
780             // create a '.new' file; rename later
781 DeflaterOutputStream f = new DeflaterOutputStream (
782                 new FileOutputStream (sFileBackup + ".new"),
783                 new Deflater (Deflater.BEST_SPEED), COPY_BLOCK_SIZE);
784             byte b[] = new byte[COPY_BLOCK_SIZE];
785             FileInputStream in = new FileInputStream (sFileCache);
786
787             while (true) {
788                 int l = in.read(b, 0, COPY_BLOCK_SIZE);
789
790                 if (l == -1) {
791                     break;
792                 }
793
794                 f.write(b, 0, l);
795             }
796
797             f.close();
798             in.close();
799
800             time = System.currentTimeMillis() - time;
801
802             if (Trace.TRACE) {
803                 Trace.trace(time);
804             }
805         } catch (Exception e) {
806             throw Trace.error(Trace.FILE_IO_ERROR, sFileBackup);
807         }
808     }
809
810     /**
811      * Method declaration
812      *
813      * @throws SQLException
814      */
815     private void restoreBackup() throws SQLException {
816
817         if (Trace.TRACE) {
818             Trace.trace("not closed last time!");
819         }
820
821         if (!(new File (sFileBackup)).exists()) {
822
823             // the backup don't exists because it was never made or is empty
824 // the cache file must be deleted in this case
825 (new File (sFileCache)).delete();
826
827             return;
828         }
829
830         try {
831             long time = System.currentTimeMillis();
832             InflaterInputStream f =
833                 new InflaterInputStream (new FileInputStream (sFileBackup),
834                                         new Inflater ());
835             FileOutputStream cache = new FileOutputStream (sFileCache);
836             byte b[] = new byte[COPY_BLOCK_SIZE];
837
838             while (true) {
839                 int l = f.read(b, 0, COPY_BLOCK_SIZE);
840
841                 if (l == -1) {
842                     break;
843                 }
844
845                 cache.write(b, 0, l);
846             }
847
848             cache.close();
849             f.close();
850
851             time = System.currentTimeMillis() - time;
852
853             if (Trace.TRACE) {
854                 Trace.trace(time);
855             }
856         } catch (Exception e) {
857             throw Trace.error(Trace.FILE_IO_ERROR, sFileBackup);
858         }
859     }
860
861     /**
862      * Method declaration
863      *
864      * @throws SQLException
865      */
866     private void openScript() throws SQLException {
867
868         if (Trace.TRACE) {
869             Trace.trace();
870         }
871
872         try {
873
874             // todo: use a compressed stream
875 wScript = new BufferedWriter (new FileWriter (sFileScript, true),
876                                          4096);
877         } catch (Exception e) {
878             throw Trace.error(Trace.FILE_IO_ERROR, sFileScript);
879         }
880     }
881
882     /**
883      * Method declaration
884      *
885      * @throws SQLException
886      */
887     private void closeScript() throws SQLException {
888
889         if (Trace.TRACE) {
890             Trace.trace();
891         }
892
893         try {
894             if (wScript != null) {
895                 wScript.close();
896
897                 wScript = null;
898             }
899         } catch (Exception e) {
900             throw Trace.error(Trace.FILE_IO_ERROR, sFileScript);
901         }
902     }
903
904     /**
905      * Method declaration
906      *
907      * @throws SQLException
908      */
909     private void runScript() throws SQLException {
910
911         if (Trace.TRACE) {
912             Trace.trace();
913         }
914
915         if (!(new File (sFileScript)).exists()) {
916             return;
917         }
918
919         bRestoring = true;
920
921         dDatabase.setReferentialIntegrity(false);
922
923         HsqlArrayList session = new HsqlArrayList();
924
925         session.add(sysSession);
926
927         Session current = sysSession;
928
929         try {
930             long time = System.currentTimeMillis();
931             LineNumberReader r =
932                 new LineNumberReader (new FileReader (sFileScript));
933
934             while (true) {
935                 String s = readLine(r);
936
937                 if (s == null) {
938                     break;
939                 }
940
941                 if (s.startsWith("/*C")) {
942                     int id = Integer.parseInt(s.substring(3, s.indexOf('*',
943                                  4)));
944
945                     if (id >= session.size()) {
946                         session.setSize(id + 1);
947                     }
948
949                     current = (Session) session.get(id);
950
951                     if (current == null) {
952