\input texinfo	@c -*texinfo-*-
@c %**start of header
@setfilename sqlrefman.texi
@settitle SQLdb SQL Language Reference Manual
@setchapternewpage odd
@paragraphindent 0
@c %**end of header

@ifinfo
This file documents the SQL syntax of SQLdb

Copyright 1990-1993 Kyle Saunders

Permission is granted to freely distribute this file in
its entirety as part of the SQLdb evaluation package.
@end ifinfo

@titlepage
@title SQLdb SQL Language Reference Manual
@author Kyle Saunders

@page
@vskip 0pt plus 1filll
Copyright @copyright{} 1990-1993 Kyle Saunders

Permission is granted to freely distribute this file in
its entirety as part of the SQLdb evaluation package.
@end titlepage

@ifinfo
@node Top, Copying, (dir), (dir)
@top SQLdb
This file documents the March, 1993 alpha version of SQLdb.
@end ifinfo

@menu
* Copying::			SQLdb evaluation version is freely
				redistributable
* Introduction::		What is this manual about?
* Simple Elements::		Base tokens
* Data Definition::		Creation and Deletion of Data Objects
* Data IO::			Open and Closing of Data Objects
* Data Manipulation::		Select, Insert, Delete and Update
* Misc::
* Index::
@end menu

@node Copying, Introduction, Top, Top
@unnumbered Copying
Copyright 1990-1993 Kyle Saunders

Permission is granted to freely distribute this file in
its entirety as part of the SQLdb evaluation package.

@node Introduction, Simple Elements, Copying, Top
@chapter Introduction
SQLdb SQL Language reference manual.  Everything in this manual applies
only to SQLdb and any resemblence to other SQL dialects is purely coincidental.

@node Simple Elements, Data Definition, Introduction, Top
@chapter Simple Elements

@menu
* Identifiers::
* Literals::
@end menu

@node Identifiers, Literals, Simple Elements, Simple Elements
@section Identifiers

@menu
* database-ref::
* table-ref::
* column-ref::
* table-alias-ref::
* column-alias-ref::
* cursor-ref::
* index-ref::
@end menu

@node database-ref, table-ref, Identifiers, Identifiers
@subsection database-ref
A database-ref is composed of a letter followed by zero or more characters
from the set of numbers, letters, '_', '#'.  Thus, A#_o1ne is a legal 
database-ref, while _a#45 is not.

An database-ref cannot be a valid SQL keyword.

@node table-ref, column-ref, database-ref, Identifiers 
@subsection table-ref
A table-ref is composed of a letter followed by zero or more characters
from the set of numbers, letters, '_', '#'.  Thus, A#_o1ne is a legal 
table-ref, while _a#45 is not.

A table-ref cannot be a valid SQL keyword.

@node column-ref, table-alias-ref, table-ref, Identifiers
@subsection column-ref
A column-ref is composed of a letter followed by zero or more characters
from the set of numbers, letters, '_', '#'.  Thus, A#_o1ne is a legal 
column-ref, while _a#45 is not.

A column-ref cannot be a valid SQL keyword.

@node table-alias-ref, column-alias-ref, column-ref, Identifiers
@subsection table-alias-ref
A table-alias-ref is composed of a letter followed by zero or more characters
from the set of numbers, letters, '_', '#'.  Thus, A#_o1ne is a legal 
table-alias-ref, while _a#45 is not.

A table-alias-ref cannot be a valid SQL keyword.

@node column-alias-ref, cursor-ref, table-alias-ref, Identifiers
@subsection column-alias-ref
A column-alias-ref is composed of a letter followed by zero or more characters
from the set of numbers, letters, '_', '#'.  Thus, A#_o1ne is a legal 
column-alias-ref, while _a#45 is not.

A column-alias-ref cannot be a valid SQL keyword.

@node cursor-ref, index-ref, column-alias-ref, Identifiers
@subsection cursor-ref
A cursor-ref is composed of a letter followed by zero or more characters
from the set of numbers, letters, '_', '#'.  Thus, A#_o1ne is a legal 
cursor-ref, while _a#45 is not.

A cursor-ref cannot be a valid SQL keyword.

@node index-ref, Literals, cursor-ref, Identifiers
@subsection index-ref
An index-ref is composed of a letter followed by zero or more characters
from the set of numbers, letters, '_', '#'.  Thus, A#_o1ne is a legal 
index-ref, while _a#45 is not.

An index-ref cannot be a valid SQL keyword.

@node Literals, Data Definition, Identifiers, Simple Elements
@section Literals
This section defines the literals of the various data types
available.

@menu
* integer::		INTEGER and SMALLINT
* float::		FLOAT
* character::		CHAR(size)
* date::		DATE
* time::		TIME
@end menu

@node integer, float, Literals, Literals
@subsection integer
An integer literal consists of one or more digits 0 through 9.

45332 is an example of an integer literal.

@node float, character, integer, Literals
@subsection float
A float literal consists of an integer literal (@pxref{integer}),
a period (decimal point), and another integer literal.

45.674 is an example of a float literal.  Note that .456 is @emph{not}
a valid float literal.

@node character, date, float, Literals
@subsection character
A character literal consists of a string of characters enclosed in single quotes (').

'Hello, World' is an example of a character literal.

@node date, time, character, Literals
@subsection date
A date literal is a character literal (@pxref{character}) with a special format.
The format is 'mm/dd/yyyy', where mm is the month (1 is January, 12 is December),
dd is the day of the month, and yyyy is the year.

'4/21/1993' is an example of a date literal.

@node time, Data Definition, date, Literals
@subsection time
A time literal is a character literal (@pxref{character}) with a special
format.  The format is 'hh:mm:ss', where hh is the hour (00 is midnight, 23 is 11pm),
mm is minute (00-59), and ss is the second (00-59).

'17:35:01' is an example of a time literal.

@node Data Definition, Data IO, Simple Elements, Top
@chapter Data Definition

@menu
* CREATE DATABASE::
* CREATE TABLE::
* DROP TABLE::
* CREATE INDEX::
* DROP INDEX::
@end menu

@node CREATE DATABASE, CREATE TABLE, Data Definition, Data Definition
@section CREATE DATABASE
@code{CREATE DATABASE} @var{database-ref}

Creates and opens specified database.  A database consists of a group of 
tables and global information that applies to those tables.  This command 
will fail if a database is already open.	

@xref{database-ref}.

@node CREATE TABLE, DROP TABLE, CREATE DATABASE, Data Definition
@section CREATE TABLE
@code{CREATE TABLE} @var{table-ref} @code{(} @var{table-def-item-list} @code{)}

This statement will create the specified table.  If a table already exists,
it will be overwritten.  However, you cannot create a table is currently
open.  The table will be automatically opened after creation.  You must have
an open database (@pxref{CREATE DATABASE} or @pxref{OPEN DATABASE}), or this
command will fail.

@xref{table-ref}.
@xref{table-def-item}.

@node DROP TABLE, CREATE INDEX, CREATE TABLE, Data Definition
@section DROP TABLE
@code{DROP TABLE} @var{table-ref}

This statement will delete the specified table and remove it from the
database.  The table must be currently open.

@xref{table-ref}.

@node CREATE INDEX, DROP INDEX, DROP TABLE, Data Definition
@section CREATE INDEX
@code{CREATE INDEX} @var{index-ref} @code{ON} @var{table-ref} @code{(} @var{order-ref-list} @code{)}

This statement will create an index on the specified open table.  If the table
contains any rows, they will be entered into the index.  Likewise, all new rows
will be entered.  All index entries must be unique.  If any existing rows contain
non-unique entries for the index, the command will fail.

@xref{index-ref}.
@xref{table-ref}.
@xref{order-ref}.

@node DROP INDEX, Data IO, CREATE INDEX, Data Definition
@section DROP INDEX
@code{DROP INDEX} @var{index-ref} @code{ON} @var{table-ref}

This statement will delete the specified index from the specified open
table.

@xref{index-ref}.
@xref{table-ref}.

@node Data IO, Data Manipulation, Data Definition, Top
@chapter Data IO

@menu
* OPEN DATABASE::
* CLOSE DATABASE::
* OPEN TABLE::
* CLOSE TABLE::
@end menu

@node OPEN DATABASE, CLOSE DATABASE, Data IO, Data IO
@section OPEN DATABASE
@code{OPEN DATABASE} @var{database-ref}

Opens specified database.  Any tables that are created will be
added to the currently open database.  This command will fail if
a database is already open.

@node CLOSE DATABASE, OPEN TABLE, OPEN DATABASE, Data IO
@section CLOSE DATABASE
@code{CLOSE DATABASE} 

Closes the currently open database.

@node OPEN TABLE, CLOSE TABLE, CLOSE DATABASE, Data IO
@section OPEN TABLE
@code{OPEN TABLE} @var{table-ref}

This statement will open the specified table.  The must have
been previously created, or this command will fail.

@node CLOSE TABLE, Data Manipulation, OPEN TABLE, Data IO
@section CLOSE TABLE
@code{CLOSE TABLE} @var{table}

This statement will close the specified table.  All non-system (ie user)
tables must be closed before you may exit SQLdb.

@node Data Manipulation, Misc, Data IO, Top
@chapter Data Manipulation

@menu
* query-spec::		SELECT statement
* insert-spec::		INSERT statement
* delete-spec::		DELETE statement
* update-spec::		UPDATE statement
* Cursors::
* Importing::
@end menu

@node query-spec, insert-spec, Data Manipulation, Data Manipulation
@section query-spec
@flushleft
@var{query-spec}:
        @code{SELECT} [ @code{DISTINCT} ] @{ @var{select-item-list} | @code{*} @}
           @code{FROM} @var{basetable-ref-list}
         [ @code{WHERE} @var{search-condition} ]
         [ @code{GROUP BY} @var{group-ref-list}
         [ @code{HAVING} @var{search-condition} ] ]
         [ @code{ORDER BY} @var{order-ref-list} ]
         [ @code{OUTPUT TO} @var{file-name} ]
@end flushleft

This statement is used to retrieve information from the database.  It is
made up of several clauses, which are explained in the following sections.

If @code{DISTINCT} is specified, then all duplicate rows will be removed from the
result table.

The clauses are, in general, order sensitive.  For example, the @code{OUTPUT TO} clause
should always be the last clause in the @code{SELECT} statement.

@menu
* FROM::
* WHERE::
* GROUP BY::
* HAVING::
* ORDER BY::
* OUTPUT TO::
@end menu
 
@node FROM, WHERE, query-spec, query-spec
@subsection FROM

This clause specifies which tables SQLdb is supposed to gather information
from.  Conceptually, SQLdb will generate a cartesian product of all the
specfied tables.

@xref{basetable-ref}.

@node WHERE, GROUP BY, FROM, query-spec
@subsection WHERE

This clause is used by several other statements, and is used to restrict
the set of rows to be operated on.  Let @var{T} be the result of the
immediately preceding @code{FROM} clause.  The result of the @code{WHERE}
clause is a table that is derived from @var{T} by eliminating all rows for
which the @var{search-condition} does not evaluate to TRUE.

@xref{search-condition}.

@node GROUP BY, HAVING, WHERE, query-spec
@subsection GROUP BY

Let @var{T} be the result of the @code{FROM} clause and @code{WHERE} clause
(if any).  Each "column" mentioned in the @code{GROUP BY} clause must be a
column of @var{T}.  The result of the @code{GROUP BY} clause is a set of tables,
derived from @var{T} by conceptually rearranging it into the minimum number of
groups such that within any one group all rows have the same value for the
combination of columns identified by the @code{GROUP BY} clause.

@xref{group-ref}.

@node HAVING, ORDER BY, GROUP BY, query-spec
@subsection HAVING

Let @var{G} be the grouped table result from the evaluation of the
immediately preceding @code{FROM} clause, @code{WHERE} clause (if any),
and @code{GROUP BY} clause.  The result of the @code{HAVING} clause
are those groups for which the @var{search-condition} is TRUE.

@xref{search-condition}.

@node ORDER BY, OUTPUT TO, HAVING, query-spec
@subsection ORDER BY

This clause orders the result of the preceding clauses, including the
projection of the @var{select-item-list}.  The rows are ordered according
to the @var{order-ref-list}, with each @var{order-ref} being a progressively
minor sort key, to break ties of the previous sort key.  All @var{order-ref}'s
must refer to an item in the @var{select-item-list}.

@xref{order-ref}.
@xref{select-item}.

@node OUTPUT TO, insert-spec, ORDER BY, query-spec
@subsection OUTPUT TO

This command will send the normal query output to the 
specified filename.

@node insert-spec, delete-spec, query-spec, Data Manipulation
@section insert-spec
@flushleft
@var{insert-spec}:
        @code{INSERT INTO} @var{table-ref} 
          [ @code{(} @var{column-ref-list} @code{)} ]
          @{ @code{VALUES} @code{(} @var{insert-item-list} @code{)} | 
            @var{query-spec}
	  @}
@end flushleft

This statement is used to put new rows into a table.  If the @var{column-ref-list}
is omitted, it is equivalent to specifying all of the columns of the target table, in
left-to-right order.  Any columns not named will a @code{NULL} value for each newly
inserted row.

If a query is supplied instead of a value list, the query is executed and all
rows in the result will be inserted into the table.

@xref{table-ref}.
@xref{column-ref}.
@xref{insert-item}.
@xref{query-spec}.

@node delete-spec, update-spec, insert-spec, Data Manipulation
@section delete-spec
@flushleft
@var{delete-spec}:
        @code{DELETE FROM} @var{table-ref} 
          [ @code{WHERE} 
            @{ @var{search-condition} | 
              @code{CURRENT OF} @var{cursor-ref}
            @}
          ]
@end flushleft

This statement is used to delete rows that satisfy the optional WHERE clause.
If the WHERE clause is omitted, all rows in the table are deleted.  If a cursor
is specified, then the row the cursor is on is deleted.

@xref{table-ref}.
@xref{cursor-ref}.
@xref{search-condition}.

@node update-spec, Cursors, delete-spec, Data Manipulation
@section update-spec
@flushleft
@var{update-spec}:
        @code{UPDATE} @var{table-ref}
            @code{SET} @var{assignment-list}
          [ @code{WHERE} @{ search-condition | 
                            @code{CURRENT OF} @var{cursor-ref}
                    @}
          ]
@end flushleft

This statement is used to modify existing rows that satisfy the optional WHERE
clause.  If the WHERE clause is omitted, all rows in the table are modified.

@xref{table-ref}.
@xref{cursor-ref}.
@xref{assignment}.
@xref{search-condition}.

@node Cursors, Importing, update-spec, Data Manipulation
@section Cursors

The following statements can be type interactively, but they are intended to 
be used through an ARexx port.

@menu
* DECLARE::		Declaring a cursor
* OPEN::		Open a cursor
* FETCH::		Fetch a row through a cursor
* CLOSE::		Closing a cusor
@end menu

@node DECLARE, OPEN, Cursors, Cursors
@subsection DECLARE
@code{DECLARE} @var{cursor-ref} @code{CURSOR FOR} @var{query-spec}

This statement will create and define a cursor.  The cursor is
positioned before the first row of the result table of the @var{query-spec}.

@xref{cursor-ref}.
@xref{query-spec}.

@node OPEN, FETCH, DECLARE, Cursors
@subsection OPEN
@code{OPEN} @var{cursor-ref}

This statement will execute a previously declared cursor's @var{query-spec}.  You
must close every cursor that is opened.

@node FETCH, CLOSE, OPEN, Cursors
@subsection FETCH
@code{FETCH} @{ @code{COLUMNS} | @code{FIRST} | @code{LAST} |
@code{PREVIOUS} | @code{NEXT} | @code{ABSOLUTE} @var{integer} |
@code{RELATIVE} @var{integer} @} @code{OF} @var{cursor-ref}

This statement will retrieve the specified row or column list, of the table 
created by the cursor's @var{query-spec}.

If a column list is specified, it will return three elements for each column
of the result table separated by a space:
@var{column-ref} @var{column-type} @var{maximum-value-size}

@xref{column-ref}.

@node CLOSE, Misc, FETCH, Cursors
@subsection CLOSE
@code{CLOSE} @var{cursor-ref}

This statement will close and remove an existing cursor.  A cursor that has
been closed must be re-declared and re-opened.

@node search-condition, , ,
@unnumbered search-condition
@flushleft
@var{search-condition}:
        @var{search-item} |
        @var{search-item} @{ @code{AND} | @code{OR} @}
        @var{search-item}
@end flushleft

Each search-item evaluates to a true, false, AMARK, or IMARK.  This is a
four value logic system.

@flushleft
Truth Tables:

AND| F  A  I  T		OR| F  A  I  T
---------------		--------------
 F | F  F  F  F		F | F  A  F  T
 A | F  A  I  A		A | A  A  A  T
 I | F  I  I  I		I | F  A  I  T
 T | F  A  I  T		T | T  T  T  T
@end flushleft

@xref{search-item}.

@node search-item, , , 
@unnumberedsec search-item
@flushleft
@var{search-item}:
        @{ @var{search-test} |
          @{ @code{NOT} | @code{MAYBE_A} | @code{MAYBE_I} | @code{MAYBE} @}
          @code{(} @var{search-condition} @code{)}
        @}
@end flushleft

The logical operators NOT, MAYBE_A, MAYBE_I, MAYBE are defined below:

@flushleft
	P |NOT P   P | MAYBE_I P   P | MAYBE_A P   P | MAYBE P
	--------   -------------   -------------   -----------
	t | f	   t | f	   t | f	   t | f
	a | a      a | f           a | t	   a | t
	i | i      i | t 	   i | f	   i | t
  	f | t      f | f 	   f | f	   f | f
@end flushleft

@xref{search-test}.

@node search-test, , , 
@unnumberedsubsec search-test
@flushleft
@var{search-test}:
        @var{comparison-test} | @var{like-test} |
        @var{set-test} | @var{quantified-test} |
        @var{existence-test} | @var{is-null-test}
@end flushleft

@menu
* comparison-test::
* like-test::
* set-test::
* quantified-test::
* existence-test::
* is-null-test::
@end menu

@node comparison-test, like-test, search-test, search-test
@unnumberedsubsec comparison-test
@flushleft
@var{comparison-test}:
        @var{expr}
        @{ @code{=} | @code{<>} | @code{<} | @code{<=} | @code{>} | @code{>=} @}
        @{ @var{expr} | @var{query-spec} @}
@end flushleft

In the case of an @var{query-spec} on the right-hand side, the @var{expr}
is compared with the first element of the the first row of the result table.

@xref{query-spec}.
@xref{expr}.

@node like-test, set-test, comparison-test, search-test
@unnumberedsubsec like-test
@flushleft
@var{like-test}:
        @var{column-ref} [ @code{NOT} ] @code{LIKE}
        @var{string-pattern}
        [ @code{ESCAPE} @var{charstr} ]
@end flushleft

A string pattern is a string literal.  The '%' is a wildcard to match
0 or more characters, and the '_' is a wildcard to match one character.
The escape character, if specified, will turn a '%' or '_' into a normal
character.  

	Example:  foo LIKE 'ab#%c' ESCAPE '#' will match the string 'ab%c'.

@xref{column-ref}.

@node set-test, quantified-test, like-test, search-test
@unnumberedsubsec set-test
@flushleft
@var{set-test}:
        @var{expr} [ @code{NOT} ] @code{IN}
        @{ @code{(} @var{literal-list} @code{)} | @var{query-spec} @}
@end flushleft

@xref{expr}.
@xref{Literals}.
@xref{query-spec}.

@node quantified-test, existence-test, set-test, search-test
@unnumberedsubsec quantified-test
@flushleft
@var{quantified-test}:
        @var{expr}
        @{ @code{=} | @code{<>} | @code{<} | @code{<=} | @code{>} | @code{>=} @}
        @{ @code{ALL} | @code{ANY} | @code{SOME} @} @var{query-spec}
@end flushleft

@xref{expr}.
@xref{query-spec}.


@node existence-test, is-null-test, quantified-test, search-test
@unnumberedsubsec existence-test
@flushleft
@code{existence-test}:
        [ @code{NOT} ] @code{EXISTS} @var{query-spec}
@end flushleft

@node is-null-test, , existence-test, search-test
@unnumberedsubsec is-null-test
@flushleft
@code{is-null-test}:
        @code{IS} [ @code{NOT} ] @code{NULL}
@end flushleft

@node expr, , ,
@unnumberedsubsec expr
@flushleft
@var{expr}:
        @var{expr-item} |
        @var{expr-item} @{ @code{+} | @code{-} | @code{*} | @code{/} @} @var{expr-item}
@end flushleft

The four operators have equal precedence.  Use parentheses to force a 
particular evaluation order.

@xref{expr-item}.

@node expr-item, , ,
@unnumberedsubsec expr-item
@flushleft
@var{expr-item}:
        @var{function} | @var{value} | @var{column-ref} | @code{(} @var{expr} @code{)}
@end flushleft

@xref{function}.
@xref{value}.
@xref{column-ref}.
@xref{expr}.

@node value, , ,
@unnumberedsubsec value
@flushleft
@var{value}:
        @var{literal} | @code{AMARK} | @code{IMARK} | @code{NULL}
@end flushleft

@xref{Literals}.

@node function, , ,
@unnumberedsubsec function
@flushleft
@var{function}:
        @{ @code{AVG} | @code{MAX} | @code{MIN} | @code{SUM} | @code{COUNT} @} @code{(} expr @code{)}
@end flushleft

Functions can only be applied to numeric (@code{FLOAT}, @code{SMALLINT}, and @code{INTEGER}) columns.

@flushleft
	@code{AVG}		average of all values in an expression
	@code{MAX}		maximum value in an expression
	@code{MIN}		minimum value in an expression
	@code{SUM}		total of values in an expression
	@code{COUNT}		number of values (rows)
@end flushleft

@node assignment, , ,
@unnumberedsubsec assignment
@flushleft
@var{assignment}:
	@var{qualcolumn-ref} @code{=} @var{expr}
@end flushleft

@xref{qualcolumn-ref}.
@xref{expr}.

@node insert-item, , ,
@unnumberedsubsec insert-item
@flushleft
@var{insert-item}:
	@var{value}
@end flushleft

@xref{value}.

@node select-item, , ,
@unnumberedsubsec select-item
@flushleft
@var{select-item}:
	@var{expr} [ @code{AS} @var{column-alias-ref} ]
@end flushleft

Column aliases can be used to reference an expression later in the 
select-item-list.

@flushleft
	Example:  SELECT col1,col1 AS foocol, foocol*2 AS bleh FROM footab;

	col1  foocol  bleh
	----  ------  ----
	1     1       2
	3     3       6
@end flushleft

@xref{expr}.
@xref{column-alias-ref}.

@node basetable-ref, , ,
@unnumberedsubsec basetable-ref
@flushleft
@var{basetable-ref}:
	@var{table-ref} [ @var{table-alias-ref} ]
@end flushleft

@xref{table-ref}.
@xref{table-alias-ref}.

@node qualcolumn-ref, , ,
@unnumberedsubsec qualcolumn-ref
@flushleft
@var{qualcolumn-ref}:
	[ @{ @var{table-ref} | @var{table-alias-ref} @} . ] @var{column-ref}
@end flushleft

@xref{table-ref}.
@xref{table-alias-ref}.
@xref{column-ref}.

@node group-ref, , ,
@unnumberedsubsec group-ref
@flushleft
@var{group-ref}:
	@var{qualcolumn-ref} | @var{integer}
@end flushleft

@xref{qualcolumn-ref}.
@xref{integer}.

@node order-ref, , ,
@unnumberedsubsec order-ref
@flushleft
@var{order-ref}:
	@var{group-ref} [ @{ @code{ASC} | @code{DESC} @} ]
@end flushleft

@xref{group-ref}.

@node table-def-item, , ,
@unnumberedsubsec table-def-item
@flushleft
@var{table-def-item}:
	@var{column-def}
@end flushleft

@xref{column-def}.

@node column-def, , ,
@unnumberedsubsec column-def
@flushleft
@var{column-def}:
	@var{column-ref}
	@{ @code{INTEGER} | @code{SMALLINT} |
	  @code{FLOAT} | @code{CHAR(}@var{integer}@code{)} |
	  @code{DATE} | @code{TIME}
	@}
@end flushleft

The maximum size of CHAR column is 1024.

@xref{Literals}.

@node Importing, Misc, Cursors, Data Manipulation
@section Importing

@menu
* IMPORT ASCII::
* IMPORT DBASE::
@end menu

@node IMPORT ASCII, IMPORT DBASE, Importing, Importing
@subsection IMPORT ASCII
@flushleft
@code{IMPORT ASCII} @var{filename}
	@{ @code{DELIMITER} @var{string} |
	   @code{TEMPLATE} template-col-list
	@}
@end flushleft

@xref{template-col}.

@node template-col, , ,
@unnumberedsubsec
@flushleft
@var{template-col}:
	start-col@code{:}end-col
@end flushleft

@node IMPORT DBASE, , IMPORT ASCII, Importing
@subsection IMPORT DBASE

Not implemented.

@node Misc, Index, Importing, Top
@chapter Misc

@menu
* DISPLAY TABLE::
* DISPLAY DATABASE::
@end menu

@node DISPLAY TABLE, DISPLAY DATABASE, Misc, Misc
@section DISPLAY TABLE
@flushleft
@code{DISPLAY TABLE} @var{table-ref}
@end flushleft

This statement will display information about the specified open table.

@xref{table-ref}.

@node DISPLAY DATABASE, Index, DISPLAY TABLE, Misc
@section DISPLAY DATABASE
@flushleft
@code{DISPLAY DATABASE}
@end flushleft

This statement will display the names of all open tables.

@node Index, , Misc, Top
@appendix Index
@printindex fn
@contents
@bye