\documentclass {article}
%\documentclass [twocolumn]{article}
\usepackage{amsmath}
\usepackage{indentfirst}
\usepackage{blkarray}
                             % The preamble begins here.
\title{The Java SQLite3 Database Editor}  % Declares the document's title.
\author{Sidney Marshall}      % Declares the author's name.
\date{October 17, 2014 (updated \today)}  % Deleting this command produces today's date.




%allow other brackets in bordermatrix using [] arguments

\makeatletter
\newif\if@borderstar
\def\bordermatrix{\@ifnextchar*{%
  \@borderstartrue\@bordermatrix@i}{\@borderstarfalse\@bordermatrix@i*}%
}
\def\@bordermatrix@i*{\@ifnextchar[{\@bordermatrix@ii}{\@bordermatrix@ii[()]}}
\def\@bordermatrix@ii[#1]#2{%
\begingroup
 \m@th\@tempdima8.75\p@\setbox\z@\vbox{%
  \def\cr{\crcr\noalign{\kern 2\p@\global\let\cr\endline }}%
  \ialign {$##$\hfil\kern 2\p@\kern\@tempdima & \thinspace %
  \hfil $##$\hfil && \quad\hfil $##$\hfil\crcr\omit\strut %
  \hfil\crcr\noalign{\kern -\baselineskip}#2\crcr\omit %
  \strut\cr}}%
 \setbox\tw@\vbox{\unvcopy\z@\global\setbox\@ne\lastbox}%
 \setbox\tw@\hbox{\unhbox\@ne\unskip\global\setbox\@ne\lastbox}%
 \setbox\tw@\hbox{%
  $\kern\wd\@ne\kern -\@tempdima\left\@firstoftwo#1%
   \if@borderstar\kern2pt\else\kern -\wd\@ne\fi%
  \global\setbox\@ne\vbox{\box\@ne\if@borderstar\else\kern 2\p@\fi}%
  \vcenter{\if@borderstar\else\kern -\ht\@ne\fi%
   \unvbox\z@\kern-\if@borderstar2\fi\baselineskip}%
   \if@borderstar\kern-2\@tempdima\kern2\p@\else\,\fi\right\@secondoftwo#1 $%
 }\null \;\vbox{\kern\ht\@ne\box\tw@}%
\endgroup
}
\makeatother

\DeclareMathOperator{\sech}{sech}
\DeclareMathOperator{\csch}{csch}
\DeclareMathOperator{\arc}{arc}
\DeclareMathOperator{\real}{real}
\DeclareMathOperator{\imag}{imag}
\DeclareMathOperator{\AGM}{AGM}
%\DeclareMathOperator{\Re}{Re}
%\DeclareMathOperator{\Im}{Im}

\usepackage{enumitem}

\newcommand{\ip}[2]{(#1, #2)}
                             % Defines \ip{arg1}{arg2} to mean
                             % (arg1, arg2).

%\newcommand{\ip}[2]{\langle #1 | #2\rangle}
                             % This is an alternative definition of
                             % \ip that is commented out.

% from latex.ltx

\begin{document}             % End of preamble and beginning of text.

\maketitle                   % Produces the title.
%\addappheadtotoc
\tableofcontents

\newpage

\begin{abstract}



\end{abstract}

\section{Introduction - The SQLite3 Database Editor}

The Java Database editor is a Java jar file program that together with
the sqlite-jdbc jar file edits SQLite3 databases. It runs under
windows, linux, and macs. Originally the code was based on some work
of RIT students but the current code has diverged from this original
code base.

The current editor can run with any SQLite3 version (after 3.7.9) by
pointing the class path to the desired jdbc version. Currently, the
class path is set to \verb|sqlite-jdbc-3.27.2.jar| although any recent
SQLite3 jdbc version can be used. There are some new SQL commands
available in the later versions that are not available in the earlier
versions.

All of the DatabaseEditor source code is available in the
\verb|dbe.jar| file in the file \verb|DatabaseEditor.java|. The
interface source code, class files, and native libraries for various
operating systems are in the \verb|sqlite-jdbc-xxx.jar| file. You need
both the \verb|dbe.jar| and \verb|sqlite-jdbc-xxx.jar| files to run
the editor.

\section{Tools Needed To Run the Database Editor}

You need a Java from \verb|java.sun.com| or
\verb|www.oracle.com/technetwork/java|. I use Java8. If you do not
want to recompile the editor you only need the JRE. If you do want to
recompile the editor you will need the SDK.

\section{Using the Database Editor}

The editor can be run from the command line or by double-clicking the
\verb|dbe.jar| icon. The command line invocation is:

\verb|java -jar dbe.jar [database [database char-set [file char-set]]|

If the optional \verb|database| argument is not given or if the editor
is run by clicking on its icon a file browser will appear to choose
the database to open. If the \verb|database| is given on the command
line then the named database is opened. If the database name given
does not exist then an empty database will be created.

All internal strings use the Java String character set. When reading
or writing the database these strings are converted to or from byte
strings using the \verb|database char-set|. When reading or writing
files these strings are converted to or from file bytes using the
\verb|file char-set|.

If the optional \verb|char-set| or the optional \verb|file char-set|
argument is not given then the default UTF-8 character set is
used. Otherwise an attempt will be made to use the specified character
set encoding. Lines are always terminated with a new-line byte and not
a platform-specific end-of-line character.

The windows available in the database editor are:

\begin{description}[style=multiline,leftmargin=2in]
  \item[Database Chooser] Chooses which database to operate on
  \item[Database Window] Displays the tables and views in the database
  \item[Table Window] Displays the rows and columns of a table or view
  \item[Result Table Window] Displays the rows and columns of a result
    set
  \item[Edit Window] An editable text window for editing the contents
    of a table cell
  \item[Command Window] An editable text window allowing the execution
    of SQL commands
  \item[Find-Replace Window] A control window for text searching and
    replacing in an Edit Window or Command Window
  \item[Column Search Window] A control window for searching a table
    column
\end{description}

The contents of all editable text windows can be copied or pasted to
or from the clipboard. The control characters for all editable windows
are:

\begin{description}[style=multiline,leftmargin=1in]
  \item[cntrl-X] Cuts the selected text and copies it to the clipboard
  \item[cntrl-C] Copies the selected text to the clipboard
  \item[cntrl-V] Pastes the text from the clipboard replacing the
    selected text
  \item[cntrl-A] Selects all of the text
  \item[DEL] Deletes the selected text or the character following the
    cursor if nothing is selected
\end{description}

In addition, multiline edit windows support:

\begin{description}[style=multiline,leftmargin=1in]
  \item[cntrl-Z] Undoes the last action
  \item[cntrl-Y] Redoes the last action
\end{description}

Multiple redos or undoes can be done.

When a window is closed all dependent windows are also closed. In
particular, when a Database Window is closed all windows associated
with this database connection are closed. Here is a list of what gets closed:

\begin{description}[style=multiline,leftmargin=2in]
  \item[Database Window] All windows associated with this database
    connection
  \item[Table Window] All Edit Windows editing a cell of the table or
    view and all Column Search windows
  \item[Result Table Window] All Column Search windows
  \item[Edit Window] Find Replace windows on the Edit window
  \item[Command Window] Find Replace windows on the Command window
  \item[Find-Replace Window] Nothing else gets closed
  \item[Column Search Window] Nothing else gets closed
\end{description}

\subsection{The Database Chooser}

Chooses the database file to operate on. If several databases are
opened there is no connection between them and SQL statements cannot
reference tables from multiple databases. You can \verb|attach| a
database (using a Command Window) and SQL statements can then be used
to reference multiple databases.

\subsection{The Database Window}

When a database is opened a Database Window will appear listing all of
the tables and views in all of the databases currently attached. Views
have a background of yellow. If the name of a table appears in
multiple databases then the name of the datamase (\verb|main|,
\verb|temp|, or attached name) is displayed before the table name for
disambiguation. Hovering the mouse over an entry will display the full
name, i.e., database name and table/view name.

Left clicking on the name of a table or view will bring up a Table
Window displaying the contents of this table or view. All of the
tables and views in the \verb|temp| database and attached databases
are also listed.

Right clicking on the name of a table or view additionally brings up a
Table Window displaying the contents of the table or view. It also
brings up a Table Search Window that can search the contents of a
table column.

In most cases there will be only one Table Window opened on a
particular table or view. If an attempt to open another Table Window
on the same table or view the previously opened Table Window will be
selected and brought to the front.

Below the list of tables and views are four buttons:

\begin{description}[style=multiline,leftmargin=2in]
  \item[Refresh] Refreshes the list of tables and views in case any
    have been added or removed
  \item[Show Hidden Tables] Displays all tables and views in the
    database with database names including internal SQLite tables
  \item[Open Command Window] Opens an empty Command Window which
    allows executing SQL commands
  \item[Open Database] Opens the same or different database in a
    separate process
  \item[Read Database] Reads and executes SQL commands from a file
  \item[Write Database] Writes the entire database as SQL statements
\end{description}

Note that if you create or drop tables or views the list of tables and
views will not be updated until you click \verb|Refresh|.

If you click \verb|Show Hidden Tables| then all tables are displayed
including tables that begin with \verb|sqlite_| used by the SQLite
database itself. Do not edit these tables unless you {\it really} know
what you are doing.

If you open the same or another database using the
\verb|Open Database| button the two database connections do not share
any state, in particular, \verb|temp| tables will not be shared
between database connections. If you \verb|attach| a database in a
Command Window then you can access both databases simultaneously,
e.g., in an SQL statement.

The \verb|Read Database| button will bring up a File
Chooser. Selecting a file will read and execute SQL statements from
the selected file. If the database is empty and the file was created
with the \verb|Write Database| button then the database will be
restored. This button will also read arbitrary SQL statements from a
file and execute them. For all statements that generate a table (e.g.,
\verb|select| statements) a result table is displayed. This can be
used to open several Table Windows and do other database maintenance
automatically. {\bf Warning: If the commands read from the file open a
  transaction and an error occurs, the transaction is still pending;
  you will lose all subsequent work unless you close the pending
  transaction.}

The \verb|Write Database| button will output the entire database to a
file as SQL statements that, when read into an empty database, will
restore the database. You can also use an editor on this file to
extract pieces of the database.

\subsection{The Table Window}

The Table Window displays the contents of a table, view, or the result
of a \verb|select| statement or executed command that returns a result
set. The labels at the top of the table indicate the database column
names. You can resize columns by dragging the boundaries of the
labels. You can move columns around by dragging a label to where you
want the column. Neither of these operations has any effect on the
actual database itself.

All database tables are assumed to contain strings (or
\verb|NULL|). SQLite does not enforce strict typing and will convert
other types to strings. \verb|BLOB|s containing binary information are
not specifically handled by this editor although they can be created
by executing SQL statements. Read the section on type affinities in
the sqlite documentation for more information (sqlite.org $\Rightarrow$ SQL
Syntax $\Rightarrow$ expression $\Rightarrow$ scroll to CAST expressions $\Rightarrow$ rules for
determining column affinity).

When the Table Window is first initialized it reads the contents of
the table from the database and caches this contents in a ``shadow''
table in memory. It also initializes another ``backing'' table with
the same contents. Whenever the Table Window is refreshed it uses the
backing table. Table entries that differ between the shadow and
backing tables are colored red to indicate a changed table
entry. Editing a table entry changes the backing table but does not
change the shadow table. Only the buttons ``Delete Selected Rows'' and
``Update Table'' refresh the shadow copy from the database after
performing their other operations. The button ``Delete Selected Rows''
also forgets any pending updates to the table (this is probably a
bug but somewhat hard to fix).

The contents of a table entry may be edited by selecting the entry and
editing it in place. You can drag table entries to other entries and
the dragged contents will replace the previous contents of the
entry. You can also drag file names from file browser windows although
only a single file can be dragged at a time.

Right clicking on any cell of the table will bring up an Edit Window
initialized with the contents of the cell. This is useful if the text
is long or contains multiple lines. The in-place editor does not
handle multiple lines of text. Right clicking on a cell in a newly
created table row will bring up an editor on the cell but the update
button is missing in the editor (as the cell does not have a real row
in the table until that row is saved to the table as the editor would
be confused as to which cell it was editing).

Right clicking on a column title will bring up a Table Search Window
that can search the contents of an entire table column.

Drag-and-drop works between table cells of the same or different
tables. You can also drag-and-drop single files from a file window to
a cell and the file name (without directory information) will be
copied to the cell. Copy and paste also work.

Updates to a view or result set (created by executing a select statement in a command window) are not permitted (since views and result sets cannot be modified) unless
\verb|instead of| triggers are defined on a view. Also ***********

There are two varieties of Table Windows: those on tables and views
and those on a result set generated by executing a \verb|select|
statement.

\subsubsection{The Table Window on Tables and Views}

Editing a table entry does not affect the database table until one of
the update buttons is clicked. Entries that differ from the value
fetched from the table are colored red to indicate that the entry has
not been updated. The buttons at the bottom of the Table Window on a
table or view are:

\begin{description}[style=multiline,leftmargin=1.6in]
  \item[Delete Selected Rows] Deletes the selected row
  \item[Make NULL] Makes the selected cell \verb|NULL|
  \item[Revert Selected] Reverts all entries in the row with the
    selection to their initial values
  \item[Revert Table] Reverts all entries in the table to their
    initial values
  \item[Add Row] Adds a new row to the table with all entries
    \verb|NULL|
  \item[Fill Column] See below
  \item[Update Selected] Updates the database with the changed entries
    in the row with the selection
  \item[Update Table] Updates the database with all changed entries in
    the entire table and then refreshes the table from the database
\end{description}

The \verb|Fill Column| button fills contiguous \verb|NULL| cells in a
column. The filling will proceed until a non-\verb|NULL| cell is
encountered or the end of the column is reached.

If the selected cell contains a \verb|NULL| and the cell above it is
non-\verb|NULL| or the selected cell is non-\verb|NULL| then the
\verb|NULL| cells are filled with a copy of the non-\verb|NULL| cell.

If the selected cell is non-\verb|NULL| and the followung cell is
non-\verb|NULL| and the second following cell is \verb|NULL| and the
two non-\verb|NULL| cells contain strings of the same length and
differ in only one character then the following \verb|NULL| cells are
filled with strings in an arithmetical progression for the differing
character in the strings.

In the following examples the selected cell is in brackets. The
examples are layed out horizontaly but they represent a vertical set
of cells.

Clicking on \verb|Fill Column| in the following examples gives the
indicated results.

[xab], null, null, null, abc $\Rightarrow$ xab, xab, xab, xab, abc

xab, [null], null, null, abc $\Rightarrow$ xab, xab, xab, xab, abc

[xab], xbb, null, null, abc $\Rightarrow$ xab, xbb, xcb, xdb, abc

\subsubsection{The Table Window on Result Sets}

Result sets are not editable (although the display of a result set can
be edited). The bottom of a Table Window on a result set resulting
from executing a select statement in a Command Window contains:

\begin{description}[style=multiline,leftmargin=1.6in]
  \item[Write File] Writes a file containing an image of the result
    set.
  \item[Text line] The name of the file to write defaults to
    \verb|data.txt|.
  \item[Browse button] Brings up a file browser to select the file to
    be written.
  \item[Escape Strings] Check to escape cell strings.
  \item[Column Separator] Text separating cells in a row --- defaults
    to a comma character.
  \item[Row End] Text terminating rows --- defaults to the new-line
    character.
  \item[null] Text for outputting nulls --- defaults to \verb|null|.
\end{description}

Clicking on the \verb|Write File| button writes the named file with
the contents of the result set. Cells in a row are separated by the
\verb|Row Separator| field and each row is terminated by the contents
of the \verb|ColunmEnd| field. Cells with \verb|null| are output with
the contents of the \verb|null| field.

The \verb|Browse| button brings up a file browser to select the file
to be written. The \verb|set| button sets the file to be written but
does not actually write any files.

If the \verb|Escape Strings| box is checked then all of the cells are
output with quotes ($'$) around them and any quote characters are
replaced with double quotes. This does not affect \verb|null| fields.

\subsection{The Edit Window}

This is an editable text window that is tied to a particular cell in a
Table Window. You can perform any edits here and copy and paste
between windows. The buttons at the bottom of the Edit Window are:

\begin{description}[style=multiline,leftmargin=1.6in]
  \item[Open in Command Window] Opens a Command Window with the
    contents of this window
  \item[Break Lines in Selection] Replaces selection with lines broken
    at no more than 70 characters - preserves double newlines
  \item[Update] Updates the table cell spawning this window with this
    window's contents
\end{description}

Note that the database is not updated when the \verb|Update| button is
clicked. An update button on the Table Window must also be clicked to
update the database.

The \verb|Open in Command Window| button was added to conveniently
execute SQL statements that are stored in the database itself.

\subsection{The Command Window}

The Command Window is an editable text window that allows SQL
statements to be executed. There are six buttons at the bottom:

\begin{description}[style=multiline,leftmargin=1.5in]
  \item[Execute Selection] Executes the selection in the window as an
    SQL statement
  \item[Select Next Command] Selects the next sql statement following
    the current selection
  \item[Break Lines in Selection] Replaces selection with lines broken
    at no more than 70 characters - preserves double newlines
  \item[Print] Send the contents of the window to a printer
  \item[Read File] Loads a file into the Command Window for editing
  \item[Write File] Saves the contents of the Command Window into a
    file
\end{description}

If the button is clicked and there is no selection then the entire
window contents is executed as an SQL statement.

Because the JDBC interface to SQLite3 only executes a single statement
only one statement at a time can be executed.

After the statement is executed any errors (Java exceptions) are noted
in the status line at the bottom of the window. If there are no errors
then the update count is displayed in the status line if it is not
negative. Otherwise, the statement returned a result set and a Table
Window is created displaying the contents of this result set. This
result set is not editable but its cell contents can be copied or
brought up in an Edit Window.

The \verb|Read File| and \verb|Write File| buttons allow the Command
Window to be used as a text editor.

\subsection{The Find-Replace Window}

Right clicking in an Edit Window or a Command Window brings up a
Find-Replace Window. There are two editable fields (find and replace)
and four buttons in the window:

\begin{description}[style=multiline,leftmargin=1.2in]
  \item[Find] Finds and selects the next occurrence of the text in the
    adjacent find field
  \item[Find Funny] Finds and selects the next ``funny'' character - a
    funny character is any character that is not 7-bit ASCII or a
    new-line
  \item[Replace] Replaces the selected text with the contents of the
    adjacent replace field
  \item[Replace/Find] Does a replace operation followed by a find
    operation
\end{description}

The \verb|Replace| operations modify the contents of the associated
Edit Window but the database will not be affected until the Edit
Window update is clicked and an \verb|Update| button on the Table
Window is clicked.

If a \verb|Find| or \verb|Find Funny| search does not find any further
matches then the selection is set to the beginning of the file and the
status line displays \verb|not found|. This means the search will
start at the beginning, i.e., the search will start at the beginning
the next time a search is attempted.

The status line also contains a check box on the right labelled
\verb|Ignore Case|. If checked, the search is done without requiring
that the case of the search string maches. If unchecked, the search
string must match exactly, including case.

\subsection{The Column Search Window}

Right clicking on a table in the The Table Search window or right
clicking on a table column label brings up a Column Search Window. A
Column Search Window enables searching the contents of an entire
column of a table or view. There are four buttons in the window:

\begin{description}[style=multiline,leftmargin=1in]
  \item[Find] Finds the next cell in the specified column after the
    selected cell containing the search string and brings up an Edit
    Window on the cell's contents with an associated Find-Replace
    Window.
  \item[Find Funny] Finds the next cell in the specified column after
    the selected cell with a ``funny'' character and brings up an Edit
    Window on the cell's contents with an associated Find-Replace
    Window - a funny character is any character that is not ASCII or a
    new-line
  \item[To Hex] Replaces the contents of the replace field with a hex
    representation of its contents
  \item[From Hex] Replaces the contents of the replace field with a
    string having this hex representation
\end{description}

Before performing a column search the column field must be initialized
to a valid column designation. Right clicking on a table header will
do this automatically. Right clicking on a table or view in a Database
Editor Window initializes this designation to the first column in the
table. Using the drop-down menu you can select any column. You can
change the column designation at any time.

The table field is for your information only and indicates which table
is being searched. Its contents are not editable.

If there is no cell selected the search starts at the first
row. Otherwise it starts in the row following the row with the
selection.

When a \verb|Find| or \verb|Find Funny| operation finds a matching
cell it selects it and brings up an Edit Window on this cell and a
Find-Replace window on this Edit Window. Nothing is selected in the
Edit Window and the find and replace fields in the Find-Replace window
are initialized from the corresponding fields of the Column Search
window. You must do your own search or other editing in the cell
contents Edit window.

The \verb|To Hex| and \verb|From Hex| buttons are for manipulating
text by their numerical value. The results can be copied and pasted to
other windows. The replace field should be set to a replacement string
if a replace operation is desired.

There is also a check box labelled \verb|Ignore Case| on the status
line. If checked, the search is done without requiring that the case
of the search string matches. If unchecked, the search string must
match exactly, including case.

\section{Compiling The Database Editor}

To recompile the \verb|dbe.jar| file you need the following files:

\begin{description}[style=multiline,leftmargin=1.6in]
  \item[DatabaseEditor.java] The source for the Database editor
  \item[manifest.txt] A file with a manifest with a class path
    pointing to the current jdbc database \verb|.jar| file
  \item[sqlite-jdbc-XXX.jar] The jdbc file implementing the Java
    interface
\end{description}

You can make the \verb|manifest.txt| file with a single line using any
text editor with the contents (for example):
\begin{verbatim}
Class-Path: sqlite-jdbc-3.16.1.jar
\end{verbatim}

Then do the following:
\begin{verbatim}
rm DatabaseEditor.class DatabaseEditor\$*.class
javac -target 1.8 -source 1.8 DatabaseEditor.java
jar cfme dbe.jar manifest.txt DatabaseEditor DatabaseEditor*.class DatabaseEditor.java
rm DatabaseEditor.class DatabaseEditor\$*.class
\end{verbatim}
Here is my Makefile section:
\begin{verbatim}
dbe.jar: DatabaseEditor.java manifest.txt Makefile
	touch DatabaseEditor.class
	-rm DatabaseEditor*.class
	javac -target 1.8 -source 1.8 DatabaseEditor.java
	jar cfme dbe.jar manifest.txt DatabaseEditor DatabaseEditor*.class DatabaseEditor.java
	rm DatabaseEditor*.class
\end{verbatim}

\subsection{SQLite3}

SQLite3 is a free relational database system. All of the tables of a
database are stored in a single file making backup as simple as
copying this file. It can be downloaded from www.sqlite.org by
following directions there. I am using version 3.16.1 although most
versions are compatible with each other. I compiled the
sqlite-amalgamation version which also contains a shell driver for
executing SQL commands. The database editor can also be made with
SQLite3 version 3.7.9 with reduced functionality.

You do not need to compile SQLite3 to maintain a database. Command
Windows in the Java Database editor are all you need. But if you want
a \verb|.c| program or want to use \verb|C| programs to interact with
a database you can do the following.

To compile the SQLite3 program use the command
\begin{verbatim}
gcc shell.c sqlite3.c -o sqlite3
\end{verbatim}
This compiles the files \verb|shell.c|, \verb|sqlite3.c|,
\verb|sqlite3.h|, and \verb|sqlite3ext.h| and makes an \verb|sqlite3|
executable. Any ANSI C compiler can be used.

You can also use the shell driver \verb|sqlite3| for examining or
modifying databases. You run it (after appropriately compiling it) by
typing
\begin{verbatim}
./sqlite3 xxx.db
\end{verbatim}

\subsection{Java / sqlite-jdbc}

The sqlitejdbc project has free sqlite3 interfaces for Java. I used
this interface to write Java programs to display and update SQLite3
tables and views. This is the program I use to enter and update data
for the web site. Programs can execute raw SQL commands for changing
the structure of the database or you can use other tools (like the
SQLite shell) for this. The jar file \verb|dbe.jar| is a
self-executing file and can be run (in some environments) by
double-clicking on it or running the command
\verb|java -jar dbe.jar|. You can also specify a database to be opened
with the command \verb|java -jar dbe.jar squaredance.db|. You must
have a \verb|sqlite-jdbc-XXX.jar| file in the same directory as this
is the interface between Java and SQLite3. Various versions of the
\verb|sqlite-jdbc-XXX.jar| file are available from
\verb|https://bitbucket.org/xerial/sqlite-jdbc/downloads|

If the appropriate triggers are written you can also update
views. Check the corresponding trigger to see what you should enter.
It may not be what you expect.

\subsection{Java}

The tools work under Java8. A \verb|sqlite-jdbc-XXX.jar| file is
needed to supply the interface between Java and sqlite3. Included in
this .jar file are native libraries that speed up the interface. The
supplied \verb|Makefile| has a target for \verb|dbe.jar| that will
compile \verb|DatabaseEditor.java| and create a database editor
\verb|.jar| file with the correct manifest.

\section{Bugs or Things To Fix}

Sometimes edit windows created off-screen.

Break lines needs work.

\end{document}               % End of document.

%%  LocalWords:  SQLite sqlite jdbc linux RIT SQL DatabaseEditor dbe
%%  LocalWords:  JRE SDK UTF cntrl multiline redos resize txt
%%  LocalWords:  ColunmEnd Makefile sqlitejdbc squaredance
