Studio Online Help
TIBCO Product Documentation and Support Services
How to Access TIBCO Documentation
How to Contact TIBCO Support
How to Join TIBCO Community
Legal and Third-Party Notices
Installation and Upgrade Guide
Preparing for Installation
Software Components for Installation
Overview of Installation
Tracking and Documenting Your Install or Upgrade
Installation Requirements and Support Information
Disk Space and Physical Memory Requirements
Minimum Installation Requirements
Sizing Guidelines for TDV
Port Requirements
Studio and Server Connectivity and Installer Limitations
TDV Supported Platforms
Java Support
Operating System Support for Studio
Operating System Support for Server
Support for Virtualization Environments
Driver Support
SNMP Support
Web Service Protocols
Directory Services Support for LDAP
Options and Features Supported for Use with TDV
Kerberos Support
Web Browser Support
Browsers and Kerberos Support
Directory Services Support for Kerberos
Supported Data Sources
Supported Add-On Adapters
Supported Advanced Data Source Adapters
Supported Cache Targets
Data Ship Source and Target Support
TDV DDL Feature Support
Supported Client Applications
Client Application Target Framework
Enterprise Service Buses
Client-Side ADO.NET Driver Support
Data Sources Supported for Kerberos Token Pass-through
Security Features
Support and Maintenance Policies for TIBCO Products
Limitations for TDV Discovery
Installing TDV, Studio, and Drivers
Overview of Installation Steps
Installation Overview for New TDV Software Customers
Installation Overview for Existing Customers Upgrading from a Previous Release
Preparing Your System for Installation
Preparing UNIX for TDV Installation
Preparing Microsoft Windows for TDV Installation
Installing on Windows
Running the TDV Server Installer
Running the Studio Installer
Installing the Drivers
Installing on UNIX
Installing TDV Server on UNIX
Installing Drivers on UNIX
Setting the TDV Server to Start Automatically on UNIX
Installing on Amazon Web Service
About TDV Software Patches
About the Installed TDV Services
Importing Metadata into the New TDV Instance
Tips from an Expert if the Server Does Not Start
Where to Go After Installation
Silent Mode Installation
TDV Docker Container
Prerequisites
Docker
TDV
Building TDV Docker Images
Using Quick Start Script
Using Docker Build
Publishing TDV Docker Images
Launching TDV Containers
Launching TDV Containers (Single Node) - Using Quick Start Script
Launching TDV Containers (Single Node) - Using Docker Compose
Launching TDV Containers (Single Node) - Using Docker Run
Launching TDV Containers (Cluster Nodes) - Using Quick Start Script
Launching TDV Containers (Cluster) - Using Docker Run
Runtime TDV Container Configuration - Common Examples
Change TDV Admin Password (while container is running)
Change TDV Base Port
Change TDV Server Memory Setting
Configure External Volume For Local Persisted File Data Sources
Configure Data Source With 3rd party JDBC Driver (type 4)
Configure Data Source With 3rd party JDBC Driver (type 3)
Configure JVM Settings from Docker
Configure LDAP Properties From Docker
Configure Truststore and Keystore Files From Docker
Limitations
Upgrading to a New Version of TDV Server
Tips from Expert
Useful Docker Commands for TDV Containers
Container Orchestration Using Kubernetes
Introduction to Container Orchestration
TDV Container Orchestration Architecture
Prerequisites
Pre-Configuration of the Runtime Environment (On-Premises/Private Cloud only):
Configuring Kubernetes Using Quick Start Script
Deploying TDV as a Single Mode instance
Deploying TDV as a Cluster Mode Instance
Installing the TDV HAProxy Service using the Quick Start Script
Removing a TDV application via Helm
Running TDV on a Public Cloud - Microsoft Azure
Setting up the Resource Group
Creating a Container Registry
Creating a Cluster
Deploying the TDV Helm Chart
TIBCO Data Virtualization(R) Container Distribution
Useful Kubernetes Commands
Generic Kubernetes Commands
Useful TDV-Specific Commands
TDV Deployment Examples
TDV for AWS Marketplace
Prerequisites
Launching TDV Server on AWS Marketplace
Launching a TDV Windows Image on AWS Marketplace
Launching a TDV Linux Image on AWS Marketplace
TDV Server Configuration
TDV Instance Id
TDV Admin Password
Default TDV Security Group Configuration
TDV Security Group
Data Source Driver Management
TDV Updates and Bundled TDV Software
Installing Optional TDV Products
Version Support
Installation Requirements
Add-On Adapter Installation Requirements
Active Cluster Installation Requirements
Installing an Optional TDV Product
Installing the Advanced Adapters
Auto Deployment
Manual Deployment
Installing the TDV Client Drivers that are Distributed with TDV
Importing Resources Defined in an Earlier Release
Manage Active Cluster Security
Updating the Digital Certificate to Secure Cluster Communication
Set Access Privileges
TDV and Business Directory Product Maintenance
Upgrade, Downgrade, and Rollback
About Hotfix Maintenance
Applying the Hotfix to TDV Server, Studio, and Business Directory
About Service Pack Maintenance
Applying the Service Pack to TDV Server, Studio, and Business Directory
Applying the Service Pack or Hotfix to Active Cluster
Upgrading from an Earlier Release and Migrating The Metadata
Downgrade/Rollback
Maintaining TDV-to-Client Application Connections
Updating an ODBC Client Application
Updating a JDBC Client Application
Uninstalling TDV
Uninstalling TDV on Windows
Uninstalling TDV on UNIX
Preparing for Uninstalling on UNIX
Uninstalling TDV On UNIX
TIBCO Product Documentation and Support Services
How to Access TIBCO Documentation
How to Contact TIBCO Support
How to Join TIBCO Community
Legal and Third-Party Notices
Getting Started Guide
Introduction
TIBCO Data Virtualization Architecture
About TDV Roles
TDV Resource Terms
Studio Modeling and Publishing Terms
Logging Into TDV Server
Connecting to TDV Server and Starting Studio
Studio Modeler and Resource Tree Overview
Viewing and Opening Resources
Getting Started with Studio
About this Tutorial
Adding Data Sources
Creating a Folder
Adding the Orders Data Source
Viewing the Data Source Schema
Adding the Inventory Data Source
Adding the XML Data Source
Creating the XML Data Transformation
Creating the Transformation Container
Adding Loop and Cast Functions
Building Simple Views
Building and Executing the Order Information View
Building and Executing the Supplier Information View
Building and Executing the Sales Information View
Creating a Composite View
Publishing Your Views
Publishing Views to TDV Databases
What You Learned in this Tutorial
Sample Resources
Sample Data Sources
Sample Transformations
Sample Definition Set
Sample Published View
Sample Views
Sample SQL Script
Sample Discovery Model
User Guide
Overview of Studio
About Studio
Modeler Resource Tree
Opening Studio and Switching User
Starting Studio
Starting Studio from the Command Line
Changing the Connection Type
Customizing Studio
Customizing Studio Using the Studio Options Dialog
Customizing Studio Result Panel XML Text
Modifying Studio Memory Usage
Changing Your TDV Password
Using the Code Editor Text Editing Commands
Editor Text Editing Command Reference
Security Features
Studio Resource Management Overview
About Resource Management
Creating a TDV Resource
Locating a Container for a TDV Resource
Creating a Resource
Copying Privileges to Another Resource
Opening a Resource
Getting Information about a Resource
Annotating a Resource
Moving, Copying, Deleting, or Renaming a Resource
Searching for Resources in the Server
Impacted Resources
Managing the Display of Impacted Resources
Investigating Impacted Resources
Repairing Impacted Resources
Exporting (Archiving) and Importing Resources
Access Rights for Export and Import
Exporting Resources
Export and Import Locked Resources
Marking Rebindables
Rules for Importing Resources
Importing a Resource
Rebinding an Imported Resource
Using Studio for a Full Server Backup
Working with Resource Locks
Locking and Unlocking a Resource
Identifying Locked Resources
Change History of a Lock
Working with Data Sources
About Data Sources and TDV
About TDV Adapters
About Introspection
About Federated Queries
Data Source Categories
Adding a Data Source
Custom Adapters
Auto-Discovering Data Sources
Editing or Reviewing Configuration Information for a Data Source
Viewing Data Source Table Details
Adding and Removing Data Source Resources
Testing the Connection to Your Data Source
TDV Configuration Parameters Common to Multiple Data Sources
Data Source Connection Pool Checkout Timeout
Buffer Flush Threshold
Column Delimiter
Enable String Data Normalization
Escape Character
Row Delimiter
Default Commit Row Limit
Default Execution Timeout
Delayed Connection Commit/Rollback Timeout
Delayed Statement Close Timeout
Enable Data Source Connection Pool Checkout Timeout
Introspectable Resource Id Cache Expiration Period
Introspectable Resource Id Cache Cache Purge Frequency
Introspection Full Report Size Threshold
Default OAuth Page Execution Timeout
Push Oracle/Vertica/MySQL query hints
Suppress Data Source Properties Validation Errors
Trace level
Configuring Relational Data Sources
About Pass-Through Login
About Data Source Native Load Performance Options
Adding Relational Data Sources
Enabling Bulk Loading for SELECT and INSERT Statements
Configuring Advanced Adapters
Adapter Data Type Limitation
Dynamics CRM Adapter ID Ordering
Upgrading the ADO.NET Driver for Sharepoint Adapters
Configuring OAuth 2.0 for TDV Advanced Adapters
Installing the Siebel Data Bean JARs
Registering with the SAP System Landscape Directory
Installing the SAP Java Connector Library
Verifying a Successful Activation of an Adapter
Increasing the Maximum Size of Excel Sheets for SharePoint
Retrieving Data Source Metadata
About Introspection and Reintrospection
Introspecting Data Sources
Invoking Data Source Introspection
Introspecting a Data Source
Tracking and Viewing the Introspection Process
Tracking Introspection
Viewing the Introspection Task Status Report
Viewing the Introspection Report for a Data Source
Introspecting Data Source Table and Column Comment Metadata
Setting Introspection Filters on a Resource
Reintrospecting Data Sources
Reintrospecting a Data Source Immediately
Scheduling Reintrospection
Triggering Reintrospection
Tips on Introspecting Multiple Files in a Network Share Folder
Tips on Introspecting Based on a CREATE TABLE Statement
Tips on Introspecting Large Data Sources
Understanding the Resource ID Fetching Phase
Understanding the Introspection Plan Creation Phase
Understanding the Introspection Plan Implementation Phase
Tips to Improve Performance of Resource ID Fetching
Tips to Improve Performance of Introspection Implementation
Tips for Reintrospecting Large Data Sets
Views and Table Resources
About Composite Views
Creating a New View
Setting Default Query Options
Commenting SQL
Adding Column Level Annotations
SQL Request Annotation Pass-Through
Designing a View and Table Resource
Designing a View in the Model Panel
Designing a View in the Grid Panel
Designing SQL for a View in the SQL Panel
Defining Primary Key for a View or Table in the Indexes Panel
Defining a Foreign Key for a View or Table Resource
Generating a Model from the SQL Panel
Working with Views and JSON
Using a JSON Table Within a TDV View
JSON Table Examples
Designing Column Projections Using the Columns Panel
Obtaining View Details
Executing a View
Generating a Query Execution (Explain) Plan
Generating an Explain Plan and Displaying it in a Client Application
Rebinding a View
Displaying the Lineage of a View
View Column Dependencies and References
Getting Column Dependencies Using the API
Getting Column References Using the API
Creating a View from a Cube
Ad Hoc SQL and the SQL Scratchpad Editor
Opening the SQL Scratchpad Editor
Composing and Executing an Ad Hoc SQL Query
The SQL Scratchpad History Pane
The SQL Scratchpad Result Panel
Procedures
About Procedures
Creating a SQL Script Procedure
Working with SQL Scripts
Designing Parameters for a SQL Script
Promoting Procedures to Custom Functions
Pushing a Custom Function to the Native Data Source
Using Pipes and Cursors
Java Procedures
Viewing Java Procedure Parameters
XQuery Procedures
Creating an XQuery Procedure
Designing Parameters for an XQuery
XQuery 3.0 Support
XPath 3.0 Support
XSLT Procedures
Creating an XSLT Procedure
Designing Parameters for an XSLT Procedure
Packaged Queries
Creating a Packaged Query
Specify Input Parameters for a Packaged Query
Multiple SQL Execution Statements in a Packaged Query
DDL Support in Packaged Queries
Parameterized Queries
Quick Steps for Creating a Parameterized Query
Add Input Parameters
Adding a Parameter to a SELECT Clause
Adding a Parameter to a WHERE Clause
Adding a Parameter to a FROM Clause
Physical Stored Procedures
Editing a Stored Procedure in an Introspected Data Source
Editing a Stored Procedure in Microsoft SQL Server
Editing a Stored Procedure in DB2
Using Stored Procedures
Rebinding a Procedure
Setting Transaction Options for a Procedure
Executing a Procedure or Parameterized Query
Executing a Procedure in Studio
Executing a Parameterized Query
Executing a Stored Procedure
Executing a Procedure through JDBC
Using Design Procedure By Example for Introspected Procedures
Using Transformations
Studio Transformation Types
Creating an XML, XSLT, or Streaming Transformation
Adding a New Transformation (XML, XSLT, or Streaming)
Adding an XSLT Transformation for a Table, a View, or a Function
Mapping Source Data to Target Output Columns (XSLT or Streaming)
Adding Target Columns through the Outputs Panel (XSLT)
Creating an XQuery Transformation
Specifying a Target Value
Viewing the Source Scope
Specifying the Source for a Top-Level Element
Specifying Settings for Target Sources in an XQuery Transformation
Specifying Global Input Parameters in an XQuery Transformation
Viewing and Editing the XQuery
Viewing Output Parameters in the XQuery Transformation
Upgrading XML to Tabular Mapping Transforms
Upgrading and Creating a Backup of an XML to Tabular Mapping Transform
Creating an Upgraded XML to Tabular Mapping Transform
Executing a Transformation
Converting XML to JSON using Design By Example
JSON XML List Formatting Example
Using the Any-Any Transformation Editor
Transformation Editor Concepts
The Transformation Editor Window
Transformation Editor Terminology
About Transformation Editor Operations and Parameter Containers
Transformation Editor Limitations
Using the Transformation Editor
Creating a New Transform
Undoing and Redoing Actions in the Transformation Editor
Zooming and Arranging the Model
Editing Operations in the Transformation Editor Model
Adding Resources
Working with Connections and Loops
Working with Expressions
About Expressions
Adding Expression Operations
Working with Operations
Working with Operation and Parameter Container Details
Deleting Operations in the Transformation Editor
Working with Messages
Using Messages to Refine Your Transform
Rebinding Transformation Operations
Working with the Transformation Editor XQuery Tab
Using a Transform as a Resource in Another Transform
Caching Transform Data
Definition Sets
About Definition Sets
Creating a Definition Set
Creating a SQL Definition Set
Creating an XML Definition Set
Creating a WSDL Definition Set
Using a SQL Definition Set
Using an XML Definition Set
Using a WSDL Definition Set
Triggers
About Triggers
Creating a JMS Event Trigger
Creating a System Event Trigger
Creating a Timer Event Trigger
Creating a User-Defined Event Trigger
Creating Email Alerts
Publishing Resources
Updating Published Resources
About Publishing Resources
About the TDV DDL Feature
About the OData Feature
OData Support Limitations
OData v4 Support Limitations
OData Features
OData v4 Features
OData to TDV Data Type Mappings
Accessing REST-Based Web Services Using JSON
Publishing Resources (Creation, Access, and Deletion)
Publishing Resources to a Database Service
Publishing Resources to a Database Service with OData
Configuring DDL for a Data Service
Configuring TEMP Table Space for a Data Service
Publishing Resources to a Web Service
About WSDL and Web Service Data Services
Publishing a SOAP Data Service
Publishing a Contract-First WSDL and SOAP Data Service
Moving the Namespace Declaration From Elements to the Soap Header
Publishing a REST Service
Web Services Security
Supported Web Service Security Standards
Using a Predefined Security Policy for a Web Service
Creating and Using a Custom Security Policy for a Web Service
Security and Privileges on Published Resources
Disable OData for Published Data Sources
Unsupported Resource List Limit
Exploring Data Lineage
About Data Lineage
Displaying Data Lineage
Working with the Data Lineage Graph
Changing the Resource Focus
Changing What Is Displayed
Filtering the Visible Columns
Getting Resource Summary Information
Getting Resource Details
Using the History Feature
Refreshing the Lineage Graph
Printing the Lineage Graph
Exporting Lineage Reports to a Comma-Separated-Values File
Lineage Information for Different Resource Types
TDV Caching
Overview of TDV Caching
TDV Caching Concepts
How Does TDV Caching Work?
TDV-Created Caching Objects
What Incremental Caching Options Are Available in TDV?
About Native and Parallel (Bulk) Caching
Cache Status and Events Reporting
Cache Requirements and Limitations
Supported Data Sources for Caching
Supported Cache Target Storage Types
Privileges and Caching
Caching Limitations
Native (Bulk) Caching DDL Creation Limitations
Setting Up Caching
Caching Transaction Results of a Procedure
Caching to the Default Database Target
Caching to a File Target
Pre-Creating Caching Objects for Database Caching
Caching to a Single-Table Database Target
Creating a Multiple Table Cache on a Database Target
Enabling Cache Data Storage to Multiple Data Sources
Setting Up Native (Bulk) Caching Options
Setting Up the Parallel Cache Option
Enabling JDBC-Only Cache Loading
Canceling a Cache Refresh that Is Using Native or Parallel Loading
Defining Cache Refresh Behavior
Refresh Owner
Controlling Cache Refresh Behavior for Individual Resources
Controlling Cache Refresh Behavior for Multiple Resources
Defining Pre- and Post-Actions for a Full Refresh Mode Cache
Setting Up Pull-Based Incremental Cache
Setting Up Push-Based Incremental Caching for Oracle
Cache Maintenance
Indexing Your Cache
Managing Configuration Changes and Cache Behavior
Displaying the Dependencies of a Cached View
Displaying the Dependencies of a Cache Policy
Managing Import and Export Cache Information
Caching Tips from an Expert
Destroying a File or Default Cache
Managing Cache Status Table Probe Row Conflicts
Managing Unresponsive Cache Tables
Managing Open Connection Threads
Managing Buckets
Managing Cache Data
TDV Configuration Parameters
Viewing or Editing Configuration Parameters
Finding Parameters in the Configuration Window
Performance Tuning
About Performance Tuning in TDV
Working with the SQL Execution Plan
Generating and Displaying a SQL Execution Plan
Execution Plan Nodes in the Tree Panel
Execution Plan Query Attributes in the Details Panel
Execution Plan Node Attributes in the Details Panel
Updating the Query Execution Plan
Viewing How Much Data was Processed by a Query
Refreshing All Execution Plan Caches
Creating Cardinality Statistics for Cost-Based Optimization
Creating Cardinality Statistics for a View
Creating Cardinality Statistics on a Data Source
Scheduling Cardinality Statistics Refresh
Refreshing Cardinality Statistics
Using TDV API Procedures to Refresh or Cancel Resource Statistics
Use Indexes, and Primary and Foreign Keys, to Improve Query Performance
Types of Joins
SQL Join Reordering
Multiple Join Conditions
Semijoin Optimization Option
About the Semijoin Optimization
Semijoin Option Syntax Examples
Setting Semijoin Configuration Parameters
Configuring Your Data Source for the Semijoin Optimization
Using the Semijoin Option
Semijoin with Non-Equality Conditions Scenarios
Star Schema Semijoin
Using Oracle SQL Optimizer Hints
Tuning Nested Aggregate Function Behavior
Tuning Database Channel Queue Size
Specifying the Fetch Size for Oracle and MS SQL Server
TDV Query Engine Optimizations
Subquery Optimizations
Partition or Join Pruning Optimization
DATA_SHIP_MODE Values
Performance Configuration Parameter Tips from an Expert
Data Ship Performance Optimization
About Data Ship
Data Ship Support and Requirements
Data Ship Limitations
Defining TDV Data Ship Configuration Parameters
Configuring Data Ship
Configuring Data Ship for DB2
Configuring Data Ship Bulk Loading Option for DB2
Configuring Data Ship for Microsoft SQL Server
Configuring Data Ship for Netezza
Configuring Data Ship for Oracle
Configuring Data Ship for Sybase IQ
Configuring Data Ship for Sybase IQ Targets with Location
Configuring Data Ship for PostgreSQL and Vertica
Finishing Data Ship Configuration for Data Sources
Evaluating Queries for Data Ship Using Execution Plans
Using Time Series Functions for Vertica Data Ship Targets
Disabling Data Ship for Specific Query SQL
Managing Open Connection Threads
Using Data Ship for Prepared Statements
Configuring the TDV Massively Parallel Processing Engine
About the TDV MPP Engine Configuration
MPP Engine OS Support
Supported Data sources
Ports used for TDV MPP Engine
Setting Up and Configuring the TDV MPP Engine
When should the MPP Engine be engaged?
Configuring the MPP engine from the Query Execution Plan Viewer
Considerations for using MPP Engine
JOIN Restrictions
Tuning the Server Configuration
SQL Functions
Canceling Jobs When MPP Engine is Active
Push-Based Incremental Caching
View Requirements and Restrictions for Push-Based Incremental Caching
Requirements for Push-Based Incremental Caching
Configuring Oracle Database for Push-based Incremental Caching
Installing and Configuring Oracle GoldenGate
Installing the TIBCO JAR File
Configuring JMS Pump for Oracle GoldenGate Using TIBCO EMS
Adding the Change Notification Custom Java Procedures
Defining Connectors
Install the Central Server
Configuring Push-Based Incremental Caching and Change Management
Publishing the cms_call_propagator Procedure
Configuring Oracle Data Sources for Change Notification
Setting Up an Push-Based Incremental Cache in Studio
Publish Push-Based Incremental Caches
Recovering from a Messaging Error
Push-Based Incremental Caching Configuration Parameters
Legacy Web Services
Limitations for Legacy Web Service Conversion
Converting Legacy WSDL Data Sources to SOAP Data Sources
Converting Legacy Web Service
Studio User Interface Reference
Studio Menus
Studio Status Bar
Studio Text Editing
Line numbers in the SQL Editor
Studio Code Editing Keyboard Shortcuts
View and Table Editor Panel Reference
Model Panel
Grid Panel
SQL Panel
Columns Panel
Indexes Panel
Foreign Keys Panel
Cardinality Statistics Panel
Rebind Panel
Result Panel
Execution Plan Panel
Procedure Editor Panel Reference
Introduction to Procedure Panels and Tabs
Model Panel
Grid Panel
SQL Script Panel
SQL Panel
Parameters Panel
Data Map Panel
XSLT Panel for XSLT Transformations
XSLT Panel for XSLT Procedures
XQuery Panel
Inputs Panel
Outputs Panel
XSLT Debug Input Panel
XSLT Debug Output Panel
Trigger Editor Panel Reference
Condition Tab
SQL Definition Set Editor
SQL Definition Set Editor Toolbars
XML Definition Set Editor
XML Schema Panel (XML Definition Set)
XML Schema Panel Toolbar
WSDL Definition Set Editor
WSDL Panel
WSDL Panel Toolbar
Reference Guide
TDV SQL Support
Data Types
Summary of Data Types that TDV Supports
Binary Literals
BOOLEAN
INTERVAL DAY
INTERVAL YEAR
XML
Subqueries in TDV
Scalar Subqueries
Correlated Subqueries
Consolidated List of TDV Keywords
Maximum SQL Length for Data Sources
TDV SQL Keywords and Syntax
BETWEEN
CREATE TABLE
DDL Clauses
CREATE TABLE AS SELECT
CROSS JOIN
DELETE
DISTINCT
DROP
EXCEPT
FULL OUTER JOIN
GROUP BY
HAVING
INNER JOIN
INSERT
INSERT, UPDATE, and DELETE on Views
INTERSECT
LEFT OUTER JOIN
OFFSET and FETCH
ORDER BY
PIVOT
UNPIVOT
RIGHT OUTER JOIN
SELECT
SELECT (Virtual Columns)
SELECT (with Derived Column List)
SEMIJOIN to a Procedure
UNION
UNION ALL
UPDATE
WHERE
WITH
TDV Support for SQL Functions
About SQL Functions in TDV
Analytical Functions
Window Clause
CONDITIONAL_CHANGE_EVENT
CONDITIONAL_TRUE_EVENT
CUME_DIST
DENSE_RANK
EXPONENTIAL_MOVING_AVERAGE
EXP_WEIGHTED_AVG
FIRST_VALUE
FIRST_VALUE_IGNORE_NULLS
LAG
LAG_IGNORE_NULLS
LAST_VALUE
LAST_VALUE_IGNORE_NULLS
LEAD
LEAD_IGNORE_NULLS
NTH_VALUE
NTH_VALUE_FROM_LAST
NTH_VALUE_FROM_LAST_IGNORE_NULLS
NTH_VALUE_IGNORE_NULLS
NTILE
PERCENT_RANK
RANK
RATIO_TO_REPORT
ROW_NUMBER
TIMESERIES
Aggregate Functions
ANY_VALUE
APPROX_COUNT_DISTINCT
APPROX_QUANTILES
ARRAY_AGG
AVG
BIT_AND
BIT_OR
BIT_XOR
CORR
CORR_SPEARMAN
COUNT
COVAR_POP
COVAR_SAMP
DISTINCT in Aggregate Functions
FIRST
GROUP_CONCAT
GROUP_CONCAT_UNQUOTED
LAST
JSON_OBJECTAGG
JSON_ARRAYAGG
LISTAGG
MAX
MEDIAN
MIN
NEST
NTH
PERCENTILE
PERCENTILE_APPROX
PERCENTILE_CONT
PERCENTILE_DISC
QUANTILES
REGR_AVGX
REGR_AVGY
REGR_COUNT
REGR_INTERCEPT
REGR_R2
REGR_SLOPE
REGR_SXX
REGR_SXY
REGR_SYY
STDDEV
STDDEV_POP
STDDEV_SAMP
SUM
SUM_FLOAT
VAR_POP
VAR_SAMP
VARIANCE
XMLAGG
Array SQL Script Functions
ARRAY_APPEND
ARRAY_AVG
ARRAY_CONCAT
ARRAY_CONTAINS
ARRAY_COUNT
ARRAY_DISTINCT
ARRAY_IFNULL
ARRAY_LENGTH
ARRAY_MAX
ARRAY_MIN
ARRAY_POSITION
ARRAY_PREPEND
ARRAY_PUT
ARRAY_REMOVE
ARRAY_REPLACE
ARRAY_REVERSE
ARRAY_SORT
ARRAY_SUM
CARDINALITY
EXTEND
FIND_INDEX
TOARRAY
TOATOM
TOBOOLEAN
TONUMBERCB
TOOBJECT
TOSTRING
TRUNCATE
Binary Functions
AND Functions
NOT Functions
OR Functions
SHL Functions
SHR Functions
XOR Functions
BYTE_SUBSTR
Character Functions
ASCII
BASE64
BITCOUNT
BIT_LENGTH
BITSTRING_TO_BINARY
BTRIM
CHAR_LENGTH
CHARACTER_LENGTH
CHARINDEX
CHR
CONCAT
CONTAINS
DLE_DST
ENDSWITH
FIND
FIND_IN_SET
GET_JSON_OBJECT
GREATEST
HEX_TO_BINARY
INDEXOF
INET_ATON
INET_NTOA
INITCAP
INSERT
INSTR
ISOF
ISUTF8
LCASE
LEAST
LEFT
LENGTH
LE_DST
LOCATE
LOWER
LPAD
LSHIFT
LTRIM
MD5
OCTET_LENGTH
OVERLAYB
PARSE_URL
PARTIAL_STRING_MASK
POSITION
QUOTE_IDENT
QUOTE_LITERAL
REGEXP_CONTAINS
REGEXP_COUNT
REGEXP_EXTRACT
REGEXP_INSTR
REGEXP_REPLACE
REGEXP_SUBSTR
REGEXP_LIKE
REGEXP_POSITION
REPEAT
REVERSE
RIGHT
REPLACE
REGEXP
RLIKE
RPAD
RSHIFT
RTRIM
SPACE
SPLIT
SPLIT_PART
STARTSWITH
STATEMENT_TIMESTAMP
STRPOS
SUBSTR
SUBSTRING
SUBSTRINGOF
TRANSLATE
TRIM
TRIMBOTH
TRIMLEADING
TRIMTRAILING
TYPE
UCASE
UNICHR
UNICODE
UPPER
V6_ATON
V6_NTOA
V6_SUBNETA
V6_SUBNETN
V6_TYPE
Conditional Functions
COALESCE
COMMON
DECODE
ES_MATCH
FILTER
IFINF
IFMISSING
IFMISSINGORNULL
IFNAN
IFNANORINF
IFNULL
IFNULLCB
ISARRAY
ISATOM
ISBOOLEAN
ISNUMBER
ISOBJECT
ISNULL
ISNUMERIC
ISSTRING
MATCH_PHRASE
MATCH_PHRASE_PREFIX
MISSINGIF
NANIF
NEGINFIF
NULLIF
NVL
NVL2
POSINFIF
TERM
TEST
Convert Functions
CAST
FORMAT_DATE
PARSE_DATE
PARSE_TIME
PARSE_TIMESTAMP
TIMESTAMP
TO_BITSTRING
TO_CHAR
TO_DATE
TO_HEX
TO_NUMBER
TO_TIMESTAMP
TO_TIMESTAMP_TZ
TRUNC
TRUNC (for date/time)
TRUNC (for numbers)
Cryptographic Functions
HASHMD2
HASHMD4
HASHMD5
HASHSHA
HASHSHA1
Date Functions
ADD_MONTHS
AGE
AT TIME ZONE
CALENDAR_MONTH
CALENDAR_QUARTER
CALENDAR_YEAR
CLOCK_MILLIS
CLOCK_STR
CLOCK_TIMESTAMP
CURRENT_DATE
CURRENT_TIME
CURRENT_TIMESTAMP
DATE
DATE_ADD
DATEADD
DATE_ADD_MILLIS
DATE_ADD_STR
DATE_DIFF_MILLIS
DATE_DIFF_STR
DATE_PART
DATENAME
DATEPART
DATE_PART_MILLIS
DATE_PART_STR
DATE_SUB
DATE_TRUNC
DATETRUNC
DATE_TRUNC_MILLIS
DATE_TRUNC_STR
DAY_IN_MONTH
DAY_IN_WEEK
DAY_IN_YEAR
DAYNAME
DAYOFMONTH
DAYOFWEEK_ISO
DAYOFWEEK
DAYOFYEAR
DAY_ONLY
DATEDIFF
DAY,MONTH,and YEAR
DAYS
DAYS_BETWEEN
DBTIMEZONE
EXTRACT
EXTRACTDAY
EXTRACTDOW
EXTRACTDOY
EXTRACTEPOCH
EXTRACTHOUR
EXTRACTMICROSECOND
EXTRACTMILLISECOND
EXTRACTMINUTE
EXTRACTMONTH
EXTRACTQUARTER
EXTRACTSECOND
EXTRACTWEEK
EXTRACTYEAR
FISCAL_MONTH
FISCAL_QUARTER
FISCAL_YEAR
FRACTIONALSECONDS
FROM_UNIXTIME
GETUTCDATE
HOUR
HOUR_IN_DAY
ISFINITE
ISUTF8
JULIAN_DAY
LAST_DAY
LOCALTIME
LOCALTIMESTAMP
MICROSECOND
MIDNIGHT_SECONDS
MILLIS
MILLIS_TO_STR
MILLIS_TO_UTC
MAXDATETIME
MINDATETIME
MINUTE
MONTHNAME
MONTHS_BETWEEN
NEW_TIME
NEXT_DAY
NOW
NOW_MILLIS
NOW_STR
NUMTODSINTERVAL
NUMTOYMINTERVAL
QUARTER
ROUND
SECOND
STR_TO_MILLIS
STR_TO_UTC
STR_TO_ZONE_NAME
SYSDATE
TIME
TIMESTAMP_ROUND
TIME_SLICE
TIMEOFDAY
TIMESTAMPADD
TIMESTAMPDIFF
TIMESTAMP_TRUNC
TRANSACTION_TIMESTAMP
TOTALOFFSETMINUTES
TOTALSECONDS
TZ_OFFSET
TZCONVERTOR
UNIX_TIMESTAMP
UTC_TO_TIMESTAMP
WEEK
WEEK_ISO
WEEK_IN_MONTH
WEEK_IN_YEAR
YEAR_ISO
JSON Functions
DECODE_JSON
ENCODE_JSON
ENCODED_SIZE
JSON_TABLE
JSON_EXTRACT
JSON_EXTRACT_SCALAR
JSON_COUNT
JSON_SUM
JSON_MIN
JSON_MAX
JSON_AVG
JSONPATH
JSON_OBJECT
JSON_ARRAY
Numeric Functions
ABS
ACOS
ASIN
ATAN
ATAN2
CBRT
CEILING
COS
COSH
COT
DECFLOAT
DEGREES
E
EXP
FLOOR
GEO.DISTANCE
GEO.INTERSECTS
GEO.LENGTH
LN
LOG
LOG10
MOD
NEGATIVE
NORMALIZE_DECFLOAT
PI
POW
POWER
QUANTIZE
RADIANS
RAND
RANDOM
ROUND (for date/time)
ROUND (for numbers)
ROWNUM
SIGN
SIN
SINH
SQRT
TAN
TANH
TOTALORDER
Operator Functions
Add-Operator
Concatenate-Operator
Divide-Operator
Exponentiate-Operator
Factorial-Operator
FACTORIAL
Module-Operator
Multiply-Operator
Negate-Operator
Subtract-Operator
Phonetic Functions
DBL_MP
NYSIIS
PRI_MP
SCORE_MP
SEC_MP
SOUNDEX
DIFFERENCE
Utility Function
XML Functions
Identifier Escaping
Text Escaping
XMLATTRIBUTES
XMLCOMMENT
XMLCONCAT
XMLDOCUMENT
XMLELEMENT
XML_EXTRACT
XMLFOREST
XMLNAMESPACES
XMLPI
XMLQUERY
XMLTEXT
XPATH
XSLT
TDV Support for SQL Operators
Arithmetic Operators
Add
Concatenation
Divide
Exponentiate
Factorial
Modulo
Multiply
Negate
Subtract
Comparison Operators
Quantified Comparisons
Logical Operators
AND
NOT
OR
Condition Operators
CASE
COALESCE
DECODE
EXISTS and NOT EXISTS
IN and NOT IN
IS NOT NULL
IS NULL
LIKE
OVERLAPS
TDV Query Engine Options
DATA_SHIP_MODE Values
GROUP BY Options
INSERT, UPDATE, and DELETE Options
JOIN Options
DISABLE_PUSH (JOIN Option)
DISABLE_THREADS (JOIN Option)
FORCE_DISK (JOIN Option)
FORCE_ORDER (JOIN Option)
HASH (JOIN Option)
LEFT_CARDINALITY (JOIN Option)
NESTEDLOOP (JOIN Option)
PARTITION_SIZE (JOIN Option)
RIGHT_CARDINALITY (JOIN Option)
SEMIJOIN (JOIN Option)
SORTMERGE (JOIN Option)
SWAP_ORDER (JOIN Option)
ORDER BY Options
DISABLE_PUSH (ORDER BY Option)
DISABLE_THREADS (ORDER BY Option)
FORCE_DISK (ORDER BY Option)
SELECT Options
CASE_SENSITIVE (SELECT Option)
DISABLE_CBO (SELECT Option)
DISABLE_DATA_CACHE (SELECT Option)
DISABLE_JOIN_PRUNER (SELECT Option)
DISABLE_PLAN_CACHE (SELECT Option)
DISABLE_PUSH (SELECT Option)
DISABLE_SELECTION_REWRITER (SELECT Option)
DISABLE_SORT_REMOVAL (SELECT Option)
DISABLE_STATISTICS (SELECT Option)
DISABLE_THREADS (SELECT Option)
FORCE_DISK (SELECT Option)
FORCE_ESTIMATION (SELECT Option)
IGNORE_TRAILING_SPACES (SELECT Option)
MAX_ROWS_LIMIT (SELECT Option)
ROWS_OFFSET (SELECT Option)
STRICT (SELECT Option)
PUSH_NULL_SELECTS (SELECT OPTION)
DISABLE_CONSTANT_FUNCTION_INLINING (SELECT OPTION)
DISABLE_UNION_PREAGGREGATOR (SELECT OPTION)
USE_COMPARABLE_ESTIMATES (SELECT OPTION)
UNION, INTERSECT, and EXCEPT Options
DISABLE_PUSH (UNION, INTERSECT, and EXCEPT Option)
FORCE_DISK (UNION, INTERSECT, and EXCEPT Option)
PARALLEL (UNION, INTERSECT, and EXCEPT Option)
ROUND_ROBIN (UNION, INTERSECT, and EXCEPT Option)
SORT_MERGE (UNION, INTERSECT, and EXCEPT Option)
TDV and Business Directory System Tables
Accessing TDV and Business Directory System Tables
ALL_BD_RESOURCES
ALL_CATALOGS
ALL_CATEGORIES
ALL_CATEGORY_VALUES
ALL_CLASSIFICATIONS
ALL_COLUMNS
ALL_COMMENTS
ALL_CUSTOM_PROPERTIES
ALL_CUSTOM_PROPERTY_CLASSIFICATIONS
ALL_CUSTOM_PROPERTY_GROUPS
ALL_CUSTOM_PROPERTY_GROUPS_ASSOCIATIONS
ALL_DATASOURCES
ALL_DOMAINS
ALL_ENDPOINT_MAPPINGS
ALL_FOREIGN_KEYS
ALL_GROUPS
ALL_INDEXES
ALL_LINEAGE
ALL_PARAMETERS
ALL_PRINCIPAL_SET_MAPPINGS
ALL_PRIVILEGES
ALL_PROCEDURES
ALL_PUBLISHED_FOLDERS
ALL_RELATIONSHIP_COLUMNS
ALL_RELATIONSHIPS
ALL_RESOURCES
ALL_SCHEMAS
ALL_TABLES
ALL_USERS
ALL_USER_PROFILES
ALL_WATCHES
ALL_WSDL_OPERATIONS
DEPLOYMENT_PLAN_DETAIL_LOG
DEPLOYMENT_PLAN_LOG
DUAL
LOG_DISK
LOG_EVENTS
LOG_IO
LOG_MEMORY
SYS_CACHES
SYS_CLUSTER
SYS_DATA_OBJECTS
SYS_DATASOURCES
SYS_DEPLOYMENT_PLANS
SYS_PRINCIPAL_SETS
SYS_REQUESTS
SYS_RESOURCE_SETS
SYS_SESSIONS
SYS_SITES
SYS_STATISTICS
SYS_TASKS
SYS_TRANSACTIONS
SYS_TRANSIENT_COLUMNS
SYS_TRANSIENT_SCHEMAS
SYS_TRANSIENT_TABLES
SYS_TRIGGERS
TEMPTABLE_LOG
TRANSACTION_LOG
USER_PROFILE
TDV SQL Script
SQL Script Overview
SQL Language Concepts
Identifiers
Data Types
Value Expressions
Conditional Expressions
Literal Values
Noncursor Variables
Cursor Variables
Attributes of Cursors
Attributes of CURRENT_EXCEPTION
SQL Script Keywords
SQL Script Procedures and Structure
Basic Structure of a SQL Script Procedure
SQL Script Procedure Header
Compound Statements
Independent Transactions
Compensating Transactions
Exceptions
SQL Script Statement Reference
BEGIN...END
CALL
CASE
CLOSE
COMMIT
CREATE TABLE
CREATE TABLE AS SELECT
CREATE INDEX
DECLARE Constants
DECLARE CURSOR of Type Variable
DECLARE <cursorName> CURSOR FOR
DECLARE EXCEPTION
DECLARE TYPE
DECLARE Variable
DECLARE VECTOR
DELETE
DROP TABLE
DROP INDEX
EXECUTE IMMEDIATE
FIND_INDEX
FETCH
FOR
IF
INSERT
ITERATE
LEAVE
LOOP
OPEN
PATH
RAISE
REPEAT
ROLLBACK
SELECT INTO
SET
TOP
UPDATE
WHILE
SQL Script Examples
Example 1 (Fetch All Rows)
Example 2 (Fetch All Categories)
Example 3 (User-Defined Type)
Example 4 (User-Defined Type)
Example 5 (Pipe Variable)
Example 6 (Dynamic SQL Extract with Individual Inserts)
Example 7 (Dynamic SQL Inserts by Variable Name)
Example 8 (Prepackaged Query)
Example 9 (Exception Handling)
Example 10 (Row Declaration)
Example 11 (Avoiding Division-by-Zero Errors)
TDV Built-in Functions for XQuery
executeStatement
formatBooleanSequence
formatDateSequence
formatDecimalSequence
formatDoubleSequence
formatFloatSequence
formatIntegerSequence
formatStringSequence
formatTimeSequence
formatTimestampSequence
Java APIs for Custom Procedures
com.compositesw.extension
CustomCursor
CustomProcedure
CustomProcedureException
ExecutionEnvironment
ParameterInfo
ProcedureConstants
ProcedureReference
Function Support for Data Sources
Pushing or Not Pushing Functions
Function Support Issues when Combining Data Sources
ASCII Function with Empty String Argument
Case Sensitivity and Trailing Spaces
Collating Sequence
Data Precision
Decimal Digit Limitation on Functions
INSTR Function
Interval Calculations
Mapping of Native to TDV Data Types Across TDV Versions
MERGE
ORDER BY Clause
SPACE Function
SQL Server Sorting Order
Time Functions
Truncation vs. Rounding
TDV Native Function Support
TDV Aggregate Function Support
TDV Character Function Support
TDV Conditional Function Support
TDV Conversion Function Support
TDV Date Function Support
TDV Numeric Function Support
Custom Procedure Examples
About the Custom Procedure Examples Syntax
Example 1: Simple Query
Example 2: Simple Update
Example 3: External Update without Compensation
Example 4: Nontransactional External Update without Compensation
Example 5: Expression Evaluator
Example 6: Output Cursor
Example 7: Simple Procedure that Invokes Another Procedure
Time Zones
Application Programming Interface Guide
Introduction
Purpose of the Web Services Operations
Groups of Operations
Administrative Operations
Utility Operations
Purpose of the Procedures
Groups of Procedures
Debug Procedures
Deployment Procedures
JMS Procedures
Lineage Procedures
Profile Procedures
Resource Procedures
Service Procedures
Transformation Procedure
User Procedures
Utility Procedures
Security Features
Using Web Services Operations
Using Operations in Studio
Finding and Opening Operations
Preparing and Executing an Operation
Using Operations from a Web Services Client
Web Services Port
WSDL Definitions of Operations
Web Services Operations
Operations Reference
addLicenses
addLoginModule
addPrincipalMapping
addUsersToGroup
addUserToGroups
beginSession
beginTransaction
cancelArchive
cancelCreateDomain
cancelDataSourceReintrospect
cancelResourceStatistics
cancelServerTask
changeResourceOwner
clearIntrospectableResourceIdCache
clearResourceCache
clearResourceStatistics
closeResult
closeSession
closeTransaction
copyResource
copyResourcePrivileges
copyResources
createCluster
createConnector
createCustomDataSourceType
createDataSource
createDBHealthMonitorTable
createDomain
createExportArchive
createGroup
createImportArchive
createLink
createLinksRecursively
createResource
createUser
destroyConnector
destroyCustomDataSourceType
destroyDomain
destroyGroup
destroyResource
destroyResources
destroyUser
executeNativeSql
executeProcedure
executeSql
executePreparedSql
executeSqlScript
getAllResourcesByPath
getAncestorResources
getArchiveContents
getArchiveExportData
getArchiveExportSettings
getArchiveImportReport
getArchiveImportSettings
getAvailableLoginModuleNames
getCachedResourceStatisticsConfig
getChildResources
getClusterConfig
getConnectorGroup
getConnectorGroupNames
getConnectors
getCreateDBHealthMonitorTableSQL
getDataSourceAttributeDefs
getDataSourceChildResources
getDataSourceReintrospectResult
getDataSourceStatisticsConfig
getDataSourceTypeAttributeDefs
getDataSourceTypeCustomCapabilities
getDataSourceTypes
getDependentResources
getDomainGroups
getDomains
getDomainTypeAttributeDefs
getDomainTypes
getDomainUsers
getExtendableDataSourceTypes
getGeneralSettings
getGroups
getGroupsByUser
getIntrospectableResourceIdsResult
getIntrospectableResourceIdsTask
getIntrospectedResourceIdsResult
getIntrospectedResourceIdsTask
getIntrospectionAttributeDefs
getIntrospectionAttributes
getLicenses
getLockedResources
getLoginModule
getLoginModuleDefaultProperties
getLoginModuleList
getMostRecentIntrospectionStatus
getParentDataSourceType
getParentResource
getPrincipalMapping
getPrincipalMappingList
getProceduralResult
getResource
getResourceCacheConfig
getResourcePlan
getResourcePrivileges
getResources
getResourceStatisticsConfig
getResourceStatsSummary
getResourceUpdates
getResultSetPlan
getServerActions
getServerAttributeDefChildren
getServerAttributeDefs
getServerAttributes
getServerInfo
getServerName
getSqlPlan
getTabularResult
getTransformFunctions
getUsedDataSources
getUsedResources
getUser
getUsers
getUsersByGroup
introspectResourcesResult
introspectResourcesTask
joinCluster
lockResource
lockResources
moveResource
moveResources
parseSqlQuery
performArchiveImport
performServerAction
rbsAssignFilterPolicy
rbsDeleteFilterPolicy
rbsGetFilterPolicy
rbsGetFilterPolicyList
rbsIsEnabled
rbsSetEnabled
rbsWriteFilterPolicy
rebindResources
refreshResourceCache
refreshResourceStatistics
reintrospectDataSource
removeFromCluster
removeLicenses
removeLoginModule
removePrincipalMapping
removeUserFromGroups
removeUsersFromGroup
renameResource
repairCluster
resourceExists
syncDomainGroups
testDataSourceConnection
unlockResource
unlockResources
updateArchiveExportSettings
updateArchiveImportSettings
updateBasicTransformProcedure
updateCachedResourceStatisticsConfig
updateClusterName
updateColumnAnnotation
updateConnector
updateCustomDataSourceType
updateDataServicePort
updateDataSource
updateDataSourceChildInfos
updateDataSourceChildInfosWithFilter
updateDataSourcePort
updateDataSourceStatisticsConfig
updateDataSourceTypeCustomCapabilities
updateDefinitionSet
updateDomain
updateExternalSqlProcedure
updateGeneralSettings
updateGroup
updateImplementationContainer
updateLink
updateLoginModule
updateLoginModuleList
updatePrincipalMapping
updateResourceAnnotation
updateResourceCacheConfig
updateResourceEnabled
updateResourcePrivileges
updateResources
updateResourceStatisticsConfig
updateServerAttributes
updateServerName
updateSqlScriptProcedure
updateSqlTable
updateStreamTransformProcedure
updateTransformProcedure
updateTrigger
updateUser
updateUserLockState
updateXQueryProcedure
updateXQueryTransformProcedure
updateXSLTProcedure
updateXsltTransformProcedure
Recurring Element Structures
Attribute Definitions Element
Attributes Element
Column Element
Connector Element
Domains Element
Filter Policy Definition
Groups Element
Import Hints
Introspection Plan Element
Introspection Report Status Element
Licenses Element
Messages Element
Parameters Element
Refresh Element
Reintrospect Report Element
Resources Element
Schedule Element
User and Group Rights Mask
User Element
Users Element
TDV Resource Types and Subtypes
Built-in Procedures
About TDV Built-in Procedures
Naming Conflicts between User-Defined and Built-in Procedures
Sample JMS Built-in Procedure
Procedures Reference
AddUsernameToken
CancelDataSourceReintrospect
CancelResourceStatistics
ClearAllDataSourceCredentials
ClearAlternatePrincipal
ClearMessageProperties
ClearResourceCache
ClearResourceStatistics
CopyResource
CreateElement
CreateResourceCacheKey
DeleteElement
EncryptElement
ExecuteBasicTransform
ExplainAttributes
ExplainPrincipals
ExplainResources
GenerateEvent
GetClaim
GetColumnDependencies
GetColumnProfiles
GetColumnReferences
GetDataSourceReintrospectReport
GetEnvironment
GetPartitionClauses
GetPrincipalSet
GetTableProfiles
GetProperty
GetResourceCacheStatus
GetResourceSet
HasClaim
ListAttributes
ListPrincipals
ListResources
LoadResourceCacheStatus
Log
LogError
LogMessageToFile
MoveResource
Pause
PreviewResourceSet
Print
ProcessSecurityHeader
RefreshResourceCache
RefreshResourceCacheSynchronously
RefreshResourceStatistics
ReintrospectDataSource
RenameResource
ResourceExists
Search
SendEMail
SendMapMessage
SendResultsInEMail
SendTextMessage
SetAlternatePrincipal
SetAlternateSecurityProperty
SetDataSourceCredentials
SetEnvironment
SetEnvironmentFromNodeValue
SetMessageProperties
SetMessageProperty
SetNodeValueFromEnvironment
SignElement
SqlPerf
SyncDomain
TestAllDataSourceConnections
TestDataSourceConnection
TestUserIdentity
UpdateResourceCacheEnabled
UpdateResourceCacheKeyStatus
UpdateResourceEnabled
SQL Definition Sets
extendedSql SQL Definition Set
Jms SQL Definition Set
ResourceDefs SQL Definition Set
sql SQL Definition Set
System SQL Definition Set
UserDefs SQL Definition Set
Server Actions
About Server Actions
Server Actions Reference
CheckLicense
ClearDataSourceConnectionPools
ClearRepositoryCache
ClearQueryPlanCache
ClearServerProfile
Echo
FreeUnusedMemory
GetServerProfile
PurgeCompletedRequests
PurgeCompletedSessions
PurgeCompletedTransactions
RegenerateFiles
ResetSystemNamespace
ShutdownServer
TerminateRequests
TerminateSessions
TerminateTransactions
TestAllDataSources
DSL API
Data Sources
DSL Syntax
Relational Data Sources
File Delimited Data Sources
Excel Data Sources
System Tables
Logging
Data Views
DSL Syntax
Considerations
Examples
System Tables
Logging
SQL Script Procedures
DSL Syntax
Considerations
Examples
System Tables
Logging
Folders
DSL Syntax
Considerations
Examples
System Tables
Logging
Virtual Databases
DSL Syntax
Considerations
Examples
System Tables
Virtual Tables and Procedures
DSL Syntax
Considerations
Examples
System Tables
Logging
Virtual Schemas
DSL Syntax
Considerations
Examples
System Tables
Virtual Catalogs
DSL Syntax
Considerations
Examples
System Tables
Logging
DSL Support in SQL Scripts
Examples
REST API
TDV Server REST APIs
Catalog
Column-Based Security
Datasource
Dataview
Deployment Manager
Execute
Folders
Link
Resource
Schema
Script
Security
Session
Version Control System
Workload Management
Auth
Data Source Toolkit Guide
Introduction
What Is the TDV Data Source Toolkit?
Workflow
Basic Concepts
How to Prepare a Data Source Extension Adapter
How to Write an Extension Adapter
TDV and Adapters
TDV Extension API
Retrieve Adapter Configuration
Customize Connection Handling
Customize Metadata Retrieval (Introspection)
Customize Retrieval of Results
Directory Contents and Build Steps
Adapter Package Deployment
Deploying the Package
Troubleshoot Package Deployment
Resource Tree Structure of a Deployed Package
Undeploying a Package
Troubleshoot Package Undeployment
Extension Adapter Configuration
Overview of Extension Adapter Configuration
Extension Adapter User Interface
Extension Adapter Configuration Tab
Flags
Add Any Property
Delete Any Property
Configure Data Type Mappings
Configure Simple Properties
Configure Clauses
Configure Operators or Functions
Extension Adapter Text Tab
Data Source Configuration
Create a New Custom Data Source
Configure a New Custom Data Source
Simple Properties Tabs
Data Type Mappings Tab
Clauses Tab
Operators Tab
Functions Tab
Configuring Extension Adapters for Maven
Configuration Files
YAML File Organization
Data Type Naming
Metadata Introspection Method Properties
Adapter Introspection Properties
Client Interfaces Guide
Introduction to Accessing Your Data through Client Interfaces
About Client Interface Connections
Connecting Client Applications to TDV Resources
Driver Support
TDV Port Settings for Client Connections to TDV
TDV Data Retrieval Tuning for Client Connections to TDV
Connecting to TDV Server through JDBC
Installing JDBC Drivers
Updating the JDBC Driver
Setting the Java CLASSPATH for the JDBC Driver
Setting Pass-Through Credentials for JDBC Clients
Connecting to TDV Server through TIBCO Spotfire
Connecting to TDV Server through SQuirreL
Defining a JDBC Client using a Connection URL
JDBC Driver Connection URL Properties
Examples
Example Java JDBC Client Application Code
Examples of Accessing Data through JDBC
Tips From an Expert on Duplicate Schema Names in a Catalog
Unsupported JDBC Methods
Connecting to TDV Server through ODBC
ODBC Driver Requirements
Installing the ODBC Driver
Installing the ODBC Client Driver on Windows
Uninstalling the ODBC Client Driver on Windows
Installing the ODBC Client Driver on UNIX
Setting the ODBC Environment Variables on UNIX
Creating a DSN with driverConfig on UNIX
Uninstalling the ODBC Client Driver on Unix
Updating the ODBC Driver
Preparing TDV Data Services for ODBC Client Connections
Configuring Each Windows System Data Source Name
Adding a New System DSN
Override the Configured Settings
Defining an ODBC Client using a Connection String
ODBC Driver Connection String Properties
TDV Supported Encoding Standards
Windows
Unix
Connecting Cognos to TDV Using ODBC
Connecting Oracle Database Gateway to TDV Using ODBC
Connecting MicroStrategy to TDV Using ODBC
Connecting Tableau to TDV Using ODBC
Connecting PowerBI to TDV Using ODBC
Examples Using ODBC to Connect to TDV Server
PERL Code Sample for Connecting to TDV Server
C++ Example using the Connection String (DSN-less connection)
C++ UNIX Code Sample for Connecting to TDV Server
VBA Code Sample for Connecting to TDV Server
TIBCO Power BI Data Connector for TDV
Overview
Getting Started
Installing the Connector
Creating the Data Source Name
Getting Data
Advanced Settings
Using the Connector
Querying Data
Visualizing Data
Connection String Options
Remarks
Connection String Options
Connecting to TDV Server through Web Interfaces
Connecting to TDV Server through SOAP
SOAP Message Compression
SOAP Message Optimization
Connecting to TDV Server through REST
Connecting to TDV Server through OData
Connecting to TDV Server through ADO.NET
Setting Up the ADO.NET Driver
Client-Side ADO.NET Driver Support
Installing the ADO.NET Driver
Uninstalling and Repairing ADO.NET
Updating the ADO.NET Driver
Configure an ADO.NET Connection to a Client Restricted Server
Adding and Configuring a Connection to TDV in Visual Studio
Modifying or Deleting a Connection
Working with the Server Explorer
Working with the Visual ToolBox Items
Defining an ADO.NET Client using a Connection URL
ADO.NET Driver Connection URL Properties
Sample Code for Testing of an ADO.NET Driver
Create a CompositeConnection Object
Create a CompositeCommand Object
Select Data from a TDV Published Resource
Select Data from a TDV Published Resource on the Server
Getting the Column Type
Getting Column Metadata
Using an Update Operation in the Sample Code
About Using Parameters
About ADO.NET Placeholders
Invoking a Stored Procedure Example
Using CompositeCommandBuilder
Example with Special Data Types
Retrieving Metadata
Retrieving Tables with a Named Schema
TIBCO ADO.NET 2020 Data Provider for TDV
Overview
Getting Started
Establishing a Connection
Using ADO.NET
Installed Assemblies
Connecting from Code
Querying with the DataReader
Updating the Data
Using the CompositeDataSource
Connection Pooling
Calling Stored Procedures
Using ADO.NET (Entity Framework)
Using EF 6
Model-First Approach
Code-First Approach
Using ADO.NET (Entity Framework Core)
EFCore Console Application
EFCore ASP.NET Application
Code-First Approach
Reverse Engineering (Scaffolding)
Using ADO.NET (LINQ)
LINQ Queries
LINQ Updates
LINQ Inserts
LINQ Deletes
Stored Procedures
Using ADO.NET (SSRS)
Deploy the Provider
Create a Data Source
Create a Dataset
Publish a Report
Using ADO.NET (DbProviderFactory)
Creating DbConnections
Executing DbCommands
Schema Discovery
Tables
Views
Columns
Procedures
Procedure Parameters
Indexes
Index Columns
Foreign Keys
Databases
Users
Connection Properties
Result Sets
Connection String Options
Alternate Security Credentials
Case Sensitive
Catalog
Commit Failure
Commit Interrupt
Compensate
Connection Life Time
Connect Timeout
Data Source
Default Catalog
Default Schema
Domain
Enable Fast Exec
Enable Flood
Enable Reconnect On Error
Encrypt
Fetch Bytes
Fetch Rows
Host
Ignore Trailing Spaces
Kerberos KDC
Kerberos Realm
Kerberos SPN
Locale
Location
Logfile
Max Log File Count
Max Log File Size
Max Rows
No Metadata
Optimization Prepare
Other
Param Mode
Password
Pool Idle Timeout
Pool Max Size
Pool Min Size
Pool Wait Time
Port
Query Passthrough
Readonly
Register Output Cursors
Request Timeout
Session Timeout
Session Token
SSL Client Cert
SSL Client Cert Password
SSL Client Cert Subject
SSL Client Cert Type
SSL Server Cert
SSO
Strip Duplicates
Strip Trailing Zeros
Tables
Trace Folder
Trace Level
Use Connection Pooling
User
User Tokens
Validate Remote Cert
Validate Remote Hostname
Verbosity
Views
TIBCO SSIS Components for TDV
Getting Started
Adding Items to the Toolbox
Establishing a Connection
Deploying to Azure
Prerequisites
Deploying TIBCO SSIS Components to Azure
Managing and Running the Project in SSMS
Configuring the AzureDeploy.ps1 Script
Using the AzureLogfile.ps1 Script
Changelog
General Changes
SSIS Changes
Advanced Features
SSL Configuration
Firewall and Proxy
Logging
Using the SSIS Components
Using the Source Component
Using the Destination Component
Using the Lookup Component
Using the Execute SQL Task
Calling Stored Procedures
Connection Properties
Authentication
Host
Port
Domain
DataSource
User
Password
Encrypt
SSO
UserTokens
Kerberos
KerberosKDC
KerberosRealm
KerberosSPN
UsePlatformKerberosAPI
SSL
SSLClientCert
SSLClientCertType
SSLClientCertPassword
SSLClientCertSubject
SSLServerCert
Logging
Logfile
Verbosity
LogModules
MaxLogFileSize
MaxLogFileCount
Schema
Location
BrowsableSchemas
Tables
Views
Miscellaneous
Alternate Security Credentials
Case Sensitive
Catalog
Commit Failure
Commit Interrupt
Compensate
Connect Timeout
Default Catalog
Default Schema
Enable Flood
Enable Reconnect On Error
Fetch Bytes
Fetch Rows
Ignore Trailing Spaces
Locale
Max Rows
No Metadata
Optimization Prepare
Other
Param Mode
Query Passthrough
Readonly
Register Output Cursors
Request Timeout
Session Timeout
Session Token
Strip Duplicates
Strip Trailing Zeros
Trace Folder
Trace Level
Validate Remote Cert
Validate Remote Hostname
Other
EnableFastExec
Tutorial Guide
REST Tutorial
Understanding REST and the Tutorial Workflows
Basic REST Workflow
Overview of the ACT Example and Summary of Tasks
Creating Studio Resources for Use in this Tutorial
Creating Data Sources
Introspecting the Data Source
Creating the Vplaydata View
Creating the Procedures
Publishing the Procedures to a REST Service
Linking and Mapping Procedures to Specific REST Service URLs
Linking the playdataByID Procedure to an HTTP Verb
Mapping the Studio REST playdataByID URLs to Specific REST Services
Linking the insertPlaydata Procedure to an HTTP Verb
Mapping the Studio REST insertPlaydata URLs to Specific REST Services
Linking the deletePlaydata Procedures to an HTTP Verb
Mapping the Studio REST deletePlaydata URLs to Specific REST Services
Adding a Custom Parameter in an HTTP Header for a REST Request to a Published Method
Creating a Basic Transform Tutorial
Creating the Any-Any Transform
Adding a Query to the supplyChainV Transform
Linking Outputs for Your Transform
Executing and Testing Your Transform
Transform Table and XML Data Tutorials
Create an XML Definition Set for the Tutorial
Converting Relational to Hierarchical Data Tutorial
Converting XML to a View
Creating the Transform and Adding the in Parameters
Adding Parameters to out
Adding the Loop and Iterators
Executing the XML2view Transform
Transform XML Schemas Tutorial
Create the School.xml Data File for the Tutorial
Create an XML Data Source for the Tutorial
Create the GetStudents Transformation Procedure
Creating the ClassStudent Transformation
Adding and Connecting Source Operations
Completing the ClassStudent Transformation
Transform Name and Value Pair Tutorial
Creating an XML Data Source for the Tutorial
Starting the NameValue Transformation Procedure
Creating the Resource to Loop Connections
Creating the Cursor Outputs
Connecting the Loop Operations to out
Connecting the Loop Operations to the Cast Operations
Allowing NULL Output Values
Executing and Testing Your Transform
Transform XML to Relational Tutorial
Creating the School.xml Data File for the Tutorial
Creating an XML Data Source for the Tutorial
Creating the SchoolXML2Rel Transformation
Creating the SchoolXML2Rel View
SAP Hana View Tutorial
Creating a TDV View using an SAP Hana Data Source
Using GROUP BY and COUNT with an SAP Hana Data Source
Discovery Guide
Introducing Discovery
Overview of Discovery
Discovery Key Features and Benefits
How Discovery Works
Discovery and TDV
Discovery Concepts
Discovery Architecture
Indexing
Data Relationships
What Is Included in Studio with Discovery
About Relationship Discovery
About Data Sampling
About the Discovery Tasks Panel
About Indexing
About Pattern Expressions
About the Relationships Discovered
What Is and Is Not Discovered
About Multicolumn Relationships
Table Statistics Displayed for Relationship Discovery
About the Relationship Probability Score (RPS)
Getting Started with Discovery
Discovery Requirements and Support
Discovery System Recommendations
Supported and Unsupported Data Sources
Supported Data Types
About Exporting and Importing Discovery Information
Overview of the Discovery Workflow
A Quick Tour of Discovery
Indexing and Discovering the Data Sources
Creating a New Model
Adding the Data Source to the Model
Discovering Relationships between Multiple Data Sources
Viewing the Schemas in the Model
Getting Table and Relationship Information
Revising the Model and Relationships
Creating a View Based on the Model
Editing the View in Studio
Using and Configuring Discovery
Enabling Multicolumn Relationship Discovery
Defining a Data Source for Discovery
Modifying a Data Source Definition
Deleting a Resource Used by Discovery
Working with Data Domains in Discovery
Using Data Domains
Working with Denormalized Data
Running Indexing and Relationship Discovery
Indexing and Discovering a Data Source
Indexing and Discovering Relationships Across Data Sources
Reindexing and Rediscovering a Data Source
Working with the Discovery Tasks Panel
Viewing Discovery Tasks Panel
Filtering Discovery Tasks
Deleting All Discovery Indexes and Relationships
Clearing Discovery Tasks
Getting Discovery Task Details
Tracking Index and Relationship Task History
Getting More Information about Relationships
Configuring Indexing and Relationship Discovery
Changing the Index Directory
Configuring Case Sensitivity
Configuring Data Domains
Configuring Data Sampling
Configuring Indexing and Discovery for Native Oracle Views
Adjusting the Minimum Score for Relationship Discovery
Adjusting the Minimum Unique Percentage
Adjusting the Weights of the RPS Factors
Adjusting the Maximum Concurrent Tasks
Working with Models in Discovery
About Models in Discovery
Creating a Model
Adding a Resource to a Model
Adding and Removing Resources in a Model
Renaming a Model
Refreshing a Model
Saving a Model
Deleting a Model
Working with the Model Diagram
Editing the Model Diagram
Finding Resources in the Model Diagram
Working with Relationships in the Model Diagram
Printing the Model Diagram
Working with the Cross Schema Diagram
Working with the Model Resources Tab
Working with the Relationships Tab
Ignoring Certain Columns
Saving Relationships to a File
About the Model Info Tab
Creating Views with Discovery
Creating a New Composite View from a Discovery Model
Working with Discovered Relationships in Views
Adding Discovered Relationships to a View
Showing Discovered Relationships in a View
Configuring Relationship Display in Views
Active Cluster Guide
Introducing Active Cluster
Overview of Active Cluster
Advantages of Active Cluster
Active Cluster Architecture
Metadata Repository
Cache Data Sharing
Using a Load Balancer
About the Timekeeper
Triggers
Propagation of Metadata Changes
Error Recovery
Joining and Leaving an Active Cluster
Security Implementation
Installation
Planning the Deployment of Active Cluster
Considerations for Deploying Active Cluster
Deployment Environments
Determining the Number of Nodes in a Cluster
Performance Considerations
Monitor Considerations
Caching
Deployment Example
Typical Process for Deployment
Working with Active Cluster
About Working with Active Cluster
About Manager with Active Cluster
About the cluster_util Program
About Studio with Active Cluster
Privileges Required for Working with Active Cluster
Triggers and Active Cluster
prePropagation of Custom Adapters in an Active Cluster
Creating a New Active Cluster
Adding a TDV Server to an Active Cluster
Preparing to Join an Active Cluster
Joining an Active Cluster
Renaming an Active Cluster
Removing a TDV Server from an Active Cluster
Propagate a Domain Between Clusters
Delete an Active Cluster
Viewing the Status of an Active Cluster
Getting the Active Cluster and Member Names
Configuring an Active Cluster
Configuring Logging for Active Cluster
Changing the Port of a Cluster Node
Handling Active Cluster Errors
Overview of Error Handling
Setting a Timekeeper and Repairing Active Cluster Nodes
Regroup Using Manager
Regroup Using the cluster_util Script
Regroup Using the API
Troubleshooting
Issues with Setting Up a Cluster
A Cluster Node Is DISCONNECTED
A Cluster Node Is Frequently DISCONNECTED
The Timekeeper Cluster Node Fails or Is Taken Offline
A Cluster Node Is Frequently BLOCKED
Cannot start CMS after Backing Up a Cluster Node
Other Best Practices for Active Cluster
Work with Large Amounts of Data
Work with the Command Line Interface
The cluster_util Command-Line Program
Using the cluster_util Program
The -create Subcommand
The -getConfig Subcommand
The -join Subcommand
The -remove Subcommand
The -setClusterName Subcommand
Active Cluster SYS_CLUSTER System Table
Administration Guide
Basic TDV Administration Tasks
Overview of TDV Administration
Security Features
Starting TDV Processes on Windows
Starting and Stopping TDV Processes on Windows
Keeping the TDV Server Process Running after Logoff
Turning Off Automatic Restart of Some Processes
Customizing the TDV Server Startup Scripts on Windows
Starting TDV Processes on UNIX
Starting TDV Server on UNIX
Setting TDV Server to Start Automatically on UNIX
Removing TDV Service Files on UNIX
Starting, Stopping, or Restarting the Cache Database on UNIX
Starting, Stopping, or Restarting the Repository on UNIX
Starting TDV without the Monitor on UNIX
Customizing the TDV Server Startup Scripts on UNIX
Working with the Repository Utility
Configuring the Java Keystore File
Understanding TDV User Templates and Rights
Group and User Rights Templates
Summary of TDV Rights
Changing the Repository Password
Managing the Repository Metadata Table Size
Validating TDV Software License Compliance and Asset Management
Tips for Configuring the Number of TDV Processors
TDV Logging Information
About TDV Log Files
Installation and Uninstallation Logs
Server, Monitor, and Studio Log Files
Configuring Email Alerts for TDV Events or Actions
Configuring and Enabling Event Logging
Enabling Logging of System Events
Enabling SNMP Traps in TDV
About the SNMP Server Events in TDV
Configuring an SNMP Trap Receiver
Events that Can Be Sent to Custom Event Handlers
Enabling Recording of Data Source Usage in the Events Log
Customizing Audit Log File Behavior
Adjusting Time Limits for Request Events
Determining Data Source Type and Version Information
Logging Query Execution Statistics
Using TDV Log Files to Track Resource Privilege Changes
Validating TDV Software License Compliance and Asset Management
Determining Your TDV Software License Conformance
Tips for Configuring the Number of TDV Processors
Logging Tips from an Expert
Using Detailed Logging
Controlling the Size of Files Specified in log4j.properties
Configuring TDV Data Connections
Installing and Using Preconfigured JDBC Drivers
Using the ODBC Driver on Windows
Supported ODBC Data Types
Adding ODBC Data Sources on Windows
Using the ODBC Driver on UNIX
Setting the ODBC Environment Variables on UNIX
Creating a DSN with driverConfig on UNIX
Connecting SAS System to TDV ODBC
Configuring TDV for Using a JMS Broker
Configure Communications between TDV and the JMS Broker
Adding JMS Connectors to the TDV Server
Configuring TDV for AIX Platforms
Improving Studio Response Times for AIX Connections
System Monitoring with Studio Manager
Studio Manager Window and Toolbar Overview
Using Studio Manager
Launching Studio Manager
Selecting Columns for Display
Viewing Table Row Details
Sorting Rows
Customizing Filters for Studio Manager
Configuring the Columns on the Cached Resources Panel
Enabling and Disabling Caches in Studio Manager
Modifying the Cache Schedule in Studio Manager
Refreshing a Cache in Studio Manager
How to Troubleshoot Cache Refresh
Configuring Time for Requests to Stay Active on the Studio Manager Request Panel
Scheduling Data Source Connection Testing
Studio Manager UI Reference
Server Overview Panel
Cached Resources Panel
Data Sources Panel
Events Panel
I/O Panel
Memory Panel
Requests Panel
Sessions Panel
Storage Panel
Transactions Panel
Triggers Panel
System Management with Manager
Using Manager
Launching Manager
Refresh the Current Page
Sort with Manager
Filter Table Data
Creating a New Table Filter
Copying an Existing Filter
Manager UI Reference
MANAGER HOME Page
SERVER OVERVIEW Page
CACHED RESOURCES Page
DATA SOURCES Page
REQUESTS page
SESSIONS page
TRANSACTIONS Page
TRIGGERS page
TDV Configuration Options
Fine Tuning Memory
About Paging
Configuring the Caching and Data Processing Directory
Viewing Usage and Cleaning Up Memory
Changing Default Memory Settings
Fine Tuning Performance Using Connection Pools
Using Pass-through Optimization with Oracle Data Source Clients
Using Pass-through Optimization with SQL Server Data Source Clients
Using Pass-Through Introspection with Vertica Data Source Clients
Enabling Studio Locking
Configuring Case Sensitivity and Trailing Spaces Settings
Determine Whether Case or Trailing Space Settings Affect Query Performance
Setting Server-wide Case and Trailing Space Behavior Using Configuration Parameters
Setting Session-wide Case and Trailing Space Behavior Using Connection Properties
Configuring Case and Trailing Space Behavior for Built-in Procedures
Configuring Case and Trailing Space Behavior for Queries
Using STRICT to Control Case and Trailing Space Behavior for Queries
Mismatch Effects on String Comparisons
Function Overrides
LPAD and RPAD return length
Management of Data Source Customization
Password Storage Options
Customizing the Login Screen Default Domain Value
Custom Server Settings For External Tools
Composite Domain Administration
About the Composite Domain
About Domain Management
Group Management
Built-in Groups
Adding Groups to the Composite Domain
Removing Groups
User Management
Built-in Users and Their Privileges
Adding Users to the Composite Domain
Removing Users from the Composite Domain
Auditing User Access to TDV Defined Resources
Managing Group Membership
Viewing Group Membership
Editing Group Membership
Changing Passwords for Other Composite Domain Users
Changing Ownership of Resources
Manage User and Group Privileges
LDAP Domain Administration
About the LDAP Domain
LDAP Domain - Active Directory 2003 Limitation
Configure the LDAP Properties File
Structure of the LDAP Properties File
Example of an ldap.properties File
LDAP Properties File Symbols and Attributes
Query Examples
LDAP Domain Administration
About Kerberos Configuration Files and LDAP Login Credentials
Adding an LDAP Domain
Working with Groups from an LDAP domain
Editing LDAP Domain Connection Parameters
Removing an LDAP Domain
LDAP User Management
Adding Users to TDV from an LDAP Domain
Remove LDAP Users from TDV
Add Users to Groups
Configuring LDAP for Use with Certificate Authentication
Configuring LDAP for Use with Nested Groups
Azure Domain Administration
About the Azure Domain
Azure Domain Administration
Adding an Azure Domain
Azure Group Management
Editing Azure Domain Connection Parameters
Removing an Azure Domain
Dynamic Domain Administration
About Dynamic Domains
About Dynamic Domain Administration
Enabling the Dynamic Domain
About Group Administration for Dynamic Domains
Considerations for Granting Privileges to Dynamic Domain Users
Viewing Dynamic User Names
About User Administration
Adding Users to the Dynamic Domain
Remove Users from the Dynamic Domain
Dynamic Users Group Membership
Viewing Dynamic User Group Membership
OAuth Domain Administration
About the OAuth2 Domain
OAuth2 Architecture
OAuth2 Domain Administration
Adding an OAuth2 Domain
Working with Claims from an OAuth2 domain
Editing OAuth2 Domain Connection Parameters
Removing an OAuth2 Domain
Defining Security Policies for Claims
Hybrid OAuth2 Domain
TDV and SSL Authentication
Overview of TDV and SSL
Keystore and Truststore Files for TDV
Keys Passed between System Components
Default Locations of Keystore and Truststore Files
Keystore and Truststore Configuration Parameters
Setting Which Protocols to Disable When Creating an SSL Connector
Setting Up SSL
Using the Keytool Utility
Installing a Truststore Certificate
Setting Up Authentication between Studio and the TDV Server
Setting Up Authentication between Client Applications and TDV Server
Creating a JDBC Client Application with SSL Capability
Setting Up Authentication between Client Applications and TDV Server over JDBC
Setting Up Client Authentication for Web Data Sources
Setting Up Client Authentication for Relational Database Sources
SSL Mutual Authentication
Example - How to Obtain a third-party SSL Certificate and install into your Server and Studio Truststore?
Configuring Kerberos Single Sign-On
About Kerberos Authentication and TDV
Supported Platforms and Requirements for Kerberos
Data Sources and Kerberos
Using Kerberos Authentication with TDV
Configuring Kerberos for Use with TDV
Configuring TDV for Use with Kerberos Authentication
Setting Up SSPI Kerberos SSO
Setting Up JGSS Kerberos SSO
About Studio and SSO with Remote Desktop
Using Kerberos Authentication with Published Resources
Configuring New Web Services for Kerberos Authentication
Verifying Kerberos for an OData Data Service
Using Kerberos SSO Authentication with Data Sources
About Configuring Kerberos SSO for Data Sources
About JDBC Clients and Kerberos SSO
Setting the DSN for ODBC Clients and Kerberos SSO
About ADO.NET Clients and Kerberos SSO
Configuring Kerberos with Hive and Impala Data Sources
Tip from an Expert on SSO Connection Issues
Kerberos Test Utility
Troubleshooting Tips
Managing Security for TDV Resources
Overview of TDV Security Features
Summary of Password Encryption and Security in TDV
Summary of Internet Security Options
Rights and Privileges
Resource Rights
Resource Privileges
Configuring Account Security for TDV
Configuring Account Lockout for TDV
Locking and Unlocking TDV User Accounts
Setting IP Restrictions
Row-Based Security
About Row-Based Security
Enabling Row-Based Security on TDV Resources
Creating or Editing Row Filter Policies
Creating or Editing a Row Filter Policy Group
Assigning Row Filter Policies to TDV Resources
Testing the Security Filter Policies Within Studio
Encryption Settings for TDV Server
Configuring Pass-Through Security for HiveServer2
Configuring Samba and Winbind for NTLM (Tips from an Expert)
Using Version Control and TDV
About Version Control (VCS) for TDV
Configuring Version Control for TDV Resources
Creating a VCS connection with SSL Authentication
Change User Credentials for TDV Version Control
Attach a TDV Folder to a VCS Instance
Committing TDV Resources to the VCS
View the History of a Resource
View the Full History of a Resource
Compare a Resource with Local
Revert Changes to a Resource
Checking In a Resource to the VCS
Checking In Multiple Resources to the VCS
Detach a VCS Folder from Your TDV Instance
TDV Data Directory Management
Manage Connections
Managing Column-Based Security
About Column-Based Data Obfuscation
Column-Based Restrictions and Privileges
Enabling Column-Based Security on TDV Resources
Creating or Editing Column Filter Policies
Mapping Column Filter Policies to TDV Resources
Testing the Column Filter Policies Within Studio
Importing and Exporting Column Filter Policies
System Event and Log Monitoring
Configuring Events
About Events
EVENT LOG Summary Information
Work with the EVENT LOG Page
The EVENT LOG Table
Event Details in Manager
I/O Log
Memory Log
Storage Log
TDV Command-Line Utilities
The TDV Export and Import Utilities
About the Backup Export Utility
Rights Required for the Backup Export Utility
Using the Backup Export Utility
Using the Keystore File from an Exported CAR File
Rules for the Backup Import Utility
Rights Required for the Backup Import Utility
Using the Backup Import Utility
Modifying the PostgreSQL Repository Maximum Allowed Packets
The TDV Package Import Utility
Rules for the Package Import Utility
Restrictions for the Package Import Utility
Using the Package Import Utility
The TDV Package Export Utility
The TDV Server Utility Program
Using the Server Utility
Server_util.sh Examples
Using the TDV Server Heap Dump Utility Program
Deployment Manager
About Deployment Manager
Deployment Manager Architecture
Limitations
Basic Deployment Manager Concepts and Definitions
User Roles and Workflows
Starting Deployment Manager
Defining Sites
Accessing Sites
Adding a New Site
Editing Site Properties
Refreshing Site Resources
Deleting a Site
Defining Resource Bundles
Defining Principal Bundles
Defining Mappings
Defining Deployment Plans
Accessing Plans
Creating a New Deployment Plan
Defining the Resource Bundle to Migrate
Defining the Principal Bundles to Migrate
Removing Resources from a Target Site
Removing Principals from a Target Site
Extending Deployments with Procedure Call Operations
Previewing a Deployment Plan
Editing Deployment Plan Properties
Refreshing Deployment Plans
Exporting a Deployment Plan
Deleting a Deployment Plan
Executing Deployment Plans
Executing a Deployment Plan
Executing a Deployment Plan Remotely
Viewing Source Site Updates Since the Last Plan Execution
Viewing the Execution Log Results
Purging the Execution Logs
Importing and Executing a Deployment Plan
Backing Up and Restoring the Deployment Manager Server
Backing Up the Deployment Manager
Restoring the Deployment Manager Server
Using TDV Workload Management
Limitations
About Rule Precedence
Setting Up and Configuring Workload Management
Viewing Your Workload Management Rules in Studio
Viewing Rule Precedence
Testing Workload Rules
Configuring Email Alerts for Workload Management
Example - Creating a trigger to limit memory use using Workload Management
Configuring NTLM Authentication
NTLM Authentication and TDV
Implementing NTLM Authentication for Windows
Configuring TDV as the Server
Configuring SQL Server in the TDV Server to use Windows Authentication
Configuring TDV as the Client
Implementing NTLM Authentication for UNIX
Verifying NTLM for an OData Data Service
Pluggable Authentication Modules
About Pluggable Authentication Modules
Minimum Elements of a PAM
Working with TDV and PAM
The Manifest File
Creating a Principal Authentication Module
Deploying Pluggable Authentication Modules
What Happens at Deployment and Run Time
Verifying that the PAM Deployed
Enabling PAM Features for TDV
Adding a Module
Ordering Module Execution Sequence
Assigning Users to TDV Groups or Identities
Undeploying Pluggable Authentication Modules
Example
Collecting TDV and Data Usage Metrics
About Data Usage Metrics
Setting Up and Configuring Metrics Collection
Pre-Creating the External Database and Tables for Metrics Data Storage
Using Studio to Create the Database and Tables for Metrics Data Storage
Configuring TDV Metrics Collection
Configuring Email Alerts for Metrics Notification
Publishing and Reporting on TDV Metrics Data
About Using MAXMEMORY in Your Reports
SNMP Trap Message Reference
SNMP Details for Monitor Events
SNMP Details for Server Events
SNMP Details for Requests
SNMP Details for Transactions
SNMP Details for Cached Resources
SNMP Details for Triggers
SNMP Details for Data Sources
SNMP Details for Sessions
SNMP Details for Resources
SNMP Details for Storage
SNMP Details for Server Events
SNMP Details for Security
SNMP Details for Workload
SNMP Details for KPI
SNMP Details for Audit Startup and Shutdown
TDV Event Log Message Reference
TDV Trap Messages and Variables
TDV Monitor Events
TDV Server Events
Active Cluster Events
Security Features Guide
About TDV and BD Security Features
Security Feature Highlights
TDV Security Features by Component
TDV Installer Security
Script output:Repository Security
Repository and Cache Database Access and Privileges
Log File Security
Encryption
Studio Session Security
Data Source Security
Export Files Security
Monitor Security
JDBC, ODBC, and ADO.NET Client Security
Manager Clients Security
Studio Client Security
TDV Server Security
Kerberos Support
Web Service Client Security
Supported Web Service Security Standards
Explanation of Web Services Policy
Authentication between Clients and TDV
Using Kerberos Constrained Delegation
Authentication between TDV and Data Sources
Composite Domain Security
SSL Protocol Configuration
Java Supported Cipher Suites
How To Disable Specific Ciphers
Updating JDK and Security Property
TIBCO Data Virtualization®
Updating JDK and Security Property