SQL/MED - file_fdw

diff --git a/src/backend/commands/copy.c b/src/backend/commands/copy.c
index 7b8bee8..05bbce1 100644
*** a/src/backend/commands/copy.c
--- b/src/backend/commands/copy.c
*************** typedef struct CopyStateData
*** 142,150 ****
  	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
--- 142,149 ----
  	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
*************** typedef struct CopyStateData
*** 167,175 ****
  	char	   *raw_buf;
  	int			raw_buf_index;	/* next byte to process */
  	int			raw_buf_len;	/* total # of bytes stored */
- } CopyStateData;
  
! typedef CopyStateData *CopyState;
  
  /* DestReceiver for COPY (SELECT) TO */
  typedef struct
--- 166,186 ----
  	char	   *raw_buf;
  	int			raw_buf_index;	/* next byte to process */
  	int			raw_buf_len;	/* total # of bytes stored */
  
! 	/*
! 	 * The definition of input functions and default expressions are stored
! 	 * in these variables.
! 	 */
! 	EState	   *estate;
! 	AttrNumber	num_defaults;
! 	bool		file_has_oids;
! 	FmgrInfo	oid_in_function;
! 	Oid			oid_typioparam;
! 	FmgrInfo   *in_functions;
! 	Oid		   *typioparams;
! 	int		   *defmap;
! 	ExprState **defexprs;		/* array of default att expressions */
! } CopyStateData;
  
  /* DestReceiver for COPY (SELECT) TO */
  typedef struct
*************** static const char BinarySignature[11] = 
*** 248,253 ****
--- 259,270 ----
  
  
  /* non-export function prototypes */
+ static CopyState BeginCopy(bool is_from,
+ 				Relation rel, Node *raw_query, const char *queryString,
+ 				const char *filename, List *attnamelist, List *options);
+ static CopyState BeginCopyTo(Relation rel, Node *query, const char *queryString,
+ 				const char *filename, List *attnamelist, List *options);
+ static void EndCopyTo(CopyState cstate);
  static void DoCopyTo(CopyState cstate);
  static void CopyTo(CopyState cstate);
  static void CopyOneRowTo(CopyState cstate, Oid tupleOid,
*************** CopyLoadRawBuf(CopyState cstate)
*** 718,730 ****
   * Do not allow the copy if user doesn't have proper permission to access
   * the table or the specifically requested columns.
   */
! uint64
! DoCopy(const CopyStmt *stmt, const char *queryString)
  {
  	CopyState	cstate;
- 	bool		is_from = stmt->is_from;
- 	bool		pipe = (stmt->filename == NULL);
- 	List	   *attnamelist = stmt->attlist;
  	List	   *force_quote = NIL;
  	List	   *force_notnull = NIL;
  	bool		force_quote_all = false;
--- 735,746 ----
   * Do not allow the copy if user doesn't have proper permission to access
   * the table or the specifically requested columns.
   */
! static CopyState
! BeginCopy(bool is_from,
! 				Relation rel, Node *raw_query, const char *queryString,
! 				const char *filename, List *attnamelist, List *options)
  {
  	CopyState	cstate;
  	List	   *force_quote = NIL;
  	List	   *force_notnull = NIL;
  	bool		force_quote_all = false;
*************** DoCopy(const CopyStmt *stmt, const char 
*** 733,745 ****
  	ListCell   *option;
  	TupleDesc	tupDesc;
  	int			num_phys_attrs;
- 	uint64		processed;
  
  	/* Allocate workspace and zero all fields */
  	cstate = (CopyStateData *) palloc0(sizeof(CopyStateData));
  
  	/* Extract options from the statement node tree */
! 	foreach(option, stmt->options)
  	{
  		DefElem    *defel = (DefElem *) lfirst(option);
  
--- 749,760 ----
  	ListCell   *option;
  	TupleDesc	tupDesc;
  	int			num_phys_attrs;
  
  	/* Allocate workspace and zero all fields */
  	cstate = (CopyStateData *) palloc0(sizeof(CopyStateData));
  
  	/* Extract options from the statement node tree */
! 	foreach(option, options)
  	{
  		DefElem    *defel = (DefElem *) lfirst(option);
  
*************** DoCopy(const CopyStmt *stmt, const char 
*** 980,1005 ****
  				(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
  				 errmsg("CSV quote character must not appear in the NULL specification")));
  
! 	/* Disallow file COPY except to superusers. */
! 	if (!pipe && !superuser())
! 		ereport(ERROR,
! 				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
! 				 errmsg("must be superuser to COPY to or from a file"),
! 				 errhint("Anyone can COPY to stdout or from stdin. "
! 						 "psql's \\copy command also works for anyone.")));
! 
! 	if (stmt->relation)
  	{
  		RangeTblEntry  *rte;
  		List		   *attnums;
  		ListCell	   *cur;
  
! 		Assert(!stmt->query);
! 		cstate->queryDesc = NULL;
  
! 		/* Open and lock the relation, using the appropriate lock type. */
! 		cstate->rel = heap_openrv(stmt->relation,
! 							 (is_from ? RowExclusiveLock : AccessShareLock));
  
  		tupDesc = RelationGetDescr(cstate->rel);
  
--- 995,1009 ----
  				(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
  				 errmsg("CSV quote character must not appear in the NULL specification")));
  
! 	if (rel)
  	{
  		RangeTblEntry  *rte;
  		List		   *attnums;
  		ListCell	   *cur;
  
! 		Assert(!raw_query);
  
! 		cstate->rel = rel;
  
  		tupDesc = RelationGetDescr(cstate->rel);
  
*************** DoCopy(const CopyStmt *stmt, const char 
*** 1058,1064 ****
  		 * function and is executed repeatedly.  (See also the same hack in
  		 * DECLARE CURSOR and PREPARE.)  XXX FIXME someday.
  		 */
! 		rewritten = pg_analyze_and_rewrite((Node *) copyObject(stmt->query),
  										   queryString, NULL, 0);
  
  		/* We don't expect more or less than one result query */
--- 1062,1068 ----
  		 * function and is executed repeatedly.  (See also the same hack in
  		 * DECLARE CURSOR and PREPARE.)  XXX FIXME someday.
  		 */
! 		rewritten = pg_analyze_and_rewrite((Node *) copyObject(raw_query),
  										   queryString, NULL, 0);
  
  		/* We don't expect more or less than one result query */
*************** DoCopy(const CopyStmt *stmt, const char 
*** 1160,1171 ****
  		}
  	}
  
- 	/* Set up variables to avoid per-attribute overhead. */
- 	initStringInfo(&cstate->attribute_buf);
- 	initStringInfo(&cstate->line_buf);
- 	cstate->line_buf_converted = false;
- 	cstate->raw_buf = (char *) palloc(RAW_BUF_SIZE + 1);
- 	cstate->raw_buf_index = cstate->raw_buf_len = 0;
  	cstate->processed = 0;
  
  	/*
--- 1164,1169 ----
*************** DoCopy(const CopyStmt *stmt, const char 
*** 1181,1202 ****
  	cstate->encoding_embeds_ascii = PG_ENCODING_IS_CLIENT_ONLY(cstate->client_encoding);
  
  	cstate->copy_dest = COPY_FILE;		/* default */
! 	cstate->filename = stmt->filename;
  
  	if (is_from)
  		CopyFrom(cstate);		/* copy from file to database */
  	else
  		DoCopyTo(cstate);		/* copy from database to file */
  
  	/*
! 	 * Close the relation or query.  If reading, we can release the
! 	 * AccessShareLock we got; if writing, we should hold the lock until end
! 	 * of transaction to ensure that updates will be committed before lock is
! 	 * released.
  	 */
! 	if (cstate->rel)
! 		heap_close(cstate->rel, (is_from ? NoLock : AccessShareLock));
! 	else
  	{
  		/* Close down the query and free resources. */
  		ExecutorEnd(cstate->queryDesc);
--- 1179,1681 ----
  	cstate->encoding_embeds_ascii = PG_ENCODING_IS_CLIENT_ONLY(cstate->client_encoding);
  
  	cstate->copy_dest = COPY_FILE;		/* default */
! 	cstate->filename = (filename ? pstrdup(filename) : NULL);
! 
! 	return cstate;
! }
! 
! CopyState
! BeginCopyFrom(Relation rel, const char *filename, List *attnamelist, List *options)
! {
! 	CopyState		cstate;
! 	bool			pipe = (filename == NULL);
! 	TupleDesc		tupDesc;
! 	int				num_phys_attrs;
! 	Form_pg_attribute *attr;
! 	AttrNumber		attr_count;
! 	int				attnum;
! 	EState		   *estate;
! 	Oid				in_func_oid;
! 
! 	cstate = BeginCopy(true, rel, NULL, NULL, filename, attnamelist, options);
! 
! 	/* Initialize state variables */
! 	cstate->fe_eof = false;
! 	cstate->eol_type = EOL_UNKNOWN;
! 	cstate->cur_relname = RelationGetRelationName(cstate->rel);
! 	cstate->cur_lineno = 0;
! 	cstate->cur_attname = NULL;
! 	cstate->cur_attval = NULL;
! 
! 	/* Set up variables to avoid per-attribute overhead. */
! 	initStringInfo(&cstate->attribute_buf);
! 	initStringInfo(&cstate->line_buf);
! 	cstate->line_buf_converted = false;
! 	cstate->raw_buf = (char *) palloc(RAW_BUF_SIZE + 1);
! 	cstate->raw_buf_index = cstate->raw_buf_len = 0;
! 
! 	tupDesc = RelationGetDescr(cstate->rel);
! 	attr = tupDesc->attrs;
! 	num_phys_attrs = tupDesc->natts;
! 	attr_count = list_length(cstate->attnumlist);
! 	cstate->num_defaults = 0;
! 
! 	/*
! 	 * Pick up the required catalog information for each attribute in the
! 	 * relation, including the input function, the element type (to pass to
! 	 * the input function), and info about defaults and constraints. (Which
! 	 * input function we use depends on text/binary format choice.)
! 	 */
! 	cstate->in_functions = (FmgrInfo *) palloc(num_phys_attrs * sizeof(FmgrInfo));
! 	cstate->typioparams = (Oid *) palloc(num_phys_attrs * sizeof(Oid));
! 	cstate->defmap = (int *) palloc(num_phys_attrs * sizeof(int));
! 	cstate->defexprs = (ExprState **) palloc(num_phys_attrs * sizeof(ExprState *));
! 
! 	/* We need a ResultRelInfo to check constraints. */
! 	estate = cstate->estate = CreateExecutorState();
! 
! 	for (attnum = 1; attnum <= num_phys_attrs; attnum++)
! 	{
! 		/* We don't need info for dropped attributes */
! 		if (attr[attnum - 1]->attisdropped)
! 			continue;
! 
! 		/* Fetch the input function and typioparam info */
! 		if (cstate->binary)
! 			getTypeBinaryInputInfo(attr[attnum - 1]->atttypid,
! 								   &in_func_oid, &cstate->typioparams[attnum - 1]);
! 		else
! 			getTypeInputInfo(attr[attnum - 1]->atttypid,
! 							 &in_func_oid, &cstate->typioparams[attnum - 1]);
! 		fmgr_info(in_func_oid, &cstate->in_functions[attnum - 1]);
! 
! 		/* Get default info if needed */
! 		if (!list_member_int(cstate->attnumlist, attnum))
! 		{
! 			/* attribute is NOT to be copied from input */
! 			/* use default value if one exists */
! 			Node	   *defexpr = build_column_default(cstate->rel, attnum);
! 
! 			if (defexpr != NULL)
! 			{
! 				cstate->defexprs[cstate->num_defaults] =
! 								ExecPrepareExpr((Expr *) defexpr, estate);
! 				cstate->defmap[cstate->num_defaults] = attnum - 1;
! 				cstate->num_defaults++;
! 			}
! 		}
! 	}
! 
! 	if (pipe)
! 	{
! 		if (whereToSendOutput == DestRemote)
! 			ReceiveCopyBegin(cstate);
! 		else
! 			cstate->copy_file = stdin;
! 	}
! 	else
! 	{
! 		struct stat st;
! 
! 		cstate->copy_file = AllocateFile(cstate->filename, PG_BINARY_R);
! 
! 		if (cstate->copy_file == NULL)
! 			ereport(ERROR,
! 					(errcode_for_file_access(),
! 					 errmsg("could not open file \"%s\" for reading: %m",
! 							cstate->filename)));
! 
! 		fstat(fileno(cstate->copy_file), &st);
! 		if (S_ISDIR(st.st_mode))
! 			ereport(ERROR,
! 					(errcode(ERRCODE_WRONG_OBJECT_TYPE),
! 					 errmsg("\"%s\" is a directory", cstate->filename)));
! 	}
! 
! 	if (!cstate->binary)
! 		cstate->file_has_oids = cstate->oids;	/* must rely on user to tell us... */
! 	else
! 	{
! 		/* Read and verify binary header */
! 		char		readSig[11];
! 		int32		tmp;
! 
! 		/* Signature */
! 		if (CopyGetData(cstate, readSig, 11, 11) != 11 ||
! 			memcmp(readSig, BinarySignature, 11) != 0)
! 			ereport(ERROR,
! 					(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
! 					 errmsg("COPY file signature not recognized")));
! 		/* Flags field */
! 		if (!CopyGetInt32(cstate, &tmp))
! 			ereport(ERROR,
! 					(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
! 					 errmsg("invalid COPY file header (missing flags)")));
! 		cstate->file_has_oids = (tmp & (1 << 16)) != 0;
! 		tmp &= ~(1 << 16);
! 		if ((tmp >> 16) != 0)
! 			ereport(ERROR,
! 					(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
! 				 errmsg("unrecognized critical flags in COPY file header")));
! 		/* Header extension length */
! 		if (!CopyGetInt32(cstate, &tmp) ||
! 			tmp < 0)
! 			ereport(ERROR,
! 					(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
! 					 errmsg("invalid COPY file header (missing length)")));
! 		/* Skip extension header, if present */
! 		while (tmp-- > 0)
! 		{
! 			if (CopyGetData(cstate, readSig, 1, 1) != 1)
! 				ereport(ERROR,
! 						(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
! 						 errmsg("invalid COPY file header (wrong length)")));
! 		}
! 	}
! 
! 	if (cstate->file_has_oids && cstate->binary)
! 	{
! 		Oid		in_func_oid;
! 		getTypeBinaryInputInfo(OIDOID,
! 							   &in_func_oid, &cstate->oid_typioparam);
! 		fmgr_info(in_func_oid, &cstate->oid_in_function);
! 	}
! 
! 	/* create workspace for CopyReadAttributes results */
! 	if (!cstate->binary)
! 	{
! 		int		nfields = cstate->file_has_oids ? (attr_count + 1) : attr_count;
! 
! 		cstate->max_fields = nfields;
! 		cstate->raw_fields = (char **) palloc(nfields * sizeof(char *));
! 	}
! 
! 	return cstate;
! }
! 
! static CopyState
! BeginCopyTo(Relation rel, Node *query, const char *queryString,
! 			const char *filename, List *attnamelist, List *options)
! {
! 	return BeginCopy(false, rel, query, queryString,
! 					 filename, attnamelist, options);
! }
! 
! /* return false if no more tuples */
! bool
! NextCopyFrom(CopyState cstate, Datum *values, bool *nulls, Oid *oid)
! {
! 	TupleDesc	tupDesc;
! 	Form_pg_attribute *attr;
! 	AttrNumber	num_phys_attrs,
! 				attr_count,
! 				num_defaults = cstate->num_defaults;
! 	FmgrInfo   *in_functions = cstate->in_functions;
! 	Oid		   *typioparams = cstate->typioparams;
! 	int			i;
! 	int			nfields;
! 	char	  **field_strings;
! 	bool		isnull;
! 	int		   *defmap = cstate->defmap;
! 	ExprState **defexprs = cstate->defexprs;
! 	ExprContext	*econtext;		/* used for ExecEvalExpr for default atts */
! 
! 	/* on input just throw the header line away */
! 	if (cstate->cur_lineno == 0 && cstate->header_line)
! 	{
! 		cstate->cur_lineno++;
! 		if (CopyReadLine(cstate))
! 			return false;	/* done */
! 	}
! 
! 	cstate->cur_lineno++;
! 
! 	tupDesc = RelationGetDescr(cstate->rel);
! 	attr = tupDesc->attrs;
! 	num_phys_attrs = tupDesc->natts;
! 	attr_count = list_length(cstate->attnumlist);
! 	nfields = cstate->file_has_oids ? (attr_count + 1) : attr_count;
! 
! 	/* Initialize all values for row to NULL */
! 	MemSet(values, 0, num_phys_attrs * sizeof(Datum));
! 	MemSet(nulls, true, num_phys_attrs * sizeof(bool));
! 
! 	if (!cstate->binary)
! 	{
! 		ListCell   *cur;
! 		int			fldct;
! 		int			fieldno;
! 		char	   *string;
! 
! 		/*
! 		 * Actually read the line into memory here.
! 		 * EOF at start of line means we're done.  If we see EOF after
! 		 * some characters, we act as though it was newline followed by
! 		 * EOF, ie, process the line and then exit loop on next iteration.
! 		 */
! 		if (CopyReadLine(cstate) && cstate->line_buf.len == 0)
! 			return false;
! 
! 		/* Parse the line into de-escaped field values */
! 		if (cstate->csv_mode)
! 			fldct = CopyReadAttributesCSV(cstate);
! 		else
! 			fldct = CopyReadAttributesText(cstate);
! 
! 		/* check for overflowing fields */
! 		if (nfields > 0 && fldct > nfields)
! 			ereport(ERROR,
! 					(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
! 						errmsg("extra data after last expected column")));
! 
! 		fieldno = 0;
! 		field_strings = cstate->raw_fields;
! 
! 		/* Read the OID field if present */
! 		if (cstate->file_has_oids)
! 		{
! 			if (fieldno >= fldct)
! 				ereport(ERROR,
! 						(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
! 							errmsg("missing data for OID column")));
! 			string = field_strings[fieldno++];
! 
! 			if (string == NULL)
! 				ereport(ERROR,
! 						(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
! 							errmsg("null OID in COPY data")));
! 			else
! 			{
! 				cstate->cur_attname = "oid";
! 				cstate->cur_attval = string;
! 				*oid = DatumGetObjectId(DirectFunctionCall1(oidin,
! 												CStringGetDatum(string)));
! 				if (*oid == InvalidOid)
! 					ereport(ERROR,
! 							(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
! 								errmsg("invalid OID in COPY data")));
! 				cstate->cur_attname = NULL;
! 				cstate->cur_attval = NULL;
! 			}
! 		}
! 
! 		/* Loop to read the user attributes on the line. */
! 		foreach(cur, cstate->attnumlist)
! 		{
! 			int			attnum = lfirst_int(cur);
! 			int			m = attnum - 1;
! 
! 			if (fieldno >= fldct)
! 				ereport(ERROR,
! 						(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
! 							errmsg("missing data for column \"%s\"",
! 								NameStr(attr[m]->attname))));
! 			string = field_strings[fieldno++];
! 
! 			if (cstate->csv_mode && string == NULL &&
! 				cstate->force_notnull_flags[m])
! 			{
! 				/* Go ahead and read the NULL string */
! 				string = cstate->null_print;
! 			}
! 
! 			cstate->cur_attname = NameStr(attr[m]->attname);
! 			cstate->cur_attval = string;
! 			values[m] = InputFunctionCall(&in_functions[m],
! 										  string,
! 										  typioparams[m],
! 										  attr[m]->atttypmod);
! 			if (string != NULL)
! 				nulls[m] = false;
! 			cstate->cur_attname = NULL;
! 			cstate->cur_attval = NULL;
! 		}
! 
! 		Assert(fieldno == nfields);
! 	}
! 	else
! 	{
! 		/* binary */
! 		int16		fld_count;
! 		ListCell   *cur;
! 
! 		if (!CopyGetInt16(cstate, &fld_count))
! 		{
! 			/* EOF detected (end of file, or protocol-level EOF) */
! 			return false;
! 		}
! 
! 		if (fld_count == -1)
! 		{
! 			/*
! 			 * Received EOF marker.  In a V3-protocol copy, wait for
! 			 * the protocol-level EOF, and complain if it doesn't come
! 			 * immediately.  This ensures that we correctly handle
! 			 * CopyFail, if client chooses to send that now.
! 			 *
! 			 * Note that we MUST NOT try to read more data in an
! 			 * old-protocol copy, since there is no protocol-level EOF
! 			 * marker then.  We could go either way for copy from file,
! 			 * but choose to throw error if there's data after the EOF
! 			 * marker, for consistency with the new-protocol case.
! 			 */
! 			char	dummy;
! 
! 			if (cstate->copy_dest != COPY_OLD_FE &&
! 				CopyGetData(cstate, &dummy, 1, 1) > 0)
! 				ereport(ERROR,
! 						(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
! 							errmsg("received copy data after EOF marker")));
! 			return false;
! 		}
! 
! 		if (fld_count != attr_count)
! 			ereport(ERROR,
! 					(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
! 						errmsg("row field count is %d, expected %d",
! 							(int) fld_count, attr_count)));
! 
! 		if (cstate->file_has_oids)
! 		{
! 			cstate->cur_attname = "oid";
! 			*oid = DatumGetObjectId(CopyReadBinaryAttribute(cstate,
! 															0,
! 															&cstate->oid_in_function,
! 															cstate->oid_typioparam,
! 															-1,
! 															&isnull));
! 			if (isnull || *oid == InvalidOid)
! 				ereport(ERROR,
! 						(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
! 							errmsg("invalid OID in COPY data")));
! 			cstate->cur_attname = NULL;
! 		}
! 
! 		i = 0;
! 		foreach(cur, cstate->attnumlist)
! 		{
! 			int			attnum = lfirst_int(cur);
! 			int			m = attnum - 1;
! 
! 			cstate->cur_attname = NameStr(attr[m]->attname);
! 			i++;
! 			values[m] = CopyReadBinaryAttribute(cstate,
! 												i,
! 												&in_functions[m],
! 												typioparams[m],
! 												attr[m]->atttypmod,
! 												&nulls[m]);
! 			cstate->cur_attname = NULL;
! 		}
! 	}
! 
! 	/*
! 	 * Now compute and insert any defaults available for the columns not
! 	 * provided by the input data.	Anything not processed here or above
! 	 * will remain NULL.
! 	 */
! 	econtext = GetPerTupleExprContext(cstate->estate);
! 	for (i = 0; i < num_defaults; i++)
! 	{
! 		values[defmap[i]] = ExecEvalExpr(defexprs[i], econtext,
! 										 &nulls[defmap[i]], NULL);
! 	}
! 
! 	return true;
! }
! 
! uint64
! DoCopy(const CopyStmt *stmt, const char *queryString)
! {
! 	CopyState	cstate;
! 	bool		is_from = stmt->is_from;
! 	bool		pipe = (stmt->filename == NULL);
! 	Relation	rel;
! 	uint64		processed;
! 
! 	/* Disallow file COPY except to superusers. */
! 	if (!pipe && !superuser())
! 		ereport(ERROR,
! 				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
! 				 errmsg("must be superuser to COPY to or from a file"),
! 				 errhint("Anyone can COPY to stdout or from stdin. "
! 						 "psql's \\copy command also works for anyone.")));
! 
! 	if (stmt->relation)
! 	{
! 		Assert(!stmt->query);
! 
! 		/* Open and lock the relation, using the appropriate lock type. */
! 		rel = heap_openrv(stmt->relation,
! 							 (is_from ? RowExclusiveLock : AccessShareLock));
! 	}
! 	else
! 	{
! 		Assert(stmt->query);
! 
! 		rel = NULL;
! 	}
  
  	if (is_from)
+ 	{
+ 		cstate = BeginCopyFrom(rel, stmt->filename, stmt->attlist, stmt->options);
  		CopyFrom(cstate);		/* copy from file to database */
+ 		processed = cstate->processed;
+ 		EndCopyFrom(cstate);
+ 	}
  	else
+ 	{
+ 		cstate = BeginCopyTo(rel, stmt->query, queryString, stmt->filename, stmt->attlist, stmt->options);
  		DoCopyTo(cstate);		/* copy from database to file */
+ 		processed = cstate->processed;
+ 		EndCopyTo(cstate);
+ 	}
  
  	/*
! 	 * Close the relation. If reading, we can release the AccessShareLock we got;
! 	 * if writing, we should hold the lock until end of transaction to ensure that
! 	 * updates will be committed before lock is released.
  	 */
! 	if (rel != NULL)
! 		heap_close(rel, (is_from ? NoLock : AccessShareLock));
! 
! 	return processed;
! }
! 
! void
! EndCopyFrom(CopyState cstate)
! {
! 	FreeExecutorState(cstate->estate);
! 
! 	/* Clean up storage */
! 	if (cstate->filename)
! 	{
! 		if (FreeFile(cstate->copy_file))
! 			ereport(ERROR,
! 					(errcode_for_file_access(),
! 					 errmsg("could not read from file \"%s\": %m",
! 							cstate->filename)));
! 		pfree(cstate->filename);
! 	}
! 	if (!cstate->binary)
! 		pfree(cstate->raw_fields);
! 	pfree(cstate->attribute_buf.data);
! 	pfree(cstate->line_buf.data);
! 	pfree(cstate->raw_buf);
! 	pfree(cstate->in_functions);
! 	pfree(cstate->typioparams);
! 	pfree(cstate->defmap);
! 	pfree(cstate->defexprs);
! 	pfree(cstate);
! }
! 
! static void
! EndCopyTo(CopyState cstate)
! {
! 	/*
! 	 * Close the relation or query. We can release the AccessShareLock we got.
! 	 */
! 	if (cstate->rel == NULL)
  	{
  		/* Close down the query and free resources. */
  		ExecutorEnd(cstate->queryDesc);
*************** DoCopy(const CopyStmt *stmt, const char 
*** 1204,1221 ****
  		PopActiveSnapshot();
  	}
  
! 	/* Clean up storage (probably not really necessary) */
! 	processed = cstate->processed;
! 
! 	pfree(cstate->attribute_buf.data);
! 	pfree(cstate->line_buf.data);
! 	pfree(cstate->raw_buf);
  	pfree(cstate);
- 
- 	return processed;
  }
  
- 
  /*
   * This intermediate routine exists mainly to localize the effects of setjmp
   * so we don't need to plaster a lot of variables with "volatile".
--- 1683,1694 ----
  		PopActiveSnapshot();
  	}
  
! 	/* Clean up storage */
! 	if (cstate->filename)
! 		pfree(cstate->filename);
  	pfree(cstate);
  }
  
  /*
   * This intermediate routine exists mainly to localize the effects of setjmp
   * so we don't need to plaster a lot of variables with "volatile".
*************** limit_printout_length(const char *str)
*** 1666,1698 ****
  static void
  CopyFrom(CopyState cstate)
  {
- 	bool		pipe = (cstate->filename == NULL);
  	HeapTuple	tuple;
  	TupleDesc	tupDesc;
- 	Form_pg_attribute *attr;
- 	AttrNumber	num_phys_attrs,
- 				attr_count,
- 				num_defaults;
- 	FmgrInfo   *in_functions;
- 	FmgrInfo	oid_in_function;
- 	Oid		   *typioparams;
- 	Oid			oid_typioparam;
- 	int			attnum;
- 	int			i;
- 	Oid			in_func_oid;
  	Datum	   *values;
  	bool	   *nulls;
- 	int			nfields;
- 	char	  **field_strings;
  	bool		done = false;
- 	bool		isnull;
  	ResultRelInfo *resultRelInfo;
! 	EState	   *estate = CreateExecutorState(); /* for ExecConstraints() */
  	TupleTableSlot *slot;
- 	bool		file_has_oids;
- 	int		   *defmap;
- 	ExprState **defexprs;		/* array of default att expressions */
- 	ExprContext *econtext;		/* used for ExecEvalExpr for default atts */
  	MemoryContext oldcontext = CurrentMemoryContext;
  	ErrorContextCallback errcontext;
  	CommandId	mycid = GetCurrentCommandId(true);
--- 2139,2152 ----
  static void
  CopyFrom(CopyState cstate)
  {
  	HeapTuple	tuple;
  	TupleDesc	tupDesc;
  	Datum	   *values;
  	bool	   *nulls;
  	bool		done = false;
  	ResultRelInfo *resultRelInfo;
! 	EState	   *estate = cstate->estate; /* for ExecConstraints() */
  	TupleTableSlot *slot;
  	MemoryContext oldcontext = CurrentMemoryContext;
  	ErrorContextCallback errcontext;
  	CommandId	mycid = GetCurrentCommandId(true);
*************** CopyFrom(CopyState cstate)
*** 1720,1725 ****
--- 2174,2181 ----
  							RelationGetRelationName(cstate->rel))));
  	}
  
+ 	tupDesc = RelationGetDescr(cstate->rel);
+ 
  	/*----------
  	 * Check to see if we can avoid writing WAL
  	 *
*************** CopyFrom(CopyState cstate)
*** 1755,1792 ****
  			hi_options |= HEAP_INSERT_SKIP_WAL;
  	}
  
- 	if (pipe)
- 	{
- 		if (whereToSendOutput == DestRemote)
- 			ReceiveCopyBegin(cstate);
- 		else
- 			cstate->copy_file = stdin;
- 	}
- 	else
- 	{
- 		struct stat st;
- 
- 		cstate->copy_file = AllocateFile(cstate->filename, PG_BINARY_R);
- 
- 		if (cstate->copy_file == NULL)
- 			ereport(ERROR,
- 					(errcode_for_file_access(),
- 					 errmsg("could not open file \"%s\" for reading: %m",
- 							cstate->filename)));
- 
- 		fstat(fileno(cstate->copy_file), &st);
- 		if (S_ISDIR(st.st_mode))
- 			ereport(ERROR,
- 					(errcode(ERRCODE_WRONG_OBJECT_TYPE),
- 					 errmsg("\"%s\" is a directory", cstate->filename)));
- 	}
- 
- 	tupDesc = RelationGetDescr(cstate->rel);
- 	attr = tupDesc->attrs;
- 	num_phys_attrs = tupDesc->natts;
- 	attr_count = list_length(cstate->attnumlist);
- 	num_defaults = 0;
- 
  	/*
  	 * We need a ResultRelInfo so we can use the regular executor's
  	 * index-entry-making machinery.  (There used to be a huge amount of code
--- 2211,2216 ----
*************** CopyFrom(CopyState cstate)
*** 1815,1865 ****
  	slot = ExecInitExtraTupleSlot(estate);
  	ExecSetSlotDescriptor(slot, tupDesc);
  
- 	econtext = GetPerTupleExprContext(estate);
- 
- 	/*
- 	 * Pick up the required catalog information for each attribute in the
- 	 * relation, including the input function, the element type (to pass to
- 	 * the input function), and info about defaults and constraints. (Which
- 	 * input function we use depends on text/binary format choice.)
- 	 */
- 	in_functions = (FmgrInfo *) palloc(num_phys_attrs * sizeof(FmgrInfo));
- 	typioparams = (Oid *) palloc(num_phys_attrs * sizeof(Oid));
- 	defmap = (int *) palloc(num_phys_attrs * sizeof(int));
- 	defexprs = (ExprState **) palloc(num_phys_attrs * sizeof(ExprState *));
- 
- 	for (attnum = 1; attnum <= num_phys_attrs; attnum++)
- 	{
- 		/* We don't need info for dropped attributes */
- 		if (attr[attnum - 1]->attisdropped)
- 			continue;
- 
- 		/* Fetch the input function and typioparam info */
- 		if (cstate->binary)
- 			getTypeBinaryInputInfo(attr[attnum - 1]->atttypid,
- 								   &in_func_oid, &typioparams[attnum - 1]);
- 		else
- 			getTypeInputInfo(attr[attnum - 1]->atttypid,
- 							 &in_func_oid, &typioparams[attnum - 1]);
- 		fmgr_info(in_func_oid, &in_functions[attnum - 1]);
- 
- 		/* Get default info if needed */
- 		if (!list_member_int(cstate->attnumlist, attnum))
- 		{
- 			/* attribute is NOT to be copied from input */
- 			/* use default value if one exists */
- 			Node	   *defexpr = build_column_default(cstate->rel, attnum);
- 
- 			if (defexpr != NULL)
- 			{
- 				defexprs[num_defaults] = ExecPrepareExpr((Expr *) defexpr,
- 														 estate);
- 				defmap[num_defaults] = attnum - 1;
- 				num_defaults++;
- 			}
- 		}
- 	}
- 
  	/* Prepare to catch AFTER triggers. */
  	AfterTriggerBeginQuery();
  
--- 2239,2244 ----
*************** CopyFrom(CopyState cstate)
*** 1871,1942 ****
  	 */
  	ExecBSInsertTriggers(estate, resultRelInfo);
  
! 	if (!cstate->binary)
! 		file_has_oids = cstate->oids;	/* must rely on user to tell us... */
! 	else
! 	{
! 		/* Read and verify binary header */
! 		char		readSig[11];
! 		int32		tmp;
! 
! 		/* Signature */
! 		if (CopyGetData(cstate, readSig, 11, 11) != 11 ||
! 			memcmp(readSig, BinarySignature, 11) != 0)
! 			ereport(ERROR,
! 					(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
! 					 errmsg("COPY file signature not recognized")));
! 		/* Flags field */
! 		if (!CopyGetInt32(cstate, &tmp))
! 			ereport(ERROR,
! 					(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
! 					 errmsg("invalid COPY file header (missing flags)")));
! 		file_has_oids = (tmp & (1 << 16)) != 0;
! 		tmp &= ~(1 << 16);
! 		if ((tmp >> 16) != 0)
! 			ereport(ERROR,
! 					(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
! 				 errmsg("unrecognized critical flags in COPY file header")));
! 		/* Header extension length */
! 		if (!CopyGetInt32(cstate, &tmp) ||
! 			tmp < 0)
! 			ereport(ERROR,
! 					(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
! 					 errmsg("invalid COPY file header (missing length)")));
! 		/* Skip extension header, if present */
! 		while (tmp-- > 0)
! 		{
! 			if (CopyGetData(cstate, readSig, 1, 1) != 1)
! 				ereport(ERROR,
! 						(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
! 						 errmsg("invalid COPY file header (wrong length)")));
! 		}
! 	}
! 
! 	if (file_has_oids && cstate->binary)
! 	{
! 		getTypeBinaryInputInfo(OIDOID,
! 							   &in_func_oid, &oid_typioparam);
! 		fmgr_info(in_func_oid, &oid_in_function);
! 	}
! 
! 	values = (Datum *) palloc(num_phys_attrs * sizeof(Datum));
! 	nulls = (bool *) palloc(num_phys_attrs * sizeof(bool));
! 
! 	/* create workspace for CopyReadAttributes results */
! 	nfields = file_has_oids ? (attr_count + 1) : attr_count;
! 	if (! cstate->binary)
! 	{
! 		cstate->max_fields = nfields;
! 		cstate->raw_fields = (char **) palloc(nfields * sizeof(char *));
! 	}
! 
! 	/* Initialize state variables */
! 	cstate->fe_eof = false;
! 	cstate->eol_type = EOL_UNKNOWN;
! 	cstate->cur_relname = RelationGetRelationName(cstate->rel);
! 	cstate->cur_lineno = 0;
! 	cstate->cur_attname = NULL;
! 	cstate->cur_attval = NULL;
  
  	bistate = GetBulkInsertState();
  
--- 2250,2257 ----
  	 */
  	ExecBSInsertTriggers(estate, resultRelInfo);
  
! 	values = (Datum *) palloc(tupDesc->natts * sizeof(Datum));
! 	nulls = (bool *) palloc(tupDesc->natts * sizeof(bool));
  
  	bistate = GetBulkInsertState();
  
*************** CopyFrom(CopyState cstate)
*** 1946,1958 ****
  	errcontext.previous = error_context_stack;
  	error_context_stack = &errcontext;
  
- 	/* on input just throw the header line away */
- 	if (cstate->header_line)
- 	{
- 		cstate->cur_lineno++;
- 		done = CopyReadLine(cstate);
- 	}
- 
  	while (!done)
  	{
  		bool		skip_tuple;
--- 2261,2266 ----
*************** CopyFrom(CopyState cstate)
*** 1960,2166 ****
  
  		CHECK_FOR_INTERRUPTS();
  
- 		cstate->cur_lineno++;
- 
  		/* Reset the per-tuple exprcontext */
  		ResetPerTupleExprContext(estate);
  
  		/* Switch into its memory context */
  		MemoryContextSwitchTo(GetPerTupleMemoryContext(estate));
  
! 		/* Initialize all values for row to NULL */
! 		MemSet(values, 0, num_phys_attrs * sizeof(Datum));
! 		MemSet(nulls, true, num_phys_attrs * sizeof(bool));
! 
! 		if (!cstate->binary)
! 		{
! 			ListCell   *cur;
! 			int			fldct;
! 			int			fieldno;
! 			char	   *string;
! 
! 			/* Actually read the line into memory here */
! 			done = CopyReadLine(cstate);
! 
! 			/*
! 			 * EOF at start of line means we're done.  If we see EOF after
! 			 * some characters, we act as though it was newline followed by
! 			 * EOF, ie, process the line and then exit loop on next iteration.
! 			 */
! 			if (done && cstate->line_buf.len == 0)
! 				break;
! 
! 			/* Parse the line into de-escaped field values */
! 			if (cstate->csv_mode)
! 				fldct = CopyReadAttributesCSV(cstate);
! 			else
! 				fldct = CopyReadAttributesText(cstate);
! 
! 			/* check for overflowing fields */
! 			if (nfields > 0 && fldct > nfields)
! 				ereport(ERROR,
! 						(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
! 						 errmsg("extra data after last expected column")));
! 
! 			fieldno = 0;
! 			field_strings = cstate->raw_fields;
! 
! 			/* Read the OID field if present */
! 			if (file_has_oids)
! 			{
! 				if (fieldno >= fldct)
! 					ereport(ERROR,
! 							(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
! 							 errmsg("missing data for OID column")));
! 				string = field_strings[fieldno++];
! 
! 				if (string == NULL)
! 					ereport(ERROR,
! 							(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
! 							 errmsg("null OID in COPY data")));
! 				else
! 				{
! 					cstate->cur_attname = "oid";
! 					cstate->cur_attval = string;
! 					loaded_oid = DatumGetObjectId(DirectFunctionCall1(oidin,
! 												   CStringGetDatum(string)));
! 					if (loaded_oid == InvalidOid)
! 						ereport(ERROR,
! 								(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
! 								 errmsg("invalid OID in COPY data")));
! 					cstate->cur_attname = NULL;
! 					cstate->cur_attval = NULL;
! 				}
! 			}
! 
! 			/* Loop to read the user attributes on the line. */
! 			foreach(cur, cstate->attnumlist)
! 			{
! 				int			attnum = lfirst_int(cur);
! 				int			m = attnum - 1;
! 
! 				if (fieldno >= fldct)
! 					ereport(ERROR,
! 							(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
! 							 errmsg("missing data for column \"%s\"",
! 									NameStr(attr[m]->attname))));
! 				string = field_strings[fieldno++];
! 
! 				if (cstate->csv_mode && string == NULL &&
! 					cstate->force_notnull_flags[m])
! 				{
! 					/* Go ahead and read the NULL string */
! 					string = cstate->null_print;
! 				}
! 
! 				cstate->cur_attname = NameStr(attr[m]->attname);
! 				cstate->cur_attval = string;
! 				values[m] = InputFunctionCall(&in_functions[m],
! 											  string,
! 											  typioparams[m],
! 											  attr[m]->atttypmod);
! 				if (string != NULL)
! 					nulls[m] = false;
! 				cstate->cur_attname = NULL;
! 				cstate->cur_attval = NULL;
! 			}
! 
! 			Assert(fieldno == nfields);
! 		}
! 		else
! 		{
! 			/* binary */
! 			int16		fld_count;
! 			ListCell   *cur;
! 
! 			if (!CopyGetInt16(cstate, &fld_count))
! 			{
! 				/* EOF detected (end of file, or protocol-level EOF) */
! 				done = true;
! 				break;
! 			}
! 
! 			if (fld_count == -1)
! 			{
! 				/*
! 				 * Received EOF marker.  In a V3-protocol copy, wait for
! 				 * the protocol-level EOF, and complain if it doesn't come
! 				 * immediately.  This ensures that we correctly handle
! 				 * CopyFail, if client chooses to send that now.
! 				 *
! 				 * Note that we MUST NOT try to read more data in an
! 				 * old-protocol copy, since there is no protocol-level EOF
! 				 * marker then.  We could go either way for copy from file,
! 				 * but choose to throw error if there's data after the EOF
! 				 * marker, for consistency with the new-protocol case.
! 				 */
! 				char	dummy;
! 
! 				if (cstate->copy_dest != COPY_OLD_FE &&
! 					CopyGetData(cstate, &dummy, 1, 1) > 0)
! 					ereport(ERROR,
! 							(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
! 							 errmsg("received copy data after EOF marker")));
! 				done = true;
! 				break;
! 			}
! 
! 			if (fld_count != attr_count)
! 				ereport(ERROR,
! 						(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
! 						 errmsg("row field count is %d, expected %d",
! 								(int) fld_count, attr_count)));
! 
! 			if (file_has_oids)
! 			{
! 				cstate->cur_attname = "oid";
! 				loaded_oid =
! 					DatumGetObjectId(CopyReadBinaryAttribute(cstate,
! 															 0,
! 															 &oid_in_function,
! 															 oid_typioparam,
! 															 -1,
! 															 &isnull));
! 				if (isnull || loaded_oid == InvalidOid)
! 					ereport(ERROR,
! 							(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
! 							 errmsg("invalid OID in COPY data")));
! 				cstate->cur_attname = NULL;
! 			}
! 
! 			i = 0;
! 			foreach(cur, cstate->attnumlist)
! 			{
! 				int			attnum = lfirst_int(cur);
! 				int			m = attnum - 1;
! 
! 				cstate->cur_attname = NameStr(attr[m]->attname);
! 				i++;
! 				values[m] = CopyReadBinaryAttribute(cstate,
! 													i,
! 													&in_functions[m],
! 													typioparams[m],
! 													attr[m]->atttypmod,
! 													&nulls[m]);
! 				cstate->cur_attname = NULL;
! 			}
! 		}
! 
! 		/*
! 		 * Now compute and insert any defaults available for the columns not
! 		 * provided by the input data.	Anything not processed here or above
! 		 * will remain NULL.
! 		 */
! 		for (i = 0; i < num_defaults; i++)
! 		{
! 			values[defmap[i]] = ExecEvalExpr(defexprs[i], econtext,
! 											 &nulls[defmap[i]], NULL);
! 		}
  
  		/* And now we can form the input tuple. */
  		tuple = heap_form_tuple(tupDesc, values, nulls);
  
! 		if (cstate->oids && file_has_oids)
  			HeapTupleSetOid(tuple, loaded_oid);
  
  		/* Triggers and stuff need to be invoked in query context. */
--- 2268,2287 ----
  
  		CHECK_FOR_INTERRUPTS();
  
  		/* Reset the per-tuple exprcontext */
  		ResetPerTupleExprContext(estate);
  
  		/* Switch into its memory context */
  		MemoryContextSwitchTo(GetPerTupleMemoryContext(estate));
  
! 		done = !NextCopyFrom(cstate, values, nulls, &loaded_oid);
! 		if (done)
! 			break;
  
  		/* And now we can form the input tuple. */
  		tuple = heap_form_tuple(tupDesc, values, nulls);
  
! 		if (cstate->oids && cstate->file_has_oids)
  			HeapTupleSetOid(tuple, loaded_oid);
  
  		/* Triggers and stuff need to be invoked in query context. */
*************** CopyFrom(CopyState cstate)
*** 2233,2261 ****
  
  	pfree(values);
  	pfree(nulls);
- 	if (! cstate->binary)
- 		pfree(cstate->raw_fields);
- 
- 	pfree(in_functions);
- 	pfree(typioparams);
- 	pfree(defmap);
- 	pfree(defexprs);
  
  	ExecResetTupleTable(estate->es_tupleTable, false);
  
  	ExecCloseIndices(resultRelInfo);
  
- 	FreeExecutorState(estate);
- 
- 	if (!pipe)
- 	{
- 		if (FreeFile(cstate->copy_file))
- 			ereport(ERROR,
- 					(errcode_for_file_access(),
- 					 errmsg("could not read from file \"%s\": %m",
- 							cstate->filename)));
- 	}
- 
  	/*
  	 * If we skipped writing WAL, then we need to sync the heap (but not
  	 * indexes since those use WAL anyway)
--- 2354,2364 ----
diff --git a/src/include/commands/copy.h b/src/include/commands/copy.h
index 6d409e8..4d9bd60 100644
*** a/src/include/commands/copy.h
--- b/src/include/commands/copy.h
***************
*** 18,25 ****
--- 18,32 ----
  #include "tcop/dest.h"
  
  
+ typedef struct CopyStateData  *CopyState;
+ 
  extern uint64 DoCopy(const CopyStmt *stmt, const char *queryString);
  
+ extern CopyState BeginCopyFrom(Relation rel,
+ 	const char *filename, List *attnamelist, List *options);
+ extern void EndCopyFrom(CopyState cstate);
+ extern bool NextCopyFrom(CopyState cstate, Datum *values, bool *nulls, Oid *oid);
+ 
  extern DestReceiver *CreateCopyDestReceiver(void);
  
  #endif   /* COPY_H */

diff --git a/src/backend/commands/copy.c b/src/backend/commands/copy.c
index 7b8bee8..57f6ec5 100644
*** a/src/backend/commands/copy.c
--- b/src/backend/commands/copy.c
*************** typedef struct CopyStateData
*** 99,105 ****
  	int			client_encoding;	/* remote side's character encoding */
  	bool		need_transcoding;		/* client encoding diff from server? */
  	bool		encoding_embeds_ascii;	/* ASCII can be non-first byte? */
- 	uint64		processed;		/* # of tuples processed */
  
  	/* parameters from the COPY command */
  	Relation	rel;			/* relation to copy to or from */
--- 99,104 ----
*************** typedef struct CopyStateData
*** 119,125 ****
  	bool	   *force_quote_flags;		/* per-column CSV FQ flags */
  	bool	   *force_notnull_flags;	/* per-column CSV FNN flags */
  
! 	/* these are just for error messages, see copy_in_error_callback */
  	const char *cur_relname;	/* table name for error messages */
  	int			cur_lineno;		/* line number for error messages */
  	const char *cur_attname;	/* current att for error messages */
--- 118,124 ----
  	bool	   *force_quote_flags;		/* per-column CSV FQ flags */
  	bool	   *force_notnull_flags;	/* per-column CSV FNN flags */
  
! 	/* these are just for error messages, see CopyFromErrorCallback */
  	const char *cur_relname;	/* table name for error messages */
  	int			cur_lineno;		/* line number for error messages */
  	const char *cur_attname;	/* current att for error messages */
*************** typedef struct CopyStateData
*** 142,150 ****
  	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
--- 141,148 ----
  	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
*************** typedef struct CopyStateData
*** 167,181 ****
  	char	   *raw_buf;
  	int			raw_buf_index;	/* next byte to process */
  	int			raw_buf_len;	/* total # of bytes stored */
- } CopyStateData;
  
! typedef CopyStateData *CopyState;
  
  /* DestReceiver for COPY (SELECT) TO */
  typedef struct
  {
  	DestReceiver pub;			/* publicly-known function pointers */
  	CopyState	cstate;			/* CopyStateData for the command */
  } DR_copy;
  
  
--- 165,192 ----
  	char	   *raw_buf;
  	int			raw_buf_index;	/* next byte to process */
  	int			raw_buf_len;	/* total # of bytes stored */
  
! 	/*
! 	 * The definition of input functions and default expressions are stored
! 	 * in these variables.
! 	 */
! 	EState	   *estate;
! 	AttrNumber	num_defaults;
! 	bool		file_has_oids;
! 	FmgrInfo	oid_in_function;
! 	Oid			oid_typioparam;
! 	FmgrInfo   *in_functions;
! 	Oid		   *typioparams;
! 	int		   *defmap;
! 	ExprState **defexprs;		/* array of default att expressions */
! } CopyStateData;
  
  /* DestReceiver for COPY (SELECT) TO */
  typedef struct
  {
  	DestReceiver pub;			/* publicly-known function pointers */
  	CopyState	cstate;			/* CopyStateData for the command */
+ 	uint64		processed;		/* # of tuples processed */
  } DR_copy;
  
  
*************** static const char BinarySignature[11] = 
*** 248,258 ****
  
  
  /* non-export function prototypes */
! static void DoCopyTo(CopyState cstate);
! static void CopyTo(CopyState cstate);
  static void CopyOneRowTo(CopyState cstate, Oid tupleOid,
  			 Datum *values, bool *nulls);
! static void CopyFrom(CopyState cstate);
  static bool CopyReadLine(CopyState cstate);
  static bool CopyReadLineText(CopyState cstate);
  static int CopyReadAttributesText(CopyState cstate);
--- 259,275 ----
  
  
  /* non-export function prototypes */
! static CopyState BeginCopy(bool is_from,
! 				Relation rel, Node *raw_query, const char *queryString,
! 				const char *filename, List *attnamelist, List *options);
! static CopyState BeginCopyTo(Relation rel, Node *query, const char *queryString,
! 				const char *filename, List *attnamelist, List *options);
! static void EndCopyTo(CopyState cstate);
! static uint64 DoCopyTo(CopyState cstate);
! static uint64 CopyTo(CopyState cstate);
  static void CopyOneRowTo(CopyState cstate, Oid tupleOid,
  			 Datum *values, bool *nulls);
! static uint64 CopyFrom(CopyState cstate, Relation rel);
  static bool CopyReadLine(CopyState cstate);
  static bool CopyReadLineText(CopyState cstate);
  static int CopyReadAttributesText(CopyState cstate);
*************** CopyLoadRawBuf(CopyState cstate)
*** 718,730 ****
   * Do not allow the copy if user doesn't have proper permission to access
   * the table or the specifically requested columns.
   */
! uint64
! DoCopy(const CopyStmt *stmt, const char *queryString)
  {
  	CopyState	cstate;
- 	bool		is_from = stmt->is_from;
- 	bool		pipe = (stmt->filename == NULL);
- 	List	   *attnamelist = stmt->attlist;
  	List	   *force_quote = NIL;
  	List	   *force_notnull = NIL;
  	bool		force_quote_all = false;
--- 735,746 ----
   * Do not allow the copy if user doesn't have proper permission to access
   * the table or the specifically requested columns.
   */
! static CopyState
! BeginCopy(bool is_from,
! 				Relation rel, Node *raw_query, const char *queryString,
! 				const char *filename, List *attnamelist, List *options)
  {
  	CopyState	cstate;
  	List	   *force_quote = NIL;
  	List	   *force_notnull = NIL;
  	bool		force_quote_all = false;
*************** DoCopy(const CopyStmt *stmt, const char 
*** 733,745 ****
  	ListCell   *option;
  	TupleDesc	tupDesc;
  	int			num_phys_attrs;
- 	uint64		processed;
  
  	/* Allocate workspace and zero all fields */
  	cstate = (CopyStateData *) palloc0(sizeof(CopyStateData));
  
  	/* Extract options from the statement node tree */
! 	foreach(option, stmt->options)
  	{
  		DefElem    *defel = (DefElem *) lfirst(option);
  
--- 749,760 ----
  	ListCell   *option;
  	TupleDesc	tupDesc;
  	int			num_phys_attrs;
  
  	/* Allocate workspace and zero all fields */
  	cstate = (CopyStateData *) palloc0(sizeof(CopyStateData));
  
  	/* Extract options from the statement node tree */
! 	foreach(option, options)
  	{
  		DefElem    *defel = (DefElem *) lfirst(option);
  
*************** DoCopy(const CopyStmt *stmt, const char 
*** 980,1005 ****
  				(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
  				 errmsg("CSV quote character must not appear in the NULL specification")));
  
! 	/* Disallow file COPY except to superusers. */
! 	if (!pipe && !superuser())
! 		ereport(ERROR,
! 				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
! 				 errmsg("must be superuser to COPY to or from a file"),
! 				 errhint("Anyone can COPY to stdout or from stdin. "
! 						 "psql's \\copy command also works for anyone.")));
! 
! 	if (stmt->relation)
  	{
  		RangeTblEntry  *rte;
  		List		   *attnums;
  		ListCell	   *cur;
  
! 		Assert(!stmt->query);
! 		cstate->queryDesc = NULL;
  
! 		/* Open and lock the relation, using the appropriate lock type. */
! 		cstate->rel = heap_openrv(stmt->relation,
! 							 (is_from ? RowExclusiveLock : AccessShareLock));
  
  		tupDesc = RelationGetDescr(cstate->rel);
  
--- 995,1009 ----
  				(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
  				 errmsg("CSV quote character must not appear in the NULL specification")));
  
! 	if (rel)
  	{
  		RangeTblEntry  *rte;
  		List		   *attnums;
  		ListCell	   *cur;
  
! 		Assert(!raw_query);
  
! 		cstate->rel = rel;
  
  		tupDesc = RelationGetDescr(cstate->rel);
  
*************** DoCopy(const CopyStmt *stmt, const char 
*** 1058,1064 ****
  		 * function and is executed repeatedly.  (See also the same hack in
  		 * DECLARE CURSOR and PREPARE.)  XXX FIXME someday.
  		 */
! 		rewritten = pg_analyze_and_rewrite((Node *) copyObject(stmt->query),
  										   queryString, NULL, 0);
  
  		/* We don't expect more or less than one result query */
--- 1062,1068 ----
  		 * function and is executed repeatedly.  (See also the same hack in
  		 * DECLARE CURSOR and PREPARE.)  XXX FIXME someday.
  		 */
! 		rewritten = pg_analyze_and_rewrite((Node *) copyObject(raw_query),
  										   queryString, NULL, 0);
  
  		/* We don't expect more or less than one result query */
*************** DoCopy(const CopyStmt *stmt, const char 
*** 1160,1173 ****
  		}
  	}
  
- 	/* Set up variables to avoid per-attribute overhead. */
- 	initStringInfo(&cstate->attribute_buf);
- 	initStringInfo(&cstate->line_buf);
- 	cstate->line_buf_converted = false;
- 	cstate->raw_buf = (char *) palloc(RAW_BUF_SIZE + 1);
- 	cstate->raw_buf_index = cstate->raw_buf_len = 0;
- 	cstate->processed = 0;
- 
  	/*
  	 * Set up encoding conversion info.  Even if the client and server
  	 * encodings are the same, we must apply pg_client_to_server() to validate
--- 1164,1169 ----
*************** DoCopy(const CopyStmt *stmt, const char 
*** 1181,1229 ****
  	cstate->encoding_embeds_ascii = PG_ENCODING_IS_CLIENT_ONLY(cstate->client_encoding);
  
  	cstate->copy_dest = COPY_FILE;		/* default */
! 	cstate->filename = stmt->filename;
  
! 	if (is_from)
! 		CopyFrom(cstate);		/* copy from file to database */
  	else
! 		DoCopyTo(cstate);		/* copy from database to file */
  
  	/*
! 	 * Close the relation or query.  If reading, we can release the
! 	 * AccessShareLock we got; if writing, we should hold the lock until end
! 	 * of transaction to ensure that updates will be committed before lock is
! 	 * released.
  	 */
! 	if (cstate->rel)
! 		heap_close(cstate->rel, (is_from ? NoLock : AccessShareLock));
  	else
  	{
! 		/* Close down the query and free resources. */
! 		ExecutorEnd(cstate->queryDesc);
! 		FreeQueryDesc(cstate->queryDesc);
! 		PopActiveSnapshot();
  	}
  
! 	/* Clean up storage (probably not really necessary) */
! 	processed = cstate->processed;
  
  	pfree(cstate->attribute_buf.data);
  	pfree(cstate->line_buf.data);
  	pfree(cstate->raw_buf);
  	pfree(cstate);
- 
- 	return processed;
  }
  
  
  /*
   * This intermediate routine exists mainly to localize the effects of setjmp
   * so we don't need to plaster a lot of variables with "volatile".
   */
! static void
  DoCopyTo(CopyState cstate)
  {
  	bool		pipe = (cstate->filename == NULL);
  
  	if (cstate->rel)
  	{
--- 1177,1722 ----
  	cstate->encoding_embeds_ascii = PG_ENCODING_IS_CLIENT_ONLY(cstate->client_encoding);
  
  	cstate->copy_dest = COPY_FILE;		/* default */
! 	cstate->filename = (filename ? pstrdup(filename) : NULL);
  
! 	return cstate;
! }
! 
! CopyState
! BeginCopyFrom(Relation rel,
! 			  const char *filename,
! 			  List *attnamelist,
! 			  List *options)
! {
! 	CopyState	cstate;
! 	bool		pipe = (filename == NULL);
! 	TupleDesc	tupDesc;
! 	Form_pg_attribute *attr;
! 	AttrNumber	num_phys_attrs,
! 				attr_count,
! 				num_defaults;
! 	FmgrInfo   *in_functions;
! 	Oid		   *typioparams;
! 	int			attnum;
! 	Oid			in_func_oid;
! 	EState	   *estate = CreateExecutorState(); /* for ExecPrepareExpr() */
! 	int		   *defmap;
! 	ExprState **defexprs;
! 
! 	cstate = BeginCopy(true, rel, NULL, NULL, filename, attnamelist, options);
! 
! 	/* Initialize state variables */
! 	cstate->fe_eof = false;
! 	cstate->eol_type = EOL_UNKNOWN;
! 	cstate->cur_relname = RelationGetRelationName(cstate->rel);
! 	cstate->cur_lineno = 0;
! 	cstate->cur_attname = NULL;
! 	cstate->cur_attval = NULL;
! 
! 	/* Set up variables to avoid per-attribute overhead. */
! 	initStringInfo(&cstate->attribute_buf);
! 	initStringInfo(&cstate->line_buf);
! 	cstate->line_buf_converted = false;
! 	cstate->raw_buf = (char *) palloc(RAW_BUF_SIZE + 1);
! 	cstate->raw_buf_index = cstate->raw_buf_len = 0;
! 
! 	tupDesc = RelationGetDescr(cstate->rel);
! 	attr = tupDesc->attrs;
! 	num_phys_attrs = tupDesc->natts;
! 	attr_count = list_length(cstate->attnumlist);
! 	num_defaults = 0;
! 
! 	/*
! 	 * Pick up the required catalog information for each attribute in the
! 	 * relation, including the input function, the element type (to pass to
! 	 * the input function), and info about defaults and constraints. (Which
! 	 * input function we use depends on text/binary format choice.)
! 	 */
! 	in_functions = (FmgrInfo *) palloc(num_phys_attrs * sizeof(FmgrInfo));
! 	typioparams = (Oid *) palloc(num_phys_attrs * sizeof(Oid));
! 	defmap = (int *) palloc(num_phys_attrs * sizeof(int));
! 	defexprs = (ExprState **) palloc(num_phys_attrs * sizeof(ExprState *));
! 
! 	for (attnum = 1; attnum <= num_phys_attrs; attnum++)
! 	{
! 		/* We don't need info for dropped attributes */
! 		if (attr[attnum - 1]->attisdropped)
! 			continue;
! 
! 		/* Fetch the input function and typioparam info */
! 		if (cstate->binary)
! 			getTypeBinaryInputInfo(attr[attnum - 1]->atttypid,
! 								   &in_func_oid, &typioparams[attnum - 1]);
! 		else
! 			getTypeInputInfo(attr[attnum - 1]->atttypid,
! 							 &in_func_oid, &typioparams[attnum - 1]);
! 		fmgr_info(in_func_oid, &in_functions[attnum - 1]);
! 
! 		/* Get default info if needed */
! 		if (!list_member_int(cstate->attnumlist, attnum))
! 		{
! 			/* attribute is NOT to be copied from input */
! 			/* use default value if one exists */
! 			Node	   *defexpr = build_column_default(cstate->rel, attnum);
! 
! 			if (defexpr != NULL)
! 			{
! 				defexprs[num_defaults] = ExecPrepareExpr((Expr *) defexpr,
! 														 estate);
! 				defmap[num_defaults] = attnum - 1;
! 				num_defaults++;
! 			}
! 		}
! 	}
! 
! 	/* We keep those variables in cstate. */
! 	cstate->estate = estate;
! 	cstate->in_functions = in_functions;
! 	cstate->typioparams = typioparams;
! 	cstate->defmap = defmap;
! 	cstate->defexprs = defexprs;
! 	cstate->num_defaults = num_defaults;
! 
! 	if (pipe)
! 	{
! 		if (whereToSendOutput == DestRemote)
! 			ReceiveCopyBegin(cstate);
! 		else
! 			cstate->copy_file = stdin;
! 	}
  	else
! 	{
! 		struct stat st;
! 
! 		cstate->copy_file = AllocateFile(cstate->filename, PG_BINARY_R);
! 
! 		if (cstate->copy_file == NULL)
! 			ereport(ERROR,
! 					(errcode_for_file_access(),
! 					 errmsg("could not open file \"%s\" for reading: %m",
! 							cstate->filename)));
! 
! 		fstat(fileno(cstate->copy_file), &st);
! 		if (S_ISDIR(st.st_mode))
! 			ereport(ERROR,
! 					(errcode(ERRCODE_WRONG_OBJECT_TYPE),
! 					 errmsg("\"%s\" is a directory", cstate->filename)));
! 	}
! 
! 	if (!cstate->binary)
! 	{
! 		/* must rely on user to tell us... */
! 		cstate->file_has_oids = cstate->oids;
! 	}
! 	else
! 	{
! 		/* Read and verify binary header */
! 		char		readSig[11];
! 		int32		tmp;
! 
! 		/* Signature */
! 		if (CopyGetData(cstate, readSig, 11, 11) != 11 ||
! 			memcmp(readSig, BinarySignature, 11) != 0)
! 			ereport(ERROR,
! 					(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
! 					 errmsg("COPY file signature not recognized")));
! 		/* Flags field */
! 		if (!CopyGetInt32(cstate, &tmp))
! 			ereport(ERROR,
! 					(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
! 					 errmsg("invalid COPY file header (missing flags)")));
! 		cstate->file_has_oids = (tmp & (1 << 16)) != 0;
! 		tmp &= ~(1 << 16);
! 		if ((tmp >> 16) != 0)
! 			ereport(ERROR,
! 					(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
! 				 errmsg("unrecognized critical flags in COPY file header")));
! 		/* Header extension length */
! 		if (!CopyGetInt32(cstate, &tmp) ||
! 			tmp < 0)
! 			ereport(ERROR,
! 					(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
! 					 errmsg("invalid COPY file header (missing length)")));
! 		/* Skip extension header, if present */
! 		while (tmp-- > 0)
! 		{
! 			if (CopyGetData(cstate, readSig, 1, 1) != 1)
! 				ereport(ERROR,
! 						(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
! 						 errmsg("invalid COPY file header (wrong length)")));
! 		}
! 	}
! 
! 	if (cstate->file_has_oids && cstate->binary)
! 	{
! 		getTypeBinaryInputInfo(OIDOID,
! 							   &in_func_oid, &cstate->oid_typioparam);
! 		fmgr_info(in_func_oid, &cstate->oid_in_function);
! 	}
! 
! 	/* create workspace for CopyReadAttributes results */
! 	if (!cstate->binary)
! 	{
! 		int	nfields = cstate->file_has_oids ? (attr_count + 1) : attr_count;
! 
! 		cstate->max_fields = nfields;
! 		cstate->raw_fields = (char **) palloc(nfields * sizeof(char *));
! 	}
! 
! 	return cstate;
! }
! 
! static CopyState
! BeginCopyTo(Relation rel,
! 			Node *query,
! 			const char *queryString,
! 			const char *filename,
! 			List *attnamelist,
! 			List *options)
! {
! 	return BeginCopy(false, rel, query, queryString,
! 					 filename, attnamelist, options);
! }
! 
! /* return false if no more tuples */
! bool
! NextCopyFrom(CopyState cstate, Datum *values, bool *nulls, Oid *tupleOid)
! {
! 	TupleDesc	tupDesc;
! 	Form_pg_attribute *attr;
! 	AttrNumber	num_phys_attrs,
! 				attr_count,
! 				num_defaults = cstate->num_defaults;
! 	FmgrInfo   *in_functions = cstate->in_functions;
! 	Oid		   *typioparams = cstate->typioparams;
! 	int			i;
! 	int			nfields;
! 	char	  **field_strings;
! 	bool		isnull;
! 	int		   *defmap = cstate->defmap;
! 	ExprState **defexprs = cstate->defexprs;
! 	ExprContext	*econtext;		/* used for ExecEvalExpr for default atts */
! 
! 	/* on input just throw the header line away */
! 	if (cstate->cur_lineno == 0 && cstate->header_line)
! 	{
! 		cstate->cur_lineno++;
! 		if (CopyReadLine(cstate))
! 			return false;	/* done */
! 	}
! 
! 	cstate->cur_lineno++;
! 
! 	tupDesc = RelationGetDescr(cstate->rel);
! 	attr = tupDesc->attrs;
! 	num_phys_attrs = tupDesc->natts;
! 	attr_count = list_length(cstate->attnumlist);
! 	nfields = cstate->file_has_oids ? (attr_count + 1) : attr_count;
! 
! 	/* Initialize all values for row to NULL */
! 	MemSet(values, 0, num_phys_attrs * sizeof(Datum));
! 	MemSet(nulls, true, num_phys_attrs * sizeof(bool));
! 
! 	if (!cstate->binary)
! 	{
! 		ListCell   *cur;
! 		int			fldct;
! 		int			fieldno;
! 		char	   *string;
! 
! 		/*
! 		 * Actually read the line into memory here.
! 		 * EOF at start of line means we're done.  If we see EOF after
! 		 * some characters, we act as though it was newline followed by
! 		 * EOF, ie, process the line and then exit loop on next iteration.
! 		 */
! 		if (CopyReadLine(cstate) && cstate->line_buf.len == 0)
! 			return false;
! 
! 		/* Parse the line into de-escaped field values */
! 		if (cstate->csv_mode)
! 			fldct = CopyReadAttributesCSV(cstate);
! 		else
! 			fldct = CopyReadAttributesText(cstate);
! 
! 		/* check for overflowing fields */
! 		if (nfields > 0 && fldct > nfields)
! 			ereport(ERROR,
! 					(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
! 						errmsg("extra data after last expected column")));
! 
! 		fieldno = 0;
! 		field_strings = cstate->raw_fields;
! 
! 		/* Read the OID field if present */
! 		if (cstate->file_has_oids)
! 		{
! 			if (fieldno >= fldct)
! 				ereport(ERROR,
! 						(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
! 							errmsg("missing data for OID column")));
! 			string = field_strings[fieldno++];
! 
! 			if (string == NULL)
! 				ereport(ERROR,
! 						(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
! 							errmsg("null OID in COPY data")));
! 			else if (cstate->oids && tupleOid != NULL)
! 			{
! 				cstate->cur_attname = "oid";
! 				cstate->cur_attval = string;
! 				*tupleOid = DatumGetObjectId(DirectFunctionCall1(oidin,
! 												   CStringGetDatum(string)));
! 				if (*tupleOid == InvalidOid)
! 					ereport(ERROR,
! 							(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
! 								errmsg("invalid OID in COPY data")));
! 				cstate->cur_attname = NULL;
! 				cstate->cur_attval = NULL;
! 			}
! 		}
! 
! 		/* Loop to read the user attributes on the line. */
! 		foreach(cur, cstate->attnumlist)
! 		{
! 			int			attnum = lfirst_int(cur);
! 			int			m = attnum - 1;
! 
! 			if (fieldno >= fldct)
! 				ereport(ERROR,
! 						(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
! 							errmsg("missing data for column \"%s\"",
! 								NameStr(attr[m]->attname))));
! 			string = field_strings[fieldno++];
! 
! 			if (cstate->csv_mode && string == NULL &&
! 				cstate->force_notnull_flags[m])
! 			{
! 				/* Go ahead and read the NULL string */
! 				string = cstate->null_print;
! 			}
! 
! 			cstate->cur_attname = NameStr(attr[m]->attname);
! 			cstate->cur_attval = string;
! 			values[m] = InputFunctionCall(&in_functions[m],
! 										  string,
! 										  typioparams[m],
! 										  attr[m]->atttypmod);
! 			if (string != NULL)
! 				nulls[m] = false;
! 			cstate->cur_attname = NULL;
! 			cstate->cur_attval = NULL;
! 		}
! 
! 		Assert(fieldno == nfields);
! 	}
! 	else
! 	{
! 		/* binary */
! 		int16		fld_count;
! 		ListCell   *cur;
! 
! 		if (!CopyGetInt16(cstate, &fld_count))
! 		{
! 			/* EOF detected (end of file, or protocol-level EOF) */
! 			return false;
! 		}
! 
! 		if (fld_count == -1)
! 		{
! 			/*
! 			 * Received EOF marker.  In a V3-protocol copy, wait for
! 			 * the protocol-level EOF, and complain if it doesn't come
! 			 * immediately.  This ensures that we correctly handle
! 			 * CopyFail, if client chooses to send that now.
! 			 *
! 			 * Note that we MUST NOT try to read more data in an
! 			 * old-protocol copy, since there is no protocol-level EOF
! 			 * marker then.  We could go either way for copy from file,
! 			 * but choose to throw error if there's data after the EOF
! 			 * marker, for consistency with the new-protocol case.
! 			 */
! 			char	dummy;
! 
! 			if (cstate->copy_dest != COPY_OLD_FE &&
! 				CopyGetData(cstate, &dummy, 1, 1) > 0)
! 				ereport(ERROR,
! 						(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
! 							errmsg("received copy data after EOF marker")));
! 			return false;
! 		}
! 
! 		if (fld_count != attr_count)
! 			ereport(ERROR,
! 					(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
! 						errmsg("row field count is %d, expected %d",
! 							(int) fld_count, attr_count)));
! 
! 		if (cstate->file_has_oids)
! 		{
! 			Oid		oid;
! 
! 			cstate->cur_attname = "oid";
! 			oid = DatumGetObjectId(CopyReadBinaryAttribute(cstate,
! 														   0,
! 														   &cstate->oid_in_function,
! 														   cstate->oid_typioparam,
! 														   -1,
! 														   &isnull));
! 			if (isnull || oid == InvalidOid)
! 				ereport(ERROR,
! 						(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
! 							errmsg("invalid OID in COPY data")));
! 			cstate->cur_attname = NULL;
! 			if (cstate->oids && tupleOid != NULL)
! 				*tupleOid = oid;
! 		}
! 
! 		i = 0;
! 		foreach(cur, cstate->attnumlist)
! 		{
! 			int			attnum = lfirst_int(cur);
! 			int			m = attnum - 1;
! 
! 			cstate->cur_attname = NameStr(attr[m]->attname);
! 			i++;
! 			values[m] = CopyReadBinaryAttribute(cstate,
! 												i,
! 												&in_functions[m],
! 												typioparams[m],
! 												attr[m]->atttypmod,
! 												&nulls[m]);
! 			cstate->cur_attname = NULL;
! 		}
! 	}
  
  	/*
! 	 * Now compute and insert any defaults available for the columns not
! 	 * provided by the input data.	Anything not processed here or above
! 	 * will remain NULL.
  	 */
! 	econtext = GetPerTupleExprContext(cstate->estate);
! 	for (i = 0; i < num_defaults; i++)
! 	{
! 		values[defmap[i]] = ExecEvalExpr(defexprs[i], econtext,
! 										 &nulls[defmap[i]], NULL);
! 	}
! 
! 	return true;
! }
! 
! uint64
! DoCopy(const CopyStmt *stmt, const char *queryString)
! {
! 	CopyState	cstate;
! 	bool		is_from = stmt->is_from;
! 	bool		pipe = (stmt->filename == NULL);
! 	Relation	rel;
! 	uint64		processed;
! 
! 	/* Disallow file COPY except to superusers. */
! 	if (!pipe && !superuser())
! 		ereport(ERROR,
! 				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
! 				 errmsg("must be superuser to COPY to or from a file"),
! 				 errhint("Anyone can COPY to stdout or from stdin. "
! 						 "psql's \\copy command also works for anyone.")));
! 
! 	if (stmt->relation)
! 	{
! 		Assert(!stmt->query);
! 
! 		/* Open and lock the relation, using the appropriate lock type. */
! 		rel = heap_openrv(stmt->relation,
! 							 (is_from ? RowExclusiveLock : AccessShareLock));
! 	}
  	else
  	{
! 		Assert(stmt->query);
! 
! 		rel = NULL;
  	}
  
! 	if (is_from)
! 	{
! 		cstate = BeginCopyFrom(rel, stmt->filename, stmt->attlist, stmt->options);
! 		processed = CopyFrom(cstate, rel);	/* copy from file to database */
! 		EndCopyFrom(cstate);
! 	}
! 	else
! 	{
! 		cstate = BeginCopyTo(rel, stmt->query, queryString, stmt->filename, stmt->attlist, stmt->options);
! 		processed = DoCopyTo(cstate);		/* copy from database to file */
! 		EndCopyTo(cstate);
! 	}
  
+ 	/*
+ 	 * Close the relation. If reading, we can release the AccessShareLock we got;
+ 	 * if writing, we should hold the lock until end of transaction to ensure that
+ 	 * updates will be committed before lock is released.
+ 	 */
+ 	if (rel != NULL)
+ 		heap_close(rel, (is_from ? NoLock : AccessShareLock));
+ 
+ 	return processed;
+ }
+ 
+ void
+ EndCopyFrom(CopyState cstate)
+ {
+ 	FreeExecutorState(cstate->estate);
+ 
+ 	/* Clean up storage */
+ 	if (cstate->filename)
+ 	{
+ 		if (FreeFile(cstate->copy_file))
+ 			ereport(ERROR,
+ 					(errcode_for_file_access(),
+ 					 errmsg("could not read from file \"%s\": %m",
+ 							cstate->filename)));
+ 		pfree(cstate->filename);
+ 	}
+ 	if (!cstate->binary)
+ 		pfree(cstate->raw_fields);
  	pfree(cstate->attribute_buf.data);
  	pfree(cstate->line_buf.data);
  	pfree(cstate->raw_buf);
+ 	pfree(cstate->in_functions);
+ 	pfree(cstate->typioparams);
+ 	pfree(cstate->defmap);
+ 	pfree(cstate->defexprs);
  	pfree(cstate);
  }
  
+ static void
+ EndCopyTo(CopyState cstate)
+ {
+ 	/*
+ 	 * Close the relation or query. We can release the AccessShareLock we got.
+ 	 */
+ 	if (cstate->rel == NULL)
+ 	{
+ 		/* Close down the query and free resources. */
+ 		ExecutorEnd(cstate->queryDesc);
+ 		FreeQueryDesc(cstate->queryDesc);
+ 		PopActiveSnapshot();
+ 	}
+ 
+ 	/* Clean up storage */
+ 	if (cstate->filename)
+ 		pfree(cstate->filename);
+ 	pfree(cstate);
+ }
  
  /*
   * This intermediate routine exists mainly to localize the effects of setjmp
   * so we don't need to plaster a lot of variables with "volatile".
   */
! static uint64
  DoCopyTo(CopyState cstate)
  {
  	bool		pipe = (cstate->filename == NULL);
+ 	uint64		processed;
  
  	if (cstate->rel)
  	{
*************** DoCopyTo(CopyState cstate)
*** 1291,1297 ****
  		if (cstate->fe_copy)
  			SendCopyBegin(cstate);
  
! 		CopyTo(cstate);
  
  		if (cstate->fe_copy)
  			SendCopyEnd(cstate);
--- 1784,1790 ----
  		if (cstate->fe_copy)
  			SendCopyBegin(cstate);
  
! 		processed = CopyTo(cstate);
  
  		if (cstate->fe_copy)
  			SendCopyEnd(cstate);
*************** DoCopyTo(CopyState cstate)
*** 1316,1333 ****
  					 errmsg("could not write to file \"%s\": %m",
  							cstate->filename)));
  	}
  }
  
  /*
   * Copy from relation or query TO file.
   */
! static void
  CopyTo(CopyState cstate)
  {
  	TupleDesc	tupDesc;
  	int			num_phys_attrs;
  	Form_pg_attribute *attr;
  	ListCell   *cur;
  
  	if (cstate->rel)
  		tupDesc = RelationGetDescr(cstate->rel);
--- 1809,1829 ----
  					 errmsg("could not write to file \"%s\": %m",
  							cstate->filename)));
  	}
+ 
+ 	return processed;
  }
  
  /*
   * Copy from relation or query TO file.
   */
! static uint64
  CopyTo(CopyState cstate)
  {
  	TupleDesc	tupDesc;
  	int			num_phys_attrs;
  	Form_pg_attribute *attr;
  	ListCell   *cur;
+ 	uint64		processed;
  
  	if (cstate->rel)
  		tupDesc = RelationGetDescr(cstate->rel);
*************** CopyTo(CopyState cstate)
*** 1433,1438 ****
--- 1929,1935 ----
  
  		scandesc = heap_beginscan(cstate->rel, GetActiveSnapshot(), 0, NULL);
  
+ 		processed = 0;
  		while ((tuple = heap_getnext(scandesc, ForwardScanDirection)) != NULL)
  		{
  			CHECK_FOR_INTERRUPTS();
*************** CopyTo(CopyState cstate)
*** 1442,1447 ****
--- 1939,1945 ----
  
  			/* Format and send the data */
  			CopyOneRowTo(cstate, HeapTupleGetOid(tuple), values, nulls);
+ 			processed++;
  		}
  
  		heap_endscan(scandesc);
*************** CopyTo(CopyState cstate)
*** 1450,1455 ****
--- 1948,1954 ----
  	{
  		/* run the plan --- the dest receiver will send tuples */
  		ExecutorRun(cstate->queryDesc, ForwardScanDirection, 0L);
+ 		processed = ((DR_copy *) cstate->queryDesc->dest)->processed;
  	}
  
  	if (cstate->binary)
*************** CopyTo(CopyState cstate)
*** 1461,1466 ****
--- 1960,1967 ----
  	}
  
  	MemoryContextDelete(cstate->rowcontext);
+ 
+ 	return processed;
  }
  
  /*
*************** CopyOneRowTo(CopyState cstate, Oid tuple
*** 1552,1567 ****
  	CopySendEndOfRow(cstate);
  
  	MemoryContextSwitchTo(oldcontext);
- 
- 	cstate->processed++;
  }
  
  
  /*
   * error context callback for COPY FROM
   */
! static void
! copy_in_error_callback(void *arg)
  {
  	CopyState	cstate = (CopyState) arg;
  
--- 2053,2066 ----
  	CopySendEndOfRow(cstate);
  
  	MemoryContextSwitchTo(oldcontext);
  }
  
  
  /*
   * error context callback for COPY FROM
   */
! void
! CopyFromErrorCallback(void *arg)
  {
  	CopyState	cstate = (CopyState) arg;
  
*************** limit_printout_length(const char *str)
*** 1663,1725 ****
  /*
   * Copy FROM file to relation.
   */
! static void
! CopyFrom(CopyState cstate)
  {
- 	bool		pipe = (cstate->filename == NULL);
  	HeapTuple	tuple;
  	TupleDesc	tupDesc;
- 	Form_pg_attribute *attr;
- 	AttrNumber	num_phys_attrs,
- 				attr_count,
- 				num_defaults;
- 	FmgrInfo   *in_functions;
- 	FmgrInfo	oid_in_function;
- 	Oid		   *typioparams;
- 	Oid			oid_typioparam;
- 	int			attnum;
- 	int			i;
- 	Oid			in_func_oid;
  	Datum	   *values;
  	bool	   *nulls;
- 	int			nfields;
- 	char	  **field_strings;
  	bool		done = false;
- 	bool		isnull;
  	ResultRelInfo *resultRelInfo;
! 	EState	   *estate = CreateExecutorState(); /* for ExecConstraints() */
  	TupleTableSlot *slot;
- 	bool		file_has_oids;
- 	int		   *defmap;
- 	ExprState **defexprs;		/* array of default att expressions */
- 	ExprContext *econtext;		/* used for ExecEvalExpr for default atts */
  	MemoryContext oldcontext = CurrentMemoryContext;
  	ErrorContextCallback errcontext;
  	CommandId	mycid = GetCurrentCommandId(true);
  	int			hi_options = 0; /* start with default heap_insert options */
  	BulkInsertState bistate;
  
! 	Assert(cstate->rel);
  
! 	if (cstate->rel->rd_rel->relkind != RELKIND_RELATION)
  	{
! 		if (cstate->rel->rd_rel->relkind == RELKIND_VIEW)
  			ereport(ERROR,
  					(errcode(ERRCODE_WRONG_OBJECT_TYPE),
  					 errmsg("cannot copy to view \"%s\"",
! 							RelationGetRelationName(cstate->rel))));
! 		else if (cstate->rel->rd_rel->relkind == RELKIND_SEQUENCE)
  			ereport(ERROR,
  					(errcode(ERRCODE_WRONG_OBJECT_TYPE),
  					 errmsg("cannot copy to sequence \"%s\"",
! 							RelationGetRelationName(cstate->rel))));
  		else
  			ereport(ERROR,
  					(errcode(ERRCODE_WRONG_OBJECT_TYPE),
  					 errmsg("cannot copy to non-table relation \"%s\"",
! 							RelationGetRelationName(cstate->rel))));
  	}
  
  	/*----------
  	 * Check to see if we can avoid writing WAL
  	 *
--- 2162,2209 ----
  /*
   * Copy FROM file to relation.
   */
! static uint64
! CopyFrom(CopyState cstate, Relation rel)
  {
  	HeapTuple	tuple;
  	TupleDesc	tupDesc;
  	Datum	   *values;
  	bool	   *nulls;
  	bool		done = false;
  	ResultRelInfo *resultRelInfo;
! 	EState	   *estate; /* for ExecConstraints() */
  	TupleTableSlot *slot;
  	MemoryContext oldcontext = CurrentMemoryContext;
  	ErrorContextCallback errcontext;
  	CommandId	mycid = GetCurrentCommandId(true);
  	int			hi_options = 0; /* start with default heap_insert options */
  	BulkInsertState bistate;
+ 	uint64		processed = 0;
  
! 	Assert(rel != NULL);
  
! 	if (rel->rd_rel->relkind != RELKIND_RELATION)
  	{
! 		if (rel->rd_rel->relkind == RELKIND_VIEW)
  			ereport(ERROR,
  					(errcode(ERRCODE_WRONG_OBJECT_TYPE),
  					 errmsg("cannot copy to view \"%s\"",
! 							RelationGetRelationName(rel))));
! 		else if (rel->rd_rel->relkind == RELKIND_SEQUENCE)
  			ereport(ERROR,
  					(errcode(ERRCODE_WRONG_OBJECT_TYPE),
  					 errmsg("cannot copy to sequence \"%s\"",
! 							RelationGetRelationName(rel))));
  		else
  			ereport(ERROR,
  					(errcode(ERRCODE_WRONG_OBJECT_TYPE),
  					 errmsg("cannot copy to non-table relation \"%s\"",
! 							RelationGetRelationName(rel))));
  	}
  
+ 	estate = GetCopyExecutorState(cstate);
+ 	tupDesc = RelationGetDescr(rel);
+ 
  	/*----------
  	 * Check to see if we can avoid writing WAL
  	 *
*************** CopyFrom(CopyState cstate)
*** 1747,1792 ****
  	 * no additional work to enforce that.
  	 *----------
  	 */
! 	if (cstate->rel->rd_createSubid != InvalidSubTransactionId ||
! 		cstate->rel->rd_newRelfilenodeSubid != InvalidSubTransactionId)
  	{
  		hi_options |= HEAP_INSERT_SKIP_FSM;
  		if (!XLogIsNeeded())
  			hi_options |= HEAP_INSERT_SKIP_WAL;
  	}
  
- 	if (pipe)
- 	{
- 		if (whereToSendOutput == DestRemote)
- 			ReceiveCopyBegin(cstate);
- 		else
- 			cstate->copy_file = stdin;
- 	}
- 	else
- 	{
- 		struct stat st;
- 
- 		cstate->copy_file = AllocateFile(cstate->filename, PG_BINARY_R);
- 
- 		if (cstate->copy_file == NULL)
- 			ereport(ERROR,
- 					(errcode_for_file_access(),
- 					 errmsg("could not open file \"%s\" for reading: %m",
- 							cstate->filename)));
- 
- 		fstat(fileno(cstate->copy_file), &st);
- 		if (S_ISDIR(st.st_mode))
- 			ereport(ERROR,
- 					(errcode(ERRCODE_WRONG_OBJECT_TYPE),
- 					 errmsg("\"%s\" is a directory", cstate->filename)));
- 	}
- 
- 	tupDesc = RelationGetDescr(cstate->rel);
- 	attr = tupDesc->attrs;
- 	num_phys_attrs = tupDesc->natts;
- 	attr_count = list_length(cstate->attnumlist);
- 	num_defaults = 0;
- 
  	/*
  	 * We need a ResultRelInfo so we can use the regular executor's
  	 * index-entry-making machinery.  (There used to be a huge amount of code
--- 2231,2244 ----
  	 * no additional work to enforce that.
  	 *----------
  	 */
! 	if (rel->rd_createSubid != InvalidSubTransactionId ||
! 		rel->rd_newRelfilenodeSubid != InvalidSubTransactionId)
  	{
  		hi_options |= HEAP_INSERT_SKIP_FSM;
  		if (!XLogIsNeeded())
  			hi_options |= HEAP_INSERT_SKIP_WAL;
  	}
  
  	/*
  	 * We need a ResultRelInfo so we can use the regular executor's
  	 * index-entry-making machinery.  (There used to be a huge amount of code
*************** CopyFrom(CopyState cstate)
*** 1794,1801 ****
  	 */
  	resultRelInfo = makeNode(ResultRelInfo);
  	resultRelInfo->ri_RangeTableIndex = 1;		/* dummy */
! 	resultRelInfo->ri_RelationDesc = cstate->rel;
! 	resultRelInfo->ri_TrigDesc = CopyTriggerDesc(cstate->rel->trigdesc);
  	if (resultRelInfo->ri_TrigDesc)
  	{
  		resultRelInfo->ri_TrigFunctions = (FmgrInfo *)
--- 2246,2253 ----
  	 */
  	resultRelInfo = makeNode(ResultRelInfo);
  	resultRelInfo->ri_RangeTableIndex = 1;		/* dummy */
! 	resultRelInfo->ri_RelationDesc = rel;
! 	resultRelInfo->ri_TrigDesc = CopyTriggerDesc(rel->trigdesc);
  	if (resultRelInfo->ri_TrigDesc)
  	{
  		resultRelInfo->ri_TrigFunctions = (FmgrInfo *)
*************** CopyFrom(CopyState cstate)
*** 1815,1865 ****
  	slot = ExecInitExtraTupleSlot(estate);
  	ExecSetSlotDescriptor(slot, tupDesc);
  
- 	econtext = GetPerTupleExprContext(estate);
- 
- 	/*
- 	 * Pick up the required catalog information for each attribute in the
- 	 * relation, including the input function, the element type (to pass to
- 	 * the input function), and info about defaults and constraints. (Which
- 	 * input function we use depends on text/binary format choice.)
- 	 */
- 	in_functions = (FmgrInfo *) palloc(num_phys_attrs * sizeof(FmgrInfo));
- 	typioparams = (Oid *) palloc(num_phys_attrs * sizeof(Oid));
- 	defmap = (int *) palloc(num_phys_attrs * sizeof(int));
- 	defexprs = (ExprState **) palloc(num_phys_attrs * sizeof(ExprState *));
- 
- 	for (attnum = 1; attnum <= num_phys_attrs; attnum++)
- 	{
- 		/* We don't need info for dropped attributes */
- 		if (attr[attnum - 1]->attisdropped)
- 			continue;
- 
- 		/* Fetch the input function and typioparam info */
- 		if (cstate->binary)
- 			getTypeBinaryInputInfo(attr[attnum - 1]->atttypid,
- 								   &in_func_oid, &typioparams[attnum - 1]);
- 		else
- 			getTypeInputInfo(attr[attnum - 1]->atttypid,
- 							 &in_func_oid, &typioparams[attnum - 1]);
- 		fmgr_info(in_func_oid, &in_functions[attnum - 1]);
- 
- 		/* Get default info if needed */
- 		if (!list_member_int(cstate->attnumlist, attnum))
- 		{
- 			/* attribute is NOT to be copied from input */
- 			/* use default value if one exists */
- 			Node	   *defexpr = build_column_default(cstate->rel, attnum);
- 
- 			if (defexpr != NULL)
- 			{
- 				defexprs[num_defaults] = ExecPrepareExpr((Expr *) defexpr,
- 														 estate);
- 				defmap[num_defaults] = attnum - 1;
- 				num_defaults++;
- 			}
- 		}
- 	}
- 
  	/* Prepare to catch AFTER triggers. */
  	AfterTriggerBeginQuery();
  
--- 2267,2272 ----
*************** CopyFrom(CopyState cstate)
*** 1871,1958 ****
  	 */
  	ExecBSInsertTriggers(estate, resultRelInfo);
  
! 	if (!cstate->binary)
! 		file_has_oids = cstate->oids;	/* must rely on user to tell us... */
! 	else
! 	{
! 		/* Read and verify binary header */
! 		char		readSig[11];
! 		int32		tmp;
! 
! 		/* Signature */
! 		if (CopyGetData(cstate, readSig, 11, 11) != 11 ||
! 			memcmp(readSig, BinarySignature, 11) != 0)
! 			ereport(ERROR,
! 					(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
! 					 errmsg("COPY file signature not recognized")));
! 		/* Flags field */
! 		if (!CopyGetInt32(cstate, &tmp))
! 			ereport(ERROR,
! 					(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
! 					 errmsg("invalid COPY file header (missing flags)")));
! 		file_has_oids = (tmp & (1 << 16)) != 0;
! 		tmp &= ~(1 << 16);
! 		if ((tmp >> 16) != 0)
! 			ereport(ERROR,
! 					(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
! 				 errmsg("unrecognized critical flags in COPY file header")));
! 		/* Header extension length */
! 		if (!CopyGetInt32(cstate, &tmp) ||
! 			tmp < 0)
! 			ereport(ERROR,
! 					(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
! 					 errmsg("invalid COPY file header (missing length)")));
! 		/* Skip extension header, if present */
! 		while (tmp-- > 0)
! 		{
! 			if (CopyGetData(cstate, readSig, 1, 1) != 1)
! 				ereport(ERROR,
! 						(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
! 						 errmsg("invalid COPY file header (wrong length)")));
! 		}
! 	}
! 
! 	if (file_has_oids && cstate->binary)
! 	{
! 		getTypeBinaryInputInfo(OIDOID,
! 							   &in_func_oid, &oid_typioparam);
! 		fmgr_info(in_func_oid, &oid_in_function);
! 	}
! 
! 	values = (Datum *) palloc(num_phys_attrs * sizeof(Datum));
! 	nulls = (bool *) palloc(num_phys_attrs * sizeof(bool));
! 
! 	/* create workspace for CopyReadAttributes results */
! 	nfields = file_has_oids ? (attr_count + 1) : attr_count;
! 	if (! cstate->binary)
! 	{
! 		cstate->max_fields = nfields;
! 		cstate->raw_fields = (char **) palloc(nfields * sizeof(char *));
! 	}
! 
! 	/* Initialize state variables */
! 	cstate->fe_eof = false;
! 	cstate->eol_type = EOL_UNKNOWN;
! 	cstate->cur_relname = RelationGetRelationName(cstate->rel);
! 	cstate->cur_lineno = 0;
! 	cstate->cur_attname = NULL;
! 	cstate->cur_attval = NULL;
  
  	bistate = GetBulkInsertState();
  
  	/* Set up callback to identify error line number */
! 	errcontext.callback = copy_in_error_callback;
  	errcontext.arg = (void *) cstate;
  	errcontext.previous = error_context_stack;
  	error_context_stack = &errcontext;
  
- 	/* on input just throw the header line away */
- 	if (cstate->header_line)
- 	{
- 		cstate->cur_lineno++;
- 		done = CopyReadLine(cstate);
- 	}
- 
  	while (!done)
  	{
  		bool		skip_tuple;
--- 2278,2294 ----
  	 */
  	ExecBSInsertTriggers(estate, resultRelInfo);
  
! 	values = (Datum *) palloc(tupDesc->natts * sizeof(Datum));
! 	nulls = (bool *) palloc(tupDesc->natts * sizeof(bool));
  
  	bistate = GetBulkInsertState();
  
  	/* Set up callback to identify error line number */
! 	errcontext.callback = CopyFromErrorCallback;
  	errcontext.arg = (void *) cstate;
  	errcontext.previous = error_context_stack;
  	error_context_stack = &errcontext;
  
  	while (!done)
  	{
  		bool		skip_tuple;
*************** CopyFrom(CopyState cstate)
*** 1960,2166 ****
  
  		CHECK_FOR_INTERRUPTS();
  
- 		cstate->cur_lineno++;
- 
  		/* Reset the per-tuple exprcontext */
  		ResetPerTupleExprContext(estate);
  
  		/* Switch into its memory context */
  		MemoryContextSwitchTo(GetPerTupleMemoryContext(estate));
  
! 		/* Initialize all values for row to NULL */
! 		MemSet(values, 0, num_phys_attrs * sizeof(Datum));
! 		MemSet(nulls, true, num_phys_attrs * sizeof(bool));
! 
! 		if (!cstate->binary)
! 		{
! 			ListCell   *cur;
! 			int			fldct;
! 			int			fieldno;
! 			char	   *string;
! 
! 			/* Actually read the line into memory here */
! 			done = CopyReadLine(cstate);
! 
! 			/*
! 			 * EOF at start of line means we're done.  If we see EOF after
! 			 * some characters, we act as though it was newline followed by
! 			 * EOF, ie, process the line and then exit loop on next iteration.
! 			 */
! 			if (done && cstate->line_buf.len == 0)
! 				break;
! 
! 			/* Parse the line into de-escaped field values */
! 			if (cstate->csv_mode)
! 				fldct = CopyReadAttributesCSV(cstate);
! 			else
! 				fldct = CopyReadAttributesText(cstate);
! 
! 			/* check for overflowing fields */
! 			if (nfields > 0 && fldct > nfields)
! 				ereport(ERROR,
! 						(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
! 						 errmsg("extra data after last expected column")));
! 
! 			fieldno = 0;
! 			field_strings = cstate->raw_fields;
! 
! 			/* Read the OID field if present */
! 			if (file_has_oids)
! 			{
! 				if (fieldno >= fldct)
! 					ereport(ERROR,
! 							(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
! 							 errmsg("missing data for OID column")));
! 				string = field_strings[fieldno++];
! 
! 				if (string == NULL)
! 					ereport(ERROR,
! 							(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
! 							 errmsg("null OID in COPY data")));
! 				else
! 				{
! 					cstate->cur_attname = "oid";
! 					cstate->cur_attval = string;
! 					loaded_oid = DatumGetObjectId(DirectFunctionCall1(oidin,
! 												   CStringGetDatum(string)));
! 					if (loaded_oid == InvalidOid)
! 						ereport(ERROR,
! 								(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
! 								 errmsg("invalid OID in COPY data")));
! 					cstate->cur_attname = NULL;
! 					cstate->cur_attval = NULL;
! 				}
! 			}
! 
! 			/* Loop to read the user attributes on the line. */
! 			foreach(cur, cstate->attnumlist)
! 			{
! 				int			attnum = lfirst_int(cur);
! 				int			m = attnum - 1;
! 
! 				if (fieldno >= fldct)
! 					ereport(ERROR,
! 							(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
! 							 errmsg("missing data for column \"%s\"",
! 									NameStr(attr[m]->attname))));
! 				string = field_strings[fieldno++];
! 
! 				if (cstate->csv_mode && string == NULL &&
! 					cstate->force_notnull_flags[m])
! 				{
! 					/* Go ahead and read the NULL string */
! 					string = cstate->null_print;
! 				}
! 
! 				cstate->cur_attname = NameStr(attr[m]->attname);
! 				cstate->cur_attval = string;
! 				values[m] = InputFunctionCall(&in_functions[m],
! 											  string,
! 											  typioparams[m],
! 											  attr[m]->atttypmod);
! 				if (string != NULL)
! 					nulls[m] = false;
! 				cstate->cur_attname = NULL;
! 				cstate->cur_attval = NULL;
! 			}
! 
! 			Assert(fieldno == nfields);
! 		}
! 		else
! 		{
! 			/* binary */
! 			int16		fld_count;
! 			ListCell   *cur;
! 
! 			if (!CopyGetInt16(cstate, &fld_count))
! 			{
! 				/* EOF detected (end of file, or protocol-level EOF) */
! 				done = true;
! 				break;
! 			}
! 
! 			if (fld_count == -1)
! 			{
! 				/*
! 				 * Received EOF marker.  In a V3-protocol copy, wait for
! 				 * the protocol-level EOF, and complain if it doesn't come
! 				 * immediately.  This ensures that we correctly handle
! 				 * CopyFail, if client chooses to send that now.
! 				 *
! 				 * Note that we MUST NOT try to read more data in an
! 				 * old-protocol copy, since there is no protocol-level EOF
! 				 * marker then.  We could go either way for copy from file,
! 				 * but choose to throw error if there's data after the EOF
! 				 * marker, for consistency with the new-protocol case.
! 				 */
! 				char	dummy;
! 
! 				if (cstate->copy_dest != COPY_OLD_FE &&
! 					CopyGetData(cstate, &dummy, 1, 1) > 0)
! 					ereport(ERROR,
! 							(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
! 							 errmsg("received copy data after EOF marker")));
! 				done = true;
! 				break;
! 			}
! 
! 			if (fld_count != attr_count)
! 				ereport(ERROR,
! 						(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
! 						 errmsg("row field count is %d, expected %d",
! 								(int) fld_count, attr_count)));
! 
! 			if (file_has_oids)
! 			{
! 				cstate->cur_attname = "oid";
! 				loaded_oid =
! 					DatumGetObjectId(CopyReadBinaryAttribute(cstate,
! 															 0,
! 															 &oid_in_function,
! 															 oid_typioparam,
! 															 -1,
! 															 &isnull));
! 				if (isnull || loaded_oid == InvalidOid)
! 					ereport(ERROR,
! 							(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
! 							 errmsg("invalid OID in COPY data")));
! 				cstate->cur_attname = NULL;
! 			}
! 
! 			i = 0;
! 			foreach(cur, cstate->attnumlist)
! 			{
! 				int			attnum = lfirst_int(cur);
! 				int			m = attnum - 1;
! 
! 				cstate->cur_attname = NameStr(attr[m]->attname);
! 				i++;
! 				values[m] = CopyReadBinaryAttribute(cstate,
! 													i,
! 													&in_functions[m],
! 													typioparams[m],
! 													attr[m]->atttypmod,
! 													&nulls[m]);
! 				cstate->cur_attname = NULL;
! 			}
! 		}
! 
! 		/*
! 		 * Now compute and insert any defaults available for the columns not
! 		 * provided by the input data.	Anything not processed here or above
! 		 * will remain NULL.
! 		 */
! 		for (i = 0; i < num_defaults; i++)
! 		{
! 			values[defmap[i]] = ExecEvalExpr(defexprs[i], econtext,
! 											 &nulls[defmap[i]], NULL);
! 		}
  
  		/* And now we can form the input tuple. */
  		tuple = heap_form_tuple(tupDesc, values, nulls);
  
! 		if (cstate->oids && file_has_oids)
  			HeapTupleSetOid(tuple, loaded_oid);
  
  		/* Triggers and stuff need to be invoked in query context. */
--- 2296,2315 ----
  
  		CHECK_FOR_INTERRUPTS();
  
  		/* Reset the per-tuple exprcontext */
  		ResetPerTupleExprContext(estate);
  
  		/* Switch into its memory context */
  		MemoryContextSwitchTo(GetPerTupleMemoryContext(estate));
  
! 		done = !NextCopyFrom(cstate, values, nulls, &loaded_oid);
! 		if (done)
! 			break;
  
  		/* And now we can form the input tuple. */
  		tuple = heap_form_tuple(tupDesc, values, nulls);
  
! 		if (loaded_oid != InvalidOid)
  			HeapTupleSetOid(tuple, loaded_oid);
  
  		/* Triggers and stuff need to be invoked in query context. */
*************** CopyFrom(CopyState cstate)
*** 2193,2203 ****
  			ExecStoreTuple(tuple, slot, InvalidBuffer, false);
  
  			/* Check the constraints of the tuple */
! 			if (cstate->rel->rd_att->constr)
  				ExecConstraints(resultRelInfo, slot, estate);
  
  			/* OK, store the tuple and create index entries for it */
! 			heap_insert(cstate->rel, tuple, mycid, hi_options, bistate);
  
  			if (resultRelInfo->ri_NumIndices > 0)
  				recheckIndexes = ExecInsertIndexTuples(slot, &(tuple->t_self),
--- 2342,2352 ----
  			ExecStoreTuple(tuple, slot, InvalidBuffer, false);
  
  			/* Check the constraints of the tuple */
! 			if (rel->rd_att->constr)
  				ExecConstraints(resultRelInfo, slot, estate);
  
  			/* OK, store the tuple and create index entries for it */
! 			heap_insert(rel, tuple, mycid, hi_options, bistate);
  
  			if (resultRelInfo->ri_NumIndices > 0)
  				recheckIndexes = ExecInsertIndexTuples(slot, &(tuple->t_self),
*************** CopyFrom(CopyState cstate)
*** 2214,2220 ****
  			 * this is the same definition used by execMain.c for counting
  			 * tuples inserted by an INSERT command.
  			 */
! 			cstate->processed++;
  		}
  	}
  
--- 2363,2369 ----
  			 * this is the same definition used by execMain.c for counting
  			 * tuples inserted by an INSERT command.
  			 */
! 			processed++;
  		}
  	}
  
*************** CopyFrom(CopyState cstate)
*** 2233,2267 ****
  
  	pfree(values);
  	pfree(nulls);
- 	if (! cstate->binary)
- 		pfree(cstate->raw_fields);
- 
- 	pfree(in_functions);
- 	pfree(typioparams);
- 	pfree(defmap);
- 	pfree(defexprs);
  
  	ExecResetTupleTable(estate->es_tupleTable, false);
  
  	ExecCloseIndices(resultRelInfo);
  
- 	FreeExecutorState(estate);
- 
- 	if (!pipe)
- 	{
- 		if (FreeFile(cstate->copy_file))
- 			ereport(ERROR,
- 					(errcode_for_file_access(),
- 					 errmsg("could not read from file \"%s\": %m",
- 							cstate->filename)));
- 	}
- 
  	/*
  	 * If we skipped writing WAL, then we need to sync the heap (but not
  	 * indexes since those use WAL anyway)
  	 */
  	if (hi_options & HEAP_INSERT_SKIP_WAL)
! 		heap_sync(cstate->rel);
  }
  
  
--- 2382,2400 ----
  
  	pfree(values);
  	pfree(nulls);
  
  	ExecResetTupleTable(estate->es_tupleTable, false);
  
  	ExecCloseIndices(resultRelInfo);
  
  	/*
  	 * If we skipped writing WAL, then we need to sync the heap (but not
  	 * indexes since those use WAL anyway)
  	 */
  	if (hi_options & HEAP_INSERT_SKIP_WAL)
! 		heap_sync(rel);
! 
! 	return processed;
  }
  
  
*************** CopyGetAttnums(TupleDesc tupDesc, Relati
*** 3502,3507 ****
--- 3635,3647 ----
  	return attnums;
  }
  
+ /* retrieve internal EState in CopyState */
+ EState *
+ GetCopyExecutorState(CopyState cstate)
+ {
+ 	return cstate->estate;
+ }
+ 
  
  /*
   * copy_dest_startup --- executor startup
*************** copy_dest_receive(TupleTableSlot *slot, 
*** 3526,3531 ****
--- 3666,3672 ----
  
  	/* And send the data */
  	CopyOneRowTo(cstate, InvalidOid, slot->tts_values, slot->tts_isnull);
+ 	myState->processed++;
  }
  
  /*
diff --git a/src/include/commands/copy.h b/src/include/commands/copy.h
index 6d409e8..8c69703 100644
*** a/src/include/commands/copy.h
--- b/src/include/commands/copy.h
***************
*** 14,25 ****
--- 14,36 ----
  #ifndef COPY_H
  #define COPY_H
  
+ #include "nodes/execnodes.h"
  #include "nodes/parsenodes.h"
  #include "tcop/dest.h"
  
  
+ typedef struct CopyStateData  *CopyState;
+ 
  extern uint64 DoCopy(const CopyStmt *stmt, const char *queryString);
  
+ extern CopyState BeginCopyFrom(Relation rel, const char *filename,
+ 							   List *attnamelist, List *options);
+ extern void EndCopyFrom(CopyState cstate);
+ extern bool NextCopyFrom(CopyState cstate,
+ 						 Datum *values, bool *nulls, Oid *tupleOid);
+ extern EState *GetCopyExecutorState(CopyState cstate);
+ extern void CopyFromErrorCallback(void *arg);
+ 
  extern DestReceiver *CreateCopyDestReceiver(void);
  
  #endif   /* COPY_H */

���Mfile_fdw.patch�<kw�6���_�uok���v���c����h�����fo��C����"������wf� E�N_���S�f0�@w<f�������?
�Q�����]���R���;���8�?�v��{��w������������x6j�Z���?�{v����	�H�v�{�v��bk�
�J%�����x�K�w<�=�=k�=���0�:��,�����p���Y�!����D��������������G�d�_N�z������@��X��~1:p^�����}{�)f��2J5���Y��������U�y����"���
|��A��`6�#��0�C����,Zl�z|�����g��������|�t:���,��������X�px�^O-����z�A�a�S@�����8�N��cE[��|pH���k�u8k��7��x2�h�W���bq������4�y��ALB`��?����
����^���7?��o"������az���~������b	��m���
+6���W�N�^���w�����"��������14��\
�3����g��a����q�d<r����#.mF#�"�"�xd��e�/]�>�{x��z�+��r����������F�E�]����=��S�w���/�-�@��[!�q=����As8�]/2�����c��A/=o��k_���~v^��;v��������}h������K=�aQcwB����	����r�����
�`>����^z�����=��{H�l��(���9�^o��\��JC�v����F��4��X=��[����OH�R����qi�����HT�~C�89�����
)��yT�� �xy���~�~��8~stT�9:�O����/^��������{���D��]G)�H�������{�
4�k�P6H.�$�%��@I2�����9�,�<b������_�[��T��#EC���y���u'C�"*�^C�_��<tF�Wi�X�1���~�s��k��G���6����w��0��Q�du�1��H�u]+�?��d��]a{;�;Uv�h��?��%�&v���g���e�sC��}=�\tZ�A�{����	������h��9���f���!V��aYO�1�T�&
p8�����u|�������|O0�AH&��B>�w+�
�w��bk���g��-g�.�����=@.-y2s�!(����2h��(�KK���������@���
�_�-f��{���@�]���:��
%~�\� g�GS��,�u��RR�`�X&�S"�X�@Wh5�'�QtlG�(�p]B
��`\�,"fO��mr��q$��u�R�-(��>:.����$���p����,�����p�/��_ZC�:r�`�OXh�-
�,�F�������E���)�2u�:��+��� &43�H�|�iE�������Jc}�E
�`�R�t�'���-�\�3���f�������J��I���;`E�]�rc�ji?�!mp�%k&<�_� �6mVK:+���8�A�q����;!	0������u���D5��A��C:A�Tk���SnA.����@	#9����c��'�}��O�����@����w�W���=N~�b�!pl�h4��F�s}�@5#�o��p��O��z��@A�1iA������g�V��"���-tR�f��_9^	4E��
�����xC\��K1���g��+���j���'��:�q�2��?�v���A	d*:�,"$��}�����&.�Lu1�d`2+�fW��(��%L�w
R(:%���8�U6�a�I.�(����"k���f�B�
��'o�G���|(����*�����2������c����� }%K7�;��z>G;��Q��+���Xy���Hj��i�4fUVtg\p��	�-pT`����(('C���s�
��4����]`�UF��Z�2|�i��c$�v��&~={V!���z�''�8���w����lb�*6TdG"*�<�A��F������L��X�"���A� ���{����]t{�����e|�k���{U�o����[�!������%��4���i��w�=��F��v���i�Q�&�0�(�A H!w$�+�c�����\_t��w����������'�G��h) ���!�4Pm'
-_���������=C`����N�bDJZ�OX:��9/�jU��ZX��	m���Q@�
�k
:��LW�0{�C�H�X�E���@%*��7�[����j��\"�$&����
��I:������*Y=i���*
�k��)���)��z���>���z�S�$'S�H)�/������E
I�;v9x(��{���Hh��H�,6u�(��p�)#��:
�H�)&�k�����n��Y���(��mQ�E��u��J��o�N\e���o�f�����$;c���A�&{�67M]���ng	���2)zQ�ahC����y{�����U�|��!�n�kW31)o*��;����0SF0��)ofS
��)����-^1Z,�kZ���P�^{p���u�We��jc��r�luVZullZk%��0��?EP�	�JV8��-��o�@-�Q \���$�(���;�z���A{���n�����,q��wh���Cz�����2���lTyC
e`���<:�-2_�?M6V���,q����'s95���������6z��.�0�M+H8��;
�d�c�E��ug����]3�O��e+���NX3����!$6��kM8�q��b��q����(H/��`�����N�w,]����kWq���'q��X=�������I�
���G�J�H�02�R�(p
[�#l�,P�Z�8c]��cc��*�A�*7���O������%{�K��S�W������5��������7���g�<������;�{��_�<8<JQ<?��������������mT���r������,�����J�
�V�=�AS5$qH���{*���-%�3���3�6������6����e���J!'�Ta��eX��>��UkLK��R j��B��,�xi&����&���O�,�qK+�.,����}�V"�\z�%�JA�EWd�nH�z���������+|����:����
������t��'�Ma�$U�\���4&5��I�X�Y�L�U���,������{����A+�X����4��J��7I�3y���i�$G+;�YO0w��W���C�6�n^l�w4%���,�*#���a���@�o��
U��<<��0�,^������W��X����?���jZub������cf�s&�:�6����"���Sbby���@��BU�%$6
<G`a0�'����,�m�x��'l�@@�����9^R���
�%��T��g��2g�u
��-�����R��?�����d�5��eg�5��u�1��d3��e�q��=4����w��'�f���Wff[����Y���%�a���i(���.�Sq���qA{����o�]�P���)�*D��u���=����
<q�������qf�]�C�?�`�<7�7���q �'�V���9��6U�g���#���]��TK��Kr	!��{����*� 3XnO���N�=\�s��geu��,����g�\�Z��xA�TY�V����������F���I
n�,�*��k�x3[	~�����@
�����B%I���)��2-)�	�s��-���KC�S�.ux�VZ�vT�
V [�g�����\�q�@�����K\��<�������6�0�B,����aR������4�:!����^2}���G�_�)1��;����gH��@�j��P��qa<�e
����N��[����@���F����
.J���1H�������"�?vU��+��7��$<�!����E�`HG���Q)��V���.�Lt(����3c-sJL�������T������)�0
��_"�Sg�������!��0J�����=[�,���r��	�������Nh&��iwP6�j���%������x_)g�29����~
7>�b/���iB�9u��-
"�IP�x��iQr�L���'�Qt9p���!����t���2���		�$��e{�5�9���K���q)�u���v�x$�����$M��\0!	���r�Kb��\`��2]k���qF��K�3g��E���r?�rkNW0��I��!"��]H��5����7�����{������l �$d�JQ����K2��*D�MFOUS27�|�%iS:�p��(�?�(�L����UY+1��gA��R�K���%�>�G<U���`"�_��]4�W��/�x�������\��t�
����P �����a�!�~G��`���'�>�E�d�f�2u9�,���R���E	�(�{A9��.������t}���+���IHJ�O�$��C�u���kG+%���	m,ft�z�J(t�h����d���ps��\�K�fQX��$
Fr���j��_�<���Mi���gJ)��,h��u������uH�8��u�R�5��}|"�d�Y>�S�^���JO�� �����d���E�\����?�J�����f�$J=�����k��`�2yA��
c9����� �������DQ�.�D��wtd�@3�����-dR��w�z���u<q�[��	���R��>����
!����<B$?$C��F�������JLN+wMK������_�$�h8��=-�����P
�C��U��jid}z���HGR:+�2�'�����%���&���%��P1E_�
T���*/��q#]5ri���^3��;E���:��H~p�W��O
����r^���#p��
��c��z.9Z��H��|�0DD��\�sI�2�����������/;�a��n��^���_I�)9f�����_71U
����N����
���;YL�}���	���.	��G���P^^���#�D�)��7������p/�@piH)�i��(m�N�a
����D�P%�|��������������I��R�B`S���,E�X��G�xJ�uX��fh �/A�C��n�~Y$�
�RD0KO����T_��w��P�q����fO�i��z���5����C���)W�k�;b��=��#&a��\����a
vv��G��d��=���b��
�N�X�#2N����o���^Y�����_(�7�Vx���������D~nH���Y��yA����
�������o���[O|*>{u��u�7���e��e9���^�*��#�C��G����OD���TK�/f�����\&>���jH(�-���^�d8e��������B{
�
A=8#`\�8�A�tU�B���8����Ks��=���j3��/ge��?	�ey~����}��^��4o���Vuk���j^_�6/�����^�5P�?� }�\6i0:'E
|!E���
�7�^��6�����z��'*�zD�����*�������Axn�:$�W������� �>������6����Y�X����s1������|h�p���n�,�8�F��������
�TK�>��=:zY��7�kP�cF71_[��.�;�F�4�-X���,���p�z��a������k^p�[����w�l�+j
��pa��?�^������'���"t#�P�J}��|/��l,�w���~����
���&+��N�����o��xu�����+�r�{z��v�*xk��_���(5@�}&	����Y�)���O�����`\���a�����1�?�������#��o�)��{��%
�'�va�
_����YZ���>���n������w��jWu�$���'^Y
���U�����3��
�$��8�d�s���(H:'G ���������������~=>Bn����u�=;D,�#\��#V��^�c��(���sv���
�p��
��4%3�P1&l����S�2}7�}D�0J������wq��Q
s�(�#�
�KS
Wh��t��9��-GI>�(�+ \�EJf�vt��.�����Bt
e�6Vgk �k��*�8�YXa��+�6�{��FY�A�u�����F�3���n�N4Q��25W(��h��~p�M����oB����jT4/}H�$���UMZ��������������9��t�#�J�QW�Ml�v���*
]-�������3D�3X�a\��c���<^Fhl��0���Eh������r@������W��77��q�v���/�A���~�bu���:f���{T1�����#�(��KGY������H7>��[#�x���.b���{���F�v�<��%��0=�
���)DO�����|���b	��������v�r|��=
�45`\�+A"��������\�
�w:iq�MZ���*�0�����M���d�=�7:�$2F���� �����
Q����[$ ���v�
�
i� ��\�������x6��E	zn]��=~_��5���."UT%\�������i���A�x������~�����\x���,AK����D�_A����]F���]"����a'���7�ah��l����6�q����T������X��������Nn�>�����K�w�z�?Y���������n��0�aar���8G��MJ�eE��_�� ��e���uP$��H��?�C��!t�bz�C�
��>{��yE�J����������lv���
��l"(5���9o�I��C���,$�E�������l�Cs�
@�J�*�h�e5��d�9%�}�#�'�y?q�?$60�s�������M��3�%���P�r�3��[�T�]x�i2B��TE2"�[�o>$Ki<�3-��DTbq��7��J\J�(w�����16�K�x�EJ\7`����5���~qi�TR��7�Q����
���*����cL.�����G�Y&�@��bSw�|���*3!QHC���pB�S��c��
=�1
,;
�b����_�n��GA���O(p��|;RPO�'f(��3�qNl l�����m������f�f�j��+P��U���X��1v��G
�f��GO�;�{Ul�@ z�qy���4��|t����k�U�,&6	�|�1�q����W�/��cV��S<P�Q5t(L{Ms�Ch6|����U~��d"��,���I���Ro"n�;p��Sd�jq�'�����"3n:R�Z��2�% '����C�1��|���X3�z�����`Z�� �� *�pA��Z�'��2-����Q��s8�dHV����zh��F�l�Zx��H*�h�z�H�},5�aQ��C��i�U���M^G�%AJi{���H7k�����,�c���9�$ ���h��8z�
+.�e*~�����V�(*N����zw�;���N���_>��V�:R�}�pG����6)3����.^r1#����8yW��(3	h�a��ej%�t��$��S[$$0��D��`Fh%#��!��z�����  A}7D3�J����i�:`SG:�'[d,��:�_�\��C����I��.�t�x�����[_G�������@����G���.���
_Y�	���6�q�#��^f�����\g��E��']1��1��!h�3�f���)vR���E�a�����s�G�E|�-��pe�F������"6�Y��Q�O�zr�R��V���
��&��f��������v����
�@;�o�_8bW��fm�[�[�m^y'��J�I2�3�Dd$yzg�3����3�$b;1���qF�F
p�49h��S\/����w���N;�������A�����99D������N�n8_�������������9��Y=�T��/"uDQ�y�*���l�u�I%k����z��$��a�g@����(����fG�����_�`����e@�}>��<�H�r3��T���]^,�E��W�������U��{
��S�)��h�}�.�Y
��mA;�[h;�(Fqq���E����EG�$��0Z�}LI������VZ9$r��Y%�
�����e�6�C8�xp%�d�_F�
]�s$3R>��G��\b+��Kq�o����`��	����v�1e�'��./~��G*��E��^��{fa*��mCq����*��#<tr�k>R6��C�~�m��Oz8=D~���{}r~R3���fgG�z��N@�N��^���fwI�Q?rB�;y/5`,n���Q�������o��k��F���p�U������_��(^���=�6����Q	�?���e�<�l5.-:��SU3] ���`�G�5
y�/3�'I��A+������}�d�����G6}N	�-���R�u@�|�\-���8������,���k(reEKQ�C�&R�!
i�����L�	��m����� �F�����C�$�4PX'P�
lHKN��w����]��$�f�Q��l����q�L:���)N�$���C�����4����K��|A�;���d���s�t�_�+�RY�
�%y����a*O�`�e��4�~�}����[��81��Fdz����`�	�^�]���lZ�
�2�������:z�t��O��k���"���@x��hcS��9@�E��~r\�L�\8^5�xHF9P���Y\��=g<p���H���,���
l7J����S{"[��N��m�kR&�����T()6uO�v��\���d���[0�������x�<G���.~��'�10Ta�+sr�U!S�o�ht �^H
�#�4:O�)�I�!@�~��
$����hE�{R���Z�����_!$������O,��]���E�Zz�0�C��z���A7�F�����o,��$W����:V<�Q/$J��q�p���"�Y�f��s����=�[��[�bM�
����{����'ya�o��e��%��`����g���'3U[99����^n��S��D
���b�9d��I��mW�A�n�S,ahGP��{!��B��2��
� |�q��;�G�7p��Z�`5Vo��o
��+a�Cm�`���BA]\�����l�_�\-���Z�g�
����m������x|��C�>����d^��O��YN�"�p&���������>�%[�=dl�A@�
�I�Z\6�\�r�w����� u��;���s�9]
7���p^��r����v�V�)Kq_�p��?r�u?���,�4m9��������������������T��v
B��6`�������������_��"��0n���!$V��v�CW/�Y;�5~��-�����U���+e��������FZ��+�,��:s@.�5��Y2X'�NPq!���tE"l>�����ka�~��$zU�r����=���Uc�^�4�h�J�4
Q����BxB���s_�"��*mo�������@6�$�"&�Ny\���PZv�gcF�6�R��R�f:c�%!;�/��y6/J�9�-R����6�7&!1��C��/��
�INJ��~=��.��AMAJ��58��N6��N|�=�!��#7y�J�W�%/��;%3��B*s6A��'	����cX�$����O�*�I�Fy� �&�i�eC4����C��.�����>
��������6YF9d�&yM)�H1
����*�G�j��$N��x� ,x��K�[�����S��1��8�.�����Y�"	~w�!����oON�;�����tNW@��F��d�
T@%�����FPEB�Z_
mv������y"�i"�<��x{{����y�����v�������BP���X8�H������4+n!X����)�"���M���s�S�.�)�����f����+�!��_u2��c�&��N��?*6���3�Z��Q�7��O�|�'S
)�&9�vz�����U�{�$��;<��w;�������v�:�+(���1�X�/�X91��4ahL�y��fD���l���g0���sspV���E=�eP��{J�fEOE���"�$��j�1='�1'Gn�*������*Mu.|�b�S�uPm7`�v����2�����'E ��������!��S�gG�;`)�o��,���O����'e���=�FhzY0'�x�LO����r�xTm6�MJ�����3�=O�������I����3#��9�Z\ll,��i]$b�\
n0�Qbg��
�H�~0��	`u[[��W��>�����^�
��hB�c�����>���e�:�R��[�[�2N,��K����A�h�F�q�c�:0�2Jv���u�_��g��#�h'�G?�
�a~Y�BlTl��Hp?�`�"$$xD�r9uV4T��-�Y��ywf�h���a��2Y
V\�nh'�-��!Ks�@��#���Fm��g���^�X=��H{#���+�|�#�����	.&�+s���zI�g����+_�lV��	�(�S�}�m/������i���	�KR`�]yg���f��{�S��e�s��aK��"I58Z��\\.��\l�U44"6���D��=*H��_"C��mr7B������M/��'��������Y�j8J
k@E��PoX����h��*��c����/m4�@F���/o<�BM���e��No��s�h:����� �����q�A���$}hE;?qI)$JM�J�Z;$/��>b�&�x�i�,���b
�B*[��ed�B��}Q�Atb<������.�7l���k�N�H�4�6���s"�c����Y�n�b��}���^D ��iw���8T����+I%=$�����1�"�6����a�!���c���)�*��=L~�*E���Tu�,���G��1�6�#����GS*hF>�5���L�5���/>��lf�`9����A��+��n3��G#��\�����y��An��8x�+���
e������A�~��d+�:�d{*<��k��vP�s\N�	x=
�����1��s]��c����/]���K��l����kX����j6�,H�@�7�����1�0��-����{��T�_V����
�l�K*��Xj�D�s���re�;�k���I��D^�5j�@���Y�������'�����T(�����Q���z����j��RU����^3y�yC�������]��O<�m��������
p�|Y�������r�C�
���}����!��z�/rIw���L�>
g����5u$��K)�Mb�2�M�`���KFJ�>6���u�-T��=������1��X�3��6WP��Q����b#�N���)��q�e�grY����]��P�{�Y��\��8����J�����L�h��s�#"��Q�}Y��b��Q��a�������#��?�`�����E>�����4M��^<�s#xv]u�6��|3���y"v�u���~d�-�����i�����2����<�|��R���!Rg���@���F��&��U��b%z��������",������G�5��.�a�f�&�	t�
�|PX8�Epl
�.���*<��
��*h��o���'>$H!nI������m�a��(:�0�����zxs��&;��<�U q�1���6��us��������|�\����(!:��3��t]�p�L��M����UPD3_�n2��m���V��f/����^)�w�MH�F��~cx]b�]�M8�����w#����xQ^�#
}}0o-,T�����@i���a��k��=>H�p��')��^l���d��G���Al�~y9J/��1����qZA�SQ������|��8]#^n��!<xkg�.1����0���bG�Z���<1��s��B2/9P+��%
��,��l�G��-���>��V&���!�4�j}����b�0q��������;���=��1���6�?E����������9<�D�1t����
�B�}�o�q�x���CZ��)BL7��=��	o
���cog����L`�?J�2$���
��(q���K���z��&���*��sf6��_=��V�
��;�0z�<N���
lW���.b\�A3?������|4*KP�S�E6����n8�Kc���������=,����|��o�i2�^�������V2��yU[���e�%���e�qj`�$}�u6��EeR<*�c��|���P^���=��C�T�Z����u����p�PV�r/�/�	pT��e�0lE$�
�)��H(@w�;�
f�?��
������l^���{d��J�2��o_�^u��N���1h��[	�1�pM7�H�������|�e��t��g���A��A�R�A{�qY_��OO�_�N^�gg��w���N�e0�T���7�~p}8���)�:x�������d��k{,���Y}t���
k(<PYo�Hx��2�e��DV�l�;E!�^�K��).�)i�^b��G�����K�����=>��z����Q2��s`��9h	�'�[L]Q�e��
���&��R��:=jp�CFu�@�k�����H�8��][�ak5q���(�H�q���d�'��v3Z���&&g��/_26�/t���0e�F��l/����B����@���l������OXw��.�@P���j
�~M����$~�(�_���jf��G�
��%3��eG�0#�F+�0E!�	��#��KV�&���eU�7��-2��o�D����y�)%��\�>��&"V��/r����W�L�p�4�'9*��������kpTX9��+[���l�dl����o�%�#�����K�{����
����D�����K���&)��I����5�^��r6����-���H����R���d<����eW]K�U�X]�X���
5�{2����������j����K����� �S������
�A��;W�e6��FA{����gv��`�����1��]�K�r��Q���a���:�[���
@J=���)�����������s�D�;���R40�
O�����W�nK�6���a
�`�&��g�G�V�|E.%��i:�]I��P�����[Z0��J��,�M�n��C~�%e�EhM�=��*�m[��xB���'��_�:���@��5�*���C���
�Q6�J�'i�������=gy;�����XN��
6�a��tj.��59��0��
�� ��*5�����Zo�n���$g�����09��s�iW�����j.n_��h�=SaX�����2��d\2	\��:���4���(�6��T��wO��j��$n�d�������,!W������Y�4���&��f����21d2m#���M5dm����_{��{�`�t�pW��
T��������	S��r��<�jL��{�[��gyJ����W(,�8�+�4�Y������AsOU1�/_��b�~�,��sx�m��l�|����V����=�5/������:�������7
�Qy��q[D-�����L����a��+Tw�!�L�J�U���2A�����L�lI�o�y`�U*�J#/f�+�t*K���
�������tT)�*V������15�A�yCz�&�l<�b���e�v�`�o�y�w8�ve|R�x����������g����
+\U6J�/�6
��'&�LP��1���E���
��.�j�\s����`:�+���J\&�N��tV�]������g�r�����#+�J����T��H��{ |
�����o��
����a�Px���}�2}Mc�9+f���0W@����7&�U|~l�N��'��`v9A�6����f�o�l��
RC������'/���Q���e��[����a{"glK?���W��7��Rp��Y���v����(O���wg��@<�o �_�<Q�=�o��$�'�F�gR��mZ�����I=$�.��qmP	��������6U0��>��1sN�V���$6�c��#���-^0P�K����=����)�X_D�,��<���fJT4�I�}���������H
-e�����F)�����0dd&�_U�&�T_�L�j>�`�\�b\z��H��,����)�Va yq�IU�(&���1�'�p�7�c�����~��x��S�$,��_�E�����`���'/�\8J���s�fd��<�$?�X�G�Xq��u6:��OZ�'9R����~������A|�Pv����;�O����nI��e�p<�Z��CNJ;��m���H{���I���B����l�s\6����H������c�\"�F��NP���nM��N�IT����s��q8���|b���,Go�Y���In�R��� ��HYJ��g���?#{�{���'��*7�s>��.�a�Q7)�lO����c�0�M�p��K��e�R�����	�
��pC��*
�����������V�0M=����Z����t��T��W��#��z��Me��l${\�0t�`�.'����)�����O��g�=�I����z�?�f�u
6����x���a��
F���|�.�Qvm'I+�
�,q'����B�G��o���g���+��9r��hr���w������jF�t[	g�p�u.���;�]�R��v��������E	<�����B_W�}�4��7��y�[�`0�����8�"*f����}��a=����F�������M�IK;��zj�h4=��TD6-T:�.#����6n���Z���n5�M������y�)�����d�]^��[��h���(���*�ed�w���q�o<]�������eR��4�
S
"VE���s�y7h��b[2�n�K�krcb����U�n�/��*$�P�����
���+�8Kf�R��}��W��e�{�eo_��X7om�<���8hz�?�#::��4����-1;)���m����b��dM�8HN��c��m5J(�A�^k���|N��rNV�����bt� ��?������V�����8B���@b�.�W����,oI�Y�}K�����v�J_4o�C�}�9KH��
$4��0],�]3�����=�`GBf�{��= ��
z��mo�u���KQX�����
���or���ay�&r5V��~S�s��{��|C��p�����X�gv��)7���
���C.@�3S�1B�[���T�������uU��?��jL�}bgt�c*y���m�."W�$���o<�Is�*�0itx����� 7�j\�����%k�H���S��*�o�k��"���g
�������`Jpg�oF��E��y��]�SP�����+�%�=��u�'LtL�R��y���w�������M�c�Q%%���-M��p����l������j
�D����&	�tX���Y�sw��)?J�zeB}[`�%�m��F�~�E�~�-�RE�q���Fc��q� ���2�[<.�����Q��NU�E'������b��W!l�>s^�����2�����&��2.!���M�|j�'x�-���~���P�nd���o�+�w���z�Y=)g�]�9�
k%�i���-'���������n|�n�[I���j�f���,���H�2��=i$h%I�"�)&:o��mg��H�w9���`����������%�{����?Z���r<��h�z��k2����o�g�y&�B&&�"8=�����c���E�X���R��1��@30M����Y��
Nj�T���/#���p]���D��j6���J�*�*�j�2�;4Y�Abx�C���#q��]��Z��/����0�!�\��
&XaB���V=Fi"�c.�bv�q�o���	|��F`p�L�}O)�/9)�,����o�/��.���������mZyH�!UH�K��.E�[���LV���4:�T8���B�����BJ{d��nbo=�wJ����������)`��7�5����K]
���a��3>������d�2���X���# A��2�r���\^��]
U���1��.$�r���vn*`�8W��uu�=�d��6a�c��&H�*�2���sn�1�1��r��B]=Gw�*8u�n	�P�W�����N	I��V��*�;Df��DyA�dLS{���UQ�8#��$������Pj=^�j0"Z�L��X�b�+�1�F��?�k��QaUC7)��2���,���1j,L��^Eg L'��qx�-��(�R�x�|o��D��(�HF8o��%�����D
��0�6�26�8���5���K�G���}���c)�
�����b���J�Uo�< 6�<��TT�C��H���&���������{@�zzbNo��g��@�����qV�=H���K����
5d"��|J�DwP*�N����ohQM/�Z)I��=��I��"��9A!.�*�����H�e��^���p�v�zo��������:��~��������yb���X�80
�8�|�%NG�
�K���
�������N����5=Z t�Hn���J��������}����T�c�/r��bB&�l>3�V�U�-�C�!]������='��Wz�@��9_��3��$��:���^0��C��G�� �r�mp���J>��9�N��@�F�?_��:�����#�\1C{�l���h�������}���`{�
,��x�Zv�D�e�y��,o`
��
�o�m@�\�w���*��!��M.�!�Q������_w�{.z��F�E�
����{�*
W�����vT���g�9�f����\~��)l{][M���p}%�+�Ub����n�m5�����g%&�R�����23����p���
�r�wW��iV�Zzf��#;l\� �_�ikF�"���rv��M�&�US,F(��4I�&?1 �%�I#��7�K��L����D���h��:�)~���x1��`O�����4���X�J���X=�s\U*����	M��'�����/9K!_�F�Y��Dj0I���h�|��KEGT��a�,�t�<����N%�1����.��q�'
>�t�l�������Qjb*SD�x:�WJ�B����L���>��(q^,�}�{x��
���r/������0I���4N����E2�F��&��.e~��B���UXU�4r\�4��Yb@>O�"��1�����p��|j+�b�^���&%	.@�����(u�B����������8���%�XN��
�6��t]4��mL�]GkNm�����2��ke�=�;Y����p����_YV��|2n�4�47�&g?�����5)��P�Wt�UwN#��5(���o�����1]*|�%�
5=��y+(77}|�h��&�8�H2i�v�?���w���h���!+����Q��0`��?�Z��&�L����3�.2�m��i6���.6��]���S��������_T�7g�nh�l�'�N���H��D�����j]������F���B���Xi����s�����K<�=qP�
]���������4�t��t���>x>x>x>�2|�U���{��N���r{��2�����L�����9e��a��"j
�W����7����{��YE��Zi�U������&����������N/�vXGM�o�ygd�P��_��X�����O�e�S�M��5Z"��n}�t{�Y�]�I�B�zod�}z|���*�������$��k�2->�����mj�C#JS�o�z�W�p�^�����6�*�������'�������z�}K����[�
U�������
}������Tb����Tb��D^*�/)1+��-)��T�cU	uR��I��u�^�U���*.�������}F7�a�^�#~��
lb�Z��zSF	�:��v�<7�L*
�(0&��k�����el %!�!�)j�[{g�����5�=�*@�:S��Y�����#s��(�4a^���|n**����0��P�M�0�������`�r��^�@�H�7���
�����Z>���:��@�a�Y����<����&0�����(G8p�~���6c���|���8���]�iV�hF��M���������,������a�6�:��Y�A�hu&B��J�!W�'*�P����`�U�5$#��y�eb>~�5_<�ix;�^�A��F�wV���)��Oq&����{��/�y�-�6�i��_s�#cm(b�SL��\�aB&�8���l'mJ���vB#��%�XA����I���TB��(�x%*E�T����S)�?U)�4���iL
���B�wU���B/��w��s���~���#�����0�"x�r�]'d�-�~��U�����qI��@���$l5V�f���O�z�L�&��z	M�|�x���+l�u������i��]1e���Bp���c��d���%Ww�����^0'S��7+:�LX�3��x]�Dz��%s�������aY���{>Q���M�Ub{���M�^�V��V^�m�.�=�!��M���C��� L�T
��h\
B��K�
z�o���%�F��3��u���O>��f�(y��bO�n<*�4vU*H�V�Y�2�_"�[���}���A�!q��_%N�`�VX�Ph1j��o��Dy��oxn,,�QU���U�j�~�������f�ZK�Y�:�M����O�k�=�u2���.�{1O	������o3}�R!{���r�$T��T�-8eMK�8Xf��z)v��W�b;Q]�K���G���	4@m8�l���tj��%���v������{r�l����C��s��A�*���=Y��B���*�'�a�F6���EQbr.��������lM3�'�,"nJ=�/�����f��zf���U�C�(�1Se�C���q�*#����!��k&�\3i!+hqp��q��'��@?H��4�5���*������#�]3(C�gv����#=d��4jF��������t��I�#���0y��K&�@xd��Ns�N]V�������T,�[$�7��!�V��s��a>R�
����R%5i$�w��WMv��Y�_�G5ULQ���d���n�B�;>�v�;�H������.#�J]�P�B2��
�����V��8��Jxj~�lT��M,�T�`k:��Cm���J����M��-��`x�z����<�bM�����{{���;���U3,wgq �"�o�����+�z@���-_�[���T^]J�Xo�`��@�*.DC�L(
)BD��c�[�q����9])��tX�W�/��X<�t��^t�[;�/�Z��iU+��b�:�*gR]�}��UQuJ�S��c�9�m���I������qGe�R�0��:���������Z:�=?u��L[�F3lf0�\=pF��%��x�����pp����.o_EK>��s|�E�i���i��������C0���?��Q�����w��E�����uW��w�����0���-���~VXTL���R����aq��lz���W3t��v�������8�o�bv�'g��(z=�.�$�Q6�������[2�����<~��a��������uN{o��\��s�Q������������Ddt����Ta�4NR4\�`�z)�I���.H��/�xA�]�����+����T~~��Ik��������4a	A�[�E��.�Z��^LH����l�����[��#q?�&�xRO"����IE��KI����!���6�&�%��d5��?���T���XE�����4OIB�c[P��|��SP~`���T�������~�%���<CK�����b$��8��l���h�db�k:8=y��u��a���{v~f;�i*�Q�j�g��$CU�G�Kj:��4*��O;��q[�������������;�]�c������W|7
�A�*aWI�O��D����#����NJ�y��p�P�a��`A^D�q>�����}���9!=	>H�N*�6�>a`�e������nx�"�NCSD���E�usK���)#��ON;�������^���������ug^&�4.*[[X����{G]xu�����N�����#�y����]^O�T
���qUV�;8�������f-�T�|^���C;{�;����c����/��*�~�1�%�����
���Dld�26"���;�j���������U��E#s��l�`�������.FQc�j5N��wO��@�bFo��x���[��~u��rl4��v#�&����[�;�F��q������
[+��&[>6^�^p�w������>{{v��5_^���l�������k�Q����U���u+j��h�?���W��A���28[��%�~��yz���Og����9(��*rT;0������a�W������ w�������v���P\�E���L�c�9�
��OO�s3����i'��^F;������F����|��epN�o��qZ�
�G������pW
��W'g�f�������Yg���])?D����`�; |5`6������X0��"H����w�Tpg��+t���NP�Oo�)x�C��3Zw�-/��G[S�
��"�5Q8 
��:�z�����h�l��}�[��R�.W���tr]�u�?|��^����F���z�d����� ����3
uw$�-,�G�rw)�-��%�_V@���"E���N� ���|.G�y]��XG�^��j�NP��t�Z��z�w'$���c��1W��I���W�U4�<r���B��%���"��-��$���'�������z���	��#&�qCe$���
��[�1-��F���|���'G�?@|.����z���Y�������Oa����~��z�C�O�q�;�����3z��x��I����7����7����y
7
�]l�r���Y�(�a+��o��j�u������#�G���c���� �>���Q�o�'����E����|�B?�g�C^�����&�p~��+�g�e����������}�%M�gS��������k�������P������q�$@����>���R�����N�����
��
/�<����c��+�!�v��^����J������%�O���Jh���bz��
�����<��%S��A�V�m���w�<:)V(��/�N�b���0���kti�W�th����W/�|��~��Uu��K�B�}������1�TP3�������SY���f��j�P�>W��)g\S6R8�F�X�,�z5R����Uo��
�.��e��(��� ����J��Q�w������8��/�����#����(KlE��� �o�%�U\�Gf����^�;���_����v{x�|��O������)��yo��vC4��l
�����a�<O���� �xy������sj����o�v[��"�,���Y�Sq3��?���M�H������*��)"����-���E�����M1�)^�]v������l���g��;�������;�.(S1��+�6��~�,�}�����s���N�^��/��U�|��`���|��s��9�cc��g�$,=�>��U�<��[���1w�0[=7����%*�#�0��b��T���p>�#����G6����(4
�
;
Ri,��S��o��0y����Lh�1�����b�}�o�Gm�"���Hf���P:X�=7�+`��c|���+�%��������VM!���+S��^+|�
�d��r��e�.	'�=�B����A@
�>Ir�M�#�����c��0��]������X��U2*C:Jl�#��H'8h���^����[��G��c�l��C�!��h���T�nQ�pS��re� 9=L��

74��Hn>��.-g%	=��O[�?O�R�y>|�=��h�Tt���a��p����Y��E(!����4
���q�L���1���=����������/|H��x��3�r�|�k�7�3��L�m���B�L��Yx����Vs�?�_^z��'n��Q�b��6��H��7�\���g;��e����@^���2�"|9�C�
����#&Q�3|����_�i�,P��|Ppm�&[�4�N��������e�P�v$	@(�E���+	V0&;� ��_�?�{2�(���,<���������D��*R��� =.������^s�$�8yX���R�M��n?�L>�}a��]T�p���(����E����1�le4�R���N�[������&tG��S�S�x�h�	�yLW�����
�(f4��(��k}�n��D
�����j
���{��EX�f^�Hs����:�)��q�9�N�8��?�����8Z��HqS����6Os���������e�EAt��Z]�x~u}���)���8�,�H��_;/��Vx�je+�Rd�8~4�z{���r�h�b�h�����UbHV��-l��#�>����f7�T�e���y��h�>�6@H�e<iV���W�D^�����{��Y-
:���~S�������X����)~^Q���r
~n
�?�<��W

diff --git a/src/backend/commands/copy.c b/src/backend/commands/copy.c
index 7b8bee8..ff55a23 100644
*** a/src/backend/commands/copy.c
--- b/src/backend/commands/copy.c
*************** typedef struct CopyStateData
*** 93,105 ****
  	FILE	   *copy_file;		/* used if copy_dest == COPY_FILE */
  	StringInfo	fe_msgbuf;		/* used for all dests during COPY TO, only for
  								 * dest == COPY_NEW_FE in COPY FROM */
- 	bool		fe_copy;		/* true for all FE copy dests */
  	bool		fe_eof;			/* true if detected end of copy data */
  	EolType		eol_type;		/* EOL type of input */
  	int			client_encoding;	/* remote side's character encoding */
  	bool		need_transcoding;		/* client encoding diff from server? */
  	bool		encoding_embeds_ascii;	/* ASCII can be non-first byte? */
- 	uint64		processed;		/* # of tuples processed */
  
  	/* parameters from the COPY command */
  	Relation	rel;			/* relation to copy to or from */
--- 93,103 ----
*************** typedef struct CopyStateData
*** 119,125 ****
  	bool	   *force_quote_flags;		/* per-column CSV FQ flags */
  	bool	   *force_notnull_flags;	/* per-column CSV FNN flags */
  
! 	/* these are just for error messages, see copy_in_error_callback */
  	const char *cur_relname;	/* table name for error messages */
  	int			cur_lineno;		/* line number for error messages */
  	const char *cur_attname;	/* current att for error messages */
--- 117,123 ----
  	bool	   *force_quote_flags;		/* per-column CSV FQ flags */
  	bool	   *force_notnull_flags;	/* per-column CSV FNN flags */
  
! 	/* these are just for error messages, see CopyFromErrorCallback */
  	const char *cur_relname;	/* table name for error messages */
  	int			cur_lineno;		/* line number for error messages */
  	const char *cur_attname;	/* current att for error messages */
*************** typedef struct CopyStateData
*** 142,150 ****
  	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
--- 140,147 ----
  	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
*************** typedef struct CopyStateData
*** 167,181 ****
  	char	   *raw_buf;
  	int			raw_buf_index;	/* next byte to process */
  	int			raw_buf_len;	/* total # of bytes stored */
- } CopyStateData;
  
! typedef CopyStateData *CopyState;
  
  /* DestReceiver for COPY (SELECT) TO */
  typedef struct
  {
  	DestReceiver pub;			/* publicly-known function pointers */
  	CopyState	cstate;			/* CopyStateData for the command */
  } DR_copy;
  
  
--- 164,191 ----
  	char	   *raw_buf;
  	int			raw_buf_index;	/* next byte to process */
  	int			raw_buf_len;	/* total # of bytes stored */
  
! 	/*
! 	 * The definition of input functions and default expressions are stored
! 	 * in these variables.
! 	 */
! 	EState	   *estate;
! 	AttrNumber	num_defaults;
! 	bool		file_has_oids;
! 	FmgrInfo	oid_in_function;
! 	Oid			oid_typioparam;
! 	FmgrInfo   *in_functions;
! 	Oid		   *typioparams;
! 	int		   *defmap;
! 	ExprState **defexprs;		/* array of default att expressions */
! } CopyStateData;
  
  /* DestReceiver for COPY (SELECT) TO */
  typedef struct
  {
  	DestReceiver pub;			/* publicly-known function pointers */
  	CopyState	cstate;			/* CopyStateData for the command */
+ 	uint64		processed;		/* # of tuples processed */
  } DR_copy;
  
  
*************** static const char BinarySignature[11] = 
*** 248,258 ****
  
  
  /* non-export function prototypes */
! static void DoCopyTo(CopyState cstate);
! static void CopyTo(CopyState cstate);
  static void CopyOneRowTo(CopyState cstate, Oid tupleOid,
  			 Datum *values, bool *nulls);
! static void CopyFrom(CopyState cstate);
  static bool CopyReadLine(CopyState cstate);
  static bool CopyReadLineText(CopyState cstate);
  static int CopyReadAttributesText(CopyState cstate);
--- 258,273 ----
  
  
  /* non-export function prototypes */
! static CopyState BeginCopy(bool is_from, Relation rel, Node *raw_query,
! 				const char *queryString, List *attnamelist, List *options);
! static CopyState BeginCopyTo(Relation rel, Node *query, const char *queryString,
! 				const char *filename, List *attnamelist, List *options);
! static void EndCopyTo(CopyState cstate);
! static uint64 DoCopyTo(CopyState cstate);
! static uint64 CopyTo(CopyState cstate);
  static void CopyOneRowTo(CopyState cstate, Oid tupleOid,
  			 Datum *values, bool *nulls);
! static uint64 CopyFrom(CopyState cstate);
  static bool CopyReadLine(CopyState cstate);
  static bool CopyReadLineText(CopyState cstate);
  static int CopyReadAttributesText(CopyState cstate);
*************** DoCopy(const CopyStmt *stmt, const char 
*** 724,745 ****
  	CopyState	cstate;
  	bool		is_from = stmt->is_from;
  	bool		pipe = (stmt->filename == NULL);
! 	List	   *attnamelist = stmt->attlist;
  	List	   *force_quote = NIL;
  	List	   *force_notnull = NIL;
  	bool		force_quote_all = false;
  	bool		format_specified = false;
- 	AclMode		required_access = (is_from ? ACL_INSERT : ACL_SELECT);
  	ListCell   *option;
  	TupleDesc	tupDesc;
  	int			num_phys_attrs;
- 	uint64		processed;
  
  	/* Allocate workspace and zero all fields */
  	cstate = (CopyStateData *) palloc0(sizeof(CopyStateData));
  
  	/* Extract options from the statement node tree */
! 	foreach(option, stmt->options)
  	{
  		DefElem    *defel = (DefElem *) lfirst(option);
  
--- 739,850 ----
  	CopyState	cstate;
  	bool		is_from = stmt->is_from;
  	bool		pipe = (stmt->filename == NULL);
! 	Relation	rel;
! 	uint64		processed;
! 
! 	/* Disallow file COPY except to superusers. */
! 	if (!pipe && !superuser())
! 		ereport(ERROR,
! 				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
! 				 errmsg("must be superuser to COPY to or from a file"),
! 				 errhint("Anyone can COPY to stdout or from stdin. "
! 						 "psql's \\copy command also works for anyone.")));
! 
! 	if (stmt->relation)
! 	{
! 		TupleDesc		tupDesc;
! 		AclMode			required_access = (is_from ? ACL_INSERT : ACL_SELECT);
! 		RangeTblEntry  *rte;
! 		List		   *attnums;
! 		ListCell	   *cur;
! 
! 		Assert(!stmt->query);
! 
! 		/* Open and lock the relation, using the appropriate lock type. */
! 		rel = heap_openrv(stmt->relation,
! 							 (is_from ? RowExclusiveLock : AccessShareLock));
! 
! 		rte = makeNode(RangeTblEntry);
! 		rte->rtekind = RTE_RELATION;
! 		rte->relid = RelationGetRelid(rel);
! 		rte->requiredPerms = required_access;
! 
! 		tupDesc = RelationGetDescr(rel);
! 		attnums = CopyGetAttnums(tupDesc, rel, stmt->attlist);
! 		foreach (cur, attnums)
! 		{
! 			int		attno = lfirst_int(cur) -
! 							FirstLowInvalidHeapAttributeNumber;
! 
! 			if (is_from)
! 				rte->modifiedCols = bms_add_member(rte->modifiedCols, attno);
! 			else
! 				rte->selectedCols = bms_add_member(rte->selectedCols, attno);
! 		}
! 		ExecCheckRTPerms(list_make1(rte), true);
! 	}
! 	else
! 	{
! 		Assert(stmt->query);
! 
! 		rel = NULL;
! 	}
! 
! 	if (is_from)
! 	{
! 		/* check read-only transaction */
! 		if (XactReadOnly && rel->rd_backend != MyBackendId)
! 			PreventCommandIfReadOnly("COPY FROM");
! 
! 		cstate = BeginCopyFrom(rel, stmt->filename,
! 							   stmt->attlist, stmt->options);
! 		processed = CopyFrom(cstate);	/* copy from file to database */
! 		EndCopyFrom(cstate);
! 	}
! 	else
! 	{
! 		cstate = BeginCopyTo(rel, stmt->query, queryString, stmt->filename,
! 							 stmt->attlist, stmt->options);
! 		processed = DoCopyTo(cstate);		/* copy from database to file */
! 		EndCopyTo(cstate);
! 	}
! 
! 	/*
! 	 * Close the relation. If reading, we can release the AccessShareLock we got;
! 	 * if writing, we should hold the lock until end of transaction to ensure that
! 	 * updates will be committed before lock is released.
! 	 */
! 	if (rel != NULL)
! 		heap_close(rel, (is_from ? NoLock : AccessShareLock));
! 
! 	return processed;
! }
! 
! /*
!  * Common setup routines used by BeginCopyFrom and BeginCopyTo.
!  */
! static CopyState
! BeginCopy(bool is_from,
! 		  Relation rel,
! 		  Node *raw_query,
! 		  const char *queryString,
! 		  List *attnamelist,
! 		  List *options)
! {
! 	CopyState	cstate;
  	List	   *force_quote = NIL;
  	List	   *force_notnull = NIL;
  	bool		force_quote_all = false;
  	bool		format_specified = false;
  	ListCell   *option;
  	TupleDesc	tupDesc;
  	int			num_phys_attrs;
  
  	/* Allocate workspace and zero all fields */
  	cstate = (CopyStateData *) palloc0(sizeof(CopyStateData));
  
  	/* Extract options from the statement node tree */
! 	foreach(option, options)
  	{
  		DefElem    *defel = (DefElem *) lfirst(option);
  
*************** DoCopy(const CopyStmt *stmt, const char 
*** 980,1030 ****
  				(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
  				 errmsg("CSV quote character must not appear in the NULL specification")));
  
! 	/* Disallow file COPY except to superusers. */
! 	if (!pipe && !superuser())
! 		ereport(ERROR,
! 				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
! 				 errmsg("must be superuser to COPY to or from a file"),
! 				 errhint("Anyone can COPY to stdout or from stdin. "
! 						 "psql's \\copy command also works for anyone.")));
! 
! 	if (stmt->relation)
  	{
! 		RangeTblEntry  *rte;
! 		List		   *attnums;
! 		ListCell	   *cur;
! 
! 		Assert(!stmt->query);
! 		cstate->queryDesc = NULL;
  
! 		/* Open and lock the relation, using the appropriate lock type. */
! 		cstate->rel = heap_openrv(stmt->relation,
! 							 (is_from ? RowExclusiveLock : AccessShareLock));
  
  		tupDesc = RelationGetDescr(cstate->rel);
  
- 		/* Check relation permissions. */
- 		rte = makeNode(RangeTblEntry);
- 		rte->rtekind = RTE_RELATION;
- 		rte->relid = RelationGetRelid(cstate->rel);
- 		rte->requiredPerms = required_access;
- 
- 		attnums = CopyGetAttnums(tupDesc, cstate->rel, attnamelist);
- 		foreach (cur, attnums)
- 		{
- 			int		attno = lfirst_int(cur) - FirstLowInvalidHeapAttributeNumber;
- 
- 			if (is_from)
- 				rte->modifiedCols = bms_add_member(rte->modifiedCols, attno);
- 			else
- 				rte->selectedCols = bms_add_member(rte->selectedCols, attno);
- 		}
- 		ExecCheckRTPerms(list_make1(rte), true);
- 
- 		/* check read-only transaction */
- 		if (XactReadOnly && is_from && cstate->rel->rd_backend != MyBackendId)
- 			PreventCommandIfReadOnly("COPY FROM");
- 
  		/* Don't allow COPY w/ OIDs to or from a table without them */
  		if (cstate->oids && !cstate->rel->rd_rel->relhasoids)
  			ereport(ERROR,
--- 1085,1098 ----
  				(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
  				 errmsg("CSV quote character must not appear in the NULL specification")));
  
! 	if (rel)
  	{
! 		Assert(!raw_query);
  
! 		cstate->rel = rel;
  
  		tupDesc = RelationGetDescr(cstate->rel);
  
  		/* Don't allow COPY w/ OIDs to or from a table without them */
  		if (cstate->oids && !cstate->rel->rd_rel->relhasoids)
  			ereport(ERROR,
*************** DoCopy(const CopyStmt *stmt, const char 
*** 1058,1064 ****
  		 * function and is executed repeatedly.  (See also the same hack in
  		 * DECLARE CURSOR and PREPARE.)  XXX FIXME someday.
  		 */
! 		rewritten = pg_analyze_and_rewrite((Node *) copyObject(stmt->query),
  										   queryString, NULL, 0);
  
  		/* We don't expect more or less than one result query */
--- 1126,1132 ----
  		 * function and is executed repeatedly.  (See also the same hack in
  		 * DECLARE CURSOR and PREPARE.)  XXX FIXME someday.
  		 */
! 		rewritten = pg_analyze_and_rewrite((Node *) copyObject(raw_query),
  										   queryString, NULL, 0);
  
  		/* We don't expect more or less than one result query */
*************** DoCopy(const CopyStmt *stmt, const char 
*** 1160,1173 ****
  		}
  	}
  
- 	/* Set up variables to avoid per-attribute overhead. */
- 	initStringInfo(&cstate->attribute_buf);
- 	initStringInfo(&cstate->line_buf);
- 	cstate->line_buf_converted = false;
- 	cstate->raw_buf = (char *) palloc(RAW_BUF_SIZE + 1);
- 	cstate->raw_buf_index = cstate->raw_buf_len = 0;
- 	cstate->processed = 0;
- 
  	/*
  	 * Set up encoding conversion info.  Even if the client and server
  	 * encodings are the same, we must apply pg_client_to_server() to validate
--- 1228,1233 ----
*************** DoCopy(const CopyStmt *stmt, const char 
*** 1181,1229 ****
  	cstate->encoding_embeds_ascii = PG_ENCODING_IS_CLIENT_ONLY(cstate->client_encoding);
  
  	cstate->copy_dest = COPY_FILE;		/* default */
- 	cstate->filename = stmt->filename;
- 
- 	if (is_from)
- 		CopyFrom(cstate);		/* copy from file to database */
- 	else
- 		DoCopyTo(cstate);		/* copy from database to file */
  
! 	/*
! 	 * Close the relation or query.  If reading, we can release the
! 	 * AccessShareLock we got; if writing, we should hold the lock until end
! 	 * of transaction to ensure that updates will be committed before lock is
! 	 * released.
! 	 */
! 	if (cstate->rel)
! 		heap_close(cstate->rel, (is_from ? NoLock : AccessShareLock));
! 	else
! 	{
! 		/* Close down the query and free resources. */
! 		ExecutorEnd(cstate->queryDesc);
! 		FreeQueryDesc(cstate->queryDesc);
! 		PopActiveSnapshot();
! 	}
! 
! 	/* Clean up storage (probably not really necessary) */
! 	processed = cstate->processed;
! 
! 	pfree(cstate->attribute_buf.data);
! 	pfree(cstate->line_buf.data);
! 	pfree(cstate->raw_buf);
! 	pfree(cstate);
! 
! 	return processed;
  }
  
  
  /*
!  * This intermediate routine exists mainly to localize the effects of setjmp
!  * so we don't need to plaster a lot of variables with "volatile".
   */
! static void
! DoCopyTo(CopyState cstate)
  {
! 	bool		pipe = (cstate->filename == NULL);
  
  	if (cstate->rel)
  	{
--- 1241,1266 ----
  	cstate->encoding_embeds_ascii = PG_ENCODING_IS_CLIENT_ONLY(cstate->client_encoding);
  
  	cstate->copy_dest = COPY_FILE;		/* default */
  
! 	return cstate;
  }
  
  
  /*
!  * Setup CopyState to read tuples from a table or a query for COPY TO.
   */
! static CopyState
! BeginCopyTo(Relation rel,
! 			Node *query,
! 			const char *queryString,
! 			const char *filename,
! 			List *attnamelist,
! 			List *options)
  {
! 	CopyState	cstate;
! 	bool		pipe = (filename == NULL);
! 
! 	cstate = BeginCopy(false, rel, query, queryString, attnamelist, options);
  
  	if (cstate->rel)
  	{
*************** DoCopyTo(CopyState cstate)
*** 1250,1258 ****
  
  	if (pipe)
  	{
! 		if (whereToSendOutput == DestRemote)
! 			cstate->fe_copy = true;
! 		else
  			cstate->copy_file = stdout;
  	}
  	else
--- 1287,1293 ----
  
  	if (pipe)
  	{
! 		if (whereToSendOutput != DestRemote)
  			cstate->copy_file = stdout;
  	}
  	else
*************** DoCopyTo(CopyState cstate)
*** 1264,1274 ****
  		 * Prevent write to relative path ... too easy to shoot oneself in the
  		 * foot by overwriting a database file ...
  		 */
! 		if (!is_absolute_path(cstate->filename))
  			ereport(ERROR,
  					(errcode(ERRCODE_INVALID_NAME),
  					 errmsg("relative path not allowed for COPY to file")));
  
  		oumask = umask(S_IWGRP | S_IWOTH);
  		cstate->copy_file = AllocateFile(cstate->filename, PG_BINARY_W);
  		umask(oumask);
--- 1299,1310 ----
  		 * Prevent write to relative path ... too easy to shoot oneself in the
  		 * foot by overwriting a database file ...
  		 */
! 		if (!is_absolute_path(filename))
  			ereport(ERROR,
  					(errcode(ERRCODE_INVALID_NAME),
  					 errmsg("relative path not allowed for COPY to file")));
  
+ 		cstate->filename = pstrdup(filename);
  		oumask = umask(S_IWGRP | S_IWOTH);
  		cstate->copy_file = AllocateFile(cstate->filename, PG_BINARY_W);
  		umask(oumask);
*************** DoCopyTo(CopyState cstate)
*** 1286,1299 ****
  					 errmsg("\"%s\" is a directory", cstate->filename)));
  	}
  
  	PG_TRY();
  	{
! 		if (cstate->fe_copy)
  			SendCopyBegin(cstate);
  
! 		CopyTo(cstate);
  
! 		if (cstate->fe_copy)
  			SendCopyEnd(cstate);
  	}
  	PG_CATCH();
--- 1322,1349 ----
  					 errmsg("\"%s\" is a directory", cstate->filename)));
  	}
  
+ 	return cstate;
+ }
+ 
+ /*
+  * This intermediate routine exists mainly to localize the effects of setjmp
+  * so we don't need to plaster a lot of variables with "volatile".
+  */
+ static uint64
+ DoCopyTo(CopyState cstate)
+ {
+ 	bool		pipe = (cstate->filename == NULL);
+ 	bool		fe_copy = (pipe && whereToSendOutput == DestRemote);
+ 	uint64		processed;
+ 
  	PG_TRY();
  	{
! 		if (fe_copy)
  			SendCopyBegin(cstate);
  
! 		processed = CopyTo(cstate);
  
! 		if (fe_copy)
  			SendCopyEnd(cstate);
  	}
  	PG_CATCH();
*************** DoCopyTo(CopyState cstate)
*** 1308,1333 ****
  	}
  	PG_END_TRY();
  
! 	if (!pipe)
  	{
  		if (FreeFile(cstate->copy_file))
  			ereport(ERROR,
  					(errcode_for_file_access(),
! 					 errmsg("could not write to file \"%s\": %m",
  							cstate->filename)));
  	}
  }
  
  /*
   * Copy from relation or query TO file.
   */
! static void
  CopyTo(CopyState cstate)
  {
  	TupleDesc	tupDesc;
  	int			num_phys_attrs;
  	Form_pg_attribute *attr;
  	ListCell   *cur;
  
  	if (cstate->rel)
  		tupDesc = RelationGetDescr(cstate->rel);
--- 1358,1408 ----
  	}
  	PG_END_TRY();
  
! 	return processed;
! }
! 
! /*
!  * Clean up storage and release resources for COPY TO.
!  */
! static void
! EndCopyTo(CopyState cstate)
! {
! 	if (cstate->filename)
  	{
  		if (FreeFile(cstate->copy_file))
  			ereport(ERROR,
  					(errcode_for_file_access(),
! 					 errmsg("could not close file \"%s\": %m",
  							cstate->filename)));
+ 
+ 		pfree(cstate->filename);
  	}
+ 
+ 	/*
+ 	 * Close the relation or query. We can release the AccessShareLock we got.
+ 	 */
+ 	if (cstate->rel == NULL)
+ 	{
+ 		/* Close down the query and free resources. */
+ 		ExecutorEnd(cstate->queryDesc);
+ 		FreeQueryDesc(cstate->queryDesc);
+ 		PopActiveSnapshot();
+ 	}
+ 
+ 	pfree(cstate);
  }
  
  /*
   * Copy from relation or query TO file.
   */
! static uint64
  CopyTo(CopyState cstate)
  {
  	TupleDesc	tupDesc;
  	int			num_phys_attrs;
  	Form_pg_attribute *attr;
  	ListCell   *cur;
+ 	uint64		processed;
  
  	if (cstate->rel)
  		tupDesc = RelationGetDescr(cstate->rel);
*************** CopyTo(CopyState cstate)
*** 1433,1438 ****
--- 1508,1514 ----
  
  		scandesc = heap_beginscan(cstate->rel, GetActiveSnapshot(), 0, NULL);
  
+ 		processed = 0;
  		while ((tuple = heap_getnext(scandesc, ForwardScanDirection)) != NULL)
  		{
  			CHECK_FOR_INTERRUPTS();
*************** CopyTo(CopyState cstate)
*** 1442,1447 ****
--- 1518,1524 ----
  
  			/* Format and send the data */
  			CopyOneRowTo(cstate, HeapTupleGetOid(tuple), values, nulls);
+ 			processed++;
  		}
  
  		heap_endscan(scandesc);
*************** CopyTo(CopyState cstate)
*** 1450,1455 ****
--- 1527,1533 ----
  	{
  		/* run the plan --- the dest receiver will send tuples */
  		ExecutorRun(cstate->queryDesc, ForwardScanDirection, 0L);
+ 		processed = ((DR_copy *) cstate->queryDesc->dest)->processed;
  	}
  
  	if (cstate->binary)
*************** CopyTo(CopyState cstate)
*** 1461,1466 ****
--- 1539,1546 ----
  	}
  
  	MemoryContextDelete(cstate->rowcontext);
+ 
+ 	return processed;
  }
  
  /*
*************** CopyOneRowTo(CopyState cstate, Oid tuple
*** 1552,1567 ****
  	CopySendEndOfRow(cstate);
  
  	MemoryContextSwitchTo(oldcontext);
- 
- 	cstate->processed++;
  }
  
  
  /*
   * error context callback for COPY FROM
   */
! static void
! copy_in_error_callback(void *arg)
  {
  	CopyState	cstate = (CopyState) arg;
  
--- 1632,1645 ----
  	CopySendEndOfRow(cstate);
  
  	MemoryContextSwitchTo(oldcontext);
  }
  
  
  /*
   * error context callback for COPY FROM
   */
! void
! CopyFromErrorCallback(void *arg)
  {
  	CopyState	cstate = (CopyState) arg;
  
*************** limit_printout_length(const char *str)
*** 1663,1703 ****
  /*
   * Copy FROM file to relation.
   */
! static void
  CopyFrom(CopyState cstate)
  {
- 	bool		pipe = (cstate->filename == NULL);
  	HeapTuple	tuple;
  	TupleDesc	tupDesc;
- 	Form_pg_attribute *attr;
- 	AttrNumber	num_phys_attrs,
- 				attr_count,
- 				num_defaults;
- 	FmgrInfo   *in_functions;
- 	FmgrInfo	oid_in_function;
- 	Oid		   *typioparams;
- 	Oid			oid_typioparam;
- 	int			attnum;
- 	int			i;
- 	Oid			in_func_oid;
  	Datum	   *values;
  	bool	   *nulls;
- 	int			nfields;
- 	char	  **field_strings;
  	bool		done = false;
- 	bool		isnull;
  	ResultRelInfo *resultRelInfo;
! 	EState	   *estate = CreateExecutorState(); /* for ExecConstraints() */
  	TupleTableSlot *slot;
- 	bool		file_has_oids;
- 	int		   *defmap;
- 	ExprState **defexprs;		/* array of default att expressions */
- 	ExprContext *econtext;		/* used for ExecEvalExpr for default atts */
  	MemoryContext oldcontext = CurrentMemoryContext;
  	ErrorContextCallback errcontext;
  	CommandId	mycid = GetCurrentCommandId(true);
  	int			hi_options = 0; /* start with default heap_insert options */
  	BulkInsertState bistate;
  
  	Assert(cstate->rel);
  
--- 1741,1763 ----
  /*
   * Copy FROM file to relation.
   */
! static uint64
  CopyFrom(CopyState cstate)
  {
  	HeapTuple	tuple;
  	TupleDesc	tupDesc;
  	Datum	   *values;
  	bool	   *nulls;
  	bool		done = false;
  	ResultRelInfo *resultRelInfo;
! 	EState	   *estate; /* for ExecConstraints() */
  	TupleTableSlot *slot;
  	MemoryContext oldcontext = CurrentMemoryContext;
  	ErrorContextCallback errcontext;
  	CommandId	mycid = GetCurrentCommandId(true);
  	int			hi_options = 0; /* start with default heap_insert options */
  	BulkInsertState bistate;
+ 	uint64		processed = 0;
  
  	Assert(cstate->rel);
  
*************** CopyFrom(CopyState cstate)
*** 1720,1725 ****
--- 1780,1788 ----
  							RelationGetRelationName(cstate->rel))));
  	}
  
+ 	estate = GetCopyExecutorState(cstate);
+ 	tupDesc = RelationGetDescr(cstate->rel);
+ 
  	/*----------
  	 * Check to see if we can avoid writing WAL
  	 *
*************** CopyFrom(CopyState cstate)
*** 1755,1792 ****
  			hi_options |= HEAP_INSERT_SKIP_WAL;
  	}
  
- 	if (pipe)
- 	{
- 		if (whereToSendOutput == DestRemote)
- 			ReceiveCopyBegin(cstate);
- 		else
- 			cstate->copy_file = stdin;
- 	}
- 	else
- 	{
- 		struct stat st;
- 
- 		cstate->copy_file = AllocateFile(cstate->filename, PG_BINARY_R);
- 
- 		if (cstate->copy_file == NULL)
- 			ereport(ERROR,
- 					(errcode_for_file_access(),
- 					 errmsg("could not open file \"%s\" for reading: %m",
- 							cstate->filename)));
- 
- 		fstat(fileno(cstate->copy_file), &st);
- 		if (S_ISDIR(st.st_mode))
- 			ereport(ERROR,
- 					(errcode(ERRCODE_WRONG_OBJECT_TYPE),
- 					 errmsg("\"%s\" is a directory", cstate->filename)));
- 	}
- 
- 	tupDesc = RelationGetDescr(cstate->rel);
- 	attr = tupDesc->attrs;
- 	num_phys_attrs = tupDesc->natts;
- 	attr_count = list_length(cstate->attnumlist);
- 	num_defaults = 0;
- 
  	/*
  	 * We need a ResultRelInfo so we can use the regular executor's
  	 * index-entry-making machinery.  (There used to be a huge amount of code
--- 1818,1823 ----
*************** CopyFrom(CopyState cstate)
*** 1815,1821 ****
  	slot = ExecInitExtraTupleSlot(estate);
  	ExecSetSlotDescriptor(slot, tupDesc);
  
! 	econtext = GetPerTupleExprContext(estate);
  
  	/*
  	 * Pick up the required catalog information for each attribute in the
--- 1846,2027 ----
  	slot = ExecInitExtraTupleSlot(estate);
  	ExecSetSlotDescriptor(slot, tupDesc);
  
! 	/* Prepare to catch AFTER triggers. */
! 	AfterTriggerBeginQuery();
! 
! 	/*
! 	 * Check BEFORE STATEMENT insertion triggers. It's debateable whether we
! 	 * should do this for COPY, since it's not really an "INSERT" statement as
! 	 * such. However, executing these triggers maintains consistency with the
! 	 * EACH ROW triggers that we already fire on COPY.
! 	 */
! 	ExecBSInsertTriggers(estate, resultRelInfo);
! 
! 	values = (Datum *) palloc(tupDesc->natts * sizeof(Datum));
! 	nulls = (bool *) palloc(tupDesc->natts * sizeof(bool));
! 
! 	bistate = GetBulkInsertState();
! 
! 	/* Set up callback to identify error line number */
! 	errcontext.callback = CopyFromErrorCallback;
! 	errcontext.arg = (void *) cstate;
! 	errcontext.previous = error_context_stack;
! 	error_context_stack = &errcontext;
! 
! 	while (!done)
! 	{
! 		bool		skip_tuple;
! 		Oid			loaded_oid = InvalidOid;
! 
! 		CHECK_FOR_INTERRUPTS();
! 
! 		/* Reset the per-tuple exprcontext */
! 		ResetPerTupleExprContext(estate);
! 
! 		/* Switch into its memory context */
! 		MemoryContextSwitchTo(GetPerTupleMemoryContext(estate));
! 
! 		done = !NextCopyFrom(cstate, values, nulls, &loaded_oid);
! 		if (done)
! 			break;
! 
! 		/* And now we can form the input tuple. */
! 		tuple = heap_form_tuple(tupDesc, values, nulls);
! 
! 		if (loaded_oid != InvalidOid)
! 			HeapTupleSetOid(tuple, loaded_oid);
! 
! 		/* Triggers and stuff need to be invoked in query context. */
! 		MemoryContextSwitchTo(oldcontext);
! 
! 		skip_tuple = false;
! 
! 		/* BEFORE ROW INSERT Triggers */
! 		if (resultRelInfo->ri_TrigDesc &&
! 			resultRelInfo->ri_TrigDesc->trig_insert_before_row)
! 		{
! 			HeapTuple	newtuple;
! 
! 			newtuple = ExecBRInsertTriggers(estate, resultRelInfo, tuple);
! 
! 			if (newtuple == NULL)		/* "do nothing" */
! 				skip_tuple = true;
! 			else if (newtuple != tuple) /* modified by Trigger(s) */
! 			{
! 				heap_freetuple(tuple);
! 				tuple = newtuple;
! 			}
! 		}
! 
! 		if (!skip_tuple)
! 		{
! 			List	   *recheckIndexes = NIL;
! 
! 			/* Place tuple in tuple slot */
! 			ExecStoreTuple(tuple, slot, InvalidBuffer, false);
! 
! 			/* Check the constraints of the tuple */
! 			if (cstate->rel->rd_att->constr)
! 				ExecConstraints(resultRelInfo, slot, estate);
! 
! 			/* OK, store the tuple and create index entries for it */
! 			heap_insert(cstate->rel, tuple, mycid, hi_options, bistate);
! 
! 			if (resultRelInfo->ri_NumIndices > 0)
! 				recheckIndexes = ExecInsertIndexTuples(slot, &(tuple->t_self),
! 													   estate);
! 
! 			/* AFTER ROW INSERT Triggers */
! 			ExecARInsertTriggers(estate, resultRelInfo, tuple,
! 								 recheckIndexes);
! 
! 			list_free(recheckIndexes);
! 
! 			/*
! 			 * We count only tuples not suppressed by a BEFORE INSERT trigger;
! 			 * this is the same definition used by execMain.c for counting
! 			 * tuples inserted by an INSERT command.
! 			 */
! 			processed++;
! 		}
! 	}
! 
! 	/* Done, clean up */
! 	error_context_stack = errcontext.previous;
! 
! 	FreeBulkInsertState(bistate);
! 
! 	MemoryContextSwitchTo(oldcontext);
! 
! 	/* Execute AFTER STATEMENT insertion triggers */
! 	ExecASInsertTriggers(estate, resultRelInfo);
! 
! 	/* Handle queued AFTER triggers */
! 	AfterTriggerEndQuery(estate);
! 
! 	pfree(values);
! 	pfree(nulls);
! 
! 	ExecResetTupleTable(estate->es_tupleTable, false);
! 
! 	ExecCloseIndices(resultRelInfo);
! 
! 	/*
! 	 * If we skipped writing WAL, then we need to sync the heap (but not
! 	 * indexes since those use WAL anyway)
! 	 */
! 	if (hi_options & HEAP_INSERT_SKIP_WAL)
! 		heap_sync(cstate->rel);
! 
! 	return processed;
! }
! 
! /*
!  * Setup CopyState to read tuples from a file for COPY FROM.
!  */
! CopyState
! BeginCopyFrom(Relation rel,
! 			  const char *filename,
! 			  List *attnamelist,
! 			  List *options)
! {
! 	CopyState	cstate;
! 	bool		pipe = (filename == NULL);
! 	TupleDesc	tupDesc;
! 	Form_pg_attribute *attr;
! 	AttrNumber	num_phys_attrs,
! 				attr_count,
! 				num_defaults;
! 	FmgrInfo   *in_functions;
! 	Oid		   *typioparams;
! 	int			attnum;
! 	Oid			in_func_oid;
! 	EState	   *estate = CreateExecutorState(); /* for ExecPrepareExpr() */
! 	int		   *defmap;
! 	ExprState **defexprs;
! 
! 	cstate = BeginCopy(true, rel, NULL, NULL, attnamelist, options);
! 
! 	/* Initialize state variables */
! 	cstate->fe_eof = false;
! 	cstate->eol_type = EOL_UNKNOWN;
! 	cstate->cur_relname = RelationGetRelationName(cstate->rel);
! 	cstate->cur_lineno = 0;
! 	cstate->cur_attname = NULL;
! 	cstate->cur_attval = NULL;
! 
! 	/* Set up variables to avoid per-attribute overhead. */
! 	initStringInfo(&cstate->attribute_buf);
! 	initStringInfo(&cstate->line_buf);
! 	cstate->line_buf_converted = false;
! 	cstate->raw_buf = (char *) palloc(RAW_BUF_SIZE + 1);
! 	cstate->raw_buf_index = cstate->raw_buf_len = 0;
! 
! 	tupDesc = RelationGetDescr(cstate->rel);
! 	attr = tupDesc->attrs;
! 	num_phys_attrs = tupDesc->natts;
! 	attr_count = list_length(cstate->attnumlist);
! 	num_defaults = 0;
  
  	/*
  	 * Pick up the required catalog information for each attribute in the
*************** CopyFrom(CopyState cstate)
*** 1860,1878 ****
  		}
  	}
  
! 	/* Prepare to catch AFTER triggers. */
! 	AfterTriggerBeginQuery();
  
! 	/*
! 	 * Check BEFORE STATEMENT insertion triggers. It's debateable whether we
! 	 * should do this for COPY, since it's not really an "INSERT" statement as
! 	 * such. However, executing these triggers maintains consistency with the
! 	 * EACH ROW triggers that we already fire on COPY.
! 	 */
! 	ExecBSInsertTriggers(estate, resultRelInfo);
  
  	if (!cstate->binary)
! 		file_has_oids = cstate->oids;	/* must rely on user to tell us... */
  	else
  	{
  		/* Read and verify binary header */
--- 2066,2111 ----
  		}
  	}
  
! 	/* We keep those variables in cstate. */
! 	cstate->estate = estate;
! 	cstate->in_functions = in_functions;
! 	cstate->typioparams = typioparams;
! 	cstate->defmap = defmap;
! 	cstate->defexprs = defexprs;
! 	cstate->num_defaults = num_defaults;
  
! 	if (pipe)
! 	{
! 		if (whereToSendOutput == DestRemote)
! 			ReceiveCopyBegin(cstate);
! 		else
! 			cstate->copy_file = stdin;
! 	}
! 	else
! 	{
! 		struct stat st;
! 
! 		cstate->filename = pstrdup(filename);
! 		cstate->copy_file = AllocateFile(cstate->filename, PG_BINARY_R);
! 
! 		if (cstate->copy_file == NULL)
! 			ereport(ERROR,
! 					(errcode_for_file_access(),
! 					 errmsg("could not open file \"%s\" for reading: %m",
! 							cstate->filename)));
! 
! 		fstat(fileno(cstate->copy_file), &st);
! 		if (S_ISDIR(st.st_mode))
! 			ereport(ERROR,
! 					(errcode(ERRCODE_WRONG_OBJECT_TYPE),
! 					 errmsg("\"%s\" is a directory", cstate->filename)));
! 	}
  
  	if (!cstate->binary)
! 	{
! 		/* must rely on user to tell us... */
! 		cstate->file_has_oids = cstate->oids;
! 	}
  	else
  	{
  		/* Read and verify binary header */
*************** CopyFrom(CopyState cstate)
*** 1890,1896 ****
  			ereport(ERROR,
  					(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
  					 errmsg("invalid COPY file header (missing flags)")));
! 		file_has_oids = (tmp & (1 << 16)) != 0;
  		tmp &= ~(1 << 16);
  		if ((tmp >> 16) != 0)
  			ereport(ERROR,
--- 2123,2129 ----
  			ereport(ERROR,
  					(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
  					 errmsg("invalid COPY file header (missing flags)")));
! 		cstate->file_has_oids = (tmp & (1 << 16)) != 0;
  		tmp &= ~(1 << 16);
  		if ((tmp >> 16) != 0)
  			ereport(ERROR,
*************** CopyFrom(CopyState cstate)
*** 1912,1973 ****
  		}
  	}
  
! 	if (file_has_oids && cstate->binary)
  	{
  		getTypeBinaryInputInfo(OIDOID,
! 							   &in_func_oid, &oid_typioparam);
! 		fmgr_info(in_func_oid, &oid_in_function);
  	}
  
- 	values = (Datum *) palloc(num_phys_attrs * sizeof(Datum));
- 	nulls = (bool *) palloc(num_phys_attrs * sizeof(bool));
- 
  	/* create workspace for CopyReadAttributes results */
! 	nfields = file_has_oids ? (attr_count + 1) : attr_count;
! 	if (! cstate->binary)
  	{
  		cstate->max_fields = nfields;
  		cstate->raw_fields = (char **) palloc(nfields * sizeof(char *));
  	}
  
! 	/* Initialize state variables */
! 	cstate->fe_eof = false;
! 	cstate->eol_type = EOL_UNKNOWN;
! 	cstate->cur_relname = RelationGetRelationName(cstate->rel);
! 	cstate->cur_lineno = 0;
! 	cstate->cur_attname = NULL;
! 	cstate->cur_attval = NULL;
! 
! 	bistate = GetBulkInsertState();
  
! 	/* Set up callback to identify error line number */
! 	errcontext.callback = copy_in_error_callback;
! 	errcontext.arg = (void *) cstate;
! 	errcontext.previous = error_context_stack;
! 	error_context_stack = &errcontext;
  
  	/* on input just throw the header line away */
! 	if (cstate->header_line)
  	{
  		cstate->cur_lineno++;
! 		done = CopyReadLine(cstate);
  	}
  
! 	while (!done)
! 	{
! 		bool		skip_tuple;
! 		Oid			loaded_oid = InvalidOid;
! 
! 		CHECK_FOR_INTERRUPTS();
  
  		cstate->cur_lineno++;
  
- 		/* Reset the per-tuple exprcontext */
- 		ResetPerTupleExprContext(estate);
- 
- 		/* Switch into its memory context */
- 		MemoryContextSwitchTo(GetPerTupleMemoryContext(estate));
- 
  		/* Initialize all values for row to NULL */
  		MemSet(values, 0, num_phys_attrs * sizeof(Datum));
  		MemSet(nulls, true, num_phys_attrs * sizeof(bool));
--- 2145,2212 ----
  		}
  	}
  
! 	if (cstate->file_has_oids && cstate->binary)
  	{
  		getTypeBinaryInputInfo(OIDOID,
! 							   &in_func_oid, &cstate->oid_typioparam);
! 		fmgr_info(in_func_oid, &cstate->oid_in_function);
  	}
  
  	/* create workspace for CopyReadAttributes results */
! 	if (!cstate->binary)
  	{
+ 		int	nfields = cstate->file_has_oids ? (attr_count + 1) : attr_count;
+ 
  		cstate->max_fields = nfields;
  		cstate->raw_fields = (char **) palloc(nfields * sizeof(char *));
  	}
  
! 	return cstate;
! }
  
! /*
!  * Read next tuple from file for COPY FROM. Return false if no more tuples.
!  *
!  * valus and nulls arrays must be the same length as columns of the
!  * relation passed to BeginCopyFrom. Oid of the tuple is returned with
!  * tupleOid separately.
!  */
! bool
! NextCopyFrom(CopyState cstate, Datum *values, bool *nulls, Oid *tupleOid)
! {
! 	TupleDesc	tupDesc;
! 	Form_pg_attribute *attr;
! 	AttrNumber	num_phys_attrs,
! 				attr_count,
! 				num_defaults = cstate->num_defaults;
! 	FmgrInfo   *in_functions = cstate->in_functions;
! 	Oid		   *typioparams = cstate->typioparams;
! 	int			i;
! 	int			nfields;
! 	char	  **field_strings;
! 	bool		isnull;
! 	bool		file_has_oids = cstate->file_has_oids;
! 	int		   *defmap = cstate->defmap;
! 	ExprState **defexprs = cstate->defexprs;
! 	ExprContext	*econtext;		/* used for ExecEvalExpr for default atts */
  
  	/* on input just throw the header line away */
! 	if (cstate->cur_lineno == 0 && cstate->header_line)
  	{
  		cstate->cur_lineno++;
! 		if (CopyReadLine(cstate))
! 			return false;	/* done */
  	}
  
! 	tupDesc = RelationGetDescr(cstate->rel);
! 	attr = tupDesc->attrs;
! 	num_phys_attrs = tupDesc->natts;
! 	attr_count = list_length(cstate->attnumlist);
! 	nfields = file_has_oids ? (attr_count + 1) : attr_count;
  
+ 	/* XXX: Indentation is not adjusted to keep the patch small. */
  		cstate->cur_lineno++;
  
  		/* Initialize all values for row to NULL */
  		MemSet(values, 0, num_phys_attrs * sizeof(Datum));
  		MemSet(nulls, true, num_phys_attrs * sizeof(bool));
*************** CopyFrom(CopyState cstate)
*** 1978,1983 ****
--- 2217,2223 ----
  			int			fldct;
  			int			fieldno;
  			char	   *string;
+ 			bool		done;
  
  			/* Actually read the line into memory here */
  			done = CopyReadLine(cstate);
*************** CopyFrom(CopyState cstate)
*** 1988,1994 ****
  			 * EOF, ie, process the line and then exit loop on next iteration.
  			 */
  			if (done && cstate->line_buf.len == 0)
! 				break;
  
  			/* Parse the line into de-escaped field values */
  			if (cstate->csv_mode)
--- 2228,2234 ----
  			 * EOF, ie, process the line and then exit loop on next iteration.
  			 */
  			if (done && cstate->line_buf.len == 0)
! 				return false;
  
  			/* Parse the line into de-escaped field values */
  			if (cstate->csv_mode)
*************** CopyFrom(CopyState cstate)
*** 2018,2030 ****
  					ereport(ERROR,
  							(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
  							 errmsg("null OID in COPY data")));
! 				else
  				{
  					cstate->cur_attname = "oid";
  					cstate->cur_attval = string;
! 					loaded_oid = DatumGetObjectId(DirectFunctionCall1(oidin,
! 												   CStringGetDatum(string)));
! 					if (loaded_oid == InvalidOid)
  						ereport(ERROR,
  								(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
  								 errmsg("invalid OID in COPY data")));
--- 2258,2270 ----
  					ereport(ERROR,
  							(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
  							 errmsg("null OID in COPY data")));
! 				else if (cstate->oids && tupleOid != NULL)
  				{
  					cstate->cur_attname = "oid";
  					cstate->cur_attval = string;
! 					*tupleOid = DatumGetObjectId(DirectFunctionCall1(oidin,
! 													   CStringGetDatum(string)));
! 					if (*tupleOid == InvalidOid)
  						ereport(ERROR,
  								(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
  								 errmsg("invalid OID in COPY data")));
*************** CopyFrom(CopyState cstate)
*** 2076,2083 ****
  			if (!CopyGetInt16(cstate, &fld_count))
  			{
  				/* EOF detected (end of file, or protocol-level EOF) */
! 				done = true;
! 				break;
  			}
  
  			if (fld_count == -1)
--- 2316,2322 ----
  			if (!CopyGetInt16(cstate, &fld_count))
  			{
  				/* EOF detected (end of file, or protocol-level EOF) */
! 				return false;
  			}
  
  			if (fld_count == -1)
*************** CopyFrom(CopyState cstate)
*** 2101,2108 ****
  					ereport(ERROR,
  							(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
  							 errmsg("received copy data after EOF marker")));
! 				done = true;
! 				break;
  			}
  
  			if (fld_count != attr_count)
--- 2340,2346 ----
  					ereport(ERROR,
  							(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
  							 errmsg("received copy data after EOF marker")));
! 				return false;
  			}
  
  			if (fld_count != attr_count)
*************** CopyFrom(CopyState cstate)
*** 2113,2124 ****
  
  			if (file_has_oids)
  			{
  				cstate->cur_attname = "oid";
  				loaded_oid =
  					DatumGetObjectId(CopyReadBinaryAttribute(cstate,
  															 0,
! 															 &oid_in_function,
! 															 oid_typioparam,
  															 -1,
  															 &isnull));
  				if (isnull || loaded_oid == InvalidOid)
--- 2351,2364 ----
  
  			if (file_has_oids)
  			{
+ 				Oid		loaded_oid;
+ 
  				cstate->cur_attname = "oid";
  				loaded_oid =
  					DatumGetObjectId(CopyReadBinaryAttribute(cstate,
  															 0,
! 															 &cstate->oid_in_function,
! 															 cstate->oid_typioparam,
  															 -1,
  															 &isnull));
  				if (isnull || loaded_oid == InvalidOid)
*************** CopyFrom(CopyState cstate)
*** 2126,2131 ****
--- 2366,2373 ----
  							(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
  							 errmsg("invalid OID in COPY data")));
  				cstate->cur_attname = NULL;
+ 				if (cstate->oids && tupleOid != NULL)
+ 					*tupleOid = loaded_oid;
  			}
  
  			i = 0;
*************** CopyFrom(CopyState cstate)
*** 2151,2267 ****
  		 * provided by the input data.	Anything not processed here or above
  		 * will remain NULL.
  		 */
  		for (i = 0; i < num_defaults; i++)
  		{
  			values[defmap[i]] = ExecEvalExpr(defexprs[i], econtext,
  											 &nulls[defmap[i]], NULL);
  		}
  
! 		/* And now we can form the input tuple. */
! 		tuple = heap_form_tuple(tupDesc, values, nulls);
! 
! 		if (cstate->oids && file_has_oids)
! 			HeapTupleSetOid(tuple, loaded_oid);
! 
! 		/* Triggers and stuff need to be invoked in query context. */
! 		MemoryContextSwitchTo(oldcontext);
! 
! 		skip_tuple = false;
! 
! 		/* BEFORE ROW INSERT Triggers */
! 		if (resultRelInfo->ri_TrigDesc &&
! 			resultRelInfo->ri_TrigDesc->trig_insert_before_row)
! 		{
! 			HeapTuple	newtuple;
! 
! 			newtuple = ExecBRInsertTriggers(estate, resultRelInfo, tuple);
! 
! 			if (newtuple == NULL)		/* "do nothing" */
! 				skip_tuple = true;
! 			else if (newtuple != tuple) /* modified by Trigger(s) */
! 			{
! 				heap_freetuple(tuple);
! 				tuple = newtuple;
! 			}
! 		}
! 
! 		if (!skip_tuple)
! 		{
! 			List	   *recheckIndexes = NIL;
! 
! 			/* Place tuple in tuple slot */
! 			ExecStoreTuple(tuple, slot, InvalidBuffer, false);
! 
! 			/* Check the constraints of the tuple */
! 			if (cstate->rel->rd_att->constr)
! 				ExecConstraints(resultRelInfo, slot, estate);
! 
! 			/* OK, store the tuple and create index entries for it */
! 			heap_insert(cstate->rel, tuple, mycid, hi_options, bistate);
! 
! 			if (resultRelInfo->ri_NumIndices > 0)
! 				recheckIndexes = ExecInsertIndexTuples(slot, &(tuple->t_self),
! 													   estate);
! 
! 			/* AFTER ROW INSERT Triggers */
! 			ExecARInsertTriggers(estate, resultRelInfo, tuple,
! 								 recheckIndexes);
! 
! 			list_free(recheckIndexes);
! 
! 			/*
! 			 * We count only tuples not suppressed by a BEFORE INSERT trigger;
! 			 * this is the same definition used by execMain.c for counting
! 			 * tuples inserted by an INSERT command.
! 			 */
! 			cstate->processed++;
! 		}
! 	}
! 
! 	/* Done, clean up */
! 	error_context_stack = errcontext.previous;
! 
! 	FreeBulkInsertState(bistate);
! 
! 	MemoryContextSwitchTo(oldcontext);
! 
! 	/* Execute AFTER STATEMENT insertion triggers */
! 	ExecASInsertTriggers(estate, resultRelInfo);
! 
! 	/* Handle queued AFTER triggers */
! 	AfterTriggerEndQuery(estate);
! 
! 	pfree(values);
! 	pfree(nulls);
! 	if (! cstate->binary)
! 		pfree(cstate->raw_fields);
! 
! 	pfree(in_functions);
! 	pfree(typioparams);
! 	pfree(defmap);
! 	pfree(defexprs);
! 
! 	ExecResetTupleTable(estate->es_tupleTable, false);
! 
! 	ExecCloseIndices(resultRelInfo);
  
! 	FreeExecutorState(estate);
  
! 	if (!pipe)
  	{
  		if (FreeFile(cstate->copy_file))
  			ereport(ERROR,
  					(errcode_for_file_access(),
! 					 errmsg("could not read from file \"%s\": %m",
  							cstate->filename)));
  	}
  
! 	/*
! 	 * If we skipped writing WAL, then we need to sync the heap (but not
! 	 * indexes since those use WAL anyway)
! 	 */
! 	if (hi_options & HEAP_INSERT_SKIP_WAL)
! 		heap_sync(cstate->rel);
  }
  
  
--- 2393,2437 ----
  		 * provided by the input data.	Anything not processed here or above
  		 * will remain NULL.
  		 */
+ 		econtext = GetPerTupleExprContext(cstate->estate);
  		for (i = 0; i < num_defaults; i++)
  		{
  			values[defmap[i]] = ExecEvalExpr(defexprs[i], econtext,
  											 &nulls[defmap[i]], NULL);
  		}
  
! 	return true;
! }
  
! /*
!  * Clean up storage and release resources for COPY FROM.
!  */
! void
! EndCopyFrom(CopyState cstate)
! {
! 	FreeExecutorState(cstate->estate);
  
! 	if (cstate->filename)
  	{
  		if (FreeFile(cstate->copy_file))
  			ereport(ERROR,
  					(errcode_for_file_access(),
! 					 errmsg("could not close file \"%s\": %m",
  							cstate->filename)));
+ 		pfree(cstate->filename);
  	}
  
! 	/* Clean up storage */
! 	if (!cstate->binary)
! 		pfree(cstate->raw_fields);
! 	pfree(cstate->attribute_buf.data);
! 	pfree(cstate->line_buf.data);
! 	pfree(cstate->raw_buf);
! 	pfree(cstate->in_functions);
! 	pfree(cstate->typioparams);
! 	pfree(cstate->defmap);
! 	pfree(cstate->defexprs);
! 	pfree(cstate);
  }
  
  
*************** CopyGetAttnums(TupleDesc tupDesc, Relati
*** 3502,3507 ****
--- 3672,3684 ----
  	return attnums;
  }
  
+ /* retrieve internal EState in CopyState */
+ EState *
+ GetCopyExecutorState(CopyState cstate)
+ {
+ 	return cstate->estate;
+ }
+ 
  
  /*
   * copy_dest_startup --- executor startup
*************** copy_dest_receive(TupleTableSlot *slot, 
*** 3526,3531 ****
--- 3703,3709 ----
  
  	/* And send the data */
  	CopyOneRowTo(cstate, InvalidOid, slot->tts_values, slot->tts_isnull);
+ 	myState->processed++;
  }
  
  /*
diff --git a/src/include/commands/copy.h b/src/include/commands/copy.h
index 6d409e8..8c69703 100644
*** a/src/include/commands/copy.h
--- b/src/include/commands/copy.h
***************
*** 14,25 ****
--- 14,36 ----
  #ifndef COPY_H
  #define COPY_H
  
+ #include "nodes/execnodes.h"
  #include "nodes/parsenodes.h"
  #include "tcop/dest.h"
  
  
+ typedef struct CopyStateData  *CopyState;
+ 
  extern uint64 DoCopy(const CopyStmt *stmt, const char *queryString);
  
+ extern CopyState BeginCopyFrom(Relation rel, const char *filename,
+ 							   List *attnamelist, List *options);
+ extern void EndCopyFrom(CopyState cstate);
+ extern bool NextCopyFrom(CopyState cstate,
+ 						 Datum *values, bool *nulls, Oid *tupleOid);
+ extern EState *GetCopyExecutorState(CopyState cstate);
+ extern void CopyFromErrorCallback(void *arg);
+ 
  extern DestReceiver *CreateCopyDestReceiver(void);
  
  #endif   /* COPY_H */

diff --git a/src/backend/commands/copy.c b/src/backend/commands/copy.c
index d884764..c0c228f 100644
*** a/src/backend/commands/copy.c
--- b/src/backend/commands/copy.c
*************** CopyFrom(CopyState cstate)
*** 1875,1886 ****
  
  		CHECK_FOR_INTERRUPTS();
  
- 		/* Reset the per-tuple exprcontext */
- 		ResetPerTupleExprContext(estate);
- 
- 		/* Switch into its memory context */
- 		MemoryContextSwitchTo(GetPerTupleMemoryContext(estate));
- 
  		done = !NextCopyFrom(cstate, values, nulls, &loaded_oid);
  		if (done)
  			break;
--- 1875,1880 ----
*************** CopyFrom(CopyState cstate)
*** 1891,1899 ****
  		if (loaded_oid != InvalidOid)
  			HeapTupleSetOid(tuple, loaded_oid);
  
- 		/* Triggers and stuff need to be invoked in query context. */
- 		MemoryContextSwitchTo(oldcontext);
- 
  		skip_tuple = false;
  
  		/* BEFORE ROW INSERT Triggers */
--- 1885,1890 ----
*************** CopyFrom(CopyState cstate)
*** 1918,1924 ****
  			List	   *recheckIndexes = NIL;
  
  			/* Place tuple in tuple slot */
! 			ExecStoreTuple(tuple, slot, InvalidBuffer, false);
  
  			/* Check the constraints of the tuple */
  			if (cstate->rel->rd_att->constr)
--- 1909,1915 ----
  			List	   *recheckIndexes = NIL;
  
  			/* Place tuple in tuple slot */
! 			ExecStoreTuple(tuple, slot, InvalidBuffer, true);
  
  			/* Check the constraints of the tuple */
  			if (cstate->rel->rd_att->constr)
*************** BeginCopyFrom(Relation rel,
*** 2170,2179 ****
--- 2161,2173 ----
   * valus and nulls arrays must be the same length as columns of the
   * relation passed to BeginCopyFrom. Oid of the tuple is returned with
   * tupleOid separately.
+  *
+  * We do everything in per-tuple context and it would be reset in the head.
   */
  bool
  NextCopyFrom(CopyState cstate, Datum *values, bool *nulls, Oid *tupleOid)
  {
+ 	MemoryContext oldcontext = CurrentMemoryContext;
  	TupleDesc	tupDesc;
  	Form_pg_attribute *attr;
  	AttrNumber	num_phys_attrs,
*************** NextCopyFrom(CopyState cstate, Datum *va
*** 2190,2201 ****
--- 2184,2202 ----
  	ExprState **defexprs = cstate->defexprs;
  	ExprContext	*econtext;		/* used for ExecEvalExpr for default atts */
  
+ 	/* Reset the per-tuple exprcontext and switch into its memory context */
+ 	ResetPerTupleExprContext(cstate->estate);
+ 	MemoryContextSwitchTo(GetPerTupleMemoryContext(cstate->estate));
+ 
  	/* on input just throw the header line away */
  	if (cstate->cur_lineno == 0 && cstate->header_line)
  	{
  		cstate->cur_lineno++;
  		if (CopyReadLine(cstate))
+ 		{
+ 			MemoryContextSwitchTo(oldcontext);
  			return false;	/* done */
+ 		}
  	}
  
  	tupDesc = RelationGetDescr(cstate->rel);
*************** NextCopyFrom(CopyState cstate, Datum *va
*** 2228,2234 ****
--- 2229,2238 ----
  		 * EOF, ie, process the line and then exit loop on next iteration.
  		 */
  		if (done && cstate->line_buf.len == 0)
+ 		{
+ 			MemoryContextSwitchTo(oldcontext);
  			return false;
+ 		}
  
  		/* Parse the line into de-escaped field values */
  		if (cstate->csv_mode)
*************** NextCopyFrom(CopyState cstate, Datum *va
*** 2316,2321 ****
--- 2320,2326 ----
  		if (!CopyGetInt16(cstate, &fld_count))
  		{
  			/* EOF detected (end of file, or protocol-level EOF) */
+ 			MemoryContextSwitchTo(oldcontext);
  			return false;
  		}
  
*************** NextCopyFrom(CopyState cstate, Datum *va
*** 2340,2345 ****
--- 2345,2351 ----
  				ereport(ERROR,
  						(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
  						 errmsg("received copy data after EOF marker")));
+ 			MemoryContextSwitchTo(oldcontext);
  			return false;
  		}
  
*************** NextCopyFrom(CopyState cstate, Datum *va
*** 2400,2405 ****
--- 2406,2412 ----
  										 &nulls[defmap[i]], NULL);
  	}
  
+ 	MemoryContextSwitchTo(oldcontext);
  	return true;
  }
  

diff --git a/src/backend/commands/copy.c b/src/backend/commands/copy.c
index 841bf22..00139b9 100644
*** a/src/backend/commands/copy.c
--- b/src/backend/commands/copy.c
*************** typedef struct CopyStateData
*** 93,105 ****
  	FILE	   *copy_file;		/* used if copy_dest == COPY_FILE */
  	StringInfo	fe_msgbuf;		/* used for all dests during COPY TO, only for
  								 * dest == COPY_NEW_FE in COPY FROM */
- 	bool		fe_copy;		/* true for all FE copy dests */
  	bool		fe_eof;			/* true if detected end of copy data */
  	EolType		eol_type;		/* EOL type of input */
  	int			client_encoding;	/* remote side's character encoding */
  	bool		need_transcoding;		/* client encoding diff from server? */
  	bool		encoding_embeds_ascii;	/* ASCII can be non-first byte? */
- 	uint64		processed;		/* # of tuples processed */
  
  	/* parameters from the COPY command */
  	Relation	rel;			/* relation to copy to or from */
--- 93,103 ----
*************** typedef struct CopyStateData
*** 119,125 ****
  	bool	   *force_quote_flags;		/* per-column CSV FQ flags */
  	bool	   *force_notnull_flags;	/* per-column CSV FNN flags */
  
! 	/* these are just for error messages, see copy_in_error_callback */
  	const char *cur_relname;	/* table name for error messages */
  	int			cur_lineno;		/* line number for error messages */
  	const char *cur_attname;	/* current att for error messages */
--- 117,123 ----
  	bool	   *force_quote_flags;		/* per-column CSV FQ flags */
  	bool	   *force_notnull_flags;	/* per-column CSV FNN flags */
  
! 	/* these are just for error messages, see CopyFromErrorCallback */
  	const char *cur_relname;	/* table name for error messages */
  	int			cur_lineno;		/* line number for error messages */
  	const char *cur_attname;	/* current att for error messages */
*************** typedef struct CopyStateData
*** 142,148 ****
  	StringInfoData attribute_buf;
  
  	/* field raw data pointers found by COPY FROM */
- 
  	int max_fields;
  	char ** raw_fields;
  
--- 140,145 ----
*************** typedef struct CopyStateData
*** 167,181 ****
  	char	   *raw_buf;
  	int			raw_buf_index;	/* next byte to process */
  	int			raw_buf_len;	/* total # of bytes stored */
- } CopyStateData;
  
! typedef CopyStateData *CopyState;
  
  /* DestReceiver for COPY (SELECT) TO */
  typedef struct
  {
  	DestReceiver pub;			/* publicly-known function pointers */
  	CopyState	cstate;			/* CopyStateData for the command */
  } DR_copy;
  
  
--- 164,191 ----
  	char	   *raw_buf;
  	int			raw_buf_index;	/* next byte to process */
  	int			raw_buf_len;	/* total # of bytes stored */
  
! 	/*
! 	 * The definition of input functions and default expressions are stored
! 	 * in these variables.
! 	 */
! 	EState	   *estate;
! 	AttrNumber	num_defaults;
! 	bool		file_has_oids;
! 	FmgrInfo	oid_in_function;
! 	Oid			oid_typioparam;
! 	FmgrInfo   *in_functions;
! 	Oid		   *typioparams;
! 	int		   *defmap;
! 	ExprState **defexprs;		/* array of default att expressions */
! } CopyStateData;
  
  /* DestReceiver for COPY (SELECT) TO */
  typedef struct
  {
  	DestReceiver pub;			/* publicly-known function pointers */
  	CopyState	cstate;			/* CopyStateData for the command */
+ 	uint64		processed;		/* # of tuples processed */
  } DR_copy;
  
  
*************** static const char BinarySignature[11] = 
*** 248,258 ****
  
  
  /* non-export function prototypes */
! static void DoCopyTo(CopyState cstate);
! static void CopyTo(CopyState cstate);
  static void CopyOneRowTo(CopyState cstate, Oid tupleOid,
  			 Datum *values, bool *nulls);
! static void CopyFrom(CopyState cstate);
  static bool CopyReadLine(CopyState cstate);
  static bool CopyReadLineText(CopyState cstate);
  static int CopyReadAttributesText(CopyState cstate);
--- 258,273 ----
  
  
  /* non-export function prototypes */
! static CopyState BeginCopy(bool is_from, Relation rel, Node *raw_query,
! 				const char *queryString, List *attnamelist, List *options);
! static CopyState BeginCopyTo(Relation rel, Node *query, const char *queryString,
! 				const char *filename, List *attnamelist, List *options);
! static void EndCopyTo(CopyState cstate);
! static uint64 DoCopyTo(CopyState cstate);
! static uint64 CopyTo(CopyState cstate);
  static void CopyOneRowTo(CopyState cstate, Oid tupleOid,
  			 Datum *values, bool *nulls);
! static uint64 CopyFrom(CopyState cstate);
  static bool CopyReadLine(CopyState cstate);
  static bool CopyReadLineText(CopyState cstate);
  static int CopyReadAttributesText(CopyState cstate);
*************** DoCopy(const CopyStmt *stmt, const char 
*** 724,745 ****
  	CopyState	cstate;
  	bool		is_from = stmt->is_from;
  	bool		pipe = (stmt->filename == NULL);
! 	List	   *attnamelist = stmt->attlist;
  	List	   *force_quote = NIL;
  	List	   *force_notnull = NIL;
  	bool		force_quote_all = false;
  	bool		format_specified = false;
- 	AclMode		required_access = (is_from ? ACL_INSERT : ACL_SELECT);
  	ListCell   *option;
  	TupleDesc	tupDesc;
  	int			num_phys_attrs;
- 	uint64		processed;
  
  	/* Allocate workspace and zero all fields */
  	cstate = (CopyStateData *) palloc0(sizeof(CopyStateData));
  
  	/* Extract options from the statement node tree */
! 	foreach(option, stmt->options)
  	{
  		DefElem    *defel = (DefElem *) lfirst(option);
  
--- 739,850 ----
  	CopyState	cstate;
  	bool		is_from = stmt->is_from;
  	bool		pipe = (stmt->filename == NULL);
! 	Relation	rel;
! 	uint64		processed;
! 
! 	/* Disallow file COPY except to superusers. */
! 	if (!pipe && !superuser())
! 		ereport(ERROR,
! 				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
! 				 errmsg("must be superuser to COPY to or from a file"),
! 				 errhint("Anyone can COPY to stdout or from stdin. "
! 						 "psql's \\copy command also works for anyone.")));
! 
! 	if (stmt->relation)
! 	{
! 		TupleDesc		tupDesc;
! 		AclMode			required_access = (is_from ? ACL_INSERT : ACL_SELECT);
! 		RangeTblEntry  *rte;
! 		List		   *attnums;
! 		ListCell	   *cur;
! 
! 		Assert(!stmt->query);
! 
! 		/* Open and lock the relation, using the appropriate lock type. */
! 		rel = heap_openrv(stmt->relation,
! 							 (is_from ? RowExclusiveLock : AccessShareLock));
! 
! 		rte = makeNode(RangeTblEntry);
! 		rte->rtekind = RTE_RELATION;
! 		rte->relid = RelationGetRelid(rel);
! 		rte->requiredPerms = required_access;
! 
! 		tupDesc = RelationGetDescr(rel);
! 		attnums = CopyGetAttnums(tupDesc, rel, stmt->attlist);
! 		foreach (cur, attnums)
! 		{
! 			int		attno = lfirst_int(cur) -
! 							FirstLowInvalidHeapAttributeNumber;
! 
! 			if (is_from)
! 				rte->modifiedCols = bms_add_member(rte->modifiedCols, attno);
! 			else
! 				rte->selectedCols = bms_add_member(rte->selectedCols, attno);
! 		}
! 		ExecCheckRTPerms(list_make1(rte), true);
! 	}
! 	else
! 	{
! 		Assert(stmt->query);
! 
! 		rel = NULL;
! 	}
! 
! 	if (is_from)
! 	{
! 		/* check read-only transaction */
! 		if (XactReadOnly && rel->rd_backend != MyBackendId)
! 			PreventCommandIfReadOnly("COPY FROM");
! 
! 		cstate = BeginCopyFrom(rel, stmt->filename,
! 							   stmt->attlist, stmt->options);
! 		processed = CopyFrom(cstate);	/* copy from file to database */
! 		EndCopyFrom(cstate);
! 	}
! 	else
! 	{
! 		cstate = BeginCopyTo(rel, stmt->query, queryString, stmt->filename,
! 							 stmt->attlist, stmt->options);
! 		processed = DoCopyTo(cstate);	/* copy from database to file */
! 		EndCopyTo(cstate);
! 	}
! 
! 	/*
! 	 * Close the relation. If reading, we can release the AccessShareLock we got;
! 	 * if writing, we should hold the lock until end of transaction to ensure that
! 	 * updates will be committed before lock is released.
! 	 */
! 	if (rel != NULL)
! 		heap_close(rel, (is_from ? NoLock : AccessShareLock));
! 
! 	return processed;
! }
! 
! /*
!  * Common setup routines used by BeginCopyFrom and BeginCopyTo.
!  */
! static CopyState
! BeginCopy(bool is_from,
! 		  Relation rel,
! 		  Node *raw_query,
! 		  const char *queryString,
! 		  List *attnamelist,
! 		  List *options)
! {
! 	CopyState	cstate;
  	List	   *force_quote = NIL;
  	List	   *force_notnull = NIL;
  	bool		force_quote_all = false;
  	bool		format_specified = false;
  	ListCell   *option;
  	TupleDesc	tupDesc;
  	int			num_phys_attrs;
  
  	/* Allocate workspace and zero all fields */
  	cstate = (CopyStateData *) palloc0(sizeof(CopyStateData));
  
  	/* Extract options from the statement node tree */
! 	foreach(option, options)
  	{
  		DefElem    *defel = (DefElem *) lfirst(option);
  
*************** DoCopy(const CopyStmt *stmt, const char 
*** 980,1030 ****
  				(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
  				 errmsg("CSV quote character must not appear in the NULL specification")));
  
! 	/* Disallow file COPY except to superusers. */
! 	if (!pipe && !superuser())
! 		ereport(ERROR,
! 				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
! 				 errmsg("must be superuser to COPY to or from a file"),
! 				 errhint("Anyone can COPY to stdout or from stdin. "
! 						 "psql's \\copy command also works for anyone.")));
! 
! 	if (stmt->relation)
  	{
! 		RangeTblEntry  *rte;
! 		List		   *attnums;
! 		ListCell	   *cur;
! 
! 		Assert(!stmt->query);
! 		cstate->queryDesc = NULL;
  
! 		/* Open and lock the relation, using the appropriate lock type. */
! 		cstate->rel = heap_openrv(stmt->relation,
! 							 (is_from ? RowExclusiveLock : AccessShareLock));
  
  		tupDesc = RelationGetDescr(cstate->rel);
  
- 		/* Check relation permissions. */
- 		rte = makeNode(RangeTblEntry);
- 		rte->rtekind = RTE_RELATION;
- 		rte->relid = RelationGetRelid(cstate->rel);
- 		rte->requiredPerms = required_access;
- 
- 		attnums = CopyGetAttnums(tupDesc, cstate->rel, attnamelist);
- 		foreach (cur, attnums)
- 		{
- 			int		attno = lfirst_int(cur) - FirstLowInvalidHeapAttributeNumber;
- 
- 			if (is_from)
- 				rte->modifiedCols = bms_add_member(rte->modifiedCols, attno);
- 			else
- 				rte->selectedCols = bms_add_member(rte->selectedCols, attno);
- 		}
- 		ExecCheckRTPerms(list_make1(rte), true);
- 
- 		/* check read-only transaction */
- 		if (XactReadOnly && is_from && cstate->rel->rd_backend != MyBackendId)
- 			PreventCommandIfReadOnly("COPY FROM");
- 
  		/* Don't allow COPY w/ OIDs to or from a table without them */
  		if (cstate->oids && !cstate->rel->rd_rel->relhasoids)
  			ereport(ERROR,
--- 1085,1098 ----
  				(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
  				 errmsg("CSV quote character must not appear in the NULL specification")));
  
! 	if (rel)
  	{
! 		Assert(!raw_query);
  
! 		cstate->rel = rel;
  
  		tupDesc = RelationGetDescr(cstate->rel);
  
  		/* Don't allow COPY w/ OIDs to or from a table without them */
  		if (cstate->oids && !cstate->rel->rd_rel->relhasoids)
  			ereport(ERROR,
*************** DoCopy(const CopyStmt *stmt, const char 
*** 1058,1064 ****
  		 * function and is executed repeatedly.  (See also the same hack in
  		 * DECLARE CURSOR and PREPARE.)  XXX FIXME someday.
  		 */
! 		rewritten = pg_analyze_and_rewrite((Node *) copyObject(stmt->query),
  										   queryString, NULL, 0);
  
  		/* We don't expect more or less than one result query */
--- 1126,1132 ----
  		 * function and is executed repeatedly.  (See also the same hack in
  		 * DECLARE CURSOR and PREPARE.)  XXX FIXME someday.
  		 */
! 		rewritten = pg_analyze_and_rewrite((Node *) copyObject(raw_query),
  										   queryString, NULL, 0);
  
  		/* We don't expect more or less than one result query */
*************** DoCopy(const CopyStmt *stmt, const char 
*** 1160,1173 ****
  		}
  	}
  
- 	/* Set up variables to avoid per-attribute overhead. */
- 	initStringInfo(&cstate->attribute_buf);
- 	initStringInfo(&cstate->line_buf);
- 	cstate->line_buf_converted = false;
- 	cstate->raw_buf = (char *) palloc(RAW_BUF_SIZE + 1);
- 	cstate->raw_buf_index = cstate->raw_buf_len = 0;
- 	cstate->processed = 0;
- 
  	/*
  	 * Set up encoding conversion info.  Even if the client and server
  	 * encodings are the same, we must apply pg_client_to_server() to validate
--- 1228,1233 ----
*************** DoCopy(const CopyStmt *stmt, const char 
*** 1181,1229 ****
  	cstate->encoding_embeds_ascii = PG_ENCODING_IS_CLIENT_ONLY(cstate->client_encoding);
  
  	cstate->copy_dest = COPY_FILE;		/* default */
- 	cstate->filename = stmt->filename;
- 
- 	if (is_from)
- 		CopyFrom(cstate);		/* copy from file to database */
- 	else
- 		DoCopyTo(cstate);		/* copy from database to file */
- 
- 	/*
- 	 * Close the relation or query.  If reading, we can release the
- 	 * AccessShareLock we got; if writing, we should hold the lock until end
- 	 * of transaction to ensure that updates will be committed before lock is
- 	 * released.
- 	 */
- 	if (cstate->rel)
- 		heap_close(cstate->rel, (is_from ? NoLock : AccessShareLock));
- 	else
- 	{
- 		/* Close down the query and free resources. */
- 		ExecutorEnd(cstate->queryDesc);
- 		FreeQueryDesc(cstate->queryDesc);
- 		PopActiveSnapshot();
- 	}
  
! 	/* Clean up storage (probably not really necessary) */
! 	processed = cstate->processed;
! 
! 	pfree(cstate->attribute_buf.data);
! 	pfree(cstate->line_buf.data);
! 	pfree(cstate->raw_buf);
! 	pfree(cstate);
! 
! 	return processed;
  }
  
  
  /*
!  * This intermediate routine exists mainly to localize the effects of setjmp
!  * so we don't need to plaster a lot of variables with "volatile".
   */
! static void
! DoCopyTo(CopyState cstate)
  {
! 	bool		pipe = (cstate->filename == NULL);
  
  	if (cstate->rel)
  	{
--- 1241,1266 ----
  	cstate->encoding_embeds_ascii = PG_ENCODING_IS_CLIENT_ONLY(cstate->client_encoding);
  
  	cstate->copy_dest = COPY_FILE;		/* default */
  
! 	return cstate;
  }
  
  
  /*
!  * Setup CopyState to read tuples from a table or a query for COPY TO.
   */
! static CopyState
! BeginCopyTo(Relation rel,
! 			Node *query,
! 			const char *queryString,
! 			const char *filename,
! 			List *attnamelist,
! 			List *options)
  {
! 	CopyState	cstate;
! 	bool		pipe = (filename == NULL);
! 
! 	cstate = BeginCopy(false, rel, query, queryString, attnamelist, options);
  
  	if (cstate->rel)
  	{
*************** DoCopyTo(CopyState cstate)
*** 1256,1264 ****
  
  	if (pipe)
  	{
! 		if (whereToSendOutput == DestRemote)
! 			cstate->fe_copy = true;
! 		else
  			cstate->copy_file = stdout;
  	}
  	else
--- 1293,1299 ----
  
  	if (pipe)
  	{
! 		if (whereToSendOutput != DestRemote)
  			cstate->copy_file = stdout;
  	}
  	else
*************** DoCopyTo(CopyState cstate)
*** 1270,1280 ****
  		 * Prevent write to relative path ... too easy to shoot oneself in the
  		 * foot by overwriting a database file ...
  		 */
! 		if (!is_absolute_path(cstate->filename))
  			ereport(ERROR,
  					(errcode(ERRCODE_INVALID_NAME),
  					 errmsg("relative path not allowed for COPY to file")));
  
  		oumask = umask(S_IWGRP | S_IWOTH);
  		cstate->copy_file = AllocateFile(cstate->filename, PG_BINARY_W);
  		umask(oumask);
--- 1305,1316 ----
  		 * Prevent write to relative path ... too easy to shoot oneself in the
  		 * foot by overwriting a database file ...
  		 */
! 		if (!is_absolute_path(filename))
  			ereport(ERROR,
  					(errcode(ERRCODE_INVALID_NAME),
  					 errmsg("relative path not allowed for COPY to file")));
  
+ 		cstate->filename = pstrdup(filename);
  		oumask = umask(S_IWGRP | S_IWOTH);
  		cstate->copy_file = AllocateFile(cstate->filename, PG_BINARY_W);
  		umask(oumask);
*************** DoCopyTo(CopyState cstate)
*** 1292,1305 ****
  					 errmsg("\"%s\" is a directory", cstate->filename)));
  	}
  
  	PG_TRY();
  	{
! 		if (cstate->fe_copy)
  			SendCopyBegin(cstate);
  
! 		CopyTo(cstate);
  
! 		if (cstate->fe_copy)
  			SendCopyEnd(cstate);
  	}
  	PG_CATCH();
--- 1328,1355 ----
  					 errmsg("\"%s\" is a directory", cstate->filename)));
  	}
  
+ 	return cstate;
+ }
+ 
+ /*
+  * This intermediate routine exists mainly to localize the effects of setjmp
+  * so we don't need to plaster a lot of variables with "volatile".
+  */
+ static uint64
+ DoCopyTo(CopyState cstate)
+ {
+ 	bool		pipe = (cstate->filename == NULL);
+ 	bool		fe_copy = (pipe && whereToSendOutput == DestRemote);
+ 	uint64		processed;
+ 
  	PG_TRY();
  	{
! 		if (fe_copy)
  			SendCopyBegin(cstate);
  
! 		processed = CopyTo(cstate);
  
! 		if (fe_copy)
  			SendCopyEnd(cstate);
  	}
  	PG_CATCH();
*************** DoCopyTo(CopyState cstate)
*** 1314,1339 ****
  	}
  	PG_END_TRY();
  
! 	if (!pipe)
  	{
  		if (FreeFile(cstate->copy_file))
  			ereport(ERROR,
  					(errcode_for_file_access(),
! 					 errmsg("could not write to file \"%s\": %m",
  							cstate->filename)));
  	}
  }
  
  /*
   * Copy from relation or query TO file.
   */
! static void
  CopyTo(CopyState cstate)
  {
  	TupleDesc	tupDesc;
  	int			num_phys_attrs;
  	Form_pg_attribute *attr;
  	ListCell   *cur;
  
  	if (cstate->rel)
  		tupDesc = RelationGetDescr(cstate->rel);
--- 1364,1414 ----
  	}
  	PG_END_TRY();
  
! 	return processed;
! }
! 
! /*
!  * Clean up storage and release resources for COPY TO.
!  */
! static void
! EndCopyTo(CopyState cstate)
! {
! 	if (cstate->filename)
  	{
  		if (FreeFile(cstate->copy_file))
  			ereport(ERROR,
  					(errcode_for_file_access(),
! 					 errmsg("could not close file \"%s\": %m",
  							cstate->filename)));
+ 
+ 		pfree(cstate->filename);
  	}
+ 
+ 	/*
+ 	 * Close the relation or query. We can release the AccessShareLock we got.
+ 	 */
+ 	if (cstate->rel == NULL)
+ 	{
+ 		/* Close down the query and free resources. */
+ 		ExecutorEnd(cstate->queryDesc);
+ 		FreeQueryDesc(cstate->queryDesc);
+ 		PopActiveSnapshot();
+ 	}
+ 
+ 	pfree(cstate);
  }
  
  /*
   * Copy from relation or query TO file.
   */
! static uint64
  CopyTo(CopyState cstate)
  {
  	TupleDesc	tupDesc;
  	int			num_phys_attrs;
  	Form_pg_attribute *attr;
  	ListCell   *cur;
+ 	uint64		processed;
  
  	if (cstate->rel)
  		tupDesc = RelationGetDescr(cstate->rel);
*************** CopyTo(CopyState cstate)
*** 1439,1444 ****
--- 1514,1520 ----
  
  		scandesc = heap_beginscan(cstate->rel, GetActiveSnapshot(), 0, NULL);
  
+ 		processed = 0;
  		while ((tuple = heap_getnext(scandesc, ForwardScanDirection)) != NULL)
  		{
  			CHECK_FOR_INTERRUPTS();
*************** CopyTo(CopyState cstate)
*** 1448,1453 ****
--- 1524,1530 ----
  
  			/* Format and send the data */
  			CopyOneRowTo(cstate, HeapTupleGetOid(tuple), values, nulls);
+ 			processed++;
  		}
  
  		heap_endscan(scandesc);
*************** CopyTo(CopyState cstate)
*** 1456,1461 ****
--- 1533,1539 ----
  	{
  		/* run the plan --- the dest receiver will send tuples */
  		ExecutorRun(cstate->queryDesc, ForwardScanDirection, 0L);
+ 		processed = ((DR_copy *) cstate->queryDesc->dest)->processed;
  	}
  
  	if (cstate->binary)
*************** CopyTo(CopyState cstate)
*** 1467,1472 ****
--- 1545,1552 ----
  	}
  
  	MemoryContextDelete(cstate->rowcontext);
+ 
+ 	return processed;
  }
  
  /*
*************** CopyOneRowTo(CopyState cstate, Oid tuple
*** 1558,1573 ****
  	CopySendEndOfRow(cstate);
  
  	MemoryContextSwitchTo(oldcontext);
- 
- 	cstate->processed++;
  }
  
  
  /*
   * error context callback for COPY FROM
   */
! static void
! copy_in_error_callback(void *arg)
  {
  	CopyState	cstate = (CopyState) arg;
  
--- 1638,1653 ----
  	CopySendEndOfRow(cstate);
  
  	MemoryContextSwitchTo(oldcontext);
  }
  
  
  /*
   * error context callback for COPY FROM
+  *
+  * The argument for the error context must be CopyState.
   */
! void
! CopyFromErrorCallback(void *arg)
  {
  	CopyState	cstate = (CopyState) arg;
  
*************** limit_printout_length(const char *str)
*** 1669,1709 ****
  /*
   * Copy FROM file to relation.
   */
! static void
  CopyFrom(CopyState cstate)
  {
- 	bool		pipe = (cstate->filename == NULL);
  	HeapTuple	tuple;
  	TupleDesc	tupDesc;
- 	Form_pg_attribute *attr;
- 	AttrNumber	num_phys_attrs,
- 				attr_count,
- 				num_defaults;
- 	FmgrInfo   *in_functions;
- 	FmgrInfo	oid_in_function;
- 	Oid		   *typioparams;
- 	Oid			oid_typioparam;
- 	int			attnum;
- 	int			i;
- 	Oid			in_func_oid;
  	Datum	   *values;
  	bool	   *nulls;
- 	int			nfields;
- 	char	  **field_strings;
  	bool		done = false;
- 	bool		isnull;
  	ResultRelInfo *resultRelInfo;
! 	EState	   *estate = CreateExecutorState(); /* for ExecConstraints() */
  	TupleTableSlot *slot;
- 	bool		file_has_oids;
- 	int		   *defmap;
- 	ExprState **defexprs;		/* array of default att expressions */
- 	ExprContext *econtext;		/* used for ExecEvalExpr for default atts */
  	MemoryContext oldcontext = CurrentMemoryContext;
  	ErrorContextCallback errcontext;
  	CommandId	mycid = GetCurrentCommandId(true);
  	int			hi_options = 0; /* start with default heap_insert options */
  	BulkInsertState bistate;
  
  	Assert(cstate->rel);
  
--- 1749,1771 ----
  /*
   * Copy FROM file to relation.
   */
! static uint64
  CopyFrom(CopyState cstate)
  {
  	HeapTuple	tuple;
  	TupleDesc	tupDesc;
  	Datum	   *values;
  	bool	   *nulls;
  	bool		done = false;
  	ResultRelInfo *resultRelInfo;
! 	EState	   *estate = cstate->estate; /* for ExecConstraints() */
  	TupleTableSlot *slot;
  	MemoryContext oldcontext = CurrentMemoryContext;
  	ErrorContextCallback errcontext;
  	CommandId	mycid = GetCurrentCommandId(true);
  	int			hi_options = 0; /* start with default heap_insert options */
  	BulkInsertState bistate;
+ 	uint64		processed = 0;
  
  	Assert(cstate->rel);
  
*************** CopyFrom(CopyState cstate)
*** 1731,1736 ****
--- 1793,1800 ----
  							RelationGetRelationName(cstate->rel))));
  	}
  
+ 	tupDesc = RelationGetDescr(cstate->rel);
+ 
  	/*----------
  	 * Check to see if we can avoid writing WAL
  	 *
*************** CopyFrom(CopyState cstate)
*** 1766,1803 ****
  			hi_options |= HEAP_INSERT_SKIP_WAL;
  	}
  
- 	if (pipe)
- 	{
- 		if (whereToSendOutput == DestRemote)
- 			ReceiveCopyBegin(cstate);
- 		else
- 			cstate->copy_file = stdin;
- 	}
- 	else
- 	{
- 		struct stat st;
- 
- 		cstate->copy_file = AllocateFile(cstate->filename, PG_BINARY_R);
- 
- 		if (cstate->copy_file == NULL)
- 			ereport(ERROR,
- 					(errcode_for_file_access(),
- 					 errmsg("could not open file \"%s\" for reading: %m",
- 							cstate->filename)));
- 
- 		fstat(fileno(cstate->copy_file), &st);
- 		if (S_ISDIR(st.st_mode))
- 			ereport(ERROR,
- 					(errcode(ERRCODE_WRONG_OBJECT_TYPE),
- 					 errmsg("\"%s\" is a directory", cstate->filename)));
- 	}
- 
- 	tupDesc = RelationGetDescr(cstate->rel);
- 	attr = tupDesc->attrs;
- 	num_phys_attrs = tupDesc->natts;
- 	attr_count = list_length(cstate->attnumlist);
- 	num_defaults = 0;
- 
  	/*
  	 * We need a ResultRelInfo so we can use the regular executor's
  	 * index-entry-making machinery.  (There used to be a huge amount of code
--- 1830,1835 ----
*************** CopyFrom(CopyState cstate)
*** 1826,1832 ****
  	slot = ExecInitExtraTupleSlot(estate);
  	ExecSetSlotDescriptor(slot, tupDesc);
  
! 	econtext = GetPerTupleExprContext(estate);
  
  	/*
  	 * Pick up the required catalog information for each attribute in the
--- 1858,2037 ----
  	slot = ExecInitExtraTupleSlot(estate);
  	ExecSetSlotDescriptor(slot, tupDesc);
  
! 	/* Prepare to catch AFTER triggers. */
! 	AfterTriggerBeginQuery();
! 
! 	/*
! 	 * Check BEFORE STATEMENT insertion triggers. It's debateable whether we
! 	 * should do this for COPY, since it's not really an "INSERT" statement as
! 	 * such. However, executing these triggers maintains consistency with the
! 	 * EACH ROW triggers that we already fire on COPY.
! 	 */
! 	ExecBSInsertTriggers(estate, resultRelInfo);
! 
! 	values = (Datum *) palloc(tupDesc->natts * sizeof(Datum));
! 	nulls = (bool *) palloc(tupDesc->natts * sizeof(bool));
! 
! 	bistate = GetBulkInsertState();
! 
! 	/* Set up callback to identify error line number */
! 	errcontext.callback = CopyFromErrorCallback;
! 	errcontext.arg = (void *) cstate;
! 	errcontext.previous = error_context_stack;
! 	error_context_stack = &errcontext;
! 
! 	while (!done)
! 	{
! 		bool		skip_tuple;
! 		Oid			loaded_oid = InvalidOid;
! 
! 		CHECK_FOR_INTERRUPTS();
! 
! 		/* Reset the per-tuple exprcontext */
! 		ResetPerTupleExprContext(estate);
! 
! 		/* Switch into its memory context */
! 		MemoryContextSwitchTo(GetPerTupleMemoryContext(estate));
! 
! 		done = !NextCopyFrom(cstate, values, nulls, &loaded_oid);
! 		if (done)
! 			break;
! 
! 		/* And now we can form the input tuple. */
! 		tuple = heap_form_tuple(tupDesc, values, nulls);
! 
! 		if (loaded_oid != InvalidOid)
! 			HeapTupleSetOid(tuple, loaded_oid);
! 
! 		/* Triggers and stuff need to be invoked in query context. */
! 		MemoryContextSwitchTo(oldcontext);
! 
! 		skip_tuple = false;
! 
! 		/* BEFORE ROW INSERT Triggers */
! 		if (resultRelInfo->ri_TrigDesc &&
! 			resultRelInfo->ri_TrigDesc->trig_insert_before_row)
! 		{
! 			HeapTuple	newtuple;
! 
! 			newtuple = ExecBRInsertTriggers(estate, resultRelInfo, tuple);
! 
! 			if (newtuple == NULL)		/* "do nothing" */
! 				skip_tuple = true;
! 			else if (newtuple != tuple) /* modified by Trigger(s) */
! 			{
! 				heap_freetuple(tuple);
! 				tuple = newtuple;
! 			}
! 		}
! 
! 		if (!skip_tuple)
! 		{
! 			List	   *recheckIndexes = NIL;
! 
! 			/* Place tuple in tuple slot */
! 			ExecStoreTuple(tuple, slot, InvalidBuffer, false);
! 
! 			/* Check the constraints of the tuple */
! 			if (cstate->rel->rd_att->constr)
! 				ExecConstraints(resultRelInfo, slot, estate);
! 
! 			/* OK, store the tuple and create index entries for it */
! 			heap_insert(cstate->rel, tuple, mycid, hi_options, bistate);
! 
! 			if (resultRelInfo->ri_NumIndices > 0)
! 				recheckIndexes = ExecInsertIndexTuples(slot, &(tuple->t_self),
! 													   estate);
! 
! 			/* AFTER ROW INSERT Triggers */
! 			ExecARInsertTriggers(estate, resultRelInfo, tuple,
! 								 recheckIndexes);
! 
! 			list_free(recheckIndexes);
! 
! 			/*
! 			 * We count only tuples not suppressed by a BEFORE INSERT trigger;
! 			 * this is the same definition used by execMain.c for counting
! 			 * tuples inserted by an INSERT command.
! 			 */
! 			processed++;
! 		}
! 	}
! 
! 	/* Done, clean up */
! 	error_context_stack = errcontext.previous;
! 
! 	FreeBulkInsertState(bistate);
! 
! 	MemoryContextSwitchTo(oldcontext);
! 
! 	/* Execute AFTER STATEMENT insertion triggers */
! 	ExecASInsertTriggers(estate, resultRelInfo);
! 
! 	/* Handle queued AFTER triggers */
! 	AfterTriggerEndQuery(estate);
! 
! 	pfree(values);
! 	pfree(nulls);
! 
! 	ExecResetTupleTable(estate->es_tupleTable, false);
! 
! 	ExecCloseIndices(resultRelInfo);
! 
! 	/*
! 	 * If we skipped writing WAL, then we need to sync the heap (but not
! 	 * indexes since those use WAL anyway)
! 	 */
! 	if (hi_options & HEAP_INSERT_SKIP_WAL)
! 		heap_sync(cstate->rel);
! 
! 	return processed;
! }
! 
! /*
!  * Setup CopyState to read tuples from a file for COPY FROM.
!  */
! CopyState
! BeginCopyFrom(Relation rel,
! 			  const char *filename,
! 			  List *attnamelist,
! 			  List *options)
! {
! 	CopyState	cstate;
! 	bool		pipe = (filename == NULL);
! 	TupleDesc	tupDesc;
! 	Form_pg_attribute *attr;
! 	AttrNumber	num_phys_attrs,
! 				num_defaults;
! 	FmgrInfo   *in_functions;
! 	Oid		   *typioparams;
! 	int			attnum;
! 	Oid			in_func_oid;
! 	EState	   *estate = CreateExecutorState(); /* for ExecPrepareExpr() */
! 	int		   *defmap;
! 	ExprState **defexprs;
! 
! 	cstate = BeginCopy(true, rel, NULL, NULL, attnamelist, options);
! 
! 	/* Initialize state variables */
! 	cstate->fe_eof = false;
! 	cstate->eol_type = EOL_UNKNOWN;
! 	cstate->cur_relname = RelationGetRelationName(cstate->rel);
! 	cstate->cur_lineno = 0;
! 	cstate->cur_attname = NULL;
! 	cstate->cur_attval = NULL;
! 
! 	/* Set up variables to avoid per-attribute overhead. */
! 	initStringInfo(&cstate->attribute_buf);
! 	initStringInfo(&cstate->line_buf);
! 	cstate->line_buf_converted = false;
! 	cstate->raw_buf = (char *) palloc(RAW_BUF_SIZE + 1);
! 	cstate->raw_buf_index = cstate->raw_buf_len = 0;
! 
! 	tupDesc = RelationGetDescr(cstate->rel);
! 	attr = tupDesc->attrs;
! 	num_phys_attrs = tupDesc->natts;
! 	num_defaults = 0;
  
  	/*
  	 * Pick up the required catalog information for each attribute in the
*************** CopyFrom(CopyState cstate)
*** 1871,1889 ****
  		}
  	}
  
! 	/* Prepare to catch AFTER triggers. */
! 	AfterTriggerBeginQuery();
  
! 	/*
! 	 * Check BEFORE STATEMENT insertion triggers. It's debateable whether we
! 	 * should do this for COPY, since it's not really an "INSERT" statement as
! 	 * such. However, executing these triggers maintains consistency with the
! 	 * EACH ROW triggers that we already fire on COPY.
! 	 */
! 	ExecBSInsertTriggers(estate, resultRelInfo);
  
  	if (!cstate->binary)
! 		file_has_oids = cstate->oids;	/* must rely on user to tell us... */
  	else
  	{
  		/* Read and verify binary header */
--- 2076,2121 ----
  		}
  	}
  
! 	/* We keep those variables in cstate. */
! 	cstate->estate = estate;
! 	cstate->in_functions = in_functions;
! 	cstate->typioparams = typioparams;
! 	cstate->defmap = defmap;
! 	cstate->defexprs = defexprs;
! 	cstate->num_defaults = num_defaults;
  
! 	if (pipe)
! 	{
! 		if (whereToSendOutput == DestRemote)
! 			ReceiveCopyBegin(cstate);
! 		else
! 			cstate->copy_file = stdin;
! 	}
! 	else
! 	{
! 		struct stat st;
! 
! 		cstate->filename = pstrdup(filename);
! 		cstate->copy_file = AllocateFile(cstate->filename, PG_BINARY_R);
! 
! 		if (cstate->copy_file == NULL)
! 			ereport(ERROR,
! 					(errcode_for_file_access(),
! 					 errmsg("could not open file \"%s\" for reading: %m",
! 							cstate->filename)));
! 
! 		fstat(fileno(cstate->copy_file), &st);
! 		if (S_ISDIR(st.st_mode))
! 			ereport(ERROR,
! 					(errcode(ERRCODE_WRONG_OBJECT_TYPE),
! 					 errmsg("\"%s\" is a directory", cstate->filename)));
! 	}
  
  	if (!cstate->binary)
! 	{
! 		/* must rely on user to tell us... */
! 		cstate->file_has_oids = cstate->oids;
! 	}
  	else
  	{
  		/* Read and verify binary header */
*************** CopyFrom(CopyState cstate)
*** 1901,1907 ****
  			ereport(ERROR,
  					(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
  					 errmsg("invalid COPY file header (missing flags)")));
! 		file_has_oids = (tmp & (1 << 16)) != 0;
  		tmp &= ~(1 << 16);
  		if ((tmp >> 16) != 0)
  			ereport(ERROR,
--- 2133,2139 ----
  			ereport(ERROR,
  					(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
  					 errmsg("invalid COPY file header (missing flags)")));
! 		cstate->file_has_oids = (tmp & (1 << 16)) != 0;
  		tmp &= ~(1 << 16);
  		if ((tmp >> 16) != 0)
  			ereport(ERROR,
*************** CopyFrom(CopyState cstate)
*** 1923,1984 ****
  		}
  	}
  
! 	if (file_has_oids && cstate->binary)
  	{
  		getTypeBinaryInputInfo(OIDOID,
! 							   &in_func_oid, &oid_typioparam);
! 		fmgr_info(in_func_oid, &oid_in_function);
  	}
  
- 	values = (Datum *) palloc(num_phys_attrs * sizeof(Datum));
- 	nulls = (bool *) palloc(num_phys_attrs * sizeof(bool));
- 
  	/* create workspace for CopyReadAttributes results */
! 	nfields = file_has_oids ? (attr_count + 1) : attr_count;
! 	if (! cstate->binary)
  	{
  		cstate->max_fields = nfields;
  		cstate->raw_fields = (char **) palloc(nfields * sizeof(char *));
  	}
  
! 	/* Initialize state variables */
! 	cstate->fe_eof = false;
! 	cstate->eol_type = EOL_UNKNOWN;
! 	cstate->cur_relname = RelationGetRelationName(cstate->rel);
! 	cstate->cur_lineno = 0;
! 	cstate->cur_attname = NULL;
! 	cstate->cur_attval = NULL;
! 
! 	bistate = GetBulkInsertState();
  
! 	/* Set up callback to identify error line number */
! 	errcontext.callback = copy_in_error_callback;
! 	errcontext.arg = (void *) cstate;
! 	errcontext.previous = error_context_stack;
! 	error_context_stack = &errcontext;
  
  	/* on input just throw the header line away */
! 	if (cstate->header_line)
  	{
  		cstate->cur_lineno++;
! 		done = CopyReadLine(cstate);
  	}
  
! 	while (!done)
! 	{
! 		bool		skip_tuple;
! 		Oid			loaded_oid = InvalidOid;
! 
! 		CHECK_FOR_INTERRUPTS();
  
  		cstate->cur_lineno++;
  
- 		/* Reset the per-tuple exprcontext */
- 		ResetPerTupleExprContext(estate);
- 
- 		/* Switch into its memory context */
- 		MemoryContextSwitchTo(GetPerTupleMemoryContext(estate));
- 
  		/* Initialize all values for row to NULL */
  		MemSet(values, 0, num_phys_attrs * sizeof(Datum));
  		MemSet(nulls, true, num_phys_attrs * sizeof(bool));
--- 2155,2223 ----
  		}
  	}
  
! 	if (cstate->file_has_oids && cstate->binary)
  	{
  		getTypeBinaryInputInfo(OIDOID,
! 							   &in_func_oid, &cstate->oid_typioparam);
! 		fmgr_info(in_func_oid, &cstate->oid_in_function);
  	}
  
  	/* create workspace for CopyReadAttributes results */
! 	if (!cstate->binary)
  	{
+ 		AttrNumber	attr_count = list_length(cstate->attnumlist);
+ 		int	nfields = cstate->file_has_oids ? (attr_count + 1) : attr_count;
+ 
  		cstate->max_fields = nfields;
  		cstate->raw_fields = (char **) palloc(nfields * sizeof(char *));
  	}
  
! 	return cstate;
! }
  
! /*
!  * Read next tuple from file for COPY FROM. Return false if no more tuples.
!  *
!  * valus and nulls arrays must be the same length as columns of the
!  * relation passed to BeginCopyFrom. Oid of the tuple is returned with
!  * tupleOid separately.
!  */
! bool
! NextCopyFrom(CopyState cstate, Datum *values, bool *nulls, Oid *tupleOid)
! {
! 	TupleDesc	tupDesc;
! 	Form_pg_attribute *attr;
! 	AttrNumber	num_phys_attrs,
! 				attr_count,
! 				num_defaults = cstate->num_defaults;
! 	FmgrInfo   *in_functions = cstate->in_functions;
! 	Oid		   *typioparams = cstate->typioparams;
! 	int			i;
! 	int			nfields;
! 	char	  **field_strings;
! 	bool		isnull;
! 	bool		file_has_oids = cstate->file_has_oids;
! 	int		   *defmap = cstate->defmap;
! 	ExprState **defexprs = cstate->defexprs;
! 	ExprContext	*econtext;		/* used for ExecEvalExpr for default atts */
  
  	/* on input just throw the header line away */
! 	if (cstate->cur_lineno == 0 && cstate->header_line)
  	{
  		cstate->cur_lineno++;
! 		if (CopyReadLine(cstate))
! 			return false;	/* done */
  	}
  
! 	tupDesc = RelationGetDescr(cstate->rel);
! 	attr = tupDesc->attrs;
! 	num_phys_attrs = tupDesc->natts;
! 	attr_count = list_length(cstate->attnumlist);
! 	nfields = file_has_oids ? (attr_count + 1) : attr_count;
  
+ 	/* XXX: Indentation is not adjusted to keep the patch small. */
  		cstate->cur_lineno++;
  
  		/* Initialize all values for row to NULL */
  		MemSet(values, 0, num_phys_attrs * sizeof(Datum));
  		MemSet(nulls, true, num_phys_attrs * sizeof(bool));
*************** CopyFrom(CopyState cstate)
*** 1989,1994 ****
--- 2228,2234 ----
  			int			fldct;
  			int			fieldno;
  			char	   *string;
+ 			bool		done;
  
  			/* Actually read the line into memory here */
  			done = CopyReadLine(cstate);
*************** CopyFrom(CopyState cstate)
*** 1999,2005 ****
  			 * EOF, ie, process the line and then exit loop on next iteration.
  			 */
  			if (done && cstate->line_buf.len == 0)
! 				break;
  
  			/* Parse the line into de-escaped field values */
  			if (cstate->csv_mode)
--- 2239,2245 ----
  			 * EOF, ie, process the line and then exit loop on next iteration.
  			 */
  			if (done && cstate->line_buf.len == 0)
! 				return false;
  
  			/* Parse the line into de-escaped field values */
  			if (cstate->csv_mode)
*************** CopyFrom(CopyState cstate)
*** 2029,2041 ****
  					ereport(ERROR,
  							(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
  							 errmsg("null OID in COPY data")));
! 				else
  				{
  					cstate->cur_attname = "oid";
  					cstate->cur_attval = string;
! 					loaded_oid = DatumGetObjectId(DirectFunctionCall1(oidin,
! 												   CStringGetDatum(string)));
! 					if (loaded_oid == InvalidOid)
  						ereport(ERROR,
  								(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
  								 errmsg("invalid OID in COPY data")));
--- 2269,2281 ----
  					ereport(ERROR,
  							(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
  							 errmsg("null OID in COPY data")));
! 				else if (cstate->oids && tupleOid != NULL)
  				{
  					cstate->cur_attname = "oid";
  					cstate->cur_attval = string;
! 					*tupleOid = DatumGetObjectId(DirectFunctionCall1(oidin,
! 													   CStringGetDatum(string)));
! 					if (*tupleOid == InvalidOid)
  						ereport(ERROR,
  								(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
  								 errmsg("invalid OID in COPY data")));
*************** CopyFrom(CopyState cstate)
*** 2087,2094 ****
  			if (!CopyGetInt16(cstate, &fld_count))
  			{
  				/* EOF detected (end of file, or protocol-level EOF) */
! 				done = true;
! 				break;
  			}
  
  			if (fld_count == -1)
--- 2327,2333 ----
  			if (!CopyGetInt16(cstate, &fld_count))
  			{
  				/* EOF detected (end of file, or protocol-level EOF) */
! 				return false;
  			}
  
  			if (fld_count == -1)
*************** CopyFrom(CopyState cstate)
*** 2112,2119 ****
  					ereport(ERROR,
  							(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
  							 errmsg("received copy data after EOF marker")));
! 				done = true;
! 				break;
  			}
  
  			if (fld_count != attr_count)
--- 2351,2357 ----
  					ereport(ERROR,
  							(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
  							 errmsg("received copy data after EOF marker")));
! 				return false;
  			}
  
  			if (fld_count != attr_count)
*************** CopyFrom(CopyState cstate)
*** 2124,2135 ****
  
  			if (file_has_oids)
  			{
  				cstate->cur_attname = "oid";
  				loaded_oid =
  					DatumGetObjectId(CopyReadBinaryAttribute(cstate,
  															 0,
! 															 &oid_in_function,
! 															 oid_typioparam,
  															 -1,
  															 &isnull));
  				if (isnull || loaded_oid == InvalidOid)
--- 2362,2375 ----
  
  			if (file_has_oids)
  			{
+ 				Oid		loaded_oid;
+ 
  				cstate->cur_attname = "oid";
  				loaded_oid =
  					DatumGetObjectId(CopyReadBinaryAttribute(cstate,
  															 0,
! 															 &cstate->oid_in_function,
! 															 cstate->oid_typioparam,
  															 -1,
  															 &isnull));
  				if (isnull || loaded_oid == InvalidOid)
*************** CopyFrom(CopyState cstate)
*** 2137,2142 ****
--- 2377,2384 ----
  							(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
  							 errmsg("invalid OID in COPY data")));
  				cstate->cur_attname = NULL;
+ 				if (cstate->oids && tupleOid != NULL)
+ 					*tupleOid = loaded_oid;
  			}
  
  			i = 0;
*************** CopyFrom(CopyState cstate)
*** 2162,2278 ****
  		 * provided by the input data.	Anything not processed here or above
  		 * will remain NULL.
  		 */
  		for (i = 0; i < num_defaults; i++)
  		{
  			values[defmap[i]] = ExecEvalExpr(defexprs[i], econtext,
  											 &nulls[defmap[i]], NULL);
  		}
  
! 		/* And now we can form the input tuple. */
! 		tuple = heap_form_tuple(tupDesc, values, nulls);
! 
! 		if (cstate->oids && file_has_oids)
! 			HeapTupleSetOid(tuple, loaded_oid);
! 
! 		/* Triggers and stuff need to be invoked in query context. */
! 		MemoryContextSwitchTo(oldcontext);
! 
! 		skip_tuple = false;
! 
! 		/* BEFORE ROW INSERT Triggers */
! 		if (resultRelInfo->ri_TrigDesc &&
! 			resultRelInfo->ri_TrigDesc->trig_insert_before_row)
! 		{
! 			HeapTuple	newtuple;
! 
! 			newtuple = ExecBRInsertTriggers(estate, resultRelInfo, tuple);
! 
! 			if (newtuple == NULL)		/* "do nothing" */
! 				skip_tuple = true;
! 			else if (newtuple != tuple) /* modified by Trigger(s) */
! 			{
! 				heap_freetuple(tuple);
! 				tuple = newtuple;
! 			}
! 		}
! 
! 		if (!skip_tuple)
! 		{
! 			List	   *recheckIndexes = NIL;
! 
! 			/* Place tuple in tuple slot */
! 			ExecStoreTuple(tuple, slot, InvalidBuffer, false);
! 
! 			/* Check the constraints of the tuple */
! 			if (cstate->rel->rd_att->constr)
! 				ExecConstraints(resultRelInfo, slot, estate);
! 
! 			/* OK, store the tuple and create index entries for it */
! 			heap_insert(cstate->rel, tuple, mycid, hi_options, bistate);
! 
! 			if (resultRelInfo->ri_NumIndices > 0)
! 				recheckIndexes = ExecInsertIndexTuples(slot, &(tuple->t_self),
! 													   estate);
! 
! 			/* AFTER ROW INSERT Triggers */
! 			ExecARInsertTriggers(estate, resultRelInfo, tuple,
! 								 recheckIndexes);
! 
! 			list_free(recheckIndexes);
! 
! 			/*
! 			 * We count only tuples not suppressed by a BEFORE INSERT trigger;
! 			 * this is the same definition used by execMain.c for counting
! 			 * tuples inserted by an INSERT command.
! 			 */
! 			cstate->processed++;
! 		}
! 	}
! 
! 	/* Done, clean up */
! 	error_context_stack = errcontext.previous;
! 
! 	FreeBulkInsertState(bistate);
! 
! 	MemoryContextSwitchTo(oldcontext);
! 
! 	/* Execute AFTER STATEMENT insertion triggers */
! 	ExecASInsertTriggers(estate, resultRelInfo);
! 
! 	/* Handle queued AFTER triggers */
! 	AfterTriggerEndQuery(estate);
! 
! 	pfree(values);
! 	pfree(nulls);
! 	if (! cstate->binary)
! 		pfree(cstate->raw_fields);
! 
! 	pfree(in_functions);
! 	pfree(typioparams);
! 	pfree(defmap);
! 	pfree(defexprs);
! 
! 	ExecResetTupleTable(estate->es_tupleTable, false);
! 
! 	ExecCloseIndices(resultRelInfo);
  
! 	FreeExecutorState(estate);
  
! 	if (!pipe)
  	{
  		if (FreeFile(cstate->copy_file))
  			ereport(ERROR,
  					(errcode_for_file_access(),
! 					 errmsg("could not read from file \"%s\": %m",
  							cstate->filename)));
  	}
  
! 	/*
! 	 * If we skipped writing WAL, then we need to sync the heap (but not
! 	 * indexes since those use WAL anyway)
! 	 */
! 	if (hi_options & HEAP_INSERT_SKIP_WAL)
! 		heap_sync(cstate->rel);
  }
  
  
--- 2404,2448 ----
  		 * provided by the input data.	Anything not processed here or above
  		 * will remain NULL.
  		 */
+ 		econtext = GetPerTupleExprContext(cstate->estate);
  		for (i = 0; i < num_defaults; i++)
  		{
  			values[defmap[i]] = ExecEvalExpr(defexprs[i], econtext,
  											 &nulls[defmap[i]], NULL);
  		}
  
! 	return true;
! }
  
! /*
!  * Clean up storage and release resources for COPY FROM.
!  */
! void
! EndCopyFrom(CopyState cstate)
! {
! 	FreeExecutorState(cstate->estate);
  
! 	if (cstate->filename)
  	{
  		if (FreeFile(cstate->copy_file))
  			ereport(ERROR,
  					(errcode_for_file_access(),
! 					 errmsg("could not close file \"%s\": %m",
  							cstate->filename)));
+ 		pfree(cstate->filename);
  	}
  
! 	/* Clean up storage */
! 	if (!cstate->binary)
! 		pfree(cstate->raw_fields);
! 	pfree(cstate->attribute_buf.data);
! 	pfree(cstate->line_buf.data);
! 	pfree(cstate->raw_buf);
! 	pfree(cstate->in_functions);
! 	pfree(cstate->typioparams);
! 	pfree(cstate->defmap);
! 	pfree(cstate->defexprs);
! 	pfree(cstate);
  }
  
  
*************** copy_dest_receive(TupleTableSlot *slot, 
*** 3537,3542 ****
--- 3707,3713 ----
  
  	/* And send the data */
  	CopyOneRowTo(cstate, InvalidOid, slot->tts_values, slot->tts_isnull);
+ 	myState->processed++;
  }
  
  /*
diff --git a/src/include/commands/copy.h b/src/include/commands/copy.h
index 9e2bbe8..8340e3d 100644
*** a/src/include/commands/copy.h
--- b/src/include/commands/copy.h
***************
*** 14,25 ****
--- 14,35 ----
  #ifndef COPY_H
  #define COPY_H
  
+ #include "nodes/execnodes.h"
  #include "nodes/parsenodes.h"
  #include "tcop/dest.h"
  
  
+ typedef struct CopyStateData  *CopyState;
+ 
  extern uint64 DoCopy(const CopyStmt *stmt, const char *queryString);
  
+ extern CopyState BeginCopyFrom(Relation rel, const char *filename,
+ 							   List *attnamelist, List *options);
+ extern void EndCopyFrom(CopyState cstate);
+ extern bool NextCopyFrom(CopyState cstate,
+ 						 Datum *values, bool *nulls, Oid *tupleOid);
+ extern void CopyFromErrorCallback(void *arg);
+ 
  extern DestReceiver *CreateCopyDestReceiver(void);
  
  #endif   /* COPY_H */

diff --git a/src/backend/commands/copy.c b/src/backend/commands/copy.c
index 00139b9..fab811a 100644
*** a/src/backend/commands/copy.c
--- b/src/backend/commands/copy.c
*************** NextCopyFrom(CopyState cstate, Datum *va
*** 2415,2420 ****
--- 2415,2448 ----
  }
  
  /*
+  * Reset read pointer to the head of the file.
+  * This can't be used for COPY FROM STDIN.
+  */
+ void
+ ResetCopyFrom(CopyState cstate)
+ {
+ 	/* stdin can't be rewinded */
+ 	Assert(cstate->copy_dest == COPY_FILE);
+ 
+ 	/* rewind seek pointer to the head */
+ 	if (fseek(cstate->copy_file, 0, SEEK_SET))
+ 		ereport(ERROR,
+ 				(errcode_for_file_access(),
+ 				 errmsg("could not seek in file \"%s\": %m",
+ 						cstate->filename)));
+ 	cstate->fe_eof = false;
+ 
+ 	/* reset error context */
+ 	cstate->cur_lineno = 0;
+ 	cstate->cur_attname = NULL;
+ 	cstate->cur_attval = NULL;
+ 
+ 	/* just clear the line buffer to avoid re-allocation */
+ 	resetStringInfo(&cstate->line_buf);
+ }
+ 
+ 
+ /*
   * Clean up storage and release resources for COPY FROM.
   */
  void
diff --git a/src/include/commands/copy.h b/src/include/commands/copy.h
index 8340e3d..424d170 100644
*** a/src/include/commands/copy.h
--- b/src/include/commands/copy.h
*************** extern CopyState BeginCopyFrom(Relation 
*** 28,33 ****
--- 28,34 ----
  extern void EndCopyFrom(CopyState cstate);
  extern bool NextCopyFrom(CopyState cstate,
  						 Datum *values, bool *nulls, Oid *tupleOid);
+ extern void ResetCopyFrom(CopyState cstate);
  extern void CopyFromErrorCallback(void *arg);
  
  extern DestReceiver *CreateCopyDestReceiver(void);

diff --git a/src/backend/commands/copy.c b/src/backend/commands/copy.c
index 00139b9..5ee6bb0 100644
*** a/src/backend/commands/copy.c
--- b/src/backend/commands/copy.c
*************** typedef struct CopyStateData
*** 124,129 ****
--- 124,134 ----
  	const char *cur_attval;		/* current att value for error messages */
  
  	/*
+ 	 * Working state for COPY TO/FROM
+ 	 */
+ 	MemoryContext copycontext;	/* per-copy execution context */
+ 
+ 	/*
  	 * Working state for COPY TO
  	 */
  	FmgrInfo   *out_functions;	/* lookup info for output functions */
*************** static const char BinarySignature[11] = 
*** 260,265 ****
--- 265,271 ----
  /* non-export function prototypes */
  static CopyState BeginCopy(bool is_from, Relation rel, Node *raw_query,
  				const char *queryString, List *attnamelist, List *options);
+ static void EndCopy(CopyState cstate);
  static CopyState BeginCopyTo(Relation rel, Node *query, const char *queryString,
  				const char *filename, List *attnamelist, List *options);
  static void EndCopyTo(CopyState cstate);
*************** BeginCopy(bool is_from,
*** 839,848 ****
--- 845,870 ----
  	ListCell   *option;
  	TupleDesc	tupDesc;
  	int			num_phys_attrs;
+ 	MemoryContext oldcontext;
  
  	/* Allocate workspace and zero all fields */
  	cstate = (CopyStateData *) palloc0(sizeof(CopyStateData));
  
+ 	/*
+ 	 * We allocate everything linked from cstate in new per-COPY context
+ 	 * which is created in caller's context.
+ 	 * This would avoid memory leak repeated COPY use in a query.
+ 	 *
+ 	 * Caller should MemoryContextDelete(cstate->copycontext) first, and then
+ 	 * pfree(cstate) to release memory.
+ 	 */
+ 	cstate->copycontext = AllocSetContextCreate(CurrentMemoryContext,
+ 												"COPY context",
+ 												ALLOCSET_DEFAULT_MINSIZE,
+ 												ALLOCSET_DEFAULT_INITSIZE,
+ 												ALLOCSET_DEFAULT_MAXSIZE);
+ 	oldcontext = MemoryContextSwitchTo(cstate->copycontext);
+ 
  	/* Extract options from the statement node tree */
  	foreach(option, options)
  	{
*************** BeginCopy(bool is_from,
*** 1242,1250 ****
--- 1264,1284 ----
  
  	cstate->copy_dest = COPY_FILE;		/* default */
  
+ 	/* switch back to caller's context */
+ 	MemoryContextSwitchTo(oldcontext);
+ 
  	return cstate;
  }
  
+ /*
+  * Release resources allocated in BeginCopu() for this copy execution.
+  */
+ static void
+ EndCopy(CopyState cstate)
+ {
+ 	MemoryContextDelete(cstate->copycontext);
+ 	pfree(cstate);
+ }
  
  /*
   * Setup CopyState to read tuples from a table or a query for COPY TO.
*************** BeginCopyTo(Relation rel,
*** 1259,1266 ****
--- 1293,1302 ----
  {
  	CopyState	cstate;
  	bool		pipe = (filename == NULL);
+ 	MemoryContext oldcontext;
  
  	cstate = BeginCopy(false, rel, query, queryString, attnamelist, options);
+ 	oldcontext = MemoryContextSwitchTo(cstate->copycontext);
  
  	if (cstate->rel)
  	{
*************** BeginCopyTo(Relation rel,
*** 1328,1333 ****
--- 1364,1372 ----
  					 errmsg("\"%s\" is a directory", cstate->filename)));
  	}
  
+ 	/* switch back to caller's context */
+ 	MemoryContextSwitchTo(oldcontext);
+ 
  	return cstate;
  }
  
*************** EndCopyTo(CopyState cstate)
*** 1395,1401 ****
  		PopActiveSnapshot();
  	}
  
! 	pfree(cstate);
  }
  
  /*
--- 1434,1441 ----
  		PopActiveSnapshot();
  	}
  
! 	/* Release memory resources */
! 	EndCopy(cstate);
  }
  
  /*
*************** BeginCopyFrom(Relation rel,
*** 2010,2017 ****
--- 2050,2059 ----
  	EState	   *estate = CreateExecutorState(); /* for ExecPrepareExpr() */
  	int		   *defmap;
  	ExprState **defexprs;
+ 	MemoryContext oldcontext;
  
  	cstate = BeginCopy(true, rel, NULL, NULL, attnamelist, options);
+ 	oldcontext = MemoryContextSwitchTo(cstate->copycontext);
  
  	/* Initialize state variables */
  	cstate->fe_eof = false;
*************** BeginCopyFrom(Relation rel,
*** 2172,2177 ****
--- 2214,2221 ----
  		cstate->raw_fields = (char **) palloc(nfields * sizeof(char *));
  	}
  
+ 	MemoryContextSwitchTo(oldcontext);
+ 
  	return cstate;
  }
  
*************** EndCopyFrom(CopyState cstate)
*** 2433,2448 ****
  	}
  
  	/* Clean up storage */
! 	if (!cstate->binary)
! 		pfree(cstate->raw_fields);
! 	pfree(cstate->attribute_buf.data);
! 	pfree(cstate->line_buf.data);
! 	pfree(cstate->raw_buf);
! 	pfree(cstate->in_functions);
! 	pfree(cstate->typioparams);
! 	pfree(cstate->defmap);
! 	pfree(cstate->defexprs);
! 	pfree(cstate);
  }
  
  
--- 2477,2483 ----
  	}
  
  	/* Clean up storage */
! 	EndCopy(cstate);
  }
  
  

diff --git a/src/backend/commands/copy.c b/src/backend/commands/copy.c
index 841bf22..3a8d8d3 100644
*** a/src/backend/commands/copy.c
--- b/src/backend/commands/copy.c
*************** typedef struct CopyStateData
*** 93,105 ****
  	FILE	   *copy_file;		/* used if copy_dest == COPY_FILE */
  	StringInfo	fe_msgbuf;		/* used for all dests during COPY TO, only for
  								 * dest == COPY_NEW_FE in COPY FROM */
- 	bool		fe_copy;		/* true for all FE copy dests */
  	bool		fe_eof;			/* true if detected end of copy data */
  	EolType		eol_type;		/* EOL type of input */
  	int			client_encoding;	/* remote side's character encoding */
  	bool		need_transcoding;		/* client encoding diff from server? */
  	bool		encoding_embeds_ascii;	/* ASCII can be non-first byte? */
- 	uint64		processed;		/* # of tuples processed */
  
  	/* parameters from the COPY command */
  	Relation	rel;			/* relation to copy to or from */
--- 93,103 ----
*************** typedef struct CopyStateData
*** 119,131 ****
  	bool	   *force_quote_flags;		/* per-column CSV FQ flags */
  	bool	   *force_notnull_flags;	/* per-column CSV FNN flags */
  
! 	/* these are just for error messages, see copy_in_error_callback */
  	const char *cur_relname;	/* table name for error messages */
  	int			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 for COPY TO
  	 */
  	FmgrInfo   *out_functions;	/* lookup info for output functions */
--- 117,134 ----
  	bool	   *force_quote_flags;		/* per-column CSV FQ flags */
  	bool	   *force_notnull_flags;	/* per-column CSV FNN flags */
  
! 	/* these are just for error messages, see CopyFromErrorCallback */
  	const char *cur_relname;	/* table name for error messages */
  	int			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 for COPY TO/FROM
+ 	 */
+ 	MemoryContext copycontext;	/* per-copy execution context */
+ 
+ 	/*
  	 * Working state for COPY TO
  	 */
  	FmgrInfo   *out_functions;	/* lookup info for output functions */
*************** typedef struct CopyStateData
*** 167,181 ****
  	char	   *raw_buf;
  	int			raw_buf_index;	/* next byte to process */
  	int			raw_buf_len;	/* total # of bytes stored */
- } CopyStateData;
  
! typedef CopyStateData *CopyState;
  
  /* DestReceiver for COPY (SELECT) TO */
  typedef struct
  {
  	DestReceiver pub;			/* publicly-known function pointers */
  	CopyState	cstate;			/* CopyStateData for the command */
  } DR_copy;
  
  
--- 170,197 ----
  	char	   *raw_buf;
  	int			raw_buf_index;	/* next byte to process */
  	int			raw_buf_len;	/* total # of bytes stored */
  
! 	/*
! 	 * The definition of input functions and default expressions are stored
! 	 * in these variables.
! 	 */
! 	EState	   *estate;
! 	AttrNumber	num_defaults;
! 	bool		file_has_oids;
! 	FmgrInfo	oid_in_function;
! 	Oid			oid_typioparam;
! 	FmgrInfo   *in_functions;
! 	Oid		   *typioparams;
! 	int		   *defmap;
! 	ExprState **defexprs;		/* array of default att expressions */
! } CopyStateData;
  
  /* DestReceiver for COPY (SELECT) TO */
  typedef struct
  {
  	DestReceiver pub;			/* publicly-known function pointers */
  	CopyState	cstate;			/* CopyStateData for the command */
+ 	uint64		processed;		/* # of tuples processed */
  } DR_copy;
  
  
*************** static const char BinarySignature[11] = 
*** 248,258 ****
  
  
  /* non-export function prototypes */
! static void DoCopyTo(CopyState cstate);
! static void CopyTo(CopyState cstate);
  static void CopyOneRowTo(CopyState cstate, Oid tupleOid,
  			 Datum *values, bool *nulls);
! static void CopyFrom(CopyState cstate);
  static bool CopyReadLine(CopyState cstate);
  static bool CopyReadLineText(CopyState cstate);
  static int CopyReadAttributesText(CopyState cstate);
--- 264,280 ----
  
  
  /* non-export function prototypes */
! static CopyState BeginCopy(bool is_from, Relation rel, Node *raw_query,
! 				const char *queryString, List *attnamelist, List *options);
! static void EndCopy(CopyState cstate);
! static CopyState BeginCopyTo(Relation rel, Node *query, const char *queryString,
! 				const char *filename, List *attnamelist, List *options);
! static void EndCopyTo(CopyState cstate);
! static uint64 DoCopyTo(CopyState cstate);
! static uint64 CopyTo(CopyState cstate);
  static void CopyOneRowTo(CopyState cstate, Oid tupleOid,
  			 Datum *values, bool *nulls);
! static uint64 CopyFrom(CopyState cstate);
  static bool CopyReadLine(CopyState cstate);
  static bool CopyReadLineText(CopyState cstate);
  static int CopyReadAttributesText(CopyState cstate);
*************** DoCopy(const CopyStmt *stmt, const char 
*** 724,745 ****
  	CopyState	cstate;
  	bool		is_from = stmt->is_from;
  	bool		pipe = (stmt->filename == NULL);
! 	List	   *attnamelist = stmt->attlist;
  	List	   *force_quote = NIL;
  	List	   *force_notnull = NIL;
  	bool		force_quote_all = false;
  	bool		format_specified = false;
- 	AclMode		required_access = (is_from ? ACL_INSERT : ACL_SELECT);
  	ListCell   *option;
  	TupleDesc	tupDesc;
  	int			num_phys_attrs;
! 	uint64		processed;
  
  	/* Allocate workspace and zero all fields */
  	cstate = (CopyStateData *) palloc0(sizeof(CopyStateData));
  
  	/* Extract options from the statement node tree */
! 	foreach(option, stmt->options)
  	{
  		DefElem    *defel = (DefElem *) lfirst(option);
  
--- 746,870 ----
  	CopyState	cstate;
  	bool		is_from = stmt->is_from;
  	bool		pipe = (stmt->filename == NULL);
! 	Relation	rel;
! 	uint64		processed;
! 
! 	/* Disallow file COPY except to superusers. */
! 	if (!pipe && !superuser())
! 		ereport(ERROR,
! 				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
! 				 errmsg("must be superuser to COPY to or from a file"),
! 				 errhint("Anyone can COPY to stdout or from stdin. "
! 						 "psql's \\copy command also works for anyone.")));
! 
! 	if (stmt->relation)
! 	{
! 		TupleDesc		tupDesc;
! 		AclMode			required_access = (is_from ? ACL_INSERT : ACL_SELECT);
! 		RangeTblEntry  *rte;
! 		List		   *attnums;
! 		ListCell	   *cur;
! 
! 		Assert(!stmt->query);
! 
! 		/* Open and lock the relation, using the appropriate lock type. */
! 		rel = heap_openrv(stmt->relation,
! 							 (is_from ? RowExclusiveLock : AccessShareLock));
! 
! 		rte = makeNode(RangeTblEntry);
! 		rte->rtekind = RTE_RELATION;
! 		rte->relid = RelationGetRelid(rel);
! 		rte->requiredPerms = required_access;
! 
! 		tupDesc = RelationGetDescr(rel);
! 		attnums = CopyGetAttnums(tupDesc, rel, stmt->attlist);
! 		foreach (cur, attnums)
! 		{
! 			int		attno = lfirst_int(cur) -
! 							FirstLowInvalidHeapAttributeNumber;
! 
! 			if (is_from)
! 				rte->modifiedCols = bms_add_member(rte->modifiedCols, attno);
! 			else
! 				rte->selectedCols = bms_add_member(rte->selectedCols, attno);
! 		}
! 		ExecCheckRTPerms(list_make1(rte), true);
! 	}
! 	else
! 	{
! 		Assert(stmt->query);
! 
! 		rel = NULL;
! 	}
! 
! 	if (is_from)
! 	{
! 		/* check read-only transaction */
! 		if (XactReadOnly && rel->rd_backend != MyBackendId)
! 			PreventCommandIfReadOnly("COPY FROM");
! 
! 		cstate = BeginCopyFrom(rel, stmt->filename,
! 							   stmt->attlist, stmt->options);
! 		processed = CopyFrom(cstate);	/* copy from file to database */
! 		EndCopyFrom(cstate);
! 	}
! 	else
! 	{
! 		cstate = BeginCopyTo(rel, stmt->query, queryString, stmt->filename,
! 							 stmt->attlist, stmt->options);
! 		processed = DoCopyTo(cstate);	/* copy from database to file */
! 		EndCopyTo(cstate);
! 	}
! 
! 	/*
! 	 * Close the relation. If reading, we can release the AccessShareLock we got;
! 	 * if writing, we should hold the lock until end of transaction to ensure that
! 	 * updates will be committed before lock is released.
! 	 */
! 	if (rel != NULL)
! 		heap_close(rel, (is_from ? NoLock : AccessShareLock));
! 
! 	return processed;
! }
! 
! /*
!  * Common setup routines used by BeginCopyFrom and BeginCopyTo.
!  */
! static CopyState
! BeginCopy(bool is_from,
! 		  Relation rel,
! 		  Node *raw_query,
! 		  const char *queryString,
! 		  List *attnamelist,
! 		  List *options)
! {
! 	CopyState	cstate;
  	List	   *force_quote = NIL;
  	List	   *force_notnull = NIL;
  	bool		force_quote_all = false;
  	bool		format_specified = false;
  	ListCell   *option;
  	TupleDesc	tupDesc;
  	int			num_phys_attrs;
! 	MemoryContext oldcontext;
  
  	/* Allocate workspace and zero all fields */
  	cstate = (CopyStateData *) palloc0(sizeof(CopyStateData));
  
+ 	/*
+ 	 * We allocate everything used by a cstate in a new memory context.
+ 	 * This would avoid memory leaks repeated uses of COPY in a query.
+ 	 */
+ 	cstate->copycontext = AllocSetContextCreate(CurrentMemoryContext,
+ 												"COPY",
+ 												ALLOCSET_DEFAULT_MINSIZE,
+ 												ALLOCSET_DEFAULT_INITSIZE,
+ 												ALLOCSET_DEFAULT_MAXSIZE);
+ 
+ 	oldcontext = MemoryContextSwitchTo(cstate->copycontext);
+ 
  	/* Extract options from the statement node tree */
! 	foreach(option, options)
  	{
  		DefElem    *defel = (DefElem *) lfirst(option);
  
*************** DoCopy(const CopyStmt *stmt, const char 
*** 980,1030 ****
  				(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
  				 errmsg("CSV quote character must not appear in the NULL specification")));
  
! 	/* Disallow file COPY except to superusers. */
! 	if (!pipe && !superuser())
! 		ereport(ERROR,
! 				(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
! 				 errmsg("must be superuser to COPY to or from a file"),
! 				 errhint("Anyone can COPY to stdout or from stdin. "
! 						 "psql's \\copy command also works for anyone.")));
! 
! 	if (stmt->relation)
  	{
! 		RangeTblEntry  *rte;
! 		List		   *attnums;
! 		ListCell	   *cur;
! 
! 		Assert(!stmt->query);
! 		cstate->queryDesc = NULL;
  
! 		/* Open and lock the relation, using the appropriate lock type. */
! 		cstate->rel = heap_openrv(stmt->relation,
! 							 (is_from ? RowExclusiveLock : AccessShareLock));
  
  		tupDesc = RelationGetDescr(cstate->rel);
  
- 		/* Check relation permissions. */
- 		rte = makeNode(RangeTblEntry);
- 		rte->rtekind = RTE_RELATION;
- 		rte->relid = RelationGetRelid(cstate->rel);
- 		rte->requiredPerms = required_access;
- 
- 		attnums = CopyGetAttnums(tupDesc, cstate->rel, attnamelist);
- 		foreach (cur, attnums)
- 		{
- 			int		attno = lfirst_int(cur) - FirstLowInvalidHeapAttributeNumber;
- 
- 			if (is_from)
- 				rte->modifiedCols = bms_add_member(rte->modifiedCols, attno);
- 			else
- 				rte->selectedCols = bms_add_member(rte->selectedCols, attno);
- 		}
- 		ExecCheckRTPerms(list_make1(rte), true);
- 
- 		/* check read-only transaction */
- 		if (XactReadOnly && is_from && cstate->rel->rd_backend != MyBackendId)
- 			PreventCommandIfReadOnly("COPY FROM");
- 
  		/* Don't allow COPY w/ OIDs to or from a table without them */
  		if (cstate->oids && !cstate->rel->rd_rel->relhasoids)
  			ereport(ERROR,
--- 1105,1118 ----
  				(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
  				 errmsg("CSV quote character must not appear in the NULL specification")));
  
! 	if (rel)
  	{
! 		Assert(!raw_query);
  
! 		cstate->rel = rel;
  
  		tupDesc = RelationGetDescr(cstate->rel);
  
  		/* Don't allow COPY w/ OIDs to or from a table without them */
  		if (cstate->oids && !cstate->rel->rd_rel->relhasoids)
  			ereport(ERROR,
*************** DoCopy(const CopyStmt *stmt, const char 
*** 1058,1064 ****
  		 * function and is executed repeatedly.  (See also the same hack in
  		 * DECLARE CURSOR and PREPARE.)  XXX FIXME someday.
  		 */
! 		rewritten = pg_analyze_and_rewrite((Node *) copyObject(stmt->query),
  										   queryString, NULL, 0);
  
  		/* We don't expect more or less than one result query */
--- 1146,1152 ----
  		 * function and is executed repeatedly.  (See also the same hack in
  		 * DECLARE CURSOR and PREPARE.)  XXX FIXME someday.
  		 */
! 		rewritten = pg_analyze_and_rewrite((Node *) copyObject(raw_query),
  										   queryString, NULL, 0);
  
  		/* We don't expect more or less than one result query */
*************** DoCopy(const CopyStmt *stmt, const char 
*** 1160,1173 ****
  		}
  	}
  
- 	/* Set up variables to avoid per-attribute overhead. */
- 	initStringInfo(&cstate->attribute_buf);
- 	initStringInfo(&cstate->line_buf);
- 	cstate->line_buf_converted = false;
- 	cstate->raw_buf = (char *) palloc(RAW_BUF_SIZE + 1);
- 	cstate->raw_buf_index = cstate->raw_buf_len = 0;
- 	cstate->processed = 0;
- 
  	/*
  	 * Set up encoding conversion info.  Even if the client and server
  	 * encodings are the same, we must apply pg_client_to_server() to validate
--- 1248,1253 ----
*************** DoCopy(const CopyStmt *stmt, const char 
*** 1181,1264 ****
  	cstate->encoding_embeds_ascii = PG_ENCODING_IS_CLIENT_ONLY(cstate->client_encoding);
  
  	cstate->copy_dest = COPY_FILE;		/* default */
- 	cstate->filename = stmt->filename;
- 
- 	if (is_from)
- 		CopyFrom(cstate);		/* copy from file to database */
- 	else
- 		DoCopyTo(cstate);		/* copy from database to file */
  
! 	/*
! 	 * Close the relation or query.  If reading, we can release the
! 	 * AccessShareLock we got; if writing, we should hold the lock until end
! 	 * of transaction to ensure that updates will be committed before lock is
! 	 * released.
! 	 */
! 	if (cstate->rel)
! 		heap_close(cstate->rel, (is_from ? NoLock : AccessShareLock));
! 	else
! 	{
! 		/* Close down the query and free resources. */
! 		ExecutorEnd(cstate->queryDesc);
! 		FreeQueryDesc(cstate->queryDesc);
! 		PopActiveSnapshot();
! 	}
  
! 	/* Clean up storage (probably not really necessary) */
! 	processed = cstate->processed;
  
! 	pfree(cstate->attribute_buf.data);
! 	pfree(cstate->line_buf.data);
! 	pfree(cstate->raw_buf);
  	pfree(cstate);
- 
- 	return processed;
  }
  
- 
  /*
!  * This intermediate routine exists mainly to localize the effects of setjmp
!  * so we don't need to plaster a lot of variables with "volatile".
   */
! static void
! DoCopyTo(CopyState cstate)
  {
! 	bool		pipe = (cstate->filename == NULL);
  
! 	if (cstate->rel)
  	{
! 		if (cstate->rel->rd_rel->relkind != RELKIND_RELATION)
! 		{
! 			if (cstate->rel->rd_rel->relkind == RELKIND_VIEW)
! 				ereport(ERROR,
! 						(errcode(ERRCODE_WRONG_OBJECT_TYPE),
! 						 errmsg("cannot copy from view \"%s\"",
! 								RelationGetRelationName(cstate->rel)),
! 						 errhint("Try the COPY (SELECT ...) TO variant.")));
! 			else if (cstate->rel->rd_rel->relkind == RELKIND_FOREIGN_TABLE)
! 				ereport(ERROR,
! 						(errcode(ERRCODE_WRONG_OBJECT_TYPE),
! 						 errmsg("cannot copy from foreign table \"%s\"",
! 								RelationGetRelationName(cstate->rel)),
! 						 errhint("Try the COPY (SELECT ...) TO variant.")));
! 			else if (cstate->rel->rd_rel->relkind == RELKIND_SEQUENCE)
! 				ereport(ERROR,
! 						(errcode(ERRCODE_WRONG_OBJECT_TYPE),
! 						 errmsg("cannot copy from sequence \"%s\"",
! 								RelationGetRelationName(cstate->rel))));
! 			else
! 				ereport(ERROR,
! 						(errcode(ERRCODE_WRONG_OBJECT_TYPE),
! 						 errmsg("cannot copy from non-table relation \"%s\"",
! 								RelationGetRelationName(cstate->rel))));
! 		}
  	}
  
  	if (pipe)
  	{
! 		if (whereToSendOutput == DestRemote)
! 			cstate->fe_copy = true;
! 		else
  			cstate->copy_file = stdout;
  	}
  	else
--- 1261,1329 ----
  	cstate->encoding_embeds_ascii = PG_ENCODING_IS_CLIENT_ONLY(cstate->client_encoding);
  
  	cstate->copy_dest = COPY_FILE;		/* default */
  
! 	MemoryContextSwitchTo(oldcontext);
  
! 	return cstate;
! }
  
! /*
!  * Release resources allocated in a cstate.
!  */
! static void
! EndCopy(CopyState cstate)
! {
! 	MemoryContextDelete(cstate->copycontext);
  	pfree(cstate);
  }
  
  /*
!  * Setup CopyState to read tuples from a table or a query for COPY TO.
   */
! static CopyState
! BeginCopyTo(Relation rel,
! 			Node *query,
! 			const char *queryString,
! 			const char *filename,
! 			List *attnamelist,
! 			List *options)
  {
! 	CopyState	cstate;
! 	bool		pipe = (filename == NULL);
! 	MemoryContext oldcontext;
  
! 	if (rel != NULL && rel->rd_rel->relkind != RELKIND_RELATION)
  	{
! 		if (rel->rd_rel->relkind == RELKIND_VIEW)
! 			ereport(ERROR,
! 					(errcode(ERRCODE_WRONG_OBJECT_TYPE),
! 					 errmsg("cannot copy from view \"%s\"",
! 							RelationGetRelationName(rel)),
! 					 errhint("Try the COPY (SELECT ...) TO variant.")));
! 		else if (rel->rd_rel->relkind == RELKIND_FOREIGN_TABLE)
! 			ereport(ERROR,
! 					(errcode(ERRCODE_WRONG_OBJECT_TYPE),
! 					 errmsg("cannot copy from foreign table \"%s\"",
! 							RelationGetRelationName(rel)),
! 					 errhint("Try the COPY (SELECT ...) TO variant.")));
! 		else if (rel->rd_rel->relkind == RELKIND_SEQUENCE)
! 			ereport(ERROR,
! 					(errcode(ERRCODE_WRONG_OBJECT_TYPE),
! 					 errmsg("cannot copy from sequence \"%s\"",
! 							RelationGetRelationName(rel))));
! 		else
! 			ereport(ERROR,
! 					(errcode(ERRCODE_WRONG_OBJECT_TYPE),
! 					 errmsg("cannot copy from non-table relation \"%s\"",
! 							RelationGetRelationName(rel))));
  	}
  
+ 	cstate = BeginCopy(false, rel, query, queryString, attnamelist, options);
+ 	oldcontext = MemoryContextSwitchTo(cstate->copycontext);
+ 
  	if (pipe)
  	{
! 		if (whereToSendOutput != DestRemote)
  			cstate->copy_file = stdout;
  	}
  	else
*************** DoCopyTo(CopyState cstate)
*** 1270,1280 ****
  		 * Prevent write to relative path ... too easy to shoot oneself in the
  		 * foot by overwriting a database file ...
  		 */
! 		if (!is_absolute_path(cstate->filename))
  			ereport(ERROR,
  					(errcode(ERRCODE_INVALID_NAME),
  					 errmsg("relative path not allowed for COPY to file")));
  
  		oumask = umask(S_IWGRP | S_IWOTH);
  		cstate->copy_file = AllocateFile(cstate->filename, PG_BINARY_W);
  		umask(oumask);
--- 1335,1346 ----
  		 * Prevent write to relative path ... too easy to shoot oneself in the
  		 * foot by overwriting a database file ...
  		 */
! 		if (!is_absolute_path(filename))
  			ereport(ERROR,
  					(errcode(ERRCODE_INVALID_NAME),
  					 errmsg("relative path not allowed for COPY to file")));
  
+ 		cstate->filename = pstrdup(filename);
  		oumask = umask(S_IWGRP | S_IWOTH);
  		cstate->copy_file = AllocateFile(cstate->filename, PG_BINARY_W);
  		umask(oumask);
*************** DoCopyTo(CopyState cstate)
*** 1292,1305 ****
  					 errmsg("\"%s\" is a directory", cstate->filename)));
  	}
  
  	PG_TRY();
  	{
! 		if (cstate->fe_copy)
  			SendCopyBegin(cstate);
  
! 		CopyTo(cstate);
  
! 		if (cstate->fe_copy)
  			SendCopyEnd(cstate);
  	}
  	PG_CATCH();
--- 1358,1387 ----
  					 errmsg("\"%s\" is a directory", cstate->filename)));
  	}
  
+ 	MemoryContextSwitchTo(oldcontext);
+ 
+ 	return cstate;
+ }
+ 
+ /*
+  * This intermediate routine exists mainly to localize the effects of setjmp
+  * so we don't need to plaster a lot of variables with "volatile".
+  */
+ static uint64
+ DoCopyTo(CopyState cstate)
+ {
+ 	bool		pipe = (cstate->filename == NULL);
+ 	bool		fe_copy = (pipe && whereToSendOutput == DestRemote);
+ 	uint64		processed;
+ 
  	PG_TRY();
  	{
! 		if (fe_copy)
  			SendCopyBegin(cstate);
  
! 		processed = CopyTo(cstate);
  
! 		if (fe_copy)
  			SendCopyEnd(cstate);
  	}
  	PG_CATCH();
*************** DoCopyTo(CopyState cstate)
*** 1314,1339 ****
  	}
  	PG_END_TRY();
  
! 	if (!pipe)
  	{
! 		if (FreeFile(cstate->copy_file))
! 			ereport(ERROR,
! 					(errcode_for_file_access(),
! 					 errmsg("could not write to file \"%s\": %m",
! 							cstate->filename)));
  	}
  }
  
  /*
   * Copy from relation or query TO file.
   */
! static void
  CopyTo(CopyState cstate)
  {
  	TupleDesc	tupDesc;
  	int			num_phys_attrs;
  	Form_pg_attribute *attr;
  	ListCell   *cur;
  
  	if (cstate->rel)
  		tupDesc = RelationGetDescr(cstate->rel);
--- 1396,1442 ----
  	}
  	PG_END_TRY();
  
! 	return processed;
! }
! 
! /*
!  * Clean up storage and release resources for COPY TO.
!  */
! static void
! EndCopyTo(CopyState cstate)
! {
! 	if (cstate->filename != NULL && FreeFile(cstate->copy_file))
! 		ereport(ERROR,
! 				(errcode_for_file_access(),
! 				 errmsg("could not close file \"%s\": %m",
! 						cstate->filename)));
! 
! 	/*
! 	 * Close the relation or query. We can release the AccessShareLock we got.
! 	 */
! 	if (cstate->queryDesc != NULL)
  	{
! 		/* Close down the query and free resources. */
! 		ExecutorEnd(cstate->queryDesc);
! 		FreeQueryDesc(cstate->queryDesc);
! 		PopActiveSnapshot();
  	}
+ 
+ 	/* Clean up storage */
+ 	EndCopy(cstate);
  }
  
  /*
   * Copy from relation or query TO file.
   */
! static uint64
  CopyTo(CopyState cstate)
  {
  	TupleDesc	tupDesc;
  	int			num_phys_attrs;
  	Form_pg_attribute *attr;
  	ListCell   *cur;
+ 	uint64		processed;
  
  	if (cstate->rel)
  		tupDesc = RelationGetDescr(cstate->rel);
*************** CopyTo(CopyState cstate)
*** 1439,1444 ****
--- 1542,1548 ----
  
  		scandesc = heap_beginscan(cstate->rel, GetActiveSnapshot(), 0, NULL);
  
+ 		processed = 0;
  		while ((tuple = heap_getnext(scandesc, ForwardScanDirection)) != NULL)
  		{
  			CHECK_FOR_INTERRUPTS();
*************** CopyTo(CopyState cstate)
*** 1448,1461 ****
--- 1552,1570 ----
  
  			/* Format and send the data */
  			CopyOneRowTo(cstate, HeapTupleGetOid(tuple), values, nulls);
+ 			processed++;
  		}
  
  		heap_endscan(scandesc);
+ 
+ 		pfree(values);
+ 		pfree(nulls);
  	}
  	else
  	{
  		/* run the plan --- the dest receiver will send tuples */
  		ExecutorRun(cstate->queryDesc, ForwardScanDirection, 0L);
+ 		processed = ((DR_copy *) cstate->queryDesc->dest)->processed;
  	}
  
  	if (cstate->binary)
*************** CopyTo(CopyState cstate)
*** 1467,1472 ****
--- 1576,1583 ----
  	}
  
  	MemoryContextDelete(cstate->rowcontext);
+ 
+ 	return processed;
  }
  
  /*
*************** CopyOneRowTo(CopyState cstate, Oid tuple
*** 1558,1573 ****
  	CopySendEndOfRow(cstate);
  
  	MemoryContextSwitchTo(oldcontext);
- 
- 	cstate->processed++;
  }
  
  
  /*
   * error context callback for COPY FROM
   */
! static void
! copy_in_error_callback(void *arg)
  {
  	CopyState	cstate = (CopyState) arg;
  
--- 1669,1684 ----
  	CopySendEndOfRow(cstate);
  
  	MemoryContextSwitchTo(oldcontext);
  }
  
  
  /*
   * error context callback for COPY FROM
+  *
+  * The argument for the error context must be CopyState.
   */
! void
! CopyFromErrorCallback(void *arg)
  {
  	CopyState	cstate = (CopyState) arg;
  
*************** limit_printout_length(const char *str)
*** 1669,1709 ****
  /*
   * Copy FROM file to relation.
   */
! static void
  CopyFrom(CopyState cstate)
  {
- 	bool		pipe = (cstate->filename == NULL);
  	HeapTuple	tuple;
  	TupleDesc	tupDesc;
- 	Form_pg_attribute *attr;
- 	AttrNumber	num_phys_attrs,
- 				attr_count,
- 				num_defaults;
- 	FmgrInfo   *in_functions;
- 	FmgrInfo	oid_in_function;
- 	Oid		   *typioparams;
- 	Oid			oid_typioparam;
- 	int			attnum;
- 	int			i;
- 	Oid			in_func_oid;
  	Datum	   *values;
  	bool	   *nulls;
- 	int			nfields;
- 	char	  **field_strings;
  	bool		done = false;
- 	bool		isnull;
  	ResultRelInfo *resultRelInfo;
! 	EState	   *estate = CreateExecutorState(); /* for ExecConstraints() */
  	TupleTableSlot *slot;
- 	bool		file_has_oids;
- 	int		   *defmap;
- 	ExprState **defexprs;		/* array of default att expressions */
- 	ExprContext *econtext;		/* used for ExecEvalExpr for default atts */
  	MemoryContext oldcontext = CurrentMemoryContext;
  	ErrorContextCallback errcontext;
  	CommandId	mycid = GetCurrentCommandId(true);
  	int			hi_options = 0; /* start with default heap_insert options */
  	BulkInsertState bistate;
  
  	Assert(cstate->rel);
  
--- 1780,1802 ----
  /*
   * Copy FROM file to relation.
   */
! static uint64
  CopyFrom(CopyState cstate)
  {
  	HeapTuple	tuple;
  	TupleDesc	tupDesc;
  	Datum	   *values;
  	bool	   *nulls;
  	bool		done = false;
  	ResultRelInfo *resultRelInfo;
! 	EState	   *estate = cstate->estate; /* for ExecConstraints() */
  	TupleTableSlot *slot;
  	MemoryContext oldcontext = CurrentMemoryContext;
  	ErrorContextCallback errcontext;
  	CommandId	mycid = GetCurrentCommandId(true);
  	int			hi_options = 0; /* start with default heap_insert options */
  	BulkInsertState bistate;
+ 	uint64		processed = 0;
  
  	Assert(cstate->rel);
  
*************** CopyFrom(CopyState cstate)
*** 1731,1736 ****
--- 1824,1831 ----
  							RelationGetRelationName(cstate->rel))));
  	}
  
+ 	tupDesc = RelationGetDescr(cstate->rel);
+ 
  	/*----------
  	 * Check to see if we can avoid writing WAL
  	 *
*************** CopyFrom(CopyState cstate)
*** 1766,1803 ****
  			hi_options |= HEAP_INSERT_SKIP_WAL;
  	}
  
- 	if (pipe)
- 	{
- 		if (whereToSendOutput == DestRemote)
- 			ReceiveCopyBegin(cstate);
- 		else
- 			cstate->copy_file = stdin;
- 	}
- 	else
- 	{
- 		struct stat st;
- 
- 		cstate->copy_file = AllocateFile(cstate->filename, PG_BINARY_R);
- 
- 		if (cstate->copy_file == NULL)
- 			ereport(ERROR,
- 					(errcode_for_file_access(),
- 					 errmsg("could not open file \"%s\" for reading: %m",
- 							cstate->filename)));
- 
- 		fstat(fileno(cstate->copy_file), &st);
- 		if (S_ISDIR(st.st_mode))
- 			ereport(ERROR,
- 					(errcode(ERRCODE_WRONG_OBJECT_TYPE),
- 					 errmsg("\"%s\" is a directory", cstate->filename)));
- 	}
- 
- 	tupDesc = RelationGetDescr(cstate->rel);
- 	attr = tupDesc->attrs;
- 	num_phys_attrs = tupDesc->natts;
- 	attr_count = list_length(cstate->attnumlist);
- 	num_defaults = 0;
- 
  	/*
  	 * We need a ResultRelInfo so we can use the regular executor's
  	 * index-entry-making machinery.  (There used to be a huge amount of code
--- 1861,1866 ----
*************** CopyFrom(CopyState cstate)
*** 1826,1832 ****
  	slot = ExecInitExtraTupleSlot(estate);
  	ExecSetSlotDescriptor(slot, tupDesc);
  
! 	econtext = GetPerTupleExprContext(estate);
  
  	/*
  	 * Pick up the required catalog information for each attribute in the
--- 1889,2070 ----
  	slot = ExecInitExtraTupleSlot(estate);
  	ExecSetSlotDescriptor(slot, tupDesc);
  
! 	/* Prepare to catch AFTER triggers. */
! 	AfterTriggerBeginQuery();
! 
! 	/*
! 	 * Check BEFORE STATEMENT insertion triggers. It's debateable whether we
! 	 * should do this for COPY, since it's not really an "INSERT" statement as
! 	 * such. However, executing these triggers maintains consistency with the
! 	 * EACH ROW triggers that we already fire on COPY.
! 	 */
! 	ExecBSInsertTriggers(estate, resultRelInfo);
! 
! 	values = (Datum *) palloc(tupDesc->natts * sizeof(Datum));
! 	nulls = (bool *) palloc(tupDesc->natts * sizeof(bool));
! 
! 	bistate = GetBulkInsertState();
! 
! 	/* Set up callback to identify error line number */
! 	errcontext.callback = CopyFromErrorCallback;
! 	errcontext.arg = (void *) cstate;
! 	errcontext.previous = error_context_stack;
! 	error_context_stack = &errcontext;
! 
! 	while (!done)
! 	{
! 		bool		skip_tuple;
! 		Oid			loaded_oid = InvalidOid;
! 
! 		CHECK_FOR_INTERRUPTS();
! 
! 		/* Reset the per-tuple exprcontext */
! 		ResetPerTupleExprContext(estate);
! 
! 		/* Switch into its memory context */
! 		MemoryContextSwitchTo(GetPerTupleMemoryContext(estate));
! 
! 		done = !NextCopyFrom(cstate, values, nulls, &loaded_oid);
! 		if (done)
! 			break;
! 
! 		/* And now we can form the input tuple. */
! 		tuple = heap_form_tuple(tupDesc, values, nulls);
! 
! 		if (loaded_oid != InvalidOid)
! 			HeapTupleSetOid(tuple, loaded_oid);
! 
! 		/* Triggers and stuff need to be invoked in query context. */
! 		MemoryContextSwitchTo(oldcontext);
! 
! 		skip_tuple = false;
! 
! 		/* BEFORE ROW INSERT Triggers */
! 		if (resultRelInfo->ri_TrigDesc &&
! 			resultRelInfo->ri_TrigDesc->trig_insert_before_row)
! 		{
! 			HeapTuple	newtuple;
! 
! 			newtuple = ExecBRInsertTriggers(estate, resultRelInfo, tuple);
! 
! 			if (newtuple == NULL)		/* "do nothing" */
! 				skip_tuple = true;
! 			else if (newtuple != tuple) /* modified by Trigger(s) */
! 			{
! 				heap_freetuple(tuple);
! 				tuple = newtuple;
! 			}
! 		}
! 
! 		if (!skip_tuple)
! 		{
! 			List	   *recheckIndexes = NIL;
! 
! 			/* Place tuple in tuple slot */
! 			ExecStoreTuple(tuple, slot, InvalidBuffer, false);
! 
! 			/* Check the constraints of the tuple */
! 			if (cstate->rel->rd_att->constr)
! 				ExecConstraints(resultRelInfo, slot, estate);
! 
! 			/* OK, store the tuple and create index entries for it */
! 			heap_insert(cstate->rel, tuple, mycid, hi_options, bistate);
! 
! 			if (resultRelInfo->ri_NumIndices > 0)
! 				recheckIndexes = ExecInsertIndexTuples(slot, &(tuple->t_self),
! 													   estate);
! 
! 			/* AFTER ROW INSERT Triggers */
! 			ExecARInsertTriggers(estate, resultRelInfo, tuple,
! 								 recheckIndexes);
! 
! 			list_free(recheckIndexes);
! 
! 			/*
! 			 * We count only tuples not suppressed by a BEFORE INSERT trigger;
! 			 * this is the same definition used by execMain.c for counting
! 			 * tuples inserted by an INSERT command.
! 			 */
! 			processed++;
! 		}
! 	}
! 
! 	/* Done, clean up */
! 	error_context_stack = errcontext.previous;
! 
! 	FreeBulkInsertState(bistate);
! 
! 	MemoryContextSwitchTo(oldcontext);
! 
! 	/* Execute AFTER STATEMENT insertion triggers */
! 	ExecASInsertTriggers(estate, resultRelInfo);
! 
! 	/* Handle queued AFTER triggers */
! 	AfterTriggerEndQuery(estate);
! 
! 	pfree(values);
! 	pfree(nulls);
! 
! 	ExecResetTupleTable(estate->es_tupleTable, false);
! 
! 	ExecCloseIndices(resultRelInfo);
! 
! 	/*
! 	 * If we skipped writing WAL, then we need to sync the heap (but not
! 	 * indexes since those use WAL anyway)
! 	 */
! 	if (hi_options & HEAP_INSERT_SKIP_WAL)
! 		heap_sync(cstate->rel);
! 
! 	return processed;
! }
! 
! /*
!  * Setup CopyState to read tuples from a file for COPY FROM.
!  */
! CopyState
! BeginCopyFrom(Relation rel,
! 			  const char *filename,
! 			  List *attnamelist,
! 			  List *options)
! {
! 	CopyState	cstate;
! 	bool		pipe = (filename == NULL);
! 	TupleDesc	tupDesc;
! 	Form_pg_attribute *attr;
! 	AttrNumber	num_phys_attrs,
! 				num_defaults;
! 	FmgrInfo   *in_functions;
! 	Oid		   *typioparams;
! 	int			attnum;
! 	Oid			in_func_oid;
! 	EState	   *estate = CreateExecutorState(); /* for ExecPrepareExpr() */
! 	int		   *defmap;
! 	ExprState **defexprs;
! 	MemoryContext oldcontext;
! 
! 	cstate = BeginCopy(true, rel, NULL, NULL, attnamelist, options);
! 	oldcontext = MemoryContextSwitchTo(cstate->copycontext);
! 
! 	/* Initialize state variables */
! 	cstate->fe_eof = false;
! 	cstate->eol_type = EOL_UNKNOWN;
! 	cstate->cur_relname = RelationGetRelationName(cstate->rel);
! 	cstate->cur_lineno = 0;
! 	cstate->cur_attname = NULL;
! 	cstate->cur_attval = NULL;
! 
! 	/* Set up variables to avoid per-attribute overhead. */
! 	initStringInfo(&cstate->attribute_buf);
! 	initStringInfo(&cstate->line_buf);
! 	cstate->line_buf_converted = false;
! 	cstate->raw_buf = (char *) palloc(RAW_BUF_SIZE + 1);
! 	cstate->raw_buf_index = cstate->raw_buf_len = 0;
! 
! 	tupDesc = RelationGetDescr(cstate->rel);
! 	attr = tupDesc->attrs;
! 	num_phys_attrs = tupDesc->natts;
! 	num_defaults = 0;
  
  	/*
  	 * Pick up the required catalog information for each attribute in the
*************** CopyFrom(CopyState cstate)
*** 1871,1889 ****
  		}
  	}
  
! 	/* Prepare to catch AFTER triggers. */
! 	AfterTriggerBeginQuery();
  
! 	/*
! 	 * Check BEFORE STATEMENT insertion triggers. It's debateable whether we
! 	 * should do this for COPY, since it's not really an "INSERT" statement as
! 	 * such. However, executing these triggers maintains consistency with the
! 	 * EACH ROW triggers that we already fire on COPY.
! 	 */
! 	ExecBSInsertTriggers(estate, resultRelInfo);
  
  	if (!cstate->binary)
! 		file_has_oids = cstate->oids;	/* must rely on user to tell us... */
  	else
  	{
  		/* Read and verify binary header */
--- 2109,2154 ----
  		}
  	}
  
! 	/* We keep those variables in cstate. */
! 	cstate->estate = estate;
! 	cstate->in_functions = in_functions;
! 	cstate->typioparams = typioparams;
! 	cstate->defmap = defmap;
! 	cstate->defexprs = defexprs;
! 	cstate->num_defaults = num_defaults;
  
! 	if (pipe)
! 	{
! 		if (whereToSendOutput == DestRemote)
! 			ReceiveCopyBegin(cstate);
! 		else
! 			cstate->copy_file = stdin;
! 	}
! 	else
! 	{
! 		struct stat st;
! 
! 		cstate->filename = pstrdup(filename);
! 		cstate->copy_file = AllocateFile(cstate->filename, PG_BINARY_R);
! 
! 		if (cstate->copy_file == NULL)
! 			ereport(ERROR,
! 					(errcode_for_file_access(),
! 					 errmsg("could not open file \"%s\" for reading: %m",
! 							cstate->filename)));
! 
! 		fstat(fileno(cstate->copy_file), &st);
! 		if (S_ISDIR(st.st_mode))
! 			ereport(ERROR,
! 					(errcode(ERRCODE_WRONG_OBJECT_TYPE),
! 					 errmsg("\"%s\" is a directory", cstate->filename)));
! 	}
  
  	if (!cstate->binary)
! 	{
! 		/* must rely on user to tell us... */
! 		cstate->file_has_oids = cstate->oids;
! 	}
  	else
  	{
  		/* Read and verify binary header */
*************** CopyFrom(CopyState cstate)
*** 1901,1907 ****
  			ereport(ERROR,
  					(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
  					 errmsg("invalid COPY file header (missing flags)")));
! 		file_has_oids = (tmp & (1 << 16)) != 0;
  		tmp &= ~(1 << 16);
  		if ((tmp >> 16) != 0)
  			ereport(ERROR,
--- 2166,2172 ----
  			ereport(ERROR,
  					(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
  					 errmsg("invalid COPY file header (missing flags)")));
! 		cstate->file_has_oids = (tmp & (1 << 16)) != 0;
  		tmp &= ~(1 << 16);
  		if ((tmp >> 16) != 0)
  			ereport(ERROR,
*************** CopyFrom(CopyState cstate)
*** 1923,1984 ****
  		}
  	}
  
! 	if (file_has_oids && cstate->binary)
  	{
  		getTypeBinaryInputInfo(OIDOID,
! 							   &in_func_oid, &oid_typioparam);
! 		fmgr_info(in_func_oid, &oid_in_function);
  	}
  
- 	values = (Datum *) palloc(num_phys_attrs * sizeof(Datum));
- 	nulls = (bool *) palloc(num_phys_attrs * sizeof(bool));
- 
  	/* create workspace for CopyReadAttributes results */
! 	nfields = file_has_oids ? (attr_count + 1) : attr_count;
! 	if (! cstate->binary)
  	{
  		cstate->max_fields = nfields;
  		cstate->raw_fields = (char **) palloc(nfields * sizeof(char *));
  	}
  
! 	/* Initialize state variables */
! 	cstate->fe_eof = false;
! 	cstate->eol_type = EOL_UNKNOWN;
! 	cstate->cur_relname = RelationGetRelationName(cstate->rel);
! 	cstate->cur_lineno = 0;
! 	cstate->cur_attname = NULL;
! 	cstate->cur_attval = NULL;
  
! 	bistate = GetBulkInsertState();
  
! 	/* Set up callback to identify error line number */
! 	errcontext.callback = copy_in_error_callback;
! 	errcontext.arg = (void *) cstate;
! 	errcontext.previous = error_context_stack;
! 	error_context_stack = &errcontext;
  
  	/* on input just throw the header line away */
! 	if (cstate->header_line)
  	{
  		cstate->cur_lineno++;
! 		done = CopyReadLine(cstate);
  	}
  
! 	while (!done)
! 	{
! 		bool		skip_tuple;
! 		Oid			loaded_oid = InvalidOid;
! 
! 		CHECK_FOR_INTERRUPTS();
  
  		cstate->cur_lineno++;
  
- 		/* Reset the per-tuple exprcontext */
- 		ResetPerTupleExprContext(estate);
- 
- 		/* Switch into its memory context */
- 		MemoryContextSwitchTo(GetPerTupleMemoryContext(estate));
- 
  		/* Initialize all values for row to NULL */
  		MemSet(values, 0, num_phys_attrs * sizeof(Datum));
  		MemSet(nulls, true, num_phys_attrs * sizeof(bool));
--- 2188,2258 ----
  		}
  	}
  
! 	if (cstate->file_has_oids && cstate->binary)
  	{
  		getTypeBinaryInputInfo(OIDOID,
! 							   &in_func_oid, &cstate->oid_typioparam);
! 		fmgr_info(in_func_oid, &cstate->oid_in_function);
  	}
  
  	/* create workspace for CopyReadAttributes results */
! 	if (!cstate->binary)
  	{
+ 		AttrNumber	attr_count = list_length(cstate->attnumlist);
+ 		int	nfields = cstate->file_has_oids ? (attr_count + 1) : attr_count;
+ 
  		cstate->max_fields = nfields;
  		cstate->raw_fields = (char **) palloc(nfields * sizeof(char *));
  	}
  
! 	MemoryContextSwitchTo(oldcontext);
  
! 	return cstate;
! }
  
! /*
!  * Read next tuple from file for COPY FROM. Return false if no more tuples.
!  *
!  * valus and nulls arrays must be the same length as columns of the
!  * relation passed to BeginCopyFrom. Oid of the tuple is returned with
!  * tupleOid separately.
!  */
! bool
! NextCopyFrom(CopyState cstate, Datum *values, bool *nulls, Oid *tupleOid)
! {
! 	TupleDesc	tupDesc;
! 	Form_pg_attribute *attr;
! 	AttrNumber	num_phys_attrs,
! 				attr_count,
! 				num_defaults = cstate->num_defaults;
! 	FmgrInfo   *in_functions = cstate->in_functions;
! 	Oid		   *typioparams = cstate->typioparams;
! 	int			i;
! 	int			nfields;
! 	char	  **field_strings;
! 	bool		isnull;
! 	bool		file_has_oids = cstate->file_has_oids;
! 	int		   *defmap = cstate->defmap;
! 	ExprState **defexprs = cstate->defexprs;
! 	ExprContext	*econtext;		/* used for ExecEvalExpr for default atts */
  
  	/* on input just throw the header line away */
! 	if (cstate->cur_lineno == 0 && cstate->header_line)
  	{
  		cstate->cur_lineno++;
! 		if (CopyReadLine(cstate))
! 			return false;	/* done */
  	}
  
! 	tupDesc = RelationGetDescr(cstate->rel);
! 	attr = tupDesc->attrs;
! 	num_phys_attrs = tupDesc->natts;
! 	attr_count = list_length(cstate->attnumlist);
! 	nfields = file_has_oids ? (attr_count + 1) : attr_count;
  
+ 	/* XXX: Indentation is not adjusted to keep the patch small. */
  		cstate->cur_lineno++;
  
  		/* Initialize all values for row to NULL */
  		MemSet(values, 0, num_phys_attrs * sizeof(Datum));
  		MemSet(nulls, true, num_phys_attrs * sizeof(bool));
*************** CopyFrom(CopyState cstate)
*** 1989,1994 ****
--- 2263,2269 ----
  			int			fldct;
  			int			fieldno;
  			char	   *string;
+ 			bool		done;
  
  			/* Actually read the line into memory here */
  			done = CopyReadLine(cstate);
*************** CopyFrom(CopyState cstate)
*** 1999,2005 ****
  			 * EOF, ie, process the line and then exit loop on next iteration.
  			 */
  			if (done && cstate->line_buf.len == 0)
! 				break;
  
  			/* Parse the line into de-escaped field values */
  			if (cstate->csv_mode)
--- 2274,2280 ----
  			 * EOF, ie, process the line and then exit loop on next iteration.
  			 */
  			if (done && cstate->line_buf.len == 0)
! 				return false;
  
  			/* Parse the line into de-escaped field values */
  			if (cstate->csv_mode)
*************** CopyFrom(CopyState cstate)
*** 2029,2041 ****
  					ereport(ERROR,
  							(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
  							 errmsg("null OID in COPY data")));
! 				else
  				{
  					cstate->cur_attname = "oid";
  					cstate->cur_attval = string;
! 					loaded_oid = DatumGetObjectId(DirectFunctionCall1(oidin,
! 												   CStringGetDatum(string)));
! 					if (loaded_oid == InvalidOid)
  						ereport(ERROR,
  								(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
  								 errmsg("invalid OID in COPY data")));
--- 2304,2316 ----
  					ereport(ERROR,
  							(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
  							 errmsg("null OID in COPY data")));
! 				else if (cstate->oids && tupleOid != NULL)
  				{
  					cstate->cur_attname = "oid";
  					cstate->cur_attval = string;
! 					*tupleOid = DatumGetObjectId(DirectFunctionCall1(oidin,
! 													   CStringGetDatum(string)));
! 					if (*tupleOid == InvalidOid)
  						ereport(ERROR,
  								(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
  								 errmsg("invalid OID in COPY data")));
*************** CopyFrom(CopyState cstate)
*** 2087,2094 ****
  			if (!CopyGetInt16(cstate, &fld_count))
  			{
  				/* EOF detected (end of file, or protocol-level EOF) */
! 				done = true;
! 				break;
  			}
  
  			if (fld_count == -1)
--- 2362,2368 ----
  			if (!CopyGetInt16(cstate, &fld_count))
  			{
  				/* EOF detected (end of file, or protocol-level EOF) */
! 				return false;
  			}
  
  			if (fld_count == -1)
*************** CopyFrom(CopyState cstate)
*** 2112,2119 ****
  					ereport(ERROR,
  							(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
  							 errmsg("received copy data after EOF marker")));
! 				done = true;
! 				break;
  			}
  
  			if (fld_count != attr_count)
--- 2386,2392 ----
  					ereport(ERROR,
  							(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
  							 errmsg("received copy data after EOF marker")));
! 				return false;
  			}
  
  			if (fld_count != attr_count)
*************** CopyFrom(CopyState cstate)
*** 2124,2135 ****
  
  			if (file_has_oids)
  			{
  				cstate->cur_attname = "oid";
  				loaded_oid =
  					DatumGetObjectId(CopyReadBinaryAttribute(cstate,
  															 0,
! 															 &oid_in_function,
! 															 oid_typioparam,
  															 -1,
  															 &isnull));
  				if (isnull || loaded_oid == InvalidOid)
--- 2397,2410 ----
  
  			if (file_has_oids)
  			{
+ 				Oid		loaded_oid;
+ 
  				cstate->cur_attname = "oid";
  				loaded_oid =
  					DatumGetObjectId(CopyReadBinaryAttribute(cstate,
  															 0,
! 															 &cstate->oid_in_function,
! 															 cstate->oid_typioparam,
  															 -1,
  															 &isnull));
  				if (isnull || loaded_oid == InvalidOid)
*************** CopyFrom(CopyState cstate)
*** 2137,2142 ****
--- 2412,2419 ----
  							(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
  							 errmsg("invalid OID in COPY data")));
  				cstate->cur_attname = NULL;
+ 				if (cstate->oids && tupleOid != NULL)
+ 					*tupleOid = loaded_oid;
  			}
  
  			i = 0;
*************** CopyFrom(CopyState cstate)
*** 2162,2278 ****
  		 * provided by the input data.	Anything not processed here or above
  		 * will remain NULL.
  		 */
  		for (i = 0; i < num_defaults; i++)
  		{
  			values[defmap[i]] = ExecEvalExpr(defexprs[i], econtext,
  											 &nulls[defmap[i]], NULL);
  		}
  
! 		/* And now we can form the input tuple. */
! 		tuple = heap_form_tuple(tupDesc, values, nulls);
! 
! 		if (cstate->oids && file_has_oids)
! 			HeapTupleSetOid(tuple, loaded_oid);
! 
! 		/* Triggers and stuff need to be invoked in query context. */
! 		MemoryContextSwitchTo(oldcontext);
! 
! 		skip_tuple = false;
! 
! 		/* BEFORE ROW INSERT Triggers */
! 		if (resultRelInfo->ri_TrigDesc &&
! 			resultRelInfo->ri_TrigDesc->trig_insert_before_row)
! 		{
! 			HeapTuple	newtuple;
! 
! 			newtuple = ExecBRInsertTriggers(estate, resultRelInfo, tuple);
! 
! 			if (newtuple == NULL)		/* "do nothing" */
! 				skip_tuple = true;
! 			else if (newtuple != tuple) /* modified by Trigger(s) */
! 			{
! 				heap_freetuple(tuple);
! 				tuple = newtuple;
! 			}
! 		}
! 
! 		if (!skip_tuple)
! 		{
! 			List	   *recheckIndexes = NIL;
! 
! 			/* Place tuple in tuple slot */
! 			ExecStoreTuple(tuple, slot, InvalidBuffer, false);
! 
! 			/* Check the constraints of the tuple */
! 			if (cstate->rel->rd_att->constr)
! 				ExecConstraints(resultRelInfo, slot, estate);
! 
! 			/* OK, store the tuple and create index entries for it */
! 			heap_insert(cstate->rel, tuple, mycid, hi_options, bistate);
! 
! 			if (resultRelInfo->ri_NumIndices > 0)
! 				recheckIndexes = ExecInsertIndexTuples(slot, &(tuple->t_self),
! 													   estate);
! 
! 			/* AFTER ROW INSERT Triggers */
! 			ExecARInsertTriggers(estate, resultRelInfo, tuple,
! 								 recheckIndexes);
! 
! 			list_free(recheckIndexes);
! 
! 			/*
! 			 * We count only tuples not suppressed by a BEFORE INSERT trigger;
! 			 * this is the same definition used by execMain.c for counting
! 			 * tuples inserted by an INSERT command.
! 			 */
! 			cstate->processed++;
! 		}
! 	}
! 
! 	/* Done, clean up */
! 	error_context_stack = errcontext.previous;
! 
! 	FreeBulkInsertState(bistate);
! 
! 	MemoryContextSwitchTo(oldcontext);
! 
! 	/* Execute AFTER STATEMENT insertion triggers */
! 	ExecASInsertTriggers(estate, resultRelInfo);
! 
! 	/* Handle queued AFTER triggers */
! 	AfterTriggerEndQuery(estate);
! 
! 	pfree(values);
! 	pfree(nulls);
! 	if (! cstate->binary)
! 		pfree(cstate->raw_fields);
! 
! 	pfree(in_functions);
! 	pfree(typioparams);
! 	pfree(defmap);
! 	pfree(defexprs);
! 
! 	ExecResetTupleTable(estate->es_tupleTable, false);
! 
! 	ExecCloseIndices(resultRelInfo);
  
! 	FreeExecutorState(estate);
  
! 	if (!pipe)
! 	{
! 		if (FreeFile(cstate->copy_file))
! 			ereport(ERROR,
! 					(errcode_for_file_access(),
! 					 errmsg("could not read from file \"%s\": %m",
! 							cstate->filename)));
! 	}
  
! 	/*
! 	 * If we skipped writing WAL, then we need to sync the heap (but not
! 	 * indexes since those use WAL anyway)
! 	 */
! 	if (hi_options & HEAP_INSERT_SKIP_WAL)
! 		heap_sync(cstate->rel);
  }
  
  
--- 2439,2471 ----
  		 * provided by the input data.	Anything not processed here or above
  		 * will remain NULL.
  		 */
+ 		econtext = GetPerTupleExprContext(cstate->estate);
  		for (i = 0; i < num_defaults; i++)
  		{
  			values[defmap[i]] = ExecEvalExpr(defexprs[i], econtext,
  											 &nulls[defmap[i]], NULL);
  		}
+ 	/* XXX: End of only-indentation changes. */
  
! 	return true;
! }
  
! /*
!  * Clean up storage and release resources for COPY FROM.
!  */
! void
! EndCopyFrom(CopyState cstate)
! {
! 	FreeExecutorState(cstate->estate);
  
! 	if (cstate->filename != NULL && FreeFile(cstate->copy_file))
! 		ereport(ERROR,
! 				(errcode_for_file_access(),
! 				 errmsg("could not close file \"%s\": %m",
! 						cstate->filename)));
  
! 	/* Clean up storage */
! 	EndCopy(cstate);
  }
  
  
*************** copy_dest_receive(TupleTableSlot *slot, 
*** 3537,3542 ****
--- 3730,3736 ----
  
  	/* And send the data */
  	CopyOneRowTo(cstate, InvalidOid, slot->tts_values, slot->tts_isnull);
+ 	myState->processed++;
  }
  
  /*
diff --git a/src/include/commands/copy.h b/src/include/commands/copy.h
index 9e2bbe8..8340e3d 100644
*** a/src/include/commands/copy.h
--- b/src/include/commands/copy.h
***************
*** 14,25 ****
--- 14,35 ----
  #ifndef COPY_H
  #define COPY_H
  
+ #include "nodes/execnodes.h"
  #include "nodes/parsenodes.h"
  #include "tcop/dest.h"
  
  
+ typedef struct CopyStateData  *CopyState;
+ 
  extern uint64 DoCopy(const CopyStmt *stmt, const char *queryString);
  
+ extern CopyState BeginCopyFrom(Relation rel, const char *filename,
+ 							   List *attnamelist, List *options);
+ extern void EndCopyFrom(CopyState cstate);
+ extern bool NextCopyFrom(CopyState cstate,
+ 						 Datum *values, bool *nulls, Oid *tupleOid);
+ extern void CopyFromErrorCallback(void *arg);
+ 
  extern DestReceiver *CreateCopyDestReceiver(void);
  
  #endif   /* COPY_H */