Hubbry Logo
DatasourceDatasourceMain
Open search
Datasource
Community hub
Datasource
logo
7 pages, 0 posts
0 subscribers
Be the first to start a discussion here.
Be the first to start a discussion here.
Contribute something
Datasource
Datasource
Datasource
View on Wikipedia
from Wikipedia

A datasource or DataSource is a name given to the connection set up to a database from a server. The name is commonly used when creating a query to the database. The data source name (DSN) need not be the same as the filename for the database. For example, a database file named friends.mdb could be set up with a DSN of school. Then DSN school would be used to refer to the database when performing a query.

Sun's version of DataSource [1]

[edit]

A factory for connections to the physical data source that this DataSource object represents. An alternative to the DriverManager facility, a DataSource object is the preferred means of getting a connection. An object that implements the DataSource interface will typically be registered with a naming service based on the Java Naming and Directory Interface (JNDI) API.

The DataSource interface is implemented by a driver vendor. There are three types of implementations:

  • Basic implementation — produces a standard Connection object
  • Connection pooling implementation — produces a Connection object that will automatically participate in connection pooling. This implementation works with a middle-tier connection pooling manager.
  • Distributed transaction implementation — produces a Connection object that may be used for distributed transactions and almost always participates in connection pooling. This implementation works with a middle-tier transaction manager and almost always with a connection pooling manager.

A DataSource object has properties that can be modified when necessary. For example, if the data source is moved to a different server, the property for the server can be changed. The benefit is that because the data source's properties can be changed, any code accessing that data source does not need to be changed.

A driver that is accessed via a DataSource object does not register itself with the DriverManager. Rather, a DataSource object is retrieved through a lookup operation and then used to create a Connection object. With a basic implementation, the connection obtained through a DataSource object is identical to a connection obtained through the DriverManager facility.

Sun's DataSource Overview [2]

[edit]

A DataSource object is the representation of a data source in the Java programming language. In basic terms, a data source is a facility for storing data. It can be as sophisticated as a complex database for a large corporation or as simple as a file with rows and columns. A data source can reside on a remote server, or it can be on a local desktop machine. Applications access a data source using a connection, and a DataSource object can be thought of as a factory for connections to the particular data source that the DataSource instance represents. The DataSource interface provides two methods for establishing a connection with a data source.

Using a DataSource object is the preferred alternative to using the DriverManager for establishing a connection to a data source. They are similar to the extent that the DriverManager class and DataSource interface both have methods for creating a connection, methods for getting and setting a timeout limit for making a connection, and methods for getting and setting a stream for logging.

Their differences are more significant than their similarities, however. Unlike the DriverManager, a DataSource object has properties that identify and describe the data source it represents. Also, a DataSource object works with a Java Naming and Directory Interface (JNDI) naming service and can be created, deployed, and managed separately from the applications that use it. A driver vendor will provide a class that is a basic implementation of the DataSource interface as part of its Java Database Connectivity (JDBC) 2.0 or 3.0 driver product. What a system administrator does to register a DataSource object with a JNDI naming service and what an application does to get a connection to a data source using a DataSource object registered with a JNDI naming service are described later in this chapter.

Being registered with a JNDI naming service gives a DataSource object two major advantages over the DriverManager. First, an application does not need to hardcode driver information, as it does with the DriverManager. A programmer can choose a logical name for the data source and register the logical name with a JNDI naming service. The application uses the logical name, and the JNDI naming service will supply the DataSource object associated with the logical name. The DataSource object can then be used to create a connection to the data source it represents.

The second major advantage is that the DataSource facility allows developers to implement a DataSource class to take advantage of features like connection pooling and distributed transactions. Connection pooling can increase performance dramatically by reusing connections rather than creating a new physical connection each time a connection is requested. The ability to use distributed transactions enables an application to do the heavy duty database work of large enterprises.

Although an application may use either the DriverManager or a DataSource object to get a connection, using a DataSource object offers significant advantages and is the recommended way to establish a connection.

Since 1.4

Since Java EE 6 a JNDI-bound DataSource can alternatively be configured in a declarative way directly from within the application.[1][2] This alternative is particularly useful for self-sufficient applications or for transparently using an embedded database.[3][4]

Yahoo's version of DataSource [3]

[edit]

A DataSource is an abstract representation of a live set of data that presents a common predictable API for other objects to interact with. The nature of your data, its quantity, its complexity, and the logic for returning query results all play a role in determining your type of DataSource. For small amounts of simple textual data, a JavaScript array is a good choice. If your data has a small footprint but requires a simple computational or transformational filter before being displayed, a JavaScript function may be the right approach. For very large datasets—for example, a robust relational database—or to access a third-party webservice you'll certainly need to leverage the power of a Script Node or XHR DataSource.

References

[edit]
Revisions and contributorsEdit on WikipediaRead on Wikipedia

Datasource

View on Grokipedia
from Grokipedia
In , a data source is a location or mechanism from which data is obtained, such as a database, file, , or , enabling applications to access and process information. One prominent implementation is the DataSource interface in the (JDBC) , defined in the javax.sql package, that serves as a for creating connections to a physical data source such as a . Introduced with JDBC 2.0 in , it provides a portable and configurable mechanism for applications to access data sources without directly using the DriverManager class, enabling better integration with enterprise environments like Java EE containers. Unlike the older DriverManager approach, a DataSource object can be configured with properties such as server name, port number, and database name, which can be modified at runtime or deployment without recompiling the application code. It is typically obtained through Java Naming and Directory Interface (JNDI) lookups in server-based applications, promoting resource pooling and connection management for improved performance and scalability. Implementations of DataSource, such as those provided by database vendors like or DBCP, support features like connection pooling, distributed transactions via XADataSource, and connection validation to handle and load balancing. This interface has become foundational in modern applications for decoupling data access logic from specific driver details, facilitating easier maintenance and portability across different database systems.

General Concept

Definition and Purpose

A DataSource is a standardized facility or interface in software systems that enables applications to connect to and retrieve data from various underlying storage systems, such as databases, files, or remote services, while abstracting the complexities of direct low-level connections. This abstraction layer simplifies data access by providing a uniform mechanism to obtain connections, regardless of the specific data provider or protocol involved. The primary purpose of a DataSource is to facilitate efficient data access through mechanisms like resource pooling, where connections are reused to minimize the overhead of repeatedly establishing new links to the data origin. It also promotes portability by allowing applications to switch between different data providers—such as from one database vendor to another—without requiring modifications to the core application code, thanks to its vendor-independent design. Key benefits of using a DataSource include enhanced , as connection pooling supports handling increased loads by efficiently managing a limited set of reusable connections; improved through centralized , which avoids sensitive information directly in application and enables secure mapping of user identities to database privileges; and greater in multi-tier architectures, where the DataSource acts as a decoupling layer between and . These advantages make DataSources particularly valuable in enterprise environments requiring robust, flexible . Examples of data origins accessible via a DataSource include relational databases through standards like JDBC, and APIs or remote services that expose data endpoints. In each case, the emphasis is on the , which shields developers from provider-specific details and ensures consistent data handling across diverse sources.

Historical Development

The concept of DataSource emerged in the late as part of efforts to standardize database access in enterprise environments, with early precursors focusing on unifying connectivity across disparate systems. In 1992, introduced (ODBC) as a key milestone, providing a standardized () for accessing relational databases on Windows platforms and enabling driver-based connections to various data sources. In the Java ecosystem, the Java Naming and Directory Interface (JNDI) was specified in 1998 by to facilitate resource location in distributed applications, laying groundwork for managed DataSource lookups in application servers. This was followed by the introduction of the javax.sql.DataSource interface in JDBC 2.0's Standard Extension in 1998, developed by to overcome limitations of the basic DriverManager for connection pooling and distributed transactions in enterprise settings. Subsequent enhancements came with JDBC 3.0 in 2002 under JSR 54, which built on DataSource capabilities by adding features like statement pooling and savepoint support to improve performance in high-load scenarios. On the front, Yahoo released its () library in February 2006, incorporating a DataSource utility as an early adaptation for handling asynchronous data retrieval in AJAX applications. Post-2010 developments shifted toward cloud-native architectures, exemplified by the release of Spring Boot 1.0 in April 2014, which simplified DataSource configuration through auto-configuration and integration with cloud services for scalable, containerized deployments.

In Database Technologies

Java JDBC DataSource

The Java JDBC DataSource interface, defined in the javax.sql package, serves as a factory for establishing connections to physical data sources, extending the foundational JDBC model to support advanced features like connection pooling and distributed transactions. Introduced as part of JDBC 2.0, it provides a standardized, vendor-implemented mechanism that is typically registered with a naming service such as JNDI, allowing applications to obtain connections without directly interacting with the DriverManager class. Key methods of the DataSource interface include getConnection(), which attempts to establish a database connection using default credentials, and getConnection(String username, String password), which uses provided details; both may throw SQLException if the operation fails. Inheriting from CommonDataSource, it also supports configuration methods such as setLoginTimeout(int seconds) to specify the maximum time in seconds to wait for a connection (defaulting to 0 for no timeout) and getLoginTimeout() to retrieve this value. For scenarios involving distributed transactions, the related XADataSource interface produces XAConnection objects, enabling coordination across multiple resources via a transaction manager. DataSource integrates seamlessly with connection pooling implementations to manage reusable database connections, acting as a that minimizes latency by connections rather than creating new ones for each request. Popular libraries include DBCP, which provides a BasicDataSource implementation configurable via properties for basic pooling needs, and HikariCP, a lightweight, high-performance pool known for its minimal overhead and reliability in production environments. These implementations allow DataSource to handle high-concurrency scenarios efficiently, such as in web applications where frequent database queries occur. Configuration of a JDBC DataSource often occurs in application servers like Apache Tomcat through JNDI lookups, where resources are defined in files such as context.xml. Essential properties include driverClassName (e.g., com.mysql.cj.jdbc.Driver for MySQL), url (the JDBC connection string, e.g., jdbc:mysql://localhost:3306/mydb), and pooling parameters like maxTotal (maximum active connections, e.g., 100) or maxIdle (maximum idle connections, e.g., 30). The JDBC driver JAR must be placed in the server's library directory (e.g., $CATALINA_HOME/lib), and the resource is referenced in the application's web.xml for container-managed authentication. Compared to the DriverManager approach, DataSource offers superior thread-safety for concurrent access, support for distributed transactions through XADataSource, and the ability to avoid hard-coding credentials by leveraging JNDI-bound configurations, making it ideal for enterprise applications. Later JDBC versions (e.g., 4.0 and above) introduce additional exception types like SQLTimeoutException for timeout handling. In a typical servlet-based example, a DataSource is looked up using InitialContext for database operations:

java

import javax.naming.Context; import javax.naming.InitialContext; import javax.sql.DataSource; import java.sql.Connection; import java.sql.SQLException; // Lookup the DataSource Context ctx = new InitialContext(); DataSource ds = (DataSource) ctx.lookup("java:comp/env/jdbc/MyDB"); // Obtain a connection Connection con = null; try { con = ds.getConnection("username", "password"); // Perform database queries here, e.g., PreparedStatement execution } catch (SQLException e) { // Handle exception } finally { if (con != null) { try { con.close(); // Returns connection to pool } catch (SQLException e) { // Handle close exception } } }

import javax.naming.Context; import javax.naming.InitialContext; import javax.sql.DataSource; import java.sql.Connection; import java.sql.SQLException; // Lookup the DataSource Context ctx = new InitialContext(); DataSource ds = (DataSource) ctx.lookup("java:comp/env/jdbc/MyDB"); // Obtain a connection Connection con = null; try { con = ds.getConnection("username", "password"); // Perform database queries here, e.g., PreparedStatement execution } catch (SQLException e) { // Handle exception } finally { if (con != null) { try { con.close(); // Returns connection to pool } catch (SQLException e) { // Handle close exception } } }

This ensures connections are efficiently managed and returned to the pool upon closure.

Implementations in Other Languages

In the .NET ecosystem, , introduced in 2002 with the .NET Framework 1.0, provides DataSource-like functionality through classes such as SqlConnection and DbProviderFactory for managing pooled database connections. SqlConnection enables efficient access to SQL Server or data sources by reusing connections via connection strings, which specify parameters like server name, database, and pooling options such as Min Pool Size and Max Pool Size to optimize resource usage and reduce overhead from frequent connection establishment. DbProviderFactory, part of the System.Data.Common namespace, implements a to instantiate provider-specific connection objects dynamically, promoting portability across different database providers without hardcoding implementation details. In Python, the DB-API specification (PEP 249), finalized in 1999, defines a standard interface for database access, with connection pooling commonly implemented through libraries like SQLAlchemy, first released in 2006. SQLAlchemy's object serves as a DataSource equivalent, creating and managing a pool of connections to databases such as , where it handles creation, validation, and recycling of connections to maintain performance in multi-threaded or web applications. For specifically, the psycopg2 adapter (compliant with DB-API) includes built-in pooling classes like ThreadedConnectionPool, which pre-allocate a fixed number of connections for efficient reuse and minimize latency in high-concurrency scenarios. PHP's PHP Data Objects (PDO), introduced in 2005 with 5.1.0, offers a DataSource-style using Data Source Names (DSN) to specify connection details for various drivers, including , , and , allowing a single interface for multiple backend databases. PDO connections are established via the constructor with a DSN string (e.g., "mysql:host=;dbname=test"), and pooling is achieved through persistent connections enabled by the PDO::ATTR_PERSISTENT option or extensions like Swoole for advanced, coroutine-based pooling in asynchronous environments, which cache connections across script executions to avoid repeated handshakes. Across these languages, common patterns emphasize factory-based creation of connection objects and external configuration for portability; for instance, .NET applications often use appsettings. files to store connection strings, enabling environment-specific adjustments without code changes. A notable cross-language trend is the integration of Object-Relational Mapping (ORM) tools that embed DataSource logic, such as in .NET (released in 2008), which abstracts connection management within its DbContext for simplified querying and reduces boilerplate for pooled access compared to raw . Similar ORM approaches in Python (via SQLAlchemy) and (e.g., ) follow this pattern, prioritizing developer productivity while leveraging underlying pooling mechanisms.

In Client-Side Development

Yahoo YUI DataSource

The Yahoo YUI DataSource utility, introduced as part of the Yahoo! User Interface (YUI) Library version 2.x in February 2006, served as a class designed to fetch, cache, and manage data from various sources in client-side AJAX applications. It provided a unified interface for handling tabular data, enabling widgets like DataTable and to interact with local or remote data sources without requiring full page reloads. YUI DataSource supported several core subclasses tailored to different data origins: LocalDataSource for in-memory structures such as arrays, object literals, XML documents, or tables; XHRDataSource for making asynchronous HTTP requests to server-side endpoints; and ScriptNodeDataSource (introduced in YUI 2.6.0) for cross-domain data retrieval via using dynamic script nodes. Each type inherited from the base DataSource class and included methods like sendRequest(), which initiated data retrieval by passing a request object and a callback configuration, and doBeforeParseFn(), a customizable function for preprocessing raw responses before schema-based parsing. The architecture emphasized asynchronous operation, where data requests were queued, cached locally (with configurable maxCacheEntries to limit size), and processed through a response schema defined via the responseSchema property to extract fields, results, and metadata from formats like , XML, or text. This parsing integrated seamlessly with YUI components, such as populating a DataTable widget by passing the parsed results array directly to its rendering pipeline, while custom events like requestEvent and responseParseEvent allowed developers to into the data flow for modifications. Periodic polling was also supported via setInterval() for real-time updates from remote sources. In early web applications around 2006–2010, DataSource was commonly used to load dynamic content, such as populating UI grids or dropdowns from server APIs in single-page interfaces, addressing the limitations of synchronous scripting in browsers like and 1.5. For instance, developers could instantiate a XHRDataSource to query a endpoint and feed the results into a sortable DataTable without disrupting user interactions. YUI DataSource received its last major update in version 2.9.0, released on April 13, 2011, after which YUI 2 entered deprecation in 2011 as Yahoo shifted focus to YUI 3 and modern JavaScript standards; the library was fully archived by 2014 with no further maintenance.

Evolution in Modern Frameworks

Following the decline of older utilities like Yahoo's YUI DataSource, modern data sourcing evolved through native browser APIs that simplified asynchronous operations. The API, once the standard for network requests since the early 2000s, was largely supplanted by the Fetch API introduced in 2015 (ES6), which provides a cleaner, promise-based interface for fetching resources across the network. This shift was complemented by the native adoption of in ES6, enabling more readable handling of asynchronous data flows without callback hell. In popular frameworks, these native capabilities integrated deeply with component lifecycles and . React, starting with version 16.8 in 2019, introduced hooks like useEffect to manage side effects such as calls, allowing functional components to fetch and synchronize data declaratively. Similarly, Angular's HttpClient module, released in version 4.3 in 2017, offers typed HTTP requests with built-in support for interceptors to handle authentication, logging, and error transformation in a reactive, Observable-based manner. Advanced state management libraries further refined DataSource patterns for complex applications. Redux, launched in June 2015, centralizes data fetching and updates in a predictable store, often paired with middleware like Redux Thunk or for async actions. For GraphQL-specific datasources, Apollo Client, released in 2016, provides normalized caching, automatic query optimization, and real-time subscriptions via WebSockets, reducing over-fetching compared to RESTful approaches. Emerging trends emphasize serverless and real-time datasources with seamless offline capabilities. AWS Amplify, introduced in November 2017, abstracts backend services like authentication and APIs into client-side SDKs, supporting real-time data syncing across devices. , launched in April 2012 and later acquired by , offers a realtime database with offline persistence and push notifications, enabling progressive web apps to function without constant connectivity. More recent developments as of 2025 include specialized data-fetching libraries like TanStack Query (initially released as React Query in 2019), which enhances React applications with features like automatic refetching, pagination, and infinite queries, integrating seamlessly with server-side rendering in frameworks like . Additionally, the introduction of React Server Components in React 18 (March 2022) has shifted some data fetching to the server, reducing client-side bundle sizes and improving performance for data-intensive applications. These modern implementations surpass earlier tools like YUI in error handling through structured promise rejections and try-catch integration, native typings for type-safe data flows, and modular designs that avoid monolithic library dependencies.

Broader Applications

In Enterprise Integration

In enterprise integration, DataSources play a pivotal in Enterprise Service Buses (ESBs) by providing standardized connection management to databases within integration flows that connect disparate systems. For instance, MuleSoft's ESB, introduced in 2006, utilizes DataSources through its Database Connector to enable JDBC-based operations in flows that integrate with JMS queues for asynchronous messaging, file polling for monitoring directories, and endpoints for interactions. Similarly, Apache Camel's SQL component, part of the framework released in 2007, relies on injected DataSources to execute database queries in patterns that combine with JMS for message queuing and file polling for event-driven processing. These mechanisms allow ESBs to treat databases as reliable data origins, facilitating seamless data exchange across heterogeneous environments without direct application-level coding. The Java Connector Architecture (JCA), standardized as JSR-16 in 2001, further embeds DataSources in enterprise integration by defining resource adapters that expose connection factories to Enterprise Information Systems (EIS). These adapters, provided by EIS vendors, implement JCA contracts for resource pooling, transaction management, and , allowing application servers to integrate with non-relational or legacy systems like ERPs or mainframes. In practice, JCA resource adapters often leverage DataSource-like interfaces for JDBC-compliant EIS, enabling uniform connectivity where the adapter handles outbound calls from applications to external resources. This architecture ensures that DataSources are managed at the container level, supporting distributed scenarios beyond simple database access. Configuration of DataSources in enterprise integration typically involves XML-based deployment descriptors that define pooling parameters, transaction boundaries, and XA compliance for distributed operations. In , for example, XA DataSources are configured in standalone.xml with elements specifying JNDI names, driver classes, and pool sizes, enabling connection sharing across integrated components. similarly uses XML files under the resources.xml scope to set up JDBC providers and DataSources with attributes for validation timeouts and statement caching, ensuring efficient handling of transactions in clustered environments. These descriptors support XA-compliant sources, which integrate with the for coordinating commits across multiple resources, akin to JDBC connection pooling but extended for EIS interactions. Key use cases for DataSources in enterprise integration include (ETL) processes that link databases to messaging systems, where data is pulled via a pooled DataSource, transformed in the ESB, and pushed to JMS queues or other endpoints. This setup ensures data consistency in scenarios like order processing, where updates span multiple systems, by leveraging two-phase commit protocols in XA transactions to achieve atomicity—preparing all resources before a final commit or . For example, an ESB might use a DataSource to extract transaction records from a database, apply business rules, and load them into a compliance reporting system via integrated channels, maintaining across the flow. Security aspects of DataSources in enterprise integration emphasize (RBAC) and to protect cross-system data flows. Java EE containers enforce RBAC through security realms, where DataSource connections are bound to user roles defined in deployment descriptors, restricting access to authorized principals only. is implemented by masking passwords in XML configurations and using SSL/TLS for transport, as seen in JBoss where vaulted credentials prevent exposure of sensitive connection details. These measures, combined with JCA's security contract, mitigate risks in integrated environments by authenticating connections and auditing access during EIS interactions.

In Data Analytics and BI

In data analytics and (BI), the Java DataSource interface facilitates efficient database connections for Java-based BI tools and ETL processes, enabling scalable extraction and processing from relational . Java-based platforms like and utilize DataSources to manage JDBC connections, supporting features such as connection pooling and distributed transactions for handling large datasets in reporting and visualization workflows. A key aspect involves the (ETL) process, where DataSources provide pooled connections to extract data from databases, transform it for consistency, and load it into data warehouses for analysis. ETL can account for up to 80% of the effort in BI projects, making efficient connection management via DataSources essential for performance. For instance, in environments using EE, DataSources integrate with tools like or custom applications to connect to SQL databases, Azure services, or other sources, allowing seamless data flow for creation and predictive modeling. Effective use of DataSources in BI emphasizes integration and to maintain . They support hybrid environments by combining internal database sources with external feeds through standardized JDBC access, enhancing and efficiency. Best practices include configuring connection validation and using JNDI lookups in application servers for managed access, as seen in frameworks prioritizing real-time processing for dynamic .

References

  1. https://learn.microsoft.com/en-us/sql/odbc/reference/data-sources?view=sql-server-ver17
  2. https://docs.oracle.com/cd/B14099_19/web.1012/b14012/datasrc.htm
  3. https://docs.spring.io/spring-framework/reference/data-access/jdbc/connections.html
  4. https://docs.oracle.com/middleware/1221/wls/JDBCA/jdbc_datasources.htm
  5. https://web.mit.edu/java_v1.5.0_22/distrib/share/docs/guide/jdbc/getstart/datasource.html
  6. https://docs.oracle.com/cd/E13222_01/wls/docs70/pdf/jdbc.pdf
  7. https://www.redbooks.ibm.com/redbooks/pdfs/sg246500.pdf
  8. https://docs.oracle.com/middleware/1212/wls/JDBCA/ds_security.htm
  9. https://www.ibm.com/docs/en/cognos-analytics/12.1.x?topic=security-data-sources-connections
  10. https://learn.microsoft.com/en-us/sql/odbc/reference/odbc-programmer-s-reference?view=sql-server-ver17
  11. https://www.techtarget.com/searchoracle/definition/Open-Database-Connectivity
  12. https://www.innoq.com/en/articles/2022/04/java-jndi/
  13. https://jotm.ow2.org/related/jdbc20.stdext.pdf
  14. https://jcp.org/en/jsr/detail?id=54
  15. https://www.sencha.com/blog/a-fond-farewell-to-yui/
  16. https://spring.io/blog/2014/04/01/spring-boot-1-0-ga-released
  17. https://docs.oracle.com/javase/8/docs/api/javax/sql/DataSource.html
  18. https://docs.oracle.com/javase/tutorial/jdbc/basics/sqldatasources.html
  19. https://docs.oracle.com/javase/8/docs/api/javax/sql/CommonDataSource.html
  20. https://docs.oracle.com/javase/8/docs/api/javax/sql/XADataSource.html
  21. https://github.com/brettwooldridge/HikariCP
  22. https://tomcat.apache.org/tomcat-9.0-doc/jndi-datasource-examples-howto.html
  23. https://learn.microsoft.com/en-us/dotnet/framework/data/adonet/sql-server-connection-pooling
  24. https://peps.python.org/pep-0249/
  25. https://docs.sqlalchemy.org/en/20/core/engines.html
  26. https://www.psycopg.org/docs/pool.html
  27. https://www.php.net/manual/en/intro.pdo.php
  28. https://learn.microsoft.com/en-us/ef/ef6/what-is-new/past-releases
  29. https://yahooeng.tumblr.com/post/96098168666/important-announcement-regarding-yui
  30. https://yui.github.io/yui2/docs/yui_2.9.0_full/datasource/index.html
  31. https://yuiblog.com/blog/2011/04/13/announcing-yui-2-9-0/
  32. https://yui.github.io/yui2/
  33. https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API
  34. https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise
  35. https://react.dev/reference/react/useEffect
  36. https://www.digitalocean.com/community/tutorials/angular-httpclient-intro
  37. https://redux.js.org/understanding/history-and-design/history-of-redux
  38. https://www.apollographql.com/blog/graphql-with-react-and-redux
  39. https://aws.amazon.com/blogs/mobile/announcing-aws-amplify-and-the-aws-mobile-cli/
  40. https://app.dealroom.co/companies/firebase
  41. https://tanstack.com/query/latest
  42. https://react.dev/blog/2022/03/29/react-v18
  43. https://dev.to/lukeskw/from-xmlhttprequest-to-fetch-api-how-fetch-became-the-way-forward-for-js-development-2a9b
  44. https://docs.mulesoft.com/db-connector/latest/
  45. https://camel.apache.org/components/4.14.x/sql-component.html
  46. https://jcp.org/en/jsr/detail?id=16
  47. https://docs.redhat.com/en/documentation/red_hat_jboss_enterprise_application_platform/7.2/html/configuration_guide/jca_management
  48. https://docs.redhat.com/en/documentation/red_hat_jboss_enterprise_application_platform/6.4/html/administration_and_configuration_guide/sect-xa_datasources
  49. https://www.ibm.com/docs/en/was-nd/9.0.5?topic=resources-jdbc-providers-data-sources
  50. https://docs.redhat.com/en/documentation/red_hat_jboss_enterprise_application_platform/7.4/html/configuration_guide/datasource_management
  51. https://www.integrate.io/blog/oracle-connectors/
  52. https://docs.oracle.com/middleware/1221/wls/JDBCA/ds_security.htm
  53. https://docs.redhat.com/en/documentation/jboss_enterprise_application_platform_common_criteria_certification/5/html/security_guide/encrypting_data_source_passwords
  54. https://www.ibm.com/docs/en/cics-ts/6.x?topic=server-java-ee-connector-architecture-jca
  55. https://dzone.com/articles/top-5-java-based-tools-for-business-intelligence
  56. https://www.academia.edu/11434594/ETL_and_its_impact_on_Business_Intelligence
  57. https://learn.microsoft.com/en-us/power-bi/connect-data/desktop-data-sources
  58. https://www.tableau.com/business-intelligence/what-is-business-intelligence
Add your contribution
Related Hubs
Contribute something
User Avatar
No comments yet.