Integrated development environments (IDEs) provide a common platform and design tools for modern software development. While software is often the most time-consuming and highest risk aspect of electronic program development, it also holds the greatest potential to enhance a design for multiple target applications. Such design tools allow designers to efficiently develop code where graphical user interfaces (GUI) automate and simplify configuration of complex programming projects. These tools also enable designers to create source code by enhancing code readability and simplifying code writing. For instance, source code editor features may include syntax coloring, auto-indenting and shortcut menus that link stored procedure calls to their definitions, declarations and usages even when these references reside in separate files. Other aspects of the tools include simulation resources to allow designers to develop and debug applications.
One area of software development that is performed on IDEs includes mapping class objects to relational objects, referred to as O/R mapping, and is the latest advancement in modern day programming technologies. It improves productivity of programmers by many degrees while providing flexibility to adapt to changing business needs. While O/R technology itself provides many benefits to programmers, enabling O/R classes to be created and set up correctly is not an easy task for normal development nor is it well supported in current programming tools. Without providing adequate tools support, programmers trying to adopt the technology may be forced to write their respective code manually.
One purpose driving O/R technologies is the need to interface the relational database world with the models supported in the object oriented programming world. For example, relational database management systems (RDBMS) supporting a relational database pre-dated the popularization of object-oriented programming in the 1990s. Using relational databases to store object-oriented data leads to a semantic gap where programmers would be required to allow their software to function in two different worlds—processing of data would be performed in object-oriented form, but the same data would have to be stored in relational form.
Requiring this constant conversion between two different forms of the same data not only had the effect of stifling performance but also imposed difficulties for programmers as relational or object-oriented forms would impose limitations on each other. For example, relational databases make complicated associations difficult, and they tend to “map” poorly into the object-oriented world since they fail to implement the relational model's user-defined types. This problem is sometimes referred to as the Object-Relational impedance mismatch.
Generally, relational databases use a series of tables representing simple data, where optional or related information is stored in other tables. A single (persistent object) record in the database often spans several of these tables, and requires a join to collect all of the related information back into a single piece of data for processing. This would be the case for an address book example, which would likely include at least a user and address table, but perhaps even a phone number table as well. In the object world, there is a clear sense of “ownership,” where a particular person object owns a particular phone number in the above example. This is not the case in relational databases, where the tables have no understanding how they relate to other tables at a fundamental level. Instead, the user must construct a “query” to gather information together. Queries not only request what information to return but also need to know how the tables involved are related to each other, illustrating the point that tables do not know their relationships when they are residing in the database. Thus, these relationships are typically only known when a query is run to specify the relationships. Relational databases (which attempt to implement the Relational Model), do maintain relationships via constraints but the Structured Query Language (SQL), for example, is generally unaware of these.
When creating Object/Relational (O/R) classes by mapping class objects to database objects, it is important to also set correct associations between related objects so that applications written on top of these objects can easily take advantage of such relationships. Hand coding such relationship is not a trivial task for typical developers. While the O/R technology itself provides many benefits to programmers, manually having O/R classes created and set up correctly is not a straightforward or simple task. With current development tools support, programmers trying to adopt O/R technology are often forced to write code manually which detracts from the utility of such tools.