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