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

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