1 2 3 Previous Next

Qlik Design Blog

414 posts

What is Advanced Analytics?

 

Gartner defines Advanced Analytics as:

 

The autonomous or semi-autonomous examination of data or content using sophisticated techniques and tools, typically beyond those of traditional business intelligence (BI), to discover deeper insights, make predictions, or generate recommendations.

 

What resonates with me here are the key words "sophisticated techniques and tools" - these can mean statistical analysis environments, (perhaps R), or general purpose and machine learning program languages (Python / MATLAB) or even specific operations used for pattern search (regex), just to name a few. So what does this have to do with Qlik? Well, let's say you have an investment in R, Python, MATLAB or even something custom you created for your advanced analytics activities. You may want to reuse or apply algorithms from those systems to data available in your Qlik environment, taking advantage of Qlik's associative model as well - how would you do that? Previously, you might have to export the data from those systems and then import and associate it within Qlik. Well not any longer now that we have Qlik Advanced Analytics Integration.


What is Qlik Advanced Analytics Integration?


7-20-2017 5-40-37 PM.png

Architecture

 

Simply put, Qlik Advanced Analytics Integration (AAI) enables direct server to server data exchange between Qlik Sense and 3rd party calculation / analysis engines via a connector or what we also call a plugin. So for example, a specific forecasting function that is part of an R library can now be called from within Qlik script and chart expressions and calculated on the fly. Passing the results back to the Qlik analysis engine and subsequent visualizations.

aa1.gifi.e. - Holt-Winters Forecast / K-means Clustering - running on R

 

With the release of Qlik Sense June 2017, Qlik specifically now supports the APIs that can provide connectivity to such engines. Allowing you to build virtually any connector to any system. The Qlik Sense engine is also now aware of specific expressions to directly call the 3rd party engine via these connectors. To kick things off we have provided two open source connector projects that enable connectivity to R and Python. (there are compiled binaries for R available here)

 

To learn more about Qlik Advanced Analytics Integration, join the conversation and obtain resources and community support please visit the Advanced Analytics Integration forum.

 

Take a look at this 60 second video that provides a quick overview of Qlik Advanced Analytics Integration:

 

 

 

 

NOTE: To increase resolution or size of the video, select the YouTube logo at the bottom right of the player. You will be brought directly to YouTube where you can increase the resolution and size of the player window. Look for the 'settings' gears icon in the lower right of the player once at YouTube.

 

Regards,

Michael Tarallo (@mtarallo) | Twitter

Qlik

 

Can't see the video?

 

Download the .mp4 and watch from your computer or mobile device.

Yianni Ververis

Trello and Qlik Sense

Posted by Yianni Ververis Jul 21, 2017

Are you a Trello user and want to start integrating your cards with Qlik Sense and getting some statistical analysis out of your projects' workflow? Here I will show you how to connect to you boards and get your lists and cards into Qlik Sense.

 

First, you need to have a developer’s key and an authorization token, both generated for you by trello.com.

  • To get you Key you need to go to https://trello.com/app-key
  • To get your Auth token, at the same page, right under your key, there is a link "Token". Click on that and it will take to a page that asks you "Let Server Token use your account?". You need to click "Allow" and then copy the key.

 

Then, lets go to Qlik Sense and setup our Rest Connector to get our data. All of the desired template links are in Trello Developers. Here I will just create a simple connection that retrieves all of the lists and their cards from a single board

  • Go to your "Data Load Editor"
  • Create a new section and name it Trello
  • Create a new connection using the "Qlik REST Connector"
  • In the url add "https://api.trello.com/1/boards/[board_id]/lists?cards=open&card_fields=name&fields=name&key=[key]&token=[token]". Don't forget to substitute the key and token that you got above. To get your board id, simply open your trello board and go to the url. It should be in the form of "https://trello.com/b/[board_id]/[your-board-name]".
  • Method is "GET"
  • Under Authentication select "BASIC" and add your username and password, give it a name and save it.
  • 2017-07-19 07_49_08-Qlik Sense Desktop.png
  • Click on "Select Data" and select what you want to get. If you select "root", you will get only the lists. If you select cards too, then you will get all of the lists with their cards
  • The REST Connector should generate the load script for you and should look something like this

 

LIB CONNECT TO 'Trello-board-list';

RestConnectorMasterTable:
SQL SELECT
"id" AS "id_u0",
"name" AS "name_u0",
"__KEY_root",
(SELECT
"id",
"name",
"__FK_cards"
FROM "cards" FK "__FK_cards")
FROM JSON (wrap on) "root" PK "__KEY_root";

[cards]:
LOAD [id] AS [card_id],
[name] AS [card_name],
[__FK_cards] AS [list_key]
RESIDENT RestConnectorMasterTable
WHERE NOT IsNull([__FK_cards]);

[root]:
LOAD [id_u0] AS [list_id],
[name_u0] AS [list_name],
[__KEY_root] AS [list_key]
RESIDENT RestConnectorMasterTable
WHERE NOT IsNull([__KEY_root]);

DROP TABLE RestConnectorMasterTable;






 

The end result should be something like :

2017-07-18 10_48_40-Qlik Sense Desktop.png

 

There are a lot of possibilities here. You can combine this with some power ups/custom fields that you would like to track and get more detail into your visualizations.

 

This is it!! Now with few steps you can add your lists and cards intro Qlik Sense and create charts or KPIs based on these data.

 

https://branch-blog.qlik.com/trello-and-qlik-sense-2da6e1912967

 

Yianni

gio.png

 

Happy Tuesday everyone! - I have the pleasure of introducing our newest contributor to the Qlik Design Blog, Giuseppe Panella. I like to call him Gio! Gio has joined Qlik in 2015 after the acquisition of NPrinting by Qlik. He is now part of the Product Content and Media team as an interaction designer working on the production of videos for the Qlik Help channel managed on YouTube. Gio and I share the same love for video production at Qlik and will be teaming up to bring you the latest news, features, capabilities and innovation from time to time via the Qlik Design Blog and other channels. Make sure to follow / subscribe to get the latest updates on our posted content. Gio is now producing a video series called Tuesday Tips and Tricks - with each short clip describing a particular capability across the Qlik product line. Today's clip shows you how to use a Qlik Sense extension available from Qlik Branch that enables Qlik Sense to provide an On-Demand Report capability in combination with NPrinting. (This capability is native in QlikView.)  You can learn more about this feature here. http://branch.qlik.com/#!/project/58be6fc151be1c2744fb32a0 Future Tuesday Tips and Tricks will be promoted on the Qlik Design Blog from time to time and will also be made available in the Help Channel playlist. Enjoy!

 

 

 

Tuesday Tips and Tricks

 

NOTE: To increase resolution or size of the video, select the YouTube logo at the bottom right of the player. You will be brought directly to YouTube where you can increase the resolution and size of the player window. Look for the 'settings' gears icon in the lower right of the player once at YouTube.

 

Can't see the video? - You can download the attached .mp4 file to play on your computer or local device.

The Qlik Sense June 2017 release came with a bunch of new visualizations, distribution plot is one of the new objects available to drag and drop into Qlik Sense. Let’s use an example to check what a distribution chart can tell us that was previously hidden from our eyes.

 

I’m going to use a very simple example of sales data, it contains 3 sales rep and monthly sales that extends over a year. We want to see how our reps are preforming over the year by observing some execution indicators such as total sales and average sales.

 

table.png

 

In our not-so-random example data, sales are even for the sales team. As you can see in the picture below, their aggregated numbers are almost identical.

 

barchart.png

 

Average is just not enough to see how sales rep are performing, we need more granularity if we really want to understand how the sales process works. To do so we could try to include months and maybe use a different visualization object like a line chart.

 

linechart.png

 

Line chart will help us to see sales with a temporal component, I see how both Jerry and Sheri have a very regular sales process over the months while Dani's go all over the board with excellent months and not so great ones.

 

Distribution plot can help me to get a better picture of our sales by giving us a glance of data dispersion.

 

distributionplot.png

 

I see that despite having the same yearly sales amount and sales average the actual distribution over time is quite different from each other.

 

Jerry has tight sales performance month to month with all the points(months) falling in a compact cluster. Sherri meanwhile has a very tight bucket of dots a little over $150 but also a couple of months that could be considered as outliers. That is valuable information that wasn’t obvious only attending to the line chart.

 

Dani's sales don’t follow the pattern described by the other two individuals. For Dani, monthly sales range from $0 to $600 is either an excellent or a terrible month. Any company will be happier with a more consistent sales performance and our imaginary company is no exception to that. By learning how each one of the sales team performs we can take the necessary actions to help Dani to be more reliable.

 

As we have seen similar yearly sales and identical sales average could hide some valuable information, there’s a story in your data that needs to be discovered.

 

Enjoy it,

Arturo (@arturoqv)

In this edition of the Qlik Design Blog, Denise is back discussing some additional connectivity updates for Qlik Sense Cloud Business and Qlik Sense Cloud Basic.

 

What's New

 

Qlik Sense Cloud Business users have been eagerly waiting for direct connectivity to an on-premise Microsoft SQL Server. We’ve seen rapid adoption of Qlik Sense Cloud Business’s connectors to cloud data sources – Salesforce, web connectors, etc. – over the past few months, but we know that just because you’ve moved your analytics to the cloud, you haven’t necessarily moved all of your data there. In this article you will find how to set up the connector and to learn about few other Qlik Sense Cloud updates.

 

MS SQL Server in Qlik Sense Cloud Business

 

The process of setting up connectivity between Qlik Sense Cloud Business and a MS SQL Server is similar to what you’ve done to set up other connectors. A prompt will ask you to enter the appropriate host information (server host name, port number, available database, and credentials) to establish the connection and allow access passed the firewall. Check out Mike Tarallo’s video below to see how he set up connectivity between his SQL server and the Qlik Sense Cloud Business environment (thanks Mike!). And, don’t forget, you can use the automated data refresh functionality to update your Qlik Sense apps from your MS SQL data!

 

 

Here are a few other updates and improvements that have also been introduced to the Qlik Sense Cloud offering:

 

Web File Connectivity

 

You might already have learned a trick to use the REST Connector in Qlik Sense Cloud Business to directly connect to web files, but we’ve now added a separate web file connector so that users have a much simpler and easier way to connect to an unsecured web file. Basically any file source that Qlik Sense can connect to (HTML tables, csv, xml, xls, etc) can also be made available over the web via HTTP and even FTP. Please refer to our online help to learn how to configure these types of connections. As an added bonus, this connector is now available in both Qlik Sense Cloud Business and Qlik Sense Cloud Basic. Qlik Sense Cloud Basic users now have another way to load data in addition to uploading files allowing them to freely experience how the associative model works to uncover insights across multiple data sources.

 

App Governance

 

When using Qlik Sense Cloud business you can have up to 50 users within a workspace. With up to 50 users viewing and editing multiple apps, group members often want transparency around when apps were accessed and by whom. We’ve added a “recent history” data stream to apps in the collaborative workspace so users have visibility into group activity, making governance and communication even easier to manage. Simply click on the “i” icon in any app to view the details:

 

app_gov.png

 

Data Wizard Redesign

 

As you’ve been building out new apps, you probably noticed that the Data Wizard looks a little different lately. All of the same functionality exists – upload or attach files, access to Qlik DataMarket, etc. - but we’ve listed options differently for better usability. The biggest improvement is that all available connectors will be visible on the screen, which will be particularly helpful when we launch the next group of connectors on the way – check back soon!

 

data_wiz.png

 

NOTE: To increase resolution or size of the video, select the YouTube logo at the bottom right of the player. You will be brought directly to YouTube where you can increase the resolution and size of the player window. Look for the 'settings' gears icon in the lower right of the player once at YouTube.

 

denise.pngDenise LaForgia is a Senior Product Marketing Manager focused on Qlik cloud solutions. On an occasional basis, Denise will share updates on our Qlik Sense Cloud solutions on the Qlik Design blog so please subscribe and stay tuned. You can also download the videos mentioned in these blog, see the .mp4 attachment on the bottom.

With the Qlik Sense June 2017 release comes server side extensions, which allow you to extend the Qlik built-in expression library with functionality from external calculation engines. We've released an open source server side extension that enables interaction with R, and if you use the R-Plugin, you know that you have to start Rserve.exe and SSEtoRserve.exe, then restart the Qlik Sense Engine Service. What I'm going to walk you through is how to setup Rserve.exe and SSEtoRserve.exe to run as services, and then make the Qlik Sense Engine Service depend on those services so that they start whenever the Qlik Sense Engine Service starts.

This post is for people who have already installed the open source R-Plugin and would like to run the plugin as a Windows service instead of starting it manually. If you haven't gotten started with the open source R-Plugin, and would like to, please check out this guide sse-r-plugin - get started.

 

The first thing we need is NSSM. Download and unzip, then open a command prompt with admin privileges and change directory to  <path-to-nssm>\nssm-{x}.{x}{x}\win64.

nssm.png

 

Now we need to install our 2 new services. In the command prompt, enter nssm install RserveService. An interface will pop up where we can define the service. Enter <directory>\Rserve.exe into "Path", and set "Startup directory" to the directory Rserve.exe is in. Then, go to the "Environment" tab, and enter PATH=%Path%;C:\R\R-3.4.1\bin\x64 (assuming you have R-3.4.1 installed in the C:\R directory, otherwise make adjustments as necessary). Now click the "Install service" button.

rservepath.pngrserveenv.png

 

Next, we need to install a service for SSEtoRserve.exe. So, again, at the command prompt enter nssm install SSEtoRserveService, and then enter <directory>\SSEtoRserve.exe into "Path", and set "Startup directory" to the directory SSEtoRserve.exe is in. Now click "Install service".

ssetorserve.png

 

Now that the two services are installed, we can set the Qlik Sense Engine Service to depend on them, so that any time the Qlik Sense Engine Service starts, these services will be available. Back at the command prompt enter nssm edit QlikSenseEngineService. Go to the "Dependencies" tab and add RserveService and SSEtoRserveService, each on their own new lines under the already existing QlikSenseRepositoryService.

engineservice.png

 

All of you have to do now is restart the Qlik Sense Engine Service and you should be good to go.

Jennell McIntire

Rank Function

Posted by Jennell McIntire Jun 30, 2017

Over the years, I have seen the Rank function used in various expressions.  Recently, I was working on a Broadway Shows project where we wanted to show the rank in a bar chart before the label adding a numeric indicator of how a show ranked.  You can see what I am referring to in the bar charts used in the Broadway app.  The bar chart below is an example of one of the charts.  We added the rank before the show name on the y-axis label.

Broadway.png

In this blog, I will discuss how the Rank arguments can be used to change how the rank is presented.  To do so, I will use a simplified data set to illustrate how the rank can be displayed.  Let’s start by defining the Rank function.  The Rank function is a chart function and is defined in Qlik Sense Help as:

 

Rank() evaluates the rows of the chart in the expression, and for each row, displays the relative position of the value of the dimension evaluated in the expression. When evaluating the expression, the function compares the result with the result of the other rows containing the current column segment and returns the ranking of the current row within the segment.

 

For charts other than tables, the current column segment is defined as it appears in the chart's straight table equivalent.

 

Syntax:

Rank([TOTAL] expr[, mode[, fmt]])

 

Originally, I used the Rank function without any arguments.  This will rank the products by their sales and display it before the product label.

Rank no arguments.png

Rank no arguments chart.png

By default, with no arguments for mode and fmt, the Rank function will show the lowest and highest value displayed like a range as seen in the chart above.  But what if you want to show a single number for the rank where Product_B and Product_J would show 1 as the rank for both projects since they both tied for first place.  This can be accomplished by using the mode and fmt arguments.  Mode can take values 0 – 4 and controls which rank is shown for each row for example show the lowest rank, the average rank or the highest rank.  The fmt argument takes values 0 – 2 and controls how and where the rank is displayed.  You can find the detailed description for each setting in Qlik Sense Help.

 

For the Broadway app, I set the mode to 4 and the fmt to 1.  If I do this with this data set, I will get a chart like this:

Rank arguments.png

Rank arguments chart.png

The mode argument is 4. This will show the lowest rank on the first row, then increment by one for each row.  The fmt argument is 1 and this will show the low value on all rows.  When there is a tie, only the lowest rank will be displayed on the respective rows.

 

There are not always ties when using the Rank function but when there are, the Rank function provides options for how to handle the display of the rank.  This was something I never had a need for until now but I found it to be very valuable so I thought I would share what I have learned.  The next time you use the Rank function, try out the various arguments to find the display that works best for your app.

 

Thanks,

Jennell

2laurie.pngThis week I am honored to introduce our newest guest blogger, Laurie Chan-Lam. Laurie is one of our talented architects in Qlik R&D who has personally worked on one of Qlik's unique and game changing capabilities, Smart Search. She recently was inspired by Mitul's blog post on Controlling Fields Shown in Smart Search - when encountering some questions regarding the possibility to create the Smart Search Index, BEFORE the actual search was initiated. (If you are not familiar with Qlik's Global and Visual Smart Search capabilities - you can review a few videos on the topic here)

 

 

Mitul's blog Controlling Fields Shown in Smart Search explains how you can configure what fields are searchable when creating the Search Index. So to recap, in order for the Smart Search capabilities to present the desired information to the user when using Smart Search, Qlik Sense needs to index it. With previous versions of Qlik Sense, the search index was created when first requested, therefore taking an additional amount of time before the results were displayed. Starting with Qlik Sense 3.1, you can now chose to create the search index at reload time as explained in the documentation by using the system variable CreateSearchIndexOnReload.

 

Follow these steps to learn more how to achieve this:

 

 

How can I turn on/off the creation of the search index at reload time?

In order to turn on the creation of the search index at reload time, several criteria need to be met:

  1. The Engine needs to be enabled to support the creation of search index at reload time. This can be done via a setting in the QMC. (Qlik Management Console)
    1. Go to menu items Engines
    2. Edit the node you want to work on
    3. Tick the Advanced menu
    4.   Tick the "Enable creation of search index on reload" box

 

ww.png

 

Then in the app in the Data Load script:

 

The app needs to have the System Variable Set CreateSearchIndexOnReload=1; This statement exists by default in Qlik Sense. Note that the statement of Set CreateSearchIndexOnReload=0; will allow the user to delay the creation of the search index at search time.


xx.png

 

Why should I create the search index at reload time?

Creating the search index at reload time makes the search index ready from the first use. Therefore there is no need to wait for the index to be created. The first use of Smart Search after the initial  reload will be as fast as the following ones.

 

Some exceptions:


Session apps

By definition, session apps are not persisted. Therefore, the corresponding search index shouldn't be persisted and Qlik Sense doesn't index at reload time for session apps.

 

Synchronized persistence

If the reload node is not the node on which the user is searching, then the creation of the search index on the reload node needs to be disabled. If you do not disable this, an index is created when you reload, which consumes time and disk space to no advantage


Thank You for reading.


Laurie Chan-Lam

Qlik Architect

A while ago I blogged about 2 of our most beautiful mashups in the Demo Team, Salesforce and CIO dashboard.

 

Case study: Salesforce mashup

Jazzing up your Mashups

 

After I was asked by many for the source files, here are the 2 github pages

 

GitHub - yianni-ververis/CIO: CIO mashup created by the Demo Team

GitHub - yianni-ververis/Salesforce: Salesforce Mashup created by the Demo Team

 

Upload the qvfs on your server and put the ids into the project.json file. Then in the command line type "npm install" to install all the required libraries and "gulp" to build and run the project.

 

Depending of the version of Qlik Sense you are running, most likely you will get CORS errors and some fonts may not load up. If you have valid certificates for localhost then under ./gulp-tasks/server.js comment out lines 15-18

 

Mashups:

https://webapps.qlik.com/salesforce/index.html

CIO Dashboard

 

Best,

Yianni

Guided apps are probably the more common data viz pieces nowadays. Are strongly influenced by the traditional journalistic approach to a story and related with storytelling. The goal of guided apps is to walk the reader from point A to point Z.

 

A well-constructed guided visualization is incredible powerful at proving a point, examples can be found almost daily at mass media websites. As a data professional, I love data stories but maybe because I’m such a data geek I usually never get completely satisfied by the visualizations used to emphasize the story. I almost always hungry for ways to explore the data or I simply miss one angle from the story to feel fulfilled.

 

On the other hand, the so-called Discovery apps are intended to let the user to manage the ride and rely on reader capacity to be able to interact and to understand the data they are looking at. Scenarios with simple and familiar data are generally more appropriate for discovery apps.

 

We recently got one of those great data sets for discovery, simple data and containing thousands of potential stories in it. Barcelona Marathon organization contacted us to create a piece to let runners (data users) to explore every corner of their data. They have been collecting runners’ data during the last decade, our part was just to put a nice wrap around it. We like to see it as a nice hybrid (more on the discovery side) of guided and discovery app.

 

barcelonaMarathon.png

 

 

We divided the mashup into three sections trying to help first time users to better get familiarized with the data. It’s just a visual separation of the data, each section belongs to the same data model, filters are global and every selection affect all the charts. For the clarity of it we reduced the use of set analysis as much as possible.

 

The app starts with race overview data, about participation and finishing times. The second section serves as demographic info, with three main characteristics to consider, age, sex and nationality. Finally, we reserved a little bit of complexity for the very last section, we called it Performance. As you can see in the picture below taken from the chart “Avg time by age” the sweet spot age for someone to run this marathon is 35 years old, in average people in that age get the best results.

 

avg time by age.png

 

You can check the mashup live at Barcelona Marathon page here or as a stand-alone version at Marató Barcelona.

 

Regards,

Arturo Munoz (@arturoqv)

excited.png

Hey guys! - I'm very excited to introduce you to our latest release of Qlik Sense, June 2017. Yep - no version number or dots in this naming convention. With the announcement of our continuous release process discussed here, Qlik will begin releasing Qlik Sense every 10 weeks!  Since each release will be similar in scope, we are also replacing our number-based naming convention with releases identified by the month and year they were distributed.  This means that instead of Qlik Sense 4.0, our June release is simply called Qlik Sense June 2017.  (Most other Qlik products will also follow a similar cadence going forward as well.)

 

 

Currently customers and partners are invited to Join the Technical Preview and can get the latest software here. If you are not a customer or partner, our freemium product, Qlik Sense Desktop - will be available later in the month (UPDATE: available NOW here: Download Free Data Visualization Development Platform - don't forget you can always experience newer features before the software is available (such as the new data preparation features) without downloading any software by registering with Qlik Sense Cloud, thanks to our continuous release process.

 

There is so much goodness in this release that I don't want to create a giant text wall telling you about it. I created a brief summary video for your enjoyment as well as longer videos detailing and demonstrating the new features. You can view them at the video index below which include video files and samples. Please note that additional information on our Advanced Analytics integration is available in this community group Advanced Analytics Extensions and requires permission. Please send an email to mailto:insight@qlik.com to gain access. I am in the middle of working on a brief summary and "Hello World"-type video to demonstrate its concepts.

 

We want to hear from you, so please your comments and questions below!

 

Qlik Sense June 2017 - Highlights

 

The main video index for the Qlik Sense June 2017 Release and video .mp4 files and samples can be found here: Qlik Sense June 2017 - What's New

 

NOTE: To increase resolution or size of the video, select the YouTube logo at the bottom right of the player. You will be brought directly to YouTube where you can increase the resolution and size of the player window. Look for the 'settings' gears icon in the lower right of the player once at YouTube.

 

Regards,

Michael Tarallo (@mtarallo) | Twitter
Qlik

If you're creating a mashup that includes embedded Qlik Sense charts, there's a couple issues you may run into that you'll want to be aware of.

 

First, if your mashup scrolls, and you scroll down the page, you will notice that the tooltips on the Qlik Sense charts are not positioned correctly, like below:

2017-06-07 11_20_25-Marató Barcelona.png

The tooltips will get more and more displaced the further down the page you scroll. For the tooltips to be positioned correctly, you'll have to adjust how scrolling happens on your page a little bit.

 

The easiest option that you can implement with just some CSS is to set the html and body tags to a height of 100%, hide the overflow on the html tag, and add use overflow: auto on the body tag. That looks like this:

html, body {
height: 100%;
overflow: hidden;
}
body {
overflow: auto;
}









 

Now the tooltips will no longer be displaced when you scroll your mashup. However, there are times when it may be necessary to watch the scroll position of the page, or be able to set the scroll position of the page programmatically, and for some reason, when using the above method the scrollTop attribute of the body tag never actually updates, so there is no way to observe when the page scrolls or set the scroll position programmatically.

 

In instances like this, just a simple extra step will fix the issue. What you'll need to do is add a wrapper element that wraps the entire content of your mashup, and also set that to a height of 100%, and put the overflow on that element. That element's scrollTop will be set correctly, and you can observe or set it programmatically. So, it would be something like this:

<head>
<style>
  html, body, #page-content {
    height: 100%;
    overflow: hidden;
  }
  #page-content {
    overflow: auto;
  }
</style>
</head>
<body>
<div id="page-content">
  <!-- All of your content -->
</div>
</body>









 

The other issue you may run into is the chart tooltip not be styled correctly, since it may be affected by the CSS in your mashup. The most common example I see of this is if using Bootstrap v4. Bootstrap v4 adds some negative margins to the .row class, and the tooltip also uses the row class, and it makes the text in the tooltip get cut off, like this:

2017-06-07 12_11_20-Marató Barcelona.png

To fix this, and any other styling issues you may have with the tooltips, it's helpful to be able to inspect it. A div with the class .qs-chart-tooltip will be appended near the end of the body. If you inspect the page and find that element, then expand it, it's first child element is a div that has display: none set, just uncheck that style and you'll be able to view the tooltip in it's last location. Then you can continue to expand those child elements and inspect the element, looking for any issues. In the case I show above, as I stated, the problem is with Bootstrap v4 and it's negative margins on the .row class. So the css below fixed the tooltip:

.qv-chart-tooltip-inner .row {
margin-left: 0;
margin-right: 0;
}


 

So, now you should be able to address these Qlik Sense chart tooltip issues I often see in mashups. If you have any questions, let me know!

The switch control statement is one of many controls statement that can used to determine the flow of the script.  In Qlik Sense help, it is defined as:

 

The switch control statement is a script selection construct forcing the script execution to follow different paths, depending on the value of an expression.

 

Syntax:

Switch expression {case valuelist [ statements ]} [default statements] end switch


The switch control statement can be used in the script to identify a specific execution path.  With the switch control statement, several paths can be defined and a default path can be defined as well when no match is found in the case clause.  The various script paths cannot cross – they should be individual paths that do not overlap.  In the script below, the expression x will be compared to each case.  When there is a match, the script for that case will be executed.

 

In the example below, Case 1 will be executed – the variable y will be set to Sunday and one record will be generated in the table.

script.png

Below is a look at the record generated.

Table.png

It is also possible to have more than one value for a case, for instance, you can use the script below to run the same script if x matches 1, 2 or 3.

case 1 2 3.png

When faced with various script execution paths, try using the switch control statement.  While I rarely have a need to use it, I like how neat and straight-forward the syntax is.  I have attached an example Qlik Sense app with the full script for you to test out for yourself.

 

Thanks,

Jennell

In this edition of the Qlik Design Blog, our Emerging Technology Evangelist, David Freriks is back discussing integration between Qlik and Kudu.

 

 

Navigating the analytics labyrinth with integration of Kudu, Impala, and Qlik

 


apachekudu_logo_0716_345px.pngUsing Hadoop for Big Data analytics is nothing new, but a new entity has entered the stale file format conversation with the backing of Cloudera – you might have heard of it, it’s called Kudu.

 

What is Kudu?

 

Let’s first take a step back and think about the dullest topic in the universe, file system storage formats. Flat files, AVRO, Parquet, ORC, etc. have been around for a while and all provide various advantages and strategies for data access optimizations in an HDFS construct. However, they all suffer from the same issue… static data that can only be appended to – unlike a real database.

 

So, enter Kudu – defined by Apache: “Kudu provides a combination of fast inserts/updates and efficient columnar scans to enable multiple real-time analytic workloads across a single storage layer.” Deconstructing that message – Kudu acts as a columnar database that allows real database operations that aren’t possible in HDFS file formats. It is now possible to interact with your Hadoop data where INSERTS, UPDATES, DELETES, ALTERS, etc. are now available as data operations. This means not just read/write capabilities for Hadoop , but also interactive operations without having to move to Hbase or other systems. IoT use cases, interactive applications, write-back, and traditional data warehousing are now possible without adding layer upon layer of additional technologies.

 

Now that we have a general understanding of what Kudu can do, how does this benefit Qlik? Kudu is fast, columnar, and designed for analytics – but with the ability to manipulate and transform the data to power new use cases.

 

Let’s start simple by showing how easy it is to move some data from an Impala table on Parquet into Kudu.

 

Starting in Hue we need to do some basic database-like work. To put data into a table, one needs to first create a table, so we’ll start there.

 

Kudu uses standard database syntax for the most part, but you’ll notice that Kudu is less specific and rigid about data types than your typical relational database – and that’s awesome. Not sure if your data is a varchar(20), or if it is smaller or larger?  No worries, with Kudu –  just declare it as a basic string.

 

1.png

 

Numerical data are basic as well, there a just few types to choose from based on the length of the number.   This makes creating columns and designing a schema very, very straightforward and easy to setup.  It also reduces data type problems when loading data.

2a.png

Having a general understanding of table creation, we will go ahead and create a table we are going to copy from Parquet.  It’s worth noting there are some differences here versus creating a Parquet table in Hue.

 

•    First:  A Kudu table needs to have at least 1 primary key to be created.

•    Second:  A Kudu table needs a partition method to distribute those primary keys

 

Referencing the schema design guide, we are going to use a HASH partition and use the number 3 (since we have 3 worker nodes).

 

In summary, we have a bunch of strings, a few integers, and some floating decimals to represent prices and profit. We’ve identified our keys and specified our partitions – let’s roll!

 

The query runs for a second and viola – we have our new (albeit empty) table. Next, we need some data. We have an existing table that we would like to copy over into Kudu. We will run another query to move the data and make a little tweak on the keys to match our new table.

 

We had to cast our customer_sk and item_sk columns from string in Parquet to int in Kudu but that’s pretty easy to do as shown in the SQL here.

 

We run the INSERT query and now we have our data moved over into Kudu, and even better – that table is now immediately available to query using Impala!

 

3a.png

 

 

Enter Qlik

 

With the data loaded into Kudu and exposed via Impala – we can now connect to it with Qlik and start building visualizations.

 

Using the latest Cloudera Impala drivers , we start the process of building a Qlik app by connecting to our new data set.

 

4a.png

 

Opening Qlik Sense, we will create a new connection to our cluster and select our new table.

 

Once we have the table and columns selected – we can modify the load script created by the data manager to directly query Kudu (versus loading the data into memory) to take advantage of the speed and power of Impala on Kudu.(we do this using Direct Discovery - NOTE the Direct Query syntax) This change is accomplished with a slight alteration in the syntax to identify dimensions and measures.

 

5a.png

 

We now have live queries running against Kudu data sets through Impala.

 

6a.png

 

The great part about Kudu is that we’re just getting started with the possibilities of how we can leverage the technology with Qlik. Some things we’re cooking up for the not too distant future involve write-back with Kafka and Qlik Server Side Extension integration – so stayed tuned.

 

Please visit cloudera.qlik.com for more demos and to see the Kudu demo in action.

 

Regards,

David Freriks (@dlfreriks) | Twitter
Emerging Technology Evangelist

Last year I blogged about our  Mobile Friendly Horizontal Bar Chart that we use in most of our mashups in the Qlik Demo Team.

 

Since then, many things have changed. For a start, if you have a mashup that uses many objects, you will see the load time to be much faster since I used d3.v4 and I have added a break point on how many bars to create, You can define if you want to show all or only the first 50.

 

I have also changed the currency. If you select the measure to be displayed as 'auto' then extension will use the custom format. You can abbreviate the measure with their respective symbol like 'B' for billions, 'T' for trillions etc and use your custom currency symbol

2017-05-24 18_04_56-Nordea Masters - CBO _ Sheets - Qlik Sense.png

Another new feature is the custom text to display when there is no data. If you make a selection in the sheet and that produces no results then this text will be displayed.

2017-05-25 19_33_42-_Nordea Masters - CBO - 2017 Nordea Golfers _ Sheets - Qlik Sense.png

 

Also, the tooltip is more elegant now and different from the standard Qlik Sense one. I changed it to follow the mouse instead of always aligned center at the top of the bar

2017-05-25 17_40_21-_Nordea Masters - CBO - 2017 Nordea Golfers _ Sheets - Qlik Sense.png

YIANNI

 

Files

Qlik Branch

Filter Blog

By date:
By tag: