{"id":37950,"date":"2018-11-07T17:22:53","date_gmt":"2018-11-07T11:52:53","guid":{"rendered":"https:\/\/data-flair.training\/blogs\/?p=37950"},"modified":"2021-12-07T11:23:44","modified_gmt":"2021-12-07T05:53:44","slug":"qlikview-script-statements-keywords","status":"publish","type":"post","link":"https:\/\/data-flair.training\/blogs\/qlikview-script-statements-keywords\/","title":{"rendered":"QlikView Script Statements | QlikView Keywords – Types and Syntax"},"content":{"rendered":"

In our last tutorial, we studied\u00a0QlikView Operators<\/strong><\/a>. Here, we will open a new chapter called QlikView Script Statements and keyword – the most crucial elements of Qlikview Scripting<\/a><\/strong>. Moreover, we will learn the different types of script statements and keywords in QlikView: script control,\u00a0script regular,\u00a0script prefixes, and\u00a0script variables in QlikView.<\/p>\n

The QlikView<\/em>\u00a0statements and keywords populate the script. Whenever you wish to perform a manipulation and control task in QlikView on the loaded data sets, you will have to do so by writing commands using these scripts and keywords<\/em>.<\/span><\/span><\/p>\n

So, let’s start QlikView Script\u00a0Statements and keyword.<\/p>\n

\"QlikView<\/a>

QlikView Script Statements & Keywords – Types and Syntax<\/p><\/div>\n

What are QlikView Script Statements and Keywords?<\/h3>\n

As we know, that any software using scripting as a means of controlling the functioning of the software, having the fundamental knowledge of QlikView script statements and keywords plays an essential role. The QlikView statements and keywords followed in computer language follow a certain standardization and formalism. <\/span><\/span><\/p>\n

Similarly, the QlikView script follows the Backus-Naur formalism<\/strong><\/a>. The QlikView script statements strictly follow the formulation rules, thus have a well-defined and structured script command language. <\/span><\/span><\/p>\n

You will have to deal with these QlikView script statements and keywords a lot if you wish to work on QlikView and be a professional. So, we would solicit you to pay some extra attention and understand these statements fully so that you have a very strong fundamental knowledge of QlikView scripting and its elements. <\/span><\/span><\/p>\n

We will discuss about the QlikView statements and keywords by broadly categorizing them in several categories i.e. control statements, regular statements, script prefixes and script variables. The prefixes and variables are keywords whereas, control and regular are two types of script statements in QlikView.<\/span><\/span><\/p>\n

Do you know What is\u00a0QlikView Directory Service Connector (DSC)?<\/a><\/strong><\/p>\n

Let us learn about all the important QlikView script statements and keywords.<\/span><\/span><\/p>\n

Types of QlikView Script Statements and Keyword<\/h3>\n

In this section, we are going to discuss about the uses and syntax of all the QlikView\u00a0script statements and keywords. <\/span><\/span><\/p>\n

a. QlikView Script Control Statements<\/h4>\n

The QlikView script control statements are used to manage and monitor the control flow of the script execution. A control statement can end with a semicolon or EOL (end of line).<\/span><\/span><\/p>\n

\"QlikView<\/a>

QlikView Script Statements & Keywords – QlikView Script Control Statements<\/p><\/div>\n

    \n
  1. \n

    Call<\/span><\/span><\/p>\n<\/li>\n<\/ol>\n

    Calls a subroutine along with defined parameters. Also, the subroutine must be in the script as \u2018sub\u2019 earlier, so that the user can call it through the call function. <\/span><\/span><\/p>\n

    Call<\/b><\/span><\/span> name ([parameterlist])<\/span><\/span><\/p>\n

      \n
    1. \n

      Do..loop<\/span><\/span><\/p>\n<\/li>\n<\/ol>\n

      It executes one or several statements until or while a logical condition is met. It is a script iteration statement.<\/span><\/span><\/p>\n

      do [ ( while | until )<\/b><\/span><\/span> condition ] [statements]<\/span><\/span><\/p>\n

      [exit do [ ( when | unless )<\/b><\/span><\/span> condition ] [statements]<\/span><\/span><\/p>\n

      loop [ ( while | until )<\/b><\/span><\/span> condition ]<\/span><\/span><\/p>\n

        \n
      1. \n

        Exit script<\/span><\/span><\/p>\n<\/li>\n<\/ol>\n

        The Exit script, use for terminating the script execution and can insert anywhere in the script.<\/span><\/span><\/p>\n

        exit script[ (when | unless)<\/b><\/span><\/span> condition ]<\/span><\/span><\/p>\n

        Follow this link to know about QlikView Ports<\/a><\/strong><\/p>\n

          \n
        1. \n

          For each ..next<\/span><\/span><\/p>\n<\/li>\n<\/ol>\n

          The execution of one or several statements for each value in a comma-separated list.<\/span><\/span><\/p>\n

          The statements enclosed by for and next will execute for each value of the list individually. <\/span><\/span><\/p>\n

          For Each<\/b><\/span><\/span> var <\/span><\/span>in<\/b><\/span><\/span> list [statements]<\/span><\/span> <\/b><\/p>\n

          [exit for<\/b><\/span><\/span> [ ( when | unless )<\/b><\/span><\/span> condition <\/span><\/span>]<\/b><\/span><\/span> [statements] <\/span><\/span>next<\/b><\/span><\/span> [var]<\/span><\/span><\/p>\n

            \n
          1. \n

            For..next<\/span><\/span><\/p>\n<\/li>\n<\/ol>\n

            The QlikView script statements of for and next will execute for each value of the counter variable between (and including) specified low and high limits.<\/span><\/span><\/p>\n

            For<\/b><\/span><\/span>counter = var1 <\/span><\/span>to<\/b><\/span><\/span> var2 [ <\/span><\/span>step<\/b><\/span><\/span>var3 ] [statements] <\/span><\/span>[exit for [ ( when | unless )<\/b><\/span><\/span> condition <\/span><\/span>]<\/b><\/span><\/span> [statements] <\/span><\/span>Next<\/b><\/span><\/span> [counter]<\/span><\/span><\/p>\n

              \n
            1. \n

              If..then<\/span><\/span><\/p>\n<\/li>\n<\/ol>\n

              It is a script selection construct. It controls script execution and makes it follow different paths depending on one or several logical conditions.<\/span><\/span><\/p>\n

              If<\/b><\/span><\/span> condition <\/span><\/span>then<\/b><\/span><\/span> [statements]{<\/span><\/span>elseif<\/b><\/span><\/span> condition <\/span><\/span>then<\/b><\/span><\/span> [ statements ]}<\/span><\/span>[ else<\/b><\/span><\/span>[ statements ] ] <\/span><\/span>end if<\/b><\/span><\/span><\/p>\n

                \n
              1. \n

                Sub<\/span><\/span><\/p>\n<\/li>\n<\/ol>\n

                The sub..end sub control statement defines a subroutine which can be called upon from a call statement.<\/span><\/span><\/p>\n

                Sub<\/b><\/span><\/span> name [(paramlist)] statements <\/span><\/span>end sub<\/b><\/span><\/span><\/p>\n

                  \n
                1. \n

                  Switch<\/span><\/span><\/p>\n<\/li>\n<\/ol>\n

                  The script follows different paths, depending on the value of an expression during execution. <\/span><\/span><\/p>\n

                  Switch<\/b><\/span><\/span> expression {<\/span><\/span>case<\/b><\/span><\/span> valuelist [statements]} [<\/span><\/span>default<\/b><\/span><\/span> statements] <\/span><\/span>end switch<\/b><\/span><\/span><\/p>\n

                  b. QlikView Script Regular Statements<\/h4>\n

                  Qlikview regular statements are those statements which are commonly used for data manipulation. Every regular statement must end with a semicolon \u2018;\u2019<\/span><\/span><\/p>\n

                    \n
                  1. \n

                    Alias<\/span><\/span><\/p>\n<\/li>\n<\/ol>\n

                    Used to rename a data field temporarily.<\/span><\/span><\/p>\n

                    Alias<\/b><\/span><\/span> fieldname <\/span><\/span>as<\/b><\/span><\/span> aliasname {,fieldname <\/span><\/span>as<\/b><\/span><\/span> aliasname}<\/span><\/span><\/p>\n

                      \n
                    1. \n

                      Binary<\/span><\/span><\/p>\n<\/li>\n<\/ol>\n

                      It use to load data from another QlikView document files (QVD files), including section access data.<\/span><\/span><\/p>\n

                      Binary<\/b><\/span><\/span> file <\/span><\/span>file ::= [ path ] filename<\/b><\/span><\/span><\/p>\n

                        \n
                      1. \n

                        Comment Field<\/span><\/span><\/p>\n<\/li>\n<\/ol>\n

                        It use for display the field comments from databases and spreadsheets. The last data value use as comment of there are repeating values of field name values.<\/span><\/span><\/p>\n

                        comment<\/b><\/span><\/span> *fieldlist <\/span><\/span>using<\/b><\/span><\/span> mapname<\/span><\/span><\/p>\n

                        comment<\/b><\/span><\/span> fieldname <\/span><\/span>with <\/b><\/span><\/span>comment<\/span><\/span><\/p>\n

                        Have a look at –\u00a0QlikView Distribution Service<\/a> <\/strong><\/p>\n

                          \n
                        1. \n

                          The Comment Table<\/span><\/span><\/p>\n<\/li>\n<\/ol>\n

                          Used to display metadata or table comments from databases or spreadsheets.<\/span><\/span><\/p>\n

                          comment-table<\/b><\/span><\/span> tablelist <\/span><\/span>using<\/b><\/span><\/span> mapname <\/span><\/span><\/p>\n

                          comment-table<\/b><\/span><\/span> tablename <\/span><\/span>with<\/b><\/span><\/span> comment<\/span><\/span><\/p>\n

                            \n
                          1. \n

                            Connect<\/span><\/span><\/p>\n<\/li>\n<\/ol>\n

                            Used to connect to the database through the OLE DB\/ODBC interface.<\/span><\/span><\/p>\n

                            ODBC CONNECT TO <\/b><\/span><\/span>connect-string<\/span><\/span><\/p>\n

                            OLEDB CONNECT TO <\/b><\/span><\/span>connect-string<\/span><\/span><\/p>\n

                            CUSTOM CONNECT TO <\/b><\/span><\/span>connect-string<\/span><\/span><\/p>\n

                            LIB CONNECT TO <\/b><\/span><\/span>connection<\/span><\/span><\/p>\n

                              \n
                            1. \n

                              Direct Query<\/span><\/span><\/p>\n<\/li>\n<\/ol>\n

                              Used to access tables from ODBC\/OLE DB connection using the Direct Discovery function.<\/span><\/span><\/p>\n

                              direct-query<\/b><\/span><\/span> [path]<\/span><\/span><\/p>\n

                                \n
                              1. \n

                                Directory<\/span><\/span><\/p>\n<\/li>\n<\/ol>\n

                                The Directory statement defines which directory to look in for data files in subsequent LOAD statements until a new Directory statement is made.<\/span><\/span><\/p>\n

                                Directory<\/b><\/span><\/span> [path]<\/span><\/span><\/p>\n

                                  \n
                                1. \n

                                  Disconnect<\/span><\/span><\/p>\n<\/li>\n<\/ol>\n

                                  Used to terminate the ongoing ODBC\/OLE DB\/Custom connection. <\/span><\/span><\/p>\n

                                  Disconnect<\/b><\/span><\/span><\/p>\n

                                    \n
                                  1. \n

                                    Drop Field<\/span><\/span><\/p>\n<\/li>\n<\/ol>\n

                                    Used to drop\/discontinue fields from table or tables that field exist in. Both <\/span><\/span>drop field<\/i><\/span><\/span> and <\/span><\/span>drop fields<\/i><\/span><\/span> forms of this statements are in use. The field will drop from all tables where it occurs if no specific table is mentioned in the statement. The dropped fields are also removed from the QlikView memory.<\/span><\/span><\/p>\n

                                    drop-field<\/b><\/span><\/span> fieldname [, fieldname2 …][<\/span><\/span>from<\/b><\/span><\/span> tablename1 [, tablename2 …]] <\/span><\/span><\/p>\n

                                    drop fields<\/b><\/span><\/span> fieldname [, fieldname2 …][<\/span><\/span>from<\/b><\/span><\/span> tablename1 [, tablename2 …]]<\/span><\/span><\/p>\n

                                      \n
                                    1. \n

                                      Drop Table<\/span><\/span><\/p>\n<\/li>\n<\/ol>\n

                                      Used to drop one or more internal QlikView tables both from the data model and from the internal memory.<\/span><\/span><\/p>\n

                                      drop-table<\/b><\/span><\/span> tablename [, tablename2 …] <\/span><\/span><\/p>\n

                                      drop tables<\/b><\/span><\/span> [s]<\/b><\/span><\/span> tablename [, tablename2 …]<\/span><\/span><\/p>\n

                                        \n
                                      1. \n

                                        Execute<\/span><\/span><\/p>\n<\/li>\n<\/ol>\n

                                        It runs other programs while QlikView is loading data. Like, making necessary conversations.<\/span><\/span><\/p>\n

                                        Execute<\/b><\/span><\/span> commandline<\/span><\/span><\/p>\n

                                        Let’s Explore\u00a0QlikView SNMP (Simple Network Management Protocol)<\/a><\/strong><\/p>\n

                                          \n
                                        1. \n

                                          Force<\/span><\/span><\/p>\n<\/li>\n<\/ol>\n

                                          It use fro interpret field names and field values and associates field values from data tables.<\/span><\/span><\/p>\n

                                          Force ( capitalization | case upper | case lower | case mixed )<\/b><\/span><\/span><\/p>\n

                                            \n
                                          1. \n

                                            LOAD<\/span><\/span><\/p>\n<\/li>\n<\/ol>\n

                                            It can use in several ways like, to load fields from a file, from data defined in the script, from a previously loaded table, from a web page, from the result of a subsequent SELECT statement or by generating data automatically.<\/span><\/span><\/p>\n

                                            LOAD [ distinct ] *fieldlist [( from file [format-spec] | from_field fieldassource [format-spec] inline data [ format-spec ] | resident table-label | autogenerate size )] [ where criterion | while criterion ] [ group_by groupbyfieldlist ] [order_by orderbyfieldlist]<\/b><\/span><\/span><\/p>\n

                                              \n
                                            1. \n

                                              Let<\/span><\/span><\/p>\n<\/li>\n<\/ol>\n

                                              This statement use for defining script variables. It is complementary to the Set statement as the set statement gives a calculated output and considers the value on RHS as an expression to calculate. If it is given that,<\/span><\/span><\/p>\n

                                              Let x= 3+2; <\/span><\/span><\/p>\n

                                              Then the result will be 6. Whereas in the case of Set the result would have been the string \u20183+2\u2019.<\/span><\/span><\/p>\n

                                              Let<\/b><\/span><\/span> variablename=expression<\/span><\/span><\/p>\n

                                                \n
                                              1. \n

                                                Loosen Table<\/span><\/span><\/p>\n<\/li>\n<\/ol>\n

                                                It is used to make some internal QlikView tables as loosely coupled tables. <\/span><\/span><\/p>\n

                                                Loosen<\/b><\/span><\/span>–<\/span><\/span>table[s]<\/b><\/span><\/span> tablename [ ,tablename2 …] <\/span><\/span><\/p>\n

                                                The [s] is to indicate that the statement can accept both as \u2018table\u2019 and \u2018tables\u2019. <\/span><\/span><\/p>\n

                                                  \n
                                                1. \n

                                                  Map..using<\/span><\/span><\/p>\n<\/li>\n<\/ol>\n

                                                  Used for mapping a certain field value or expression to the values of a specific mapping table. <\/span><\/span><\/p>\n

                                                  Map<\/b><\/span><\/span> *fieldlist <\/span><\/span>Using<\/b><\/span><\/span> mapname<\/span><\/span><\/p>\n

                                                    \n
                                                  1. \n

                                                    NullAsNull<\/span><\/span><\/p>\n<\/li>\n<\/ol>\n

                                                    It is used to turn off the conversion of NULL values to string values. The terminates the action invoked by NullAsValue statement.<\/span><\/span><\/p>\n

                                                    NullAsNull<\/b><\/span><\/span> *fieldlist<\/span><\/span><\/p>\n

                                                      \n
                                                    1. \n

                                                      NullAsValue<\/span><\/span><\/p>\n<\/li>\n<\/ol>\n

                                                      Used to convert specific field values into NULL<\/span><\/span>. <\/span><\/span><\/p>\n

                                                      NullAsValue<\/b><\/span><\/span> *fieldlist<\/span><\/span><\/p>\n

                                                        \n
                                                      1. \n

                                                        Qualify<\/span><\/span><\/p>\n<\/li>\n<\/ol>\n

                                                        Used to give field names the table name as a prefix. It is known as the qualification of the field names.<\/span><\/span><\/p>\n

                                                        Qualify<\/b><\/span><\/span> *fieldlist<\/span><\/span><\/p>\n

                                                          \n
                                                        1. \n

                                                          Rem<\/span><\/span><\/p>\n<\/li>\n<\/ol>\n

                                                          Used to insert remarks, or comments, into the script, or to temporarily deactivate script statements without removing them.<\/span><\/span><\/p>\n

                                                          Rem<\/b><\/span><\/span> string<\/span><\/span><\/p>\n

                                                            \n
                                                          1. \n

                                                            Rename Field<\/span><\/span><\/p>\n<\/li>\n<\/ol>\n

                                                            Used to rename one or more existing QlikView field(s).<\/span><\/span><\/p>\n

                                                            rename-field[s]<\/b><\/span><\/span> (<\/span><\/span>using<\/b><\/span><\/span> mapname | oldname <\/span><\/span>to<\/b><\/span><\/span> newname { , oldname <\/span><\/span>to<\/b><\/span><\/span> newname })<\/span><\/span><\/p>\n

                                                              \n
                                                            1. \n

                                                              Rename Table<\/span><\/span><\/p>\n<\/li>\n<\/ol>\n

                                                              Used to rename existing QlikView tables after they are loaded into QlikView\u2019s memory.<\/span><\/span><\/p>\n

                                                              rename-table[s]<\/b><\/span><\/span>(<\/span><\/span>using<\/b><\/span><\/span> mapname | oldname <\/span><\/span>to<\/b><\/span><\/span> newname{ , oldname <\/span><\/span>to<\/b><\/span><\/span> newname }) <\/span><\/span><\/p>\n

                                                                \n
                                                              1. \n

                                                                Section<\/span><\/span><\/p>\n<\/li>\n<\/ol>\n

                                                                It is used to decide and define if, subsequent LOAD and SELECT statements should consider as data or as a definition of the section access rights.<\/span><\/span><\/p>\n

                                                                Section (access | application)<\/b><\/span><\/span><\/p>\n

                                                                Refer this – Top Companies using QlikView<\/a><\/strong><\/p>\n

                                                                  \n
                                                                1. \n

                                                                  Select<\/span><\/span><\/p>\n<\/li>\n<\/ol>\n

                                                                  Used to select fields from the data sources like ODBC or OLE DB. It is a standard SQL Select statement type. <\/span><\/span><\/p>\n

                                                                  Select<\/b><\/span><\/span> [all | distinct | distinctrow | top <\/b><\/span><\/span>n<\/span><\/span> [percent]] *fieldlist<\/b><\/span><\/span><\/p>\n

                                                                  From<\/b><\/span><\/span> tablelist<\/span><\/span><\/p>\n

                                                                  [<\/span><\/span>Where<\/b><\/span><\/span> criterion ]<\/span><\/span><\/p>\n

                                                                  [<\/span><\/span>Group<\/b><\/span><\/span> by<\/b><\/span><\/span> fieldlist [<\/span><\/span>having<\/b><\/span><\/span> criterion ] ]<\/span><\/span><\/p>\n

                                                                  [<\/span><\/span>Order<\/b><\/span><\/span> by<\/b><\/span><\/span> fieldlist [asc | desc] ]<\/span><\/span><\/p>\n

                                                                  [(<\/span><\/span>Inner | Left | Right | Full<\/b><\/span><\/span>)<\/span><\/span>Join <\/b><\/span><\/span>tablename<\/span><\/span> on <\/b><\/span><\/span>fieldref<\/span><\/span> <\/b>=<\/span><\/span> <\/b>fieldref<\/span><\/span> ]<\/b><\/span><\/span><\/p>\n

                                                                    \n
                                                                  1. \n

                                                                    Set<\/span><\/span><\/p>\n<\/li>\n<\/ol>\n

                                                                    Used to define script variables as opposed to the use of Let. <\/span><\/span><\/p>\n

                                                                    Set<\/b><\/span><\/span> variablename<\/span><\/span>=<\/b><\/span><\/span>string<\/span><\/span><\/p>\n

                                                                      \n
                                                                    1. \n

                                                                      Sleep<\/span><\/span><\/p>\n<\/li>\n<\/ol>\n

                                                                      It pauses script execution for a specified time.<\/span><\/span><\/p>\n

                                                                      Sleep n<\/span><\/span><\/p>\n

                                                                      Where n is any positive integer less than 3600000 representing time.<\/span><\/span><\/p>\n

                                                                        \n
                                                                      1. \n

                                                                        SQL<\/span><\/span><\/p>\n<\/li>\n<\/ol>\n

                                                                        It is used to send an arbitrary SQL command through an ODBC or OLE DB connection.<\/span><\/span><\/p>\n

                                                                        SQL sql_command<\/b><\/span><\/span><\/p>\n

                                                                          \n
                                                                        1. \n

                                                                          SQL Columns<\/span><\/span><\/p>\n<\/li>\n<\/ol>\n

                                                                          When a connection with ODBC or OLE DB data sources is made, this statement returns a set of fields describing the columns the data source. <\/span><\/span><\/p>\n

                                                                          SQLColumns<\/b><\/span><\/span><\/p>\n

                                                                            \n
                                                                          1. \n

                                                                            SQL Tables<\/span><\/span><\/p>\n<\/li>\n<\/ol>\n

                                                                            Returns a set of fields describing the tables of an ODBC or OLE DB data source after connecting to the source. <\/span><\/span><\/p>\n

                                                                            SQLTables<\/b><\/span><\/p>\n

                                                                              \n
                                                                            1. \n

                                                                              SQL Types<\/span><\/span><\/p>\n<\/li>\n<\/ol>\n

                                                                              Returns a set of fields describing the types of an ODBC or OLE DB data source which is connected to QlikView. <\/span><\/span><\/p>\n

                                                                              SQLTypes<\/b><\/span><\/span><\/p>\n

                                                                                \n
                                                                              1. \n

                                                                                Star<\/span><\/span><\/p>\n<\/li>\n<\/ol>\n

                                                                                In order to represent entire value set from a database, a string is created and selected using the star statement. <\/span><\/span><\/p>\n

                                                                                Star<\/b><\/span><\/span> is<\/b><\/span><\/span> [ string ]<\/span><\/span><\/p>\n

                                                                                  \n
                                                                                1. \n

                                                                                  Store<\/span><\/span><\/p>\n<\/li>\n<\/ol>\n

                                                                                  Used to create a QVD or a CSV file.<\/span><\/span><\/p>\n

                                                                                  Store<\/b><\/span><\/span> [*fieldlist <\/span><\/span>from<\/b><\/span><\/span>] table <\/span><\/span>into<\/b><\/span><\/span> filename[format-spec ];<\/span><\/span><\/p>\n

                                                                                    \n
                                                                                  1. \n

                                                                                    Tag<\/span><\/span><\/p>\n<\/li>\n<\/ol>\n

                                                                                    Used to assign tags to one or more fields in a table.<\/span><\/span><\/p>\n

                                                                                    Tag<\/b><\/span><\/span> fields<\/b><\/span><\/span> fieldlist <\/span><\/span>using<\/b><\/span><\/span> mapname <\/span><\/span><\/p>\n

                                                                                    Tag<\/b><\/span><\/span> field<\/b><\/span><\/span> fieldname <\/span><\/span>with<\/b><\/span><\/span> tagname<\/span><\/span><\/p>\n

                                                                                      \n
                                                                                    1. \n

                                                                                      Trace<\/span><\/span><\/p>\n<\/li>\n<\/ol>\n

                                                                                      With the help of this statement a string is written to script execution progress window and to the script log file, when they are in use. It is of significance in dubbing processes. <\/span><\/span><\/p>\n

                                                                                      Trace string<\/b><\/span><\/span><\/p>\n

                                                                                        \n
                                                                                      1. \n

                                                                                        Unmap<\/span><\/span><\/p>\n<\/li>\n<\/ol>\n

                                                                                        It is used for disabling the filed value mapping. <\/span><\/span><\/p>\n

                                                                                        Unmap<\/b><\/span><\/span> *fieldlist<\/span><\/span><\/p>\n

                                                                                          \n
                                                                                        1. \n

                                                                                          Unqualify<\/span><\/span><\/p>\n<\/li>\n<\/ol>\n

                                                                                          It used to turn off the qualifications applied on the field names using the Qualify statement.<\/span><\/span><\/p>\n

                                                                                          Unqualify<\/b><\/span><\/span> *fieldlist<\/span><\/span><\/p>\n

                                                                                            \n
                                                                                          1. \n

                                                                                            Untag<\/span><\/span><\/p>\n<\/li>\n<\/ol>\n

                                                                                            Used to remove tags from one or more fields. <\/span><\/span><\/p>\n

                                                                                            Untag<\/b><\/span><\/span> fields<\/b><\/span><\/span> fieldlist <\/span><\/span>using<\/b><\/span><\/span> mapname <\/span><\/span><\/p>\n

                                                                                            Untag<\/b><\/span><\/span> field<\/b><\/span><\/span> fieldname <\/span><\/span>with<\/b><\/span><\/span> tagname<\/span><\/span><\/p>\n

                                                                                            Follow this link to know about\u00a0QlikView Sheet and Object<\/a><\/strong><\/p>\n

                                                                                            c.\u00a0 QlikView Script Prefixes<\/h4>\n

                                                                                            QlikView script prefixes (QlikView keywords) are only applicable before regular statements; control statements never use prefixes. They might however use some suffixes.<\/span><\/span><\/p>\n

                                                                                              \n
                                                                                            1. \n

                                                                                              Add<\/span><\/span><\/p>\n<\/li>\n<\/ol>\n

                                                                                              Can add to any LOAD, SELECT or map…using statement in the script.<\/span><\/span><\/p>\n

                                                                                              Add[only]<\/b><\/span><\/span>(loadstatement|selectstatement|mapstatement<\/span><\/span>)<\/span><\/span><\/p>\n

                                                                                                \n
                                                                                              1. \n

                                                                                                Buffer<\/span><\/span><\/p>\n<\/li>\n<\/ol>\n

                                                                                                This prefix is used to create and maintain QVD files. It can also use on load and select statements. <\/span><\/span><\/p>\n

                                                                                                Buffer<\/b><\/span><\/span>[(option[,option])](loadstatement|selectstatement ) <\/span><\/span><\/p>\n

                                                                                                  \n
                                                                                                1. \n

                                                                                                  Bundle<\/span><\/span><\/p>\n<\/li>\n<\/ol>\n

                                                                                                  The Bundle prefix is used to include external files, such as image or sound files, or objects connected to a field value, to store in the qvw file.<\/span><\/span><\/p>\n

                                                                                                  Bundle<\/b><\/span><\/span> [Info]<\/b><\/span><\/span> ( loadstatement | selectstatement)<\/span><\/span><\/p>\n

                                                                                                    \n
                                                                                                  1. \n

                                                                                                    Concatenate<\/span><\/span><\/p>\n<\/li>\n<\/ol>\n

                                                                                                    This prefix is used to join or concatenate two tables even if the tables have different sets of fields.<\/span><\/span><\/p>\n

                                                                                                    concatenate<\/b><\/span><\/span>[(tablename)](loadstatement|selectstatement )<\/span><\/span><\/p>\n

                                                                                                      \n
                                                                                                    1. \n

                                                                                                      Crosstable<\/span><\/span><\/p>\n<\/li>\n<\/ol>\n

                                                                                                      This prefix is used to convert a cross table into a straight table. That means, a horizontal table with many columns is turned into a vertical table, with the column headings being placed into a single attribute column.<\/span><\/span><\/p>\n

                                                                                                      crosstable<\/b><\/span><\/span> (attribute field name, data field name [ , n ] ) ( loadstatement | selectstatement )<\/span><\/span><\/p>\n

                                                                                                        \n
                                                                                                      1. \n

                                                                                                        First<\/span><\/span><\/p>\n<\/li>\n<\/ol>\n

                                                                                                        This prefix is used for loading a fixed maximum number of records from a data source table. It can also place in front of LOAD and SELECT statement. <\/span><\/span><\/p>\n

                                                                                                        First<\/b><\/span><\/span> n( loadstatement | selectstatement )<\/span><\/span><\/p>\n

                                                                                                          \n
                                                                                                        1. \n

                                                                                                          Generic<\/span><\/span><\/p>\n<\/li>\n<\/ol>\n

                                                                                                          This prefix is used to unpack a vertical table and create a table with one field per attribute value.<\/span><\/span><\/p>\n

                                                                                                          Generic<\/b><\/span><\/span> ( loadstatement | selectstatement )<\/span><\/span><\/p>\n

                                                                                                            \n
                                                                                                          1. \n

                                                                                                            Hierarchy<\/span><\/span><\/p>\n<\/li>\n<\/ol>\n

                                                                                                            This prefix, use to transform a parent-child hierarchy table to a QlikView data model suiting. It can place in front of a LOAD or a SELECT statement <\/span><\/span><\/p>\n

                                                                                                            Hierarchy<\/b><\/span><\/span> (NodeID, ParentID, NodeName, [ParentName], [PathSource],[PathName],[PathDelimiter],[Depth])(loadstatement | selectstatement)<\/span><\/span><\/p>\n

                                                                                                            Have a look at – Working of QlikView<\/a><\/strong><\/p>\n

                                                                                                              \n
                                                                                                            1. \n

                                                                                                              HierarchyBelongsTo<\/span><\/span><\/p>\n<\/li>\n<\/ol>\n

                                                                                                              It serves the same purpose as the above Hierarchy prefix, but this prefix also specifies the ancestor table which the transformed parent-child hierarchy table beolongs to. <\/span><\/span><\/p>\n

                                                                                                              HierarchyBelongsTo<\/b><\/span><\/span> (NodeID, ParentID, NodeName, AncestorID, AncestorName, [DepthDiff])(loadstatement | selectstatement)<\/span><\/span><\/p>\n

                                                                                                                \n
                                                                                                              1. \n

                                                                                                                Image_Size<\/span><\/span><\/p>\n<\/li>\n<\/ol>\n

                                                                                                                This prefix, use to resize images from a database management system to fit in the fields. It is most commonly used with Info or Bundle prefix. <\/span><\/span><\/p>\n

                                                                                                                Info<\/b><\/span><\/span> [Image_Size(width,height )] ( loadstatement | selectstatement )<\/span><\/span><\/p>\n

                                                                                                                  \n
                                                                                                                1. \n

                                                                                                                  Info<\/span><\/span><\/p>\n<\/li>\n<\/ol>\n

                                                                                                                  Infor, use to link external information, such as a text file, a picture or a video to a field value.<\/span><\/span><\/p>\n

                                                                                                                  Info<\/b><\/span><\/span>( loadstatement | selectstatement )<\/span><\/span><\/p>\n

                                                                                                                    \n
                                                                                                                  1. \n

                                                                                                                    Inner<\/span><\/span><\/p>\n<\/li>\n<\/ol>\n

                                                                                                                    This prefix is generally use with Keep and Join prefixes. We have learned about the Keep and Join prefixes earlier in the tutorial. When an Inner Join is used, only the combination of similar fields is displayed in the joined table. Whereas, when Inner Keep is used, only the common intersecting fields are shown in the resultant table.<\/span><\/span><\/p>\n

                                                                                                                    Inner<\/b><\/span><\/span> (<\/b><\/span><\/span> Join<\/b><\/span><\/span> |<\/b><\/span><\/span> Keep)<\/b><\/span><\/span> [ (tablename) ](loadstatement |selectstatement )<\/span><\/span><\/p>\n

                                                                                                                      \n
                                                                                                                    1. \n

                                                                                                                      IntervalMatch<\/span><\/span><\/p>\n<\/li>\n<\/ol>\n

                                                                                                                      QlikView IntervalMatch<\/strong>, use to create a table where the numerical values from one table matched with the duration or intervals in another table.<\/span><\/span><\/p>\n

                                                                                                                      IntervalMatch<\/b><\/span><\/span>(matchfield)(loadstatement|selectstatement ) <\/span><\/span><\/p>\n

                                                                                                                      IntervalMatch<\/b><\/span><\/span> (matchfield,keyfield1 [ , keyfield2, … keyfield5 ] ) (loadstatement | selectstatement )<\/span><\/span><\/p>\n

                                                                                                                        \n
                                                                                                                      1. \n

                                                                                                                        Join<\/span><\/span><\/p>\n<\/li>\n<\/ol>\n

                                                                                                                        It use to join two tables during one table is loading and second table is pre-existing or is also in the state of loading. <\/span><\/span><\/p>\n

                                                                                                                        [Inner | Outer | Left | Right ] <\/span><\/span>Join<\/b><\/span><\/span> [ (tablename ) ]( loadstatement | selectstatement )<\/span><\/span><\/p>\n

                                                                                                                          \n
                                                                                                                        1. \n

                                                                                                                          Keep<\/span><\/span><\/p>\n<\/li>\n<\/ol>\n

                                                                                                                          The Keep prefix reduces and joins the common fields in two tables and displays one table as a result. Unlike in the Join, Keep does not merge thw two tables in the QlikView Memory and save it as one, but the two tables merged using Keep are stored separately. <\/span><\/span><\/p>\n

                                                                                                                          (Inner | Left | Right) <\/span><\/span>Keep<\/b><\/span><\/span> [(tablename)]( loadstatement | selectstatement)<\/span><\/span><\/p>\n

                                                                                                                          Let’s Explore\u00a0QlikView Keep Functions<\/a><\/strong><\/p>\n

                                                                                                                            \n
                                                                                                                          1. \n

                                                                                                                            Left<\/span><\/span><\/p>\n<\/li>\n<\/ol>\n

                                                                                                                            The Left prefix use with Join and Keep keywords and it commands the system to fetch the data values from the left table and display a final table having the left table fields and the fields in common with the left and right tables. <\/span><\/span><\/p>\n

                                                                                                                            Left (Join | Keep)<\/b><\/span><\/span> [(<\/b><\/span><\/span>tablename<\/span><\/span>)](<\/b><\/span><\/span>loadstatement |selectstatement <\/span><\/span>)<\/b><\/span><\/span><\/p>\n

                                                                                                                              \n
                                                                                                                            1. \n

                                                                                                                              Mapping<\/span><\/span><\/p>\n<\/li>\n<\/ol>\n

                                                                                                                              This prefix use to create a mapping table that can use for purposes like replacing field values and field names during script execution.<\/span><\/span><\/p>\n

                                                                                                                              Mapping<\/b><\/span><\/span> ( loadstatement | selectstatement )<\/span><\/span><\/p>\n

                                                                                                                                \n
                                                                                                                              1. \n

                                                                                                                                NoConcatenate<\/span><\/span><\/p>\n<\/li>\n<\/ol>\n

                                                                                                                                If two tables have identical fields then they are automatically concatenated by during execution. To keep these tables separate and avoid automatic concatenation, NoConcatenate prefix is used. <\/span><\/span><\/p>\n

                                                                                                                                NoConcatenate<\/b><\/span><\/span>( loadstatement | selectstatement )<\/span><\/span><\/p>\n

                                                                                                                                  \n
                                                                                                                                1. \n

                                                                                                                                  Outer<\/span><\/span><\/p>\n<\/li>\n<\/ol>\n

                                                                                                                                  The Outer prefix use with the keyword Join and is used to join the tables having identical fields and make a complete table without repeating similar fields in the final table. <\/span><\/span><\/p>\n

                                                                                                                                  Outer Join<\/b><\/span><\/span> [(tablename)](loadstatement |selectstatement )<\/span><\/span><\/p>\n

                                                                                                                                    \n
                                                                                                                                  1. \n

                                                                                                                                    Replace<\/span><\/span><\/p>\n<\/li>\n<\/ol>\n

                                                                                                                                    The Replace prefix replaces an already existing table with a new table while loading. The old table drops and replace by a new one. <\/span><\/span><\/p>\n

                                                                                                                                    Replace[only]<\/b><\/span><\/span>(loadstatement|selectstatement|map…usingstatement)<\/span><\/span><\/p>\n

                                                                                                                                      \n
                                                                                                                                    1. \n

                                                                                                                                      Right<\/span><\/span><\/p>\n<\/li>\n<\/ol>\n

                                                                                                                                      Just like the Left prefix, Right prefix use to only fetch the data\/field values from the right table and the resultant table will have fields from right table and the fields in common between the right and the left table. <\/span><\/span><\/p>\n

                                                                                                                                      Right<\/b><\/span><\/span> (Join | Keep)<\/b><\/span><\/span> [(tablename)](loadstatement |selectstatement )<\/span><\/span><\/p>\n

                                                                                                                                        \n
                                                                                                                                      1. \n

                                                                                                                                        Sample<\/span><\/span><\/p>\n<\/li>\n<\/ol>\n

                                                                                                                                        The sample prefix, use to load a sample of records from the data source arbitrarily. It is used with LOAD and SELECT statements.<\/span><\/span><\/p>\n

                                                                                                                                        Sample<\/b><\/span><\/span> p ( loadstatement | selectstatement )<\/span><\/span><\/p>\n

                                                                                                                                          \n
                                                                                                                                        1. \n

                                                                                                                                          Semantic<\/span><\/span><\/p>\n<\/li>\n<\/ol>\n

                                                                                                                                          The Semantic prefix use by a record to refer or point towards another relevant record like, self-references within a table. <\/span><\/span><\/p>\n

                                                                                                                                          Semantic<\/b><\/span><\/span> (loadstatement | selectstatement)<\/span><\/span><\/p>\n

                                                                                                                                            \n
                                                                                                                                          1. \n

                                                                                                                                            Unless<\/span><\/span><\/p>\n<\/li>\n<\/ol>\n

                                                                                                                                            Unless, is use to decide whether a statement should evaluate during execution or not. It is like a short alternative to the full <\/span><\/span>if..end if<\/b><\/span><\/span> statement. It use as a conditional statement.<\/span><\/span><\/p>\n

                                                                                                                                            (Unless condition statement | exitstatement Unless condition)<\/b><\/span><\/span><\/p>\n

                                                                                                                                              \n
                                                                                                                                            1. \n

                                                                                                                                              When<\/span><\/span><\/p>\n<\/li>\n<\/ol>\n

                                                                                                                                              It is similar to the Unless statement as it is also a conditional statement and decides whether or not a statement or exit clause will evaluate during script execution. <\/span><\/span><\/p>\n

                                                                                                                                              (When condition statement | exitstatement when condition)<\/b><\/span><\/span><\/p>\n

                                                                                                                                              Also, Refer QlikView Circular Reference & Loosely Coupled Tables<\/a><\/strong><\/p>\n

                                                                                                                                              d. QlikView Script Variable<\/h4>\n

                                                                                                                                              The QlikView script variables (QlikView keywords) are containers that contains data values. The values can be string or calculable values. If a defined value has \u2018=\u2019 sign in front of it, then the value will evaluate. There are several types of script variables in QlikView are:<\/span><\/span><\/p>\n

                                                                                                                                              i. Error Variables<\/span><\/span><\/p>\n

                                                                                                                                              ii. Number Interpretation Variables<\/span><\/span><\/p>\n

                                                                                                                                              iii. System Variables<\/span><\/span><\/p>\n

                                                                                                                                              iv. Value Handling Variables<\/span><\/span><\/p>\n

                                                                                                                                              v. Direct Discovery Variables<\/span><\/span><\/p>\n

                                                                                                                                              So, this was all about QlikView\u00a0script statements and keywords. Hope you like our explanation,<\/span><\/span><\/p>\n

                                                                                                                                              Conclusion<\/h3>\n

                                                                                                                                              Hence, this was a complete categoric account of QlikView script statements and keywords. We took a comprehensive view of two types of QlikView script statements; control and regular statements and two types of QlikView keywords; prefix and variables. Still, confusion? Free to share with us, surely we will get back to you!<\/span><\/span><\/p>\n

                                                                                                                                              Related Topic –\u00a0\u00a0QlikView Distribution Service <\/strong><\/a><\/p>\n

                                                                                                                                              Reference\u00a0<\/span><\/span><\/a><\/strong><\/p>\n

                                                                                                                                              In our last tutorial, we studied\u00a0QlikView Operators. Here, we will open a new chapter called QlikView Script Statements and keyword – the most crucial elements of Qlikview Scripting. Moreover, we will learn the different...<\/p>\n","protected":false},"author":6,"featured_media":37994,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[47],"tags":[17113,17114,17118,17115,17111,17110,17117,17116,17112],"class_list":["post-37950","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-qlikview","tag-qlikview-keyword","tag-qlikview-script-control-statements","tag-qlikview-script-prefixes","tag-qlikview-script-regular-statements","tag-qlikview-script-statements","tag-qlikview-script-statements-and-keywords","tag-qlikview-script-variable","tag-script-statements-in-qlikview","tag-types-of-qlikview-script-statements"],"yoast_head":"\nQlikView Script Statements | QlikView Keywords - Types and Syntax - DataFlair<\/title>\n<meta name=\"description\" content=\"QlikView Script Statements- QlikView Keywords, Types of Script Statements & Keywords in QlikView:Script Variable, Script Prefixes,Script Control & Regular\" \/>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/data-flair.training\/blogs\/qlikview-script-statements-keywords\/\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"QlikView Script Statements | QlikView Keywords - Types and Syntax - DataFlair\" \/>\n<meta property=\"og:description\" content=\"QlikView Script Statements- QlikView Keywords, Types of Script Statements & Keywords in QlikView:Script Variable, Script Prefixes,Script Control & Regular\" \/>\n<meta property=\"og:url\" content=\"https:\/\/data-flair.training\/blogs\/qlikview-script-statements-keywords\/\" \/>\n<meta property=\"og:site_name\" content=\"DataFlair\" \/>\n<meta property=\"article:publisher\" content=\"https:\/\/www.facebook.com\/DataFlairWS\/\" \/>\n<meta property=\"article:published_time\" content=\"2018-11-07T11:52:53+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2021-12-07T05:53:44+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2018\/10\/Types-of-QlikView-Script-Statements-and-Keywords-01.jpg\" \/>\n\t<meta property=\"og:image:width\" content=\"1200\" \/>\n\t<meta property=\"og:image:height\" content=\"628\" \/>\n\t<meta property=\"og:image:type\" content=\"image\/jpeg\" \/>\n<meta name=\"author\" content=\"DataFlair Team\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:creator\" content=\"@DataFlairWS\" \/>\n<meta name=\"twitter:site\" content=\"@DataFlairWS\" \/>\n<meta name=\"twitter:label1\" content=\"Written by\" \/>\n\t<meta name=\"twitter:data1\" content=\"DataFlair Team\" \/>\n\t<meta name=\"twitter:label2\" content=\"Est. reading time\" \/>\n\t<meta name=\"twitter:data2\" content=\"13 minutes\" \/>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"QlikView Script Statements | QlikView Keywords - Types and Syntax - DataFlair","description":"QlikView Script Statements- QlikView Keywords, Types of Script Statements & Keywords in QlikView:Script Variable, Script Prefixes,Script Control & Regular","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/data-flair.training\/blogs\/qlikview-script-statements-keywords\/","og_locale":"en_US","og_type":"article","og_title":"QlikView Script Statements | QlikView Keywords - Types and Syntax - DataFlair","og_description":"QlikView Script Statements- QlikView Keywords, Types of Script Statements & Keywords in QlikView:Script Variable, Script Prefixes,Script Control & Regular","og_url":"https:\/\/data-flair.training\/blogs\/qlikview-script-statements-keywords\/","og_site_name":"DataFlair","article_publisher":"https:\/\/www.facebook.com\/DataFlairWS\/","article_published_time":"2018-11-07T11:52:53+00:00","article_modified_time":"2021-12-07T05:53:44+00:00","og_image":[{"width":1200,"height":628,"url":"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2018\/10\/Types-of-QlikView-Script-Statements-and-Keywords-01.jpg","type":"image\/jpeg"}],"author":"DataFlair Team","twitter_card":"summary_large_image","twitter_creator":"@DataFlairWS","twitter_site":"@DataFlairWS","twitter_misc":{"Written by":"DataFlair Team","Est. reading time":"13 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/data-flair.training\/blogs\/qlikview-script-statements-keywords\/#article","isPartOf":{"@id":"https:\/\/data-flair.training\/blogs\/qlikview-script-statements-keywords\/"},"author":{"name":"DataFlair Team","@id":"https:\/\/data-flair.training\/blogs\/#\/schema\/person\/2c58ecb4f73a39f0ef993f1ddfcd7b89"},"headline":"QlikView Script Statements | QlikView Keywords – Types and Syntax","datePublished":"2018-11-07T11:52:53+00:00","dateModified":"2021-12-07T05:53:44+00:00","mainEntityOfPage":{"@id":"https:\/\/data-flair.training\/blogs\/qlikview-script-statements-keywords\/"},"wordCount":2828,"commentCount":0,"publisher":{"@id":"https:\/\/data-flair.training\/blogs\/#organization"},"image":{"@id":"https:\/\/data-flair.training\/blogs\/qlikview-script-statements-keywords\/#primaryimage"},"thumbnailUrl":"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2018\/10\/Types-of-QlikView-Script-Statements-and-Keywords-01.jpg","keywords":["QlikView Keyword","QlikView script control statements","QlikView Script Prefixes","QlikView script regular Statements","QlikView Script Statements","QlikView Script Statements and Keywords","QlikView Script Variable","script statements in QlikView","Types of QlikView Script Statements"],"articleSection":["QlikView Tutorials"],"inLanguage":"en-US","potentialAction":[{"@type":"CommentAction","name":"Comment","target":["https:\/\/data-flair.training\/blogs\/qlikview-script-statements-keywords\/#respond"]}]},{"@type":"WebPage","@id":"https:\/\/data-flair.training\/blogs\/qlikview-script-statements-keywords\/","url":"https:\/\/data-flair.training\/blogs\/qlikview-script-statements-keywords\/","name":"QlikView Script Statements | QlikView Keywords - Types and Syntax - DataFlair","isPartOf":{"@id":"https:\/\/data-flair.training\/blogs\/#website"},"primaryImageOfPage":{"@id":"https:\/\/data-flair.training\/blogs\/qlikview-script-statements-keywords\/#primaryimage"},"image":{"@id":"https:\/\/data-flair.training\/blogs\/qlikview-script-statements-keywords\/#primaryimage"},"thumbnailUrl":"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2018\/10\/Types-of-QlikView-Script-Statements-and-Keywords-01.jpg","datePublished":"2018-11-07T11:52:53+00:00","dateModified":"2021-12-07T05:53:44+00:00","description":"QlikView Script Statements- QlikView Keywords, Types of Script Statements & Keywords in QlikView:Script Variable, Script Prefixes,Script Control & Regular","breadcrumb":{"@id":"https:\/\/data-flair.training\/blogs\/qlikview-script-statements-keywords\/#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https:\/\/data-flair.training\/blogs\/qlikview-script-statements-keywords\/"]}]},{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/data-flair.training\/blogs\/qlikview-script-statements-keywords\/#primaryimage","url":"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2018\/10\/Types-of-QlikView-Script-Statements-and-Keywords-01.jpg","contentUrl":"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2018\/10\/Types-of-QlikView-Script-Statements-and-Keywords-01.jpg","width":1200,"height":628,"caption":"QlikView Script Statements & Keywords - Types and Syntax"},{"@type":"BreadcrumbList","@id":"https:\/\/data-flair.training\/blogs\/qlikview-script-statements-keywords\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Blog Home","item":"https:\/\/data-flair.training\/blogs\/"},{"@type":"ListItem","position":2,"name":"QlikView Tutorials","item":"https:\/\/data-flair.training\/blogs\/category\/qlikview\/"},{"@type":"ListItem","position":3,"name":"QlikView Script Statements | QlikView Keywords – Types and Syntax"}]},{"@type":"WebSite","@id":"https:\/\/data-flair.training\/blogs\/#website","url":"https:\/\/data-flair.training\/blogs\/","name":"DataFlair","description":"Learn Today. Lead Tomorrow.","publisher":{"@id":"https:\/\/data-flair.training\/blogs\/#organization"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/data-flair.training\/blogs\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"en-US"},{"@type":"Organization","@id":"https:\/\/data-flair.training\/blogs\/#organization","name":"DataFlair","url":"https:\/\/data-flair.training\/blogs\/","logo":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/data-flair.training\/blogs\/#\/schema\/logo\/image\/","url":"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2016\/07\/Data-Flair.png","contentUrl":"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2016\/07\/Data-Flair.png","width":106,"height":48,"caption":"DataFlair"},"image":{"@id":"https:\/\/data-flair.training\/blogs\/#\/schema\/logo\/image\/"},"sameAs":["https:\/\/www.facebook.com\/DataFlairWS\/","https:\/\/x.com\/DataFlairWS","https:\/\/www.linkedin.com\/company\/dataflair-web-services-pvt-ltd\/","https:\/\/www.youtube.com\/user\/DataFlairWS"]},{"@type":"Person","@id":"https:\/\/data-flair.training\/blogs\/#\/schema\/person\/2c58ecb4f73a39f0ef993f1ddfcd7b89","name":"DataFlair Team","image":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/secure.gravatar.com\/avatar\/1ce4a0e3e542444fc73bbebf83e89e8b73e2d95ccb1fcee64da9945f078b97c5?s=96&d=mm&r=g","url":"https:\/\/secure.gravatar.com\/avatar\/1ce4a0e3e542444fc73bbebf83e89e8b73e2d95ccb1fcee64da9945f078b97c5?s=96&d=mm&r=g","contentUrl":"https:\/\/secure.gravatar.com\/avatar\/1ce4a0e3e542444fc73bbebf83e89e8b73e2d95ccb1fcee64da9945f078b97c5?s=96&d=mm&r=g","caption":"DataFlair Team"},"description":"The DataFlair Team provides industry-driven content on programming, Java, Python, C++, DSA, AI, ML, data Science, Android, Flutter, MERN, Web Development, and technology. Our expert educators focus on delivering value-packed, easy-to-follow resources for tech enthusiasts and professionals.","url":"https:\/\/data-flair.training\/blogs\/author\/dfteam2\/"}]}},"amp_enabled":true,"_links":{"self":[{"href":"https:\/\/data-flair.training\/blogs\/wp-json\/wp\/v2\/posts\/37950","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/data-flair.training\/blogs\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/data-flair.training\/blogs\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/data-flair.training\/blogs\/wp-json\/wp\/v2\/users\/6"}],"replies":[{"embeddable":true,"href":"https:\/\/data-flair.training\/blogs\/wp-json\/wp\/v2\/comments?post=37950"}],"version-history":[{"count":7,"href":"https:\/\/data-flair.training\/blogs\/wp-json\/wp\/v2\/posts\/37950\/revisions"}],"predecessor-version":[{"id":105003,"href":"https:\/\/data-flair.training\/blogs\/wp-json\/wp\/v2\/posts\/37950\/revisions\/105003"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/data-flair.training\/blogs\/wp-json\/wp\/v2\/media\/37994"}],"wp:attachment":[{"href":"https:\/\/data-flair.training\/blogs\/wp-json\/wp\/v2\/media?parent=37950"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/data-flair.training\/blogs\/wp-json\/wp\/v2\/categories?post=37950"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/data-flair.training\/blogs\/wp-json\/wp\/v2\/tags?post=37950"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}