INGRES is a relational database management system.There are two distinct strains of INGRES; there is so-called "University" Ingres, which is in the public domain, and there is a commercial version of INGRES developed and marketed by Computer Associates. 

University Ingres is also known as Berkeley Ingres, Ingres89, and
"distributed" Ingres. (The latter term is unfortunate because it is
hard to know whether someone is talking about public domain
"University" Ingres, or the distributed database management
capabilities of OpenIngres. The term "distributed" should probably be avoided.) University Ingres is the original version of Ingres
developed at UC Berkeley during the 1970s to demonstrate the concept of a relational database. It has a plausible claim to being the first implementation of a relational database management system since it pre-dates IBM's System R. This program eventually evolved into the first versions of the commercial product marketed by Relational Technology Inc. (eventually bought by The ASK Group and then by Computer Associates). It has some of the features of the currently available commercial version, but is architecturally different; the DML is QUEL, and the performance and reliability are only fair to
adequate. NB: NONE of this FAQ is related to University Ingres unless
EXPLICITLY noted.

OpenIngres is a commercial product and costs money to buy. It is a
robust, state-of-the-art RDBMS with a reputation for including
first-class development tools. The database server component runs on
all the major Unix derivatives, as well as VMS, Microsoft Windows NT,
and even on Novell Netware as an NLM. The Ingres client components run on all of these too, and also on AXP VMS, Microsoft DOS and Microsoft Windows.

As well as a database engine, the OpenIngres product suite includes a
range of development and enquiry tools and components for implementing distributed databases. The database engine and tools are usually referred to collectively as "Ingres" without distinction.

OpenIngres supports SQL. OpenIngres 1.x is compliant with the ANSI/ISO Entry-Level SQL92 (SQL2) standard and also has some of the Intermediate-Level features. Embedded SQL and embedded Dynamic SQL are also fully supported. (See section 05.003 below for SQL2 references.) OpenIngres also supports QUEL and embedded QUEL, which it inherits from University Ingres. Computer Associates de-emphasizes QUEL for obvious commercial reasons. Because QUEL has considerable technical advantages over SQL, OpenIngres adopted SQL relatively late (c. 1986) and perhaps for this reason there is a lingering misapprehension that OpenIngres still does not support SQL.

Features of OpenIngres

OpenIngres supports the following native data types:

i1 1-byte signed integers
i2 2-byte signed integers
i4 4-byte signed integers
f4 4-byte floating point
f8 8-byte floating point
cN N-byte fixed length PRINTING character strings (1<=N<=2000)
char(N) N-byte fixed length ASCII character strings (1<=N<=2000)
varchar(N) N-byte variable length ASCII strings (1<=N<=2000)
text(N) N-byte variable length ASCII, except NULL (1<=N<=2000)
date 12-byte date and/or time (absolute or interval)
money 8-byte money type (locally defined currency)
byte 1-byte unsigned quantity
decimal N-byte fixed decimal 
long varchar N-byte variable length ASCII strings (1<=N<=2Gb)
long byte N-byte variable length binary data (1<=N<=2Gb)

Columns of the above types may be made nullable, or may be assigned a default value. OpenIngres 1.x allows user definable default values.

table_key 8-byte surrogate key (optionally system maintained)
object_key 16-byte surrogate key (optionally system maintained)

In addition, an optional OpenIngres component, the Object Management Extension, allows the programmer to define abstract data types and operators on those data types and the native data types. The new types and operators can be used in any context without restriction.

OpenIngres allows base tables (and secondary indices) to be organized as:

ISAM
compressed ISAM
hash tables
compressed hash tables
heaps
compressed heaps
sorted heaps
compressed sorted heaps
B-trees
compressed B-trees
Tables may have up to 300 columns, and a row may be up to 2000 bytes.
Tables may have up to 8 million pages of 2kb each (16Gb). The number
of rows that will fit in 8 million pages depends on the row size.
There is no practical limit on the number of tables in a database.
There is no practical limit on the number of databases on a system.
Tables may be reorganized, relocated and re-indexed on-line.
A table may be distributed over multiple OpenIngres locations.
OpenIngres locations can be defined on an unlimited number of physical drives.

OpenIngres uses the native file system of the platform on which it is
running. A "database" is (one or more) directories, and tables
are files within the directory.

OpenIngres supports all the SQL92 operators, and QUEL.

DISTRIBUTED DATABASE CAPABILITIES

OpenIngres applications can connect over a network to remote databases using OpenIngres/Net. That is to say that the application does not necessarily have to be running on the same machine as the database. An application can use OpenIngres/Net to connect to more than one remote database simultaneously  More importantly changes
made to the databases cannot be guaranteed to have referential
integrity. To achieve this, special coding is required, or the
application should use OpenIngres/Star. Using OpenIngres/STAR databases can be distributed over multiple host systems. Using OpenIngres/STAR a table in database `A' CAN be joined with 
a table in database `B'. OpenIngres also provides gateway products that allow OpenIngres to access "foreign" databases. Gateways exist for a number of products such as Rdb, DB2 and IMS. 

OpenIngres can act as an ODBC server.

SECURITY

Using SQL OpenIngres provides the usual per-user security constraints. Users can be selectively permitted to read, update, append and delete, on a table by table basis.

Using the optional OpenIngres/Knowledge Management Extensions it
is also possible to define and manage groups of users and user roles.
Both of these make security management much simpler.

QUEL users can additionally control access by time of day, day of 
the week, terminal used, and the content of the record. These 
extra QUEL constraints ARE NOT IMPOSED ON SQL USERS.

For users with special security needs, there is a secure version 
of OpenIngres called OpenIngres/Enhanced Security.

INTEGRITY

Integrity constraints on the data are imposed at the level of the 
database engine and cannot be subverted, except that integrity 
constraints are not enforced during table load operations using the
`copy' command. Integrity constraints can also be imposed in form 
definitions, but these are imposed only if the user happens to use 
form which includes the constraints 

Declarative referential integrity constraints are supported.

Checkpoints of the database can be done on-line and can be written
to disc or tape.

What platform should I run OpenIngres on?

There is no single good answer to this question, although it pops up
regularly. It depends on dozens, maybe even hundreds of factors.

You have three or four choices: (1) you can run the OpenIngres server
and the OpenIngres applications on a central system in the traditional
mainframe style. (2) You can run the OpenIngres server on a central
database host and have one or more OpenIngres application servers
accessing the database through OpenIngres/NET. (3) You can have the OpenIngres server run on a database host and have the applications run on desktop clients such as PCs or Unix workstations. (4) You can do a mix of all of the above, with X-terminals thrown in to cloud the issue still further.

It is believed that the entire OpenIngres product is presently available 
for at least the following machines/operating systems:

Intel machines running Windows NT
Intel machines running OS/2 (strictly Net) --OpenROAD/W4GL in beta
Bull DPX/20
Convex (** see below)
DEC Alpha OSF/1
DEC VAX BSD
DEC VAX Ultrix
DEC VAX VMS
DG AViiON DG/UX
HP 9000 HP/UX
IBM HACMP/6000
IBM RS/6000 AIX
ICL DRS 6000
ICL VME
MOTOROLA 88000 System V
NCR Series 3000
NCR Series 3600 (massively parallel)
PYRAMID OSx BSD
PYRAMID SYSTEM V
SCO Open Desktop
SCO UNIX
SEQUENT DYNIX/PTX
SIEMENS MX
Sun SPARCsystems Solaris 2.x
Sun SPARCsystems SunOS 4.1.x
TANDEM Integrity Nonstop-UX

In addition, the OpenIngres clients are available for:

386/486 machines running MS-DOS
386/486 machines running MS-Windows
DEC AXP OpenVMS

There is NO server product available for MS-DOS or MS-Windows.

There is NO OpenIngres product available for Silicon Graphics, but this
is under development and should be available by late 97/early 98.

There are OpenIngres/NET network adaptors for at least: 

TCP/IP
DECnet
SNA LU0
SNA LU62
Wollongong TCP/IP
DEC UCX TCP/IP
IBM TCP/IP
KNET TCP/IP

Does Postgres anything to do with INGRES?

Postgres is an experimental relational database management system
developed at UC Berkeley. It is intended to demonstrate how object
oriented data management can be accomplished without discarding the relational model. 

The project is directed by Professor Michael Stonebraker, one of
the originators of Ingres. Postgres is a spiritual descendent of 
University Ingres but is not truly related to INGRES.