Summary

Sometimes you can get more refined results by combining multiple queries. The concatenateQueries() GraphQL query fied can be used to concatenate multiple valid queries into one query. It can also be used to get diagnostic information on the compound query, including suggestions on making improvements.

API Stability Short-Term

Syntax

graphql
concatenateQueries(
     input: ConcatenateQueriesArguments!
   ): QueryConcatenationInfo

For the input, you'd enter the query strings to concatenate. See the Input Parameters section for more. The concatenated query is returned. See the Returned Values section for more on this.

Example

Raw
graphql
query {
	concatenateQueries(input:
      { queryStrings: [ "actor.type=*", 
                        "groupBy([#type,actor.type])" ],
        version: { name: "legacy" } }
  )
  { concatenatedQuery, 
    validationResult { isValid, 
                       diagnostics{ message, code, severity } }
  }
}
Mac OS or Linux (curl)
shell
curl -v -X POST $YOUR_LOGSCALE_URL/graphql \
    -H "Authorization: Bearer $TOKEN" \
    -H "Content-Type: application/json" \
    -d @- << EOF
{"query" : "query {
	concatenateQueries(input:
      { queryStrings: [ \"actor.type=*\", 
                        \"groupBy([#type,actor.type])\" ],
        version: { name: \"legacy\" } }
  )
  { concatenatedQuery, 
    validationResult { isValid, 
                       diagnostics{ message, code, severity } }
  }
}"
}
EOF
Mac OS or Linux (curl) One-line
shell
curl -v -X POST $YOUR_LOGSCALE_URL/graphql \
    -H "Authorization: Bearer $TOKEN" \
    -H "Content-Type: application/json" \
    -d @- << EOF
{"query" : "query {
	concatenateQueries(input:
      { queryStrings: [ \"actor.type=*\", 
                        \"groupBy([#type,actor.type])\" ],
        version: { name: \"legacy\" } }
  )
  { concatenatedQuery, 
    validationResult { isValid, 
                       diagnostics{ message, code, severity } }
  }
}"
}
EOF
Windows Cmd and curl
shell
curl -v -X POST $YOUR_LOGSCALE_URL/graphql ^
    -H "Authorization: Bearer $TOKEN" ^
    -H "Content-Type: application/json" ^
    -d @'{"query" : "query { ^
	concatenateQueries(input: ^
      { queryStrings: [ \"actor.type=*\",  ^
                        \"groupBy([#type,actor.type])\" ], ^
        version: { name: \"legacy\" } } ^
  ) ^
  { concatenatedQuery,  ^
    validationResult { isValid,  ^
                       diagnostics{ message, code, severity } } ^
  } ^
}" ^
} '
Windows Powershell and curl
powershell
curl.exe -X POST 
    -H "Authorization: Bearer $TOKEN"
    -H "Content-Type: application/json"
    -d '{"query" : "query {
	concatenateQueries(input:
      { queryStrings: [ \"actor.type=*\", 
                        \"groupBy([#type,actor.type])\" ],
        version: { name: \"legacy\" } }
  )
  { concatenatedQuery, 
    validationResult { isValid, 
                       diagnostics{ message, code, severity } }
  }
}"
}'
    "$YOUR_LOGSCALE_URL/graphql"
Perl
perl
#!/usr/bin/perl

use HTTP::Request;
use LWP;

my $TOKEN = "TOKEN";

my $uri = '$YOUR_LOGSCALE_URL/graphql';

my $query = "query {
	concatenateQueries(input:
      { queryStrings: [ \"actor.type=*\", 
                        \"groupBy([#type,actor.type])\" ],
        version: { name: \"legacy\" } }
  )
  { concatenatedQuery, 
    validationResult { isValid, 
                       diagnostics{ message, code, severity } }
  }
}";
$query =~ s/\n/ /g;
my $json = sprintf('{"query" : "%s"}',$query);
my $req = HTTP::Request->new("POST", $uri );

$req->header("Authorization" => "Bearer $TOKEN");
$req->header("Content-Type" => "application/json");

$req->content( $json );

my $lwp = LWP::UserAgent->new;

my $result = $lwp->request( $req );

print $result->{"_content"},"\n";
Python
python
#! /usr/local/bin/python3

import requests

url = '$YOUR_LOGSCALE_URL/graphql'
mydata = r'''{"query" : "query {
	concatenateQueries(input:
      { queryStrings: [ \"actor.type=*\", 
                        \"groupBy([#type,actor.type])\" ],
        version: { name: \"legacy\" } }
  )
  { concatenatedQuery, 
    validationResult { isValid, 
                       diagnostics{ message, code, severity } }
  }
}"
}'''

resp = requests.post(url,
                     data = mydata,
                     headers = {
   "Authorization" : "Bearer $TOKEN",
   "Content-Type" : "application/json"
}
)

print(resp.text)
Node.js
javascript
const https = require('https');

const data = JSON.stringify(
    {"query" : "query {
	concatenateQueries(input:
      { queryStrings: [ \"actor.type=*\", 
                        \"groupBy([#type,actor.type])\" ],
        version: { name: \"legacy\" } }
  )
  { concatenatedQuery, 
    validationResult { isValid, 
                       diagnostics{ message, code, severity } }
  }
}"
}
);


const options = {
  hostname: '$YOUR_LOGSCALE_URL',
  path: 'graphql',
  port: 443,
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Content-Length': data.length,
    Authorization: 'BEARER ' + process.env.TOKEN,
    'User-Agent': 'Node',
  },
};

const req = https.request(options, (res) => {
  let data = '';
  console.log(`statusCode: ${res.statusCode}`);

  res.on('data', (d) => {
    data += d;
  });
  res.on('end', () => {
    console.log(JSON.parse(data).data);
  });
});

req.on('error', (error) => {
  console.error(error);
});

req.write(data);
req.end();
Example Responses
Success (HTTP Response Code 200 OK)
json
{
  "data": {
    "concatenateQueries": {
      "concatenatedQuery": "actor.type=*\n| groupBy([#type,actor.type])",
      "validationResult": {
        "isValid": true,
        "diagnostics": []
      }
    }
  }
}

For the input, the arguments given are within curly-brackets. The values for queryStrings is given in square-brackets because it's an array. Incidentally, you can give more than two query strings.

Input Parameters

For the input, you would provide the query strings that you want to string together into one query. This is described below along with the other parameter:

Table: ConcatenateQueriesArguments Input Datatype

ParameterTypeRequiredDefaultStabilityDescription
Some input parameters may be required, as indicated in the Required column. For return values, this indicates that you are assured a value if the field is requested for the results.
Table last updated: Sep 17, 2024
querystrings[string]yes Short-TermThe query strings.
versionLanguageVersionInputTypeyes Short-TermThe language version used. See LanguageVersionInputType.

Returned Values

For the results, there are a couple possible values returned, which are listed below. The one on query validation has some sub-choices — as shown in the example above. In particular, it leads to some diagnostic information that may help you to improve your queries.

Table: QueryConcatenationInfo Datatype

ParameterTypeRequiredDefaultStabilityDescription
Some input parameters may be required, as indicated in the Required column. For return values, this indicates that you are assured a value if the field is requested for the results.
Table last updated: Oct 2, 2024
concatenatedQuerystringyes Short-TermThe result of concatenating the queries.
validationResultQueryValidationInfoyes Short-TermThe validation results. See QueryValidationInfo.