Examples of org.apache.derby.iapi.sql.depend.DependencyManager

Package org.apache.derby.iapi.sql.depend

Examples of org.apache.derby.iapi.sql.depend.DependencyManager

org.apache.derby.iapi.sql.depend.DependencyManager
rns what it sees // as the "most important" // of its invalid types. void makeInvalid( ); void makeInvalid( DependencyType dt, InvalidType it ); void makeValid(); } interface Provider() { } interface Dependency() { Provider getProvider(); Dependent getDependent(); DependencyType getDependencyType(); boolean isValid(); InvalidType getInvalidType(); // returns what it sees // as the "most important" // of its invalid types. } interface DependencyManager() { void addDependency(Dependent d, Provider p, ContextManager cm); void invalidateFor(Provider p); void invalidateFor(Provider p, DependencyType dt, InvalidType it); void clearDependencies(Dependent d); void clearDependencies(Dependent d, DependencyType dt); Enumeration getProviders (Dependent d); Enumeration getProviders (Dependent d, DependencyType dt); Enumeration getInvalidDependencies (Dependent d, DependencyType dt, InvalidType it); Enumeration getDependents (Provider p); Enumeration getDependents (Provider p, DependencyType dt); Enumeration getInvalidDependencies (Provider p, DependencyType dt, InvalidType it); }
The simplest things for DependencyType and InvalidType to be are integer id's or strings, rather than complex objects.
In terms of ensuring that no makeInvalid calls are made until we have identified all objects that could be, so that the calls will be made from "leaf" invalid objects (those not in turn relied on by other dependents) to dependent objects upon which others depend, the dependency manager will need to maintain an internal queue of dependencies and make the calls once it has completes its analysis of the dependencies of which it is aware. Since it is much simpler and potentially faster for makeInvalid calls to be made as soon as the dependents are identified, separate implementations may be called for, or separate interfaces to trigger the different styles of invalidation.
In terms of separate interfaces, the DependencyManager might have two methods,
```
 void makeInvalidImmediate(); void makeInvalidOrdered(); 
```
or a flag on the makeInvalid method to choose the style to use.
In terms of separate implementations, the ImmediateInvalidate manager might have simpler internal structures for tracking dependencies than the OrderedInvalidate manager.
The language system doesn't tend to suffer from this ordering problem, as it tends to handle the impact of invalidation by simply deferring recompilation until the next execution. So, a prepared statement might be invalidated several times by a transaction that contains several DDL operations, and only recompiled once, at its next execution. This is sufficient for the common use of a system, where DDL changes tend to be infrequent and clustered.
There could be ways to push this "ordering problem" out of the dependency system, but since it knows when it starts and when it finished finding all of the invalidating actions, it is likely the best home for this.
One other problem that could arise is multiple invalidations occurring one after another. The above design of the dependency system can really only react to each invalidation request as a unit, not to multiple invalidation requests.
Another extension that might be desired is for the dependency manager to provide for cascading invalidations -- that is, if it finds and marks one Dependent object as invalid, if that object can also be a provider, to look for its dependent objects and cascade the dependency on to them. This can be a way to address the multiple-invalidation request need, if it should arise. The simplest way to do this is to always cascade the same invalidation type; otherwise, dependents need to be able to say what a certain type of invalidation type gets changed to when it is handed on.
The basic language system does not need support for cascaded dependencies -- statements do not depend on other statements in a way that involves the dependency system.
I do not know if it would be worthwhile to consider using the dependency manager to aid in the implementation of the SQL DROP statements or not. Past implementations of database systems have not used the dependency system to implement this functionality, but have instead hard-coded the lookups like so:
```
 in DropTable: scan the TableAuthority table looking for authorities on this table; drop any that are found. scan the ColumnAuthority table looking for authorities on this table; drop any that are found. scan the View table looking for views on this table; drop any that are found. scan the Column table looking for rows for columns of this table; drop any that are found. scan the Constraint table looking for rows for constraints of this table; drop any that are found. scan the Index table looking for rows for indexes of this table; drop the indexes, and any rows that are found. drop the table's conglomerate drop the table's row in the Table table. 
```
The direct approach such as that outlined in the example will probably be quicker and is definitely "known technology" over the use of a dependency system in this area.

   */
  public void prepareToInvalidate(Provider p, int action,
          LanguageConnectionContext lcc) 
    throws StandardException
  {
    DependencyManager dm = getDataDictionary().getDependencyManager();


    switch (action)
    {
      /*
      ** Currently, the only thing we are dependent
      ** on is an alias descriptor for an ANSI UDT.
      */
        default:


        throw StandardException.newException(SQLState.LANG_PROVIDER_HAS_DEPENDENT_TABLE, 
                  dm.getActionString(action), 
                  p.getObjectName(),
                  getQualifiedName());
    }
  }

View Full Code Here

    ** We should never get here, we should have barfed on 
    ** prepareToInvalidate().
    */
    if (SanityManager.DEBUG)
    {
      DependencyManager dm;
  
      dm = getDataDictionary().getDependencyManager();


      SanityManager.THROWASSERT("makeInvalid("+
        dm.getActionString(action)+
        ") not expected to get called");
    }
  }

View Full Code Here

          //select count(*) from t1
          //select count(1) from t1
          //select 1 from t1
          //select t1.c1 from t1, t2
          if (privType == Authorizer.MIN_SELECT_PRIV && permittedColumns != null) {
            DependencyManager dm = dd.getDependencyManager();
            RoleGrantDescriptor rgd =
              dd.getRoleDefinitionDescriptor(role);
            ContextManager cm = lcc.getContextManager();


            dm.addDependency(ps, rgd, cm);
            dm.addDependency(activation, rgd, cm);
            return;
          }


          //Use the privileges obtained through the role to satisfy
          //the column level privileges we need. If all the remaining
          //column level privileges are satisfied through this role,
          //we will quit out of this while loop
          for(int i = unresolvedColumns.anySetBit();
            i >= 0;
            i = unresolvedColumns.anySetBit(i)) {


            if(permittedColumns != null && permittedColumns.get(i)) {
              unresolvedColumns.clear(i);
            }
          }
        }
      }
    }
    TableDescriptor td = getTableDescriptor(dd);
    //if we are still here, then that means that we didn't find any select
    //privilege on the table or any column in the table
    if (privType == Authorizer.MIN_SELECT_PRIV)
      throw StandardException.newException( forGrant ? SQLState.AUTH_NO_TABLE_PERMISSION_FOR_GRANT
            : SQLState.AUTH_NO_TABLE_PERMISSION,
            authorizationId,
            getPrivName(),
            td.getSchemaName(),
            td.getName());


    int remains = unresolvedColumns.anySetBit();


    if (remains >= 0) {
      // No permission on this column.
      ColumnDescriptor cd = td.getColumnDescriptor(remains + 1);


      if(cd == null) {
        throw StandardException.newException(
          SQLState.AUTH_INTERNAL_BAD_UUID, "column");
      } else {
        throw StandardException.newException(
          (forGrant
           ? SQLState.AUTH_NO_COLUMN_PERMISSION_FOR_GRANT
           : SQLState.AUTH_NO_COLUMN_PERMISSION),
          authorizationId,
          getPrivName(),
          cd.getColumnName(),
          td.getSchemaName(),
          td.getName());
      }
    } else {
      // We found and successfully applied a role to resolve the
      // (remaining) required permissions.
      //
      // Also add a dependency on the role (qua provider), so
      // that if role is no longer available to the current
      // user (e.g. grant is revoked, role is dropped,
      // another role has been set), we are able to
      // invalidate the ps or activation (the latter is used
      // if the current role changes).
      DependencyManager dm = dd.getDependencyManager();
      RoleGrantDescriptor rgd =
        dd.getRoleDefinitionDescriptor(role);
      ContextManager cm = lcc.getContextManager();


      dm.addDependency(ps, rgd, cm);
      dm.addDependency(activation, rgd, cm);
    }


  } // end of check

View Full Code Here

        throws StandardException
  {
    LanguageConnectionContext   lcc = 
            activation.getLanguageConnectionContext();
    DataDictionary              dd = lcc.getDataDictionary();
    DependencyManager           dm = dd.getDependencyManager();
    TransactionController       tc = lcc.getTransactionExecute();


    int              numRows = 0;
        boolean            tableScanned = false;


        //Following if is for inplace compress. Compress using temporary
        //tables to do the compression is done later in this method.
    if (compressTable)
    {
      if (purge || defragment || truncateEndOfTable)
      {
        td = dd.getTableDescriptor(tableId);
        if (td == null)
        {
          throw StandardException.newException(
            SQLState.LANG_TABLE_NOT_FOUND_DURING_EXECUTION, tableName);
        }
              // Each of the following may give up locks allowing ddl on the
              // table, so each phase needs to do the data dictionary lookup.
              // The order is important as it makes sense to first purge
              // deleted rows, then defragment existing non-deleted rows, and
              // finally to truncate the end of the file which may have been
              // made larger by the previous purge/defragment pass.
              if (purge)
                  purgeRows(tc);


              if (defragment)
                  defragmentRows(tc, lcc);


              if (truncateEndOfTable)
                  truncateEnd(tc);            
              return;        
      }
    }


    if (updateStatistics)
    {
      updateStatistics(activation);
            return;
    }
    /*
    ** Inform the data dictionary that we are about to write to it.
    ** There are several calls to data dictionary "get" methods here
    ** that might be done in "read" mode in the data dictionary, but
    ** it seemed safer to do this whole operation in "write" mode.
    **
    ** We tell the data dictionary we're done writing at the end of
    ** the transaction.
    */
    dd.startWriting(lcc);


    // now do the real work


    // get an exclusive lock of the heap, to avoid deadlock on rows of
    // SYSCOLUMNS etc datadictionary tables and phantom table
    // descriptor, in which case table shape could be changed by a
    // concurrent thread doing add/drop column.


    // older version (or at target) has to get td first, potential deadlock
    if (tableConglomerateId == 0)
    {
      td = dd.getTableDescriptor(tableId);
      if (td == null)
      {
        throw StandardException.newException(
          SQLState.LANG_TABLE_NOT_FOUND_DURING_EXECUTION, tableName);
      }
      tableConglomerateId = td.getHeapConglomerateId();
    }


    lockTableForDDL(tc, tableConglomerateId, true);


    td = dd.getTableDescriptor(tableId);
    if (td == null)
    {
      throw StandardException.newException(
        SQLState.LANG_TABLE_NOT_FOUND_DURING_EXECUTION, tableName);
    }


    if (truncateTable)
      dm.invalidateFor(td, DependencyManager.TRUNCATE_TABLE, lcc);
    else
      dm.invalidateFor(td, DependencyManager.ALTER_TABLE, lcc);


    // Save the TableDescriptor off in the Activation
    activation.setDDLTableDescriptor(td);


    /*
    ** If the schema descriptor is null, then we must have just read 
        ** ourselves in.  So we will get the corresponding schema descriptor 
        ** from the data dictionary.
    */
    if (sd == null)
    {
      sd = getAndCheckSchemaDescriptor(dd, schemaId, "ALTER TABLE");
    }
    
    /* Prepare all dependents to invalidate.  (This is there chance
     * to say that they can't be invalidated.  For example, an open
     * cursor referencing a table/view that the user is attempting to
     * alter.) If no one objects, then invalidate any dependent objects.
     */
    if(truncateTable)
      dm.invalidateFor(td, DependencyManager.TRUNCATE_TABLE, lcc);
    else
      dm.invalidateFor(td, DependencyManager.ALTER_TABLE, lcc);


    // Are we working on columns?
    if (columnInfo != null)
    {
            boolean tableNeedsScanning = false;

View Full Code Here

    ConglomerateDescriptor[] cds;
    long[] conglomerateNumber;
    ExecIndexRow[] indexRow;
    UUID[] objectUUID;
    GroupFetchScanController gsc;
    DependencyManager dm = dd.getDependencyManager();
    //initialize numRows to -1 so we can tell if we scanned an index.  
    long numRows = -1;    
    
    td = dd.getTableDescriptor(tableId);
    if (updateStatisticsAll)
    {
      cds = td.getConglomerateDescriptors();
    }
    else
    {
      cds = new ConglomerateDescriptor[1];
      cds[0] = dd.getConglomerateDescriptor(indexNameForUpdateStatistics, sd, false);
    }


    conglomerateNumber = new long[cds.length];
    indexRow = new ExecIndexRow[cds.length];
    objectUUID = new UUID[cds.length];
    ConglomerateController heapCC =
      tc.openConglomerate(td.getHeapConglomerateId(), false, 0,
          TransactionController.MODE_RECORD,
          TransactionController.ISOLATION_REPEATABLE_READ);


    try
    {
      for (int i = 0; i < cds.length; i++)
      {
        if (!cds[i].isIndex())
        {
          conglomerateNumber[i] = -1;
          continue;
        }


        conglomerateNumber[i] = cds[i].getConglomerateNumber();


        objectUUID[i] = cds[i].getUUID();


        indexRow[i] =
          cds[i].getIndexDescriptor().getNullIndexRow(
            td.getColumnDescriptorList(),
            heapCC.newRowLocationTemplate());
      }
    }
    finally
    {
      heapCC.close();
    }


    dd.startWriting(lcc);


    dm.invalidateFor(td, DependencyManager.UPDATE_STATISTICS, lcc);


    for (int indexNumber = 0; indexNumber < conglomerateNumber.length;
       indexNumber++)
    {
      if (conglomerateNumber[indexNumber] == -1)

View Full Code Here

  private void dropColumnFromTable(Activation activation, String columnName )
          throws StandardException
  {
    LanguageConnectionContext lcc = activation.getLanguageConnectionContext();
    DataDictionary dd = lcc.getDataDictionary();
    DependencyManager dm = dd.getDependencyManager();
    TransactionController tc = lcc.getTransactionExecute();
    boolean cascade = (behavior == StatementType.DROP_CASCADE);


        // drop any generated columns which reference this column
        ColumnDescriptorList    generatedColumnList = td.getGeneratedColumns();
        int                                 generatedColumnCount = generatedColumnList.size();
        ArrayList                   cascadedDroppedColumns = new ArrayList();
        for ( int i = 0; i < generatedColumnCount; i++ )
        {
            ColumnDescriptor    generatedColumn = generatedColumnList.elementAt( i );
            String[]                       referencedColumnNames = generatedColumn.getDefaultInfo().getReferencedColumnNames();
            int                         referencedColumnCount = referencedColumnNames.length;
            for ( int j = 0; j < referencedColumnCount; j++ )
            {
                if ( columnName.equals( referencedColumnNames[ j ] ) )
                {
                    String      generatedColumnName = generatedColumn.getColumnName();
                    
                    // ok, the current generated column references the column
                    // we're trying to drop
                    if (! cascade)
                    {
                        // Reject the DROP COLUMN, because there exists a
                        // generated column which references this column.
                        //
                        throw StandardException.newException
                            (
                             SQLState.LANG_PROVIDER_HAS_DEPENDENT_OBJECT,
                             dm.getActionString(DependencyManager.DROP_COLUMN),
                             columnName, "GENERATED COLUMN",
                             generatedColumnName
                             );
                    }
                    else
                    {
                        cascadedDroppedColumns.add( generatedColumnName );
                    }
                }
            }
        }


    DataDescriptorGenerator ddg = dd.getDataDescriptorGenerator();
        int                             cascadedDrops = cascadedDroppedColumns.size();
    int sizeAfterCascadedDrops = td.getColumnDescriptorList().size() - cascadedDrops;


    // can NOT drop a column if it is the only one in the table
    if (sizeAfterCascadedDrops == 1)
    {
      throw StandardException.newException(
                    SQLState.LANG_PROVIDER_HAS_DEPENDENT_OBJECT,
                    dm.getActionString(DependencyManager.DROP_COLUMN),
                    "THE *LAST* COLUMN " + columnName,
                    "TABLE",
                    td.getQualifiedName() );
    }


        // now drop dependent generated columns
        for ( int i = 0; i < cascadedDrops; i++ )
        {
            String      generatedColumnName = (String) cascadedDroppedColumns.get( i );
            
            activation.addWarning
                ( StandardException.newWarning( SQLState.LANG_GEN_COL_DROPPED, generatedColumnName, td.getName() ) );


            //
            // We can only recurse 2 levels since a generation clause cannot
            // refer to other generated columns.
            //
            dropColumnFromTable( activation, generatedColumnName );
        }


        /*
         * Cascaded drops of dependent generated columns may require us to
         * rebuild the table descriptor.
         */
    td = dd.getTableDescriptor(tableId);


    ColumnDescriptor columnDescriptor = td.getColumnDescriptor( columnName );


    // We already verified this in bind, but do it again
    if (columnDescriptor == null)
    {
      throw 
        StandardException.newException(
                    SQLState.LANG_COLUMN_NOT_FOUND_IN_TABLE, 
                    columnName,
                    td.getQualifiedName());
    }


    int size = td.getColumnDescriptorList().size();
    droppedColumnPosition = columnDescriptor.getPosition();


    FormatableBitSet toDrop = new FormatableBitSet(size + 1);
    toDrop.set(droppedColumnPosition);
    td.setReferencedColumnMap(toDrop);


    dm.invalidateFor(td, 
                        (cascade ? DependencyManager.DROP_COLUMN
                                 : DependencyManager.DROP_COLUMN_RESTRICT),
                        lcc);
          
    // If column has a default we drop the default and any dependencies
    if (columnDescriptor.getDefaultInfo() != null)
    {
      dm.clearDependencies(
                lcc, columnDescriptor.getDefaultDescriptor(dd));
    }


    // need to deal with triggers if has referencedColumns
    GenericDescriptorList tdl = dd.getTriggerDescriptors(td);
    Enumeration descs = tdl.elements();
    while (descs.hasMoreElements())
    {
      TriggerDescriptor trd = (TriggerDescriptor) descs.nextElement();
      int[] referencedCols = trd.getReferencedCols();
      if (referencedCols == null)
        continue;
      int refColLen = referencedCols.length, j;
      boolean changed = false;
      for (j = 0; j < refColLen; j++)
      {
        if (referencedCols[j] > droppedColumnPosition)
                {
          changed = true;
                }
        else if (referencedCols[j] == droppedColumnPosition)
        {
          if (cascade)
          {
                        trd.drop(lcc);
            activation.addWarning(
              StandardException.newWarning(
                                SQLState.LANG_TRIGGER_DROPPED, 
                                trd.getName(), td.getName()));
          }
          else
          {  // we'd better give an error if don't drop it,
            // otherwsie there would be unexpected behaviors
            throw StandardException.newException(
                            SQLState.LANG_PROVIDER_HAS_DEPENDENT_OBJECT,
                            dm.getActionString(DependencyManager.DROP_COLUMN),
                            columnName, "TRIGGER",
                            trd.getName() );
          }
          break;
        }
      }


      // change triggers to refer to columns in new positions
      if (j == refColLen && changed)
      {
        dd.dropTriggerDescriptor(trd, tc);
        for (j = 0; j < refColLen; j++)
        {
          if (referencedCols[j] > droppedColumnPosition)
            referencedCols[j]--;
        }
        dd.addDescriptor(trd, sd,
                 DataDictionary.SYSTRIGGERS_CATALOG_NUM,
                 false, tc);
      }
    }


    ConstraintDescriptorList csdl = dd.getConstraintDescriptors(td);
    int csdl_size = csdl.size();


    ArrayList newCongloms = new ArrayList();


    // we want to remove referenced primary/unique keys in the second
    // round.  This will ensure that self-referential constraints will
    // work OK.
    int tbr_size = 0;
    ConstraintDescriptor[] toBeRemoved = 
            new ConstraintDescriptor[csdl_size];


    // let's go downwards, don't want to get messed up while removing
    for (int i = csdl_size - 1; i >= 0; i--)
    {
      ConstraintDescriptor cd = csdl.elementAt(i);
      int[] referencedColumns = cd.getReferencedColumns();
      int numRefCols = referencedColumns.length, j;
      boolean changed = false;
      for (j = 0; j < numRefCols; j++)
      {
        if (referencedColumns[j] > droppedColumnPosition)
          changed = true;
        if (referencedColumns[j] == droppedColumnPosition)
          break;
      }
      if (j == numRefCols)      // column not referenced
      {
        if ((cd instanceof CheckConstraintDescriptor) && changed)
        {
          dd.dropConstraintDescriptor(cd, tc);
          for (j = 0; j < numRefCols; j++)
          {
            if (referencedColumns[j] > droppedColumnPosition)
              referencedColumns[j]--;
          }
          ((CheckConstraintDescriptor) cd).setReferencedColumnsDescriptor(new ReferencedColumnsDescriptorImpl(referencedColumns));
          dd.addConstraintDescriptor(cd, tc);
        }
        continue;
      }


      if (! cascade)
      {
        // Reject the DROP COLUMN, because there exists a constraint
        // which references this column.
        //
        throw StandardException.newException(
                        SQLState.LANG_PROVIDER_HAS_DEPENDENT_OBJECT,
                        dm.getActionString(DependencyManager.DROP_COLUMN),
                        columnName, "CONSTRAINT",
                        cd.getConstraintName() );
      }


      if (cd instanceof ReferencedKeyConstraintDescriptor)
      {
        // restrict will raise an error in invalidate if referenced
        toBeRemoved[tbr_size++] = cd;
        continue;
      }


      // drop now in all other cases
      dm.invalidateFor(cd, DependencyManager.DROP_CONSTRAINT,
                  lcc);


      dropConstraint(cd, td, newCongloms, activation, lcc, true);
      activation.addWarning(
                StandardException.newWarning(SQLState.LANG_CONSTRAINT_DROPPED,
        cd.getConstraintName(), td.getName()));
    }


    for (int i = tbr_size - 1; i >= 0; i--)
    {
      ConstraintDescriptor cd = toBeRemoved[i];
      dropConstraint(cd, td, newCongloms, activation, lcc, false);


      activation.addWarning(
                StandardException.newWarning(SQLState.LANG_CONSTRAINT_DROPPED,
                cd.getConstraintName(), td.getName()));


      if (cascade)
      {
        ConstraintDescriptorList fkcdl = dd.getForeignKeys(cd.getUUID());
        for (int j = 0; j < fkcdl.size(); j++)
        {
          ConstraintDescriptor fkcd = 
                        (ConstraintDescriptor) fkcdl.elementAt(j);


          dm.invalidateFor(fkcd,
                  DependencyManager.DROP_CONSTRAINT,
                  lcc);


          dropConstraint(fkcd, td,
            newCongloms, activation, lcc, true);


          activation.addWarning(
                        StandardException.newWarning(
                            SQLState.LANG_CONSTRAINT_DROPPED,
                fkcd.getConstraintName(), 
                            fkcd.getTableDescriptor().getName()));
        }
      }


      dm.invalidateFor(cd, DependencyManager.DROP_CONSTRAINT, lcc);
      dm.clearDependencies(lcc, cd);
    }


    /* If there are new backing conglomerates which must be
     * created to replace a dropped shared conglomerate
     * (where the shared conglomerate was dropped as part

View Full Code Here

                   int ix)
      throws StandardException             
  {
    LanguageConnectionContext lcc = activation.getLanguageConnectionContext();
    DataDictionary dd = lcc.getDataDictionary();
    DependencyManager dm = dd.getDependencyManager();
    TransactionController tc = lcc.getTransactionExecute();


    ColumnDescriptor columnDescriptor = 
      td.getColumnDescriptor(columnInfo[ix].name);
    DataDescriptorGenerator ddg = dd.getDataDescriptorGenerator();
    int columnPosition = columnDescriptor.getPosition();


    // Clean up after the old default, if non-null
    if (columnDescriptor.hasNonNullDefault())
    {
      // Invalidate off of the old default
      DefaultDescriptor defaultDescriptor = new DefaultDescriptor(dd, columnInfo[ix].oldDefaultUUID, 
                     td.getUUID(), columnPosition);


    
      dm.invalidateFor(defaultDescriptor, DependencyManager.MODIFY_COLUMN_DEFAULT, lcc);
    
      // Drop any dependencies
      dm.clearDependencies(lcc, defaultDescriptor);
    }


    UUID defaultUUID = columnInfo[ix].newDefaultUUID;


    /* Generate a UUID for the default, if one exists

View Full Code Here

      Activation activation, Dependent dependent)
  throws StandardException
  {
    LanguageConnectionContext lcc = activation.getLanguageConnectionContext();
    DataDictionary dd = lcc.getDataDictionary();
    DependencyManager dm = dd.getDependencyManager();
    
    //If the Database Owner is creating this view/triiger, then no need to  
    //collect any privilege dependencies because the Database Owner can  
    //access any objects without any restrictions
    if (!(lcc.getAuthorizationId().equals(dd.getAuthorizationDatabaseOwner())))
    {
      PermissionsDescriptor permDesc;
      List requiredPermissionsList = activation.getPreparedStatement().getRequiredPermissionsList();
      if (requiredPermissionsList != null && ! requiredPermissionsList.isEmpty())
      {
        for(Iterator iter = requiredPermissionsList.iterator();iter.hasNext();)
        {
          StatementPermission statPerm = (StatementPermission) iter.next();
          //The schema ownership permission just needs to be checked 
          //at object creation time, to see if the object creator has 
          //permissions to create the object in the specified schema. 
          //But we don't need to add schema permission to list of 
          //permissions that the object is dependent on once it is 
          //created.
          if (statPerm instanceof StatementSchemaPermission)
            continue;
          //See if we can find the required privilege for given authorizer?
          permDesc = statPerm.getPermissionDescriptor(lcc.getAuthorizationId(), dd);        
          if (permDesc == null)//privilege not found for given authorizer 
          {
            //The if condition above means that required privilege does 
            //not exist at the user level. The privilege has to exist at 
            //PUBLIC level.
            permDesc = statPerm.getPermissionDescriptor(Authorizer.PUBLIC_AUTHORIZATION_ID, dd);
            //If the user accessing the object is the owner of that 
            //object, then no privilege tracking is needed for the
            //owner.
            if (!(permDesc.checkOwner(lcc.getAuthorizationId())))
              dm.addDependency(dependent, permDesc, lcc.getContextManager());
            continue;
          }
          //if the object on which permission is required is owned by the
          //same user as the current user, then no need to keep that
          //object's privilege dependency in the dependency system
          if (!(permDesc.checkOwner(lcc.getAuthorizationId())))
          {
            dm.addDependency(dependent, permDesc, lcc.getContextManager());                           
            if (permDesc instanceof ColPermsDescriptor)
            {
              //For a given table, the table owner can give privileges
              //on some columns at individual user level and privileges
              //on some columns at PUBLIC level. Hence, when looking for
              //column level privileges, we need to look both at user
              //level as well as PUBLIC level(only if user level column
              //privileges do not cover all the columns accessed by this
              //object). We have finished adding dependency for user level 
              //columns, now we are checking if some required column 
              //level privileges are at PUBLIC level.
              //A specific eg of a view
              //user1
              //create table t11(c11 int, c12 int);
              //grant select(c11) on t1 to user2;
              //grant select(c12) on t1 to PUBLIC;
              //user2
              //create view v1 as select c11 from user1.t11 where c12=2;
              //For the view above, there are 2 column level privilege 
              //depencies, one for column c11 which exists directly
              //for user2 and one for column c12 which exists at PUBLIC level.
              StatementColumnPermission statementColumnPermission = (StatementColumnPermission) statPerm;
              permDesc = statementColumnPermission.getPUBLIClevelColPermsDescriptor(lcc.getAuthorizationId(), dd);
              //Following if checks if some column level privileges
              //exist only at public level. If so, then the public
              //level column privilege dependency of view is added
              //into dependency system.
              if (permDesc != null)
                dm.addDependency(dependent, permDesc, lcc.getContextManager());                           
            }
          }
        }
      }

View Full Code Here

    UUID              indexId = null;
    String            indexUUIDString;


    LanguageConnectionContext lcc = activation.getLanguageConnectionContext();
    DataDictionary dd = lcc.getDataDictionary();
    DependencyManager dm = dd.getDependencyManager();
    TransactionController tc = lcc.getTransactionExecute();




    /*
    ** Inform the data dictionary that we are about to write to it.
    ** There are several calls to data dictionary "get" methods here
    ** that might be done in "read" mode in the data dictionary, but
    ** it seemed safer to do this whole operation in "write" mode.
    **
    ** We tell the data dictionary we're done writing at the end of
    ** the transaction.
    */
    dd.startWriting(lcc);


    td = dd.getTableDescriptor(tableId);


    if (td == null)
    {
      throw StandardException.newException(SQLState.LANG_TABLE_NOT_FOUND_DURING_EXECUTION, tableName);
    }


    /* Table gets locked in AlterTableConstantAction */


    /*
    ** If the schema descriptor is null, then
    ** we must have just read ourselves in.  
    ** So we will get the corresponding schema
    ** descriptor from the data dictionary.
    */


    SchemaDescriptor tdSd = td.getSchemaDescriptor();
    SchemaDescriptor constraintSd = 
      constraintSchemaName == null ? tdSd : dd.getSchemaDescriptor(constraintSchemaName, tc, true);




    /* Get the constraint descriptor for the index, along
     * with an exclusive row lock on the row in sys.sysconstraints
     * in order to ensure that no one else compiles against the
     * index.
     */
    if (constraintName == null)  // this means "alter table drop primary key"
      conDesc = dd.getConstraintDescriptors(td).getPrimaryKey();
    else
      conDesc = dd.getConstraintDescriptorByName(td, constraintSd, constraintName, true);


    // Error if constraint doesn't exist
    if (conDesc == null)
    {
      String errorName = constraintName == null ? "PRIMARY KEY" :
                (constraintSd.getSchemaName() + "."+ constraintName);


      throw StandardException.newException(SQLState.LANG_DROP_NON_EXISTENT_CONSTRAINT, 
            errorName,
            td.getQualifiedName());
    }
        switch( verifyType)
        {
        case DataDictionary.UNIQUE_CONSTRAINT:
            if( conDesc.getConstraintType() != verifyType)
                throw StandardException.newException(SQLState.LANG_DROP_CONSTRAINT_TYPE,
                                                     constraintName, "UNIQUE");
            break;


        case DataDictionary.CHECK_CONSTRAINT:
            if( conDesc.getConstraintType() != verifyType)
                throw StandardException.newException(SQLState.LANG_DROP_CONSTRAINT_TYPE,
                                                     constraintName, "CHECK");
            break;


        case DataDictionary.FOREIGNKEY_CONSTRAINT:
            if( conDesc.getConstraintType() != verifyType)
                throw StandardException.newException(SQLState.LANG_DROP_CONSTRAINT_TYPE,
                                                     constraintName, "FOREIGN KEY");
            break;
        }


    boolean cascadeOnRefKey = (cascade && 
            conDesc instanceof ReferencedKeyConstraintDescriptor);
    if (!cascadeOnRefKey)
    {
      dm.invalidateFor(conDesc, DependencyManager.DROP_CONSTRAINT, lcc);
    }


    /*
    ** If we had a primary/unique key and it is drop cascade,  
    ** drop all the referencing keys now.  We MUST do this AFTER
    ** dropping the referenced key because otherwise we would
    ** be repeatedly changing the reference count of the referenced
    ** key and generating unnecessary I/O.
    */
    dropConstraintAndIndex(dm, td, dd, conDesc, tc, lcc, !cascadeOnRefKey);


    if (cascadeOnRefKey) 
    {
      ForeignKeyConstraintDescriptor fkcd;
      ReferencedKeyConstraintDescriptor cd;
      ConstraintDescriptorList cdl;


      cd = (ReferencedKeyConstraintDescriptor)conDesc;
      cdl = cd.getForeignKeyConstraints(ReferencedKeyConstraintDescriptor.ALL);
      int cdlSize = cdl.size();


      for(int index = 0; index < cdlSize; index++)
      {
        fkcd = (ForeignKeyConstraintDescriptor) cdl.elementAt(index);
        dm.invalidateFor(fkcd, DependencyManager.DROP_CONSTRAINT, lcc);
        dropConstraintAndIndex(dm, fkcd.getTableDescriptor(), dd, fkcd,
                tc, lcc, true);
      }
  
      /*
      ** We told dropConstraintAndIndex not to
      ** remove our dependencies, so send an invalidate,
      ** and drop the dependencies.
      */
      dm.invalidateFor(conDesc, DependencyManager.DROP_CONSTRAINT, lcc);
      dm.clearDependencies(lcc, conDesc);
    }
  }

View Full Code Here

    {
      compilerContext.popCurrentPrivType();
      compilerContext.setCurrentAuxiliaryProviderList(prevAPL);
    }


    DependencyManager     dm = dataDictionary.getDependencyManager();
    ProviderInfo[]      providerInfos = dm.getPersistentProviderInfos(apl);
    // need to clear the column info in case the same table descriptor
    // is reused, eg., in multiple target only view definition
    dm.clearColumnInfoInProviders(apl);


    /* Verify that all underlying ResultSets reclaimed their FromList */
    if (SanityManager.DEBUG)
    {
      SanityManager.ASSERT(fromList.size() == 0,

View Full Code Here

0 1 2 3 4 5 6 7 8 9

TOP

Related Classes of org.apache.derby.iapi.sql.depend.DependencyManager

org.apache.derby.iapi.sql.dictionary.AliasDescriptor

org.apache.derby.iapi.sql.dictionary.ConglomerateDescriptor

org.apache.derby.iapi.sql.dictionary.ConstraintDescriptor

org.apache.derby.iapi.sql.dictionary.DefaultDescriptor

org.apache.derby.iapi.sql.dictionary.SchemaDescriptor

org.apache.derby.iapi.sql.dictionary.SequenceDescriptor

org.apache.derby.iapi.sql.dictionary.SPSDescriptor

org.apache.derby.iapi.sql.dictionary.StatementColumnPermission

org.apache.derby.iapi.sql.dictionary.StatementPermission

org.apache.derby.iapi.sql.dictionary.StatementRoutinePermission

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.