X-Git-Url: http://sigaev.ru/git/gitweb.cgi?p=plantuner.git;a=blobdiff_plain;f=plantuner.c;h=5ef74dd9fe38414a83c2ebf80c6cb1e8d1ddc7ab;hp=4e0f0c598b2abca7b9b933bd9427b528affb3f77;hb=9e19c8ca1864564ba32ac238da9ace5cc561418d;hpb=176da910e8225a413bac8992e650507f10f9b9d1 diff --git a/plantuner.c b/plantuner.c index 4e0f0c5..5ef74dd 100644 --- a/plantuner.c +++ b/plantuner.c @@ -1,28 +1,62 @@ /* * Copyright (c) 2009 Teodor Sigaev + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of the author nor the names of any co-contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY CONTRIBUTORS ``AS IS'' AND ANY EXPRESS + * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL CONTRIBUTORS BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE + * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER + * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR + * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN + * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #include #include +#include #include #include #include #include +#include #include #include #include +#include PG_MODULE_MAGIC; -static int nIndexesOut = 0; -static Oid *indexesOut = NULL; +static int nDisabledIndexes = 0; +static Oid *disabledIndexes = NULL; +static char *disableIndexesOutStr = ""; + +static int nEnabledIndexes = 0; +static Oid *enabledIndexes = NULL; +static char *enableIndexesOutStr = ""; + get_relation_info_hook_type prevHook = NULL; +static bool fix_empty_table = false; -static char *indexesOutStr = ""; static const char * -indexesOutAssign(const char * newval, bool doit, GucSource source) +indexesAssign(const char * newval, bool doit, GucSource source, bool isDisable) { char *rawname; List *namelist; @@ -41,22 +75,32 @@ indexesOutAssign(const char * newval, bool doit, GucSource source) nOids = list_length(namelist); newOids = malloc(sizeof(Oid) * (nOids+1)); if (!newOids) - elog(ERROR,"could not allocate %d bytes", sizeof(Oid) * (nOids+1)); + elog(ERROR,"could not allocate %d bytes", (int)(sizeof(Oid) * (nOids+1))); } foreach(l, namelist) { char *curname = (char *) lfirst(l); - Oid indexOid = RangeVarGetRelid(makeRangeVarFromNameList(stringToQualifiedNameList(curname)), true); + Oid indexOid = RangeVarGetRelid(makeRangeVarFromNameList(stringToQualifiedNameList(curname)), +#if PG_VERSION_NUM >= 90200 + NoLock, +#endif + true); if (indexOid == InvalidOid) { - elog(WARNING,"'%s' does not exist", curname); +#if PG_VERSION_NUM >= 90100 + if (doit == false) +#endif + elog(WARNING,"'%s' does not exist", curname); continue; } else if ( get_rel_relkind(indexOid) != RELKIND_INDEX ) { - elog(WARNING,"'%s' is not an index", curname); +#if PG_VERSION_NUM >= 90100 + if (doit == false) +#endif + elog(WARNING,"'%s' is not an index", curname); continue; } else if (doit) @@ -67,8 +111,16 @@ indexesOutAssign(const char * newval, bool doit, GucSource source) if (doit) { - nIndexesOut = nOids; - indexesOut = newOids; + if (isDisable) + { + nDisabledIndexes = nOids; + disabledIndexes = newOids; + } + else + { + nEnabledIndexes = nOids; + enabledIndexes = newOids; + } } pfree(rawname); @@ -84,12 +136,71 @@ cleanup: return NULL; } +static const char * +assignDisabledIndexes(const char * newval, bool doit, GucSource source) +{ + return indexesAssign(newval, doit, source, true); +} + +static const char * +assignEnabledIndexes(const char * newval, bool doit, GucSource source) +{ + return indexesAssign(newval, doit, source, false); +} + +#if PG_VERSION_NUM >= 90100 + +static bool +checkDisabledIndexes(char **newval, void **extra, GucSource source) +{ + char *val; + + val = (char*)indexesAssign(*newval, false, source, true); + + if (val) + { + *newval = val; + return true; + } + + return false; +} + +static bool +checkEnabledIndexes(char **newval, void **extra, GucSource source) +{ + char *val; + + val = (char*)indexesAssign(*newval, false, source, false); + + if (val) + { + *newval = val; + return true; + } + + return false; +} + +static void +assignDisabledIndexesNew(const char *newval, void *extra) +{ + assignDisabledIndexes(newval, true, PGC_S_USER /* doesn't matter */); +} + +static void +assignEnabledIndexesNew(const char *newval, void *extra) +{ + assignEnabledIndexes(newval, true, PGC_S_USER /* doesn't matter */); +} + +#endif static void indexFilter(PlannerInfo *root, Oid relationObjectId, bool inhparent, RelOptInfo *rel) { int i; - for(i=0;iindexoid) + if (disabledIndexes[i] == info->indexoid) { - rel->indexlist = list_delete_ptr(rel->indexlist, info); + int j; + + for(j=0; jindexoid) + break; + + if (j >= nEnabledIndexes) + rel->indexlist = list_delete_ptr(rel->indexlist, info); + break; } } } + if (fix_empty_table && rel) + { + + + } + +} + +static void +execPlantuner(PlannerInfo *root, Oid relationObjectId, bool inhparent, RelOptInfo *rel) { + Relation relation; + + relation = heap_open(relationObjectId, NoLock); + if (relation->rd_rel->relkind == RELKIND_RELATION) + { + if (fix_empty_table && RelationGetNumberOfBlocks(relation) == 0) + { + /* + * estimate_rel_size() could be too pessimistic for particular + * workload + */ + rel->pages = 0.0; + rel->tuples = 0.0; + } + + indexFilter(root, relationObjectId, inhparent, rel); + } + heap_close(relation, NoLock); + /* * Call next hook if it exists */ @@ -113,20 +261,20 @@ indexFilter(PlannerInfo *root, Oid relationObjectId, bool inhparent, RelOptInfo } static const char* -IndexFilterShow(void) +IndexFilterShow(Oid* indexes, int nIndexes) { char *val, *ptr; int i, len; - len = 1 /* \0 */ + nIndexesOut * (2 * NAMEDATALEN + 2 /* ', ' */ + 1 /* . */); + len = 1 /* \0 */ + nIndexes * (2 * NAMEDATALEN + 2 /* ', ' */ + 1 /* . */); ptr = val = palloc(len); *ptr ='\0'; - for(i=0; i= 90100 + checkDisabledIndexes, + assignDisabledIndexesNew, +#else + assignDisabledIndexes, +#endif + disabledIndexFilterShow + ); + + DefineCustomStringVariable( + "plantuner.disable_index", + "List of disabled indexes", "Listed indexes will not be used in queries", - &indexesOutStr, + &disableIndexesOutStr, "", PGC_USERSET, 0, - indexesOutAssign, - IndexFilterShow +#if PG_VERSION_NUM >= 90100 + checkDisabledIndexes, + assignDisabledIndexesNew, +#else + assignDisabledIndexes, +#endif + disabledIndexFilterShow + ); + + DefineCustomStringVariable( + "plantuner.enable_index", + "List of enabled indexes (overload plantuner.disable_index)", + "Listed indexes which could be used in queries even they are listed in plantuner.disable_index", + &enableIndexesOutStr, + "", + PGC_USERSET, + 0, +#if PG_VERSION_NUM >= 90100 + checkEnabledIndexes, + assignEnabledIndexesNew, +#else + assignEnabledIndexes, +#endif + enabledIndexFilterShow + ); + + DefineCustomBoolVariable( + "plantuner.fix_empty_table", + "Sets to zero estimations for empty tables", + "Sets to zero estimations for empty or newly created tables", + &fix_empty_table, +#if PG_VERSION_NUM >= 80400 + fix_empty_table, +#endif + PGC_USERSET, +#if PG_VERSION_NUM >= 80400 + GUC_NOT_IN_SAMPLE, +#if PG_VERSION_NUM >= 90100 + NULL, +#endif +#endif + NULL, + NULL ); - if (get_relation_info_hook != indexFilter ) + if (get_relation_info_hook != execPlantuner ) { prevHook = get_relation_info_hook; - get_relation_info_hook = indexFilter; + get_relation_info_hook = execPlantuner; } }