- Documentation
- Reference manual
 - Packages
- Constraint Query Language A high level interface to SQL databases
- library(cql/cql): CQL - Constraint Query Language
- Examples
- Simple INSERT
 - Simple INSERT with retrieval of identity of the inserted
 - Simple DELETE
 - Simple SELECT
 - Simple UPDATE
 - WHERE with arithmetic comparison
 - Simple INNER JOIN
 - Arithmetic UPDATE with an INNER JOIN and a WHERE restriction
 - Confirm row does not exist
 - Aggregation - Count
 - Aggregation - Sum
 - Aggregation - Average
 - Maximum Value
 - Minimum Value
 - Aggregation requiring GROUP BY
 - INNER JOIN with an aggregation sub-query where the sub-query is constrained by a shared variable from the main query
 - INNER JOIN in an aggregation sub-query
 - Negation
 - EXISTS
 - Left Outer Join
 - List-based Restrictions
 - Compile time in-list constraint
 - Disjunction resulting in OR in WHERE clause
 - Disjunction resulting in different joins (implemented as a SQL UNION)
 - Disjunction resulting in different SELECT attributes (implemented as separate ODBC queries)
 - ORDER BY
 - DISTINCT
 - SELECT with NOT NULL restriction
 - First N
 - Self JOIN
 - Removing null comparisions
 - Three table JOIN
 - Three table JOIN with NOLOCK locking hint
 - SELECT with LIKE
 - Writing exceptions directly to the database
 - TOP N is Parametric
 - Using compile_time_goal/1
 - ON
 - Expressions In Where Restrictions
 - Explicitly avoid the "No WHERE restriction" message
 - HAVING
 - INSERT and UPDATE value in-line formatting
 - Negations in WHERE Clauses
 - Predicate-generated Attribute Values
 - INSERT from SELECT
 
 
 - Examples
 
 - library(cql/cql): CQL - Constraint Query Language
 
 - Constraint Query Language A high level interface to SQL databases
 
 
1.7.22 Compile time in-list constraint
If your list is bound at compile-time, you can simply use it as the attribute value in CQL, for example:
{[], se_lt_x :: [a-['ELSTON_M', 'LILLEY_N']]}
This does not require the list to be ground, merely bound. For example, this is not precluded:
foo(V1, V2):-
    {[], se_lt_x :: [a-[V1, V2]]}.
If, however, your list is not bound at compile-time, you must wrap the variable in list/1:
Bar = [a,b,c],
{[], se_lt_x :: [bar-list(Bar)]}
If you write
foo(V1):-
    {[], se_lt_x :: [a-V1]}.
and at runtime call foo([value1]), you will get a type 
error.
Remember: If the list of IN values is empty then no restriction is generated i.e.
{[], se_lt_x :: [a-[], b-B}
is the exactly the same as
{[], se_lt_x :: [b-B}