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