Welcome to Scribd, the world's digital library. Read, publish, and share books and documents. See more
Standard view
Full view
of .
Save to My Library
Look up keyword or section
Like this

Table Of Contents

Chapter 1. Defining custom operators
Compiling operators
Using your operator
Chapter 2. Creating operators
Derivation requirements for APT_Operator base class
The APT_Operator class interface
APT_Operator derivation examples
ExampleOperator example
HelloWorldOp example
Including additional APT_Operator member functions
Defining parallel and sequential operators
Creating parallel operators
Creating sequential operators
Creating operators that can be either parallel or sequential
Specifying input and output interface schemas
Schema variables
Operators with dynamic interface schemas
Specifying a partitioning method
Specifying partitioning style
Specifying sort keys
Specifying a collection method
Using cursors
Using field accessors
Field accessors and schema variables
Field accessors and dynamic operators
Examples of operator derivations with options
Including schema variables in an interface schema
The transfer mechanism
Working with dynamic interface schemas
Customizing job monitoring messages
Customizing metadata and summary response messages
Generating custom messages asynchronously
Declaring external data for MetaStage
Chapter 3. Composite operators
A composite operator with two suboperators
The APT_CompositeOperator class interface
Composite operator example derivation
Chapter 4. Subprocess operators
The APT_SubProcessOperator class interface
Deriving from APT_SubProcessOperator
Subprocess operator example derivation
Chapter 5. Localizing messages
Using the messaging macros
Descriptions of the message macros
Message environment variables
Localizing message code
Convert a multi-line message
Convert a message with no run time variables
Convert a message with run time variables
Steps to convert pre-NLS messages
Eliminating deprecated interfaces
Chapter 6. Argument-list processor
The advantages of argument-list processing
Supplying an argument-list description
Argument-list description elements
Structure of the generated property list
Argument-list description syntax
Argument-list description examples
Property list encoding of operator arguments
Traversing a property list
Error handling
Command-line argument errors
Usage strings
Executing your custom operator
Chapter 7. Type conversions
Default type conversions
Non-default predefined type conversions
Define custom type-conversion functions
Example: Using predefined type conversions
Example: Creating new type conversions
How record fields are referenced
Example of accessing records with cursors
Field accessors
Define field accessors
Chapter 9. Creating Partitioners
Setting the preserve-partitioning flag
Choosing a partitioning method
Using the default partitioning method
Using a keyless partitioning method
Using the class APT_HashPartitioner
Using the class APT_RangePartitioner
The APT_Partitioner class interface
Creating a custom partitioner
Overriding APT_Partitioner::setupInputs()
Overriding APT_Partitioner::partitionInput()
Overriding APT_Partitioner::getPartitioningStyle()
Example partitioning method definition
Hashing functions
Using a view adapter with a partitioner
Chapter 10. Creating Collectors
Choosing a collection method
How APT_Collector operates
Overriding APT_Collector::describeCollector()
Overriding APT_Collector::setupInputs()
Overriding APT_Collector::selectInput()
Example collector derivation
Example collector with a view adapter
Chapter 11. Field Lists
Creating a field list
The APT_FieldList class interface
Expanding a field list
Using field lists with operators
Simple persistence and complex persistence
Storing and loading simple and complex persistent objects
Store an object
Load an object into memory on the processing node
Create archives
The APT_Archive class interface
Using the serialization operators
Defining simple-persistent classes
Defining complex-persistent classes
The APT_Persistent class interface
Implementing APT_Persistent::serialize()
Serializing pointers
Serializing arrays
Persistence macros
Chapter 13. Run time type information
Determining the run time data type of an object
Performing casts
Adding RTTI support to derived classes
RTTI macros
Derivation macros
Application macros
Chapter 14. Using the error log
The APT_ErrorLog Class interface
Base class error log functions
The error log compared to the assertion failures facility
Error log structure
Define message identifiers
Use the error log in a derived operator
Chapter 15. Advanced features
Generic functions, accessors, and dynamic schema
Combinable operators
When to use combinable operators
Using combinable operators
Methods used by combinable operators
The combinable controller
Limitations and risks
End-of-wave batch processing
Making an operator wave-aware
Per-partition processing
Contacting IBM
Software services
Product documentation
How to read syntax diagrams
Product accessibility
Notices and trademarks
0 of .
Results for:
No results containing your search query
P. 1
InfoSphere DS8

InfoSphere DS8

Ratings: (0)|Views: 213 |Likes:
Published by sohagiya

More info:

Published by: sohagiya on Sep 05, 2010
Copyright:Attribution Non-commercial


Read on Scribd mobile: iPhone, iPad and Android.
download as PDF, TXT or read online from Scribd
See more
See less





You're Reading a Free Preview
Pages 5 to 80 are not shown in this preview.
You're Reading a Free Preview
Pages 85 to 118 are not shown in this preview.
You're Reading a Free Preview
Pages 123 to 141 are not shown in this preview.
You're Reading a Free Preview
Pages 146 to 184 are not shown in this preview.
You're Reading a Free Preview
Pages 189 to 221 are not shown in this preview.

You're Reading a Free Preview

/*********** DO NOT ALTER ANYTHING BELOW THIS LINE ! ************/ var s_code=s.t();if(s_code)document.write(s_code)//-->