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

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

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

nexj.core.meta.persistence.sql.upgrade.CreateTableStep
Upgrade step for creating a new table.

         {
            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();

View Full Code Here

      m_connection = m_adapter.getConnection();
      m_manager.setOwner("test"); // same as in lock() during schema creation
      m_manager.setConnection(m_connection.getConnection());


      SQLUtil.execute(m_connection.getConnection(), getSQLScript(ST_DROP));
      m_doubleColTableStep = new CreateTableStep();
      m_singleColTableStep = new CreateTableStep();
      m_singleIdxColTableStep = new CreateTableStep();
      m_singlePKColTableStep = new CreateTableStep();
      m_doubleColTableStep.setName(((RelationalSchema)m_database.getSchema()).getPrefix() + "a");
      m_singleColTableStep.setName(m_doubleColTableStep.getName());   // readSchema() returns
      m_singleIdxColTableStep.setName(m_doubleColTableStep.getName()); // prefixed table names
      m_singlePKColTableStep.setName(m_doubleColTableStep.getName());

View Full Code Here

      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));

View Full Code Here

         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());

View Full Code Here

TOP

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

nexj.core.meta.Aspect

nexj.core.meta.AspectManager

nexj.core.meta.persistence.sql.Column

nexj.core.meta.persistence.sql.Index

nexj.core.meta.persistence.sql.RelationalSchema

nexj.core.meta.persistence.sql.RelationalSchemaAspectManager

nexj.core.meta.persistence.sql.Table

nexj.core.meta.persistence.sql.XMLRelationalMetadataLoader

nexj.core.persistence.sql.SQLSchemaManagerTest

nexj.core.meta.MetadataLookupException

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.