source: project/wiki/eggref/4/sqlite3 @ 33350

Last change on this file since 33350 was 33350, checked in by Thomas Chust, 5 years ago

[sqlite3] Documented enable-load-extension! procedure

File size: 23.1 KB
Line 
1== Sqlite3
2
3=== Description
4
5Bindings to version 3.x of the SQLite API.
6
7=== Author
8
9[[http://www.chust.org/|Thomas Chust]]
10
11=== Requirements
12
13* [[check-errors]]
14* [[synch]]
15* [[miscmacros]]
16* [[matchable]]
17* [[sql-null]]
18
19=== Documentation
20
21The API of SQLite changed significantly from version 2.x to 3.x. These
22are new bindings to the modified API, which are reasonably complete --
23most procedures that take callback arguments are missing, though.
24
25For in-depth information on the functionality of the routines and
26general information you should consult the
27[[http://www.sqlite.org/|SQLite documentation]] as well as this
28manual.
29
30==== Exceptions
31
32Unless otherwise indicated, all procedures and methods in this egg may
33throw an exception of the kind {{(exn sqlite3)}} if something goes
34wrong. This exception will contain a {{status}} property indicating
35the return value of the operation that failed:
36
37; {{error}} : SQL error or missing database
38; {{internal}} : An internal logic error in SQLite
39; {{permission}} : Access permission denied
40; {{abort}} : Callback routine requested an abort
41; {{busy}} : The database file is locked
42; {{locked}} : A table in the database is locked
43; {{no-memory}} : A malloc() failed
44; {{read-only}} : Attempt to write a readonly database
45; {{interrupt}} : Operation terminated by {{sqlite-interrupt()}}
46; {{io-error}} : Some kind of disk I/O error occurred
47; {{corrupt}} : The database disk image is malformed
48; {{not-found}} : (Internal Only) Table or record not found
49; {{full}} : Insertion failed because database is full
50; {{cant-open}} : Unable to open the database file
51; {{protocol}} : Database lock protocol error
52; {{empty}} : (Internal Only) Database table is empty
53; {{schema}} : The database schema changed
54; {{too-big}} : Too much data for one row of a table
55; {{constraint}} : Abort due to contraint violation
56; {{mismatch}} : Data type mismatch
57; {{misuse}} : Library used incorrectly
58; {{no-lfs}} : Uses OS features not supported on host
59; {{authorization}} : Authorization denied
60; {{done}} : {{step!}} has finished executing, so no further data is ready
61
62==== Abstract data types
63
64<procedure>(database? OBJECT) => BOOLEAN</procedure>
65
66Checks whether a value represents an SQLite database.
67
68<procedure>(error-database LOCATION OBJECT [ARGUMENT-NAME]) => VOID</procedure>
69
70Raises a type error saying that a database was expected instead of the
71given value.
72
73<procedure>(check-database LOCATION OBJECT [ARGUMENT-NAME]) => VOID</procedure>
74
75Raises a type error like {{error-database}} does, unless the given
76value satisfies {{database?}}
77
78<procedure>(statement? OBJECT) => BOOLEAN</procedure>
79
80Checks whether the value {{v}} represents an SQL statement.
81
82<procedure>(error-statement LOCATION OBJECT [ARGUMENT-NAME]) => VOID</procedure>
83
84Raises a type error saying that a statement was expected instead of the given value.
85
86<procedure>(check-statement LOCATION OBJECT [ARGUMENT-NAME]) => VOID</procedure>
87
88Raises a type error like {{error-statement}} does, unless the given value satisfies {{statement?}}
89
90==== Managing databases
91
92<procedure>(open-database PATH) => DATABASE</procedure>
93
94Opens the indicated database file and returns a database object for it.
95
96Since version 3.6.0 the given path is passed to SQLite3 without modifications. Before it was subject to special expansions like paths passed to {{open-input-file}} and similar procedures used to be.
97
98<procedure>(define-collation DATABASE NAME [PROC]) => VOID</procedure>
99
100If a procedure is given, registers a new collation sequence identified
101by {{name}} for use in the context of database handle {{db}}. If no
102procedure is passed, the collation sequence with the given name is
103removed.
104
105{{PROC}} should have the signature {{(PROC STRING STRING) => FIXNUM}}.
106It should return a negative number if the first argument sorts before
107the second, a positive number if the second sorts before the first and
108zero if they are equal.
109
110As {{PROC}} will be called in a callback context from within
111{{step!}}, safety measures are installed to avoid throwing any
112exceptions, invoking continuations or returning invalid values from
113it. Attempts to do so will result in a {{0}} return value and
114warning messages.
115
116<procedure>(define-function DATABASE NAME N PROC) => VOID</procedure><br>
117<procedure>(define-function DATABASE NAME N STEP-PROC SEED [FINAL-PROC]) => VOID</procedure>
118
119Registers a new SQL function identified by {{NAME}} for use in the
120context of the given database handle. If {{STEP-PROC}} and {{SEED}}
121are given, the new function becomes an aggregate function. Once
122registered, functions cannot be deleted.
123
124{{N}} is the number of parameters the new SQL function takes or
125{{-1}} to allow any number of arguments.
126
127{{PROC}} should have the signature {{(PROC . PARAMS) => OBJECT}}.
128It is called with the {{N}} parameters given to
129the SQL function converted into Scheme objects like by
130{{column-data}}. The return value is converted into an SQLite data
131object like by {{bind!}}. A return value satisfying
132{{sql-null?}} corresponds to {{NULL}} in SQLite.
133
134{{STEP-PROC}} should have the signature {{(STEP-PROC SEED PARAMS) => SEED}}.
135It is called with the parameters given to the SQL function
136for every row being processed. The seed value passed is initially
137the one given as an argument to {{define-function}}; for subsequent
138calls it is the last value returned by {{STEP-PROC}} and after
139completion of {{FINAL-PROC}} it will be the initial value again.
140
141{{FINAL-PROC}} should have the signature {{(FINAL-PROC SEED) => OBJECT}}
142and transforms the last seed value into the value to be returned
143from the aggregate function. If it is not explicitly specified,
144{{STEP-PROC}} defaults to the identity function.
145
146As {{PROC}}, {{STEP-PROC}} and {{FINAL-PROC}} will be called
147in a callback context from within {{step!}}, safety measures
148are installed to avoid throwing any exceptions, invoking
149continuations or returning invalid values from them.
150Attempts to do such things will result in {{NULL}} return values
151and warning messages.
152
153<procedure>(set-busy-handler! DATABASE PROC) => VOID</procedure>
154
155Installs the supplied procedure as the application's busy handler, or
156removes it if {{#f}}.  When the database returns a busy error code,
157the egg will invoke this handler repeatedly until it returns {{#f}}.
158The handler will be called with arguments {{DATABASE}} and {{COUNT}}
159(number of times invoked for the same operation).
160
161As {{PROC}} is not called in a callback context, it is legal to invoke
162captured continuations, and it is safe in the presence of multiple
163threads.  In general, this handler should give up at some point to
164avoid possible deadlock.
165
166For an example handler, see the code of {{make-busy-timeout}}.
167
168<procedure>(make-busy-timeout MS) => PROC</procedure>
169
170Returns a handler suitable for use with {{set-busy-handler!}}.
171It polls in increasing intervals until the timeout in milliseconds
172is reached. The handler is non-blocking.
173
174<enscript highlight="scheme">
175(define open-database/timeout
176  (let ((handler (make-busy-timeout 2000)))
177    (lambda (db-name)
178      (let ((db (open-database db-name)))
179        (set-busy-handler! db handler)
180        db))))
181</enscript>
182
183<procedure>(interrupt! DATABASE) => VOID</procedure>
184
185Cancels any running database operation as soon as possible.
186
187This function is always successful and never throws an exception.
188
189<procedure>(auto-committing? DATABASE) => BOOLEAN</procedure>
190
191Checks whether the database is currently in auto committing mode,
192i.e. no transaction is currently active.
193
194This function always returns a state and never throws an exception.
195
196<procedure>(change-count DATABASE [TOTAL]) => CARDINAL-INTEGER</procedure>
197
198Returns the number of rows changed by the last statement (if {{(not TOTAL)}},
199which is the default) or since the database was opened (if {{TOTAL}}).
200
201This function always returns a count and never throws an exception.
202
203<procedure>(last-insert-rowid DATABASE) => INTEGER</procedure>
204
205Returns the row ID of the last row inserted in {{db}}.
206This function always returns a number and never throws an exception.
207
208<procedure>(finalize! DATABASE [FINALIZE-STATEMENTS?]) => VOID</procedure><br>
209<procedure>(finalize! STATEMENT) => VOID</procedure>
210
211Closes the given database or finalizes the given statement.
212
213Every statement must be finalized to free its resources and discard it
214before the database itself can be finalized. However, if {{FINALIZE-STATEMENTS?}}
215is not {{#f}}, finalizing the database triggers automatic finalization
216of all statements first. {{FINALIZE-STATEMENTS?}} defaults to {{#f}}.
217
218Note that both the SQLite3 egg and the SQLite3 library itself try to
219detect the use of already finalized statement or database handles in
220API calls, but the detection is not always possible and you might
221crash the program by using an already finalized handle.
222
223==== Managing statements
224
225<procedure>(prepare DATABASE SQL) => STATEMENT, SQL</procedure>
226
227Compiles the first SQL statement in {{SQL}} and returns a statement
228and the tail of the SQL code, which was not compiled (or an empty
229string).
230
231<procedure>(source-sql STATEMENT) => STRING</procedure>
232
233Retrieves the SQL source code of a statement.
234
235<procedure>(column-count STATEMENT) => CARDINAL-INTEGER</procedure>
236
237Can be applied to any statement and returns the number of columns it
238will return as results.
239
240This procedure always succeeds and never throws an exception.
241
242<procedure>(column-name STATEMENT I) => STRING</procedure>
243
244Can be applied to any statement and returns the name of the column
245number {{I}} (counting from 0) as a string or {{#f}} if the column has
246no name.
247
248This procedure always succeeds and never throws an exception.
249
250<procedure>(column-declared-type STATEMENT I) => STRING</procedure>
251
252Can be applied to any statement and returns the declared type (as
253given in the {{CREATE}} statement) of the column number {{I}}
254(counting from 0) as a string or {{#f}} if the column has no declared type.
255
256This procedure always succeeds and never throws an exception.
257
258<procedure>(bind-parameter-count STATEMENT) => CARDINAL-INTEGER</procedure>
259
260Can be applied to any statement and returns the number of free
261parameters that can be bound in the statement.
262
263This procedure always succeeds and never throws an exception.
264
265<procedure>(bind-parameter-index STATEMENT NAME) => CARDINAL-INTEGER</procedure>
266
267Can be applied to any statement and returns the index of the bindable
268parameter called {{NAME}} or {{#f}} if no such parameter exists.
269
270This procedure always succeeds and never throws an exception.
271
272<procedure>(bind-parameter-name STATEMENT I) => STRING</procedure>
273
274Can be applied to any statement and returns the name of the bindable
275parameter number {{I}} (counting from 0) or {{#f}} if no
276such parameter exists or the parameter has no name.
277
278This procedure always succeeds and never throws an exception.
279
280<procedure>(bind! STATEMENT I OBJECT) => VOID</procedure>
281
282Can be applied to any statement to bind its free parameter number
283{{I}}(counting from 0) to the given value. Scheme types of the
284value map to SQLite types as follows:
285
286<table>
287<tr><th> Scheme type</th><th>SQLite type</th></tr>
288<tr><td>{{boolean?}}</td><td>integer: {{#t}} = {{1}}, {{#f}} = {{0}}</td></tr>
289<tr><td>{{fixnum?}}</td><td>{{integer}}</td></tr>
290<tr><td>{{real?}}</td><td>{{float}}</td></tr>
291<tr><td>{{string?}}</td><td>{{text}}</td></tr>
292<tr><td>{{blob?}}</td><td>{{blob}}</td></tr>
293<tr><td>{{sql-null?}}</td><td>{{null}}</td></tr>
294</table>
295
296Unless there is internal trouble in SQLite, this method should always
297succeeds and never throw an exception. For invalid parameter indices
298the method just silently does nothing.
299
300<procedure>(bind-parameters! STATEMENT . PARAMETERS) => VOID</procedure>
301
302Resets the statement and binds all its free parameters.
303
304In addition to just listing the values to bind to the statement's
305parameters in sequence, you may specify parameters prefixed by
306keywords that are resolved to parameter indices by prefixing their
307names with {{":"}} and resolving them using {{bind-parameter-index}}.
308
309<procedure>(step! STATEMENT) => BOOLEAN</procedure>
310
311Single-steps the execution of {{STATEMENT}} and returns {{#t}} if a
312result row was produced, {{#f}} if no further results are available as
313the statement has been stepped through. This procedure must be called
314at least once before any results can be retrieved from the
315statement.
316
317<procedure>(column-type STATEMENT I) => SYMBOL</procedure>
318
319Can be applied to a statement that has just been stepped (otherwise it
320returns {{#f}}) and returns the SQLite type of the result
321column number {{I}} (counting from 0) as a symbol.
322
323The return value can be one of the symbols {{null}}, {{integer}},
324{{float}}, {{text}} or {{blob}}.
325
326This procedure always succeeds and never throws an exception.
327
328<procedure>(column-data STATEMENT I) => OBJECT</procedure>
329
330Can be applied to a statement that has just been stepped. Consults
331{{column-type}} and {{column-declared-type}} to determine
332the type of the indicated column and to return its data as an
333appropriate Scheme object:
334
335<table>
336<tr><th>SQLite type</th><th>Scheme type</th></tr>
337<tr><td>{{integer}}, declared {{"bool"}}"</td><td>{{boolean?}}</td></tr>
338<tr><td>{{integer}}</td><td>{{integer?}}</td></tr>
339<tr><td>{{float}}</td><td>{{real?}}</td></tr>
340<tr><td>{{text}}</td><td>{{string?}}</td></tr>
341<tr><td>{{blob}}</td><td>{{blob?}}</td></tr>
342<tr><td>{{null}}</td><td>{{sql-null?}}</td></tr>
343</table>
344
345The declared type of a column is considered to be boolean if the type
346declaration contains the character sequence "{{bool}}" anywhere,
347ignoring case.
348
349This procedure always succeeds and never throws an exception.
350
351<procedure>(reset! STATEMENT) => VOID</procedure>
352
353Can be applied to any statement and resets it such that execution
354using {{step!}} will perform all operations of the statement again.
355
356==== Simple statement interface
357
358<procedure>(call-with-temporary-statements PROC DATABASE . SQLS) => OBJECT</procedure>
359
360Compiles the SQL sources into statements in the context of
361{{DATABASE}}, applies {{PROC}} to these statements and returns
362{{PROC}}'s result. The statements are created and finalized in
363{{dynamic-wind}} entry and exit blocks around the application of
364{{PROC}}.
365
366<procedure>(execute STATEMENT . PARAMETERS) => VOID)</procedure><br>
367<procedure>(execute DATABASE SQL . PARAMETERS) => VOID</procedure>
368
369(Compiles the given SQL), resets the statement, binds the statement's
370free parameters and executes the statement ignoring possible results
371from it.
372
373<procedure>(update STATEMENT . PARAMETERS) => CARDINAL-INTEGER</procedure><br>
374<procedure>(update DATABASE SQL . PARAMETERS) => CARDINAL-INTEGER</procedure>
375
376(Compiles the given SQL), resets the statement, binds the statement's
377free parameters and executes the specified statement ignoring possible
378results from it, returning the result of applying {{change-count}}
379to the affected database after the execution of the statement instead.
380
381<procedure>(first-result STATEMENT . PARAMETERS) => OBJECT</procedure><br>
382<procedure>(first-result DATABASE SQL . PARAMETERS) => OBJECT</procedure>
383
384(Compiles the given SQL), resets the statement, binds the statement's
385free parameters and single-steps the statement once returning the
386value of the first column in the first result row. Resets the
387statement again just before returning.
388
389If the given statement does not yield any results, an {{(exn sqlite3)}}
390is thrown with the {{status}}-property set to {{done}}.
391
392<procedure>(first-row STATEMENT . PARAMETERS) => LIST</procedure><br>
393<procedure>(first-row DATABASE SQL . PARAMETERS) => LIST</procedure>
394
395(Compiles the given SQL), resets the statement, binds the statement's
396free parameters and single-steps the statement once returning all
397columns in the first result row as a list.
398
399If the given statement does not yield any results, an {{(exn sqlite3)}}
400is thrown with the {{status}}-property set to {{done}}.
401
402<procedure>(fold-row PROC INIT STATEMENT . PARAMETERS) => OBJECT</procedure><br>
403<procedure>(fold-row PROC INIT DATABASE SQL . PARAMETERS) => OBJECT</procedure>
404
405(Compiles the given SQL), resets the statement, binds the statement's
406free parameters and executes it step by step. After each step, the
407column values of the current result row are retrieved and {{PROC}} is
408applied to the current folded value, set to {{INIT}} in the first
409step, and the column values. The result of the application becomes the
410new folded value.
411
412<procedure>(for-each-row PROC STATEMENT . PARAMETERS) => VOID</procedure><br>
413<procedure>(for-each-row PROC DATABASE SQL . PARAMETERS) => VOID</procedure>
414
415(Compiles the given SQL), resets the statement, binds the statement's
416free parameters and executes it step by step. After each step, the
417column values of the current result row are retrieved and {{PROC}} is
418applied to them. The results of this application are discarded.
419
420<procedure>(map-row PROC STATEMENT . PARAMETERS) => LIST</procedure><br>
421<procedure>(map-row PROC DATABASE SQL . PARAMETERS) => LIST</procedure>
422
423(Compiles the given SQL), resets the statement, binds the statement's
424free parameters and executes it step by step. After each step, the
425column values of the current result row are retrieved and {{PROC}} is
426applied to them. The results of these applications are collected into
427a list.
428
429==== Utility functions
430
431<procedure>(with-transaction DATABASE THUNK [TYPE]) => OBJECT</procedure>
432
433Runs {{THUNK}} within the scope of a transaction on the database and
434returns the return value from {{THUNK}}.
435
436The transaction is committed upon exit from {{THUNK}} if {{THUNK}}
437returns a true value. If {{THUNK}} returns a false value or
438throws an exception, the transaction is rolled back.
439
440The {{TYPE}}" of the transaction can be specified as one of the symbols
441{{deferred}} (the default), {{immediate}} or {{exclusive}}.
442
443<procedure>(sql-complete? SQL) => BOOLEAN</procedure>
444
445Checks whether {{SQL}} comprises at least one complete SQL statement.
446
447<procedure>(enable-shared-cache! BOOLEAN) => BOOLEAN</procedure>
448
449Enables (or disables) the sharing of the database cache and schema
450data structures between connections to the same database.
451
452Returns whether the shared cache is now enabled. If sqlite3 was compiled
453with the feature {{disable-shared-cache}} defined, this procedure will
454unconditionally return {{#f}}, otherwise it will either return the value
455of its only argument or throw an error.
456
457<procedure>(enable-load-extension! DATABASE BOOLEAN) => BOOLEAN</procedure>
458
459Enables (or disables) the loading of native code extensions into the database engine through the use of SQL statements.
460
461<procedure>(database-version) => STRING</procedure>
462
463Returns a string identifying the version of SQLite in use.
464
465<procedure>(database-memory-used) => CARDINAL-INTEGER</procedure>
466
467Returns the amount of memory currently in use by the database engine.
468
469<procedure>(database-memory-highwater [RESET?]) => CARDINAL-INTEGER</procedure>
470
471Returns the maximum amount of memory that was in use by the database
472engine since the counter was last reset or since the program
473started. Resets the counter if {{RESET?}} is not {{#f}}. {{RESET?}}
474defaults to {{#f}}.
475
476=== Changelog
477
478* 3.7.0 Added enable-load-extension! procedure
479* 3.6.1 Added a compilation option to disable shared cache functionality
480* 3.6.0 Removed use of {{##sys#expand-home-path}}, which no longer exists
481* 3.5.1 Corrected parameter error checks for define-function
482* 3.5.0 Switched to less error prone internal C API
483* 3.4.0 Added optional automatic statement finalization when a database is finalized
484* 3.3.1 Added bindings for database memory statistics
485* 3.3.0 Switched to using {{(sql-null)}} for {{NULL}} values
486* 3.2.1 Added a test suite
487* 3.2.0 Removed the unsafe busy handler and timeout APIs, since a safe API exists
488* 3.1.0 {{bind-parameters!}} can now handle keyword arguments
489* 3.0.0 Ported to CHICKEN 4, removed dependencies on TinyCLOS and EasyFFI
490* 2.0.8 Add busy handler callbacks; ensure finalize! is called on exception. [Jim Ursetto]
491* 2.0.7 Restore error reporting. [Jim Ursetto]
492* 2.0.6 Add {{enable-shared-cache!}}, requires 3.3.0 or later. [Jim Ursetto]
493* 2.0.5 Added some <boolean> support. Change for NULL (<void>) handling. [Kon Lovett]
494* 2.0.4 Added {{sqlite3:fold-row}} & {{sqlite3:bind-parameters!}}. Fix for introduced bug in {{sqlite3:changes}}. [Kon Lovett]
495* 2.0.3 Added {{sqlite3:null-value}}, {{sqlite3:null-value?}}, and {{sqlite3:null}}. [Kon Lovett]
496* 2.0.2 Use of extended {{define-foreign-enum}}. Removed deprecated {{pointer}} use. [Kon Lovett]
497* 2.0.1 Deprecated {{<byte-vector>}}, use {{<blob>}} [Kon Lovett]
498* 2.0.0 Now using {{(void)}} to represent {{NULL}}
499* 1.5.9 dll extension not used anymore in newer chickens [felix]
500* 1.5.8 Update for synch 1.3 [Kon Lovett]
501* 1.5.7 Updated compiler flags to pull in tinyclos and easyffi
502* 1.5.6 Replaced deprecated synch operations [Kon Lovett]
503* 1.5.5 Correction in the documentation, added {{sqlite3:with-transaction}}
504* 1.5.4 Typo fixed thanks to the new imports checking code
505* 1.5.3 Proper multithreading locks for the callback code
506* 1.5.2 Code cleanups
507* 1.5.1 Potential memory leaks removed
508* 1.5.0 Support for user defined collation sequences and functions has been added
509* 1.4.0 Stale statement handles due to schema changes are now automagically recompiled to keep them valid
510* 1.3.1 Several small routines added
511* 1.3.0 Special hacks removed as CVS version of SQLite3.3.4 has been fixed
512* 1.2.0 Special hacks to deal with "valid" {{NULL}} statements
513* 1.1.4 Tightened security measures against {{#f}} pointers
514* 1.1.3 Integers not fitting in a fixnum are now read correctly from the database [thanks to Zbigniew]
515* 1.1.2 Setup file patched to call compiled output .dll on Windows
516* 1.1.1 All procedures now reset prepared statements where you would do that by hand anyway
517* 1.1.0 Promoted {{sqlite3:call-with-temporary-statement}} to {{sqlite3:call-with-temporary-statements}} and fixed a really stupid coding mistake in {{sqlite3:changes}}
518* 1.0.3 Fixed C compiler warnings
519* 1.0.2 Added a typecheck for increased safety
520* 1.0.1 Fixed type mistakes in the source
521* 1.0.0 Initial release
522
523=== License
524
525  Copyright (c) 2005-2009, Thomas Chust <chust@web.de>.  All rights reserved.
526 
527  Redistribution and use in source and binary forms, with or without
528  modification, are permitted provided that the following conditions are met:
529 
530  Redistributions of source code must retain the above copyright notice,
531  this list of conditions and the following disclaimer. Redistributions in
532  binary form must reproduce the above copyright notice, this list of
533  conditions and the following disclaimer in the documentation and/or
534  other materials provided with the distribution. Neither the name of the
535  author nor the names of its contributors may be used to endorse or
536  promote products derived from this software without specific prior
537  written permission.
538 
539  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
540  IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
541  THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
542  PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR
543  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
544  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
545  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
546  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
547  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
548  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
549  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
Note: See TracBrowser for help on using the repository browser.