Assert(!isnull);
        ownerId = DatumGetObjectId(datum);
 
-       if (!has_privs_of_role(GetUserId(), DatumGetObjectId(ownerId)))
+       if (!has_privs_of_role(GetUserId(), ownerId))
            aclcheck_error(ACLCHECK_NOT_OWNER, get_object_type(classId, objectId),
                           old_name);
 
 
    *isnull = false;
 
    if (!fcinfo->args[0].isnull)
-       return DatumGetUInt32(hashop->d.hashdatum.fn_addr(fcinfo));
+       return hashop->d.hashdatum.fn_addr(fcinfo);
    else
        return (Datum) 0;
 }
    *isnull = false;
 
    if (!fcinfo->args[0].isnull)
-       return DatumGetUInt32(hashop->d.hashdatum.fn_addr(fcinfo));
+       return hashop->d.hashdatum.fn_addr(fcinfo);
    else
        return (Datum) 0;
 }
    if (!fcinfo->args[0].isnull)
    {
        *isnull = false;
-       return DatumGetUInt32(hashop->d.hashdatum.fn_addr(fcinfo));
+       return hashop->d.hashdatum.fn_addr(fcinfo);
    }
    else
    {
 
    /*
     * Change ev_enabled if it is different from the desired new state.
     */
-   if (DatumGetChar(ruleform->ev_enabled) !=
-       fires_when)
+   if (ruleform->ev_enabled != fires_when)
    {
-       ruleform->ev_enabled = CharGetDatum(fires_when);
+       ruleform->ev_enabled = fires_when;
        CatalogTupleUpdate(pg_rewrite_desc, &ruletup->t_self, ruletup);
 
        changed = true;
 
            }
            else
            {
-               result->values[idx][i] = (Datum) datum;
+               result->values[idx][i] = datum;
                result->nulls[idx][i] = false;
            }
 
 
                     * position and go to multiword mode
                     */
 
-                   ld->curDictId = DatumGetObjectId(map->dictIds[i]);
+                   ld->curDictId = map->dictIds[i];
                    ld->posDict = i + 1;
                    ld->curSub = curVal->next;
                    if (res)
                 * dictionaries ?
                 */
                for (i = 0; i < map->len && !dictExists; i++)
-                   if (ld->curDictId == DatumGetObjectId(map->dictIds[i]))
+                   if (ld->curDictId == map->dictIds[i])
                        dictExists = true;
 
                if (!dictExists)
 
 static bool
 match_db_entries(PgStatShared_HashEntry *entry, Datum match_data)
 {
-   return entry->key.dboid == DatumGetObjectId(MyDatabaseId);
+   return entry->key.dboid == MyDatabaseId;
 }
 
 /*
 
 
    hash ^= hash_bytes((const unsigned char *) entry->key, entry->key_len);
 
-   return DatumGetUInt32(hash);
+   return hash;
 }
 
 static int
 
    bool        empty;
 
    if (RangeIsEmpty(r) || MultirangeIsEmpty(mr))
-       PG_RETURN_BOOL(false);
-
+       return false;
 
    range_deserialize(rangetyp, r, &lower1, &upper1, &empty);
    Assert(!empty);
    multirange_get_bounds(rangetyp, mr, mr->rangeCount - 1,
                          &lower2, &upper2);
 
-   PG_RETURN_BOOL(range_cmp_bounds(rangetyp, &upper1, &upper2) <= 0);
+   return (range_cmp_bounds(rangetyp, &upper1, &upper2) <= 0);
 }
 
 Datum
    bool        empty;
 
    if (RangeIsEmpty(r) || MultirangeIsEmpty(mr))
-       PG_RETURN_BOOL(false);
+       return false;
 
    range_deserialize(rangetyp, r, &lower1, &upper1, &empty);
    Assert(!empty);
 
        return r1;
 
    if (strict &&
-       !DatumGetBool(range_overlaps_internal(typcache, r1, r2)) &&
-       !DatumGetBool(range_adjacent_internal(typcache, r1, r2)))
+       !range_overlaps_internal(typcache, r1, r2) &&
+       !range_adjacent_internal(typcache, r1, r2))
        ereport(ERROR,
                (errcode(ERRCODE_DATA_EXCEPTION),
                 errmsg("result of range union would not be contiguous")));
 
 {
    /* fastpath when max encoding length is one */
    if (pg_database_encoding_max_length() == 1)
-       PG_RETURN_INT32(toast_raw_datum_size(str) - VARHDRSZ);
+       return (toast_raw_datum_size(str) - VARHDRSZ);
    else
    {
        text       *t = DatumGetTextPP(str);
 
-       PG_RETURN_INT32(pg_mbstrlen_with_len(VARDATA_ANY(t),
-                                            VARSIZE_ANY_EXHDR(t)));
+       return (pg_mbstrlen_with_len(VARDATA_ANY(t), VARSIZE_ANY_EXHDR(t)));
    }
 }
 
 
        if ((LockTagType) locallock->tag.lock.locktag_type !=
            LOCKTAG_RELATION)
            continue;
-       relid = ObjectIdGetDatum(locallock->tag.lock.locktag_field2);
+       relid = locallock->tag.lock.locktag_field2;
        r = RelationIdGetRelation(relid);
        if (!RelationIsValid(r))
            continue;