---
title: "Beispiel-Queries"
slug: "beispiel-queries"
updated: 2025-10-15T13:45:38Z
published: 2025-10-15T13:45:38Z
canonical: "docs.vasgard.com/beispiel-queries"
---

> ## Documentation Index
> Fetch the complete documentation index at: https://docs.vasgard.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Beispiel-Queries

## Beispiele für einfache Funktionen

### X-VALUES Wert ist nicht vorhanden

Werden alle Angaben in den **VALUES** Werten gemacht, so enthält der **X-VALUES** Wert keine Informationen.

Es gibt dann auch nur eine Ausgabezeile. Dieser **X-VALUES** Ausdruck kann dann folgendermaßen angegeben werden. Der Wert in den eckigen Klammern darf nicht leer sein.

```plaintext
X-VALUES [1]
```

### Ermitteln der Anzahl der Assets je CI-Klasse

Mit **distinct** werden die einzelnen Assetklassen voneinander getrennt. Mit **count** werden die Assets gezählt.

```plaintext
TYPE 'table'
X-VALUES distinct(assets.*.asset_type) ORDERBY x
VALUES x AS "Asset-Klasse"
VALUES count(assets[asset_type=x].ci_number) AS "Anzahl"
```

### Ermitteln der Anzahl von Hierarchy Dummys je CI-Klasse

Wie bei **Ermitteln der Anzahl der Assets je CI-Klasse** mit extra Zählung von Dummy-Assets.

```plaintext
TYPE 'table'
X-VALUES distinct(assets.*.asset_type) ORDERBY x
VALUES x AS "Asset-Klasse"
VALUES count(assets[asset_type=x].ci_number) AS "Anzahl"
VALUES count(assets[is_hierarchy_dummy=true AND asset_type=x]) as 'davon Dummys'
```

### Ermitteln der Anzahl Assets in der CCDB

```plaintext
TYPE 'table'
X-VALUES ['Assets']
VALUES x as 'Name'
VALUES count(assets) as 'Gesamt'
```

### Ausgabe aller Assets ohne gesetzten Status

Listet alle Assets auf, bei denen kein Status gesetzt ist.

```plaintext
TYPE table
X-VALUES assets[not status exists]
VALUES x AS 'Assets ohne Status'
```

### Ermitteln der Anzahl von Assets mit und ohne Status

Es werden in einer Tabelle die Anzahl aller vorhandenen Assets, der Assets ohne Status und der Assets mit Status angezeigt.

```plaintext
TYPE table
X-VALUES [1]
VALUES count(assets) AS 'Anzahl Assets'
VALUES count(assets[not status exists]) AS 'Status nicht gesetzt'
VALUES count(assets[status exists]) AS 'Status gesetzt'
```

### Ausgaben aller ToDos aus allen Cases mit Case und Status

Listet alle Cases mit ToDos auf **flat** beschränkt die Liste auf die Cases, die ToDos (=remediations) haben.

> [!WARNING]
> Achtung!
> 
> Es werden nur Cases ausgewertet, für die man berechtigt ist.

```plaintext
TYPE 'table'
X-VALUES flat(cases[remediations.status exists].remediations)
VALUES x.case.name AS 'Case Name'
VALUES x.name AS 'ToDo Name'
VALUES x.description AS 'Beschreibung'
VALUES x.status AS 'Status'
```

### Alle nicht geschlossenen Maßnahmen mit Fristdatum, sortiert nach Frist

Hier werden Hierarchie Dummies ignoriert.

```plaintext
TYPE 'table'
X-VALUES assets[asset_type='Measure' AND (status != 'Closed') AND ((NOT(is_hierarchy_dummy=true)) OR (NOT(is_hierarchy_dummy exists)))] ORDERBY x.deadline
VALUES x.name as Name
VALUES x.status as Status
VALUES format_date(x.deadline, '%d.%m.%y') AS Frist
```

### Ausgabe aller Tickets mit Informationen

```plaintext
TYPE 'table'
X-VALUES tickets ORDERBY x.created_at
VALUES x.subject AS 'Betreff'
VALUES x.status AS 'Status'
VALUES x.created_by AS 'erstellt von'
VALUES x.priority AS 'Prio'
VALUES x.ticket_type AS 'Ticket-Typ'
VALUES format_date(x.created_at, '%d.%m.%y') AS 'Datum'
```

### Zählen von Ergebnissen in einem bestimmten Case

Beispiel für die Funktion **count_equals()**:

```plaintext
TYPE 'table'
X-VALUES cases[name='ISMS RA'].evaluations
VALUES count_equals(x.eval_result, 'MISS') AS 'MISS'
VALUES count_equals(x.eval_result, 'FAIL') AS 'FAIL'
VALUES count_equals(x.eval_result, 'PARTIAL') AS 'PARTIAL'
VALUES count_equals(x.eval_result, 'PASS') AS 'PASS'
VALUES count_equals(x.eval_result, 'N/A') AS 'N/A'
```

### Beispiel für defaults

Beispiel für den Einsatz von **defaults** an Hand der Berechnung der Summe von Risiken:

```plaintext
TYPE 'table'
X-VALUES [1]
VALUES sum(defaults((assets[asset_type='IR_Field'].risk_value),0)) AS 'Summe'
```

### Anforderungen in einem bestimmten Case mit Ergebnis

```plaintext
TYPE 'table'
X-VALUES flat(cases[name='CAIQ 3.01 - Zoom'].evaluations) ORDERBY
x.requirement.name
VALUES x.requirement.name AS 'Anforderung'
VALUES x.eval_result AS 'Ergebnis'
```

### Benutzung der Result-Spalte zum Anzeigen, ob es Nachfolger gibt

Die Ergebnisse in der Result-Spalte werden nur im generierten Bericht grün oder rot.

```plaintext
TYPE 'table'
X-VALUES assets[asset_type='Process' AND (not(successors exists)) AND
(start_delivery exists)] ORDERBY x.start_delivery
VALUES x AS 'Prozess'
VALUES column_type='result' if_greaterorequals(now(),
date(x.start_delivery)+timespan(months=1),'FAIL', 'PASS') AS 'Neu (<1 Monat)'
VALUES x.start_delivery AS 'Startdatum'
```

## Beispiele für die Formatierung von Zahlen und Daten

### Formatierung von Zahlen mit format_number

```plaintext
TYPE 'table'
X-VALUES [1,2,3,(5.5),4000,5000]
VALUES x
VALUES format_number(x, decimals=2) AS '2 Nachkommastellen'
VALUES format_number(x, dot='.') AS 'Punkt'
VALUES format_number(x, grouping=3, dot='.') AS '3er Gruppe mit Punkt'
VALUES format_number(x, grouping=2, dot=';') AS '2er Gruppe mit Semikolon'
```

### Zählen von noch offenen Anforderungen in einem Case und Ausgabe in Prozent

Beispiel dafür, wie man mit gezählten Ergebnissen rechnen kann (letzte Zeile). Zur besseren Lesbarkeit wird das Ergebnis auf zwei Stellen hinter dem Komma gekürzt.

```plaintext
TYPE 'table'
X-VALUES cases[name='CAIQ 3.01 - Zoom'].evaluations
VALUES count(x.eval_result) AS 'Gesamt'
VALUES count_nonequals(x.eval_result, 'MISS') AS 'schon bearbeitet'
VALUES format_number(count_nonequals(x.eval_result, 'MISS') * 100 /
count(x),decimals=2) AS '% bearbeitet'
```

### Ausgabe in einer Tabelle durch Ersetzung der Werte kürzen

```plaintext
TYPE 'table'
X-VALUES assets[asset_type='Process' and (own_level_confidentiality exists) ]
VALUES x.display_name as 'name'
VALUES x.own_level_confidentiality as 'C'
VALUES x.own_level_integrity as 'I'
VALUES x.own_level_availability as 'A'
VALUES x.own_level_confidentiality + ' / ' + x.own_level_integrity + ' / ' + x.own_level_availability AS 'CIA lang'
VALUES if_equals(x.own_level_confidentiality, '0 - Keine Auswirkung', '0',
if_equals(x.own_level_confidentiality, '1 - Geringe Auswirkungen', '1',
if_equals(x.own_level_confidentiality, '2 - Mittlere Auswirkungen', '2',
if_equals(x.own_level_confidentiality, '3 - Schwere Auswirkungen', '3', '')))) + ' - ' +
if_equals(x.own_level_integrity, '0 - Keine Auswirkung', '0',
if_equals(x.own_level_integrity, '1 - Geringe Auswirkungen', '1',
if_equals(x.own_level_integrity, '2 - Mittlere Auswirkungen', '2',
if_equals(x.own_level_integrity, '3 - Schwere Auswirkungen', '3', '')))) + ' - ' +
if_equals(x.own_level_availability, '0 - Keine Auswirkung', '0',
if_equals(x.own_level_availability, '1 - Geringe Auswirkungen', '1',
if_equals(x.own_level_availability, '2 - Mittlere Auswirkungen', '2',
if_equals(x.own_level_availability, '3 - Schwere Auswirkungen', '3', '')))) AS 'CIA kurz'
```

## Beispiele für das Rechnen mit Daten

### Ausgabe aller Prozesse, die vor mindestens einem Monat gestartet sind

> [!WARNING]
> Achtung:
> 
> - now() + timespan(months=1): Jetzt in einem Monat
> - now() + timespan(month=1): Datum von heute, der Wert des Monats wird auf den ersten Monat dieses Jahres gesetzt (Januar)

```plaintext
TYPE 'table'
X-VALUES assets[asset_type='Process' AND
(start_delivery<(now()-timespan(months=1)))]
VALUES x
```

```plaintext
TYPE 'table'
X-VALUES assets[asset_type='Process'] limit 10
values now() + timespan(months=1)
values now() + timespan(month=1)
```

### Bearbeitungszeit eines Risikos ausrechnen von geöffnet bis geschlossen

Beispiel für das Rechnen mit Daten.

```plaintext
TYPE 'table'
X-VALUES assets[asset_type='Risk' AND (closed_at exists)]
VALUES x.display_name AS 'Risiko'
VALUES format_date(x.identified_date, '%d.%m.%y') AS 'Geöffnet am'
VALUES format_date(x.closed_at, '%d.%m.%y') AS 'Geschlossen am'
VALUES date(x.closed_at) - date(x.identified_date) AS 'Bearbeitungszeit'
```

### Auswertung auf letztes Änderungsdatum von Assets der Klasse 'Business_Partner'

Das Datum im Attribut **date_of_last_change** sieht fast aus wie ein Datum, ist aber ein String. Deshalb ist die Funktion **date** erforderlich, um mit den Daten rechnen zu können:

```plaintext
TYPE 'table'
X-VALUES assets[asset_type='Business_Partner' ] orderby x.date_of_last_change
VALUES x.display_name
VALUES x.date_of_last_change
VALUES date(x.date_of_last_change)
VALUES if_greaterorequals(date(x.date_of_last_change), date('2021-01-01'), 'neu', 'alt') as 'if >= 2021-01-01'
```

## Beispiele für komplexe VALUES-Audrücke

### Ausgabe aller Ansprechpartner mit zugehöriger Firma und E-Mail Adresse

Das folgende Beispiel ermittelt **Kontaktpersonen**, die zu Kunden (=Customer) oder Geschäftspartner/ Lieferanten (=Business Partner) gehören.

Zu der **Contact Person**, die im **X-VALUES** bestimmt wird, wird in den letzten beiden Zeilen die Firma herausgesucht. In der vorletzten Zeile ist die Firma ein Kunde; in der letzten Zeile ist die Firma ein Geschäftspartner/Lieferant.

```plaintext
TYPE 'table'
X-VALUES assets[asset_type='Contact_Person']
VALUES x.name as 'Name'
VALUES x.first_name as 'Vorname'
VALUES x.last_name as 'Nachname'
VALUES x.email as 'Email'
VALUES x.address as 'Adresse'
VALUES assets[(asset_type='Customer') and (contact_persons contains [{'contact': x.uuid}])].display_name as 'Firma (Kunde)'
VALUES assets[(asset_type='Business_Partner') and (contact_persons contains [{'contact': x.uuid}])].display_name as 'Firma (Lieferant)'
```

### Balkendiagramm der Schwachstellen aller Assets nach Status

Es wird kein Filter im **X-VALUES** genutzt, weil über count die Assets in den **VALUES** Werten gezählt werden.

```plaintext
TYPE 'bar' colors=['purple', 'red', 'orange', 'yellow']
X-VALUES ['Assets']
VALUES count(assets[vuln_status.0.vuln_number_critical > 0]) AS 'critical'
VALUES count(assets[vuln_status.0.vuln_number_high > 0]) AS 'high'
VALUES count(assets[vuln_status.0.vuln_number_medium > 0]) AS 'medium'
VALUES count(assets[vuln_status.0.vuln_number_low > 0]) AS 'low'
```

### Ausgeben aller Teilnehmer einer Schulung

Assets der Klasse **Training** werden gesucht und auf den Namen ISMS gefiltert. Dann wird eine Liste mit allen Teilnehmern erstellt. Die Funktion **flat** macht die Liste für eine Ausgabe zugänglich.

In der letzten Zeile wird der Filter aus dem **X-VALUES** umgeschrieben und geändert, um an die Firma der Teilnehmer zu gelangen.

```plaintext
TYPE 'table'
X-VALUES flat(assets[asset_type='Training' AND (display_name contains 'ISMS')].participants)
VALUES lookup_displayname(x.participant) AS 'Teilnehmer'
VALUES if_equals(x.successful, true, 'Bestanden', if_equals(x.successful, false, 'Durchgefallen', 'Nicht teilgenommen')) AS 'Ergebnis'
VALUES format_date(x.participate_date,'%d.%m.%y') AS 'Datum der Prüfung'
VALUES assets[asset_type='Employee' AND (uuid = x.participant)].company.display_name AS 'Firma des Teilnehmers'
```

Die Ergebnisse und Namen können auch kombiniert werden (Konkatenation von Strings):

```plaintext
TYPE 'table'
X-VALUES flat(assets[asset_type='Training' AND (display_name contains 'ISMS')].participants)
VALUES lookup_displayname(x.participant) + ' / ' + if_equals(x.successful, true, 'Bestanden', if_equals(x.successful, false, 'Durchgefallen', 'Nicht teilgenommen')) AS 'Teilnehmer / Ergebnis'
VALUES format_date(x.participate_date,'%d.%m.%y') AS 'Datum der Prüfung'
VALUES assets[asset_type='Employee' AND (uuid = x.participant)].company.display_name AS 'Firma des Teilnehmers'
```

Die Auswertung geschieht hier auf zwei Wegen. Der erste Weg nutzt **if_equals**, während der zweite Weg die Funktionen **default()** und **map()** nutzt:

```plaintext
TYPE 'table'
X-VALUES flat(assets[asset_type='Training' AND (display_name contains 'ISMS')].participants)
VALUES lookup_displayname(x.participant) AS 'Teilnehmer'
VALUES if_equals(x.successful, true, 'Bestanden', if_equals(x.successful,false, 'Durchgefallen', 'Nicht teilgenommen')) AS 'if_equals'
VALUES default(map(x.successful, {true:'Bestanden', false:'Durchgeknallt'}), 'n/a') AS 'default(map())'
```

### Beispiel für viele Funktionen in einer Query

```plaintext
TYPE 'table'
X-VALUES assets[asset_type= 'Risk' AND (NOT(status='Vermieden')) AND (NOT(status='Nicht relevant')) AND (current_deadline<(now()+timespan(months=4)))]
VALUES format_date(now(), '%d.%m.%y') AS 'Erstellungsdatum'
VALUES x.display_name AS 'Nummer'
VALUES x.description AS 'Bezeichnung'
VALUES format_array(x.responsible.full_name, ' / ', '') AS 'Verantwortlich'
VALUES if_equals(x.risk_matrix, 'Green', 'Grün', if_equals(x.risk_matrix, 'Yellow', 'Gelb', if_equals(x.risk_matrix, 'Red', 'Rot', x.risk_matrix))) AS 'Indikator'
VALUES format_number(x.risk_value, dot='.') AS 'Risiko'
VALUES format_date(x.current_deadline, '%d.%m.%y') AS 'Umsetzungsfrist'
VALUES x.prolongation_count AS 'Anzahl Prolongationen'
VALUES format_date(min(x.prolongations.original_deadline), '%d.%m.%y') AS 'ursprüngliche Umsetzung'
VALUES x.status AS 'Status'
```

Ein ISMS (Informationssicherheits-Managementsystem) ist ein systematischer Ansatz, um die Informationssicherheit in einem Unternehmen zu gewährleisten. Es umfasst Richtlinien, Verfahren und technische sowie organisatorische Maßnahmen, die darauf abzielen, Vertraulichkeit, Integrität und Verfügbarkeit von Informationen zu schützen. Dazu gehört die kontinuierliche Identifikation, Bewertung und Behandlung von Risiken sowie die fortlaufende Verbesserung des Sicherheitsniveaus.