Introduction to eQL

eQL, which stands for eB Query Language (eB is the former name of AssetWise), is a special language designed to allow users to extract information from AssetWise for reporting. eQL is used by Report Designer in AssetWise Director and AssetWise Engineering Designer, as well as the quick and extended search interfaces in all AssetWise client applications (including AssetWise Web).

eQL resembles SQL, the database query language, but is simpler to work with than SQL, and is tailored for AssetWise objects and their relationships. eQL provides great flexibility in constructing queries, and is used as the basis for all searching and reporting in AssetWise.

The result of an eQL query is a set of records. Each record has information about one object, and each field in the record is a piece of information related to that object. Together, the records can be represented as a table, where each row in the table is a record, and each column heading in the table describes the information in each field of the records.

Here is an example eQL query and a sample of the results it returns from a hypothetical database:

START WITH Document
SELECT
  Code,
  Name,
  Class.Name,
  Files.Name
WHERE
  Name LIKE '%Maintenance%'
ORDER BY
  Code
Code | Name | Class.Name | File.Name
076-SP-0071 | Specification for Routine Maintenance Procedures | Specification | maintprocspec.doc
D0004116 | Routine maintenance for turbines | Procedure |
G142-31 | Regular Service & Maintenance | Policy | Reg Sve Maint.pdf
PRO-M46-0004 | Maintenance for Engine Mounts | Procedure | pro_m46_0004.pdf
Parent topic: eQL (SELECTseries 7) Help


The Parts of an eQL Query

An eQL query consists of four parts:

  • The START WITH clause specifies the primary object
  • The SELECT clause specifies the columns to return
  • The WHERE clause specifies the filtering criteria
  • The ORDER BY clause specifies the sort order

The START WITH clause, SELECT clause, and WHERE clause are required, and the ORDER BY clause is optional. The following sections describe each of these parts.

Primary Object - the START WITH Clause
Columns to Return - The SELECT Clause
Filtering Criteria - The WHERE Clause
Sorting - The ORDER BY Clause
Parent topic: eQL (SELECTseries 7) Help


Primary Object - the START WITH Clause

You specify the primary object in an eQL query after the START WITH keyword. The primary object is the main type of object for which you want to get information, such as document, project, physical item, person, and so on. The following table is not complete, but lists the most common primary objects:

ChangeRequest | FileplanActionOrder | Person | SharePointItem
DistributionList | Folder | PhysicalItem | Skill
DistributionOrder | GroupedVirtualItem | Project | Tag
Document | Keyword | Prototype | Transmittal
DocumentCopy | Location | Report | VirtualItem
File | Note | Role | VirtualItemGroup
Fileplan | Organization | SerializedItem | WorkOrder

How do you decide what should be the object of interest? For a question such as, “ which documents are approved?”, it is fairly easy to see that the primary object is document.

Choosing the primary object is not always so straightforward. For example, if you ask, “which documents are approved and are in projects that are inactive?”, it may not be evident whether the primary object is document or project. Really, the choice depends on what is your main focus for the question.

If you want additional information on an object related to your primary object, you can get that information by choosing which columns to return, covered in the next section.

Parent topic: The Parts of an eQL Query


Columns to Return - The SELECT Clause

The columns to return are the fields of information you want to display in the report. These are the entries after the SELECT keyword in the eQL query. So, if you have an eQL query such as:

START WITH Document
SELECT
  Code,
  Name,
  Class.Name
WHERE Id > 0

The SELECT clause says you want to get the code property, the name property, and the class name property for each document returned.

Multiple data fields may be defined with each separated by a comma. Make sure a comma does not exist after the last data field. The order of the data fields in the SELECT clause determines the order of the columns in the returned results.

Parent topic: The Parts of an eQL Query

Id Columns

AssetWise maintains an internal Id for each of its objects. Although you rarely if ever need to see this Id in a report, you often need to include it as a column in the SELECT clause. The reason for including the Id column is that this allows you to set up hotlinks in the report to open detailed views on the objects displayed in the report. For more information on displaying hyperlinks in a report, see Format Layout tab.

Columns for Related Object Properties

In the Columns to Return example above, the class name is not a property of the document directly. Instead, it is a property of the Class object, which is related to the document. The addition of the Class.Name property has the effect of linking to the Class object and retrieving the appropriate class name associated with this document. In SQL, linking is done with a JOIN between the documents table and the classes table. In eQL, this is accomplished by including the column in the SELECT clause. (As you will see below, these virtual joins can also be accomplished using the WHERE clause.)

Since the SELECT clause (and the WHERE clause) can extend the properties of the query beyond the primary object to objects that are related to the primary object, the list of all possible properties is extremely large for any one object type. eQL Elements lists document properties and related object properties that can be used in the SELECT and WHERE clauses when searching for documents. A similar list could be generated for each of the primary objects you could use in an eQL query. In the Design Search tab of the Report Designer window, the primary object properties and its related object properties are displayed in a tree control for easy reference and inclusion.

The following example shows how to retrieve related file and physical item information for a document. The SELECT clause specifies columns for the document's File Names and related Physical Item Names as well as the document Code and Name.

START WITH Document
SELECT
  Code,
  Name,
  Files.Name,
  PhysicalItems.PhysicalItem.Name
WHERE
  Name LIKE '%'

In the above example, the Name property of the physical item related to the document is accessed using the property PhysicalItems.PhysicalItem.Name. Using this dot syntax is typical for properties of related objects. For some properties, the dot syntax can produce a property name that is quite long. For example, if the object related to a document is a virtual item that is part of a virtual item group, and you wish to retrieve the class name for that virtual item group, the property is:

GroupedVirtualItems.GroupedVirtualItem.VirtualItemGroup.Class.Name

Such long names can be awkward when used as a column heading in a table of results. For more information, see Renaming Columns.

Specifying Custom Attributes in the SELECT Clause

In addition to the standard object properties, AssetWise lets you define your own custom attributes for documents and other objects. eQL has a special syntax for indicating custom attributes in a SELECT clause (or a WHERE clause). The following example shows the format for accessing attribute values.

SELECT Attributes["Global","Max RPM"].Value

The keyword Attributes followed by brackets [ ] that enclose the scope name and the attribute name (each name within double quotes and separated by a comma), followed by .Value.

You can also query using custom attributes of objects related to the primary object. The format for accessing the attribute values is the same as for the primary object, except that it is preceded by the related object qualifier. The following example shows the format for accessing the Activity attribute of a project object where the primary object is a document.

SELECT
Projects.Project.Attributes["Global", "Activity”].Value

Renaming Columns

The column names that eQL uses internally might not be the names you want to see in your report output. There are two methods for changing the column names for the report output. One option is to specify an alias for the column name in the eQL query by adding the alias after the eQL column name in the SELECT clause. In the example below, the column Projects.Project.Name is given the alias Project. The alias must contain no spaces or non-alphanumeric characters except for underscore.

START WITH Document
SELECT
  Code Number,
  Name Title,
  Projects.Project.Name Project
WHERE
  Name LIKE '%'

The other method is to use the Format Layout tab in the Report Designer window as described earlier in this document. The alternative column name in the Format Layout tab can use any unicode character.


Filtering Criteria - The WHERE Clause

The WHERE clause is used to narrow the set of records you retrieve for a query. Without filtering criteria, you would get back all instances of your primary object type, which might be millions of records and cause a timeout error.

The properties you can use in the WHERE clause are the same ones available for the SELECT clause. This means that you have an extremely wide set of characteristics you can use to filter and narrow the results. These characteristics include not only properties and attributes of the primary object, but also properties and attributes of objects related to the primary object. See eQL Elements for a list of properties you can use in the WHERE clause of a document search.

The WHERE clause is required since you normally only submit queries that retrieve a small, targeted fraction of the records in the community.

Parent topic: The Parts of an eQL Query

Minimal Criteria

Although the WHERE clause is required, you can still retrieve all records of a particular object type using WHERE Id>0. This WHERE clause retrieves all records because it is true for every object.

In order to retrieve all objects of a particular object type except templates for that object type, you can use WHERE IsTemplate = 'N'.

Multiple Criteria

The real power of the WHERE clause comes from being able to use multiple criteria in combination. The following example combines criteria in a WHERE clause to return only approved documents that are not templates and whose project status is set to Authorized:

START WITH Document
SELECT
  Id
WHERE
  ApprovalStatus = 'A'
  AND IsTemplate = 'N'
  AND Projects.Project.Status = 'A'

When you are creating an eQL query using Report Designer and defining the WHERE clause with system fields, the Quick Info button provides a listing of system codes and their corresponding user friendly names. For example, if you place your cursor on the ApprovalStatus row and click the Quick Info button, a table is displayed with the values:

  • A - Authorized
  • C - Cancelled
  • F - Completed
  • P - Planned
  • S - Suspended

Combining Multiple Criteria

Criteria in the WHERE clause can be combined using AND and OR. The keyword NOT can also be used after AND and OR to search on the negation of the criterion.

When combining criteria using AND, the object has to satisfy both criteria, so linking criteria with AND tends to return a smaller results set.

When combining criteria using OR, the object need satisfy one or the other criterion but not necessarily both, so linking criteria with OR tends to return a larger results set.

Mixing AND and OR in a WHERE Clause

When using both AND and OR together in the same WHERE clause, you should use parentheses to indicate the proper grouping of criteria. The examples below use the same criteria but group them differently, producing different results.

WHERE
  ApprovalStatus = 'N'
  AND (
  Attributes["Global","Site"].Value = 'Site 1'
  OR Attributes["Global","Site"].Value = 'Site 2'
  )
  AND IsTemplate = 'N'
  WHERE
  (
  ApprovalStatus = 'N'
  AND Attributes["Global","Site"].Value = 'Site 1'
  )
  OR (
  ApprovalStatus = 'A'
  AND Attributes["Global","Site"].Value = 'Site 2'
  )
  AND IsTemplate = 'N'

The first WHERE clause finds documents that are not approved and not a template, and are either for site 1 or 2. The second WHERE clause finds documents that are either for site 1 and not approved, or for site 2 and approved and not a template.

Criteria Operators

When you specify criteria in a WHERE clause, you specify a property and compare it to a value using an operator. The equal sign (=) is a common operator, but AssetWise supports others:

Operator | Meaning
= Equal To
<> Not Equal To
< Less Than
> Greater Than
<= Less Than or Equal To
>= Greater Than or Equal To
LIKE | Used to search for a specified pattern. A pattern can include regular characters or the '%' and '_' wildcard characters. See Using Wildcards.
CONTAINS Used to search for a word in the chosen criteria. Words are separated by spaces and ALL of the words must exist. For example, in the first WHERE clause below, the report will look at the contents of the file. In the second WHERE clause, the report looks at the descriptive fields (find something in the title of a document).
WHERE Files.ContentData CONTAINS @criteria
WHERE Name CONTAINS @criteria
FREETEXT Used to search for a word in the chosen criteria. Words are separated by spaces and ANY of the words may exist. For example, in the first WHERE clause below, the report will look at the contents of the file. In the second WHERE clause, the report looks at the descriptive fields (find something in the title of a document).
WHERE Files.ContentData FREETEXT @criteria
WHERE Name FREETEXT @criteria
Note: If FTR is not configured, you cannot perform a CONTAINS or FREETEXT search on file content.

Using Wildcards

eQL supports wildcards, which are special characters used to substitute for any other characters. The percent character (%) can substitute for zero or more characters; the underscore (_) can substitute for one character. You would use these characters in an eQL query in the WHERE clause, after the operator LIKE, as in the following examples.

Example 1: Find all documents where Site appears anywhere in the title

WHERE
  Name LIKE '%Site%'

Example 2: Find all documents where the title starts with Site

WHERE
  Name LIKE 'Site%'

Example 3: Find all documents where the title ends with Site

WHERE
  Name LIKE '%Site'

Example 4: Find all documents where the title starts with S and ends with e

WHERE
  Name LIKE 'S%e'

Example 5: Find all documents where the title is SiteA, Sitea, SiteB, Site1, but not Site

WHERE
  Name LIKE 'Site_'

Specifying Full Text Retrieval (FTR) Searches in the WHERE Clause

If FTR is configured, you can use the CONTAINS or FREETEXT operators in an eQL WHERE clause to search for a document based on text contained within the files related to the document. The following examples show the format for FTR searches in an eQL WHERE clause:

Example 1: File must contain both the exact strings “London” and “CAD-Connect”

WHERE Files.ContentData CONTAINS @criteria

Example 2: File must contain either the exact string “London” or “CAD-Connect”

WHERE Files.ContentData FREETEXT @criteria

Example 3: File must contain the exact phrase “London CAD-Connect”

WHERE Files.ContentData = @criteria

Specifying Custom Attributes in the WHERE Clause

Just as you can use custom attributes in a SELECT clause, you can use them to filter results in a WHERE clause. The following example shows how to use custom attributes in a WHERE clause.

WHERE Attributes["Global", "Max RPM"].Value > 500

The keyword Attributes followed by brackets [ ] that enclose the scope name and the attribute name (both names in double quotes, separated by a comma), followed by .Value.

Specifying NULL Values

In databases, a NULL value is different from a numerical value of 0 or a blank string. In AssetWise, object properties that are not required and have not been set will usually have a value of NULL. If you search for a property and specify that the value must equal a blank string, records that have NULL for that property will not be returned as hits.

eQL has a special keyword to let you search for values that are either NULL or not NULL. You can use this feature to find document attributes that have not been set or documents where the attribute has been set, as in the following examples.

Example 1: Find documents where Max RPM has not been set

WHERE Attributes["Global", "Max RPM"].Value IS NULL

Example 2: Find documents where Max RPM has been set

WHERE Attributes["Global", "Max RPM"].Value IS NOT NULL
Note: Notice in the above examples that you do not use the equal sign, but instead use IS NULL or IS NOT NULL.

Distinguishing Among Related Objects

When an object such as a document is related to multiple objects, such as files, you might want to find documents where a property among its files has two distinct values.

For example, you might want to search for all documents that have both a PDF file and a DOC file. The following eQL query returns no documents, because no one file is both a PDF file and a DOC file.

WHERE
  Files.Name LIKE '%.pdf'
  AND Files.Name LIKE '%.doc'

To solve this problem, eQL allows you to add a numerical identifier to the property to indicate that the second property should be from a different object than the first property. Here is that same example with numerical identifiers. This code finds documents where one file has a .pdf extension and another file has a .doc extension.

WHERE
  Files[1].Name LIKE '%.pdf'
  AND Files[2].Name LIKE '%.doc'
Note: The actual numbers you use in the brackets do not matter, as long as they are different from each other.

You can also use numerical identifiers with multi-value attributes. Multi-value attributes are attributes that can have more than one value for a single object. An example of a multi-value attribute might be a subject area attribute for a document that spans several subjects.

If documents use multi-value attributes and you want to find documents that have two or more values of a particular attribute, numerical identifiers let you distinguish among the different attribute values. Here is an eQL query for finding documents with at least two values of the Dept attribute, one set to Acct and one set to HR.

WHERE
  Attributes["Global","Dept"][1].Value LIKE 'ACCT'
  AND Attributes["Global","Dept"][2].Value LIKE 'HR'
  AND IsTemplate = 'N'

Traversing AssetWise Class Hierarchies Using eQL

Classes are objects that can be arranged in hierarchies and can be associated with documents and other objects. You can create eQL queries that make use of these hierarchies to find objects. Rather than specifying each level of the hierarchy to search, you just specify a starting point (using the class id) and AssetWise will search up or down the hierarchy from that point.

The DESCENDS operator searches down the hierarchy. The ASCENDS operator searches up the hierarchy.

The following example searches for all documents in a class which is a descendent of the Drawing class, whose class id is 70.

WHERE Class.Id DESCENDS 70

To determine the Class.Id from which to descend, you can first perform a query on the Class object. You then take that Class Id and use it in the DESCENDS clause to find objects belonging to classes descended from that class.

START WITH Document
SELECT
  Class.Id Id,
  Class.Code,
  Code DocCode,
  Name
WHERE
  Class.Id DESCENDS 70
ORDER BY
 Code
Id | Class.Code | DocCode | Name
71 | DWG-S | S-WH=00346 | Specification for wheel subassembly
71 | DWG-S | DSTD001 | Drawing standards in specification
72 | DWG-V | VM-J-21784 | Vendor manual for J-21784

The WHERE clause above returns all documents having a class of DWG-S or DWG-V since they are child classes of DWG (class Id 70).


Sorting - The ORDER BY Clause

The ORDER BY clause lets you specify which columns to use for sorting the records. Any or all of the columns specified in the SELECT clause can be used in the ORDER BY clause. You can even sort by columns that are not specified in the SELECT clause, although this would not commonly be done, because no column in the resulting report would reflect the sort order.

If you use more than one column in the ORDER BY clause, the columns will be read from left to right within the ORDER BY clause to provide multiple levels of sorting. The actual layout of the columns (first, second, third, etc.) is set by the SELECT clause (and the Format Layout tab, described earlier) rather than the ORDER BY clause, meaning that you specify the column arrangement independent of the sorting. The following example sorts first by project name, and then by document name (title) within the project.

START WITH Document
SELECT
  Code,
  Name,
  Projects.Project.Name
WHERE
  Id > 0
ORDER BY
  Projects.Project.Name, Name
Code | Name | Project
G142-31 | Regular service & maintenance | Longmuir
D0004116 | Routine maintenance for turbines | Longmuir
076-SP-0072 | Specification for routine maintenance procedures | Longmuir
PRO-M46-0005 | Diagnostics for engine mounts | Polaris
PRO-M46-0004 | Maintenance for engine mounts | Polaris
D0002114 | Routine maintenance for steam condensers | Polaris
Parent topic: The Parts of an eQL Query


Functions in eQL

eQL has functions that can be applied to retrieved data for purposes of column display or for modifying data prior to a comparison in a WHERE clause. For example, you may want to truncate dates to display only the year portion or to retrieve records prior to a given year.

A function has a list of parameters enclosed in parentheses and separated by commas. For example, LEFT("fireworks", 4) retrieves fire.

The following table categorizes the eQL functions. The Functions user assistance button in Report Designer describes how to use each function.

Category | Function Name | Usage
Date Processing | DATECALC | Calculates a new date based on an increment from the supplied date.
Text Processing | CAST | Truncates the date or displays it in a specific format.
 | LEFT | Returns the left part of a text string.
 | RIGHT | Returns the right part of a text string.
 | LENGTH | Returns the number of characters in a text string.
 | POSITION | Returns the starting position of specified characters in a text string.
 | REPLACE | Replaces characters in a string.
 | TRIM | Removes leading and trailing spaces.
 | SUBSTRING | Returns a specified number of characters starting at a specified position in a text string.
 | LOWER | Converts a text string to lowercase.
 | UPPER | Converts a text string to uppercase.
Display | DISPLAY_NAME | Displays the word(s) instead of the single-character code for certain AssetWise properties.
Data Type Conversion | CAST | Converts between data types (text, number, date).
Conditional Processing | CASE | Chooses one of multiple result expressions based on the value of an input expression.
 | IFNULL | Replaces NULL values with replacement values.
Administrative Report Objects
Parent topic: eQL (SELECTseries 7) Help


Administrative Report Objects

The following objects are not typically used by end-users, but may be used by administrators to search for configuration settings:

AttributeDef | MediaType | Relationship | Session
Class | Object | RelationshipType | SettingDef
CrossReferenceType | PrintTemplate | ResponsibilityType | SharePointItem
DistributionReason | ProductStructureType | RevisionRule | Template
FileFormat | PublisherPackage | Scope |
JobType | QueueJob | Server |
Parent topic: Functions in eQL


Executing Stored Procedures

In some cases it may be necessary to perform a more complex search than the current eQL syntax can provide. For this purpose you can create or use an existing system stored procedure in the database.

Examples

EXEC GetSystemData( 0, 20, 'Keywords', NULL, 1, 200 )
START WITH Person EXEC AddKeyword( 'Test-' + Code ) WHERE Id > 0
EXEC GetMyThings (@ObjectId, @StartAt, @PageSize, @PersonId, @RetCount)

Custom procedures must be registered methods in the database. As an example, create the procedure myp_eql_test_procedure:

CREATE PROCEDURE myp_eql_test_procedure
@pi_first_param INT
AS
BEGIN
   SET NOCOUNT ON;

   SELECT @pi_first_param
END
GO

Then register the procedure for execution by entering the following into the method and parameter info tables.

insert into method_info values (10000, 'myp_eql_test_procedure', 1, 'N', 'myp_eql_test_procedure')
insert into parameter_info values (10000, 1, 'myp_eql_test_procedure', 'INT', 'Y', 'N', 'N', 'NULL', 'N' )

You should now be able to execute the eQL command:

EXEC myp_eql_test_procedure ( 1 )
Parent topic: eQL (SELECTseries 7) Help


Search Settings

A number of settings are available that can be used to change certain behaviors of the eQL search. These settings all use the verb SET and have the syntax of:

SET <SettingVariable> <SettingValue>

MaxInnerRows

This will change the system setting for MaxInnerRows to modify the maximum number of rows that a search will consider for order and filtering during the current session. Once set it will remain unchanged until it is either changed again or the session is ended.

Example:

SET MaxInnerRows= 1000000;

PageSize

This will change the users current setting for PageSize to modify the maximum number of rows returned in the search results. Once set it will remain unchanged until it is either changed again or the session is ended.

Example:

SET PageSize 1000;

StartAt

This is used to set which row of the query result a search should start returning rows from. By default this is the first row of the results set.

Example:

SET StartAt =100;

Distinct

eQL queries return distinct values by default (almost an equivalent of the DISTINCT keyword in SQL). This setting will disable such behavior and probably improve the performance of the query. This is a local setting that applies only to the query being executed. It does not affect other eQL queries being executed in the session.

Example:

The following query will return multiple rows for the same document if the document has more than one revision.

SET Distinct = OFF;
START WITH Document SELECT Code
WHERE Code = 'DOC1'

Paging

eQL queries have paging turned on by default. This setting allows to turn paging off.

Internally, Paging and Distinct operations use default (invisible) ORDER BY even when the ordering is not specified explicitly. (For documents, default is ORDER BY Code, Revision) It is necessary for Paging and Distinct operations to have explicit or default ORDER BY to provide consistent results during paging and across multiple queries. When both of these settings are turned off, the default ordering is not required anymore, therefore there is a potential for the query to perform better.

Example:

The following query will return revisions of all documents. The number of results will be limited by the MaxInnerRows setting.

SET Distinct = OFF;
SET Paging = OFF;
START WITH Document SELECT Id, Code
WHERE Id > 0
Parent topic: eQL (SELECTseries 7) Help


eQL Elements

The following eQL elements are available for a document (START WITH object) for the SELECT, WHERE, and ORDER BY clauses. Similar eQL elements are available for the other AssetWise objects.

Parent topic: eQL (SELECTseries 7) Help

eQL Elements for Document Properties

The following eQL elements may be used in the SELECT, WHERE, and ORDER BY clauses when the START WITH object is Document.

Id | ChangeControlled | InDefaultScope | Synopsis
Code | IsUnderChange | InDefaultVisibleScope | Namespace.Id
Middle | IsCheckedOut | HasPendingChange | Namespace.Name
Revision | IsLatestRevision | ApprovalStatus | Scope.I
Name | IsLatestApprovedRevision | ApprovalStatus | Scope.Name
DateEffective | IsSuperseded | Remark |
DateObsolete | IsTemplate | Attributes["Scope","Name"].Value |

eQL Elements for Objects Related to Documents

The following eQL elements for objects related to documents can be used in the SELECT, WHERE, and ORDER BY clause when the START WITH object is Document.

Affected Change Requests

AffectedChangeRequests.Id
AffectedChangeRequests.Code
AffectedChangeRequests.Description
AffectedChangeRequests.Status
AffectedChangeRequests.Class.Id
AffectedChangeRequests.Class.Path
AffectedChangeRequests.Reason
AffectedChangeRequests.Category
AffectedChangeRequests.ApprOrRejectReason
AffectedChangeRequests.DateRegistered
AffectedChangeRequests.IsTemplate
AffectedChangeRequests.InDefaultScope
AffectedChangeRequests.InDefaultVisibleScope

Audit Details

AuditDetails.Person.Id
AuditDetails.Person.Code
AuditDetails.Person.Surname
AuditDetails.Person.FirstName
AuditDetails.AuditDate
AuditDetails.AuditDef.ActionType

Change Requests

ChangeRequests.ChangeRequest.Id
ChangeRequests.ChangeRequest.Code
ChangeRequests.ChangeRequest.Description
ChangeRequests.ChangeRequest.Status
ChangeRequests.ChangeRequest.Class.Id
ChangeRequests.ChangeRequest.Class.Path
ChangeRequests.ChangeRequest.Reason
ChangeRequests.ChangeRequest.Category
ChangeRequests.ChangeRequest.ApprOrRejectReason
ChangeRequests.ChangeRequest.DateRegistered
ChangeRequests.ChangeRequest.IsTemplate
ChangeRequests.ChangeRequest.InDefaultScope
ChangeRequests.ChangeRequest.InDefaultVisibleScope
ChangeRequests.RelationshipType.Id
ChangeRequests.RelationshipType.DerivedFrom.Id
ChangeRequests.RelationshipType.DerivedFrom.Code
ChangeRequests.RelationshipType.DerivedFrom.Name
ChangeRequests.RelationshipType.DerivedFrom.Description
ChangeRequests.RelationshipType.LeftType
ChangeRequests.RelationshipType.RightType
ChangeRequests.RelationshipType.LeftName
ChangeRequests.RelationshipType.RightName
ChangeRequests.RelationshipType.InDefaultScope
ChangeRequests.RelationshipType.InDefaultVisibleScope

Child Documents

Children.Right.Id
Children.Right.Code
Children.Right.Middle
Children.Right.Revision

Document Class

Class.Id
Class.Code
Class.Name
Class.Description
Class.SysType
Class.Path

Document Copies

Copies.Id
Copies.Code
Copies.IsOnBackorder
Copies.CopyType
Copies.Purpose
Copies.Status
Copies.Remark
Copies.IsTemplate
Copies.Location.Id
Copies.Location.Code
Copies.Location.Name
Copies.MediaType.Id
Copies.MediaType.Name
Copies.MediaType.SysType

Cross References

CrossReferences.CrossReferenceType.Id
CrossReferences.CrossReferenceType.Name
CrossReferences.Number

Deviations

Deviations.Deviation.Id
Deviations.Deviation.Code
Deviations.Deviation.Description
Deviations.Deviation.SysType
Deviations.Deviation.Status
Deviations.Deviation.Reason
Deviations.Deviation.Priority
Deviations.Deviation.DateRegistered
Deviations.Deviation.InDefaultScope
Deviations.Deviation.InDefaultVisibleScope
Deviations.RelationshipType.Id
Deviations.RelationshipType.DerivedFrom.Id
Deviations.RelationshipType.DerivedFrom.Code
Deviations.RelationshipType.DerivedFrom.Name
Deviations.RelationshipType.DerivedFrom.Description
Deviations.RelationshipType.LeftType
Deviations.RelationshipType.RightType
Deviations.RelationshipType.LeftName
Deviations.RelationshipType.RightName
Deviations.RelationshipType.InDefaultScope
Deviations.RelationshipType.InDefaultVisibleScope

Related Documents

Documents.Left.ApprovalStatus
Documents.Left.ChangeControlled
Documents.Left.Class.Id
Documents.Left.Class.Path
Documents.Left.Code
Documents.Left.DateEffective
Documents.Left.DateObsolete
Documents.Left.HasFlags
Documents.Left.HasPendingChange
Documents.Left.Id
Documents.Left.InDefaultScope
Documents.Left.InDefaultVisibleScope
Documents.Left.IsCheckedOut
Documents.Left.IsLatestApprovedRevision
Documents.Left.IsLatestRevision
Documents.Left.IsSuperseded
Documents.Left.IsTemplate
Documents.Left.IsUnderChange
Documents.Left.Middle
Documents.Left.Name
Documents.Left.Namespace.Id
Documents.Left.Remark
Documents.Left.Revision
Documents.Left.Scope.Id
Documents.Left.Scope.Name
Documents.Left.Scope.Owner.Id
Documents.Left.Scope.Owner.Label
Documents.Left.Scope.Owner.Type
Documents.Left.State
Documents.Left.Synopsis
Documents.Left.State
Documents.Left.Synopsis
Documents.Right.ApprovalStatus
Documents.Right.ChangeControlled
Documents.Right.Class.Id
Documents.Right.Class.Path
Documents.Right.Code
Documents.Right.DateEffective
Documents.Right.DateObsolete
Documents.Right.HasFlags
Documents.Right.HasPendingChange
Documents.Right.Id
Documents.Right.InDefaultScope
Documents.Right.InDefaultVisibleScope
Documents.Right.IsCheckedOut
Documents.Right.IsLatestApprovedRevision
Documents.Right.IsLatestRevision
Documents.Right.IsSuperseded
Documents.Right.IsTemplate
Documents.Right.IsUnderChange
Documents.Right.Middle
Documents.Right.Name
Documents.Right.Namespace.Id
Documents.Right.Remark
Documents.Right.Revision
Documents.Right.Scope.Id
Documents.Right.Scope.Name
Documents.Right.Scope.Owner.Id
Documents.Right.Scope.Owner.Label
Documents.Right.Scope.Owner.Type
Documents.Right.State
Documents.Right.Synopsis
Documents.Right.State
Documents.Right.Synopsis
Documents.RelationshipType.AllowCircularReference
Documents.RelationshipType.ControlledBy
Documents.RelationshipType.DerivedFrom.Code
Documents.RelationshipType.DerivedFrom.Description
Documents.RelationshipType.DerivedFrom.Id
Documents.RelationshipType.DerivedFrom.Name
Documents.RelationshipType.Id
Documents.RelationshipType.InDefaultScope
Documents.RelationshipType.InDefaultVisibleScope
Documents.RelationshipType.IsDirected
Documents.RelationshipType.LeftName
Documents.RelationshipType.LeftType
Documents.RelationshipType.NumLeft
Documents.RelationshipType.NumRight
Documents.RelationshipType.Presentation
Documents.RelationshipType.RightName
Documents.RelationshipType.RightType
Documents.RelationshipType.Scope.Id
Documents.RelationshipType.Scope.Name
Documents.RelationshipType.Scope.Owner.Id
Documents.RelationshipType.Scope.Owner.Label
Documents.RelationshipType.Scope.Owner.Type

Events

Events.Event.Id
Events.Event.Code
Events.Event.Name
Events.Event.Description
Events.Event.Class.Id
Events.Event.Class.Path
Events.Event.ApprovalStatus
Events.Event.StartDate
Events.Event.EndDate
Events.Event.IsTemplate
Events.Event.SupersededBy.Id
Events.Event.InDefaultScope
Events.Event.InDefaultVisibleScope
Events.RelationshipType.Id
Events.RelationshipType.DerivedFrom.Id
Events.RelationshipType.DerivedFrom.Code
Events.RelationshipType.DerivedFrom.Name
Events.RelationshipType.DerivedFrom.Description
Events.RelationshipType.LeftType
Events.RelationshipType.RightType
Events.RelationshipType.LeftName
Events.RelationshipType.RightName
Events.RelationshipType.InDefaultScope
Events.RelationshipType.InDefaultVisibleScope

Document Files

Files.Id
Files.Name
Files.Path
Files.FileDate
Files.AuditDetails.Person.Id
Files.AuditDetails.Person.Code
Files.AuditDetails.Person.Surname
Files.AuditDetails.Person.FirstName
Files.AuditDetails.AuditDate
Files.AuditDetails.AuditDef.ActionType

Grouped Virtual Items

GroupedVirtualItems.GroupedVirtualItem.Id
GroupedVirtualItems.GroupedVirtualItem.Description
GroupedVirtualItems.GroupedVirtualItem.HasFlags
GroupedVirtualItems.GroupedVirtualItem.VirtualItemGroup.Id
GroupedVirtualItems.GroupedVirtualItem.VirtualItemGroup.Code
GroupedVirtualItems.GroupedVirtualItem.VirtualItemGroup.Middle
GroupedVirtualItems.GroupedVirtualItem.VirtualItemGroup.Revision
GroupedVirtualItems.GroupedVirtualItem.VirtualItemGroup.Name
GroupedVirtualItems.GroupedVirtualItem.VirtualItemGroup.DateEffective
GroupedVirtualItems.GroupedVirtualItem.VirtualItemGroup.DateObsolete
GroupedVirtualItems.GroupedVirtualItem.VirtualItemGroup.ChangeControlled
GroupedVirtualItems.GroupedVirtualItem.VirtualItemGroup.IsUnderChange
GroupedVirtualItems.GroupedVirtualItem.VirtualItemGroup.IsCheckedOut
GroupedVirtualItems.GroupedVirtualItem.VirtualItemGroup.IsLatestRevision
GroupedVirtualItems.GroupedVirtualItem.VirtualItemGroup.IsLatestApprovedRevision
GroupedVirtualItems.GroupedVirtualItem.VirtualItemGroup.IsSuperseded
GroupedVirtualItems.GroupedVirtualItem.VirtualItemGroup.HasPendingChange
GroupedVirtualItems.GroupedVirtualItem.VirtualItemGroup.ApprovalStatus
GroupedVirtualItems.GroupedVirtualItem.VirtualItemGroup.State
GroupedVirtualItems.GroupedVirtualItem.VirtualItemGroup.Remark
GroupedVirtualItems.GroupedVirtualItem.VirtualItemGroup.Synopsis
GroupedVirtualItems.GroupedVirtualItem.VirtualItemGroup.IsTemplate
GroupedVirtualItems.GroupedVirtualItem.VirtualItemGroup.Class.Id
GroupedVirtualItems.GroupedVirtualItem.VirtualItemGroup.Class.Code
GroupedVirtualItems.GroupedVirtualItem.VirtualItemGroup.Class.Name
GroupedVirtualItems.GroupedVirtualItem.VirtualItemGroup.Class.Description
GroupedVirtualItems.GroupedVirtualItem.VirtualItemGroup.Class.Path
GroupedVirtualItems.GroupedVirtualItem.VirtualItem.Id
GroupedVirtualItems.GroupedVirtualItem.VirtualItem.Code
GroupedVirtualItems.GroupedVirtualItem.VirtualItem.Description
GroupedVirtualItems.GroupedVirtualItem.VirtualItem.Class.Id
GroupedVirtualItems.GroupedVirtualItem.VirtualItem.Class.Code
GroupedVirtualItems.GroupedVirtualItem.VirtualItem.Class.Name
GroupedVirtualItems.GroupedVirtualItem.VirtualItem.Class.Description
GroupedVirtualItems.GroupedVirtualItem.VirtualItem.Class.Path
GroupedVirtualItems.RelationshipType.Id
GroupedVirtualItems.RelationshipType.DerivedFrom.Id
GroupedVirtualItems.RelationshipType.DerivedFrom.Code
GroupedVirtualItems.RelationshipType.DerivedFrom.Name
GroupedVirtualItems.RelationshipType.DerivedFrom.Description
GroupedVirtualItems.RelationshipType.LeftType
GroupedVirtualItems.RelationshipType.RightType
GroupedVirtualItems.RelationshipType.LeftName
GroupedVirtualItems.RelationshipType.RightName
GroupedVirtualItems.RelationshipType.InDefaultScope
GroupedVirtualItems.RelationshipType.InDefaultVisibleScope

Keywords

Keywords.Keyword.Id
Keywords.Keyword.Name

Locations

Locations.Location.Id
Locations.Location.Code
Locations.Location.Path
Locations.Location.Name
Locations.Location.Class.Id
Locations.Location.Class.Path
Locations.Location.IsTemplate
Locations.Location.Namespace.Id
Locations.Location.InDefaultScope
Locations.Location.InDefaultVisibleScope
Locations.RelationshipType.Id
Locations.RelationshipType.DerivedFrom.Id
Locations.RelationshipType.DerivedFrom.Code
Locations.RelationshipType.DerivedFrom.Name
Locations.RelationshipType.DerivedFrom.Description
Locations.RelationshipType.LeftType
Locations.RelationshipType.RightType
Locations.RelationshipType.LeftName
Locations.RelationshipType.RightName
Locations.RelationshipType.InDefaultScope
Locations.RelationshipType.InDefaultVisibleScope

Model Of

ModelOf.Id
ModelOf.Name
ModelOf.Description
ModelOf.CodeMask
ModelOf.Status

Modification

Modifications.Modification.Id
Modifications.Modification.Code
Modifications.Modification.Description
Modifications.Modification.Status
Modifications.Modification.DateRegistered
Modifications.Modification.IsTemplate
Modifications.Modification.InDefaultScope
Modifications.Modification.InDefaultVisibleScope
Modifications.RelationshipType.Id
Modifications.RelationshipType.DerivedFrom.Id
Modifications.RelationshipType.DerivedFrom.Code
Modifications.RelationshipType.DerivedFrom.Name
Modifications.RelationshipType.DerivedFrom.Description
Modifications.RelationshipType.LeftType
Modifications.RelationshipType.RightType
Modifications.RelationshipType.LeftName
Modifications.RelationshipType.RightName
Modifications.RelationshipType.InDefaultScope
Modifications.RelationshipType.InDefaultVisibleScope

Notes

Notes.Name
Notes.Id
Notes.Content
Notes.DateAdded
Notes.AddedBy.Id
Notes.AddedBy.Code
Notes.AddedBy.Surname
Notes.AddedBy.FirstName
Notes.Priority.Id
Notes.Priority.Name

Organizations

Organizations.Organization.Id
Organizations.Organization.Code
Organizations.Organization.Name
Organizations.Organization.Status
Organizations.Organization.Remark
Organizations.Organization.Class.Id
Organizations.Organization.IsTemplate
Organizations.Organization.Namespace.Id
Organizations.Organization.InDefaultScope
Organizations.Organization.InDefaultVisibleScope
Organizations.RelationshipType.Id
Organizations.RelationshipType.DerivedFrom.Id
Organizations.RelationshipType.DerivedFrom.Code
Organizations.RelationshipType.DerivedFrom.Name
Organizations.RelationshipType.DerivedFrom.Description
Organizations.RelationshipType.LeftType
Organizations.RelationshipType.RightType
Organizations.RelationshipType.LeftName
Organizations.RelationshipType.RightName
Organizations.RelationshipType.InDefaultScope
Organizations.RelationshipType.InDefaultVisibleScope

Parent Documents

Parents.Left.Id
Parents.Left.Code
Parents.Left.Middle
Parents.Left.Revision

Persons

Persons.Person.Id
Persons.Person.FullName
Persons.Person.Initial
Persons.Person.FirstName
Persons.Person.Surname
Persons.Person.Status
Persons.Person.Title
Persons.Person.Code
Persons.Person.NationalId
Persons.Person.SecurityRefNo
Persons.Person.SecurityExpDate
Persons.Person.Remark
Persons.Person.Class.Id
Persons.Person.Class.Path
Persons.Person.IsTemplate
Persons.Person.Namespace.Id
Persons.Person.InDefaultScope
Persons.Person.InDefaultVisibleScope
Persons.RelationshipType.Id
Persons.RelationshipType.DerivedFrom.Id
Persons.RelationshipType.DerivedFrom.Code
Persons.RelationshipType.DerivedFrom.Name
Persons.RelationshipType.DerivedFrom.Description
Persons.RelationshipType.LeftType
Persons.RelationshipType.RightType
Persons.RelationshipType.LeftName
Persons.RelationshipType.RightName
Persons.RelationshipType.InDefaultScope
Persons.RelationshipType.InDefaultVisibleScope

Physical Items

PhysicalItems.PhysicalItem.Id
PhysicalItems.PhysicalItem.Code
PhysicalItems.PhysicalItem.Version
PhysicalItems.PhysicalItem.Name
PhysicalItems.PhysicalItem.Class.Id
PhysicalItems.PhysicalItem.Class.Path
PhysicalItems.PhysicalItem.Status
PhysicalItems.PhysicalItem.State
PhysicalItems.PhysicalItem.ExtendedDescription
PhysicalItems.PhysicalItem.IsUnderChange
PhysicalItems.PhysicalItem.HasPendingChange
PhysicalItems.PhysicalItem.IsTemplate
PhysicalItems.PhysicalItem.DateObsolete
PhysicalItems.PhysicalItem.ItemClass
PhysicalItems.PhysicalItem.IsSerialized
PhysicalItems.PhysicalItem.IsMainEquipment
PhysicalItems.PhysicalItem.IsSoftware
PhysicalItems.PhysicalItem.IsPhantom
PhysicalItems.PhysicalItem.InDefaultScope
PhysicalItems.PhysicalItem.InDefaultVisibleScope
PhysicalItems.RelationshipType.Id
PhysicalItems.RelationshipType.DerivedFrom.Id
PhysicalItems.RelationshipType.DerivedFrom.Code
PhysicalItems.RelationshipType.DerivedFrom.Name
PhysicalItems.RelationshipType.DerivedFrom.Description
PhysicalItems.RelationshipType.LeftType
PhysicalItems.RelationshipType.RightType
PhysicalItems.RelationshipType.LeftName
PhysicalItems.RelationshipType.RightName
PhysicalItems.RelationshipType.InDefaultScope
PhysicalItems.RelationshipType.InDefaultVisibleScope

Projects

Projects.Project.Id
Projects.Project.Code
Projects.Project.Name
Projects.Project.Status
Projects.Project.Class.Id
Projects.Project.Class.Path
Projects.Project.IsTemplate
Projects.Project.InDefaultScope
Projects.Project.InDefaultVisibleScope
Projects.RelationshipType.Id
Projects.RelationshipType.DerivedFrom.Id
Projects.RelationshipType.DerivedFrom.Code
Projects.RelationshipType.DerivedFrom.Name
Projects.RelationshipType.DerivedFrom.Description
Projects.RelationshipType.LeftType
Projects.RelationshipType.RightType
Projects.RelationshipType.LeftName
Projects.RelationshipType.RightName
Projects.RelationshipType.InDefaultScope
Projects.RelationshipType.InDefaultVisibleScope

Prototypes

PrototypeRef.Id
PrototypeRef.Status
PrototypeRef.BaseObject.Id
PrototypeRef.BaseObject.Code
PrototypeRef.BaseObject.VersionOrMiddle
PrototypeRef.BaseObject.Revision
PrototypeRef.BaseObject.Name
PrototypeRef.ChangeRequest.Id
PrototypeRef.ChangeRequest.Code
PrototypeRef.ChangeRequest.Description
PrototypeRef.ChangeRequest.Class.Id
PrototypeRef.ChangeRequest.Status

Responsibilities

Responsibilities.ResponsibilityType.Id
Responsibilities.ResponsibilityType.Name
Responsibilities.Person.Id
Responsibilities.Person.Code
Responsibilities.Person.Surname
Responsibilities.Person.FirstName
Responsibilities.Organization.Id
Responsibilities.Organization.Code
Responsibilities.Organization.Name

Serialized Items

SerializedItems.SerializedItem.Id
SerializedItems.SerializedItem.Code
SerializedItems.SerializedItem.BatchQty
SerializedItems.SerializedItem.Remark
SerializedItems.SerializedItem.Class.Id
SerializedItems.SerializedItem.Class.Path
SerializedItems.SerializedItem.IsTemplate
SerializedItems.SerializedItem.Status
SerializedItems.SerializedItem.IsUnderMod
SerializedItems.SerializedItem.HasPendingMod
SerializedItems.SerializedItem.ManufItemNumber
SerializedItems.SerializedItem.InDefaultScope
SerializedItems.SerializedItem.InDefaultVisibleScope
SerializedItems.RelationshipType.Id
SerializedItems.RelationshipType.DerivedFrom.Id
SerializedItems.RelationshipType.DerivedFrom.Code
SerializedItems.RelationshipType.DerivedFrom.Name
SerializedItems.RelationshipType.DerivedFrom.Description
SerializedItems.RelationshipType.LeftType
SerializedItems.RelationshipType.RightType
SerializedItems.RelationshipType.LeftName
SerializedItems.RelationshipType.RightName
SerializedItems.RelationshipType.InDefaultScope
SerializedItems.RelationshipType.InDefaultVisibleScope

SharePoint Items

SharePointItems.SharePointItem.Id
SharePointItems.SharePointItem.Name
SharePointItems.SharePointItem.Description
SharePointItems.SharePointItem.ItemType
SharePointItems.SharePointItem.IsExcluded
SharePointItems.SharePointItem.SyncOptions
SharePointItems.SharePointItem.Origin
SharePointItems.SharePointItem.Status
SharePointItems.SharePointItem.IsSynchronizing
SharePointItems.SharePointItem.Hints
SharePointItems.SharePointItem.SharePointId
SharePointItems.SharePointItem.Url
SharePointItems.SharePointItem.Server
SharePointItems.SharePointItem.Class.Id
SharePointItems.SharePointItem.Class.Path
SharePointItems.SharePointItem.InDefaultScope
SharePointItems.SharePointItem.InDefaultVisibleScope
SharePointItems.RelationshipType.Id
SharePointItems.RelationshipType.DerivedFrom.Id
SharePointItems.RelationshipType.DerivedFrom.Code
SharePointItems.RelationshipType.DerivedFrom.Name
SharePointItems.RelationshipType.DerivedFrom.Description
SharePointItems.RelationshipType.LeftType
SharePointItems.RelationshipType.RightType
SharePointItems.RelationshipType.LeftName
SharePointItems.RelationshipType.RightName
SharePointItems.RelationshipType.InDefaultScope
SharePointItems.RelationshipType.InDefaultVisibleScope

Tags

Tags.Tag.Id
Tags.Tag.Code
Tags.Tag.Revision
Tags.Tag.Name
Tags.Tag.Description
Tags.Tag.ApprovalStatus
Tags.Tag.OperationalStatus
Tags.Tag.IsPrototype
Tags.Tag.IsTemplate
Tags.Tag.Class.Id
Tags.Tag.Class.Path
Tags.Tag.InDefaultScope
Tags.Tag.InDefaultVisibleScope
Tags.RelationshipType.Id
Tags.RelationshipType.DerivedFrom.Id
Tags.RelationshipType.DerivedFrom.Code
Tags.RelationshipType.DerivedFrom.Name
Tags.RelationshipType.DerivedFrom.Description
Tags.RelationshipType.LeftType
Tags.RelationshipType.RightType
Tags.RelationshipType.LeftName
Tags.RelationshipType.RightName
Tags.RelationshipType.InDefaultScope
Tags.RelationshipType.InDefaultVisibleScope

Virtual Item Groups

VirtualItemGroups.VirtualItemGroup.Id
VirtualItemGroups.VirtualItemGroup.Code
VirtualItemGroups.VirtualItemGroup.Middle
VirtualItemGroups.VirtualItemGroup.Revision
VirtualItemGroups.VirtualItemGroup.Name
VirtualItemGroups.VirtualItemGroup.DateEffective
VirtualItemGroups.VirtualItemGroup.DateObsolete
VirtualItemGroups.VirtualItemGroup.ChangeControlled
VirtualItemGroups.VirtualItemGroup.IsUnderChange
VirtualItemGroups.VirtualItemGroup.IsCheckedOut
VirtualItemGroups.VirtualItemGroup.IsLatestRevision
VirtualItemGroups.VirtualItemGroup.IsLatestApprovedRevision
VirtualItemGroups.VirtualItemGroup.IsSuperseded
VirtualItemGroups.VirtualItemGroup.HasPendingChange
VirtualItemGroups.VirtualItemGroup.ApprovalStatus
VirtualItemGroups.VirtualItemGroup.State
VirtualItemGroups.VirtualItemGroup.Remark
VirtualItemGroups.VirtualItemGroup.Synopsis
VirtualItemGroups.VirtualItemGroup.Class.Id
VirtualItemGroups.VirtualItemGroup.Class.Path
VirtualItemGroups.VirtualItemGroup.IsTemplate
VirtualItemGroups.VirtualItemGroup.Namespace.Id
VirtualItemGroups.VirtualItemGroup.InDefaultScope
VirtualItemGroups.VirtualItemGroup.InDefaultVisibleScope
VirtualItemGroups.RelationshipType.Id
VirtualItemGroups.RelationshipType.DerivedFrom.Id
VirtualItemGroups.RelationshipType.DerivedFrom.Code
VirtualItemGroups.RelationshipType.DerivedFrom.Name
VirtualItemGroups.RelationshipType.DerivedFrom.Description
VirtualItemGroups.RelationshipType.LeftType
VirtualItemGroups.RelationshipType.RightType
VirtualItemGroups.RelationshipType.LeftName
VirtualItemGroups.RelationshipType.RightName
VirtualItemGroups.RelationshipType.InDefaultScope
VirtualItemGroups.RelationshipType.InDefaultVisibleScope

Work Tasks

WorkTasks.WorkTask.WorkOrder.Id
WorkTasks.WorkTask.WorkOrder.Code
WorkTasks.WorkTask.WorkOrder.Description
WorkTasks.WorkTask.Id
WorkTasks.WorkTask.Code
WorkTasks.WorkTask.Description
WorkTasks.IsSubjectData


eQL (SELECTseries 7) Help

Help last updated: August 09, 2016
Introduction to eQL
The Parts of an eQL Query
Functions in eQL
Executing Stored Procedures
Search Settings
eQL Elements