53ffd201f8adc46b8f7d64214606f816cb37abe5
[online_analyze.git] / online_analyze.c
1 /*
2  * Copyright (c) 2011 Teodor Sigaev <teodor@sigaev.ru>
3  * All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *              notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *              notice, this list of conditions and the following disclaimer in the
12  *              documentation and/or other materials provided with the distribution.
13  * 3. Neither the name of the author nor the names of any co-contributors
14  *              may be used to endorse or promote products derived from this software
15  *              without specific prior written permission.
16  *
17  * THIS SOFTWARE IS PROVIDED BY CONTRIBUTORS ``AS IS'' AND ANY EXPRESS
18  * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
19  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20  * ARE DISCLAIMED. IN NO EVENT SHALL CONTRIBUTORS BE LIABLE FOR ANY
21  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
23  * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
24  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
25  * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
26  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
27  * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28  */
29
30 #include "postgres.h"
31
32 #include "pgstat.h"
33 #include "access/transam.h"
34 #include "access/xact.h"
35 #include "catalog/namespace.h"
36 #include "commands/vacuum.h"
37 #include "executor/executor.h"
38 #include "nodes/nodes.h"
39 #include "nodes/parsenodes.h"
40 #include "storage/bufmgr.h"
41 #include "utils/builtins.h"
42 #include "utils/hsearch.h"
43 #include "utils/memutils.h"
44 #include "utils/lsyscache.h"
45 #include "utils/guc.h"
46 #if PG_VERSION_NUM >= 90200
47 #include "catalog/pg_class.h"
48 #include "nodes/primnodes.h"
49 #include "tcop/utility.h"
50 #include "utils/rel.h"
51 #include "utils/relcache.h"
52 #include "utils/timestamp.h"
53 #if PG_VERSION_NUM >= 90500
54 #include "nodes/makefuncs.h"
55 #if PG_VERSION_NUM >= 100000
56 #include "utils/varlena.h"
57 #include "utils/regproc.h"
58 #endif
59 #endif
60 #endif
61
62 #ifdef PG_MODULE_MAGIC
63 PG_MODULE_MAGIC;
64 #endif
65
66 static bool online_analyze_enable = true;
67 static bool online_analyze_local_tracking = false;
68 static bool online_analyze_verbose = true;
69 static double online_analyze_scale_factor = 0.1;
70 static int online_analyze_threshold = 50;
71 static int online_analyze_capacity_threshold = 100000;
72 static double online_analyze_min_interval = 10000;
73 static int online_analyze_lower_limit = 0;
74
75 static ExecutorEnd_hook_type oldExecutorEndHook = NULL;
76 #if PG_VERSION_NUM >= 90200
77 static ProcessUtility_hook_type oldProcessUtilityHook = NULL;
78 #endif
79
80 typedef enum CmdKind
81 {
82         CK_SELECT = CMD_SELECT,
83         CK_UPDATE = CMD_UPDATE,
84         CK_INSERT = CMD_INSERT,
85         CK_DELETE = CMD_DELETE,
86         CK_TRUNCATE,
87         CK_FASTTRUNCATE,
88         CK_CREATE,
89         CK_ANALYZE,
90         CK_VACUUM
91 } CmdKind;
92
93
94 typedef enum
95 {
96         OATT_ALL                = 0x03,
97         OATT_PERSISTENT = 0x01,
98         OATT_TEMPORARY  = 0x02,
99         OATT_NONE               = 0x00
100 } OnlineAnalyzeTableType;
101
102 static const struct config_enum_entry online_analyze_table_type_options[] =
103 {
104         {"all", OATT_ALL, false},
105         {"persistent", OATT_PERSISTENT, false},
106         {"temporary", OATT_TEMPORARY, false},
107         {"none", OATT_NONE, false},
108         {NULL, 0, false},
109 };
110
111 static int online_analyze_table_type = (int)OATT_ALL;
112
113 typedef struct TableList {
114         int             nTables;
115         Oid             *tables;
116         char    *tableStr;
117 } TableList;
118
119 static TableList excludeTables = {0, NULL, NULL};
120 static TableList includeTables = {0, NULL, NULL};
121
122 typedef struct OnlineAnalyzeTableStat {
123         Oid                             tableid;
124         bool                    rereadStat;
125         PgStat_Counter  n_tuples;
126         PgStat_Counter  changes_since_analyze;
127         TimestampTz             autovac_analyze_timestamp;
128         TimestampTz             analyze_timestamp;
129 } OnlineAnalyzeTableStat;
130
131 static  MemoryContext   onlineAnalyzeMemoryContext = NULL;
132 static  HTAB    *relstats = NULL;
133
134 static void relstatsInit(void);
135
136 #if PG_VERSION_NUM < 100000
137 static int
138 oid_cmp(const void *a, const void *b)
139 {
140         if (*(Oid*)a == *(Oid*)b)
141                 return 0;
142         return (*(Oid*)a > *(Oid*)b) ? 1 : -1;
143 }
144 #endif
145
146 static const char *
147 tableListAssign(const char * newval, bool doit, TableList *tbl)
148 {
149         char            *rawname;
150         List            *namelist;
151         ListCell        *l;
152         Oid                     *newOids = NULL;
153         int                     nOids = 0,
154                                 i = 0;
155
156         rawname = pstrdup(newval);
157
158         if (!SplitIdentifierString(rawname, ',', &namelist))
159                 goto cleanup;
160
161         if (doit)
162         {
163                 nOids = list_length(namelist);
164                 newOids = malloc(sizeof(Oid) * (nOids+1));
165                 if (!newOids)
166                         elog(ERROR,"could not allocate %d bytes",
167                                  (int)(sizeof(Oid) * (nOids+1)));
168         }
169
170         foreach(l, namelist)
171         {
172                 char    *curname = (char *) lfirst(l);
173 #if PG_VERSION_NUM >= 90200
174                 Oid             relOid = RangeVarGetRelid(makeRangeVarFromNameList(
175                                                         stringToQualifiedNameList(curname)), NoLock, true);
176 #else
177                 Oid             relOid = RangeVarGetRelid(makeRangeVarFromNameList(
178                                                         stringToQualifiedNameList(curname)), true);
179 #endif
180
181                 if (relOid == InvalidOid)
182                 {
183 #if PG_VERSION_NUM >= 90100
184                         if (doit == false)
185 #endif
186                         elog(WARNING,"'%s' does not exist", curname);
187                         continue;
188                 }
189                 else if ( get_rel_relkind(relOid) != RELKIND_RELATION )
190                 {
191 #if PG_VERSION_NUM >= 90100
192                         if (doit == false)
193 #endif
194                                 elog(WARNING,"'%s' is not an table", curname);
195                         continue;
196                 }
197                 else if (doit)
198                 {
199                         newOids[i++] = relOid;
200                 }
201         }
202
203         if (doit)
204         {
205                 tbl->nTables = i;
206                 if (tbl->tables)
207                         free(tbl->tables);
208                 tbl->tables = newOids;
209                 if (tbl->nTables > 1)
210                         qsort(tbl->tables, tbl->nTables, sizeof(tbl->tables[0]), oid_cmp);
211         }
212
213         pfree(rawname);
214         list_free(namelist);
215
216         return newval;
217
218 cleanup:
219         if (newOids)
220                 free(newOids);
221         pfree(rawname);
222         list_free(namelist);
223         return NULL;
224 }
225
226 #if PG_VERSION_NUM >= 90100
227 static bool
228 excludeTablesCheck(char **newval, void **extra, GucSource source)
229 {
230         char *val;
231
232         val = (char*)tableListAssign(*newval, false, &excludeTables);
233
234         if (val)
235         {
236                 *newval = val;
237                 return true;
238         }
239
240         return false;
241 }
242
243 static void
244 excludeTablesAssign(const char *newval, void *extra)
245 {
246         tableListAssign(newval, true, &excludeTables);
247 }
248
249 static bool
250 includeTablesCheck(char **newval, void **extra, GucSource source)
251 {
252         char *val;
253
254         val = (char*)tableListAssign(*newval, false, &includeTables);
255
256         if (val)
257         {
258                 *newval = val;
259                 return true;
260         }
261
262         return false;
263 }
264
265 static void
266 includeTablesAssign(const char *newval, void *extra)
267 {
268         tableListAssign(newval, true, &excludeTables);
269 }
270
271 #else /* PG_VERSION_NUM < 90100 */
272
273 static const char *
274 excludeTablesAssign(const char * newval, bool doit, GucSource source)
275 {
276         return tableListAssign(newval, doit, &excludeTables);
277 }
278
279 static const char *
280 includeTablesAssign(const char * newval, bool doit, GucSource source)
281 {
282         return tableListAssign(newval, doit, &includeTables);
283 }
284
285 #endif
286
287 static const char*
288 tableListShow(TableList *tbl)
289 {
290         char    *val, *ptr;
291         int             i,
292                         len;
293
294         len = 1 /* \0 */ + tbl->nTables * (2 * NAMEDATALEN + 2 /* ', ' */ + 1 /* . */);
295         ptr = val = palloc(len);
296         *ptr ='\0';
297         for(i=0; i<tbl->nTables; i++)
298         {
299                 char    *relname = get_rel_name(tbl->tables[i]);
300                 Oid             nspOid = get_rel_namespace(tbl->tables[i]);
301                 char    *nspname = get_namespace_name(nspOid);
302
303                 if ( relname == NULL || nspOid == InvalidOid || nspname == NULL )
304                         continue;
305
306                 ptr += snprintf(ptr, len - (ptr - val), "%s%s.%s",
307                                                                                                         (i==0) ? "" : ", ",
308                                                                                                         nspname, relname);
309         }
310
311         return val;
312 }
313
314 static const char*
315 excludeTablesShow(void)
316 {
317         return tableListShow(&excludeTables);
318 }
319
320 static const char*
321 includeTablesShow(void)
322 {
323         return tableListShow(&includeTables);
324 }
325
326 static bool
327 matchOid(TableList *tbl, Oid oid)
328 {
329         Oid     *StopLow = tbl->tables,
330                 *StopHigh = tbl->tables + tbl->nTables,
331                 *StopMiddle;
332
333         /* Loop invariant: StopLow <= val < StopHigh */
334         while (StopLow < StopHigh)
335         {
336                 StopMiddle = StopLow + ((StopHigh - StopLow) >> 1);
337
338                 if (*StopMiddle == oid)
339                         return true;
340                 else  if (*StopMiddle < oid)
341                         StopLow = StopMiddle + 1;
342                 else
343                         StopHigh = StopMiddle;
344         }
345
346         return false;
347 }
348
349 #if PG_VERSION_NUM >= 90500
350 static RangeVar*
351 makeRangeVarFromOid(Oid relOid)
352 {
353         return makeRangeVar(
354                                 get_namespace_name(get_rel_namespace(relOid)),
355                                 get_rel_name(relOid),
356                                 -1
357                         );
358
359 }
360 #endif
361
362 static void
363 makeAnalyze(Oid relOid, CmdKind operation, int64 naffected)
364 {
365         TimestampTz                             now = GetCurrentTimestamp();
366         Relation                                rel;
367         OnlineAnalyzeTableType  reltype;
368         bool                                    found = false,
369                                                         newTable = false;
370         OnlineAnalyzeTableStat  *rstat,
371                                                         dummyrstat;
372         PgStat_StatTabEntry             *tabentry = NULL;
373
374         if (relOid == InvalidOid)
375                 return;
376
377         if (naffected == 0)
378                 /* return if there is no changes */
379                 return;
380         else if (naffected < 0)
381                 /* number if affected rows is unknown */
382                 naffected = 0;
383
384         rel = RelationIdGetRelation(relOid);
385         if (rel->rd_rel->relkind != RELKIND_RELATION)
386         {
387                 RelationClose(rel);
388                 return;
389         }
390
391         reltype =
392 #if PG_VERSION_NUM >= 90100
393                 (rel->rd_rel->relpersistence == RELPERSISTENCE_TEMP)
394 #else
395                 (rel->rd_istemp || rel->rd_islocaltemp)
396 #endif
397                         ? OATT_TEMPORARY : OATT_PERSISTENT;
398
399         RelationClose(rel);
400
401         /*
402          * includeTables overwrites excludeTables
403          */
404         switch(online_analyze_table_type)
405         {
406                 case OATT_ALL:
407                         if (get_rel_relkind(relOid) != RELKIND_RELATION ||
408                                 (matchOid(&excludeTables, relOid) == true &&
409                                 matchOid(&includeTables, relOid) == false))
410                                 return;
411                         break;
412                 case OATT_NONE:
413                         if (get_rel_relkind(relOid) != RELKIND_RELATION ||
414                                 matchOid(&includeTables, relOid) == false)
415                                 return;
416                         break;
417                 case OATT_TEMPORARY:
418                 case OATT_PERSISTENT:
419                 default:
420                         /*
421                          * skip analyze if relation's type doesn't not match
422                          * online_analyze_table_type
423                          */
424                         if ((online_analyze_table_type & reltype) == 0 ||
425                                 matchOid(&excludeTables, relOid) == true)
426                         {
427                                 if (matchOid(&includeTables, relOid) == false)
428                                         return;
429                         }
430                         break;
431         }
432
433         /*
434          * Do not store data about persistent table in local memory because we
435          * could not track changes of them: they could be changed by another
436          * backends. So always get a pgstat table entry.
437          */
438         if (reltype == OATT_TEMPORARY)
439                 rstat = hash_search(relstats, &relOid, HASH_ENTER, &found);
440         else
441                 rstat = &dummyrstat; /* found == false for following if */
442
443         if (!found)
444         {
445                 MemSet(rstat, 0, sizeof(*rstat));
446                 rstat->tableid = relOid;
447                 newTable = true;
448         }
449         else if (operation == CK_VACUUM)
450         {
451                 /* force reread becouse vacuum could change n_tuples */
452                 rstat->rereadStat = true;
453                 return;
454         }
455         else if (operation == CK_ANALYZE)
456         {
457                 /* only analyze */
458                 rstat->changes_since_analyze = 0;
459                 rstat->analyze_timestamp = now;
460                 return;
461         }
462
463         Assert(rstat->tableid == relOid);
464
465         if (
466                 /* do not reread data if it was a truncation */
467                 operation != CK_TRUNCATE && operation != CK_FASTTRUNCATE &&
468                 /* read  for persistent table and for temp teble if it allowed */
469                 (reltype == OATT_PERSISTENT || online_analyze_local_tracking == false) &&
470                 /* read only for new table or we know that it's needed */
471                 (newTable == true || rstat->rereadStat == true)
472            )
473         {
474                 rstat->rereadStat = false;
475
476                 tabentry = pgstat_fetch_stat_tabentry(relOid);
477
478                 if (tabentry)
479                 {
480                         rstat->n_tuples = tabentry->n_dead_tuples + tabentry->n_live_tuples;
481                         rstat->changes_since_analyze =
482 #if PG_VERSION_NUM >= 90000
483                                 tabentry->changes_since_analyze;
484 #else
485                                 tabentry->n_live_tuples + tabentry->n_dead_tuples -
486                                         tabentry->last_anl_tuples;
487 #endif
488                         rstat->autovac_analyze_timestamp =
489                                 tabentry->autovac_analyze_timestamp;
490                         rstat->analyze_timestamp = tabentry->analyze_timestamp;
491                 }
492         }
493
494         if (newTable ||
495                 /* force analyze after truncate, fasttruncate already did analyze */
496                 operation == CK_TRUNCATE || (
497                 /* do not analyze too often, if both stamps are exceeded the go */
498                 TimestampDifferenceExceeds(rstat->analyze_timestamp, now, online_analyze_min_interval) &&
499                 TimestampDifferenceExceeds(rstat->autovac_analyze_timestamp, now, online_analyze_min_interval) &&
500                 /* do not analyze too small tables */
501                 rstat->n_tuples + rstat->changes_since_analyze + naffected > online_analyze_lower_limit &&
502                 /* be in sync with relation_needs_vacanalyze */
503                 ((double)(rstat->changes_since_analyze + naffected)) >=
504                          online_analyze_scale_factor * ((double)rstat->n_tuples) +
505                          (double)online_analyze_threshold))
506         {
507 #if PG_VERSION_NUM < 90500
508                 VacuumStmt                              vacstmt;
509 #else
510                 VacuumParams                    vacstmt;
511 #endif
512                 TimestampTz                             startStamp, endStamp;
513
514
515                 memset(&startStamp, 0, sizeof(startStamp)); /* keep compiler quiet */
516
517                 memset(&vacstmt, 0, sizeof(vacstmt));
518
519                 vacstmt.freeze_min_age = -1;
520                 vacstmt.freeze_table_age = -1; /* ??? */
521
522 #if PG_VERSION_NUM < 90500
523                 vacstmt.type = T_VacuumStmt;
524                 vacstmt.relation = NULL;
525                 vacstmt.va_cols = NIL;
526 #if PG_VERSION_NUM >= 90000
527                 vacstmt.options = VACOPT_ANALYZE;
528                 if (online_analyze_verbose)
529                         vacstmt.options |= VACOPT_VERBOSE;
530 #else
531                 vacstmt.vacuum = vacstmt.full = false;
532                 vacstmt.analyze = true;
533                 vacstmt.verbose = online_analyze_verbose;
534 #endif
535 #else
536                 vacstmt.multixact_freeze_min_age = -1;
537                 vacstmt.multixact_freeze_table_age = -1;
538                 vacstmt.log_min_duration = -1;
539 #endif
540
541                 if (online_analyze_verbose)
542                         startStamp = GetCurrentTimestamp();
543
544                 analyze_rel(relOid,
545 #if PG_VERSION_NUM < 90500
546                         &vacstmt
547 #if PG_VERSION_NUM >= 90018
548                         , true
549 #endif
550                         , GetAccessStrategy(BAS_VACUUM)
551 #if (PG_VERSION_NUM >= 90000) && (PG_VERSION_NUM < 90004)
552                         , true
553 #endif
554 #else
555                         makeRangeVarFromOid(relOid),
556                         VACOPT_ANALYZE | ((online_analyze_verbose) ? VACOPT_VERBOSE : 0),
557                         &vacstmt, NULL, true, GetAccessStrategy(BAS_VACUUM)
558 #endif
559                 );
560
561                 if (online_analyze_verbose)
562                 {
563                         long    secs;
564                         int             microsecs;
565
566                         endStamp = GetCurrentTimestamp();
567                         TimestampDifference(startStamp, endStamp, &secs, &microsecs);
568                         elog(INFO, "analyze \"%s\" took %.02f seconds",
569                                 get_rel_name(relOid),
570                                 ((double)secs) + ((double)microsecs)/1.0e6);
571                 }
572
573                 rstat->autovac_analyze_timestamp = now;
574                 rstat->changes_since_analyze = 0;
575
576                 switch(operation)
577                 {
578                         case CK_CREATE:
579                         case CK_INSERT:
580                         case CK_UPDATE:
581                                 rstat->n_tuples += naffected;
582                         case CK_DELETE:
583                                 rstat->rereadStat = (reltype == OATT_PERSISTENT);
584                                 break;
585                         case CK_TRUNCATE:
586                         case CK_FASTTRUNCATE:
587                                 rstat->rereadStat = false;
588                                 rstat->n_tuples = 0;
589                                 break;
590                         default:
591                                 break;
592                 }
593
594                 /* update last analyze timestamp in local memory of backend */
595                 if (tabentry)
596                 {
597                         tabentry->analyze_timestamp = now;
598                         tabentry->changes_since_analyze = 0;
599                 }
600 #if 0
601                 /* force reload stat for new table */
602                 if (newTable)
603                         pgstat_clear_snapshot();
604 #endif
605         }
606         else
607         {
608 #if PG_VERSION_NUM >= 90000
609                 if (tabentry)
610                         tabentry->changes_since_analyze += naffected;
611 #endif
612                 switch(operation)
613                 {
614                         case CK_CREATE:
615                         case CK_INSERT:
616                                 rstat->changes_since_analyze += naffected;
617                                 rstat->n_tuples += naffected;
618                                 break;
619                         case CK_UPDATE:
620                                 rstat->changes_since_analyze += 2 * naffected;
621                                 rstat->n_tuples += naffected;
622                         case CK_DELETE:
623                                 rstat->changes_since_analyze += naffected;
624                                 break;
625                         case CK_TRUNCATE:
626                         case CK_FASTTRUNCATE:
627                                 rstat->changes_since_analyze = 0;
628                                 rstat->n_tuples = 0;
629                                 break;
630                         default:
631                                 break;
632                 }
633         }
634
635         /* Reset local cache if we are over limit */
636         if (hash_get_num_entries(relstats) > online_analyze_capacity_threshold)
637                 relstatsInit();
638 }
639
640 static Const*
641 isFastTruncateCall(QueryDesc *queryDesc)
642 {
643         TargetEntry     *te;
644         FuncExpr        *fe;
645         Const           *constval;
646
647         if (!(
648                   queryDesc->plannedstmt &&
649                   queryDesc->operation == CMD_SELECT &&
650                   queryDesc->plannedstmt->planTree &&
651                   queryDesc->plannedstmt->planTree->targetlist &&
652                   list_length(queryDesc->plannedstmt->planTree->targetlist) == 1
653                  ))
654                 return NULL;
655
656         te = linitial(queryDesc->plannedstmt->planTree->targetlist);
657
658         if (!IsA(te, TargetEntry))
659                 return NULL;
660
661         fe = (FuncExpr*)te->expr;
662
663         if (!(
664                   fe && IsA(fe, FuncExpr) &&
665                   fe->funcid >= FirstNormalObjectId &&
666                   fe->funcretset == false &&
667                   fe->funcresulttype == VOIDOID &&
668                   fe->funcvariadic == false &&
669                   list_length(fe->args) == 1
670                  ))
671                 return NULL;
672
673         constval = linitial(fe->args);
674
675         if (!(
676                   IsA(constval,Const) &&
677                   constval->consttype == TEXTOID &&
678                   strcmp(get_func_name(fe->funcid), "fasttruncate") == 0
679                  ))
680                 return NULL;
681
682         return constval;
683 }
684
685
686 extern PGDLLIMPORT void onlineAnalyzeHooker(QueryDesc *queryDesc);
687 void
688 onlineAnalyzeHooker(QueryDesc *queryDesc)
689 {
690         int64   naffected = -1;
691         Const   *constval;
692
693         if (queryDesc->estate)
694                 naffected = queryDesc->estate->es_processed;
695
696 #if PG_VERSION_NUM >= 90200
697         if (online_analyze_enable &&
698                 (constval = isFastTruncateCall(queryDesc)) != NULL)
699         {
700                 Datum           tblnamed = constval->constvalue;
701                 char            *tblname = text_to_cstring(DatumGetTextP(tblnamed));
702                 RangeVar        *tblvar =
703                         makeRangeVarFromNameList(stringToQualifiedNameList(tblname));
704
705                 makeAnalyze(RangeVarGetRelid(tblvar,
706                                                                          NoLock,
707                                                                          false),
708                                         CK_FASTTRUNCATE, -1);
709         }
710 #endif
711
712         if (online_analyze_enable && queryDesc->plannedstmt &&
713                         (queryDesc->operation == CMD_INSERT ||
714                          queryDesc->operation == CMD_UPDATE ||
715                          queryDesc->operation == CMD_DELETE
716 #if PG_VERSION_NUM < 90200
717                          || (queryDesc->operation == CMD_SELECT &&
718                                  queryDesc->plannedstmt->intoClause)
719 #endif
720                          ))
721         {
722 #if PG_VERSION_NUM < 90200
723                 if (queryDesc->operation == CMD_SELECT)
724                 {
725                         Oid     relOid = RangeVarGetRelid(queryDesc->plannedstmt->intoClause->rel, true);
726
727                         makeAnalyze(relOid, queryDesc->operation, naffected);
728                 }
729                 else
730 #endif
731                 if (queryDesc->plannedstmt->resultRelations &&
732                                  queryDesc->plannedstmt->rtable)
733                 {
734                         ListCell        *l;
735
736                         foreach(l, queryDesc->plannedstmt->resultRelations)
737                         {
738                                 int                             n = lfirst_int(l);
739                                 RangeTblEntry   *rte = list_nth(queryDesc->plannedstmt->rtable, n-1);
740
741                                 if (rte->rtekind == RTE_RELATION)
742                                         makeAnalyze(rte->relid, (CmdKind)queryDesc->operation, naffected);
743                         }
744                 }
745         }
746
747         if (oldExecutorEndHook)
748                 oldExecutorEndHook(queryDesc);
749         else
750                 standard_ExecutorEnd(queryDesc);
751 }
752
753 static List             *toremove = NIL;
754
755 /*
756  * removeTable called on transaction end, see call RegisterXactCallback() below
757  */
758 static void
759 removeTable(XactEvent event, void *arg)
760 {
761         ListCell        *cell;
762
763         switch(event)
764         {
765                 case XACT_EVENT_COMMIT:
766                         break;
767                 case XACT_EVENT_ABORT:
768                         toremove = NIL;
769                 default:
770                         return;
771         }
772
773         foreach(cell, toremove)
774         {
775                 Oid     relOid = lfirst_oid(cell);
776
777                 hash_search(relstats, &relOid, HASH_REMOVE, NULL);
778         }
779
780         toremove = NIL;
781 }
782
783
784 #if PG_VERSION_NUM >= 90200
785 static void
786 onlineAnalyzeHookerUtility(
787 #if PG_VERSION_NUM >= 100000
788                                                    PlannedStmt *pstmt,
789 #else
790                                                    Node *parsetree,
791 #endif
792                                                    const char *queryString,
793 #if PG_VERSION_NUM >= 90300
794                                                         ProcessUtilityContext context, ParamListInfo params,
795 #if PG_VERSION_NUM >= 100000
796                                                         QueryEnvironment *queryEnv,
797 #endif
798 #else
799                                                         ParamListInfo params, bool isTopLevel,
800 #endif
801                                                         DestReceiver *dest, char *completionTag) {
802         List            *tblnames = NIL;
803         CmdKind         op = CK_INSERT;
804 #if PG_VERSION_NUM >= 100000
805         Node            *parsetree = NULL;
806
807         if (pstmt->commandType == CMD_UTILITY)
808                 parsetree = pstmt->utilityStmt;
809 #endif
810
811         if (parsetree && online_analyze_enable)
812         {
813                 if (IsA(parsetree, CreateTableAsStmt) &&
814                         ((CreateTableAsStmt*)parsetree)->into)
815                 {
816                         tblnames =
817                                 list_make1((RangeVar*)copyObject(((CreateTableAsStmt*)parsetree)->into->rel));
818                         op = CK_CREATE;
819                 }
820                 else if (IsA(parsetree, TruncateStmt))
821                 {
822                         tblnames = list_copy(((TruncateStmt*)parsetree)->relations);
823                         op = CK_TRUNCATE;
824                 }
825                 else if (IsA(parsetree, DropStmt) &&
826                                  ((DropStmt*)parsetree)->removeType == OBJECT_TABLE)
827                 {
828                         ListCell        *cell;
829
830                         foreach(cell, ((DropStmt*)parsetree)->objects)
831                         {
832                                 List            *relname = (List *) lfirst(cell);
833                                 RangeVar        *rel = makeRangeVarFromNameList(relname);
834                                 Oid                     relOid = RangeVarGetRelid(rel, NoLock, true);
835
836                                 if (OidIsValid(relOid))
837                                 {
838                                         MemoryContext   ctx;
839
840                                         ctx = MemoryContextSwitchTo(TopTransactionContext);
841                                         toremove = lappend_oid(toremove, relOid);
842                                         MemoryContextSwitchTo(ctx);
843                                 }
844                         }
845                 }
846                 else if (IsA(parsetree, VacuumStmt))
847                 {
848                         VacuumStmt      *vac = (VacuumStmt*)parsetree;
849
850                         tblnames = list_make1(vac->relation);
851
852                         if (vac->options & (VACOPT_VACUUM | VACOPT_FULL | VACOPT_FREEZE))
853                                 /* optionally with analyze */
854                                 op = CK_VACUUM;
855                         else if (vac->options & VACOPT_ANALYZE)
856                                 op = CK_ANALYZE;
857                         else
858                                 tblnames = NIL;
859                 }
860         }
861
862 #if PG_VERSION_NUM >= 100000
863 #define parsetree pstmt
864 #endif
865
866         if (oldProcessUtilityHook)
867                 oldProcessUtilityHook(parsetree, queryString,
868 #if PG_VERSION_NUM >= 90300
869                                                           context, params,
870 #if PG_VERSION_NUM >= 100000
871                                                           queryEnv,
872 #endif
873 #else
874                                                           params, isTopLevel,
875 #endif
876                                                           dest, completionTag);
877         else
878                 standard_ProcessUtility(parsetree, queryString,
879 #if PG_VERSION_NUM >= 90300
880                                                                 context, params,
881 #if PG_VERSION_NUM >= 100000
882                                                                 queryEnv,
883 #endif
884 #else
885                                                                 params, isTopLevel,
886 #endif
887                                                                 dest, completionTag);
888
889 #if PG_VERSION_NUM >= 100000
890 #undef parsetree
891 #endif
892
893         if (tblnames) {
894                 ListCell        *l;
895
896                 foreach(l, tblnames)
897                 {
898                         RangeVar        *tblname = (RangeVar*)lfirst(l);
899                         Oid     tblOid = RangeVarGetRelid(tblname, NoLock, true);
900
901                         makeAnalyze(tblOid, op, -1);
902                 }
903         }
904 }
905 #endif
906
907 static void
908 relstatsInit(void)
909 {
910         HASHCTL hash_ctl;
911         int             flags = 0;
912
913         MemSet(&hash_ctl, 0, sizeof(hash_ctl));
914
915         hash_ctl.hash = oid_hash;
916         flags |= HASH_FUNCTION;
917
918         if (onlineAnalyzeMemoryContext)
919         {
920                 Assert(relstats != NULL);
921                 MemoryContextReset(onlineAnalyzeMemoryContext);
922         }
923         else
924         {
925                 Assert(relstats == NULL);
926                 onlineAnalyzeMemoryContext =
927                         AllocSetContextCreate(CacheMemoryContext,
928                                                                   "online_analyze storage context",
929 #if PG_VERSION_NUM < 90600
930                                                                   ALLOCSET_DEFAULT_MINSIZE,
931                                                                   ALLOCSET_DEFAULT_INITSIZE,
932                                                                   ALLOCSET_DEFAULT_MAXSIZE
933 #else
934                                                                   ALLOCSET_DEFAULT_SIZES
935 #endif
936                                                                  );
937         }
938
939         hash_ctl.hcxt = onlineAnalyzeMemoryContext;
940         flags |= HASH_CONTEXT;
941
942         hash_ctl.keysize = sizeof(Oid);
943
944         hash_ctl.entrysize = sizeof(OnlineAnalyzeTableStat);
945         flags |= HASH_ELEM;
946
947         relstats = hash_create("online_analyze storage", 1024, &hash_ctl, flags);
948 }
949
950 void _PG_init(void);
951 void
952 _PG_init(void)
953 {
954         relstatsInit();
955
956         oldExecutorEndHook = ExecutorEnd_hook;
957
958         ExecutorEnd_hook = onlineAnalyzeHooker;
959
960 #if PG_VERSION_NUM >= 90200
961         oldProcessUtilityHook = ProcessUtility_hook;
962
963         ProcessUtility_hook = onlineAnalyzeHookerUtility;
964 #endif
965
966
967         DefineCustomBoolVariable(
968                 "online_analyze.enable",
969                 "Enable on-line analyze",
970                 "Enables analyze of table directly after insert/update/delete/select into",
971                 &online_analyze_enable,
972 #if PG_VERSION_NUM >= 80400
973                 online_analyze_enable,
974 #endif
975                 PGC_USERSET,
976 #if PG_VERSION_NUM >= 80400
977                 GUC_NOT_IN_SAMPLE,
978 #if PG_VERSION_NUM >= 90100
979                 NULL,
980 #endif
981 #endif
982                 NULL,
983                 NULL
984         );
985
986         DefineCustomBoolVariable(
987                 "online_analyze.local_tracking",
988                 "Per backend tracking",
989                 "Per backend tracking for temp tables (do not use system statistic)",
990                 &online_analyze_local_tracking,
991 #if PG_VERSION_NUM >= 80400
992                 online_analyze_local_tracking,
993 #endif
994                 PGC_USERSET,
995 #if PG_VERSION_NUM >= 80400
996                 GUC_NOT_IN_SAMPLE,
997 #if PG_VERSION_NUM >= 90100
998                 NULL,
999 #endif
1000 #endif
1001                 NULL,
1002                 NULL
1003         );
1004
1005         DefineCustomBoolVariable(
1006                 "online_analyze.verbose",
1007                 "Verbosity of on-line analyze",
1008                 "Make ANALYZE VERBOSE after table's changes",
1009                 &online_analyze_verbose,
1010 #if PG_VERSION_NUM >= 80400
1011                 online_analyze_verbose,
1012 #endif
1013                 PGC_USERSET,
1014 #if PG_VERSION_NUM >= 80400
1015                 GUC_NOT_IN_SAMPLE,
1016 #if PG_VERSION_NUM >= 90100
1017                 NULL,
1018 #endif
1019 #endif
1020                 NULL,
1021                 NULL
1022         );
1023
1024         DefineCustomRealVariable(
1025                 "online_analyze.scale_factor",
1026                 "fraction of table size to start on-line analyze",
1027                 "fraction of table size to start on-line analyze",
1028                 &online_analyze_scale_factor,
1029 #if PG_VERSION_NUM >= 80400
1030                 online_analyze_scale_factor,
1031 #endif
1032                 0.0,
1033                 1.0,
1034                 PGC_USERSET,
1035 #if PG_VERSION_NUM >= 80400
1036                 GUC_NOT_IN_SAMPLE,
1037 #if PG_VERSION_NUM >= 90100
1038                 NULL,
1039 #endif
1040 #endif
1041                 NULL,
1042                 NULL
1043         );
1044
1045         DefineCustomIntVariable(
1046                 "online_analyze.threshold",
1047                 "min number of row updates before on-line analyze",
1048                 "min number of row updates before on-line analyze",
1049                 &online_analyze_threshold,
1050 #if PG_VERSION_NUM >= 80400
1051                 online_analyze_threshold,
1052 #endif
1053                 0,
1054                 0x7fffffff,
1055                 PGC_USERSET,
1056 #if PG_VERSION_NUM >= 80400
1057                 GUC_NOT_IN_SAMPLE,
1058 #if PG_VERSION_NUM >= 90100
1059                 NULL,
1060 #endif
1061 #endif
1062                 NULL,
1063                 NULL
1064         );
1065
1066         DefineCustomIntVariable(
1067                 "online_analyze.capacity_threshold",
1068                 "Max local cache table capacity",
1069                 "Max local cache table capacity",
1070                 &online_analyze_capacity_threshold,
1071 #if PG_VERSION_NUM >= 80400
1072                 online_analyze_capacity_threshold,
1073 #endif
1074                 0,
1075                 0x7fffffff,
1076                 PGC_USERSET,
1077 #if PG_VERSION_NUM >= 80400
1078                 GUC_NOT_IN_SAMPLE,
1079 #if PG_VERSION_NUM >= 90100
1080                 NULL,
1081 #endif
1082 #endif
1083                 NULL,
1084                 NULL
1085         );
1086
1087         DefineCustomRealVariable(
1088                 "online_analyze.min_interval",
1089                 "minimum time interval between analyze call (in milliseconds)",
1090                 "minimum time interval between analyze call (in milliseconds)",
1091                 &online_analyze_min_interval,
1092 #if PG_VERSION_NUM >= 80400
1093                 online_analyze_min_interval,
1094 #endif
1095                 0.0,
1096                 1e30,
1097                 PGC_USERSET,
1098 #if PG_VERSION_NUM >= 80400
1099                 GUC_NOT_IN_SAMPLE,
1100 #if PG_VERSION_NUM >= 90100
1101                 NULL,
1102 #endif
1103 #endif
1104                 NULL,
1105                 NULL
1106         );
1107
1108         DefineCustomEnumVariable(
1109                 "online_analyze.table_type",
1110                 "Type(s) of table for online analyze: all(default), persistent, temporary, none",
1111                 NULL,
1112                 &online_analyze_table_type,
1113 #if PG_VERSION_NUM >= 80400
1114                 online_analyze_table_type,
1115 #endif
1116                 online_analyze_table_type_options,
1117                 PGC_USERSET,
1118 #if PG_VERSION_NUM >= 80400
1119                 GUC_NOT_IN_SAMPLE,
1120 #if PG_VERSION_NUM >= 90100
1121                 NULL,
1122 #endif
1123 #endif
1124                 NULL,
1125                 NULL
1126         );
1127
1128         DefineCustomStringVariable(
1129                 "online_analyze.exclude_tables",
1130                 "List of tables which will not online analyze",
1131                 NULL,
1132                 &excludeTables.tableStr,
1133 #if PG_VERSION_NUM >= 80400
1134                 "",
1135 #endif
1136                 PGC_USERSET,
1137                 0,
1138 #if PG_VERSION_NUM >= 90100
1139                 excludeTablesCheck,
1140                 excludeTablesAssign,
1141 #else
1142                 excludeTablesAssign,
1143 #endif
1144                 excludeTablesShow
1145         );
1146
1147         DefineCustomStringVariable(
1148                 "online_analyze.include_tables",
1149                 "List of tables which will online analyze",
1150                 NULL,
1151                 &includeTables.tableStr,
1152 #if PG_VERSION_NUM >= 80400
1153                 "",
1154 #endif
1155                 PGC_USERSET,
1156                 0,
1157 #if PG_VERSION_NUM >= 90100
1158                 includeTablesCheck,
1159                 includeTablesAssign,
1160 #else
1161                 includeTablesAssign,
1162 #endif
1163                 includeTablesShow
1164         );
1165
1166         DefineCustomIntVariable(
1167                 "online_analyze.lower_limit",
1168                 "min number of rows in table to analyze",
1169                 "min number of rows in table to analyze",
1170                 &online_analyze_lower_limit,
1171 #if PG_VERSION_NUM >= 80400
1172                 online_analyze_lower_limit,
1173 #endif
1174                 0,
1175                 0x7fffffff,
1176                 PGC_USERSET,
1177 #if PG_VERSION_NUM >= 80400
1178                 GUC_NOT_IN_SAMPLE,
1179 #if PG_VERSION_NUM >= 90100
1180                 NULL,
1181 #endif
1182 #endif
1183                 NULL,
1184                 NULL
1185         );
1186
1187         RegisterXactCallback(removeTable, NULL);
1188 }
1189
1190 void _PG_fini(void);
1191 void
1192 _PG_fini(void)
1193 {
1194         ExecutorEnd_hook = oldExecutorEndHook;
1195 #if PG_VERSION_NUM >= 90200
1196         ProcessUtility_hook = oldProcessUtilityHook;
1197 #endif
1198
1199         if (excludeTables.tables)
1200                 free(excludeTables.tables);
1201         if (includeTables.tables)
1202                 free(includeTables.tables);
1203
1204         excludeTables.tables = includeTables.tables = NULL;
1205         excludeTables.nTables = includeTables.nTables = 0;
1206 }