QUERY DERIVED COMMUNICATION MECHANISM FOR COMMUNICATION BETWEEN RELATIONAL DATABASES AND OBJECT-BASED COMPUTING ENVIRONMENTS AND SYSTEMS
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.
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.
BACKGROUNDData 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.
SUMMARYBroadly 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.
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:
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
More specifically, referring to
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
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
However, referring now back to
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,
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
Referring to
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
To illustrate,
Referring now to
Referring now to
Similarly,
Referring back to
Referring to
Referring back to
As show in
To further elaborate,
To elaborate even further,
Referring to
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.
Referring to
Referring back to
As shown in
To further elaborate,
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.
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
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.
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
Referring back to
Referring to
Referring to
Referring to
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.
Conceptually,
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
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.
Type: Application
Filed: Sep 12, 2012
Publication Date: Oct 3, 2013
Inventors: John J. Smith (San Diego, CA), Michael G. Coutts (Glasgow)
Application Number: 13/612,145
International Classification: G06F 17/30 (20060101);