A (very) brief description of the query syntax

• A query consists of a regular expression over attribute expressions and must always end with a semicolon ;. The regular expression operators available are concatenation (as usual), disjunction (|), Kleene star (*, matching any number of repetitions, including 0), plus operator (matching 1 or more repetitions), the interval operator

      {n, k}
    

  matches between n and k repetitions. If k is omitted, at least n repetitions are matched. If the interval has the form

      {n}
    

  exactly n repetitions are matched. The examples below will clarify this.
• Each attribute expression is -- roughly speaking -- evaluated against the word (and/or other, additional attributes) at a given corpus position. It has the form

      [Boolean expression]
    

  that is, an attribute expression is a boolean expression surrounded by brackets.
• A boolean expression is a set of attribute value tests, combined with the usual boolean expression operators conjunction (&), disjunction (|) and negation (!). Parentheses may be used in the usual way.
• In this demo version, the two attributes word and pos are defined for the corpus. These two attributes can now be used in attribute-value tests. Here, such a test has the form

      attribute_name operator string
    

  where attribute_name is either word or pos (in this demo version), operator is either the ``match'' operator = or the non-match operator !=, and string is either a ``plain'' string or a (POSIX egrep) regular expression, both enclosed in double quotes.

  In the full version, there are some additional forms of a boolean expression, but these are not available here.

• Very often, you only want to look for a given word, for example you want to retrieve all concordances where a word beginning with confus occurs. The full form of this query would be

      [word="confus.*"];
    

  but if only the word attribute and the match operator = are used, this can be abbreviated to

      "confus.*";
    

• case is significant to the query processor. If you want case-insensitive search, you can append the character sequence %c to a string value:

      "on"%c;
    

  (in a similar way, diacritic-insensitive search is possible)
• Quite often you don't care how a word (between two others) looks like. In this case, the ``match any'' operator [] can be used (similar to the dot in ``standard'' regular expressions):

      "confus.*" []* "by";
    

  This query finds all sequences of a word beginning with confus, followed by an arbitrary number of arbitrary forms ([]*), then followed by the word by. The match-any operator must not be the first expression in a query.
• If you want to control the ``length'' of the match, you can restrict it to at most n words with the within statement. For example, if you are looking for confus and by within a span of 10 words, this can be expressed the following way:

      "confus.*" []* "by" within 10;
    

  The within statement is always the very last statement directly preceding the semicolon, that is, it must not be followed by any more attribute expressions. Alternatively, one could express the last query via the interval operator:

      "confus.*" []{0,8} "by";
    

  Here, at most 8 words may lie between confus and by. Additionally, each structural attribute defined for a corpus may be used to express a search space limit (in this demo corpus, the structural attribute s for ``sentence'' is provided):

      "confus.*" []* "by" within s;
    

  The within s statement requires that the whole match lies within one sentence. The name of the structural attribute may be preceded by a number, in which case the match must lie within that number of sentences.
• SGML-like tags may be used to access boundaries of structural attributes (sentences, for example):

      <s> [pos="NPS"] []* [pos="VB.*"];
    

  Here, a proper noun (singular) must occur at the beginning of a sentence, followed by an arbitrary number of unspecified words, and finally followed by a verb.
• Note that we use regular expressions at two levels in our query system: at the level of attribute expressions and within string values.