001    package org.apache.directory.shared.ldap.schema;
002    
003    
004    import java.util.Map;
005    import java.util.Set;
006    
007    import org.apache.directory.shared.ldap.entry.Entry;
008    import org.apache.directory.shared.ldap.name.DN;
009    import org.apache.directory.shared.ldap.schema.AttributeType;
010    import org.apache.directory.shared.ldap.schema.MatchingRule;
011    import org.apache.directory.shared.ldap.schema.ObjectClass;
012    import org.apache.directory.shared.ldap.schema.registries.Schema;
013    
014    
015    public interface SchemaDao
016    {
017    
018        /**
019         * Gets a Map of Schemas managed by a schema store.
020         *
021         * @return a Map of Schemas using the name of the Schema as the key
022         * @throws Exception if there is some problem accessing the schema data
023         */
024        Map<String, Schema> getSchemas() throws Exception;
025    
026    
027        Set<String> getSchemaNames() throws Exception;
028    
029    
030        Schema getSchema( String schemaName ) throws Exception;
031    
032    
033        boolean hasMatchingRule( String oid ) throws Exception;
034    
035    
036        boolean hasAttributeType( String oid ) throws Exception;
037    
038    
039        boolean hasObjectClass( String oid ) throws Exception;
040    
041    
042        boolean hasSyntax( String oid ) throws Exception;
043    
044    
045        boolean hasSyntaxChecker( String oid ) throws Exception;
046    
047    
048        /**
049         * Given the non-normalized name (alias) or the OID for a schema entity.  This 
050         * method finds the schema under which that entity is located. 
051         * 
052         * NOTE: this method presumes that all alias names across schemas are unique.  
053         * This should be the case for LDAP but this can potentially be violated so 
054         * we should make sure this is a unique name.
055         * 
056         * @param entityName one of the names of the entity or it's numeric id
057         * @return the name of the schema that contains that entity or null if no entity with 
058         * that alias name exists
059         * @throws LdapException if more than one entity has the name, or if there 
060         * are underlying data access problems
061         */
062        String findSchema( String entityName ) throws Exception;
063    
064    
065        DN findDn( String entityName ) throws Exception;
066    
067    
068        /**
069         * Given the non-normalized name (alias) or the OID for a schema entity.  This 
070         * method finds the entry of the schema entity. 
071         * 
072         * NOTE: this method presumes that all alias names across schemas are unique.  
073         * This should be the case for LDAP but this can potentially be violated so 
074         * we should make sure this is a unique name.
075         * 
076         * @param entityName one of the names of the entity or it's numeric id
077         * @return the search result for the entity or null if no such entity exists with 
078         * that alias or numeric oid
079         * @throws LdapException if more than one entity has the name, or if there 
080         * are underlying data access problems
081         */
082        Entry find( String entityName ) throws Exception;
083    
084    
085        /**
086         * Enables a schema by removing it's m-disabled attribute if present.
087         * 
088         * NOTE:
089         * This is a write operation and great care must be taken to make sure it
090         * is used in a limited capacity.  This method is called in two places 
091         * currently.  
092         * 
093         * (1) Within the initialization sequence to enable schemas required
094         *     for the correct operation of indices in other partitions.
095         * (2) Within the partition schema loader to auto enable schemas that are
096         *     depended on by other schemas which are enabled.
097         * 
098         * In both cases, the modifier is effectively the administrator since the 
099         * server is performing the operation directly or on behalf of a user.  In 
100         * case (1) during intialization there is no other user involved so naturally
101         * the modifier is the administrator.  In case (2) when a user enables a 
102         * schema with a dependency that is not enabled the server enables that 
103         * dependency on behalf of the user.  Again effectively it is the server that
104         * is modifying the schema entry and hence the admin is the modifier.
105         * 
106         * No need to worry about a lack of replication propagation in both cases.  In 
107         * case (1) all replicas will enable these schemas anyway on startup.  In case
108         * (2) the original operation that enabled the schema depending on the on that
109         * enableSchema() is called for itself will be replicated.  Hence the same chain 
110         * reaction will occur in a replica.
111         * 
112         * @param schemaName the name of the schema to enable
113         * @throws LdapException if there is a problem updating the schema entry
114         */
115        void enableSchema( String schemaName ) throws Exception;
116    
117    
118        /**
119         * Returns the set of matchingRules and attributeTypes which depend on the 
120         * provided syntax.
121         *
122         * @param numericOid the numeric identifier for the entity
123         * @return the set of matchingRules and attributeTypes depending on a syntax
124         * @throws LdapException if the dao fails to perform search operations
125         */
126        Set<Entry> listSyntaxDependents( String numericOid ) throws Exception;
127    
128    
129        Set<Entry> listMatchingRuleDependents( MatchingRule mr ) throws Exception;
130    
131    
132        Set<Entry> listAttributeTypeDependents( AttributeType at ) throws Exception;
133    
134    
135        /**
136         * Lists the SearchResults of metaSchema objects that depend on a schema.
137         * 
138         * @param schemaName the name of the schema to search for dependees
139         * @return a set of SearchResults over the schemas whose m-dependency attribute contains schemaName
140         * @throws LdapException if there is a problem while searching the schema partition
141         */
142        Set<Entry> listSchemaDependents( String schemaName ) throws Exception;
143    
144    
145        /**
146         * Lists the SearchResults of metaSchema objects that depend on a schema.
147         * 
148         * @param schemaName the name of the schema to search for dependencies
149         * @return a set of SearchResults over the schemas whose m-dependency attribute contains schemaName
150         * @throws LdapException if there is a problem while searching the schema partition
151         */
152        Set<Entry> listEnabledSchemaDependents( String schemaName ) throws Exception;
153    
154    
155        Set<Entry> listObjectClassDependents( ObjectClass oc ) throws Exception;
156    }