← Back to branch summary

~ubuntu-branches/ubuntu/natty/postgresql-8.4/natty-security

« back to all changes in this revision

Viewing changes to src/backend/utils/adt/tsrank.c

Tags: upstream-8.4.0
Import upstream version 8.4.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/backend/utils/adt/tsrank.c
7
7
 *
8
8
 *
9
9
 * IDENTIFICATION
10
 
 *        $PostgreSQL: pgsql/src/backend/utils/adt/tsrank.c,v 1.14 2009/01/01 17:23:50 momjian Exp $
 
10
 *        $PostgreSQL: pgsql/src/backend/utils/adt/tsrank.c,v 1.15 2009/06/11 14:49:04 momjian Exp $
11
11
 *
12
12
 *-------------------------------------------------------------------------
13
13
 */
72
72
}
73
73
 
74
74
 
75
 
#define WordECompareQueryItem(e,q,p,i,m) \
 
75
#define WordECompareQueryItem(e,q,p,i,m) \
76
76
        tsCompareString((q) + (i)->distance, (i)->length,       \
77
 
                                        (e) + (p)->pos, (p)->len, (m))
 
77
                                        (e) + (p)->pos, (p)->len, (m))
78
78
 
79
79
 
80
80
/*
90
90
        WordEntry  *StopMiddle = StopHigh;
91
91
        int                     difference;
92
92
 
93
 
        *nitem=0;
 
93
        *nitem = 0;
94
94
 
95
95
        /* Loop invariant: StopLow <= item < StopHigh */
96
96
        while (StopLow < StopHigh)
100
100
                if (difference == 0)
101
101
                {
102
102
                        StopHigh = StopMiddle;
103
 
                        *nitem=1;
 
103
                        *nitem = 1;
104
104
                        break;
105
105
                }
106
106
                else if (difference > 0)
109
109
                        StopHigh = StopMiddle;
110
110
        }
111
111
 
112
 
        if ( item->prefix == true )
 
112
        if (item->prefix == true)
113
113
        {
114
 
                if ( StopLow >= StopHigh )
 
114
                if (StopLow >= StopHigh)
115
115
                        StopMiddle = StopHigh;
116
116
 
117
 
                *nitem=0;
 
117
                *nitem = 0;
118
118
 
119
 
                while( StopMiddle < (WordEntry *) STRPTR(t) && 
120
 
                                WordECompareQueryItem(STRPTR(t), GETOPERAND(q), StopMiddle, item, true) == 0 )
 
119
                while (StopMiddle < (WordEntry *) STRPTR(t) &&
 
120
                           WordECompareQueryItem(STRPTR(t), GETOPERAND(q), StopMiddle, item, true) == 0)
121
121
                {
122
122
                        (*nitem)++;
123
123
                        StopMiddle++;
124
124
                }
125
125
        }
126
126
 
127
 
        return ( *nitem > 0 ) ? StopHigh : NULL;
 
127
        return (*nitem > 0) ? StopHigh : NULL;
128
128
}
129
129
 
130
130
 
237
237
                if (!entry)
238
238
                        continue;
239
239
 
240
 
                while( entry - firstentry < nitem )
 
240
                while (entry - firstentry < nitem)
241
241
                {
242
242
                        if (entry->haspos)
243
243
                                pos[i] = _POSVECPTR(t, entry);
260
260
                                                if (dist || (dist == 0 && (pos[i] == &POSNULL || pos[k] == &POSNULL)))
261
261
                                                {
262
262
                                                        float           curw;
263
 
        
 
263
 
264
264
                                                        if (!dist)
265
265
                                                                dist = MAXENTRYPOS;
266
266
                                                        curw = sqrt(wpos(post[l]) * wpos(ct[p]) * word_distance(dist));
304
304
                if (!entry)
305
305
                        continue;
306
306
 
307
 
                while( entry - firstentry < nitem )
 
307
                while (entry - firstentry < nitem)
308
308
                {
309
309
                        if (entry->haspos)
310
310
                        {
650
650
                if (!entry)
651
651
                        continue;
652
652
 
653
 
                while( entry - firstentry < nitem )
 
653
                while (entry - firstentry < nitem)
654
654
                {
655
655
                        if (entry->haspos)
656
656
                        {
674
674
                                if (j == 0)
675
675
                                {
676
676
                                        int                     k;
677
 
        
 
677
 
678
678
                                        doc[cur].nitem = 0;
679
679
                                        doc[cur].item = (QueryItem **) palloc(sizeof(QueryItem *) * qr->query->size);
680
 
        
 
680
 
681
681
                                        for (k = 0; k < qr->query->size; k++)
682
682
                                        {
683
683
                                                QueryOperand *kptr = &item[k].operand;
684
684
                                                QueryOperand *iptr = &item[i].operand;
685
 
        
 
685
 
686
686
                                                if (k == i ||
687
687
                                                        (item[k].type == QI_VAL &&
688
688
                                                         compareQueryOperand(&kptr, &iptr, operand) == 0))
689
689
                                                {
690
690
                                                        /*
691
 
                                                         * if k == i, we've already checked above that it's
692
 
                                                         * type == Q_VAL
 
691
                                                         * if k == i, we've already checked above that
 
692
                                                         * it's type == Q_VAL
693
693
                                                         */
694
694
                                                        doc[cur].item[doc[cur].nitem] = item + k;
695
695
                                                        doc[cur].nitem++;