QUEL statements are always defined by
tuple variables, which can be used to limit queries or return result sets. Consider this example, taken from one of the first original Ingres papers: range of E is EMPLOYEE retrieve into W (COMP = E.Salary / (E.Age - 18)) where E.Name = "Jones" Here is a tuple variable that ranges over the relation, and all tuples in that relation are found which satisfy the qualification . The result of the query is a new relation , which has a single domain that has been calculated for each qualifying tuple. Additional queries can then be made against the relation . An equivalent SQL statement is: create table W as select (E.salary / (E.age - 18)) as COMP from employee as E where E.name = 'Jones' In this example, the relation is being stored in a new table W. This is not a direct analog of the QUEL version; relations in QUEL are more similar to temporary tables seen in most modern SQL implementations. Here is a sample of a simple session that creates a table, inserts a row into it, and then retrieves and modifies the data inside it and finally deletes the row that was added (assuming that name is a unique field). Another feature of QUEL was a built-in system for moving records en-masse into and out of the system. Consider this command: copy student(name=c0, comma=d1, age=c0, comma=d1, sex=c0, comma=d1, address=c0, nl=d1) into "/student.txt" which creates a comma-delimited file of all the records in the student table. The d1 indicates a delimiter, as opposed to a data type. Changing the to a reverses the process. Similar commands are available in many SQL systems, but usually as external tools, as opposed to being internal to the SQL language. This makes them unavailable to
stored procedures. QUEL has an extremely powerful aggregation capability. Aggregates can be nested, and different aggregates can have independent by-lists and/or restriction clauses. For example: retrieve (a=count(y.i by y.d where y.str = "ii*" or y.str = "foo"), b=max(count(y.i by y.d))) This example illustrates one of the arguably less desirable quirks of QUEL, namely that all string comparisons are potentially pattern matches. matches all values starting with . In contrast, SQL uses only for exact matches, while is used when pattern matching is required. ==See also==