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-2000 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         char **atname )
  23 {
  24         AttributeType *at;
  25         slap_mask_t mask = 0;
  26
  27         /* we do not support indexing of binary attributes */
  28         if( slap_ad_is_binary( desc ) ) return 0;
  29
  30         attr_mask( be->be_private, desc->ad_cname.bv_val, &mask );
  31
  32         if( mask ) {
  33                 *atname = desc->ad_cname.bv_val;
  34                 *dbname = desc->ad_cname.bv_val;
  35                 return mask;
  36         }
  37
  38         if( slap_ad_is_lang( desc ) ) {
  39                 /* has language tag */
  40                 attr_mask( be->be_private, desc->ad_type->sat_cname, &mask );
  41
  42                 if( mask & SLAP_INDEX_AUTO_LANG ) {
  43                         *atname = desc->ad_cname.bv_val;
  44                         *dbname = desc->ad_type->sat_cname;
  45                         return mask;
  46                 }
  47                 if( mask & SLAP_INDEX_LANG ) {
  48                         *atname = desc->ad_type->sat_cname;
  49                         *dbname = desc->ad_type->sat_cname;
  50                         return mask;
  51                 }
  52         }
  53
  54         /* see if supertype defined mask for its subtypes */
  55         for( at = desc->ad_type; at != NULL ; at = at->sat_sup ) {
  56                 attr_mask( be->be_private, at->sat_cname, &mask );
  57
  58                 if( mask & SLAP_INDEX_AUTO_SUBTYPES ) {
  59                         *atname = desc->ad_type->sat_cname;
  60                         *dbname = at->sat_cname;
  61                         return mask;
  62                 }
  63                 if( mask & SLAP_INDEX_SUBTYPES ) {
  64                         *atname = at->sat_cname;
  65                         *dbname = at->sat_cname;
  66                         return mask;
  67                 }
  68
  69                 if( mask ) break;
  70         }
  71
  72         return 0;
  73 }
  74
  75 int index_param(
  76         Backend *be,
  77         AttributeDescription *desc,
  78         int ftype,
  79         char **dbnamep,
  80         slap_mask_t *maskp,
  81         struct berval **prefixp )
  82 {
  83         slap_mask_t mask;
  84         char *dbname;
  85         char *atname;
  86
  87         mask = index_mask( be, desc, &dbname, &atname );
  88
  89         if( mask == 0 ) {
  90                 return LDAP_INAPPROPRIATE_MATCHING;
  91         }
  92
  93         switch(ftype) {
  94         case LDAP_FILTER_PRESENT:
  95                 if( IS_SLAP_INDEX( mask, SLAP_INDEX_PRESENT ) ) {
  96                         goto done;
  97                 }
  98                 break;
  99
 100         case LDAP_FILTER_APPROX:
 101                 if( IS_SLAP_INDEX( mask, SLAP_INDEX_APPROX ) ) {
 102                         goto done;
 103                 }
 104                 /* fall thru */
 105
 106         case LDAP_FILTER_EQUALITY:
 107                 if( IS_SLAP_INDEX( mask, SLAP_INDEX_EQUALITY ) ) {
 108                         goto done;
 109                 }
 110                 break;
 111
 112         case LDAP_FILTER_SUBSTRINGS:
 113                 if( IS_SLAP_INDEX( mask, SLAP_INDEX_SUBSTR ) ) {
 114                         goto done;
 115                 }
 116                 break;
 117
 118         default:
 119                 return LDAP_OTHER;
 120         }
 121
 122         return LDAP_INAPPROPRIATE_MATCHING;
 123
 124 done:
 125         *dbnamep = dbname;
 126         *prefixp = ber_bvstrdup( atname );
 127         *maskp = mask;
 128         return LDAP_SUCCESS;
 129 }
 130
 131 static int indexer(
 132         Backend *be,
 133         char *dbname,
 134         char *atname,
 135         struct berval **vals,
 136         ID id,
 137         int op,
 138         slap_mask_t mask )
 139 {
 140         int rc, i;
 141         const char *text;
 142     DBCache     *db;
 143         AttributeDescription *ad = NULL;
 144         struct berval **keys;
 145         struct berval prefix;
 146
 147         assert( mask );
 148
 149         rc = slap_str2ad( atname, &ad, &text );
 150
 151         if( rc != LDAP_SUCCESS ) return rc;
 152
 153         prefix.bv_val = atname;
 154         prefix.bv_len = strlen( atname );
 155
 156         db = ldbm_cache_open( be, dbname, LDBM_SUFFIX, LDBM_WRCREAT );
 157
 158         if ( db == NULL ) {
 159 #ifdef NEW_LOGGING
 160                 LDAP_LOG(( "index", LDAP_LEVEL_ERR,
 161                            "index_read: Could not open db %s%s\n",
 162                            dbname, LDBM_SUFFIX ));
 163 #else
 164                 Debug( LDAP_DEBUG_ANY,
 165                     "<= index_read NULL (could not open %s%s)\n",
 166                         dbname, LDBM_SUFFIX, 0 );
 167 #endif
 168
 169                 return LDAP_OTHER;
 170         }
 171
 172         if( IS_SLAP_INDEX( mask, SLAP_INDEX_PRESENT ) ) {
 173                 key_change( be, db, &prefix, id, op );
 174         }
 175
 176         if( IS_SLAP_INDEX( mask, SLAP_INDEX_EQUALITY ) ) {
 177                 rc = ad->ad_type->sat_equality->smr_indexer(
 178                         LDAP_FILTER_EQUALITY,
 179                         mask,
 180                         ad->ad_type->sat_syntax,
 181                         ad->ad_type->sat_equality,
 182                         &prefix, vals, &keys );
 183
 184                 if( rc == LDAP_SUCCESS && keys != NULL ) {
 185                         for( i=0; keys[i] != NULL; i++ ) {
 186                                 key_change( be, db, keys[i], id, op );
 187                         }
 188                         ber_bvecfree( keys );
 189                 }
 190         }
 191
 192         if( IS_SLAP_INDEX( mask, SLAP_INDEX_APPROX ) ) {
 193                 rc = ad->ad_type->sat_approx->smr_indexer(
 194                         LDAP_FILTER_APPROX,
 195                         mask,
 196                         ad->ad_type->sat_syntax,
 197                         ad->ad_type->sat_approx,
 198                         &prefix, vals, &keys );
 199
 200                 if( rc == LDAP_SUCCESS && keys != NULL ) {
 201                         for( i=0; keys[i] != NULL; i++ ) {
 202                                 key_change( be, db, keys[i], id, op );
 203                         }
 204                         ber_bvecfree( keys );
 205                 }
 206         }
 207
 208         if( IS_SLAP_INDEX( mask, SLAP_INDEX_SUBSTR ) ) {
 209                 rc = ad->ad_type->sat_substr->smr_indexer(
 210                         LDAP_FILTER_SUBSTRINGS,
 211                         mask,
 212                         ad->ad_type->sat_syntax,
 213                         ad->ad_type->sat_substr,
 214                         &prefix, vals, &keys );
 215
 216                 if( rc == LDAP_SUCCESS && keys != NULL ) {
 217                         for( i=0; keys[i] != NULL; i++ ) {
 218                                 key_change( be, db, keys[i], id, op );
 219                         }
 220                         ber_bvecfree( keys );
 221                 }
 222         }
 223
 224         ldbm_cache_close( be, db );
 225         return LDAP_SUCCESS;
 226 }
 227
 228 static int index_at_values(
 229         Backend *be,
 230         AttributeType *type,
 231         struct berval *lang,
 232         struct berval **vals,
 233         ID id,
 234         int op,
 235         char ** dbnamep,
 236         slap_mask_t *maskp )
 237 {
 238         slap_mask_t mask;
 239         slap_mask_t tmpmask = 0;
 240         int lindex = 0;
 241
 242         if( type->sat_sup ) {
 243                 /* recurse */
 244                 (void) index_at_values( be,
 245                         type->sat_sup, lang,
 246                         vals, id, op,
 247                         dbnamep, &tmpmask );
 248         }
 249
 250         attr_mask( be->be_private, type->sat_cname, &mask );
 251
 252         if( mask ) {
 253                 *dbnamep = type->sat_cname;
 254         } else if ( tmpmask & SLAP_INDEX_AUTO_SUBTYPES ) {
 255                 mask = tmpmask;
 256         }
 257
 258         if( mask ) {
 259                 indexer( be, *dbnamep,
 260                         type->sat_cname,
 261                         vals, id, op,
 262                         mask );
 263         }
 264
 265         if( lang->bv_len ) {
 266                 char *dbname = NULL;
 267                 size_t tlen = strlen( type->sat_cname );
 268                 size_t llen = lang->bv_len;
 269                 char *lname = ch_malloc( tlen + llen + sizeof(";") );
 270
 271                 sprintf( lname, "%s;%s", type->sat_cname, lang->bv_val );
 272
 273                 attr_mask( be->be_private, lname, &tmpmask );
 274
 275                 if( tmpmask ) {
 276                         dbname = lname;
 277                 } else if ( mask & SLAP_INDEX_AUTO_LANG ) {
 278                         dbname = *dbnamep;
 279                         tmpmask = mask;
 280                 }
 281
 282                 if( dbname != NULL ) {
 283                         indexer( be, dbname, lname,
 284                                 vals, id, op,
 285                                 tmpmask );
 286                 }
 287
 288                 ch_free( lname );
 289         }
 290
 291         return LDAP_SUCCESS;
 292 }
 293
 294 int index_values(
 295         Backend *be,
 296         AttributeDescription *desc,
 297         struct berval **vals,
 298         ID id,
 299         int op )
 300 {
 301         char *dbname = NULL;
 302         slap_mask_t mask;
 303
 304         if( slap_ad_is_binary( desc ) ) {
 305                 /* binary attributes have no index capabilities */
 306                 return LDAP_SUCCESS;
 307         }
 308
 309         (void) index_at_values( be,
 310                 desc->ad_type, &desc->ad_lang,
 311                 vals, id, op,
 312                 &dbname, &mask );
 313
 314         return LDAP_SUCCESS;
 315 }
 316
 317
 318 int
 319 index_entry(
 320     Backend     *be,
 321         int op,
 322     Entry       *e,
 323         Attribute *ap
 324 )
 325 {
 326 #ifdef NEW_LOGGING
 327         LDAP_LOG(( "index", LDAP_LEVEL_ENTRY,
 328                    "index_entry: %s (%s)%ld\n",
 329                    op == SLAP_INDEX_ADD_OP ? "add" : "del",
 330                    e->e_dn, e->e_id ));
 331 #else
 332         Debug( LDAP_DEBUG_TRACE, "=> index_entry_%s( %ld, \"%s\" )\n",
 333                 op == SLAP_INDEX_ADD_OP ? "add" : "del",
 334                 e->e_id, e->e_dn );
 335 #endif
 336
 337
 338         /* add each attribute to the indexes */
 339         for ( ; ap != NULL; ap = ap->a_next ) {
 340                 index_values( be, ap->a_desc, ap->a_vals, e->e_id, op );
 341         }
 342
 343 #ifdef NEW_LOGGING
 344         LDAP_LOG(( "index", LDAP_LEVEL_ENTRY,
 345                    "index_entry: success\n" ));
 346 #else
 347         Debug( LDAP_DEBUG_TRACE, "<= index_entry_%s( %ld, \"%s\" ) success\n",
 348             op == SLAP_INDEX_ADD_OP ? "add" : "del",
 349                 e->e_id, e->e_dn );
 350 #endif
 351
 352
 353         return LDAP_SUCCESS;
 354 }
 355