#include "catalog/catalog.h"
#include "catalog/index.h"
#include "catalog/indexing.h"
+#include "catalog/namespace.h"
#include "catalog/pg_collation.h"
#include "catalog/pg_inherits_fn.h"
#include "catalog/pg_namespace.h"
heap_close(sd, RowExclusiveLock);
}
+/*
+ * update_ext_stats() -- update extended statistics
+ */
+static void
+update_ext_stats(Name nspname, Name name,
+ bytea *ndistinct, bytea *dependencies)
+{
+ Oid nspoid;
+ Relation sd;
+ HeapTuple stup,
+ oldtup;
+ int i;
+ Datum values[Natts_pg_statistic_ext];
+ bool nulls[Natts_pg_statistic_ext];
+ bool replaces[Natts_pg_statistic_ext];
+
+ nspoid = get_namespace_oid(NameStr(*nspname), false);
+
+ sd = heap_open(StatisticExtRelationId, RowExclusiveLock);
+
+ /*
+ * Construct a new pg_statistic_ext tuple
+ */
+ for (i = 0; i < Natts_pg_statistic_ext; ++i)
+ {
+ nulls[i] = false;
+ replaces[i] = false;
+ }
+
+ replaces[Anum_pg_statistic_ext_stxndistinct - 1] = true;
+ replaces[Anum_pg_statistic_ext_stxdependencies - 1] = true;
+
+ /* ndistinct */
+ if (ndistinct)
+ values[Anum_pg_statistic_ext_stxndistinct - 1] = PointerGetDatum(ndistinct);
+ else
+ nulls[Anum_pg_statistic_ext_stxndistinct - 1] = true;
+
+ /* dependencies */
+ if (dependencies)
+ values[Anum_pg_statistic_ext_stxdependencies - 1] = PointerGetDatum(dependencies);
+ else
+ nulls[Anum_pg_statistic_ext_stxdependencies - 1] = true;
+
+ /* Is there already a pg_statistic_ext tuple for this attribute? */
+ oldtup = SearchSysCache2(STATEXTNAMENSP,
+ NameGetDatum(name),
+ ObjectIdGetDatum(nspoid));
+
+ /*
+ * We only expect data for extended statistics already defined on
+ * the coordinator, so fail if we got something unexpected.
+ */
+ if (!HeapTupleIsValid(oldtup))
+ elog(ERROR, "unknown extended statistic");
+
+ /* Yes, replace it */
+ stup = heap_modify_tuple(oldtup,
+ RelationGetDescr(sd),
+ values,
+ nulls,
+ replaces);
+ ReleaseSysCache(oldtup);
+ CatalogTupleUpdate(sd, &stup->t_self, stup);
+
+ heap_freetuple(stup);
+ heap_close(sd, RowExclusiveLock);
+}
+
/*
* Standard fetch function for use by compute_stats subroutines.
*
int i;
/* Number of data nodes from which attribute statistics are received. */
int *numnodes;
+ List *stat_oids;
/* Get the relation identifier */
relname = RelationGetRelationName(onerel);
}
}
update_attstats(RelationGetRelid(onerel), inh, attr_cnt, vacattrstats);
+
+ /*
+ * Build extended statistics on the coordinator.
+ *
+ * We take an approach similar to the simple per-attribute stats by
+ * fetching the already-built extended statistics, and pick data
+ * from a random datanode on the assumption that the datanodes are
+ * fairly similar in terms of data volume and distribution.
+ *
+ * That seems to be working fairly well, although there are likely
+ * some weaknesses too - e.g. on distribution keys it may easily
+ * neglect large portions of the data.
+ */
+
+ /* Make up query string fetching data from pg_statistic_ext */
+ initStringInfo(&query);
+
+ appendStringInfo(&query, "SELECT ns.nspname, "
+ "stxname, "
+ "stxndistinct::bytea AS stxndistinct, "
+ "stxdependencies::bytea AS stxdependencies "
+ " FROM pg_statistic_ext s JOIN pg_class c "
+ " ON s.stxrelid = c.oid "
+ "JOIN pg_namespace nc "
+ " ON c.relnamespace = nc.oid "
+ "JOIN pg_namespace ns "
+ " ON s.stxnamespace = ns.oid "
+ "WHERE nc.nspname = '%s' AND c.relname = '%s'",
+ nspname, relname);
+
+ /* Build up RemoteQuery */
+ step = makeNode(RemoteQuery);
+ step->combine_type = COMBINE_TYPE_NONE;
+ step->exec_nodes = NULL;
+ step->sql_statement = query.data;
+ step->force_autocommit = true;
+ step->exec_type = EXEC_ON_DATANODES;
+
+ /* Add targetlist entries */
+ step->scan.plan.targetlist = lappend(step->scan.plan.targetlist,
+ make_relation_tle(NamespaceRelationId,
+ "pg_namespace",
+ "nspname"));
+
+ step->scan.plan.targetlist = lappend(step->scan.plan.targetlist,
+ make_relation_tle(StatisticExtRelationId,
+ "pg_statistic_ext",
+ "stxname"));
+
+ step->scan.plan.targetlist = lappend(step->scan.plan.targetlist,
+ make_relation_tle(StatisticExtRelationId,
+ "pg_statistic_ext",
+ "stxndistinct"));
+
+ step->scan.plan.targetlist = lappend(step->scan.plan.targetlist,
+ make_relation_tle(StatisticExtRelationId,
+ "pg_statistic_ext",
+ "stxdependencies"));
+
+ /* Execute query on the data nodes */
+ estate = CreateExecutorState();
+
+ oldcontext = MemoryContextSwitchTo(estate->es_query_cxt);
+
+ /*
+ * Take a fresh snapshot so that we see the effects of the ANALYZE
+ * command on datanodes. That command is run in auto-commit mode
+ * hence just bumping up the command ID is not good enough.
+ */
+ PushActiveSnapshot(GetTransactionSnapshot());
+ estate->es_snapshot = GetActiveSnapshot();
+
+ node = ExecInitRemoteQuery(step, estate, 0);
+ MemoryContextSwitchTo(oldcontext);
+
+ /* get ready to combine results */
+ numnodes = (int *) palloc(attr_cnt * sizeof(int));
+ for (i = 0; i < attr_cnt; i++)
+ numnodes[i] = 0;
+
+ result = ExecRemoteQuery(node);
+ PopActiveSnapshot();
+
+ /*
+ * We only want to update each statistics once, as we'd get errors
+ * about self-updated tuples otherwise. So keep a list of OIDs for
+ * stats we already updated, and check before each update.
+ */
+ stat_oids = NIL;
+ while (result != NULL && !TupIsNull(result))
+ {
+ Datum value;
+ bool isnull;
+ Name nspname;
+ Name stxname;
+ bytea *stxndistinct = NULL;
+ bytea *stxdependencies = NULL;
+
+ HeapTuple htup;
+ Oid nspoid;
+ Oid stat_oid;
+ bool updated;
+ ListCell *lc;
+
+ /* Process statistics from the data node */
+ value = slot_getattr(result, 1, &isnull); /* nspname */
+ nspname = DatumGetName(value);
+
+ value = slot_getattr(result, 2, &isnull); /* stxname */
+ stxname = DatumGetName(value);
+
+ value = slot_getattr(result, 3, &isnull); /* stxndistinct */
+ if (!isnull)
+ stxndistinct = DatumGetByteaP(value);
+
+ value = slot_getattr(result, 4, &isnull); /* stxdependencies */
+ if (!isnull)
+ stxdependencies = DatumGetByteaP(value);
+
+ nspoid = get_namespace_oid(NameStr(*nspname), false);
+
+ /* get OID of the statistics */
+ htup = SearchSysCache2(STATEXTNAMENSP,
+ NameGetDatum(stxname),
+ ObjectIdGetDatum(nspoid));
+
+ stat_oid = HeapTupleGetOid(htup);
+ ReleaseSysCache(htup);
+
+ /* see if we already updated this pg_statistic_ext tuple */
+ updated = false;
+ foreach(lc, stat_oids)
+ {
+ Oid oid = lfirst_oid(lc);
+
+ if (stat_oid == oid)
+ {
+ updated = true;
+ break;
+ }
+ }
+
+ /* if not, update it (with all the available data) */
+ if (!updated)
+ {
+ update_ext_stats(nspname, stxname, stxndistinct, stxdependencies);
+ stat_oids = lappend_oid(stat_oids, stat_oid);
+ }
+
+ /* fetch stats from next node */
+ result = ExecRemoteQuery(node);
+ }
+ ExecEndRemoteQuery(node);
}
#endif
FROM pg_statistic_ext WHERE stxrelid = 'ndistinct'::regclass;
stxkind | stxndistinct
---------+---------------------------------------------------------
- {d,f} | {"3, 4": 301, "3, 6": 301, "4, 6": 301, "3, 4, 6": 301}
+ {d,f} | {"3, 4": 161, "3, 6": 161, "4, 6": 161, "3, 4, 6": 161}
(1 row)
-- Hash Aggregate, thanks to estimates improved by the statistic
EXPLAIN (COSTS off)
SELECT COUNT(*) FROM ndistinct GROUP BY a, b;
- QUERY PLAN
------------------------------
+ QUERY PLAN
+-----------------------------------------------------------
HashAggregate
Group Key: a, b
- -> Seq Scan on ndistinct
-(3 rows)
+ -> Remote Subquery Scan on all (datanode_1,datanode_2)
+ -> Seq Scan on ndistinct
+(4 rows)
EXPLAIN (COSTS off)
SELECT COUNT(*) FROM ndistinct GROUP BY b, c;
- QUERY PLAN
------------------------------
+ QUERY PLAN
+-----------------------------------------------------------
HashAggregate
Group Key: b, c
- -> Seq Scan on ndistinct
-(3 rows)
+ -> Remote Subquery Scan on all (datanode_1,datanode_2)
+ -> Seq Scan on ndistinct
+(4 rows)
EXPLAIN (COSTS off)
SELECT COUNT(*) FROM ndistinct GROUP BY a, b, c;
- QUERY PLAN
------------------------------
+ QUERY PLAN
+-----------------------------------------------------------
HashAggregate
Group Key: a, b, c
- -> Seq Scan on ndistinct
-(3 rows)
+ -> Remote Subquery Scan on all (datanode_1,datanode_2)
+ -> Seq Scan on ndistinct
+(4 rows)
-- last two plans keep using Group Aggregate, because 'd' is not covered
-- by the statistic and while it's NULL-only we assume 200 values for it
ANALYZE ndistinct;
SELECT stxkind, stxndistinct
FROM pg_statistic_ext WHERE stxrelid = 'ndistinct'::regclass;
- stxkind | stxndistinct
----------+-------------------------------------------------------------
- {d,f} | {"3, 4": 2550, "3, 6": 800, "4, 6": 1632, "3, 4, 6": 10000}
+ stxkind | stxndistinct
+---------+------------------------------------------------------------
+ {d,f} | {"3, 4": 2378, "3, 6": 800, "4, 6": 1632, "3, 4, 6": 6060}
(1 row)
-- plans using Group Aggregate, thanks to using correct esimates
EXPLAIN (COSTS off)
SELECT COUNT(*) FROM ndistinct GROUP BY a, b;
- QUERY PLAN
------------------------------------
+ QUERY PLAN
+-----------------------------------------------------------
GroupAggregate
Group Key: a, b
- -> Sort
- Sort Key: a, b
- -> Seq Scan on ndistinct
-(5 rows)
+ -> Remote Subquery Scan on all (datanode_1,datanode_2)
+ -> Sort
+ Sort Key: a, b
+ -> Seq Scan on ndistinct
+(6 rows)
EXPLAIN (COSTS off)
SELECT COUNT(*) FROM ndistinct GROUP BY a, b, c;
- QUERY PLAN
------------------------------------
+ QUERY PLAN
+-----------------------------------------------------------
GroupAggregate
Group Key: a, b, c
- -> Sort
- Sort Key: a, b, c
- -> Seq Scan on ndistinct
-(5 rows)
+ -> Remote Subquery Scan on all (datanode_1,datanode_2)
+ -> Sort
+ Sort Key: a, b, c
+ -> Seq Scan on ndistinct
+(6 rows)
EXPLAIN (COSTS off)
SELECT COUNT(*) FROM ndistinct GROUP BY a, b, c, d;
- QUERY PLAN
------------------------------------
+ QUERY PLAN
+-----------------------------------------------------------
GroupAggregate
Group Key: a, b, c, d
- -> Sort
- Sort Key: a, b, c, d
- -> Seq Scan on ndistinct
-(5 rows)
+ -> Remote Subquery Scan on all (datanode_1,datanode_2)
+ -> Sort
+ Sort Key: a, b, c, d
+ -> Seq Scan on ndistinct
+(6 rows)
EXPLAIN (COSTS off)
SELECT COUNT(*) FROM ndistinct GROUP BY b, c, d;
projects / postgres-xl.git / commitdiff