Unlock a world of possibilities! Login now and discover the exclusive benefits awaiting you.
By reading the Product Innovation blog, you will learn about what's new across all of the products in our growing Qlik product portfolio.
The Support Updates blog delivers important and useful Qlik Support information about end-of-product support, new service releases, and general support topics.
This blog was created for professors and students using Qlik within academia.
Hear it from your Community Managers! The Community News blog provides updates about the Qlik Community Platform and other news and important announcements.
The Qlik Digest is your essential monthly low-down of the need-to-know product updates, events, and resources from Qlik.
The Qlik Learning blog offers information about the latest updates to our courses and programs, as well as insights from the Qlik Learning team.
企業のビジネス活動において、データはこれまで以上に必要不可欠な資産となっています。増え続けるデータを管理・統合・分析し、データでアクションを起こす必要性が増している現在、成功している企業はどのようなデータ戦略を実行しているのか?
本 Web セミナーシリーズでは、Qlik でデータからアクションを起こすデータ主導のビジネスで成功しているお客様より、課題から導入の経緯、デモンストレーション、活用例などをご紹介します。
データはあるがどう活かせば良いかわからない、もっと組織の壁を越えてデータを活用したいなど、データの持つ可能性に気づいているが故に多くの方が悩みを抱えていると思います。
スズキ株式会社では、さまざまな部門でデータ活用が進んでいます。その中の1つである海外営業部門では、海外拠点の膨大なデータを収集して可視化。ユーザー自身がデータを分析し、売上状況や在庫管理に活用しています。いかにして部門や国をまたいだデータ活用の機運が高まったのか。Qlik Sense の導入経緯や活用例、課題の克服など、デモを交えてご紹介します。また、Qlik 技術担当者との対談では、技術面や社内の活用状況などを詳しくお伺いします。
When using Enigma.js to communicate with the Qlik Associative Engine to build visualizations for instance or simply to get access to data from Qlik Sense, you will certainly come across the concept of Generic Objects, which are structures for storing and interacting with data in an application. They are considered generic because of they are flexible structures that can represent many different app components such as sheets, bookmarks, hypercubes, lists etc..
In this blog post, we will go over Hypercubes and List Objects providing a brief explanation of the concepts and how to use them with enigma.js
In Qlik Sense, a Hypercube is an interface for defining a set of data to extract. It is the definition provided to the Qlik Data Engine, which holds all information on which data is queried and how it’s calculated. If selections are applied to a Hypercube, only the selected values will be returned.
For example, this can represent data needed to display some type of visualization such as a bar chart that shows “Sum of Sales” by “Salesperson”. At its simplest form, you can think of it as a table comprised of rows and columns. In that sense, our Hypercube that would power our barchart, would consist of a table with “Salesperson” as a column, and the evaluated “Sum(Sales)” expression as the other column. The engine will fill the cells of this table and extract all the information.
In order to use a Hypercube, we need to define it through the “qHyperCubeDef” object which is passed on to the Qlik Engine API to create a query for processing the data.
A very simple definition of a Hypercube looks like this:
qHyperCubeDef: {
qDimensions: [],
qMeasures: [],
qInitialDataFetch: [{
qWidth: 2,
qHeight: 50
}]
}
But since it is a very flexible tool of extracting data, that means that there is a huge amount of settings available for it. You can view the full definition of the structure here.
Let’s go over the most important ones:
Below is an example of a Hypercube where we define 1 dimension (ID) and 1 measure (=Sum(Value)), Notice that we define qWidth and qHeight properties within qInitialDataFetch as 2 and 5 respectively, since we have 2 columns and would like to get 5 rows of data for a total of 10 cells.
P.S: The maximum number of cells (qWidth * qHeight) allowed in an initial data fetch is 10,000.
const properties = {
qInfo: {
qType: 'my-straight-hypercube',
},
qHyperCubeDef: {
qDimensions: [
{
qDef: { qFieldDefs: ['ID'] },
},
],
qMeasures: [
{
qDef: { qDef: '=Sum(Value)' },
},
],
qInitialDataFetch: [
{
qHeight: 5,
qWidth: 2,
},
],
},
};
So how does the implementation look like in enigma.js?
For the purposes of this example, we are creating a Session App (i.e: have an inline script and create an app on the fly).
const qlikScript = `
TempTable:
Load
RecNo() as ID,
Rand() as Value
AutoGenerate 100
`;
const properties = {
qInfo: {
qType: 'my-straight-hypercube',
},
qHyperCubeDef: {
qDimensions: [
{
qDef: { qFieldDefs: ['ID'] },
},
],
qMeasures: [
{
qDef: { qDef: '=Sum(Value)' },
},
],
qInitialDataFetch: [
{
qHeight: 5,
qWidth: 2,
},
],
},
};
const session = createSession();
// Open the session and create a session document:
session.open()
.then((global) => global.getActiveDoc())
.then((doc) => doc.setScript(qlikScript)
.then(() => doc.doReload())
// Create a generic object with a hypercube definition containing one dimension and one measure
.then(() => doc.createObject(properties))
// Get hypercube layout
.then((object) => object.getLayout()
.then((layout) => console.log('Hypercube data pages:', JSON.stringify(layout.qHyperCube.qDataPages, null, ' ')))
// Select cells at position 0, 2 and 4 in the dimension.
.then(() => object.selectHyperCubeCells('/qHyperCubeDef', [0, 2, 4], [0], false))
// Get layout and view the selected values
.then(() => console.log('\n### After selection (notice the `qState` values):\n'))
.then(() => object.getLayout().then((layout) => console.log('Hypercube data pages after selection:', JSON.stringify(layout.qHyperCube.qDataPages, null, ' '))))))
// Close the session
.then(() => session.close())
.catch((error) => {
console.log('Session: Failed to open socket:', error);
process.exit(1);
});
Notice that after opening the enigma session, and calling the necessary methods for our session app, we call “createObject” to create a Generic Object with our Hypercube definition containing 1 dimension and 1 measure, then get the Hypercube Layout which returns a bunch of results including our data.
We’re mostly interested in “qDataPages” which holds our calculated data. Below is how the typical response looks like:
Going back to our code, the full qDataPages results are as follows from our first console.log:
Hypercube data pages: [
{
"qMatrix": [
[
{
"qText": "1",
"qNum": 1,
"qElemNumber": 0,
"qState": "O"
},
{
"qText": "0.73213545326144",
"qNum": 0.732135453261435,
"qElemNumber": 0,
"qState": "L"
}
],
[
{
"qText": "2",
"qNum": 2,
"qElemNumber": 1,
"qState": "O"
},
{
"qText": "0.66564685385674",
"qNum": 0.6656468538567424,
"qElemNumber": 0,
"qState": "L"
}
],
[
{
"qText": "3",
"qNum": 3,
"qElemNumber": 2,
"qState": "O"
},
{
"qText": "0.66189019801095",
"qNum": 0.6618901980109513,
"qElemNumber": 0,
"qState": "L"
}
],
[
{
"qText": "4",
"qNum": 4,
"qElemNumber": 3,
"qState": "O"
},
{
"qText": "0.98009621817619",
"qNum": 0.9800962181761861,
"qElemNumber": 0,
"qState": "L"
}
],
[
{
"qText": "5",
"qNum": 5,
"qElemNumber": 4,
"qState": "O"
},
{
"qText": "0.48425585823134",
"qNum": 0.4842558582313359,
"qElemNumber": 0,
"qState": "L"
}
]
],
"qTails": [
{
"qUp": 0,
"qDown": 0
}
],
"qArea": {
"qLeft": 0,
"qTop": 0,
"qWidth": 2,
"qHeight": 5
}
}
]
Notice that we have additionally called the “selectHyperCubeCells” method in order to make a selection on the cells at positions 0, 2, and 4 in the Dimension. Here is how the results of qDataPages looks like after the selection:
### After selection (notice the `qState` values):
Hypercube data pages after selection: [
{
"qMatrix": [
[
{
"qText": "1",
"qNum": 1,
"qElemNumber": 0,
"qState": "S"
},
{
"qText": "0.73213545326144",
"qNum": 0.732135453261435,
"qElemNumber": 0,
"qState": "L"
}
],
[
{
"qText": "3",
"qNum": 3,
"qElemNumber": 2,
"qState": "S"
},
{
"qText": "0.66189019801095",
"qNum": 0.6618901980109513,
"qElemNumber": 0,
"qState": "L"
}
],
[
{
"qText": "5",
"qNum": 5,
"qElemNumber": 4,
"qState": "S"
},
{
"qText": "0.48425585823134",
"qNum": 0.4842558582313359,
"qElemNumber": 0,
"qState": "L"
}
]
],
"qTails": [
{
"qUp": 0,
"qDown": 0
}
],
"qArea": {
"qLeft": 0,
"qTop": 0,
"qWidth": 2,
"qHeight": 3
}
}
]
Alongside qHyperCube, the family of Generic Objects provides us with another structure called qListObject.
Unlike a Hypercube, a List Object better serves the purposes of displaying one single dimension without any required calculation, meaning no metrics are required to be defined.
As such, it is fairly straightforward to work the list objects, and their definition is very similar to the qHyperCube object, with some added extra properties minus measures.
I usually use List Objects when I want to build a list of values to be used for selections.
The following code is an example of creating a qListObjectDef and writing the resulting list object into the console:
List object data: [
[
{
"qText": "0.063513102941215",
"qNum": 0.06351310294121504,
"qElemNumber": 0,
"qState": "O"
}
],
[
{
"qText": "0.15987460175529",
"qNum": 0.15987460175529122,
"qElemNumber": 1,
"qState": "O"
}
],
[
{
"qText": "0.50091209867969",
"qNum": 0.5009120986796916,
"qElemNumber": 2,
"qState": "O"
}
]
]
After selection of the first value, the qDataPages response looks like the following:
(Notice that with a qListObject, all values are rendered, regardless of whether they have been excluded or not.If selections are applied to a list object, the selected values are displayed along with the excluded and the optional values. We do however hava access to the qState property which lets us know if the value is selected (S), alternate (A), etc..)
List object data: [
[
{
"qText": "0.063513102941215",
"qNum": 0.06351310294121504,
"qElemNumber": 0,
"qState": "S"
}
],
[
{
"qText": "0.15987460175529",
"qNum": 0.15987460175529122,
"qElemNumber": 1,
"qState": "A"
}
],
[
{
"qText": "0.50091209867969",
"qNum": 0.5009120986796916,
"qElemNumber": 2,
"qState": "A"
}
]
]
Attached is a zip file containing example code that shows how a default Hypercube, Pivot Hypercube, Stacked Hypercube, and a List Object are used in enigma.js.
To run the code:
To see how Hypercube can be used as part of creating visualizations with Nebula.js, checkout my previous blog post: https://community.qlik.com/t5/Qlik-Design-Blog/Create-a-Slope-chart-with-tooltips-and-brushing-using-Nebula-js/ba-p/1827168

Reduction of turnover, reduction of absences, reduction of overtime, payroll spending planning, benefits management, decentralized management!!!

Decentralized Management of People and Benefits! Budget management and Payroll planning!

Hour control; Benefits Control; Fair management;

Reduction of overtime; Control and monitoring of hiring new employees; Reduction in hiring expenses!!!
I am pleased to introduce Angel Monjaras as the Qlik Educator Ambassador for 2024! Angel is a Professor of Business Intelligence at Instituto Tecnologico Autonomo De Mexico (ITAM), where he’s been using Qlik in his teaching for seven years.
For this year’s iteration of his course, he is debuting a BI Best Practices Catalog on Qlik Sense that will enable students to find the most common metrics and dimensions for each business area and / or industry.
According to Angel, “This will free up class time to delve into Data Literacy and AI topics that will help students feel comfortable speaking about data, and help them stay grounded and focus on real issues and solutions, instead of jumping on the many bandwagons, buzzwords, and false promises headed their way.”
While he’s always integrated Qlik software, the past couple of years, he started to integrate some of the learning exercises from the Qlik Academic Program, “Students perform various exercises and homework, including regression analysis, visualization best practices, common visualization pitfalls, and data quality. They also design a dashboard from scratch as part of a practical course-long BI project. We use some exercises taken from QCC and the Data Analytics Curriculum, since they provide good sample data.”
Angel’s passion for Qlik goes beyond his own classroom, he has been introducing new educators from Universidad Nacional Autónoma de México, and other universities to Qlik. Angel has conducted introductory workshops for students. Angel plans to share his knowledge even further this year, by continuing to conduct open workshops for any student at his university to join.
Angel is a 2024 Qlik Luminary and will host a session in Qlik Connect this year: “C40: Taking our world-changing work to the next level with Qlik Cloud”
For Angel, one of the most rewarding parts of teaching Qlik has been seeing his students leave university and get jobs, become Qlik customers, and even fellow professors.
Educators and students can get access to free Qlik software and training resources, qualifications and certifications by applying to the Academic Program today: qlik.com/academicprogram
Our Instant Sense Application allows any data set to be uploaded and analysed. Even relatively simple datasets, like this one, can yield interesting discoveries. Perhaps the most striking thing is the large gap between the top seven players and the rest of the pack. The other thing is how the very top female players beat the top male players on many different measures.
As sports are divided into male and female competitions the data are often displayed and considered separately. By loading the data from two different sources and blending them a combined view can be given. Colouring the data by the competition dimension makes the achievements of the female players stand out.
The important thing when bringing data and analytics to people is to bring them data that they can engage with. Sometimes the simplest of data sources can be best at telling a story and drawing people in. Once those users have got used to navigating a simple dataset on a topic that interests them they will be ready to engage with the business data that can give them the edge.
Our Instant Sense Application is free to download and use and can be used over any dataset. It's a great way to provide a proof of concept and to quickly discover which measures are worth tracking. It ships with a number of scripts that are generally useful, such as Qlik Session Monitors and QVD Profiling, as well as scripts to load from online sources like this one.
Hello Qlik Users,
Beginning on April 22nd 2024, Qlik Cloud will change how the font sizes for titles, subtitles, and footnotes are displayed. The change will carry over to Qlik Sense Enterprise on Windows with its May 2024 release.
Font sizes for titles, subtitles, and footnotes are controlled by either:
The conversion factor Qlik uses at present is incorrect, caused by a defect introduced by a previous change in a base font type.
What does this mean?
Currently, we convert using 13 as a base when we should be using 14. This results in the font size being slightly larger than the one set by the user.
The current scaling ratio is 1/13 * 14 =~ 1.077.
As an example:
The default theme Horizon, currently set to a 16-pixel default size, is in reality using 17.23 pixels.
Since we use other technologies to embed charts, we don’t want to replicate this error across all interfaces just to get matching title sizes. This means that we’ll now fix this defect, and start using the correct font size.
The fix is planned for Qlik Cloud on April 22nd 2024.
Qlik Sense Enterprise on Windows will receive the fix in its May 2024 release.
After the fix is deployed, the text in titles, subtitles and footnotes will appear smaller (about 93% of the current size), reverting to the intended size set by the user or the theme developer.
Since this will free up a small amount of space inside each object area, charts and graphics will become slightly bigger.
In rare scenarios, the resulting expansion might result in a different look for charts, where certain features (like labels or legends) appear, move or disappear due to the reaching of specific visual breakpoints.
No action is required for Qlik Cloud users. This change will automatically be applied to all the dashboards at the time of deployment. Qlik Sense Enterprise on Windows users will need to see their platform being upgraded to May 2024.
Can I preview the changes?
A preview is not possible before the deployment on April 22nd.
We're available for questions if needed! As always, thank you for choosing Qlik,
Qlik Support
As noted in Qlik’s 2024 industry trends – Hybrid AI Bridges the Maturity Gap, it’s critical to take a portfolio approach to AI – one that leverages both generative and predictive AI to solve a full breadth of problems. According to the Boston Consulting Group, generative AI is only expected to achieve ~30% share of the overall AI market by 2024. So in two year's time traditional machine learning will still represent the majority of the AI market. And there’s a reason for this – because traditional ML delivers highly actionable, accurate predictions for specific use-cases that can drive improved outcomes across your business and tremendous value.
For those of us who want to go beyond the out-of-the-box capabilities of Qlik Sense and want to leverage the full potential of the platform to create complex visualizations or satisfy custom development needs, understanding the Engine API is fundamental to taking advantage of what Qlik Sense hides under the hood.
The Qlik Engine API is a websocket protocol that uses JSON RPC 2.0 to communicate between the Qlik Associative Engine and clients. It works independently of any platform and programming language as long as it supports WebSockets and can parse JSON.
A great place to get your feet wet with trying out the Engine API is through Qixplorer (You might remember this as the Engine API Explorer on Qlik Managed). The tool that you can access at https://qixplorer.qlik.dev features a newly reimagined user interface and additional updates for a better experience.
Right off the bat, you can see that the format is divided into 4 main sections:
Other settings include a Light/Dark mode toggle at the top left, as well as a Layout toggle that lets you switch between the Original Layout (side by side request and response sections) or, my favorite, the Chat Layout.
The first thing you would need to create a new connection to your Qlik Cloud tenant is a Web Integration ID. You can grab that by going to your tenant’s Management Console, under Web, Create a new integration and add https://qixplorer.qlik.dev as an origin.
Once you have the generated ID in hand, create a new connection on Qixplorer as shown below:
The next step is to choose the app you want to connect to from the second dropdown.
Once you select that, you will see that a first request and response have been made automatically. That’s the “OpenDoc” method, it is responsible for opening an app. More about it here.
Notice that a few items are now highlighted on the Left panel that you can start using - including the Doc and Global classes that can be expanded to reveal all the methods you can execute. You can also use the pre-defined Macros to list sheets, dimensions etc...
⚠️Before we continue, keep in mind that when using Qixplorer, you are performing changes directly on your apps, so when executing API methods to update or delete within Qixplorer, it will affect the objects in your apps.
From the Macros dropdown, click on “ListSheets”.
Notice that the Request section at the bottom has our generated JSON with the methods needed to list sheets.
Click on Execute and view the JSON returned in the Response section.
P.S: notice that two separate requests have been made by our Macro: CreateSessionObject and GetLayout.
Let’s create an App in our tenant directly from Qixplorer.
First, select the “CreateApp” method from the Global dropdown.
Notice that the right panel has been populated with the inline documentation for our method. This makes it really convenient to view the definition and parameters at a glance.
Within the Request section that now contains the editable JSON, enter a name for the app we’re creating in the “qAppName” property.
Our request and response look like this:
{
"handle": -1,
"method": "CreateApp",
"params": {
"qLocale": "",
"qLocalizedScriptMainSection": "",
"qAppName": "test-qixplorer"
}
}
You can check your tenant to view the newly created app:
Let’s retrieve the calculated data from a Table object in our app.
First, we need to get the object. Under ”Doc”, scroll down to GetObject and change the “qId” property to our Table's object id.
Now that we got the object, you can go to ”GenericObject”, then “Select Object” and click on table.
Next, scroll down to the “GetHyperCubeData” method under “GenericObject” and modify the JSON as follows to set the qHeight (number of rows to retrieve) and qWidth (number of columns)
{
"handle": 2,
"method": "GetHyperCubeData",
"params": {
"qPages": [
{
"qHeight": 1000,
"qWidth": 5,
"qTop": 0,
"qLeft": 0
}
],
"qPath": "/qHyperCubeDef"
}
}
Click on execute and examine the response:
The Engine API is without a doubt very powerful as it exposes methods that can be used to tap directly into the associative engine and manipulate complex data structures. Having a tool like Qixplorer is a great way to try out the API and learn more about all the methods available in a single place.
Let me know in the comments how you use Qixplorer on you end!