US20130262510A1

US20130262510A1 - Query derived communication mechanism for communication between relational databases and object-based computing environments and systems

Info

Publication number: US20130262510A1
Application number: US13/612,145
Authority: US
Inventors: John J. Smith; Michael G. Coutts
Original assignee: Teradata Corp
Current assignee: Teradata Corp
Priority date: 2012-04-03
Filing date: 2012-09-12
Publication date: 2013-10-03
Also published as: US20130262408A1; US9558251B2

Abstract

Techniques for providing communication mechanisms between object-based and relational database systems are disclosed. A communication mechanism (e.g., a Web service) can be effectively derived from one or more query statements (e.g., SQL statements) based on a mapping to the objects of the object-based system. The communication mechanism can be generated in a Top-Down or Contract-First approach based on definitions and/or metadata needed to effectively construct the communication mechanism.

Description

CROSS REFERENCE TO RELATED APPLICATIONS

This application takes priority of the U.S. Provisional Patent Application No. 61,619,893, entitled “QUERY DERIVED WEB SERVICES,” by John J. Smith and Mike G. Coutts, filed on Sep. 26, 2011, which is hereby incorporated herein by reference in its entirety and for all purposes.

BACKGROUND

Data can be an abstract term. In the context of computing environments and systems, data can be generally encompassing of all forms of information that can be stored in a computer readable medium (e.g., memory, hard disk). Data, and in particular, one or more instances of data can also be referred to as data object(s), especially in the context of object-based approaches to computing, where a data object can, for example, be an actual instance of data, a class, type, or form data, and so on.
However, the term database can refer to a collection of data and/or data structures typically stored in a digital form. Data can be stored in a database for various reasons and to serve various entities or “users.” Generally, data stored in the database can be used by the database users. A user of a database can, for example, be a person, a database administrator, a computer application designed to interact with a database, etc. A very simple database or database system can, for example, be provided on a Personal Computer (PC) by storing data on a Hard Disk (e.g., contact information) and executing a computer program that allows access to the data. The executable computer program can be referred to as a database program or a database management program. The executable computer program can, for example, retrieve and display data (e.g., a list of names with their phone numbers) based on a request submitted by a person (e.g., show me the phone numbers of all my friends in Ohio).
Generally, database systems are much more complex than the example noted above. In addition, databases have been evolved over the years and are used in various business and organizations (e.g., banks, retail stores, governmental agencies, universities). Today, databases can be very complex. Some databases can support several users simultaneously and allow then to make very complex queries (e.g., give me the names of all customers under the age of thirty five (35) in Ohio that have bought all the items in a given list of items in the past month and also have bought a ticket for a baseball game and purchased a baseball hat in the past 10 years).
Typically, a Database Manager (DM) or a Database Management System (DBMS) is provided for relatively large and/or complex databases. As known in the art, a DBMS can effectively manage the database or data stored in a database, and serve as an interface for the users of the database. A DBMS can be provided as an executable computer program (or software) product as is also known in the art.
It should also be noted that a database can be organized in accordance with a Data Model. Notable Data Models include a Relational Model, an Entity-relationship model, and an Object Model. The design and maintenance of a complex database can require highly specialized knowledge and skills by database application programmers, DBMS developers/programmers, database administrators (DBAs), etc. To assist in design and maintenance of a complex database, various tools can be provided, either as part of the DBMS or as free-standing (stand-alone) software products. These tools can include specialized Database languages (e.g., Data Description Languages, Data Manipulation Languages, Query Languages). Database languages can be specific to one data model or to one DBMS type. One widely supported language is Structured Query Language (SQL) developed, by in large, for Relational Model and can combine the roles of Data Description Language, Data Manipulation language, and a Query Language.
Today, databases have become prevalent in virtually all aspects of business and personal life. Moreover, database use is likely to continue to grow even more rapidly and widely across all aspects of commerce. Generally, databases and DBMS that manage them can be very large and extremely complex partly in order to support an ever increasing need to store data and analyze data. Typically, larger databases are used by larger organizations. Larger databases are supported by a relatively large amount of capacity, including computing capacity (e.g., processor and memory) to allow them to perform many tasks and/or complex tasks effectively at the same time (or in parallel). On the other hand, smaller databases systems are also available today and can be used by smaller organizations. In contrast to larger databases, smaller databases can operate with less capacity.
A popular type of database in use today is the relational database with a Relational Database Management System (RDBMS), which includes relational tables, also referred to as relations, made up of rows and columns (also referred to as tuples and attributes). In a relational database, each row represents an occurrence of an entity defined by a table, with an entity being a person, place, thing, or other object about which the table contains information.
Another important aspect of modern computing environments is the object-based approach which includes Object Oriented Programming (OOP) as is widely known in the art. OOP is preferred over more conventional approaches to programming.
In view of the ever increasing need for relational databases and object-based environments, communication mechanism that facilitate communication between object-based components (e.g., object-based application programs) and relational databases are very useful.

SUMMARY

Broadly speaking, the invention relates to computing environments and systems. More particularly, the invention relates to techniques for providing communication mechanisms between object-based and relational database systems.
In accordance with one aspect of the invention, a communication mechanism between object-based and database systems can be effectively derived from one or more query statements provided as input. The communication mechanism can, for example, be a Web service derived from one or more SQL statements provided as database requests from a relational database.
In accordance with another aspect of the invention, a communication mechanism between an object-based system and a relational database system can be generated in a Top-Down or Contract-First approach based on definitions and/or metadata also derived from one or more query statements. Generally, one or all of the components needed to effectively construct the communication mechanism can be directly or indirectly generated from one or more query statements. In doing so, one or more database components associated with the one or more database queries (e.g., database fields) can be effectively mapped to one or more object-based components (e.g., data types) of one or more object-based programming languages.
By way of example, in order to construct a SQL derived Web service for a relational database, a SQL mapping (or SQL map) can be generated based on one or more SQL statements provided as input. The SQL mapping can then be used to generate WSDL and XSD files as definitions and schema for the web server which can, in turn, be used to construct a skeleton for the implemented services (or server) as well as a proxy client. The SQL mapping can also be used to generate various other components that are needed to construct the Web service, including a Data Access Object (DAO) as an abstract interface to relational database, and database service class that can effectively connect the implemented Web services (server) to the DAO. The database service class can also facilitate the effective translation of schema objects and resultant objects (or result objects). It should also be noted that schema objects can be generated based on the XSD file(s) and the resultant objects can be generated based on the SQL map obtained by executing the one or more input SQL statements. It should be noted that configuration files (e.g., Spring configuration files) can also be generated and used to effectively connect various components of the Web service to the relational database.
Still other aspects, embodiment and advantages of the invention will become apparent from the following detailed description, taken in conjunction with the accompanying drawings, illustrating by way of example the principles of the invention.

BRIEF DESCRIPTION OF THE DRAWINGS

The present invention will be readily understood by the following detailed description in conjunction with the accompanying drawings, wherein like reference numerals designate like structural elements, and in which:

FIG. 1 depicts a computing environment with a relational-data to object-based communication-facilitator or object-based mapping generator (OBMG) 102 in accordance with one embodiment of the invention.

FIG. 2 depicts a query-derived service-based communication mechanism (or “service”) in accordance with one embodiment of the invention.

FIGS. 3A-3D depict a first wizard (SQL MAP wizard) that can act similar to a relational-data to object-based communication-facilitator (OBMG) in accordance with one or more embodiments of the invention.

FIGS. 4A-4H depict a second wizard (service wizard) that can effectively be used to generate various components needed to construct a Web service based on the SQL Map and Result Set Objects generated by the first wizard based on the SQL statements in accordance with one or more embodiments of the invention.

FIGS. 5A-5B depict computing environments with Web services provided by way of requests and responses using an implemented class (e.g. a SOAP implemented class) in accordance with embodiments of the invention.

FIG. 6A-6G depicts generating a Java Domain class and an iBatis XML mapping file based on one or more SQL statements in accordance with one or more embodiments of the invention.

FIGS. 7A-7I depict one or more enhanced iBatis (compatible) DAO Wizard(s) with Web service generation capabilities in accordance with one or more embodiments of the invention.

FIG. 8A depicts a method for at least facilitating generation of a communication mechanism for communicating with a relational database over a network by one or more object-based applications of one or more object-based programming languages in accordance with one embodiment of the invention.

FIG. 8B depicts a method for at least facilitating generation of a communication mechanism for communicating with a relational database over a network by one or more object-based applications of one or more object-based programming languages in accordance with one embodiment of the invention.

FIG. 9 depicts a method 900 for generating a query-based (or query derived) Web service (or services) as a communication mechanism between a database and application programs in an object-based programing language in accordance with one embodiment of the invention.

FIGS. 10A-10F depict screenshots of a User Interface (UI) that can be provided to facilitate generation of query driven of Web services in accordance with one or more embodiments of the invention.

FIGS. 11A-11M depict screenshots of a Wizard (iBatis SQL Map Wizard) that can be provided to generate a map (SQL map) for the SQL statements (shown in FIG. 10F) in accordance with embodiments of the invention.

FIGS. 12A-12G depict screenshots of another Wizard (iBatis DAO with Web services) that can be provided to generate Web services in accordance with one embodiment of the invention.

FIGS. 13A-13D depict an environment where a number of layers connected between a database and its Web services in accordance with one or more embodiments of the invention.

FIG. 14 depicts a “findCreditScore” Web service that can be provided in accordance with one embodiment of the invention.

DETAILED DESCRIPTION

As noted in the background section, communication mechanism that facilitate communication between object-based components (e.g., object-based application programs) and relational databases are very useful.
However, conventionally, bridging the gap between object-based computing environments and relational database requires an extensive knowledge often lacked even by Database Administrator (DBA's) with extensive knowledge of the specific database systems that they may administer and manage. Bridging this gap can also require a significant amount of time and resources. Typically, experts in object-based computing environments would have to be acquired who would have to painstakingly develop code by hand to implement, for example, a Web service as a communication mechanism between object-based clients and a relational database.
To further elaborate, a Relational Database Management Systems (RDBMS) can effectively provide for the storage and retrieval of Set-Based data through, for example, the use of Structured Query Language (SQL), whereas object-based applications, such as, Enterprise Applications are traditionally developed using an Object Oriented Programming (OOP) approach. This initially requires that a developer conduct Object to Relational Mapping (ORM) to effectively maps objects of an OOP to components of a database (e.g., database fields) in order to allow these two paradigms to effectively cooperate. Although a number of tools (e.g., iBatis, Hibernate) are available today to assist a developer with the task of Object Relational Mapping. By and large, these conventional tools are limited to the mapping of objects to database component. As a result, even using these tools, an export developer with the expertise in that particular object-based environment (e.g., an Enterprise Application developed in JAVA for using Web services) would still be needed to painstakingly develop code by hand to bridge the gap between a particular object-based environment and a relational database.
It should be noted that the gap between the object-based and relational systems can be even more difficult to bridge in some environments, including, for example, a Web service paradigm where there can be a need for an interoperable communications mechanism between two Enterprise Applications (or between a Client Application and an Enterprise Application), further distancing the Set Based RDBMS model (and its SQL focused developers) from the end-users in Enterprise systems who are to be provided with sets of data of the Set Based RDBMS model.
Furthermore, aside from the need for interoperability, there are still other important considerations, including an advocated approach for the development of Web services, which is generally known as Top-Down or Contract First approach, whereby a definition for the Web service (WSDL) is to be developed according to standard practices for Interoperability (WS-I), Security (WS-Security) etc. so. In other words, Web services are typically defined by a Web services Definition Language (WSDL) file (and associated XML Schema Definition or XSD files). Generally, WSDL can be an Interface Definition Language (IDL) that defines the request and response messages between systems that implement a Web service interface.
Furthermore, such considerations still place a greater burden on SQL-focused developers in that even to provide for a single Web service implementation of a simple SQL Select statement they would need to learn a new programming model and Object Oriented Programming and an associated programming language (e.g., Java, C++, C#). They must then define and implement the Web service itself, which would require learning another development paradigm, namely, Web services and its associated XML based language (WSDL/XSD).
Although development tools exist to assist with Top-Down or Contract first development of Web services (e.g., the Eclipse Web Tools Project, Web services Wizard, the Microsoft Visual Studio Web reference Wizard), these tools require knowledge of the Web services language of WSDL/XSD and its associated Object Oriented programming model. As such, these tools do little to assist the Set Based SQL developer who may lack knowledge of the Web services language of WSDL/XSD and its associated Object Oriented programming model.
In any case, the conventional process can be very time consuming and can also be very difficult to use even for developers with extensive knowledge of object-based and Web service systems. For example, even when the WSDL is generated correctly, the conventional tool creating the implementation of the Web service may not support all the available structures defined in the WSDL. Also, the convention tools used to create Web services may only create the code that handles the Request—a Response communication part of the service, leaving a stub from which the developer needs to create the actual implementation of the Response communication part of the service.
In view of the foregoing, improved techniques for generating communication mechanisms, especially Web services, between object-based and relational database systems are needed and would be very useful.
As such, it will be appreciated that a communication mechanism between object-based and database systems can be effectively derived from one or more query statements provided as input in accordance with one aspect of the invention. The communication mechanism can, for example, be a Web service derived from one or more SQL statements provided as database requests from a relational database.
It will also be appreciated that a communication mechanism between an object-based system and a relational database system can be generated in a Top-Down or Contract-First approach based on definitions and/or metadata also derived from one or more query statements in accordance with another aspect of the invention. Generally, one or all of the components needed to effectively construct the communication mechanism can be directly or indirectly generated from one or more query statements. In doing so, one or more database components associated with the one or more database queries (e.g., database fields) can be effectively mapped to one or more object-based components (e.g., data types) of one or more object-based programming languages.
By way of example, in order to construct a SQL derived Web service for a relational database, a SQL mapping (or SQL map) can be generated based on one or more SQL statements provided as input. The SQL mapping can then be used to generate WSDL and XSD files as definitions and schema for the web server which can, in turn, be used to construct a skeleton for the implemented services (or server) as well as a proxy client. The SQL mapping can also be used to generate various other components that are needed to construct the Web service, including a Data Access Object (DAO) as an abstract interface to relational database, and database service class that can effectively connect the implemented Web services (server) to the DAO. The database service class can also facilitate the effective translation of schema objects and resultant objects (or result objects). It should also be noted that schema objects can be generated based on the XSD file(s) and the resultant objects can be generated based on the SQL map obtained by executing the one or more input SQL statements. It should be noted that configuration files (e.g., Spring configuration files) can also be generated and used to effectively connect various components of the Web service to the relational database.
Embodiments of these aspects of the invention are also discussed below with reference to FIGS. 1-14D. However, those skilled in the art will readily appreciate that the detailed description given herein with respect to these figures is for explanatory purposes as the invention extends beyond these limited embodiments.
FIG. 1 depicts a computing environment 100 with a relational-data to object-based communication-facilitator or object-based mapping generator (OBMG) 102 in accordance with one embodiment of the invention. It will be appreciated that OBMG 102 can facilitate generation of a communication mechanism (e.g., Web services) 110 for communicating with a relational database, or a relational database system (hereinafter “database”) 101 over a network 103. Among other things, the communication mechanism 110 can be used by one or more object-based applications 108 which can be implemented in one or more object-based programming languages (e.g., Java, C++). It will be also appreciated that the communication mechanism can at least in part be an object-based communication mechanism with a number of object-based components provided, for example, in or as a part of an Integrated Development Environment (IDE) that, among other things, provides comprehensive facilities to computer programmers for software development with many of advantages as generally known in the art.
More specifically, referring to FIG. 1, the OBMG 102 can obtain (e.g., receive as input, determine, identify, select) one or more database requests or queries (hereinafter “queries” or “database queries”) 104. Typically, the queries 104 can be provided in a database query language (e.g., one or more SQL queries or statements) 104. It should be noted that the queries 104 can be provided to the database 101 in order to obtain, for example, a set of resultant values (e.g., all customers of a bank that have a credit score above 790). Typically, a database manager (not shown) of the database 101 receives a database query 104 in a database query language and executes it to determine and to output a set of resultant values in response to the query 104.
In the computing environment 100, the OBMG 102 can also receive one or more database queries 104 (i.e., one or more queries that can be executed by the database 101). Moreover, the OBMG 102 can generate, at least partly based on the one or more database queries 104, relational-query-to-object data 106. It will be appreciated that the relational-query-to-object data 106 can facilitate generation of the communication mechanism 110 between one or more object-based applications 108 and the database 101 to effectively bridge the gap between their respective relational and object-based systems.
In doing so, the relational-query-to-object data 106 can at least associate one or more database components (e.g., database fields) associated with the one or more database queries 104 to one or more object-based components (e.g., programing objects or objects, data types) of one or more object-based programming languages, thereby allowing the communication mechanism 110 to be generated at least partly based on the relational-query-to-object data to allow the object-based application(s) 108 provided in one or more object-based programming languages to communicate via the communication mechanism 110 with the relational database 101 over the network 103.
It should be noted that the relational-query-to-object data 106 can be generated based on the database queries 104 as opposed to generating them based on actual database tables (i.e., complete tables) in accordance with one aspect of the invention. As such, the communication mechanism 110 can be effectively generated based on the queries 104, or data relevant to the queries 104, as opposed to being generated directly based on the entire data in the tables of the database. As a result, the communication mechanism 110 can be more effectively tailored to a desired communication mechanism expressed as queries 104 (e.g., specific Web services desired to service specific requests for information). In addition, it will be appreciated that the communication mechanism 110 can remain relevant despite any changes to data in the data tables of the database 101. Furthermore, the communication mechanism 110 can be changed, modified or altered to the extent desired by simply changing, modifying or altering the database queries 104.
By way of example, the relational-query-to-object data 106 can include a relational to object mapping of one or more database fields associated with the queries 104 to one or more objects and data types of an object oriented programing language. Those skilled in the art will appreciate that the relational to object mapping can effectively serve as an Object to Relational Mapping (ORM) but would be generated based on database queries 104, by executing the database queries 104. In addition to the relational to object mapping, the relational-query-to-object data 106 can also include one or more of the objects of the object oriented programing language that are constructed based on the results (resultant values) obtained from the execution of the one or more database queries 104.
As noted above, the relational-query-to-object data 106 can facilitate generation of the communication mechanism 110. More particularly, referring to FIG. 1 depicts a communication component generator (CCG) 120 that can facilitate generation of the communication mechanism 110 in accordance with one embodiment of the invention. Based on the relational-query-to-object data 106, the CCG 120 can effectively generate one or more communication components 122 needed for building or constructing the communication mechanism 110. It should be noted that the communication components 122 can include one or more components that can be directly used with or without any modifications (final components) to construct the communication mechanism 110, as well as one or more components (or intermediate components) that are needed to construct the components of the communication mechanism 110.
By way of example, a relational to object mapping provided in the relational-query-to-object data 106 can be used by the CCG 120 to generate service definitions, schema, meta-data and/or verification data as one or more intermediate components needed to ultimately generate and provide an object-based server-side as a part of an object-based communication service (e.g., a server-side of a Web service) represented in FIG. 1 as communication mechanism 110. In the example, the relational to object mapping provided in the relational-query-to-object data 106 can also be used by the CCG 120 to generate an abstract interface (e.g., Data Access Object (DAO)) for accessing to the database 101, including some operations that can be performed on the database 101 without exposing the details of the database 101. For example, those skilled in the art will appreciate that a Data Access Object (DAO) can be generated as an abstract interface for accessing the database 101 based on the relational-query-to-object data 106 derived from the one or more database queries 104. For example, a DAO can be generated for the database 101 in connection with a Java-based database access technology, namely, Java Database Connectivity (JDBC) as one of the components needed to effectively build a communication service (e.g., a Web service that includes a server side and client side). Other examples of the components needed to build the communication mechanism 110 between the database 101 and one or more object-based applications 108 (e.g., client or client-side application of a Web service) include configuration files (e.g., Spring configuration files) that can be used to effectively connect, configure, set and/or tailor communication mechanism 110 to a particular database 101 or in accordance with specific needs or desired with respect to a database 101. The relational-query-to-object data 106 and the communication components 122 are discussed in greater detail below.
However, referring now back to FIG. 1, it should be noted that the computing environment 100 can additionally include a communication mechanism constructor or builder (CMB) 130 in accordance with one embodiment of the invention. The communication components 122 can use the communication components 122 to build the communication mechanism 101. Conceptually, the CMB 130 can build or generate the communication mechanism 101 by piecing, assembling, fitting or putting together the communication components 122.
Although OBMG 102, CCG 120 and CMB 130 are depicted as separate components, it should be noted that one or more of them can be combined. It will readily be appreciated that each one of the OBMG 102, CCG 120 and CMB 130 can, for example, be provided as one or more hardware and/or software components. By way of example, the OBMG 102 can be provided by or as a part of a computing system that uses one or more processors to execute executable computer code for the OBMG 102 stored in computer readable media (e.g., stored in RAM for execution and stored in a hard drive). As another example, one or all of the components OBMG 102, CCG 120 and CMB 130 can be provided by or in connection with a Wizard that would facilitate generation of the communication mechanism 110 based on the one or more database queries 104. In other words, a user (e.g., a person, database administrate) can interact with a wizard to build the communication mechanism 110 as a query-driven communication mechanism based on one or more database queries 104 entered as input.
Given the prevalence of communication mechanisms in the form of one or more services, connecting a relational database with object-based applications with a service-based communication mechanism is discussed in greater detail below with respect with other exemplary embodiments of the invention.
To further elaborate, FIG. 2 depicts a query-derived service-based communication mechanism (or “service”) in accordance with one embodiment of the invention. Referring to FIG. 2, one or more database queries 104 are provided as input to OBMG 102. Based on the database queries 104, the OBMG 102 can generate as a part of the relational-query-to-object data 106, a relational/query to object map (or map) 106A and one or more resulting objects 106B which can be constructed based on the results (or result sets) of the execution of the database queries 104. In other words, the map 106A can be used to construct an object with data types that map to the data fields associated with the database queries 104. In addition, the database queries 104 can be executed and the results can be stored for the data types of the constructed object. Conceptually, the database query can be represented horizontally with a number of its associated fields (e.g., customer name, credit score) to denote a relational nature, similar to a column of a table in a database (or database table), while the mapped object can be represented vertically with it data types (e.g., integer, string) to partly represent the intended or desired top-down design of an integration development environment for object-based programming. By way of example, the map 106A can be provided as a document in an extendable markup language (e.g., XML) and the resulting objects can be Java-based objects provided in a Java IDE as those skilled in the art will appreciate.
In any case, the CCG 120 can use the relational/query to object map 106A to generate a number of service components 122, including, service definitions 122A1 (e.g., WSDL for a Web service) and schema, metadata and/or verification data 122A2 (e.g., Schema definitions, a XSD file provided for service definitions of a WSDL file) for the service which can be used by the CCG 120 or another component (not shown) to generate a server-side 12213 for the service (e.g., skeletons for a server-side component or a server based on a WSDL and XSD).
As those skilled in the art will readily appreciate, service definitions 122A1 (e.g., WSDL for a Web service) and schema, metadata and/or verification data 122A2 (e.g., XSD) can be important parts of an object-based service (hereinafter “service”) since the service can be generated at least partly based on them. As such, the service definitions 122A1 can, in turn, be used by the CCG 120 or another component (not shown) to generate a shell or skeleton for a server-side object-based service component, namely, a server shell 124. Similarly, schema, metadata and/or verification data 122A2 (e.g., Schema definitions or XSD) can, in turn, be used by the CCG 120 or another component (not shown) to generate abstract/schema (or metadata) objects (e.g., schema objects) 126 that can be used by the client-side of the service (or client applications) and the server-side of the service (or server) as will also be appreciated by those skilled in the art.
As noted above, the CCG 120 can generate, at least partly based on the map 106A, an interface 107 (e.g., Data Access Object (DAO)) for accessing to the database 101, including some operations that can be performed on the database 101 without exposing the details of the database 101. The interface is depicted as the interface 127 in FIG. 2. In addition, the CCG 120 can generate, at least partly based on the map 106A, one or more database service classes 128, configuration data 131, at least a shell or a proxy for a client application 132 as other components needed to construct the service represented as the implemented service 140 in FIG. 2.
Referring to FIG. 2, the implemented service 140 can be effectively constructed by the CMB 130 based on the components generated by the CCG 120. As suggested by FIG. 2, as a part of the implemented service 140, the interface 127 can use a database connection mechanism (e.g., JDBC) 129 to facilitate access to the database 101. This access can be provided by an implemented database class 128 ^! that can be constructed based on the generated database service class 128 and abstract/schema objects 126 and resultant objects 106B. In effect, the implemented database class 128 ^! can wrap the interface 127 into the database service class 128. The configuration data 131 can be used by the CMB 130 to effectively configure and link the implemented service 140 to the database 101. In addition, the CMB 130 can also build an implemented server 124 ^! based on the server shell 124, for example, by filling it or setting it to access the generated interface 127. The implemented server 124 ^! can, for example, represent a set of implemented services in the form of request and response messages that are exchanged between the implemented server 124 ^! and an implemented client 132 ^! also constructed by the GMB 130. The implemented client 132 ^! can be constructed by the GMB 130 based on the generated proxy client 132. It should be noted that implemented client 132 ^! can be an object-based client application in an Object Oriented Programming (OOP) programming language but able to access the database 101 via the services provided by the implemented server 124 ^! by making requests and receiving responses. As such, the implemented client 132 ^! could effectively make a service request equivalent to the one or more queries 104 (e.g., find the names of all customers with a credit score above 790) and receive in response the resultant set (e.g., list of the names all customers who have a credit score above 790) in a form acceptable to an object-based application and in accordance with an object-based paradigm with its many advantages.
As noted above, one or more wizards can be provided to allow construction of a communication mechanism between a database and one or more object-based application of an OOP language in accordance to one or more embodiments of the invention. To elaborate even further, a simplified example is discussed in the context of Web services provided in a Java programming environment to access a database system, for example, a Teradata compliant database system that is currently available from the Teradata Corporation, in Dayton, Ohio.
Referring to FIG. 3A, a first wizard (or SQL MAP wizard) 302 can act similar to a relational-data to object-based communication-facilitator (OBMG) 102 (depicted in FIG. 1). Specifically, in the example depicted in FIG. 3, as a SQL Map wizard, the first wizard 302 can be generate Result Set Objects 304 for an object-based programing language (e.g., Java) and also generate a SQL MAP 306 in an extensible markup language (e.g., XML). The Result Set Objects 304 can be Domain Objects that are obtained based on the mapping of set of SQL Queries 301 received as input by the first wizard 302. Specifically, the Result Set Objects 304 can be obtained based on the results of the execution of the SQL Queries 301.
To illustrate, FIG. 3B depicts a screenshot of a wizard in accordance with one embodiment of the invention. Referring to FIG. 3B, SQL statements 300, corresponding to a query about customers with of a particular credit score, can be entered as input using an editor.
Referring now to FIG. 3C, the first wizard 302 (shown in FIG. 3A) can then generate a sample SQL map 320 corresponding to the SQL statements 300 (depicted in FIG. 3B).
FIG. 3D depicts, the Result Set Objects 304 (or Domain objects) that corresponds to the SQL statements 300 (depicted in FIG. 3B). It should be noted that the SQL map 320 (shown in FIG. 3C) can be in line with an Object to Relational Model (ORM) provided by an ORM tool (e.g., iBatis). As such, SQL map 320 can, for example, be provided as an iBatis compliant ORM file in XML.
Referring now to FIG. 4A, a second wizard (service wizard) 302 can effectively be used to generate various components needed to construct a Web service based on the SQL Map 306 and Result Set Objects 304 generated by the first wizard 302 (shown in FIG. 3A) based on the SQL statements 300. These components include DAO 404, representing an abstract interface for accessing data in a database, as well as WSDL and XSD file(s) 406 that can be provided as service definitions and schema data as will be appreciated by those skilled in the art.
FIG. 4B depicts an example of WSDL and XSD file 406 corresponding to the SQL statements 300 (depicted in FIG. 3B) that can effectively be generated by the wizard 402 and made available for viewing and editing.
Similarly, FIG. 4C depicts an example of DAO 404 generated based on the SQL statements 300 (depicted in FIG. 3B) that can effectively made available for viewing and editing by the wizard 402.
Referring back to FIG. 4A, those skilled in the art will readily appreciate that the XSD file 406 can be used by the wizard (or service wizard) 402 to generate schema objects 407 in accordance with one embodiment of the invention. FIG. 4F depicts an example of the schema objects 407 that can be used by server-side and a client-side (client) of a Web service in accordance with one embodiment of the invention.
Referring to FIG. 4A, it should be noted that the WSDL and XSD file 406 can also be used by the wizard 402 to generate a server skeleton 408 that can be viewed and edited in accordance with one embodiment of the invention. In particular, wizard 402 can allow a user to edit a generated server skeleton so that it can access a generated DAO 404 using a generated database class 410. As a result, wizard 402 can allow an implemented server to be effectively generated by merely editing a server skeleton to refer to a database service class also generated by the wizrard.
FIG. 4D depicts an example of an implemented server that can be obtained by editing a server skeleton so that it can access a generated DAD 404 using a generated database service class 410 in accordance with one embodiment of the invention. It should be noted that a server skeleton 408 can be effectively edited using the wizard 402 to construct an implemented web server as a SOAP implementation class, as shown in the example of FIG. 4D.
FIG. 4E depicts an example of a database service class 410 that can be generated and made available for viewing and editing by the wizard 402 in accordance with one embodiment of the invention. More particularly, as the example in FIG. 4E shows, a DAD 404 can effectively be wrapped into a database service class. Those skilled in the art will also appreciate that database service class 410 can call the DAO 404, for example, using a database Session Manager. In addition, database service class 410 can convert schema classes associated with schema objects 407 to the Result Set Objects 304 and vice versa, as well as providing static access methods to retrieve the database service(s) from an application context.
Referring back to FIG. 4A again, the WSDL and XSD file 406 can also be used by the wizard 402 to also generate a client proxy 412 which can be viewed and edited by using the wizard 402 in order to generate a client for a Web service. FIG. 4G depicts a test client as an example of a client for a Web service that can be generated using the wizard 402 in accordance with one embodiment of the invention.
As show in FIG. 4A, the wizard 402 can also generate configuration file(s) 414. It should be noted that the configuration file(s) 414 can be used to effectively connect or link the various component needed to construct Web services together and ultimately to a relational database. FIG. 4H depicts a Spring configuration file as an example of a configuration file that can be generated and used by the wizard 402 to effectively provide Web services that are derived from one or more database queries as those skilled in the art will appreciate.
To further elaborate, FIG. 5A depicts a computing environment 500 with Web services provided by way of requests and responses using an implemented class 501 (e.g. a SOAP implemented class) in accordance with one embodiment of the invention. FIG. 5A shows how a number of components that can, for example, be generated by wizard 402 (Shown in FIG. 4A), can conceptually be pieced together to connect a query-derived Web service for a relational database system. Referring to FIG. 5A, a client 502 can effectively use the implemented class 501 via a database service class (database class) 504 to access a DAO 506, and in turn, a relational database system 508. As shown in FIG. 5A, the database service class 504 can facilitate conversion of schema objects 407 to result set objects 304 and vice versa. In addition, a database connection layer 510 that effectively connect the DAO 506 with the database system 508 and provide additional functionality.
FIG. 5B depicts in greater detail an example of a database connection layer 508 in accordance with one embodiment of the invention. Referring to FIG. 5B, those skilled in the art will readily appreciate that the connection layer 508 can, for example, include a Java Database connection (JDBC), database tools (DTP) and an Eclipse component. The database tools (DTP) among other things, can facilitate editing, searching and various other operations that can be provided by one or more wizards (e.g., wizards 302 and 402). JDBC and an Eclipse component of the connection layer 508 can facilitate establishing a connection to the database system 508 (shown in FIG. 5A) and providing Web services, as it will readily be appreciated by those skilled in the art.
To elaborate even further, FIG. 6A depicts a process of generating a Java Domain class 602 and an iBatis XML mapping file 604 based on one or more SQL statements 601 in accordance with one embodiment of the invention. It should be noted that the Java Domain class 602 is an example of the result set objects 304 (shown in FIG. 3A) and the iBatis (or iBatis compliant or compatible) XML mapping file 604 is an example of a SQL map 306 (also shown in FIG. 3A). SQL statements 601 are also shown as SQL queries 301 in FIG. 3A.
Referring to FIG. 6A, a number of actions that can be presented in the SQL statements 601 are shown as iBatis actions 610. It will be appreciated that a subset of the iBatis actions 610 (e.g., select, procedure) when present in the SQL statements 601 can be processed by a Create ResultMap process 612 to create a result map and thereby the Java Domain Class 602, partly by executing the SQL statements 601. In addition, virtually all of the iBatis actions 610 present in the SQL statements 601 can be processed, for example, by a Create iBatis SQL Mapping process 614 to create the iBatis XML mapping file 604.
More specifically, in the example, a SQL statement processed by the Create SQL Mapping process 614 of an iBatis SQL Map Wizard can use a JDBC “CallableStatement.getParametadata( )” to get an instance of the “Parametadata” class. This would allow the Wizard to get information about the parameters defined in the SQL statement using a parameter substitution (“?”). The “Parameterdata” class can retrieve the fully-qualified name of the Java class used to map to the “parameterClass” in the iBatis SQL Map. Also, the “Parameterdata” class can retrieve the parameter mode for defining parameters to be “IN” or “OUT” types for a procedure which is mapped in the iBatis Map. In the Create SQL Mapping process 614, an additional processing for mapping the parameters can, for example, include casting distinct UDT parameters to the original UDT type, creating mapping for a specific database type (e.g., a Period Data type defined for a particular database) and mapping custom types Defined By Users using an iBatis Custom Data Type Wizard. After Parameter metadata information is retrieved from JDBC, it can then be effectively wrapped in a “JavaBeanMember” class and used to create the parameter mapping for iBatis XML Mapping file 604.
FIG. 6B depicts a create parameter method that can be used an iBatis XML descriptor in accordance with one embodiment of the invention.
Referring to FIGS. 6C and 6D, Custom Java Types for the iBatis Map can be retrieved through a method “IBatisUtils.getJavaType( )” that uses a properties table defined by the iBatis Custom Data Wizard and a HashMap defined for Custom database types for a specific database, namely a Teradata database.
Referring back to FIG. 6A, the Create result map process 612 can effectively use JDBC to generate the Java Domain class (or object or object class) 602 that represent an example of the Result Set Objects 304 (shown in FIG. 3A). More specifically, in the example, the SQL statement(s) 601 can be processed, by the Create result map process 612 of a iBatis SQL Map Wizard, by using a JDBC method “ResultSet.getMetadata( )” to get “ResultSetMetada.” This allows the Wizard to get information about the result set objects being returned from the JDBC when the SQL statement(s) 601 is/are executed (or one or more database queries are run by the database). The Metadata can return the Column names, SQL types and Java Types, which are typically needed to create the “resultMap” in the iBatis Mapping of the iBatis XML Mapping file 604. The Wizard can also use the same information to create the Domain Object(s) mapped from the iBatis resultMap. Additional processing in the Create result map process 612 can, for example, include creating mappings for database specific Data types (e.g., a Period Data type defined for a particular database) as those skilled in the art will readily appreciate.
As shown in FIG. 6E, the “ResultSetMetadata” information can be mapped to a “TeradataResultMetadata” that can then be converted into an iBatis ResultSetMap in accordance with one embodiment of the invention. In particular, a method “iBatisUtils.getTeradataTypes” can convert a resultMap to use both Teradata custom types from the “customTeradataTypes HashMap” and user defined Custom type properties table defined from the “iBatis CustomMap.” FIG. 6F depicts “customTeradataTypes HashMap” in accordance with one embodiment of the invention.
FIG. 6G depicts an iBatis XML mapping file with a parameter mapping in connection with a “Select” SQL statement in accordance with one embodiment of the invention. Referring to FIG. 6G, a “define object mapping” portion of the XML mapping file can be used to generate the corresponding Java Domain Object.
To further elaborate, FIG. 7A depicts an enhanced iBatis (compatible) DAO Wizard 700 with Web service generation capabilities in accordance with one embodiment of the invention. Referring to FIG. 7A, Wizard 700 can generate various components suitable for construction of a Web service. In particular, the Wizard 700 can use an iBatis XML mapping 604 (shown in FIG. 6A) to generate a DAO, WSDL (Web service Definition Language), a Teradata service as a database service class, a Top-Down Web service with a Server Skeleton, and Spring Configuration files.
As an iBatis Web service Wizard, the Wizard 700 can parse the iBatis XML mapping file 604 with a “ParselBatisDecriptor” class. This class can load virtually all of the iBatis Mappings, including the Parameter Mappings, SQL Actions and ResultMaps from the iBatis XML mapping file 604. This information can be used to create the DAO class as a Data Access Object class. Those skilled in the art will readily appreciate that the generated DAO class can call the iBatis Map with a Java iBatis API and the parsed XML can provide virtually all the information needed to create the Class including iBatis SQL Actions, Parameter Mappings and Result Maps.
FIGS. 7B, 7C and 7D respectively show exemplary code for a Parameter Map, a Result Map, and SQL Action in accordance with one embodiment of the invention.
It should be noted that virtually the same information can be used to also create a Web service Definition Language (WSDL) file as an Interface Definition Language (IDL) that defines the request and response messages between systems that implement a Web services interface. In this case, the WSDL file can be used to create a Top-Down Web service. In doing so, the SQL data types, that were extracted from the iBatis XML mapping file 604 by a parser, can be mapped into the WSDL as the corresponding XSD (XML Schema Definition) types. These types can be mapped from the “xsdMap HashMap” Table (shown in FIG. 7E) in the “GenerateIBatisSpringDAO” class.
Those skilled in the art will readily appreciate that XSD types define the data types and can be used for the Response and Request messages for the Web service. Generally, user defined or custom data types need to be converted from the properties file created by the iBatis Custom Type Wizard to XSD data types.
FIG. 7F shows an exemplary method for converting SQL data types to XSD types in accordance with one embodiment of the invention. As a generator class, a “GenerateIBatisSpringDAO” class can also generate a “Teradata Service” which calls the DAO. This generator class can use the information from the parsed iBatis XML file to create the “Teradata Service.”
Data type conversions for types, specific to a Teradata database specific types (e.g., a Period Data Type) can be done through the “Teradata Service.” Referring to FIG. 7G, these conversions can be defined by an exemplary “convertMap HashMap” in the “GenerateIBatisSpringDAO” class in accordance with one embodiment of the invention.
Referring back to FIG. 7A, it should be noted that a WTP Web services Wizard 702 can be extended and made part of the iBatis Web service Wizard in accordance with one embodiment of the invention. The WTP Web service Wizard 702 can be used to effectively generate a Top down Web service from the WSDL by generating a Skeleton Class in which the user can implement his Web service. As an iBatis DAO with Web services Wizard, the Wizard 700 can extent this capability of the WTP Web service Wizard 702 at least partly by allowing modification of the server Skelton to a workable Teradata Service method. This can, for example, be done by using a “Java Reflection” and “Eclipse's CompilationUnit Interface” as those skilled in the art will know. FIG. 7H depicts an “UpdateSoapImpl” method in accordance with one embodiment of the invention.
FIG. 7A also depicts Spring configuration files. These can effectively connect and run the Teradata database with the generated Web service. The configuration files enable the Web service to run as a Web application. The information needed to create the Spring configuration files can be derived from the information gathered when the XML iBatis Map file was parsed with the “ParselBatisDecriptor” class. FIG. 7I depicts a “getContextFile” method that can be used to get the file content of Spring configuration files.
FIG. 8A depicts a method 800 for at least facilitating generation of a communication mechanism for communicating with a relational database over a network by one or more object-based applications of one or more object-based programming languages in accordance with one embodiment of the invention. The method 800 can, for example, be performed by a relational-data to object-based communication-facilitator (OBMG) 102 shown in FIG. 1.
Referring to FIG. 8A, initially, one or more database queries of the relational database in a database query language are obtained (802). Thereafter, relational-query-to-object data is generated (804) at least partly based on the one or more database queries. It should be noted that the relational-query-to-object data at least maps one or more database components associated with the one or more database queries to one or more object-based components of the one or more object-based programming languages, thereby allowing a query-based communication mechanism to be generated, at least partly based on the one or more database queries. The communication mechanism allows one or more object-based applications of the one or more object-based programming languages to communicate via the communication mechanism with the relational database over the network. Method 800 ends after the relational-query-to-object data is generated (804).
FIG. 8B depicts a method 810 for at least facilitating generation of a communication mechanism for communicating with a relational database over a network by one or more object-based applications of one or more object-based programming languages in accordance with one embodiment of the invention. The method 810 can, for example, be performed by the communication component generator (CCG) 120 of FIG. 1.
Referring to FIG. 8B, initially, relational-query-to-object is obtained (812). It should be noted that the data that relational-query-to-object at least maps one or more database components associated with the one or more database queries to one or more object-based components of the one or more object-based programming languages, thereby allowing a query-based communication mechanism to be generated, at least partly based on the one or more database queries, that allows the one or more object-based applications of the one or more object-based programming languages to communicate via the communication mechanism with the relational database over the network. Accordingly, at least part of the communication mechanism is generated (814) based on the relational-query-to-object data before the method 810 ends. It will readily be appreciated that methods 800 and 810 can be combined to generate the communication mechanism as output based on one or more database queries as input.
FIG. 9 depicts a method 900 for generating a query-based (or query derived) Web service (or services) as a communication mechanism between a database and application programs in an object-based programing language in accordance with one embodiment of the invention. Method 900 can represent a method for constructing the Web services in a manner depicted in FIG. 5A.
Referring to FIG. 9, initially, it is determined (902) whether one or more query statements (e.g., SQL statements) have been received. In effect, method 900 can wait for one or more query statements to be received as input for generation of the Web service. If it is determined (902) that one or more query statements have been received, a map and one or more resultant objects are generated (904) based on the one or more query statements. More particularly, the map and resultant objects can be obtained by the execution of the one or more query statements. The map can effectively map the one or more queries statements to one or more corresponding objects of the object-based programing language and the resultant objects can effectively represent one or more corresponding objects of the object-based programing language.
The map can then be used to generate (906) a definition and schema for the Web service, as well as a number of components for constructing the Web service. These components include an abstract database interface for accessing the database (e.g., a DAO in a Java programming environment), a database service class that can be configured to effectively connect the Web service to the abstract database interface, and configuration files (e.g., Spring configuration files) that effectively allow configuring and/or linking the Web service to the database.
As those skilled in the art will readily appreciate, the generated (906) definition and schema for the Web service can be used to generate (908) a skeleton (or shell or frame) for the server, and schema objects for the server can be generated (910) based on the generated (906) schema for the Web service.
In addition, the generated (908) server skeleton can be modified and/or configured to obtain (912) an implemented service (server) that can access the abstract the database service class. By way of example, the generated (908) server skeleton can be displayed for editing and merely edited to refer to the name or names of appropriate database service class. Similarly, the database service class can be modified and/or configured (912) to access the database interface, and the proxy client can be modified and/or configured (912) to access services by sending requests and responses to the server. Generally, the generated configuration files (906) can be used to effectively configure and/or generate components together so that a client can send messages in the form of requests and responses to and from an implemented service (or service) that accesses the abstract database interface via an implemented database service operable to access the database system. It should be noted that the database service class allows schema objects of the service to be translated to the resultant objects and vice versa to facilitate the translation between the database system and the Web service provided in the object-based programing language. Method 900 ends after the Web service has been effectively constructed by configuring and/or effective linking of its components.
FIGS. 10A-10F depict screenshots of a User Interface (UI) that can be provided to facilitate generation of query driven of Web services in accordance with one or more embodiments of the invention. Referring to FIGS. 10A-B, project preferences can be selected and created. As depicted in FIGS. 10C-E, directory structures and table can be viewed. Referring to FIG. 10F, SQL statements can be created.
FIGS. 11A-11M depict screenshots of a Wizard (iBatis SQL Map Wizard) that can be provided to generate a map (SQL map) for the SQL statements (shown in FIG. 10F) in accordance with embodiments of the invention. As shown in FIG. 11A, a pop-up menu can be provided to give an option to generate a SQL map for a SQL statement. The SQL map is shown in FIG. 11M as an iBatis SQL map.
FIGS. 12A-12G depict screenshots of another Wizard (iBatis DAO with Web services) that can be provided to generate Web services in accordance with one embodiment of the invention. Referring to FIG. 12A, an iBatis DAO with Web services can be launched using a pop-up menu. As shown in FIG. 12B-12E, the iBatis DAO with Web services can display various options that can be selected for creation a Web services. FIG. 12F shows a simple example of Web services that can be created using the wizard without having to write programming code. A working test example of Web services is depicted in FIG. 1G, where a customer's credit score can be provided based on a customer id. As this example demonstrates, the wizard allows creation of various object-based methods (e.g., “findCustCreditscore”) to effectively implement a Web service for a database. The Web service allows object-based application to access the database via the services provided by a server configured to effectively communicate with the database.
Conceptually, FIGS. 13A-13D depict an environment where a number of layers connected between a database and its Web services in accordance with one or more embodiments of the invention. Referring to FIG. 13A, a Data Access Layer can be provided to access a database via a database layer as those skilled in art will readily appreciate. Moreover, A SQL map can be used to generate a DAO accessible by Domain objects of a Domain Object Layer. It should be noted that the SQL map can be generated for SQL statement provided as input. Referring to FIG. 13B, the SQL map can also be used to generate WSDL and XSD as service definitions and schema for a Web service that can be provided in an Interface Layer (SOA). It should be noted that WSDL and XSD can be effectively derived from input SQL statements since the SQL map can be generated based on the SQL statements provided as input. As shown in FIG. 13C, the WSDL and XSD can be used to effectively generate the Web service. The Web service can be effectively generated based on the SQL statements provided as input. However, a contract first or top town approach can be taken since the Web services can be generated based on the WSDL and XSD. Referring to FIG. 13D, after generation of a shell or outline of services, Spring Configuration files can be used to effectively connect the Web service in the Interface Layer to Business Service Layer, Domain Object Layer, and Data Access Layer, thereby effectively “wiring” or connecting all the pieces need to provide a Web service for a database.
FIG. 14 depicts a “findCreditScore” Web service that can be provided in accordance with one embodiment of the invention. Referring to FIG. 14, the “findCreditScore” Web service includes a Service Provider that can be generated using the techniques described above. The Service Provider can interact with a database to get information associated with a credit score stored in the database. In addition, a Service Requester (e.g., an ATM application or a call center application) can also be generated using the techniques described above, for example, by using Visual Studio. The Service Requester can interact with a service registry to find registered services provided, for example, in accordance with a Universal Description, Discovery and Integration (UDDI) service description. “findCreditScore” Web service can adhere to various requirement or standards associated with Web services, for example, including SOAP and WSDL.
In view of the foregoing, I will be appreciated that a Web service interface to a relational database can be generated automatically in accordance with one or more embodiments of the invention. Furthermore, Web service applications can easily be updated as the desired input SQL may change. Still further, a Web service interface and applications can be created without requiring knowledge of XML, OOP, or ORM.
Implementations of the subject matter and the functional operations described in this specification can be implemented in digital electronic circuitry, or in computer software, firmware, or hardware, including the structures disclosed in this specification and their structural equivalents, or in combinations of one or more of them. Implementations of the subject matter described in this specification can be implemented as one or more computer program products, i.e., one or more modules of computer program instructions encoded on a computer readable medium for execution by, or to control the operation of, data processing apparatus. The computer readable medium can be a machine-readable storage device, a machine-readable storage substrate, a memory device, a composition of matter affecting a machine-readable propagated signal, or a combination of one or more of them. The term “data processing apparatus” encompasses all apparatus, devices, and machines for processing data, including by way of example a programmable processor, a computer, or multiple processors or computers. The apparatus can include, in addition to hardware, code that creates an execution environment for the computer program in question, e.g., code that constitutes processor firmware, a protocol stack, a database management system, an operating system, or a combination of one or more of them. A propagated signal is an artificially generated signal, e.g., a machine-generated electrical, optical, or electromagnetic signal that is generated to encode information for transmission to suitable receiver apparatus.
A computer program (also known as a program, software, software application, script, or code) can be written in any form of programming language, including compiled or interpreted languages, and it can be deployed in any form, including as a standalone program or as a module, component, subroutine, or other unit suitable for use in a computing environment. A computer program does not necessarily correspond to a file in a file system. A program can be stored in a portion of a file that holds other programs or data (e.g., one or more scripts stored in a markup language document), in a single file dedicated to the program in question, or in multiple coordinated files (e.g., files that store one or more modules, subprograms, or portions of code). A computer program can be deployed to be executed on one computer or on multiple computers that are located at one site or distributed across multiple sites and interconnected by a communication network.
The processes and logic flows described in this specification can be performed by one or more programmable processors executing one or more computer programs to perform functions by operating on input data and generating output. The processes and logic flows can also be performed by, and apparatus can also be implemented as, special purpose logic circuitry, e.g., an FPGA (field programmable gate array) or an ASIC (application specific integrated circuit).
Processors suitable for the execution of a computer program include, by way of example, both general and special purpose microprocessors, and any one or more processors of any kind of digital computer. Generally, a processor will receive instructions and data from a read only memory or a random access memory or both. The essential elements of a computer are a processor for performing instructions and one or more memory devices for storing instructions and data. Generally, a computer will also include, or be operatively coupled to receive data from or transfer data to, or both, one or more mass storage devices for storing data, e.g., magnetic, magneto-optical disks, or optical disks. However, a computer need not have such devices. Moreover, a computer can be embedded in another device, e.g., a mobile telephone, a personal digital assistant (PDA), a mobile audio player, a Global Positioning System (GPS) receiver, to name just a few. Computer readable media suitable for storing computer program instructions and data include all forms of nonvolatile memory, media and memory devices, including by way of example semiconductor memory devices, e.g., EPROM, EEPROM, and flash memory devices; magnetic disks, e.g., internal hard disks or removable disks; magneto optical disks; and CDROM and DVD-ROM disks. The processor and the memory can be supplemented by, or incorporated in, special purpose logic circuitry.
To interact with a user, implementations of the subject matter described in this specification can be implemented on a computer having a display device, e.g., a CRT (cathode ray tube) or LCD (liquid crystal display) monitor, for displaying information to the user and a keyboard and a pointing device, e.g., a mouse or a trackball, by which the user can provide input to the computer. Other kinds of devices can be used to provide for interaction with a user as well; for example, feedback provided to the user can be any form of sensory feedback, e.g., visual feedback, auditory feedback, or tactile feedback; and input from the user can be received in any form, including acoustic, speech, tactile or near-tactile input.
Implementations of the subject matter described in this specification can be implemented in a computing system that includes a backend component, e.g., as a data server, or that includes a middleware component, e.g., an application server, or that includes a frontend component, e.g., a client computer having a graphical user interface or a Web browser through which a user can interact with an implementation of the subject matter described is this specification, or any combination of one or more such backend, middleware, or frontend components. The components of the system can be interconnected by any form or medium of digital data communication, e.g., a communication network. Examples of communication networks include a local area network (“LAN”) and a wide area network (“WAN”), e.g., the Internet.
A computing system can include clients and servers. A client and server are generally remote from each other and typically interact through a communication network. The relationship of client and server can arises by virtue of computer programs running on the respective computers and having a client-server relationship to each other.
While this specification contains many specifics, these should not be construed as limitations on the scope of the disclosure or of what may be claimed, but rather as descriptions of features specific to particular implementations of the disclosure. Certain features that are described in this specification in the context of separate implementations can also be implemented in combination in a single implementation. Conversely, various features that are described in the context of a single implementation can also be implemented in multiple implementations separately or in any suitable sub-combination. Moreover, although features may be described above as acting in certain combinations and even initially claimed as such, one or more features from a claimed combination can in some cases be excised from the combination, and the claimed combination may be directed to a sub-combination or variation of a sub-combination.
Similarly, while operations are depicted in the drawings in a particular order, this should not be understood as requiring that such operations be performed in the particular order shown or in sequential order, or that all illustrated operations be performed, to achieve desirable results. In certain circumstances, multitasking and parallel processing may be advantageous. Moreover, the separation of various system components in the implementations described above should not be understood as requiring such separation in all implementations, and it should be understood that the described program components and systems can generally be integrated together in a single software product or packaged into multiple software products.
The various aspects, features, embodiments or implementations of the invention described above can be used alone or in various combinations. The many features and advantages of the present invention are apparent from the written description and, thus, it is intended by the appended claims to cover all such features and advantages of the invention. Further, since numerous modifications and changes will readily occur to those skilled in the art, the invention should not be limited to the exact construction and operation as illustrated and described. Hence, all suitable modifications and equivalents may be resorted to as falling within the scope of the invention.

Claims

What is claimed is:

1. A computer-implemented method for at least facilitating generation of a communication mechanism for communicating with a relational database over a network by one or more object-based applications of one or more object-based programming languages, the computer-implemented method comprising:

obtaining one or more database queries of the relational database in a database query language;

generating, at least partly based on the one or more database queries, relational-query-to-object data that at least maps one or more database components associated with the one or more database queries to one or more object-based components of the one or more object-based programming languages, thereby allowing a query-based communication mechanism to be generated, at least partly based on the one or more database queries, that allows the one or more object-based applications of the one or more object-based programming languages to communicate via the query-based communication mechanism with the relational database over the network.

2. The computer-implemented method of claim 1, wherein the computer-implemented method further comprises:

generating at least part of the communication mechanism based on the relational-query-to-object data.

3. The computer-implemented method of claim 1, wherein the generated communication mechanism includes one or more services provided over the network.

4. The computer-implemented method of claim 3,

wherein the one or more services are provided as a Web service over the Internet, and

wherein the one or more object-based programming languages are one or more object oriented programming languages.

5. The computer-implemented method of claim 1, wherein the relational-query-to-object data further includes:

a mapping of the one or more database fields associated with the one or more queries to one or more data types of at least one of the one or more object-based programming languages.

6. The computer-implemented method of claim 5, wherein at least part of the mapping is provided in an extensible markup language.

7. The computer-implemented method of claim 1, wherein the relational-query-to-object data further includes one or more resulting objects corresponding to the result of the execution of one or more database queries.

8. The computer-implemented method of claim 5, wherein the computer-implemented method further comprises:

generating, based on the mapping, one or more service definitions for the one or more services provided over the network.

9. The method of claim 5, wherein the computer-implemented method further comprises:

generating, based on the one or more service definitions, a skeleton server.

10. The computer-implemented method of claim 5, wherein the computer-implemented method further comprises:

generating, based on the mapping, an abstract interface for accessing the database service and a database service class that can that effectively connect the abstract interface to the one or more services.

11. The computer-implemented method of claim 5,

wherein the relational-query-to-object data further includes:

one or more resultant objects of the one or more object-based programming languages obtained at least partly based on the one or more database queries; and

wherein the computer-implemented method further comprises:

executing the one or more database queries which are provided in the database query language to obtain one or more results;

generating, at least partly based on the mapping of the one or more database fields, the one or more resultant objects which correspond to the one or more results of the execution of the one or more database queries.

12. The computer-implemented method of claim 3, wherein the generating of the communication mechanism that includes one or more services provided over the network comprises one or more the following:

generating one or more service definitions for the one or more services;

generating schema or metadata for the one or more services;

generating an abstract interface for accessing the database system;

generating abstract and/schema objects;

a server skeleton for a server of the one or more services;

one or more database service classes;

a client proxy for a client or a server of the one or more services;

configuration data for connecting the database to the one or more services;

13. The computer-implemented method of claim 3, wherein the computer-implemented method further comprises: modifying based on user input one or more components of the following based on user input.

14. The computer-implemented method of claim 13, wherein the modifying comprises:

displaying the one or more components on the display; and

allowing editing of the one or more components on the display.

15. A system including one or more processors or processing cores operable to:

obtain one or more database queries of a relational database in a database query language;

generate, at least partly based on the one or more database queries, relational-query-to-object data that at least maps one or more database components associated with the one or more database queries to one or more object-based components of one or more object-based programming languages, thereby allowing a query-based communication mechanism to be generated, at least partly based on the one or more database queries, that allows one or more object-based applications of the one or more object-based programming languages to communicate via the query-based communication mechanism with the relational database over the network.

16. A non-transitory computer readable medium storing at least executable computer code for at least facilitating generation of a communication mechanism for communicating with a relational database over a network by one or more object-based applications of one or more object-based programming languages, wherein the executable computer code includes:

executable computer code obtaining one or more database queries of the relational database in a database query language;

executable computer code for generating, at least partly based on the one or more database queries, relational-query-to-object data that at least maps one or more database components associated with the one or more database queries to one or more object-based components of the one or more object-based programming languages, thereby allowing a query-based communication mechanism to be generated, at least partly based on the one or more database queries, that allows the one or more object-based applications of the one or more object-based programming languages to communicate via the query-based communication mechanism with the relational database over the network.