This commit will display the contents of the Optimizer Mem Account when
the optimizer GUC is on and explain_memory_verbosity is set to
'summary'.
Signed-off-by: NSambitesh Dash <sdash@pivotal.io>

This bumps the copyright years to the appropriate years after not
having been updated for some time.  Also reformats existing code
headers to match the upstream style to ensure consistency.

The whole cdb directory was shipped to end users and all header files
that cdb*.h included are also need to be shipped to make checkinc.py
pass. However, exposing gp_libpq_fe/*.h will confuse customer because
they are almost the same as libpq/*, as Heikki's suggestion, we should
keep gp_libpq_fe/* unchanged. So to make system work, we include
gp-libpg-fe.h and gp-libpq-int.h directly in c files that need them

Resource group memory spill is similar to 'statement_mem' in
resource queue, the difference is memory spill is calculated
according to the memory quota of the resource group.

The related GUCs, variables and functions shared by both resource
queue and resource group are moved to the namespace resource manager.

Also codes of resource queue relating to memory policy are refactored in this commit.
Signed-off-by: NPengzhou Tang <ptang@pivotal.io>
Signed-off-by: NNing Yu <nyu@pivotal.io>

This resolves #1880. Thanks Lirong Jian for the inital PR #1952.

Details:
Fixed a typo of string comparison in cdbexplain
Fix the typo for UNINITIALIZED_SORT.
Add new method to convert sort space type str to enum.

This commit also resolves #1646.
Porting only the function `tuplesort_get_stats` in tuplesort.c from the
Postgres commit
https://github.com/postgres/postgres/blob/9bd27b7c9e998087f390774bd0f43916813a2847/src/backend/utils/sort/tuplesort.c
Link to gpdb-dev discussion - https://groups.google.com/a/greenplum.org/forum/#!topic/gpdb-dev/V-zIshnNzyE

In many places where we had used a mixture of spaces and tabs for
indentation, new versions of gcc complained about misleading indentation,
because gcc doesn't know we're using tab width of 4. To fix, make the
indentation consistent in all the places where gcc gave a warning. Would
be nice to fix it all around, but that's a lot of work, so let's do it
in a piecemeal fashion whenever we run into issues or need to modify a
piece of code anyway.

For some files, especially the GPDB-specific ones, I ran pgindent over
the whole file. I used the pgindent from PostgreSQL master, which is
slightly different from what was used back 8.3 days, but that's what I had
easily available, and that's what we're heading to in the future anyway.
In some cases, I didn't commit the pgindented result if there were
funnily formatted code or comments that would need special treatment.

For other places, I fixed the indentation locally, just enough to make the
warnings go away.

I also did a tiny bit of other trivial cleanup, that I happened to spot
while working on this, although I tried to refrain from anything more
extensive.

Previously accounting tree and reference to accounts were pointer based.
This prevents us from freeing accounts at the end of each statement as
later statements of that transaction can potentially access memory and
the corresponding accounts. This resulted in a perceived memory leak as
the accounts were not freed per-statement.

In this implementation we convert pointers to index that can refer to an
array of accounts. This allows us to partition indexes based on
"generation" to define which accounts are live and which are already
dead. This is also a soft-pointer so we don't crash accessing it. This
also allows us to optimize the previous heavyweight "rollover" at the
time of generation overflow as we no longer need to detect the validity
of accounts based on generation, and rather we can just refer to logical
range of indexes to identify the liveness.

[#120028219]

This is also transient information, only valid during execution, and should
not be cached with the plan.

There's no real need for a separate MemoryContext for EXPLAIN stuff. Might
as well leave all that in the per-statement context.

Workfile caching was an experimental feature that was never taken into
production use. It has since been removed, but these instrumentation
remnants of it were still lying around unused.