Age Owner Branch data TLA Line data Source code
1 : : /*-------------------------------------------------------------------------
2 : : *
3 : : * trgm_regexp.c
4 : : * Regular expression matching using trigrams.
5 : : *
6 : : * The general idea of trigram index support for a regular expression (regex)
7 : : * search is to transform the regex into a logical expression on trigrams.
8 : : * For example:
9 : : *
10 : : * (ab|cd)efg => ((abe & bef) | (cde & def)) & efg
11 : : *
12 : : * If a string matches the regex, then it must match the logical expression on
13 : : * trigrams. The opposite is not necessarily true, however: a string that
14 : : * matches the logical expression might not match the original regex. Such
15 : : * false positives are removed via recheck, by running the regular regex match
16 : : * operator on the retrieved heap tuple.
17 : : *
18 : : * Since the trigram expression involves both AND and OR operators, we can't
19 : : * expect the core index machinery to evaluate it completely. Instead, the
20 : : * result of regex analysis is a list of trigrams to be sought in the index,
21 : : * plus a simplified graph that is used by trigramsMatchGraph() to determine
22 : : * whether a particular indexed value matches the expression.
23 : : *
24 : : * Converting a regex to a trigram expression is based on analysis of an
25 : : * automaton corresponding to the regex. The algorithm consists of four
26 : : * stages:
27 : : *
28 : : * 1) Compile the regexp to NFA form. This is handled by the PostgreSQL
29 : : * regexp library, which provides accessors for its opaque regex_t struct
30 : : * to expose the NFA state graph and the "colors" (sets of equivalent
31 : : * characters) used as state transition labels.
32 : : *
33 : : * 2) Transform the original NFA into an expanded graph, where arcs
34 : : * are labeled with trigrams that must be present in order to move from
35 : : * one state to another via the arcs. The trigrams used in this stage
36 : : * consist of colors, not characters, as in the original NFA.
37 : : *
38 : : * 3) Expand the color trigrams into regular trigrams consisting of
39 : : * characters. If too many distinct trigrams are produced, trigrams are
40 : : * eliminated and the graph is simplified until it's simple enough.
41 : : *
42 : : * 4) Finally, the resulting graph is packed into a TrgmPackedGraph struct,
43 : : * and returned to the caller.
44 : : *
45 : : * 1) Compile the regexp to NFA form
46 : : * ---------------------------------
47 : : * The automaton returned by the regexp compiler is a graph where vertices
48 : : * are "states" and arcs are labeled with colors. Each color represents
49 : : * a set of characters, so that all characters assigned to the same color
50 : : * are interchangeable, so far as matching the regexp is concerned. There
51 : : * are two special states: "initial" and "final". A state can have multiple
52 : : * outgoing arcs labeled with the same color, which makes the automaton
53 : : * non-deterministic, because it can be in many states simultaneously.
54 : : *
55 : : * Note that this NFA is already lossy compared to the original regexp,
56 : : * since it ignores some regex features such as lookahead constraints and
57 : : * backref matching. This is OK for our purposes since it's still the case
58 : : * that only strings matching the NFA can possibly satisfy the regexp.
59 : : *
60 : : * 2) Transform the original NFA into an expanded graph
61 : : * ----------------------------------------------------
62 : : * In the 2nd stage, the automaton is transformed into a graph based on the
63 : : * original NFA. Each state in the expanded graph represents a state from
64 : : * the original NFA, plus a prefix identifying the last two characters
65 : : * (colors, to be precise) seen before entering the state. There can be
66 : : * multiple states in the expanded graph for each state in the original NFA,
67 : : * depending on what characters can precede it. A prefix position can be
68 : : * "unknown" if it's uncertain what the preceding character was, or "blank"
69 : : * if the character was a non-word character (we don't need to distinguish
70 : : * which non-word character it was, so just think of all of them as blanks).
71 : : *
72 : : * For convenience in description, call an expanded-state identifier
73 : : * (two prefix colors plus a state number from the original NFA) an
74 : : * "enter key".
75 : : *
76 : : * Each arc of the expanded graph is labeled with a trigram that must be
77 : : * present in the string to match. We can construct this from an out-arc of
78 : : * the underlying NFA state by combining the expanded state's prefix with the
79 : : * color label of the underlying out-arc, if neither prefix position is
80 : : * "unknown". But note that some of the colors in the trigram might be
81 : : * "blank". This is OK since we want to generate word-boundary trigrams as
82 : : * the regular trigram machinery would, if we know that some word characters
83 : : * must be adjacent to a word boundary in all strings matching the NFA.
84 : : *
85 : : * The expanded graph can also have fewer states than the original NFA,
86 : : * because we don't bother to make a separate state entry unless the state
87 : : * is reachable by a valid arc. When an enter key is reachable from a state
88 : : * of the expanded graph, but we do not know a complete trigram associated
89 : : * with that transition, we cannot make a valid arc; instead we insert the
90 : : * enter key into the enterKeys list of the source state. This effectively
91 : : * means that the two expanded states are not reliably distinguishable based
92 : : * on examining trigrams.
93 : : *
94 : : * So the expanded graph resembles the original NFA, but the arcs are
95 : : * labeled with trigrams instead of individual characters, and there may be
96 : : * more or fewer states. It is a lossy representation of the original NFA:
97 : : * any string that matches the original regexp must match the expanded graph,
98 : : * but the reverse is not true.
99 : : *
100 : : * We build the expanded graph through a breadth-first traversal of states
101 : : * reachable from the initial state. At each reachable state, we identify the
102 : : * states reachable from it without traversing a predictable trigram, and add
103 : : * those states' enter keys to the current state. Then we generate all
104 : : * out-arcs leading out of this collection of states that have predictable
105 : : * trigrams, adding their target states to the queue of states to examine.
106 : : *
107 : : * When building the graph, if the number of states or arcs exceed pre-defined
108 : : * limits, we give up and simply mark any states not yet processed as final
109 : : * states. Roughly speaking, that means that we make use of some portion from
110 : : * the beginning of the regexp. Also, any colors that have too many member
111 : : * characters are treated as "unknown", so that we can't derive trigrams
112 : : * from them.
113 : : *
114 : : * 3) Expand the color trigrams into regular trigrams
115 : : * --------------------------------------------------
116 : : * The trigrams in the expanded graph are "color trigrams", consisting
117 : : * of three consecutive colors that must be present in the string. But for
118 : : * search, we need regular trigrams consisting of characters. In the 3rd
119 : : * stage, the color trigrams are expanded into regular trigrams. Since each
120 : : * color can represent many characters, the total number of regular trigrams
121 : : * after expansion could be very large. Because searching the index for
122 : : * thousands of trigrams would be slow, and would likely produce so many
123 : : * false positives that we would have to traverse a large fraction of the
124 : : * index, the graph is simplified further in a lossy fashion by removing
125 : : * color trigrams. When a color trigram is removed, the states connected by
126 : : * any arcs labeled with that trigram are merged.
127 : : *
128 : : * Trigrams do not all have equivalent value for searching: some of them are
129 : : * more frequent and some of them are less frequent. Ideally, we would like
130 : : * to know the distribution of trigrams, but we don't. But because of padding
131 : : * we know for sure that the empty character is more frequent than others,
132 : : * so we can penalize trigrams according to presence of whitespace. The
133 : : * penalty assigned to each color trigram is the number of simple trigrams
134 : : * it would produce, times the penalties[] multiplier associated with its
135 : : * whitespace content. (The penalties[] constants were calculated by analysis
136 : : * of some real-life text.) We eliminate color trigrams starting with the
137 : : * highest-penalty one, until we get to a total penalty of no more than
138 : : * WISH_TRGM_PENALTY. However, we cannot remove a color trigram if that would
139 : : * lead to merging the initial and final states, so we may not be able to
140 : : * reach WISH_TRGM_PENALTY. It's still okay so long as we have no more than
141 : : * MAX_TRGM_COUNT simple trigrams in total, otherwise we fail.
142 : : *
143 : : * 4) Pack the graph into a compact representation
144 : : * -----------------------------------------------
145 : : * The 2nd and 3rd stages might have eliminated or merged many of the states
146 : : * and trigrams created earlier, so in this final stage, the graph is
147 : : * compacted and packed into a simpler struct that contains only the
148 : : * information needed to evaluate it.
149 : : *
150 : : * ALGORITHM EXAMPLE:
151 : : *
152 : : * Consider the example regex "ab[cd]". This regex is transformed into the
153 : : * following NFA (for simplicity we show colors as their single members):
154 : : *
155 : : * 4#
156 : : * c/
157 : : * a b /
158 : : * 1* --- 2 ---- 3
159 : : * \
160 : : * d\
161 : : * 5#
162 : : *
163 : : * We use * to mark initial state and # to mark final state. It's not depicted,
164 : : * but states 1, 4, 5 have self-referencing arcs for all possible characters,
165 : : * because this pattern can match to any part of a string.
166 : : *
167 : : * As the result of stage 2 we will have the following graph:
168 : : *
169 : : * abc abd
170 : : * 2# <---- 1* ----> 3#
171 : : *
172 : : * The process for generating this graph is:
173 : : * 1) Create state 1 with enter key (UNKNOWN, UNKNOWN, 1).
174 : : * 2) Add key (UNKNOWN, "a", 2) to state 1.
175 : : * 3) Add key ("a", "b", 3) to state 1.
176 : : * 4) Create new state 2 with enter key ("b", "c", 4). Add an arc
177 : : * from state 1 to state 2 with label trigram "abc".
178 : : * 5) Mark state 2 final because state 4 of source NFA is marked as final.
179 : : * 6) Create new state 3 with enter key ("b", "d", 5). Add an arc
180 : : * from state 1 to state 3 with label trigram "abd".
181 : : * 7) Mark state 3 final because state 5 of source NFA is marked as final.
182 : : *
183 : : *
184 : : * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
185 : : * Portions Copyright (c) 1994, Regents of the University of California
186 : : *
187 : : * IDENTIFICATION
188 : : * contrib/pg_trgm/trgm_regexp.c
189 : : *
190 : : *-------------------------------------------------------------------------
191 : : */
192 : : #include "postgres.h"
193 : :
194 : : #include "catalog/pg_collation_d.h"
195 : : #include "regex/regexport.h"
196 : : #include "trgm.h"
197 : : #include "tsearch/ts_locale.h"
198 : : #include "utils/formatting.h"
199 : : #include "utils/hsearch.h"
200 : : #include "utils/memutils.h"
201 : : #include "varatt.h"
202 : :
203 : : /*
204 : : * Uncomment (or use -DTRGM_REGEXP_DEBUG) to print debug info,
205 : : * for exploring and debugging the algorithm implementation.
206 : : * This produces three graph files in /tmp, in Graphviz .gv format.
207 : : * Some progress information is also printed to postmaster stderr.
208 : : */
209 : : /* #define TRGM_REGEXP_DEBUG */
210 : :
211 : : /*
212 : : * These parameters are used to limit the amount of work done.
213 : : * Otherwise regex processing could be too slow and memory-consuming.
214 : : *
215 : : * MAX_EXPANDED_STATES - How many states we allow in expanded graph
216 : : * MAX_EXPANDED_ARCS - How many arcs we allow in expanded graph
217 : : * MAX_TRGM_COUNT - How many simple trigrams we allow to be extracted
218 : : * WISH_TRGM_PENALTY - Maximum desired sum of color trigram penalties
219 : : * COLOR_COUNT_LIMIT - Maximum number of characters per color
220 : : */
221 : : #define MAX_EXPANDED_STATES 128
222 : : #define MAX_EXPANDED_ARCS 1024
223 : : #define MAX_TRGM_COUNT 256
224 : : #define WISH_TRGM_PENALTY 16
225 : : #define COLOR_COUNT_LIMIT 256
226 : :
227 : : /*
228 : : * Penalty multipliers for trigram counts depending on whitespace contents.
229 : : * Numbers based on analysis of real-life texts.
230 : : */
231 : : static const float4 penalties[8] = {
232 : : 1.0f, /* "aaa" */
233 : : 3.5f, /* "aa " */
234 : : 0.0f, /* "a a" (impossible) */
235 : : 0.0f, /* "a " (impossible) */
236 : : 4.2f, /* " aa" */
237 : : 2.1f, /* " a " */
238 : : 25.0f, /* " a" */
239 : : 0.0f /* " " (impossible) */
240 : : };
241 : :
242 : : /* Struct representing a single pg_wchar, converted back to multibyte form */
243 : : typedef struct
244 : : {
245 : : char bytes[MAX_MULTIBYTE_CHAR_LEN];
246 : : } trgm_mb_char;
247 : :
248 : : /*
249 : : * Attributes of NFA colors:
250 : : *
251 : : * expandable - we know the character expansion of this color
252 : : * containsNonWord - color contains non-word characters
253 : : * (which will not be extracted into trigrams)
254 : : * wordCharsCount - count of word characters in color
255 : : * wordChars - array of this color's word characters
256 : : * (which can be extracted into trigrams)
257 : : *
258 : : * When expandable is false, the other attributes don't matter; we just
259 : : * assume this color represents unknown character(s).
260 : : */
261 : : typedef struct
262 : : {
263 : : bool expandable;
264 : : bool containsNonWord;
265 : : int wordCharsCount;
266 : : trgm_mb_char *wordChars;
267 : : } TrgmColorInfo;
268 : :
269 : : /*
270 : : * A "prefix" is information about the colors of the last two characters read
271 : : * before reaching a specific NFA state. These colors can have special values
272 : : * COLOR_UNKNOWN and COLOR_BLANK. COLOR_UNKNOWN means that we have no
273 : : * information, for example because we read some character of an unexpandable
274 : : * color. COLOR_BLANK means that we read a non-word character.
275 : : *
276 : : * We call a prefix ambiguous if at least one of its colors is unknown. It's
277 : : * fully ambiguous if both are unknown, partially ambiguous if only the first
278 : : * is unknown. (The case of first color known, second unknown is not valid.)
279 : : *
280 : : * Wholly- or partly-blank prefixes are mostly handled the same as regular
281 : : * color prefixes. This allows us to generate appropriate partly-blank
282 : : * trigrams when the NFA requires word character(s) to appear adjacent to
283 : : * non-word character(s).
284 : : */
285 : : typedef int TrgmColor;
286 : :
287 : : /* We assume that colors returned by the regexp engine cannot be these: */
288 : : #define COLOR_UNKNOWN (-3)
289 : : #define COLOR_BLANK (-4)
290 : :
291 : : typedef struct
292 : : {
293 : : TrgmColor colors[2];
294 : : } TrgmPrefix;
295 : :
296 : : /*
297 : : * Color-trigram data type. Note that some elements of the trigram can be
298 : : * COLOR_BLANK, but we don't allow COLOR_UNKNOWN.
299 : : */
300 : : typedef struct
301 : : {
302 : : TrgmColor colors[3];
303 : : } ColorTrgm;
304 : :
305 : : /*
306 : : * Key identifying a state of our expanded graph: color prefix, and number
307 : : * of the corresponding state in the underlying regex NFA. The color prefix
308 : : * shows how we reached the regex state (to the extent that we know it).
309 : : */
310 : : typedef struct
311 : : {
312 : : TrgmPrefix prefix;
313 : : int nstate;
314 : : } TrgmStateKey;
315 : :
316 : : /*
317 : : * One state of the expanded graph.
318 : : *
319 : : * stateKey - ID of this state
320 : : * arcs - outgoing arcs of this state (List of TrgmArc)
321 : : * enterKeys - enter keys reachable from this state without reading any
322 : : * predictable trigram (List of TrgmStateKey)
323 : : * flags - flag bits
324 : : * snumber - number of this state (initially assigned as -1, -2, etc,
325 : : * for debugging purposes only; then at the packaging stage,
326 : : * surviving states are renumbered with positive numbers)
327 : : * parent - parent state, if this state has been merged into another
328 : : * tentFlags - flags this state would acquire via planned merges
329 : : * tentParent - planned parent state, if considering a merge
330 : : */
331 : : #define TSTATE_INIT 0x01 /* flag indicating this state is initial */
332 : : #define TSTATE_FIN 0x02 /* flag indicating this state is final */
333 : :
334 : : typedef struct TrgmState
335 : : {
336 : : TrgmStateKey stateKey; /* hashtable key: must be first field */
337 : : List *arcs;
338 : : List *enterKeys;
339 : : int flags;
340 : : int snumber;
341 : : struct TrgmState *parent;
342 : : int tentFlags;
343 : : struct TrgmState *tentParent;
344 : : } TrgmState;
345 : :
346 : : /*
347 : : * One arc in the expanded graph.
348 : : */
349 : : typedef struct
350 : : {
351 : : ColorTrgm ctrgm; /* trigram needed to traverse arc */
352 : : TrgmState *target; /* next state */
353 : : } TrgmArc;
354 : :
355 : : /*
356 : : * Information about arc of specific color trigram (used in stage 3)
357 : : *
358 : : * Contains pointers to the source and target states.
359 : : */
360 : : typedef struct
361 : : {
362 : : TrgmState *source;
363 : : TrgmState *target;
364 : : } TrgmArcInfo;
365 : :
366 : : /*
367 : : * Information about color trigram (used in stage 3)
368 : : *
369 : : * ctrgm - trigram itself
370 : : * cnumber - number of this trigram (used in the packaging stage)
371 : : * count - number of simple trigrams created from this color trigram
372 : : * expanded - indicates this color trigram is expanded into simple trigrams
373 : : * arcs - list of all arcs labeled with this color trigram.
374 : : */
375 : : typedef struct
376 : : {
377 : : ColorTrgm ctrgm;
378 : : int cnumber;
379 : : int count;
380 : : float4 penalty;
381 : : bool expanded;
382 : : List *arcs;
383 : : } ColorTrgmInfo;
384 : :
385 : : /*
386 : : * Data structure representing all the data we need during regex processing.
387 : : *
388 : : * regex - compiled regex
389 : : * colorInfo - extracted information about regex's colors
390 : : * ncolors - number of colors in colorInfo[]
391 : : * states - hashtable of TrgmStates (states of expanded graph)
392 : : * initState - pointer to initial state of expanded graph
393 : : * queue - queue of to-be-processed TrgmStates
394 : : * keysQueue - queue of to-be-processed TrgmStateKeys
395 : : * arcsCount - total number of arcs of expanded graph (for resource
396 : : * limiting)
397 : : * overflowed - we have exceeded resource limit for transformation
398 : : * colorTrgms - array of all color trigrams present in graph
399 : : * colorTrgmsCount - count of those color trigrams
400 : : * totalTrgmCount - total count of extracted simple trigrams
401 : : */
402 : : typedef struct
403 : : {
404 : : /* Source regexp, and color information extracted from it (stage 1) */
405 : : regex_t *regex;
406 : : TrgmColorInfo *colorInfo;
407 : : int ncolors;
408 : :
409 : : /* Expanded graph (stage 2) */
410 : : HTAB *states;
411 : : TrgmState *initState;
412 : : int nstates;
413 : :
414 : : /* Workspace for stage 2 */
415 : : List *queue;
416 : : List *keysQueue;
417 : : int arcsCount;
418 : : bool overflowed;
419 : :
420 : : /* Information about distinct color trigrams in the graph (stage 3) */
421 : : ColorTrgmInfo *colorTrgms;
422 : : int colorTrgmsCount;
423 : : int totalTrgmCount;
424 : : } TrgmNFA;
425 : :
426 : : /*
427 : : * Final, compact representation of expanded graph.
428 : : */
429 : : typedef struct
430 : : {
431 : : int targetState; /* index of target state (zero-based) */
432 : : int colorTrgm; /* index of color trigram for transition */
433 : : } TrgmPackedArc;
434 : :
435 : : typedef struct
436 : : {
437 : : int arcsCount; /* number of out-arcs for this state */
438 : : TrgmPackedArc *arcs; /* array of arcsCount packed arcs */
439 : : } TrgmPackedState;
440 : :
441 : : /* "typedef struct TrgmPackedGraph TrgmPackedGraph" appears in trgm.h */
442 : : struct TrgmPackedGraph
443 : : {
444 : : /*
445 : : * colorTrigramsCount and colorTrigramGroups contain information about how
446 : : * trigrams are grouped into color trigrams. "colorTrigramsCount" is the
447 : : * count of color trigrams and "colorTrigramGroups" contains number of
448 : : * simple trigrams for each color trigram. The array of simple trigrams
449 : : * (stored separately from this struct) is ordered so that the simple
450 : : * trigrams for each color trigram are consecutive, and they're in order
451 : : * by color trigram number.
452 : : */
453 : : int colorTrigramsCount;
454 : : int *colorTrigramGroups; /* array of size colorTrigramsCount */
455 : :
456 : : /*
457 : : * The states of the simplified NFA. State number 0 is always initial
458 : : * state and state number 1 is always final state.
459 : : */
460 : : int statesCount;
461 : : TrgmPackedState *states; /* array of size statesCount */
462 : :
463 : : /* Temporary work space for trigramsMatchGraph() */
464 : : bool *colorTrigramsActive; /* array of size colorTrigramsCount */
465 : : bool *statesActive; /* array of size statesCount */
466 : : int *statesQueue; /* array of size statesCount */
467 : : };
468 : :
469 : : /*
470 : : * Temporary structure for representing an arc during packaging.
471 : : */
472 : : typedef struct
473 : : {
474 : : int sourceState;
475 : : int targetState;
476 : : int colorTrgm;
477 : : } TrgmPackArcInfo;
478 : :
479 : :
480 : : /* prototypes for private functions */
481 : : static TRGM *createTrgmNFAInternal(regex_t *regex, TrgmPackedGraph **graph,
482 : : MemoryContext rcontext);
483 : : static void RE_compile(regex_t *regex, text *text_re,
484 : : int cflags, Oid collation);
485 : : static void getColorInfo(regex_t *regex, TrgmNFA *trgmNFA);
486 : : static bool convertPgWchar(pg_wchar c, trgm_mb_char *result);
487 : : static void transformGraph(TrgmNFA *trgmNFA);
488 : : static void processState(TrgmNFA *trgmNFA, TrgmState *state);
489 : : static void addKey(TrgmNFA *trgmNFA, TrgmState *state, TrgmStateKey *key);
490 : : static void addKeyToQueue(TrgmNFA *trgmNFA, TrgmStateKey *key);
491 : : static void addArcs(TrgmNFA *trgmNFA, TrgmState *state);
492 : : static void addArc(TrgmNFA *trgmNFA, TrgmState *state, TrgmStateKey *key,
493 : : TrgmColor co, TrgmStateKey *destKey);
494 : : static bool validArcLabel(TrgmStateKey *key, TrgmColor co);
495 : : static TrgmState *getState(TrgmNFA *trgmNFA, TrgmStateKey *key);
496 : : static bool prefixContains(TrgmPrefix *prefix1, TrgmPrefix *prefix2);
497 : : static bool selectColorTrigrams(TrgmNFA *trgmNFA);
498 : : static TRGM *expandColorTrigrams(TrgmNFA *trgmNFA, MemoryContext rcontext);
499 : : static void fillTrgm(trgm *ptrgm, trgm_mb_char s[3]);
500 : : static void mergeStates(TrgmState *state1, TrgmState *state2);
501 : : static int colorTrgmInfoCmp(const void *p1, const void *p2);
502 : : static int colorTrgmInfoPenaltyCmp(const void *p1, const void *p2);
503 : : static TrgmPackedGraph *packGraph(TrgmNFA *trgmNFA, MemoryContext rcontext);
504 : : static int packArcInfoCmp(const void *a1, const void *a2);
505 : :
506 : : #ifdef TRGM_REGEXP_DEBUG
507 : : static void printSourceNFA(regex_t *regex, TrgmColorInfo *colors, int ncolors);
508 : : static void printTrgmNFA(TrgmNFA *trgmNFA);
509 : : static void printTrgmColor(StringInfo buf, TrgmColor co);
510 : : static void printTrgmPackedGraph(TrgmPackedGraph *packedGraph, TRGM *trigrams);
511 : : #endif
512 : :
513 : :
514 : : /*
515 : : * Main entry point to process a regular expression.
516 : : *
517 : : * Returns an array of trigrams required by the regular expression, or NULL if
518 : : * the regular expression was too complex to analyze. In addition, a packed
519 : : * graph representation of the regex is returned into *graph. The results
520 : : * must be allocated in rcontext (which might or might not be the current
521 : : * context).
522 : : */
523 : : TRGM *
4532 tgl@sss.pgh.pa.us 524 :CBC 65 : createTrgmNFA(text *text_re, Oid collation,
525 : : TrgmPackedGraph **graph, MemoryContext rcontext)
526 : : {
527 : : TRGM *trg;
528 : : regex_t regex;
529 : : MemoryContext tmpcontext;
530 : : MemoryContext oldcontext;
531 : :
532 : : /*
533 : : * This processing generates a great deal of cruft, which we'd like to
534 : : * clean up before returning (since this function may be called in a
535 : : * query-lifespan memory context). Make a temp context we can work in so
536 : : * that cleanup is easy.
537 : : */
4533 538 : 65 : tmpcontext = AllocSetContextCreate(CurrentMemoryContext,
539 : : "createTrgmNFA temporary context",
540 : : ALLOCSET_DEFAULT_SIZES);
541 : 65 : oldcontext = MemoryContextSwitchTo(tmpcontext);
542 : :
543 : : /*
544 : : * Stage 1: Compile the regexp into a NFA, using the regexp library.
545 : : */
546 : : #ifdef IGNORECASE
1489 547 : 65 : RE_compile(®ex, text_re,
548 : : REG_ADVANCED | REG_NOSUB | REG_ICASE, collation);
549 : : #else
550 : : RE_compile(®ex, text_re,
551 : : REG_ADVANCED | REG_NOSUB, collation);
552 : : #endif
553 : :
882 tmunro@postgresql.or 554 : 65 : trg = createTrgmNFAInternal(®ex, graph, rcontext);
555 : :
556 : : /* Clean up all the cruft we created (including regex) */
4533 tgl@sss.pgh.pa.us 557 : 65 : MemoryContextSwitchTo(oldcontext);
558 : 65 : MemoryContextDelete(tmpcontext);
559 : :
560 : 65 : return trg;
561 : : }
562 : :
563 : : /*
564 : : * Body of createTrgmNFA, exclusive of regex compilation/freeing.
565 : : */
566 : : static TRGM *
567 : 65 : createTrgmNFAInternal(regex_t *regex, TrgmPackedGraph **graph,
568 : : MemoryContext rcontext)
569 : : {
570 : : TRGM *trg;
571 : : TrgmNFA trgmNFA;
572 : :
573 : 65 : trgmNFA.regex = regex;
574 : :
575 : : /* Collect color information from the regex */
576 : 65 : getColorInfo(regex, &trgmNFA);
577 : :
578 : : #ifdef TRGM_REGEXP_DEBUG
579 : : printSourceNFA(regex, trgmNFA.colorInfo, trgmNFA.ncolors);
580 : : #endif
581 : :
582 : : /*
583 : : * Stage 2: Create an expanded graph from the source NFA.
584 : : */
585 : 65 : transformGraph(&trgmNFA);
586 : :
587 : : #ifdef TRGM_REGEXP_DEBUG
588 : : printTrgmNFA(&trgmNFA);
589 : : #endif
590 : :
591 : : /*
592 : : * Fail if we were unable to make a nontrivial graph, ie it is possible to
593 : : * get from the initial state to the final state without reading any
594 : : * predictable trigram.
595 : : */
3118 596 [ + + ]: 65 : if (trgmNFA.initState->flags & TSTATE_FIN)
4533 597 : 9 : return NULL;
598 : :
599 : : /*
600 : : * Stage 3: Select color trigrams to expand. Fail if too many trigrams.
601 : : */
602 [ + + ]: 56 : if (!selectColorTrigrams(&trgmNFA))
603 : 3 : return NULL;
604 : :
605 : : /*
606 : : * Stage 4: Expand color trigrams and pack graph into final
607 : : * representation.
608 : : */
609 : 53 : trg = expandColorTrigrams(&trgmNFA, rcontext);
610 : :
611 : 53 : *graph = packGraph(&trgmNFA, rcontext);
612 : :
613 : : #ifdef TRGM_REGEXP_DEBUG
614 : : printTrgmPackedGraph(*graph, trg);
615 : : #endif
616 : :
617 : 53 : return trg;
618 : : }
619 : :
620 : : /*
621 : : * Main entry point for evaluating a graph during index scanning.
622 : : *
623 : : * The check[] array is indexed by trigram number (in the array of simple
624 : : * trigrams returned by createTrgmNFA), and holds true for those trigrams
625 : : * that are present in the index entry being checked.
626 : : */
627 : : bool
628 : 3557 : trigramsMatchGraph(TrgmPackedGraph *graph, bool *check)
629 : : {
630 : : int i,
631 : : j,
632 : : k,
633 : : queueIn,
634 : : queueOut;
635 : :
636 : : /*
637 : : * Reset temporary working areas.
638 : : */
639 : 3557 : memset(graph->colorTrigramsActive, 0,
640 : 3557 : sizeof(bool) * graph->colorTrigramsCount);
641 : 3557 : memset(graph->statesActive, 0, sizeof(bool) * graph->statesCount);
642 : :
643 : : /*
644 : : * Check which color trigrams were matched. A match for any simple
645 : : * trigram associated with a color trigram counts as a match of the color
646 : : * trigram.
647 : : */
648 : 3557 : j = 0;
649 [ + + ]: 11039 : for (i = 0; i < graph->colorTrigramsCount; i++)
650 : : {
651 : 7482 : int cnt = graph->colorTrigramGroups[i];
652 : :
653 [ + + ]: 166728 : for (k = j; k < j + cnt; k++)
654 : : {
655 [ + + ]: 163098 : if (check[k])
656 : : {
657 : : /*
658 : : * Found one matched trigram in the group. Can skip the rest
659 : : * of them and go to the next group.
660 : : */
661 : 3852 : graph->colorTrigramsActive[i] = true;
662 : 3852 : break;
663 : : }
664 : : }
665 : 7482 : j = j + cnt;
666 : : }
667 : :
668 : : /*
669 : : * Initialize the statesQueue to hold just the initial state. Note:
670 : : * statesQueue has room for statesCount entries, which is certainly enough
671 : : * since no state will be put in the queue more than once. The
672 : : * statesActive array marks which states have been queued.
673 : : */
674 : 3557 : graph->statesActive[0] = true;
675 : 3557 : graph->statesQueue[0] = 0;
676 : 3557 : queueIn = 0;
677 : 3557 : queueOut = 1;
678 : :
679 : : /* Process queued states as long as there are any. */
680 [ + + ]: 7657 : while (queueIn < queueOut)
681 : : {
682 : 7521 : int stateno = graph->statesQueue[queueIn++];
683 : 7521 : TrgmPackedState *state = &graph->states[stateno];
684 : 7521 : int cnt = state->arcsCount;
685 : :
686 : : /* Loop over state's out-arcs */
687 [ + + ]: 15156 : for (i = 0; i < cnt; i++)
688 : : {
689 : 11056 : TrgmPackedArc *arc = &state->arcs[i];
690 : :
691 : : /*
692 : : * If corresponding color trigram is present then activate the
693 : : * corresponding state. We're done if that's the final state,
694 : : * otherwise queue the state if it's not been queued already.
695 : : */
696 [ + + ]: 11056 : if (graph->colorTrigramsActive[arc->colorTrgm])
697 : : {
698 : 7724 : int nextstate = arc->targetState;
699 : :
700 [ + + ]: 7724 : if (nextstate == 1)
701 : 3421 : return true; /* success: final state is reachable */
702 : :
703 [ + + ]: 4303 : if (!graph->statesActive[nextstate])
704 : : {
705 : 4246 : graph->statesActive[nextstate] = true;
706 : 4246 : graph->statesQueue[queueOut++] = nextstate;
707 : : }
708 : : }
709 : : }
710 : : }
711 : :
712 : : /* Queue is empty, so match fails. */
713 : 136 : return false;
714 : : }
715 : :
716 : : /*
717 : : * Compile regex string into struct at *regex.
718 : : * NB: pg_regfree must be applied to regex if this completes successfully.
719 : : */
720 : : static void
721 : 65 : RE_compile(regex_t *regex, text *text_re, int cflags, Oid collation)
722 : : {
723 [ - + - - : 65 : int text_re_len = VARSIZE_ANY_EXHDR(text_re);
- - - - -
+ ]
724 [ - + ]: 65 : char *text_re_val = VARDATA_ANY(text_re);
725 : : pg_wchar *pattern;
726 : : int pattern_len;
727 : : int regcomp_result;
728 : : char errMsg[100];
729 : :
730 : : /* Convert pattern string to wide characters */
731 : 65 : pattern = (pg_wchar *) palloc((text_re_len + 1) * sizeof(pg_wchar));
732 : 65 : pattern_len = pg_mb2wchar_with_len(text_re_val,
733 : : pattern,
734 : : text_re_len);
735 : :
736 : : /* Compile regex */
737 : 65 : regcomp_result = pg_regcomp(regex,
738 : : pattern,
739 : : pattern_len,
740 : : cflags,
741 : : collation);
742 : :
743 : 65 : pfree(pattern);
744 : :
745 [ - + ]: 65 : if (regcomp_result != REG_OKAY)
746 : : {
747 : : /* re didn't compile (no need for pg_regfree, if so) */
4533 tgl@sss.pgh.pa.us 748 :UBC 0 : pg_regerror(regcomp_result, regex, errMsg, sizeof(errMsg));
749 [ # # ]: 0 : ereport(ERROR,
750 : : (errcode(ERRCODE_INVALID_REGULAR_EXPRESSION),
751 : : errmsg("invalid regular expression: %s", errMsg)));
752 : : }
4533 tgl@sss.pgh.pa.us 753 :CBC 65 : }
754 : :
755 : :
756 : : /*---------------------
757 : : * Subroutines for pre-processing the color map (stage 1).
758 : : *---------------------
759 : : */
760 : :
761 : : /*
762 : : * Fill TrgmColorInfo structure for each color using regex export functions.
763 : : */
764 : : static void
765 : 65 : getColorInfo(regex_t *regex, TrgmNFA *trgmNFA)
766 : : {
767 : 65 : int colorsCount = pg_reg_getnumcolors(regex);
768 : : int i;
769 : :
770 : 65 : trgmNFA->ncolors = colorsCount;
771 : 65 : trgmNFA->colorInfo = (TrgmColorInfo *)
772 : 65 : palloc0(colorsCount * sizeof(TrgmColorInfo));
773 : :
774 : : /*
775 : : * Loop over colors, filling TrgmColorInfo about each. Note we include
776 : : * WHITE (0) even though we know it'll be reported as non-expandable.
777 : : */
778 [ + + ]: 596 : for (i = 0; i < colorsCount; i++)
779 : : {
780 : 531 : TrgmColorInfo *colorInfo = &trgmNFA->colorInfo[i];
781 : 531 : int charsCount = pg_reg_getnumcharacters(regex, i);
782 : : pg_wchar *chars;
783 : : int j;
784 : :
785 [ + + - + ]: 531 : if (charsCount < 0 || charsCount > COLOR_COUNT_LIMIT)
786 : : {
787 : : /* Non expandable, or too large to work with */
788 : 325 : colorInfo->expandable = false;
789 : 325 : continue;
790 : : }
791 : :
792 : 206 : colorInfo->expandable = true;
793 : 206 : colorInfo->containsNonWord = false;
794 : 206 : colorInfo->wordChars = (trgm_mb_char *)
795 : 206 : palloc(sizeof(trgm_mb_char) * charsCount);
796 : 206 : colorInfo->wordCharsCount = 0;
797 : :
798 : : /* Extract all the chars in this color */
799 : 206 : chars = (pg_wchar *) palloc(sizeof(pg_wchar) * charsCount);
800 : 206 : pg_reg_getcharacters(regex, i, chars, charsCount);
801 : :
802 : : /*
803 : : * Convert characters back to multibyte form, and save only those that
804 : : * are word characters. Set "containsNonWord" if any non-word
805 : : * character. (Note: it'd probably be nicer to keep the chars in
806 : : * pg_wchar format for now, but ISWORDCHR wants to see multibyte.)
807 : : */
808 [ + + ]: 991 : for (j = 0; j < charsCount; j++)
809 : : {
810 : : trgm_mb_char c;
811 : :
812 [ + + ]: 785 : if (!convertPgWchar(chars[j], &c))
813 : 365 : continue; /* ok to ignore it altogether */
814 [ + + ]: 420 : if (ISWORDCHR(c.bytes))
815 : 395 : colorInfo->wordChars[colorInfo->wordCharsCount++] = c;
816 : : else
817 : 25 : colorInfo->containsNonWord = true;
818 : : }
819 : :
820 : 206 : pfree(chars);
821 : : }
822 : 65 : }
823 : :
824 : : /*
825 : : * Convert pg_wchar to multibyte format.
826 : : * Returns false if the character should be ignored completely.
827 : : */
828 : : static bool
829 : 785 : convertPgWchar(pg_wchar c, trgm_mb_char *result)
830 : : {
831 : : /* "s" has enough space for a multibyte character and a trailing NUL */
832 : : char s[MAX_MULTIBYTE_CHAR_LEN + 1];
833 : :
834 : : /*
835 : : * We can ignore the NUL character, since it can never appear in a PG text
836 : : * string. This avoids the need for various special cases when
837 : : * reconstructing trigrams.
838 : : */
839 [ - + ]: 785 : if (c == 0)
4533 tgl@sss.pgh.pa.us 840 :UBC 0 : return false;
841 : :
842 : : /* Do the conversion, making sure the result is NUL-terminated */
4533 tgl@sss.pgh.pa.us 843 :CBC 785 : memset(s, 0, sizeof(s));
844 : 785 : pg_wchar2mb_with_len(&c, s, 1);
845 : :
846 : : /*
847 : : * In IGNORECASE mode, we can ignore uppercase characters. We assume that
848 : : * the regex engine generated both uppercase and lowercase equivalents
849 : : * within each color, since we used the REG_ICASE option; so there's no
850 : : * need to process the uppercase version.
851 : : *
852 : : * XXX this code is dependent on the assumption that str_tolower() works
853 : : * the same as the regex engine's internal case folding machinery. Might
854 : : * be wiser to expose pg_wc_tolower and test whether c ==
855 : : * pg_wc_tolower(c). On the other hand, the trigrams in the index were
856 : : * created using str_tolower(), so we're probably screwed if there's any
857 : : * incompatibility anyway.
858 : : */
859 : : #ifdef IGNORECASE
860 : : {
263 peter@eisentraut.org 861 : 785 : char *lowerCased = str_tolower(s, strlen(s), DEFAULT_COLLATION_OID);
862 : :
4533 tgl@sss.pgh.pa.us 863 [ + + ]: 785 : if (strcmp(lowerCased, s) != 0)
864 : : {
865 : 365 : pfree(lowerCased);
866 : 365 : return false;
867 : : }
868 : 420 : pfree(lowerCased);
869 : : }
870 : : #endif
871 : :
872 : : /* Fill result with exactly MAX_MULTIBYTE_CHAR_LEN bytes */
3878 873 : 420 : memcpy(result->bytes, s, MAX_MULTIBYTE_CHAR_LEN);
4533 874 : 420 : return true;
875 : : }
876 : :
877 : :
878 : : /*---------------------
879 : : * Subroutines for expanding original NFA graph into a trigram graph (stage 2).
880 : : *---------------------
881 : : */
882 : :
883 : : /*
884 : : * Transform the graph, given a regex and extracted color information.
885 : : *
886 : : * We create and process a queue of expanded-graph states until all the states
887 : : * are processed.
888 : : *
889 : : * This algorithm may be stopped due to resource limitation. In this case we
890 : : * force every unprocessed branch to immediately finish with matching (this
891 : : * can give us false positives but no false negatives) by marking all
892 : : * unprocessed states as final.
893 : : */
894 : : static void
895 : 65 : transformGraph(TrgmNFA *trgmNFA)
896 : : {
897 : : HASHCTL hashCtl;
898 : : TrgmStateKey initkey;
899 : : TrgmState *initstate;
900 : : ListCell *lc;
901 : :
902 : : /* Initialize this stage's workspace in trgmNFA struct */
903 : 65 : trgmNFA->queue = NIL;
904 : 65 : trgmNFA->keysQueue = NIL;
905 : 65 : trgmNFA->arcsCount = 0;
906 : 65 : trgmNFA->overflowed = false;
907 : :
908 : : /* Create hashtable for states */
909 : 65 : hashCtl.keysize = sizeof(TrgmStateKey);
910 : 65 : hashCtl.entrysize = sizeof(TrgmState);
911 : 65 : hashCtl.hcxt = CurrentMemoryContext;
912 : 65 : trgmNFA->states = hash_create("Trigram NFA",
913 : : 1024,
914 : : &hashCtl,
915 : : HASH_ELEM | HASH_BLOBS | HASH_CONTEXT);
3067 916 : 65 : trgmNFA->nstates = 0;
917 : :
918 : : /* Create initial state: ambiguous prefix, NFA's initial state */
4533 919 [ - + - - : 65 : MemSet(&initkey, 0, sizeof(initkey));
- - - - -
- ]
920 : 65 : initkey.prefix.colors[0] = COLOR_UNKNOWN;
921 : 65 : initkey.prefix.colors[1] = COLOR_UNKNOWN;
922 : 65 : initkey.nstate = pg_reg_getinitialstate(trgmNFA->regex);
923 : :
924 : 65 : initstate = getState(trgmNFA, &initkey);
3118 925 : 65 : initstate->flags |= TSTATE_INIT;
4533 926 : 65 : trgmNFA->initState = initstate;
927 : :
928 : : /*
929 : : * Recursively build the expanded graph by processing queue of states
930 : : * (breadth-first search). getState already put initstate in the queue.
931 : : * Note that getState will append new states to the queue within the loop,
932 : : * too; this works as long as we don't do repeat fetches using the "lc"
933 : : * pointer.
934 : : */
1405 935 [ + - + + : 729 : foreach(lc, trgmNFA->queue)
+ + ]
936 : : {
937 : 664 : TrgmState *state = (TrgmState *) lfirst(lc);
938 : :
939 : : /*
940 : : * If we overflowed then just mark state as final. Otherwise do
941 : : * actual processing.
942 : : */
4533 943 [ + + ]: 664 : if (trgmNFA->overflowed)
3118 944 : 9 : state->flags |= TSTATE_FIN;
945 : : else
4533 946 : 655 : processState(trgmNFA, state);
947 : :
948 : : /* Did we overflow? */
949 [ + - + + ]: 1328 : if (trgmNFA->arcsCount > MAX_EXPANDED_ARCS ||
950 : 664 : hash_get_num_entries(trgmNFA->states) > MAX_EXPANDED_STATES)
951 : 12 : trgmNFA->overflowed = true;
952 : : }
953 : 65 : }
954 : :
955 : : /*
956 : : * Process one state: add enter keys and then add outgoing arcs.
957 : : */
958 : : static void
959 : 655 : processState(TrgmNFA *trgmNFA, TrgmState *state)
960 : : {
961 : : ListCell *lc;
962 : :
963 : : /* keysQueue should be NIL already, but make sure */
964 : 655 : trgmNFA->keysQueue = NIL;
965 : :
966 : : /*
967 : : * Add state's own key, and then process all keys added to keysQueue until
968 : : * queue is finished. But we can quit if the state gets marked final.
969 : : */
970 : 655 : addKey(trgmNFA, state, &state->stateKey);
1405 971 [ + + + + : 1266 : foreach(lc, trgmNFA->keysQueue)
+ + ]
972 : : {
973 : 692 : TrgmStateKey *key = (TrgmStateKey *) lfirst(lc);
974 : :
975 [ + + ]: 692 : if (state->flags & TSTATE_FIN)
976 : 81 : break;
4533 977 : 611 : addKey(trgmNFA, state, key);
978 : : }
979 : :
980 : : /* Release keysQueue to clean up for next cycle */
1405 981 : 655 : list_free(trgmNFA->keysQueue);
982 : 655 : trgmNFA->keysQueue = NIL;
983 : :
984 : : /*
985 : : * Add outgoing arcs only if state isn't final (we have no interest in
986 : : * outgoing arcs if we already match)
987 : : */
3118 988 [ + + ]: 655 : if (!(state->flags & TSTATE_FIN))
4533 989 : 571 : addArcs(trgmNFA, state);
990 : 655 : }
991 : :
992 : : /*
993 : : * Add the given enter key into the state's enterKeys list, and determine
994 : : * whether this should result in any further enter keys being added.
995 : : * If so, add those keys to keysQueue so that processState will handle them.
996 : : *
997 : : * If the enter key is for the NFA's final state, mark state as TSTATE_FIN.
998 : : * This situation means that we can reach the final state from this expanded
999 : : * state without reading any predictable trigram, so we must consider this
1000 : : * state as an accepting one.
1001 : : *
1002 : : * The given key could be a duplicate of one already in enterKeys, or be
1003 : : * redundant with some enterKeys. So we check that before doing anything.
1004 : : *
1005 : : * Note that we don't generate any actual arcs here. addArcs will do that
1006 : : * later, after we have identified all the enter keys for this state.
1007 : : */
1008 : : static void
1009 : 1266 : addKey(TrgmNFA *trgmNFA, TrgmState *state, TrgmStateKey *key)
1010 : : {
1011 : : regex_arc_t *arcs;
1012 : : TrgmStateKey destKey;
1013 : : ListCell *cell;
1014 : : int i,
1015 : : arcsCount;
1016 : :
1017 : : /*
1018 : : * Ensure any pad bytes in destKey are zero, since it may get used as a
1019 : : * hashtable key by getState.
1020 : : */
1021 [ - + - - : 1266 : MemSet(&destKey, 0, sizeof(destKey));
- - - - -
- ]
1022 : :
1023 : : /*
1024 : : * Compare key to each existing enter key of the state to check for
1025 : : * redundancy. We can drop either old key(s) or the new key if we find
1026 : : * redundancy.
1027 : : */
2245 1028 [ + + + + : 1979 : foreach(cell, state->enterKeys)
+ + ]
1029 : : {
4533 1030 : 1016 : TrgmStateKey *existingKey = (TrgmStateKey *) lfirst(cell);
1031 : :
1032 [ + + ]: 1016 : if (existingKey->nstate == key->nstate)
1033 : : {
1034 [ + + ]: 312 : if (prefixContains(&existingKey->prefix, &key->prefix))
1035 : : {
1036 : : /* This old key already covers the new key. Nothing to do */
1037 : 303 : return;
1038 : : }
1039 [ + + ]: 9 : if (prefixContains(&key->prefix, &existingKey->prefix))
1040 : : {
1041 : : /*
1042 : : * The new key covers this old key. Remove the old key, it's
1043 : : * no longer needed once we add this key to the list.
1044 : : */
2245 1045 : 6 : state->enterKeys = foreach_delete_current(state->enterKeys,
1046 : : cell);
1047 : : }
1048 : : }
1049 : : }
1050 : :
1051 : : /* No redundancy, so add this key to the state's list */
4533 1052 : 963 : state->enterKeys = lappend(state->enterKeys, key);
1053 : :
1054 : : /* If state is now known final, mark it and we're done */
1055 [ + + ]: 963 : if (key->nstate == pg_reg_getfinalstate(trgmNFA->regex))
1056 : : {
3118 1057 : 84 : state->flags |= TSTATE_FIN;
4533 1058 : 84 : return;
1059 : : }
1060 : :
1061 : : /*
1062 : : * Loop through all outgoing arcs of the corresponding state in the
1063 : : * original NFA.
1064 : : */
1065 : 879 : arcsCount = pg_reg_getnumoutarcs(trgmNFA->regex, key->nstate);
1066 : 879 : arcs = (regex_arc_t *) palloc(sizeof(regex_arc_t) * arcsCount);
1067 : 879 : pg_reg_getoutarcs(trgmNFA->regex, key->nstate, arcs, arcsCount);
1068 : :
1069 [ + + ]: 2384 : for (i = 0; i < arcsCount; i++)
1070 : : {
1071 : 1505 : regex_arc_t *arc = &arcs[i];
1072 : :
1073 [ + + ]: 1505 : if (pg_reg_colorisbegin(trgmNFA->regex, arc->co))
1074 : : {
1075 : : /*
1076 : : * Start of line/string (^). Trigram extraction treats start of
1077 : : * line same as start of word: double space prefix is added.
1078 : : * Hence, make an enter key showing we can reach the arc
1079 : : * destination with all-blank prefix.
1080 : : */
1081 : 246 : destKey.prefix.colors[0] = COLOR_BLANK;
1082 : 246 : destKey.prefix.colors[1] = COLOR_BLANK;
1083 : 246 : destKey.nstate = arc->to;
1084 : :
1085 : : /* Add enter key to this state */
1086 : 246 : addKeyToQueue(trgmNFA, &destKey);
1087 : : }
1088 [ + + ]: 1259 : else if (pg_reg_colorisend(trgmNFA->regex, arc->co))
1089 : : {
1090 : : /*
1091 : : * End of line/string ($). We must consider this arc as a
1092 : : * transition that doesn't read anything. The reason for adding
1093 : : * this enter key to the state is that if the arc leads to the
1094 : : * NFA's final state, we must mark this expanded state as final.
1095 : : */
1096 : 162 : destKey.prefix.colors[0] = COLOR_UNKNOWN;
1097 : 162 : destKey.prefix.colors[1] = COLOR_UNKNOWN;
1098 : 162 : destKey.nstate = arc->to;
1099 : :
1100 : : /* Add enter key to this state */
1101 : 162 : addKeyToQueue(trgmNFA, &destKey);
1102 : : }
1659 1103 [ + + ]: 1097 : else if (arc->co >= 0)
1104 : : {
1105 : : /* Regular color (including WHITE) */
4533 1106 : 893 : TrgmColorInfo *colorInfo = &trgmNFA->colorInfo[arc->co];
1107 : :
1108 [ + - ]: 893 : if (colorInfo->expandable)
1109 : : {
1110 [ + + ]: 893 : if (colorInfo->containsNonWord &&
1111 [ + + ]: 55 : !validArcLabel(key, COLOR_BLANK))
1112 : : {
1113 : : /*
1114 : : * We can reach the arc destination after reading a
1115 : : * non-word character, but the prefix is not something
1116 : : * that addArc will accept with COLOR_BLANK, so no trigram
1117 : : * arc can get made for this transition. We must make an
1118 : : * enter key to show that the arc destination is
1119 : : * reachable. Set it up with an all-blank prefix, since
1120 : : * that corresponds to what the trigram extraction code
1121 : : * will do at a word starting boundary.
1122 : : */
1123 : 27 : destKey.prefix.colors[0] = COLOR_BLANK;
1124 : 27 : destKey.prefix.colors[1] = COLOR_BLANK;
1125 : 27 : destKey.nstate = arc->to;
1126 : 27 : addKeyToQueue(trgmNFA, &destKey);
1127 : : }
1128 : :
1129 [ + + ]: 893 : if (colorInfo->wordCharsCount > 0 &&
1130 [ + + ]: 838 : !validArcLabel(key, arc->co))
1131 : : {
1132 : : /*
1133 : : * We can reach the arc destination after reading a word
1134 : : * character, but the prefix is not something that addArc
1135 : : * will accept, so no trigram arc can get made for this
1136 : : * transition. We must make an enter key to show that the
1137 : : * arc destination is reachable. The prefix for the enter
1138 : : * key should reflect the info we have for this arc.
1139 : : */
1140 : 131 : destKey.prefix.colors[0] = key->prefix.colors[1];
1141 : 131 : destKey.prefix.colors[1] = arc->co;
1142 : 131 : destKey.nstate = arc->to;
1143 : 131 : addKeyToQueue(trgmNFA, &destKey);
1144 : : }
1145 : : }
1146 : : else
1147 : : {
1148 : : /*
1149 : : * Unexpandable color. Add enter key with ambiguous prefix,
1150 : : * showing we can reach the destination from this state, but
1151 : : * the preceding colors will be uncertain. (We do not set the
1152 : : * first prefix color to key->prefix.colors[1], because a
1153 : : * prefix of known followed by unknown is invalid.)
1154 : : */
4533 tgl@sss.pgh.pa.us 1155 :UBC 0 : destKey.prefix.colors[0] = COLOR_UNKNOWN;
1156 : 0 : destKey.prefix.colors[1] = COLOR_UNKNOWN;
1157 : 0 : destKey.nstate = arc->to;
1158 : 0 : addKeyToQueue(trgmNFA, &destKey);
1159 : : }
1160 : : }
1161 : : else
1162 : : {
1163 : : /* RAINBOW: treat as unexpandable color */
1659 tgl@sss.pgh.pa.us 1164 :CBC 204 : destKey.prefix.colors[0] = COLOR_UNKNOWN;
1165 : 204 : destKey.prefix.colors[1] = COLOR_UNKNOWN;
1166 : 204 : destKey.nstate = arc->to;
1167 : 204 : addKeyToQueue(trgmNFA, &destKey);
1168 : : }
1169 : : }
1170 : :
4533 1171 : 879 : pfree(arcs);
1172 : : }
1173 : :
1174 : : /*
1175 : : * Add copy of given key to keysQueue for later processing.
1176 : : */
1177 : : static void
1178 : 770 : addKeyToQueue(TrgmNFA *trgmNFA, TrgmStateKey *key)
1179 : : {
1180 : 770 : TrgmStateKey *keyCopy = (TrgmStateKey *) palloc(sizeof(TrgmStateKey));
1181 : :
1182 : 770 : memcpy(keyCopy, key, sizeof(TrgmStateKey));
1183 : 770 : trgmNFA->keysQueue = lappend(trgmNFA->keysQueue, keyCopy);
1184 : 770 : }
1185 : :
1186 : : /*
1187 : : * Add outgoing arcs from given state, whose enter keys are all now known.
1188 : : */
1189 : : static void
1190 : 571 : addArcs(TrgmNFA *trgmNFA, TrgmState *state)
1191 : : {
1192 : : TrgmStateKey destKey;
1193 : : ListCell *cell;
1194 : : regex_arc_t *arcs;
1195 : : int arcsCount,
1196 : : i;
1197 : :
1198 : : /*
1199 : : * Ensure any pad bytes in destKey are zero, since it may get used as a
1200 : : * hashtable key by getState.
1201 : : */
1202 [ - + - - : 571 : MemSet(&destKey, 0, sizeof(destKey));
- - - - -
- ]
1203 : :
1204 : : /*
1205 : : * Iterate over enter keys associated with this expanded-graph state. This
1206 : : * includes both the state's own stateKey, and any enter keys we added to
1207 : : * it during addKey (which represent expanded-graph states that are not
1208 : : * distinguishable from this one by means of trigrams). For each such
1209 : : * enter key, examine all the out-arcs of the key's underlying NFA state,
1210 : : * and try to make a trigram arc leading to where the out-arc leads.
1211 : : * (addArc will deal with whether the arc is valid or not.)
1212 : : */
1213 [ + - + + : 1336 : foreach(cell, state->enterKeys)
+ + ]
1214 : : {
1215 : 765 : TrgmStateKey *key = (TrgmStateKey *) lfirst(cell);
1216 : :
1217 : 765 : arcsCount = pg_reg_getnumoutarcs(trgmNFA->regex, key->nstate);
1218 : 765 : arcs = (regex_arc_t *) palloc(sizeof(regex_arc_t) * arcsCount);
1219 : 765 : pg_reg_getoutarcs(trgmNFA->regex, key->nstate, arcs, arcsCount);
1220 : :
1221 [ + + ]: 1946 : for (i = 0; i < arcsCount; i++)
1222 : : {
1223 : 1181 : regex_arc_t *arc = &arcs[i];
1224 : : TrgmColorInfo *colorInfo;
1225 : :
1226 : : /*
1227 : : * Ignore non-expandable colors; addKey already handled the case.
1228 : : *
1229 : : * We need no special check for WHITE or begin/end pseudocolors
1230 : : * here. We don't need to do any processing for them, and they
1231 : : * will be marked non-expandable since the regex engine will have
1232 : : * reported them that way. We do have to watch out for RAINBOW,
1233 : : * which has a negative color number.
1234 : : */
1658 1235 [ + + ]: 1181 : if (arc->co < 0)
1236 : 102 : continue;
1237 [ - + ]: 1079 : Assert(arc->co < trgmNFA->ncolors);
1238 : :
1239 : 1079 : colorInfo = &trgmNFA->colorInfo[arc->co];
4533 1240 [ + + ]: 1079 : if (!colorInfo->expandable)
1241 : 210 : continue;
1242 : :
1243 [ + + ]: 869 : if (colorInfo->containsNonWord)
1244 : : {
1245 : : /*
1246 : : * Color includes non-word character(s).
1247 : : *
1248 : : * Generate an arc, treating this transition as occurring on
1249 : : * BLANK. This allows word-ending trigrams to be manufactured
1250 : : * if possible.
1251 : : */
1252 : 55 : destKey.prefix.colors[0] = key->prefix.colors[1];
1253 : 55 : destKey.prefix.colors[1] = COLOR_BLANK;
1254 : 55 : destKey.nstate = arc->to;
1255 : :
1256 : 55 : addArc(trgmNFA, state, key, COLOR_BLANK, &destKey);
1257 : : }
1258 : :
1259 [ + + ]: 869 : if (colorInfo->wordCharsCount > 0)
1260 : : {
1261 : : /*
1262 : : * Color includes word character(s).
1263 : : *
1264 : : * Generate an arc. Color is pushed into prefix of target
1265 : : * state.
1266 : : */
1267 : 814 : destKey.prefix.colors[0] = key->prefix.colors[1];
1268 : 814 : destKey.prefix.colors[1] = arc->co;
1269 : 814 : destKey.nstate = arc->to;
1270 : :
1271 : 814 : addArc(trgmNFA, state, key, arc->co, &destKey);
1272 : : }
1273 : : }
1274 : :
1275 : 765 : pfree(arcs);
1276 : : }
1277 : 571 : }
1278 : :
1279 : : /*
1280 : : * Generate an out-arc of the expanded graph, if it's valid and not redundant.
1281 : : *
1282 : : * state: expanded-graph state we want to add an out-arc to
1283 : : * key: provides prefix colors (key->nstate is not used)
1284 : : * co: transition color
1285 : : * destKey: identifier for destination state of expanded graph
1286 : : */
1287 : : static void
1288 : 869 : addArc(TrgmNFA *trgmNFA, TrgmState *state, TrgmStateKey *key,
1289 : : TrgmColor co, TrgmStateKey *destKey)
1290 : : {
1291 : : TrgmArc *arc;
1292 : : ListCell *cell;
1293 : :
1294 : : /* Do nothing if this wouldn't be a valid arc label trigram */
1295 [ + + ]: 869 : if (!validArcLabel(key, co))
1296 : 137 : return;
1297 : :
1298 : : /*
1299 : : * Check if we are going to reach key which is covered by a key which is
1300 : : * already listed in this state. If so arc is useless: the NFA can bypass
1301 : : * it through a path that doesn't require any predictable trigram, so
1302 : : * whether the arc's trigram is present or not doesn't really matter.
1303 : : */
1304 [ + - + + : 1767 : foreach(cell, state->enterKeys)
+ + ]
1305 : : {
1306 : 1041 : TrgmStateKey *existingKey = (TrgmStateKey *) lfirst(cell);
1307 : :
1308 [ + + + + ]: 1066 : if (existingKey->nstate == destKey->nstate &&
1309 : 25 : prefixContains(&existingKey->prefix, &destKey->prefix))
1310 : 6 : return;
1311 : : }
1312 : :
1313 : : /* Checks were successful, add new arc */
1314 : 726 : arc = (TrgmArc *) palloc(sizeof(TrgmArc));
1315 : 726 : arc->target = getState(trgmNFA, destKey);
1316 : 726 : arc->ctrgm.colors[0] = key->prefix.colors[0];
1317 : 726 : arc->ctrgm.colors[1] = key->prefix.colors[1];
1318 : 726 : arc->ctrgm.colors[2] = co;
1319 : :
1320 : 726 : state->arcs = lappend(state->arcs, arc);
1321 : 726 : trgmNFA->arcsCount++;
1322 : : }
1323 : :
1324 : : /*
1325 : : * Can we make a valid trigram arc label from the given prefix and arc color?
1326 : : *
1327 : : * This is split out so that tests in addKey and addArc will stay in sync.
1328 : : */
1329 : : static bool
1330 : 1762 : validArcLabel(TrgmStateKey *key, TrgmColor co)
1331 : : {
1332 : : /*
1333 : : * We have to know full trigram in order to add outgoing arc. So we can't
1334 : : * do it if prefix is ambiguous.
1335 : : */
1336 [ + + ]: 1762 : if (key->prefix.colors[0] == COLOR_UNKNOWN)
1337 : 233 : return false;
1338 : :
1339 : : /* If key->prefix.colors[0] isn't unknown, its second color isn't either */
1340 [ - + ]: 1529 : Assert(key->prefix.colors[1] != COLOR_UNKNOWN);
1341 : : /* And we should not be called with an unknown arc color anytime */
1342 [ - + ]: 1529 : Assert(co != COLOR_UNKNOWN);
1343 : :
1344 : : /*
1345 : : * We don't bother with making arcs representing three non-word
1346 : : * characters, since that's useless for trigram extraction.
1347 : : */
1348 [ + + ]: 1529 : if (key->prefix.colors[0] == COLOR_BLANK &&
1349 [ + + + + ]: 164 : key->prefix.colors[1] == COLOR_BLANK &&
1350 : : co == COLOR_BLANK)
1351 : 12 : return false;
1352 : :
1353 : : /*
1354 : : * We also reject nonblank-blank-anything. The nonblank-blank-nonblank
1355 : : * case doesn't correspond to any trigram the trigram extraction code
1356 : : * would make. The nonblank-blank-blank case is also not possible with
1357 : : * RPADDING = 1. (Note that in many cases we'd fail to generate such a
1358 : : * trigram even if it were valid, for example processing "foo bar" will
1359 : : * not result in considering the trigram "o ". So if you want to support
1360 : : * RPADDING = 2, there's more to do than just twiddle this test.)
1361 : : */
1362 [ + + ]: 1517 : if (key->prefix.colors[0] != COLOR_BLANK &&
1363 [ + + ]: 1365 : key->prefix.colors[1] == COLOR_BLANK)
1364 : 50 : return false;
1365 : :
1366 : : /*
1367 : : * Other combinations involving blank are valid, in particular we assume
1368 : : * blank-blank-nonblank is valid, which presumes that LPADDING is 2.
1369 : : *
1370 : : * Note: Using again the example "foo bar", we will not consider the
1371 : : * trigram " b", though this trigram would be found by the trigram
1372 : : * extraction code. Since we will find " ba", it doesn't seem worth
1373 : : * trying to hack the algorithm to generate the additional trigram.
1374 : : */
1375 : :
1376 : : /* arc label is valid */
1377 : 1467 : return true;
1378 : : }
1379 : :
1380 : : /*
1381 : : * Get state of expanded graph for given state key,
1382 : : * and queue the state for processing if it didn't already exist.
1383 : : */
1384 : : static TrgmState *
1385 : 791 : getState(TrgmNFA *trgmNFA, TrgmStateKey *key)
1386 : : {
1387 : : TrgmState *state;
1388 : : bool found;
1389 : :
1390 : 791 : state = (TrgmState *) hash_search(trgmNFA->states, key, HASH_ENTER,
1391 : : &found);
1392 [ + + ]: 791 : if (!found)
1393 : : {
1394 : : /* New state: initialize and queue it */
1395 : 664 : state->arcs = NIL;
1396 : 664 : state->enterKeys = NIL;
3118 1397 : 664 : state->flags = 0;
1398 : : /* states are initially given negative numbers */
3067 1399 : 664 : state->snumber = -(++trgmNFA->nstates);
4533 1400 : 664 : state->parent = NULL;
3067 1401 : 664 : state->tentFlags = 0;
3118 1402 : 664 : state->tentParent = NULL;
1403 : :
4533 1404 : 664 : trgmNFA->queue = lappend(trgmNFA->queue, state);
1405 : : }
1406 : 791 : return state;
1407 : : }
1408 : :
1409 : : /*
1410 : : * Check if prefix1 "contains" prefix2.
1411 : : *
1412 : : * "contains" means that any exact prefix (with no ambiguity) that satisfies
1413 : : * prefix2 also satisfies prefix1.
1414 : : */
1415 : : static bool
1416 : 346 : prefixContains(TrgmPrefix *prefix1, TrgmPrefix *prefix2)
1417 : : {
1418 [ + + ]: 346 : if (prefix1->colors[1] == COLOR_UNKNOWN)
1419 : : {
1420 : : /* Fully ambiguous prefix contains everything */
1421 : 306 : return true;
1422 : : }
1423 [ + + ]: 40 : else if (prefix1->colors[0] == COLOR_UNKNOWN)
1424 : : {
1425 : : /*
1426 : : * Prefix with only first unknown color contains every prefix with
1427 : : * same second color.
1428 : : */
1429 [ + + ]: 12 : if (prefix1->colors[1] == prefix2->colors[1])
1430 : 3 : return true;
1431 : : else
1432 : 9 : return false;
1433 : : }
1434 : : else
1435 : : {
1436 : : /* Exact prefix contains only the exact same prefix */
1437 [ + + ]: 28 : if (prefix1->colors[0] == prefix2->colors[0] &&
1438 [ + + ]: 13 : prefix1->colors[1] == prefix2->colors[1])
1439 : 6 : return true;
1440 : : else
1441 : 22 : return false;
1442 : : }
1443 : : }
1444 : :
1445 : :
1446 : : /*---------------------
1447 : : * Subroutines for expanding color trigrams into regular trigrams (stage 3).
1448 : : *---------------------
1449 : : */
1450 : :
1451 : : /*
1452 : : * Get vector of all color trigrams in graph and select which of them
1453 : : * to expand into simple trigrams.
1454 : : *
1455 : : * Returns true if OK, false if exhausted resource limits.
1456 : : */
1457 : : static bool
1458 : 56 : selectColorTrigrams(TrgmNFA *trgmNFA)
1459 : : {
1460 : : HASH_SEQ_STATUS scan_status;
1461 : 56 : int arcsCount = trgmNFA->arcsCount,
1462 : : i;
1463 : : TrgmState *state;
1464 : : ColorTrgmInfo *colorTrgms;
1465 : : int64 totalTrgmCount;
1466 : : float4 totalTrgmPenalty;
1467 : : int cnumber;
1468 : :
1469 : : /* Collect color trigrams from all arcs */
3067 1470 : 56 : colorTrgms = (ColorTrgmInfo *) palloc0(sizeof(ColorTrgmInfo) * arcsCount);
4533 1471 : 56 : trgmNFA->colorTrgms = colorTrgms;
1472 : :
1473 : 56 : i = 0;
1474 : 56 : hash_seq_init(&scan_status, trgmNFA->states);
1475 [ + + ]: 711 : while ((state = (TrgmState *) hash_seq_search(&scan_status)) != NULL)
1476 : : {
1477 : : ListCell *cell;
1478 : :
1479 [ + + + + : 1381 : foreach(cell, state->arcs)
+ + ]
1480 : : {
1481 : 726 : TrgmArc *arc = (TrgmArc *) lfirst(cell);
1482 : 726 : TrgmArcInfo *arcInfo = (TrgmArcInfo *) palloc(sizeof(TrgmArcInfo));
3067 1483 : 726 : ColorTrgmInfo *trgmInfo = &colorTrgms[i];
1484 : :
4533 1485 : 726 : arcInfo->source = state;
1486 : 726 : arcInfo->target = arc->target;
3067 1487 : 726 : trgmInfo->ctrgm = arc->ctrgm;
1488 : 726 : trgmInfo->cnumber = -1;
1489 : : /* count and penalty will be set below */
1490 : 726 : trgmInfo->expanded = true;
1491 : 726 : trgmInfo->arcs = list_make1(arcInfo);
4533 1492 : 726 : i++;
1493 : : }
1494 : : }
1495 [ - + ]: 56 : Assert(i == arcsCount);
1496 : :
1497 : : /* Remove duplicates, merging their arcs lists */
1498 [ + + ]: 56 : if (arcsCount >= 2)
1499 : : {
1500 : : ColorTrgmInfo *p1,
1501 : : *p2;
1502 : :
1503 : : /* Sort trigrams to ease duplicate detection */
1504 : 34 : qsort(colorTrgms, arcsCount, sizeof(ColorTrgmInfo), colorTrgmInfoCmp);
1505 : :
1506 : : /* p1 is probe point, p2 is last known non-duplicate. */
1507 : 34 : p2 = colorTrgms;
1508 [ + + ]: 706 : for (p1 = colorTrgms + 1; p1 < colorTrgms + arcsCount; p1++)
1509 : : {
1510 [ + + ]: 672 : if (colorTrgmInfoCmp(p1, p2) > 0)
1511 : : {
1512 : 224 : p2++;
1513 : 224 : *p2 = *p1;
1514 : : }
1515 : : else
1516 : : {
1517 : 448 : p2->arcs = list_concat(p2->arcs, p1->arcs);
1518 : : }
1519 : : }
1520 : 34 : trgmNFA->colorTrgmsCount = (p2 - colorTrgms) + 1;
1521 : : }
1522 : : else
1523 : : {
1524 : 22 : trgmNFA->colorTrgmsCount = arcsCount;
1525 : : }
1526 : :
1527 : : /*
1528 : : * Count number of simple trigrams generated by each color trigram, and
1529 : : * also compute a penalty value, which is the number of simple trigrams
1530 : : * times a multiplier that depends on its whitespace content.
1531 : : *
1532 : : * Note: per-color-trigram counts cannot overflow an int so long as
1533 : : * COLOR_COUNT_LIMIT is not more than the cube root of INT_MAX, ie about
1534 : : * 1290. However, the grand total totalTrgmCount might conceivably
1535 : : * overflow an int, so we use int64 for that within this routine. Also,
1536 : : * penalties are calculated in float4 arithmetic to avoid any overflow
1537 : : * worries.
1538 : : */
1539 : 56 : totalTrgmCount = 0;
4172 1540 : 56 : totalTrgmPenalty = 0.0f;
4533 1541 [ + + ]: 334 : for (i = 0; i < trgmNFA->colorTrgmsCount; i++)
1542 : : {
1543 : 278 : ColorTrgmInfo *trgmInfo = &colorTrgms[i];
1544 : : int j,
4172 1545 : 278 : count = 1,
1546 : 278 : typeIndex = 0;
1547 : :
4533 1548 [ + + ]: 1112 : for (j = 0; j < 3; j++)
1549 : : {
1550 : 834 : TrgmColor c = trgmInfo->ctrgm.colors[j];
1551 : :
4172 1552 : 834 : typeIndex *= 2;
1553 [ + + ]: 834 : if (c == COLOR_BLANK)
1554 : 113 : typeIndex++;
1555 : : else
4533 1556 : 721 : count *= trgmNFA->colorInfo[c].wordCharsCount;
1557 : : }
1558 : 278 : trgmInfo->count = count;
1559 : 278 : totalTrgmCount += count;
4172 1560 : 278 : trgmInfo->penalty = penalties[typeIndex] * (float4) count;
1561 : 278 : totalTrgmPenalty += trgmInfo->penalty;
1562 : : }
1563 : :
1564 : : /* Sort color trigrams in descending order of their penalties */
4533 1565 : 56 : qsort(colorTrgms, trgmNFA->colorTrgmsCount, sizeof(ColorTrgmInfo),
1566 : : colorTrgmInfoPenaltyCmp);
1567 : :
1568 : : /*
1569 : : * Remove color trigrams from the graph so long as total penalty of color
1570 : : * trigrams exceeds WISH_TRGM_PENALTY. (If we fail to get down to
1571 : : * WISH_TRGM_PENALTY, it's OK so long as total count is no more than
1572 : : * MAX_TRGM_COUNT.) We prefer to remove color trigrams with higher
1573 : : * penalty, since those are the most promising for reducing the total
1574 : : * penalty. When removing a color trigram we have to merge states
1575 : : * connected by arcs labeled with that trigram. It's necessary to not
1576 : : * merge initial and final states, because our graph becomes useless if
1577 : : * that happens; so we cannot always remove the trigram we'd prefer to.
1578 : : */
4172 1579 [ + + ]: 204 : for (i = 0; i < trgmNFA->colorTrgmsCount; i++)
1580 : : {
4533 1581 : 179 : ColorTrgmInfo *trgmInfo = &colorTrgms[i];
1582 : 179 : bool canRemove = true;
1583 : : ListCell *cell;
1584 : :
1585 : : /* Done if we've reached the target */
4172 1586 [ + + ]: 179 : if (totalTrgmPenalty <= WISH_TRGM_PENALTY)
1587 : 31 : break;
1588 : :
1589 : : #ifdef TRGM_REGEXP_DEBUG
1590 : : fprintf(stderr, "considering ctrgm %d %d %d, penalty %f, %d arcs\n",
1591 : : trgmInfo->ctrgm.colors[0],
1592 : : trgmInfo->ctrgm.colors[1],
1593 : : trgmInfo->ctrgm.colors[2],
1594 : : trgmInfo->penalty,
1595 : : list_length(trgmInfo->arcs));
1596 : : #endif
1597 : :
1598 : : /*
1599 : : * Does any arc of this color trigram connect initial and final
1600 : : * states? If so we can't remove it.
1601 : : */
4533 1602 [ + - + + : 306 : foreach(cell, trgmInfo->arcs)
+ + ]
1603 : : {
1604 : 191 : TrgmArcInfo *arcInfo = (TrgmArcInfo *) lfirst(cell);
1605 : 191 : TrgmState *source = arcInfo->source,
1606 : 191 : *target = arcInfo->target;
1607 : : int source_flags,
1608 : : target_flags;
1609 : :
1610 : : #ifdef TRGM_REGEXP_DEBUG
1611 : : fprintf(stderr, "examining arc to s%d (%x) from s%d (%x)\n",
1612 : : -target->snumber, target->flags,
1613 : : -source->snumber, source->flags);
1614 : : #endif
1615 : :
1616 : : /* examine parent states, if any merging has already happened */
1617 [ + + ]: 341 : while (source->parent)
1618 : 150 : source = source->parent;
1619 [ + + ]: 407 : while (target->parent)
1620 : 216 : target = target->parent;
1621 : :
1622 : : #ifdef TRGM_REGEXP_DEBUG
1623 : : fprintf(stderr, " ... after completed merges: to s%d (%x) from s%d (%x)\n",
1624 : : -target->snumber, target->flags,
1625 : : -source->snumber, source->flags);
1626 : : #endif
1627 : :
1628 : : /* we must also consider merges we are planning right now */
3067 1629 : 191 : source_flags = source->flags | source->tentFlags;
3118 1630 [ + + ]: 195 : while (source->tentParent)
1631 : : {
1632 : 4 : source = source->tentParent;
3067 1633 : 4 : source_flags |= source->flags | source->tentFlags;
1634 : : }
1635 : 191 : target_flags = target->flags | target->tentFlags;
3118 1636 [ + + ]: 206 : while (target->tentParent)
1637 : : {
1638 : 15 : target = target->tentParent;
3067 1639 : 15 : target_flags |= target->flags | target->tentFlags;
1640 : : }
1641 : :
1642 : : #ifdef TRGM_REGEXP_DEBUG
1643 : : fprintf(stderr, " ... after tentative merges: to s%d (%x) from s%d (%x)\n",
1644 : : -target->snumber, target_flags,
1645 : : -source->snumber, source_flags);
1646 : : #endif
1647 : :
1648 : : /* would fully-merged state have both INIT and FIN set? */
3118 1649 [ + + ]: 191 : if (((source_flags | target_flags) & (TSTATE_INIT | TSTATE_FIN)) ==
1650 : : (TSTATE_INIT | TSTATE_FIN))
1651 : : {
4533 1652 : 33 : canRemove = false;
1653 : 33 : break;
1654 : : }
1655 : :
1656 : : /* ok so far, so remember planned merge */
3118 1657 [ + + ]: 158 : if (source != target)
1658 : : {
1659 : : #ifdef TRGM_REGEXP_DEBUG
1660 : : fprintf(stderr, " ... tentatively merging s%d into s%d\n",
1661 : : -target->snumber, -source->snumber);
1662 : : #endif
1663 : 113 : target->tentParent = source;
3067 1664 : 113 : source->tentFlags |= target_flags;
1665 : : }
1666 : : }
1667 : :
1668 : : /*
1669 : : * We must reset all the tentFlags/tentParent fields before
1670 : : * continuing. tentFlags could only have become set in states that
1671 : : * are the source or parent or tentative parent of one of the current
1672 : : * arcs; likewise tentParent could only have become set in states that
1673 : : * are the target or parent or tentative parent of one of the current
1674 : : * arcs. There might be some overlap between those sets, but if we
1675 : : * clear tentFlags in target states as well as source states, we
1676 : : * should be okay even if we visit a state as target before visiting
1677 : : * it as a source.
1678 : : */
3118 1679 [ + - + + : 348 : foreach(cell, trgmInfo->arcs)
+ + ]
1680 : : {
1681 : 200 : TrgmArcInfo *arcInfo = (TrgmArcInfo *) lfirst(cell);
3067 1682 : 200 : TrgmState *source = arcInfo->source,
1683 : 200 : *target = arcInfo->target;
1684 : : TrgmState *ttarget;
1685 : :
1686 : : /* no need to touch previously-merged states */
1687 [ + + ]: 350 : while (source->parent)
1688 : 150 : source = source->parent;
3118 1689 [ + + ]: 440 : while (target->parent)
1690 : 240 : target = target->parent;
1691 : :
3067 1692 [ + + ]: 406 : while (source)
1693 : : {
1694 : 206 : source->tentFlags = 0;
1695 : 206 : source = source->tentParent;
1696 : : }
1697 : :
3118 1698 [ + + ]: 313 : while ((ttarget = target->tentParent) != NULL)
1699 : : {
1700 : 113 : target->tentParent = NULL;
3067 1701 : 113 : target->tentFlags = 0; /* in case it was also a source */
3118 1702 : 113 : target = ttarget;
1703 : : }
1704 : : }
1705 : :
1706 : : /* Now, move on if we can't drop this trigram */
4533 1707 [ + + ]: 148 : if (!canRemove)
1708 : : {
1709 : : #ifdef TRGM_REGEXP_DEBUG
1710 : : fprintf(stderr, " ... not ok to merge\n");
1711 : : #endif
1712 : 33 : continue;
1713 : : }
1714 : :
1715 : : /* OK, merge states linked by each arc labeled by the trigram */
1716 [ + - + + : 263 : foreach(cell, trgmInfo->arcs)
+ + ]
1717 : : {
1718 : 148 : TrgmArcInfo *arcInfo = (TrgmArcInfo *) lfirst(cell);
1719 : 148 : TrgmState *source = arcInfo->source,
1720 : 148 : *target = arcInfo->target;
1721 : :
1722 [ + + ]: 292 : while (source->parent)
1723 : 144 : source = source->parent;
1724 [ + + ]: 346 : while (target->parent)
1725 : 198 : target = target->parent;
1726 [ + + ]: 148 : if (source != target)
1727 : : {
1728 : : #ifdef TRGM_REGEXP_DEBUG
1729 : : fprintf(stderr, "merging s%d into s%d\n",
1730 : : -target->snumber, -source->snumber);
1731 : : #endif
1732 : 103 : mergeStates(source, target);
1733 : : /* Assert we didn't merge initial and final states */
3118 1734 [ - + ]: 103 : Assert((source->flags & (TSTATE_INIT | TSTATE_FIN)) !=
1735 : : (TSTATE_INIT | TSTATE_FIN));
1736 : : }
1737 : : }
1738 : :
1739 : : /* Mark trigram unexpanded, and update totals */
4533 1740 : 115 : trgmInfo->expanded = false;
1741 : 115 : totalTrgmCount -= trgmInfo->count;
4172 1742 : 115 : totalTrgmPenalty -= trgmInfo->penalty;
1743 : : }
1744 : :
1745 : : /* Did we succeed in fitting into MAX_TRGM_COUNT? */
4533 1746 [ + + ]: 56 : if (totalTrgmCount > MAX_TRGM_COUNT)
1747 : 3 : return false;
1748 : :
1749 : 53 : trgmNFA->totalTrgmCount = (int) totalTrgmCount;
1750 : :
1751 : : /*
1752 : : * Sort color trigrams by colors (will be useful for bsearch in packGraph)
1753 : : * and enumerate the color trigrams that are expanded.
1754 : : */
3067 1755 : 53 : cnumber = 0;
4533 1756 : 53 : qsort(colorTrgms, trgmNFA->colorTrgmsCount, sizeof(ColorTrgmInfo),
1757 : : colorTrgmInfoCmp);
1758 [ + + ]: 328 : for (i = 0; i < trgmNFA->colorTrgmsCount; i++)
1759 : : {
1760 [ + + ]: 275 : if (colorTrgms[i].expanded)
1761 : : {
3067 1762 : 160 : colorTrgms[i].cnumber = cnumber;
1763 : 160 : cnumber++;
1764 : : }
1765 : : }
1766 : :
4533 1767 : 53 : return true;
1768 : : }
1769 : :
1770 : : /*
1771 : : * Expand selected color trigrams into regular trigrams.
1772 : : *
1773 : : * Returns the TRGM array to be passed to the index machinery.
1774 : : * The array must be allocated in rcontext.
1775 : : */
1776 : : static TRGM *
1777 : 53 : expandColorTrigrams(TrgmNFA *trgmNFA, MemoryContext rcontext)
1778 : : {
1779 : : TRGM *trg;
1780 : : trgm *p;
1781 : : int i;
1782 : : TrgmColorInfo blankColor;
1783 : : trgm_mb_char blankChar;
1784 : :
1785 : : /* Set up "blank" color structure containing a single zero character */
1786 : 53 : memset(blankChar.bytes, 0, sizeof(blankChar.bytes));
1787 : 53 : blankColor.wordCharsCount = 1;
1788 : 53 : blankColor.wordChars = &blankChar;
1789 : :
1790 : : /* Construct the trgm array */
1791 : : trg = (TRGM *)
1792 : 53 : MemoryContextAllocZero(rcontext,
1793 : : TRGMHDRSIZE +
1794 : 53 : trgmNFA->totalTrgmCount * sizeof(trgm));
1795 : 53 : trg->flag = ARRKEY;
1796 : 53 : SET_VARSIZE(trg, CALCGTSIZE(ARRKEY, trgmNFA->totalTrgmCount));
1797 : 53 : p = GETARR(trg);
1798 [ + + ]: 328 : for (i = 0; i < trgmNFA->colorTrgmsCount; i++)
1799 : : {
1800 : 275 : ColorTrgmInfo *colorTrgm = &trgmNFA->colorTrgms[i];
1801 : : TrgmColorInfo *c[3];
1802 : : trgm_mb_char s[3];
1803 : : int j,
1804 : : i1,
1805 : : i2,
1806 : : i3;
1807 : :
1808 : : /* Ignore any unexpanded trigrams ... */
1809 [ + + ]: 275 : if (!colorTrgm->expanded)
1810 : 115 : continue;
1811 : :
1812 : : /* Get colors, substituting the dummy struct for COLOR_BLANK */
1813 [ + + ]: 640 : for (j = 0; j < 3; j++)
1814 : : {
1815 [ + + ]: 480 : if (colorTrgm->ctrgm.colors[j] != COLOR_BLANK)
1816 : 413 : c[j] = &trgmNFA->colorInfo[colorTrgm->ctrgm.colors[j]];
1817 : : else
1818 : 67 : c[j] = &blankColor;
1819 : : }
1820 : :
1821 : : /* Iterate over all possible combinations of colors' characters */
1822 [ + + ]: 377 : for (i1 = 0; i1 < c[0]->wordCharsCount; i1++)
1823 : : {
1824 : 217 : s[0] = c[0]->wordChars[i1];
1825 [ + + ]: 728 : for (i2 = 0; i2 < c[1]->wordCharsCount; i2++)
1826 : : {
1827 : 511 : s[1] = c[1]->wordChars[i2];
1828 [ + + ]: 1970 : for (i3 = 0; i3 < c[2]->wordCharsCount; i3++)
1829 : : {
1830 : 1459 : s[2] = c[2]->wordChars[i3];
1831 : 1459 : fillTrgm(p, s);
1832 : 1459 : p++;
1833 : : }
1834 : : }
1835 : : }
1836 : : }
1837 : :
1838 : 53 : return trg;
1839 : : }
1840 : :
1841 : : /*
1842 : : * Convert trigram into trgm datatype.
1843 : : */
1844 : : static void
1845 : 1459 : fillTrgm(trgm *ptrgm, trgm_mb_char s[3])
1846 : : {
1847 : : char str[3 * MAX_MULTIBYTE_CHAR_LEN],
1848 : : *p;
1849 : : int i,
1850 : : j;
1851 : :
1852 : : /* Write multibyte string into "str" (we don't need null termination) */
1853 : 1459 : p = str;
1854 : :
1855 [ + + ]: 5836 : for (i = 0; i < 3; i++)
1856 : : {
1857 [ + + ]: 4377 : if (s[i].bytes[0] != 0)
1858 : : {
1859 [ + - + + ]: 8232 : for (j = 0; j < MAX_MULTIBYTE_CHAR_LEN && s[i].bytes[j]; j++)
1860 : 4116 : *p++ = s[i].bytes[j];
1861 : : }
1862 : : else
1863 : : {
1864 : : /* Emit a space in place of COLOR_BLANK */
1865 : 261 : *p++ = ' ';
1866 : : }
1867 : : }
1868 : :
1869 : : /* Convert "str" to a standard trigram (possibly hashing it) */
1870 : 1459 : compact_trigram(ptrgm, str, p - str);
1871 : 1459 : }
1872 : :
1873 : : /*
1874 : : * Merge two states of graph.
1875 : : */
1876 : : static void
1877 : 103 : mergeStates(TrgmState *state1, TrgmState *state2)
1878 : : {
1879 [ - + ]: 103 : Assert(state1 != state2);
1880 [ - + ]: 103 : Assert(!state1->parent);
1881 [ - + ]: 103 : Assert(!state2->parent);
1882 : :
1883 : : /* state1 absorbs state2's flags */
3118 1884 : 103 : state1->flags |= state2->flags;
1885 : :
1886 : : /* state2, and indirectly all its children, become children of state1 */
4533 1887 : 103 : state2->parent = state1;
1888 : 103 : }
1889 : :
1890 : : /*
1891 : : * Compare function for sorting of color trigrams by their colors.
1892 : : */
1893 : : static int
1894 : 5089 : colorTrgmInfoCmp(const void *p1, const void *p2)
1895 : : {
1896 : 5089 : const ColorTrgmInfo *c1 = (const ColorTrgmInfo *) p1;
1897 : 5089 : const ColorTrgmInfo *c2 = (const ColorTrgmInfo *) p2;
1898 : :
1899 : 5089 : return memcmp(&c1->ctrgm, &c2->ctrgm, sizeof(ColorTrgm));
1900 : : }
1901 : :
1902 : : /*
1903 : : * Compare function for sorting color trigrams in descending order of
1904 : : * their penalty fields.
1905 : : */
1906 : : static int
4172 1907 : 423 : colorTrgmInfoPenaltyCmp(const void *p1, const void *p2)
1908 : : {
1909 : 423 : float4 penalty1 = ((const ColorTrgmInfo *) p1)->penalty;
1910 : 423 : float4 penalty2 = ((const ColorTrgmInfo *) p2)->penalty;
1911 : :
1912 [ + + ]: 423 : if (penalty1 < penalty2)
4533 1913 : 127 : return 1;
4172 1914 [ + + ]: 296 : else if (penalty1 == penalty2)
4533 1915 : 162 : return 0;
1916 : : else
1917 : 134 : return -1;
1918 : : }
1919 : :
1920 : :
1921 : : /*---------------------
1922 : : * Subroutines for packing the graph into final representation (stage 4).
1923 : : *---------------------
1924 : : */
1925 : :
1926 : : /*
1927 : : * Pack expanded graph into final representation.
1928 : : *
1929 : : * The result data must be allocated in rcontext.
1930 : : */
1931 : : static TrgmPackedGraph *
1932 : 53 : packGraph(TrgmNFA *trgmNFA, MemoryContext rcontext)
1933 : : {
3067 1934 : 53 : int snumber = 2,
1935 : : arcIndex,
1936 : : arcsCount;
1937 : : HASH_SEQ_STATUS scan_status;
1938 : : TrgmState *state;
1939 : : TrgmPackArcInfo *arcs;
1940 : : TrgmPackedArc *packedArcs;
1941 : : TrgmPackedGraph *result;
1942 : : int i,
1943 : : j;
1944 : :
1945 : : /* Enumerate surviving states, giving init and fin reserved numbers */
4533 1946 : 53 : hash_seq_init(&scan_status, trgmNFA->states);
1947 [ + + ]: 755 : while ((state = (TrgmState *) hash_seq_search(&scan_status)) != NULL)
1948 : : {
1949 [ + + ]: 971 : while (state->parent)
1950 : 322 : state = state->parent;
1951 : :
3067 1952 [ + + ]: 649 : if (state->snumber < 0)
1953 : : {
3118 1954 [ + + ]: 546 : if (state->flags & TSTATE_INIT)
3067 1955 : 53 : state->snumber = 0;
3118 1956 [ + + ]: 493 : else if (state->flags & TSTATE_FIN)
3067 1957 : 57 : state->snumber = 1;
1958 : : else
1959 : : {
1960 : 436 : state->snumber = snumber;
1961 : 436 : snumber++;
1962 : : }
1963 : : }
1964 : : }
1965 : :
1966 : : /* Collect array of all arcs */
1967 : : arcs = (TrgmPackArcInfo *)
4533 1968 : 53 : palloc(sizeof(TrgmPackArcInfo) * trgmNFA->arcsCount);
1969 : 53 : arcIndex = 0;
1970 : 53 : hash_seq_init(&scan_status, trgmNFA->states);
1971 [ + + ]: 702 : while ((state = (TrgmState *) hash_seq_search(&scan_status)) != NULL)
1972 : : {
1973 : 649 : TrgmState *source = state;
1974 : : ListCell *cell;
1975 : :
1976 [ + + ]: 971 : while (source->parent)
1977 : 322 : source = source->parent;
1978 : :
1979 [ + + + + : 1372 : foreach(cell, state->arcs)
+ + ]
1980 : : {
1981 : 723 : TrgmArc *arc = (TrgmArc *) lfirst(cell);
1982 : 723 : TrgmState *target = arc->target;
1983 : :
1984 [ + + ]: 1352 : while (target->parent)
1985 : 629 : target = target->parent;
1986 : :
3067 1987 [ + + ]: 723 : if (source->snumber != target->snumber)
1988 : : {
1989 : : ColorTrgmInfo *ctrgm;
1990 : :
4533 1991 : 566 : ctrgm = (ColorTrgmInfo *) bsearch(&arc->ctrgm,
1992 : 566 : trgmNFA->colorTrgms,
1993 : 566 : trgmNFA->colorTrgmsCount,
1994 : : sizeof(ColorTrgmInfo),
1995 : : colorTrgmInfoCmp);
1996 [ - + ]: 566 : Assert(ctrgm != NULL);
1997 [ - + ]: 566 : Assert(ctrgm->expanded);
1998 : :
3067 1999 : 566 : arcs[arcIndex].sourceState = source->snumber;
2000 : 566 : arcs[arcIndex].targetState = target->snumber;
2001 : 566 : arcs[arcIndex].colorTrgm = ctrgm->cnumber;
4533 2002 : 566 : arcIndex++;
2003 : : }
2004 : : }
2005 : : }
2006 : :
2007 : : /* Sort arcs to ease duplicate detection */
2008 : 53 : qsort(arcs, arcIndex, sizeof(TrgmPackArcInfo), packArcInfoCmp);
2009 : :
2010 : : /* We could have duplicates because states were merged. Remove them. */
910 2011 [ + + ]: 53 : if (arcIndex > 1)
2012 : : {
2013 : : /* p1 is probe point, p2 is last known non-duplicate. */
2014 : : TrgmPackArcInfo *p1,
2015 : : *p2;
2016 : :
2017 : 31 : p2 = arcs;
2018 [ + + ]: 546 : for (p1 = arcs + 1; p1 < arcs + arcIndex; p1++)
2019 : : {
2020 [ + + ]: 515 : if (packArcInfoCmp(p1, p2) > 0)
2021 : : {
2022 : 509 : p2++;
2023 : 509 : *p2 = *p1;
2024 : : }
2025 : : }
2026 : 31 : arcsCount = (p2 - arcs) + 1;
2027 : : }
2028 : : else
2029 : 22 : arcsCount = arcIndex;
2030 : :
2031 : : /* Create packed representation */
2032 : : result = (TrgmPackedGraph *)
4533 2033 : 53 : MemoryContextAlloc(rcontext, sizeof(TrgmPackedGraph));
2034 : :
2035 : : /* Pack color trigrams information */
2036 : 53 : result->colorTrigramsCount = 0;
2037 [ + + ]: 328 : for (i = 0; i < trgmNFA->colorTrgmsCount; i++)
2038 : : {
2039 [ + + ]: 275 : if (trgmNFA->colorTrgms[i].expanded)
2040 : 160 : result->colorTrigramsCount++;
2041 : : }
2042 : 53 : result->colorTrigramGroups = (int *)
2043 : 53 : MemoryContextAlloc(rcontext, sizeof(int) * result->colorTrigramsCount);
2044 : 53 : j = 0;
2045 [ + + ]: 328 : for (i = 0; i < trgmNFA->colorTrgmsCount; i++)
2046 : : {
2047 [ + + ]: 275 : if (trgmNFA->colorTrgms[i].expanded)
2048 : : {
2049 : 160 : result->colorTrigramGroups[j] = trgmNFA->colorTrgms[i].count;
2050 : 160 : j++;
2051 : : }
2052 : : }
2053 : :
2054 : : /* Pack states and arcs information */
3067 2055 : 53 : result->statesCount = snumber;
4533 2056 : 53 : result->states = (TrgmPackedState *)
3067 2057 : 53 : MemoryContextAlloc(rcontext, snumber * sizeof(TrgmPackedState));
2058 : : packedArcs = (TrgmPackedArc *)
4533 2059 : 53 : MemoryContextAlloc(rcontext, arcsCount * sizeof(TrgmPackedArc));
2060 : 53 : j = 0;
3067 2061 [ + + ]: 595 : for (i = 0; i < snumber; i++)
2062 : : {
4533 2063 : 542 : int cnt = 0;
2064 : :
2065 : 542 : result->states[i].arcs = &packedArcs[j];
2066 [ + + + + ]: 1102 : while (j < arcsCount && arcs[j].sourceState == i)
2067 : : {
2068 : 560 : packedArcs[j].targetState = arcs[j].targetState;
2069 : 560 : packedArcs[j].colorTrgm = arcs[j].colorTrgm;
2070 : 560 : cnt++;
2071 : 560 : j++;
2072 : : }
2073 : 542 : result->states[i].arcsCount = cnt;
2074 : : }
2075 : :
2076 : : /* Allocate working memory for trigramsMatchGraph() */
2077 : 53 : result->colorTrigramsActive = (bool *)
2078 : 53 : MemoryContextAlloc(rcontext, sizeof(bool) * result->colorTrigramsCount);
2079 : 53 : result->statesActive = (bool *)
2080 : 53 : MemoryContextAlloc(rcontext, sizeof(bool) * result->statesCount);
2081 : 53 : result->statesQueue = (int *)
2082 : 53 : MemoryContextAlloc(rcontext, sizeof(int) * result->statesCount);
2083 : :
2084 : 53 : return result;
2085 : : }
2086 : :
2087 : : /*
2088 : : * Comparison function for sorting TrgmPackArcInfos.
2089 : : *
2090 : : * Compares arcs in following order: sourceState, colorTrgm, targetState.
2091 : : */
2092 : : static int
2093 : 4546 : packArcInfoCmp(const void *a1, const void *a2)
2094 : : {
2095 : 4546 : const TrgmPackArcInfo *p1 = (const TrgmPackArcInfo *) a1;
2096 : 4546 : const TrgmPackArcInfo *p2 = (const TrgmPackArcInfo *) a2;
2097 : :
2098 [ + + ]: 4546 : if (p1->sourceState < p2->sourceState)
2099 : 2179 : return -1;
2100 [ + + ]: 2367 : if (p1->sourceState > p2->sourceState)
2101 : 2050 : return 1;
2102 [ + + ]: 317 : if (p1->colorTrgm < p2->colorTrgm)
2103 : 198 : return -1;
2104 [ + + ]: 119 : if (p1->colorTrgm > p2->colorTrgm)
2105 : 107 : return 1;
2106 [ - + ]: 12 : if (p1->targetState < p2->targetState)
4533 tgl@sss.pgh.pa.us 2107 :UBC 0 : return -1;
4533 tgl@sss.pgh.pa.us 2108 [ - + ]:CBC 12 : if (p1->targetState > p2->targetState)
4533 tgl@sss.pgh.pa.us 2109 :UBC 0 : return 1;
4533 tgl@sss.pgh.pa.us 2110 :CBC 12 : return 0;
2111 : : }
2112 : :
2113 : :
2114 : : /*---------------------
2115 : : * Debugging functions
2116 : : *
2117 : : * These are designed to emit GraphViz files.
2118 : : *---------------------
2119 : : */
2120 : :
2121 : : #ifdef TRGM_REGEXP_DEBUG
2122 : :
2123 : : /*
2124 : : * Print initial NFA, in regexp library's representation
2125 : : */
2126 : : static void
2127 : : printSourceNFA(regex_t *regex, TrgmColorInfo *colors, int ncolors)
2128 : : {
2129 : : StringInfoData buf;
2130 : : int nstates = pg_reg_getnumstates(regex);
2131 : : int state;
2132 : : int i;
2133 : :
2134 : : initStringInfo(&buf);
2135 : :
2136 : : appendStringInfoString(&buf, "\ndigraph sourceNFA {\n");
2137 : :
2138 : : for (state = 0; state < nstates; state++)
2139 : : {
2140 : : regex_arc_t *arcs;
2141 : : int i,
2142 : : arcsCount;
2143 : :
2144 : : appendStringInfo(&buf, "s%d", state);
2145 : : if (pg_reg_getfinalstate(regex) == state)
2146 : : appendStringInfoString(&buf, " [shape = doublecircle]");
2147 : : appendStringInfoString(&buf, ";\n");
2148 : :
2149 : : arcsCount = pg_reg_getnumoutarcs(regex, state);
2150 : : arcs = (regex_arc_t *) palloc(sizeof(regex_arc_t) * arcsCount);
2151 : : pg_reg_getoutarcs(regex, state, arcs, arcsCount);
2152 : :
2153 : : for (i = 0; i < arcsCount; i++)
2154 : : {
2155 : : appendStringInfo(&buf, " s%d -> s%d [label = \"%d\"];\n",
2156 : : state, arcs[i].to, arcs[i].co);
2157 : : }
2158 : :
2159 : : pfree(arcs);
2160 : : }
2161 : :
2162 : : appendStringInfoString(&buf, " node [shape = point ]; initial;\n");
2163 : : appendStringInfo(&buf, " initial -> s%d;\n",
2164 : : pg_reg_getinitialstate(regex));
2165 : :
2166 : : /* Print colors */
2167 : : appendStringInfoString(&buf, " { rank = sink;\n");
2168 : : appendStringInfoString(&buf, " Colors [shape = none, margin=0, label=<\n");
2169 : :
2170 : : for (i = 0; i < ncolors; i++)
2171 : : {
2172 : : TrgmColorInfo *color = &colors[i];
2173 : : int j;
2174 : :
2175 : : appendStringInfo(&buf, "<br/>Color %d: ", i);
2176 : : if (color->expandable)
2177 : : {
2178 : : for (j = 0; j < color->wordCharsCount; j++)
2179 : : {
2180 : : char s[MAX_MULTIBYTE_CHAR_LEN + 1];
2181 : :
2182 : : memcpy(s, color->wordChars[j].bytes, MAX_MULTIBYTE_CHAR_LEN);
2183 : : s[MAX_MULTIBYTE_CHAR_LEN] = '\0';
2184 : : appendStringInfoString(&buf, s);
2185 : : }
2186 : : }
2187 : : else
2188 : : appendStringInfoString(&buf, "not expandable");
2189 : : appendStringInfoChar(&buf, '\n');
2190 : : }
2191 : :
2192 : : appendStringInfoString(&buf, " >];\n");
2193 : : appendStringInfoString(&buf, " }\n");
2194 : : appendStringInfoString(&buf, "}\n");
2195 : :
2196 : : {
2197 : : /* dot -Tpng -o /tmp/source.png < /tmp/source.gv */
2198 : : FILE *fp = fopen("/tmp/source.gv", "w");
2199 : :
2200 : : fprintf(fp, "%s", buf.data);
2201 : : fclose(fp);
2202 : : }
2203 : :
2204 : : pfree(buf.data);
2205 : : }
2206 : :
2207 : : /*
2208 : : * Print expanded graph.
2209 : : */
2210 : : static void
2211 : : printTrgmNFA(TrgmNFA *trgmNFA)
2212 : : {
2213 : : StringInfoData buf;
2214 : : HASH_SEQ_STATUS scan_status;
2215 : : TrgmState *state;
2216 : : TrgmState *initstate = NULL;
2217 : :
2218 : : initStringInfo(&buf);
2219 : :
2220 : : appendStringInfoString(&buf, "\ndigraph transformedNFA {\n");
2221 : :
2222 : : hash_seq_init(&scan_status, trgmNFA->states);
2223 : : while ((state = (TrgmState *) hash_seq_search(&scan_status)) != NULL)
2224 : : {
2225 : : ListCell *cell;
2226 : :
2227 : : appendStringInfo(&buf, "s%d", -state->snumber);
2228 : : if (state->flags & TSTATE_FIN)
2229 : : appendStringInfoString(&buf, " [shape = doublecircle]");
2230 : : if (state->flags & TSTATE_INIT)
2231 : : initstate = state;
2232 : : appendStringInfo(&buf, " [label = \"%d\"]", state->stateKey.nstate);
2233 : : appendStringInfoString(&buf, ";\n");
2234 : :
2235 : : foreach(cell, state->arcs)
2236 : : {
2237 : : TrgmArc *arc = (TrgmArc *) lfirst(cell);
2238 : :
2239 : : appendStringInfo(&buf, " s%d -> s%d [label = \"",
2240 : : -state->snumber, -arc->target->snumber);
2241 : : printTrgmColor(&buf, arc->ctrgm.colors[0]);
2242 : : appendStringInfoChar(&buf, ' ');
2243 : : printTrgmColor(&buf, arc->ctrgm.colors[1]);
2244 : : appendStringInfoChar(&buf, ' ');
2245 : : printTrgmColor(&buf, arc->ctrgm.colors[2]);
2246 : : appendStringInfoString(&buf, "\"];\n");
2247 : : }
2248 : : }
2249 : :
2250 : : if (initstate)
2251 : : {
2252 : : appendStringInfoString(&buf, " node [shape = point ]; initial;\n");
2253 : : appendStringInfo(&buf, " initial -> s%d;\n", -initstate->snumber);
2254 : : }
2255 : :
2256 : : appendStringInfoString(&buf, "}\n");
2257 : :
2258 : : {
2259 : : /* dot -Tpng -o /tmp/transformed.png < /tmp/transformed.gv */
2260 : : FILE *fp = fopen("/tmp/transformed.gv", "w");
2261 : :
2262 : : fprintf(fp, "%s", buf.data);
2263 : : fclose(fp);
2264 : : }
2265 : :
2266 : : pfree(buf.data);
2267 : : }
2268 : :
2269 : : /*
2270 : : * Print a TrgmColor readably.
2271 : : */
2272 : : static void
2273 : : printTrgmColor(StringInfo buf, TrgmColor co)
2274 : : {
2275 : : if (co == COLOR_UNKNOWN)
2276 : : appendStringInfoChar(buf, 'u');
2277 : : else if (co == COLOR_BLANK)
2278 : : appendStringInfoChar(buf, 'b');
2279 : : else
2280 : : appendStringInfo(buf, "%d", (int) co);
2281 : : }
2282 : :
2283 : : /*
2284 : : * Print final packed representation of trigram-based expanded graph.
2285 : : */
2286 : : static void
2287 : : printTrgmPackedGraph(TrgmPackedGraph *packedGraph, TRGM *trigrams)
2288 : : {
2289 : : StringInfoData buf;
2290 : : trgm *p;
2291 : : int i;
2292 : :
2293 : : initStringInfo(&buf);
2294 : :
2295 : : appendStringInfoString(&buf, "\ndigraph packedGraph {\n");
2296 : :
2297 : : for (i = 0; i < packedGraph->statesCount; i++)
2298 : : {
2299 : : TrgmPackedState *state = &packedGraph->states[i];
2300 : : int j;
2301 : :
2302 : : appendStringInfo(&buf, " s%d", i);
2303 : : if (i == 1)
2304 : : appendStringInfoString(&buf, " [shape = doublecircle]");
2305 : :
2306 : : appendStringInfo(&buf, " [label = <s%d>];\n", i);
2307 : :
2308 : : for (j = 0; j < state->arcsCount; j++)
2309 : : {
2310 : : TrgmPackedArc *arc = &state->arcs[j];
2311 : :
2312 : : appendStringInfo(&buf, " s%d -> s%d [label = \"trigram %d\"];\n",
2313 : : i, arc->targetState, arc->colorTrgm);
2314 : : }
2315 : : }
2316 : :
2317 : : appendStringInfoString(&buf, " node [shape = point ]; initial;\n");
2318 : : appendStringInfo(&buf, " initial -> s%d;\n", 0);
2319 : :
2320 : : /* Print trigrams */
2321 : : appendStringInfoString(&buf, " { rank = sink;\n");
2322 : : appendStringInfoString(&buf, " Trigrams [shape = none, margin=0, label=<\n");
2323 : :
2324 : : p = GETARR(trigrams);
2325 : : for (i = 0; i < packedGraph->colorTrigramsCount; i++)
2326 : : {
2327 : : int count = packedGraph->colorTrigramGroups[i];
2328 : : int j;
2329 : :
2330 : : appendStringInfo(&buf, "<br/>Trigram %d: ", i);
2331 : :
2332 : : for (j = 0; j < count; j++)
2333 : : {
2334 : : if (j > 0)
2335 : : appendStringInfoString(&buf, ", ");
2336 : :
2337 : : /*
2338 : : * XXX This representation is nice only for all-ASCII trigrams.
2339 : : */
2340 : : appendStringInfo(&buf, "\"%c%c%c\"", (*p)[0], (*p)[1], (*p)[2]);
2341 : : p++;
2342 : : }
2343 : : }
2344 : :
2345 : : appendStringInfoString(&buf, " >];\n");
2346 : : appendStringInfoString(&buf, " }\n");
2347 : : appendStringInfoString(&buf, "}\n");
2348 : :
2349 : : {
2350 : : /* dot -Tpng -o /tmp/packed.png < /tmp/packed.gv */
2351 : : FILE *fp = fopen("/tmp/packed.gv", "w");
2352 : :
2353 : : fprintf(fp, "%s", buf.data);
2354 : : fclose(fp);
2355 : : }
2356 : :
2357 : : pfree(buf.data);
2358 : : }
2359 : :
2360 : : #endif /* TRGM_REGEXP_DEBUG */
|
