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( IS_SLAP_INDEX( mask, SLAP_INDEX_APPROX ) ) {
 119                         goto done;
 120                 }
 121                 /* fall thru */
 122
 123         case LDAP_FILTER_EQUALITY:
 124                 if( IS_SLAP_INDEX( mask, SLAP_INDEX_EQUALITY ) ) {
 125                         goto done;
 126                 }
 127                 break;
 128
 129         case LDAP_FILTER_SUBSTRINGS:
 130                 if( IS_SLAP_INDEX( mask, SLAP_INDEX_SUBSTR ) ) {
 131                         goto done;
 132                 }
 133                 break;
 134
 135         default:
 136                 return LDAP_OTHER;
 137         }
 138
 139         return LDAP_INAPPROPRIATE_MATCHING;
 140
 141 done:
 142         *dbnamep = dbname;
 143         *maskp = mask;
 144         return LDAP_SUCCESS;
 145 }
 146
 147 static int indexer(
 148         Operation *op,
 149         char *dbname,
 150         struct berval *atname,
 151         BerVarray vals,
 152         ID id,
 153         int opid,
 154         slap_mask_t mask )
 155 {
 156         int rc, i;
 157         const char *text;
 158         DBCache *db;
 159         AttributeDescription *ad = NULL;
 160         struct berval *keys;
 161
 162         assert( mask );
 163
 164         rc = slap_bv2ad( atname, &ad, &text );
 165
 166         if( rc != LDAP_SUCCESS ) return rc;
 167
 168         db = ldbm_cache_open( op->o_bd, dbname, LDBM_SUFFIX, LDBM_WRCREAT );
 169
 170         if ( db == NULL ) {
 171 #ifdef NEW_LOGGING
 172                 LDAP_LOG( INDEX, ERR,
 173                            "index_read: Could not open db %s%s\n", dbname, LDBM_SUFFIX, 0 );
 174 #else
 175                 Debug( LDAP_DEBUG_ANY,
 176                     "<= index_read NULL (could not open %s%s)\n",
 177                         dbname, LDBM_SUFFIX, 0 );
 178 #endif
 179
 180                 return LDAP_OTHER;
 181         }
 182
 183         if( IS_SLAP_INDEX( mask, SLAP_INDEX_PRESENT ) ) {
 184                 key_change( op->o_bd, db, atname, id, opid );
 185         }
 186
 187         if( IS_SLAP_INDEX( mask, SLAP_INDEX_EQUALITY ) ) {
 188                 rc = ad->ad_type->sat_equality->smr_indexer(
 189                         LDAP_FILTER_EQUALITY,
 190                         mask,
 191                         ad->ad_type->sat_syntax,
 192                         ad->ad_type->sat_equality,
 193                         atname, vals, &keys, op->o_tmpmemctx );
 194
 195                 if( rc == LDAP_SUCCESS && keys != NULL ) {
 196                         for( i=0; keys[i].bv_val != NULL; i++ ) {
 197                                 key_change( op->o_bd, db, &keys[i], id, opid );
 198                         }
 199                         ber_bvarray_free_x( keys, op->o_tmpmemctx );
 200                 }
 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, op->o_tmpmemctx );
 210
 211                 if( rc == LDAP_SUCCESS && keys != NULL ) {
 212                         for( i=0; keys[i].bv_val != NULL; i++ ) {
 213                                 key_change( op->o_bd, db, &keys[i], id, opid );
 214                         }
 215                         ber_bvarray_free_x( keys, op->o_tmpmemctx );
 216                 }
 217         }
 218
 219         if( IS_SLAP_INDEX( mask, SLAP_INDEX_SUBSTR ) ) {
 220                 rc = ad->ad_type->sat_substr->smr_indexer(
 221                         LDAP_FILTER_SUBSTRINGS,
 222                         mask,
 223                         ad->ad_type->sat_syntax,
 224                         ad->ad_type->sat_substr,
 225                         atname, vals, &keys, op->o_tmpmemctx );
 226
 227                 if( rc == LDAP_SUCCESS && keys != NULL ) {
 228                         for( i=0; keys[i].bv_val != NULL; i++ ) {
 229                                 key_change( op->o_bd, db, &keys[i], id, opid );
 230                         }
 231                         ber_bvarray_free_x( keys, op->o_tmpmemctx );
 232                 }
 233         }
 234
 235         ldbm_cache_close( op->o_bd, db );
 236
 237         return LDAP_SUCCESS;
 238 }
 239
 240 static int index_at_values(
 241         Operation *op,
 242         AttributeType *type,
 243         struct berval *tags,
 244         BerVarray vals,
 245         ID id,
 246         int opid )
 247 {
 248         slap_mask_t mask = 0;
 249
 250         if( type->sat_sup ) {
 251                 /* recurse */
 252                 (void) index_at_values( op,
 253                         type->sat_sup, tags,
 254                         vals, id, opid );
 255         }
 256
 257         /* If this type has no AD, we've never used it before */
 258         if( type->sat_ad ) {
 259                 attr_mask( op->o_bd->be_private, type->sat_ad, &mask );
 260         }
 261
 262         if( mask ) {
 263                 indexer( op, type->sat_cname.bv_val,
 264                         &type->sat_cname,
 265                         vals, id, opid,
 266                         mask );
 267         }
 268
 269         if( tags->bv_len ) {
 270                 AttributeDescription *desc;
 271
 272                 mask = 0;
 273
 274                 desc = ad_find_tags(type, tags);
 275                 if( desc ) {
 276                         attr_mask( op->o_bd->be_private, desc, &mask );
 277                 }
 278
 279                 if( mask ) {
 280                         indexer( op, desc->ad_cname.bv_val, &desc->ad_cname,
 281                                 vals, id, opid,
 282                                 mask );
 283                 }
 284         }
 285
 286         return LDAP_SUCCESS;
 287 }
 288
 289 int index_values(
 290         Operation *op,
 291         AttributeDescription *desc,
 292         BerVarray vals,
 293         ID id,
 294         int opid )
 295 {
 296         (void) index_at_values( op,
 297                 desc->ad_type, &desc->ad_tags,
 298                 vals, id, opid );
 299
 300         return LDAP_SUCCESS;
 301 }
 302
 303 int
 304 index_entry(
 305         Operation *op,
 306         int opid,
 307         Entry *e )
 308 {
 309         Attribute *ap = e->e_attrs;
 310 #ifdef NEW_LOGGING
 311         LDAP_LOG( INDEX, ENTRY,
 312                 "index_entry: %s (%s)%ld\n", opid == SLAP_INDEX_ADD_OP ? "add" : "del",
 313                 e->e_dn, e->e_id );
 314 #else
 315         Debug( LDAP_DEBUG_TRACE, "=> index_entry_%s( %ld, \"%s\" )\n",
 316                 opid == SLAP_INDEX_ADD_OP ? "add" : "del",
 317                 e->e_id, e->e_dn );
 318 #endif
 319
 320         /* add each attribute to the indexes */
 321         for ( ; ap != NULL; ap = ap->a_next ) {
 322                 index_values( op, ap->a_desc,
 323                         ap->a_nvals,
 324                         e->e_id, opid );
 325         }
 326
 327 #ifdef NEW_LOGGING
 328         LDAP_LOG( INDEX, ENTRY, "index_entry: success\n", 0, 0, 0 );
 329 #else
 330         Debug( LDAP_DEBUG_TRACE, "<= index_entry_%s( %ld, \"%s\" ) success\n",
 331             opid == SLAP_INDEX_ADD_OP ? "add" : "del",
 332                 e->e_id, e->e_dn );
 333 #endif
 334
 335         return LDAP_SUCCESS;
 336 }
 337