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 drop(LanguageConnectionContext lcc,
          TableDescriptor td)
  throws StandardException
  {     
        DataDictionary dd = getDataDictionary();
        DependencyManager dm = dd.getDependencyManager();
        TransactionController tc = lcc.getTransactionExecute();
        
        // invalidate any prepared statements that
        // depended on the index (including this one)
        dm.invalidateFor(this, DependencyManager.DROP_INDEX, lcc);
      
        // only drop the conglomerate if no similar index but with different
      // name. Get from dd in case we drop other dup indexes with a cascade operation      
      if (dd.getConglomerateDescriptors(getConglomerateNumber()).length == 1)
      {

View Full Code Here

        // thrown, indicating that the DDL modification should be
        // rejected because a view is dependent on the underlying
        // object (table, column, privilege, etc.)
        default:


        DependencyManager dm;


        dm = getDataDictionary().getDependencyManager();
        throw StandardException.newException(SQLState.LANG_PROVIDER_HAS_DEPENDENT_VIEW, 
          dm.getActionString(action), 
          p.getObjectName(), viewName);


    }  // end switch
  }

View Full Code Here

  public void drop(LanguageConnectionContext lcc,
                SchemaDescriptor sd, TableDescriptor td)
    throws StandardException
  {
        DataDictionary dd = getDataDictionary();
        DependencyManager dm = dd.getDependencyManager();
        TransactionController tc = lcc.getTransactionExecute();
        
    /* Drop the columns */
    dd.dropAllColumnDescriptors(td.getUUID(), tc);


    /* 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
     * drop.) If no one objects, then invalidate any dependent objects.
     */
    dm.invalidateFor(td, DependencyManager.DROP_VIEW, lcc);


    /* Clear the dependencies for the view */
    dm.clearDependencies(lcc, this);


    /* Drop the view */
    dd.dropViewDescriptor(this, tc);


    /* Drop all table and column permission descriptors */

View Full Code Here

    private void dropAllDeclaredGlobalTempTables() throws StandardException 
    {
        if (allDeclaredGlobalTempTables == null)
            return;
    
        DependencyManager dm = getDataDictionary().getDependencyManager();
        StandardException topLevelStandardException = null;


        // collect all the exceptions we might receive while dropping the 
        // temporary tables and throw them as one chained exception at the end.
        for (int i = 0; i < allDeclaredGlobalTempTables.size(); i++) 
        {
            try 
            {
                TempTableInfo tempTableInfo = 
                    (TempTableInfo)allDeclaredGlobalTempTables.get(i);


                TableDescriptor td = tempTableInfo.getTableDescriptor();


                // the following 2 lines of code has been copied from 
                // DropTableConstantAction. If there are any changes made there
                // in future, we should check if they need to be made here too.
                dm.invalidateFor(td, DependencyManager.DROP_TABLE, this);
                tran.dropConglomerate(td.getHeapConglomerateId());


            } 
            catch (StandardException e) 
            {

View Full Code Here


                /* is there an open result set? */
                if (rs != null && ! rs.isClosed())
                {
                    if ((provider != null) && rs.returnsRows()) {
                    DependencyManager dmgr = getDataDictionary().getDependencyManager();


                    throw StandardException.newException(SQLState.LANG_CANT_INVALIDATE_OPEN_RESULT_SET, 
                                    dmgr.getActionString(action), 
                                    provider.getObjectName());


                    }
                    return true;
                }

View Full Code Here

    }


    /* Clean up any dependencies */
    if (dependencies != null)
    {
      DependencyManager dmgr = lcc.getDataDictionary().getDependencyManager();


      for (Iterator iterator = dependencies.iterator(); iterator.hasNext(); ) 
      {
        Dependency dy = (Dependency) iterator.next();
        dmgr.clearInMemoryDependency(dy);
      }


      dependencies = null;
    }

View Full Code Here

      compilingStatement = true;
    }


    try {


      DependencyManager dm = lcc.getDataDictionary().getDependencyManager();


      /* Clear out the old dependencies on this statement as we
       * will build the new set during the reprepare in makeValid().
       */
      dm.clearDependencies(lcc, this);


      /*
      ** If we are invalidating an EXECUTE STATEMENT because of a stale
      ** plan, we also need to invalidate the stored prepared statement.
      */

View Full Code Here

        case DependencyManager.DROP_TABLE:
        case DependencyManager.DROP_SYNONYM:
        case DependencyManager.DROP_SPS:
        case DependencyManager.RENAME:
        case DependencyManager.REVOKE_PRIVILEGE_RESTRICT:
        DependencyManager dm = getDataDictionary().getDependencyManager();
        throw StandardException.newException(SQLState.LANG_PROVIDER_HAS_DEPENDENT_OBJECT, 
                  dm.getActionString(action), 
                  p.getObjectName(), "TRIGGER", name);


        /*
      ** The trigger descriptor depends on the trigger table.
      ** This means that we get called whenever anything happens

View Full Code Here


    switch (action)
    {
      // invalidate this trigger descriptor
      case DependencyManager.USER_RECOMPILE_REQUEST:
        DependencyManager dm = getDataDictionary().getDependencyManager();
        dm.invalidateFor(this, DependencyManager.PREPARED_STATEMENT_RELEASE, lcc);
        break;


      // When REVOKE_PRIVILEGE gets sent (this happens for privilege 
      // types SELECT, UPDATE, DELETE, INSERT, REFERENCES, TRIGGER), we  
      // make the TriggerDescriptor drop itself.

View Full Code Here

  }
    
    public void drop(LanguageConnectionContext   lcc) throws StandardException
    {
        DataDictionary dd = getDataDictionary();
        DependencyManager dm = getDataDictionary().getDependencyManager();
        TransactionController tc = lcc.getTransactionExecute();
        dm.invalidateFor(this, DependencyManager.DROP_TRIGGER, lcc);


        // Drop the trigger
        dd.dropTriggerDescriptor(this, tc);


        // Clear the dependencies for the trigger 
        dm.clearDependencies(lcc, this);


        // Drop the spses
        SPSDescriptor spsd = dd.getSPSDescriptor(this.getActionId());


        // there shouldn't be any dependencies, but in case
        // there are, lets clear them
        dm.invalidateFor(spsd, DependencyManager.DROP_TRIGGER, lcc);
        dm.clearDependencies(lcc, spsd);
        dd.dropSPSDescriptor(spsd, tc);
        
        if (getWhenClauseId() != null)
        {   
            spsd = dd.getSPSDescriptor(getWhenClauseId());
            dm.invalidateFor(spsd, DependencyManager.DROP_TRIGGER, lcc);
            dm.clearDependencies(lcc, spsd);
            dd.dropSPSDescriptor(spsd, tc);
        }
    }

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.