PostgreSQL Source Code  git master
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)
 
int2vectorbuildint2vector (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)
 
oidvectorbuildoidvector (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)
 
textcstring_to_text (const char *s)
 
textcstring_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.

677 {
678  int i;
679 
680  /*
681  * Note that we rely on the assumption that ' ' is a singleton unit on
682  * every supported multibyte server encoding.
683  */
684  for (i = len - 1; i >= 0; i--)
685  {
686  if (s[i] != ' ')
687  break;
688  }
689  return i + 1;
690 }
int i
Definition: isn.c:73
const void size_t len

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.

115 {
116  int2vector *result;
117 
118  result = (int2vector *) palloc0(Int2VectorSize(n));
119 
120  if (n > 0 && int2s)
121  memcpy(result->values, int2s, n * sizeof(int16));
122 
123  /*
124  * Attach standard array header. For historical reasons, we set the index
125  * lower bound to 0 not 1.
126  */
127  SET_VARSIZE(result, Int2VectorSize(n));
128  result->ndim = 1;
129  result->dataoffset = 0; /* never any nulls */
130  result->elemtype = INT2OID;
131  result->dim1 = n;
132  result->lbound1 = 0;
133 
134  return result;
135 }
signed short int16
Definition: c.h:493
#define Int2VectorSize(n)
Definition: int.c:45
void * palloc0(Size size)
Definition: mcxt.c:1346
Definition: c.h:715
int ndim
Definition: c.h:717
int dim1
Definition: c.h:720
Oid elemtype
Definition: c.h:719
int16 values[FLEXIBLE_ARRAY_MEMBER]
Definition: c.h:722
int32 dataoffset
Definition: c.h:718
int lbound1
Definition: c.h:721
#define SET_VARSIZE(PTR, len)
Definition: varatt.h:305

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

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

◆ buildoidvector()

oidvector* buildoidvector ( const Oid oids,
int  n 
)

Definition at line 87 of file oid.c.

88 {
89  oidvector *result;
90 
91  result = (oidvector *) palloc0(OidVectorSize(n));
92 
93  if (n > 0 && oids)
94  memcpy(result->values, oids, n * sizeof(Oid));
95 
96  /*
97  * Attach standard array header. For historical reasons, we set the index
98  * lower bound to 0 not 1.
99  */
100  SET_VARSIZE(result, OidVectorSize(n));
101  result->ndim = 1;
102  result->dataoffset = 0; /* never any nulls */
103  result->elemtype = OIDOID;
104  result->dim1 = n;
105  result->lbound1 = 0;
106 
107  return result;
108 }
#define OidVectorSize(n)
Definition: oid.c:29
unsigned int Oid
Definition: postgres_ext.h:31
Definition: c.h:726
int dim1
Definition: c.h:731
int32 dataoffset
Definition: c.h:729
Oid elemtype
Definition: c.h:730
int lbound1
Definition: c.h:732
int ndim
Definition: c.h:728
Oid values[FLEXIBLE_ARRAY_MEMBER]
Definition: c.h:733

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 2095 of file network.c.

2096 {
2097  if (addr_family == AF_INET6)
2098  {
2099  char *pct = strchr(addr, '%');
2100 
2101  if (pct)
2102  *pct = '\0';
2103  }
2104 }

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 1502 of file network.c.

1503 {
1504  switch (typid)
1505  {
1506  case INETOID:
1507  case CIDROID:
1508  {
1509  inet *ip = DatumGetInetPP(value);
1510  int len;
1511  double res;
1512  int i;
1513 
1514  /*
1515  * Note that we don't use the full address for IPv6.
1516  */
1517  if (ip_family(ip) == PGSQL_AF_INET)
1518  len = 4;
1519  else
1520  len = 5;
1521 
1522  res = ip_family(ip);
1523  for (i = 0; i < len; i++)
1524  {
1525  res *= 256;
1526  res += ip_addr(ip)[i];
1527  }
1528  return res;
1529  }
1530  case MACADDROID:
1531  {
1532  macaddr *mac = DatumGetMacaddrP(value);
1533  double res;
1534 
1535  res = (mac->a << 16) | (mac->b << 8) | (mac->c);
1536  res *= 256 * 256 * 256;
1537  res += (mac->d << 16) | (mac->e << 8) | (mac->f);
1538  return res;
1539  }
1540  case MACADDR8OID:
1541  {
1543  double res;
1544 
1545  res = (mac->a << 24) | (mac->b << 16) | (mac->c << 8) | (mac->d);
1546  res *= ((double) 256) * 256 * 256 * 256;
1547  res += (mac->e << 24) | (mac->f << 16) | (mac->g << 8) | (mac->h);
1548  return res;
1549  }
1550  }
1551 
1552  *failure = true;
1553  return 0;
1554 }
static struct @155 value
Definition: inet.h:53
Definition: inet.h:108
unsigned char c
Definition: inet.h:111
unsigned char b
Definition: inet.h:110
unsigned char d
Definition: inet.h:112
unsigned char e
Definition: inet.h:113
unsigned char g
Definition: inet.h:115
unsigned char h
Definition: inet.h:116
unsigned char a
Definition: inet.h:109
unsigned char f
Definition: inet.h:114
Definition: inet.h:95
unsigned char e
Definition: inet.h:100
unsigned char b
Definition: inet.h:97
unsigned char f
Definition: inet.h:101
unsigned char c
Definition: inet.h:98
unsigned char a
Definition: inet.h:96
unsigned char d
Definition: inet.h:99
#define ip_addr(inetptr)
Definition: inet.h:77
static macaddr * DatumGetMacaddrP(Datum X)
Definition: inet.h:147
#define ip_family(inetptr)
Definition: inet.h:71
#define PGSQL_AF_INET
Definition: inet.h:39
static inet * DatumGetInetPP(Datum X)
Definition: inet.h:123
static macaddr8 * DatumGetMacaddr8P(Datum X)
Definition: inet.h:163

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.

185 {
186  return cstring_to_text_with_len(s, strlen(s));
187 }
text * cstring_to_text_with_len(const char *s, int len)
Definition: varlena.c:196

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(), cash_words(), 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.

197 {
198  text *result = (text *) palloc(len + VARHDRSZ);
199 
200  SET_VARSIZE(result, len + VARHDRSZ);
201  memcpy(VARDATA(result), s, len);
202 
203  return result;
204 }
#define VARHDRSZ
Definition: c.h:692
void * palloc(Size size)
Definition: mcxt.c:1316
Definition: c.h:687
#define VARDATA(PTR)
Definition: varatt.h:278

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(), 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(), 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.

348 {
349  (void) domain_check_internal(value, isnull, domainType, extra, mcxt,
350  NULL);
351 }
static bool domain_check_internal(Datum value, bool isnull, Oid domainType, void **extra, MemoryContext mcxt, Node *escontext)
Definition: domains.c:371

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.

358 {
359  return domain_check_internal(value, isnull, domainType, extra, mcxt,
360  escontext);
361 }

References domain_check_internal(), and value.

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

◆ errdatatype()

int errdatatype ( Oid  datatypeOid)

Definition at line 407 of file domains.c.

408 {
409  HeapTuple tup;
410  Form_pg_type typtup;
411 
412  tup = SearchSysCache1(TYPEOID, ObjectIdGetDatum(datatypeOid));
413  if (!HeapTupleIsValid(tup))
414  elog(ERROR, "cache lookup failed for type %u", datatypeOid);
415  typtup = (Form_pg_type) GETSTRUCT(tup);
416 
418  get_namespace_name(typtup->typnamespace));
420 
421  ReleaseSysCache(tup);
422 
423  return 0; /* return value does not matter */
424 }
#define NameStr(name)
Definition: c.h:746
int err_generic_string(int field, const char *str)
Definition: elog.c:1514
#define ERROR
Definition: elog.h:39
#define elog(elevel,...)
Definition: elog.h:224
#define HeapTupleIsValid(tuple)
Definition: htup.h:78
#define GETSTRUCT(TUP)
Definition: htup_details.h:653
char * get_namespace_name(Oid nspid)
Definition: lsyscache.c:3344
FormData_pg_type * Form_pg_type
Definition: pg_type.h:261
static Datum ObjectIdGetDatum(Oid X)
Definition: postgres.h:252
#define PG_DIAG_SCHEMA_NAME
Definition: postgres_ext.h:64
#define PG_DIAG_DATATYPE_NAME
Definition: postgres_ext.h:67
void ReleaseSysCache(HeapTuple tuple)
Definition: syscache.c:266
HeapTuple SearchSysCache1(int cacheId, Datum key1)
Definition: syscache.c:218

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.

432 {
433  errdatatype(datatypeOid);
435 
436  return 0; /* return value does not matter */
437 }
int errdatatype(Oid datatypeOid)
Definition: domains.c:407
#define PG_DIAG_CONSTRAINT_NAME
Definition: postgres_ext.h:68

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.

344 {
345  return format_type_extended(type_oid, -1, 0);
346 }
char * format_type_extended(Oid type_oid, int32 typemod, bits16 flags)
Definition: format_type.c:112

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(), GetOperatorFromWellKnownStrategy(), 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(), 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)

◆ format_type_extended()

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

Definition at line 112 of file format_type.c.

113 {
114  HeapTuple tuple;
115  Form_pg_type typeform;
116  Oid array_base_type;
117  bool is_array;
118  char *buf;
119  bool with_typemod;
120 
121  if (type_oid == InvalidOid)
122  {
123  if ((flags & FORMAT_TYPE_INVALID_AS_NULL) != 0)
124  return NULL;
125  else if ((flags & FORMAT_TYPE_ALLOW_INVALID) != 0)
126  return pstrdup("-");
127  }
128 
129  tuple = SearchSysCache1(TYPEOID, ObjectIdGetDatum(type_oid));
130  if (!HeapTupleIsValid(tuple))
131  {
132  if ((flags & FORMAT_TYPE_INVALID_AS_NULL) != 0)
133  return NULL;
134  else if ((flags & FORMAT_TYPE_ALLOW_INVALID) != 0)
135  return pstrdup("???");
136  else
137  elog(ERROR, "cache lookup failed for type %u", type_oid);
138  }
139  typeform = (Form_pg_type) GETSTRUCT(tuple);
140 
141  /*
142  * Check if it's a "true" array type. Pseudo-array types such as "name"
143  * shouldn't get deconstructed. Also check the toast property, and don't
144  * deconstruct "plain storage" array types --- this is because we don't
145  * want to show oidvector as oid[].
146  */
147  array_base_type = typeform->typelem;
148 
149  if (IsTrueArrayType(typeform) &&
150  typeform->typstorage != TYPSTORAGE_PLAIN)
151  {
152  /* Switch our attention to the array element type */
153  ReleaseSysCache(tuple);
154  tuple = SearchSysCache1(TYPEOID, ObjectIdGetDatum(array_base_type));
155  if (!HeapTupleIsValid(tuple))
156  {
157  if ((flags & FORMAT_TYPE_INVALID_AS_NULL) != 0)
158  return NULL;
159  else if ((flags & FORMAT_TYPE_ALLOW_INVALID) != 0)
160  return pstrdup("???[]");
161  else
162  elog(ERROR, "cache lookup failed for type %u", type_oid);
163  }
164  typeform = (Form_pg_type) GETSTRUCT(tuple);
165  type_oid = array_base_type;
166  is_array = true;
167  }
168  else
169  is_array = false;
170 
171  with_typemod = (flags & FORMAT_TYPE_TYPEMOD_GIVEN) != 0 && (typemod >= 0);
172 
173  /*
174  * See if we want to special-case the output for certain built-in types.
175  * Note that these special cases should all correspond to special
176  * productions in gram.y, to ensure that the type name will be taken as a
177  * system type, not a user type of the same name.
178  *
179  * If we do not provide a special-case output here, the type name will be
180  * handled the same way as a user type name --- in particular, it will be
181  * double-quoted if it matches any lexer keyword. This behavior is
182  * essential for some cases, such as types "bit" and "char".
183  */
184  buf = NULL; /* flag for no special case */
185 
186  switch (type_oid)
187  {
188  case BITOID:
189  if (with_typemod)
190  buf = printTypmod("bit", typemod, typeform->typmodout);
191  else if ((flags & FORMAT_TYPE_TYPEMOD_GIVEN) != 0)
192  {
193  /*
194  * bit with typmod -1 is not the same as BIT, which means
195  * BIT(1) per SQL spec. Report it as the quoted typename so
196  * that parser will not assign a bogus typmod.
197  */
198  }
199  else
200  buf = pstrdup("bit");
201  break;
202 
203  case BOOLOID:
204  buf = pstrdup("boolean");
205  break;
206 
207  case BPCHAROID:
208  if (with_typemod)
209  buf = printTypmod("character", typemod, typeform->typmodout);
210  else if ((flags & FORMAT_TYPE_TYPEMOD_GIVEN) != 0)
211  {
212  /*
213  * bpchar with typmod -1 is not the same as CHARACTER, which
214  * means CHARACTER(1) per SQL spec. Report it as bpchar so
215  * that parser will not assign a bogus typmod.
216  */
217  }
218  else
219  buf = pstrdup("character");
220  break;
221 
222  case FLOAT4OID:
223  buf = pstrdup("real");
224  break;
225 
226  case FLOAT8OID:
227  buf = pstrdup("double precision");
228  break;
229 
230  case INT2OID:
231  buf = pstrdup("smallint");
232  break;
233 
234  case INT4OID:
235  buf = pstrdup("integer");
236  break;
237 
238  case INT8OID:
239  buf = pstrdup("bigint");
240  break;
241 
242  case NUMERICOID:
243  if (with_typemod)
244  buf = printTypmod("numeric", typemod, typeform->typmodout);
245  else
246  buf = pstrdup("numeric");
247  break;
248 
249  case INTERVALOID:
250  if (with_typemod)
251  buf = printTypmod("interval", typemod, typeform->typmodout);
252  else
253  buf = pstrdup("interval");
254  break;
255 
256  case TIMEOID:
257  if (with_typemod)
258  buf = printTypmod("time", typemod, typeform->typmodout);
259  else
260  buf = pstrdup("time without time zone");
261  break;
262 
263  case TIMETZOID:
264  if (with_typemod)
265  buf = printTypmod("time", typemod, typeform->typmodout);
266  else
267  buf = pstrdup("time with time zone");
268  break;
269 
270  case TIMESTAMPOID:
271  if (with_typemod)
272  buf = printTypmod("timestamp", typemod, typeform->typmodout);
273  else
274  buf = pstrdup("timestamp without time zone");
275  break;
276 
277  case TIMESTAMPTZOID:
278  if (with_typemod)
279  buf = printTypmod("timestamp", typemod, typeform->typmodout);
280  else
281  buf = pstrdup("timestamp with time zone");
282  break;
283 
284  case VARBITOID:
285  if (with_typemod)
286  buf = printTypmod("bit varying", typemod, typeform->typmodout);
287  else
288  buf = pstrdup("bit varying");
289  break;
290 
291  case VARCHAROID:
292  if (with_typemod)
293  buf = printTypmod("character varying", typemod, typeform->typmodout);
294  else
295  buf = pstrdup("character varying");
296  break;
297 
298  case JSONOID:
299  buf = pstrdup("json");
300  break;
301  }
302 
303  if (buf == NULL)
304  {
305  /*
306  * Default handling: report the name as it appears in the catalog.
307  * Here, we must qualify the name if it is not visible in the search
308  * path or if caller requests it; and we must double-quote it if it's
309  * not a standard identifier or if it matches any keyword.
310  */
311  char *nspname;
312  char *typname;
313 
314  if ((flags & FORMAT_TYPE_FORCE_QUALIFY) == 0 &&
315  TypeIsVisible(type_oid))
316  nspname = NULL;
317  else
318  nspname = get_namespace_name_or_temp(typeform->typnamespace);
319 
320  typname = NameStr(typeform->typname);
321 
323 
324  if (with_typemod)
325  buf = printTypmod(buf, typemod, typeform->typmodout);
326  }
327 
328  if (is_array)
329  buf = psprintf("%s[]", buf);
330 
331  ReleaseSysCache(tuple);
332 
333  return buf;
334 }
#define FORMAT_TYPE_ALLOW_INVALID
Definition: builtins.h:125
#define FORMAT_TYPE_INVALID_AS_NULL
Definition: builtins.h:127
#define FORMAT_TYPE_TYPEMOD_GIVEN
Definition: builtins.h:124
static char * printTypmod(const char *typname, int32 typmod, Oid typmodout)
Definition: format_type.c:371
char * get_namespace_name_or_temp(Oid nspid)
Definition: lsyscache.c:3368
char * pstrdup(const char *in)
Definition: mcxt.c:1695
bool TypeIsVisible(Oid typid)
Definition: namespace.c:1025
static char * buf
Definition: pg_test_fsync.c:73
NameData typname
Definition: pg_type.h:41
#define InvalidOid
Definition: postgres_ext.h:36
char * psprintf(const char *fmt,...)
Definition: psprintf.c:46
char * quote_qualified_identifier(const char *qualifier, const char *ident)
Definition: ruleutils.c:12707

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()

◆ generate_operator_clause()

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

Definition at line 13031 of file ruleutils.c.

13035 {
13036  HeapTuple opertup;
13037  Form_pg_operator operform;
13038  char *oprname;
13039  char *nspname;
13040 
13041  opertup = SearchSysCache1(OPEROID, ObjectIdGetDatum(opoid));
13042  if (!HeapTupleIsValid(opertup))
13043  elog(ERROR, "cache lookup failed for operator %u", opoid);
13044  operform = (Form_pg_operator) GETSTRUCT(opertup);
13045  Assert(operform->oprkind == 'b');
13046  oprname = NameStr(operform->oprname);
13047 
13048  nspname = get_namespace_name(operform->oprnamespace);
13049 
13050  appendStringInfoString(buf, leftop);
13051  if (leftoptype != operform->oprleft)
13052  add_cast_to(buf, operform->oprleft);
13053  appendStringInfo(buf, " OPERATOR(%s.", quote_identifier(nspname));
13054  appendStringInfoString(buf, oprname);
13055  appendStringInfo(buf, ") %s", rightop);
13056  if (rightoptype != operform->oprright)
13057  add_cast_to(buf, operform->oprright);
13058 
13059  ReleaseSysCache(opertup);
13060 }
#define Assert(condition)
Definition: c.h:858
FormData_pg_operator * Form_pg_operator
Definition: pg_operator.h:83
const char * quote_identifier(const char *ident)
Definition: ruleutils.c:12623
static void add_cast_to(StringInfo buf, Oid typid)
Definition: ruleutils.c:13071
void appendStringInfo(StringInfo str, const char *fmt,...)
Definition: stringinfo.c:97
void appendStringInfoString(StringInfo str, const char *s)
Definition: stringinfo.c:182

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.

191 {
192  return hex_decode_safe(src, len, dst, NULL);
193 }
uint64 hex_decode_safe(const char *src, size_t len, char *dst, Node *escontext)
Definition: encode.c:196

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.

197 {
198  const char *s,
199  *srcend;
200  char v1,
201  v2,
202  *p;
203 
204  srcend = src + len;
205  s = src;
206  p = dst;
207  while (s < srcend)
208  {
209  if (*s == ' ' || *s == '\n' || *s == '\t' || *s == '\r')
210  {
211  s++;
212  continue;
213  }
214  if (!get_hex(s, &v1))
215  ereturn(escontext, 0,
216  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
217  errmsg("invalid hexadecimal digit: \"%.*s\"",
218  pg_mblen(s), s)));
219  s++;
220  if (s >= srcend)
221  ereturn(escontext, 0,
222  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
223  errmsg("invalid hexadecimal data: odd number of digits")));
224  if (!get_hex(s, &v2))
225  ereturn(escontext, 0,
226  (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
227  errmsg("invalid hexadecimal digit: \"%.*s\"",
228  pg_mblen(s), s)));
229  s++;
230  *p++ = (v1 << 4) | v2;
231  }
232 
233  return p - dst;
234 }
int errcode(int sqlerrcode)
Definition: elog.c:859
int errmsg(const char *fmt,...)
Definition: elog.c:1072
#define ereturn(context, dummy_value,...)
Definition: elog.h:276
static bool get_hex(const char *cp, char *out)
Definition: encode.c:176
int pg_mblen(const char *mbstr)
Definition: mbutils.c:1023

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.

163 {
164  const char *end = src + len;
165 
166  while (src < end)
167  {
168  *dst++ = hextbl[(*src >> 4) & 0xF];
169  *dst++ = hextbl[*src & 0xF];
170  src++;
171  }
172  return (uint64) len * 2;
173 }
static const char hextbl[]
Definition: encode.c:148

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.

248 {
249  if (!name && !str)
250  return 0;
251  if (!name)
252  return -1; /* NULL < anything */
253  if (!str)
254  return 1; /* NULL < anything */
255  return strncmp(NameStr(*name), str, NAMEDATALEN);
256 }
const char * str
#define NAMEDATALEN
const char * name

References name, NAMEDATALEN, NameStr, and str.

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

◆ namestrcpy()

◆ network_scan_first()

Datum network_scan_first ( Datum  in)

Definition at line 1690 of file network.c.

1691 {
1693 }
#define DirectFunctionCall1(func, arg1)
Definition: fmgr.h:642
Datum network_network(PG_FUNCTION_ARGS)
Definition: network.c:1330

References DirectFunctionCall1, and network_network().

Referenced by match_network_subset().

◆ network_scan_last()

Datum network_scan_last ( Datum  in)

Definition at line 1704 of file network.c.

1705 {
1708  Int32GetDatum(-1));
1709 }
#define DirectFunctionCall2(func, arg1, arg2)
Definition: fmgr.h:644
Datum network_broadcast(PG_FUNCTION_ARGS)
Definition: network.c:1285
Datum inet_set_masklen(PG_FUNCTION_ARGS)
Definition: network.c:324
static Datum Int32GetDatum(int32 X)
Definition: postgres.h:212

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 4661 of file numeric.c.

4662 {
4663  Numeric num = PG_GETARG_NUMERIC(0);
4664  double val;
4665 
4666  if (NUMERIC_IS_SPECIAL(num))
4667  {
4668  if (NUMERIC_IS_PINF(num))
4669  val = HUGE_VAL;
4670  else if (NUMERIC_IS_NINF(num))
4671  val = -HUGE_VAL;
4672  else
4673  val = get_float8_nan();
4674  }
4675  else
4676  {
4677  NumericVar x;
4678 
4679  init_var_from_num(num, &x);
4681  }
4682 
4684 }
#define NUMERIC_IS_SPECIAL(n)
Definition: numeric.c:172
static void init_var_from_num(Numeric num, NumericVar *dest)
Definition: numeric.c:7451
#define NUMERIC_IS_PINF(n)
Definition: numeric.c:204
#define NUMERIC_IS_NINF(n)
Definition: numeric.c:205
static double numericvar_to_double_no_overflow(const NumericVar *var)
Definition: numeric.c:8341
static float8 get_float8_nan(void)
Definition: float.h:123
#define PG_RETURN_FLOAT8(x)
Definition: fmgr.h:367
long val
Definition: informix.c:670
int x
Definition: isn.c:71
#define PG_GETARG_NUMERIC(n)
Definition: numeric.h:78

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.

259 {
260  Oid v1 = *((const Oid *) p1);
261  Oid v2 = *((const Oid *) p2);
262 
263  return pg_cmp_u32(v1, v2);
264 }
static int pg_cmp_u32(uint32 a, uint32 b)
Definition: int.h:489

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.

236 {
237  switch (nodeTag(node))
238  {
239  case T_Integer:
240  return intVal(node);
241  case T_Float:
242 
243  /*
244  * Values too large for int4 will be represented as Float
245  * constants by the lexer. Accept these if they are valid OID
246  * strings.
247  */
248  return uint32in_subr(castNode(Float, node)->fval, NULL,
249  "oid", NULL);
250  default:
251  elog(ERROR, "unrecognized node type: %d", (int) nodeTag(node));
252  }
253  return InvalidOid; /* keep compiler quiet */
254 }
#define nodeTag(nodeptr)
Definition: nodes.h:133
#define castNode(_type_, nodeptr)
Definition: nodes.h:176
uint32 uint32in_subr(const char *s, char **endloc, const char *typname, Node *escontext)
Definition: numutils.c:900
Definition: value.h:48
#define intVal(v)
Definition: value.h:79

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

Referenced by get_object_address(), and objectNamesToOids().

◆ parse_bool()

bool parse_bool ( const char *  value,
bool result 
)

Definition at line 30 of file bool.c.

31 {
32  return parse_bool_with_len(value, strlen(value), result);
33 }
bool parse_bool_with_len(const char *value, size_t len, bool *result)
Definition: bool.c:36

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 36 of file bool.c.

37 {
38  /* Check the most-used possibilities first. */
39  switch (*value)
40  {
41  case 't':
42  case 'T':
43  if (pg_strncasecmp(value, "true", len) == 0)
44  {
45  if (result)
46  *result = true;
47  return true;
48  }
49  break;
50  case 'f':
51  case 'F':
52  if (pg_strncasecmp(value, "false", len) == 0)
53  {
54  if (result)
55  *result = false;
56  return true;
57  }
58  break;
59  case 'y':
60  case 'Y':
61  if (pg_strncasecmp(value, "yes", len) == 0)
62  {
63  if (result)
64  *result = true;
65  return true;
66  }
67  break;
68  case 'n':
69  case 'N':
70  if (pg_strncasecmp(value, "no", len) == 0)
71  {
72  if (result)
73  *result = false;
74  return true;
75  }
76  break;
77  case 'o':
78  case 'O':
79  /* 'o' is not unique enough */
80  if (pg_strncasecmp(value, "on", (len > 2 ? len : 2)) == 0)
81  {
82  if (result)
83  *result = true;
84  return true;
85  }
86  else if (pg_strncasecmp(value, "off", (len > 2 ? len : 2)) == 0)
87  {
88  if (result)
89  *result = false;
90  return true;
91  }
92  break;
93  case '1':
94  if (len == 1)
95  {
96  if (result)
97  *result = true;
98  return true;
99  }
100  break;
101  case '0':
102  if (len == 1)
103  {
104  if (result)
105  *result = false;
106  return true;
107  }
108  break;
109  default:
110  break;
111  }
112 
113  if (result)
114  *result = false; /* suppress compiler warning */
115  return false;
116 }
int pg_strncasecmp(const char *s1, const char *s2, size_t n)
Definition: pgstrcasecmp.c:69

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.

57 {
58  switch (af)
59  {
60  case PGSQL_AF_INET:
61  return inet_cidr_ntop_ipv4(src, bits, dst, size);
62  case PGSQL_AF_INET6:
63  return inet_cidr_ntop_ipv6(src, bits, dst, size);
64  default:
65  errno = EAFNOSUPPORT;
66  return NULL;
67  }
68 }
static char * inet_cidr_ntop_ipv6(const u_char *src, int bits, char *dst, size_t size)
static char * inet_cidr_ntop_ipv4(const u_char *src, int bits, char *dst, size_t size)
static pg_noinline void Size size
Definition: slab.c:607
#define PGSQL_AF_INET6
Definition: inet.h:40
#define EAFNOSUPPORT
Definition: win32_port.h:378

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 62 of file inet_net_pton.c.

63 {
64  switch (af)
65  {
66  case PGSQL_AF_INET:
67  return size == -1 ?
68  inet_net_pton_ipv4(src, dst) :
69  inet_cidr_pton_ipv4(src, dst, size);
70  case PGSQL_AF_INET6:
71  return size == -1 ?
72  inet_net_pton_ipv6(src, dst) :
73  inet_cidr_pton_ipv6(src, dst, size);
74  default:
75  errno = EAFNOSUPPORT;
76  return -1;
77  }
78 }
static int inet_net_pton_ipv6(const char *src, u_char *dst)
static int inet_net_pton_ipv4(const char *src, u_char *dst)
static int inet_cidr_pton_ipv6(const char *src, u_char *dst, size_t size)
static int inet_cidr_pton_ipv4(const char *src, u_char *dst, size_t size)
Definition: inet_net_pton.c:97

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 1044 of file numutils.c.

1045 {
1046  return pg_ltoa((int32) i, a);
1047 }
signed int int32
Definition: c.h:494
int a
Definition: isn.c:69
int pg_ltoa(int32 value, char *a)
Definition: numutils.c:1122

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 1229 of file numutils.c.

1230 {
1231  uint64 uvalue = value;
1232  int len = 0;
1233 
1234  if (value < 0)
1235  {
1236  uvalue = (uint64) 0 - uvalue;
1237  a[len++] = '-';
1238  }
1239 
1240  len += pg_ulltoa_n(uvalue, a + len);
1241  a[len] = '\0';
1242  return len;
1243 }
int pg_ulltoa_n(uint64 value, char *a)
Definition: numutils.c:1142

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 1122 of file numutils.c.

1123 {
1124  uint32 uvalue = (uint32) value;
1125  int len = 0;
1126 
1127  if (value < 0)
1128  {
1129  uvalue = (uint32) 0 - uvalue;
1130  a[len++] = '-';
1131  }
1132  len += pg_ultoa_n(uvalue, a + len);
1133  a[len] = '\0';
1134  return len;
1135 }
unsigned int uint32
Definition: c.h:506
int pg_ultoa_n(uint32 value, char *a)
Definition: numutils.c:1057

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 121 of file numutils.c.

122 {
123  return pg_strtoint16_safe(s, NULL);
124 }
int16 pg_strtoint16_safe(const char *s, Node *escontext)
Definition: numutils.c:127

References pg_strtoint16_safe().

◆ pg_strtoint16_safe()

int16 pg_strtoint16_safe ( const char *  s,
Node escontext 
)

Definition at line 127 of file numutils.c.

128 {
129  const char *ptr = s;
130  const char *firstdigit;
131  uint16 tmp = 0;
132  bool neg = false;
133  unsigned char digit;
134 
135  /*
136  * The majority of cases are likely to be base-10 digits without any
137  * underscore separator characters. We'll first try to parse the string
138  * with the assumption that's the case and only fallback on a slower
139  * implementation which handles hex, octal and binary strings and
140  * underscores if the fastpath version cannot parse the string.
141  */
142 
143  /* leave it up to the slow path to look for leading spaces */
144 
145  if (*ptr == '-')
146  {
147  ptr++;
148  neg = true;
149  }
150 
151  /* a leading '+' is uncommon so leave that for the slow path */
152 
153  /* process the first digit */
154  digit = (*ptr - '0');
155 
156  /*
157  * Exploit unsigned arithmetic to save having to check both the upper and
158  * lower bounds of the digit.
159  */
160  if (likely(digit < 10))
161  {
162  ptr++;
163  tmp = digit;
164  }
165  else
166  {
167  /* we need at least one digit */
168  goto slow;
169  }
170 
171  /* process remaining digits */
172  for (;;)
173  {
174  digit = (*ptr - '0');
175 
176  if (digit >= 10)
177  break;
178 
179  ptr++;
180 
181  if (unlikely(tmp > -(PG_INT16_MIN / 10)))
182  goto out_of_range;
183 
184  tmp = tmp * 10 + digit;
185  }
186 
187  /* when the string does not end in a digit, let the slow path handle it */
188  if (unlikely(*ptr != '\0'))
189  goto slow;
190 
191  if (neg)
192  {
193  /* check the negative equivalent will fit without overflowing */
194  if (unlikely(tmp > (uint16) (-(PG_INT16_MIN + 1)) + 1))
195  goto out_of_range;
196  return -((int16) tmp);
197  }
198 
199  if (unlikely(tmp > PG_INT16_MAX))
200  goto out_of_range;
201 
202  return (int16) tmp;
203 
204 slow:
205  tmp = 0;
206  ptr = s;
207  /* no need to reset neg */
208 
209  /* skip leading spaces */
210  while (isspace((unsigned char) *ptr))
211  ptr++;
212 
213  /* handle sign */
214  if (*ptr == '-')
215  {
216  ptr++;
217  neg = true;
218  }
219  else if (*ptr == '+')
220  ptr++;
221 
222  /* process digits */
223  if (ptr[0] == '0' && (ptr[1] == 'x' || ptr[1] == 'X'))
224  {
225  firstdigit = ptr += 2;
226 
227  for (;;)
228  {
229  if (isxdigit((unsigned char) *ptr))
230  {
231  if (unlikely(tmp > -(PG_INT16_MIN / 16)))
232  goto out_of_range;
233 
234  tmp = tmp * 16 + hexlookup[(unsigned char) *ptr++];
235  }
236  else if (*ptr == '_')
237  {
238  /* underscore must be followed by more digits */
239  ptr++;
240  if (*ptr == '\0' || !isxdigit((unsigned char) *ptr))
241  goto invalid_syntax;
242  }
243  else
244  break;
245  }
246  }
247  else if (ptr[0] == '0' && (ptr[1] == 'o' || ptr[1] == 'O'))
248  {
249  firstdigit = ptr += 2;
250 
251  for (;;)
252  {
253  if (*ptr >= '0' && *ptr <= '7')
254  {
255  if (unlikely(tmp > -(PG_INT16_MIN / 8)))
256  goto out_of_range;
257 
258  tmp = tmp * 8 + (*ptr++ - '0');
259  }
260  else if (*ptr == '_')
261  {
262  /* underscore must be followed by more digits */
263  ptr++;
264  if (*ptr == '\0' || *ptr < '0' || *ptr > '7')
265  goto invalid_syntax;
266  }
267  else
268  break;
269  }
270  }
271  else if (ptr[0] == '0' && (ptr[1] == 'b' || ptr[1] == 'B'))
272  {
273  firstdigit = ptr += 2;
274 
275  for (;;)
276  {
277  if (*ptr >= '0' && *ptr <= '1')
278  {
279  if (unlikely(tmp > -(PG_INT16_MIN / 2)))
280  goto out_of_range;
281 
282  tmp = tmp * 2 + (*ptr++ - '0');
283  }
284  else if (*ptr == '_')
285  {
286  /* underscore must be followed by more digits */
287  ptr++;
288  if (*ptr == '\0' || *ptr < '0' || *ptr > '1')
289  goto invalid_syntax;
290  }
291  else
292  break;
293  }
294  }
295  else
296  {
297  firstdigit = ptr;
298 
299  for (;;)
300  {
301  if (*ptr >= '0' && *ptr <= '9')
302  {
303  if (unlikely(tmp > -(PG_INT16_MIN / 10)))
304  goto out_of_range;
305 
306  tmp = tmp * 10 + (*ptr++ - '0');
307  }
308  else if (*ptr == '_')
309  {
310  /* underscore may not be first */
311  if (unlikely(ptr == firstdigit))
312  goto invalid_syntax;
313  /* and it must be followed by more digits */
314  ptr++;
315  if (*ptr == '\0' || !isdigit((unsigned char) *ptr))
316  goto invalid_syntax;
317  }
318  else
319  break;
320  }
321  }
322 
323  /* require at least one digit */
324  if (unlikely(ptr == firstdigit))
325  goto invalid_syntax;
326 
327  /* allow trailing whitespace, but not other trailing chars */
328  while (isspace((unsigned char) *ptr))
329  ptr++;
330 
331  if (unlikely(*ptr != '\0'))
332  goto invalid_syntax;
333 
334  if (neg)
335  {
336  /* check the negative equivalent will fit without overflowing */
337  if (tmp > (uint16) (-(PG_INT16_MIN + 1)) + 1)
338  goto out_of_range;
339  return -((int16) tmp);
340  }
341 
342  if (tmp > PG_INT16_MAX)
343  goto out_of_range;
344 
345  return (int16) tmp;
346 
347 out_of_range:
348  ereturn(escontext, 0,
349  (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
350  errmsg("value \"%s\" is out of range for type %s",
351  s, "smallint")));
352 
353 invalid_syntax:
354  ereturn(escontext, 0,
355  (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
356  errmsg("invalid input syntax for type %s: \"%s\"",
357  "smallint", s)));
358 }
unsigned short uint16
Definition: c.h:505
#define likely(x)
Definition: c.h:310
#define PG_INT16_MIN
Definition: c.h:585
#define unlikely(x)
Definition: c.h:311
#define PG_INT16_MAX
Definition: c.h:586
static const int8 hexlookup[128]
Definition: numutils.c:87

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

Referenced by int2in(), and pg_strtoint16().

◆ pg_strtoint32()

int32 pg_strtoint32 ( const char *  s)

Definition at line 383 of file numutils.c.

384 {
385  return pg_strtoint32_safe(s, NULL);
386 }
int32 pg_strtoint32_safe(const char *s, Node *escontext)
Definition: numutils.c:389

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.

390 {
391  const char *ptr = s;
392  const char *firstdigit;
393  uint32 tmp = 0;
394  bool neg = false;
395  unsigned char digit;
396 
397  /*
398  * The majority of cases are likely to be base-10 digits without any
399  * underscore separator characters. We'll first try to parse the string
400  * with the assumption that's the case and only fallback on a slower
401  * implementation which handles hex, octal and binary strings and
402  * underscores if the fastpath version cannot parse the string.
403  */
404 
405  /* leave it up to the slow path to look for leading spaces */
406 
407  if (*ptr == '-')
408  {
409  ptr++;
410  neg = true;
411  }
412 
413  /* a leading '+' is uncommon so leave that for the slow path */
414 
415  /* process the first digit */
416  digit = (*ptr - '0');
417 
418  /*
419  * Exploit unsigned arithmetic to save having to check both the upper and
420  * lower bounds of the digit.
421  */
422  if (likely(digit < 10))
423  {
424  ptr++;
425  tmp = digit;
426  }
427  else
428  {
429  /* we need at least one digit */
430  goto slow;
431  }
432 
433  /* process remaining digits */
434  for (;;)
435  {
436  digit = (*ptr - '0');
437 
438  if (digit >= 10)
439  break;
440 
441  ptr++;
442 
443  if (unlikely(tmp > -(PG_INT32_MIN / 10)))
444  goto out_of_range;
445 
446  tmp = tmp * 10 + digit;
447  }
448 
449  /* when the string does not end in a digit, let the slow path handle it */
450  if (unlikely(*ptr != '\0'))
451  goto slow;
452 
453  if (neg)
454  {
455  /* check the negative equivalent will fit without overflowing */
456  if (unlikely(tmp > (uint32) (-(PG_INT32_MIN + 1)) + 1))
457  goto out_of_range;
458  return -((int32) tmp);
459  }
460 
461  if (unlikely(tmp > PG_INT32_MAX))
462  goto out_of_range;
463 
464  return (int32) tmp;
465 
466 slow:
467  tmp = 0;
468  ptr = s;
469  /* no need to reset neg */
470 
471  /* skip leading spaces */
472  while (isspace((unsigned char) *ptr))
473  ptr++;
474 
475  /* handle sign */
476  if (*ptr == '-')
477  {
478  ptr++;
479  neg = true;
480  }
481  else if (*ptr == '+')
482  ptr++;
483 
484  /* process digits */
485  if (ptr[0] == '0' && (ptr[1] == 'x' || ptr[1] == 'X'))
486  {
487  firstdigit = ptr += 2;
488 
489  for (;;)
490  {
491  if (isxdigit((unsigned char) *ptr))
492  {
493  if (unlikely(tmp > -(PG_INT32_MIN / 16)))
494  goto out_of_range;
495 
496  tmp = tmp * 16 + hexlookup[(unsigned char) *ptr++];
497  }
498  else if (*ptr == '_')
499  {
500  /* underscore must be followed by more digits */
501  ptr++;
502  if (*ptr == '\0' || !isxdigit((unsigned char) *ptr))
503  goto invalid_syntax;
504  }
505  else
506  break;
507  }
508  }
509  else if (ptr[0] == '0' && (ptr[1] == 'o' || ptr[1] == 'O'))
510  {
511  firstdigit = ptr += 2;
512 
513  for (;;)
514  {
515  if (*ptr >= '0' && *ptr <= '7')
516  {
517  if (unlikely(tmp > -(PG_INT32_MIN / 8)))
518  goto out_of_range;
519 
520  tmp = tmp * 8 + (*ptr++ - '0');
521  }
522  else if (*ptr == '_')
523  {
524  /* underscore must be followed by more digits */
525  ptr++;
526  if (*ptr == '\0' || *ptr < '0' || *ptr > '7')
527  goto invalid_syntax;
528  }
529  else
530  break;
531  }
532  }
533  else if (ptr[0] == '0' && (ptr[1] == 'b' || ptr[1] == 'B'))
534  {
535  firstdigit = ptr += 2;
536 
537  for (;;)
538  {
539  if (*ptr >= '0' && *ptr <= '1')
540  {
541  if (unlikely(tmp > -(PG_INT32_MIN / 2)))
542  goto out_of_range;
543 
544  tmp = tmp * 2 + (*ptr++ - '0');
545  }
546  else if (*ptr == '_')
547  {
548  /* underscore must be followed by more digits */
549  ptr++;
550  if (*ptr == '\0' || *ptr < '0' || *ptr > '1')
551  goto invalid_syntax;
552  }
553  else
554  break;
555  }
556  }
557  else
558  {
559  firstdigit = ptr;
560 
561  for (;;)
562  {
563  if (*ptr >= '0' && *ptr <= '9')
564  {
565  if (unlikely(tmp > -(PG_INT32_MIN / 10)))
566  goto out_of_range;
567 
568  tmp = tmp * 10 + (*ptr++ - '0');
569  }
570  else if (*ptr == '_')
571  {
572  /* underscore may not be first */
573  if (unlikely(ptr == firstdigit))
574  goto invalid_syntax;
575  /* and it must be followed by more digits */
576  ptr++;
577  if (*ptr == '\0' || !isdigit((unsigned char) *ptr))
578  goto invalid_syntax;
579  }
580  else
581  break;
582  }
583  }
584 
585  /* require at least one digit */
586  if (unlikely(ptr == firstdigit))
587  goto invalid_syntax;
588 
589  /* allow trailing whitespace, but not other trailing chars */
590  while (isspace((unsigned char) *ptr))
591  ptr++;
592 
593  if (unlikely(*ptr != '\0'))
594  goto invalid_syntax;
595 
596  if (neg)
597  {
598  /* check the negative equivalent will fit without overflowing */
599  if (tmp > (uint32) (-(PG_INT32_MIN + 1)) + 1)
600  goto out_of_range;
601  return -((int32) tmp);
602  }
603 
604  if (tmp > PG_INT32_MAX)
605  goto out_of_range;
606 
607  return (int32) tmp;
608 
609 out_of_range:
610  ereturn(escontext, 0,
611  (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
612  errmsg("value \"%s\" is out of range for type %s",
613  s, "integer")));
614 
615 invalid_syntax:
616  ereturn(escontext, 0,
617  (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
618  errmsg("invalid input syntax for type %s: \"%s\"",
619  "integer", s)));
620 }
#define PG_INT32_MAX
Definition: c.h:589
#define PG_INT32_MIN
Definition: c.h:588

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

Referenced by int4in(), and pg_strtoint32().

◆ pg_strtoint64()

int64 pg_strtoint64 ( const char *  s)

Definition at line 645 of file numutils.c.

646 {
647  return pg_strtoint64_safe(s, NULL);
648 }
int64 pg_strtoint64_safe(const char *s, Node *escontext)
Definition: numutils.c:651

References pg_strtoint64_safe().

◆ pg_strtoint64_safe()

int64 pg_strtoint64_safe ( const char *  s,
Node escontext 
)

Definition at line 651 of file numutils.c.

652 {
653  const char *ptr = s;
654  const char *firstdigit;
655  uint64 tmp = 0;
656  bool neg = false;
657  unsigned char digit;
658 
659  /*
660  * The majority of cases are likely to be base-10 digits without any
661  * underscore separator characters. We'll first try to parse the string
662  * with the assumption that's the case and only fallback on a slower
663  * implementation which handles hex, octal and binary strings and
664  * underscores if the fastpath version cannot parse the string.
665  */
666 
667  /* leave it up to the slow path to look for leading spaces */
668 
669  if (*ptr == '-')
670  {
671  ptr++;
672  neg = true;
673  }
674 
675  /* a leading '+' is uncommon so leave that for the slow path */
676 
677  /* process the first digit */
678  digit = (*ptr - '0');
679 
680  /*
681  * Exploit unsigned arithmetic to save having to check both the upper and
682  * lower bounds of the digit.
683  */
684  if (likely(digit < 10))
685  {
686  ptr++;
687  tmp = digit;
688  }
689  else
690  {
691  /* we need at least one digit */
692  goto slow;
693  }
694 
695  /* process remaining digits */
696  for (;;)
697  {
698  digit = (*ptr - '0');
699 
700  if (digit >= 10)
701  break;
702 
703  ptr++;
704 
705  if (unlikely(tmp > -(PG_INT64_MIN / 10)))
706  goto out_of_range;
707 
708  tmp = tmp * 10 + digit;
709  }
710 
711  /* when the string does not end in a digit, let the slow path handle it */
712  if (unlikely(*ptr != '\0'))
713  goto slow;
714 
715  if (neg)
716  {
717  /* check the negative equivalent will fit without overflowing */
718  if (unlikely(tmp > (uint64) (-(PG_INT64_MIN + 1)) + 1))
719  goto out_of_range;
720  return -((int64) tmp);
721  }
722 
723  if (unlikely(tmp > PG_INT64_MAX))
724  goto out_of_range;
725 
726  return (int64) tmp;
727 
728 slow:
729  tmp = 0;
730  ptr = s;
731  /* no need to reset neg */
732 
733  /* skip leading spaces */
734  while (isspace((unsigned char) *ptr))
735  ptr++;
736 
737  /* handle sign */
738  if (*ptr == '-')
739  {
740  ptr++;
741  neg = true;
742  }
743  else if (*ptr == '+')
744  ptr++;
745 
746  /* process digits */
747  if (ptr[0] == '0' && (ptr[1] == 'x' || ptr[1] == 'X'))
748  {
749  firstdigit = ptr += 2;
750 
751  for (;;)
752  {
753  if (isxdigit((unsigned char) *ptr))
754  {
755  if (unlikely(tmp > -(PG_INT64_MIN / 16)))
756  goto out_of_range;
757 
758  tmp = tmp * 16 + hexlookup[(unsigned char) *ptr++];
759  }
760  else if (*ptr == '_')
761  {
762  /* underscore must be followed by more digits */
763  ptr++;
764  if (*ptr == '\0' || !isxdigit((unsigned char) *ptr))
765  goto invalid_syntax;
766  }
767  else
768  break;
769  }
770  }
771  else if (ptr[0] == '0' && (ptr[1] == 'o' || ptr[1] == 'O'))
772  {
773  firstdigit = ptr += 2;
774 
775  for (;;)
776  {
777  if (*ptr >= '0' && *ptr <= '7')
778  {
779  if (unlikely(tmp > -(PG_INT64_MIN / 8)))
780  goto out_of_range;
781 
782  tmp = tmp * 8 + (*ptr++ - '0');
783  }
784  else if (*ptr == '_')
785  {
786  /* underscore must be followed by more digits */
787  ptr++;
788  if (*ptr == '\0' || *ptr < '0' || *ptr > '7')
789  goto invalid_syntax;
790  }
791  else
792  break;
793  }
794  }
795  else if (ptr[0] == '0' && (ptr[1] == 'b' || ptr[1] == 'B'))
796  {
797  firstdigit = ptr += 2;
798 
799  for (;;)
800  {
801  if (*ptr >= '0' && *ptr <= '1')
802  {
803  if (unlikely(tmp > -(PG_INT64_MIN / 2)))
804  goto out_of_range;
805 
806  tmp = tmp * 2 + (*ptr++ - '0');
807  }
808  else if (*ptr == '_')
809  {
810  /* underscore must be followed by more digits */
811  ptr++;
812  if (*ptr == '\0' || *ptr < '0' || *ptr > '1')
813  goto invalid_syntax;
814  }
815  else
816  break;
817  }
818  }
819  else
820  {
821  firstdigit = ptr;
822 
823  for (;;)
824  {
825  if (*ptr >= '0' && *ptr <= '9')
826  {
827  if (unlikely(tmp > -(PG_INT64_MIN / 10)))
828  goto out_of_range;
829 
830  tmp = tmp * 10 + (*ptr++ - '0');
831  }
832  else if (*ptr == '_')
833  {
834  /* underscore may not be first */
835  if (unlikely(ptr == firstdigit))
836  goto invalid_syntax;
837  /* and it must be followed by more digits */
838  ptr++;
839  if (*ptr == '\0' || !isdigit((unsigned char) *ptr))
840  goto invalid_syntax;
841  }
842  else
843  break;
844  }
845  }
846 
847  /* require at least one digit */
848  if (unlikely(ptr == firstdigit))
849  goto invalid_syntax;
850 
851  /* allow trailing whitespace, but not other trailing chars */
852  while (isspace((unsigned char) *ptr))
853  ptr++;
854 
855  if (unlikely(*ptr != '\0'))
856  goto invalid_syntax;
857 
858  if (neg)
859  {
860  /* check the negative equivalent will fit without overflowing */
861  if (tmp > (uint64) (-(PG_INT64_MIN + 1)) + 1)
862  goto out_of_range;
863  return -((int64) tmp);
864  }
865 
866  if (tmp > PG_INT64_MAX)
867  goto out_of_range;
868 
869  return (int64) tmp;
870 
871 out_of_range:
872  ereturn(escontext, 0,
873  (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
874  errmsg("value \"%s\" is out of range for type %s",
875  s, "bigint")));
876 
877 invalid_syntax:
878  ereturn(escontext, 0,
879  (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
880  errmsg("invalid input syntax for type %s: \"%s\"",
881  "bigint", s)));
882 }
#define PG_INT64_MAX
Definition: c.h:592
#define PG_INT64_MIN
Definition: c.h:591

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

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

◆ pg_ulltoa_n()

int pg_ulltoa_n ( uint64  value,
char *  a 
)

Definition at line 1142 of file numutils.c.

1143 {
1144  int olength,
1145  i = 0;
1146  uint32 value2;
1147 
1148  /* Degenerate case */
1149  if (value == 0)
1150  {
1151  *a = '0';
1152  return 1;
1153  }
1154 
1155  olength = decimalLength64(value);
1156 
1157  /* Compute the result string. */
1158  while (value >= 100000000)
1159  {
1160  const uint64 q = value / 100000000;
1161  uint32 value3 = (uint32) (value - 100000000 * q);
1162 
1163  const uint32 c = value3 % 10000;
1164  const uint32 d = value3 / 10000;
1165  const uint32 c0 = (c % 100) << 1;
1166  const uint32 c1 = (c / 100) << 1;
1167  const uint32 d0 = (d % 100) << 1;
1168  const uint32 d1 = (d / 100) << 1;
1169 
1170  char *pos = a + olength - i;
1171 
1172  value = q;
1173 
1174  memcpy(pos - 2, DIGIT_TABLE + c0, 2);
1175  memcpy(pos - 4, DIGIT_TABLE + c1, 2);
1176  memcpy(pos - 6, DIGIT_TABLE + d0, 2);
1177  memcpy(pos - 8, DIGIT_TABLE + d1, 2);
1178  i += 8;
1179  }
1180 
1181  /* Switch to 32-bit for speed */
1182  value2 = (uint32) value;
1183 
1184  if (value2 >= 10000)
1185  {
1186  const uint32 c = value2 - 10000 * (value2 / 10000);
1187  const uint32 c0 = (c % 100) << 1;
1188  const uint32 c1 = (c / 100) << 1;
1189 
1190  char *pos = a + olength - i;
1191 
1192  value2 /= 10000;
1193 
1194  memcpy(pos - 2, DIGIT_TABLE + c0, 2);
1195  memcpy(pos - 4, DIGIT_TABLE + c1, 2);
1196  i += 4;
1197  }
1198  if (value2 >= 100)
1199  {
1200  const uint32 c = (value2 % 100) << 1;
1201  char *pos = a + olength - i;
1202 
1203  value2 /= 100;
1204 
1205  memcpy(pos - 2, DIGIT_TABLE + c, 2);
1206  i += 2;
1207  }
1208  if (value2 >= 10)
1209  {
1210  const uint32 c = value2 << 1;
1211  char *pos = a + olength - i;
1212 
1213  memcpy(pos - 2, DIGIT_TABLE + c, 2);
1214  }
1215  else
1216  *a = (char) ('0' + value2);
1217 
1218  return olength;
1219 }
static const char DIGIT_TABLE[200]
Definition: numutils.c:28
static int decimalLength64(const uint64 v)
Definition: numutils.c:63
char * c

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 1057 of file numutils.c.

1058 {
1059  int olength,
1060  i = 0;
1061 
1062  /* Degenerate case */
1063  if (value == 0)
1064  {
1065  *a = '0';
1066  return 1;
1067  }
1068 
1069  olength = decimalLength32(value);
1070 
1071  /* Compute the result string. */
1072  while (value >= 10000)
1073  {
1074  const uint32 c = value - 10000 * (value / 10000);
1075  const uint32 c0 = (c % 100) << 1;
1076  const uint32 c1 = (c / 100) << 1;
1077 
1078  char *pos = a + olength - i;
1079 
1080  value /= 10000;
1081 
1082  memcpy(pos - 2, DIGIT_TABLE + c0, 2);
1083  memcpy(pos - 4, DIGIT_TABLE + c1, 2);
1084  i += 4;
1085  }
1086  if (value >= 100)
1087  {
1088  const uint32 c = (value % 100) << 1;
1089 
1090  char *pos = a + olength - i;
1091 
1092  value /= 100;
1093 
1094  memcpy(pos - 2, DIGIT_TABLE + c, 2);
1095  i += 2;
1096  }
1097  if (value >= 10)
1098  {
1099  const uint32 c = value << 1;
1100 
1101  char *pos = a + olength - i;
1102 
1103  memcpy(pos - 2, DIGIT_TABLE + c, 2);
1104  }
1105  else
1106  {
1107  *a = (char) ('0' + value);
1108  }
1109 
1110  return olength;
1111 }
static int decimalLength32(const uint32 v)
Definition: numutils.c:44

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 1309 of file numutils.c.

1310 {
1311  int len = pg_ultoa_n(value, str);
1312 
1313  return str + len;
1314 }

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 1269 of file numutils.c.

1270 {
1271  int len;
1272 
1273  Assert(minwidth > 0);
1274 
1275  if (value < 100 && minwidth == 2) /* Short cut for common case */
1276  {
1277  memcpy(str, DIGIT_TABLE + value * 2, 2);
1278  return str + 2;
1279  }
1280 
1281  len = pg_ultoa_n(value, str);
1282  if (len >= minwidth)
1283  return str + len;
1284 
1285  memmove(str + minwidth - len, str, len);
1286  memset(str, '0', minwidth - len);
1287  return str + minwidth;
1288 }

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 12623 of file ruleutils.c.

12624 {
12625  /*
12626  * Can avoid quoting if ident starts with a lowercase letter or underscore
12627  * and contains only lowercase letters, digits, and underscores, *and* is
12628  * not any SQL keyword. Otherwise, supply quotes.
12629  */
12630  int nquotes = 0;
12631  bool safe;
12632  const char *ptr;
12633  char *result;
12634  char *optr;
12635 
12636  /*
12637  * would like to use <ctype.h> macros here, but they might yield unwanted
12638  * locale-specific results...
12639  */
12640  safe = ((ident[0] >= 'a' && ident[0] <= 'z') || ident[0] == '_');
12641 
12642  for (ptr = ident; *ptr; ptr++)
12643  {
12644  char ch = *ptr;
12645 
12646  if ((ch >= 'a' && ch <= 'z') ||
12647  (ch >= '0' && ch <= '9') ||
12648  (ch == '_'))
12649  {
12650  /* okay */
12651  }
12652  else
12653  {
12654  safe = false;
12655  if (ch == '"')
12656  nquotes++;
12657  }
12658  }
12659 
12661  safe = false;
12662 
12663  if (safe)
12664  {
12665  /*
12666  * Check for keyword. We quote keywords except for unreserved ones.
12667  * (In some cases we could avoid quoting a col_name or type_func_name
12668  * keyword, but it seems much harder than it's worth to tell that.)
12669  *
12670  * Note: ScanKeywordLookup() does case-insensitive comparison, but
12671  * that's fine, since we already know we have all-lower-case.
12672  */
12673  int kwnum = ScanKeywordLookup(ident, &ScanKeywords);
12674 
12675  if (kwnum >= 0 && ScanKeywordCategories[kwnum] != UNRESERVED_KEYWORD)
12676  safe = false;
12677  }
12678 
12679  if (safe)
12680  return ident; /* no change needed */
12681 
12682  result = (char *) palloc(strlen(ident) + nquotes + 2 + 1);
12683 
12684  optr = result;
12685  *optr++ = '"';
12686  for (ptr = ident; *ptr; ptr++)
12687  {
12688  char ch = *ptr;
12689 
12690  if (ch == '"')
12691  *optr++ = '"';
12692  *optr++ = ch;
12693  }
12694  *optr++ = '"';
12695  *optr = '\0';
12696 
12697  return result;
12698 }
const uint8 ScanKeywordCategories[SCANKEYWORDS_NUM_KEYWORDS]
Definition: keywords.c:29
#define ident
Definition: indent_codes.h:47
PGDLLIMPORT const ScanKeywordList ScanKeywords
#define UNRESERVED_KEYWORD
Definition: keywords.h:20
int ScanKeywordLookup(const char *str, const ScanKeywordList *keywords)
Definition: kwlookup.c:38
bool quote_all_identifiers
Definition: ruleutils.c:323

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(), processIndirection(), quote_ident(), quote_object_name(), quote_qualified_identifier(), regnamespaceout(), regoperout(), regroleout(), ReplicationSlotDropAtPubNode(), report_extension_updates(), 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.

104 {
105  char *result;
106  int len;
107  int newlen;
108 
109  len = strlen(rawstr);
110  /* We make a worst-case result area; wasting a little space is OK */
111  result = palloc(len * 2 + 3 + 1);
112 
113  newlen = quote_literal_internal(result, rawstr, len);
114  result[newlen] = '\0';
115 
116  return result;
117 }
static size_t quote_literal_internal(char *dst, const char *src, size_t len)
Definition: quote.c:47

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

Referenced by build_tuplestore_recursively(), fetch_remote_table_info(), get_publications_str(), get_sql_delete(), get_sql_insert(), get_sql_update(), get_tuple_of_interest(), 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()

◆ 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.

1955 {
1956  char *result;
1957  regex_t *re;
1958  int cflags;
1959  int re_result;
1960  pg_wchar *str;
1961  size_t slen;
1962  size_t maxlen;
1963  char errMsg[100];
1964 
1965  *exact = false; /* default result */
1966 
1967  /* Compile RE */
1968  cflags = REG_ADVANCED;
1969  if (case_insensitive)
1970  cflags |= REG_ICASE;
1971 
1972  re = RE_compile_and_cache(text_re, cflags | REG_NOSUB, collation);
1973 
1974  /* Examine it to see if there's a fixed prefix */
1975  re_result = pg_regprefix(re, &str, &slen);
1976 
1977  switch (re_result)
1978  {
1979  case REG_NOMATCH:
1980  return NULL;
1981 
1982  case REG_PREFIX:
1983  /* continue with wchar conversion */
1984  break;
1985 
1986  case REG_EXACT:
1987  *exact = true;
1988  /* continue with wchar conversion */
1989  break;
1990 
1991  default:
1992  /* re failed??? */
1993  pg_regerror(re_result, re, errMsg, sizeof(errMsg));
1994  ereport(ERROR,
1995  (errcode(ERRCODE_INVALID_REGULAR_EXPRESSION),
1996  errmsg("regular expression failed: %s", errMsg)));
1997  break;
1998  }
1999 
2000  /* Convert pg_wchar result back to database encoding */
2001  maxlen = pg_database_encoding_max_length() * slen + 1;
2002  result = (char *) palloc(maxlen);
2003  slen = pg_wchar2mb_with_len(str, result, slen);
2004  Assert(slen < maxlen);
2005 
2006  pfree(str);
2007 
2008  return result;
2009 }
#define ereport(elevel,...)
Definition: elog.h:149
unsigned int pg_wchar
Definition: mbprint.c:31
int pg_wchar2mb_with_len(const pg_wchar *from, char *to, int len)
Definition: mbutils.c:1008
int pg_database_encoding_max_length(void)
Definition: mbutils.c:1546
void pfree(void *pointer)
Definition: mcxt.c:1520
size_t pg_regerror(int errcode, const regex_t *preg, char *errbuf, size_t errbuf_size)
Definition: regerror.c:60
#define REG_ICASE
Definition: regex.h:106
#define REG_NOMATCH
Definition: regex.h:138
#define REG_EXACT
Definition: regex.h:162
#define REG_PREFIX
Definition: regex.h:161
#define REG_ADVANCED
Definition: regex.h:103
#define REG_NOSUB
Definition: regex.h:107
regex_t * RE_compile_and_cache(text *text_re, int cflags, Oid collation)
Definition: regexp.c:141
int pg_regprefix(regex_t *re, chr **string, size_t *slength)
Definition: regprefix.c:46
Definition: regex.h:56

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, 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.

218 {
219  /* must cast away the const, unfortunately */
220  text *tunpacked = pg_detoast_datum_packed(unconstify(text *, t));
221  int len = VARSIZE_ANY_EXHDR(tunpacked);
222  char *result;
223 
224  result = (char *) palloc(len + 1);
225  memcpy(result, VARDATA_ANY(tunpacked), len);
226  result[len] = '\0';
227 
228  if (tunpacked != t)
229  pfree(tunpacked);
230 
231  return result;
232 }
#define unconstify(underlying_type, expr)
Definition: c.h:1245
struct varlena * pg_detoast_datum_packed(struct varlena *datum)
Definition: fmgr.c:1864
#define VARDATA_ANY(PTR)
Definition: varatt.h:324
#define VARSIZE_ANY_EXHDR(PTR)
Definition: varatt.h:317

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_detach(), injection_points_run(), 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_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(), transform_string_values_scalar(), 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.

249 {
250  /* must cast away the const, unfortunately */
251  text *srcunpacked = pg_detoast_datum_packed(unconstify(text *, src));
252  size_t src_len = VARSIZE_ANY_EXHDR(srcunpacked);
253 
254  if (dst_len > 0)
255  {
256  dst_len--;
257  if (dst_len >= src_len)
258  dst_len = src_len;
259  else /* ensure truncation is encoding-safe */
260  dst_len = pg_mbcliplen(VARDATA_ANY(srcunpacked), src_len, dst_len);
261  memcpy(dst, VARDATA_ANY(srcunpacked), dst_len);
262  dst[dst_len] = '\0';
263  }
264 
265  if (srcunpacked != src)
266  pfree(srcunpacked);
267 }
int pg_mbcliplen(const char *mbstr, int len, int limit)
Definition: mbutils.c:1083

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.

413 {
414  if (typemod < 0)
415  return -1;
416 
417  switch (type_oid)
418  {
419  case BPCHAROID:
420  case VARCHAROID:
421  /* typemod includes varlena header */
422 
423  /* typemod is in characters not bytes */
424  return (typemod - VARHDRSZ) *
426  + VARHDRSZ;
427 
428  case NUMERICOID:
429  return numeric_maximum_size(typemod);
430 
431  case VARBITOID:
432  case BITOID:
433  /* typemod is the (max) number of bits */
434  return (typemod + (BITS_PER_BYTE - 1)) / BITS_PER_BYTE
435  + 2 * sizeof(int32);
436  }
437 
438  /* Unknown type, or unlimited-width type such as 'text' */
439  return -1;
440 }
int32 numeric_maximum_size(int32 typmod)
Definition: numeric.c:944
int GetDatabaseEncoding(void)
Definition: mbutils.c:1261
#define BITS_PER_BYTE
int pg_encoding_max_length(int encoding)
Definition: wchar.c:2127

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 900 of file numutils.c.

902 {
903  uint32 result;
904  unsigned long cvt;
905  char *endptr;
906 
907  errno = 0;
908  cvt = strtoul(s, &endptr, 0);
909 
910  /*
911  * strtoul() normally only sets ERANGE. On some systems it may also set
912  * EINVAL, which simply means it couldn't parse the input string. Be sure
913  * to report that the same way as the standard error indication (that
914  * endptr == s).
915  */
916  if ((errno && errno != ERANGE) || endptr == s)
917  ereturn(escontext, 0,
918  (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
919  errmsg("invalid input syntax for type %s: \"%s\"",
920  typname, s)));
921 
922  if (errno == ERANGE)
923  ereturn(escontext, 0,
924  (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
925  errmsg("value \"%s\" is out of range for type %s",
926  s, typname)));
927 
928  if (endloc)
929  {
930  /* caller wants to deal with rest of string */
931  *endloc = endptr;
932  }
933  else
934  {
935  /* allow only whitespace after number */
936  while (*endptr && isspace((unsigned char) *endptr))
937  endptr++;
938  if (*endptr)
939  ereturn(escontext, 0,
940  (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
941  errmsg("invalid input syntax for type %s: \"%s\"",
942  typname, s)));
943  }
944 
945  result = (uint32) cvt;
946 
947  /*
948  * Cope with possibility that unsigned long is wider than uint32, in which
949  * case strtoul will not raise an error for some values that are out of
950  * the range of uint32.
951  *
952  * For backwards compatibility, we want to accept inputs that are given
953  * with a minus sign, so allow the input value if it matches after either
954  * signed or unsigned extension to long.
955  *
956  * To ensure consistent results on 32-bit and 64-bit platforms, make sure
957  * the error message is the same as if strtoul() had returned ERANGE.
958  */
959 #if PG_UINT32_MAX != ULONG_MAX
960  if (cvt != (unsigned long) result &&
961  cvt != (unsigned long) ((int) result))
962  ereturn(escontext, 0,
963  (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
964  errmsg("value \"%s\" is out of range for type %s",
965  s, typname)));
966 #endif
967 
968  return result;
969 }

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 987 of file numutils.c.

989 {
990  uint64 result;
991  char *endptr;
992 
993  errno = 0;
994  result = strtou64(s, &endptr, 0);
995 
996  /*
997  * strtoul[l] normally only sets ERANGE. On some systems it may also set
998  * EINVAL, which simply means it couldn't parse the input string. Be sure
999  * to report that the same way as the standard error indication (that
1000  * endptr == s).
1001  */
1002  if ((errno && errno != ERANGE) || endptr == s)
1003  ereturn(escontext, 0,
1004  (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
1005  errmsg("invalid input syntax for type %s: \"%s\"",
1006  typname, s)));
1007 
1008  if (errno == ERANGE)
1009  ereturn(escontext, 0,
1010  (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
1011  errmsg("value \"%s\" is out of range for type %s",
1012  s, typname)));
1013 
1014  if (endloc)
1015  {
1016  /* caller wants to deal with rest of string */
1017  *endloc = endptr;
1018  }
1019  else
1020  {
1021  /* allow only whitespace after number */
1022  while (*endptr && isspace((unsigned char) *endptr))
1023  endptr++;
1024  if (*endptr)
1025  ereturn(escontext, 0,
1026  (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
1027  errmsg("invalid input syntax for type %s: \"%s\"",
1028  typname, s)));
1029  }
1030 
1031  return result;
1032 }
#define strtou64(str, endptr, base)
Definition: c.h:1298

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

Referenced by xid8in().

◆ xidComparator()

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

Definition at line 139 of file xid.c.

140 {
141  TransactionId xid1 = *(const TransactionId *) arg1;
142  TransactionId xid2 = *(const TransactionId *) arg2;
143 
144  return pg_cmp_u32(xid1, xid2);
145 }
uint32 TransactionId
Definition: c.h:652

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 156 of file xid.c.

157 {
158  TransactionId xid1 = *(const TransactionId *) arg1;
159  TransactionId xid2 = *(const TransactionId *) arg2;
160 
163 
164  if (TransactionIdPrecedes(xid1, xid2))
165  return -1;
166 
167  if (TransactionIdPrecedes(xid2, xid1))
168  return 1;
169 
170  return 0;
171 }
bool TransactionIdPrecedes(TransactionId id1, TransactionId id2)
Definition: transam.c:280
#define TransactionIdIsNormal(xid)
Definition: transam.h:42

References Assert, TransactionIdIsNormal, and TransactionIdPrecedes().

Referenced by ProcArrayApplyRecoveryInfo().

Variable Documentation

◆ quote_all_identifiers

PGDLLIMPORT bool quote_all_identifiers
extern

Definition at line 323 of file ruleutils.c.

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