This is Info file database.info, produced by Makeinfo-1.55 from the input file database.texi.  File: database.info, Node: Local variables, Next: Global variables, Prev: Hooks and customization functions, Up: Customization Local variables =============== Variables may be specified to be local to a particular data display buffer or to a database; that is, when the variable's value is changed in one data display buffer or in one database, its value elsewhere is unaffected. * Menu: * Per-data-display-buffer variables:: Per-data-display-buffer variables * Per-database variables:: Per-database variables  File: database.info, Node: Per-data-display-buffer variables, Next: Per-database variables, Up: Local variables Per-data-display-buffer variables --------------------------------- Per-data-display-buffer variables permit different data display buffers to have different values for variables. This feature is heavily used by the EDB implementation; for instance, the per-buffer variable `dbc-database' records which database the data display buffer is displaying. Per-data-display-buffer variables are also useful when several data display buffers are all displaying the same database. The built-in Emacs function `make-variable-buffer-local' makes an ordinary variable local to every buffer. `db-default-field-type' The type to use for record fields whose type is not explicitly specified.  File: database.info, Node: Per-database variables, Prev: Per-data-display-buffer variables, Up: Local variables Per-database variables ---------------------- Per-database variables permit every data display buffer viewing a particular database to share information without making it global or interfering with other databases and other data display buffers. When the database is saved in internal EDB file layout, per-database variables are also saved, so their values persist from one invocation of the database to the next. Use the following functions to create and manipulate per-database variables. `database-make-local' Declare a database-local variable named by SYMBOL for DATABASE. Each such variable should only be declared once. If optional argument VALUE is specified, the variable is set to it. Database designers who are very concerned about speed should arrange to call this function in increasing order of frequency of variable reference; that is, add the least-used variables first. `database-local-p' Return non-`nil' if SYMBOL is a database-local variable for DATABASE. `database-set-local' Set the value of database-local variable SYMBOL, in DATABASE, to VALUE. SYMBOL must have been declared by a previous call to `database-make-local' unless optional argument NO-ERROR is supplied, in which case the function does that automatically. `database-get-local' Return the value of database-local variable SYMBOL for DATABASE. sYMBOL must have been declared by a previous call to `database-make-local' unless optional argument NO-ERROR is supplied, in which case `nil' is returned. To learn how to set local variables automatically whenever a record is edited, *Note Edit mode hooks::. (This section of the manual does not refer to the "Local Variables" section of the database format file, which may be used to set variables and execute arbitrary Emacs Lisp code when a data display buffer is being set up; that is described in *Note Reading from disk::.)  File: database.info, Node: Global variables, Prev: Local variables, Up: Customization Global variables ================ This section describes a potpourri of customization variables which you can use to control EDB's behavior. When a potentially slow computation is underway, EDB displays a message in the echo area reporting how many records have been processed. Use the following variable to control how often this message is updated. `db-inform-interval' When doing a lengthy computation, inform the user of progress every this many records. If `nil', don't inform. To make EDB use `with-electric-help' where appropriate instead of `with-output-to-temp-buffer', set the following variables, which default to `nil'. You must have `ehelp.el' on your load path or have already loaded it. `use-electric-help-p' Non-`nil' if Emacs programs should use electric help where possible. Don't set this to a non-`nil' value unless the ehelp package is available. EDB does not simply test for `(featurep 'ehelp)' because some packages load `ehelp' without determining whether the user desires that behavior. Even if that has happened, users of EDB have a way to retain Emacs's traditional behavior. `with-electric-help-maybe' Similar to `with-electric-help' if `use-electric-help-p' is non-`nil'; otherwise like `with-output-to-temp-buffer' with the "*Help*" buffer. Ehelp is loaded if necessary. BODY is not a thunk (a function of no arguments) but simply a set of forms.  File: database.info, Node: Database representation, Next: Naming conventions, Prev: Customization, Up: Top Database representation *********************** Perhaps the most important information about a database--besides the records it contains--is the number of fields in each record, and the type of each field. As explained in *Note Terminology::, a database consists of records with identical numbers of fields; each field has an associated type such as string or integer. Each field also has a name which is used when extracting its value from the record. A database is basically just a doubly-linked circular list, where each link contains a single record. The database contains some additional supporting information, and so does each link in the list of records. The database is represented as a structure of type database whose `first-link' slot points to the circular list of links. Internally, database records are represented by vectors; however, the programmer should never manipulate those vectors directly, only through the functions described in this chapter. Given a record, it is not possible to determine which link (if any) points to it; similarly, you cannot go from a link to its containing database. The database-to-link and link-to-record connections are one-way. * Menu: * The database structure:: The database structure * Mapping over the database:: Mapping over the database * Manipulating records:: Manipulating records  File: database.info, Node: The database structure, Next: Mapping over the database, Up: Database representation The database structure ====================== The internal representation of a database is as a structure of type database. The slots of this structure may be accessed by using the macro `database-'SLOTNAME. The slots may be set using the macro `database-set-'SLOTNAME, whose second argument is the value to be stored in the slot. The slots of the database are as follows: `print-name' A string which briefly describes the database. It appears, among other places, in prompts for questions regarding the database. It defaults to "Unnamed databse N", where the positive integers are assigned to N in order. `first-link' The first link in the database. The links are arranged as a doubly-linked circular list, and each link contains a record, among other information. *Note The link structure::. `no-of-records' An integer, the number of records (and links) in the database. The first link is numbered 1 and the last link is numbered `no-of-records'. `file' A string, the name of the file from which this database was read. `file-local-variables' A string, the text of the "Local Variables" section of the file from which this database was read, if any. `aux-file' A string, the name of this database's auxiliary file. If it is `nil', then a number of default filenames are tried, based on `db-aux-file-suffixes' (*note Auxiliary files::.). `data-display-buffers' A list of data display buffers which are displaying this database. Since every summary buffer is associated with (and subordinate to) a data display buffer, summary buffers are not listed in the database structure. `default-format-file' A string, the name of the default format file for this database. If it is `nil', then a number of default filenames are tried by function `db-file->format-file' (*note Auxiliary files::.). `omit-functions' This does not appear to be used at present. `no-of-fields' An integer, the number of fields in each record. `fieldnames' A vector of symbols, the names of the record fields. Function `fieldnumber->fieldname' (*note Accessing record fields::.) uses this to determine the name of a field, given its index. The user may set this slot to be a list, and EDB will automatically convert it to a vector, as well as setting other database slots that can be determined from it. (When doing so, use `database-set-fieldnames-to-list', which can safely be placed in any format file, instead of `database-set-fieldnames'; for details, see *Note Changing display formats::.) This information is duplicated in the recordfieldspecs. `database-set-fieldnames-to-list' Set DATABASE's fieldnames and record field types according to FIELDNAMES-LIST. Users should never call `database-set-fieldnames' directly. FIELDNAMES-LIST is a list of fieldnames (symbols); each list element may instead be a cons of fieldname and type to specify the field's recordfieldtype as well. If no type is specified for a field, the value of `db-default-field-type' is used. This function sets several database slots besides the fieldnames slot, but has no effect if the fieldnames slot of the database is already set. The following call specifies three fields of types one-line-string, integer, and string, presuming that variable `db-default-field-type' (*note Per-data-display-buffer variables::.) has not been changed from its default of `string': (database-set-fieldnames-to-list database '((name . one-line-string) (age . integer) address)) `fieldname-alist' An alist of fieldnames and indices. Function `fieldname->fieldnumber' (*note Accessing record fields::.) uses this to determine the index of a field, given its name. `recordfieldspecs' A vector of symbols or recordfieldspecs which specify the type of each record field. If the value is a symbol, it is a record field type name which is converted to a recordfieldspec via function `recordfieldtype->recordfieldspec', which performs a lookup in `db-recordfieldtypes'. To access or change a particular recordfieldspec, use the following functions: `database-recordfieldspec' Return the recordfieldspec of DATABASE corresponding to RECORD-INDEX. Dereferences via `recordfieldtype->recordfieldspec' any symbol found in the recordfieldspecs slot of DATABASE. `database-recordfieldspec-type' Return the type of the recordfieldspec of DATABASE corresponding to RECORD-INDEX. `database-set-recordfieldspec' Set the recordfieldspec of DATABASE corresponding to RECORD-INDEX to RS. Use this to redefine, on a per-field basis, subfields of the recordfieldspec. `field-priorities' Determines in which order fields are compared when sorting records, and which fields are ignored entirely. This slot's vlaue is a cons of two lists: the first list contains fields that will be used for sorting, and the second list is the ignored fields. Each list consists of pairs of fieldnumber and order-info. The user may use `nil' for the second list when setting this slot. EDB always maintains the list of ignored fields, however, as its order might be worthwhile--for instance, for reminding the user of what the order used to be. The order-info specifies how the field should be sorted: in increasing order, in decreasing order, or according to an arbitrary function. To choose the default ordering, or its inverse, use the symbol `increasing' or `decreasing'. Otherwise, order-info is a cons of TYPE and VALUE, where TYPE is a symbol (either `order-function' or `sort-function') and VALUE specifies the function. In the sorting section's example (*note Sorting::.), the record fields were foo, bar, baz, bum, and bee, and records were to first be sorted on baz in increasing order, then on foo in decreasing order, and finally on bum in increasing order, ignoring bar and bee entirely for the purposes of the sort. The corresponding field priorities list would be (((2 . increasing) (0 . decreasing) (3 . increasing)) . ((1 . increasing) (4 . increasing))) `omitted-to-end-p' A boolean which determines whether, when sorting, omitted records should be sorted in the usual way or placed at the end of the sorted order. `internal-file-layout-p' A boolean which determines whether the database will be saved in internal file layout. This has no effect when the database is read, but it is set at read time so that, by default, the database will be written out as it was read in. Setting this slot, then saving the database to disk, is a good way to convert the database to or from internal file layout. It can be set in the usual way, or interactively via use of the following function: `M-x db-toggle-internal-file-layout' Toggle whether the database will be saved in EDB's internal file layout. With a nonzero prefix argument, set it to use internal file layout. With a zero prefix argument, set it not to use internal file layout. `record-sepinfo' `field-sepinfo' `alternative-sepinfo' These sepinfos are used when reading databases with regular file layouts. A sepinfo contains a particular string, a regular expression, or a function that specifies how pieces of information are separated in the disk file (for more about the sepinfo struture, *note How to specify regular file layouts::.). These sepinfos describe how to separate records, fields within a record, and alternatives within a field. (The latter is not yet fully implemented.) `read-record-from-region' Nil or a function of no arguments which returns a record read from the current region of the current buffer. For details, *Note Nonregular file layout::. `write-region-from-record' Nil or a function which takes a record as its argument and inserts the file representation of that record in the current buffer. For details, *Note Nonregular file layout::. `sub-fieldsep-string' `sub-recordsep-string' When delimiter substitution is required in reading a database, these strings are temporarily used to delimit fields and records, respectively. (These strings replace the actual field and/or record separators before substitution occurs.) Their values are chosen automatically if these slots aren't set. `quotation-char' A character which is used to quote delimiters which appear in a database field. This character is prepended to ambiguous strings; strings preceded by it are treated verbatim rather than as delimiters. For more about quotation in reading databases, *note Regular file layout::.. `quotation-char-regexp' A regexp used to recognize the quotation character. `quoted-regexp' A regexp which matches all strings that should be quoted. If it is `nil', it is set from the `quoted-strings' slot. `quoted-strings' A list of strings that should be quoted. If it is `nil', then the value returned by function `quoted-strings-default'--basically all the strings mentioned in the database's `record-sepinfo', `field-sepinfo', and `alternative-sepinfo' slots, plus the `quotation-char' slot--is used instead. `actual-quoted-regexp' The regexp that is actually used for finding quoted strings. The user should never set this slot. `substitutions' An alist of actual and stored strings which permits translations from how the data appears in the data file to how it should really look; for instance, in data files with the tab-separated text layout, fields may not contain newlines, so any newlines in the data can be converted to some other character (such as `^K') when the database is written and then converted back when it is read in again. For more about substituion in reading databases, *note Regular file layout::.. `modified-p' Non-`nil' if this database has been modified since it was last read or written. `modifiable-p' Non-`nil' if this database may be modified. It is set to `nil' if the database file is not writable, and occasionally for other reasons. This does not prevent the user from editing edit mode, only from making changes while in edit mode. The slot may be set directly, the following function is bound in view, edit, and summary modes to permit the slot to be changed interactively. `C-x C-q' (`db-toggle-modifiable-p') Toggle whether the database may be modified by the user. With a nonzero prefix argument, set it modifiable. With a zero prefix argument, set it non-modifiable. `locals' An alist of symbols and values for per-database variables. (For the number of local variables I expect each database to have, an alist is faster than a hashtable, and it's easier to save to disk besides.) Such variables should be created with `database-make-local', set using `database-set-local' (note the singular form) and dereferenced with `database-get-local'; for more information about these functions, see *Note Local variables::. * Menu: * The link structure:: The link structure  File: database.info, Node: The link structure, Up: The database structure The link structure ------------------ The records of the database--the information that the user cares most about--are kept in a doubly-linked list, one record per link. The link structure also contains some other information about the record which doesn't belong in the record proper. The slots of a link are listed below; a slot may be accessed by using the macro `link-'SLOTNAME and set using the macro `link-set-'SLOTNAME, whose second argument is the value to be stored in the slot. `prev' The previous link in the circular list. `next' The next link in the circular list. `omittedp' `markedp' These booleans are non-`nil' if this record is marked or omitted, respectively. For more information about marking and omitting, see *Note Marking and omitting::. `summary' A string which is used to represent this record in the summary buffer, or `nil' if the record's value has changed since the last summary buffer was made (or if no summary buffer has been made). `record' The database record proper, a vector with as many elements as the record has fields. Setting this slot with the `link-set-record' function also has the effect of setting the `summary' slot to `nil', which is usually what is desired; to set only the `record' slot, use the `link-set-record-slot' macro instead.  File: database.info, Node: Mapping over the database, Next: Manipulating records, Prev: The database structure, Up: Database representation Mapping over the database ========================= Mapping refers to applying a function to each link or record in the database, or executing a piece of code for each link or record. Four functions provided this capability. The first two, more complicated, ones, provide access to each link of the database in turn. `maplinks' Apply FUNC to every link in DATABASE. If optional third arg OMIT is non-`nil', apply FUNC only to unomitted links. If optional fourth arg MESSAGE is non-`nil', it should be a format string containing one numeric (%d) specifier. That message will be issued every `db-inform-interval' links. If optional fifth arg ACCUMULATE is non-`nil', return a list of the results; otherwise return `nil'. In the body, variable maplinks-index is bound to the index of the link being operated upon, and maplinks-link is the argument to FUNC. The loop may be short-circuited (aborted) by calling `maplinks-break'. To avoid the per-link function call overhead, use `maplinks-macro' instead. `maplinks-macro' Execute BODY for each link in DATABASE, and return `nil'. If optional third arg OMIT is non-`nil', execute BODY only for unomitted links. If optional fourth arg MESSAGE is non-`nil', it should be a format string containing one numeric (%d) specifier. That message will be issued every `db-inform-interval' links. In the body, variable maplinks-link is bound to the link being operated upon, and maplinks-index is bound to its index. The loop may be short-circuited (aborted) by calling `maplinks-break'. Speed demons should call this instead of `maplinks' to avoid a function call overhead per link. `maplinks-break' Cause the maplinks loop to quit after executing the current iteration. This is not a nonlocal exit! It sets a flag which prevents future iterations. Actually, it sets maplinks-link. Two other functions provide a slightly different interface which simplifies access to each record. Links and the information contained in them are not accessible from database records, but when that information is not of interest, these functions provide direct access to records. `maprecords' Apply FUNC to every record in DATABASE. Return `nil'. If optional third arg OMIT is non-`nil', apply FUNC only to unomitted records. If optional fourth arg MESSAGE is non-`nil', it should be a format string containing one numeric (%d) specifier. That message will be issued every `db-inform-interval' records. If optional fifth arg ACCUMULATE is non-`nil', return a list of the results; otherwise return `nil'. This is syntactic sugar for a call to `maplinks', which see. See also `maprecords-macro'. `maprecords-macro' Execute BODY for each record in DATABASE, and return `nil'. If optional third arg OMIT is non-`nil', execute BODY only for unomitted records. If optional fourth arg MESSAGE is non-`nil', it should be a format string containing one numeric (%d) specifier. That message will be issued every `db-inform-interval' links. In the body, variable maprecords-record is bound to the record being operated upon. The loop may be short-circuited (aborted) by calling `maprecords-break'. This is syntactic sugar for a call to `maplinks-macro', which see. See also `maprecords'. `maprecords-break' Cause the maplinks loop to quit after executing the current iteration. This is not a nonlocal exit! It sets a flag which prevents future iterations. Actually, it sets maplinks-link. For instance, to sum, for all records, the values contained in field summand (of type number), you could use any of the following forms, presuming that variable `database' was set to the database in question: (let ((result 0)) (maplinks-macro (setq result (+ result (record-field (link-record maplinks-link) 'summand database))) database) result) (let ((result 0)) (maprecords-macro (setq result (+ result (record-field maprecords-record 'summand database))) database) result) (let ((result 0)) (maprecords (function (lambda (record) (setq result (+ result (record-field record 'summand database))))) database) result) (apply (function +) (maprecords (function (lambda (record) (record-field record 'summand database))) database nil nil t))  File: database.info, Node: Manipulating records, Prev: Mapping over the database, Up: Database representation Manipulating records ==================== A database consists of records, each of which has the same makeup: corresponding fields in a database's records contain data of the same type. For instance, the fifth field of each record might contain an address, and the seventh field, a date. The particular addresses and dates would would vary from record to record. (Different databases will contain records with different numbers and types of fields.) Each field has a name and a type, which specifies what sort of information can be stored in the field; for more details about record field types, see *Note Record field types::. Records are represented internally as vectors, but should never be operated on as such; use the abstractions described in this section. Creating and copying records ---------------------------- `make-record' Return a record with number of fields specified by argument DATABASE. When the user creates a new record by using `db-add-record' (*note Adding and removing records::.), `db-new-record-function' is invoked (*note Display format change hooks::.), the number of records in the database is modified, and so forth. `make-record', on the other hand, performs none of these housekeeping tasks. `copy-record' Return a copy of RECORD. `copy-record-to-record' Copy the field values of the SOURCE record to the TARGET record. * Menu: * Accessing record fields:: Accessing record fields * Mapping over record fields:: Mapping over record fields  File: database.info, Node: Accessing record fields, Next: Mapping over record fields, Up: Manipulating records Accessing record fields ----------------------- Ordinarily, record fields are accessed by specifying the name of the desired field; the database must also be specified so that the fieldname-to-fieldnumber correspondence can be determined. `record-field' Return from RECORD the field with name FIELDNAME. Third argument is DATABASE. `record-set-field' Set, in RECORD, field FIELDNAME to VALUE. Fourth argument DATABASE. Check constraints first unless optional fifth argument NOCHECK is non-`nil'. This version correctly deals with reversed VALUE and DATABASE arguments. There are also special commands for manipulating the current record--that is, the one that appears in the data display buffer. They are better because they require fewer arguments, flag that a redisplay of the record is necessary, and automatically call `dbf-set-this-record-modified-p', which is essential if the changes are to be copied back into the original record in the database from the one that is being displayed. (A copy is always displayed so that changes can be gracefully undone.) `dbf-displayed-record' Return the record currently displayed in this data display buffer. This is `dbf-this-record' if `dbf-this-record-modified-p' is non-`nil' and `dbf-this-record-original' otherwise. `dbf-displayed-record-field' Return the value of the field named FIELDNAME from the displayed record. `dbf-displayed-record-set-field' Set field with name FIELDNAME in displayed record to VALUE. Cause the entire record to be redisplayed pretty soon. `dbf-displayed-record-set-field-and-redisplay' Set field with name FIELDNAME in displayed record to VALUE. Cause the entire record to be redisplayed immediately. `dbf-set-this-record-modified-p' Set the value of `dbf-this-record-modified-p' to ARG. If ARG is non-`nil' and `dbf-this-record-modified-p' is `nil', also do the necessary record-copying and call `dbf-set-this-record-modified-function'. It is also possible--and more efficient--to use the fieldnumbers directly. The database does this internally, remembering fields by their numbers and only converting to fieldnames when interacting with the user. Adopting such a strategy for all field accesses would be cumbersome, error-prone, and make reading code difficult, but in some situations--particularly when `record-field' or `record-set-field' is being called with a constant second argument--it is worthwhile. The code can be sped up by allocating a variable for the fieldnumber, looking it up after the database has been loaded (for instance, by calling `fieldname->fieldnumber' after `database-set-fieldnames-to-list' or in `db-after-read-hooks'), and then using that variable along with `record-field-from-index' or `record-set-field-from-index'. Do not confuse the record fieldnumber, which describes in what order fields happen to occur in the database's internal representation of a record, with the format fieldnumber, which describes in what order fields are displayed in the data display buffer. `fieldname->fieldnumber' Given a FIELDNAME and DATABASE, return a record fieldnumber. Do not be fooled into thinking this is a format fieldnumber. `fieldnumber->fieldname' Given a record FIELDNUMBER and DATABASE, return a record fieldname. The first argument is not a format fieldnumber. `record-field-from-index' Return from RECORD the value of the FIELDNOth field. `record-set-field-from-index' Set, in RECORD, the FIELDNOth field to VALUE. Checks field constraints first if DATABASE is non-`nil'.  File: database.info, Node: Mapping over record fields, Prev: Accessing record fields, Up: Manipulating records Mapping over record fields -------------------------- To perform an action on every field of a record, use the following function or macro. `mapfields' Apply FUNC to each field in RECORD, with variable mapfields-index bound. Third argument is DATABASE. `mapfields-macro' Execute BODY for each field of RECORD, a record of DATABASE, with variables mapfields-field and mapfields-index bound.  File: database.info, Node: Naming conventions, Next: Function Index, Prev: Database representation, Up: Top Naming conventions ****************** * Menu: * Function and variable naming conventions:: Function and variable naming conventions * File naming conventions:: File naming conventions  File: database.info, Node: Function and variable naming conventions, Next: File naming conventions, Up: Naming conventions Function and variable naming conventions ======================================== The names of EDB's functions and variables contain one of the following prefixes: `edb-' These variables contain information about EDB such as the version number, last modification date, or names of the files comprising EDB. They do not relate to general database functionality, only to this particular implementation. `db-' In a variable, indicates that the variable is global and affects all databases. In a function, indicates that the function is user-visible and may be called interactively. It is also used in some situations for internal database functionality which is not connected with any particular buffer. `database-' These functions operate on the (internal representation of) the database structure itself. `dbc-' Indicates a variable local to the data display buffer which refers to the current database (the database being manipulated by that data display buffer), or a non-user-visible function which manipulates such variables. The `c' stands for "current." `dbf-' Indicates a variable local to the data display buffer which controls some aspect of formatting, or a non-user-visible function which manipulates such variables. The `f' stands for "format"; many such variables are intimately related to the format, and the data display buffer used to be called the format buffer. `dbs-' Indicates a variable local to the summary buffer, or a summary buffer function. Since the summary buffer may disappear at any time, the summary buffer gets most of its information from the associated data display buffer's local variables. `dbfs-' Indicates a variable which is too important to be kept only in the summary buffer, which may disappear at any time, but is so often used by the summary buffer that it would be inefficient to keep it only in the data display buffer. Such variables are kept in both the data display and summary buffers. `dbsi-' Indicates a variable local to a sort interface buffer, or a sort interface function.  File: database.info, Node: File naming conventions, Prev: Function and variable naming conventions, Up: Naming conventions File naming conventions ======================= The names of EDB's files contain one of the following suffixes: `.dat' These are database files proper; they contain the information that makes up the fields and records of the database. Database filenames may also contain no extension at all. `.fmt' Format files control the structure of the data display buffer, which displays one record at a time. `.dba' Auxiliary files contain arbitrary Emacs Lisp code; they can be used to define functions, set variables, or operate directly on the database. For more information, see *Note Invoking EDB::.  File: database.info, Node: Function Index, Next: Variable Index, Prev: Naming conventions, Up: Top Function Index ************** * Menu: * right-justify display specification parameter: Display specification optional parameters. * after-find-file-edb: Installation. * byte-compile-database: Compiling EDB. * byte-compile-database: Compiling EDB. * byte-compile-database: Compiling EDB. * byte-compile-database: Installation. * byte-compile-database-all: Compiling EDB. * copy-record: Manipulating records. * copy-record-to-record: Manipulating records. * database-get-local: Per-database variables. * database-local-p: Per-database variables. * database-make-local: Per-database variables. * database-make-local: Per-database variables. * database-make-local: Per-database variables. * database-recordfieldspec: The database structure. * database-recordfieldspec: The database structure. * database-recordfieldspec-type: The database structure. * database-set-fieldnames: The database structure. * database-set-fieldnames-to-list: Creating a new database. * database-set-fieldnames-to-list: The database structure. * database-set-fieldnames-to-list: Specifying a record field type. * database-set-fieldnames-to-list: Tagged file layout. * database-set-local: Per-database variables. * database-set-recordfieldspec: The database structure. * database-sort: The recordfieldspec structure. * database-stored->actual: Load and read hooks. * date->storage-string: Predefined record field types. * date->storage-string-lisp: Predefined record field types. * date->storage-string-mmddyyyy: Predefined record field types. * date-day: Date displaytype. * date-month: Date displaytype. * date-year: Date displaytype. * db-accept-record: Making changes permanent. * db-add-record: Adding and removing records. * db-add-record: Manipulating records. * db-additional-data-display-buffer: Making additional data display buffers. * db-alternate-format: Record display hooks. * db-alternate-format: Record display hooks. * db-alternate-format: Record display hooks. * db-alternate-format: Changing display formats. * db-alternate-format: Changing display formats. * db-alternate-format: Execution of format file eval expressions. * db-commit-record: Making changes permanent. * db-copy-record: Adding and removing records. * db-delete-record: Adding and removing records. * db-emergency-restore-format: Data display buffer. * db-exit: Exiting database mode. * db-exit: Exiting database mode. * db-field-help: The recordfieldspec structure. * db-field-help: Getting help. * db-file->format-file: Auxiliary files. * db-find-file: Invoking EDB. * db-first-field: Moving from field to field. * db-first-field: Changing to edit mode. * db-first-record: Moving around in the database. * db-insert: Compiling EDB. * db-jump-to-record: Moving around in the database. * db-kill-buffers: Exiting database mode. * db-kill-buffers: Exiting database mode. * db-last-field: Changing to edit mode. * db-last-field: Moving from field to field. * db-last-record: Moving around in the database. * db-mark-record: Setting the mark and omit bits. * db-mark-unomitted-records: Setting the mark and omit bits. * db-next-field: Moving from field to field. * db-next-line-or-field: Movement within a field. * db-next-marked-record: Movement among marked and omitted records. * db-next-record: Moving around in the database. * db-next-record: Moving from record to record. * db-next-record-ignore-omitting: Movement among marked and omitted records. * db-next-screen-or-record: Moving around in the database. * db-omit-record: Setting the mark and omit bits. * db-omit-unmarked-records: Setting the mark and omit bits. * db-omitting-set: Details of omitting. * db-omitting-toggle: Details of omitting. * db-output-record-to-db: Adding and removing records. * db-prepare-to-debug: Debugging EDB. * db-previous-field: Moving from field to field. * db-previous-line-or-field: Movement within a field. * db-previous-marked-record: Movement among marked and omitted records. * db-previous-record: Moving from record to record. * db-previous-record: Moving around in the database. * db-previous-record-ignore-omitting: Movement among marked and omitted records. * db-previous-screen-or-record: Moving around in the database. * db-quit: Exiting database mode. * db-quit: Exiting database mode. * db-report: Reports. * db-revert-database: Undoing all changes to a record. * db-revert-field: Undoing changes to a field. * db-revert-record: Undoing all changes to a record. * db-save-database: Invoking EDB. * db-search: Searching. * db-search: Searching. * db-search: Searching. * db-search-field: Searching. * db-search-field: Searching. * db-setup-format: Reading from disk. * db-setup-format-parse-displayspecs: Reading from disk. * db-sort: Sorting. * db-summary: Summary mode. * db-tagged-setup: Tagged file layout. * db-this-buffer: Installation. * db-toggle-internal-file-layout: The database structure. * db-toggle-modifiable-p: The database structure. * db-toggle-show-omitted-records: Details of omitting. * db-unmark-all: Setting the mark and omit bits. * db-unomit-all: Setting the mark and omit bits. * db-view-mode: Exiting edit mode. * db-write-database-file: Invoking EDB. * dbc-set-omit-p: Details of omitting. * dbf-always: Execution of format file eval expressions. * dbf-displayed-record: Accessing record fields. * dbf-displayed-record-field: Accessing record fields. * dbf-displayed-record-set-field: Accessing record fields. * dbf-displayed-record-set-field-and-redisplay: Accessing record fields. * dbf-process-current-record-maybe: Display format change hooks. * dbf-set-change-function: Display format change hooks. * dbf-set-change-function: Display format change hooks. * dbf-set-summary-format: Execution of format file eval expressions. * dbf-set-summary-format: Summary mode. * dbf-set-summary-format: Summary mode. * dbf-set-this-record-modified-p: Accessing record fields. * dbf-set-this-record-modified-p: Display format change hooks. * dbsi-decreasing: Sorting. * dbsi-increasing: Sorting. * dbsi-kill-line: Sorting. * dbsi-ordering-function: Sorting. * dbsi-quit: Sorting. * dbsi-quit-clear-buffer-default: Sorting. * dbsi-sorting-function: Sorting. * dbsi-this-field-only: Sorting. * dbsi-toggle-omitted-to-end: Sorting. * dbsi-use-ordering: Sorting. * dbsi-use-ordering-make-buffer-default: Sorting. * dbsi-use-ordering-make-database-default: Sorting. * dbsi-yank-line: Sorting. * debug-on-error: Debugging EDB. * define-displaytype-from-displayspec: Defining new displaytypes. * define-displaytype-from-optstring: Defining new displaytypes. * define-enum-type: Multi-character enumeration displaytypes. * define-one-char-enum-displaytype: One-character enumeration displaytypes. * define-recordfieldtype-from-recordfieldspec: Specifying a record field type. * define-recordfieldtype-from-recordfieldspec: Specifying a record field type. * define-type-alias: Predefined record field types. * display-record: Execution of format file eval expressions. * display-record: Record display hooks. * display-record: Record display hooks. * display-record: Data display buffer. * displaytype->displayspec: Defining new displaytypes. * edb-update: EDB is in beta test. * equal: The recordfieldspec structure. * fieldname->fieldnumber: The database structure. * fieldname->fieldnumber: Accessing record fields. * fieldnumber->fieldname: Accessing record fields. * fieldnumber->fieldname: The database structure. * find-file: Invoking EDB. * find-file: Installation. * format-date: Predefined displaytypes. * format-date-full: Predefined record field types. * insert: Compiling EDB. * kill-buffer: Exiting database mode. * link-set-record: Compiling EDB. * link-set-record: The link structure. * link-set-record-slot: The link structure. * load-database: Compiling EDB. * load-database: Compiling EDB. * make-date: Date displaytype. * make-displayspec: Defining new displaytypes. * make-n-line-sep-function: Sepinfo examples. * make-record: Nonregular file layout. * make-record: Manipulating records. * mapfields: Mapping over record fields. * mapfields-macro: Mapping over record fields. * maplinks: Mapping over the database. * maplinks: Mapping over the database. * maplinks: Mapping over the database. * maplinks-break: Mapping over the database. * maplinks-break: Mapping over the database. * maplinks-break: Mapping over the database. * maplinks-macro: Mapping over the database. * maplinks-macro: Mapping over the database. * maplinks-macro: Mapping over the database. * maprecords: Mapping over the database. * maprecords: Mapping over the database. * maprecords-break: Mapping over the database. * maprecords-break: Mapping over the database. * maprecords-macro: Mapping over the database. * maprecords-macro: Mapping over the database. * mde-save-some-buffers: Exiting Emacs or saving files. * parse-date-string: Predefined displaytypes. * parse-date-string: Predefined record field types. * quoted-strings-default: The database structure. * record-field: Accessing record fields. * record-field-from-index: Accessing record fields. * record-set-field: Nonregular file layout. * record-set-field: Accessing record fields. * record-set-field-from-index: Accessing record fields. * recordfieldspec-order-function: The recordfieldspec structure. * recordfieldspec-sort-function: The recordfieldspec structure. * recordfieldtype->recordfieldspec: Specifying a record field type. * recordfieldtype->recordfieldspec: The database structure. * recordfieldtype->recordfieldspec: The database structure. * recordfieldtype->recordfieldspec: Specifying a record field type. * recordfieldtype->recordfieldspec: Specifying a record field type. * right-justify: Display specification optional parameters. * save-some-buffers: Database mode. * save-some-buffers: Exiting Emacs or saving files. * simple-format-date: Predefined record field types. * storage-string->date: Predefined record field types. * storage-string->date: Predefined record field types. * storage-string-lisp->date: Predefined record field types. * storage-string-mmddyyyy->date: Predefined record field types. * with-elecric-help: Compiling EDB. * with-electric-help: Global variables. * with-electric-help-maybe: Global variables. * with-output-to-temp-buffer: Global variables. * with-output-to-temp-buffer: Global variables. * x-flush-mouse-queue: Compiling EDB. * x-paste-text: Using the mouse.