<?xml version="1.0" encoding="utf-8" standalone="yes" ?>
<!-- <?xml-stylesheet type="text/xsl" href="project-plan-render.xsl"?>-->
<?xml-stylesheet type="text/xsl" href="http://www.eclipse.org/projects/project-plan.xsl"?>
<plan plan-format="1.0" xmlns="http://www.eclipse.org/project/plan" xmlns:html="http://www.w3.org/1999/xhtml" name="DTP Modelbase">
   <release projectid="datatools.modelbase" version="1.7"></release>
   <introduction><html:div xmlns="http://www.w3.org/1999/xhtml">
     <p>"Data Tools" is a vast domain, yet there are a fairly small number of foundational 
     requirements when developing with or managing data-centric systems. A developer is 
     interested in an environment that is easy to configure, one in which the challenges of 
     application development are due to the problem domain, not the complexity of the tools employed. 
     Data management, whether by a developer working on an application, or an administrator maintaining 
     or monitoring a production system, should also provide a consistent, highly usable environment 
     that works well with associated technologies.</p>
     <p>The <a href="http://www.eclipse.org/datatools"><b>Data Tools Platform (DTP)</b></a>
project provides a set of frameworks and basic tools to enable data-centric development in a variety
of data types, including databases (via JDBC) and ODA data sources (for BIRT reporting). The frameworks
are open to allow common interfaces (both API and user interface) across different types of data.</p>
	 <p>DTP is broken into a number of sub-projects. This project plan focuses on the Modelbase subproject, which provides EMF models for managing database and SQL details.</p>
   </html:div>
   </introduction>
   <release_deliverables><html:div xmlns="http://www.w3.org/1999/xhtml">
   		DTP provides two main deliverables: one deliverable for developers, which includes 
   		source code, examples, and so on; and a user or runtime deliverable that just provides 
   		the basics for DTP use.  
    </html:div>
    </release_deliverables>
   <release_milestones>
      <preamble>
	    <html:p>The DTP project delivers a set of components to ease connecting to and working with data sources. Primarily DTP focuses on database (SQL development) work and ODA data sources for BIRT reporting.</html:p>
	  </preamble>
	  <milestone date="11/5/2008" milestone="M3">
	  	<html:div><html:p>
					Release Train M3 +1 Date (M3 GA on 11/19/08)
				</html:p>
	  		<html:p>(Note that this will be the DTP 1.6.2 M1 build for now until we branch Galileo sometime the week of November 10th)</html:p>
	  	</html:div>
		</milestone>
	  <milestone date="12/17/2008" milestone="M4">
	  	<html:div><html:p>
					Release Train M4 +1 Date (M4 GA on 1/12/09)
				</html:p>
			</html:div>
		</milestone>
	  <milestone date="2/3/2009" milestone="M5">
	  	<html:div><html:p>
					Release Train M5 +1 Date (M5 GA on 2/16/09)
				</html:p>
			</html:div>
		</milestone>
	  <milestone date="3/16/2009" milestone="M6">
	  	<html:div><html:p>
					Release Train M6 +1 Date (M6 GA on 3/23/09)
				</html:p>
			</html:div>
		</milestone>
	  <milestone date="5/4/2009" milestone="M7">
	  	<html:div><html:p>
					Release Train M7 +1 Date (M7 GA on 5/11/09)
				</html:p>
			</html:div>
		</milestone>
	  <milestone date="5/18/2009" milestone="RC1">
	  	<html:div><html:p>
					Release Train RC1 +1 Date (RC1 GA on 5/25/09)
				</html:p>
			</html:div>
		</milestone>
	  <milestone date="5/25/2009" milestone="RC2">
	  	<html:div><html:p>
					Release Train RC2 +1 Date (RC2 GA on 6/1/09)
				</html:p>
			</html:div>
		</milestone>
	  <milestone date="6/1/2009" milestone="RC3">
	  	<html:div><html:p>
					Release Train RC3 +1 Date (RC3 GA on 6/8/09)
				</html:p>
			</html:div>
		</milestone>
	  <milestone date="6/8/2009" milestone="RC4">
	  	<html:div><html:p>
					Release Train RC4 +1 Date (RC4 GA on 6/15/09)
				</html:p>
			</html:div>
		</milestone>
	  <milestone date="6/15/2009" milestone="RC5">
	  	<html:div><html:p>
					Release Train RC5 +1 Date (Galileo GA on 6/26/09)
				</html:p>
			</html:div>
		</milestone>
      <postamble></postamble>
   </release_milestones>
   <target_environments>
   	<html:div xmlns="http://www.w3.org/1999/xhtml">
   <html:p>See the main Datatools plan for target environment details.</html:p>
    </html:div>
   </target_environments>
   <compatibility_with_previous_releases><html:div xmlns="http://www.w3.org/1999/xhtml">
<p>The goal of this release is to be backward compatible back to DTP 1.6.</p>
    </html:div>
   </compatibility_with_previous_releases>
   <themes_and_priorities>
     <preamble>
     	<html:p>The Modelbase sub-project will work on the following themes and priority for the DTP Galileo release.</html:p>
     	<html:p>(Note that "committed" items have the "plan" keyword in the BZ entry. "Proposed" items do not.)</html:p>
     </preamble>
     <theme name="Modelbase Priorities">
        <description>
	        <html:p>We will focus on the following:</html:p>
	        <html:ul>
	        	<html:li>Continue enhancing the dbdefinition model and database vendor docs</html:li>
		        <html:li>Respond to requests for proposed model changes</html:li>
	        </html:ul>
	    </description>
     </theme>
   </themes_and_priorities>
 </plan>