Creating and Customizing Data Sources · Creating and Customizing Data Sources Project Name Release 1.1 Date March 2018 Primary Author Tony Young / Mike DeAngelo Document Owner Tony

1

Professional

Services

www.tibco.com

Global Headquarters 3303 Hillview

Avenue Palo Alto, CA 94304

Tel: +1 650-846-1000 +1 800-420-8450 Fax: +1 650-846-1005

TIBCO Software empowers

executives, developers, and

business users with Fast Data

solutions that make the right data

available in real time for faster

answers, better decisions, and

smarter action. Over the past 15

years, thousands of businesses

across the globe have relied on

TIBCO technology to integrate their

applications and ecosystems,

analyze their data, and create real-

time solutions. Learn how TIBCO

turns data—big or small—into

differentiation at www.tibco.com.

Creating and Customizing Data Sources

Project Name

Release 1.1

Date March 2018

Primary Author

Tony Young / Mike DeAngelo

Document Owner

Tony Young

Client

Document Location

Purpose Introduces the concepts and procedures to

create and customize data sources in TIBCO Data Virtualization.


© Copyright TIBCO Software Inc. 2 of 48



Revision History

Version Date Author Comments

1.0 November 2013 Tony Young, Mike DeAngelo

Initial revision

1.1 March 2018 Deane Harding Updated with TIBCO branding

Approvals This document requires the following approvals. Signed approval forms are filed in the project files.

Name Signature Title Company Date of Issue Version

Distribution This document has been distributed to:

Name Title Company Date of Issue Version

Related Documents This document is related to:

Document File Name Author



Copyright Notice COPYRIGHT© TIBCO Software Inc. This document is unpublished and the foregoing notice is affixed to protect TIBCO Software Inc. in the event of inadvertent publication. All rights reserved. No part of this document may be reproduced in any form, including photocopying or transmission electronically to any computer, without prior written consent of TIBCO Software Inc. The information contained in this document is confidential and proprietary to TIBCO Software Inc. and may not be used or disclosed except as expressly authorized in writing by TIBCO Software Inc. Copyright protection includes material generated from our software programs displayed on the screen, such as icons, screen displays, and the like.

Trademarks All brand and product names are trademarks or registered trademarks of their respective holders and are hereby acknowledged. Technologies described herein are either covered by existing patents or patent applications are in progress.

Confidentiality The information in this document is subject to change without notice. This document contains information that is confidential and proprietary to TIBCO Software Inc. and its affiliates and may not be copied, published, or disclosed to others, or used for any purposes other than review, without written authorization of an officer of TIBCO Software Inc. Submission of this document does not represent a commitment to implement any portion of this specification in the products of the submitters.

Content Warranty The information in this document is subject to change without notice. THIS DOCUMENT IS PROVIDED "AS IS" AND TIBCO MAKES NO WARRANTY, EXPRESS, IMPLIED, OR STATUTORY, INCLUDING BUT NOT LIMITED TO ALL

WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. TIBCO Software Inc. shall not be liable for errors contained herein or for incidental or consequential damages in connection with the furnishing, performance or use of this material.

Export This document and related technical data, are subject to U.S. export control laws, including without limitation the U.S. Export Administration Act and its associated regulations, and may be subject to export or import regulations of other countries. You agree not to export or re-export this document in any form in violation of the applicable export or import laws of the United States or any foreign jurisdiction.

For more information, please contact:

TIBCO Software Inc. 3303 Hillview Avenue Palo Alto, CA 94304

USA



Table of Contents 1 Introduction .............................................................................................................................. 7

1.1 Purpose ................................................................................................................... 7

1.2 Audience ................................................................................................................. 7

2 Before You Start ....................................................................................................................... 8

2.1 SQL JDBC Client ................................................................................................... 8

2.2 Coding Environment ............................................................................................... 8

2.3 WinTail ................................................................................................................... 8

2.4 Documentation ........................................................................................................ 8

2.5 Gather Information ................................................................................................. 8

3 Step 1: Connect Independent of TDV ...................................................................................... 9

3.1 Connect with a SQL JDBC Tool ............................................................................ 9

3.2 Check out the MetaData Objects ............................................................................ 9

4 Step 2: Connecting TDV to the Data Source ......................................................................... 10

4.1 Logging ................................................................................................................. 10

4.2 Create the Data Source Type in TDV ................................................................... 10

4.3 Understanding the Data Source Values File ......................................................... 10

4.4 Create the Data Source ......................................................................................... 11

5 Step 3: Introspection ............................................................................................................... 13

5.1 Modify Settings .................................................................................................... 13

5.1.1 Catalogs and Schemas ................................................................................................ 13

5.1.2 Tables .......................................................................................................................... 13

5.1.3 Objects Associated with Tables .................................................................................... 13

5.1.4 Objects Associated with Tables .................................................................................... 13

5.1.5 Perform the Table Introspection.................................................................................... 13

5.2 Check the Column Introspection .......................................................................... 14

6 Step 4: SQL SELECT Generation .......................................................................................... 15

6.1 Basic SELECT ...................................................................................................... 15

6.2 Case Sensitivity and Trailing Spaces .................................................................... 16

6.3 Simple WHERE Clause Equality Predicates ........................................................ 16

6.4 Date, Time and Timestamp Literals ..................................................................... 17

6.5 Simple Non-Equality Operations .......................................................................... 17

6.6 More Complex Operations ................................................................................... 17

6.7 Logical Operations................................................................................................ 18

6.8 Sub-queries in WHERE Clause ............................................................................ 18



6.9 Basic Aggregates .................................................................................................. 18

6.10 Sorting .................................................................................................................. 19

6.11 Joins ...................................................................................................................... 19

6.12 Distinct .................................................................................................................. 19

6.13 Sub-queries in FROM ........................................................................................... 19

6.14 Set Operations ....................................................................................................... 19

6.15 Functions and Operators ....................................................................................... 20

6.15.1 Notes About Function and Operator Expressions ......................................................... 20

6.15.2 Functions ..................................................................................................................... 21

6.15.3 CAST Functions ........................................................................................................... 21

6.15.4 Operators ..................................................................................................................... 23

7 Capabilities, Statements and Prepared Statements ................................................................. 24

8 Conclusion .............................................................................................................................. 25

Appendix A: Example Values File for IBM Classic Federation Server .......................................... 26

Appendix B: Full List of Properties ................................................................................................. 35

Capabilities for Data Source Driver ........................................................................................... 35

Capabilities for Data Source Introspection ................................................................................ 35

Constants for Data Source Connection Supported Operation in IAF Layer ................................ 35

Constants for Data Source Supported Operations in JDBC Driver ............................................. 36

Constants for JDBC Data Source Capabilities ........................................................................... 37

Constants for Expressions ........................................................................................................ 44

Constants for Comparisons ...................................................................................................... 46

Constants for Datatype Categories ........................................................................................... 46

Constants for Primitive Datatypes ............................................................................................. 46

Constants for Primitive Datatype Attributes ............................................................................... 47

Constants for SQL Statement Clauses ...................................................................................... 47

Constants for Function Mapping ............................................................................................... 48



1 Introduction

1.1 Purpose The purpose of this document is to introduce the concepts and procedures to create and customize data sources in TIBCO Data Virtualization (TDV). Those looking to create a new data source entirely, or to whom the idea of customizing data sources is completely new, should read the entire document. Those familiar with capabilities and

values files, or looking only to customize a given data source, should find the below section on SQL SELECT statements useful.

1.2 Audience This document is intended to provide guidance for the following users:

• TIBCO Professional Services

• Clients requiring integration of non-standard data sources

It is assumed readers are familiar with the following technologies and TDV concepts:

• XML: attributes, elements and document structure

• Data sources: creation and introspection concepts, querying

• SQL and JDBC



2 Before You Start

2.1 SQL JDBC Client Download and install a generic JDBC client such as Squirrel SQL or DBVisualizer. JDBC is important because that is the protocol that TDV uses under-the-hood and you may do apples-to-apples comparisons. Ultimately, choose a tool you are comfortable using.

2.2 Coding Environment Download and install a JDK and IDE such as Eclipse. It can be useful for troubleshooting really tough problems if you can get yourself a little bit of skeleton code, create a JDBC connection in a standalone program, get the DatabaseMetaData object and inspect the list of tables, columns for a table etc. It will also be possible to run a query and examine the ResultSetMetaData object.

2.3 WinTail If you are developing on a windows platform, download and install WinTail. It will allow you to perform a UNIX-style tail command on log files, which will come in handy when trying to debug connections and function calls to the data sources.

2.4 Documentation It would be useful to download the JDK 7 JavaDocs locally so you can access them even if you have limited connectivity to the internet. Also, find and download as much documentation on the data source you are connecting to as possible. JDBC reference guides, installation guides, SQL language references, etc. will all come in handy if you

have no internet connection.

2.5 Gather Information Ensure you have at least the following from the client: full product name and version/revision, server name, port, database name, user ID and password. If possible, get the set of JDBC drivers directly from the client, or, download them from the internet if that is a problem. Other useful pieces of information include: the JDBC connection URL format, the driver classname to use.



3 Step 1: Connect Independent of TDV

3.1 Connect with a SQL JDBC Tool It is important to prove that the JDBC driver works in the client’s environment. Create a connection to the data source in question and verify that the information provided to you by the client is correct:

• JDBC URL is correct

• Driver class name is correct

• Server, port, database name, username, and password are correct.

3.2 Check out the MetaData Objects Most generic JDBC tools have a SQL view and an Object view. The SQL view allows you to execute SQL commands and display the result sets, while the object view allows you to browse the various objects available in the data source, by hierarchy, and is the result of the various DatabaseMetaData calls in JDBC

Browse around the Objects view, and make note of what you see:

• Can you see catalogs, schemas and tables?

• Can you see the column names and types for a table?

Some data sources won’t show data here. For example, some versions of DB2 on mainframe need a special set of stored procedures installed so that these metadata calls work. Some products may have a minimal driver that doesn’t properly implement the metadata calls

Many of the metadata methods return ResultSet objects. For instance, if you choose a table in the object browser, then

choose columns of the table, you’ll see the ResultSet that is returned by the JDBC getColumns() method. Inspect the column names:

• Do they match the columns specified in the JavaDoc for java.sql.DatabaseMetaData.getColumns()?

• Some JDBC drivers, for example the SAS Share driver, do not provide the correct column names. Is something non-standard displayed, such as column names or data type names?

If the metadata methods seem to work according to the JDBC spec, there is a good chance introspection will work out of the box. If the metadata methods work, but don’t conform to the JDBC spec by doing things like using non-standard column names, there will need to be more configuration and possibly a product patch

If the driver does not supply metadata at all (like SAS SPD,) then it is unlikely you can get something working without significant development. You may consider creating the data source, skipping introspection, and using packaged

queries to access the data.



4 Step 2: Connecting TDV to the Data Source

4.1 Logging Enable debugging for log4j.logger.com.compositesw.cdms.datasource=DEBUG and log4j.logger.com.compositesw.cdms.datasource.introspect=DEBUG. These properties are in the log4j.properties file at TDV_HOME/conf/server. With these properties switched on, a lot of log information will be generated, so it will be

useful to tail the logs.

4.2 Create the Data Source Type in TDV In the “New Data Source…” dialog in Studio, create the new data source type. Reuse the driver classname and JDBC URL patterns that were used when connecting the generic JDBC client to the data source with three important substitutions:

• Replace the server address with <HOST>

• Replace the server port with <PORT>

• Replace the database name with <DATABASE_NAME>

These three substitutions will allow TDV to automatically insert the configured values in the data source configuration paned

TIP: You can get some good hints about the JDBC URL pa tterns by entering this command on a console in TDV_HOME:

find apps/dlm -path \*/cis_ds_\*/conf\*.capabilitie s -exec grep -iH ^dsdriver\.url_pattern {} \;

TIP: Keep this command in your back pocket. Changing t he pattern to grep is a nice way to see any setting in all the capabilities files at once.

The data source type generation will create a directory in conf/adapters/custom. The directory will be the name of the custom data source type name provided in all lower case, with spaces turned into underscores, and some other handling for special characters. Copy the JDBC driver and any needed supporting files into that directory. There will also be a file created in that directory <DATASOURCE_TYPE_NAME>_values.xml (referred to herein as “values file.”)

Inside that XML is where data source settings will be created/modified for your custom data source.

4.3 Understanding the Data Source Values File TDV “learns” how to “talk” to a data source through capabilities files. These files are provided by TIBCO Engineering and follow a precise format of:

<property>: <value>

Such as:

jdbcds.with_clause: false

When customizing a data source, do not modify the capabilities files. They will be overwritten when product patches are applied, and won’t transfer when a data source is exported or promoted. Also, these files are not created for custom data sources. Instead, modify the values XML file at:



TDV_HOME/conf/adapters/<TYPE>/<DATASOURCE_TYPE_NAME >/<DATASOURCE_TYPE_NAME>_values.xml

This file will not be overwritten by patches. It will also be carried along with JDBC driver files during exports. Values files are a simple collection of XML fragments of type Attribute, and are defined as entries like this:

<ns33:attribute xmlns:ns33="http://www.compositesw.com/services/sys tem/util/common">

<ns33:name>/runtime/query/withClause</ns33:name>

<ns33:type>BOOLEAN</ns33:type>

<ns33:value>false</ns33:value>

<ns33:configID>jdbcds.with_clause</ns33:configID>

</ns33:attribute>

For readability, you may pull out the namespace and use the common namespace instead: <common:attribute>

<common:name>/runtime/query/withClause</common:na me>

<common:type>BOOLEAN</common:type>

<common:value>false</common:value>

<common:configID>jdbcds.with_clause</common:confi gID>

</common:attribute>

• The “name” element isn’t really important and may be defined as

/custom/attribute.property

• The “value” element in normally true | false, a number, or a string. Keep in mind that values can contain characters that need special handling in XML, so use &, ", ', > and < when needed

• The “type” element specifies the data type of the “value” element, and is usually

BOOLEAN | STRING | INTEGER

• The “configID” element is the property to be modified or defined, and follows the property set defined in capabilities files. A full reference on these properties is included in this document

It is also possible to create a text file with capabilities-style text fragments and convert that to a XML values file using the capabilities converter java application from TIBCO Engineering. This is the supported method of generating values file entries. This document assumes the reader will choose the method that they are comfortable with. Properties to be modified will be presented as capabilities-style text fragments for readability.

4.4 Create the Data Source In the “Add Data Source…” dialog inside Studio, select the custom data source type just created, and configure the connection information. Test the data source connection and watch the logs for a successful connection or an error message Save the connection and try to introspect. Again, watch the logs. One error that often comes up here is that TDV tries to issue a commit in order to test a connection. If the data source does not support transactions this could throw an exception. In that case, you need to modify the values file and set this property:

iafconnection.commit: false

Setting the transaction isolation level can also throw an exception. We need to set the following properties to tell TDV whether the data source supports these transaction isolation levels. This information may generally be found in the SQL or JDBC reference documents downloaded earlier, or, through trial and error by setting the properties all to true, and



setting the isolation level in the data source configuration panel to each isolation level in turn, changing the property values to false for unsupported isolation levels:

jdbc.transaction_none: true | false

jdbc.transaction_read_committed: true | false

jdbc.transaction_read_uncommitted: true | false

jdbc.transaction_transaction_repeatable_read: true | false

jdbc.transaction_serializable: true | false

jdbc.transactions: true | false



5 Step 3: Introspection

5.1 Modify Settings The pattern of: set property value, restart server, test; will be repeated frequently when creating a new data source.

5.1.1 Catalogs and Schemas It is important to determine if the data source supports catalogs and schemas. Then, set the appropriate values for:

introspect.relational.include_catalog: true | false

introspect.relational.include_schema: true | false

If it uses neither catalogs nor schemas define both to be false.

Sometimes, a database does not use schemas but does use catalogs. Since this is against the JDBC spec, TDV doesn’t support this directly, but one can tell the introspector to treat the catalogs as if they were schemas. To do this, set:

introspect.relational.use_catalogs_for_schemas: tru e

5.1.2 Tables One almost certainly wants to include tables for introspection. But, one may set:

introspect.relational.include_table: true | false

5.1.3 Objects Associated with Tables Primary and foreign keys, and indexes, are less important to the overall use of a data source in TDV. One can try to introspect them, and, set these values to true or false as appropriate

introspect.relational.include_table.primary_keys: t rue | false

introspect.relational.include_table.foreign_keys: t rue | false

introspect.relational.include_table.foreign_keys.im ported: true | false

introspect.relational.include_table.foreign_keys.ex ported: true | false

introspect.relational.include_table.indexes: true | false

5.1.4 Objects Associated with Tables Stored procedures may be introspected as well as tables. Set the value for including procedures during introspection appropriately. If procedures are not needed, it is best to not introspect them as additional settings and determination of output parameters may be skipped:

introspect.relational.include_procedure: true | fal se

5.1.5 Perform the Table Introspection Once the settings above are complete, it is recommended to restart the server to ensure the settings are properly loaded. The button inside a data source to reload custom capabilities does not reload all settings.

Check the log files to verify that no errors are present.



5.2 Check the Column Introspection If introspection completed properly, a list of tables should be present inside the namespace in Studio. Open each table

to look at the column definitions and check:

• Are all the columns introspected for each table?

• Are the columns introspected with the appropriate types?

Pay particular attention to a column that is introspected with a type of OTHER. These columns may need to have their data types (native types) mapped to an ANSI standard data type. To map a native type to a TDV type, add an attribute element with the configID of jdbcds.datatype.<native_type> and an appropriate value of the type in TDV. The native type in the configID field should be trimmed of any length/precision info, converted to lower case, and any spaces converted to underscores. For example, say that a data source reports a type LONG INTEGER(25) and TDV treats it as OTHER. The entry in the values file might be:

<common:attribute>

<common:name>/config/jdbcds.datatype.long_integ er</common:name>

<common:type>STRING</common:type>

<common:value>bigint</common:value>

<common:configID>jdbcds.datatype.long_integer</ common:configID>

</common:attribute>

Restart TDV and re-introspect to see that the column types are handled properly.



6 Step 4: SQL SELECT Generation

6.1 Basic SELECT Once introspection is functioning correctly, the next step is to get a basic SELECT working so that “Show Contents” for a table will work properly in studio. Some databases require it, and these settings will tell TDV to wrap the column, table, schema, and catalogs in double-quotes.

jdbcds.delimited_identifier_closing_char: "

jdbcds.delimited_identifier_opening_char: "

jdbcds.catalog_delimited_identifier_opening_char: "

jdbcds.catalog_delimited_identifier_closing_char: "

jdbcds.schema_delimited_identifier_opening_char: "

jdbcds.schema_delimited_identifier_closing_char: "

jdbcds.table_delimited_identifier_opening_char: "

jdbcds.table_delimited_identifier_closing_char: "

jdbcds.column_delimited_identifier_opening_char: "

jdbcds.column_delimited_identifier_closing_char: "

TIP: Don’t forget that in XML format, the double-quote character will need to be expressed as "

Next we need to tell TDV to reference the table using “catalog”.“schema”.”table” and the columns as “table”.”column”. Set the following to true or false as appropriate:

jdbcds.catalogs_in_tables: true | false

jdbcds.schemas_in_tables: true | false

jdbcds.tables_in_columns: true | false

You might also add the following in order to generate aliases…

jdbcds.alias_generation_pattern: expr$1

With these settings in place, restart the server and attempt to perform a simple “SELECT * FROM table” within Studio. Generate a Query Plan and inspect the generated SQL in the FETCH node. If there are any problems executing the SQL, copy and paste it into the generic JDBC tool and execute it to determine whether the data source does not like the submitted SQL, or TDV is having some problem interpreting the response from the data source

If the SQL is not correct, inspect the data source error messages and experiment with the SQL in the database tool until it successfully executes. Adjust the SQL generation in TDV appropriately

If TDV is not able to interpret the response from the data source, the data type mapping may need to be adjusted, followed by a re-introspection, and retesting of the query.



6.2 Case Sensitivity and Trailing Spaces Using the generic JDBC tool, run some queries against the data source to determine its case sensitivity and trailing

space settings. For example, run the following to get some sample data:

SELECT <some_varchar_column> FROM <some table>

Pull a random row from the table having <some_varchar_column> equal to <Some Data>. To determine if the database is case sensitive, execute the SQL command:

SELECT <some_varchar_column> FROM <some table> WHER E <some_varchar_column> = '<SOME DATA>'

If you receive the original row chosen, then the database has case insensitive comparisons. If you receive only rows where the case of <Some Data> is all uppercase, or no rows at all, then the database has case sensitive comparisons

Next, using the same random row, execute the SQL command:

SELECT <some_varchar_column> FROM <some table> WHER E <some_varchar_column> = '<Some Data> '

If you receive the original row chosen, then the database does not include trailing spaces in comparisons. If you do not receive the original row chosen, or rows where the column value is exactly '<Some Data> ', then the database does include trailing spaces in comparisons

Set the following properties based on your findings:

jdbcds.comparisons_case_insensitive: true | false

jdbcds.trailing_spaces_included_in_comparison: true | false

6.3 Simple WHERE Clause Equality Predicates In Studio, write a simple SELECT with a WHERE clause equality predicate on a VARCHAR or CHAR column. Generate a query plan. Does it push? If not, check the No Push Reason. You may need to set or adjust one of these properties:

expr.eq_pattern: $1 = $2

comp.eq_pattern: (@date,@date)||(~number,~number)||(@char,@char)||(@ char,@varchar)||(@varchar,@varchar)

sql.where.clause: true

TIP: The comp.eq_pattern can get very long. Look at va rious capabilities files for examples

Don’t forget that the query engine must be using the same settings for trailing spaces and case sensitivity as the data

source to have these options push without modification. To properly verify push, either modify the server settings temporarily to match the database settings, or include a query hint to force execution of the query to follow the settings of the database

Once a simple WHERE clause executes properly with character data, try a simple WHERE for numbers. If you are having trouble pushing character or numeric literals, try and look at the definition of expr.numeric and expr.string. These are normally defined as $1 and ‘$1’ respectively, but these properties may need to be overridden for some data sources

expr.numeric: $1

expr.string: ‘$1’



6.4 Date, Time and Timestamp Literals For dates, times and timestamps, one needs to define expression patterns. If the data source accepts an ISO

expression for a literal date, time or timestamp, this may be as simple as the following:

expr.datetime: ''yyyy-MM-dd HH:mm:ss''

Or it could be more complex like the following:

expr.datetime: 'CONVERT(DATETIME, '''yyyy-MM-dd HH: mm:ss.SSS''')'

Another pattern used occasionally is the JDBC escape syntax, that looks like this example:

expr.datetime: '{ts ''yyyy-MM-dd HH:mm:ss''}'

Ultimately, one must define the pattern that TDV must use to properly format date, time, and timestamp values for the

database. The capabilities files contain many examples for each data source TDV supports. The various format pattern options, such as four-digit year mapping to ‘yyyy’, are noted in the TDV Reference Guide. To verify the format pattern is correct, issue a simple SELECT statement with a WHERE clause on a date, time, and timestamp column.

6.5 Simple Non-Equality Operations The same process used for equality operations is followed for simple operators other than “=”. The following patterns and comparison sets should be defined appropriately:

expr.ne_pattern: $1 != $2

comp.ne_pattern: (@date,@date)||(~number,~number)||(@char,@char)||(@ char,@varchar)||(@varchar,@varchar)

expr.lt_pattern: $1 < $2

comp.lt_pattern: (@date,@date)||(~number,~number)||(@char,@char)||(@ char,@varchar)||(@varchar,@varchar)

expr.gt_pattern: $1 > $2

comp.gt_pattern: (@date,@date)||(~number,~number)||(@char,@char)||(@ char,@varchar)||(@varchar,@varchar)

expr.le_pattern: $1 <= $2

comp.le_pattern: (@date,@date)||(~number,~number)||(@char,@char)||(@ char,@varchar)||(@varchar,@varchar)

expr.ge_pattern: $1 >= $2

comp.ge_pattern: (@date,@date)||(~number,~number)||(@char,@char)||(@ char,@varchar)||(@varchar,@varchar)

6.6 More Complex Operations Following from the non-equality operators, test LIKE, IN, IS NULL and IS NOT NULL, and adjust these if needed.

expr.like_pattern

comp.like_pattern

expr.like_pattern.wildcard

expr.like_pattern.single_char_wildcard



expr.in_pattern

expr.in_row_pattern

expr.is_null_pattern

comp.is_null_pattern

expr.is_not_null_pattern

comp.is_not_null_pattern

6.7 Logical Operations Test combining two or more predicates with AND, OR, and NOT. Adjust these if needed:

expr.and_pattern: $1 AND $2

expr.or_pattern: $1 OR $2

expr.not_pattern: NOT ($1)

6.8 Sub-queries in WHERE Clause If sub-queries in the WHERE clause is supported, then set the following:

jdbc.subqueries_in_comparisons: true

jdbc.subqueries_in_exists: true

jdbc.subqueries_in_ins: true

jdbc.correlated_subqueries: true

TIP: Also define the expr.exists_pattern to ensure tha t the sub-query pushes

6.9 Basic Aggregates If the data source supports basic aggregates, then enable GROUP BY processing by setting the following:

sql.groupby.clause: true

jdbc.group_by: true

Then, also define aggregate functions. When defining attributes for functions, the left side is the pattern that we will look for in the TDV SQL engine, and the right side is how the expression will be pushed to the data source:

COUNT(~any): COUNT($1)

COUNT(~any).distinct: COUNT(DISTINCT $1)

SUM(~number): SUM($1)

AVG(~number): AVG($1)

MAX(~any): MAX($1)

MIN(~any): MIN($1)

TIP: Above are the basic aggregate functions, but othe rs like VARIANCE can also be defined

Once these are configured, try to push them to the data source and test using a SQL statement. Generate the query plan and examine any No Push Reasons to troubleshoot.



Next enable the setting for the HAVING clause and test HAVING

sql.having.clause: true

6.10 Sorting If basic SQL ORDER BY clauses are supported, set the following property:

sql.orderby.clause: true

Check the query plan for a simple SELECT statement with ORDER BY to make sure the clause is pushing.

If the data source performs a non-standard (for TDV) ordering, such as EBCIDIC, sort merge joins will not work, as the

results are not in the expected order. To overcome this, set the following property:

ds.uses_non_unicode_ordering: true

6.11 Joins TDV must know how the data source supports joins. Set these options based on whether the data source supports

INNER JOIN, OUTER JOIN, CROSS JOIN, and SQL ’92 join syntax.

jdbcds.inner_joins: true | false

jdbc.outer_joins: true | false

jdbc.full_outer_joins: true | false

jdbcds.sql92_join_syntax: true | false

jdbcds.no_support_sql92_full_outer_join: true | fal se

jdbcds.no_support_sql92_cross_join: true | false

jdbcds.no_parentheses_for_nested_joins: true | fals e

6.12 Distinct If the data source supports SELECT DISTINCT then set these properties to true and test using a query plan:

jdbcds.distinct

sql.distinct.clause

6.13 Sub-queries in FROM This property is critical. Many layered views in TDV generate sub-queries in the from clause. If this is supported, then

set the following property to true and test using a query plan:

jdbcds.subqueries_in_from

6.14 Set Operations TDV can push set operations to the data source if it accepts the UNION, UNION ALL, INTERSECT and EXCEPT

operators. If these are supported, then set the following properties to true:

sql.except.clause

jdbcds.except_operator



jdbcds.except_all_operator

sql.intersect.clause

jdbcds.intersect_operator

jdbcds.intersect_all_operator

sql.union.clause

jdbc.union

jdbc.union_all

TIP: If the data source needs the same aliases on both branches of the UNION, also set this property to true:

jdbcds.match_union_left_right_aliases

TDV also needs to know what combinations of datatypes are valid on each side of a set operation. Is it valid to have a column on one side of the UNION as a CHAR, while the other is a VARCHAR? Define these to patterns to define the legal combinations:

comp.union_pattern

comp.intersect_pattern

comp.except_pattern

6.15 Functions and Operators Different data sources make different functions and operators available for querying. If TDV knows the mappings for these functions, they can be pushed to the data source. Some examples follow, but this is a non-exhaustive list. See examples in the capabilities files.

6.15.1 Notes About Function and Operator Expressions The expressions use a hierarchy of data types:

• The tilde ‘~’ represents a group of types

• The strudel ‘@’ represents a specific type

A function pattern like FUNC(~string, @varchar) would push a call to FUNC where the first parameter is any kind of string including a VARCHAR and a CHAR, but the second parameter is specifically a VARCHAR.

For numbers, any number may be referenced as ~number. Any type of integer can be referenced by ~whole_number, while any type of float can be ~floating_point. @integer specifically matches an INTEGER, @decimal matches a

DECIMAL, etc.

For date/time types, any date, time or timestamp, may be referenced by ~date, while @date matches only a DATE type, @time matches only a TIME type, etc.

To match a situation when no type has been associated with a value, use @null

SELECT NULL FROM <table>

The above returns a NULL value that would match @null

SELECT CAST(NULL AS VARCHAR) FROM <table>



The above would return a NULL value of VARCHAR type, and would match ~string and @varchar

To match any data type, use ~any.

TIP: In some expressions, data types without a tilde or strudel are used. These are native data source types.

6.15.2 Functions This is a non-exhaustive list of functions and sample patterns for the function. As before, when defining attributes for functions, the left side is the pattern that we will look for in the TDV SQL engine, and the right side is how the expression will be pushed to the data source:

UPPER(~string): UPPER($1)

LOWER(~string): LOWER($1)

RTRIM(~string): RTRIM($1)

LTRIM(~string): LTRIM($1)

CONCAT(@varchar,@varchar): (CASE WHEN ($1 IS NULL) OR ($2 IS NULL) THEN NULL ELSE CONCAT($1, $2) END)

INSTR(~string,~string) : INSTR($1,$2)

LENGTH(@varchar): LENGTH($1)

REPLACE(@varchar,@varchar,@varchar): REPLACE($1, $2 , $3)

REPLACE(@varchar,@varchar,@varchar): REPLACE($1, $2 , $3)

POSITION(~stringIN~string): INSTR($2, $1)

TO_CHAR(~number): TO_CHAR($1)

TO_DATE(@varchar): TO_DATE(SUBSTR($1, 1, 10), 'YYYY -MM-DD')

TO_NUMBER(@varchar): TO_NUMBER($1)

TO_TIMESTAMP(@varchar): TO_DATE(SUBSTR($1, 1, 19), 'YYYY-MM-DD HH24:MI:SS')

FORMAT_DATE(~date,~string): TO_CHAR($1, $2)

PARSE_TIMESTAMP(~string,~string): TO_DATE($1, $2)

CEILING(~number): CEIL($1)

FLOOR(~number): FLOOR($1)

EXP(~number): EXP($1)

LN(~number): LN($1)

ROUND(~number,~number): ROUND($1, $2)

SIN(~number): SIN($1)

COS(~number): COS($1)

TAN(~number): TAN($1)

6.15.3 CAST Functions Cast functions deserve their own section as there are many permutations. This is a sample for Oracle

CAST(@nullAS~whole_number): CAST($1 AS INTEGER)

CAST(@nullAS@numeric): TO_NUMBER(NULL)



CAST(@nullAS@decimal): TO_NUMBER(NULL)

CAST(@nullAS@float): CAST(NULL as FLOAT)

CAST(@nullAS@double): CAST(NULL as FLOAT)

CAST(@nullAS@real): CAST(NULL as FLOAT)

CAST(@nullAS~string): TO_CHAR(NULL)

CAST(@nullAS@date): TO_DATE(NULL, 'YYYY-MM-DD')

CAST(@nullAS@timestamp): TO_DATE(NULL, 'YYYY-MM-DD HH24:MI:SS')

CAST(~whole_numberAS~whole_number): CAST($1 AS INTE GER)

CAST(~floating_pointAS~whole_number): CAST($1 AS IN TEGER)

CAST(~numberAS@double): CAST($1 AS FLOAT)

CAST(~numberAS@float): CAST($1 AS FLOAT)

CAST(~numberAS@real): CAST($1 AS REAL)

CAST(~numberAS@decimal): $1

CAST(~numberAS@numeric): $1

CAST(~numberAS@char): TO_CHAR($1)

CAST(~numberAS@varchar): TO_CHAR($1)

CAST(~numberAS@null): NULL

CAST(@charAS~whole_number): CAST($1 AS INTEGER)

CAST(@charAS@double): CAST($1 AS FLOAT)

CAST(@charAS@float): CAST($1 AS FLOAT)

CAST(@charAS@real): CAST($1 AS REAL)

CAST(@charAS@decimal): TO_NUMBER($1)

CAST(@charAS@numeric): TO_NUMBER($1)

CAST(@charAS@char): TO_CHAR($1)

CAST(@charAS@varchar): TO_CHAR($1)

CAST(@charAS@date): TO_DATE(SUBSTR($1, 1, 10), 'YYY Y-MM-DD')

CAST(char(10)AS@date): TO_DATE($1, 'YYYY-MM-DD')

CAST(nchar(10)AS@date): TO_DATE($1, 'YYYY-MM-DD')

CAST(varchar(10)AS@date): TO_DATE($1, 'YYYY-MM-DD')

CAST(nvarchar(10)AS@date): TO_DATE($1, 'YYYY-MM-DD' )

CAST(varchar2(10)AS@date): TO_DATE($1, 'YYYY-MM-DD' )

CAST(nvarchar2(10)AS@date): TO_DATE($1, 'YYYY-MM-DD ')

CAST(@charAS@timestamp): TO_DATE(SUBSTR($1, 1, 19), 'YYYY-MM-DD HH24:MI:SS')

CAST(@charAS@null): NULL

CAST(@varcharAS~whole_number): CAST($1 AS INTEGER)

CAST(@varcharAS@double): CAST($1 AS FLOAT)



CAST(@varcharAS@float): CAST($1 AS FLOAT)

CAST(@varcharAS@real): CAST($1 AS REAL)

CAST(@varcharAS@decimal): TO_NUMBER($1)

CAST(@varcharAS@numeric): TO_NUMBER($1)

CAST(@varcharAS@char): TO_CHAR($1)

CAST(@varcharAS@varchar): TO_CHAR($1)

CAST(@varcharAS@date): TO_DATE(SUBSTR($1, 1, 10), ' YYYY-MM-DD')

CAST(@varcharAS@timestamp): TO_DATE(SUBSTR($1, 1, 1 9), 'YYYY-MM-DD HH24:MI:SS')

CAST(@varcharAS@null): NULL

CAST(@dateAS@char): TO_CHAR($1, 'YYYY-MM-DD')

CAST(@dateAS@varchar): TO_CHAR($1, 'YYYY-MM-DD')

CAST(@dateAS@date): TO_DATE(TO_CHAR($1, 'YYYY-MM-DD '), 'YYYY-MM-DD')

CAST(@dateAS@timestamp): TO_DATE($1)

CAST(@dateAS@null): NULL

CAST(@timestampAS@char): TO_CHAR($1, 'YYYY-MM-DD HH 24:MI:SS')

CAST(@timestampAS@varchar): TO_CHAR($1, 'YYYY-MM-DD HH24:MI:SS')

CAST(@timestampAS@date): TO_DATE(TO_CHAR($1, 'YYYY- MM-DD'), 'YYYY-MM-DD')

CAST(@timestampAS@timestamp): TO_DATE($1)

CAST(@timestampAS@null): NULL

6.15.4 Operators Operators follow a similar pattern to functions. When defining attributes for operators, the left side is the pattern that we

will look for in the TDV SQL engine, and the right side is how the expression will be pushed to the data source:

~number+~number: ($1 + $2)

~number-~number: ($1 - $2)

~number*~number: ($1 * $2)

~number/~number: ($1 / $2)

~number%~number: MOD($1, $2)

-~number: (-($1))

@varchar||@varchar: (CASE WHEN ($1 IS NULL) OR ($2 IS NULL) THEN NULL ELSE ($1 || $2) END)



7 Capabilities, Statements and Prepared Statements

When submitting a query from a java application using the TDV JDBC driver, two methods of execution can be used:

• Statement: In this case, the application composes a SQL query, complete with parameter substitutions, and then executes it with a Statement object. Parameters are part of the query and the optimizer is able to choose an appropriate execution path for the query given it’s parameters

• PreparedStatement: In this case, the application composes a SQL query, substituting special characters for parameters (usually a ‘?’ character.) The query is opened with a PreparedStatement object, and TDV will optimize the query at that time. After the PreparedStatement object is optimized, the application substitutes parameters and executes the PreparedStatement. Since TDV does not know the types of the parameters

ahead of time, value substitution happens AFTER optimization and the optimizer cannot choose the best path for the parameters to be used

In both scenarios, it is possible to have TDV push the parameters to the data sources using capabilities entries. It is important to ensure that an appropriate capabilities entry exists for functions or operations to be performed using your parameters, and the assumed data type of the parameter to be applied. For example, if your query against Sybase ASE 15 like this:

SELECT *

FROM T1

WHERE MY_DATE_COLUMN = ?

TDV will likely translate this query into:

SELECT *

FROM T1

WHERE MY_DATE_COLUMN = CAST(? AS DATE)

If your java code will then set this with a string, it is important to ensure that a capabilities entry exists to push the CAST

function to the data source, such as:

CAST(~stringAS@date): CONVERT($2, $1)

This will ensure that functions are pushed once parameter values have been substituted.



8 Conclusion

This document outlined the procedure to create a new data source or modify data source capabilities to support additional functions, types and operators. Please address suggestions and requests for additional content to the TIBCO Data Virtualization Professional Services team directly.



Appendix A: Example Values File for IBM Classic Federation Server

<?xml version="1.1" encoding="UTF-8"?>



<common:attributes xmlns:common="http://www.compositesw.com/services/s ystem/util/common">

<common:attribute xmlns:common="http://www.composit esw.com/services/system/util/common">

<common:name>/introspection/relational/supportsCa talog</common:name>



<common:configID>introspect.relational.include_ca talog</common:configID>

</common:attribute>

<ns1:attribute xmlns:ns1="http://www.compositesw.co m/services/system/util/common">

<ns1:name>/introspection/relational/supportsForei gnKey</ns1:name>


<ns1:value>false</ns1:value> <ns1:configID>introspect.relational.include_table.f oreign_keys</ns1:configID>

</ns1:attribute>


<ns2:name>/introspection/relational/supportsIndex </ns2:name>



<ns2:configID>introspect.relational.include_table .indexes</ns2:configID>

</ns2:attribute>


<ns3:name>/introspection/relational/supportsPrima ryKey</ns3:name>



<ns3:configID>introspect.relational.include_table_p rimary_keys</ns3:configID>

</ns3:attribute>


<ns4:name>/introspection/relational/supportsProce dure</ns4:name>



<ns4:configID>introspect.relational.include_proce dure</ns4:configID>

</ns4:attribute>




<ns5:name>/introspection/relational/supportsSchem a</ns5:name>


<ns5:value>true</ns5:value>

<ns5:configID>introspect.relational.include_schem a</ns5:configID>

</ns5:attribute>


<ns6:name>/introspection/relational/supportsTable </ns6:name>



<ns6:configID>introspect.relational.include_table </ns6:configID>

</ns6:attribute>


<ns7:name>/runtime/iud/batchSize</ns7:name>

<ns7:type>INTEGER</ns7:type>

<ns7:value>100</ns7:value>

<ns7:configID>jdbc.batch_size</ns7:configID>

</ns7:attribute>


<ns8:name>/runtime/iud/batchUpdates</ns8:name>



<ns8:configID>jdbc.batch_updates</ns8:configID>

</ns8:attribute>


<ns9:name>/runtime/iud/fetchSize</ns9:name>



<ns9:configID>jdbc.fetch_size</ns9:configID>

</ns9:attribute>

<ns10:attribute xmlns:ns10="http://www.compositesw. com/services/system/util/common">

<ns10:name>/runtime/query/NoSql92FullCrossJoin</n s10:name>



<ns10:configID>jdbcds.no_support_sql92_cross_join </ns10:configID>

</ns10:attribute>


<ns11:name>/runtime/query/NoSql92FullOuterJoin</n s11:name>





<ns11:configID>jdbcds.no_support_sql92_full_outer _join</ns11:configID>

</ns11:attribute>


<ns12:name>/runtime/query/comparisonCaseInSensiti ve</ns12:name>



<ns12:configID>jdbcds.comparisons_case_insensitiv e</ns12:configID>

</ns12:attribute>


<ns13:name>/runtime/query/correlatedSubqueries</n s13:name>



<ns13:configID>jdbc.correlated_subqueries</ns13:c onfigID>

</ns13:attribute>


<ns14:name>/runtime/query/distinct</ns14:name>



<ns14:configID>jdbcds.distinct</ns14:configID>

</ns14:attribute>


<ns15:name>/runtime/query/except</ns15:name>



<ns15:configID>jdbcds.except_operator</ns15:confi gID>

</ns15:attribute>


<ns16:name>/runtime/query/exceptAll</ns16:name>



<ns16:configID>jdbcds.except_all_operator</ns16:c onfigID>

</ns16:attribute>


<ns17:name>/runtime/query/exceptNativeKeyword</ns 17:name>

<ns17:type>STRING</ns17:type>

<ns17:value>EXCEPT</ns17:value>

<ns17:configID>jdbcds.except_native_keyword</ns17 :configID>

</ns17:attribute>




<ns18:name>/runtime/query/groupBy</ns18:name>



<ns18:configID>jdbc.group_by</ns18:configID>

</ns18:attribute>


<ns19:name>/runtime/query/having</ns19:name>



<ns19:configID>jdbcds.having</ns19:configID>

</ns19:attribute>


<ns20:name>/runtime/query/inner_joins</ns20:name>



<ns20:configID>jdbcds.inner_joins</ns20:configID>

</ns20:attribute>


<ns21:name>/runtime/query/intersect</ns21:name>



<ns21:configID>jdbcds.intersect_operator</ns21:co nfigID>

</ns21:attribute>


<ns22:name>/runtime/query/intersectAll</ns22:name >



<ns22:configID>jdbcds.intersect_all_operator</ns2 2:configID>

</ns22:attribute>


<ns23:name>/runtime/query/intersectNativeKeyword< /ns23:name>

<ns23:type>STRING</ns23:type>

<ns23:value>INTERSECT</ns23:value>

<ns23:configID>jdbcds.intersect_native_keyword</n s23:configID>

</ns23:attribute>


<ns24:name>/runtime/query/maxSqlLength</ns24:name >





<ns24:configID>jdbcds.max_sql_length</ns24:config ID>

</ns24:attribute>


<ns25:name>/runtime/query/orderBy</ns25:name>



<ns25:configID>jdbcds.order_by</ns25:configID>

</ns25:attribute>


<ns26:name>/runtime/query/scalarSubqueries</ns26: name>



<ns26:configID>jdbcds.scalar_subqueries</ns26:con figID>

</ns26:attribute>


<ns27:name>/runtime/query/sql92JoinSyntax</ns27:n ame>



<ns27:configID>jdbcds.sql92_join_syntax</ns27:con figID>

</ns27:attribute>


<ns28:name>/runtime/query/subqueriesInExists</ns2 8:name>



<ns28:configID>jdbc.subqueries_in_exists</ns28:co nfigID>

</ns28:attribute>


<ns29:name>/runtime/query/subqueriesInIns</ns29:n ame>



<ns29:configID>jdbc.subqueries_in_ins</ns29:confi gID>

</ns29:attribute>


<ns30:name>/runtime/query/trailingSpaceIncludeInC omparison</ns30:name>



<ns30:configID>jdbcds.trailing_spaces_included_in_c omparison</ns30:configID>

</ns30:attribute>




<ns31:name>/runtime/query/union</ns31:name>



<ns31:configID>jdbc.union</ns31:configID>

</ns31:attribute>


<ns32:name>/runtime/query/unionAll</ns32:name>



<ns32:configID>jdbc.union_all</ns32:configID>

</ns32:attribute>


<ns33:name>/runtime/query/withClause</ns33:name>



<ns33:configID>jdbcds.with_clause</ns33:configID>

</ns33:attribute>


<common:name>/custom/jdbcds.schemas_in_tables</co mmon:name>


<common:value>true</common:value>

<common:configID>jdbcds.schemas_in_tables</common :configID>

</common:attribute>


<common:name>/custom/jdbcds.alias_generation_patt ern</common:name>


<common:value>expr$1</common:value>

<common:configID>jdbcds.alias_generation_pattern< /common:configID>

</common:attribute>


<common:name>/custom/jdbc.transaction_none</commo n:name>



<common:configID>jdbc.transaction_none</common:co nfigID>

</common:attribute>


<common:name>/custom/jdbc.transaction_read_commit ted</common:name>





<common:configID>jdbc.transaction_read_committed< /common:configID>

</common:attribute>


<common:name>/custom/jdbc.transaction_read_uncomm itted</common:name>



<common:configID>jdbc.transaction_read_uncommitte d</common:configID>

</common:attribute>


<common:name>/custom/jdbc.transaction_transaction_r epeatable_read</common:name>



<common:configID>jdbc.transaction_transaction_repea table_read</common:configID>

</common:attribute>


<common:name>/custom/jdbc.transaction_serializabl e</common:name>



<common:configID>jdbc.transaction_serializable</c ommon:configID>

</common:attribute>


<common:name>/custom/jdbc.transactions</common:na me>



<common:configID>jdbc.transactions</common:config ID>

</common:attribute>


<common:name>/custom/expr.in_pattern</common:name >


<common:value>$1 IN ($2)</common:value>

<common:configID>expr.in_pattern</common:configID >

</common:attribute>


<common:name>/custom/jdbcds.subqueries_in_from</c ommon:name>



<common:configID>jdbcds.subqueries_in_from</commo n:configID>

</common:attribute>




<common:name>/custom/jdbcds.sql92_join_syntax</co mmon:name>



<common:configID>jdbcds.sql92_join_syntax</common :configID>

</common:attribute>


<common:name>/custom/sql.groupby.clause</common:n ame>



<common:configID>sql.groupby.clause</common:confi gID>

</common:attribute>


<common:name>/custom/jdbc.group_by</common:name>



<common:configID>jdbc.group_by</common:configID>

</common:attribute>


<common:name>/custom/jdbcds.having</common:name>



<common:configID>jdbcds.having</common:configID>

</common:attribute>


<common:name>/custom/MAX(~any)</common:name>


<common:value>MAX(~any): MAX($1)</common:value>

<common:configID>MAX(~any)</common:configID>

</common:attribute>


<common:name>/custom/MIN(~any)</common:name>


<common:value>MIN(~any): MAX($1)</common:value>

<common:configID>MIN(~any)</common:configID>

</common:attribute>


<common:name>/custom/COUNT(~any)</common:name>




<common:value>COUNT(~any): MAX($1)</common:value>

<common:configID>COUNT(~any)</common:configID>

</common:attribute>


<common:name>/custom/SUM(~any)</common:name>


<common:value>SUM(~any): MAX($1)</common:value>

<common:configID>SUM(~any)</common:configID>

</common:attribute>

</common:attributes>



Appendix B: Full List of Properties

This appendix contains a full listing of all properties supported for custom data sources.

Capabilities for Data Source Driver DSDRIVER_CLASS_NAME = "dsdriver.classname"; DSDRIVER_URL_PATTERN = "dsdriver.url_pattern"; DSDRIVER_VISIBLE = "dsdriver.visible";

Capabilities for Data Source Introspection INTROSPECT_MAX_BATCH_SIZE = "introspect.max_batch_size"; INTROSPECT_RELATIONAL_INCLUDE_CATALOG = "introspect.relational.include_catalog"; INTROSPECT_RELATIONAL_INCLUDE_ALL_CATALOGS = "introspect.relational.include_all_catalogs"; INTROSPECT_RELATIONAL_INCLUDE_MIX_RELATIONAL_CHILDREN = "introspect.relational.include_mix_relational_children"; INTROSPECT_RELATIONAL_INCLUDE_SCHEMA = "introspect.relational.include_schema"; INTROSPECT_RELATIONAL_INCLUDE_TABLE = "introspect.relational.include_table"; INTROSPECT_RELATIONAL_NOT_SUPPORT_TABLE_PATTERN =

"introspect.relational.not_support_table_pattern"; INTROSPECT_RELATIONAL_INCLUDE_TABLE_PRIMARY_KEYS = "introspect.relational.include_table.primary_keys"; INTROSPECT_RELATIONAL_INCLUDE_TABLE_FOREIGN_KEYS = "introspect.relational.include_table.foreign_keys"; INTROSPECT_RELATIONAL_INCLUDE_TABLE_FOREIGN_KEYS_IMPORTED = "introspect.relational.include_table.foreign_keys.imported"; INTROSPECT_RELATIONAL_INCLUDE_TABLE_FOREIGN_KEYS_EXPORTED = "introspect.relational.include_table.foreign_keys.exported"; INTROSPECT_RELATIONAL_INCLUDE_TABLE_INDEXES = "introspect.relational.include_table.indexes"; INTROSPECT_RELATIONAL_INCLUDE_PROCEDURE = "introspect.relational.include_procedure"; INTROSPECT_RELATIONAL_NOT_SUPPORT_PROCEDURE_PATTERN = "introspect.relational.not_support_procedure_pattern"; INTROSPECT_RELATIONAL_INCLUDE_PACKAGES = "introspect.relational.include_packages"; INTROSPECT_RELATIONAL_TRIM_NAMES = "introspect.relational.trim_names"; INTROSPECT_RELATIONAL_USE_CATALOGS_FOR_SCHEMA = "introspect.relational.use_catalogs_for_schemas";

INTROSPECT_DATATYPE_NUMERIC_OVERRIDE_UNSPECIFIED_PRECISION = "introspect.datatype.numeric.override_unspecified_precision"; INTROSPECT_DATATYPE_NUMERIC_OVERRIDE_UNSPECIFIED_SCALE = "introspect.datatype.numeric.override_unspecified_scale"; INTROSPECT_OVERRIDE_PARALLELISM_DEGREE = "introspect.override_parallelism_degree"; INTROSPECT_SHOW_ALL_DATABASES = "introspect.show_all_databases"; INTROSPECT_USE_INTROSPECTOR_1 = "introspect.use_introspector_1";

Constants for Data Source Connection Supported Operation in IAF Layer IAFCONNECTION_COMMIT = "iafconnection.commit"; IAFCONNECTION_CREATE_CONTAINER = "iafconnection.create_container"; IAFCONNECTION_DELETES = "iafconnection.deletes";



IAFCONNECTION_DELETE_CONTAINER = "iafconnection.delete_container"; IAFCONNECTION_FETCH_CONTAINER = "iafconnection.fetch_container"; IAFCONNECTION_FETCH_CONTAINER_WITH_FILTER = "iafconnection.fetch_container_with_filter"; IAFCONNECTION_FETCH_WITH_NATIVE_SQL = "iafconnection.fetch_with_native_sql"; IAFCONNECTION_FETCH_WITH_XQUERY = "iafconnection.fetch_with_xquery"; IAFCONNECTION_INSERTS = "iafconnection.inserts"; IAFCONNECTION_ROLLBACK = "iafconnection.rollback"; IAFCONNECTION_STORED_PROCEDURES = "iafconnection.stored_procedures"; IAFCONNECTION_UPDATES = "iafconnection.updates"; IAFCONNECTION_UPDATE_CONTAINER = "iafconnection.update_container"; IAFCONNECTION_UPDATE_CONTAINER_WITH_FILTER = "iafconnection.update_container_filter";

IAFCONNECTION_UPDATE_WITH_NATIVE_SQL = "iafconnection.update_with_native_sql"; //templeate: IAFCONNECTION_ = "iafconnection.";

Constants for Data Source Supported Operations in JDBC Driver JDBC_ANSI92_ENTRY_LEVEL_SQL = "jdbc.ansi92_entry_level_sql"; JDBC_ANSI92_FULL_SQL = "jdbc.ansi92_full_sql"; JDBC_ANSI92_INTERMEDIATE_SQL = "jdbc.ansi92_intermediate_sql"; JDBC_BATCH_UPDATES = "jdbc.batch_updates"; JDBC_BATCH_SIZE = "jdbc.batch_size";

JDBC_CATALOGS_IN_PROCEDURE_CALLS = "jdbc.catalogs_in_procedure_calls"; JDBC_COLUMN_ALIASING = "jdbc.column_aliasing"; JDBC_CONVERT = "jdbc.convert"; JDBC_CORE_SQL_GRAMMAR = "jdbc.core_sql_grammar"; JDBC_CORRELATED_SUBQUERIES = "jdbc.correlated_subqueries"; JDBC_EXPRESSIONS_IN_ORDER_BY = "jdbc.expressions_in_order_by"; JDBC_EXTENDED_SQL_GRAMMAR = "jdbc.exended_sql_grammar"; JDBC_FETCH_SIZE = "jdbc.fetch_size";

JDBC_FULL_OUTER_JOINS = "jdbc.full_outer_joins"; JDBC_GET_GENERATED_KEYS = "jdbc.get_generated_keys"; JDBC_GROUP_BY = "jdbc.group_by"; JDBC_GROUP_BY_BEYOND_SELECT = "jdbc.group_by_beyond_select"; JDBC_GROUP_BY_UNRELATED = "jdbc.group_by_unrelated"; JDBC_IDENTIFIER_QUOTE_STRING = "jdbc.identifier_quote_string"; JDBC_LIKE_ESCAPE_CLAUSE = "jdbc.like_escape_clause"; JDBC_LIMITED_OUTER_JOINS = "jdbc.limited_outer_joins";

JDBC_MINIMUM_SQL_GRAMMAR = "jdbc.odbc_minimum_sql_grammar"; JDBC_MIXED_CASE_IDENTIFIERS = "jdbc.mixed_case_identifiers"; JDBC_MIXED_CASE_QUOTED_IDENTIFIERS = "jdbc.mixed_case_quoted_identifiers"; JDBC_MULTIPLE_OPEN_RESULTS = "jdbc.multiple_open_results"; JDBC_MULTIPLE_RESULTSETS = "jdbc.multiple_resultsets"; JDBC_MULTIPLE_TRANSACTIONS = "jdbc.multiple_transactions"; JDBC_ORDER_BY_UNRELATED = "jdbc.order_by_unrelated"; JDBC_OUTER_JOINS = "jdbc.outer_joins";

JDBC_SAVE_POINTS = "jdbc.save_points"; JDBC_SCHEMAS_IN_PROCEDURE_CALLS = "jdbc.schemas_in_procedure_calls"; JDBC_SELECT_FOR_UPDATE = "jdbc.select_for_update"; JDBC_SUBQUERIES_IN_COMPARISONS = "jdbc.subqueries_in_comparisons";



JDBC_SUBQUERIES_IN_EXISTS = "jdbc.subqueries_in_exists"; JDBC_SUBQUERIES_IN_INS = "jdbc.subqueries_in_ins"; JDBC_TRANSACTION_ISOLATION_LEVEL = "jdbc.transaction_isolation_level"; JDBC_TRANSACTION_NONE = "jdbc.transaction_none"; JDBC_TRANSACTION_READ_COMMITTED = "jdbc.transaction_read_committed"; JDBC_TRANSACTION_READ_UNCOMMITTED = "jdbc.transaction_read_uncommitted"; JDBC_TRANSACTION_REPEATABLE_READ = "jdbc.transaction_transaction_repeatable_read"; JDBC_TRANSACTION_SERIALIZABLE = "jdbc.transaction_serializable"; JDBC_TRANSACTIONS = "jdbc.transactions"; JDBC_UNION = "jdbc.union"; //union distinct capability JDBC_UNION_ALL = "jdbc.union_all";

JDBC_SUBQUERIES_IN_FROM = "jdbcds.subqueries_in_from"

Constants for JDBC Data Source Capabilities JDBC_DS_SUPPORT_DDL = "jdbcds.support_ddl"; //indicates whether a data source supports DDL or not JDBC_DS_SUPPORT_DDL_CREATE_TABLE = "jdbcds.support_ddl.create_table"; //indicates whether a data source supports CREATE TABLE syntax JDBC_DS_SUPPORT_DDL_DROP_TABLE = "jdbcds.support_ddl.drop_table"; //indicates whether a data source supports DROP TABLE syntax JDBC_DS_SUPPORT_DDL_ALTER_TABLE = "jdbcds.support_ddl.alter_table"; //indicates whether a data source

supports ALTER TABLE syntax JDBC_DS_SUPPORT_DDL_CREATE_INDEX = "jdbcds.support_ddl.create_index"; //indicates whether a data source supports CREATE INDEX syntax JDBC_DS_SUPPORT_DDL_DROP_INDEX = "jdbcds.support_ddl.drop_index"; //indicates whether a data source supports DROP INDEX syntax JDBC_DS_DROP_INDEX_SYNTAX_TBL_DOT_IDX = "jdbcds.drop_index_syntax_tbl_dot_idx";//CIS-38836 JDBC_DS_DROP_INDEX_SYNTAX_NO_CATALOG = "jdbcds.drop_index_syntax_no_catalog";//CIS-38836 JDBC_DS_DROP_INDEX_SYNTAX_NO_SCHEMA = "jdbcds.drop_index_syntax_no_schema";

JDBC_DS_SUPPORTS_TRUNCATE_TABLE = "jdbcds.supports_truncate_table"; JDBC_DS_TRUNCATE_TABLE_SYNATX_NO_CATALOG = "jdbcds.truncate_table_syntax_no_catalog"; JDBC_DS_TRUNCATE_TABLE_NO_DELIM_FIRST_QUALIFIER = "jdbcds.truncate_table_no_delim_first_qualifier"; JDBC_DS_COLUMN_DEFAULTS_NOT_NULLABLE = "jdbcds.support_ddl.column_defaults_not_nullable"; //indicates whether a created column is NOT NULL by default JDBC_DS_DDL_SUPPORTS_MULTIPLE_STATEMENTS_IN_EXECUTE = "jdbcds.ddl_supports_multiple_statements_in_execute"; //indicates whether a data source supports multiple DDL statements in one execute.

JDBC_DS_DDL_REQUIRES_SEPARATE_TXN = "jdbcds.ddl_requires_separate_txn";//CIS-38331 JDBC_DS_DDL_CREATE_OR_REPLACE_TABLE = "jdbcds.ddl_create_or_replace_table"; //indicates whether a data source supports CREATE OR REPLACE TABLE JDBC_DS_DDL_CREATE_TABLE_SUFFIX = "jdbcds.support_ddl.create_table_"; JDBC_DS_DDL_AVOID_DDL_NEWLINES = "jdbcds.support_ddl.avoid_newlines"; JDBC_DS_DDL_CASCADE_RESTRICT_IN_DROP_TABLE = "jdbcds.ddl_cascade_restrict_drop_table"; //indicates whether CASCADE or RESTRICT is supported in DROP TABLE JDBC_DS_DDL_CASCADE_RESTRICT_IN_DROP_INDEX = "jdbcds.ddl_cascade_restrict_drop_index"; //indicates

whether CASCADE or RESTRICT is supported in DROP INDEX JDBC_DS_DDL_DROP_TABLE_IF_EXISTS = "jdbcds.ddl_drop_table_if_exists"; //indicates whether a data source supports DROP TABLE IF EXISTS syntax.



JDBC_DS_DDL_DROP_TABLE_DOES_NOT_EXIST_ERROR_STRING = "jdbcds.ddl_drop_table_does_not_exist_error_string"; //specifies the error string to match for DROP TABLE - table or view does not exist error JDBC_DS_DDL_CREATE_TABLE_OVERRIDE = "jdbcds.ddl_create_table_override"; //specifies the string to use instead of CREATE TABLE JDBC_DS_DDL_STRING_POSTFIX = "jdbcds.ddl_string_postfix"; //specifies the postfix to put after a string type in CREATE TABLE JDBC_DS_DDL_STRING_POSTFIX_TYPES = "jdbcds.ddl_string_postfix_types"; //specifies the types to put the postfix on in CREATE TABLE JDBC_DS_DDL_CREATE_TABLE_NO_PATITION = "jdbcds.ddl.create_table.no_partition";//if true, CREATE table requires NO_PARTITION clause (http://dv-jira.dv.local/browse/CIS-20022)

JDBC_DS_DDL_EXPLICIT_COMMIT_REQUIRED = "jdbcds.ddl.explicit_commit_required";//if true, an explicit commit is required after a DDL statement JDBC_DS_TABLE_NAME_MAX_LENGTH = "jdbcds.table.name.max_length";//Maximum allowed table name length in this DS JDBC_DS_UNIQUE_INDEX_SUPPORT_MULTIPLE_NULLS = "jdbcds.unique_index.support_multiple_nulls"; //indicates whether a data source allows more than one null value in the unique index

JDBC_DS_CATALOGS_IN_TABLES = "jdbcds.catalogs_in_tables"; //check for having catalog as prefix to table in SQL statement JDBC_DS_SCHEMAS_IN_TABLES = "jdbcds.schemas_in_tables"; //check for having schema as prefix to table in SQL statement JDBC_DS_TABLES_IN_COLUMNS = "jdbcds.tables_in_columns"; //check for having table as prefix to columns in SQL statement JDBC_DS_CATALOGS_IN_TABLES_FOR_UPDATES = "jdbcds.catalogs_in_tables_for_updates"; //check for having

catalog as prefix to table in SQL IUD statements JDBC_DS_SCHEMAS_IN_TABLES_FOR_UPDATES = "jdbcds.schemas_in_tables_for_updates"; //check for having schema as prefix to table in SQL IUD statements JDBC_DS_INNER_JOINS = "jdbcds.inner_joins"; //check for inner joins to be supported JDBC_DS_DISTINCT = "jdbcds.distinct"; //check for distinct support JDBC_DS_HAVING = "jdbcds.having"; //check for having support JDBC_DS_HAVING_MAY_USE_ALIASED_SELECTABLE = "jdbcds.having_may_use_aliased_selectable"; JDBC_DS_SQL92_JOIN_SYNTAX = "jdbcds.sql92_join_syntax"; //check for whether sql 92 join syntax is supported

JDBC_DS_NO_SUPPORT_SQL92_FULL_OUTER_JOIN = "jdbcds.no_support_sql92_full_outer_join"; // check whether sql92 full outer join is supported JDBC_DS_NO_SUPPORT_SQL92_CROSS_JOIN = "jdbcds.no_support_sql92_cross_join"; // check whether sql92 CROSS JOIN syntax is supported JDBC_DS_NO_PARENTHESES_FOR_NESESTED_JOINS = "jdbcds.no_parentheses_for_nested_joins"; JDBC_DS_BRACKET_IN_SQL = "jdbcds.bracket_in_sql"; //check for having bracket in SQL statement to be supported JDBC_DS_ALIAS_DOT_REPLACEMENT = "jdbcds.alias.dot_replacement"; //check to see whether there is a need to replace '.'

JDBC_DS_DELIMITED_IDENTIFIER_OPEINING_CHAR = "jdbcds.delimited_identifier_opening_char"; //delimited identifier JDBC_DS_DELIMITED_IDENTIFIER_CLOSING_CHAR = "jdbcds.delimited_identifier_closing_char"; //delimited identifier



JDBC_DS_CATALOG_DELIMITED_IDENTIFIER_OPENING_CHAR = "jdbcds.catalog_delimited_identifier_opening_char"; //catalog delimited identifier JDBC_DS_CATALOG_DELIMITED_IDENTIFIER_CLOSING_CHAR = "jdbcds.catalog_delimited_identifier_closing_char"; //catalog delimited identifier JDBC_DS_SCHEMA_DELIMITED_IDENTIFIER_OPENING_CHAR = "jdbcds.schema_delimited_identifier_opening_char"; //schema delimited identifier JDBC_DS_SCHEMA_DELIMITED_IDENTIFIER_CLOSING_CHAR = "jdbcds.schema_delimited_identifier_closing_char"; //schema delimited identifier JDBC_DS_TABLE_DELIMITED_IDENTIFIER_OPENING_CHAR = "jdbcds.table_delimited_identifier_opening_char"; //table delimited identifier JDBC_DS_TABLE_DELIMITED_IDENTIFIER_CLOSING_CHAR = "jdbcds.table_delimited_identifier_closing_char";

//table delimited identifier JDBC_DS_COLUMN_DELIMITED_IDENTIFIER_OPENING_CHAR = "jdbcds.column_delimited_identifier_opening_char"; //column delimited identifier JDBC_DS_COLUMN_DELIMITED_IDENTIFIER_CLOSING_CHAR = "jdbcds.column_delimited_identifier_closing_char"; //column delimited identifier JDBC_DS_PROCEDURE_DELIMITED_IDENTIFIER_OPENING_CHAR = "jdbcds.procedure_delimited_identifier_opening_char"; //procedure delimited identifier JDBC_DS_PROCEDURE_DELIMITED_IDENTIFIER_CLOSING_CHAR =

"jdbcds.procedure_delimited_identifier_closing_char"; //procedure delimited identifier JDBC_DS_MAX_DELIMITED_IDENTIFIER = "jdbcds.max_delimited_identifier"; //max_delimited_identifier JDBC_DS_DELIMITED_IDENTIFIER_CHARACTERS_PATTERN = "jdbcds.delimited_identifier_characters_pattern"; // characters pattern that require delimited identifiers JDBC_DS_ORDER_BY = "jdbcds.order_by"; //check to see whether the data source supports any form of order by JDBC_DS_COMPARISONS_CASE_INSENSITIVE = "jdbcds.comparisons_case_insensitive"; // whether 'abc' = 'Abc' JDBC_DS_TRAILING_SPACES_INCLUDED_IN_COMPARISON = "jdbcds.trailing_spaces_included_in_comparison"; // whether 'abc' = 'abc '

JDBC_DS_No_SUPPORT_ALIAS = "jdbcds.no_support_alias"; JDBC_DS_ALIAS_GENERATION_PATTERN = "jdbcds.alias_generation_pattern"; JDBC_DS_NO_COLUMN_ALIAS_GENERATION_IN_SUBSELECT = "jdbcds.no_column_alias_generation_in_subselect"; JDBC_DS_DATATYPE = "jdbcds.datatype."; JDBCDS_DATATYPE_MAX_BINARY_LENGTH = "jdbcds.datatype.max_binary_length"; //max length for binary data type JDBCDS_DATATYPE_MAX_VARBINARY_LENGTH = "jdbcds.datatype.max_varbinary_length"; //max length for

varbinary data type JDBCDS_DATATYPE_MAX_BLOB_LENGTH = "jdbcds.datatype.max_blob_length"; //max length for blob data type JDBCDS_DATATYPE_MAX_CHAR_LENGTH = "jdbcds.datatype.max_char_length"; //max length for char data type JDBCDS_DATATYPE_MAX_VARCHAR_LENGTH = "jdbcds.datatype.max_varchar_length"; //max length for varchar data type JDBCDS_DATATYPE_MAX_CLOB_LENGTH = "jdbcds.datatype.max_clob_length"; //max length for clob data type JDBCDS_DATATYPE_MAX_PRECISION = "jdbcds.datatype.max_precision"; //max precision for decimal data type JDBCDS_DATATYPE_MAX_SCALE = "jdbcds.datatype.max_scale"; //max scale for decimal data type

JDBCDS_DATATYPE_MIN_BINARY_LENGTH = "jdbcds.datatype.min_binary_length"; //min length for binary data type JDBCDS_DATATYPE_MIN_VARBINARY_LENGTH = "jdbcds.datatype.min_varbinary_length"; //min length for varbinary data type JDBCDS_DATATYPE_MIN_CHAR_LENGTH = "jdbcds.datatype.min_char_length"; //min length for char data type



JDBCDS_DATATYPE_MIN_VARCHAR_LENGTH = "jdbcds.datatype.min_varchar_length"; //min length for varchar data type JDBCDS_DATATYPE_MIN_PRECISION = "jdbcds.datatype.min_precision"; //min precision for decimal data type JDBCDS_DATATYPE_MIN_SCALE = "jdbcds.datatype.min_scale"; //min scale for decimal data type JDBC_DS_NO_SUPPORT_NULL_LITERAL = "jdbcds.no_support_null_literal"; //can NULL literal be used by itself other than in funciton. For example, if this capability is true, "SELECT NULL FROM table1" will not be allowed in data source and will not be pushed. JDBC_DS_NULL_COMPARISON_SAME_AS_IS_NULL_COMPARISON = "jdbcds.null_comparison_same_as_is_null_comparison"; // A.name = NULL is same as A.name is NULL JDBC_DS_PROMOTES_INTEGER_DIVISION_TO_FLOAT = "jdbcds.promotes_integer_division_to_float"; // 38 / 6 becomes 6.3333 = 6

JDBC_DS_REQUIRES_ALIAS_FOR_AGGREGATE_FUNCTIONS_IN_ORDER_BY = "jdbcds.requires_alias_for_aggregate_functions_in_order_by"; // select min(a) x from T order by x JDBC_DS_NO_SUPPORT_FOR_NULL_PROJECTIONS_IN_SET_OPERATION = "jdbcds.no_support_for_null_projections_in_set_operation"; // select a from T1 union all select null from T2 JDBC_DS_GENERATE_ALIASES_FOR_DUPLICATE_ALIASES = "jdbcds.generate_aliases_for_duplicate_aliases"; // select a a1, b a1 from T1 - duplicate aliases JDBC_DS_MAX_SQL_LENGTH = "jdbcds.max_sql_length"; // maximum sql length that can be pushed to the data source

JDBC_DS_ORDER_BY_AGGREGATE_FUNCTIONS_SHOULD_BE_PROJECTED = "jdbcds.order_by_aggregate_functions_should_be_projected"; //capability indicates that the aggregate functions in the ORDER BY clause needs to be projected, or else the query will fail. JDBC_DS_NO_SCALAR_WITH_AGGREGATE_FUNCTIONS_IN_ORDER_BY = "jdbcds.no_scalar_with_aggregate_functions_in_order_by"; JDBC_DS_DISABLE_SEMIJOIN = "jdbcds.disable_semijoin"; // whether semi join can be applied to this data source JDBC_DS_USE_OR_SYNTAX_FOR_SEMIJOIN = "jdbcds.use_or_syntax_for_semijoin";//http://dv-jira.dv.local/browse/CIS-15872

JDBC_DS_NO_SUPPORT_CASE = "jdbcds.no_support_case"; // check whether sql92 case expression is supported JDBC_DS_INSERT_WITH_SUBQUERIES = "jdbcds.insert_with_subqueries"; // whether insert into t (select id from t1) JDBC_DS_INSERT_WITH_MULTI_ROW_VALUES = "jdbcds.insert_with_multi_row_values"; // whether insert into t values (1,2) , (5,6) JDBC_DS_INSERT_DEFAULT_STRING = "jdbcds.insert_default_string"; // the default string - insert into t values (1,DEFAULT) JDBC_DS_INSERT_DEFAULT_VALUES_STRING = "jdbcds.insert_default_values_string"; // the default values string - insert into t DEFAULT VALUES

JDBC_DS_NO_PADDING_FOR_FIXED_LENGTH_CHARACTER_TYPES_IN_INSERT = "jdbcds.no_padding_for_fixed_length_character_types_in_insert"; JDBC_DS_UPDATE_NOT_SUPPORTED_NATIVE_DATATYPE = "jdbcds.update_not_supported_native_datatype"; // the list of native datatypes that are not supported for insert/update JDBC_DS_NO_SUPPORT_COUNT_STAR = "jdbcds.no_support_count_star"; // check whether select count(*) from t is allowed JDBC_DS_NO_CROSS_JOIN_WITH_LONG = "jdbcds.no_cross_join_with_long"; JDBC_DS_SCHEMAS_CANNOT_APPEND_TO_TABLES_OR_PROCEDURES =

"jdbcds.schemas_cannot_append_to_tables_or_procedures"; JDBC_DS_NO_MULTI_JOINS_WITH_SUBSELECT = "jdbcds.no_multi_joins_with_subselect"; // Bug 7354. Oracle does not like paranthesis grouping of joins if there is any subselect in the from clause



JDBC_DS_USE_COLUMN_POSITION_IN_ORDER_BY_IF_ALIASED = "jdbcds.use_column_position_in_order_by_if_aliased"; // Bug 7199. Access does not like ORDER BY <alias>. Use column position JDBC_DS_NO_SUPPORT_QUERY_TIMEOUT = "jdbcds.no_support_query_timeout"; JDBC_DS_SET_STATEMENT_ESCAPE_PROCESSING_FALSE = "jdbcds.set_statement_escape_processing_false"; JDBC_DS_NO_SUPPORT_SUBQUERY_IN_JOIN_CRITERIA = "jdbcds.no_support_subquery_in_join_criteria"; JDBC_DS_NO_SUPPORT_CASE_EXPRESSION_WITH_SUBQUERY_IN_JOIN_CRITERIA = "jdbcds.no_support_case_expression_with_subquery_in_join_criteria"; // Bug 10588 JDBC_DS_NO_SUPPORT_IN_OPERATOR_IN_JOIN_CRITERIA = "jdbcds.no_support_in_operator_in_join_criteria"; //CIS-27253: some DBs don't like correlated references inside ON clause JDBC_DS_NO_SUPPORT_COR_REF_IN_JOIN_CRITERIA = "jdbcds.no_support_cor_ref_in_join_criteria";

JDBC_DS_NO_SUPPORT_DISJUNCTION_IN_JOIN_CRITERIA = "jdbcds.no_support_disjunction_in_join_criteria";//CIS-29707 JDBC_DS_NO_SUPPORT_NON_EQUI_IN_JOIN_CRITERIA = "jdbcds.no_support_non_equi_in_join_criteria";//CIS-29707 JDBC_DS_REQUIRES_LEFT_DEEP_JOIN_TREE = "jdbcds.requires_left_deep_join_tree";//CIS-29720 JDBC_DS_NO_SUPPORT_IN_OPERATOR_WITH_VALUES = "jdbcds.no_support_in_operator_with_values"; JDBC_DS_NO_SUPPORT_LITERAL_PROJECTION = "jdbcds.no_support_literal_projection"; // check whether select 1 from t is allowed

JDBC_DS_TABLE_ALIAS_REQUIRES_AS = "jdbcds.table_alias_requires_as";//<table> AS <alias> JDBC_DS_MUST_PROJECT_SORT_ARGS_WITH_DIST_GP = "jdbcds.must_project_sort_arg_with_distinct_gb";//NeoView: "In a query with a GROUP BY, DISTINCT, or aggregate function, each column in the ORDER BY clause must be one of the columns explicitly SELECTed by the query." JDBC_DS_MUST_PROJECT_GROUP_BY_EXPRESSION = "jdbcds.must_project_group_by_expression";//NewView: if using expression in GB it must project it; for plain columns standard SQL rules apply JDBC_DS_MUST_PROJECT_SORT_ARG_EXPRESSION = "jdbcds.must_project_sort_arg_expression";//NewView if using an expression in ORDER BY, it must be projected and aliased. OK for plain columns

JDBC_DS_EXCEPT_OPERATOR = "jdbcds.except_operator"; //bug 7871: supports syntax to find the rows in the first query but not in the second query. Syntax: (query1) EXCEPT (query2) JDBC_DS_EXCEPT_ALL_OPERATOR = "jdbcds.except_all_operator"; //bug 7871: supports syntax to find the rows in the first query but not in the second query. Syntax: (query1) EXCEPT ALL (query2) JDBC_DS_EXCEPT_NATIVE_KEYWORD = "jdbcds.except_native_keyword"; JDBC_DS_INTERSECT_OPERATOR = "jdbcds.intersect_operator"; //bug 7870: supports syntax to find the rows in both appeared in first and second queries. Syntax: (query1) INTERSECT (query2)

JDBC_DS_INTERSECT_ALL_OPERATOR = "jdbcds.intersect_all_operator"; //bug 7870: supports syntax to find the rows in both appeared in first and second queries. Syntax: (query1) INTERSECT ALL (query2) JDBC_DS_INTERSECT_NATIVE_KEYWORD = "jdbcds.intersect_native_keyword"; JDBC_DS_MAX_SQL_ALIAS_LENGTH = "jdbcds.max_sql_alias_length"; // maximum sql alias length - select col1 as alias from T JDBC_DS_NO_SUPPORT_PARANTHESIS_BEFORE_SELECT = "jdbcds.no_support_paranthesis_before_select"; // bug 8321. My sql does not support paranthesis before SELECT keyword. JDBC_DS_NATIVE_OUTER_JOIN_SYNTAX = "jdbcds.native_outer_join_syntax"; //check whether for proprietary left /

outer join support. This will be used only if sql_92_join_syntax cap is false. JDBC_DS_SIMPLE_COLUMNS_ONLY_IN_GROUP_BY = "jdbcds.group_by.simple_columns_only"; //bug 10208 and 10113: informix can only accept simple columns in GROUP BY clause. JDBC_DS_SIMPLE_COLUMNS_ONLY_IN_NULL_PREDICATE = "jdbcds.null_predicate.simple_columns_only"; //bug 10111: informix can only accept simple columns in null predicate.



JDBC_DS_SIMPLE_COLUMNS_ONLY_IN_DISTINCT_EXPRESSION = "jdbcds.distinct_expression.simple_columns_only"; //bug 10249: informix can only accept simple columns in distinct expression JDBC_DS_SIMPLE_COLUMNS_ONLY_IN_COUNT_FUNCTION = "jdbcds.count_function.simple_columns_only"; //bug 10249: informix can only accept simple columns in count function. JDBC_DS_CAN_CANCEL_STATEMENT_ON_CURSOR_CLOSE = "jdbcds.can_cancel_statement_on_cursor_close"; JDBC_DS_SUPPORT_QUANTIFIED_COMPARISONS = "jdbcds.support_quantified_comparisons"; // whether the database supports ALL, ANY or SOME quantified comparisons JDBC_DS_NO_SUPPORT_XML_TYPES_WITH_DISTINCT = "jdbcds.no_support_xml_types_with_distinct"; // Oracle does not like sub queries with DISTINCT and XML types as projections. JDBC_DS_NO_SUPPORT_FOR_ALIASES_IN_SUBQUERY_PROJECTIONS =

"jdbcds.no_support_for_aliases_in_subquery_projections"; // Sybase does not like sub queries with aliases in projections JDBC_DS_NO_SUPPORT_SCALAR_SUBQUERY_AS_PROJECTION_WITH_GROUP_BY = "jdbcds.no_support_scalar_subquery_as_projection_with_group_by"; // Oracle does not support select (select count(*) from O10) from O10 group by O10_id JDBC_DS_NO_SUPPORT_SUBQUERIES_INSIDE_CASE_EXPRESSION = "jdbcds.no_support_subqueries_inside_case_expression"; // Teradata doesn't support select case when 1 in (select 1 from T) then 1 end from T2

JDBC_DS_NO_SUPPORT_SUBQUERIES_INSIDE_CASE_EXPRESSION_IN_ORDER_BY = "jdbcds.no_support_subqueries_inside_case_expression_in_order_by"; JDBC_DS_NO_SUPPORT_SUBQUERIES_INSIDE_CASE_EXPRESSION_IN_GROUP_BY = "jdbcds.no_support_subqueries_inside_case_expression_in_group_by"; JDBC_DS_NO_SUPPORT_SUBQUERIES_INSIDE_CASE_EXPRESSION_IN_IN_OPERATOR_VALUES = "jdbcds.no_support_subqueries_inside_case_expression_in_in_operator_values"; JDBC_DS_SUPPORTS_ONLY_PLAIN_LITERAL_VALUES_IN_IN_OPERATOR = "jdbcds.supports_only_plain_literal_values_in_in_operator"; // Teradata doesn't support select 1 from T where c1 in(c2,

'b') or select 1 from T where c1 in (trim('a'), b)) JDBC_DS_NO_SUPPORT_NULLIF_FUNCTION_AS_FUNCTION_ARGUMENT = "jdbcds.no_support_nullif_function_as_function_argument"; // Teradata doesn't support select nullif(1, nullif(10.1, 10.2)) from T JDBC_DS_NO_SUPPORT_MIN_FUNCTION_WITH_ANY_OTHER_AGGREGATE_FUNCTION_AND_NO_GROUP_BY = "jdbcds.no_support_min_function_with_any_other_aggregate_function_and_no_group_by"

DS_CONN_CHECKOUT_TIMEOUT = "ds.conn_checkout_timeout"; //get the value (in seconds) to wait for obtaining a connection DS_USES_NON_UNICODE_ORDERING = "ds.uses_non_unicode_ordering"; JDBC_DS_MATCH_UNION_LEFT_RIGHT_ALIASES = "jdbcds.match_union_left_right_aliases"; //Some data sources like DB2 expect aliases of union left and right side to match for example the query "select col a1 from T union all col a2 from T" will fail because of alias a2 in right hand side JDBC_DS_NO_SUPPORT_IMPLICIT_CAST_IN_SUBQUERY = "jdbcds.no_support_implicit_cast_in_subquery";

//Some data sources like access does not support implicit casting in subqyery. ex. select 1 from categories where 1 IN (SELECT 'a' FROM categories) JDBC_NO_SUPPORT_SET_OPERATION_IN_SUBQUERY = "jdbcds.no_set_operation_in_subquery"; JDBC_DS_WITH_CLAUSE = "jdbcds.with_clause";



JDBC_DS_NO_SUPPORT_WITH_CLAUSE_IN_DERIVED_TABLE = "jdbcds.no_support_with_clause_in_derived_table"; // SELECT * from (WITH x as (SELECT * FROM T) select * from x) q JDBC_DS_NO_SUPPORT_WITH_CLAUSE_IN_SUBQUERIES = "jdbcds.no_support_with_clause_in_subqueries"; // SELECT * from where id in(WITH x as (SELECT * FROM T) select * from x) JDBC_DS_NO_SUPPORT_TABLES_IN_COLUMN_NAMES_FOR_WITH_CLAUSE = "jdbcds.no_support_tables_in_column_names_for_with_clause"; // DB2 does not like SELECT x.a from x where x is a WITH SELECT JDBC_DS_NO_SUPPORT_ALIASES_IN_WITH_CLAUSE_TABLE_REF = "jdbcds.no_support_aliases_in_with_clause_table_ref"; // DB2 does not like WITH x as (SELECT c1 from T) SELECT a.c1 from x a

JDBC_DS_NO_SUPPORT_FOR_WITH_REFERENCING_WITH = "jdbcds.no_support_for_with_referencing_with";//DB2 doesn't like WITH x as (select c1 from T), y as (select * from x) SELECT * from y JDBC_DS_REWRITE_PREDICATE_AS_BETWEEN = "jdbcds.rewrite_predicate_as_between"; JDBC_DS_COLUMN_ALIASING_IN_WITH_CLAUSE = "jdbcds.column_aliasing_in_with_clause";//this refers to (b) part in with FOO (b) AS select a as c from T Select * from FOO, not 'a as c' JDBC_NO_SUPPORT_DISTINCT_OPERATOR_WITH_DISTINCT_AGGREGATES =

"jdbcds.no_support_distinct_operator_with_distinct_aggregates"; // Informix does not like SELECT DISTINCT MIN(DISTINCT col1) from t1 JDBC_DS_SCALAR_SUBQUERIES = "jdbcds.scalar_subqueries"; //check for support of scalar sub queries - select col1, (select c1 from t1) from T JDBC_DS_NO_SUPPORT_SCALAR_SUBQUERIES_IN_ORDERBY = "jdbcds.no_support_scalar_subqueries_in_orderby"; //check for support of scalar sub queries in order by - select col1 from T order by (select c1 from t1)

JDBC_DS_NO_SUPPORT_SCALAR_SUBQUERIES_IN_AGGREGATE_FUNCTIONS = "jdbcds.no_support_scalar_subqueries_in_aggregate_functions"; //check for support of scalar sub queries in aggregates - select max(select c1 from t1) foo from T JDBC_DS_NO_SUPPORT_NESTED_ANALYTICALORAGGREGATE_FUNCTIONS = "jdbcds.no_support_nested_analyticaloraggregate_functions"; JDBC_DS_NO_SUPPORT_AGGREGATE_CORRELATED_REFERENCES = "jdbcds.no_support_aggregate_correlated_references"; //check for support of aggregate correlated reference - select

(select max(s10.s_id) from s100 where s100.s_id = 5) a from s10 JDBC_DS_EVALUATES_AGGREGATE_CORRELATED_REFERENCES_IN_PARENT_QUERY = "jdbcds.evaluates_aggregate_correlated_references_in_parent_query"; JDBC_DS_USE_DATEFORMAT_MATCHING = "jdbcds.use_dateformat_matching"; JDBC_DS_USE_MYSQL_DATEFORMAT = "jdbcds.use_mysql_dateformat"; JDBC_DS_DATEFORMAT_PATTERN = "jdbcds.dateformat.";

JDBCDS_CAST_FUNCTION_MAX_BINARY_LENGTH = "jdbcds.cast_function_max_binary_length"; //max length allowed in cast function for binary data type JDBCDS_CAST_FUNCTION_MAX_VARBINARY_LENGTH = "jdbcds.cast_function_max_varbinary_length"; //max length allowed in cast function for varbinary data type



JDBCDS_CAST_FUNCTION_MAX_CHAR_LENGTH = "jdbcds.cast_function_max_char_length"; //max length allowed in cast function for char data type JDBCDS_CAST_FUNCTION_MAX_VARCHAR_LENGTH = "jdbcds.cast_function_max_varchar_length"; //max length allowed in cast function for varchar data type JDBCDS_CAST_FUNCTION_MAX_PRECISION = "jdbcds.cast_function_max_precision"; //max precision allowed in cast function for decimal data type JDBCDS_CAST_FUNCTION_MAX_SCALE = "jdbcds.cast_function_max_scale"; //max scale allowed in cast function for decimal data type JDBC_DS_MAX_NUMBER_OF_IN_OPERATOR_VALUES = "jdbcds.max_number_of_in_operator_values"; JDBC_DS_NO_SUPPORT_MORE_THAN_ONE_AGGREGATE_DISTINCT_FUNCTION_IN_PROJECTION =

"jdbcds.no_support_more_than_one_aggregate_distinct_function_in_projection"; // informix does not like this JDBC_DS_NO_SUPPORT_NULLABLE_ON_BIT_COLUMN_IN_CREATE_TABLE = "jdbcds.no_support_nullable_on_bit_column_in_create_table"; JDBC_DS_NO_SUPPORT_AUTOCOMMIT = "jdbcds.no_support_autocommit"; JDBC_DS_NO_SUPPORT_ACCEPT_URL = "jdbcds.no_support_accept_url"; JDBC_DS_NO_SUPPORT_PREPAREDSTMT_FOR_INSERT = "jdbcds.no_support_preparedstmt_for_insert"; JDBC_DS_NO_SUPPORT_PREPAREDSTMT_FOR_UPDATE = "jdbcds.no_support_preparedstmt_for_update";

JDBC_DS_SUPPORTS_OFFSET = "jdbcds.supports_offset"; JDBC_DS_SUPPORTS_FETCH = "jdbcds.supports_fetch"; JDBC_DS_USE_ROWNUM_FOR_PAGINATION = "jdbcds.use_row_num_for_pagination"; JDBC_DS_SUPPORTS_WINDOW_FRAME_EXCLUSION = "jdbcds.supports_window_frame_exclusion"; JDBC_DS_LARGEDATA_CLIENT_FETCHSIZE = "jdbcds.largedata_client_fetchsize"; JDBC_DS_GREENPLUM_DATATYPE = "jdbcds.greenplum_datatype"; JDBC_DS_LEFT_SEMI_JOIN_OP = "jdbcds.left_semi_join_op"; JDBC_DS_USE_SCHEMA_IN_INDEX_NAME = "jdbcds.use_schema_in_index_name";

JDBC_DS_SET_SESSION_TIME_ZONE = "jdbcds.set_session_time_zone"; LDAP_DS_QUERY_WITH_1000_ROW_LIMIT = "ldapds.qeury_with_1000_row_limit"; COMPOSITE_DATATYPE = "composite.datatype."; //native data type that is derived from TDV server. COMPOSITE_DATATYPE_PROMOTE = "_promote";

Constants for Expressions EXPR_DO_NOT_USE_SMART_PARANTHESIS_IN_PREDICATES = "expr.do_not_use_smart_paranthesis_in_predicates"; EXPR_AND_PATTERN = "expr.and_pattern"; EXPR_OR_PATTERN = "expr.or_pattern"; EXPR_NOT_PATTERN = "expr.not_pattern"; EXPR_LIKE_PATTERN = "expr.like_pattern"; EXPR_IN_PATTERN = "expr.in_pattern"; EXPR_IN_ROW_PATTERN = "expr.in_row_pattern";

EXPR_EXISTS_PATTERN = "expr.exists_pattern"; EXPR_LIKE_PATTERN_WILDCARD = "expr.like_pattern.wildcard"; EXPR_LIKE_PATTERN_SINGL_CHAR_WILDCARD = "expr.like_pattern.single_char_wildcard"; EXPR_NE_PATTERN = "expr.ne_pattern";



EXPR_EQ_PATTERN = "expr.eq_pattern"; EXPR_LT_PATTERN = "expr.lt_pattern"; EXPR_GT_PATTERN = "expr.gt_pattern"; EXPR_LE_PATTERN = "expr.le_pattern"; EXPR_GE_PATTERN = "expr.ge_pattern"; EXPR_IS_NULL_PATTERN = "expr.is_null_pattern"; EXPR_IS_NOT_NULL_PATTERN = "expr.is_not_null_pattern"; EXPR_NULL_COMPARE_PATTERN = "expr.null_compare_pattern"; // special case for DB2. It doesn't like where x=NULL. so we rewrite it as where 1<>1

EXPR_NUMERIC_PATTERN = "expr.numeric"; EXPR_STRING_PATTERN = "expr.string"; EXPR_DATE_PATTERN = "expr.date"; EXPR_DATETIME_PATTERN = "expr.datetime"; EXPR_DATETIME_AS_DATE_PATTERN = "expr.datetimeasdate"; EXPR_TIME_PATTERN = "expr.time"; EXPR_INTERVAL_DAY_PATTERN = "expr.interval day"; EXPR_INTERVAL_HOUR_PATTERN = "expr.interval hour";

EXPR_INTERVAL_MINUTE_PATTERN = "expr.interval minute"; EXPR_INTERVAL_SECOND_PATTERN = "expr.interval second"; EXPR_INTERVAL_DAY_TO_HOUR_PATTERN = "expr.interval day to hour"; EXPR_INTERVAL_DAY_TO_MINUTE_PATTERN = "expr.interval day to minute"; EXPR_INTERVAL_DAY_TO_SECOND_PATTERN = "expr.interval day to second"; EXPR_INTERVAL_HOUR_TO_MINUTE_PATTERN = "expr.interval hour to minute"; EXPR_INTERVAL_HOUR_TO_SECOND_PATTERN = "expr.interval hour to second"; EXPR_INTERVAL_MINUTE_TO_SECOND_PATTERN = "expr.interval minute to second";

EXPR_INTERVAL_YEAR_PATTERN = "expr.interval year"; EXPR_INTERVAL_YEAR_TO_MONTH_PATTERN = "expr.interval year to month"; EXPR_INTERVAL_MONTH_PATTERN = "expr.interval month"; // separate interval pattern defs since the others are taken for the interval datatype literals EXPR_INTERVAL_DAY_TO_SECOND_CAST_PATTERN = "expr.interval_day_to_second_cast_pattern"; EXPR_INTERVAL_YEAR_TO_MONTH_CAST_PATTERN = "expr.interval_year_to_month_cast_pattern"; EXPR_ESCAPE_CHARACTER = "expr.escape_character";

EXPR_CHARACTERS_TO_ESCAPE = "expr.characters_to_escape"; EXPR_CHARACTERS_TO_ESCAPE_FOR_LIKE = "expr.characters_to_escape_for_like"; EXPR_NE_NATIVE_LEFT_OUTER_JOIN_PATTERN = "expr.ne_native_left_outer_join_pattern"; EXPR_EQ_NATIVE_LEFT_OUTER_JOIN_PATTERN = "expr.eq_native_left_outer_join_pattern"; EXPR_LT_NATIVE_LEFT_OUTER_JOIN_PATTERN = "expr.lt_native_left_outer_join_pattern"; EXPR_GT_NATIVE_LEFT_OUTER_JOIN_PATTERN = "expr.gt_native_left_outer_join_pattern"; EXPR_LE_NATIVE_LEFT_OUTER_JOIN_PATTERN = "expr.le_native_left_outer_join_pattern";

EXPR_GE_NATIVE_LEFT_OUTER_JOIN_PATTERN = "expr.ge_native_left_outer_join_pattern"; EXPR_LIKE_NATIVE_LEFT_OUTER_JOIN_PATTERN = "expr.like_native_left_outer_join_pattern"; EXPR_NE_NATIVE_RIGHT_OUTER_JOIN_PATTERN = "expr.ne_native_right_outer_join_pattern"; EXPR_EQ_NATIVE_RIGHT_OUTER_JOIN_PATTERN = "expr.eq_native_right_outer_join_pattern";



EXPR_LT_NATIVE_RIGHT_OUTER_JOIN_PATTERN = "expr.lt_native_right_outer_join_pattern"; EXPR_GT_NATIVE_RIGHT_OUTER_JOIN_PATTERN = "expr.gt_native_right_outer_join_pattern"; EXPR_LE_NATIVE_RIGHT_OUTER_JOIN_PATTERN = "expr.le_native_right_outer_join_pattern"; EXPR_GE_NATIVE_RIGHT_OUTER_JOIN_PATTERN = "expr.ge_native_right_outer_join_pattern"; EXPR_LIKE_NATIVE_RIGHT_OUTER_JOIN_PATTERN = "expr.like_native_right_outer_join_pattern"; EXPR_MAP_EXTNAME_FUNCTION = "expr.map_extname_function";

Constants for Comparisons COMP_LIKE_PATTERN = "comp.like_pattern"; COMP_IS_NULL_PATTERN = "comp.is_null_pattern"; COMP_IS_NOT_NULL_PATTERN = "comp.is_not_null_pattern"; COMP_NE_PATTERN = "comp.ne_pattern";

COMP_EQ_PATTERN = "comp.eq_pattern"; COMP_LT_PATTERN = "comp.lt_pattern"; COMP_GT_PATTERN = "comp.gt_pattern"; COMP_LE_PATTERN = "comp.le_pattern"; COMP_GE_PATTERN = "comp.ge_pattern"; COMP_EXCEPT_PATTERN = "comp.except_pattern"; COMP_INTERSECT_PATTERN = "comp.intersect_pattern";

COMP_UNION_PATTERN = "comp.union_pattern";

Constants for Datatype Categories DATATYPE_CAT_ANY = "~any"; DATATYPE_CAT_NUMBER = "~number"; DATATYPE_CAT_WHOLE_NUMBER = "~whole_number"; DATATYPE_CAT_FLOATING_POINT = "~floating_point"; DATATYPE_CAT_STRING = "~string"; DATATYPE_CAT_BINARY = "~binary";

DATATYPE_CAT_DATE = "~date"; DATATYPE_CAT_LOB = "~lob"; DATATYPE_CAT_INTERVAL_DAY = "~interval_day"; DATATYPE_CAT_INTERVAL_YEAR = "~interval_year";

Constants for Primitive Datatypes PRIMITIVE_INTEGER = "@integer"; PRIMITIVE_SMALLINT = "@smallint"; PRIMITIVE_TINYINT = "@tinyint";

PRIMITIVE_BIGINT = "@bigint"; PRIMITIVE_BIT = "@bit"; PRIMITIVE_FLOAT = "@float"; PRIMITIVE_REAL = "@real"; PRIMITIVE_DOUBLE = "@double"; PRIMITIVE_DECIMAL = "@decimal"; PRIMITIVE_CHAR = "@char"; PRIMITIVE_VARCHAR = "@varchar";

PRIMITIVE_DATE = "@date"; PRIMITIVE_TIMESTAMP = "@timestamp";



PRIMITIVE_VARBINARY = "@varbinary"; PRIMITIVE_NUMERIC = "@numeric"; PRIMITIVE_BOOLEAN = "@boolean"; PRIMITIVE_BINARY = "@binary"; PRIMITIVE_BLOB = "@blob"; PRIMITIVE_LONGVARCHAR = "@longvarchar"; PRIMITIVE_CLOB = "@clob"; PRIMITIVE_TIME = "@time"; PRIMITIVE_INTERVAL_DAY = "@interval_day"; PRIMITIVE_INTERVAL_HOUR = "@interval_hour"; PRIMITIVE_INTERVAL_MINUTE = "@interval_minute";

PRIMITIVE_INTERVAL_SECOND = "@interval_second"; PRIMITIVE_INTERVAL_DAY_TO_HOUR = "@interval_day_to_hour"; PRIMITIVE_INTERVAL_DAY_TO_MINUTE = "@interval_day_to_minute"; PRIMITIVE_INTERVAL_DAY_TO_SECOND = "@interval_day_to_second"; PRIMITIVE_INTERVAL_HOUR_TO_MINUTE = "@interval_hour_to_minute"; PRIMITIVE_INTERVAL_HOUR_TO_SECOND = "@interval_hour_to_second"; PRIMITIVE_INTERVAL_MINUTE_TO_SECOND = "@interval_minute_to_second"; PRIMITIVE_INTERVAL_YEAR = "@interval_year";

PRIMITIVE_INTERVAL_YEAR_TO_MONTH = "@interval_year_to_month"; PRIMITIVE_INTERVAL_MONTH = "@interval_month"; PRIMITIVE_XML = "@xml"; PRIMITIVE_NULL = "@null";

Constants for Primitive Datatype Attributes PRIMITIVE_DATATYPE_LENGTH_PATTERN = "&l"; PRIMITIVE_DATATYPE_PRECISION_PATTERN = "&p"; PRIMITIVE_DATATYPE_SCALE_PATTERN = "&s";

PRIMITIVE_DATATYPE_YEAR_PATTERN = "&y"; PRIMITIVE_DATATYPE_MONTH_PATTERN = "&m"; PRIMITIVE_DATATYPE_DAY_PATTERN = "&d"; PRIMITIVE_DATATYPE_HOUR_PATTERN = "&h"; PRIMITIVE_DATATYPE_MINUTE_PATTERN = "&mi"; PRIMITIVE_DATATYPE_SECOND_PATTERN = "&sec"; PRIMITIVE_DATATYPE_NANOSECOND_PATTERN = "&n";

Constants for SQL Statement Clauses SQL_SELECT_CLAUSE = "sql.select.clause"; SQL_WHERE_CLAUSE = "sql.where.clause"; SQL_ORDER_BY_CLAUSE = "sql.orderby.clause"; SQL_GROUP_BY_CLAUSE = "sql.groupby.clause"; SQL_HAVING_CLAUSE = "sql.having.clause"; SQL_DISTINCT_CLAUSE = "sql.distinct.clause"; SQL_JOIN_ON_CLAUSE = "sql.join_on.clause"; SQL_EXIST_CLAUSE = "sql.exist.clause";

SQL_EXCEPT_CLAUSE = "sql.except.clause"; SQL_INTERSECT_CLAUSE = "sql.intersect.clause"; SQL_UNION_CLAUSE = "sql.union.clause";



NATIVE_DATA_TYPES = ".native.datatypes"; NATIVE_DATA_TYPES_ARRAY = ".native.datatypes.array"; DERIVED_DATA_TYPES = ".derived.datatypes"; DERIVED_DATA_TYPES_ARRAY = ".derived.datatypes.array"; VARIABLE_SUFFIX =".variable";

Constants for Function Mapping FUNCTION_NOT_SUPPORTED = "not_supported"; //indicates that a function is not supported for given set of inputs.