git.sur5r.net Git - openldap/blob - servers/slapd/back-bdb/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-bdb.h"
  17 #include "lutil_hash.h"
  18
  19 static char presence_keyval[LUTIL_HASH_BYTES] = {0,0,0,1};
  20 static struct berval presence_key = {LUTIL_HASH_BYTES, presence_keyval};
  21
  22 static slap_mask_t index_mask(
  23         Backend *be,
  24         AttributeDescription *desc,
  25         char **dbname,
  26         struct berval *atname )
  27 {
  28         AttributeType *at;
  29         slap_mask_t mask = 0;
  30
  31         bdb_attr_mask( be->be_private, desc, &mask );
  32
  33         if( mask ) {
  34                 *atname = desc->ad_cname;
  35                 *dbname = desc->ad_cname.bv_val;
  36                 return mask;
  37         }
  38
  39         /* If there is a language tag, did we ever index the base
  40          * type? If so, check for mask, otherwise it's not there.
  41          */
  42         if( slap_ad_is_lang( desc ) && desc != desc->ad_type->sat_ad ) {
  43                 /* has language tag */
  44                 bdb_attr_mask( be->be_private, desc->ad_type->sat_ad, &mask );
  45
  46                 if (! ( mask & SLAP_INDEX_NOLANG ) ) {
  47                         *atname = desc->ad_type->sat_cname;
  48                         *dbname = desc->ad_type->sat_cname.bv_val;
  49                         return mask;
  50                 }
  51         }
  52
  53         /* see if supertype defined mask for its subtypes */
  54         for( at = desc->ad_type; at != NULL ; at = at->sat_sup ) {
  55                 /* If no AD, we've never indexed this type */
  56                 if ( !at->sat_ad ) continue;
  57
  58                 bdb_attr_mask( be->be_private, at->sat_ad, &mask );
  59
  60                 if( mask & SLAP_INDEX_AUTO_SUBTYPES ) {
  61                         *atname = desc->ad_type->sat_cname;
  62                         *dbname = at->sat_cname.bv_val;
  63                         return mask;
  64                 }
  65
  66                 if( !( mask & SLAP_INDEX_NOSUBTYPES ) ) {
  67                         *atname = at->sat_cname;
  68                         *dbname = at->sat_cname.bv_val;
  69                         return mask;
  70                 }
  71
  72                 if( mask ) break;
  73         }
  74
  75         return 0;
  76 }
  77
  78 int bdb_index_param(
  79         Backend *be,
  80         AttributeDescription *desc,
  81         int ftype,
  82         DB **dbp,
  83         slap_mask_t *maskp,
  84         struct berval *prefixp )
  85 {
  86         int rc;
  87         slap_mask_t mask;
  88         DB *db;
  89         char *dbname;
  90
  91         mask = index_mask( be, desc, &dbname, prefixp );
  92
  93         if( mask == 0 ) {
  94                 return LDAP_INAPPROPRIATE_MATCHING;
  95         }
  96
  97         rc = bdb_db_cache( be, dbname, &db );
  98
  99         if( rc != LDAP_SUCCESS ) {
 100                 return rc;
 101         }
 102
 103         switch( ftype ) {
 104         case LDAP_FILTER_PRESENT:
 105                 if( IS_SLAP_INDEX( mask, SLAP_INDEX_PRESENT ) ) {
 106                         goto done;
 107                 }
 108                 break;
 109
 110         case LDAP_FILTER_APPROX:
 111                 if( IS_SLAP_INDEX( mask, SLAP_INDEX_APPROX ) ) {
 112                         goto done;
 113                 }
 114                 /* fall thru */
 115
 116         case LDAP_FILTER_EQUALITY:
 117                 if( IS_SLAP_INDEX( mask, SLAP_INDEX_EQUALITY ) ) {
 118                         goto done;
 119                 }
 120                 break;
 121
 122         case LDAP_FILTER_SUBSTRINGS:
 123                 if( IS_SLAP_INDEX( mask, SLAP_INDEX_SUBSTR ) ) {
 124                         goto done;
 125                 }
 126                 break;
 127
 128         default:
 129                 return LDAP_OTHER;
 130         }
 131
 132         return LDAP_INAPPROPRIATE_MATCHING;
 133
 134 done:
 135         *dbp = db;
 136         *maskp = mask;
 137         return LDAP_SUCCESS;
 138 }
 139
 140 static int indexer(
 141         Backend *be,
 142         DB_TXN *txn,
 143         char *dbname,
 144         struct berval *atname,
 145         struct berval **vals,
 146         ID id,
 147         int op,
 148         slap_mask_t mask )
 149 {
 150         int rc, i;
 151         const char *text;
 152         DB *db;
 153         AttributeDescription *ad = NULL;
 154         struct berval *keys;
 155
 156         assert( mask );
 157
 158         rc = bdb_db_cache( be, dbname, &db );
 159
 160         if ( rc != LDAP_SUCCESS ) {
 161 #ifdef NEW_LOGGING
 162                 LDAP_LOG(( "index", LDAP_LEVEL_ERR,
 163                         "bdb_index_read: Could not open DB %s\n", dbname));
 164 #else
 165                 Debug( LDAP_DEBUG_ANY,
 166                         "<= bdb_index_read NULL (could not open %s)\n",
 167                         dbname, 0, 0 );
 168 #endif
 169                 return LDAP_OTHER;
 170         }
 171
 172         rc = slap_bv2ad( atname, &ad, &text );
 173         if( rc != LDAP_SUCCESS ) return rc;
 174
 175         if( IS_SLAP_INDEX( mask, SLAP_INDEX_PRESENT ) ) {
 176                 rc = bdb_key_change( be, db, txn, &presence_key, id, op );
 177                 if( rc ) {
 178                         goto done;
 179                 }
 180         }
 181
 182         if( IS_SLAP_INDEX( mask, SLAP_INDEX_EQUALITY ) ) {
 183                 rc = ad->ad_type->sat_equality->smr_indexer(
 184                         LDAP_FILTER_EQUALITY,
 185                         mask,
 186                         ad->ad_type->sat_syntax,
 187                         ad->ad_type->sat_equality,
 188                         atname, vals, &keys );
 189
 190                 if( rc == LDAP_SUCCESS && keys != NULL ) {
 191                         for( i=0; keys[i].bv_val != NULL; i++ ) {
 192                                 rc = bdb_key_change( be, db, txn, &keys[i], id, op );
 193                                 if( rc ) {
 194                                         bvarray_free( keys );
 195                                         goto done;
 196                                 }
 197                         }
 198                         bvarray_free( keys );
 199                 }
 200                 rc = LDAP_SUCCESS;
 201         }
 202
 203         if( IS_SLAP_INDEX( mask, SLAP_INDEX_APPROX ) ) {
 204                 rc = ad->ad_type->sat_approx->smr_indexer(
 205                         LDAP_FILTER_APPROX,
 206                         mask,
 207                         ad->ad_type->sat_syntax,
 208                         ad->ad_type->sat_approx,
 209                         atname, vals, &keys );
 210
 211                 if( rc == LDAP_SUCCESS && keys != NULL ) {
 212                         for( i=0; keys[i].bv_val != NULL; i++ ) {
 213                                 rc = bdb_key_change( be, db, txn, &keys[i], id, op );
 214                                 if( rc ) {
 215                                         bvarray_free( keys );
 216                                         goto done;
 217                                 }
 218                         }
 219                         bvarray_free( keys );
 220                 }
 221
 222                 rc = LDAP_SUCCESS;
 223         }
 224
 225         if( IS_SLAP_INDEX( mask, SLAP_INDEX_SUBSTR ) ) {
 226                 rc = ad->ad_type->sat_substr->smr_indexer(
 227                         LDAP_FILTER_SUBSTRINGS,
 228                         mask,
 229                         ad->ad_type->sat_syntax,
 230                         ad->ad_type->sat_substr,
 231                         atname, vals, &keys );
 232
 233                 if( rc == LDAP_SUCCESS && keys != NULL ) {
 234                         for( i=0; keys[i].bv_val != NULL; i++ ) {
 235                                 bdb_key_change( be, db, txn, &keys[i], id, op );
 236                                 if( rc ) {
 237                                         bvarray_free( keys );
 238                                         goto done;
 239                                 }
 240                         }
 241                         bvarray_free( keys );
 242                 }
 243
 244                 rc = LDAP_SUCCESS;
 245         }
 246
 247 done:
 248         return rc;
 249 }
 250
 251 static int index_at_values(
 252         Backend *be,
 253         DB_TXN *txn,
 254         AttributeType *type,
 255         struct berval *lang,
 256         struct berval **vals,
 257         ID id,
 258         int op,
 259         char ** dbnamep,
 260         slap_mask_t *maskp )
 261 {
 262         int rc;
 263         slap_mask_t mask = 0;
 264         slap_mask_t tmpmask = 0;
 265         int lindex = 0;
 266
 267         if( type->sat_sup ) {
 268                 /* recurse */
 269                 rc = index_at_values( be, txn,
 270                         type->sat_sup, lang,
 271                         vals, id, op,
 272                         dbnamep, &tmpmask );
 273
 274                 if( rc ) return rc;
 275         }
 276
 277         /* If this type has no AD, we've never used it before */
 278         if( type->sat_ad ) {
 279                 bdb_attr_mask( be->be_private, type->sat_ad, &mask );
 280         }
 281
 282         if( mask ) {
 283                 *dbnamep = type->sat_cname.bv_val;
 284         } else if ( !( tmpmask & SLAP_INDEX_AUTO_SUBTYPES ) ) {
 285                 mask = tmpmask;
 286         }
 287
 288         if( mask ) {
 289                 rc = indexer( be, txn, *dbnamep,
 290                         &type->sat_cname,
 291                         vals, id, op,
 292                         mask );
 293
 294                 if( rc ) return rc;
 295         }
 296
 297         if( lang->bv_len ) {
 298                 char *dbname = NULL;
 299                 struct berval lname;
 300                 AttributeDescription *desc;
 301
 302                 tmpmask = 0;
 303                 lname.bv_val = NULL;
 304
 305                 desc = ad_find_lang( type, lang );
 306                 if( desc ) {
 307                         bdb_attr_mask( be->be_private, desc, &tmpmask );
 308                 }
 309
 310                 if( tmpmask ) {
 311                         dbname = desc->ad_cname.bv_val;
 312                         lname = desc->ad_cname;
 313                         mask = tmpmask;
 314                 }
 315
 316                 if( dbname != NULL ) {
 317                         rc = indexer( be, txn, dbname, &lname,
 318                                 vals, id, op,
 319                                 mask );
 320
 321                         if( !tmpmask ) {
 322                                 ch_free( lname.bv_val );
 323                         }
 324                         if( rc ) {
 325                                 return rc;
 326                         }
 327                 }
 328         }
 329
 330         return LDAP_SUCCESS;
 331 }
 332
 333 int bdb_index_values(
 334         Backend *be,
 335         DB_TXN *txn,
 336         AttributeDescription *desc,
 337         struct berval **vals,
 338         ID id,
 339         int op )
 340 {
 341         int rc;
 342         char *dbname = NULL;
 343         slap_mask_t mask;
 344
 345         rc = index_at_values( be, txn,
 346                 desc->ad_type, &desc->ad_lang,
 347                 vals, id, op,
 348                 &dbname, &mask );
 349
 350         return rc;
 351 }
 352
 353 int
 354 bdb_index_entry(
 355         Backend *be,
 356         DB_TXN *txn,
 357         int op,
 358         Entry   *e,
 359         Attribute *ap )
 360 {
 361         int rc;
 362
 363 #ifdef NEW_LOGGING
 364         LDAP_LOG(( "index", LDAP_LEVEL_ENTRY,
 365                 "index_entry: %s (%s) %ld\n",
 366                 op == SLAP_INDEX_ADD_OP ? "add" : "del",
 367                 e->e_dn, (long) e->e_id ));
 368 #else
 369         Debug( LDAP_DEBUG_TRACE, "=> index_entry_%s( %ld, \"%s\" )\n",
 370                 op == SLAP_INDEX_ADD_OP ? "add" : "del",
 371                 (long) e->e_id, e->e_dn );
 372 #endif
 373
 374         /* add each attribute to the indexes */
 375         for ( ; ap != NULL; ap = ap->a_next ) {
 376                 rc = bdb_index_values( be, txn,
 377                         ap->a_desc, ap->a_vals, e->e_id, op );
 378
 379                 if( rc != LDAP_SUCCESS ) {
 380 #ifdef NEW_LOGGING
 381                         LDAP_LOG(( "index", LDAP_LEVEL_ENTRY,
 382                                 "index_entry: success\n" ));
 383 #else
 384                         Debug( LDAP_DEBUG_TRACE,
 385                                 "<= index_entry_%s( %ld, \"%s\" ) success\n",
 386                                 op == SLAP_INDEX_ADD_OP ? "add" : "del",
 387                                 (long) e->e_id, e->e_dn );
 388 #endif
 389                         return rc;
 390                 }
 391         }
 392
 393 #ifdef NEW_LOGGING
 394         LDAP_LOG(( "index", LDAP_LEVEL_ENTRY,
 395                 "index_entry: success\n" ));
 396 #else
 397         Debug( LDAP_DEBUG_TRACE, "<= index_entry_%s( %ld, \"%s\" ) success\n",
 398                 op == SLAP_INDEX_ADD_OP ? "add" : "del",
 399                 (long) e->e_id, e->e_dn );
 400 #endif
 401
 402         return LDAP_SUCCESS;
 403 }