~ubuntu-branches/ubuntu/lucid/postgresql-8.4/lucid-proposed

 *

 *

 * IDENTIFICATION

 *

 *-------------------------------------------------------------------------

 */

                {

                        if (onerel->rd_rel->relisshared)

                                ereport(WARNING,

                        else if (onerel->rd_rel->relnamespace == PG_CATALOG_NAMESPACE)

                                ereport(WARNING,

                                                (errmsg("skipping \"%s\" --- only superuser or database owner can analyze it",

                                        RelationGetRelationName(onerel))));

 

        /*

         */

        GetUserIdAndContext(&save_userid, &save_secdefcxt);

        SetUserIdAndContext(onerel->rd_rel->relowner, true);

        }

 

        /*

         */

                goto cleanup;

 

        /*

         * Determine how many rows we need to sample, using the worst case from

 

        /*

         * Same for indexes. Vacuum always scans all indexes, so if we're part of

         * VACUUM.

         */

        if (!vacstmt->vacuum)

                        ivinfo.index = Irel[ind];

                        ivinfo.vacuum_full = false;

                        ivinfo.analyze_only = true;

                        ivinfo.message_level = elevel;

                        ivinfo.strategy = vac_strategy;

 

                        stats = index_vacuum_cleanup(&ivinfo, NULL);

                return NULL;

 

        /*

         */

        stats = (VacAttrStats *) palloc0(sizeof(VacAttrStats));

        stats->attr = (Form_pg_attribute) palloc(ATTRIBUTE_FIXED_PART_SIZE);

        stats->tupattnum = attnum;

 

        /*

         */

        for (i = 0; i < STATISTIC_NUM_SLOTS; i++)

        {

                                        double *totalrows, double *totaldeadrows)

{

        int                     numrows = 0;    /* # rows now in reservoir */

        double          liverows = 0;   /* # live rows seen */

        double          deadrows = 0;   /* # dead rows seen */

        double          rowstoskip = -1;        /* -1 means not set yet */

                 * the maxoffset value stays good (else concurrent VACUUM might delete

                 * tuples out from under us).  Hence, pin the page until we are done

                 * looking at it.  We also choose to hold sharelock on the buffer

                 */

                targbuffer = ReadBufferExtended(onerel, MAIN_FORKNUM, targblock,

                                                                                RBM_NORMAL, vac_strategy);

 

                        /*

                         * We ignore unused and redirect line pointers.  DEAD line

                         */

                        if (!ItemIdIsNormal(itemid))

                        {

                                        break;

 

                                case HEAPTUPLE_INSERT_IN_PROGRESS:

                                        /*

                                         * Insert-in-progress rows are not counted.  We assume

                                         * that when the inserting transaction commits or aborts,

                                         * count.  This works right only if that transaction ends

                                         * after we finish analyzing the table; if things happen

                                         * in the other order, its stats update will be

                                         *

                                         * A special case is that the inserting transaction might

                                         * the row, to accommodate users who load a table and

                                         * analyze it in one transaction.  (pgstat_report_analyze

                                         */

                                        if (TransactionIdIsCurrentTransactionId(HeapTupleHeaderGetXmin(targtuple.t_data)))

                                        {

                                        break;

 

                                case HEAPTUPLE_DELETE_IN_PROGRESS:

                                        /*

                                         * We count delete-in-progress rows as still live, using

                                         * the same reasoning given above; but we don't bother to

                                         * If the delete was done by our own transaction, however,

                                         * we must count the row as dead to make

                                         * pgstat_report_analyze's stats adjustments come out

                                         */

                                        if (TransactionIdIsCurrentTransactionId(HeapTupleHeaderGetXmax(targtuple.t_data)))

                                                deadrows += 1;

                                        /*

                                         * t in Vitter's paper is the number of records already

                                         * processed.  If we need to compute a new S value, we

                                         */

                                        if (rowstoskip < 0)

                                                rowstoskip = get_next_S(samplerows, targrows, &rstate);

                {

                        /* Yes, replace it */

                        stup = heap_modify_tuple(oldtup,

                        ReleaseSysCache(oldtup);

                        simple_heap_update(sd, &stup->t_self, stup);

                }

                        stats->numnumbers[0] = num_mcv;

                        stats->stavalues[0] = mcv_values;

                        stats->numvalues[0] = num_mcv;

                        /*

                         */

                }

        }

                        stats->numnumbers[slot_idx] = num_mcv;

                        stats->stavalues[slot_idx] = mcv_values;

                        stats->numvalues[slot_idx] = num_mcv;

                        /*

                         */

                        slot_idx++;

                }

 

                        /*

                         * The object of this loop is to copy the first and last values[]

                         * i'th value is values[(i * (nvals - 1)) / (num_hist - 1)].  But

                         * computing that subscript directly risks integer overflow when

                         * the stats target is more than a couple thousand.  Instead we

                        stats->staop[slot_idx] = mystats->ltopr;

                        stats->stavalues[slot_idx] = hist_values;

                        stats->numvalues[slot_idx] = num_hist;

                        /*

                         */

                        slot_idx++;

                }