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.7 2006/04/11 14:10:13 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.
 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)
          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)
           
 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()
           
 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 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()
          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
 

Field Detail

TYPE_BASE

public 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

public 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

public 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

public 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

public java.lang.String getType()
Getter method.

Returns:
the type of this concept

getParameterWhereThisIsOutputConcept

public 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

public 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

public 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

public EstimatedStatistics getEstimatedStatistics()
                                           throws M4Exception
Throws:
M4Exception

addColumnSet

public void addColumnSet(Columnset cs)
                  throws M4Exception
Add a columnset to this concept's columnsets.

Parameters:
cs - the additional columnset
Throws:
M4Exception

removeColumnset

public boolean removeColumnset(Columnset cs)
                        throws M4Exception
Remove a Columnset from this concept.

Parameters:
cs - the Columnset
Throws:
M4Exception

hasColumnset

public 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

public 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

public java.util.Collection getColumnSets()
                                   throws M4Exception
Returns:
the columnsets that belong to this concept
Throws:
M4Exception

getCurrentSuffix

public 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

public 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

public 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

public void resetColumnSets()
In case of multi step support this method resets the internal pointer to the current column set to the first one.


hasNextColumnSet

public 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

public 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

public Case getTheCase()
                throws M4Exception
Getter method.

Returns:
the Case this Concept belongs to
Throws:
M4Exception

setTheCase

public void setTheCase(Case ca)
                throws M4Exception
Sets the case for this concept

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

addFeature

public 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

public 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

public 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

public 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

public boolean removeFeature(Feature feature)
                      throws M4Exception
Remove a Feature (a BaseAttribute or a MultiColumnFeature) from this concept.

Throws:
M4Exception

removeFeatureByName

public 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

public void removeAllFeatures()
                       throws M4Exception
Remove all features from this concept.

Throws:
M4Exception

setFeatures

public void setFeatures(java.util.Collection theFeatures)
                 throws M4Exception
Set all Features into this concept.

Throws:
M4Exception

getFeatures

public java.util.Collection getFeatures()
                                 throws M4Exception
Returns:
All Features of this concept.
Throws:
M4Exception

getNumberOfFeatures

public int getNumberOfFeatures()
                        throws M4Exception
Returns the number of features that this Concept has.

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

hasFeature

public 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

propagateChangesToDependingConcepts

public void propagateChangesToDependingConcepts()
                                         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.

Throws:
M4Exception

getTheFromRelationships

public java.util.Collection getTheFromRelationships()
                                             throws M4Exception
Returns a Collection of Relations in which this concept is the FromConcept.

Returns:
Collection
Throws:
M4Exception

getTheToRelationships

public java.util.Collection getTheToRelationships()
                                           throws M4Exception
Returns a Collection of Relations in which this concept is the ToConcept.

Returns:
Collection
Throws:
M4Exception

getRelationshipFromConcept

public 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

public 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

public 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

public 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

public java.util.Collection getSuperConcepts()
                                      throws M4Exception
This method gets the set of all super concepts

Returns:
a Collection of Concepts
Throws:
M4Exception

getSubConcepts

public java.util.Collection getSubConcepts()
                                    throws M4Exception
This method gets the set of all sub concepts

Returns:
a Collection of Concepts
Throws:
M4Exception

getTheSuperConcept

public Concept getTheSuperConcept()
                           throws M4Exception
Usually there is only one Super Concept.

Returns:
the first Super Concept or null
Throws:
M4Exception

addSubConcept

public void addSubConcept(Concept newSubConcept)
                   throws M4Exception
Adds a Sub Concept.

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

addSuperConcept

public 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

public 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

public void removeSubConcept(Concept subCon)
                      throws M4Exception
Removes a Sub Concept.

Throws:
M4Exception

removeSuperConcept

public void removeSuperConcept(Concept superCon)
                        throws M4Exception
Removes a Super Concept.

Throws:
M4Exception

isValidSubconcept

public 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

public 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

public 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

public 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

public void addFromProjection(Projection projection)
                       throws M4Exception
Adds a From-Projection.

Parameters:
projection - The Projection to add with this Concept as the From-Concept
Returns:
true if the object was found and removed from the Collection
Throws:
M4Exception

removeFromProjection

public 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

public 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

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

getProjectionsAsFromConcept

public java.util.Collection getProjectionsAsFromConcept()
                                                 throws M4Exception
Returns the From-Projections.

Returns:
Collection of Projection objects
Throws:
M4Exception

getProjectionsAsToConcept

public java.util.Collection getProjectionsAsToConcept()
                                               throws M4Exception
Returns the To-Projections.

Returns:
Collection of Projection objects
Throws:
M4Exception

isRelationallyValid

public 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

public BaseAttribute createBaseAttribute(java.lang.String name,
                                         java.lang.String datatype,
                                         java.lang.String attributeType)
                                  throws M4Exception
Creates a BaseAttribute that is connected to this Concept. The name of the BaseAttribute must be unique within the Concept. The datatype 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

public 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

public Columnset getColumnset(java.lang.String colunsetname)
                       throws M4Exception
Throws:
M4Exception

removeAllColumnsets

public void removeAllColumnsets()
                         throws M4Exception
Throws:
M4Exception

copy

public Concept copy(Case newCase)
             throws M4Exception
Throws:
M4Exception

getBaseAttribute

public BaseAttribute getBaseAttribute(java.lang.String name)
                               throws M4Exception
Throws:
M4Exception

getBaseAttribute

public 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

public 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

public java.util.Collection getBaseAttribsNotInMcf()
                                            throws M4Exception
Returns ONLY those BaseAttributes of this Concept that do not belong to a MultiColumnFeature.

Throws:
M4Exception

connect

public 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

public 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

public 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

public PrimaryKey getPrimaryKey()
                         throws M4Exception
Returns the PrimaryKey of the Columnset of this Concept.

Returns:
Throws:
M4Exception

createMultiColumnFeature

public 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

public java.util.Collection getAllMultiColumnFeatures()
                                               throws M4Exception
Throws:
M4Exception

createFromConceptRelation

public 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.


Copyright © 2001-2005