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)
 
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 94 of file builtins.h.

◆ FORMAT_TYPE_ALLOW_INVALID

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

Definition at line 122 of file builtins.h.

◆ FORMAT_TYPE_FORCE_QUALIFY

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

Definition at line 123 of file builtins.h.

◆ FORMAT_TYPE_INVALID_AS_NULL

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

Definition at line 124 of file builtins.h.

◆ FORMAT_TYPE_TYPEMOD_GIVEN

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

Definition at line 121 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 95 of file builtins.h.

Function Documentation

◆ bpchartruelen()

int bpchartruelen ( char *  s,
int  len 
)

Definition at line 677 of file varchar.c.

678 {
679  int i;
680 
681  /*
682  * Note that we rely on the assumption that ' ' is a singleton unit on
683  * every supported multibyte server encoding.
684  */
685  for (i = len - 1; i >= 0; i--)
686  {
687  if (s[i] != ' ')
688  break;
689  }
690  return i + 1;
691 }
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:482
#define Int2VectorSize(n)
Definition: int.c:45
void * palloc0(Size size)
Definition: mcxt.c:1257
Definition: c.h:704
int ndim
Definition: c.h:706
int dim1
Definition: c.h:709
Oid elemtype
Definition: c.h:708
int16 values[FLEXIBLE_ARRAY_MEMBER]
Definition: c.h:711
int32 dataoffset
Definition: c.h:707
int lbound1
Definition: c.h:710
#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 86 of file oid.c.

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

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 @148 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 182 of file varlena.c.

183 {
184  return cstring_to_text_with_len(s, strlen(s));
185 }
text * cstring_to_text_with_len(const char *s, int len)
Definition: varlena.c:194

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(), 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(), tsquerytree(), unaccent_dict(), 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 194 of file varlena.c.

195 {
196  text *result = (text *) palloc(len + VARHDRSZ);
197 
198  SET_VARSIZE(result, len + VARHDRSZ);
199  memcpy(VARDATA(result), s, len);
200 
201  return result;
202 }
#define VARHDRSZ
Definition: c.h:681
void * palloc(Size size)
Definition: mcxt.c:1226
Definition: c.h:676
#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(), 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(), and xslt_process().

◆ domain_check()

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

Definition at line 343 of file domains.c.

345 {
346  DomainIOData *my_extra = NULL;
347 
348  if (mcxt == NULL)
349  mcxt = CurrentMemoryContext;
350 
351  /*
352  * We arrange to look up the needed info just once per series of calls,
353  * assuming the domain type doesn't change underneath us (which really
354  * shouldn't happen, but cope if it does).
355  */
356  if (extra)
357  my_extra = (DomainIOData *) *extra;
358  if (my_extra == NULL || my_extra->domain_type != domainType)
359  {
360  my_extra = domain_state_setup(domainType, true, mcxt);
361  if (extra)
362  *extra = (void *) my_extra;
363  }
364 
365  /*
366  * Do the necessary checks to ensure it's a valid domain value.
367  */
368  domain_check_input(value, isnull, my_extra, NULL);
369 }
static void domain_check_input(Datum value, bool isnull, DomainIOData *my_extra, Node *escontext)
Definition: domains.c:135
static DomainIOData * domain_state_setup(Oid domainType, bool binary, MemoryContext mcxt)
Definition: domains.c:73
MemoryContext CurrentMemoryContext
Definition: mcxt.c:135
Oid domain_type
Definition: domains.c:49

References CurrentMemoryContext, domain_check_input(), domain_state_setup(), DomainIOData::domain_type, 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(), PLyObject_ToDomain(), populate_composite(), populate_domain(), and populate_recordset_record().

◆ errdatatype()

int errdatatype ( Oid  datatypeOid)

Definition at line 376 of file domains.c.

377 {
378  HeapTuple tup;
379  Form_pg_type typtup;
380 
381  tup = SearchSysCache1(TYPEOID, ObjectIdGetDatum(datatypeOid));
382  if (!HeapTupleIsValid(tup))
383  elog(ERROR, "cache lookup failed for type %u", datatypeOid);
384  typtup = (Form_pg_type) GETSTRUCT(tup);
385 
387  get_namespace_name(typtup->typnamespace));
389 
390  ReleaseSysCache(tup);
391 
392  return 0; /* return value does not matter */
393 }
#define NameStr(name)
Definition: c.h:735
int err_generic_string(int field, const char *str)
Definition: elog.c:1511
#define ERROR
Definition: elog.h:39
#define HeapTupleIsValid(tuple)
Definition: htup.h:78
#define GETSTRUCT(TUP)
Definition: htup_details.h:653
char * get_namespace_name(Oid nspid)
Definition: lsyscache.c:3348
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:868
HeapTuple SearchSysCache1(int cacheId, Datum key1)
Definition: syscache.c:820
@ TYPEOID
Definition: syscache.h:114

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

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

◆ errdomainconstraint()

int errdomainconstraint ( Oid  datatypeOid,
const char *  conname 
)

Definition at line 400 of file domains.c.

401 {
402  errdatatype(datatypeOid);
404 
405  return 0; /* return value does not matter */
406 }
int errdatatype(Oid datatypeOid)
Definition: domains.c:376
#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(), 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(), 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(), 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(), 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(), NonFiniteTimestampTzPart(), op_signature_string(), ParseFuncOrColumn(), pg_collation_for(), plperl_array_to_datum(), plperl_sv_to_datum(), plperl_validator(), 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(), 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:122
#define FORMAT_TYPE_INVALID_AS_NULL
Definition: builtins.h:124
#define FORMAT_TYPE_TYPEMOD_GIVEN
Definition: builtins.h:121
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:3372
char * pstrdup(const char *in)
Definition: mcxt.c:1644
bool TypeIsVisible(Oid typid)
Definition: namespace.c:801
static char * buf
Definition: pg_test_fsync.c:67
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:12049

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(), TYPEOID, 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 12373 of file ruleutils.c.

12377 {
12378  HeapTuple opertup;
12379  Form_pg_operator operform;
12380  char *oprname;
12381  char *nspname;
12382 
12383  opertup = SearchSysCache1(OPEROID, ObjectIdGetDatum(opoid));
12384  if (!HeapTupleIsValid(opertup))
12385  elog(ERROR, "cache lookup failed for operator %u", opoid);
12386  operform = (Form_pg_operator) GETSTRUCT(opertup);
12387  Assert(operform->oprkind == 'b');
12388  oprname = NameStr(operform->oprname);
12389 
12390  nspname = get_namespace_name(operform->oprnamespace);
12391 
12392  appendStringInfoString(buf, leftop);
12393  if (leftoptype != operform->oprleft)
12394  add_cast_to(buf, operform->oprleft);
12395  appendStringInfo(buf, " OPERATOR(%s.", quote_identifier(nspname));
12396  appendStringInfoString(buf, oprname);
12397  appendStringInfo(buf, ") %s", rightop);
12398  if (rightoptype != operform->oprright)
12399  add_cast_to(buf, operform->oprright);
12400 
12401  ReleaseSysCache(opertup);
12402 }
Assert(fmt[strlen(fmt) - 1] !='\n')
FormData_pg_operator * Form_pg_operator
Definition: pg_operator.h:83
const char * quote_identifier(const char *ident)
Definition: ruleutils.c:11965
static void add_cast_to(StringInfo buf, Oid typid)
Definition: ruleutils.c:12413
void appendStringInfo(StringInfo str, const char *fmt,...)
Definition: stringinfo.c:91
void appendStringInfoString(StringInfo str, const char *s)
Definition: stringinfo.c:176
@ OPEROID
Definition: syscache.h:72

References add_cast_to(), appendStringInfo(), appendStringInfoString(), Assert(), buf, elog(), ERROR, get_namespace_name(), GETSTRUCT, HeapTupleIsValid, NameStr, ObjectIdGetDatum(), OPEROID, 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:858
int errmsg(const char *fmt,...)
Definition: elog.c:1069
#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:1024

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 }
#define NAMEDATALEN
const char * name

References name, NAMEDATALEN, NameStr, and generate_unaccent_rules::str.

Referenced by 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 4583 of file numeric.c.

4584 {
4585  Numeric num = PG_GETARG_NUMERIC(0);
4586  double val;
4587 
4588  if (NUMERIC_IS_SPECIAL(num))
4589  {
4590  if (NUMERIC_IS_PINF(num))
4591  val = HUGE_VAL;
4592  else if (NUMERIC_IS_NINF(num))
4593  val = -HUGE_VAL;
4594  else
4595  val = get_float8_nan();
4596  }
4597  else
4598  {
4599  NumericVar x;
4600 
4601  init_var_from_num(num, &x);
4603  }
4604 
4606 }
#define NUMERIC_IS_SPECIAL(n)
Definition: numeric.c:173
static void init_var_from_num(Numeric num, NumericVar *dest)
Definition: numeric.c:7381
#define NUMERIC_IS_PINF(n)
Definition: numeric.c:205
#define NUMERIC_IS_NINF(n)
Definition: numeric.c:206
static double numericvar_to_double_no_overflow(const NumericVar *var)
Definition: numeric.c:8271
static float8 get_float8_nan(void)
Definition: float.h:123
#define PG_RETURN_FLOAT8(x)
Definition: fmgr.h:367
long val
Definition: informix.c:664
int x
Definition: isn.c:71
#define PG_GETARG_NUMERIC(n)
Definition: numeric.h:77

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 257 of file oid.c.

258 {
259  Oid v1 = *((const Oid *) p1);
260  Oid v2 = *((const Oid *) p2);
261 
262  if (v1 < v2)
263  return -1;
264  if (v1 > v2)
265  return 1;
266  return 0;
267 }

References p2.

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

◆ oidparse()

Oid oidparse ( Node node)

Definition at line 234 of file oid.c.

235 {
236  switch (nodeTag(node))
237  {
238  case T_Integer:
239  return intVal(node);
240  case T_Float:
241 
242  /*
243  * Values too large for int4 will be represented as Float
244  * constants by the lexer. Accept these if they are valid OID
245  * strings.
246  */
247  return uint32in_subr(castNode(Float, node)->fval, NULL,
248  "oid", NULL);
249  default:
250  elog(ERROR, "unrecognized node type: %d", (int) nodeTag(node));
251  }
252  return InvalidOid; /* keep compiler quiet */
253 }
#define nodeTag(nodeptr)
Definition: nodes.h:133
#define castNode(_type_, nodeptr)
Definition: nodes.h:197
uint32 uint32in_subr(const char *s, char **endloc, const char *typname, Node *escontext)
Definition: numutils.c:901
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 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  switch (*value)
39  {
40  case 't':
41  case 'T':
42  if (pg_strncasecmp(value, "true", len) == 0)
43  {
44  if (result)
45  *result = true;
46  return true;
47  }
48  break;
49  case 'f':
50  case 'F':
51  if (pg_strncasecmp(value, "false", len) == 0)
52  {
53  if (result)
54  *result = false;
55  return true;
56  }
57  break;
58  case 'y':
59  case 'Y':
60  if (pg_strncasecmp(value, "yes", len) == 0)
61  {
62  if (result)
63  *result = true;
64  return true;
65  }
66  break;
67  case 'n':
68  case 'N':
69  if (pg_strncasecmp(value, "no", len) == 0)
70  {
71  if (result)
72  *result = false;
73  return true;
74  }
75  break;
76  case 'o':
77  case 'O':
78  /* 'o' is not unique enough */
79  if (pg_strncasecmp(value, "on", (len > 2 ? len : 2)) == 0)
80  {
81  if (result)
82  *result = true;
83  return true;
84  }
85  else if (pg_strncasecmp(value, "off", (len > 2 ? len : 2)) == 0)
86  {
87  if (result)
88  *result = false;
89  return true;
90  }
91  break;
92  case '1':
93  if (len == 1)
94  {
95  if (result)
96  *result = true;
97  return true;
98  }
99  break;
100  case '0':
101  if (len == 1)
102  {
103  if (result)
104  *result = false;
105  return true;
106  }
107  break;
108  default:
109  break;
110  }
111 
112  if (result)
113  *result = false; /* suppress compiler warning */
114  return false;
115 }
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)
#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, and PGSQL_AF_INET6.

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

Referenced by network_in().

◆ pg_itoa()

int pg_itoa ( int16  i,
char *  a 
)

Definition at line 1045 of file numutils.c.

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

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

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

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

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

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

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

◆ pg_strtoint16()

int16 pg_strtoint16 ( const char *  s)

Definition at line 122 of file numutils.c.

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

References pg_strtoint16_safe().

◆ pg_strtoint16_safe()

int16 pg_strtoint16_safe ( const char *  s,
Node escontext 
)

Definition at line 128 of file numutils.c.

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

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

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

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

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

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

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

References pg_strtoint64_safe().

◆ pg_strtoint64_safe()

int64 pg_strtoint64_safe ( const char *  s,
Node escontext 
)

Definition at line 652 of file numutils.c.

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

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

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

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

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

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

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

Referenced by AppendSeconds().

◆ pg_ultostr_zeropad()

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

Definition at line 1270 of file numutils.c.

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

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

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

◆ quote_identifier()

const char* quote_identifier ( const char *  ident)

Definition at line 11965 of file ruleutils.c.

11966 {
11967  /*
11968  * Can avoid quoting if ident starts with a lowercase letter or underscore
11969  * and contains only lowercase letters, digits, and underscores, *and* is
11970  * not any SQL keyword. Otherwise, supply quotes.
11971  */
11972  int nquotes = 0;
11973  bool safe;
11974  const char *ptr;
11975  char *result;
11976  char *optr;
11977 
11978  /*
11979  * would like to use <ctype.h> macros here, but they might yield unwanted
11980  * locale-specific results...
11981  */
11982  safe = ((ident[0] >= 'a' && ident[0] <= 'z') || ident[0] == '_');
11983 
11984  for (ptr = ident; *ptr; ptr++)
11985  {
11986  char ch = *ptr;
11987 
11988  if ((ch >= 'a' && ch <= 'z') ||
11989  (ch >= '0' && ch <= '9') ||
11990  (ch == '_'))
11991  {
11992  /* okay */
11993  }
11994  else
11995  {
11996  safe = false;
11997  if (ch == '"')
11998  nquotes++;
11999  }
12000  }
12001 
12003  safe = false;
12004 
12005  if (safe)
12006  {
12007  /*
12008  * Check for keyword. We quote keywords except for unreserved ones.
12009  * (In some cases we could avoid quoting a col_name or type_func_name
12010  * keyword, but it seems much harder than it's worth to tell that.)
12011  *
12012  * Note: ScanKeywordLookup() does case-insensitive comparison, but
12013  * that's fine, since we already know we have all-lower-case.
12014  */
12015  int kwnum = ScanKeywordLookup(ident, &ScanKeywords);
12016 
12017  if (kwnum >= 0 && ScanKeywordCategories[kwnum] != UNRESERVED_KEYWORD)
12018  safe = false;
12019  }
12020 
12021  if (safe)
12022  return ident; /* no change needed */
12023 
12024  result = (char *) palloc(strlen(ident) + nquotes + 2 + 1);
12025 
12026  optr = result;
12027  *optr++ = '"';
12028  for (ptr = ident; *ptr; ptr++)
12029  {
12030  char ch = *ptr;
12031 
12032  if (ch == '"')
12033  *optr++ = '"';
12034  *optr++ = ch;
12035  }
12036  *optr++ = '"';
12037  *optr = '\0';
12038 
12039  return result;
12040 }
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:324

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_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_tablefunc(), get_target_list(), get_update_query_targetlist_def(), get_utility_query_def(), get_variable(), get_windowfunc_expr_helper(), get_with_clause(), getObjectIdentityParts(), 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(), and text_format_string_conversion().

◆ quote_qualified_identifier()

◆ regexp_fixed_prefix()

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

Definition at line 1954 of file regexp.c.

1956 {
1957  char *result;
1958  regex_t *re;
1959  int cflags;
1960  int re_result;
1961  pg_wchar *str;
1962  size_t slen;
1963  size_t maxlen;
1964  char errMsg[100];
1965 
1966  *exact = false; /* default result */
1967 
1968  /* Compile RE */
1969  cflags = REG_ADVANCED;
1970  if (case_insensitive)
1971  cflags |= REG_ICASE;
1972 
1973  re = RE_compile_and_cache(text_re, cflags | REG_NOSUB, collation);
1974 
1975  /* Examine it to see if there's a fixed prefix */
1976  re_result = pg_regprefix(re, &str, &slen);
1977 
1978  switch (re_result)
1979  {
1980  case REG_NOMATCH:
1981  return NULL;
1982 
1983  case REG_PREFIX:
1984  /* continue with wchar conversion */
1985  break;
1986 
1987  case REG_EXACT:
1988  *exact = true;
1989  /* continue with wchar conversion */
1990  break;
1991 
1992  default:
1993  /* re failed??? */
1994  pg_regerror(re_result, re, errMsg, sizeof(errMsg));
1995  ereport(ERROR,
1996  (errcode(ERRCODE_INVALID_REGULAR_EXPRESSION),
1997  errmsg("regular expression failed: %s", errMsg)));
1998  break;
1999  }
2000 
2001  /* Convert pg_wchar result back to database encoding */
2002  maxlen = pg_database_encoding_max_length() * slen + 1;
2003  result = (char *) palloc(maxlen);
2004  slen = pg_wchar2mb_with_len(str, result, slen);
2005  Assert(slen < maxlen);
2006 
2007  pfree(str);
2008 
2009  return result;
2010 }
#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:1009
int pg_database_encoding_max_length(void)
Definition: mbutils.c:1553
void pfree(void *pointer)
Definition: mcxt.c:1456
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:142
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 generate_unaccent_rules::str.

Referenced by regex_fixed_prefix().

◆ text_to_cstring()

char* text_to_cstring ( const text t)

Definition at line 215 of file varlena.c.

216 {
217  /* must cast away the const, unfortunately */
218  text *tunpacked = pg_detoast_datum_packed(unconstify(text *, t));
219  int len = VARSIZE_ANY_EXHDR(tunpacked);
220  char *result;
221 
222  result = (char *) palloc(len + 1);
223  memcpy(result, VARDATA_ANY(tunpacked), len);
224  result[len] = '\0';
225 
226  if (tunpacked != t)
227  pfree(tunpacked);
228 
229  return result;
230 }
#define unconstify(underlying_type, expr)
Definition: c.h:1255
struct varlena * pg_detoast_datum_packed(struct varlena *datum)
Definition: fmgr.c:1847
#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_create_empty_extension(), 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(), datum_to_json_internal(), 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(), json_object_field(), json_object_field_text(), jsonb_set_lax(), 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_timestamp(), 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 246 of file varlena.c.

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

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:943
int GetDatabaseEncoding(void)
Definition: mbutils.c:1268
#define BITS_PER_BYTE
int pg_encoding_max_length(int encoding)
Definition: wchar.c:2188

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

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

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

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

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

Referenced by xid8in().

◆ xidComparator()

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

Definition at line 138 of file xid.c.

139 {
140  TransactionId xid1 = *(const TransactionId *) arg1;
141  TransactionId xid2 = *(const TransactionId *) arg2;
142 
143  if (xid1 > xid2)
144  return 1;
145  if (xid1 < xid2)
146  return -1;
147  return 0;
148 }
uint32 TransactionId
Definition: c.h:641

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

◆ xidLogicalComparator()

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

Definition at line 159 of file xid.c.

160 {
161  TransactionId xid1 = *(const TransactionId *) arg1;
162  TransactionId xid2 = *(const TransactionId *) arg2;
163 
166 
167  if (TransactionIdPrecedes(xid1, xid2))
168  return -1;
169 
170  if (TransactionIdPrecedes(xid2, xid1))
171  return 1;
172 
173  return 0;
174 }
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 324 of file ruleutils.c.

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