import org.pentaho.di.core.ProgressMonitorListener; //导入依赖的package包/类
/**
    * Get the first rows from a table (for preview) 
    * @param table_name The table name (or schema/table combination): this needs to be quoted properly
    * @param limit limit <=0 means unlimited, otherwise this specifies the maximum number of rows read.
    * @param monitor The progress monitor to update while getting the rows.
    * @return An ArrayList of rows.
    * @throws KettleDatabaseException in case something goes wrong
    */
public List<Object[]> getFirstRows(String table_name, int limit, ProgressMonitorListener monitor) throws KettleDatabaseException
{
	String sql = "SELECT";
	if (databaseMeta.getDatabaseType()==DatabaseMeta.TYPE_DATABASE_NEOVIEW)
	{
		sql+=" [FIRST " + limit +"]";
	}
	sql += " * FROM "+table_name;
	
       if (limit>0)
	{
	    sql+=databaseMeta.getLimitClause(limit);
	}
	
	return getRows(sql, limit, monitor);
}
 

import org.pentaho.di.core.ProgressMonitorListener; //导入依赖的package包/类
public JobMeta loadJob(String jobname, RepositoryDirectoryInterface repdir, ProgressMonitorListener monitor, String versionName) throws KettleException {
	
	// This is a standard load of a transformation serialized in XML...
	//
	String filename = calcDirectoryName(repdir)+jobname+EXT_JOB;
	JobMeta jobMeta = new JobMeta(filename, this);
	jobMeta.setFilename(null);
	jobMeta.setName(jobname);
	jobMeta.setObjectId(new StringObjectId(calcObjectId(repdir, jobname, EXT_JOB)));
	
   readDatabases(jobMeta, true);
   jobMeta.clearChanged();
   
	return jobMeta;

}
 

import org.pentaho.di.core.ProgressMonitorListener; //导入依赖的package包/类
/**
    * Get the first rows from a table (for preview) 
    * @param table_name The table name (or schema/table combination): this needs to be quoted properly
    * @param limit limit <=0 means unlimited, otherwise this specifies the maximum number of rows read.
    * @param monitor The progress monitor to update while getting the rows.
    * @return An ArrayList of rows.
    * @throws KettleDatabaseException in case something goes wrong
    */
public List<Object[]> getFirstRows(String table_name, int limit, ProgressMonitorListener monitor) throws KettleDatabaseException
{
	String sql = "SELECT";
	if (databaseMeta.getDatabaseInterface() instanceof NeoviewDatabaseMeta)
	{
		sql+=" [FIRST " + limit +"]";
	}
	else if (databaseMeta.getDatabaseInterface() instanceof SybaseIQDatabaseMeta)  // improve support Sybase IQ
	{
		sql+=" TOP " + limit +" ";
	}
	sql += " * FROM "+table_name;
	
       if (limit>0)
	{
	    sql+=databaseMeta.getLimitClause(limit);
	}
	
	return getRows(sql, limit, monitor);
}
 

import org.pentaho.di.core.ProgressMonitorListener; //导入依赖的package包/类
/**
 * Validate the the repository export api hasn't changed from what we use in example files.
 * 
 * @see RepositoryExporter#exportAllObjects(ProgressMonitorListener, String, RepositoryDirectoryInterface, String)
 */
public void testExportApi() throws Exception {
  Class<RepositoryExporter> exporter = RepositoryExporter.class;

  // Make sure we the expected constructor that takes a repository
  Constructor<RepositoryExporter> c = exporter.getConstructor(Repository.class);
  assertNotNull(c);

  // Make sure we have the correct signature for exporting objects
  // RepositoryExporter.exportAllObjects(ProgressMonitorListener, String, RepositoryDirectoryInterface, String)
  Class<?> param1 = ProgressMonitorListener.class;
  Class<?> param2 = String.class;
  Class<?> param3 = RepositoryDirectoryInterface.class;
  Class<?> param4 = String.class;
  Method m = exporter.getMethod("exportAllObjects", param1, param2, param3, param4); //$NON-NLS-1$
  assertNotNull(m);
}
 

import org.pentaho.di.core.ProgressMonitorListener; //导入依赖的package包/类
/**
 * Get the first rows from a table (for preview)
 *
 * @param table_name The table name (or schema/table combination): this needs to be quoted properly
 * @param limit      limit <=0 means unlimited, otherwise this specifies the maximum number of rows read.
 * @param monitor    The progress monitor to update while getting the rows.
 * @return An ArrayList of rows.
 * @throws KettleDatabaseException in case something goes wrong
 */
public List<Object[]> getFirstRows( String table_name, int limit, ProgressMonitorListener monitor )
  throws KettleDatabaseException {
  String sql = "SELECT";
  if ( databaseMeta.getDatabaseInterface() instanceof NeoviewDatabaseMeta ) {
    sql += " [FIRST " + limit + "]";
  } else if ( databaseMeta.getDatabaseInterface() instanceof SybaseIQDatabaseMeta ) {
    // improve support for Sybase IQ
    sql += " TOP " + limit + " ";
  }
  sql += " * FROM " + table_name;

  if ( limit > 0 ) {
    sql += databaseMeta.getLimitClause( limit );
  }

  return getRows( sql, limit, monitor );
}
 

import org.pentaho.di.core.ProgressMonitorListener; //导入依赖的package包/类
/**
 * Get the first rows from a table (for preview)
 * 
 * @param table_name
 *          The table name (or schema/table combination): this needs to be
 *          quoted properly
 * @param limit
 *          limit <=0 means unlimited, otherwise this specifies the maximum
 *          number of rows read.
 * @param monitor
 *          The progress monitor to update while getting the rows.
 * @return An ArrayList of rows.
 * @throws KettleDatabaseException
 *           in case something goes wrong
 */
public List<Object[]> getFirstRows(String table_name, int limit, ProgressMonitorListener monitor)
    throws KettleDatabaseException {
  String sql = "SELECT";
  if (databaseMeta.getDatabaseInterface() instanceof NeoviewDatabaseMeta) {
    sql += " [FIRST " + limit + "]";
  } else if (databaseMeta.getDatabaseInterface() instanceof SybaseIQDatabaseMeta) // improve
                                                                                  // support
                                                                                  // Sybase
                                                                                  // IQ
  {
    sql += " TOP " + limit + " ";
  }
  sql += " * FROM " + table_name;

  if (limit > 0) {
    sql += databaseMeta.getLimitClause(limit);
  }

  return getRows(sql, limit, monitor);
}
 

import org.pentaho.di.core.ProgressMonitorListener; //导入依赖的package包/类
/**
 * Validate the the repository export api hasn't changed from what we use in example files.
 *
 * @see RepositoryExporter#exportAllObjects(ProgressMonitorListener, String, RepositoryDirectoryInterface, String)
 */
public void testExportApi() throws Exception {
  Class<RepositoryExporter> exporter = RepositoryExporter.class;

  // Make sure we the expected constructor that takes a repository
  Constructor<RepositoryExporter> c = exporter.getConstructor( Repository.class );
  assertNotNull( c );

  // Make sure we have the correct signature for exporting objects
  // RepositoryExporter.exportAllObjects(ProgressMonitorListener, String, RepositoryDirectoryInterface, String)
  Class<?> param1 = ProgressMonitorListener.class;
  Class<?> param2 = String.class;
  Class<?> param3 = RepositoryDirectoryInterface.class;
  Class<?> param4 = String.class;
  Method m = exporter.getMethod( "exportAllObjects", param1, param2, param3, param4 );
  assertNotNull( m );
}
 

import org.pentaho.di.core.ProgressMonitorListener; //导入依赖的package包/类
public void export( ProgressMonitorListener monitor, List<RepositoryFile> files, OutputStreamWriter writer )
  throws KettleException {
  List<TransMeta> transformations = repository.loadTransformations( monitor, log, files, true );
  Iterator<TransMeta> transMetasIter = transformations.iterator();
  Iterator<RepositoryFile> filesIter = files.iterator();
  while ( ( monitor == null || !monitor.isCanceled() ) && transMetasIter.hasNext() ) {
    TransMeta trans = transMetasIter.next();
    setGlobalVariablesOfLogTablesNull( trans.getLogTables() );
    RepositoryFile file = filesIter.next();
    try {
      // Validate against the import rules first!
      if ( toExport( trans ) ) {
        writer.write( trans.getXML() + Const.CR );
      }
    } catch ( Exception ex ) {
      // if exception while writing one item is occurred logging it and continue looping
      log.logError( BaseMessages.getString( PKG, "PurRepositoryExporter.ERROR_SAVE_TRANSFORMATION",
          trans.getName(), file.getPath() ), ex ); //$NON-NLS-1$
    }
  }
}
 

import org.pentaho.di.core.ProgressMonitorListener; //导入依赖的package包/类
@Override
public JobMeta loadJob( String jobname, RepositoryDirectoryInterface repdir, ProgressMonitorListener monitor,
  String versionName ) throws KettleException {

  // This is a standard load of a transformation serialized in XML...
  //
  String filename = calcDirectoryName( repdir ) + jobname + EXT_JOB;
  JobMeta jobMeta = new JobMeta( filename, this );
  jobMeta.setFilename( null );
  jobMeta.setName( jobname );
  jobMeta.setObjectId( new StringObjectId( calcObjectId( repdir, jobname, EXT_JOB ) ) );

  jobMeta.setRepository( this );
  jobMeta.setMetaStore( getMetaStore() );

  readDatabases( jobMeta, true );
  jobMeta.clearChanged();

  return jobMeta;

}
 

import org.pentaho.di.core.ProgressMonitorListener; //导入依赖的package包/类
@Override
public TransMeta loadTransformation( String transname, RepositoryDirectoryInterface repdir,
  ProgressMonitorListener monitor, boolean setInternalVariables, String versionName ) throws KettleException {

  // This is a standard load of a transformation serialized in XML...
  //
  String filename = calcDirectoryName( repdir ) + transname + ".ktr";
  TransMeta transMeta = new TransMeta( filename, this, setInternalVariables );
  transMeta.setRepository( this );
  transMeta.setMetaStore( getMetaStore() );
  transMeta.setFilename( null );
  transMeta.setName( transname );
  transMeta.setObjectId( new StringObjectId( calcObjectId( repdir, transname, EXT_TRANSFORMATION ) ) );

  readDatabases( transMeta, true );
  transMeta.clearChanged();

  return transMeta;
}
 

import org.pentaho.di.core.ProgressMonitorListener; //导入依赖的package包/类
/**
 * Check a step to see if there are no multiple steps to read from. If so, check to see if the receiving rows are all
 * the same in layout. We only want to ONLY use the DBCache for this to prevent GUI stalls.
 *
 * @param stepMeta
 *          the step to check
 * @param monitor
 *          the monitor
 * @throws KettleRowException
 *           in case we detect a row mixing violation
 */
public void checkRowMixingStatically( StepMeta stepMeta, ProgressMonitorListener monitor ) throws KettleRowException {
  List<StepMeta> prevSteps = findPreviousSteps( stepMeta );
  int nrPrevious = prevSteps.size();
  if ( nrPrevious > 1 ) {
    RowMetaInterface referenceRow = null;
    // See if all previous steps send out the same rows...
    for ( int i = 0; i < nrPrevious; i++ ) {
      StepMeta previousStep = prevSteps.get( i );
      try {
        RowMetaInterface row = getStepFields( previousStep, monitor ); // Throws KettleStepException
        if ( referenceRow == null ) {
          referenceRow = row;
        } else if ( !stepMeta.getStepMetaInterface().excludeFromRowLayoutVerification() ) {
          BaseStep.safeModeChecking( referenceRow, row );
        }
      } catch ( KettleStepException e ) {
        // We ignore this one because we are in the process of designing the transformation, anything intermediate can
        // go wrong.
      }
    }
  }
}
 

import org.pentaho.di.core.ProgressMonitorListener; //导入依赖的package包/类
@Test
public void testGetValueToIdMap() throws KettleException {
  String tablename = "test-tablename";
  String idfield = "test-idfield";
  String lookupfield = "test-lookupfield";
  List<Object[]> rows = new ArrayList<Object[]>();
  int id = 1234;
  LongObjectId longObjectId = new LongObjectId( id );
  rows.add( new Object[] { lookupfield, id } );
  when( database.getRows( eq( "SELECT " + lookupfield + ", " + idfield + " FROM " + tablename ), any(
      RowMetaInterface.class ),
    eq( new Object[] {} ), eq( ResultSet.FETCH_FORWARD ),
    eq( false ), eq( -1 ), eq( (ProgressMonitorListener) null ) ) ).thenReturn( rows );
  Map<String, LongObjectId> valueToIdMap =
    kettleDatabaseRepositoryConnectionDelegate.getValueToIdMap( tablename, idfield, lookupfield );
  assertEquals( 1, valueToIdMap.size() );
  assertEquals( longObjectId, valueToIdMap.get( lookupfield ) );
}
 

import org.pentaho.di.core.ProgressMonitorListener; //导入依赖的package包/类
/** Reads the result of a ResultSet into an ArrayList
    * 
    * @param rset the ResultSet to read out
    * @param limit <=0 means unlimited, otherwise this specifies the maximum number of rows read.
    * @param monitor The progress monitor to update while getting the rows.
    * @return An ArrayList of rows.
    * @throws KettleDatabaseException if something goes wrong.
    */
public List<Object[]> getRows(ResultSet rset, int limit, ProgressMonitorListener monitor) throws KettleDatabaseException
   {
       try
       {
           List<Object[]> result = new ArrayList<Object[]>();
           boolean stop=false;
           int i=0;
           
           if (rset!=null)
           {
               if (monitor!=null && limit>0) monitor.beginTask("Reading rows...", limit);
               while ((limit<=0 || i<limit) && !stop)
               {
                   Object[] row = getRow(rset);
                   if (row!=null)
                   {
                       result.add(row);
                       i++;
                   }
                   else
                   {
                       stop=true;
                   }
                   if (monitor!=null && limit>0) monitor.worked(1);
               }
               closeQuery(rset);
               if (monitor!=null) monitor.done();
           }
           
           return result;
       }
       catch(Exception e)
       {
           throw new KettleDatabaseException("Unable to get list of rows from ResultSet : ", e);
       }
   }
 

import org.pentaho.di.core.ProgressMonitorListener; //导入依赖的package包/类
/**
 * Check all job entries within the job. Each Job Entry has the opportunity
 * to check their own settings.
 * 
 * @param remarks
 *            List of CheckResult remarks inserted into by each JobEntry
 * @param only_selected
 *            true if you only want to check the selected jobs
 * @param monitor
 *            Progress monitor (not presently in use)
 */
public void checkJobEntries(List<CheckResultInterface> remarks, boolean only_selected, ProgressMonitorListener monitor) {
	remarks.clear(); // Empty remarks
	if (monitor != null)
		monitor.beginTask(Messages.getString("JobMeta.Monitor.VerifyingThisJobEntryTask.Title"), jobcopies.size() + 2); //$NON-NLS-1$
	boolean stop_checking = false;
	for (int i = 0; i < jobcopies.size() && !stop_checking; i++) {
		JobEntryCopy copy = jobcopies.get(i); // get the job entry copy
		if ((!only_selected) || (only_selected && copy.isSelected())) {
			JobEntryInterface entry = copy.getEntry();
			if (entry != null) {
				if (monitor != null)
					monitor.subTask(Messages.getString("JobMeta.Monitor.VerifyingJobEntry.Title", entry.getName())); //$NON-NLS-1$ //$NON-NLS-2$
				entry.check(remarks, this);
				if (monitor != null) {
					monitor.worked(1); // progress bar...
					if (monitor.isCanceled()) {
						stop_checking = true;
					}
				}
			}
		}
		if (monitor != null) {
			monitor.worked(1);
		}
	}
	if (monitor != null) {
		monitor.done();
	}
}
 

import org.pentaho.di.core.ProgressMonitorListener; //导入依赖的package包/类
private void exportJobs(ProgressMonitorListener monitor, RepositoryDirectory dirTree, OutputStreamWriter writer) throws KettleException
{
	try {
     // Loop over all the directory id's
     long dirids[] = dirTree.getDirectoryIDs();
     System.out.println("Going through "+dirids.length+" directories in directory ["+dirTree.getPath()+"]");
	 
     if (monitor!=null) monitor.subTask("Exporting the jobs...");
     
     for (int d=0;d<dirids.length && (monitor==null || (monitor!=null && !monitor.isCanceled()));d++)
     {
         RepositoryDirectory repdir = dirTree.findDirectory(dirids[d]);
	
         String jobs[]  = getJobNames(dirids[d]);
         for (int i=0;i<jobs.length && (monitor==null || (monitor!=null && !monitor.isCanceled()));i++)
         {
             try
             {
                 JobMeta ji = new JobMeta(log, this, jobs[i], repdir);
                 System.out.println("Loading/Exporting job ["+repdir.getPath()+" : "+jobs[i]+"]");
                 if (monitor!=null) monitor.subTask("Exporting job ["+jobs[i]+"]");
                 
                 writer.write(ji.getXML()+Const.CR);
             }
             catch(KettleException ke)
             {
                 log.logError(toString(), "An error occurred reading job ["+jobs[i]+"] from directory ["+repdir+"] : "+ke.getMessage());
                 log.logError(toString(), "Job ["+jobs[i]+"] from directory ["+repdir+"] was not exported because of a loading error!");
             }
         }
     }
	} catch(Exception e) {
		throw new KettleException("Error while exporting repository jobs", e);
	}
}
 

import org.pentaho.di.core.ProgressMonitorListener; //导入依赖的package包/类
private void exportTransformations(ProgressMonitorListener monitor, RepositoryDirectory dirTree, OutputStreamWriter writer) throws KettleException
{
	try {
     if (monitor!=null) monitor.subTask("Exporting the transformations...");
	
     // Loop over all the directory id's
     long dirids[] = dirTree.getDirectoryIDs();
     System.out.println("Going through "+dirids.length+" directories in directory ["+dirTree.getPath()+"]");
     
     for (int d=0;d<dirids.length && (monitor==null || (monitor!=null && !monitor.isCanceled()) );d++)
     {
         RepositoryDirectory repdir = dirTree.findDirectory(dirids[d]);
	
         System.out.println("Directory ID #"+d+" : "+dirids[d]+" : "+repdir);
	
         String trans[] = getTransformationNames(dirids[d]);
         for (int i=0;i<trans.length && (monitor==null || (monitor!=null && !monitor.isCanceled()));i++)
         {
             try
             {
                 TransMeta ti = new TransMeta(this, trans[i], repdir);
                 System.out.println("Loading/Exporting transformation ["+repdir.getPath()+" : "+trans[i]+"]  ("+ti.getDirectory().getPath()+")");
                 if (monitor!=null) monitor.subTask("Exporting transformation ["+trans[i]+"]");
                 
                 writer.write(ti.getXML()+Const.CR);
             }
             catch(KettleException ke)
             {
                 log.logError(toString(), "An error occurred reading transformation ["+trans[i]+"] from directory ["+repdir+"] : "+ke.getMessage());
                 log.logError(toString(), "Transformation ["+trans[i]+"] from directory ["+repdir+"] was not exported because of a loading error!");
             }
         }
     }
     if (monitor!=null) monitor.worked(1);
     
	} catch(Exception e) {
		throw new KettleException("Error while exporting repository transformations", e);
	}
}
 

import org.pentaho.di.core.ProgressMonitorListener; //导入依赖的package包/类
/**
 * This procedure determines the impact of the different steps in a transformation on databases, tables and field.
 *
 * @param impact An ArrayList of DatabaseImpact objects.
 *
 */
public void analyseImpact(List<DatabaseImpact> impact, ProgressMonitorListener monitor) throws KettleStepException
{
    if (monitor != null)
    {
        monitor.beginTask(Messages.getString("TransMeta.Monitor.DeterminingImpactTask.Title"), nrSteps()); //$NON-NLS-1$
    }
    boolean stop = false;
    for (int i = 0; i < nrSteps() && !stop; i++)
    {
        if (monitor != null) monitor.subTask(Messages.getString("TransMeta.Monitor.LookingAtStepTask.Title") + (i + 1) + "/" + nrSteps()); //$NON-NLS-1$ //$NON-NLS-2$
        StepMeta stepMeta = getStep(i);

        RowMetaInterface prev = getPrevStepFields(stepMeta);
        StepMetaInterface stepint = stepMeta.getStepMetaInterface();
        RowMetaInterface inform = null;
        StepMeta[] lu = getInfoStep(stepMeta);
        if (lu != null)
        {
            inform = getStepFields(lu);
        }
        else
        {
            inform = stepint.getTableFields();
        }

        stepint.analyseImpact(impact, this, stepMeta, prev, null, null, inform);

        if (monitor != null)
        {
            monitor.worked(1);
            stop = monitor.isCanceled();
        }
    }

    if (monitor != null) monitor.done();
}
 

import org.pentaho.di.core.ProgressMonitorListener; //导入依赖的package包/类
/**
 * Check a step to see if there are no multiple steps to read from.
 * If so, check to see if the receiving rows are all the same in layout.
 * We only want to ONLY use the DBCache for this to prevent GUI stalls.
 * 
 * @param stepMeta the step to check
 * @throws KettleRowException in case we detect a row mixing violation
 *
 */
public void checkRowMixingStatically(StepMeta stepMeta, ProgressMonitorListener monitor) throws KettleRowException
{
   int nrPrevious = findNrPrevSteps(stepMeta);
   if (nrPrevious>1)
   {
       RowMetaInterface referenceRow = null;
       // See if all previous steps send out the same rows...
       for (int i=0;i<nrPrevious;i++)
       {
           StepMeta previousStep = findPrevStep(stepMeta, i);
           try
           {
               RowMetaInterface row = getStepFields(previousStep, monitor); // Throws KettleStepException
               if (referenceRow==null)
               {
                   referenceRow = row;
               }
               else
               {
                   if ( ! stepMeta.getStepMetaInterface().excludeFromRowLayoutVerification())
                   {
                	   BaseStep.safeModeChecking(referenceRow, row);
                   }                       
               }
           }
           catch(KettleStepException e)
           {
               // We ignore this one because we are in the process of designing the transformation, anything intermediate can go wrong.
           }
       }
   }
}
 

import org.pentaho.di.core.ProgressMonitorListener; //导入依赖的package包/类
/**
 * Check all job entries within the job. Each Job Entry has the opportunity
 * to check their own settings.
 * 
 * @param remarks
 *            List of CheckResult remarks inserted into by each JobEntry
 * @param only_selected
 *            true if you only want to check the selected jobs
 * @param monitor
 *            Progress monitor (not presently in use)
 */
public void checkJobEntries(List<CheckResultInterface> remarks, boolean only_selected, ProgressMonitorListener monitor) {
	remarks.clear(); // Empty remarks
	if (monitor != null)
		monitor.beginTask(BaseMessages.getString(PKG, "JobMeta.Monitor.VerifyingThisJobEntryTask.Title"), jobcopies.size() + 2); //$NON-NLS-1$
	boolean stop_checking = false;
	for (int i = 0; i < jobcopies.size() && !stop_checking; i++) {
		JobEntryCopy copy = jobcopies.get(i); // get the job entry copy
		if ((!only_selected) || (only_selected && copy.isSelected())) {
			JobEntryInterface entry = copy.getEntry();
			if (entry != null) {
				if (monitor != null)
					monitor.subTask(BaseMessages.getString(PKG, "JobMeta.Monitor.VerifyingJobEntry.Title", entry.getName())); //$NON-NLS-1$ //$NON-NLS-2$
				entry.check(remarks, this);
				if (monitor != null) {
					monitor.worked(1); // progress bar...
					if (monitor.isCanceled()) {
						stop_checking = true;
					}
				}
			}
		}
		if (monitor != null) {
			monitor.worked(1);
		}
	}
	if (monitor != null) {
		monitor.done();
	}
}
 

import org.pentaho.di.core.ProgressMonitorListener; //导入依赖的package包/类
public void save(RepositoryElementInterface repositoryElement, String versionComment, ProgressMonitorListener monitor, ObjectId parentId, boolean used) throws KettleException {
	try {
		if (!(repositoryElement instanceof XMLInterface) && !(repositoryElement instanceof SharedObjectInterface)) {
			throw new KettleException("Class ["+repositoryElement.getClass().getName()+"] needs to implement the XML Interface in order to save it to disk");
		}
		
		if (!Const.isEmpty(versionComment)) {
			insertLogEntry(versionComment);
		}
		
		ObjectId objectId = new StringObjectId(calcObjectId(repositoryElement));
		
		FileObject fileObject = getFileObject(repositoryElement);
		
		String xml = ((XMLInterface)repositoryElement).getXML();
		
		OutputStream os = KettleVFS.getOutputStream(fileObject, false);
		os.write(xml.getBytes(Const.XML_ENCODING));
		os.close();
		
		if (repositoryElement instanceof ChangedFlagInterface) {
		  ((ChangedFlagInterface)repositoryElement).clearChanged();
		}
		
		// See if the element was already saved in the repository.
		// If the object ID is different, then we created an extra copy.
		// If so, we need to now remove the old file to prevent us from having multiple copies.
		//
		if (repositoryElement.getObjectId()!=null && !repositoryElement.getObjectId().equals(objectId)) {
			delObject(repositoryElement.getObjectId());
		}

		repositoryElement.setObjectId(objectId);
	} catch(Exception e) {
		throw new KettleException("Unable to save repository element ["+repositoryElement+"] to XML file : "+calcFilename(repositoryElement), e);
	}
}