Integrate DB2 for z/OS with InfoSphere BigInsights, Part 2: Use the InfoSphere BigInsights connector to perform analysis using Jaql and SQL

Learn how to set up integration between IBM® DB2® 11 for z/OS® and IBM® InfoSphere® BigInsights™. Enable access to structured and non-structured data that is stored in the Hadoop Distributed File System and send the results back to DB2, where the data can be integrated with online transactional data. Using a scenario that is common to all DB2 for z/OS users, create a big data solution that uses the user-defined functions JAQL_SUBMIT and HDFS_READ to run jobs on InfoSphere BigInsights and retrieve the results using SQL.

Jane Man (janeman@us.ibm.com), Senior Software Engineer, IBM

Jane ManJane Man is a senior software engineer and one of the original members of the XML development team in DB2 for z/OS. She has worked on various features of DB2 for z/OS. In addition to her development work, she is the enablement focal point in the team and is involved in many XML enablement activities, like creating XML sample applications, demos, Hands on Labs, and presenting in conferences and XML boot camps. Before she joined the XML team, Jane was a developer in IBM Content Manager. Jane is an IBM Certified System Administrator for WebSphere Application Server, IBM Certified Database Administrator for DB2 Universal Database for z/OS, Linux, UNIX, and Windows, IBM Certified Solution Designer for DB2 Content Manager, IBM Certified Deployment Profession for Tivoli Storage Manager, and IBM Certified Application developer for DB2 Universal Database Family.



Jason Cu (jasoncu@us.ibm.com), Senior Software Engineer, IBM

Photo of Jason CuJason Cu is a senior software engineer who works on the development of DB2 for z/OS. He worked on adding many important features to DB2, including Unicode and XML, and now works on big data integration and SQL architecture. Jason also spent part of his career doing development for InfoSphere BigInsights where he worked on Jaql, BigSQL, and open source.



Rick Chang (crong@us.ibm.com), Advisory Software Engineer , IBM

Rick Chang photoRick Chang, a software engineer for over 20 years, has worked on different projects in the area of storage management, e-commerce, contain management, and recently DB2. Rick joined DB2 for z/OS team in 2005 and worked on XML publishing function, XPath, and XQuery features for DB2 for z/OS.



17 June 2014

In this article, explore how to create a big data solution that integrates IBM® DB2® 11 for z/OS® and IBM® InfoSphere® BigInsights™ 2.1.1. Learn how to use the InfoSphere BigInsights connector in DB2 for z/OS to perform analysis by using Jaql and SQL. Part 1 shows how to configure DB2 to set up the InfoSphere BigInsights connector.

InfoSphere BigInsights Quick Start Edition

InfoSphere BigInsights Quick Start Edition is a complimentary, downloadable version of InfoSphere BigInsights, IBM's Hadoop-based offering. Using Quick Start Edition, you can try out the features that IBM built to extend the value of open source Hadoop, like Big SQL, text analytics, and BigSheets. Download BigInsights Quick Start Edition now.

Using the following basic steps, you can analyze jobs that run on a mainframe by using Jaql to process the z/OS syslog:

  • Use the JAQL_SUBMIT function of InfoSphere BigInsights to issue SQL statements to DB2 for z/OS to submit jobs to the InfoSphere BigInsights cluster.
  • Use the HDFS_READ function to read the results back to DB2.

Figure 1 shows a sample of the syslog that is to be analyzed.

Figure 1. Sample of the syslog that is to be analyzed
Sample of the syslog that will be analyzed

Using the main Jaql operators in examples

The examples in this paper are intended to demonstrate the main operators in Jaql. These analyses are typically written by an analyst who is an expert in Jaql. Although a full-fledged Jaql tutorial is beyond the scope of this article, these exercises give examples of the kinds of analysis that can be performed with Jaql.

The first query starts with a relatively simple Jaql script and each subsequent exercise builds upon the previous example. The examples become increasingly complex.

Count the number of jobs that are started in the syslog

This first example and several subsequent examples follow the same pattern of the sample SQL in Part 1 this series. The JAQL_SUBMIT function is used to run a Jaql analysis on InfoSphere BigInsights and is embedded in HDFS_READ, which reads the result back for processing in SQL. These first few examples show some kinds of analysis that you can do with Jaql.

Listing 1. Run initial Jaql query
SELECT BIGINSIGHTS.CNT FROM
TABLE
(HDFS_READ
 (JAQL_SUBMIT
 ('syslog = lines("hdfs:///idz1470/syslog3sec.txt");

 [localRead(syslog)->filter(strPos($,"$HASP373")>=0)->count()]->
 write(del(location="hdfs:///idz1470/lab3e2.csv"));',

 'http://bi.ibm.com:14000/webhdfs/v1/idz1470/lab3e2.csv?op=OPEN',

 'http://bi.ibm.com:8080',
 'timeout=1000'
 ),
 ''
 )
)
AS BIGINSIGHTS(CNT INTEGER);

In Listing 1, the first line of the Jaql script in this query defines a Jaql variable syslog. The query reads the syslog file from the HDFS hdfs:///idz1470/syslog3sec.txt file by using the lines operator.

That result is piped to the filter operator filter(strPos($,"$HASP373")>=0). The arrow -> operator is called a pipe in Jaql. The filter determines which lines to keep. In this exercise, the filter uses the built-in Jaql function strPos to determine whether there is an occurrence of the string $HASP373 (a start job message code) in the line. A non-negative position of $HASP373 indicates that there is at least one occurrence.

The filtered result is piped again to the count function and the result of the count function is written to the hdfs:///idz1470/lab3e2.csv file.

Show the lines that contain $HASP373 messages

After you apply the filters to reduce the analysis to a reasonably sized data set, you might want to display the lines that were not filtered. With these lines, you can perform further analysis.

Listing 2. Display unfiltered data
SELECT BIGINSIGHTS.LINE FROM
TABLE
(HDFS_READ
(JAQL_SUBMIT
 ('syslog = lines("hdfs:///idz1470/syslog3sec.txt");

   localRead(syslog)->filter(strPos($,"$HASP373")>=0)->
   write(del(location="hdfs:///idz1470/lab3e3.csv"));',

  'http://bi.ibm.com:14000/webhdfs/v1/idz1470/lab3e3.csv?op=OPEN',

   'http://bi.ibm.com:8080',
  'timeout=1000'
 ),
 ''
)
)


AS BIGINSIGHTS(LINE VARCHAR(116));

This query in Listing 2 does not use the count operator. The lines are returned as strings. The GENERIC TABLE returned by HDFS_READ contains a single column of type VARCHAR(116) to hold the lines from the syslog.

After the query runs successfully, you can see output similar to Listing 3:

Listing 3. Sample output of a successful query

Click to see code listing

Listing 3. Sample output of a successful query

LINE
N 4000000 STLAB28  13189 20:30:00.20 JOB07351 00000010  $HASP373 PJ907163 STARTED - INIT PJ   - CLASS V - SYS 28
N 4000000 STLAB28  13189 20:30:00.20 JOB07348 00000010  $HASP373 C5LEG003 STARTED - INIT K1   - CLASS L - SYS 28
N 4000000 STLAB28  13189 20:30:00.21 JOB07288 00000010  $HASP373 T1XRP010 STARTED - INIT D6   - CLASS 8 - SYS 28 
N 4000000 STLAB28  13189 20:30:00.21 JOB07290 00000010  $HASP373 T1XRP018 STARTED - INIT D9   - CLASS 8 - SYS 28
N 4000000 STLAB28  13189 20:30:00.21 JOB07287 00000010  $HASP373 T1XRP022 STARTED - INIT D7   - CLASS 8 - SYS 28
N 4000000 STLAB28  13189 20:30:00.21 JOB07289 00000010  $HASP373 T1XRP002 STARTED - INIT D5   - CLASS 8 - SYS 28
N 4000000 STLAB28  13189 20:30:00.26 JOB07413 00000010  $HASP373 PJ907165 STARTED - INIT PJ   - CLASS V - SYS 28
N 4000000 STLAB28  13189 20:30:00.26 JOB07419 00000010  $HASP373 PJ907164 STARTED - INIT PJ   - CLASS V - SYS 28
N 4000000 STLAB28  13189 20:30:08.71 JOB07349 00000010  $HASP373 T1XRP006 STARTED - INIT D0   - CLASS 8 - SYS 28
N 4000000 STLAB28  13189 20:30:08.71 JOB07350 00000010  $HASP373 T1XRP014 STARTED - INIT D8   - CLASS 8 - SYS 28
N 4000000 STLAB28  13189 20:30:17.25 JOB07490 00000010  $HASP373 T1XRP022 STARTED - INIT D7   - CLASS 8 - SYS 28
N 4000000 STLAB28  13189 20:30:17.25 JOB07492 00000010  $HASP373 T1XRP002 STARTED - INIT D5   - CLASS 8 - SYS 28
N 4000000 STLAB28  13189 20:30:17.28 JOB07494 00000010  $HASP373 PJ907289 STARTED - INIT PJ   - CLASS V - SYS 28
N 4000000 STLAB28  13189 20:30:17.29 JOB07495 00000010  $HASP373 PJ907287 STARTED - INIT PJ   - CLASS V - SYS 28
....
161 record(s) selected

Show job names together with start times

From the full line that contains $HASP373, you can extract pieces of the line that are important to your analysis. In Jaql, use the transform operator to convert the line into another form.

Listing 4. Convert a line to another form
SELECT BIGINSIGHTS.* FROM
TABLE
(HDFS_READ
 (JAQL_SUBMIT
 ('syslog = lines("hdfs:///idz1470/syslog3sec.txt");

 hasp373 = localRead(syslog)->filter(strPos($,"$HASP373")>=0)->
transform({jobname:substring($,66,74),start:substring($,26,37)});

 hasp373->write(del(location="hdfs:///idz1470/lab3e4.csv",
 schema=schema{jobname:string,start:string}
 ));',
 'http://bi.ibm.com:14000/webhdfs/v1/idz1470/lab3e4.csv?op=OPEN',
 'http://bi.ibm.com:8080',
 'timeout=1000'
 ),
 ''
 )
)
AS BIGINSIGHTS(JOBNAME CHAR(8), START TIME);

The Jaql in Listing 4 follows the same pattern as the previous two in that it reads lines and filters down to only those lines that contain $HASP373.

For each line that contains $HASP373, you apply the transform operator to convert the line into a Jaql record. The Jaql data model is JavaScript Object Notation (JSON); therefore, the record that you want to produce is a JSON object:

{
 jobname: extract_the_job_name,
 start: extract_the_time
}

To produce the JSON object, use the transform to create a new record. The record's contents are extracted from the line by using the substring built-in function.

After the transform is applied, you have a Jaql array of records that contain the job names and start times. The array is written to the hdfs:///idz1470/lab3e4.csv file.

When the data is written to the file, a schema is provided to the Jaql del descriptor schema=schema{jobname:string,start:string}. The schema describes the records that are being written to the file so that they are appropriately written as a comma-separated file.

Because the file that Jaql wrote now contains multiple columns that are separated by a comma, the GENERIC TABLE returned by HDFS_READ specifies multiple columns as well.

After the code runs successfully, you can see output similar to:

JOBNAMESTART
PJ90716320:30:00
C5LEG00320:30:00
T1XRP01020:30:00
T1XRP01820:30:00
T1XRP02220:30:00
T1XRP00220:30:00
PJ90716520:30:00
PJ90716420:30:00
T1XRP00620:30:08
T1XRP01420:30:08
T1XRP02220:30:17
T1XRP00220:30:17
PJ90728920:30:17
PJ90728720:30:17
PJ90729020:30:17
PJ90728820:30:17
PJ90734820:30:17
PJ90728620:30:17

Show which jobs have multiple occurrences

The power of parallelism in the MapReduce framework applies to filters and transforms, which are typically accomplished in map tasks. It also applies to grouping operations similar to those specified by SQL GROUP BY clauses, which are typically performed in the reduce task.

In the previous exercise, you extract job names from the syslog. In this exercise, group the lines by job name and count the number of occurrences per job.

Listing 5. Group lines by jobname and count occurrences
SELECT BIGINSIGHTS.* FROM
TABLE
(HDFS_READ
 (JAQL_SUBMIT
 ('syslog = lines("hdfs:///idz1470/syslog3sec.txt");

 hasp373 = localRead(syslog)->filter(strPos($,"$HASP373")>=0)->
 transform({jobname:substring($,66,74)});

 hasp373->group by job=$.jobname as jobs into
 {jobname:job, occurs: count(jobs)}->
 filter ($.occurs>1)->
 write(del(location="hdfs:///idz1470/lab3e6.csv",
 schema=schema{jobname:string,occurs:long}
 ));',

 'http://bi.ibm.com:14000/webhdfs/v1/idz1470/lab3e6.csv?op=OPEN',

 'http://bi.ibm.com:8080',
 'timeout=1000'
 ),
 ''
 )
)
AS BIGINSIGHTS(JOBNAME CHAR(8), OCCURS SMALLINT);

The first part of the Jaql script extracts an array of records that contain job names, a process that is similar to what is done in the prior example.

hasp373 = localRead(syslog)->filter(strPos($,"$HASP373")>=0)->
 transform({jobname:substring($,66,74)});

The array of records is assigned to the variable hasp373. This variable is assigned primarily to make the script more readable and to avoid one long line of Jaql code. Variable assignments such as these typically do not result in a materialization of the data.

On the next line, hasp373 is piped to the group by operator.

hasp373->group by job=$.jobname as jobs into
 {jobname:job, occurs: count(jobs)}-> write(del(location="hdfs:///idz1470/lab3e6.csv",
 schema=schema{jobname:string,occurs:long},
 quoted=false
   ));

The group by operator specifies both the field to group by, which is the job (job=$.jobname as jobs); and the result of the grouping. The result of the grouping is another record that contains job names and occurrences. This record is computed by applying the Jaql count built-in aggregate function {jobname:job, occurs: count(jobs)}.

The result of the group by operator is piped again to a filter filter ($.occurs>1), which removes the records that do not have a count larger than one. SQL users can think of this filter as a HAVING predicate.

The remaining records are written to the hdfs:///idz1470/lab3e6.csv file with the appropriate schema, where they can be read by HDFS_READ.

After the code runs successfully, you can see output similar to:

JOBNAMEOCCURS
T1CMD282
T1XRP0067
C5SQ20035
T1XRP0028
T1XRP0108
C5LEG0038
T1QDM283
T1XRP0188
T1NES0023
T1XRP0147
T1LEG0025
T1XRP0228

Taking advantage of Jaql extensibility

This article covers only the surface of the power Jaql brings to your analytics. Beyond being a JSON query language, you can extend Jaql to define custom behavior to make building your analysis easier.

  • Jaql scripts can be organized in modules that can be shared across multiple scripts. This arrangement enables common fragments of Jaql to be easily reused in a modular fashion.
  • Jaql user-defined functions can be written in Jaql or Java™ code. These features can be used to build a customized analytics script library. Because Jaql is extensible in Java, complex functionality can be called from within Jaql. Examples include running shell commands, reading data from other databases, or even coding custom MapReduce jobs.
  • InfoSphere BigInsights includes Eclipse integration for Jaql to maximize developer productivity.

Running JAQL_SUBMIT as a stand-alone query

Your workflow might require DB2 to start an analysis on InfoSphere BigInsights, but not integrate the result with operational data immediately. To meet this requirement, you can invoke the JAQL_SUBMIT function by itself without a surrounding invocation of HDFS_READ, as shown in the first example. The Jaql script is run on InfoSphere BigInsights, and the result file is written to HDFS where it can be consumed by other InfoSphere BigInsights scripts.

Listing 6. Run a stand-alone Jaql query
SET RESULTVAR = JAQL_SUBMIT
 ('syslog = lines("hdfs:///idz1470/syslog3sec.txt");

 [localRead(syslog)->filter(strPos($,"$HASP373")>=0)->count()]->
 write(del(location="hdfs:///idz1470/lab3e2.csv"));',

 'http://bi.ibm.com:14000/webhdfs/v1/idz1470/lab3e2.csv?op=OPEN',

 'http://bi.ibm.com:8080',
 'timeout=1000'
  );

Integrating HDFS_READ with SQL

The previous examples embed the entire Jaql script that contains the analysis in the SQL in the call to JAQL_SUBMIT. In practice, it is more common that the analysis is built and run by someone other than the database team. Either a simple JAQL_SUBMIT is required, or the output HDFS file that contains the analysis results is provided and no JAQL_SUBMIT is required.

Running HDFS_READ as a stand-alone

In the prior examples, you invoke HDFS_READ with a nested JAQL_SUBMIT. The first argument to HDFS_READ is the name of the HDFS file to be read. In these examples, HDFS_READ is invoked without the nested JAQL_SUBMIT. The HDFS file might be populated by a process other than JAQL_SUBMIT, or the file might be written by an earlier call to JAQL_SUBMIT and is being re-read in SQL.


This example specifies the URL of the file directly in the HDFS_READ function. Use the power of SQL to manipulate the results. Assume that the InfoSphere BigInsights MapReduce job produces a manageable list of job names and start times and you want to create a customized report in SQL. Rather than building more Jaql for the reporting, you can use SQL to perform the GROUP BY and HAVING. functions, as shown in the following code listing.

Listing 7. Run HDFS_READ as stand-alone
-- read file, group to occurrences in db2
SELECT JOBNAME, COUNT(*) AS OCCURS
FROM TABLE
(HDFS_READ
 (
'http://bi.ibm.com:14000/webhdfs/v1/idz1470/lab3e4.csv?op=OPEN',
 ''
 )
)
AS BIGINSIGHTS(JOBNAME CHAR(8), START TIME)
GROUP BY JOBNAME
HAVING COUNT(*) > 1;

Joining HDFS_READ output to another table

You might have some common data sets stored in DB2, and although the analysis is performed on the InfoSphere BigInsights cluster, it becomes necessary to join the results to DB2 tables to produce meaningful results.

Assume that you have a set of tables that define a job catalog and the owning departments of the jobs, as shown in the Listing 8.

Listing 8. Join your results to DB2 tables
CREATE TABLE IOD02S.DEPT
(DEPTID INTEGER NOT NULL,
 MANAGER INTEGER,
 DEPTNAME VARCHAR(50),
 PRIMARY KEY (DEPTID),
);

CREATE TABLE IOD02S.JOBCAT
(OWNERDEPT INTEGER NOT NULL,
 JOBNAME CHAR(8) NOT NULL,
 COMMENT VARCHAR(50),
 PRIMARY KEY (OWNERDEPT, JOBNAME),
 FOREIGN KEY (OWNERDEPT) REFERENCES IOD02S.DEPT(DEPTID)
);

SELECT * from IOD02S.DEPT
DEPTID      MANAGER     DEPTNAME
21000       10013       DEMO SYSTEMS AND SERVICES
21010       10010       DB2 UDFS AND SP
21020       10012       DB2 XML
21030       10011       DB2 SQL
….

SELECT * from IOD02S.JOBCAT
OWNERDEPT   JOBNAME  COMMENT
21020       C5CPX002 RUN XMLTABLE JOB
21020       C5EAX003 RUN XMLQUERY JOB
21020       C5EAX007 RUN XMLTABLE JOB
21020       C5LEG003 RUN XML PERFORMANCE JOB
21020       C5NES001 RUN XML INDEX JOB
21020       C5NES002 RUN XMLQUERY JOB
21020       C5NES004 RUN XMLTABLE JOB
21020       C5SQ2003 RUN XMLEXISTS JOB
…….

Assume that the code in Listing 9 is the part of the output from the "occurrence of each job" that is in the idz1470/lab3e5.csv file.

Listing 9. Partial output for jobname and occurrences
JOBNAME     OCCURS
PJ907163    1      
C5EAX007    1      
PJ907289    1      
PJ907761    1      
PJ908484    1  
…  
T1CMD28     2      
T1EAX010    1
….
-- read file, jobname, and occurrences
-- join to JOBCAT table
SELECT T1.JOBNAME, J.COMMENT, T1.OCCURS
FROM
TABLE
(HDFS_READ
(
'http://bi.ibm.com:14000/webhdfs/v1/idz1470/lab3e5.csv?op=OPEN',
''
)
)
AS T1(JOBNAME CHAR(8), OCCURS SMALLINT),
IOD02S.JOBCAT J, IOD02S.DEPT D
WHERE J.JOBNAME = T1.JOBNAME
AND J.OWNERDEPT = D.DEPTID;

The SQL statement in Listing 9 joins the result of the HDFS_READ function to the IOD02S.JOBCAT and IOD02S.DEPT operations to produce a report that includes a job description and the name of the owning department of the jobs run in this period of SYSLOG. After a successful execution, you might see output similar to:

JOBNAMECOMMENTOCCURS
C5CPX002RUN XMLTABLE JOB1
C5EAX003RUN XMLQUERY JOB1
C5EAX007RUN XMLTABLE JOB1
C5LEG003RUN XML PERFORMANCE JOB8
C5NES001RUN XML INDEX JOB1
C5NES002RUN XMLQUERY JOB1
C5NES004RUN XMLTABLE JOB1
C5SQ2003RUN XMLEXISTS JOB5
PJ906521TEST UDFS JOB 1001
PJ906586TEST UDFS JOB 2001
T1XRP010SQL SPECIAL REGISTER JOB8
T1XRP014SQL HOST VARIABLE JOB7
T1XRP018SQL BIND JOB8
T1XRP022SQL DELETE JOB8

Create a view on HDFS_READ for transparent access

You can make access to the BigInsights cluster transparent for users of DB2 SQL. As shown in the following code-listing, create a view on HDFS_READ to make it seem as if the results from InfoSphere BigInsights look the same as any other DB2 table.

Listing 10. Create an HDFS_READ view to see results
-- read file, jobname and occurrences
-- join to JOBCAT table
CREATE VIEW IOD00S.JOB_RUNTIME
AS SELECT JOBNAME, OCCURS, TOTALRUNTIME
FROM
TABLE
(HDFS_READ
 (
'http://bi.ibm.com:14000/webhdfs/v1/idz1470/lab3e9.csv?op=OPEN',
 ''
 )
)
AS T1(JOBNAME CHAR(8), OCCURS SMALLINT, TOTALRUNTIME BIGINT)
WHERE T1.TOTALRUNTIME > 30000;

The view that is created by this code shows contents that satisfy the SELECT statement from an HDFS_READ table expression.

This view can be used in a stand-alone SQL SELECT statement. SQL developers need not be concerned that the data is being served from InfoSphere BigInsights. You can use the JOB_RUNTIME view in more complex SQL, including joins, grouping, and sorting. In the following simple example, the view is joined to the JOBCAT table.

-- Join the view to DB2 tables
SELECT *
FROM IOD00S.JOB_RUNTIME R, IOD02S.JOBCAT J
WHERE J.JOBNAME=R.JOBNAME

Writing HDFS_READ into another table

Creating a view according to this method includes these benefits:

  • Access is the same as it would be for a regular DB2 table
  • The data is always current with the InfoSphere BigInsights cluster because each time the view is accessed, the data is pulled over the network.

In cases where the data is accessed frequently and the result set is large, the network traffic might slow performance.

An alternative is to create a real table in DB2 to hold the results of the SELECT statement from the HDFS_READ statement, as shown in Listing 11. You can use the DB2 INSERT SQL statement to populate your new table. The advantages of using this method include these benefits:

  • Because a real table with data is stored in DB2, access is as you would expect from accessing a DB2 table directly.
  • The table can be indexed and cached in the buffer pool for performance.

The disadvantage is that if the data on the InfoSphere BigInsights cluster changes, the data must be refreshed manually in DB2.

Listing 11. Create a DB2 table to hold the results of HDFS_READ
-- CREATE a table to hold job names and start times
CREATE TABLE IOD00S.JOB_STATS
(JOBNAME CHAR(8),
 STARTTIME TIME
);


-- INSERT into the newly created table
INSERT INTO IOD00S.JOB_STATS
SELECT JOBNAME, START TIME
FROM
TABLE
(HDFS_READ
 (
'http://bi.ibm.com:14000/webhdfs/v1/idz1470/lab3e4.csv?op=OPEN',
 ''
 )
)
AS T1(JOBNAME CHAR(8), START TIME);
These SQL create the new table and populate it with data by using HDFS_READ.
Then, we may select from the table in any way that we like.

-- SELECT from the newly created table
SELECT * FROM IOD00S.JOB_STATS
ORDER BY STARTTIME DESC;

Summary

This article describes how to enable the DB2 11 for z/OS server to integrate with InfoSphere BigInsights. Using a DB2 syslog as an example, it demonstrates how to create a big data solution by using the JAQL_SUBMIT and HDFS_READ functions to run jobs on InfoSphere BigInsights and retrieve the results by using SQL.


Acknowledgments

Thanks to Joachim Limburg for his comments and assistance with this article.

Resources

Learn

Get products and technologies

Discuss

Comments

developerWorks: Sign in

Required fields are indicated with an asterisk (*).


Need an IBM ID?
Forgot your IBM ID?


Forgot your password?
Change your password

By clicking Submit, you agree to the developerWorks terms of use.

 


The first time you sign into developerWorks, a profile is created for you. Information in your profile (your name, country/region, and company name) is displayed to the public and will accompany any content you post, unless you opt to hide your company name. You may update your IBM account at any time.

All information submitted is secure.

Choose your display name



The first time you sign in to developerWorks, a profile is created for you, so you need to choose a display name. Your display name accompanies the content you post on developerWorks.

Please choose a display name between 3-31 characters. Your display name must be unique in the developerWorks community and should not be your email address for privacy reasons.

Required fields are indicated with an asterisk (*).

(Must be between 3 – 31 characters.)

By clicking Submit, you agree to the developerWorks terms of use.

 


All information submitted is secure.

Dig deeper into Big data and analytics on developerWorks


static.content.url=http://www.ibm.com/developerworks/js/artrating/
SITE_ID=1
Zone=Big data and analytics
ArticleID=974417
ArticleTitle=Integrate DB2 for z/OS with InfoSphere BigInsights, Part 2: Use the InfoSphere BigInsights connector to perform analysis using Jaql and SQL
publish-date=06172014