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

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