The second major type of query is the Property List. Whereas a page query says, "for all pages that have this property", a property list says, "apply the following pattern for all properties of this type on this page".
All property lists look more or less like this:
{query : pattern}
Looks a lot like the Page Query, right? The only difference is the asterisk substituted for the question mark of a page query. But the meaning is completely different. Whereas a page query returns all of the pages that match the pattern, the property list returns all of the properties that match the pattern on a single page.
The simplest kind of property list is one that operates just on the current page.
For example, let's give this page several ExampleItem properties:
ExampleItem = A big black book
ExampleItem = Deck of cards
ExampleItem = Some pocket lint
We can now add a query that goes through all of these properties and lists them:
{ExampleItem : <b>%%ExampleItem%%</b><br>}
That would get displayed like this:
A big black book
Deck of cards
Some pocket lint
That is, it's simply a list of values of that property. That isn't very interesting, is it? But we can make it a heck of a lot more interesting if those items are references to pages themselves, with their own properties. Say that each ExampleItem is actually the name of a page, and that each of those pages has an ItemName? and ItemDescription? property. Now we can do this:
{ExampleItem : <b>%%ExampleItem.ItemName?%%</b> (<i>%%ExampleItem.PAGENAME%%</i>) -- %%ExampleItem.ItemDescription?%%<br>}
That is, "For each ExampleItem on this page, take the value as a page name, and show the ItemName?, PAGENAME and ItemDescription? properties on that page". That shows up like this:
The Necronomicon (A Big Black Book) -- A large black book of unknown age. You get chills just trying to hold it. There is a big sealed padlock, and no apparent key.
A poker deck (Deck Of Cards) -- A perfectly ordinary-looking deck. Or is it? On closer inspection, you see that several cards have slightly cut corners. Hmm...
[Some Pocket Lint]? ([Some Pocket Lint]?) -- [Some Pocket Lint]?
Neat, huh? I left the Pocket Lint undefined, so that you can see what happens if you use this syntax to refer to a page that isn't there.
You can also do queries aimed at single values rather than multiple ones. If you substitute a "+" for the "*" in the query, it will only fetch one value. The particular power of this alternative is that it will walk up the inheritance tree: if the property is defined by an ancestor of this page, the value will be taken from that ancestor. This can be useful if you want a default value.
This variant is also useful as essentially an "if" statement. For example, this line:
{{?+ExampleItem : <h4>ExampleItems?</h4>}}
renders like this:
{{?+ExampleItem :
because there are ExampleItems? on this page. But if there's weren't any, the line would be omitted entirely. This is often useful for headers to lists.
Rather different from the above are Leaf Queries. This are specifically aimed at the prototype-oriented inherited nature of ProWiki. They allow you to fetch all of the leaves descending from a particular page -- that is, all of the descendants that do not themselves have children.
The syntax of a leaf query looks like this:
{{?~ParentPage? : <b></b> (<i>Property Lists</i>) -- <br>}}
So this says, "for each leaf page that inherits from ParentPage?, show the Name, PAGENAME and Description". Again, this is strictly practical -- it is often useful to get a listing of such leaves, without any intervening parent nodes in the inheritance tree. (A version of this that includes those parent nodes would be easy enough to add, but I haven't needed it yet.)
Next: Display Templates