Overview | Package | Class | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## edu.udo.cs.miningmart.m4
Interface Concept

All Superinterfaces:
  GraphicalM4Object, M4Data, M4Object, ParameterObject

All Known Implementing Classes:
  Concept

    public interface Concept

extends ParameterObject

Version:
  $Id: Concept.java,v 1.11 2006/09/27 14:59:58 euler Exp $
Author:
  Timm Euler, Daniel Hakenjos

Field Summary
`static java.lang.String` | `TYPE_BASE` Concepts of type BASE can be used to define a Conceptual Model.
`static java.lang.String` | `TYPE_DB` Concepts of type DB are based directly on a table.
`static java.lang.String` | `TYPE_MINING` Concepts that are the result of an operator are of type MINING.

Method Summary
`void` | `addColumnSet(Columnset cs)` Add a columnset to this concept's columnsets.
`void` | `addFeature(Feature f)` Add a Feature (a BaseAttribute or a MultiColumnFeature) to this concept.
`void` | `addFromProjection(Projection projection)` Adds a From-Projection.
`void` | `addSubConcept(Concept newSubConcept)` Adds a Sub Concept.
`void` | `addSuperConcept(Concept newSuperConcept)` Adds a Super Concept and check for cycles in the inheritance graph.
`void` | `addToProjection(Projection projection)` Adds a To-Projection.
`java.lang.String` | `canFeatureBeRemoved(Feature theFeature)` This method attempts to find invalidities of Steps that would result from removing the given Feature from this Concept.
`void` | `clearEstimations()` This method can be used to ensure that the method 'getEstimatedStatistics' updates the estimations.
`void` | `connect(java.lang.String nameOfDbObject, boolean isTable, java.util.Map columnNamesForAttribs)` This method connects this Concept to a DB object, either a table or view, by creating a Columnset and Columns for the DB object and connecting this Concept's BaseAttributes to the Columns according to the information in the given Map.
`Concept` | `copy(Case newCase)`
`BaseAttribute` | `createBaseAttribute(java.lang.String name, java.lang.String datatype, java.lang.String attributeType, java.lang.String roleName)` Creates a BaseAttribute that is connected to this Concept.
`Columnset` | `createColumnset(java.lang.String name, java.lang.String schema, java.lang.String type)` Creates a new ColumnSet that is connected to this Concept.
`Relation` | `createFromConceptRelation(java.lang.String name, Concept toConcept)` Creates a new Relationship to which this Concept is connected as FromConcept.
`MultiColumnFeature` | `createMultiColumnFeature(java.lang.String name)` Creates a new MultiColumnFeature that is connected to this Concept.
`PrimaryKey` | `createPrimaryKey(java.util.Collection keyAttribs)` Creates a PrimaryKey for the Columnset of this Concept.
`Projection` | `createProjectionToConcept(Concept toConcept, java.lang.String nameOfProjection)` Create a new Projection from this concept to the given concept.
`java.util.Collection` | `getAllBaseAttributes()` Returns ALL BaseAttributes of this Concept, including those that directly belong to a MultiColumnFeature that belongs to this Concept, but do not belong directly to this concept.
`java.util.Collection` | `getAllMultiColumnFeatures()`
`java.util.Collection` | `getBaseAttribsNotInMcf()` Returns ONLY those BaseAttributes of this Concept that do not belong to a MultiColumnFeature.
`BaseAttribute` | `getBaseAttribute(Column column)` Returns the BaseAttribute of this Concept that is connected to the given Column, if it exists.
`BaseAttribute` | `getBaseAttribute(java.lang.String name)`
`java.util.Collection` | `getBaseAttributesVisible(Step stepWhereVisible)` Returns only those BaseAttributes of this Concept that are visible at the given Step.
`Columnset` | `getColumnset(java.lang.String colunsetname)`
`java.util.Collection` | `getColumnSets()`
`java.util.Collection` | `getConceptInheritanceAsSubConcept()` Returns the Collection of ConceptInheritance objects with this Concept as a Sub-Concept
`java.util.Collection` | `getConceptInheritanceAsSuperConcept()` Returns the Collection of ConceptInheritance objects with this Concept as a Super-Concept
`Columnset` | `getCurrentColumnSet()` This method returns a specific columnset: in a compilation where multistep operators have occured, there can be more than one columnset for an input concept.
`java.lang.String` | `getCurrentSuffix()` This method returns a suffix for the current Columnset.
`EstimatedStatistics` | `getEstimatedStatistics(Step visibleHere)` Estimate the statistics for this concept and for all its attributes that are visible at the given step.
`Feature` | `getFeature(int index)` Get a specific Feature by index.
`Feature` | `getFeature(java.lang.String name)` Get a specific Feature by name.
`java.lang.String` | `getFeatureNames()` Returns a String with comma-separated names of the Features of this Concept.
`java.util.Collection` | `getFeatures()`
`Columnset` | `getNextColumnSet()` In case of multi step support this method returns the next column set after the current one and increases the internal pointer accordingly.
`int` | `getNumberOfFeatures()` Returns the number of features that this Concept has.
`Parameter` | `getParameterWhereThisIsOutputConcept()` Return the Parameter object that represents this concept as an output concept parameter (of a certain step).
`PrimaryKey` | `getPrimaryKey()` Returns the PrimaryKey of the Columnset of this Concept.
`java.util.Collection` | `getProjectionsAsFromConcept()` Returns the From-Projections.
`java.util.Collection` | `getProjectionsAsToConcept()` Returns the To-Projections.
`Relation` | `getRelationshipFromConcept(Concept fromConcept)` Returns a Relation with this concept as the ToConcept and the given concept as the FromConcept, if such a Relation exists, and NULL otherwise.
`Relation` | `getRelationshipToConcept(Concept toConcept)` Returns a Relation with this concept as the FromConcept and the given concept as the ToConcept, if such a Relation exists, and NULL otherwise.
`java.util.Collection` | `getStepsWhereThisIsInputConcept()` Returns all Steps in the Case that use this Concept as an input concept.
`Step` | `getStepWhereThisIsOutputConcept()` Returns the Step in the Case where this Concept is created as the output concept.
`java.util.Collection` | `getSubConcepts()` This method gets the set of all sub concepts
`java.util.Collection` | `getSuperConcepts()` This method gets the set of all super concepts
`Case` | `getTheCase()` Getter method.
`Concept` | `getTheFromProjection()`
`java.util.Collection` | `getTheFromRelationships()` Returns a Collection of Relations in which this concept is the FromConcept.
`Concept` | `getTheSuperConcept()` Usually there is only one Super Concept.
`java.util.Collection` | `getTheToRelationships()` Returns a Collection of Relations in which this concept is the ToConcept.
`java.lang.String` | `getType()` Getter method.
`boolean` | `hasColumnset(Columnset cs)`
`boolean` | `hasFeature(Feature f)`
`boolean` | `hasMoreThanOneRelation()` Returns true iff this concept is involved, either as From-Concept or as To-Concept, in more than one relation.
`boolean` | `hasNextColumnSet()` In case of multi step support this method answers the question if getNextColumnSet() will succeed.
`void` | `initMultiStepSupport(java.util.Collection columnsets)` This method is invoked to initialize the support for concepts referring to multiple column sets (multi steps).
`boolean` | `isRelationallyValid()` This method returns information about the relational validity of the object.
`boolean` | `isValidSubconcept(Concept potentialSubConcept)` Checks wether the given concept has the same features as this one (correspondence of features is by name).
`void` | `propagateChangesToDependingConcepts(Feature changedFeature, java.lang.String previousNameOfFeature)` When this Concept has changed its Features, depending concepts of later steps can be adapted with this method.
`void` | `removeAllColumnsets()`
`void` | `removeAllFeatures()` Remove all features from this concept.
`boolean` | `removeColumnset(Columnset cs)` Remove a Columnset from this concept.
`void` | `removeConnection()` Removes the connection of this Concept to its current Columnset, but ONLY if this Concept is of type 'DB'.
`boolean` | `removeFeature(Feature feature)` Remove a Feature (a BaseAttribute or a MultiColumnFeature) from this concept.
`boolean` | `removeFeatureByName(java.lang.String name)` Remove a Feature (a BaseAttribute or a MultiColumnFeature) with the given name from this concept.
`boolean` | `removeFromProjection(Projection projection)` Removes a From-Projection.
`void` | `removeSubConcept(Concept subCon)` Removes a Sub Concept.
`void` | `removeSuperConcept(Concept superCon)` Removes a Super Concept.
`boolean` | `removeToProjection(Projection projection)` Removes a To-Projection.
`void` | `resetColumnSets()` In case of multi step support this method resets the internal pointer to the current column set to the first one.
`void` | `setColumnSets(java.util.Collection theColumnsets)` Set the columnsets of this concept.
`void` | `setFeatures(java.util.Collection theFeatures)` Set all Features into this concept.
`void` | `setTheCase(Case ca)` Sets the case for this concept
`void` | `setTheFromProjection(Concept newFromProjection)` Sets the From-Projection as the only From-Projection of this `Concept`
`void` | `setTheSuperConcept(Concept newSuperConcept)` Sets the Super Concept to be the only Super Concept of this Concept
`void` | `setType(java.lang.String t)` Setter method for the type of this concept.

Methods inherited from interface edu.udo.cs.miningmart.m4.ParameterObject
`addParameterReference, getParameterReferences, removeParameterReference`

Methods inherited from interface edu.udo.cs.miningmart.m4.GraphicalM4Object
`getPoint, setPoint`

Methods inherited from interface edu.udo.cs.miningmart.m4.M4Data
`deleteSoon, getDocumentation, getValidName, isDirty, isWaitingForDelete, setDocumentation`

Methods inherited from interface edu.udo.cs.miningmart.m4.M4Object
`doPrint, doPrint, equals, executeBusinessSingleValueSqlRead, executeBusinessSingleValueSqlReadL, executeBusinessSqlRead, executeBusinessSqlWrite, executeM4SingleValueSqlRead, executeM4SingleValueSqlReadL, executeM4SqlRead, executeM4SqlWrite, getCasePrintObject, getId, getM4Db, getM4ObjectFromCache, getName, getNextM4SequenceValue, isNew, load, print, putM4ObjectToCache, replaceSpacesInName, setId, setName, setNotNew`

Field Detail

### TYPE_BASE

    static final java.lang.String TYPE_BASE

  Concepts of type BASE can be used to define a Conceptual Model.

  See Also:
    Constant Field Values

### TYPE_DB

    static final java.lang.String TYPE_DB

  Concepts of type DB are based directly on a table. They are not the result of some operator.

  See Also:
    Constant Field Values

### TYPE_MINING

    static final java.lang.String TYPE_MINING

  Concepts that are the result of an operator are of type MINING.

  See Also:
    Constant Field Values

Method Detail

### setType

    void setType(java.lang.String t)
                 throws M4Exception

  Setter method for the type of this concept.

  Parameters:
    `t` - the new type (one of "DB", "Base", "Mining")
  Throws:
    `M4Exception`

### getType

    java.lang.String getType()

  Getter method.

  Returns:
    the type of this concept

### getParameterWhereThisIsOutputConcept

    Parameter getParameterWhereThisIsOutputConcept()
                                                   throws M4Exception

  Return the Parameter object that represents this concept as an output concept parameter (of a certain step).

  Returns:
    a Parameter object
  Throws:
    `M4Exception`

### getStepsWhereThisIsInputConcept

    java.util.Collection getStepsWhereThisIsInputConcept()
                                                         throws M4Exception

  Returns all Steps in the Case that use this Concept as an input concept.

  Returns:
    a Collection of Steps
  Throws:
    `M4Exception`

### getStepWhereThisIsOutputConcept

    Step getStepWhereThisIsOutputConcept()
                                         throws M4Exception

  Returns the Step in the Case where this Concept is created as the output concept.

  Returns:
    a Step
  Throws:
    `M4Exception`

### getEstimatedStatistics

    EstimatedStatistics getEstimatedStatistics(Step visibleHere)
                                               throws M4Exception

  Estimate the statistics for this concept and for all its attributes that are visible at the given step. If the given step is NULL, estimate the statistics for all attributes of this concept.

  Parameters:
    `visibleHere` - step that gives the place in the case for which the statistics are to be estimated
  Returns:
    an EstimatedStatistics object
  Throws:
    `M4Exception`

### clearEstimations

    void clearEstimations()

  This method can be used to ensure that the method 'getEstimatedStatistics' updates the estimations.

### addColumnSet

    void addColumnSet(Columnset cs)
                      throws M4Exception

  Add a columnset to this concept's columnsets.

  Parameters:
    `cs` - the additional columnset
  Throws:
    `M4Exception`

### removeColumnset

    boolean removeColumnset(Columnset cs)
                            throws M4Exception

  Remove a Columnset from this concept.

  Parameters:
    `cs` - the Columnset
  Throws:
    `M4Exception`

### hasColumnset

    boolean hasColumnset(Columnset cs)
                         throws M4Exception

  Parameters:
    `cs` - a `Columnset`
  Returns:
    `true` if a `Columnset` with the same ID is already linked to this `Concept`
  Throws:
    `M4Exception`

### setColumnSets

    void setColumnSets(java.util.Collection theColumnsets)
                       throws M4Exception

  Set the columnsets of this concept.

  Parameters:
    `theColumnsets` - An array with the new columnsets.
  Throws:
    `M4Exception`

### getColumnSets

    java.util.Collection getColumnSets()
                                       throws M4Exception

  Returns:
    the columnsets that belong to this concept
  Throws:
    `M4Exception`

### getCurrentSuffix

    java.lang.String getCurrentSuffix()

  This method returns a suffix for the current Columnset. See the method "getCurrentColumnset()". It is ment as a helper method for generating distinct table names, when having an input concept with multiple column sets.

  Returns:
    the index of the current Columnset as a String or the empty String if the concept has only one Columnset

### initMultiStepSupport

    void initMultiStepSupport(java.util.Collection columnsets)

  This method is invoked to initialize the support for concepts referring to multiple column sets (multi steps). The set of column sets is stored internally and a pointer to a "current" column set is maintained, in order to ease the handling by operators.

  Parameters:
    `columnsets` - An array of column sets this concept refers to.

### getCurrentColumnSet

    Columnset getCurrentColumnSet()
                                  throws M4Exception

  This method returns a specific columnset: in a compilation where multistep operators have occured, there can be more than one columnset for an input concept. The compiler then chooses one columnset for the step, compiles the step with that columnset, then chooses another one, compiles again and so on. This method returns the currently chosen columnset.

  Returns:
    the current columnset as selected by the compiler
  Throws:
    `M4Exception`

### resetColumnSets

    void resetColumnSets()

  In case of multi step support this method resets the internal pointer to the current column set to the first one.

### hasNextColumnSet

    boolean hasNextColumnSet()
                             throws M4Exception

  In case of multi step support this method answers the question if getNextColumnSet() will succeed.

  Returns:
    true if and only if there is at least one more column set after the current one.
  Throws:
    `M4Exception`

### getNextColumnSet

    Columnset getNextColumnSet()
                               throws M4Exception

  In case of multi step support this method returns the next column set after the current one and increases the internal pointer accordingly. If this method is called when hasNextColumnSet() returns false then an exception is thrown.

  Returns:
    the next columnset
  Throws:
    `M4Exception`

### getTheCase

    Case getTheCase()
                    throws M4Exception

  Getter method.

  Returns:
    the `Case` this `Concept` belongs to
  Throws:
    `M4Exception`

### setTheCase

    void setTheCase(Case ca)
                    throws M4Exception

  Sets the case for this concept

  Parameters:
    `ca` - the `Case` this `Concept` belongs to
  Throws:
    `M4Exception`

### addFeature

    void addFeature(Feature f)
                    throws M4Exception

  Add a Feature (a BaseAttribute or a MultiColumnFeature) to this concept.

  Parameters:
    `f` - the new Feature
  Throws:
    `M4Exception`

### getFeature

    Feature getFeature(java.lang.String name)
                       throws M4Exception

  Get a specific Feature by name.

  Parameters:
    `name` - the name
  Returns:
    the Feature with that name
  Throws:
    `M4Exception`

### getFeature

    Feature getFeature(int index)
                       throws M4Exception

  Get a specific Feature by index.

  Parameters:
    `index` - the index
  Returns:
    the Feature with that name
  Throws:
    `M4Exception`

### getFeatureNames

    java.lang.String getFeatureNames()
                                     throws M4Exception

  Returns a String with comma-separated names of the Features of this Concept.

  Returns:
    a String
  Throws:
    `M4Exception`

### removeFeature

    boolean removeFeature(Feature feature)
                          throws M4Exception

  Remove a Feature (a BaseAttribute or a MultiColumnFeature) from this concept.

  Parameters:
    `f` - the Feature
  Throws:
    `M4Exception`

### removeFeatureByName

    boolean removeFeatureByName(java.lang.String name)
                                throws M4Exception

  Remove a Feature (a BaseAttribute or a MultiColumnFeature) with the given name from this concept.

  Parameters:
    `name` - the Name
  Throws:
    `M4Exception`

### removeAllFeatures

    void removeAllFeatures()
                           throws M4Exception

  Remove all features from this concept.

  Throws:
    `M4Exception`

### setFeatures

    void setFeatures(java.util.Collection theFeatures)
                     throws M4Exception

  Set all Features into this concept.

  Parameters:
    `fs` - A Collection of Feature objects
  Throws:
    `M4Exception`

### getFeatures

    java.util.Collection getFeatures()
                                     throws M4Exception

  Returns:
    All Features of this concept.
  Throws:
    `M4Exception`

### getNumberOfFeatures

    int getNumberOfFeatures()
                            throws M4Exception

  Returns the number of features that this Concept has.

  Returns:
    the number of features as an int
  Throws:
    `M4Exception`

### hasFeature

    boolean hasFeature(Feature f)
                       throws M4Exception

  Parameters:
    `f` - a `Feature`
  Returns:
    `true` if a `Feature` with the same ID is already linked to this `Concept`
  Throws:
    `M4Exception`

### hasMoreThanOneRelation

    boolean hasMoreThanOneRelation()
                                   throws M4Exception

  Returns true iff this concept is involved, either as From-Concept or as To-Concept, in more than one relation.

  Returns:
    true or false
  Throws:
    `M4Exception`

### propagateChangesToDependingConcepts

    void propagateChangesToDependingConcepts(Feature changedFeature,
                                             java.lang.String previousNameOfFeature)
                                             throws M4Exception

  When this Concept has changed its Features, depending concepts of later steps can be adapted with this method. The method is not called automatically from methods addFeature or removeFeature because those methods are used too frequently during normal M4 Java administration.

  Parameters:
    `changedFeature` - specifies which feature has been changed or added
    `previousNameOfFeature` - iff the name of the feature has changed, this gives its old name, otherwise it is null
  Throws:
    `M4Exception`

### canFeatureBeRemoved

    java.lang.String canFeatureBeRemoved(Feature theFeature)
                                         throws M4Exception

  This method attempts to find invalidities of Steps that would result from removing the given Feature from this Concept. The returned String describes such an invalidity to the user. If the method returns NULL, no invalidity arises from deleting the Feature.

  Parameters:
    `theFeature` - the feature which is going to be removed
  Returns:
    a String describing problems with removing the feature, or NULL if no problems could be detected
  Throws:
    `M4Exception`

### getTheFromRelationships

    java.util.Collection getTheFromRelationships()
                                                 throws M4Exception

  Returns a Collection of Relations in which this concept is the FromConcept.

  Returns:
    Collection
  Throws:
    `M4Exception`

### getTheToRelationships

    java.util.Collection getTheToRelationships()
                                               throws M4Exception

  Returns a Collection of Relations in which this concept is the ToConcept.

  Returns:
    Collection
  Throws:
    `M4Exception`

### getRelationshipFromConcept

    Relation getRelationshipFromConcept(Concept fromConcept)
                                        throws M4Exception

  Returns a Relation with this concept as the ToConcept and the given concept as the FromConcept, if such a Relation exists, and NULL otherwise.

  Parameters:
    `fromConcept` - the given FromConcept
  Returns:
    a Relation between this concept and the FromConcept or NULL
  Throws:
    `M4Exception`

### getRelationshipToConcept

    Relation getRelationshipToConcept(Concept toConcept)
                                      throws M4Exception

  Returns a Relation with this concept as the FromConcept and the given concept as the ToConcept, if such a Relation exists, and NULL otherwise.

  Parameters:
    `toConcept` - the given toConcept
  Returns:
    a Relation between this concept and the ToConcept or NULL
  Throws:
    `M4Exception`

### getConceptInheritanceAsSuperConcept

    java.util.Collection getConceptInheritanceAsSuperConcept()
                                                             throws M4Exception

  Returns the Collection of ConceptInheritance objects with this Concept as a Super-Concept

  Returns:
    `Collection` of `ConceptInheritance`
  Throws:
    `M4Exception`

### getConceptInheritanceAsSubConcept

    java.util.Collection getConceptInheritanceAsSubConcept()
                                                           throws M4Exception

  Returns the Collection of ConceptInheritance objects with this Concept as a Sub-Concept

  Returns:
    `Collection` of `ConceptInheritance`
  Throws:
    `M4Exception`

### getSuperConcepts

    java.util.Collection getSuperConcepts()
                                          throws M4Exception

  This method gets the set of all super concepts

  Returns:
    a `Collection` of `Concept`s
  Throws:
    `M4Exception`

### getSubConcepts

    java.util.Collection getSubConcepts()
                                        throws M4Exception

  This method gets the set of all sub concepts

  Returns:
    a `Collection` of `Concept`s
  Throws:
    `M4Exception`

### getTheSuperConcept

    Concept getTheSuperConcept()
                               throws M4Exception

  Usually there is only one Super Concept.

  Returns:
    the first Super Concept or `null`
  Throws:
    `M4Exception`

### addSubConcept

    void addSubConcept(Concept newSubConcept)
                       throws M4Exception

  Adds a Sub Concept.

  Parameters:
    `newSubConcept` - The Sub Concept to add
  Throws:
    `M4Exception`

### addSuperConcept

    void addSuperConcept(Concept newSuperConcept)
                         throws M4Exception

  Adds a Super Concept and check for cycles in the inheritance graph.

  Parameters:
    `newSuperConcept` - The Super Concept to add
  Throws:
    `M4Exception`

### setTheSuperConcept

    void setTheSuperConcept(Concept newSuperConcept)
                            throws M4Exception

  Sets the Super Concept to be the only Super Concept of this Concept

  Parameters:
    `newSuperConcept` - The Super Concept to set
  Throws:
    `M4Exception`

### removeSubConcept

    void removeSubConcept(Concept subCon)
                          throws M4Exception

  Removes a Sub Concept.

  Parameters:
    `conInh` - The `Concept` object to remove
  Throws:
    `M4Exception`

### removeSuperConcept

    void removeSuperConcept(Concept superCon)
                            throws M4Exception

  Removes a Super Concept.

  Parameters:
    `conInh` - The `Concept` object to remove
  Throws:
    `M4Exception`

### isValidSubconcept

    boolean isValidSubconcept(Concept potentialSubConcept)
                              throws M4Exception

  Checks wether the given concept has the same features as this one (correspondence of features is by name).

  Throws:
    `M4Exception`

### createProjectionToConcept

    Projection createProjectionToConcept(Concept toConcept,
                                         java.lang.String nameOfProjection)
                                         throws M4Exception

  Create a new Projection from this concept to the given concept. The new Projection is returned; in it, this concept is the from concept and the given concept is the to concept.

  Throws:
    `M4Exception`

### addToProjection

    void addToProjection(Projection projection)
                         throws M4Exception

  Adds a To-Projection.

  Parameters:
    `projection` - The Projection to add with this Concept as the To-Concept
  Throws:
    `M4Exception`

### removeToProjection

    boolean removeToProjection(Projection projection)
                               throws M4Exception

  Removes a To-Projection.

  Parameters:
    `projection` - The Projection (with this Concept as the To-Concept) to be removed
  Returns:
    `true` if the object was found and removed from the `Collection`
  Throws:
    `M4Exception`

### addFromProjection

    void addFromProjection(Projection projection)
                           throws M4Exception

  Adds a From-Projection.

  Parameters:
    `projection` - The Projection to add with this Concept as the From-Concept
  Throws:
    `M4Exception`

### removeFromProjection

    boolean removeFromProjection(Projection projection)
                                 throws M4Exception

  Removes a From-Projection.

  Parameters:
    `projection` - The Projection (with this Concept as the From-Concept) to be removed
  Throws:
    `M4Exception`

### setTheFromProjection

    void setTheFromProjection(Concept newFromProjection)
                              throws M4Exception

  Sets the From-Projection as the only From-Projection of this `Concept`

  Parameters:
    `newFromProjection` - The From-Projection to set
  Throws:
    `M4Exception`

### getTheFromProjection

    Concept getTheFromProjection()
                                 throws M4Exception

  Returns:
    the (first) `Concept` which this `Concept` is a `Projection` from.
  Throws:
    `M4Exception`

### getProjectionsAsFromConcept

    java.util.Collection getProjectionsAsFromConcept()
                                                     throws M4Exception

  Returns the From-Projections.

  Returns:
    `Collection` of `Projection` objects
  Throws:
    `M4Exception`

### getProjectionsAsToConcept

    java.util.Collection getProjectionsAsToConcept()
                                                   throws M4Exception

  Returns the To-Projections.

  Returns:
    `Collection` of `Projection` objects
  Throws:
    `M4Exception`

### isRelationallyValid

    boolean isRelationallyValid()
                                throws M4Exception

  This method returns information about the relational validity of the object. The relational validity is managed at the database level by triggers. The returned value denotes if the object is valid on the relational level or not.

  Throws:
    `M4Exception`

### createBaseAttribute

    BaseAttribute createBaseAttribute(java.lang.String name,
                                      java.lang.String datatype,
                                      java.lang.String attributeType,
                                      java.lang.String roleName)
                                      throws M4Exception

  Creates a BaseAttribute that is connected to this Concept. The name of the BaseAttribute must be unique within the Concept. The attributetype should also be provided or will be set to BASE if omitted. Use the predefined constants to set the datatype.

  Throws:
    `M4Exception` - when an error occurs during creation of the object.

### createColumnset

    Columnset createColumnset(java.lang.String name,
                              java.lang.String schema,
                              java.lang.String type)
                              throws M4Exception

  Creates a new ColumnSet that is connected to this Concept. The name must be unique within this Concept. The schema and type are also required. Use the predefined types for the type parameter.

  Throws:
    `M4Exception` - when an error occurs during creation of the object.

### getColumnset

    Columnset getColumnset(java.lang.String colunsetname)
                           throws M4Exception

  Throws:
    `M4Exception`

### removeAllColumnsets

    void removeAllColumnsets()
                             throws M4Exception

  Throws:
    `M4Exception`

### copy

    Concept copy(Case newCase)
                 throws M4Exception

  Throws:
    `M4Exception`

### getBaseAttribute

    BaseAttribute getBaseAttribute(java.lang.String name)
                                   throws M4Exception

  Throws:
    `M4Exception`

### getBaseAttribute

    BaseAttribute getBaseAttribute(Column column)
                                   throws M4Exception

  Returns the BaseAttribute of this Concept that is connected to the given Column, if it exists. Otherwise null is returned.

  Parameters:
    `column` - the Column
  Returns:
    a BaseAttribute of this Concept, or null
  Throws:
    `M4Exception`

### getAllBaseAttributes

    java.util.Collection getAllBaseAttributes()
                                              throws M4Exception

  Returns ALL BaseAttributes of this Concept, including those that directly belong to a MultiColumnFeature that belongs to this Concept, but do not belong directly to this concept.

  Throws:
    `M4Exception`

### getBaseAttribsNotInMcf

    java.util.Collection getBaseAttribsNotInMcf()
                                                throws M4Exception

  Returns ONLY those BaseAttributes of this Concept that do not belong to a MultiColumnFeature.

  Throws:
    `M4Exception`

### getBaseAttributesVisible

    java.util.Collection getBaseAttributesVisible(Step stepWhereVisible)
                                                  throws M4Exception

  Returns only those BaseAttributes of this Concept that are visible at the given Step. If the step is null, all BaseAttributes of this Concept are returned.

  Parameters:
    `stepWhereVisible` - Step where BAs must be visible
  Returns:
    Collection of BaseAttributes
  Throws:
    `M4Exception`

### connect

    void connect(java.lang.String nameOfDbObject,
                 boolean isTable,
                 java.util.Map columnNamesForAttribs)
                 throws M4Exception

  This method connects this Concept to a DB object, either a table or view, by creating a Columnset and Columns for the DB object and connecting this Concept's BaseAttributes to the Columns according to the information in the given Map. If this Concept is not of type 'DB', the method will do nothing.

  Parameters:
    `nameOfDbObject` - name of a table or view in the business data schema
    `isTable` - TRUE iff 'nameOfDbObject' refers to a table (otherwise a view is assumed)
    `columnNamesForAttribs` - a Map that maps every BaseAttribute of this Concept to a String. The String is the name of the Column that this BaseAttribute will be connected to.
  Throws:
    `M4Exception`

### removeConnection

    void removeConnection()
                          throws M4Exception

  Removes the connection of this Concept to its current Columnset, but ONLY if this Concept is of type 'DB'.

  Throws:
    `M4Exception`

### createPrimaryKey

    PrimaryKey createPrimaryKey(java.util.Collection keyAttribs)
                                throws M4Exception

  Creates a PrimaryKey for the Columnset of this Concept.

  Parameters:
    `keyAttribs` - a Collection of BaseAttributes, each of which is part of the PrimaryKey
  Returns:
    the new PrimaryKey
  Throws:
    `M4Exception`

### getPrimaryKey

    PrimaryKey getPrimaryKey()
                             throws M4Exception

  Returns the PrimaryKey of the Columnset of this Concept.

  Returns:
  Throws:
    `M4Exception`

### createMultiColumnFeature

    MultiColumnFeature createMultiColumnFeature(java.lang.String name)
                                                throws M4Exception

  Creates a new MultiColumnFeature that is connected to this Concept. The name must be unique within this Concept.

  Throws:
    `M4Exception` - when an error occurs during creation of the object.

### getAllMultiColumnFeatures

    java.util.Collection getAllMultiColumnFeatures()
                                                   throws M4Exception

  Throws:
    `M4Exception`

### createFromConceptRelation

    Relation createFromConceptRelation(java.lang.String name,
                                       Concept toConcept)
                                       throws M4Exception

  Creates a new Relationship to which this Concept is connected as FromConcept. The name of the Relationship in combination with the name of the ToConcept must be unique for the Concept. This allows a Concept to have Relationships to other Concepts with the same name. NOTE: A new Relationship should always be created as a FromConceptRelationship; no method is provided to create a ToConceptRelationship.

  Parameters:
    `name` - the name for the relationship
    `toConcept` - the Concept the relationship should point to
  Throws:
    `M4Exception` - when an error occurs during creation of the object.

Overview | Package | Class | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

Copyright © 2001-2005