• Topic
  • Discussion
    • UdaWikiWeb.Udaudajdbc(Last) -- Owiki? , 2016-08-19 15:01:25 Edit
    [TXT]
    [PLAIN]
    [DOCBOOK]
    owiki 2016-08-19 15:01:25

    uda.jdbc





    JDBC Drivers





    JDBC Drivers
    JDBC is the industry-standard API for database-independent connectivity between the Java applications and Databases, using a SQL based interface. As with Java itself one of the main features of the JDBC API is its "Write Once, Run Anywhere" capability enabling applications to be move from one OS to another without the need for recompilation. JDBC consists of two key components:

    • JDBC Driver Manager - application binds to this generic class which is then responsible for loading the requested JDBC Driver.
    • JDBC Driver - dynamically loaded by the JDBC Driver manager for making connection to target Database.
      JDBC Drivers are available in four different types ranging from Pure to Bridge construction:
    • Type 4 - Direct-to-Database Pure Java Driver using database network protocol for driver communication with database from Java
    • Type 3 - Pure Java Driver for Database Middleware using a middleware vendor''s protocol-layer for connectivity to the Database.
    • Type 2 - A native API partly Java technology-enabled driver converting JDBC calls into the Database vendor''s CLI calls for communication with the database.
    • Type 1 - JDBC-ODBC Bridge using an existing ODBC Driver for connecting to remote databases.
      JDBC enables maximum interoperability between the application and database as a single application can access any JDBC-enabled database by simply being configured to use its JDBC driver, and likewise a JDBC enabled application can access a given Database using its JDBC driver. JDBC also has the added advantage of being able to run cross platform with the need for recompilation, the so-called "Write Once, Run Anywhere" capability.
    Standards Compliance
    JDBC 3.0 Datatype Enhancements support The DATALINK and BOOLEAN datatypes are additions to java.sql.Types. the DATALINK type provides access to external resources (URLs) from within a resultset using the new getURL() methods. While the BOOLEAN type is the logical equivalent of the BIT type with additional semantics, and is retrieved from a resultset using the getBoolean() method. JDBC Metadata Enhancements support The JDBC metadata APIs have been enhanced in JDBC 3.0, with the DatabaseMetaData interface now able to retrieve SQL type hierarchies. There is also a new ParameterMetaData interface to describe the types and properties of the parameters in PreparedStatement objects.
    Platform Support Support for client, server, and application server operating systems


    | 32- and 64-bit components | Enables the development and utilization of 32- or 64-Bit DBMS independent applications.

    Database Engine Support Backend database engine support


    | Broad backend Database Support | Enables DBMS independent application utilization and deployment across a vast array of industry leading DBMS engines that includes; Oracle (7.x - 10.x), SQL Server (6.x - 2005), DB2 (6.x - 8.x), Sybase (10.x - 12.x), Progress (7.x - 10.x), Ingres (6.4 - II family), Informix (5.x - 9.x & IDS 2000), MySQL , and PostgreSQL .

    Performance
    Blistering Performance Delivery of data access performance levels across ODBC, JDBC, ADO.NET and OLE DB that don't compromise viability of DBMS independent application development and deployment. Network Aware Record Retrieval Enabling the retrieval and insertion of multiple DBMS records in batches over the network with a minimal number of network hops.
    Packaging The manner in which product components are packaged


    | Miniature Driver Size | Driver size is minimal with the smallest variant (Megathin) under 60K in size.

    Standards Compliance


    | International character support | Enables the development and deployment of international applications that are independent of underlying database engine.

    Performance
    Multithreaded Enables exploitation of scalability benefits arising from the use of multiple CPUs or Clusters while developing or using DBMS independent applications. Array Bound RowSets As part of the new RowSet class. It is now possible to bind data arrays to the columns of the OpenLink RowSet object, and retrieve the data directly into the arrays with a single invocation of the RowSet.next() method.
    Standards Compliance
    Supports Advanced Data Access API functionality Enables the development and utilization of DBMS application with DBMS independent granularity that extends to challenging areas such as scalar function calls, dates and timestamps manipulation, outer join handling, and SQL stored procedure invocation etc. ODBC and JDBC Scrollable Cursor Support Enables the development of JDBC based DBMS independent applications that are capable of exploiting the ODBC style (Attached RowSet extension to JDBC by OpenLink ) and JDBC style (Detached RowSet ) scrollable cursor models from a single driver. This approach provides the application developer with maximum flexibiity and control over the degree of database change sensitivity expressed by a JDBC based application.
    JDBC 3.0 Connection Pooling support JDBC 3.0 standardizes connection pooling configuration properties thereby alleviating complexity from the myriad vendor-specific properties in JDBC 2.0. This enables higher interchangeability across JDBC Drivers for JDBC compliant application and service developers. Additionally, the properties allow administrators to fine tune the connection pool to maximize performance characteristics of the application or service. The following properties are implemented by our drivers; maxStatements, initialPoolSize, minPoolSize, maxPoolSize, maxIdleTime, and propertyCycle
    Named Parameters in Callable Statements Prior to JDBC 3.0, the way to set a parameter in a SQL Stored Procedure was by specifying the parameter's index, not its name. The CallableStatement interface has been enhanced in JDBC 3.0 so that you can now specify parameters by their names.
    Resultset Holdability A holdable cursor, or result, is one that does not automatically close when the transaction that contains the cursor is committed. JDBC 3.0 adds support for specifying cursor holdability. To specify the holdability of your ResultSet , you must do so when preparing a statement using the createStatement(), prepareStatement(), or prepareCall() methods. The holdability may be one of the following constants: HOLD CURSORS_OVER_COMMIT or CLOSE_CURSORS_AT_COMMIT. Note it is more efficient to close CURSOR at the end of transactions (after the COMMIT). JDBC doesn't specifiy a default HOLD_CURSOR behavour but for resource expediency we have chosen CLOSE_CURSORS_AT_COMMIT as the default.
    Prepared Statement Pooling support A prepared statement allows you to take a commonly used SQL statement and pre-compile it, thereby dramatically improving performance if the statement is executed multiple times. If your applications has many queries that are reused with only parametic changes occuring, then it is beneficial to pool this statements and retain control over their life span. JDBC 3.0 delivers as solution to this need via Prepared Statement Pooling, which enables the life span of a prepared statement to be handled at the driver level thereby alleviating the JDBC application or service developer of this responsibility.
    Transaction Savepoints support JDBC 3.0 provides the ability to have increased granularity over the control of database transactions. The new Savepoint interface allows you to partition a transaction into logical breakpoints, providing control over how much of the transaction gets rolled back.