Examples of nexj.core.meta.persistence.sql.upgrade.RelationalSchemaUpgrade

Package nexj.core.meta.persistence.sql.upgrade

Examples of nexj.core.meta.persistence.sql.upgrade.RelationalSchemaUpgrade

nexj.core.meta.persistence.sql.upgrade.RelationalSchemaUpgrade
Relational schema version upgrade.

      DataSource ds = mapping.getDataSource();


      if (ds instanceof RelationalDatabase) // SysVersion persisted in RDBMS
      {
         Table table = ((RelationalMapping)mapping).getPrimaryTable();
         RelationalSchemaUpgrade version = new RelationalSchemaUpgrade(sName);
         ExecStep step = new ExecStep();
         SQLScript script = new SQLScript();
         SQLStatement stmt = new SQLStatement();


         stmt.setSQL("update ${table:"+ table.getName() +"} set " +
                     table.getColumn("loaded").getQuotedName() + "=0");
         script.addStatement(stmt);
         step.getScriptHolder().addScript(script);
         version.setDataSource(ds);
         version.addStep(step);


         return version;
      }


      // SysVersion accessible via a Scheme function
      ScriptUpgrade version = new ScriptUpgrade(sName);


      // (SysVersion 'unload)
      version.setBody(
         Pair.list(
            Pair.list(versionClass.getSymbol(), Pair.list(Symbol.QUOTE, Symbol.define("unload")))));
      version.setUpgrade(upgrade); // required for compile() to work
      version.compile(machine);


      return version;
   }

View Full Code Here


         // check for adapter compatibility limiting just to the requested datasource
         if (version instanceof RelationalSchemaUpgrade &&
             ((RelationalSchemaUpgrade)version).getDataSource() == rdb)
         {
            RelationalSchemaUpgrade upgradeVersion = (RelationalSchemaUpgrade)version;
            DataSourceAdapter adapter = upgradeVersion.getDataSource().getAdapter();


            // state already supports adapter
            if (((RelationalSchemaUpgradeState)state).containsAdapter(adapter))
            {
               return version;
            }


            // step through each step, if the AdapterStep enabling the specific adapter is at the
            // beginning of the step list or only has other AdapterSteps before it then this version
            // is compatible
            for (int i = 0, nCount = upgradeVersion.getStepCount(); i < nCount; ++i)
            {
               RelationalSchemaUpgradeStep step = upgradeVersion.getStep(i);


               if (step instanceof SupportAdapterStep)
               {
                  if (((SupportAdapterStep)step).getAdapter() == adapter)
                  {

View Full Code Here


         for (VersionUpgrade u = version; u != null; u = u.getNext())
         {
            if (u instanceof RelationalSchemaUpgrade)
            {
               RelationalSchemaUpgrade rsu = (RelationalSchemaUpgrade)u;


               if (rsu.getDataSource().getSchema() == schema)
               {
                  RelationalSchemaUpgradeState state =
                     (RelationalSchemaUpgradeState)Upgrade.getState(stateMap, u);


                  for (int i = 0, nCount = rsu.getStepCount(); i < nCount; ++i)
                  {
                     rsu.getStep(i).apply(state); // apply every every step off this upgrade
                  }


                  addDropTable(tableMap, state.getSchema()); // add any differing definitions
               }
            }

View Full Code Here

               buf.setLength(0);
            }


            if (u instanceof RelationalSchemaUpgrade)
            {
               RelationalSchemaUpgrade rsu = (RelationalSchemaUpgrade)u;


               if (rsu.getDataSource().getSchema() == schema)
               {
                  RelationalSchemaUpgradeState state = (RelationalSchemaUpgradeState)Upgrade.getState(stateMap, u);


                  do
                  {

View Full Code Here

    * @see nexj.core.meta.persistence.XMLPersistenceMetadataLoader#loadUpgrade(org.w3c.dom.Element, java.lang.String, nexj.core.meta.persistence.DataSource, nexj.core.meta.xml.XMLMetadataHelper)
    */
   public SchemaUpgrade loadUpgrade(Element upgradeElement, final String sName,
      final DataSource dataSource, final XMLMetadataHelper helper)
   {
      final RelationalSchemaUpgrade upgrade = new RelationalSchemaUpgrade(sName);


      m_helper = helper;
      m_schema = (RelationalSchema)dataSource.getSchema();
      upgrade.setDataSource(dataSource);


      XMLUtil.forEachChildElement(upgradeElement, null, helper.new ElementHandler("step")
      {
         private int m_nOrdinal;


         protected void handleElement(Element stepElement, final String sExecOrdinal)
         {
            String sElement = stepElement.getNodeName();


            if (sElement.equals("CreateTable"))
            {
               final CreateTableStep create = new CreateTableStep();


               create.setType(parseTableType(XMLUtil.getStringAttr(stepElement, "type"), create.getType()));
               create.setName(XMLMetadataHelper.getNameAttr(stepElement, "name", XMLMetadataHelper.NAME_DOT));
               create.setAlias(XMLUtil.getStringAttr(stepElement, "alias"));
               create.setTablespaceName(XMLUtil.getStringAttr(stepElement, "tablespace"));
               create.setIndexspaceName(XMLUtil.getStringAttr(stepElement, "indexspace"));
               create.setLongspaceName(XMLUtil.getStringAttr(stepElement, "longspace"));


               XMLMetadataLoader.parsePatterns(XMLUtil.getStringAttr(stepElement, "aspects"),
                  new XMLMetadataLoader.PatternHandler()
                  {
                     public void handlePattern(final String sName, final boolean bInclusive)
                     {
                        create.addAspectOverride(sName, bInclusive);
                     }
                  });


               XMLMetadataLoader.parsePatterns(XMLUtil.getStringAttr(stepElement, "pointcuts"),
                  new XMLMetadataLoader.PatternHandler()
                  {
                     public void handlePattern(final String sPattern, final boolean bInclusive)
                     {
                        create.addPointcutPattern(sPattern, bInclusive);
                     }
                  });


               XMLUtil.withFirstChildElement(stepElement, "Columns", false, new ElementHandler()
               {
                  public void handleElement(Element columnsElement)
                  {
                     XMLUtil.forEachChildElement(columnsElement, "Column",
                        getHelper().new ElementHandler("column")
                     {
                        public void handleElement(Element columnElement, String sColumnName)
                        {
                           ColumnOutline outline = new ColumnOutline();


                           loadColumnOutline(columnElement, outline, true);
                           create.addColumnOutline(outline);
                        }
                     });
                  }
               });
               
               XMLUtil.withFirstChildElement(stepElement, "Indexes", false, new ElementHandler()
               {
                  public void handleElement(Element indexesElement)
                  {
                     XMLUtil.forEachChildElement(indexesElement, "Index",
                        getHelper().new ElementHandler("index")
                     {
                        public void handleElement(Element indexElement, String sIndexName)
                        {
                           IndexOutline outline = new IndexOutline();


                           loadIndexOutline(indexElement, outline);
                           create.addIndexOutline(outline);
                        }
                     });
                  }
               });


               XMLUtil.withFirstChildElement(stepElement, "View", false, new ElementHandler()
               {
                  public void handleElement(Element viewElement)
                  {
                     final SQLScript script = new SQLScript();


                     loadSQLScript(viewElement, script);
                     create.setViewScript(script);
                     create.setViewAutoUpdated(
                        XMLUtil.getBooleanAttr(
                           viewElement, "autoupdated", create.isViewAutoUpdated()));
                  }
               });


               String sHints = XMLUtil.getStringAttr(stepElement, "hints");


               if (sHints != null)
               {
                  for (StringTokenizer tokenizer = new StringTokenizer(sHints);
                       tokenizer.hasMoreTokens();)
                  {
                     create.addHint(tokenizer.nextToken());
                  }
               }


               create.setPrimaryKeyName((create.getType() == Table.ASPECT) ?
                  XMLUtil.getStringAttr(stepElement, "primaryKey") :
                  XMLUtil.getReqStringAttr(stepElement, "primaryKey"));


               upgrade.addStep(create);
            }
            else if (sElement.equals("AlterTable"))
            {
               final AlterTableStep alter = new AlterTableStep();


               alter.setType(parseTableType(XMLUtil.getStringAttr(stepElement, "type"), alter.getType()));
               alter.setName(XMLMetadataHelper.getNameAttr(stepElement, "name", XMLMetadataHelper.NAME_DOT));
               alter.setAlias(XMLUtil.getStringAttr(stepElement, "alias"));
               alter.setPrimaryKeyName(XMLUtil.getStringAttr(stepElement, "primaryKey"));


               XMLMetadataLoader.parsePatterns(
                  XMLUtil.getStringAttr(stepElement, "hints"),
                  new XMLMetadataLoader.PatternHandler()
               {
                  public void handlePattern(String sName, boolean bEnabled)
                  {
                     alter.setHint(sName, bEnabled);
                  }
               });


               upgrade.addStep(alter);
            }
            else if (sElement.equals("RenameTable"))
            {
               RenameTableStep ren = new RenameTableStep();


               ren.setOldName(XMLMetadataHelper.getNameAttr(stepElement, "name", XMLMetadataHelper.NAME_DOT));
               ren.setNewName(XMLMetadataHelper.getNameAttr(stepElement, "to", XMLMetadataHelper.NAME_DOT));


               upgrade.addStep(ren);
            }
            else if (sElement.equals("DropTable"))
            {
               DropTableStep drop = new DropTableStep();


               drop.setName(XMLMetadataHelper.getNameAttr(stepElement, "name", XMLMetadataHelper.NAME_DOT));


               upgrade.addStep(drop);
            }
            else if (sElement.equals("ApplyTableAspect"))
            {
               final ApplyTableAspectStep apply = new ApplyTableAspectStep();


               apply.setAspectName(XMLMetadataHelper.getNameAttr(stepElement, "name", XMLMetadataHelper.NAME_DOT));
               apply.setOverride(XMLUtil.getBooleanAttr(stepElement, "override", apply.isOverride()));


               XMLMetadataLoader.parsePatterns(XMLUtil.getStringAttr(stepElement, "pointcuts"),
                  new XMLMetadataLoader.PatternHandler()
                  {
                     public void handlePattern(String sPattern, boolean bInclusive)
                     {
                        apply.addPointcutPattern(sPattern, bInclusive);
                     }
                  });


               loadSQLScripts(stepElement, apply.getScriptHolder());


               upgrade.addStep(apply);
            }
            else if (sElement.equals("RemoveTableAspect"))
            {
               final RemoveTableAspectStep remove = new RemoveTableAspectStep();


               remove.setAspectName(XMLMetadataHelper.getNameAttr(stepElement, "name", XMLMetadataHelper.NAME_DOT));
               remove.setOverride(XMLUtil.getBooleanAttr(stepElement, "override", remove.isOverride()));


               XMLMetadataLoader.parsePatterns(XMLUtil.getStringAttr(stepElement, "pointcuts"),
                  new XMLMetadataLoader.PatternHandler()
                  {
                     public void handlePattern(String sPattern, boolean bInclusive)
                     {
                        remove.addPointcutPattern(sPattern, bInclusive);
                     }
                  });


               upgrade.addStep(remove);
            }
            else if (sElement.equals("CreateColumn"))
            {
               CreateColumnStep create = new CreateColumnStep();


               create.setTableName(XMLMetadataHelper.getNameAttr(stepElement, "table", XMLMetadataHelper.NAME_DOT));


               ColumnOutline outline = new ColumnOutline();


               loadColumnOutline(stepElement, outline, true);
               create.setOutline(outline);


               loadSQLScripts(stepElement, create.getScriptHolder());


               upgrade.addStep(create);
            }
            else if (sElement.equals("AlterColumn"))
            {
               AlterColumnStep alter = new AlterColumnStep();


               alter.setTableName(XMLMetadataHelper.getNameAttr(stepElement, "table", XMLMetadataHelper.NAME_DOT));


               ColumnOutline outline = new ColumnOutline();


               loadColumnOutline(stepElement, outline, false);
               alter.setOutline(outline);


               upgrade.addStep(alter);
            }
            else if (sElement.equals("RenameColumn"))
            {
               RenameColumnStep ren = new RenameColumnStep();


               ren.setTableName(XMLMetadataHelper.getNameAttr(stepElement, "table", XMLMetadataHelper.NAME_DOT));
               ren.setOldName(XMLMetadataHelper.getNameAttr(stepElement, "name", XMLMetadataHelper.NAME_ID));
               ren.setNewName(XMLMetadataHelper.getNameAttr(stepElement, "to", XMLMetadataHelper.NAME_ID));


               upgrade.addStep(ren);
            }
            else if (sElement.equals("DropColumn"))
            {
               DropColumnStep drop = new DropColumnStep();


               drop.setTableName(XMLMetadataHelper.getNameAttr(stepElement, "table", XMLMetadataHelper.NAME_DOT));
               drop.setName(XMLMetadataHelper.getNameAttr(stepElement, "name", XMLMetadataHelper.NAME_ID));


               upgrade.addStep(drop);
            }
            else if (sElement.equals("CreateIndex"))
            {
               CreateIndexStep create = new CreateIndexStep();


               create.setTableName(XMLMetadataHelper.getNameAttr(stepElement, "table", XMLMetadataHelper.NAME_DOT));


               IndexOutline outline = new IndexOutline();


               loadIndexOutline(stepElement, outline);


               create.setOutline(outline);


               upgrade.addStep(create);
            }
            else if (sElement.equals("RenameIndex"))
            {
               RenameIndexStep ren = new RenameIndexStep();


               ren.setOldName(XMLMetadataHelper.getNameAttr(stepElement, "name", XMLMetadataHelper.NAME_DOT));
               ren.setNewName(XMLMetadataHelper.getNameAttr(stepElement, "to", XMLMetadataHelper.NAME_DOT));


               upgrade.addStep(ren);
            }
            else if (sElement.equals("DropIndex"))
            {
               DropIndexStep drop = new DropIndexStep();


               drop.setName(XMLMetadataHelper.getNameAttr(stepElement, "name", XMLMetadataHelper.NAME_DOT));


               upgrade.addStep(drop);
            }
            else if (sElement.equals("ApplyIndexAspect"))
            {
               final ApplyIndexAspectStep apply = new ApplyIndexAspectStep();


               apply.setAspectName(XMLMetadataHelper.getNameAttr(stepElement, "name", XMLMetadataHelper.NAME_DOT));
               apply.setOverride(XMLUtil.getBooleanAttr(stepElement, "override", apply.isOverride()));


               XMLMetadataLoader.parsePatterns(XMLUtil.getStringAttr(stepElement, "pointcuts"),
                  new XMLMetadataLoader.PatternHandler()
                  {
                     public void handlePattern(String sPattern, boolean bInclusive)
                     {
                        apply.addPointcutPattern(sPattern, bInclusive);
                     }
                  });


               upgrade.addStep(apply);
            }
            else if (sElement.equals("RemoveIndexAspect"))
            {
               final RemoveIndexAspectStep remove = new RemoveIndexAspectStep();


               remove.setAspectName(XMLMetadataHelper.getNameAttr(stepElement, "name", XMLMetadataHelper.NAME_DOT));
               remove.setOverride(XMLUtil.getBooleanAttr(stepElement, "override", remove.isOverride()));


               XMLMetadataLoader.parsePatterns(XMLUtil.getStringAttr(stepElement, "pointcuts"),
                  new XMLMetadataLoader.PatternHandler()
                  {
                     public void handlePattern(String sPattern, boolean bInclusive)
                     {
                        remove.addPointcutPattern(sPattern, bInclusive);
                     }
                  });


               upgrade.addStep(remove);
            }
            else if (sElement.equals("CreateObject"))
            {
               CreateObjectStep create = new CreateObjectStep();
               SQLScript script = new SQLScript();


               create.setName(
                  XMLMetadataHelper.getNameAttr(stepElement, "name", XMLMetadataHelper.NAME_DOT));
               loadSQLScript(stepElement, script);
               create.setScript(script);
               upgrade.addStep(create);
            }
            else if (sElement.equals("DropObject"))
            {
               DropObjectStep drop = new DropObjectStep();
               SQLScript script = new SQLScript();


               drop.setName(
                  XMLMetadataHelper.getNameAttr(stepElement, "name", XMLMetadataHelper.NAME_DOT));
               loadSQLScript(stepElement, script);
               drop.setScript(script);
               upgrade.addStep(drop);
            }
            else if (sElement.equals("Exec"))
            {
               final ExecStep exec = new ExecStep();


               exec.setUpgrade(upgrade);
               loadSQLScripts(stepElement, exec.getScriptHolder());


               upgrade.addStep(exec);
            }
            else if (sElement.equals("SupportAdapter"))
            {
               SupportAdapterStep adapter = new SupportAdapterStep();


               adapter.setAdapter(
                  dataSource.getType().getAdapter(XMLUtil.getStringAttr(stepElement, "name")));
               upgrade.addStep(adapter);
            }
            else
            {
               throw new MetadataException("err.meta.persistence.sql.upgrade.invalidStepElement",
                  new Object[]{sElement, sName});

View Full Code Here

      }
   }


   public void testHint()
   {
      RelationalSchemaUpgrade version = // version testing hints upgrade
         (RelationalSchemaUpgrade)getMetadata().getUpgrade("Main").getVersion("15");
      RelationalSchemaUpgradeState state =
         (RelationalSchemaUpgradeState)Upgrade.getState(Upgrade.getInitialState(version), version);


      assertNull(state.getSchema().findTable("A"));
      version.getStep(0).apply(state); // CreateTable


      Table table = state.getSchema().getTable("A");
      Iterator/*<String>*/ itr = table.getHintIterator();


      itr.next(); // 1st hint
      itr.next(); // 2nd hint
      assertFalse(itr.hasNext());
      assertTrue(table.isHintEnabled("test1"));
      assertTrue(table.isHintEnabled("test2"));
      version.getStep(1).apply(state); // AlterTable


      itr = table.getHintIterator();
      itr.next(); // 1st hint
      itr.next(); // 2nd hint
      assertFalse(itr.hasNext());

View Full Code Here

   }


   public void testViewScriptUpgradeMismtch()
   {
      Upgrade upgrade = new Upgrade(null);
      RelationalSchemaUpgrade version = new RelationalSchemaUpgrade("test");
      XMLMetadata metadata = new XMLMetadata(null, null, null, null, null);
      RelationalDatabase ds = new RelationalDatabase(null);
      RelationalSchema schema = new RelationalSchema();
      CreateTableStep step = new CreateTableStep(); // only step that can populate ViewScript
      Table table = new Table(schema);
      SQLScript finalScript = new SQLScript();
      SQLScript upgradeScript = new SQLScript();
      SQLStatement finalStmt = new SQLStatement();
      SQLStatement upgradeStmt = new SQLStatement();


      upgradeStmt.addAdapter("*", m_database.getSchema().getDataSource().getType());
      finalStmt.addAdapter("*", m_database.getSchema().getDataSource().getType());
      upgradeStmt.setSQL("upgrade view SQL");
      finalStmt.setSQL("final view SQL");
      upgradeScript.addStatement(upgradeStmt);
      finalScript.addStatement(finalStmt);
      table.setName("testTable");
      table.setType(Table.VIEW);
      step.setName(table.getName());
      step.setType(table.getType());
      step.setViewScript(upgradeScript);
      schema.addTable(table);
      schema.setDataSource(ds);
      ds.setAdapter(m_database.getSchema().getDataSource().getAdapter());
      ds.setSchema(schema);
      ds.setType(new DataSourceType(null));
      ds.getType().setMetadata(metadata);
      version.setDataSource(ds);
      version.addStep(step);
      metadata.setVersion(version.getName());
      upgrade.setMetadata(metadata);
      upgrade.addVersion(version);
      table.setViewScript(finalScript);


      try

View Full Code Here

      XMLMetadata metadata = new XMLMetadata(null, null, null, null, null)
      {
         public Upgrade getUpgrade(String sName) { return upgrade; }
      };
      SQLSchemaManager manager = m_adapter.createSchemaManager();
      RelationalSchemaUpgrade upgradeVersion;


      ds.setAdapter(valid);
      ds.setComponent(new Component("Component"));
      ds.setSchema(schema);
      ds.setType(new DataSourceType("DataSourceType"));
      ds.getType().setMetadata(metadata);
      ds.getType().addAdapter(ds.getAdapter());
      ds.getType().addAdapter(invalid);
      ((RelationalDatabaseFragment)ds.getDefaultFragment()).setDatabase("Database");
      metadata.addDataSource(ds);
      manager.setSQLAppender(manager.new SQLWriterAppender(buf));
      schema.setVersionTable(new Table(schema));
      schema.getVersionTable().setName("VersionTable");
      schema.addTable(schema.getVersionTable());
      upgrade.setMetadata(metadata);


      // setup for first upgrade version
      ExecStep execStep = new ExecStep(); // step lacking match for current adapter
      SQLScript stepScript = new SQLScript();
      SQLStatement stepStmt = new SQLStatement();


      stepStmt.addAdapter(invalid.getName(), ds.getType());
      stepStmt.setSQL("SQLStatement SQL");
      stepScript.addStatement(stepStmt);
      execStep.getScriptHolder().addScript(stepScript);


      // single incompatible step
      metadata.setVersion("1-step");
      upgradeVersion = new RelationalSchemaUpgrade(metadata.getVersion());
      upgradeVersion.addStep(execStep);
      upgradeVersion.setDataSource(ds);
      upgrade.addVersion(upgradeVersion);


      try
      {
         upgrade.validate(null, null); // must fail since an incompatible step "1-step" exists
         fail(); // exception expected
      }
      catch (MetadataException e)
      {
         assertTrue(e.getCause() instanceof MetadataException);
         e = (MetadataException)e.getCause();
         assertTrue(e.getCause() instanceof MetadataException);
         e = (MetadataException)e.getCause();
         assertTrue(e.getCause() instanceof MetadataException);
         e = (MetadataException)e.getCause();
         assertEquals("err.meta.sql.statementAdapter", e.getErrorCode());
      }


      try
      {
         manager.upgrade(schema, null); //must fail since no compatible versions found to start with
         fail(); // exception expected
      }
      catch (MetadataException e)
      {
         assertTrue(e.getCause() instanceof MetadataException);
         e = (MetadataException)e.getCause();
         assertTrue(e.getCause() instanceof MetadataException);
         e = (MetadataException)e.getCause();
         assertTrue(e.getCause() instanceof MetadataException);
         e = (MetadataException)e.getCause();
         assertEquals("err.meta.sql.statementAdapter", e.getErrorCode());
      }


      try
      {
         manager.upgrade(schema, "1-step"); // must fail since step "1-step" is incompatible
         fail(); // exception expected
      }
      catch (MetadataException e)
      {
         assertTrue(e.getCause() instanceof MetadataException);
         e = (MetadataException)e.getCause();
         assertTrue(e.getCause() instanceof MetadataException);
         e = (MetadataException)e.getCause();
         assertTrue(e.getCause() instanceof MetadataException);
         e = (MetadataException)e.getCause();
         assertEquals("err.meta.sql.statementAdapter", e.getErrorCode());
      }


      // setup for second upgrade version
      SupportAdapterStep adapterStep = new SupportAdapterStep();
      CreateTableStep createTableStep = new CreateTableStep(); // step has match for current adapter
      Table table = new Table(schema);
      SQLScript tableScript = new SQLScript();
      SQLStatement tableStmtInvalid = new SQLStatement();
      SQLStatement tableStmtValid = new SQLStatement();


      tableStmtInvalid.addAdapter(invalid.getName(), ds.getType());
      tableStmtInvalid.setSQL("SQLStatement Table SQL Invalid");
      tableStmtValid.addAdapter(ds.getAdapter().getName(), ds.getType());
      tableStmtValid.setSQL("SQLStatement Table SQL Valid");
      tableScript.addStatement(tableStmtValid);
      tableScript.addStatement(tableStmtInvalid);
      tableScript.addStatement(stepStmt);
      table.setName("Table");
      table.setType(Table.VIEW);
      table.setViewScript(tableScript);
      schema.addTable(table);
      createTableStep.setName(table.getName());
      createTableStep.setType(table.getType());
      createTableStep.setViewScript(tableScript);
      adapterStep.setAdapter(invalid);


      // incompatible step -> compatible step
      metadata.setVersion("2-step");
      upgradeVersion = new RelationalSchemaUpgrade(metadata.getVersion());
      upgradeVersion.addStep(adapterStep);
      upgradeVersion.addStep(createTableStep);
      upgradeVersion.setDataSource(ds);
      upgrade.addVersion(upgradeVersion);


      try
      {
         upgrade.validate(null, null); // must fail since an incompatible step "1-step" exists
         fail(); // exception expected
      }
      catch (MetadataException e)
      {
         assertTrue(e.getCause() instanceof MetadataException);
         e = (MetadataException)e.getCause();
         assertTrue(e.getCause() instanceof MetadataException);
         e = (MetadataException)e.getCause();
         assertTrue(e.getCause() instanceof MetadataException);
         e = (MetadataException)e.getCause();
         assertEquals("err.meta.sql.statementAdapter", e.getErrorCode());
      }


      try
      {
         manager.upgrade(schema, null); // must fail since an incompatible step "1-step" exists
         fail(); // exception expected
      }
      catch (MetadataException e)
      {
         assertTrue(e.getCause() instanceof MetadataException);
         e = (MetadataException)e.getCause();
         assertTrue(e.getCause() instanceof MetadataException);
         e = (MetadataException)e.getCause();
         assertTrue(e.getCause() instanceof MetadataException);
         e = (MetadataException)e.getCause();
         assertEquals("err.meta.sql.statementAdapter", e.getErrorCode());
      }


      buf.getBuffer().setLength(0);
      ds.setAdapter(invalid);
      manager.upgrade(schema, "2-step"); // validation of invalid adapter should not be prevented
      AssertUtil.assertContained(tableStmtInvalid.getSQL(), buf.toString());
      ds.setAdapter(valid);


      try
      {
         manager.upgrade(schema, "2-step"); // must fail since validating current adapter from start
         fail(); // exception expected
      }
      catch (MetadataException e)
      {
         assertTrue(e.getCause() instanceof MetadataException);
         e = (MetadataException)e.getCause();
         assertTrue(e.getCause() instanceof MetadataException);
         e = (MetadataException)e.getCause();
         assertTrue(e.getCause() instanceof MetadataException);
         e = (MetadataException)e.getCause();
         assertEquals("err.meta.sql.statementAdapter", e.getErrorCode());
      }


      adapterStep.setAdapter(ds.getAdapter());
      upgrade.validate(null, null); // must pass since adapter validation from "2-step"
      buf.getBuffer().setLength(0);
      manager.upgrade(schema, null); // must upgrade starting from "2-step"
      AssertUtil.assertContained(tableStmtValid.getSQL(), buf.toString());


      // setup for third upgrade version
      CreateColumnStep createColumnStep = new CreateColumnStep(); // step lacking match for adapter
      Column column = new Column("Column", table);
      ColumnOutline outline = new ColumnOutline(column.getName());


      column.setType(Primitive.INTEGER);
      table.addColumn(column);
      outline.setType(column.getType());
      createColumnStep.setOutline(outline);
      createColumnStep.setTableName(table.getName());
      createColumnStep.getScriptHolder().addScript(stepScript);


      // incompatible step -> compatible step -> incompatible step
      metadata.setVersion("3-step");
      upgradeVersion = new RelationalSchemaUpgrade(metadata.getVersion());
      upgradeVersion.addStep(createColumnStep);
      upgradeVersion.setDataSource(ds);
      upgrade.addVersion(upgradeVersion);


      try
      {
         upgrade.validate(null, null);//must fail since an incompatible step exists after compatible

View Full Code Here

         RelationalSchemaTest.addHint(schema, "test3");
      }


      RelationalSchemaUpgradeState state = new RelationalSchemaUpgradeState(schema, null, null);
      SchemaVersion version = new SchemaVersion();
      RelationalSchemaUpgrade upgrade = new RelationalSchemaUpgrade();
      SQLAppender origAppender = m_manager.getSQLAppender();


      upgrade.addStep(step);
      upgrade.setUpgrade(new Upgrade(null));
      m_manager.setSQLAppender(
         (writer == null) ? new SQLSchemaManager.SQLConnectionAppender(m_connection.getConnection())
                          : (SQLAppender)m_manager.new SQLWriterAppender(writer));


      try

View Full Code Here

TOP

Related Classes of nexj.core.meta.persistence.sql.upgrade.RelationalSchemaUpgrade

nexj.core.meta.persistence.sql.RelationalSchema

nexj.core.meta.persistence.sql.XMLRelationalMetadataLoader

nexj.core.meta.upgrade.LoadUpgrade

nexj.core.persistence.sql.SQLSchemaManager

nexj.core.persistence.sql.SQLSchemaManagerTest

nexj.core.meta.MetadataCompoundValidationException

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.