yb_ddl_parser 0.1.0

data/ext/yb_ddl_parser/vendor/yugabyte-postgres/src/include/commands/cluster.h

@@ -0,0 +1,55 @@
+/*-------------------------------------------------------------------------
+ *
+ * cluster.h
+ *	  header file for postgres cluster command stuff
+ *
+ * Portions Copyright (c) 1996-2022, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994-5, Regents of the University of California
+ *
+ * src/include/commands/cluster.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef CLUSTER_H
+#define CLUSTER_H
+
+#include "nodes/parsenodes.h"
+#include "parser/parse_node.h"
+#include "storage/lock.h"
+#include "utils/relcache.h"
+
+
+/* flag bits for ClusterParams->options */
+#define CLUOPT_VERBOSE 0x01		/* print progress info */
+#define CLUOPT_RECHECK 0x02		/* recheck relation state */
+#define CLUOPT_RECHECK_ISCLUSTERED 0x04 /* recheck relation state for
+										 * indisclustered */
+
+/* options for CLUSTER */
+typedef struct ClusterParams
+{
+	bits32		options;		/* bitmask of CLUOPT_* */
+} ClusterParams;
+
+extern void cluster(ParseState *pstate, ClusterStmt *stmt, bool isTopLevel);
+extern void cluster_rel(Oid tableOid, Oid indexOid, ClusterParams *params);
+extern void check_index_is_clusterable(Relation OldHeap, Oid indexOid,
+									   LOCKMODE lockmode);
+extern void mark_index_clustered(Relation rel, Oid indexOid, bool is_internal);
+
+extern Oid	make_new_heap(Oid OIDOldHeap, Oid NewTableSpace, Oid NewAccessMethod,
+						  char relpersistence, LOCKMODE lockmode,
+						  bool yb_copy_split_options);
+extern void finish_heap_swap(Oid OIDOldHeap, Oid OIDNewHeap,
+							 bool is_system_catalog,
+							 bool swap_toast_by_content,
+							 bool check_constraints,
+							 bool is_internal,
+							 TransactionId frozenXid,
+							 MultiXactId minMulti,
+							 char newrelpersistence,
+							 bool yb_copy_split_options,
+							 List *changedIndexNames,
+							 List *changedIndexSplitOpts);
+
+#endif							/* CLUSTER_H */

data/ext/yb_ddl_parser/vendor/yugabyte-postgres/src/include/commands/collationcmds.h

@@ -0,0 +1,25 @@
+/*-------------------------------------------------------------------------
+ *
+ * collationcmds.h
+ *	  prototypes for collationcmds.c.
+ *
+ *
+ * Portions Copyright (c) 1996-2022, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/commands/collationcmds.h
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#ifndef COLLATIONCMDS_H
+#define COLLATIONCMDS_H
+
+#include "catalog/objectaddress.h"
+#include "parser/parse_node.h"
+
+extern ObjectAddress DefineCollation(ParseState *pstate, List *names, List *parameters, bool if_not_exists);
+extern void IsThereCollationInNamespace(const char *collname, Oid nspOid);
+extern ObjectAddress AlterCollation(AlterCollationStmt *stmt);
+
+#endif							/* COLLATIONCMDS_H */

data/ext/yb_ddl_parser/vendor/yugabyte-postgres/src/include/commands/comment.h

@@ -0,0 +1,45 @@
+/*
+ * src/include/commands/comment.h
+ *
+ *-------------------------------------------------------------------------
+ *
+ * comment.h
+ *
+ * Prototypes for functions in commands/comment.c
+ *
+ * Copyright (c) 1999-2022, PostgreSQL Global Development Group
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#ifndef COMMENT_H
+#define COMMENT_H
+
+#include "catalog/objectaddress.h"
+#include "nodes/parsenodes.h"
+
+/*------------------------------------------------------------------
+ * Function Prototypes --
+ *
+ * The following prototypes define the public functions of the comment
+ * related routines.  CommentObject() implements the SQL "COMMENT ON"
+ * command.  DeleteComments() deletes all comments for an object.
+ * CreateComments creates (or deletes, if comment is NULL) a comment
+ * for a specific key.  There are versions of these two methods for
+ * both normal and shared objects.
+ *------------------------------------------------------------------
+ */
+
+extern ObjectAddress CommentObject(CommentStmt *stmt);
+
+extern void DeleteComments(Oid oid, Oid classoid, int32 subid);
+
+extern void CreateComments(Oid oid, Oid classoid, int32 subid, const char *comment);
+
+extern void DeleteSharedComments(Oid oid, Oid classoid);
+
+extern void CreateSharedComments(Oid oid, Oid classoid, const char *comment);
+
+extern char *GetComment(Oid oid, Oid classoid, int32 subid);
+
+#endif							/* COMMENT_H */

data/ext/yb_ddl_parser/vendor/yugabyte-postgres/src/include/commands/conversioncmds.h

@@ -0,0 +1,23 @@
+/*-------------------------------------------------------------------------
+ *
+ * conversioncmds.h
+ *	  prototypes for conversioncmds.c.
+ *
+ *
+ * Portions Copyright (c) 1996-2022, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/commands/conversioncmds.h
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#ifndef CONVERSIONCMDS_H
+#define CONVERSIONCMDS_H
+
+#include "catalog/objectaddress.h"
+#include "nodes/parsenodes.h"
+
+extern ObjectAddress CreateConversionCommand(CreateConversionStmt *parsetree);
+
+#endif							/* CONVERSIONCMDS_H */

data/ext/yb_ddl_parser/vendor/yugabyte-postgres/src/include/commands/copy.h

@@ -0,0 +1,120 @@
+/*-------------------------------------------------------------------------
+ *
+ * copy.h
+ *	  Definitions for using the POSTGRES copy command.
+ *
+ *
+ * Portions Copyright (c) 1996-2022, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/commands/copy.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef COPY_H
+#define COPY_H
+
+#include "nodes/execnodes.h"
+#include "nodes/parsenodes.h"
+#include "parser/parse_node.h"
+#include "tcop/dest.h"
+
+/*
+ * Represents whether a header line should be present, and whether it must
+ * match the actual names (which implies "true").
+ */
+typedef enum CopyHeaderChoice
+{
+	COPY_HEADER_FALSE = 0,
+	COPY_HEADER_TRUE,
+	COPY_HEADER_MATCH,
+} CopyHeaderChoice;
+
+/*
+ * A struct to hold COPY options, in a parsed form. All of these are related
+ * to formatting, except for 'freeze', which doesn't really belong here, but
+ * it's expedient to parse it along with all the other options.
+ */
+typedef struct CopyFormatOptions
+{
+	/* parameters from the COPY command */
+	int			file_encoding;	/* file or remote side's character encoding,
+								 * -1 if not specified */
+	bool		binary;			/* binary format? */
+	bool		freeze;			/* freeze rows on loading? */
+	bool		csv_mode;		/* Comma Separated Value format? */
+	CopyHeaderChoice header_line;	/* header line? */
+	char	   *null_print;		/* NULL marker string (server encoding!) */
+	int			null_print_len; /* length of same */
+	char	   *null_print_client;	/* same converted to file encoding */
+	char	   *delim;			/* column delimiter (must be 1 byte) */
+	char	   *quote;			/* CSV quote char (must be 1 byte) */
+	char	   *escape;			/* CSV escape char (must be 1 byte) */
+	List	   *force_quote;	/* list of column names */
+	bool		force_quote_all;	/* FORCE_QUOTE *? */
+	bool	   *force_quote_flags;	/* per-column CSV FQ flags */
+	List	   *force_notnull;	/* list of column names */
+	bool	   *force_notnull_flags;	/* per-column CSV FNN flags */
+	List	   *force_null;		/* list of column names */
+	bool	   *force_null_flags;	/* per-column CSV FN flags */
+	bool		convert_selectively;	/* do selective binary conversion? */
+	List	   *convert_select; /* list of column names (can be NIL) */
+
+	/* Yugabytes attributes */
+	int			batch_size;		/* copy from executes in batch sizes */
+	uint64		num_initial_skipped_rows;	/* rows to skip at the beginning
+											 * of the file */
+	bool		disable_fk_check;	/* Disable FK check? */
+	OnConflictAction on_conflict_action;	/* How to handle when the new row
+											 * conflicts with existing row */
+} CopyFormatOptions;
+
+/* These are private in commands/copy[from|to].c */
+typedef struct CopyFromStateData *CopyFromState;
+typedef struct CopyToStateData *CopyToState;
+
+typedef int (*copy_data_source_cb) (void *outbuf, int minread, int maxread);
+
+/*
+ * This is Yugabyte macros.
+ */
+#define DEFAULT_BATCH_ROWS_PER_TRANSACTION  20000
+
+/**
+ * YSQL guc variables that can be used to set rows per transaciton for batch copy from.
+ * e.g. 'SET yb_default_copy_from_rows_per_transaction=1000'
+ * See also the corresponding entries in guc.c.
+ */
+extern int	yb_default_copy_from_rows_per_transaction;
+
+extern void DoCopy(ParseState *state, const CopyStmt *stmt,
+				   int stmt_location, int stmt_len,
+				   uint64 *processed);
+
+extern void ProcessCopyOptions(ParseState *pstate, CopyFormatOptions *ops_out, bool is_from, List *options);
+extern CopyFromState BeginCopyFrom(ParseState *pstate, Relation rel, Node *whereClause,
+								   const char *filename,
+								   bool is_program, copy_data_source_cb data_source_cb, List *attnamelist, List *options);
+extern void EndCopyFrom(CopyFromState cstate);
+extern bool NextCopyFrom(CopyFromState cstate, ExprContext *econtext,
+						 Datum *values, bool *nulls, bool skip_row);
+extern bool NextCopyFromRawFields(CopyFromState cstate,
+								  char ***fields, int *nfields);
+extern void CopyFromErrorCallback(void *arg);
+
+extern uint64 CopyFrom(CopyFromState cstate);
+
+extern DestReceiver *CreateCopyDestReceiver(void);
+
+/*
+ * internal prototypes
+ */
+extern CopyToState BeginCopyTo(ParseState *pstate, Relation rel, RawStmt *query,
+							   Oid queryRelId, const char *filename, bool is_program,
+							   List *attnamelist, List *options);
+extern void EndCopyTo(CopyToState cstate);
+extern uint64 DoCopyTo(CopyToState cstate);
+extern List *CopyGetAttnums(TupleDesc tupDesc, Relation rel,
+							List *attnamelist);
+
+#endif							/* COPY_H */

data/ext/yb_ddl_parser/vendor/yugabyte-postgres/src/include/commands/copyfrom_internal.h

@@ -0,0 +1,176 @@
+/*-------------------------------------------------------------------------
+ *
+ * copyfrom_internal.h
+ *	  Internal definitions for COPY FROM command.
+ *
+ *
+ * Portions Copyright (c) 1996-2022, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/commands/copyfrom_internal.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef COPYFROM_INTERNAL_H
+#define COPYFROM_INTERNAL_H
+
+#include "commands/copy.h"
+#include "commands/trigger.h"
+
+/*
+ * Represents the different source cases we need to worry about at
+ * the bottom level
+ */
+typedef enum CopySource
+{
+	COPY_FILE,					/* from file (or a piped program) */
+	COPY_FRONTEND,				/* from frontend */
+	COPY_CALLBACK				/* from callback function */
+} CopySource;
+
+/*
+ *	Represents the end-of-line terminator type of the input
+ */
+typedef enum EolType
+{
+	EOL_UNKNOWN,
+	EOL_NL,
+	EOL_CR,
+	EOL_CRNL
+} EolType;
+
+/*
+ * Represents the heap insert method to be used during COPY FROM.
+ */
+typedef enum CopyInsertMethod
+{
+	/*
+	 * YB: for CIM_SINGLE, use YBCExecuteNonTxnInsert/YBCExecuteInsert for YB
+	 * relations
+	 */
+	CIM_SINGLE,					/* use table_tuple_insert or fdw routine */
+	CIM_MULTI,					/* always use table_multi_insert */
+	CIM_MULTI_CONDITIONAL		/* use table_multi_insert only if valid */
+} CopyInsertMethod;
+
+/*
+ * This struct contains all the state variables used throughout a COPY FROM
+ * operation.
+ */
+typedef struct CopyFromStateData
+{
+	/* low-level state data */
+	CopySource	copy_src;		/* type of copy source */
+	FILE	   *copy_file;		/* used if copy_src == COPY_FILE */
+	StringInfo	fe_msgbuf;		/* used if copy_src == COPY_NEW_FE */
+
+	EolType		eol_type;		/* EOL type of input */
+	int			file_encoding;	/* file or remote side's character encoding */
+	bool		need_transcoding;	/* file encoding diff from server? */
+	Oid			conversion_proc;	/* encoding conversion function */
+
+	/* parameters from the COPY command */
+	Relation	rel;			/* relation to copy from */
+	List	   *attnumlist;		/* integer list of attnums to copy */
+	char	   *filename;		/* filename, or NULL for STDIN */
+	bool		is_program;		/* is 'filename' a program to popen? */
+	copy_data_source_cb data_source_cb; /* function for reading data */
+
+	CopyFormatOptions opts;
+	bool	   *convert_select_flags;	/* per-column CSV/TEXT CS flags */
+	Node	   *whereClause;	/* WHERE condition (or NULL) */
+
+	/* these are just for error messages, see CopyFromErrorCallback */
+	const char *cur_relname;	/* table name for error messages */
+	uint64		cur_lineno;		/* line number for error messages */
+	const char *cur_attname;	/* current att for error messages */
+	const char *cur_attval;		/* current att value for error messages */
+
+	/*
+	 * Working state
+	 */
+	MemoryContext copycontext;	/* per-copy execution context */
+
+	AttrNumber	num_defaults;
+	FmgrInfo   *in_functions;	/* array of input functions for each attrs */
+	Oid		   *typioparams;	/* array of element types for in_functions */
+	int		   *defmap;			/* array of default att numbers */
+	ExprState **defexprs;		/* array of default att expressions */
+	bool		volatile_defexprs;	/* is any of defexprs volatile? */
+	List	   *range_table;
+	ExprState  *qualexpr;
+
+	TransitionCaptureState *transition_capture;
+
+	/*
+	 * These variables are used to reduce overhead in COPY FROM.
+	 *
+	 * attribute_buf holds the separated, de-escaped text for each field of
+	 * the current line.  The CopyReadAttributes functions return arrays of
+	 * pointers into this buffer.  We avoid palloc/pfree overhead by re-using
+	 * the buffer on each cycle.
+	 *
+	 * In binary COPY FROM, attribute_buf holds the binary data for the
+	 * current field, but the usage is otherwise similar.
+	 */
+	StringInfoData attribute_buf;
+
+	/* field raw data pointers found by COPY FROM */
+
+	int			max_fields;
+	char	  **raw_fields;
+
+	/*
+	 * Similarly, line_buf holds the whole input line being processed. The
+	 * input cycle is first to read the whole line into line_buf, and then
+	 * extract the individual attribute fields into attribute_buf.  line_buf
+	 * is preserved unmodified so that we can display it in error messages if
+	 * appropriate.  (In binary mode, line_buf is not used.)
+	 */
+	StringInfoData line_buf;
+	bool		line_buf_valid; /* contains the row being processed? */
+
+	/*
+	 * input_buf holds input data, already converted to database encoding.
+	 *
+	 * In text mode, CopyReadLine parses this data sufficiently to locate line
+	 * boundaries, then transfers the data to line_buf. We guarantee that
+	 * there is a \0 at input_buf[input_buf_len] at all times.  (In binary
+	 * mode, input_buf is not used.)
+	 *
+	 * If encoding conversion is not required, input_buf is not a separate
+	 * buffer but points directly to raw_buf.  In that case, input_buf_len
+	 * tracks the number of bytes that have been verified as valid in the
+	 * database encoding, and raw_buf_len is the total number of bytes stored
+	 * in the buffer.
+	 */
+#define INPUT_BUF_SIZE 65536	/* we palloc INPUT_BUF_SIZE+1 bytes */
+	char	   *input_buf;
+	int			input_buf_index;	/* next byte to process */
+	int			input_buf_len;	/* total # of bytes stored */
+	bool		input_reached_eof;	/* true if we reached EOF */
+	bool		input_reached_error;	/* true if a conversion error happened */
+	/* Shorthand for number of unconsumed bytes available in input_buf */
+#define INPUT_BUF_BYTES(cstate) ((cstate)->input_buf_len - (cstate)->input_buf_index)
+
+	/*
+	 * raw_buf holds raw input data read from the data source (file or client
+	 * connection), not yet converted to the database encoding.  Like with
+	 * 'input_buf', we guarantee that there is a \0 at raw_buf[raw_buf_len].
+	 */
+#define RAW_BUF_SIZE 65536		/* we palloc RAW_BUF_SIZE+1 bytes */
+	char	   *raw_buf;
+	int			raw_buf_index;	/* next byte to process */
+	int			raw_buf_len;	/* total # of bytes stored */
+	bool		raw_reached_eof;	/* true if we reached EOF */
+
+	/* Shorthand for number of unconsumed bytes available in raw_buf */
+#define RAW_BUF_BYTES(cstate) ((cstate)->raw_buf_len - (cstate)->raw_buf_index)
+
+	uint64		bytes_processed;	/* number of bytes processed so far */
+} CopyFromStateData;
+
+extern void ReceiveCopyBegin(CopyFromState cstate);
+extern void ReceiveCopyBinaryHeader(CopyFromState cstate);
+
+#endif							/* COPYFROM_INTERNAL_H */

data/ext/yb_ddl_parser/vendor/yugabyte-postgres/src/include/commands/createas.h

@@ -0,0 +1,34 @@
+/*-------------------------------------------------------------------------
+ *
+ * createas.h
+ *	  prototypes for createas.c.
+ *
+ *
+ * Portions Copyright (c) 1996-2022, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/commands/createas.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef CREATEAS_H
+#define CREATEAS_H
+
+#include "catalog/objectaddress.h"
+#include "nodes/params.h"
+#include "parser/parse_node.h"
+#include "tcop/dest.h"
+#include "utils/queryenvironment.h"
+
+
+extern ObjectAddress ExecCreateTableAs(ParseState *pstate, CreateTableAsStmt *stmt,
+									   ParamListInfo params, QueryEnvironment *queryEnv,
+									   QueryCompletion *qc);
+
+extern int	GetIntoRelEFlags(IntoClause *intoClause);
+
+extern DestReceiver *CreateIntoRelDestReceiver(IntoClause *intoClause);
+
+extern bool CreateTableAsRelExists(CreateTableAsStmt *ctas);
+
+#endif							/* CREATEAS_H */

data/ext/yb_ddl_parser/vendor/yugabyte-postgres/src/include/commands/dbcommands.h

@@ -0,0 +1,36 @@
+/*-------------------------------------------------------------------------
+ *
+ * dbcommands.h
+ *		Database management commands (create/drop database).
+ *
+ *
+ * Portions Copyright (c) 1996-2022, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/commands/dbcommands.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef DBCOMMANDS_H
+#define DBCOMMANDS_H
+
+#include "access/xlogreader.h"
+#include "catalog/objectaddress.h"
+#include "lib/stringinfo.h"
+#include "parser/parse_node.h"
+
+extern Oid	createdb(ParseState *pstate, const CreatedbStmt *stmt);
+extern void dropdb(const char *dbname, bool missing_ok, bool force);
+extern void DropDatabase(ParseState *pstate, DropdbStmt *stmt);
+extern ObjectAddress RenameDatabase(const char *oldname, const char *newname);
+extern Oid	AlterDatabase(ParseState *pstate, AlterDatabaseStmt *stmt, bool isTopLevel);
+extern ObjectAddress AlterDatabaseRefreshColl(AlterDatabaseRefreshCollStmt *stmt);
+extern Oid	AlterDatabaseSet(AlterDatabaseSetStmt *stmt);
+extern ObjectAddress AlterDatabaseOwner(const char *dbname, Oid newOwnerId);
+
+extern Oid	get_database_oid(const char *dbname, bool missing_ok);
+extern char *get_database_name(Oid dbid);
+
+extern void check_encoding_locale_matches(int encoding, const char *collate, const char *ctype);
+
+#endif							/* DBCOMMANDS_H */

data/ext/yb_ddl_parser/vendor/yugabyte-postgres/src/include/commands/dbcommands_xlog.h

@@ -0,0 +1,60 @@
+/*-------------------------------------------------------------------------
+ *
+ * dbcommands_xlog.h
+ *		Database resource manager XLOG definitions (create/drop database).
+ *
+ *
+ * Portions Copyright (c) 1996-2022, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/commands/dbcommands_xlog.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef DBCOMMANDS_XLOG_H
+#define DBCOMMANDS_XLOG_H
+
+#include "access/xlogreader.h"
+#include "lib/stringinfo.h"
+
+/* record types */
+#define XLOG_DBASE_CREATE_FILE_COPY		0x00
+#define XLOG_DBASE_CREATE_WAL_LOG		0x10
+#define XLOG_DBASE_DROP					0x20
+
+/*
+ * Single WAL record for an entire CREATE DATABASE operation. This is used
+ * by the FILE_COPY strategy.
+ */
+typedef struct xl_dbase_create_file_copy_rec
+{
+	Oid			db_id;
+	Oid			tablespace_id;
+	Oid			src_db_id;
+	Oid			src_tablespace_id;
+} xl_dbase_create_file_copy_rec;
+
+/*
+ * WAL record for the beginning of a CREATE DATABASE operation, when the
+ * WAL_LOG strategy is used. Each individual block will be logged separately
+ * afterward.
+ */
+typedef struct xl_dbase_create_wal_log_rec
+{
+	Oid			db_id;
+	Oid			tablespace_id;
+} xl_dbase_create_wal_log_rec;
+
+typedef struct xl_dbase_drop_rec
+{
+	Oid			db_id;
+	int			ntablespaces;	/* number of tablespace IDs */
+	Oid			tablespace_ids[FLEXIBLE_ARRAY_MEMBER];
+} xl_dbase_drop_rec;
+#define MinSizeOfDbaseDropRec offsetof(xl_dbase_drop_rec, tablespace_ids)
+
+extern void dbase_redo(XLogReaderState *rptr);
+extern void dbase_desc(StringInfo buf, XLogReaderState *rptr);
+extern const char *dbase_identify(uint8 info);
+
+#endif							/* DBCOMMANDS_XLOG_H */