| /* ----------------------------------------------------------------------- *//** |
| * |
| * @file SystemInformation_impl.hpp |
| * |
| *//* ----------------------------------------------------------------------- */ |
| |
| #ifndef MADLIB_POSTGRES_SYSTEMINFORMATION_IMPL_HPP |
| #define MADLIB_POSTGRES_SYSTEMINFORMATION_IMPL_HPP |
| |
| namespace madlib { |
| |
| namespace dbconnector { |
| |
| namespace postgres { |
| |
| namespace { |
| |
| /** |
| * @brief Initialize an OID-to-data hash table |
| */ |
| inline |
| void |
| initializeOidHashTable(HTAB*& ioHashTable, MemoryContext inCacheContext, |
| size_t inEntrySize, const char* inTabName, uint32_t inMaxNElems) { |
| |
| if (ioHashTable == NULL) { |
| HASHCTL ctl; |
| ctl.keysize = sizeof(Oid); |
| ctl.entrysize = inEntrySize; |
| ctl.hash = oid_hash; |
| ctl.hcxt = inCacheContext; |
| ioHashTable = madlib_hash_create( |
| /* tabname -- a name for the table (for debugging purposes) */ |
| inTabName, |
| /* nelem -- maximum number of elements expected */ |
| inMaxNElems, |
| /* info: additional table parameters, as indicated by flags */ |
| &ctl, |
| /* flags -- bitmask indicating which parameters to take from *info */ |
| HASH_ELEM | HASH_FUNCTION | HASH_CONTEXT |
| ); |
| } |
| } |
| |
| /** |
| * @brief Store cached system-catalog information in backend function handle |
| * |
| * @param inFmgrInfo Backend handle to the function |
| * @param inSysInfo Our system-catalog information that should be stored |
| * |
| * A set-returning function uses \c fn_extra to store cross-call information. |
| * See, e.g., init_MultiFuncCall() in funcapi.c. Fortunately, it stores a point |
| * to a <tt>struct FuncCallContext</tt> in \c fn_extra, which in turn allows to |
| * store user-defined data. |
| */ |
| inline |
| void |
| setSystemInformationInFmgrInfo(FmgrInfo* inFmgrInfo, |
| SystemInformation* inSysInfo) { |
| |
| (inFmgrInfo->fn_retset |
| ? static_cast<FuncCallContext*>(inFmgrInfo->fn_extra)->user_fctx |
| : inFmgrInfo->fn_extra) |
| = inSysInfo; |
| } |
| |
| /** |
| * @brief Get cached system-catalog information from backend function handle |
| * |
| * @see setSystemInformationInFmgrInfo() |
| */ |
| inline |
| SystemInformation* |
| getSystemInformationFromFmgrInfo(FmgrInfo* inFmgrInfo) { |
| return static_cast<SystemInformation*>(inFmgrInfo->fn_retset |
| ? static_cast<FuncCallContext*>(inFmgrInfo->fn_extra)->user_fctx |
| : inFmgrInfo->fn_extra); |
| } |
| |
| /** |
| * @brief Get memory context from backend function handle |
| * |
| * The memory context returned may be used for storing user-defined data. In |
| * SystemInformation::get(), we will use it for allocating a |
| * <tt>struct SystemInformation</tt>. |
| * |
| * @see setSystemInformationInFmgrInfo() |
| */ |
| inline |
| MemoryContext |
| getMemoryContextFromFmgrInfo(FmgrInfo* inFmgrInfo) { |
| return inFmgrInfo->fn_retset |
| ? static_cast<FuncCallContext*>(inFmgrInfo->fn_extra) |
| ->multi_call_memory_ctx |
| : inFmgrInfo->fn_mcxt; |
| } |
| |
| } // namespace |
| |
| /** |
| * @brief Get (and cache) information from the PostgreSQL catalog |
| * |
| * @param inFmgrInfo System-catalog information about the function. If no |
| * SystemInformation is currently available in struct FmgrInfo, this |
| * function will store it (and thus change the FmgrInfo struct). |
| */ |
| inline |
| SystemInformation* |
| SystemInformation::get(FunctionCallInfo fcinfo) { |
| madlib_assert(fcinfo->flinfo, |
| std::invalid_argument("Incomplete FunctionCallInfoData.")); |
| |
| SystemInformation* sysInfo |
| = getSystemInformationFromFmgrInfo(fcinfo->flinfo); |
| |
| if (!sysInfo) { |
| MemoryContext memCtxt = getMemoryContextFromFmgrInfo(fcinfo->flinfo); |
| |
| sysInfo = static_cast<SystemInformation*>( |
| madlib_MemoryContextAllocZero( |
| memCtxt, sizeof(SystemInformation))); |
| sysInfo->entryFuncOID = fcinfo->flinfo->fn_oid; |
| sysInfo->cacheContext = memCtxt; |
| sysInfo->collationOID = PG_GET_COLLATION(); |
| setSystemInformationInFmgrInfo(fcinfo->flinfo, sysInfo); |
| } |
| return sysInfo; |
| } |
| |
| /** |
| * @brief Get (and cache) information about a PostgreSQL type |
| * |
| * @param inPGInfo An PGInformation structure containing all cached information |
| * @param inTypeID The OID of the type of interest |
| */ |
| inline |
| TypeInformation* |
| SystemInformation::typeInformation(Oid inTypeID) { |
| TypeInformation* cachedTypeInfo = NULL; |
| bool found = true; |
| MemoryContext oldContext; |
| HeapTuple tup; |
| Form_pg_type pgType; |
| |
| // We arrange to look up info about types only once per series of |
| // calls, assuming the type info doesn't change underneath us. |
| initializeOidHashTable(types, cacheContext, |
| sizeof(TypeInformation), |
| "C++ AL / TypeInformation hash table", |
| 12); |
| |
| // BACKEND: Since we pass HASH_FIND, this function call will never perform |
| // an allocation. There is nothing in the code path that would raise an |
| // exception (including oid_hash()), so we are *not* wrapping in a PG_TRY() |
| // block for performance reasons. |
| cachedTypeInfo = static_cast<TypeInformation*>( |
| hash_search(types, &inTypeID, HASH_FIND, &found)); |
| |
| if (!found) { |
| cachedTypeInfo = static_cast<TypeInformation*>( |
| madlib_hash_search(types, &inTypeID, HASH_ENTER, &found)); |
| // cachedTypeInfo.oid is already set |
| tup = madlib_SearchSysCache1(TYPEOID, ObjectIdGetDatum(inTypeID)); |
| // BACKEND: HeapTupleIsValid is just a macro |
| if (!HeapTupleIsValid(tup)) { |
| throw std::runtime_error("Error while looking up a type in the " |
| "system catalog."); |
| } else { |
| // BACKEND: GETSTRUCT is just a macro |
| pgType = reinterpret_cast<Form_pg_type>(GETSTRUCT(tup)); |
| std::strncpy(cachedTypeInfo->name, pgType->typname.data, |
| NAMEDATALEN); |
| cachedTypeInfo->len = pgType->typlen; |
| cachedTypeInfo->byval = pgType->typbyval; |
| cachedTypeInfo->type = pgType->typtype; |
| |
| if (cachedTypeInfo->type == TYPTYPE_COMPOSITE) { |
| // BACKEND: MemoryContextSwitchTo just changes a global |
| // variable |
| oldContext = MemoryContextSwitchTo(cacheContext); |
| // Since type ID != RECORDOID, typmod will not be used and |
| // we can set it to -1 |
| // (RECORDOID is a pseudo type and used for transient record |
| // types. They are identified by an index in array |
| // RecordCacheArray defined in typcache.c.) |
| cachedTypeInfo->tupdesc = madlib_lookup_rowtype_tupdesc_copy( |
| /* type_id */ inTypeID, |
| /* typmod */ -1); |
| MemoryContextSwitchTo(oldContext); |
| } else { |
| cachedTypeInfo->tupdesc = NULL; |
| } |
| madlib_ReleaseSysCache(tup); |
| } |
| } |
| |
| return cachedTypeInfo; |
| } |
| |
| /** |
| * @brief Get (and cache) information about a PostgreSQL function |
| * |
| * @param inFuncID The OID of the function of interest |
| * @return |
| */ |
| inline |
| FunctionInformation* |
| SystemInformation::functionInformation(Oid inFuncID) { |
| FunctionInformation* cachedFuncInfo = NULL; |
| bool found = true; |
| HeapTuple tup; |
| Form_pg_proc pgFunc; |
| |
| // We arrange to look up info about functions only once per series of |
| // calls, assuming the function info doesn't change underneath us. |
| initializeOidHashTable(functions, cacheContext, |
| sizeof(FunctionInformation), |
| "C++ AL / FunctionInformation hash table", |
| 8); |
| |
| // BACKEND: Since we pass HASH_FIND, this function call will never perform |
| // an allocation. There is nothing in the code path that would raise an |
| // exception (including oid_hash()), so we are *not* wrapping in a PG_TRY() |
| // block for performance reasons. |
| cachedFuncInfo = static_cast<FunctionInformation*>( |
| hash_search(functions, &inFuncID, HASH_FIND, &found)); |
| |
| if (!found) { |
| cachedFuncInfo = static_cast<FunctionInformation*>( |
| madlib_hash_search(functions, &inFuncID, HASH_ENTER, &found)); |
| // cachedFuncInfo.oid is already set |
| cachedFuncInfo->mSysInfo = this; |
| tup = madlib_SearchSysCache1(PROCOID, ObjectIdGetDatum(inFuncID)); |
| if (!HeapTupleIsValid(tup)) { |
| throw std::runtime_error("Error while looking up a function in the " |
| "system catalog."); |
| } else { |
| // BACKEND: GETSTRUCT is just a macro |
| pgFunc = reinterpret_cast<Form_pg_proc>(GETSTRUCT(tup)); |
| cachedFuncInfo->cxx_func = NULL; |
| cachedFuncInfo->flinfo.fn_oid = InvalidOid; |
| // The number of arguments (excluding OUT params) |
| cachedFuncInfo->nargs |
| = static_cast<uint16_t>(pgFunc->proargtypes.dim1); |
| cachedFuncInfo->polymorphic = false; |
| cachedFuncInfo->isstrict = pgFunc->proisstrict; |
| cachedFuncInfo->secdef = pgFunc->prosecdef; |
| |
| Oid* allargs; |
| // We could use get_func_arg_info() but unfortunately that also |
| // copied names and modes |
| bool onlyINArguments = false; |
| Datum allargtypes = madlib_SysCacheGetAttr(PROCOID, tup, |
| Anum_pg_proc_proallargtypes, &onlyINArguments); |
| |
| if (onlyINArguments) { |
| allargs = pgFunc->proargtypes.values; |
| } else { |
| // See get_func_arg_info(). We expect the arrays to be 1-D |
| // arrays of the right types; verify that. |
| // Ensure that array is not toasted. We do not worry about |
| // a possible memory leak here. This code will be run only |
| // once per entry function (into the C++ AL) and query, and |
| // memory will already be garbage collected once the currenty |
| // entry point is left. |
| ArrayType* arr = madlib_DatumGetArrayTypeP(allargtypes); |
| int numargs = ARR_DIMS(arr)[0]; |
| madlib_assert(ARR_NDIM(arr) == 1 && ARR_DIMS(arr)[0] >= 0 && |
| !ARR_HASNULL(arr) && ARR_ELEMTYPE(arr) == OIDOID && |
| numargs >= pgFunc->pronargs, |
| std::runtime_error("In SystemInformation::" |
| "functionInformation(): proallargtypes is not a vaid " |
| "one-dimensional Oid array")); |
| allargs = reinterpret_cast<Oid*>(ARR_DATA_PTR(arr)); |
| } |
| |
| for (int i = 0; i < pgFunc->pronargs; ++i) { |
| // Note that pgFunc->pronargs is the number of all arguments |
| // (including OUT params) |
| if (typeInformation(allargs[i])->getType() |
| == TYPTYPE_PSEUDO) { |
| |
| cachedFuncInfo->polymorphic = true; |
| break; |
| } |
| } |
| |
| if (cachedFuncInfo->nargs == 0) { |
| cachedFuncInfo->argtypes = NULL; |
| } else { |
| cachedFuncInfo->argtypes = static_cast<Oid*>( |
| madlib_MemoryContextAlloc(cacheContext, |
| cachedFuncInfo->nargs * sizeof(Oid))); |
| std::memcpy(cachedFuncInfo->argtypes, |
| pgFunc->proargtypes.values, |
| cachedFuncInfo->nargs * sizeof(Oid)); |
| } |
| |
| cachedFuncInfo->rettype = pgFunc->prorettype; |
| |
| // If the return type is RECORDOID, we cannot yet determine the |
| // tuple description, even if the function is not polymorphic. |
| // For that, the expression parse tree is required. |
| // If the return type is composite but not RECORDOID, the tuple |
| // description will be stored with the type information, so no |
| // need to have it here. |
| cachedFuncInfo->tupdesc = NULL; |
| madlib_ReleaseSysCache(tup); |
| } |
| } |
| |
| return cachedFuncInfo; |
| } |
| |
| /** |
| * @brief Retrieve tuple description for a composite type |
| * |
| * @param inTypeMod Transient record types have tye ID RECORDOID and are |
| * identified by an index in array RecordCacheArray (defined in typcache.c). |
| * This index is stored in the tdtypmod field of struct tupleDesc. |
| * See the description of \c tupleDesc in tupdesc.h. |
| */ |
| inline |
| TupleDesc |
| TypeInformation::getTupleDesc(int32_t inTypeMod) { |
| if (tupdesc != NULL) |
| // We have the tuple description in our cache, so return it |
| return tupdesc; |
| else if (oid == RECORDOID && inTypeMod >= 0) { |
| // It is an anonymous type, but PostgreSQL has it in its own cache |
| // In this case lookup_rowtype_tupdesc_noerror(RECORDOID, ...) |
| // does currently not perform any actions that could rise an exception. |
| // We might not want to rely on that, however (at the expense of |
| // performance). |
| TupleDesc pgCachedTupDesc = lookup_rowtype_tupdesc_noerror(oid, |
| inTypeMod, /* noerror */ true); |
| |
| // The tupleDesc is in the cache (RecordCacheArray defined in |
| // typcache.c) even before lookup_rowtype... is called. There is no |
| // need to release the tupleDesc, though we do in order to avoid any |
| // side effect. |
| ReleaseTupleDesc(pgCachedTupDesc); |
| return pgCachedTupDesc; |
| } |
| |
| return NULL; |
| } |
| |
| /** |
| * @brief Determine whether a specified type is composite |
| * |
| * This is our cached replacement for type_is_rowtype() in lsyscache.c |
| */ |
| inline |
| bool |
| TypeInformation::isCompositeType() { |
| return oid == RECORDOID || type == TYPTYPE_COMPOSITE; |
| } |
| |
| /** |
| * @brief Retrieve the name of the specified type |
| */ |
| inline |
| const char* |
| TypeInformation::getName() { |
| return name; |
| } |
| |
| inline |
| bool |
| TypeInformation::isByValue() { |
| return byval; |
| } |
| |
| inline |
| int16_t |
| TypeInformation::getLen() { |
| return len; |
| } |
| |
| inline |
| char |
| TypeInformation::getType() { |
| return type; |
| } |
| |
| |
| |
| /** |
| * @brief Retrieve the type of a function argument |
| * |
| * @param inArgID The ID of the argument (first argument is 0) |
| * @param inFmgrInfo System-catalog information about the function. For |
| * polymorphic functions, this should be non-NULL and contain the |
| * expression parse tree. |
| * @return The OID of the type of the argument. The type ID of polymorphic |
| * arguments is resolved if possible, i.e., if the expression parse tree |
| * is available in <tt>inFmgrInfo->fn_expr</tt>. |
| */ |
| inline |
| Oid |
| FunctionInformation::getArgumentType(uint16_t inArgID, FmgrInfo* inFmgrInfo) { |
| if (!inFmgrInfo) |
| inFmgrInfo = getFuncMgrInfo(); |
| |
| madlib_assert(inFmgrInfo && oid == inFmgrInfo->fn_oid, std::runtime_error( |
| "Invalid arguments passed to FunctionInformation::getArgumentType().")); |
| Oid typeID = argtypes[inArgID]; |
| TypeInformation* cachedTypeInfo = mSysInfo->typeInformation(typeID); |
| |
| if (cachedTypeInfo->getType() == TYPTYPE_PSEUDO |
| && inFmgrInfo->fn_expr != NULL) { |
| // Type is a pseudotype, so the actual type information is given |
| // by the expression parse tree. |
| // This would fail if no expression parse tree is present, i.e., if |
| // inFmgrInfo->fn_expr == NULL. |
| |
| typeID = madlib_get_fn_expr_argtype(inFmgrInfo, inArgID); |
| } |
| |
| return typeID; |
| } |
| |
| /** |
| * @brief Retrieve the function return type |
| * |
| * @param fcinfo Information about function call, including the function OID |
| * @return The actual return type (i.e., with resolved pseudo-types) |
| */ |
| inline |
| Oid |
| FunctionInformation::getReturnType(FunctionCallInfo fcinfo) { |
| madlib_assert(fcinfo->flinfo && oid == fcinfo->flinfo->fn_oid, |
| std::runtime_error("Invalid arguments passed to " |
| "FunctionInformation::getReturnType().")); |
| |
| Oid returnType = rettype; |
| if (rettype != RECORDOID && |
| mSysInfo->typeInformation(rettype)->type == TYPTYPE_PSEUDO) { |
| // The function is polymorphic, and the result type thus depends on the |
| // expression parse tree. Note that the condition in the if-clause is |
| // sufficient condition for cachedFuncInfo->polymorphic, but not a |
| // necessary condition. (A function could have input arguments with |
| // pseudo types, but a fixed return type.) |
| |
| madlib_assert(polymorphic, |
| std::logic_error("Logical error: Function returns non-record " |
| "pseudo type but is not polymorphic.")); |
| |
| // This is not a composite type, so no need to pass anything for |
| // resultTupleDesc |
| madlib_get_call_result_type(fcinfo, &returnType, |
| /* resultTupleDesc */ NULL); |
| } |
| |
| return returnType; |
| } |
| |
| /** |
| * @brief Retrieve the tuple description of a function's return type |
| * |
| * @param fcinfo Information about function call, including the function OID |
| * @return The tuple description if the return type is composite and NULL |
| * otherwise |
| */ |
| inline |
| TupleDesc |
| FunctionInformation::getReturnTupleDesc(FunctionCallInfo fcinfo) { |
| madlib_assert(fcinfo->flinfo && oid == fcinfo->flinfo->fn_oid, |
| std::runtime_error("Invalid arguments passed to " |
| "FunctionInformation::getReturnTupleDesc().")); |
| |
| TupleDesc returnTupDesc = tupdesc; |
| if (returnTupDesc == NULL) { |
| if (rettype == RECORDOID) { |
| MADLIB_PG_TRY { |
| // The return type is known, so no need to pass anything for |
| // resultTypeId |
| // get_call_result_type() creates the tuple description using |
| // lookup_rowtype_tupdesc_copy(), which is not reference-counted |
| // So there is no need to release the TupleDesc |
| get_call_result_type(fcinfo, /* resultTypeId */ NULL, |
| &returnTupDesc); |
| } MADLIB_PG_DEFAULT_CATCH_AND_END_TRY; |
| |
| if (returnTupDesc == NULL) { |
| throw std::runtime_error("MADLIB-870: C++ abstract layer has " |
| "not supported UDFs that return RECORD type without " |
| "tuple described at call time"); |
| } |
| |
| MADLIB_PG_TRY { |
| if (!polymorphic) { |
| // Since the function is not polymorphic, we can store the |
| // tuple description for other calls |
| MemoryContext oldContext |
| = MemoryContextSwitchTo(mSysInfo->cacheContext); |
| tupdesc = CreateTupleDescCopyConstr(returnTupDesc); |
| MemoryContextSwitchTo(oldContext); |
| } |
| } MADLIB_PG_DEFAULT_CATCH_AND_END_TRY; |
| } else { |
| TypeInformation* cachedTypeInfo |
| = mSysInfo->typeInformation(rettype); |
| |
| if (cachedTypeInfo->type == TYPTYPE_COMPOSITE) |
| returnTupDesc = cachedTypeInfo->tupdesc; |
| } |
| } |
| |
| return returnTupDesc; |
| } |
| |
| /** |
| * @brief Retrieve (cross-call) system-catalog information about the function |
| * |
| * @param inFuncID The OID of the function of interest |
| * @return A filled FmgrInfo struct which uses the current SystemInformation |
| * object as system-catalog cache |
| * |
| * If no FmgrInfo data is stored for the function of interest, this |
| * function creates a new struct FmgrInfo and stores it in the current |
| * FunctionInformation object. It also links the new FmgrInfo struct to the |
| * currently used SystemInformation object. |
| * |
| * @note Cached FmgrInfo data is *not* used for entry functions (i.e., the |
| * immediate call by the backend). For the entry function, a complete |
| * struct FunctionCallInfoData is passed by the backend itself, which is |
| * used instead (as it also contains the parse tree). |
| */ |
| inline |
| FmgrInfo* |
| FunctionInformation::getFuncMgrInfo() { |
| // Initially flinfo.fn_oid is set to InvalidOid |
| if (flinfo.fn_oid != oid) { |
| // Check permissions |
| if (madlib_pg_proc_aclcheck(oid, GetUserId(), ACL_EXECUTE) |
| != ACLCHECK_OK) { |
| |
| throw std::invalid_argument(std::string("No privilege to run " |
| "function '") + getFullName() + "'."); |
| } |
| |
| // cacheContext will be set as fn_mcxt. |
| madlib_fmgr_info_cxt(oid, &flinfo, mSysInfo->cacheContext); |
| |
| if (!secdef) { |
| // If the function is SECURITY DEFINER then fmgr_info_cxt() has |
| // set up flinfo so that what we will actually |
| // call fmgr_security_definer() in fmgr.c, which then calls the |
| // "real" function. Because of this additional layer, and since |
| // fmgr_security_definer() uses the fn_extra field of |
| // struct FmgrInfo in an opaque way (it points to a struct that is |
| // local to fmgr.c), we only initialize the cache if the function |
| // is *not* SECURITY DEFINER. |
| setSystemInformationInFmgrInfo(&flinfo, mSysInfo); |
| } |
| } |
| |
| return &flinfo; |
| } |
| |
| /** |
| * @brief Retrieve the full function name (including arguments) |
| * |
| * We currently do not cache this information because we expect this function |
| * to be primarily called by error handlers. |
| */ |
| inline |
| const char* |
| FunctionInformation::getFullName() { |
| return madlib_format_procedure(oid); |
| } |
| |
| } // namespace postgres |
| |
| } // namespace dbconnector |
| |
| } // namespace madlib |
| |
| #endif // defined(MADLIB_POSTGRES_SYSTEMINFORMATION_IMPL_HPP) |
