Using this module enables data to be accessed which is defined in XML files.
The functions of the xmlquery module support
the xmlquery query language of the same name for easy editing of XML files.
Before executing an xmlquery statement, all
tags of the current statement environment
and all Function Variables are replaced with their current values.
Important note: xmlquery requires a fully defined XML structure to evaluate where conditions.
Missing elements and attributes can be defined with dummy definitions in the xentities.
and and or in where clauses with the usual precedence and before or,
A || B && C therefore has the meaning A || (B && C)
With the help of xmlquery you can test xmlquery statements.
The names of the elements and attributes of the XML file are used as identifiers for the data columns.
So for the names the following rules apply:
Names must begin with a letter or underscore (_). Unicode letters like ä, ö, ü, א (U+05D0), ... are allowed.
Names may not start with xml. Also all other notations like XML or Xml are forbidden.
Names may consist of the following characters:
Letters All letters. Unicode letters like ä, ö, ü, א (U+05D0), ... are allowed.
Digits 0-9
Word Delimiters
Minus (-)
ARMENIAN HYPHEN (֊ U+058A)
MONGOLIAN TODO SOFT HYPHEN (᠆ U+1806)
KATAKANA-HIRAGANA DOUBLE HYPHEN (゠ U+00A0)
SMALL HYPHEN-MINUS (﹣ U+FE63)
FULLWIDTH HYPHEN-MINUS (－ U+FF0D)
DOUBLE OBLIQUE HYPHEN (⸗ U+2E17)
HYPHEN WITH DIAERESIS (⸚ U+2E1A)
CANADIAN SYLLABICS HYPHEN (᐀ U+1400)
DOUBLE HYPHEN (⹀ U+2E40)
There are some more word delimiters, but these characters are already rejected by the XML parser (at least on the Mac).
More characters
Underscore (_)
Dot (.)
Colon (:)
Names are case-sensitive. Name and name thus denote two different elements.
If the names contain characters other than letters, numbers, underscore (_) or colon (:), the column names must be enclosed individually in Accent Graves (e.g. `namespace.name`).
Then the following statement can be used to determine all addresses whose office adresses begin with A. Please note
that the attribute tür does not need (but of course may have) any quotation marks.
select `pp.büro`, `pp.büro`.tür
node `pp.adrässe⸗1`.`pp.förma`
where `pp.büro` like 'A%'
Element paths are composed from the element names downwards separated by periods (.). (One of the reasons for the `` quotation marks when a name contains dots).
Reference to the ID of a subobject
productdata.object.sub.id
Since v4.2 R32300 With the element name child_N (with N = {0, 1, ...}) you can access the
(0-based) nth subelement of an element. The name of the subelement itself is ignored. Please note
that attributes are counted like elements!
Reference to the ID of the fourth subobject
productdata.child_3.id
In the example row.child_0 points to row.num and row.child_3.name has the content 'B'.
Higher-level elements can be accessed by .. (tow dots). Three dots denotes two levels above and so on.
The multiple dots are allowed only at the beginning of a column name.}
Access to the object above sub
..sub
In where conditions the . (dot) is replaced by the elements own content.
With the following statement the displayname of a certain keyattribute can be queried.
For A_FURNITURE_TYPE of the stylepromotion with the ID 228056984 thus "furniture type".
Normally, a distinction between attributes and elements is not necessary.
Only if there are attributes with the same name as direct subelements,
a distinction must be made. In thius case, the attribute name is prefixed with
@ (like attribute). Elements are marked with $.
span[Deutlich]{If the marking is missing, the attributes are used.}
Distinguish between different ids of an object.
@id
$id
CDATA blocks in the XML files are taken into account and restored when writing the files.
If an element value is to be defined using CDATA, the methods xmlquery::send_cdata_begin
and send_cdata_end or xmlquery::input with the type definition kCDATA can be used.
span[Deutlich]{Inside CDATA blocks the string ![[[CDATA[ must not be used.}
Statements start with the (optional) definition of the Function Variables.
After that, the XML file on which the statement is to be executed is mandatorily expected.
Then the actual statement follows:
A full path to the XML file is expected as file definition.
The path may start with a defined Alias.
In XML offline data connections, incomplete paths are also resolved relative to the current XML data folder.
Selects start with one of the (equivalent) keywords select or xmlget.
Then a comma-separated list of result columns follows.
Optionally, the results can be restricted with a prefixed distinct definition.
After the results, you specify the XML path you want to search in.
This path always starts at the root element of the given XML file.
With an orderby-definition the results can be sorted to the final order.
With the help of the keyword distinct the results of a select
can be reduced to unique results. To do this, add a distinct definition
before the results list:
distinct : The results are different in at least one column
distinct(colName [, colname]) : Since v4.2 R32300 The results are unique in the combination of the specified element paths.
Column names not included in the result list are ignored.
As results of a select you specify a comma-separated list of Element Paths
and constant values (numbers and strings). The single results can additionally be
processed by functionsor with simple calculations:
Element Paths in result columns must always start at the last element
reached by node-selectors.
Parent nodes can be reached with the dot notation.
Element Paths and constants (integers, decimal numbers and strings) are allowed
as values. Element paths start at the last element reached by the node-selectors.
Parent nodes can be reached by the dot notation .
In decimal numbers, dot (.) and comma (,) are accepted as decimal separators.
Simple calculations can be done in the return columns.
The formulas may contain Element Paths whose current values are inserted before each calculation.
The following operators are allowed :
Parentheses are not provided so far. To be able to distinguish between signs and operators,
a space must be placed between + or - and the following value .
The processing of the formulas is done strictly from left to right, all operators have the same precedence.
If possible, results are represented as integers. Here are some examples:
1 + 2 * 3 = 9 // but not 7
1.1 + 1.8 = 2.900000 // but 1.1+1.9 = 3 (without decimal places)
2 * id || name = "24Name" // with id=12 and name="Name"
2 * id || name + 3.1 = 27.1 // with id=12 and name="Name", name is not convertible to a number, so it is 0
The following functions are available for calculating strings:
lower (str) : Conversion to lowercase
upper (str) : Conversion to uppercase
trim (str) : Remove whitespace around the string
reverse (str) : Reverse the string
substr (str, from, len) : Substring from (0-based) from of length len
rsubstr (str, from, len) : Like substr, but starting from the str#6#69;ngs end
token (str, n, delim_str) : n-th token of the string delimited by the first character of delim.
Only ASCII characters are allowed as separators! Other characters may cause the program to crash!
ab v4.1 R20224 folder (str)
ab v4.1 R20224 file (str)
ab v4.1 R20224 filename (str)
ab v4.1 R20224 shortfilename (str)
ab v4.1 R20224 extender (str)
Again, only simple calls are allowed. In particular, the parameters of the functions must not contain any further calculations.
If an element or attribute of your XML file has one of the function names given above,
this name must be enclosed in Accent Graves (`..`) in the call.
E.g, instead of select filename node ... call select `filename` node ... .
node-Selectors determine the XML elements in which the statement should search.
They each consist of an Element Path and a where condition.
The evaluation always starts at the root element of the XML structure and
the node selectors must describe a continuous and existing element path .
So the first selector always starts at the root element of the XML structure.
Further node selectors can continue the element path.
The result columns start at the last element of the node selectors.
With the following statement the displayname of a certain keyattribute can be queried.
For A_FURNITURE_TYPE of the stylepromotion with the ID 228056984 thus "furniture type".
Important note: xmlquery requires a fully defined XML structure to evaluate where conditions.
Missing elements and attributes can be defined with dummy definitions in the xentities.
Conditions can be used to restrict the set of elements at the level of each node selector.
Conditions can be parenthesized and combined with and and or.
On the left side of the comparisons functions are allowed:
and and or are interpreted in the usual precedence and before or,
A || B && C therfore means A || (B && C)
The result of a condition is determined by the respective comparison operator. The following applies:
Identifiers ending in id or sequencenr (case insensitive)
or starting with id and have a number in the third position (such as id2 or id2Xid3)
expecting integers as comparison values.
The configuration file xentities.xml can be used to specify the data type of elements,
see here for more information.
At the end of the command, you can define a sorting
by adding the keyword orderby followed
by a comma-separated list of elementpaths
and a (optional) sort order. If no sort order is given, the
results are sorted ascending.
Only element paths which also appear in the result columns are allowed.
Up to 10 sort fields may be specified:
Sorting is done according to the following criteria:
Columns with the (case insensitive) names "Date" or "Datum" are sorted as date/time
According to the data type of the column specified in the type definitions.
Columns with the (case insensitive) names "Id" or "Sequencenr" are sorted as integers
Alphabetical sorting. Leading integers or commas are compared as numerical values. The decimal separator
is expected as decimal separator. The texts
00100
0020b
20a
thus get the order
20a
0020b
00100
Since v3.4 R5130 The criteria how columns should be sorted can be overridden with the following specifications:
asc_int, desc_int Compare values as integers.
asc_float, desc_float Compare values as decimal numbers. Both point and comma are allowed as decimal separators.
asc_string, desc_string Compare values alphabetically. Upper and lower case are distinguished.
asc_ustring, desc_ustring Compare values alphabetically. Upper and lower case are not important.
asc_datetime, desc_datetime Compare values as date/time
The example shows a simple select command that outputs the names and subIDs
of all the product data whose subID is 1002.
select
name,
sub.id
node productdata.object
where id > 0 and sub.id = 1002;
The command corresponds to the syntax of the command \ with the difference that behind each result column there is
a new value separated by '='. Only direct assignments are permitted for values. Assignments of the type id = id+1 are not implemented.
Changes must be confirmed using commit.
The example shows a simple update command in respect of the name and subID of all Elements
which are to be changed with the sub ID 1002.
update
name="Hallo Hallo",
sub.id=33333
node productdata.object
where id > 0 and sub.id = 1002;
The command corresponds to the syntax of the command xmlget with the difference that behind each result column there is
a new value separated by '='. For each Element found a copy will be created, and inserted into the existing structure.
If precisely one data set is to be inserted, the where condition can be set so that precisely one data set can be selected, so for example
where id = 0.
If the copy is inserted, the defined columns will be filled with the values of the insert.
New Elements can only be inserted in files which have at least one Element of the required structure.
Changes must be confirmed using commit.
In the example a copy is made of all product data which contains sub-products with the id 1002,
inserts a copy into the existing product data and changes the name and sub IDs of the new product data.
insert
name="Hallo Hallo",
sub.id=33333
node productdata.object
where id > 0 and sub.id = 1002;
The command corresponds to the syntax of the command xmlget with the difference that no result columns are
defined..
Changes must be confirmed using commit.
Delete all product data whicn contains sub-products with the id 1002.
delete
node productdata.object
where id > 0 and sub.id = 1002;
With commit all changes will be written back in the XML file. After commit changes can no longer
be undone.
The following definitions may have specifications for files in which they are to apply.
The following is valid for all file specifications in optimizations:
If empty, the definition applies to all files.
Incomplete paths are resolved relative to the XML folder.
ALIAS names of files at the beginning of the path are allowed.
Paths may be given as regular expressions.
(Attention: Regular expressions are different from the wildcards, which are used in
path specifications of console instructions! Fofr instance, abc*.xml would be a wrong specification,
the correct syntax in this case would be abc[^\.]*.xml.)
By creating an index, the processing of xmlqueries can be accelerated up to 20 times. The definition of an index
is useful and supported for the following cases:
Several xmlqueries are applied to the XML file.
The XML file contains a sortable element. The element can contain string or numeric values,
but if one element contains a string/a number, all Elements must contain a string resp. number.
The where clause of the xmlqueries must contain a condition that checks the indexed Elements for equality.
The condition must not be linked with an or.
The condition must not be inside of an or.
In the following three examples of where conditions, no index can be applied to name:
name like "ABC%" : No examination for equality
name = "ABC" or name = "DEF" : Two conditions are linked by ortitel like "A%" or (name = "ABC" and untertitel = "DEF") : Condition is part of an or
Indexes are defined in the file xindex.xml in the XML data folder and have the following format:
<indicees>
<index>
<file></file...>
<nodepath>...</nodepath>
<unique>no</unique> <!-- yes | no -->
<enabled>yes</enabled> <!-- yes | no -->
</index>
</indicees>
The file path file defines the file in which the index is to be applied.
In nodepath the full XML path of the attribute to be indexed is specified. Path separator is the dot (.).
The attribute unique defines whether an index contains unique values (yes) or not (no).
For unique indexes we can use the first found object. For non-unique indexes, all Elements of the same content are included in the selection.
With enabled the index can be disabled. Allowed are the values yes and no.
Each of the definitions are optional. Here the basics structure of the file:
<?xml version="1.0"?>
<entities></entities>
Text can contain formatting instructions which are defined in HTML or InDesign® tagged text, for example <B>my text</B>.
The XML parser will interpret this text as sub-nodes of the current nodes and give it the content My text. In order to prevent such
misinterpretations content can be replaced prior to the reading of the file. The replacements can be restricted to the individual files.
When defining the preparatory replacements, ensure that no valid XML tags of the file are replaced. Or, even better, when defining the
XML-DTD refrain from using Element names which are used in HTML or InDesign® tagged text (such as <H1>, <TABLE> oder <P>)
Replace defined text parts with others, e.g. replacing HTML-typical line delimiters (<BR>) with
InDesign® line delimiters. The replacements are implemented directly upon iport of the XML files.
The definition of the replacements can be limited to individual files. For the file paths, the alias names defined
in the panel Settings can be used.
The following keywords will be automatically replaced by their current values in the replacement string replace :
$PATH Path of the current XML file
$NAME Name of the current XML file
$LINE Current line of the XML file
The following example describes the definition which is required to replace all occurrences of AAAA.
To get the names of the currently used XML files in the data file listed in MYFILE, the following
definition can be used. Each AAAA in the data file can be replaced by the current data name.
These replacements are only implemented after the text of an XML Elements in an InDesign® document has been implemented.
They only apply to precisely defined placeholders. The background to these replacements is that, for example, the HTML specification
<B> requires various replacements in connection with the target position in the InDesign® document. The definitions can
be deactivated.
The following example describes the definitions required to translate a <B> in the placeholder 1 into a
certain script style. Two definitions are required, for start and end tag.
Be aware that while you may indeed specify <b> as the value, this opened tag will be automatically replaced. But the
closing tag (</b>) must be specified in XML-compatible syntax. Be ware, furthermore, that
the definition of the script type (hier <cFont:Verdana>) may be specified as open tag in this script type, but not
<cFont:Verdana Bold>, because Verdana Bold is not aq valid XML Element name because of the space.
When defining the file xentities.xml you should refrain from using the simple <>-script type and always use the parenthesis
in the script style <>.
The data type of Elements will be required for comparison and
sorting. In the standard case, all Elements (case insensitive) which begin with id or sequence #,
or which end with these terms, will be considered to be numbers, all other Elements are strings. With typedef Elements in the entity file
this definitions can be changed. For the data path, the alias names defined in panel Settings
can be used. Tha following values supported for type type
Integers : int, integer
Decimal numbers : float, real, double,
Text : string, text
Identifiers which end with ID, are automatically read as numbers. In the following example it is shown
that ProductID of the file products.xml should be processed as a character chain.
When importing the XML files, so-called dummy nodes can be created. The values
of these nodes can be accessed in the standard method as if they were defined in XML files.
You specify the file, for which
a definition is valid together with the parent node of the dummy. For the file path, the alias name defined in panel Settings
can be used. No text Elements may be used for the parent node.
The dummy will be defined with a name and a value. For values, the following specifications are required :
lineno Line number in the XML file
nodecounter Current node counter
dummycounter Current dummy node counter
tick Time as number (may be negative)
now Time in the format dd.mm.yyyy hh:mm:ss
Description
Example
@any text
Use the text after the @.
@missing attribute
missing attribute
[#]attributeName {attributeName}
Use the hash code of the content of attributeName. The attribute must be a direct sibling of the dummy. Versions prior
v3.3 R2711 are always using the hash value of the content.
since v3.3 R2712, 16. Nov. 2011 With a trailing # you will get the direct content instead of its hash code.
since v3.3 R2712, 16. Nov. 2011 You may give a list of any number of attribute names here. The names must be delimited by one blank.
The value of the first existing attribute is used as content of the dummy.
#author image price
Prior to inserting the nodes, a check is made if a node with the desired name is already in existence. In this
case no dummy will be created. Dummy definitions can furthermore defined whether with commit you should
write in the XML file or not.
A user-defined number of dummies may be created for a parnent node.
Dummy nodes of the type lineno are suitable for ensuring the sorting sequence of the data sets in accordance
their sequence in the XML file.
The following example creates the two sub-Elements myid and myid2 when importing the file
products.xml in the Element products.product.grid. The first Element contains the current line number of
the XML file, the second the number of the dummy node. The first node will be assumed upon commit in the file products.xml.
The third definition creates an Element for each product node, the contents of which is arranged as far as possible on a one-to-one basis to a positive number.
Placeholder objects are always supplemented with a so-called classID(integer).
This number controls, among other things, if the menu commands in a panel are activated for loading and storing. So, for example, the
command update the products of the text selectionl is only then active if a placeholder is actually selected with a product in the document.
It may also be the case the placeholders are supplemented with their own class IDs. In this case it is preferable to be also be able to process these placeholders
by means of a defined panel. The classification can be arranged using <classmap>. The definitions are evaluated in
the following cases :
Load placeholder
Store placeholder
Check placeholder
Build repeating Elements
In the following example, it is defined that all placeholders of the classes 4 and 400 can also be processed using the
panel Product Pool (classID 3).
Each xmlquery is trailed by the path of the XML file to work on.
Get the ids and names of all domains.
"domain.xml"
xmlget id, name node domains.domain where id < 0
Paths may begin with the standard prefixes$HOME, $DESKTOP, $DOCUMENTS, ... .
Incomplete paths are always calculated relatively to the current data folder.
Using the panel Settings further aliases can be defined.
The aliases are defined in the file datafiles.xml.
Incomplete aliasses are always calculated relatively to the current data folder. To ascertain the current assignments, the functions
file::enable_datafile, file::setdatafile and file::getdatafile may be used.
Here is an example of a valid file. The alias MYFILE is defined four times. One entry is active. The first two definitions point to two
files in the current XML data folder, the last to a file of the Desktop.
Use panel Settings for changes on alias names used in xml queries.
Since v4.1.5 R24666
Plugnis and comet_pdf support XPATH 1.0 for reading data from XML files.
This software is based on pugixml library (http://pugixml.org). pugixml is Copyright (C) 2006-2018 Arseny Kapoulkine.
The integration of XPATH into the priint:comet software was done in the hope,
to make your work easier. Please understand that the implementation
may not not contain all features and functions of XPATH.
For solving extremely special queries please use the functions of the module xmlnode.
The following functions are available in XPATH queries. Descriptions of these functions
can be found in the relevant XPATH documentation, here's the link to mozilla.
To obtain data records with several result columns, results can be combined with |.
Each partial expression results in its own result column.
The output takes place in the same order as in the statement.
Incomplete records are skipped.
Please note : All Elements of a result row must have exactly the same parent node in the XML data!
Results from Elements of different parents must be obtained in multiple queries.
(And if you want to collect the results of these different lists in result tuples, you also will find out why you have
to make this restriction if you want to allow incomplete and unsorted Elements at the same time.)
... then you will get the following results. The first data record is output in a different order than in the XML, because the order of the statement is observed.
The second data record is skipped because it is incomplete.
1, A
3, C
The definition of XPATH obviously does not provide 'columns' with fixed values - the parts of a | statement
must all be Elements of the XML structure. We have therefore included a small extension in our implementation: With the
statement
static-value "string"
you may insert columns with fixed values in the results rows. If the static string contains a number,
this value can (but does not have to) be retrieved as a number. You can use any number of static
columns, but the statement must contain at least one variable column.
Add an additional second column with the fixed value 2024 to the above example:
/a/b/c | static-value "2024" | /a/b/d
This will give you the following results:
1, 2024, A
3, 2024, C
static XMLTree open( char* path, int autoCommit = 0, int useTreeBuffer = 1, int autoUpload = 0, int isLocal = 0, int parseImmediate = 0)
Open an file based XML tree.
span[Deutlich]{The created tree must be closed again using close!}.
Complete path to the XML file. Aliasnames are allowed at the beginning of the path.
Under XML Offline, SOAP- or AEM®, you can open configration XMLs like panelstatements.xml
or actions.xml here too.
autoCommit
int
0
Save changes automatically when the tree is closed?
Please note that configuration data are available elsewhere
in the plug-ins and changes to these data can lead to program errors!
XML data read from a SOAP or AEM® connection do not have local files and
autoCommit on these trees therefore has no effect.
Use the parameter autoUpload for these trees.
useTreeBuffer
int
1
The reading of XML files is a quite time-intensive process.
Therefore read files can be buffered. Buffered XML data are released on logout time.
autoUpload
int
0
Upload XML while closing the tree.
The parameter only has an effect on XMLs loaded from a SOAP or AEM® connection!
isLocal
int
0
In SOAP and AEM® connections, XML files are automatically loaded from the data source.
To load local files, set the parameter to 1. The file path path must be a complete path in this case!
parseImmediate
int
0
Parse tree immediately? Normally the tree is read in only when needed, because now it is not yet clear,
whether xmlquery or XPATH should be used as query language and both methods require different internal representations of the tree.
Load the content of a placeholder from the current data file $DATAFILE.
If the requested product is not found, a conditional text with an error description is inserted into the document.
#include "internal/types.h"
#include "internal/text.h"
int main ()
{
XMLTree tree = 0;
char name [5000];
int found = 0; strcpy (name, "");
tree = xmlquery::open("$DATAFILE"); xmlquery::send(tree, "select name node posters.poster where ID = ?");
xmlquery::input(tree, kInt, gRecordID);
xmlquery::output(tree, kString, name); xmlquery::exec(tree);
while (xmlquery::fetch (tree)) found = 1; xmlquery::close(tree);
if (!found)
{
strcpy (name, "%!TT<DefineCondition:ERRORCODE=<ConditionColor:1,0,0>");
strcat (name, "<ConditionIndicatorMethod:Highlight><ConditionVisibility:0>>");
strcat (name, "<cConditionalText:ERRORCODE>Product not found!<cConditionalText:>");
} textmodel::replace (name);
return 0;
}
Write the content of a placeholder HTML-formatted back to an XML file.
Version 1.1.7, Januar 2005 autoCommit and useTreeBuffer since Version 1.1.9, 1 April 2004 autoUpload sinse v4.1 R22423, 30. Apr 2018 isLocal since v4.1.7 R26842, 22. Apr 2020 parseImmediate since v4.2 R31950, 30. Nov 2022
Closing an XML tree. The command must be made in respect of every
XML tree created with xmlquery::open or xmlquery::parse.. If the tree was opened with autocommit, the tree is written to the file before closing.
Tree of XML file opened with xmlquery::open or xmlquery::parse.
doFlush
int
0
Remove all Comet-internal data of the xml tree?
0 : no
1 : yes. Reparse the tree on next call to open.
Flush is only done for xml files opened with useTreeBuffer set to 1.
All XMLTrees of the file must be closed at flush-time. Flushing Comet standard files actions.xml, panelstatements.xml, ...
is not allowed.
Since
Version 1.1.7, January 2005 doFlush seit v3.2.1 R2345, 9. März 2011
Send an XML instruction to ascertain values of an XML tree. Subsequent
calls of xmlquery::send, xmlquery::isend and xmlquery::fsend supplement the XML instruction.
The instruction is cleared after xmlquery::exec.
Open a CDATA block inside a xmlquery. The statement has the same effect as xmlquery::send ("<![CDATA["). You can use
this call inside values that are defined as to be CDATAs too. You have to close an open CDATA block by calling
send_cdata_end
Do not use the string ![[[CDATA[ inside a CDATA block.
Name
Type
Default
Description
tree
XMLTree
-
Representation of an XML file created with xmlquery::open.
Close a CDATA block inside a xmlquery. The statement has the saqme effect as xmlquery::send (]]>"). You can use
this call inside values that are defined as to be CDATAs too.
Name
Type
Default
Description
tree
XMLTree
-
Representation of an XML file created with xmlquery::open.
Send an integer to an XML instruction. The command has a similar effect as xmlquery::send with the
difference that the number is appended to the instruction as text.
Name
Type
Default
Description
tree
XMLTree
-
Representation of an XML file created with xmlquery::open.
i
int
-
Integer which is to be appended to the XML instruction.
Send a decimal number to an XML instruction. he command has a similar effect as xmlquery::send with the
difference that the decimal number is appended to the instruction as text. The precision of floats is limited to 6 numbers.
Name
Type
Default
Description
tree
XMLTree
-
Representation of an XML file created with xmlquery::open.
f
float
-
Decimal number which is to be appended to the XML instruction.
static int input( XMLTree qu, int type, char* value)
Connect a value to the corresponding value placeholder in the SQL command.
The value is inserted in the command directly. Variables are not buffered until execution.
The specification of the second parameter is mandatory and must match the data type
of the associated attribute.
Name
Type
Default
Description
Return
int
1 = Okay
0 = Error
tree
XMLTree
-
A tree opened with xmlquery::open.
type
int
-
Type of value. The data type, which belongs to a
variable placeholder, is derived from the respective instruction.
It is the task of the script programmer to connect
the value types. kInt kFloatThe precision of floats is limited to 6 numbers. kString kCDATA
value
depends
-
This value will be sent to the database in place of the associated variable placeholder (?).
Non matching pairs can cause InDesign crashes or invalid data on your data base.
kInt: int, short, long (z.B -1, 0, 1, 2) kFloat : float, real (z.B. -1.0, 1.0, 1.1), The precision of floats is limited to 6 numbers. kString : String or char* (for instance "", "paul") kCDATA : String or char* (for instance "", "paul")
static int output( XMLTree tree, int type, int* pointer)
xmlquery_output Allocating variables to the results column of an XML instruction. This allocates the result
of the first result column to the first linked variable and so on.. because XML files
do not contain type information, the type of result column is user-defined in the sense that
the column value can only be converted in the target type. If the XML files receives a decimal number, for example,
the corresponding column can be linked to strings, integers or decimal numbers.
The instruction requires the Include #include "internal/types.h"
The allocation of variables to the results column can be carried out before or after xmlquery::exec. If
xmlquery::fetch finds no other results, the allocation is cancelled.
Name
Type
Default
Description
Return
int
1: Okay
0: Error
tree
XMLTree
-
Representation of an XML file created with xmlquery::open.
type
int
-
Data types of the following variables are follows : kInt : pointer to an integer kFloat : pointer to a decimal numberl kString : String oder char*-Variable. When the type is char*, the variable
must have sufficient reserved memory.
Size of the reserved memory for string results. When pointer is of type String, this parameter is ignored Too little memory for the
string results is very often the cause for script failures that are difficult to trace.
With the specification of the maximum length of the strings, it is ensured that it will only be stored in
reserved memory areas. Results, where required, will be limited to the specified length.
The memory length contains a byte for the string ending 0.
0 : If the specification is missing or is 0, the returned values will be completely inserted in the target variable without a check of the length.
Executing the XML instructions. The call automatically resets the XML instruction of the query.
Name
Type
Default
Description
Return
int
1 : Okay
0 : Error
You may use the functions xmlquery::error and xmlquery::errnum to get more information about the result.
tree
XMLTree
-
Representation of an XML file created with xmlquery::open.
showErrors
int
1
Is the processing error to be automatically displayed?
0 - Do not show error in an error dialog. The script undertakes the error management itself.
otherwise - display standard error dialog
A complete list of possible errors you can find here. Please notice, that
missing attributes or Elements are not errors. To catch missing nodes messages please use here.
Since
Version 1.1.7, January 2005 showErrors seit Version 1.2.2 (18. Oktober 2005)
Get the next result column of the XML instruction. Before fetching the result the
columns must be bound to variables (see xmlquery::output). If
xmlquery::fetch does not find any other results, the bindings are cancelled.
Name
Type
Default
Description
Return
int
1 result found
0 no other results. The fixed variable bindings are cancelled using xmlquery::output.
tree
Representation of an XML file created with xmlquery::open.
Ascertain the current program path to the iQuest Comet XML data files. This folder in set up globally in
InDesign® and contains, inter alia, the file placeholder.xml and the folder
actions, with which the placeholders and their actions are defined.
Selection criterion for sub elements or "" for all sub elements.
The selection criterion is applied exclusively to direct subelements or attributes of the entry level
and must have the following syntax:
name operator value
If the element to be exported has no subelement or attribute of the given name, the criterion is ignored and the element is exported.
Operator
Description
Example
= == < <= > >= != <>
Integer and floating number comparison
Export only subelements with id >= 1000.
id >= 1000
? !
TText comparison. The search text must be given in quotation marks.
Use ? for case-insensitive comparisons and ! or case-sensitive comparisons.
With the empty string ('') as search text the criterion is ignored.
At the beginning and end of the search string % are allowed as wildcards.
With \% the wildcard is ignored.
Export only sub-elements whose names start with "Article ".
name ? 'Article %'
Write all Comet Groups of the meta data export groups.xml whose ID contains 89 into a JSON.
Remove any Comet internal data for the given XML file. The file is reparsed on the next call to open.
Flush is only done for xml files opened with useTreeBuffer set to 1.
All XMLTrees of the file must be closed at flush-time. Flushing Comet standard files like actions.xml, panelstatements. xml, ...
is not allowed.
comet.xmltree.open