<?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">
   <release projectid="datatools" version="1.7"/>
   <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, including the following:</p>
	 <ul>
	 	<li>Connectivity: Provides basic frameworks for managing, connecting, and disconnecting 
	 	from data sources</li>
	 	<li>Model Base: Provides EMF models for managing database and SQL details</li>
	 	<li>SQL Development Tools: Provides a set of frameworks and basic tools to handle 
	 	management of database assets and SQL queries</li>
	 	<li>Enablement: Hosts contributions specializing DTP for specific data sources</li>
	 	<li>Incubator: Hosts new development in areas that are relevant to the other 
	 	Eclipse Data Tools Platform projects, which because of their nature would not be 
	 	appropriate for direct inclusion in the effected sub-project</li>
	 </ul>
   </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>Though DTP has, up to its Ganymede release (1.6), been compiled against version 1.4 of the Java Platform APIs, starting with Galileo we will be compiling against version 1.5.0 of the Java Platform APIs. Our primary test environment will be with JDK 1.5 and we will test with JDK 1.6 as time and resources allow.</html:p>
   <html:p>In addition, DTP will work on Eclipse Platform 3.5 and be backward compatible to Eclipse Platform 3.4.</html:p>  
    </html:div>
     <internationalization>
     <html:p>DTP has been designed with localization in mind and will keep internationalization in mind
     as we go forward. As of DTP 1.6, we are also included in the Babel project.</html:p>
     </internationalization>
   </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>DTP in the Galileo timeframe will focus on the following themes:</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="Enhance DTP User Tooling">
        <description>
	        <html:p>Enhance user tools to make DTP a compelling choice for developing data centric 
	        applications in Eclipse by providing additional exemplary tools in a variety of areas, 
	        including creation of database objects such as catalogs, schemas, tables, columns, 
	        constraints, and so on.</html:p>
        </description>
    	<committed bugzilla="https://bugs.eclipse.org/bugs/buglist.cgi?query_format=advanced&amp;short_desc_type=allwordssubstr&amp;short_desc=DTP+User+Tooling&amp;classification=DataTools&amp;product=Data+Tools&amp;target_milestone=Galileo&amp;long_desc_type=allwordssubstr&amp;long_desc=&amp;bug_file_loc_type=allwordssubstr&amp;bug_file_loc=&amp;status_whiteboard_type=allwordssubstr&amp;status_whiteboard=&amp;keywords_type=allwords&amp;keywords=&amp;emailtype1=exact&amp;email1=&amp;emailtype2=substring&amp;email2=&amp;bugidtype=include&amp;bug_id=&amp;votes=&amp;chfieldfrom=&amp;chfieldto=Now&amp;chfieldvalue=&amp;cmdtype=doit&amp;order=Reuse+same+sort+as+last+time&amp;negate0=1&amp;field0-0-0=bug_status&amp;type0-0-0=substring&amp;value0-0-0="></committed>
     </theme>
     <theme name="Improved DTP Support for RCP and Headless Applications">
        <description>
        <html:p>Enhance DTP to work better in headless and RCP applications.</html:p>
        </description>
        <committed bugzilla="https://bugs.eclipse.org/bugs/buglist.cgi?query_format=advanced&amp;short_desc_type=allwordssubstr&amp;short_desc=DTP+in+RCP&amp;classification=DataTools&amp;product=Data+Tools&amp;target_milestone=Galileo&amp;long_desc_type=allwordssubstr&amp;long_desc=&amp;bug_file_loc_type=allwordssubstr&amp;bug_file_loc=&amp;status_whiteboard_type=allwordssubstr&amp;status_whiteboard=&amp;keywords_type=allwords&amp;keywords=&amp;emailtype1=exact&amp;email1=&amp;emailtype2=substring&amp;email2=&amp;bugidtype=include&amp;bug_id=&amp;votes=&amp;chfieldfrom=&amp;chfieldto=Now&amp;chfieldvalue=&amp;cmdtype=doit&amp;order=Reuse+same+sort+as+last+time&amp;negate0=1&amp;field0-0-0=bug_status&amp;type0-0-0=substring&amp;value0-0-0="></committed>
     </theme>
     <theme name="Make DTP Easier for Extenders and Users">
        <description>
        <html:p>Make DTP easier to understand and leverage, from both the extender and user perspectives.</html:p>
        </description>
        <committed bugzilla="https://bugs.eclipse.org/bugs/buglist.cgi?query_format=advanced&amp;short_desc_type=allwordssubstr&amp;short_desc=&amp;classification=DataTools&amp;product=Data+Tools&amp;component=Connectivity&amp;target_milestone=Galileo&amp;long_desc_type=allwordssubstr&amp;long_desc=&amp;bug_file_loc_type=allwordssubstr&amp;bug_file_loc=&amp;status_whiteboard_type=allwordssubstr&amp;status_whiteboard=&amp;keywords_type=allwords&amp;keywords=&amp;bug_status=NEW&amp;bug_status=ASSIGNED&amp;bug_status=REOPENED&amp;emailtype1=exact&amp;email1=&amp;emailtype2=substring&amp;email2=&amp;bugidtype=include&amp;bug_id=252499&amp;votes=&amp;chfieldfrom=&amp;chfieldto=Now&amp;chfieldvalue=&amp;cmdtype=doit&amp;order=Reuse+same+sort+as+last+time&amp;negate0=1&amp;field0-0-0=bug_status&amp;type0-0-0=substring&amp;value0-0-0=CLOSED"></committed>
     </theme>
     <theme name="Continue Promoting and Expanding DTP Enablement support">
     	<description>
     		<html:p>DTP Enablement must continue on multiple fronts to promote and expand its support. This includes providing additional exemplary tools, encouraging community involvement, and promoting Incubator projects as they become ready. (Note there may be some duplication between the proposed items and the committed items.)</html:p></description>
     	<committed bugzilla="https://bugs.eclipse.org/bugs/buglist.cgi?query_format=advanced&amp;short_desc_type=allwordssubstr&amp;short_desc=&amp;classification=DataTools&amp;product=Data+Tools&amp;component=Enablement&amp;component=Enablement%3ASAP&amp;component=Enablement%3ASybase&amp;target_milestone=Galileo&amp;long_desc_type=allwordssubstr&amp;long_desc=&amp;bug_file_loc_type=allwordssubstr&amp;bug_file_loc=&amp;status_whiteboard_type=allwordssubstr&amp;status_whiteboard=&amp;keywords_type=allwords&amp;keywords=plan&amp;bug_status=NEW&amp;bug_status=ASSIGNED&amp;bug_status=REOPENED&amp;emailtype1=exact&amp;email1=&amp;emailtype2=substring&amp;email2=&amp;bugidtype=include&amp;bug_id=&amp;votes=&amp;chfieldfrom=&amp;chfieldto=Now&amp;chfieldvalue=&amp;cmdtype=doit&amp;order=Reuse+same+sort+as+last+time&amp;negate0=1&amp;field0-0-0=bug_status&amp;type0-0-0=substring&amp;value0-0-0=CLOSED"></committed>
     	<proposed bugzilla="https://bugs.eclipse.org/bugs/buglist.cgi?query_format=advanced&amp;short_desc_type=allwordssubstr&amp;short_desc=&amp;classification=DataTools&amp;product=Data+Tools&amp;component=Enablement&amp;component=Enablement%3ASAP&amp;component=Enablement%3ASybase&amp;target_milestone=Galileo&amp;long_desc_type=allwordssubstr&amp;long_desc=&amp;bug_file_loc_type=allwordssubstr&amp;bug_file_loc=&amp;status_whiteboard_type=allwordssubstr&amp;status_whiteboard=&amp;keywords_type=nowords&amp;keywords=plan&amp;bug_status=NEW&amp;bug_status=ASSIGNED&amp;bug_status=REOPENED&amp;emailtype1=exact&amp;email1=&amp;emailtype2=substring&amp;email2=&amp;bugidtype=include&amp;bug_id=&amp;votes=&amp;chfieldfrom=&amp;chfieldto=Now&amp;chfieldvalue=&amp;cmdtype=doit&amp;order=Reuse+same+sort+as+last+time&amp;negate0=1&amp;field0-0-0=bug_status&amp;type0-0-0=substring&amp;value0-0-0=CLOSED"></proposed></theme>
     <theme name="Continued Enhancement of DTP Model Base">
     	<description>
     		<html:p>DTP Model base will continue enhancing the dbdefinition model and database vendor docs as well as respond to community requests for model changes.</html:p></description></theme>
     <theme name="Continued Enhancement of DTP SQL Dev Tools">
     	<description>
     		<html:p>DTP SQL Dev Tools will continue to focus on various SQL-related development tools, including the SQL Query Builder and SQL Editor frameworks, and additional tooling for creating and maintaining various SQL entities. Proposed items are for the SQL Query Builder, which we will implement as time and resources allow for Galileo.</html:p></description>
     	
     	<committed bugzilla="https://bugs.eclipse.org/bugs/buglist.cgi?query_format=advanced&amp;short_desc_type=allwordssubstr&amp;short_desc=&amp;classification=DataTools&amp;product=Data+Tools&amp;component=SQL+Editor+Framework&amp;component=SQL+Results+View&amp;component=SQLDevTools&amp;target_milestone=Galileo&amp;long_desc_type=allwordssubstr&amp;long_desc=&amp;bug_file_loc_type=allwordssubstr&amp;bug_file_loc=&amp;status_whiteboard_type=allwordssubstr&amp;status_whiteboard=&amp;keywords_type=allwords&amp;keywords=plan&amp;bug_status=NEW&amp;bug_status=ASSIGNED&amp;bug_status=REOPENED&amp;emailtype1=exact&amp;email1=&amp;emailtype2=substring&amp;email2=&amp;bugidtype=include&amp;bug_id=&amp;votes=&amp;chfieldfrom=&amp;chfieldto=Now&amp;chfieldvalue=&amp;cmdtype=doit&amp;order=Reuse+same+sort+as+last+time&amp;negate0=1&amp;field0-0-0=bug_status&amp;type0-0-0=substring&amp;value0-0-0=CLOSED"></committed><proposed bugzilla="https://bugs.eclipse.org/bugs/buglist.cgi?query_format=advanced&amp;short_desc_type=allwordssubstr&amp;short_desc=&amp;classification=DataTools&amp;product=Data+Tools&amp;component=SQL+Editor+Framework&amp;component=SQL+Results+View&amp;component=SQLDevTools&amp;target_milestone=Galileo&amp;long_desc_type=allwordssubstr&amp;long_desc=&amp;bug_file_loc_type=allwordssubstr&amp;bug_file_loc=&amp;status_whiteboard_type=allwordssubstr&amp;status_whiteboard=&amp;keywords_type=allwords&amp;keywords=&amp;bug_status=NEW&amp;bug_status=ASSIGNED&amp;bug_status=REOPENED&amp;emailtype1=exact&amp;email1=&amp;emailtype2=substring&amp;email2=&amp;bugidtype=include&amp;bug_id=&amp;votes=&amp;chfieldfrom=&amp;chfieldto=Now&amp;chfieldvalue=&amp;cmdtype=doit&amp;order=Reuse+same+sort+as+last+time&amp;negate0=1&amp;field0-0-0=bug_status&amp;type0-0-0=substring&amp;value0-0-0=CLOSED"></proposed></theme>
	  <theme name="Individual DTP Sub-Project Plans">
	  	<description>
		<html:p>
		Project Plans:
		<html:ul>
		<html:li><html:a href="http://www.eclipse.org/projects/project-plan.php?projectid=datatools.connectivity">Connectivity</html:a></html:li>
		<html:li><html:a href="http://www.eclipse.org/projects/project-plan.php?projectid=datatools.enablement">Enablement</html:a></html:li>
		<html:li><html:a href="http://www.eclipse.org/projects/project-plan.php?projectid=datatools.incubator">Incubator</html:a></html:li>
		<html:li><html:a href="http://www.eclipse.org/projects/project-plan.php?projectid=datatools.modelbase">Modelbase</html:a></html:li>
		<html:li><html:a href="http://www.eclipse.org/projects/project-plan.php?projectid=datatools.sqltools">SQL Dev Tools</html:a></html:li>
		</html:ul>
		</html:p>
	  	</description>
	  </theme>
   </themes_and_priorities>
 </plan>