yb_ddl_parser 0.1.0

data/ext/yb_ddl_parser/vendor/yugabyte-postgres/src/include/executor/ybExpr.h

@@ -0,0 +1,64 @@
+/*--------------------------------------------------------------------------------------------------
+ * ybExpr.h
+ *	  prototypes for ybExpr.c
+ *
+ * Copyright (c) YugabyteDB, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
+ * in compliance with the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
+ * or implied.  See the License for the specific language governing permissions and limitations
+ * under the License.
+ *
+ * src/include/executor/ybExpr.h
+ *
+ * NOTES:
+ *   - For performance reasons, some expressions must be sent to YugaByte for execution.
+ *   - This module constructs expression tree to be sent to YBC API.
+ *   - In the future, we can move a portion of Postgres datum and engine to /yb/common such that
+ *     DocDB can execute Postgres expression without constructing YBC tree.  That involves a lot
+ *     more work, so we limit this work to construct a few simple expressions.
+ *--------------------------------------------------------------------------------------------------
+ */
+
+#pragma once
+
+#include "postgres.h"
+
+#include "nodes/execnodes.h"
+#include "yb/yql/pggate/ybc_pg_typedefs.h"
+#include "yb/yql/pggate/ybc_pggate.h"
+
+/*  Construct column reference expression. */
+extern YbcPgExpr YBCNewColumnRef(YbcPgStatement ybc_stmt, int16_t attr_num,
+								 int attr_typid, int attr_collation,
+								 const YbcPgTypeAttrs *type_attrs);
+
+/*  Construct constant expression using the given datatype "type_id" and value "datum". */
+extern YbcPgExpr YBCNewConstant(YbcPgStatement ybc_stmt, Oid type_id,
+								Oid collation_id, Datum datum, bool is_null);
+
+/*  Construct virtual constant expression using the given datatype "type_id" and virtual "datum". */
+extern YbcPgExpr YBCNewConstantVirtual(YbcPgStatement ybc_stmt, Oid type_id,
+									   YbcPgDatumKind kind);
+extern YbcPgExpr YBCNewTupleExpr(YbcPgStatement ybc_stmt, const YbcPgTypeAttrs *type_attrs,
+								 int num_elems, YbcPgExpr *elems);
+
+extern Expr *YbExprInstantiateExprs(Expr *expr, EState *estate);
+extern YbPushdownExprs *YbInstantiatePushdownExprs(YbPushdownExprs *pushdown,
+												   EState *estate);
+
+extern bool YbCanPushdownExpr(Expr *pg_expr, List **params, Oid relid);
+
+extern bool YbIsTransactionalExpr(Node *pg_expr);
+
+YbcPgExpr	YBCNewEvalExprCall(YbcPgStatement ybc_stmt, Expr *pg_expr);
+
+extern YbPgExecOutParam *YbCreateExecOutParam();
+
+extern void YbWriteExecOutParam(YbPgExecOutParam *out_param,
+								const YbcPgExecOutParamValue *value);

data/ext/yb_ddl_parser/vendor/yugabyte-postgres/src/include/executor/ybFunction.h

@@ -0,0 +1,41 @@
+/*--------------------------------------------------------------------------------------------------
+ * ybFunction.h
+ *	  prototypes for ybFunction.c
+ *
+ * Copyright (c) YugabyteDB, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
+ * in compliance with the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
+ * or implied.  See the License for the specific language governing permissions and limitations
+ * under the License.
+ *
+ * src/include/executor/ybFunction.h
+ *
+ */
+
+#pragma once
+
+#include "postgres.h"
+
+#include "funcapi.h"
+#include "yb/yql/pggate/ybc_pg_typedefs.h"
+#include "yb/yql/pggate/ybc_pggate.h"
+
+typedef struct YbPgFuncCallContextData
+{
+	YbcPgFunction handle;
+	MemoryContext per_call_ctx;
+} YbPgFuncCallContextData;
+
+typedef struct YbPgFuncCallContextData *YbFuncCallContext;
+extern YbFuncCallContext YbNewFuncCallContext(FuncCallContext *funcCallContext);
+extern void YbSetFunctionParam(YbcPgFunction handle, const char *name,
+							   int attr_typid, uint64_t datum, bool is_null);
+extern void YbSetSRFTargets(YbFuncCallContext context, TupleDesc desc);
+extern bool YbSRFGetNext(YbFuncCallContext context, uint64_t *values,
+						 bool *is_nulls);

data/ext/yb_ddl_parser/vendor/yugabyte-postgres/src/include/executor/ybModifyTable.h

@@ -0,0 +1,281 @@
+/*--------------------------------------------------------------------------------------------------
+ *
+ * ybModifyTable.h
+ *	  prototypes for ybModifyTable.c
+ *
+ * Copyright (c) YugabyteDB, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
+ * in compliance with the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
+ * or implied.  See the License for the specific language governing permissions and limitations
+ * under the License.
+ *
+ * src/include/executor/ybModifyTable.h
+ *
+ *--------------------------------------------------------------------------------------------------
+ */
+
+#pragma once
+
+#include "executor/tuptable.h"
+#include "nodes/execnodes.h"
+
+/**
+ * YSQL guc variables that can be used to enable non transactional writes.
+ * e.g. 'SET yb_disable_transactional_writes=true'
+ * See also the corresponding entries in guc.c.
+ */
+extern bool yb_disable_transactional_writes;
+
+/**
+ * YSQL guc variables that can be used to enable/disable fast-path transaction
+ * on colocated tables for copy.
+ * e.g. 'SET yb_fast_path_for_colocated_copy=true'
+ * See also the corresponding entries in guc.c.
+ */
+extern bool yb_fast_path_for_colocated_copy;
+
+/**
+ * YSQL guc variables that can be used to enable upsert mode for writes.
+ * e.g. 'SET yb_enable_upsert_mode=true'
+ * See also the corresponding entries in guc.c.
+ */
+extern bool yb_enable_upsert_mode;
+
+/* ------------------------------------------------------------------------------ */
+/* YugaByte modify table API. */
+
+typedef void (*yb_bind_for_write_function) (YbcPgStatement stmt,
+											void *indexstate,
+											Relation index,
+											Datum *values,
+											bool *isnull,
+											int natts,
+											Datum ybbasectid,
+											bool ybctid_as_value);
+
+typedef void (*yb_assign_for_write_function) (YbcPgStatement stmt,
+											  Relation index,
+											  Datum *values,
+											  bool *isnull,
+											  int natts,
+											  Datum old_ybbasectid,
+											  Datum new_ybbasectid);
+
+/*
+ * Insert data into YugaByte table.
+ * This function is equivalent to "heap_insert", but it sends data to DocDB (YugaByte storage).
+ *
+ * ybctid argument can be supplied to keep it consistent across shared inserts.
+ * If non-zero, it will be used instead of generation, otherwise it will be set
+ * to the generated value.
+ */
+extern void YBCHeapInsert(ResultRelInfo *resultRelInfo,
+						  TupleTableSlot *slot,
+						  YbcPgStatement blockInsertStmt,
+						  EState *estate);
+
+/*
+ * Whether INSERT ON CONFLICT read batching is possible for the given
+ * resultRelInfo.  Should be called only when the inspected fields of
+ * resultRelInfo are populated.
+ */
+extern bool YbIsInsertOnConflictReadBatchingPossible(ResultRelInfo *resultRelInfo);
+
+/*
+ * Insert a tuple into a YugaByte table. Will execute within a distributed
+ * transaction if the table is transactional (YSQL default).
+ *
+ * ybctid argument can be supplied to keep it consistent across shared inserts.
+ * If non-zero, it will be used instead of generation, otherwise it will be set
+ * to the generated value.
+ */
+extern void YBCExecuteInsert(Relation rel,
+							 TupleTableSlot *slot,
+							 OnConflictAction onConflictAction);
+
+/* HeapTuple based wrapper on YBCExecuteInsertForDb. */
+extern void YBCExecuteInsertHeapTupleForDb(Oid dboid,
+										   Relation rel,
+										   HeapTuple tuple,
+										   OnConflictAction onConflictAction,
+										   Datum *ybctid,
+										   YbcPgTransactionSetting transaction_setting);
+
+extern void YBCExecuteInsertForDb(Oid dboid,
+								  Relation rel,
+								  TupleTableSlot *slot,
+								  OnConflictAction onConflictAction,
+								  Datum *ybctid,
+								  YbcPgTransactionSetting transaction_setting);
+
+extern void YBCApplyWriteStmt(YbcPgStatement handle, Relation relation);
+
+/*
+ * Execute the insert outside of a transaction.
+ * Assumes the caller checked that it is safe to do so.
+ *
+ * ybctid argument can be supplied to keep it consistent across shared inserts.
+ * If non-zero, it will be used instead of generation, otherwise it will be set
+ * to the generated value.
+ */
+extern void YBCExecuteNonTxnInsert(Relation rel,
+								   TupleTableSlot *slot,
+								   OnConflictAction onConflictAction);
+extern void YBCExecuteNonTxnInsertForDb(Oid dboid,
+										Relation rel,
+										TupleTableSlot *slot,
+										OnConflictAction onConflictAction,
+										Datum *ybctid);
+
+/*
+ * Insert a tuple into the an index's backing YugaByte index table.
+ */
+extern void YBCExecuteInsertIndex(Relation rel,
+								  Datum *values,
+								  bool *isnull,
+								  Datum ybctid,
+								  const uint64_t *backfill_write_time,
+								  yb_bind_for_write_function callback,
+								  void *indexstate);
+extern void YBCExecuteInsertIndexForDb(Oid dboid,
+									   Relation rel,
+									   Datum *values,
+									   bool *isnull,
+									   Datum ybctid,
+									   const uint64_t *backfill_write_time,
+									   yb_bind_for_write_function callback,
+									   void *indexstate);
+
+/*
+ * Delete a tuple (identified by ybctid) from a YugaByte table.
+ * If this is a single row op we will return false in the case that there was
+ * no row to delete. This can occur because we do not first perform a scan if
+ * it is a single row op. 'changingPart' indicates if this delete is part of an
+ * UPDATE operation on a partitioned table that moves a row from one partition
+ * to anoter.
+ */
+extern bool YBCExecuteDelete(Relation rel,
+							 TupleTableSlot *planSlot,
+							 List *returning_columns,
+							 bool target_tuple_fetched,
+							 YbcPgTransactionSetting transaction_setting,
+							 bool changingPart,
+							 EState *estate);
+
+/*
+ * Delete a tuple (identified by index columns and base table ybctid) from an
+ * index's backing YugaByte index table.
+ */
+extern void YBCExecuteDeleteIndex(Relation index,
+								  Datum *values,
+								  bool *isnull,
+								  Datum ybctid,
+								  yb_bind_for_write_function callback,
+								  void *indexstate);
+
+extern void YBCExecuteUpdateIndex(Relation index,
+								  Datum *values,
+								  bool *isnull,
+								  Datum oldYbctid,
+								  Datum newYbctid,
+								  yb_assign_for_write_function callback);
+
+/*
+ * Update a row (identified by ybctid) in a YugaByte table.
+ * If this is a single row op we will return false in the case that there was
+ * no row to update. This can occur because we do not first perform a scan if
+ * it is a single row op.
+ */
+extern bool YBCExecuteUpdate(ResultRelInfo *resultRelInfo,
+							 TupleTableSlot *planSlot,
+							 TupleTableSlot *slot,
+							 HeapTuple oldtuple,
+							 EState *estate,
+							 ModifyTable *mt_plan,
+							 bool target_tuple_fetched,
+							 YbcPgTransactionSetting transaction_setting,
+							 Bitmapset *updatedCols,
+							 bool canSetTag);
+
+/*
+ * Update a row (identified by the roleid) in a pg_yb_role_profile. This is a
+ * stripped down and specific version of YBCExecuteUpdate. It is used by
+ * auth.c, since the typical method of writing does not work at that stage of
+ * the DB initialization.
+ *
+ * Returns true if a row was updated.
+ */
+extern bool YBCExecuteUpdateLoginAttempts(Oid roleid,
+										  int failed_attempts,
+										  char rolprfstatus);
+
+/*
+ * Replace a row in a YugaByte table by first deleting an existing row
+ * (identified by ybctid) and then inserting a tuple to replace it.
+ * This allows us to update a row primary key.
+ *
+ * This will change ybctid of a row within a tuple.
+ */
+extern void YBCExecuteUpdateReplace(Relation rel,
+									TupleTableSlot *planSlot,
+									TupleTableSlot *slot,
+									EState *estate);
+
+/* ------------------------------------------------------------------------------ */
+/*
+ * System tables modify-table API.
+ * For system tables we identify rows to update/delete directly by primary key
+ * and execute them directly (rather than needing to read ybctid first).
+ * TODO This should be used for regular tables whenever possible.
+ */
+
+extern void YBCDeleteSysCatalogTuple(Relation rel, HeapTuple tuple);
+
+extern void YBCUpdateSysCatalogTuple(Relation rel,
+									 HeapTuple oldtuple,
+									 HeapTuple tuple);
+extern void YBCUpdateSysCatalogTupleForDb(Oid dboid,
+										  Relation rel,
+										  HeapTuple oldtuple,
+										  HeapTuple tuple);
+
+/* ------------------------------------------------------------------------------ */
+/* Utility methods. */
+
+extern bool YBCIsSingleRowTxnCapableRel(ResultRelInfo *resultRelInfo);
+
+/*
+ * Checks if the given statement is planned to be executed as a single-row
+ * modify transaction.
+ */
+extern bool YbIsSingleRowModifyTxnPlanned(PlannedStmt *pstmt, EState *estate);
+
+extern Datum YBCGetYBTupleIdFromSlot(TupleTableSlot *slot);
+
+extern Datum YBCComputeYBTupleIdFromSlot(Relation rel, TupleTableSlot *slot);
+
+extern YbcPgYBTupleIdDescriptor *YBCBuildUniqueIndexYBTupleId(Relation unique_index,
+															  Datum *values,
+															  bool *nulls);
+
+/*
+ * Returns if a table has secondary indices.
+ */
+extern bool YBCRelInfoHasSecondaryIndices(ResultRelInfo *resultRelInfo);
+
+/*
+ * Returns the number of seconday indices excluding primary indexes.
+ */
+extern int	YBCRelInfoGetSecondaryIndicesCount(ResultRelInfo *resultRelInfo);
+
+/*
+ * Returns whether the current slot satisfies the partial index's predicate.
+ */
+extern bool YbIsPartialIndexPredicateSatisfied(IndexInfo *indexInfo,
+											   EState *estate);

data/ext/yb_ddl_parser/vendor/yugabyte-postgres/src/include/executor/ybOptimizeModifyTable.h

@@ -0,0 +1,40 @@
+/*-------------------------------------------------------------------------
+ *
+ * ybOptimizeModifyTable.h
+ *
+ * Copyright (c) YugabyteDB, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ *use this file except in compliance with the License.  You may obtain a copy of
+ *the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ *distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ *WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
+ *License for the specific language governing permissions and limitations under
+ *the License.
+ *
+ * Portions Copyright (c) 1996-2018, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/executor/ybOptimizeModifyTable.h
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#pragma once
+
+#include "nodes/execnodes.h"
+#include "nodes/plannodes.h"
+
+extern void YbComputeModifiedColumnsAndSkippableEntities(ModifyTableState *mtstate,
+														 ResultRelInfo *resultRelInfo,
+														 EState *estate,
+														 HeapTuple oldtuple,
+														 TupleTableSlot *newtupleslot,
+														 Bitmapset **updatedCols,
+														 bool beforeRowUpdateTriggerFired);
+
+extern bool YbIsPrimaryKeyUpdated(Relation rel, const Bitmapset *updated_cols);

data/ext/yb_ddl_parser/vendor/yugabyte-postgres/src/include/fe_utils/archive.h

@@ -0,0 +1,21 @@
+/*-------------------------------------------------------------------------
+ *
+ * archive.h
+ *	  Routines to access WAL archives from frontend
+ *
+ * Portions Copyright (c) 1996-2022, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/fe_utils/archive.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef FE_ARCHIVE_H
+#define FE_ARCHIVE_H
+
+extern int	RestoreArchivedFile(const char *path,
+								const char *xlogfname,
+								off_t expectedSize,
+								const char *restoreCommand);
+
+#endif							/* FE_ARCHIVE_H */

data/ext/yb_ddl_parser/vendor/yugabyte-postgres/src/include/fe_utils/cancel.h

@@ -0,0 +1,32 @@
+/*-------------------------------------------------------------------------
+ *
+ * Query cancellation support for frontend code
+ *
+ *
+ * Portions Copyright (c) 1996-2022, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/fe_utils/cancel.h
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#ifndef CANCEL_H
+#define CANCEL_H
+
+#include <signal.h>
+
+#include "libpq-fe.h"
+
+extern PGDLLIMPORT volatile sig_atomic_t CancelRequested;
+
+extern void SetCancelConn(PGconn *conn);
+extern void ResetCancelConn(void);
+
+/*
+ * A callback can be optionally set up to be called at cancellation
+ * time.
+ */
+extern void setup_cancel_handler(void (*cancel_callback) (void));
+
+#endif							/* CANCEL_H */

data/ext/yb_ddl_parser/vendor/yugabyte-postgres/src/include/fe_utils/conditional.h

@@ -0,0 +1,102 @@
+/*-------------------------------------------------------------------------
+ * A stack of automaton states to handle nested conditionals.
+ *
+ * This file describes a stack of automaton states which
+ * allow a manage nested conditionals.
+ *
+ * It is used by:
+ * - "psql" interpreter for handling \if ... \endif
+ * - "pgbench" interpreter for handling \if ... \endif
+ * - "pgbench" syntax checker to test for proper nesting
+ *
+ * The stack holds the state of enclosing conditionals (are we in
+ * a true branch? in a false branch? have we already encountered
+ * a true branch?) so that the interpreter knows whether to execute
+ * code and whether to evaluate conditions.
+ *
+ * Copyright (c) 2000-2022, PostgreSQL Global Development Group
+ *
+ * src/include/fe_utils/conditional.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef CONDITIONAL_H
+#define CONDITIONAL_H
+
+/*
+ * Possible states of a single level of \if block.
+ */
+typedef enum ifState
+{
+	IFSTATE_NONE = 0,			/* not currently in an \if block */
+	IFSTATE_TRUE,				/* currently in an \if or \elif that is true
+								 * and all parent branches (if any) are true */
+	IFSTATE_FALSE,				/* currently in an \if or \elif that is false
+								 * but no true branch has yet been seen, and
+								 * all parent branches (if any) are true */
+	IFSTATE_IGNORED,			/* currently in an \elif that follows a true
+								 * branch, or the whole \if is a child of a
+								 * false parent branch */
+	IFSTATE_ELSE_TRUE,			/* currently in an \else that is true and all
+								 * parent branches (if any) are true */
+	IFSTATE_ELSE_FALSE			/* currently in an \else that is false or
+								 * ignored */
+} ifState;
+
+/*
+ * The state of nested \ifs is stored in a stack.
+ *
+ * query_len is used to determine what accumulated text to throw away at the
+ * end of an inactive branch.  (We could, perhaps, teach the lexer to not add
+ * stuff to the query buffer in the first place when inside an inactive branch;
+ * but that would be very invasive.)  We also need to save and restore the
+ * lexer's parenthesis nesting depth when throwing away text.  (We don't need
+ * to save and restore any of its other state, such as comment nesting depth,
+ * because a backslash command could never appear inside a comment or SQL
+ * literal.)
+ */
+typedef struct IfStackElem
+{
+	ifState		if_state;		/* current state, see enum above */
+	int			query_len;		/* length of query_buf at last branch start */
+	int			paren_depth;	/* parenthesis depth at last branch start */
+	struct IfStackElem *next;	/* next surrounding \if, if any */
+} IfStackElem;
+
+typedef struct ConditionalStackData
+{
+	IfStackElem *head;
+}			ConditionalStackData;
+
+typedef struct ConditionalStackData *ConditionalStack;
+
+
+extern ConditionalStack conditional_stack_create(void);
+
+extern void conditional_stack_reset(ConditionalStack cstack);
+
+extern void conditional_stack_destroy(ConditionalStack cstack);
+
+extern int	conditional_stack_depth(ConditionalStack cstack);
+
+extern void conditional_stack_push(ConditionalStack cstack, ifState new_state);
+
+extern bool conditional_stack_pop(ConditionalStack cstack);
+
+extern ifState conditional_stack_peek(ConditionalStack cstack);
+
+extern bool conditional_stack_poke(ConditionalStack cstack, ifState new_state);
+
+extern bool conditional_stack_empty(ConditionalStack cstack);
+
+extern bool conditional_active(ConditionalStack cstack);
+
+extern void conditional_stack_set_query_len(ConditionalStack cstack, int len);
+
+extern int	conditional_stack_get_query_len(ConditionalStack cstack);
+
+extern void conditional_stack_set_paren_depth(ConditionalStack cstack, int depth);
+
+extern int	conditional_stack_get_paren_depth(ConditionalStack cstack);
+
+#endif							/* CONDITIONAL_H */

data/ext/yb_ddl_parser/vendor/yugabyte-postgres/src/include/fe_utils/connect_utils.h

@@ -0,0 +1,48 @@
+/*-------------------------------------------------------------------------
+ *
+ * Facilities for frontend code to connect to and disconnect from databases.
+ *
+ * Portions Copyright (c) 1996-2022, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/fe_utils/connect_utils.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef CONNECT_UTILS_H
+#define CONNECT_UTILS_H
+
+#include "libpq-fe.h"
+
+enum trivalue
+{
+	TRI_DEFAULT,
+	TRI_NO,
+	TRI_YES
+};
+
+/* Parameters needed by connectDatabase/connectMaintenanceDatabase */
+typedef struct _connParams
+{
+	/* These fields record the actual command line parameters */
+	const char *dbname;			/* this may be a connstring! */
+	const char *pghost;
+	const char *pgport;
+	const char *pguser;
+	enum trivalue prompt_password;
+	/* If not NULL, this overrides the dbname obtained from command line */
+	/* (but *only* the DB name, not anything else in the connstring) */
+	const char *override_dbname;
+} ConnParams;
+
+extern PGconn *connectDatabase(const ConnParams *cparams,
+							   const char *progname,
+							   bool echo, bool fail_ok,
+							   bool allow_password_reuse);
+
+extern PGconn *connectMaintenanceDatabase(ConnParams *cparams,
+										  const char *progname, bool echo);
+
+extern void disconnectDatabase(PGconn *conn);
+
+#endif							/* CONNECT_UTILS_H */

data/ext/yb_ddl_parser/vendor/yugabyte-postgres/src/include/fe_utils/mbprint.h

@@ -0,0 +1,29 @@
+/*-------------------------------------------------------------------------
+ *
+ * Multibyte character printing support for frontend code
+ *
+ *
+ * Portions Copyright (c) 1996-2022, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/fe_utils/mbprint.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef MBPRINT_H
+#define MBPRINT_H
+
+struct lineptr
+{
+	unsigned char *ptr;
+	int			width;
+};
+
+extern unsigned char *mbvalidate(unsigned char *pwcs, int encoding);
+extern int	pg_wcswidth(const char *pwcs, size_t len, int encoding);
+extern void pg_wcsformat(const unsigned char *pwcs, size_t len, int encoding,
+						 struct lineptr *lines, int count);
+extern void pg_wcssize(const unsigned char *pwcs, size_t len, int encoding,
+					   int *width, int *height, int *format_size);
+
+#endif							/* MBPRINT_H */

data/ext/yb_ddl_parser/vendor/yugabyte-postgres/src/include/fe_utils/option_utils.h

@@ -0,0 +1,26 @@
+/*-------------------------------------------------------------------------
+ *
+ * Command line option processing facilities for frontend code
+ *
+ * Portions Copyright (c) 1996-2022, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/fe_utils/option_utils.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef OPTION_UTILS_H
+#define OPTION_UTILS_H
+
+#include "postgres_fe.h"
+
+typedef void (*help_handler) (const char *progname);
+
+extern void handle_help_version_opts(int argc, char *argv[],
+									 const char *fixed_progname,
+									 help_handler hlp);
+extern bool option_parse_int(const char *optarg, const char *optname,
+							 int min_range, int max_range,
+							 int *result);
+
+#endif							/* OPTION_UTILS_H */