pg_conversion.c

Go to the documentation of this file.

/*-------------------------------------------------------------------------
 *
 * pg_conversion.c
 *    routines to support manipulation of the pg_conversion relation
 *
 * Portions Copyright (c) 1996-2026, PostgreSQL Global Development Group
 * Portions Copyright (c) 1994, Regents of the University of California
 *
 *
 * IDENTIFICATION
 *    src/backend/catalog/pg_conversion.c
 *
 *-------------------------------------------------------------------------
 */
#include "postgres.h"
 
#include "access/htup_details.h"
#include "access/table.h"
#include "catalog/catalog.h"
#include "catalog/dependency.h"
#include "catalog/indexing.h"
#include "catalog/objectaccess.h"
#include "catalog/pg_conversion.h"
#include "catalog/pg_namespace.h"
#include "catalog/pg_proc.h"
#include "mb/pg_wchar.h"
#include "utils/builtins.h"
#include "utils/catcache.h"
#include "utils/rel.h"
#include "utils/syscache.h"
 
/*
 * ConversionCreate
 *
 * Add a new tuple to pg_conversion.
 */
ObjectAddress
ConversionCreate(const char *conname, Oid connamespace,
                 Oid conowner,
                 int32 conforencoding, int32 contoencoding,
                 Oid conproc, bool def)
{
    int         i;
    Relation    rel;
    TupleDesc   tupDesc;
    HeapTuple   tup;
    Oid         oid;
    bool        nulls[Natts_pg_conversion];
    Datum       values[Natts_pg_conversion];
    NameData    cname;
    ObjectAddress myself,
                referenced;
 
    /* sanity checks */
    if (!conname)
        elog(ERROR, "no conversion name supplied");
 
    /* make sure there is no existing conversion of same name */
    if (SearchSysCacheExists2(CONNAMENSP,
                              PointerGetDatum(conname),
                              ObjectIdGetDatum(connamespace)))
        ereport(ERROR,
                (errcode(ERRCODE_DUPLICATE_OBJECT),
                 errmsg("conversion \"%s\" already exists", conname)));
 
    if (def)
    {
        /*
         * make sure there is no existing default <for encoding><to encoding>
         * pair in this name space
         */
        if (FindDefaultConversion(connamespace,
                                  conforencoding,
                                  contoencoding))
            ereport(ERROR,
                    (errcode(ERRCODE_DUPLICATE_OBJECT),
                     errmsg("default conversion for %s to %s already exists",
                            pg_encoding_to_char(conforencoding),
                            pg_encoding_to_char(contoencoding))));
    }
 
    /* open pg_conversion */
    rel = table_open(ConversionRelationId, RowExclusiveLock);
    tupDesc = rel->rd_att;
 
    /* initialize nulls and values */
    for (i = 0; i < Natts_pg_conversion; i++)
    {
        nulls[i] = false;
        values[i] = (Datum) 0;
    }
 
    /* form a tuple */
    namestrcpy(&cname, conname);
    oid = GetNewOidWithIndex(rel, ConversionOidIndexId,
                             Anum_pg_conversion_oid);
    values[Anum_pg_conversion_oid - 1] = ObjectIdGetDatum(oid);
    values[Anum_pg_conversion_conname - 1] = NameGetDatum(&cname);
    values[Anum_pg_conversion_connamespace - 1] = ObjectIdGetDatum(connamespace);
    values[Anum_pg_conversion_conowner - 1] = ObjectIdGetDatum(conowner);
    values[Anum_pg_conversion_conforencoding - 1] = Int32GetDatum(conforencoding);
    values[Anum_pg_conversion_contoencoding - 1] = Int32GetDatum(contoencoding);
    values[Anum_pg_conversion_conproc - 1] = ObjectIdGetDatum(conproc);
    values[Anum_pg_conversion_condefault - 1] = BoolGetDatum(def);
 
    tup = heap_form_tuple(tupDesc, values, nulls);
 
    /* insert a new tuple */
    CatalogTupleInsert(rel, tup);
 
    myself.classId = ConversionRelationId;
    myself.objectId = oid;
    myself.objectSubId = 0;
 
    /* create dependency on conversion procedure */
    referenced.classId = ProcedureRelationId;
    referenced.objectId = conproc;
    referenced.objectSubId = 0;
    recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL);
 
    /* create dependency on namespace */
    referenced.classId = NamespaceRelationId;
    referenced.objectId = connamespace;
    referenced.objectSubId = 0;
    recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL);
 
    /* create dependency on owner */
    recordDependencyOnOwner(ConversionRelationId, oid, conowner);
 
    /* dependency on extension */
    recordDependencyOnCurrentExtension(&myself, false);
 
    /* Post creation hook for new conversion */
    InvokeObjectPostCreateHook(ConversionRelationId, oid, 0);
 
    heap_freetuple(tup);
    table_close(rel, RowExclusiveLock);
 
    return myself;
}
 
/*
 * FindDefaultConversion
 *
 * Find "default" conversion proc by for_encoding and to_encoding in the
 * given namespace.
 *
 * If found, returns the procedure's oid, otherwise InvalidOid.  Note that
 * you get the procedure's OID not the conversion's OID!
 */
Oid
FindDefaultConversion(Oid name_space, int32 for_encoding, int32 to_encoding)
{
    CatCList   *catlist;
    HeapTuple   tuple;
    Form_pg_conversion body;
    Oid         proc = InvalidOid;
    int         i;
 
    catlist = SearchSysCacheList3(CONDEFAULT,
                                  ObjectIdGetDatum(name_space),
                                  Int32GetDatum(for_encoding),
                                  Int32GetDatum(to_encoding));
 
    for (i = 0; i < catlist->n_members; i++)
    {
        tuple = &catlist->members[i]->tuple;
        body = (Form_pg_conversion) GETSTRUCT(tuple);
        if (body->condefault)
        {
            proc = body->conproc;
            break;
        }
    }
    ReleaseSysCacheList(catlist);
    return proc;
}