Package | Description |
---|---|
oracle.ide.db |
Classes for representing database objects in the IDE.
|
oracle.ide.db.transfer |
Contains an API for transfering database object from one DBObjectProvider to
another.
|
oracle.javatools.db |
Contains a metadata API for describing database objects, and retrieving them
from a provider of database objects - for example a database.
|
oracle.javatools.db.ddl |
API for generating DDL in the database API.
|
oracle.javatools.db.diff |
Contains a metadata driven differ of database objects.
|
oracle.javatools.db.event | |
oracle.javatools.db.extension |
Contains classes for extending the object support that comes as standard in
the database api (e.g.
|
oracle.javatools.db.property |
Classes for dealing with properties in the database API.
|
oracle.javatools.db.refactoring |
Provides classes relevant to refactoring in a DBObjectProvider.
|
oracle.javatools.db.validators |
Contains classes that provide the capability to validate DBObjects in
a DBObjectProvider.
|
Modifier and Type | Method and Description |
---|---|
Difference |
ProviderOperator.difference(SystemObject[] orig,
SystemObject[] upd)
Diffs the two sets of objects using the provider's DiffEngine.
|
Modifier and Type | Method and Description |
---|---|
Difference |
TransferPolicy.filterDiff(TransferDescriptor td,
Difference diff)
Filter the differences to remove any which are not applicable to
the transfer policy.
|
Modifier and Type | Method and Description |
---|---|
Difference |
TransferPolicy.filterDiff(TransferDescriptor td,
Difference diff)
Filter the differences to remove any which are not applicable to
the transfer policy.
|
Modifier and Type | Method and Description |
---|---|
protected Difference |
AbstractDBObjectProvider.ensureSystemObjectListDifference(Difference diff)
Call this to ensure that the caller of an API method that takes a
Difference of SystemObject[] objects has a correct Difference arg.
|
Modifier and Type | Method and Description |
---|---|
java.util.Collection<Difference> |
SchemaObjectManager.resolveUnresolvedReferences(SystemObject obj) |
java.util.Collection<Difference> |
CascadeManager.resolveUnresolvedReferences(SystemObject obj)
If this manager supports unresolved references and the given object could
potentially fix those references then this method finds any objects that
have an unresolved reference and looks to resolve it.
|
Modifier and Type | Method and Description |
---|---|
void |
DBObjectProvider.canUpdate(Difference listDiff,
boolean replace,
boolean cascade)
Tests whether the given update can be performed.
|
void |
AbstractDBObjectProvider.canUpdate(Difference listDiff,
boolean replace,
boolean cascade) |
protected abstract java.util.Collection<DBObjectChange> |
AbstractDBObjectProvider.commitTransaction(DBObjectTransaction txn,
Difference listDiff)
Implement to commit the given transaction's difference.
|
void |
DBObjectFactory.ensureIDs(java.util.Collection<? extends DBObject> objs,
Difference diff)
Checks that all of the given objects that are part of a transaction
have an ID that is set up for the factory's provider.
|
protected Difference |
AbstractDBObjectProvider.ensureSystemObjectListDifference(Difference diff)
Call this to ensure that the caller of an API method that takes a
Difference of SystemObject[] objects has a correct Difference arg.
|
void |
SchemaObjectExpander.expand(Difference rs)
Deprecated.
Called by a DBObjectProvider during a create or update process.
|
java.util.Collection<DBObjectChange> |
AbstractDatabase.finishUpdates(Difference listDiff)
Processes the given objects after the DDL has been fired for a create,
update or delete operation.
|
static DBObject |
DBUtil.getDBObjectFromParent(Difference cmr,
java.lang.String contributor)
Search back through the parents of the Difference to find a DBObject.
|
static java.lang.String |
DBUtil.getFullPropertyPath(Difference diff)
Search back through the parents of the Difference to build
a String representing the full property path.
|
static SystemObject |
DBUtil.getSystemObjectFromParent(Difference cmr,
java.lang.String contributor)
Search back through the parents of the Difference to find a
SystemObject.
|
void |
TemplateExpander.processUpdate(DBObjectTransaction txn,
Difference objDiff) |
void |
DBObjectProvider.updateObjects(Difference listDiff,
boolean replace,
boolean cascade)
Updates the definition of a set of objects.
|
void |
AbstractDBObjectProvider.updateObjects(Difference listDiff,
boolean replace,
boolean cascade) |
Modifier and Type | Method and Description |
---|---|
Difference |
TokenContext.findUpdateDifference(DBObject obj)
If we are processing the update of an object, this finds a Difference
that shows the changes for the given object.
|
Difference |
TokenContext.getDifference()
Gets the Difference for the current token.
|
Modifier and Type | Method and Description |
---|---|
protected java.util.Collection<DBObjectChange> |
DDLDatabase.commitTransaction(DBObjectTransaction txn,
Difference listDiff) |
protected DDL |
TokenDDLGenerator.createUpdateDDL(DDLOptions options,
java.lang.String code,
Difference rs,
DDLType ddlType)
Creates a new update DDL object with the given ddlCode by processing the
given update code using a TokenProcessor and using the resulting String as
the DDL string.
|
DDL |
AlterDDLGenerator.getAlterDDL(DDLOptions options,
Difference diff)
Returns the DDL to apply an update (ALTER) statement which will effect the
changes in the given Difference.
|
DDL<T> |
DDLGenerator.getUpdateDDL(DDLOptions options,
Difference diff)
Gets ALTER statements for the given objects where possible, or DROP/CREATE,
or CREATE AND REPLACE where appropriate/necessary.
|
Modifier and Type | Class and Description |
---|---|
class |
ResultSet |
Modifier and Type | Method and Description |
---|---|
Difference |
DiffEngine.difference(java.lang.Object a,
java.lang.Object b)
Diffs the given objects and returns a Difference object that represents
the differences between them.
|
Difference |
Difference.getChildDifference(java.lang.String propName)
Gets a child Difference that has the given property name.
|
Difference |
Difference.getChildDifference(java.lang.String propName,
boolean ignoreSame)
Gets a child Difference that has the given property name.
|
Difference |
Difference.getFilteredDifference(DifferenceFilter... filters)
Filters this Difference using the given filter and returns a new
filtered Difference.
|
Difference |
Difference.getParent()
Gets the parent of this Difference, if one exists.
|
Modifier and Type | Method and Description |
---|---|
abstract java.util.Collection<? extends Difference> |
Difference.getChildren()
Gets all the children of this Difference.
|
protected java.util.Collection<? extends Difference> |
Difference.getChildrenForLog()
Called by the print code to get the child Differences that should be
included in the log.
|
java.util.List<Difference> |
ResultSet.getList(java.lang.String contributor) |
Modifier and Type | Method and Description |
---|---|
void |
DifferenceApplier.apply(Difference rs)
Applys changes in the direction specified when this applier was
constructed.
|
protected void |
Difference.copyToImpl(Difference other)
Subclasses should call this as part of the Copyable implementation.
|
SystemObject |
DifferenceApplier.getCopyOfOrigWithDiffApplied(Difference diff)
Gets a new temporary copy of the original object in the given
difference and applys all the changes in the difference to that object.
|
boolean |
DifferenceFilter.isFilteredProperty(Difference diff,
java.lang.String prop)
When applying a ResultSetFilter to a ResultSet, the following method will
be called on the given ResultSetFilter for each ResultSet that is marked
as not being the "same".
|
boolean |
DefaultResultSetFilter.isFilteredProperty(Difference rs,
java.lang.String prop) |
protected void |
Difference.setParent(Difference parent)
Sets the parent of the Difference
|
Modifier and Type | Method and Description |
---|---|
void |
DBObjectProviderListener.transactionCommited(DBObjectTransaction txn,
Difference listDiff,
java.lang.Iterable<? extends DBObjectChange> changes)
Notifies the listener that the given transasction has been comitted
to the provider.
|
void |
DBObjectProviderListener.transactionProcessed(DBObjectTransaction txn,
Difference listDiff)
Notifies the listener that the given transasction has been processed
and is ready to be commited.
|
Modifier and Type | Method and Description |
---|---|
PropertyAction |
DelegateDDLGenerator.canUpdateObject(Difference rs) |
DDL |
DelegateDDLGenerator.getUpdateDDL(DDLOptions options,
Difference diff) |
Modifier and Type | Method and Description |
---|---|
Difference |
PropertyHelper.getChildDifference(Difference diff,
java.lang.String propPath)
Traverses the given difference looking for a Difference heirachy that
matches the given property path, and returns the Difference at the end
of that path if one is found.
|
Difference |
PropertyHelper.getChildDifference(Difference diff,
java.lang.String propPath,
boolean ignoreSame)
Traverses the given difference looking for a Difference heirachy that
matches the given property path, and returns the Difference at the end
of that path if one is found.
|
Modifier and Type | Method and Description |
---|---|
PropertyAction |
PropertyManager.canUpdateObject(Difference rs)
Convenience method that uses
PropertyManager.canChangeProperty(oracle.javatools.db.SystemObject, oracle.javatools.db.SystemObject, java.lang.String) on all the
differences in the given Difference to tell whether the update on the given
objects can be done using a CREATE, ALTER or REPLACE as appropriate. |
PropertyAction |
AbstractPropertyManager.canUpdateObject(Difference rs) |
Difference |
PropertyHelper.getChildDifference(Difference diff,
java.lang.String propPath)
Traverses the given difference looking for a Difference heirachy that
matches the given property path, and returns the Difference at the end
of that path if one is found.
|
Difference |
PropertyHelper.getChildDifference(Difference diff,
java.lang.String propPath,
boolean ignoreSame)
Traverses the given difference looking for a Difference heirachy that
matches the given property path, and returns the Difference at the end
of that path if one is found.
|
Modifier and Type | Method and Description |
---|---|
Difference |
DBObjectTransaction.difference(SystemObject oldObject,
SystemObject newObject)
Convinience method to diff the two objects using the provider's
DiffEngine.
|
Difference |
DBObjectTransaction.findExistingUpdate(Difference newDiff)
If there is an update Difference in this transaction already for the
object being updated in newDiff this method returns it.
|
Difference |
DBObjectTransaction.findExistingUpdate(SystemObject obj)
Finds an existing Difference for the given object.
|
Difference |
DBObjectTransaction.getTransactionDifference()
Gets the overall Difference for this transaction that will be committed
to the underlying provider.
|
Modifier and Type | Method and Description |
---|---|
protected CascadeAction |
CascadeWorker.cascadePropertyChange(Difference objDiff,
java.lang.String propName,
java.lang.Object oldValue,
java.lang.Object newValue,
T obj)
Process the given difference from a dependent object that is being
updated.
|
protected void |
CascadeProcessor.cascadeUpdate(DBObjectTransaction txn,
Difference objDiff,
SystemObject depObj) |
CascadeAction |
CascadeWorker.cascadeUpdate(Difference objDiff,
T obj)
Cascades the given object difference to an object this CascadeWorker
is responsible for.
|
Difference |
DBObjectTransaction.findExistingUpdate(Difference newDiff)
If there is an update Difference in this transaction already for the
object being updated in newDiff this method returns it.
|
SystemObject |
DBObjectTransaction.getDiffUpdatedObject(Difference objDiff)
Gets a copy of the original object in the given diff with any
marked differences in the diff applied.
|
void |
DBObjectTransaction.includeListDifference(Difference listDiff)
Includes a Difference whose children are SystemObject Differences -
i.e.
|
void |
DBObjectTransaction.includeObjectDifference(Difference objDiff)
Includes an update to a given object in this transaction.
|
protected void |
RefactoringProcessor.processObjectDifference(DBObjectTransaction txn,
Difference objDiff)
This is called for every SystemObject Difference in the global update
Difference.
|
protected void |
CascadeProcessor.processObjectUpdate(DBObjectTransaction txn,
Difference objDiff) |
protected void |
RefactoringProcessor.processObjectUpdate(DBObjectTransaction txn,
Difference objDiff)
The default processObjectDifference implementation calls this method
for every object that is to be updated
|
protected void |
CascadeProcessor.processSingleObjectUpdate(DBObjectTransaction txn,
Difference objDiff)
This is called for each DBObject that has changed within the overall
difference.
|
abstract void |
UpdateProcessor.processUpdate(DBObjectTransaction txn,
Difference objDiff)
Called by a DBObjectProvider during a create or update process.
|
void |
RefactoringProcessor.processUpdate(DBObjectTransaction txn,
Difference objDiff) |
void |
DBObjectTransaction.removeUpdate(Difference objDiff)
Removes the given object difference from the current operation.
|
Modifier and Type | Method and Description |
---|---|
protected CascadeAction |
SchemaObjectValidator.cascadePropertyChange(Difference objDiff,
java.lang.String propName,
java.lang.Object oldValue,
java.lang.Object newValue,
T obj) |
protected boolean |
SchemaObjectValidator.checkSchemaRename(Difference objDiff,
java.lang.String propName,
T obj)
Checks the given object objDiff and propertyName and if they
represent a schema rename for the Schema of the given object then
we update obj with the new schema and return true.
|