Examples of nexj.core.meta.persistence.sql.Index

nexj.core.meta.persistence.sql.Index
Index or constraint defined for a given table.

      schema = upgrade(step, schema, null);
      table = schema.getTable(m_singleColTableStep.getName());
      assertNotNull(table);
      assertEquals(1, table.getIndexCount());


      Index index = table.getIndex(0);


      assertEquals(1, index.getIndexColumnCount());
      assertEquals("id", index.getIndexColumn(0).getColumn().getName());
   }

View Full Code Here

   {
      SQLAppender origAppender = m_manager.getSQLAppender();
      RelationalSchema schema = new RelationalSchema();
      Table table = new Table(schema);
      Column column = new Column("col", table);
      Index index = new Index("indx", Index.CLUSTER, table);


      table.setName("test"); // table name required to add table to schema, to add index to schema
      schema.addTable(table);
      column.setType(Primitive.INTEGER);
      table.addColumn(column);
      index.addIndexColumn(new IndexColumn(column, true));
      table.addIndex(index);
      table.setPrimaryKey(index);
      schema.setDataSource(m_database);


      // validate initial schema state
      assertEquals(1, schema.getIndexCount());
      assertEquals(index, schema.findIndex("indx"));


      try
      {
         m_manager.setSQLAppender(m_manager.new SQLWriterAppender(new StringWriter()));
         m_manager.discardIndex(index, true);
      }
      finally
      {
         m_manager.setSQLAppender(origAppender);
      }


      // schema definition is untouched
      assertEquals(1, schema.getIndexCount());
      assertEquals(index, schema.findIndex("indx"));


      // index either removed or renamed
      assertTrue(table.getIndexCount() == 0 || !index.getName().equals("indx"));
   }

View Full Code Here

      assertNotNull(table);
      assertEquals(1, table.getIndexCount());
      assertEquals(2, table.getIndex(0).getIndexColumnCount());
      table.setType(Table.MANAGED); // comes in as Table.EXTERNAL from DB


      Index aspect = new Index("aspect", Index.ASPECT, null);


      aspect.addIndexColumn(new IndexColumn(table.getColumn("value"), true));
      table.getIndex(0).addAspect(aspect);
      schema.addIndex(aspect);


      RemoveIndexAspectStep step = new RemoveIndexAspectStep();


      step.setAspectName("aspect");
      step.addPointcutPattern(table.getIndex(0).getName(), true);
      schema = upgrade(step, schema, null);
      table = schema.getTable(m_doubleColTableStep.getName());
      assertNotNull(table);
      assertEquals(1, table.getIndexCount());


      Index index = table.getIndex(0);


      assertEquals(1, index.getIndexColumnCount());
      assertEquals("id", index.getIndexColumn(0).getColumn().getName());
   }

View Full Code Here


         for (Iterator itr = schema.getTableIterator(); itr.hasNext();)
         {
            Table table = (Table)itr.next();
            String[] names = (String[])tableMap.get(table);
            Index index = null;
            boolean bIgnore = false;
            
            if (progress != null)
            {
               progress.progress("info.sql.schemaManager.readingIndexes", new Object[]{table.getName()},
                  0.20 + 0.50 * (nCurTable++ / nTableCount));
            }


            rs = getIndexInfo(
                    names[0], toDatabaseCase(names[1]), toDatabaseCase(table.getTableName()));


            while (rs.next())
            {
               String sIndexName = toMetadataCase(rs.getString("INDEX_NAME"));


               if (sIndexName == null)
               {
                  continue;
               }
               
               String sColumnName = rs.getString("COLUMN_NAME");
               boolean bAscending = !"D".equals(rs.getString("ASC_OR_DESC"));
               boolean bUnique = !rs.getBoolean("NON_UNIQUE");
               int nType = rs.getInt("TYPE");


               sIndexName = generateIndexName(table.getTableName(), sIndexName, null);


               if (s_logger.isDebugEnabled())
               {
                  s_logger.debug("Read index column \"" + sIndexName + "." +
                     sColumnName + "\", ascending=" + bAscending);
               }


               if (index != null && !index.getName().equals(sIndexName))
               {
                  if (!bIgnore)
                  {
                     if (addIndex(table, index))
                     {
                        bPortable &= isPortable(index);
                     }
                  }


                  index = null;
                  bIgnore = false;
               }


               if (index == null)
               {
                  index = new Index(sIndexName, (nType == DatabaseMetaData.tableIndexClustered)
                                                ? Index.CLUSTER : Index.BTREE, table);
                  index.setUnique(bUnique);
               }


               if (!isValidColumnName(sColumnName))
               {
                  if (isCaseInsensitive(sColumnName))
                  {
                     sColumnName = getCaseSensitiveName(sColumnName);
                  }
                  else if (isFunctionalIndexSupported())
                  {
                     String sExpr = rs.getString("EXPR");


                     if (sExpr != null && sExpr.length() != 0)
                     {
                        String sName = getCaseSensitiveNameFromExpression(sExpr);


                        if (sName == null)
                        {
                           bIgnore = true;
                        }
                        else
                        {
                           sColumnName = sName;
                        }
                     }
                  }
                  else
                  {
                     bIgnore = true;
                  }
               }


               sColumnName = toMetadataCase(sColumnName);


               if (!bIgnore)
               {
                  try
                  {
                     index.addIndexColumn(new IndexColumn(table.getColumn(sColumnName), bAscending));
                  }
                  catch (MetadataException e)
                  {
                     s_logger.error("Cannot find column \"" + sColumnName +
                        "\", ignoring index \"" + sIndexName + "\"", e);
                     bIgnore = true;
                  }
               }
            }


            if (index != null && !bIgnore)
            {
               if (addIndex(table, index))
               {
                  bPortable &= isPortable(index);
               }
            }


            rs.close();
            rs = null;


            // Read the primary key


            rs = getPrimaryKeys(names[0], names[1], table.getTableName());
            index = null;
            bIgnore = false;


            try
            {
               while (rs.next())
               {
                  String sColumnName = toMetadataCase(rs.getString("COLUMN_NAME"));
                  
                  if (index == null)
                  {
                     String sIndexName = rs.getString("PK_NAME");


                     if (sIndexName == null)
                     {
                        sIndexName = table.getName() + ".PK";
                        index = new Index(sIndexName, Index.BTREE, table);
                     }
                     else
                     {
                        sIndexName = generateIndexName(table.getTableName(), sIndexName, "PK");
                        index = table.findIndex(sIndexName);


                        if (index == null)
                        {
                           index = new Index(sIndexName, Index.BTREE, table);
                        }
                        else
                        {
                           table.setPrimaryKey(index);
                           bIgnore = true;


                           break;
                        }
                     }
                  }


                  if (s_logger.isDebugEnabled())
                  {
                     s_logger.debug("Read primary key column \"" + index.getName() + "." + sColumnName + "\"");
                  }


                  index.setUnique(true);
                  index.addIndexColumn(new IndexColumn(table.getColumn(sColumnName), true));
               }
            }
            catch (MetadataException e)
            {
               s_logger.error("Cannot add primary key to table \"" + table.getName() + "\"", e);
               bIgnore = true;
            }


            if (index != null)
            {
               if (!bIgnore)
               {
                  if (addIndex(table, index))
                  {
                     table.setPrimaryKey(index);
                     bPortable &= isPortable(index);
                  }
               }
            }
            else
            {
               for (int i = 0; i < table.getIndexCount(); ++i)
               {
                  index = table.getIndex(i);
                  
                  if (index.isUnique())
                  {
                     table.setPrimaryKey(index);
                     
                     break;
                  }
               }
            }
            
            if (s_logger.isDebugEnabled())
            {
               if (table.getPrimaryKey() != null)
               {
                  s_logger.debug("The primary key of table \"" + table.getName() +
                     "\" is \"" + table.getPrimaryKey().getName() + "\"");
               }
               else
               {
                  s_logger.debug("Table \"" + table.getName() + "\" has no primary key");
               }
            }


            rs.close();
            rs = null;
         }


         // Read the foreign keys


         nCurTable = 0;


         for (Iterator itr = schema.getTableIterator(); itr.hasNext();)
         {
            Table table = (Table)itr.next();
            String[] names = (String[])tableMap.get(table);
            Index index = null;
            boolean bIgnore = false;


            if (progress != null)
            {
               progress.progress("info.sql.schemaManager.readingForeignKeys", new Object[]{table.getName()},
                  0.70 + 0.30 * (nCurTable++ / nTableCount));
            }


            rs = dbmeta.getExportedKeys(names[0], names[1], table.getTableName());


            while (rs.next())
            {
               String sColumnName = toMetadataCase(rs.getString("FKCOLUMN_NAME"));
               String sSchemaName = rs.getString("FKTABLE_SCHEM");
               String sTableName = rs.getString("FKTABLE_NAME");
               String sIndexName = rs.getString("FK_NAME");


               Table foreignTable = schema.findTable(getFullTableName(sSchemaName, sTableName));


               if (foreignTable == null)
               {
                  continue;
               }


               sIndexName = generateIndexName(foreignTable.getTableName(), sIndexName, "FK" + (foreignTable.getIndexCount() + 1));


               if (index != null && !index.getName().equals(sIndexName))
               {
                  if (!bIgnore)
                  {
                     if (addIndex(index.getTable(), index))
                     {
                        addRelatedKey(table, index);
                        bPortable &= isPortable(index);
                     }
                  }


                  index = null;
                  bIgnore = false;
               }


               if (index == null)
               {
                  if (rs.getString("FK_NAME") == null)
                  {
                     index = new Index(sIndexName, Index.BTREE, foreignTable);
                  }
                  else
                  {
                     index = foreignTable.findIndex(sIndexName);
                     
                     if (index == null)
                     {
                        index = new Index(sIndexName, Index.BTREE, foreignTable);
                     }
                     else
                     {
                        addRelatedKey(table, index);
                        bIgnore = true;
                     }
                  }
               }


               if (s_logger.isDebugEnabled())
               {
                  s_logger.debug("Read foreign key column \"" + index.getName() + "." + sColumnName + "\"");
               }


               if (!bIgnore)
               {
                  index.setType(Index.BTREE);
                  index.setUnique(false);


                  try
                  {
                     index.addIndexColumn(new IndexColumn(index.getTable().getColumn(sColumnName),
                        table.getPrimaryKey().getIndexColumn(index.getIndexColumnCount()).isAscending()));
                  }
                  catch (MetadataException e)
                  {
                     s_logger.error("Cannot add foreign key column to index \"" + index.getName() + "\"", e);
                     bIgnore = true;
                  }
               }
            }


            if (index != null && !bIgnore)
            {
                if (addIndex(index.getTable(), index))
                {
                   addRelatedKey(table, index);
                   bPortable &= isPortable(index);
                }
            }

View Full Code Here

    */
   public void undo(RelationalSchemaUpgradeState state)
   {
      if (!state.renameIndex(m_sNewName, m_sOldName))
      {
         Index index = state.getSchema().findIndex(m_sNewName);


         if (index == null) // valid to have phantom index if its table is dropped later in upgrade
         {
            state.addIndex(m_sOldName, this);


            return;
         }


         index.setName(m_sOldName);
      }
   }

View Full Code Here

      {
         Table tmpTable = current.cloneTemporary(); // need different object for renameTable()


         for (int i = tmpTable.getIndexCount() - 1; i >= 0; --i) // backwards due to index removal
         {
            Index index = tmpTable.getIndex(i);


            if (target.findIndex(index.getName()) != null) // only discard index collisions
            {
               discardIndex(index, true); // discard index to avoid name clashes
            }
         }

View Full Code Here

    * @param buf The destination string buffer.
    * @param table The table object.
    */
   protected void appendPrimaryKey(StringBuffer buf, Table table)
   {
      Index index = getPrimaryKey(table);


      if (index != null)
      {
         buf.append(',');
         buf.append(SysUtil.LINE_SEP);

View Full Code Here

   {
      Table table = column.getTable();
      
      for (int i = 0, n = table.getIndexCount(); i < n; ++i)
      {
         Index index = table.getIndex(i);


         if (index.findIndexColumn(column) != null)
         {
            createIndex(index);
         }
      }
   }

View Full Code Here

    */
   protected void createIndexes(Table table)
   {
      for (int i = 0, nCount = table.getIndexCount(); i < nCount; ++i)
      {
         Index index = table.getIndex(i);


         if (!isConstraint(index))
         {
            createIndex(index);
         }

View Full Code Here

    */
   protected void alterTable(AlterTableStep step)
   {
      Table table = m_state.getSchema().getTable(step.getName());
      Table current = null;
      Index oldPK = getPrimaryKey(table);
      String sNewPK = step.getPrimaryKeyName();
      boolean bCreateIndex = sNewPK != null && (oldPK == null || !oldPK.getName().equals(sNewPK));


      if (bCreateIndex)
      {
         String sName = sNewPK;


         current = table.cloneTemporary();


         // check previous steps if PK was requested, if so then it would not have been created
         for (int i = m_nStep - 2; i >= 0; --i)
         {
            RelationalSchemaUpgradeStep st = m_upgrade.getStep(i);


            if (st instanceof CreateIndexStep)
            {
               if (((CreateIndexStep)st).getOutline().getName().equals(sName))
               {
                  // index was never created, due to an optimization
                  current.removeIndex(current.getIndex(sNewPK));
                  break;
               }
            }
            else if (st instanceof RenameIndexStep)
            {
               if (((RenameIndexStep)st).getNewName().equals(sName))
               {
                  sName = ((RenameIndexStep)st).getOldName();
               }
            }
            else if (!(st instanceof CreateColumnStep) &&
               !(st instanceof AlterColumnStep) &&
               !(st instanceof RenameColumnStep) &&
               !(st instanceof DropColumnStep) &&
               !(st instanceof DropIndexStep))
            {
               break;
            }
         }
      }


      step.apply(m_state);


      if (bCreateIndex)
      {
         Index newPK = getPrimaryKey(table);
         Table intermedary = current.cloneTemporary();


         // change/removal of PK requires drop of PK constraint/index
         if (oldPK != null && oldPK != newPK)
         {
            intermedary.removeIndex(intermedary.getIndex(oldPK.getName()));
         }


         newPK = intermedary.findIndex(newPK.getName()); // find index to be promoted to PK


         // an existing index exists that needs to be promoted to PK according to metadata
         if (newPK != null && newPK.getName().equals(sNewPK)) // PK may differ for e.g. Oracle
         {
            intermedary.removeIndex(newPK);
         }


         dropIndexes(intermedary, current);

View Full Code Here

0 1 2 3 4

TOP

Related Classes of nexj.core.meta.persistence.sql.Index

nexj.core.meta.AspectHelper

nexj.core.meta.Metaclass

nexj.core.meta.persistence.sql.upgrade.CreateIndexStep

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

nexj.core.meta.persistence.sql.upgrade.RelationalSchemaUpgradeState

nexj.core.meta.persistence.sql.upgrade.RenameIndexStep

nexj.core.persistence.sql.MySQLAdapter

nexj.core.persistence.sql.MySQLSchemaManager

nexj.core.persistence.sql.SQLAdapter

nexj.core.persistence.sql.SQLDelete

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.