Home
IBM Domino Designer Basic User Guide and Reference
Basic product usage information and programming language reference information.
Domino® Query Language
Domino Query Language (DQL) is a facility running in Domino core allowing for a terse shorthand syntax for finding documents according to a wide variety of complexity of terms. It leverages existing design elements without the need to write detailed code to access them.
DQL syntax
DQL can be executed in the LotusScript® or Java™ Query method on the (Notes®) Database object or the domino-db node.js API.

IBM Domino Designer Basic User Guide and Reference
Basic product usage information and programming language reference information.
- Accessibility and keyboard shortcuts
  Accessibility features assist users who have a disability, such as restricted mobility or limited vision, to use information technology content successfully.
- Application Design
  Welcome to the Application Design section of Domino® Designer Help.
- Application Management
  Welcome to the Application Management section of Domino® Designer Help.
- Domino® Query Language
  Domino Query Language (DQL) is a facility running in Domino core allowing for a terse shorthand syntax for finding documents according to a wide variety of complexity of terms. It leverages existing design elements without the need to write detailed code to access them.
  - Getting started
    DQL processing uses extracted, optimized design data to make intelligent choices about query plans and to work with some of its syntactic elements like view names. To do that, you first need to create and keep up to date that data in a catalog kept in your data directory, named GQFdsgn.cat.
  - DQL syntax
    DQL can be executed in the LotusScript® or Java™ Query method on the (Notes®) Database object or the domino-db node.js API.
  - Examples of simple queries
    Here are some examples of simple queries.
  - Value data types
    Domino® features a typeless data model where any type of data can be stored in any field. In a DQL query, the type of data searched for is defined by the type of data specified in the query term:
  - Booleans
    Here are some examples that couple simple queries with Boolean processing.
  - Precedence
    DQL has a natural precedence (order of processing) where ANDed terms are processed before ORed terms.
  - in all
    The all keyword modifies the inclusive in operator to exclude all but a specified list of values.
  - Text string values
    Text string evaluation is case insensitive and accent insensitive. Use a single quote (') to forces DQL processing to interpret arguments as text rather than date/times or numerals.
  - Date and time values
    DQL supports the RFC3339 standard format for date-time strings.
  - Substitution variables
    Since it is useful to run DQL queries that vary only by the values in any given term, it is tempting to build them using string construction. But building DQL queries using string construction can be a security weakness. DQL supports substitution variables in its syntax so a query can remain unchanged but differing values can be supplied.
  - View column requirements
    DQL processing requires primary collated columns for view access that must meet specific requirements.
  - Scanning limits
    Though the DQL processing engine takes measures to avoid dominating system resources, it is still possible to write and execute a runaway query. To prevent that, three limit settings are provided.
  - Performance and resource use
    DQL processing consumes memory, disk, and CPU resources. To preserve those resources and to speed up query processing, optimize your queries as much as possible.
  - Design catalog
    For high speed access to internal information about views and view columns, DQL processing uses design data extracted from view notes. In this release, this information is stored in a new database, GQFdsgn.cat.
  - DomQuery utility
    The DomQuery command line utility is shipped with the Domino® server and is used to compose and tune queries. Running it with the explain(-e) flag is instrumental in understanding and optimizing DQL syntax and how queries are processed.
  - explain
    The best way to understand how DQL syntax will be processed is by using the explain facility. Explain is available as a method in the DominoQuery class (Java) and NotesDominoQuery class (LotusScript) and with the DomQuery utility using the explain (-e) flag.
- Composite Applications - Design and Management
  Composite applications are a key element in a service-oriented architecture (SOA) and contextual collaboration strategy. The ability to create and edit composite applications lets you easily integrate different types of components and technologies.
- DB2® Access views
  Domino® Designer includes two types of design elements to assist you in managing data contained in DB2® enabled Notes® databases:
- Programming Overview and User Interface
  This section contains general guidelines and examples that show where to use Java, LotusScript, and the formula language.
- Formula Language
  This section documents the formula language.
- LotusScript® Language
  Welcome to the LotusScript® Language section of Domino® Designer Help.
- LotusScript/COM/OLE Classes
- Java/CORBA Classes
  This section documents the Java/CORBA classes.
- Lotus® Connectors
  Lotus® Connectors provide native access to a wide variety of DBMS products, ODBC, the platform File system, Enterprise Resource Planning systems, and Transaction Processing systems.
- Javadoc™ for Domino® Designer related APIs
  As part of providing additional Java™ reference documentation, Domino® Designer ships with a help plugin that contains Javadoc™ for additional Domino Designer related APIs.

DQL syntax

DQL can be executed in the LotusScript® or Java™ Query method on the (Notes®) Database object or the domino-db node.js API.

Using [ and ] to denote option tokens, the syntax of DQL is:

Term [Boolean Term [ Boolean Term ...]]

where the syntax for Term and Boolean is described in the following table.

Note: Spaces are required between Identifiers, Operators, and Values.

Table 1. DQL Term and Boolean syntax
Element	Element	Element	Value
`Term`
	`[Identifier]`
		`SummaryField \| ‘View or folder name’.Columnname \| @function`
			`SummaryField` is the name of any field stored in the summary portion of any document in a Domino® database.
			`View or folder name` is the name, or an alias, of any view or folder created in a Domino® database.
			`Columnname` is the programmatic name of any primary sorted column in the view or folder specified in `View or folder name`.
			`@function` is @all \| @ModifiedInThisFile \|@DocumentUniqueID \| @Created
	`Operator`		= \| > \| >= \| < \| <= \| in [all]
	`[Value]`	`Quoted string value` ’ \| @dt(‘ `datetime value` ’) \| `number` \| ( `in value list` )
			`Quoted string value` is any textual value desired to be found in a field or view column specified
			`datetime value` is an ISO8601-compliant value specified in GMT or Zulu time
			`number` is a floating point number, with or without decimal point, including scientific notation
			`in value list` is ‘ `value 1’` [ `,’value2’ ...` ]
`Boolean`			and \| or \| and not \| or not

With many different functions and operators in DQL, it is possible to get the same results in many ways. Understanding DQL’s Performance and resource use will help you to optimize your searches; use DQL’s explain facility via the DomQuery utility (or by the DominoQuery.explain() method in the Java and LotusScript classes) to practice this.