substring indexing optimization

diff --git a/servers/slapd/schema_init.c b/servers/slapd/schema_init.c
index 42f03d8f260a5d828e2939a3c4d0b52208d8aba6..b4649932bfe5dcab7488a47607b67f74dc065263 100644 (file)
--- a/servers/slapd/schema_init.c
+++ b/servers/slapd/schema_init.c
@@ -169,16 +169,13 @@ octetStringOrderingMatch(
        return LDAP_SUCCESS;
 }
 
-void
-hashDigestify(
+static void
+hashPreset(
        HASH_CONTEXT *HASHcontext,
-       unsigned char *HASHdigest,
        struct berval *prefix,
        char pre,
        Syntax *syntax,
-       MatchingRule *mr,
-       unsigned char *value,
-       int value_len)
+       MatchingRule *mr)
 {
        HASH_Init(HASHcontext);
        if(prefix && prefix->bv_len > 0) {
@@ -188,11 +185,21 @@ hashDigestify(
        if(pre) HASH_Update(HASHcontext, (unsigned char*)&pre, sizeof(pre));
        HASH_Update(HASHcontext, (unsigned char*)syntax->ssyn_oid, syntax->ssyn_oidlen);
        HASH_Update(HASHcontext, (unsigned char*)mr->smr_oid, mr->smr_oidlen);
-       HASH_Update(HASHcontext, value, value_len);
-       HASH_Final(HASHdigest, HASHcontext);
        return;
 }
 
+static void
+hashIter(
+       HASH_CONTEXT *HASHcontext,
+       unsigned char *HASHdigest,
+       unsigned char *value,
+       int len)
+{
+       HASH_CONTEXT ctx = *HASHcontext;
+       HASH_Update( &ctx, value, len );
+       HASH_Final( HASHdigest, &ctx );
+}
+
 /* Index generation function */
 int octetStringIndexer(
        slap_mask_t use,
@@ -225,9 +232,10 @@ int octetStringIndexer(
        slen = syntax->ssyn_oidlen;
        mlen = mr->smr_oidlen;
 
+       hashPreset( &HASHcontext, prefix, 0, syntax, mr);
        for( i=0; !BER_BVISNULL( &values[i] ); i++ ) {
-               hashDigestify( &HASHcontext, HASHdigest, prefix, 0,
-                       syntax, mr, (unsigned char *)values[i].bv_val, values[i].bv_len );
+               hashIter( &HASHcontext, HASHdigest,
+                       (unsigned char *)values[i].bv_val, values[i].bv_len );
                ber_dupbv_x( &keys[i], &digest, ctx );
        }
 
@@ -263,8 +271,9 @@ int octetStringFilter(
 
        keys = slap_sl_malloc( sizeof( struct berval ) * 2, ctx );
 
-       hashDigestify( &HASHcontext, HASHdigest, prefix, 0,
-               syntax, mr, (unsigned char *)value->bv_val, value->bv_len );
+       hashPreset( &HASHcontext, prefix, 0, syntax, mr );
+       hashIter( &HASHcontext, HASHdigest,
+               (unsigned char *)value->bv_val, value->bv_len );
 
        ber_dupbv_x( keys, &digest, ctx );
        BER_BVZERO( &keys[1] );
@@ -414,7 +423,7 @@ octetStringSubstringsIndexer(
        size_t slen, mlen;
        BerVarray keys;
 
-       HASH_CONTEXT HASHcontext;
+       HASH_CONTEXT HCany, HCini, HCfin;
        unsigned char HASHdigest[HASH_BYTES];
        struct berval digest;
        digest.bv_val = (char *)HASHdigest;
@@ -460,6 +469,13 @@ octetStringSubstringsIndexer(
        slen = syntax->ssyn_oidlen;
        mlen = mr->smr_oidlen;
 
+       if ( flags & SLAP_INDEX_SUBSTR_ANY )
+               hashPreset( &HCany, prefix, SLAP_INDEX_SUBSTR_PREFIX, syntax, mr );
+       if( flags & SLAP_INDEX_SUBSTR_INITIAL )
+               hashPreset( &HCini, prefix, SLAP_INDEX_SUBSTR_INITIAL_PREFIX, syntax, mr );
+       if( flags & SLAP_INDEX_SUBSTR_FINAL )
+               hashPreset( &HCfin, prefix, SLAP_INDEX_SUBSTR_FINAL_PREFIX, syntax, mr );
+
        nkeys = 0;
        for ( i = 0; !BER_BVISNULL( &values[i] ); i++ ) {
                ber_len_t j,max;
@@ -467,12 +483,12 @@ octetStringSubstringsIndexer(
                if( ( flags & SLAP_INDEX_SUBSTR_ANY ) &&
                        ( values[i].bv_len >= index_substr_any_len ) )
                {
-                       char pre = SLAP_INDEX_SUBSTR_PREFIX;
                        max = values[i].bv_len - (index_substr_any_len - 1);
 
                        for( j=0; j<max; j++ ) {
-                               hashDigestify( &HASHcontext, HASHdigest, prefix, pre,
-                                       syntax, mr, (unsigned char *)&values[i].bv_val[j], index_substr_any_len);
+                               hashIter( &HCany, HASHdigest,
+                                       (unsigned char *)&values[i].bv_val[j],
+                                       index_substr_any_len );
                                ber_dupbv_x( &keys[nkeys++], &digest, ctx );
                        }
                }
@@ -484,19 +500,16 @@ octetStringSubstringsIndexer(
                        ? index_substr_if_maxlen : values[i].bv_len;
 
                for( j=index_substr_if_minlen; j<=max; j++ ) {
-                       char pre;
 
                        if( flags & SLAP_INDEX_SUBSTR_INITIAL ) {
-                               pre = SLAP_INDEX_SUBSTR_INITIAL_PREFIX;
-                               hashDigestify( &HASHcontext, HASHdigest, prefix, pre,
-                                       syntax, mr, (unsigned char *)values[i].bv_val, j );
+                               hashIter( &HCini, HASHdigest,
+                                       (unsigned char *)values[i].bv_val, j );
                                ber_dupbv_x( &keys[nkeys++], &digest, ctx );
                        }
 
                        if( flags & SLAP_INDEX_SUBSTR_FINAL ) {
-                               pre = SLAP_INDEX_SUBSTR_FINAL_PREFIX;
-                               hashDigestify( &HASHcontext, HASHdigest, prefix, pre,
-                                       syntax, mr, (unsigned char *)&values[i].bv_val[values[i].bv_len-j], j );
+                               hashIter( &HCfin, HASHdigest,
+                                       (unsigned char *)&values[i].bv_val[values[i].bv_len-j], j );
                                ber_dupbv_x( &keys[nkeys++], &digest, ctx );
                        }
 
@@ -596,8 +609,9 @@ octetStringSubstringsFilter (
                klen = index_substr_if_maxlen < value->bv_len
                        ? index_substr_if_maxlen : value->bv_len;
 
-               hashDigestify( &HASHcontext, HASHdigest, prefix, pre,
-                       syntax, mr, (unsigned char *)value->bv_val, klen );
+               hashPreset( &HASHcontext, prefix, pre, syntax, mr );
+               hashIter( &HASHcontext, HASHdigest,
+                       (unsigned char *)value->bv_val, klen );
                ber_dupbv_x( &keys[nkeys++], &digest, ctx );
 
                /* If initial is too long and we have subany indexed, use it
@@ -607,10 +621,11 @@ octetStringSubstringsFilter (
                {
                        ber_len_t j;
                        pre = SLAP_INDEX_SUBSTR_PREFIX;
+                       hashPreset( &HASHcontext, prefix, pre, syntax, mr);
                        for ( j=index_substr_if_maxlen-1; j <= value->bv_len - index_substr_any_len; j+=index_substr_any_step )
                        {
-                               hashDigestify( &HASHcontext, HASHdigest, prefix, pre,
-                                       syntax, mr, (unsigned char *)&value->bv_val[j], index_substr_any_len );
+                               hashIter( &HASHcontext, HASHdigest,
+                                       (unsigned char *)&value->bv_val[j], index_substr_any_len );
                                ber_dupbv_x( &keys[nkeys++], &digest, ctx );
                        }
                }
@@ -628,12 +643,13 @@ octetStringSubstringsFilter (
 
                        value = &sa->sa_any[i];
 
+                       hashPreset( &HASHcontext, prefix, pre, syntax, mr);
                        for(j=0;
                                j <= value->bv_len - index_substr_any_len;
                                j += index_substr_any_step )
                        {
-                               hashDigestify( &HASHcontext, HASHdigest, prefix, pre,
-                                       syntax, mr, (unsigned char *)&value->bv_val[j], klen ); 
+                               hashIter( &HASHcontext, HASHdigest,
+                                       (unsigned char *)&value->bv_val[j], klen ); 
                                ber_dupbv_x( &keys[nkeys++], &digest, ctx );
                        }
                }
@@ -649,8 +665,9 @@ octetStringSubstringsFilter (
                klen = index_substr_if_maxlen < value->bv_len
                        ? index_substr_if_maxlen : value->bv_len;
 
-               hashDigestify( &HASHcontext, HASHdigest, prefix, pre,
-                       syntax, mr, (unsigned char *)&value->bv_val[value->bv_len-klen], klen );
+               hashPreset( &HASHcontext, prefix, pre, syntax, mr );
+               hashIter( &HASHcontext, HASHdigest,
+                       (unsigned char *)&value->bv_val[value->bv_len-klen], klen );
                ber_dupbv_x( &keys[nkeys++], &digest, ctx );
 
                /* If final is too long and we have subany indexed, use it
@@ -660,10 +677,11 @@ octetStringSubstringsFilter (
                {
                        ber_len_t j;
                        pre = SLAP_INDEX_SUBSTR_PREFIX;
+                       hashPreset( &HASHcontext, prefix, pre, syntax, mr);
                        for ( j=0; j <= value->bv_len - index_substr_if_maxlen; j+=index_substr_any_step )
                        {
-                               hashDigestify( &HASHcontext, HASHdigest, prefix, pre,
-                                       syntax, mr, (unsigned char *)&value->bv_val[j], index_substr_any_len );
+                               hashIter( &HASHcontext, HASHdigest,
+                                       (unsigned char *)&value->bv_val[j], index_substr_any_len );
                                ber_dupbv_x( &keys[nkeys++], &digest, ctx );
                        }
                }