builtins.h File Reference

#include "fmgr.h"
#include "nodes/nodes.h"
#include "utils/fmgrprotos.h"

Include dependency graph for builtins.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros
#define	MAXINT8LEN   20
#define	CStringGetTextDatum(s)   PointerGetDatum(cstring_to_text(s))
#define	TextDatumGetCString(d)   text_to_cstring((text *) DatumGetPointer(d))
#define	FORMAT_TYPE_TYPEMOD_GIVEN   0x01 /* typemod defined by caller */
#define	FORMAT_TYPE_ALLOW_INVALID   0x02 /* allow invalid types */
#define	FORMAT_TYPE_FORCE_QUALIFY   0x04 /* force qualification of type */
#define	FORMAT_TYPE_INVALID_AS_NULL   0x08 /* NULL if undefined */

Functions
bool	parse_bool (const char *value, bool *result)
bool	parse_bool_with_len (const char *value, size_t len, bool *result)
void	domain_check (Datum value, bool isnull, Oid domainType, void **extra, MemoryContext mcxt)
bool	domain_check_safe (Datum value, bool isnull, Oid domainType, void **extra, MemoryContext mcxt, Node *escontext)
int	errdatatype (Oid datatypeOid)
int	errdomainconstraint (Oid datatypeOid, const char *conname)
uint64	hex_encode (const char *src, size_t len, char *dst)
uint64	hex_decode (const char *src, size_t len, char *dst)
uint64	hex_decode_safe (const char *src, size_t len, char *dst, Node *escontext)
int2vector *	buildint2vector (const int16 *int2s, int n)
void	namestrcpy (Name name, const char *str)
int	namestrcmp (Name name, const char *str)
int16	pg_strtoint16 (const char *s)
int16	pg_strtoint16_safe (const char *s, Node *escontext)
int32	pg_strtoint32 (const char *s)
int32	pg_strtoint32_safe (const char *s, Node *escontext)
int64	pg_strtoint64 (const char *s)
int64	pg_strtoint64_safe (const char *s, Node *escontext)
uint32	uint32in_subr (const char *s, char **endloc, const char *typname, Node *escontext)
uint64	uint64in_subr (const char *s, char **endloc, const char *typname, Node *escontext)
int	pg_itoa (int16 i, char *a)
int	pg_ultoa_n (uint32 value, char *a)
int	pg_ulltoa_n (uint64 value, char *a)
int	pg_ltoa (int32 value, char *a)
int	pg_lltoa (int64 value, char *a)
char *	pg_ultostr_zeropad (char *str, uint32 value, int32 minwidth)
char *	pg_ultostr (char *str, uint32 value)
oidvector *	buildoidvector (const Oid *oids, int n)
Oid	oidparse (Node *node)
int	oid_cmp (const void *p1, const void *p2)
char *	regexp_fixed_prefix (text *text_re, bool case_insensitive, Oid collation, bool *exact)
const char *	quote_identifier (const char *ident)
char *	quote_qualified_identifier (const char *qualifier, const char *ident)
void	generate_operator_clause (fmStringInfo buf, const char *leftop, Oid leftoptype, Oid opoid, const char *rightop, Oid rightoptype)
int	bpchartruelen (char *s, int len)
text *	cstring_to_text (const char *s)
text *	cstring_to_text_with_len (const char *s, int len)
char *	text_to_cstring (const text *t)
void	text_to_cstring_buffer (const text *src, char *dst, size_t dst_len)
int	xidComparator (const void *arg1, const void *arg2)
int	xidLogicalComparator (const void *arg1, const void *arg2)
char *	pg_inet_cidr_ntop (int af, const void *src, int bits, char *dst, size_t size)
int	pg_inet_net_pton (int af, const char *src, void *dst, size_t size)
double	convert_network_to_scalar (Datum value, Oid typid, bool *failure)
Datum	network_scan_first (Datum in)
Datum	network_scan_last (Datum in)
void	clean_ipv6_addr (int addr_family, char *addr)
Datum	numeric_float8_no_overflow (PG_FUNCTION_ARGS)
char *	format_type_extended (Oid type_oid, int32 typemod, bits16 flags)
char *	format_type_be (Oid type_oid)
char *	format_type_be_qualified (Oid type_oid)
char *	format_type_with_typemod (Oid type_oid, int32 typemod)
int32	type_maximum_size (Oid type_oid, int32 typemod)
char *	quote_literal_cstr (const char *rawstr)

Variables
PGDLLIMPORT bool	quote_all_identifiers

Macro Definition Documentation

CStringGetTextDatum

#define CStringGetTextDatum

(

s

)

PointerGetDatum(cstring_to_text(s))

Definition at line 97 of file builtins.h.

FORMAT_TYPE_ALLOW_INVALID

#define FORMAT_TYPE_ALLOW_INVALID   0x02 /* allow invalid types */

Definition at line 125 of file builtins.h.

FORMAT_TYPE_FORCE_QUALIFY

#define FORMAT_TYPE_FORCE_QUALIFY   0x04 /* force qualification of type */

Definition at line 126 of file builtins.h.

FORMAT_TYPE_INVALID_AS_NULL

#define FORMAT_TYPE_INVALID_AS_NULL   0x08 /* NULL if undefined */

Definition at line 127 of file builtins.h.

FORMAT_TYPE_TYPEMOD_GIVEN

#define FORMAT_TYPE_TYPEMOD_GIVEN   0x01 /* typemod defined by caller */

Definition at line 124 of file builtins.h.

MAXINT8LEN

#define MAXINT8LEN   20

Definition at line 22 of file builtins.h.

TextDatumGetCString

#define TextDatumGetCString

(

d

)

text_to_cstring((text *) DatumGetPointer(d))

Definition at line 98 of file builtins.h.

Function Documentation

bpchartruelen()

int bpchartruelen	(	char *	s,
		int	len
	)

Definition at line 676 of file varchar.c.

{
    int         i;
 
    /*
     * Note that we rely on the assumption that ' ' is a singleton unit on
     * every supported multibyte server encoding.
     */
    for (i = len - 1; i >= 0; i--)
    {
        if (s[i] != ' ')
            break;
    }
    return i + 1;
}

References i, and len.

Referenced by bcTruelen(), bpcharfastcmp_c(), varstr_abbrev_convert(), and varstrfastcmp_locale().

buildint2vector()

int2vector * buildint2vector	(	const int16 *	int2s,
		int	n
	)

Definition at line 114 of file int.c.

{
    int2vector *result;
 
    result = (int2vector *) palloc0(Int2VectorSize(n));
 
    if (n > 0 && int2s)
        memcpy(result->values, int2s, n * sizeof(int16));
 
    /*
     * Attach standard array header.  For historical reasons, we set the index
     * lower bound to 0 not 1.
     */
    SET_VARSIZE(result, Int2VectorSize(n));
    result->ndim = 1;
    result->dataoffset = 0;     /* never any nulls */
    result->elemtype = INT2OID;
    result->dim1 = n;
    result->lbound1 = 0;
 
    return result;
}

References int2vector::dataoffset, int2vector::dim1, int2vector::elemtype, Int2VectorSize, int2vector::lbound1, int2vector::ndim, palloc0(), SET_VARSIZE, and int2vector::values.

Referenced by attnumstoint2vector(), CreateStatistics(), CreateTriggerFiringOn(), pg_get_publication_tables(), StorePartitionKey(), and UpdateIndexRelation().

buildoidvector()

oidvector * buildoidvector	(	const Oid *	oids,
		int	n
	)

Definition at line 87 of file oid.c.

{
    oidvector  *result;
 
    result = (oidvector *) palloc0(OidVectorSize(n));
 
    if (n > 0 && oids)
        memcpy(result->values, oids, n * sizeof(Oid));
 
    /*
     * Attach standard array header.  For historical reasons, we set the index
     * lower bound to 0 not 1.
     */
    SET_VARSIZE(result, OidVectorSize(n));
    result->ndim = 1;
    result->dataoffset = 0;     /* never any nulls */
    result->elemtype = OIDOID;
    result->dim1 = n;
    result->lbound1 = 0;
 
    return result;
}

References oidvector::dataoffset, oidvector::dim1, oidvector::elemtype, oidvector::lbound1, oidvector::ndim, OidVectorSize, palloc0(), SET_VARSIZE, and oidvector::values.

Referenced by DefineAggregate(), interpret_function_parameter_list(), makeMultirangeConstructors(), makeRangeConstructors(), StorePartitionKey(), and UpdateIndexRelation().

clean_ipv6_addr()

void clean_ipv6_addr	(	int	addr_family,
		char *	addr
	)

Definition at line 2089 of file network.c.

{
    if (addr_family == AF_INET6)
    {
        char       *pct = strchr(addr, '%');
 
        if (pct)
            *pct = '\0';
    }
}

Referenced by fill_hba_line(), inet_client_addr(), inet_server_addr(), pg_stat_get_activity(), and pg_stat_get_backend_client_addr().

convert_network_to_scalar()

double convert_network_to_scalar	(	Datum	value,
		Oid	typid,
		bool *	failure
	)

Definition at line 1496 of file network.c.

{
    switch (typid)
    {
        case INETOID:
        case CIDROID:
            {
                inet       *ip = DatumGetInetPP(value);
                int         len;
                double      res;
                int         i;
 
                /*
                 * Note that we don't use the full address for IPv6.
                 */
                if (ip_family(ip) == PGSQL_AF_INET)
                    len = 4;
                else
                    len = 5;
 
                res = ip_family(ip);
                for (i = 0; i < len; i++)
                {
                    res *= 256;
                    res += ip_addr(ip)[i];
                }
                return res;
            }
        case MACADDROID:
            {
                macaddr    *mac = DatumGetMacaddrP(value);
                double      res;
 
                res = (mac->a << 16) | (mac->b << 8) | (mac->c);
                res *= 256 * 256 * 256;
                res += (mac->d << 16) | (mac->e << 8) | (mac->f);
                return res;
            }
        case MACADDR8OID:
            {
                macaddr8   *mac = DatumGetMacaddr8P(value);
                double      res;
 
                res = (mac->a << 24) | (mac->b << 16) | (mac->c << 8) | (mac->d);
                res *= ((double) 256) * 256 * 256 * 256;
                res += (mac->e << 24) | (mac->f << 16) | (mac->g << 8) | (mac->h);
                return res;
            }
    }
 
    *failure = true;
    return 0;
}

References macaddr::a, macaddr8::a, macaddr::b, macaddr8::b, macaddr::c, macaddr8::c, macaddr::d, macaddr8::d, DatumGetInetPP(), DatumGetMacaddr8P(), DatumGetMacaddrP(), macaddr::e, macaddr8::e, macaddr::f, macaddr8::f, macaddr8::g, macaddr8::h, i, ip_addr, ip_family, len, PGSQL_AF_INET, res, and value.

Referenced by convert_to_scalar(), gbt_inet_compress(), and gbt_inet_consistent().

cstring_to_text()

text * cstring_to_text

(

const char *

s

)

Definition at line 184 of file varlena.c.

{
    return cstring_to_text_with_len(s, strlen(s));
}

References cstring_to_text_with_len().

Referenced by array_dims(), ASN1_STRING_to_text(), booltext(), brin_minmax_multi_summary_out(), brin_page_type(), build_test_info_result(), build_test_match_result(), cidr_abbrev(), convert_charset(), cstring_to_xmltype(), current_query(), datetime_to_char_body(), dblink_build_sql_delete(), dblink_build_sql_insert(), dblink_build_sql_update(), dblink_cancel_query(), dblink_close(), dblink_connect(), dblink_disconnect(), dblink_error_message(), dblink_exec(), dblink_open(), dmetaphone(), dmetaphone_alt(), exec_assign_c_string(), executeDateTimeMethod(), filter_list_to_array(), format_type(), get_command_tag(), get_command_type(), get_scalar(), hash_page_type(), icu_unicode_version(), inet_abbrev(), initcap(), json_in(), json_typeof(), jsonb_get_element(), jsonb_typeof(), JsonbValueAsText(), lower(), md5_bytea(), md5_text(), metaphone(), name_bpchar(), name_text(), network_host(), network_show(), oidvectortypes(), ParameterAclCreate(), ParameterAclLookup(), pg_collation_actual_version(), pg_collation_for(), pg_column_compression(), pg_crypt(), pg_current_logfile(), pg_database_collation_actual_version(), pg_describe_object(), pg_export_snapshot(), pg_get_statisticsobjdef_expressions(), pg_get_wal_replay_pause_state(), pg_parameter_aclmask(), pg_relation_filepath(), pg_size_pretty(), pg_size_pretty_numeric(), pg_stat_get_backend_activity(), pg_stat_get_backend_wait_event(), pg_stat_get_backend_wait_event_type(), pg_stat_get_slru(), pg_stats_ext_mcvlist_items(), pg_tablespace_location(), pg_walfile_name(), pg_xact_status(), pgsql_version(), pgxml_result_to_text(), quote_ident(), quote_ident_cstr(), quote_nullable(), sepgsql_getcon(), sepgsql_mcstrans_in(), sepgsql_mcstrans_out(), set_config_by_name(), show_all_file_settings(), show_config_by_name(), show_config_by_name_missing_ok(), ShowAllGUCConfig(), soundex(), split_part(), ssl_cipher(), ssl_client_dn(), ssl_issuer_dn(), ssl_version(), string_to_text(), test_canonicalize_path(), test_slru_page_read(), test_slru_page_readonly(), text_substring(), textin(), timeofday(), timetz_at_local(), tsquerytree(), unaccent_dict(), unicode_version(), upper(), xml_encode_special_chars(), xml_in(), and xml_recv().

cstring_to_text_with_len()

text * cstring_to_text_with_len	(	const char *	s,
		int	len
	)

Definition at line 196 of file varlena.c.

{
    text       *result = (text *) palloc(len + VARHDRSZ);
 
    SET_VARSIZE(result, len + VARHDRSZ);
    memcpy(VARDATA(result), s, len);
 
    return result;
}

References len, palloc(), SET_VARSIZE, VARDATA, and VARHDRSZ.

Referenced by array_to_json(), array_to_json_pretty(), array_to_text_internal(), brin_minmax_multi_summary_out(), build_regexp_match_result(), build_regexp_split_result(), build_test_match_result(), cash_words(), compute_tsvector_stats(), concat_internal(), convert_to_base(), cstring_to_text(), daitch_mokotoff_coding(), datum_to_json(), do_text_output_multiline(), dotrim(), each_object_field_end(), each_worker_jsonb(), elements_array_element_end(), ExecEvalMergeSupportFunc(), ExecEvalXmlExpr(), executeDateTimeMethod(), executeLikeRegex(), find_or_create_child_node(), fsm_page_contents(), get_array_element_end(), get_array_end(), get_object_end(), get_object_field_end(), get_scalar(), gin_extract_tsquery(), gin_extract_tsvector(), hstore_akeys(), hstore_avals(), hstore_each(), hstore_fetchval(), hstore_skeys(), hstore_slice_to_array(), hstore_subscript_fetch(), hstore_svals(), hstore_to_array_internal(), hstore_to_json(), hstore_to_json_loose(), json_build_array_noargs(), json_build_array_worker(), json_build_object_noargs(), json_build_object_worker(), json_object(), json_object_two_arg(), json_recv(), json_strip_nulls(), jsonb_pretty(), JsonbValueAsText(), leftmostvalue_text(), LogicalOutputWrite(), parse_ident(), pg_gen_salt(), pg_gen_salt_rounds(), pg_get_function_sqlbody(), replace_text(), replace_text_regexp(), row_to_json(), row_to_json_pretty(), serialize_deflist(), split_part(), split_text(), ssl_extension_info(), string_agg_finalfn(), stringinfo_to_xmltype(), text_format(), text_left(), text_right(), textrecv(), transform_json_string_values(), tsquerytree(), tsvector_to_array(), tsvector_unnest(), unistr(), varchar(), varchar_input(), xmltext(), xmltotext_with_options(), and xslt_process().

domain_check()

void domain_check	(	Datum	value,
		bool	isnull,
		Oid	domainType,
		void **	extra,
		MemoryContext	mcxt
	)

Definition at line 346 of file domains.c.

{
    (void) domain_check_internal(value, isnull, domainType, extra, mcxt,
                                 NULL);
}

References domain_check_internal(), and value.

Referenced by check_domain_for_new_field(), check_domain_for_new_tuple(), expanded_record_set_fields(), hstore_populate_record(), plperl_return_next_internal(), plperl_sv_to_datum(), plpgsql_exec_function(), pltcl_build_tuple_result(), and PLyObject_ToDomain().

domain_check_safe()

bool domain_check_safe	(	Datum	value,
		bool	isnull,
		Oid	domainType,
		void **	extra,
		MemoryContext	mcxt,
		Node *	escontext
	)

Definition at line 355 of file domains.c.

{
    return domain_check_internal(value, isnull, domainType, extra, mcxt,
                                 escontext);
}

References domain_check_internal(), and value.

Referenced by ExecEvalJsonCoercion(), populate_composite(), populate_domain(), and populate_recordset_record().

errdatatype()

int errdatatype

(

Oid

datatypeOid

)

Definition at line 407 of file domains.c.

{
    HeapTuple   tup;
    Form_pg_type typtup;
 
    tup = SearchSysCache1(TYPEOID, ObjectIdGetDatum(datatypeOid));
    if (!HeapTupleIsValid(tup))
        elog(ERROR, "cache lookup failed for type %u", datatypeOid);
    typtup = (Form_pg_type) GETSTRUCT(tup);
 
    err_generic_string(PG_DIAG_SCHEMA_NAME,
                       get_namespace_name(typtup->typnamespace));
    err_generic_string(PG_DIAG_DATATYPE_NAME, NameStr(typtup->typname));
 
    ReleaseSysCache(tup);
 
    return 0;                   /* return value does not matter */
}

References elog, err_generic_string(), ERROR, get_namespace_name(), GETSTRUCT, HeapTupleIsValid, NameStr, ObjectIdGetDatum(), PG_DIAG_DATATYPE_NAME, PG_DIAG_SCHEMA_NAME, ReleaseSysCache(), and SearchSysCache1().

Referenced by domain_check_input(), errdomainconstraint(), and ExecEvalConstraintNotNull().

errdomainconstraint()

int errdomainconstraint	(	Oid	datatypeOid,
		const char *	conname
	)

Definition at line 431 of file domains.c.

{
    errdatatype(datatypeOid);
    err_generic_string(PG_DIAG_CONSTRAINT_NAME, conname);
 
    return 0;                   /* return value does not matter */
}

References err_generic_string(), errdatatype(), and PG_DIAG_CONSTRAINT_NAME.

Referenced by domain_check_input(), and ExecEvalConstraintCheck().

format_type_be()

char * format_type_be

(

Oid

type_oid

)

Definition at line 343 of file format_type.c.

{
    return format_type_extended(type_oid, -1, 0);
}

References format_type_extended().

Referenced by aclcheck_error_type(), addFamilyMember(), addRangeTableEntryForFunction(), AggregateCreate(), AlterType(), AlterTypeNamespace(), AlterTypeNamespace_oid(), AlterTypeNamespaceInternal(), AlterTypeOwner(), AlterTypeOwnerInternal(), analyzeCTE(), appendTypeNameToBuffer(), array_cat(), array_cmp(), array_contain_compare(), array_eq(), array_position_common(), array_positions(), array_recv(), array_replace_internal(), array_send(), assign_record_type_identifier(), ATAddForeignKeyConstraint(), ATExecAlterColumnType(), ATPrepAlterColumnType(), brinvalidate(), btvalidate(), build_attrmap_by_name(), build_column_default(), build_datatype(), build_subplan(), CastCreate(), check_object_ownership(), check_of_type(), check_safe_enum_use(), check_sql_fn_retval(), check_valid_polymorphic_signature(), CheckAttributeType(), checkDomainOwner(), checkEnumOwner(), checkRuleResultList(), CheckVarSlotCompatibility(), coerce_record_to_complex(), coerce_to_boolean(), coerce_to_common_type(), coerce_to_specific_type_typmod(), coerce_type(), coerceJsonFuncExpr(), compare_values_of_enum(), compile_plperl_function(), compile_pltcl_function(), ComputeIndexAttrs(), ComputePartitionAttrs(), cookDefault(), create_ctas_nodata(), CreateCast(), CreateFunction(), CreateStatistics(), CreateTransform(), DefineAggregate(), DefineDomain(), DefineRange(), DefineType(), do_compile(), domain_check_input(), domain_state_setup(), dropOperators(), dropProcedures(), enforce_generic_type_consistency(), enum_first(), enum_in(), enum_last(), enum_recv(), EvaluateParams(), exec_stmt_foreach_a(), ExecAlterExtensionContentsRecurse(), ExecBuildUpdateProjection(), ExecCheckPlanOutput(), ExecEvalArrayExpr(), ExecEvalConstraintCheck(), ExecEvalConstraintNotNull(), ExecEvalFieldSelect(), ExecEvalParamExtern(), ExecEvalWholeRowVar(), ExecInitAgg(), ExecInitExprRec(), ExecInitSubscriptingRef(), exprType(), extract_date(), fetch_cursor_param_value(), findRangeSubOpclass(), findTypeInputFunction(), findTypeReceiveFunction(), fmgr_sql_validator(), format_operator_extended(), format_procedure_extended(), funcname_signature_string(), get_cached_rowtype(), get_cast_oid(), get_domain_constraint_oid(), get_expr_result_tupdesc(), get_multirange_io_data(), get_range_io_data(), get_rels_with_domain(), get_sort_group_operators(), get_transform_oid(), get_ts_parser_func(), get_ts_template_func(), GetAttributeCompression(), GetAttributeStorage(), GetColumnDefCollation(), GetDefaultOpClass(), getObjectDescription(), GetOperatorFromCompareType(), getTypeBinaryInputInfo(), getTypeBinaryOutputInfo(), getTypeInputInfo(), getTypeOutputInfo(), hash_array(), hash_array_extended(), hash_multirange(), hash_multirange_extended(), hash_range(), hash_range_extended(), hash_record(), hash_record_extended(), hashvalidate(), init_params(), initArrayResultArr(), initGinState(), internal_get_result_type(), interval_part_common(), interval_trunc(), intorel_startup(), jsonb_subscript_transform(), JsonItemFromDatum(), load_enum_cache_data(), lookup_rowtype_tupdesc_domain(), lookup_rowtype_tupdesc_internal(), LookupTypeNameExtended(), make_expanded_record_from_tupdesc(), make_expanded_record_from_typeid(), make_row_comparison_op(), make_scalar_array_op(), NonFiniteIntervalPart(), NonFiniteTimestampTzPart(), op_signature_string(), ParseFuncOrColumn(), pg_collation_for(), plperl_array_to_datum(), plperl_sv_to_datum(), plperl_validator(), plpgsql_build_datatype_arrayof(), plpgsql_build_variable(), plpgsql_param_eval_generic(), plpgsql_param_eval_generic_ro(), plpgsql_param_eval_recfield(), plpgsql_validator(), PLy_procedure_create(), prepare_sql_fn_parse_info(), print_function_arguments(), print_function_rettype(), print_function_trftypes(), processIndirection(), record_cmp(), record_eq(), record_image_cmp(), record_image_eq(), regtypeout(), RelationBuildPartitionKey(), RenameConstraintById(), RenameType(), resolve_anyarray_from_others(), resolve_anyelement_from_others(), resolve_anymultirange_from_others(), resolve_anyrange_from_others(), ResolveOpClass(), revalidate_rectypeid(), ri_HashCompareOp(), satisfies_hash_partition(), select_common_type(), select_common_type_from_oids(), spgvalidate(), stats_check_arg_type(), stats_fill_fcinfo_from_arg_pairs(), storeOperators(), storeProcedures(), time_part_common(), timestamp_part_common(), timestamp_trunc(), timestamptz_part_common(), timestamptz_trunc_internal(), timetz_part_common(), transformAggregateCall(), transformArrayExpr(), transformAssignedExpr(), transformAssignmentIndirection(), transformAssignmentSubscripts(), transformCollateClause(), transformColumnType(), transformContainerSubscripts(), transformFrameOffset(), transformJsonBehavior(), transformJsonFuncExpr(), transformJsonIsPredicate(), transformJsonReturning(), transformJsonSerializeExpr(), transformJsonValueExpr(), transformPartitionBoundValue(), transformPLAssignStmt(), transformTypeCast(), transformXmlSerialize(), tuple_to_stringinfo(), tupledesc_match(), tuples_equal(), unknown_attribute(), validateConnectbyTupleDesc(), variable_coerce_param_hook(), and width_bucket_array().

format_type_be_qualified()

char * format_type_be_qualified

(

Oid

type_oid

)

Definition at line 353 of file format_type.c.

{
    return format_type_extended(type_oid, -1, FORMAT_TYPE_FORCE_QUALIFY);
}

References format_type_extended(), and FORMAT_TYPE_FORCE_QUALIFY.

Referenced by format_operator_extended(), format_operator_parts(), format_procedure_extended(), format_procedure_parts(), and getObjectIdentityParts().

format_type_extended()

char * format_type_extended	(	Oid	type_oid,
		int32	typemod,
		bits16	flags
	)

Definition at line 112 of file format_type.c.

{
    HeapTuple   tuple;
    Form_pg_type typeform;
    Oid         array_base_type;
    bool        is_array;
    char       *buf;
    bool        with_typemod;
 
    if (type_oid == InvalidOid)
    {
        if ((flags & FORMAT_TYPE_INVALID_AS_NULL) != 0)
            return NULL;
        else if ((flags & FORMAT_TYPE_ALLOW_INVALID) != 0)
            return pstrdup("-");
    }
 
    tuple = SearchSysCache1(TYPEOID, ObjectIdGetDatum(type_oid));
    if (!HeapTupleIsValid(tuple))
    {
        if ((flags & FORMAT_TYPE_INVALID_AS_NULL) != 0)
            return NULL;
        else if ((flags & FORMAT_TYPE_ALLOW_INVALID) != 0)
            return pstrdup("???");
        else
            elog(ERROR, "cache lookup failed for type %u", type_oid);
    }
    typeform = (Form_pg_type) GETSTRUCT(tuple);
 
    /*
     * Check if it's a "true" array type.  Pseudo-array types such as "name"
     * shouldn't get deconstructed.  Also check the toast property, and don't
     * deconstruct "plain storage" array types --- this is because we don't
     * want to show oidvector as oid[].
     */
    array_base_type = typeform->typelem;
 
    if (IsTrueArrayType(typeform) &&
        typeform->typstorage != TYPSTORAGE_PLAIN)
    {
        /* Switch our attention to the array element type */
        ReleaseSysCache(tuple);
        tuple = SearchSysCache1(TYPEOID, ObjectIdGetDatum(array_base_type));
        if (!HeapTupleIsValid(tuple))
        {
            if ((flags & FORMAT_TYPE_INVALID_AS_NULL) != 0)
                return NULL;
            else if ((flags & FORMAT_TYPE_ALLOW_INVALID) != 0)
                return pstrdup("???[]");
            else
                elog(ERROR, "cache lookup failed for type %u", type_oid);
        }
        typeform = (Form_pg_type) GETSTRUCT(tuple);
        type_oid = array_base_type;
        is_array = true;
    }
    else
        is_array = false;
 
    with_typemod = (flags & FORMAT_TYPE_TYPEMOD_GIVEN) != 0 && (typemod >= 0);
 
    /*
     * See if we want to special-case the output for certain built-in types.
     * Note that these special cases should all correspond to special
     * productions in gram.y, to ensure that the type name will be taken as a
     * system type, not a user type of the same name.
     *
     * If we do not provide a special-case output here, the type name will be
     * handled the same way as a user type name --- in particular, it will be
     * double-quoted if it matches any lexer keyword.  This behavior is
     * essential for some cases, such as types "bit" and "char".
     */
    buf = NULL;                 /* flag for no special case */
 
    switch (type_oid)
    {
        case BITOID:
            if (with_typemod)
                buf = printTypmod("bit", typemod, typeform->typmodout);
            else if ((flags & FORMAT_TYPE_TYPEMOD_GIVEN) != 0)
            {
                /*
                 * bit with typmod -1 is not the same as BIT, which means
                 * BIT(1) per SQL spec.  Report it as the quoted typename so
                 * that parser will not assign a bogus typmod.
                 */
            }
            else
                buf = pstrdup("bit");
            break;
 
        case BOOLOID:
            buf = pstrdup("boolean");
            break;
 
        case BPCHAROID:
            if (with_typemod)
                buf = printTypmod("character", typemod, typeform->typmodout);
            else if ((flags & FORMAT_TYPE_TYPEMOD_GIVEN) != 0)
            {
                /*
                 * bpchar with typmod -1 is not the same as CHARACTER, which
                 * means CHARACTER(1) per SQL spec.  Report it as bpchar so
                 * that parser will not assign a bogus typmod.
                 */
            }
            else
                buf = pstrdup("character");
            break;
 
        case FLOAT4OID:
            buf = pstrdup("real");
            break;
 
        case FLOAT8OID:
            buf = pstrdup("double precision");
            break;
 
        case INT2OID:
            buf = pstrdup("smallint");
            break;
 
        case INT4OID:
            buf = pstrdup("integer");
            break;
 
        case INT8OID:
            buf = pstrdup("bigint");
            break;
 
        case NUMERICOID:
            if (with_typemod)
                buf = printTypmod("numeric", typemod, typeform->typmodout);
            else
                buf = pstrdup("numeric");
            break;
 
        case INTERVALOID:
            if (with_typemod)
                buf = printTypmod("interval", typemod, typeform->typmodout);
            else
                buf = pstrdup("interval");
            break;
 
        case TIMEOID:
            if (with_typemod)
                buf = printTypmod("time", typemod, typeform->typmodout);
            else
                buf = pstrdup("time without time zone");
            break;
 
        case TIMETZOID:
            if (with_typemod)
                buf = printTypmod("time", typemod, typeform->typmodout);
            else
                buf = pstrdup("time with time zone");
            break;
 
        case TIMESTAMPOID:
            if (with_typemod)
                buf = printTypmod("timestamp", typemod, typeform->typmodout);
            else
                buf = pstrdup("timestamp without time zone");
            break;
 
        case TIMESTAMPTZOID:
            if (with_typemod)
                buf = printTypmod("timestamp", typemod, typeform->typmodout);
            else
                buf = pstrdup("timestamp with time zone");
            break;
 
        case VARBITOID:
            if (with_typemod)
                buf = printTypmod("bit varying", typemod, typeform->typmodout);
            else
                buf = pstrdup("bit varying");
            break;
 
        case VARCHAROID:
            if (with_typemod)
                buf = printTypmod("character varying", typemod, typeform->typmodout);
            else
                buf = pstrdup("character varying");
            break;
 
        case JSONOID:
            buf = pstrdup("json");
            break;
    }
 
    if (buf == NULL)
    {
        /*
         * Default handling: report the name as it appears in the catalog.
         * Here, we must qualify the name if it is not visible in the search
         * path or if caller requests it; and we must double-quote it if it's
         * not a standard identifier or if it matches any keyword.
         */
        char       *nspname;
        char       *typname;
 
        if ((flags & FORMAT_TYPE_FORCE_QUALIFY) == 0 &&
            TypeIsVisible(type_oid))
            nspname = NULL;
        else
            nspname = get_namespace_name_or_temp(typeform->typnamespace);
 
        typname = NameStr(typeform->typname);
 
        buf = quote_qualified_identifier(nspname, typname);
 
        if (with_typemod)
            buf = printTypmod(buf, typemod, typeform->typmodout);
    }
 
    if (is_array)
        buf = psprintf("%s[]", buf);
 
    ReleaseSysCache(tuple);
 
    return buf;
}

References buf, elog, ERROR, FORMAT_TYPE_ALLOW_INVALID, FORMAT_TYPE_FORCE_QUALIFY, FORMAT_TYPE_INVALID_AS_NULL, FORMAT_TYPE_TYPEMOD_GIVEN, get_namespace_name_or_temp(), GETSTRUCT, HeapTupleIsValid, InvalidOid, NameStr, ObjectIdGetDatum(), printTypmod(), psprintf(), pstrdup(), quote_qualified_identifier(), ReleaseSysCache(), SearchSysCache1(), TypeIsVisible(), and typname.

Referenced by array_recv(), deparse_type_name(), format_type(), format_type_be(), format_type_be_qualified(), format_type_with_typemod(), gbtreekey_in(), getObjectDescription(), getObjectIdentityParts(), lookup_am_handler_func(), oidvectortypes(), and record_recv().

format_type_with_typemod()

char * format_type_with_typemod	(	Oid	type_oid,
		int32	typemod
	)

Definition at line 362 of file format_type.c.

{
    return format_type_extended(type_oid, typemod, FORMAT_TYPE_TYPEMOD_GIVEN);
}

References format_type_extended(), and FORMAT_TYPE_TYPEMOD_GIVEN.

Referenced by analyzeCTE(), ATPrepAlterColumnType(), build_attrmap_by_position(), checkRuleResultList(), checkViewColumns(), compatConnectbyTupleDescs(), compatCrosstabTupleDescs(), get_coercion_expr(), get_const_expr(), get_from_clause_coldeflist(), get_json_returning(), get_json_table_columns(), get_rule_expr(), get_rule_expr_funccall(), get_variable(), get_xmltable(), MergeChildAttribute(), and MergeInheritedAttribute().

generate_operator_clause()

void generate_operator_clause	(	fmStringInfo	buf,
		const char *	leftop,
		Oid	leftoptype,
		Oid	opoid,
		const char *	rightop,
		Oid	rightoptype
	)

Definition at line 13285 of file ruleutils.c.

{
    HeapTuple   opertup;
    Form_pg_operator operform;
    char       *oprname;
    char       *nspname;
 
    opertup = SearchSysCache1(OPEROID, ObjectIdGetDatum(opoid));
    if (!HeapTupleIsValid(opertup))
        elog(ERROR, "cache lookup failed for operator %u", opoid);
    operform = (Form_pg_operator) GETSTRUCT(opertup);
    Assert(operform->oprkind == 'b');
    oprname = NameStr(operform->oprname);
 
    nspname = get_namespace_name(operform->oprnamespace);
 
    appendStringInfoString(buf, leftop);
    if (leftoptype != operform->oprleft)
        add_cast_to(buf, operform->oprleft);
    appendStringInfo(buf, " OPERATOR(%s.", quote_identifier(nspname));
    appendStringInfoString(buf, oprname);
    appendStringInfo(buf, ") %s", rightop);
    if (rightoptype != operform->oprright)
        add_cast_to(buf, operform->oprright);
 
    ReleaseSysCache(opertup);
}

References add_cast_to(), appendStringInfo(), appendStringInfoString(), Assert, buf, elog, ERROR, get_namespace_name(), GETSTRUCT, HeapTupleIsValid, NameStr, ObjectIdGetDatum(), quote_identifier(), ReleaseSysCache(), and SearchSysCache1().

Referenced by refresh_by_match_merge(), and ri_GenerateQual().

hex_decode()

uint64 hex_decode	(	const char *	src,
		size_t	len,
		char *	dst
	)

Definition at line 190 of file encode.c.

{
    return hex_decode_safe(src, len, dst, NULL);
}

References hex_decode_safe(), and len.

hex_decode_safe()

uint64 hex_decode_safe	(	const char *	src,
		size_t	len,
		char *	dst,
		Node *	escontext
	)

Definition at line 196 of file encode.c.

{
    const char *s,
               *srcend;
    char        v1,
                v2,
               *p;
 
    srcend = src + len;
    s = src;
    p = dst;
    while (s < srcend)
    {
        if (*s == ' ' || *s == '\n' || *s == '\t' || *s == '\r')
        {
            s++;
            continue;
        }
        if (!get_hex(s, &v1))
            ereturn(escontext, 0,
                    (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                     errmsg("invalid hexadecimal digit: \"%.*s\"",
                            pg_mblen(s), s)));
        s++;
        if (s >= srcend)
            ereturn(escontext, 0,
                    (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                     errmsg("invalid hexadecimal data: odd number of digits")));
        if (!get_hex(s, &v2))
            ereturn(escontext, 0,
                    (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                     errmsg("invalid hexadecimal digit: \"%.*s\"",
                            pg_mblen(s), s)));
        s++;
        *p++ = (v1 << 4) | v2;
    }
 
    return p - dst;
}

References ereturn, errcode(), errmsg(), get_hex(), len, and pg_mblen().

Referenced by byteain(), and hex_decode().

hex_encode()

uint64 hex_encode	(	const char *	src,
		size_t	len,
		char *	dst
	)

Definition at line 162 of file encode.c.

{
    const char *end = src + len;
 
    while (src < end)
    {
        *dst++ = hextbl[(*src >> 4) & 0xF];
        *dst++ = hextbl[*src & 0xF];
        src++;
    }
    return (uint64) len * 2;
}

References hextbl, and len.

Referenced by AddFileToBackupManifest(), byteaout(), and SendBackupManifest().

namestrcmp()

int namestrcmp	(	Name	name,
		const char *	str
	)

Definition at line 247 of file name.c.

{
    if (!name && !str)
        return 0;
    if (!name)
        return -1;              /* NULL < anything */
    if (!str)
        return 1;               /* NULL < anything */
    return strncmp(NameStr(*name), str, NAMEDATALEN);
}

References name, NAMEDATALEN, NameStr, and str.

Referenced by AlterEventTrigger(), attnameAttNum(), CopyGetAttnums(), expanded_record_lookup_field(), GetAttributeByName(), InitPostgres(), NextCopyFromRawFields(), and SPI_fnumber().

namestrcpy()

void namestrcpy	(	Name	name,
		const char *	str
	)

Definition at line 233 of file name.c.

{
    /* NB: We need to zero-pad the destination. */
    strncpy(NameStr(*name), str, NAMEDATALEN);
    NameStr(*name)[NAMEDATALEN - 1] = '\0';
}

References name, NAMEDATALEN, NameStr, and str.

Referenced by AddEnumLabel(), AlterObjectRename_internal(), CatCacheCopyKeys(), CollationCreate(), ConstructTupleDescriptor(), ConversionCreate(), CreateConstraintEntry(), CreateInitDecodingContext(), CreateOpFamily(), CreateProceduralLanguage(), CreateStatistics(), current_database(), DefineAttr(), DefineOpClass(), DefineTSConfiguration(), DefineTSDictionary(), DefineTSParser(), DefineTSTemplate(), EnumValuesCreate(), ExecTypeSetColNames(), formrdesc(), getJsonEncodingConst(), index_concurrently_swap(), insert_event_trigger_tuple(), InsertRule(), NamespaceCreate(), OperatorCreate(), OperatorShellMake(), pg_stat_get_replication_slot(), ProcedureCreate(), RelationBuildLocalRelation(), RemoveAttributeById(), rename_policy(), renameatt_internal(), RenameConstraintById(), RenameDatabase(), RenameEnumLabel(), RenameRelationInternal(), RenameRewriteRule(), RenameSchema(), RenameTableSpace(), renametrig_internal(), RenameTypeInternal(), ReplicationSlotCreate(), ReplicationSlotName(), StoreIndexTuple(), synchronize_one_slot(), TupleDescInitBuiltinEntry(), TupleDescInitEntry(), TypeCreate(), TypeGetTupleDesc(), TypeShellMake(), and update_local_synced_slot().

network_scan_first()

Datum network_scan_first

(

Datum

in

)

Definition at line 1684 of file network.c.

{
    return DirectFunctionCall1(network_network, in);
}

References DirectFunctionCall1, and network_network().

Referenced by match_network_subset().

network_scan_last()

Datum network_scan_last

(

Datum

in

)

Definition at line 1698 of file network.c.

{
    return DirectFunctionCall2(inet_set_masklen,
                               DirectFunctionCall1(network_broadcast, in),
                               Int32GetDatum(-1));
}

References DirectFunctionCall1, DirectFunctionCall2, inet_set_masklen(), Int32GetDatum(), and network_broadcast().

Referenced by match_network_subset().

numeric_float8_no_overflow()

Datum numeric_float8_no_overflow

(

PG_FUNCTION_ARGS

)

Definition at line 4779 of file numeric.c.

{
    Numeric     num = PG_GETARG_NUMERIC(0);
    double      val;
 
    if (NUMERIC_IS_SPECIAL(num))
    {
        if (NUMERIC_IS_PINF(num))
            val = HUGE_VAL;
        else if (NUMERIC_IS_NINF(num))
            val = -HUGE_VAL;
        else
            val = get_float8_nan();
    }
    else
    {
        NumericVar  x;
 
        init_var_from_num(num, &x);
        val = numericvar_to_double_no_overflow(&x);
    }
 
    PG_RETURN_FLOAT8(val);
}

References get_float8_nan(), init_var_from_num(), NUMERIC_IS_NINF, NUMERIC_IS_PINF, NUMERIC_IS_SPECIAL, numericvar_to_double_no_overflow(), PG_GETARG_NUMERIC, PG_RETURN_FLOAT8, val, and x.

Referenced by convert_numeric_to_scalar(), and gbt_numeric_penalty().

oid_cmp()

int oid_cmp	(	const void *	p1,
		const void *	p2
	)

Definition at line 258 of file oid.c.

{
    Oid         v1 = *((const Oid *) p1);
    Oid         v2 = *((const Oid *) p2);
 
    return pg_cmp_u32(v1, v2);
}

References p2, and pg_cmp_u32().

Referenced by aclmembers(), AlterSubscription_refresh(), EnumValuesCreate(), and find_inheritance_children_extended().

oidparse()

Oid oidparse

(

Node *

node

)

Definition at line 235 of file oid.c.

{
    switch (nodeTag(node))
    {
        case T_Integer:
            return intVal(node);
        case T_Float:
 
            /*
             * Values too large for int4 will be represented as Float
             * constants by the lexer.  Accept these if they are valid OID
             * strings.
             */
            return uint32in_subr(castNode(Float, node)->fval, NULL,
                                 "oid", NULL);
        default:
            elog(ERROR, "unrecognized node type: %d", (int) nodeTag(node));
    }
    return InvalidOid;          /* keep compiler quiet */
}

References castNode, elog, ERROR, intVal, InvalidOid, nodeTag, and uint32in_subr().

Referenced by get_object_address().

parse_bool()

bool parse_bool	(	const char *	value,
		bool *	result
	)

Definition at line 31 of file bool.c.

{
    return parse_bool_with_len(value, strlen(value), result);
}

References parse_bool_with_len(), and value.

Referenced by executeItemOptUnwrapTarget(), GrantRole(), parse_and_validate_value(), parse_basebackup_options(), parse_extension_control_file(), parse_one_reloption(), pg_decode_startup(), and ProcessStartupPacket().

parse_bool_with_len()

bool parse_bool_with_len	(	const char *	value,
		size_t	len,
		bool *	result
	)

Definition at line 37 of file bool.c.

{
    /* Check the most-used possibilities first. */
    switch (*value)
    {
        case 't':
        case 'T':
            if (pg_strncasecmp(value, "true", len) == 0)
            {
                if (result)
                    *result = true;
                return true;
            }
            break;
        case 'f':
        case 'F':
            if (pg_strncasecmp(value, "false", len) == 0)
            {
                if (result)
                    *result = false;
                return true;
            }
            break;
        case 'y':
        case 'Y':
            if (pg_strncasecmp(value, "yes", len) == 0)
            {
                if (result)
                    *result = true;
                return true;
            }
            break;
        case 'n':
        case 'N':
            if (pg_strncasecmp(value, "no", len) == 0)
            {
                if (result)
                    *result = false;
                return true;
            }
            break;
        case 'o':
        case 'O':
            /* 'o' is not unique enough */
            if (pg_strncasecmp(value, "on", (len > 2 ? len : 2)) == 0)
            {
                if (result)
                    *result = true;
                return true;
            }
            else if (pg_strncasecmp(value, "off", (len > 2 ? len : 2)) == 0)
            {
                if (result)
                    *result = false;
                return true;
            }
            break;
        case '1':
            if (len == 1)
            {
                if (result)
                    *result = true;
                return true;
            }
            break;
        case '0':
            if (len == 1)
            {
                if (result)
                    *result = false;
                return true;
            }
            break;
        default:
            break;
    }
 
    if (result)
        *result = false;        /* suppress compiler warning */
    return false;
}

References len, pg_strncasecmp(), and value.

Referenced by boolin(), and parse_bool().

pg_inet_cidr_ntop()

char * pg_inet_cidr_ntop	(	int	af,
		const void *	src,
		int	bits,
		char *	dst,
		size_t	size
	)

Definition at line 56 of file inet_cidr_ntop.c.

{
    switch (af)
    {
        case PGSQL_AF_INET:
            return inet_cidr_ntop_ipv4(src, bits, dst, size);
        case PGSQL_AF_INET6:
            return inet_cidr_ntop_ipv6(src, bits, dst, size);
        default:
            errno = EAFNOSUPPORT;
            return NULL;
    }
}

References EAFNOSUPPORT, inet_cidr_ntop_ipv4(), inet_cidr_ntop_ipv6(), PGSQL_AF_INET, PGSQL_AF_INET6, and size.

Referenced by cidr_abbrev().

pg_inet_net_pton()

int pg_inet_net_pton	(	int	af,
		const char *	src,
		void *	dst,
		size_t	size
	)

Definition at line 61 of file inet_net_pton.c.

{
    switch (af)
    {
        case PGSQL_AF_INET:
            return size == -1 ?
                inet_net_pton_ipv4(src, dst) :
                inet_cidr_pton_ipv4(src, dst, size);
        case PGSQL_AF_INET6:
            return size == -1 ?
                inet_net_pton_ipv6(src, dst) :
                inet_cidr_pton_ipv6(src, dst, size);
        default:
            errno = EAFNOSUPPORT;
            return -1;
    }
}

References EAFNOSUPPORT, inet_cidr_pton_ipv4(), inet_cidr_pton_ipv6(), inet_net_pton_ipv4(), inet_net_pton_ipv6(), PGSQL_AF_INET, PGSQL_AF_INET6, and size.

Referenced by network_in().

pg_itoa()

int pg_itoa	(	int16	i,
		char *	a
	)

Definition at line 1042 of file numutils.c.

{
    return pg_ltoa((int32) i, a);
}

References a, i, and pg_ltoa().

Referenced by int2out(), int2vectorout(), LogicalTapeImport(), and LogicalTapeSetCreate().

pg_lltoa()

int pg_lltoa	(	int64	value,
		char *	a
	)

Definition at line 1227 of file numutils.c.

{
    uint64      uvalue = value;
    int         len = 0;
 
    if (value < 0)
    {
        uvalue = (uint64) 0 - uvalue;
        a[len++] = '-';
    }
 
    len += pg_ulltoa_n(uvalue, a + len);
    a[len] = '\0';
    return len;
}

References a, len, pg_ulltoa_n(), and value.

Referenced by int8out(), and printsimple().

pg_ltoa()

int pg_ltoa	(	int32	value,
		char *	a
	)

Definition at line 1120 of file numutils.c.

{
    uint32      uvalue = (uint32) value;
    int         len = 0;
 
    if (value < 0)
    {
        uvalue = (uint32) 0 - uvalue;
        a[len++] = '-';
    }
    len += pg_ultoa_n(uvalue, a + len);
    a[len] = '\0';
    return len;
}

References a, len, pg_ultoa_n(), and value.

Referenced by executeItemOptUnwrapTarget(), int4out(), pg_itoa(), and printsimple().

pg_strtoint16()

int16 pg_strtoint16

(

const char *

s

)

Definition at line 122 of file numutils.c.

{
    return pg_strtoint16_safe(s, NULL);
}

References pg_strtoint16_safe().

pg_strtoint16_safe()

int16 pg_strtoint16_safe	(	const char *	s,
		Node *	escontext
	)

Definition at line 128 of file numutils.c.

{
    const char *ptr = s;
    const char *firstdigit;
    uint16      tmp = 0;
    bool        neg = false;
    unsigned char digit;
    int16       result;
 
    /*
     * The majority of cases are likely to be base-10 digits without any
     * underscore separator characters.  We'll first try to parse the string
     * with the assumption that's the case and only fallback on a slower
     * implementation which handles hex, octal and binary strings and
     * underscores if the fastpath version cannot parse the string.
     */
 
    /* leave it up to the slow path to look for leading spaces */
 
    if (*ptr == '-')
    {
        ptr++;
        neg = true;
    }
 
    /* a leading '+' is uncommon so leave that for the slow path */
 
    /* process the first digit */
    digit = (*ptr - '0');
 
    /*
     * Exploit unsigned arithmetic to save having to check both the upper and
     * lower bounds of the digit.
     */
    if (likely(digit < 10))
    {
        ptr++;
        tmp = digit;
    }
    else
    {
        /* we need at least one digit */
        goto slow;
    }
 
    /* process remaining digits */
    for (;;)
    {
        digit = (*ptr - '0');
 
        if (digit >= 10)
            break;
 
        ptr++;
 
        if (unlikely(tmp > -(PG_INT16_MIN / 10)))
            goto out_of_range;
 
        tmp = tmp * 10 + digit;
    }
 
    /* when the string does not end in a digit, let the slow path handle it */
    if (unlikely(*ptr != '\0'))
        goto slow;
 
    if (neg)
    {
        if (unlikely(pg_neg_u16_overflow(tmp, &result)))
            goto out_of_range;
        return result;
    }
 
    if (unlikely(tmp > PG_INT16_MAX))
        goto out_of_range;
 
    return (int16) tmp;
 
slow:
    tmp = 0;
    ptr = s;
    /* no need to reset neg */
 
    /* skip leading spaces */
    while (isspace((unsigned char) *ptr))
        ptr++;
 
    /* handle sign */
    if (*ptr == '-')
    {
        ptr++;
        neg = true;
    }
    else if (*ptr == '+')
        ptr++;
 
    /* process digits */
    if (ptr[0] == '0' && (ptr[1] == 'x' || ptr[1] == 'X'))
    {
        firstdigit = ptr += 2;
 
        for (;;)
        {
            if (isxdigit((unsigned char) *ptr))
            {
                if (unlikely(tmp > -(PG_INT16_MIN / 16)))
                    goto out_of_range;
 
                tmp = tmp * 16 + hexlookup[(unsigned char) *ptr++];
            }
            else if (*ptr == '_')
            {
                /* underscore must be followed by more digits */
                ptr++;
                if (*ptr == '\0' || !isxdigit((unsigned char) *ptr))
                    goto invalid_syntax;
            }
            else
                break;
        }
    }
    else if (ptr[0] == '0' && (ptr[1] == 'o' || ptr[1] == 'O'))
    {
        firstdigit = ptr += 2;
 
        for (;;)
        {
            if (*ptr >= '0' && *ptr <= '7')
            {
                if (unlikely(tmp > -(PG_INT16_MIN / 8)))
                    goto out_of_range;
 
                tmp = tmp * 8 + (*ptr++ - '0');
            }
            else if (*ptr == '_')
            {
                /* underscore must be followed by more digits */
                ptr++;
                if (*ptr == '\0' || *ptr < '0' || *ptr > '7')
                    goto invalid_syntax;
            }
            else
                break;
        }
    }
    else if (ptr[0] == '0' && (ptr[1] == 'b' || ptr[1] == 'B'))
    {
        firstdigit = ptr += 2;
 
        for (;;)
        {
            if (*ptr >= '0' && *ptr <= '1')
            {
                if (unlikely(tmp > -(PG_INT16_MIN / 2)))
                    goto out_of_range;
 
                tmp = tmp * 2 + (*ptr++ - '0');
            }
            else if (*ptr == '_')
            {
                /* underscore must be followed by more digits */
                ptr++;
                if (*ptr == '\0' || *ptr < '0' || *ptr > '1')
                    goto invalid_syntax;
            }
            else
                break;
        }
    }
    else
    {
        firstdigit = ptr;
 
        for (;;)
        {
            if (*ptr >= '0' && *ptr <= '9')
            {
                if (unlikely(tmp > -(PG_INT16_MIN / 10)))
                    goto out_of_range;
 
                tmp = tmp * 10 + (*ptr++ - '0');
            }
            else if (*ptr == '_')
            {
                /* underscore may not be first */
                if (unlikely(ptr == firstdigit))
                    goto invalid_syntax;
                /* and it must be followed by more digits */
                ptr++;
                if (*ptr == '\0' || !isdigit((unsigned char) *ptr))
                    goto invalid_syntax;
            }
            else
                break;
        }
    }
 
    /* require at least one digit */
    if (unlikely(ptr == firstdigit))
        goto invalid_syntax;
 
    /* allow trailing whitespace, but not other trailing chars */
    while (isspace((unsigned char) *ptr))
        ptr++;
 
    if (unlikely(*ptr != '\0'))
        goto invalid_syntax;
 
    if (neg)
    {
        if (unlikely(pg_neg_u16_overflow(tmp, &result)))
            goto out_of_range;
        return result;
    }
 
    if (tmp > PG_INT16_MAX)
        goto out_of_range;
 
    return (int16) tmp;
 
out_of_range:
    ereturn(escontext, 0,
            (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
             errmsg("value \"%s\" is out of range for type %s",
                    s, "smallint")));
 
invalid_syntax:
    ereturn(escontext, 0,
            (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
             errmsg("invalid input syntax for type %s: \"%s\"",
                    "smallint", s)));
}

References ereturn, errcode(), errmsg(), hexlookup, likely, PG_INT16_MAX, PG_INT16_MIN, pg_neg_u16_overflow(), and unlikely.

Referenced by int2in(), and pg_strtoint16().

pg_strtoint32()

int32 pg_strtoint32

(

const char *

s

)

Definition at line 383 of file numutils.c.

{
    return pg_strtoint32_safe(s, NULL);
}

References pg_strtoint32_safe().

Referenced by ArrayGetIntegerTypmods(), check_foreign_key(), libpqrcv_endstreaming(), libpqrcv_identify_system(), pq_parse_errornotice(), prsd_headline(), and text_format().

pg_strtoint32_safe()

int32 pg_strtoint32_safe	(	const char *	s,
		Node *	escontext
	)

Definition at line 389 of file numutils.c.

{
    const char *ptr = s;
    const char *firstdigit;
    uint32      tmp = 0;
    bool        neg = false;
    unsigned char digit;
    int32       result;
 
    /*
     * The majority of cases are likely to be base-10 digits without any
     * underscore separator characters.  We'll first try to parse the string
     * with the assumption that's the case and only fallback on a slower
     * implementation which handles hex, octal and binary strings and
     * underscores if the fastpath version cannot parse the string.
     */
 
    /* leave it up to the slow path to look for leading spaces */
 
    if (*ptr == '-')
    {
        ptr++;
        neg = true;
    }
 
    /* a leading '+' is uncommon so leave that for the slow path */
 
    /* process the first digit */
    digit = (*ptr - '0');
 
    /*
     * Exploit unsigned arithmetic to save having to check both the upper and
     * lower bounds of the digit.
     */
    if (likely(digit < 10))
    {
        ptr++;
        tmp = digit;
    }
    else
    {
        /* we need at least one digit */
        goto slow;
    }
 
    /* process remaining digits */
    for (;;)
    {
        digit = (*ptr - '0');
 
        if (digit >= 10)
            break;
 
        ptr++;
 
        if (unlikely(tmp > -(PG_INT32_MIN / 10)))
            goto out_of_range;
 
        tmp = tmp * 10 + digit;
    }
 
    /* when the string does not end in a digit, let the slow path handle it */
    if (unlikely(*ptr != '\0'))
        goto slow;
 
    if (neg)
    {
        if (unlikely(pg_neg_u32_overflow(tmp, &result)))
            goto out_of_range;
        return result;
    }
 
    if (unlikely(tmp > PG_INT32_MAX))
        goto out_of_range;
 
    return (int32) tmp;
 
slow:
    tmp = 0;
    ptr = s;
    /* no need to reset neg */
 
    /* skip leading spaces */
    while (isspace((unsigned char) *ptr))
        ptr++;
 
    /* handle sign */
    if (*ptr == '-')
    {
        ptr++;
        neg = true;
    }
    else if (*ptr == '+')
        ptr++;
 
    /* process digits */
    if (ptr[0] == '0' && (ptr[1] == 'x' || ptr[1] == 'X'))
    {
        firstdigit = ptr += 2;
 
        for (;;)
        {
            if (isxdigit((unsigned char) *ptr))
            {
                if (unlikely(tmp > -(PG_INT32_MIN / 16)))
                    goto out_of_range;
 
                tmp = tmp * 16 + hexlookup[(unsigned char) *ptr++];
            }
            else if (*ptr == '_')
            {
                /* underscore must be followed by more digits */
                ptr++;
                if (*ptr == '\0' || !isxdigit((unsigned char) *ptr))
                    goto invalid_syntax;
            }
            else
                break;
        }
    }
    else if (ptr[0] == '0' && (ptr[1] == 'o' || ptr[1] == 'O'))
    {
        firstdigit = ptr += 2;
 
        for (;;)
        {
            if (*ptr >= '0' && *ptr <= '7')
            {
                if (unlikely(tmp > -(PG_INT32_MIN / 8)))
                    goto out_of_range;
 
                tmp = tmp * 8 + (*ptr++ - '0');
            }
            else if (*ptr == '_')
            {
                /* underscore must be followed by more digits */
                ptr++;
                if (*ptr == '\0' || *ptr < '0' || *ptr > '7')
                    goto invalid_syntax;
            }
            else
                break;
        }
    }
    else if (ptr[0] == '0' && (ptr[1] == 'b' || ptr[1] == 'B'))
    {
        firstdigit = ptr += 2;
 
        for (;;)
        {
            if (*ptr >= '0' && *ptr <= '1')
            {
                if (unlikely(tmp > -(PG_INT32_MIN / 2)))
                    goto out_of_range;
 
                tmp = tmp * 2 + (*ptr++ - '0');
            }
            else if (*ptr == '_')
            {
                /* underscore must be followed by more digits */
                ptr++;
                if (*ptr == '\0' || *ptr < '0' || *ptr > '1')
                    goto invalid_syntax;
            }
            else
                break;
        }
    }
    else
    {
        firstdigit = ptr;
 
        for (;;)
        {
            if (*ptr >= '0' && *ptr <= '9')
            {
                if (unlikely(tmp > -(PG_INT32_MIN / 10)))
                    goto out_of_range;
 
                tmp = tmp * 10 + (*ptr++ - '0');
            }
            else if (*ptr == '_')
            {
                /* underscore may not be first */
                if (unlikely(ptr == firstdigit))
                    goto invalid_syntax;
                /* and it must be followed by more digits */
                ptr++;
                if (*ptr == '\0' || !isdigit((unsigned char) *ptr))
                    goto invalid_syntax;
            }
            else
                break;
        }
    }
 
    /* require at least one digit */
    if (unlikely(ptr == firstdigit))
        goto invalid_syntax;
 
    /* allow trailing whitespace, but not other trailing chars */
    while (isspace((unsigned char) *ptr))
        ptr++;
 
    if (unlikely(*ptr != '\0'))
        goto invalid_syntax;
 
    if (neg)
    {
        if (unlikely(pg_neg_u32_overflow(tmp, &result)))
            goto out_of_range;
        return result;
    }
 
    if (tmp > PG_INT32_MAX)
        goto out_of_range;
 
    return (int32) tmp;
 
out_of_range:
    ereturn(escontext, 0,
            (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
             errmsg("value \"%s\" is out of range for type %s",
                    s, "integer")));
 
invalid_syntax:
    ereturn(escontext, 0,
            (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
             errmsg("invalid input syntax for type %s: \"%s\"",
                    "integer", s)));
}

References ereturn, errcode(), errmsg(), hexlookup, likely, PG_INT32_MAX, PG_INT32_MIN, pg_neg_u32_overflow(), and unlikely.

Referenced by int4in(), pg_strtoint32(), and process_integer_literal().

pg_strtoint64()

int64 pg_strtoint64

(

const char *

s

)

Definition at line 644 of file numutils.c.

{
    return pg_strtoint64_safe(s, NULL);
}

References pg_strtoint64_safe().

Referenced by defGetCopyRejectLimitOption().

pg_strtoint64_safe()

int64 pg_strtoint64_safe	(	const char *	s,
		Node *	escontext
	)

Definition at line 650 of file numutils.c.

{
    const char *ptr = s;
    const char *firstdigit;
    uint64      tmp = 0;
    bool        neg = false;
    unsigned char digit;
    int64       result;
 
    /*
     * The majority of cases are likely to be base-10 digits without any
     * underscore separator characters.  We'll first try to parse the string
     * with the assumption that's the case and only fallback on a slower
     * implementation which handles hex, octal and binary strings and
     * underscores if the fastpath version cannot parse the string.
     */
 
    /* leave it up to the slow path to look for leading spaces */
 
    if (*ptr == '-')
    {
        ptr++;
        neg = true;
    }
 
    /* a leading '+' is uncommon so leave that for the slow path */
 
    /* process the first digit */
    digit = (*ptr - '0');
 
    /*
     * Exploit unsigned arithmetic to save having to check both the upper and
     * lower bounds of the digit.
     */
    if (likely(digit < 10))
    {
        ptr++;
        tmp = digit;
    }
    else
    {
        /* we need at least one digit */
        goto slow;
    }
 
    /* process remaining digits */
    for (;;)
    {
        digit = (*ptr - '0');
 
        if (digit >= 10)
            break;
 
        ptr++;
 
        if (unlikely(tmp > -(PG_INT64_MIN / 10)))
            goto out_of_range;
 
        tmp = tmp * 10 + digit;
    }
 
    /* when the string does not end in a digit, let the slow path handle it */
    if (unlikely(*ptr != '\0'))
        goto slow;
 
    if (neg)
    {
        if (unlikely(pg_neg_u64_overflow(tmp, &result)))
            goto out_of_range;
        return result;
    }
 
    if (unlikely(tmp > PG_INT64_MAX))
        goto out_of_range;
 
    return (int64) tmp;
 
slow:
    tmp = 0;
    ptr = s;
    /* no need to reset neg */
 
    /* skip leading spaces */
    while (isspace((unsigned char) *ptr))
        ptr++;
 
    /* handle sign */
    if (*ptr == '-')
    {
        ptr++;
        neg = true;
    }
    else if (*ptr == '+')
        ptr++;
 
    /* process digits */
    if (ptr[0] == '0' && (ptr[1] == 'x' || ptr[1] == 'X'))
    {
        firstdigit = ptr += 2;
 
        for (;;)
        {
            if (isxdigit((unsigned char) *ptr))
            {
                if (unlikely(tmp > -(PG_INT64_MIN / 16)))
                    goto out_of_range;
 
                tmp = tmp * 16 + hexlookup[(unsigned char) *ptr++];
            }
            else if (*ptr == '_')
            {
                /* underscore must be followed by more digits */
                ptr++;
                if (*ptr == '\0' || !isxdigit((unsigned char) *ptr))
                    goto invalid_syntax;
            }
            else
                break;
        }
    }
    else if (ptr[0] == '0' && (ptr[1] == 'o' || ptr[1] == 'O'))
    {
        firstdigit = ptr += 2;
 
        for (;;)
        {
            if (*ptr >= '0' && *ptr <= '7')
            {
                if (unlikely(tmp > -(PG_INT64_MIN / 8)))
                    goto out_of_range;
 
                tmp = tmp * 8 + (*ptr++ - '0');
            }
            else if (*ptr == '_')
            {
                /* underscore must be followed by more digits */
                ptr++;
                if (*ptr == '\0' || *ptr < '0' || *ptr > '7')
                    goto invalid_syntax;
            }
            else
                break;
        }
    }
    else if (ptr[0] == '0' && (ptr[1] == 'b' || ptr[1] == 'B'))
    {
        firstdigit = ptr += 2;
 
        for (;;)
        {
            if (*ptr >= '0' && *ptr <= '1')
            {
                if (unlikely(tmp > -(PG_INT64_MIN / 2)))
                    goto out_of_range;
 
                tmp = tmp * 2 + (*ptr++ - '0');
            }
            else if (*ptr == '_')
            {
                /* underscore must be followed by more digits */
                ptr++;
                if (*ptr == '\0' || *ptr < '0' || *ptr > '1')
                    goto invalid_syntax;
            }
            else
                break;
        }
    }
    else
    {
        firstdigit = ptr;
 
        for (;;)
        {
            if (*ptr >= '0' && *ptr <= '9')
            {
                if (unlikely(tmp > -(PG_INT64_MIN / 10)))
                    goto out_of_range;
 
                tmp = tmp * 10 + (*ptr++ - '0');
            }
            else if (*ptr == '_')
            {
                /* underscore may not be first */
                if (unlikely(ptr == firstdigit))
                    goto invalid_syntax;
                /* and it must be followed by more digits */
                ptr++;
                if (*ptr == '\0' || !isdigit((unsigned char) *ptr))
                    goto invalid_syntax;
            }
            else
                break;
        }
    }
 
    /* require at least one digit */
    if (unlikely(ptr == firstdigit))
        goto invalid_syntax;
 
    /* allow trailing whitespace, but not other trailing chars */
    while (isspace((unsigned char) *ptr))
        ptr++;
 
    if (unlikely(*ptr != '\0'))
        goto invalid_syntax;
 
    if (neg)
    {
        if (unlikely(pg_neg_u64_overflow(tmp, &result)))
            goto out_of_range;
        return result;
    }
 
    if (tmp > PG_INT64_MAX)
        goto out_of_range;
 
    return (int64) tmp;
 
out_of_range:
    ereturn(escontext, 0,
            (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
             errmsg("value \"%s\" is out of range for type %s",
                    s, "bigint")));
 
invalid_syntax:
    ereturn(escontext, 0,
            (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
             errmsg("invalid input syntax for type %s: \"%s\"",
                    "bigint", s)));
}

References ereturn, errcode(), errmsg(), hexlookup, likely, PG_INT64_MAX, PG_INT64_MIN, pg_neg_u64_overflow(), and unlikely.

Referenced by int8in(), make_const(), and pg_strtoint64().

pg_ulltoa_n()

int pg_ulltoa_n	(	uint64	value,
		char *	a
	)

Definition at line 1140 of file numutils.c.

{
    int         olength,
                i = 0;
    uint32      value2;
 
    /* Degenerate case */
    if (value == 0)
    {
        *a = '0';
        return 1;
    }
 
    olength = decimalLength64(value);
 
    /* Compute the result string. */
    while (value >= 100000000)
    {
        const uint64 q = value / 100000000;
        uint32      value3 = (uint32) (value - 100000000 * q);
 
        const uint32 c = value3 % 10000;
        const uint32 d = value3 / 10000;
        const uint32 c0 = (c % 100) << 1;
        const uint32 c1 = (c / 100) << 1;
        const uint32 d0 = (d % 100) << 1;
        const uint32 d1 = (d / 100) << 1;
 
        char       *pos = a + olength - i;
 
        value = q;
 
        memcpy(pos - 2, DIGIT_TABLE + c0, 2);
        memcpy(pos - 4, DIGIT_TABLE + c1, 2);
        memcpy(pos - 6, DIGIT_TABLE + d0, 2);
        memcpy(pos - 8, DIGIT_TABLE + d1, 2);
        i += 8;
    }
 
    /* Switch to 32-bit for speed */
    value2 = (uint32) value;
 
    if (value2 >= 10000)
    {
        const uint32 c = value2 - 10000 * (value2 / 10000);
        const uint32 c0 = (c % 100) << 1;
        const uint32 c1 = (c / 100) << 1;
 
        char       *pos = a + olength - i;
 
        value2 /= 10000;
 
        memcpy(pos - 2, DIGIT_TABLE + c0, 2);
        memcpy(pos - 4, DIGIT_TABLE + c1, 2);
        i += 4;
    }
    if (value2 >= 100)
    {
        const uint32 c = (value2 % 100) << 1;
        char       *pos = a + olength - i;
 
        value2 /= 100;
 
        memcpy(pos - 2, DIGIT_TABLE + c, 2);
        i += 2;
    }
    if (value2 >= 10)
    {
        const uint32 c = value2 << 1;
        char       *pos = a + olength - i;
 
        memcpy(pos - 2, DIGIT_TABLE + c, 2);
    }
    else
        *a = (char) ('0' + value2);
 
    return olength;
}

References a, decimalLength64(), DIGIT_TABLE, i, and value.

Referenced by BuildQueryCompletionString(), and pg_lltoa().

pg_ultoa_n()

int pg_ultoa_n	(	uint32	value,
		char *	a
	)

Definition at line 1055 of file numutils.c.

{
    int         olength,
                i = 0;
 
    /* Degenerate case */
    if (value == 0)
    {
        *a = '0';
        return 1;
    }
 
    olength = decimalLength32(value);
 
    /* Compute the result string. */
    while (value >= 10000)
    {
        const uint32 c = value - 10000 * (value / 10000);
        const uint32 c0 = (c % 100) << 1;
        const uint32 c1 = (c / 100) << 1;
 
        char       *pos = a + olength - i;
 
        value /= 10000;
 
        memcpy(pos - 2, DIGIT_TABLE + c0, 2);
        memcpy(pos - 4, DIGIT_TABLE + c1, 2);
        i += 4;
    }
    if (value >= 100)
    {
        const uint32 c = (value % 100) << 1;
 
        char       *pos = a + olength - i;
 
        value /= 100;
 
        memcpy(pos - 2, DIGIT_TABLE + c, 2);
        i += 2;
    }
    if (value >= 10)
    {
        const uint32 c = value << 1;
 
        char       *pos = a + olength - i;
 
        memcpy(pos - 2, DIGIT_TABLE + c, 2);
    }
    else
    {
        *a = (char) ('0' + value);
    }
 
    return olength;
}

References a, decimalLength32(), DIGIT_TABLE, i, and value.

Referenced by pg_ltoa(), pg_ultostr(), pg_ultostr_zeropad(), and printsimple().

pg_ultostr()

char * pg_ultostr	(	char *	str,
		uint32	value
	)

Definition at line 1307 of file numutils.c.

{
    int         len = pg_ultoa_n(value, str);
 
    return str + len;
}

References len, pg_ultoa_n(), str, and value.

Referenced by AppendSeconds().

pg_ultostr_zeropad()

char * pg_ultostr_zeropad	(	char *	str,
		uint32	value,
		int32	minwidth
	)

Definition at line 1267 of file numutils.c.

{
    int         len;
 
    Assert(minwidth > 0);
 
    if (value < 100 && minwidth == 2)   /* Short cut for common case */
    {
        memcpy(str, DIGIT_TABLE + value * 2, 2);
        return str + 2;
    }
 
    len = pg_ultoa_n(value, str);
    if (len >= minwidth)
        return str + len;
 
    memmove(str + minwidth - len, str, len);
    memset(str, '0', minwidth - len);
    return str + minwidth;
}

References Assert, DIGIT_TABLE, len, pg_ultoa_n(), str, and value.

Referenced by AppendSeconds(), EncodeDateOnly(), EncodeDateTime(), EncodeTimeOnly(), and EncodeTimezone().

quote_identifier()

const char * quote_identifier

(

const char *

ident

)

Definition at line 12875 of file ruleutils.c.

{
    /*
     * Can avoid quoting if ident starts with a lowercase letter or underscore
     * and contains only lowercase letters, digits, and underscores, *and* is
     * not any SQL keyword.  Otherwise, supply quotes.
     */
    int         nquotes = 0;
    bool        safe;
    const char *ptr;
    char       *result;
    char       *optr;
 
    /*
     * would like to use <ctype.h> macros here, but they might yield unwanted
     * locale-specific results...
     */
    safe = ((ident[0] >= 'a' && ident[0] <= 'z') || ident[0] == '_');
 
    for (ptr = ident; *ptr; ptr++)
    {
        char        ch = *ptr;
 
        if ((ch >= 'a' && ch <= 'z') ||
            (ch >= '0' && ch <= '9') ||
            (ch == '_'))
        {
            /* okay */
        }
        else
        {
            safe = false;
            if (ch == '"')
                nquotes++;
        }
    }
 
    if (quote_all_identifiers)
        safe = false;
 
    if (safe)
    {
        /*
         * Check for keyword.  We quote keywords except for unreserved ones.
         * (In some cases we could avoid quoting a col_name or type_func_name
         * keyword, but it seems much harder than it's worth to tell that.)
         *
         * Note: ScanKeywordLookup() does case-insensitive comparison, but
         * that's fine, since we already know we have all-lower-case.
         */
        int         kwnum = ScanKeywordLookup(ident, &ScanKeywords);
 
        if (kwnum >= 0 && ScanKeywordCategories[kwnum] != UNRESERVED_KEYWORD)
            safe = false;
    }
 
    if (safe)
        return ident;           /* no change needed */
 
    result = (char *) palloc(strlen(ident) + nquotes + 2 + 1);
 
    optr = result;
    *optr++ = '"';
    for (ptr = ident; *ptr; ptr++)
    {
        char        ch = *ptr;
 
        if (ch == '"')
            *optr++ = '"';
        *optr++ = ch;
    }
    *optr++ = '"';
    *optr = '\0';
 
    return result;
}

References ident, palloc(), pg_malloc(), quote_all_identifiers, ScanKeywordCategories, ScanKeywordLookup(), ScanKeywords, and UNRESERVED_KEYWORD.

Referenced by add_cast_to(), appendFunctionName(), ATPrepAlterColumnType(), CheckMyDatabase(), copy_table(), createdb(), CreateSchemaCommand(), decompile_column_index_array(), deparseAnalyzeSql(), deparseColumnRef(), deparseOperatorName(), deparseRelation(), execute_extension_script(), ExplainIndexScanDetails(), ExplainNode(), ExplainTargetRel(), flatten_set_variable_args(), format_operator_extended(), generate_operator_clause(), generate_operator_name(), get_column_alias_list(), get_from_clause_coldeflist(), get_from_clause_item(), get_insert_query_def(), get_json_table(), get_json_table_columns(), get_json_table_nested_columns(), get_merge_query_def(), get_opclass_name(), get_parameter(), get_reloptions(), get_rte_alias(), get_rule_expr(), get_rule_windowclause(), get_rule_windowspec(), get_select_query_def(), get_target_list(), get_update_query_targetlist_def(), get_utility_query_def(), get_variable(), get_windowfunc_expr_helper(), get_with_clause(), get_xmltable(), getObjectIdentityParts(), libpqrcv_alter_slot(), make_ruledef(), NameListToQuotedString(), old_9_6_invalidate_hash_indexes(), pg_get_constraintdef_worker(), pg_get_functiondef(), pg_get_indexdef_worker(), pg_get_partkeydef_worker(), pg_get_statisticsobj_worker(), pg_get_triggerdef_worker(), pg_identify_object(), PLy_quote_ident(), postgresExplainForeignScan(), postgresImportForeignSchema(), print_function_arguments(), process_extension_updates(), processIndirection(), quote_ident(), quote_object_name(), quote_qualified_identifier(), regnamespaceout(), regoperout(), regroleout(), ReplicationSlotDropAtPubNode(), sepgsql_attribute_post_create(), sepgsql_database_post_create(), sepgsql_relation_post_create(), sepgsql_schema_post_create(), serialize_deflist(), set_frozenxids(), show_sortorder_options(), text_format_string_conversion(), tuple_to_stringinfo(), and worker_spi_main().

quote_literal_cstr()

char * quote_literal_cstr

(

const char *

rawstr

)

Definition at line 103 of file quote.c.

{
    char       *result;
    int         len;
    int         newlen;
 
    len = strlen(rawstr);
    /* We make a worst-case result area; wasting a little space is OK */
    result = palloc(len * 2 + 3 + 1);
 
    newlen = quote_literal_internal(result, rawstr, len);
    result[newlen] = '\0';
 
    return result;
}

References len, palloc(), and quote_literal_internal().

Referenced by build_tuplestore_recursively(), fetch_remote_table_info(), get_sql_delete(), get_sql_insert(), get_sql_update(), get_tuple_of_interest(), GetPublicationsStr(), pg_decode_commit_prepared_txn(), pg_decode_prepare_txn(), pg_decode_rollback_prepared_txn(), pg_decode_stream_prepare(), PLy_quote_literal(), PLy_quote_nullable(), text_format_string_conversion(), and validate_remote_info().

quote_qualified_identifier()

char * quote_qualified_identifier	(	const char *	qualifier,
		const char *	ident
	)

Definition at line 12959 of file ruleutils.c.

{
    StringInfoData buf;
 
    initStringInfo(&buf);
    if (qualifier)
        appendStringInfo(&buf, "%s.", quote_identifier(qualifier));
    appendStringInfoString(&buf, quote_identifier(ident));
    return buf.data;
}

References appendStringInfo(), appendStringInfoString(), buf, ident, initStringInfo(), and quote_identifier().

Referenced by check_default_text_search_config(), copy_table(), create_pg_locale(), format_procedure_extended(), format_type_extended(), generate_collation_name(), generate_function_name(), generate_qualified_relation_name(), generate_qualified_type_name(), generate_relation_name(), getObjectDescription(), getObjectIdentityParts(), getOpFamilyDescription(), getOpFamilyIdentity(), getRelationDescription(), getRelationIdentity(), pg_decode_change(), pg_decode_truncate(), pg_get_functiondef(), pg_get_statisticsobj_worker(), refresh_by_match_merge(), RefreshMatViewByOid(), regclassout(), regcollationout(), regconfigout(), regdictionaryout(), regprocout(), sepgsql_proc_post_create(), and transformColumnDefinition().

regexp_fixed_prefix()

char * regexp_fixed_prefix	(	text *	text_re,
		bool	case_insensitive,
		Oid	collation,
		bool *	exact
	)

Definition at line 1953 of file regexp.c.

{
    char       *result;
    regex_t    *re;
    int         cflags;
    int         re_result;
    pg_wchar   *str;
    size_t      slen;
    size_t      maxlen;
    char        errMsg[100];
 
    *exact = false;             /* default result */
 
    /* Compile RE */
    cflags = REG_ADVANCED;
    if (case_insensitive)
        cflags |= REG_ICASE;
 
    re = RE_compile_and_cache(text_re, cflags | REG_NOSUB, collation);
 
    /* Examine it to see if there's a fixed prefix */
    re_result = pg_regprefix(re, &str, &slen);
 
    switch (re_result)
    {
        case REG_NOMATCH:
            return NULL;
 
        case REG_PREFIX:
            /* continue with wchar conversion */
            break;
 
        case REG_EXACT:
            *exact = true;
            /* continue with wchar conversion */
            break;
 
        default:
            /* re failed??? */
            pg_regerror(re_result, re, errMsg, sizeof(errMsg));
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_REGULAR_EXPRESSION),
                     errmsg("regular expression failed: %s", errMsg)));
            break;
    }
 
    /* Convert pg_wchar result back to database encoding */
    maxlen = pg_database_encoding_max_length() * slen + 1;
    result = (char *) palloc(maxlen);
    slen = pg_wchar2mb_with_len(str, result, slen);
    Assert(slen < maxlen);
 
    pfree(str);
 
    return result;
}

References Assert, ereport, errcode(), errmsg(), ERROR, palloc(), pfree(), pg_database_encoding_max_length(), pg_regerror(), pg_regprefix(), pg_wchar2mb_with_len(), RE_compile_and_cache(), REG_ADVANCED, REG_EXACT, REG_ICASE, REG_NOMATCH, REG_NOSUB, REG_PREFIX, regex_t, and str.

Referenced by regex_fixed_prefix().

text_to_cstring()

char * text_to_cstring

(

const text *

t

)

Definition at line 217 of file varlena.c.

{
    /* must cast away the const, unfortunately */
    text       *tunpacked = pg_detoast_datum_packed(unconstify(text *, t));
    int         len = VARSIZE_ANY_EXHDR(tunpacked);
    char       *result;
 
    result = (char *) palloc(len + 1);
    memcpy(result, VARDATA_ANY(tunpacked), len);
    result[len] = '\0';
 
    if (tunpacked != t)
        pfree(tunpacked);
 
    return result;
}

References len, palloc(), pfree(), pg_detoast_datum_packed(), unconstify, VARDATA_ANY, and VARSIZE_ANY_EXHDR.

Referenced by array_to_text(), array_to_text_null(), binary_upgrade_add_sub_rel_state(), binary_upgrade_create_empty_extension(), binary_upgrade_replorigin_advance(), binary_upgrade_set_missing_value(), connectby_text(), connectby_text_serial(), convert_and_check_filename(), convert_any_priv_string(), convert_column_name(), convert_database_name(), convert_foreign_data_wrapper_name(), convert_function_name(), convert_language_name(), convert_schema_name(), convert_server_name(), convert_tablespace_name(), convert_type_name(), crosstab(), crosstab_hash(), cursor_to_xml(), cursor_to_xmlschema(), daitch_mokotoff(), database_to_xml(), database_to_xml_and_xmlschema(), database_to_xmlschema(), datetime_to_char_body(), dblink_cancel_query(), dblink_close(), dblink_connect(), dblink_disconnect(), dblink_error_message(), dblink_exec(), dblink_fetch(), dblink_get_notify(), dblink_is_busy(), dblink_open(), dblink_record_internal(), dblink_send_query(), deserialize_deflist(), difference(), dmetaphone(), dmetaphone_alt(), do_to_timestamp(), ExecAlterExtensionStmt(), execute_extension_script(), executeDateTimeMethod(), get_raw_page_fork(), get_raw_page_fork_1_9(), has_param_priv_byname(), has_sequence_privilege_id_name(), has_sequence_privilege_name(), has_sequence_privilege_name_name(), injection_points_attach(), injection_points_cached(), injection_points_detach(), injection_points_load(), injection_points_run(), injection_points_stats_numcalls(), injection_points_wakeup(), json_object_field(), json_object_field_text(), jsonb_set_lax(), JsonItemFromDatum(), ltree_addtext(), ltree_textadd(), NUM_cache(), parse_datetime(), parse_ident(), pg_backup_start(), pg_create_restore_point(), pg_crypt(), pg_current_logfile(), pg_get_expr_worker(), pg_get_logical_snapshot_info(), pg_get_logical_snapshot_meta(), pg_get_serial_sequence(), pg_index_column_has_property(), pg_index_has_property(), pg_indexam_has_property(), pg_input_is_valid_common(), pg_logical_emit_message_bytea(), pg_ls_replslotdir(), pg_notify(), pg_prewarm(), pg_relation_size(), pg_replication_origin_advance(), pg_replication_origin_create(), pg_replication_origin_drop(), pg_replication_origin_oid(), pg_replication_origin_progress(), pg_replication_origin_session_setup(), pg_size_bytes(), pg_split_walfile_name(), pg_stat_get_progress_info(), pg_stat_get_replication_slot(), pg_stat_have_stats(), pg_stat_reset_replication_slot(), pg_stat_reset_shared(), pg_stat_reset_slru(), pgxml_texttoxmlchar(), phraseto_tsquery_byid(), plainto_tsquery_byid(), postgres_fdw_disconnect(), query_to_xml(), query_to_xml_and_xmlschema(), query_to_xmlschema(), quote_ident(), quote_ident_cstr(), range_constructor3(), regress_setenv(), replorigin_by_oid(), schema_to_xml(), schema_to_xml_and_xmlschema(), schema_to_xmlschema(), sepgsql_mcstrans_in(), sepgsql_mcstrans_out(), soundex(), table_to_xml(), table_to_xml_and_xmlschema(), table_to_xmlschema(), test_canonicalize_path(), test_predtest(), test_slru_page_write(), text2ltree(), text_concat_ws(), textToQualifiedNameList(), to_date(), to_regclass(), to_regcollation(), to_regnamespace(), to_regoper(), to_regoperator(), to_regproc(), to_regprocedure(), to_regrole(), to_regtype(), to_regtypemod(), to_tsquery_byid(), ts_stat_sql(), tsquery_rewrite_query(), tuple_data_split(), unicode_is_normalized(), unicode_normalize_func(), verify_heapam(), websearch_to_tsquery_byid(), X509_NAME_field_to_text(), xml_out_internal(), xmlconcat(), xmlpi(), xmlroot(), and xpath_table().

text_to_cstring_buffer()

void text_to_cstring_buffer	(	const text *	src,
		char *	dst,
		size_t	dst_len
	)

Definition at line 248 of file varlena.c.

{
    /* must cast away the const, unfortunately */
    text       *srcunpacked = pg_detoast_datum_packed(unconstify(text *, src));
    size_t      src_len = VARSIZE_ANY_EXHDR(srcunpacked);
 
    if (dst_len > 0)
    {
        dst_len--;
        if (dst_len >= src_len)
            dst_len = src_len;
        else                    /* ensure truncation is encoding-safe */
            dst_len = pg_mbcliplen(VARDATA_ANY(srcunpacked), src_len, dst_len);
        memcpy(dst, VARDATA_ANY(srcunpacked), dst_len);
        dst[dst_len] = '\0';
    }
 
    if (srcunpacked != src)
        pfree(srcunpacked);
}

References pfree(), pg_detoast_datum_packed(), pg_mbcliplen(), unconstify, VARDATA_ANY, and VARSIZE_ANY_EXHDR.

Referenced by be_lo_export(), lo_import_internal(), lookup_timezone(), parse_sane_timezone(), pg_gen_salt(), pg_gen_salt_rounds(), timestamp_zone(), timestamptz_zone(), and timetz_zone().

type_maximum_size()

int32 type_maximum_size	(	Oid	type_oid,
		int32	typemod
	)

Definition at line 412 of file format_type.c.

{
    if (typemod < 0)
        return -1;
 
    switch (type_oid)
    {
        case BPCHAROID:
        case VARCHAROID:
            /* typemod includes varlena header */
 
            /* typemod is in characters not bytes */
            return (typemod - VARHDRSZ) *
                pg_encoding_max_length(GetDatabaseEncoding())
                + VARHDRSZ;
 
        case NUMERICOID:
            return numeric_maximum_size(typemod);
 
        case VARBITOID:
        case BITOID:
            /* typemod is the (max) number of bits */
            return (typemod + (BITS_PER_BYTE - 1)) / BITS_PER_BYTE
                + 2 * sizeof(int32);
    }
 
    /* Unknown type, or unlimited-width type such as 'text' */
    return -1;
}

References BITS_PER_BYTE, GetDatabaseEncoding(), numeric_maximum_size(), pg_encoding_max_length(), and VARHDRSZ.

Referenced by get_typavgwidth(), and heapam_relation_needs_toast_table().

uint32in_subr()

uint32 uint32in_subr	(	const char *	s,
		char **	endloc,
		const char *	typname,
		Node *	escontext
	)

Definition at line 898 of file numutils.c.

{
    uint32      result;
    unsigned long cvt;
    char       *endptr;
 
    errno = 0;
    cvt = strtoul(s, &endptr, 0);
 
    /*
     * strtoul() normally only sets ERANGE.  On some systems it may also set
     * EINVAL, which simply means it couldn't parse the input string.  Be sure
     * to report that the same way as the standard error indication (that
     * endptr == s).
     */
    if ((errno && errno != ERANGE) || endptr == s)
        ereturn(escontext, 0,
                (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                 errmsg("invalid input syntax for type %s: \"%s\"",
                        typname, s)));
 
    if (errno == ERANGE)
        ereturn(escontext, 0,
                (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
                 errmsg("value \"%s\" is out of range for type %s",
                        s, typname)));
 
    if (endloc)
    {
        /* caller wants to deal with rest of string */
        *endloc = endptr;
    }
    else
    {
        /* allow only whitespace after number */
        while (*endptr && isspace((unsigned char) *endptr))
            endptr++;
        if (*endptr)
            ereturn(escontext, 0,
                    (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                     errmsg("invalid input syntax for type %s: \"%s\"",
                            typname, s)));
    }
 
    result = (uint32) cvt;
 
    /*
     * Cope with possibility that unsigned long is wider than uint32, in which
     * case strtoul will not raise an error for some values that are out of
     * the range of uint32.
     *
     * For backwards compatibility, we want to accept inputs that are given
     * with a minus sign, so allow the input value if it matches after either
     * signed or unsigned extension to long.
     *
     * To ensure consistent results on 32-bit and 64-bit platforms, make sure
     * the error message is the same as if strtoul() had returned ERANGE.
     */
#if PG_UINT32_MAX != ULONG_MAX
    if (cvt != (unsigned long) result &&
        cvt != (unsigned long) ((int) result))
        ereturn(escontext, 0,
                (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
                 errmsg("value \"%s\" is out of range for type %s",
                        s, typname)));
#endif
 
    return result;
}

References ereturn, errcode(), errmsg(), and typname.

Referenced by cidin(), oidin(), oidparse(), oidvectorin(), and xidin().

uint64in_subr()

uint64 uint64in_subr	(	const char *	s,
		char **	endloc,
		const char *	typname,
		Node *	escontext
	)

Definition at line 985 of file numutils.c.

{
    uint64      result;
    char       *endptr;
 
    errno = 0;
    result = strtou64(s, &endptr, 0);
 
    /*
     * strtoul[l] normally only sets ERANGE.  On some systems it may also set
     * EINVAL, which simply means it couldn't parse the input string.  Be sure
     * to report that the same way as the standard error indication (that
     * endptr == s).
     */
    if ((errno && errno != ERANGE) || endptr == s)
        ereturn(escontext, 0,
                (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                 errmsg("invalid input syntax for type %s: \"%s\"",
                        typname, s)));
 
    if (errno == ERANGE)
        ereturn(escontext, 0,
                (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
                 errmsg("value \"%s\" is out of range for type %s",
                        s, typname)));
 
    if (endloc)
    {
        /* caller wants to deal with rest of string */
        *endloc = endptr;
    }
    else
    {
        /* allow only whitespace after number */
        while (*endptr && isspace((unsigned char) *endptr))
            endptr++;
        if (*endptr)
            ereturn(escontext, 0,
                    (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                     errmsg("invalid input syntax for type %s: \"%s\"",
                            typname, s)));
    }
 
    return result;
}

References ereturn, errcode(), errmsg(), and typname.

Referenced by xid8in().

xidComparator()

int xidComparator	(	const void *	arg1,
		const void *	arg2
	)

Definition at line 152 of file xid.c.

{
    TransactionId xid1 = *(const TransactionId *) arg1;
    TransactionId xid2 = *(const TransactionId *) arg2;
 
    return pg_cmp_u32(xid1, xid2);
}

References pg_cmp_u32().

Referenced by ReorderBufferCopySnap(), ReorderBufferGetCatalogChangesXacts(), SerializeTransactionState(), SnapBuildBuildSnapshot(), SnapBuildInitialSnapshot(), SnapBuildXidHasCatalogChanges(), and TransactionIdInArray().

xidLogicalComparator()

int xidLogicalComparator	(	const void *	arg1,
		const void *	arg2
	)

Definition at line 169 of file xid.c.

{
    TransactionId xid1 = *(const TransactionId *) arg1;
    TransactionId xid2 = *(const TransactionId *) arg2;
 
    Assert(TransactionIdIsNormal(xid1));
    Assert(TransactionIdIsNormal(xid2));
 
    if (TransactionIdPrecedes(xid1, xid2))
        return -1;
 
    if (TransactionIdPrecedes(xid2, xid1))
        return 1;
 
    return 0;
}

References Assert, TransactionIdIsNormal, and TransactionIdPrecedes().

Referenced by ProcArrayApplyRecoveryInfo().

Variable Documentation

quote_all_identifiers

PGDLLIMPORT bool quote_all_identifiers

extern

Definition at line 337 of file ruleutils.c.

Referenced by fmtId(), main(), quote_identifier(), and setup_connection().