git.sur5r.net Git - openldap/blob - servers/slapd/back-ldbm/index.c

   1 /* index.c - routines for dealing with attribute indexes */
   2 /* $OpenLDAP$ */
   3 /*
   4  * Copyright 1998-2002 The OpenLDAP Foundation, All Rights Reserved.
   5  * COPYING RESTRICTIONS APPLY, see COPYRIGHT file
   6  */
   7
   8 #include "portable.h"
   9
  10 #include <stdio.h>
  11
  12 #include <ac/string.h>
  13 #include <ac/socket.h>
  14
  15 #include "slap.h"
  16 #include "back-ldbm.h"
  17
  18 static slap_mask_t index_mask(
  19         Backend *be,
  20         AttributeDescription *desc,
  21         char **dbname,
  22         struct berval *atname )
  23 {
  24         AttributeType *at;
  25         slap_mask_t mask = 0;
  26
  27         attr_mask( be->be_private, desc, &mask );
  28
  29         if( mask ) {
  30                 *atname = desc->ad_cname;
  31                 *dbname = desc->ad_cname.bv_val;
  32                 return mask;
  33         }
  34
  35         /* If there is a language tag, did we ever index the base
  36          * type? If so, check for mask, otherwise it's not there.
  37          */
  38         if( slap_ad_is_lang( desc ) && desc != desc->ad_type->sat_ad ) {
  39                 /* has language tag */
  40                 attr_mask( be->be_private, desc->ad_type->sat_ad, &mask );
  41
  42                 if( mask && ( mask ^ SLAP_INDEX_NOLANG ) ) {
  43                         *atname = desc->ad_type->sat_cname;
  44                         *dbname = desc->ad_type->sat_cname.bv_val;
  45                         return mask;
  46                 }
  47         }
  48
  49         /* see if supertype defined mask for its subtypes */
  50         for( at = desc->ad_type->sat_sup; at != NULL ; at = at->sat_sup ) {
  51                 /* If no AD, we've never indexed this type */
  52                 if (!at->sat_ad)
  53                         continue;
  54
  55                 attr_mask( be->be_private, at->sat_ad, &mask );
  56
  57                 if( mask && ( mask ^ SLAP_INDEX_NOSUBTYPES ) ) {
  58                         *atname = at->sat_cname;
  59                         *dbname = at->sat_cname.bv_val;
  60                         return mask;
  61                 }
  62         }
  63
  64         return 0;
  65 }
  66
  67 int index_is_indexed(
  68         Backend *be,
  69         AttributeDescription *desc )
  70 {
  71         slap_mask_t mask;
  72         char *dbname;
  73         struct berval prefix;
  74
  75         mask = index_mask( be, desc, &dbname, &prefix );
  76
  77         if( mask == 0 ) {
  78                 return LDAP_INAPPROPRIATE_MATCHING;
  79         }
  80
  81         return LDAP_SUCCESS;
  82 }
  83
  84 int index_param(
  85         Backend *be,
  86         AttributeDescription *desc,
  87         int ftype,
  88         char **dbnamep,
  89         slap_mask_t *maskp,
  90         struct berval *prefixp )
  91 {
  92         slap_mask_t mask;
  93         char *dbname;
  94
  95         mask = index_mask( be, desc, &dbname, prefixp );
  96
  97         if( mask == 0 ) {
  98                 return LDAP_INAPPROPRIATE_MATCHING;
  99         }
 100
 101         switch( ftype ) {
 102         case LDAP_FILTER_PRESENT:
 103                 if( IS_SLAP_INDEX( mask, SLAP_INDEX_PRESENT ) ) {
 104                         goto done;
 105                 }
 106                 break;
 107
 108         case LDAP_FILTER_APPROX:
 109                 if( IS_SLAP_INDEX( mask, SLAP_INDEX_APPROX ) ) {
 110                         goto done;
 111                 }
 112                 /* fall thru */
 113
 114         case LDAP_FILTER_EQUALITY:
 115                 if( IS_SLAP_INDEX( mask, SLAP_INDEX_EQUALITY ) ) {
 116                         goto done;
 117                 }
 118                 break;
 119
 120         case LDAP_FILTER_SUBSTRINGS:
 121                 if( IS_SLAP_INDEX( mask, SLAP_INDEX_SUBSTR ) ) {
 122                         goto done;
 123                 }
 124                 break;
 125
 126         default:
 127                 return LDAP_OTHER;
 128         }
 129
 130         return LDAP_INAPPROPRIATE_MATCHING;
 131
 132 done:
 133         *dbnamep = dbname;
 134         *maskp = mask;
 135         return LDAP_SUCCESS;
 136 }
 137
 138 static int indexer(
 139         Backend *be,
 140         char *dbname,
 141         struct berval *atname,
 142         BerVarray vals,
 143         ID id,
 144         int op,
 145         slap_mask_t mask )
 146 {
 147         int rc, i;
 148         const char *text;
 149     DBCache     *db;
 150         AttributeDescription *ad = NULL;
 151         struct berval *keys;
 152
 153         assert( mask );
 154
 155         rc = slap_bv2ad( atname, &ad, &text );
 156
 157         if( rc != LDAP_SUCCESS ) return rc;
 158
 159         db = ldbm_cache_open( be, dbname, LDBM_SUFFIX, LDBM_WRCREAT );
 160
 161         if ( db == NULL ) {
 162 #ifdef NEW_LOGGING
 163                 LDAP_LOG(( "index", LDAP_LEVEL_ERR,
 164                            "index_read: Could not open db %s%s\n",
 165                            dbname, LDBM_SUFFIX ));
 166 #else
 167                 Debug( LDAP_DEBUG_ANY,
 168                     "<= index_read NULL (could not open %s%s)\n",
 169                         dbname, LDBM_SUFFIX, 0 );
 170 #endif
 171
 172                 return LDAP_OTHER;
 173         }
 174
 175         if( IS_SLAP_INDEX( mask, SLAP_INDEX_PRESENT ) ) {
 176                 key_change( be, db, atname, id, op );
 177         }
 178
 179         if( IS_SLAP_INDEX( mask, SLAP_INDEX_EQUALITY ) ) {
 180                 rc = ad->ad_type->sat_equality->smr_indexer(
 181                         LDAP_FILTER_EQUALITY,
 182                         mask,
 183                         ad->ad_type->sat_syntax,
 184                         ad->ad_type->sat_equality,
 185                         atname, vals, &keys );
 186
 187                 if( rc == LDAP_SUCCESS && keys != NULL ) {
 188                         for( i=0; keys[i].bv_val != NULL; i++ ) {
 189                                 key_change( be, db, &keys[i], id, op );
 190                         }
 191                         ber_bvarray_free( keys );
 192                 }
 193         }
 194
 195         if( IS_SLAP_INDEX( mask, SLAP_INDEX_APPROX ) ) {
 196                 rc = ad->ad_type->sat_approx->smr_indexer(
 197                         LDAP_FILTER_APPROX,
 198                         mask,
 199                         ad->ad_type->sat_syntax,
 200                         ad->ad_type->sat_approx,
 201                         atname, vals, &keys );
 202
 203                 if( rc == LDAP_SUCCESS && keys != NULL ) {
 204                         for( i=0; keys[i].bv_val != NULL; i++ ) {
 205                                 key_change( be, db, &keys[i], id, op );
 206                         }
 207                         ber_bvarray_free( keys );
 208                 }
 209         }
 210
 211         if( IS_SLAP_INDEX( mask, SLAP_INDEX_SUBSTR ) ) {
 212                 rc = ad->ad_type->sat_substr->smr_indexer(
 213                         LDAP_FILTER_SUBSTRINGS,
 214                         mask,
 215                         ad->ad_type->sat_syntax,
 216                         ad->ad_type->sat_substr,
 217                         atname, vals, &keys );
 218
 219                 if( rc == LDAP_SUCCESS && keys != NULL ) {
 220                         for( i=0; keys[i].bv_val != NULL; i++ ) {
 221                                 key_change( be, db, &keys[i], id, op );
 222                         }
 223                         ber_bvarray_free( keys );
 224                 }
 225         }
 226
 227         ldbm_cache_close( be, db );
 228         return LDAP_SUCCESS;
 229 }
 230
 231 static int index_at_values(
 232         Backend *be,
 233         AttributeType *type,
 234         struct berval *lang,
 235         BerVarray vals,
 236         ID id,
 237         int op )
 238 {
 239         slap_mask_t mask = 0;
 240
 241         if( type->sat_sup ) {
 242                 /* recurse */
 243                 (void) index_at_values( be,
 244                         type->sat_sup, lang,
 245                         vals, id, op );
 246         }
 247
 248         /* If this type has no AD, we've never used it before */
 249         if( type->sat_ad ) {
 250                 attr_mask( be->be_private, type->sat_ad, &mask );
 251         }
 252
 253         if( mask ) {
 254                 indexer( be, type->sat_cname.bv_val,
 255                         &type->sat_cname,
 256                         vals, id, op,
 257                         mask );
 258         }
 259
 260         if( lang->bv_len ) {
 261                 AttributeDescription *desc;
 262
 263                 mask = 0;
 264
 265                 desc = ad_find_lang(type, lang);
 266                 if( desc ) {
 267                         attr_mask( be->be_private, desc, &mask );
 268                 }
 269
 270                 if( mask ) {
 271                         indexer( be, desc->ad_cname.bv_val, &desc->ad_cname,
 272                                 vals, id, op,
 273                                 mask );
 274                 }
 275         }
 276
 277         return LDAP_SUCCESS;
 278 }
 279
 280 int index_values(
 281         Backend *be,
 282         AttributeDescription *desc,
 283         BerVarray vals,
 284         ID id,
 285         int op )
 286 {
 287         (void) index_at_values( be,
 288                 desc->ad_type, &desc->ad_lang,
 289                 vals, id, op );
 290
 291         return LDAP_SUCCESS;
 292 }
 293
 294 int
 295 index_entry(
 296     Backend     *be,
 297         int op,
 298     Entry *e,
 299         Attribute *ap )
 300 {
 301 #ifdef NEW_LOGGING
 302         LDAP_LOG(( "index", LDAP_LEVEL_ENTRY,
 303                    "index_entry: %s (%s)%ld\n",
 304                    op == SLAP_INDEX_ADD_OP ? "add" : "del",
 305                    e->e_dn, e->e_id ));
 306 #else
 307         Debug( LDAP_DEBUG_TRACE, "=> index_entry_%s( %ld, \"%s\" )\n",
 308                 op == SLAP_INDEX_ADD_OP ? "add" : "del",
 309                 e->e_id, e->e_dn );
 310 #endif
 311
 312         /* add each attribute to the indexes */
 313         for ( ; ap != NULL; ap = ap->a_next ) {
 314                 index_values( be, ap->a_desc, ap->a_vals, e->e_id, op );
 315         }
 316
 317 #ifdef NEW_LOGGING
 318         LDAP_LOG(( "index", LDAP_LEVEL_ENTRY,
 319                    "index_entry: success\n" ));
 320 #else
 321         Debug( LDAP_DEBUG_TRACE, "<= index_entry_%s( %ld, \"%s\" ) success\n",
 322             op == SLAP_INDEX_ADD_OP ? "add" : "del",
 323                 e->e_id, e->e_dn );
 324 #endif
 325
 326         return LDAP_SUCCESS;
 327 }
 328