Module org.postgresql.pljava
Package org.postgresql.pljava.model

Interface RegProcedure<M extends RegProcedure.Memo<M>>

Type Parameters:
M - distinguishes RegProcedure instances used for different known purposes, by specifying the type of a 'memo' that could be attached to the instance, perhaps with extra information helpful for the intended use. At present, such memo interfaces are all empty, but still this parameter can serve a compile-time role to discourage mixing different procedures up.
All Superinterfaces:
CatalogObject, CatalogObject.AccessControlled<org.postgresql.pljava.model.CatalogObject.EXECUTE>, CatalogObject.Addressed<RegProcedure<?>>, CatalogObject.Named<Lexicals.Identifier.Simple>, CatalogObject.Namespaced<Lexicals.Identifier.Simple>, CatalogObject.Owned
public interface RegProcedure<M extends RegProcedure.Memo<M>> extends CatalogObject.Addressed<RegProcedure<?>>, CatalogObject.Namespaced<Lexicals.Identifier.Simple>, CatalogObject.Owned, CatalogObject.AccessControlled<org.postgresql.pljava.model.CatalogObject.EXECUTE>
Model of a PostgreSQL "routine" (which in late versions can include procedures and functions of various kinds) as defined in the system catalogs, including its parameter and result types and many other properties.

  • Field Details

  • Method Details

    • language

      ProceduralLanguage language()

    • cost

      float cost()

    • rows

      float rows()

    • variadicType

      RegType variadicType()

    • support

      RegProcedure<RegProcedure.PlannerSupport> support()
      A planner-support function that may transform call sites of this function.

      In PG 9.5 to 11, there was a similar, but less flexible, "transform" function that this method can return when running on those versions.

      Since:
      PG 12

    • kind

      RegProcedure.Kind kind()
      The kind of procedure or function.

      Before PG 11, there were separate booleans to indicate an aggregate or window function, which this method can consult when running on earlier versions.

      Since:
      PG 11

    • security

      Function.Security security()

    • leakproof

      boolean leakproof()

    • onNullInput

      Function.OnNullInput onNullInput()

    • returnsSet

      boolean returnsSet()

    • effects

      Function.Effects effects()

    • parallel

      Function.Parallel parallel()

    • returnType

      RegType returnType()

    • argTypes

      List<RegType> argTypes()

    • allArgTypes

      List<RegType> allArgTypes()

    • argModes

      List<RegProcedure.ArgMode> argModes()
      Modes corresponding 1-for-1 to the arguments in allArgTypes.

    • argNames

      List<Lexicals.Identifier.Simple> argNames()
      Names corresponding 1-for-1 to the arguments in allArgTypes.

    • argDefaults

      SQLXML argDefaults()
      A pg_node_tree representation of a list of n expression trees, corresponding to the last n input arguments (that is, the last n returned by argTypes).

    • transformTypes

      List<RegType> transformTypes()

    • src

      String src()

    • bin

      String bin()

    • sqlBody

      SQLXML sqlBody()
      A pg_node_tree representation of a pre-parsed SQL function body, used when it is given in SQL-standard notation rather than as a string literal, otherwise null.
      Since:
      PG 14

    • config

      List<String> config()
      This is surely a list of guc=value pairs and ought to have a more specific return type.

      XXX

    • memo

      M memo()
      Obtain memo attached to this RegProcedure, if any.

      A RegProcedure may have an implementation of Memo attached, providing additional information on what sort of procedure it is and how to use it. Many catalog getters that return RegProcedure specialize the return type to indicate an expected subinterface of Memo.

      It may not be the case that a given RegProcedure has a valid Memo attached at all times. Documentation for a specific Memo subinterface should explain the circumstances when this method can be called to rely on a memo of that type.