API Stability Short-Term

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.

For more information on writing queries, see the Write Queries page in the main documentation.

Syntax

graphql
concatenateQueries(
     input: ConcatenateQueriesArguments!
   ): QueryConcatenationInfo

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

Example

Here's an example of this query in use:

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.

Given Datatype

This given datatype has two parameters. The key one is used to provide the query strings that you want to string together into one query. This is described below along with the other parameter:

Table: ConcatenateQueriesArguments

ParameterTypeRequiredDefaultStabilityDescription
Some arguments may be required, as indicated in the Required column. For return datatypes, this indicates that you must specify which fields you want returned in the results.
Table last updated: Sep 17, 2024
querystrings[string]yes Short-TermThe query strings.
versionLanguageVersionInputTypeyes Short-TermThe language version used. See LanguageVersionInputType.

Returned Datatype

For the returned datatype, 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. Be sure to click on the link to its table of parameters.

Table: QueryConcatenationInfo

ParameterTypeRequiredDefaultStabilityDescription
Some arguments may be required, as indicated in the Required column. For return datatypes, this indicates that you must specify which fields you want returned in the results.
Table last updated: Oct 2, 2024
concatenatedQuerystringyes Short-TermThe result of concatenating the queries.
validationResultQueryValidationInfoyes Short-TermThe validation results. See QueryValidationInfo.