开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > 查看源码
copy.c
资源名称：postgresql-6.5.2.tar.gz　[点击查看]
上传用户：blenddy
上传日期：2007-01-07
资源大小：6495k
文件大小：30k
源码类别：

数据库系统

开发平台：

Unix_Linux

copy.c：源码内容
  1. /*-------------------------------------------------------------------------
  2.  *
  3.  * copy.c
  4.  *
  5.  * Copyright (c) 1994, Regents of the University of California
  6.  *
  7.  *
  8.  * IDENTIFICATION
  9.  *   $Header: /usr/local/cvsroot/pgsql/src/backend/commands/copy.c,v 1.81 1999/07/03 00:32:39 momjian Exp $
  10.  *
  11.  *-------------------------------------------------------------------------
  12.  */
  14. #include <string.h>
  15. #include <unistd.h>
  17. #include <postgres.h>
  19. #include <access/heapam.h>
  20. #include <tcop/dest.h>
  21. #include <fmgr.h>
  22. #include <miscadmin.h>
  23. #include <utils/builtins.h>
  24. #include <utils/acl.h>
  25. #include <sys/stat.h>
  26. #include <catalog/pg_index.h>
  27. #include <utils/syscache.h>
  28. #include <utils/memutils.h>
  29. #include <executor/executor.h>
  30. #include <access/transam.h>
  31. #include <catalog/index.h>
  32. #include <access/genam.h>
  33. #include <catalog/pg_type.h>
  34. #include <catalog/catname.h>
  35. #include <catalog/pg_shadow.h>
  36. #include <commands/copy.h>
  37. #include "commands/trigger.h"
  38. #include <storage/fd.h>
  39. #include <libpq/libpq.h>
  41. #ifdef MULTIBYTE
  42. #include "mb/pg_wchar.h"
  43. #endif
  45. #define ISOCTAL(c) (((c) >= '0') && ((c) <= '7'))
  46. #define VALUE(c) ((c) - '0')
  49. /* non-export function prototypes */
  50. static void CopyTo(Relation rel, bool binary, bool oids, FILE *fp, char *delim);
  51. static void CopyFrom(Relation rel, bool binary, bool oids, FILE *fp, char *delim);
  52. static Oid GetOutputFunction(Oid type);
  53. static Oid GetTypeElement(Oid type);
  54. static Oid GetInputFunction(Oid type);
  55. static Oid IsTypeByVal(Oid type);
  56. static void GetIndexRelations(Oid main_relation_oid,
  57.   int *n_indices,
  58.   Relation **index_rels);
  60. #ifdef COPY_PATCH
  61. static void CopyReadNewline(FILE *fp, int *newline);
  62. static char *CopyReadAttribute(FILE *fp, bool *isnull, char *delim, int *newline);
  64. #else
  65. static char *CopyReadAttribute(FILE *fp, bool *isnull, char *delim);
  67. #endif
  68. static void CopyAttributeOut(FILE *fp, char *string, char *delim, int is_array);
  69. static int CountTuples(Relation relation);
  71. static int lineno;
  73. /*
  74.  * Internal communications functions
  75.  */
  76. static void CopySendData(void *databuf, int datasize, FILE *fp);
  77. static void CopySendString(char *str, FILE *fp);
  78. static void CopySendChar(char c, FILE *fp);
  79. static void CopyGetData(void *databuf, int datasize, FILE *fp);
  80. static int CopyGetChar(FILE *fp);
  81. static int CopyGetEof(FILE *fp);
  82. static int CopyPeekChar(FILE *fp);
  83. static void CopyDonePeek(FILE *fp, int c, int pickup);
  85. /*
  86.  * CopySendData sends output data either to the file
  87.  * specified by fp or, if fp is NULL, using the standard
  88.  * backend->frontend functions
  89.  *
  90.  * CopySendString does the same for null-terminated strings
  91.  * CopySendChar does the same for single characters
  92.  *
  93.  * NB: no data conversion is applied by these functions
  94.  */
  95. static void
  96. CopySendData(void *databuf, int datasize, FILE *fp)
  97. {
  98. if (!fp)
  99. pq_putbytes((char *) databuf, datasize);
  100. else
  101. fwrite(databuf, datasize, 1, fp);
  102. }
  104. static void
  105. CopySendString(char *str, FILE *fp)
  106. {
  107. CopySendData(str, strlen(str), fp);
  108. }
  110. static void
  111. CopySendChar(char c, FILE *fp)
  112. {
  113. CopySendData(&c, 1, fp);
  114. }
  116. /*
  117.  * CopyGetData reads output data either from the file
  118.  * specified by fp or, if fp is NULL, using the standard
  119.  * backend->frontend functions
  120.  *
  121.  * CopyGetChar does the same for single characters
  122.  * CopyGetEof checks if it's EOF on the input
  123.  *
  124.  * NB: no data conversion is applied by these functions
  125.  */
  126. static void
  127. CopyGetData(void *databuf, int datasize, FILE *fp)
  128. {
  129. if (!fp)
  130. pq_getbytes((char *) databuf, datasize);
  131. else
  132. fread(databuf, datasize, 1, fp);
  133. }
  135. static int
  136. CopyGetChar(FILE *fp)
  137. {
  138. if (!fp)
  139. {
  140. unsigned char ch;
  142. if (pq_getbytes((char *) &ch, 1))
  143. return EOF;
  144. return ch;
  145. }
  146. else
  147. return getc(fp);
  148. }
  150. static int
  151. CopyGetEof(FILE *fp)
  152. {
  153. if (!fp)
  154. return 0; /* Never return EOF when talking to
  155.  * frontend ? */
  156. else
  157. return feof(fp);
  158. }
  160. /*
  161.  * CopyPeekChar reads a byte in "peekable" mode.
  162.  * after each call to CopyPeekChar, a call to CopyDonePeek _must_
  163.  * follow.
  164.  * CopyDonePeek will either take the peeked char off the steam
  165.  * (if pickup is != 0) or leave it on the stream (if pickup == 0)
  166.  */
  167. static int
  168. CopyPeekChar(FILE *fp)
  169. {
  170. if (!fp)
  171. return pq_peekbyte();
  172. else
  173. return getc(fp);
  174. }
  176. static void
  177. CopyDonePeek(FILE *fp, int c, int pickup)
  178. {
  179. if (!fp)
  180. {
  181. if (pickup)
  182. {
  184. /*
  185.  * We want to pick it up - just receive again into dummy
  186.  * buffer
  187.  */
  188. char c;
  190. pq_getbytes(&c, 1);
  191. }
  192. /* If we didn't want to pick it up, just leave it where it sits */
  193. }
  194. else
  195. {
  196. if (!pickup)
  197. {
  198. /* We don't want to pick it up - so put it back in there */
  199. ungetc(c, fp);
  200. }
  201. /* If we wanted to pick it up, it's already there */
  202. }
  203. }
  207. /*
  208.  *  DoCopy executes a the SQL COPY statement.
  209.  */
  211. void
  212. DoCopy(char *relname, bool binary, bool oids, bool from, bool pipe,
  213.    char *filename, char *delim)
  214. {
  215. /*----------------------------------------------------------------------------
  216.   Either unload or reload contents of class <relname>, depending on <from>.
  218.   If <pipe> is false, transfer is between the class and the file named
  219.   <filename>.  Otherwise, transfer is between the class and our regular
  220.   input/output stream. The latter could be either stdin/stdout or a
  221.   socket, depending on whether we're running under Postmaster control.
  223.   Iff <binary>, unload or reload in the binary format, as opposed to the
  224.   more wasteful but more robust and portable text format.
  226.   If in the text format, delimit columns with delimiter <delim>.
  228.   When loading in the text format from an input stream (as opposed to
  229.   a file), recognize a "." on a line by itself as EOF. Also recognize
  230.   a stream EOF.  When unloading in the text format to an output stream,
  231.   write a "." on a line by itself at the end of the data.
  233.   Iff <oids>, unload or reload the format that includes OID information.
  235.   Do not allow a Postgres user without superuser privilege to read from
  236.   or write to a file.
  238.   Do not allow the copy if user doesn't have proper permission to access
  239.   the class.
  240. ----------------------------------------------------------------------------*/
  242. FILE    *fp;
  243. Relation rel;
  244. extern char *UserName; /* defined in global.c */
  245. const AclMode required_access = from ? ACL_WR : ACL_RD;
  246. int result;
  248. rel = heap_openr(relname);
  249. if (rel == NULL)
  250. elog(ERROR, "COPY command failed.  Class %s "
  251.  "does not exist.", relname);
  253. result = pg_aclcheck(relname, UserName, required_access);
  254. if (result != ACLCHECK_OK)
  255. elog(ERROR, "%s: %s", relname, aclcheck_error_strings[result]);
  256. /* Above should not return */
  257. else if (!superuser() && !pipe)
  258. elog(ERROR, "You must have Postgres superuser privilege to do a COPY "
  259.  "directly to or from a file.  Anyone can COPY to stdout or "
  260.  "from stdin.  Psql's \copy command also works for anyone.");
  261. /* Above should not return. */
  262. else
  263. {
  264. if (from)
  265. { /* copy from file to database */
  266. if (rel->rd_rel->relkind == RELKIND_SEQUENCE)
  267. elog(ERROR, "You can't change sequence relation %s", relname);
  268. if (pipe)
  269. {
  270. if (IsUnderPostmaster)
  271. {
  272. ReceiveCopyBegin();
  273. fp = NULL;
  274. }
  275. else
  276. fp = stdin;
  277. }
  278. else
  279. {
  280. #ifndef __CYGWIN32__
  281. fp = AllocateFile(filename, "r");
  282. #else
  283. fp = AllocateFile(filename, "rb");
  284. #endif
  285. if (fp == NULL)
  286. elog(ERROR, "COPY command, running in backend with "
  287.  "effective uid %d, could not open file '%s' for "
  288.  "reading.  Errno = %s (%d).",
  289.  geteuid(), filename, strerror(errno), errno);
  290. }
  291. CopyFrom(rel, binary, oids, fp, delim);
  292. }
  293. else
  294. { /* copy from database to file */
  295. if (pipe)
  296. {
  297. if (IsUnderPostmaster)
  298. {
  299. SendCopyBegin();
  300. pq_startcopyout();
  301. fp = NULL;
  302. }
  303. else
  304. fp = stdout;
  305. }
  306. else
  307. {
  308. mode_t oumask; /* Pre-existing umask value */
  310. oumask = umask((mode_t) 0);
  311. #ifndef __CYGWIN32__
  312. fp = AllocateFile(filename, "w");
  313. #else
  314. fp = AllocateFile(filename, "wb");
  315. #endif
  316. umask(oumask);
  317. if (fp == NULL)
  318. elog(ERROR, "COPY command, running in backend with "
  319.  "effective uid %d, could not open file '%s' for "
  320.  "writing.  Errno = %s (%d).",
  321.  geteuid(), filename, strerror(errno), errno);
  322. }
  323. CopyTo(rel, binary, oids, fp, delim);
  324. }
  325. if (!pipe)
  326. {
  327. FreeFile(fp);
  328. }
  329. else if (!from)
  330. {
  331. if (!binary)
  332. CopySendData("\.n", 3, fp);
  333. if (IsUnderPostmaster)
  334. pq_endcopyout(false);
  335. }
  336. }
  337. }
  341. static void
  342. CopyTo(Relation rel, bool binary, bool oids, FILE *fp, char *delim)
  343. {
  344. HeapTuple tuple;
  345. HeapScanDesc scandesc;
  347. int32 attr_count,
  348. i;
  349. Form_pg_attribute *attr;
  350. FmgrInfo   *out_functions;
  351. Oid out_func_oid;
  352. Oid    *elements;
  353. int32    *typmod;
  354. Datum value;
  355. bool isnull; /* The attribute we are copying is null */
  356. char    *nulls;
  358. /*
  359.  * <nulls> is a (dynamically allocated) array with one character per
  360.  * attribute in the instance being copied. nulls[I-1] is 'n' if
  361.  * Attribute Number I is null, and ' ' otherwise.
  362.  *
  363.  * <nulls> is meaningful only if we are doing a binary copy.
  364.  */
  365. char    *string;
  366. int32 ntuples;
  367. TupleDesc tupDesc;
  369. scandesc = heap_beginscan(rel, 0, QuerySnapshot, 0, NULL);
  371. attr_count = rel->rd_att->natts;
  372. attr = rel->rd_att->attrs;
  373. tupDesc = rel->rd_att;
  375. if (!binary)
  376. {
  377. out_functions = (FmgrInfo *) palloc(attr_count * sizeof(FmgrInfo));
  378. elements = (Oid *) palloc(attr_count * sizeof(Oid));
  379. typmod = (int32 *) palloc(attr_count * sizeof(int32));
  380. for (i = 0; i < attr_count; i++)
  381. {
  382. out_func_oid = (Oid) GetOutputFunction(attr[i]->atttypid);
  383. fmgr_info(out_func_oid, &out_functions[i]);
  384. elements[i] = GetTypeElement(attr[i]->atttypid);
  385. typmod[i] = attr[i]->atttypmod;
  386. }
  387. nulls = NULL; /* meaningless, but compiler doesn't know
  388.  * that */
  389. }
  390. else
  391. {
  392. elements = NULL;
  393. typmod = NULL;
  394. out_functions = NULL;
  395. nulls = (char *) palloc(attr_count);
  396. for (i = 0; i < attr_count; i++)
  397. nulls[i] = ' ';
  399. /* XXX expensive */
  401. ntuples = CountTuples(rel);
  402. CopySendData(&ntuples, sizeof(int32), fp);
  403. }
  405. while (HeapTupleIsValid(tuple = heap_getnext(scandesc, 0)))
  406. {
  408. if (oids && !binary)
  409. {
  410. CopySendString(oidout(tuple->t_data->t_oid), fp);
  411. CopySendChar(delim[0], fp);
  412. }
  414. for (i = 0; i < attr_count; i++)
  415. {
  416. value = heap_getattr(tuple, i + 1, tupDesc, &isnull);
  417. if (!binary)
  418. {
  419. if (!isnull)
  420. {
  421. string = (char *) (*fmgr_faddr(&out_functions[i]))
  422. (value, elements[i], typmod[i]);
  423. CopyAttributeOut(fp, string, delim, attr[i]->attnelems);
  424. pfree(string);
  425. }
  426. else
  427. CopySendString("\N", fp); /* null indicator */
  429. if (i == attr_count - 1)
  430. CopySendChar('n', fp);
  431. else
  432. {
  434. /*
  435.  * when copying out, only use the first char of the
  436.  * delim string
  437.  */
  438. CopySendChar(delim[0], fp);
  439. }
  440. }
  441. else
  442. {
  444. /*
  445.  * only interesting thing heap_getattr tells us in this
  446.  * case is if we have a null attribute or not.
  447.  */
  448. if (isnull)
  449. nulls[i] = 'n';
  450. }
  451. }
  453. if (binary)
  454. {
  455. int32 null_ct = 0,
  456. length;
  458. for (i = 0; i < attr_count; i++)
  459. {
  460. if (nulls[i] == 'n')
  461. null_ct++;
  462. }
  464. length = tuple->t_len - tuple->t_data->t_hoff;
  465. CopySendData(&length, sizeof(int32), fp);
  466. if (oids)
  467. CopySendData((char *) &tuple->t_data->t_oid, sizeof(int32), fp);
  469. CopySendData(&null_ct, sizeof(int32), fp);
  470. if (null_ct > 0)
  471. {
  472. for (i = 0; i < attr_count; i++)
  473. {
  474. if (nulls[i] == 'n')
  475. {
  476. CopySendData(&i, sizeof(int32), fp);
  477. nulls[i] = ' ';
  478. }
  479. }
  480. }
  481. CopySendData((char *) tuple->t_data + tuple->t_data->t_hoff,
  482.  length, fp);
  483. }
  484. }
  486. heap_endscan(scandesc);
  487. if (binary)
  488. pfree(nulls);
  489. else
  490. {
  491. pfree(out_functions);
  492. pfree(elements);
  493. pfree(typmod);
  494. }
  496. heap_close(rel);
  497. }
  499. static void
  500. CopyFrom(Relation rel, bool binary, bool oids, FILE *fp, char *delim)
  501. {
  502. HeapTuple tuple;
  503. AttrNumber attr_count;
  504. Form_pg_attribute *attr;
  505. FmgrInfo   *in_functions;
  506. int i;
  507. Oid in_func_oid;
  508. Datum    *values;
  509. char    *nulls,
  510.    *index_nulls;
  511. bool    *byval;
  512. bool isnull;
  513. bool has_index;
  514. int done = 0;
  515. char    *string = NULL,
  516.    *ptr;
  517. Relation   *index_rels;
  518. int32 len,
  519. null_ct,
  520. null_id;
  521. int32 ntuples,
  522. tuples_read = 0;
  523. bool reading_to_eof = true;
  524. Oid    *elements;
  525. int32    *typmod;
  526. FuncIndexInfo *finfo,
  527.   **finfoP = NULL;
  528. TupleDesc  *itupdescArr;
  529. HeapTuple pgIndexTup;
  530. Form_pg_index *pgIndexP = NULL;
  531. int    *indexNatts = NULL;
  532. char    *predString;
  533. Node   **indexPred = NULL;
  534. TupleDesc rtupdesc;
  535. ExprContext *econtext = NULL;
  536. EState    *estate = makeNode(EState); /* for ExecConstraints() */
  538. #ifndef OMIT_PARTIAL_INDEX
  539. TupleTable tupleTable;
  540. TupleTableSlot *slot = NULL;
  542. #endif
  543. int natts;
  544. AttrNumber *attnumP;
  545. Datum    *idatum;
  546. int n_indices;
  547. InsertIndexResult indexRes;
  548. TupleDesc tupDesc;
  549. Oid loaded_oid;
  550. bool skip_tuple = false;
  552. tupDesc = RelationGetDescr(rel);
  553. attr = tupDesc->attrs;
  554. attr_count = tupDesc->natts;
  556. has_index = false;
  558. /*
  559.  * This may be a scalar or a functional index. We initialize all
  560.  * kinds of arrays here to avoid doing extra work at every tuple copy.
  561.  */
  563. if (rel->rd_rel->relhasindex)
  564. {
  565. GetIndexRelations(RelationGetRelid(rel), &n_indices, &index_rels);
  566. if (n_indices > 0)
  567. {
  568. has_index = true;
  569. itupdescArr = (TupleDesc *) palloc(n_indices * sizeof(TupleDesc));
  570. pgIndexP = (Form_pg_index *) palloc(n_indices * sizeof(Form_pg_index));
  571. indexNatts = (int *) palloc(n_indices * sizeof(int));
  572. finfo = (FuncIndexInfo *) palloc(n_indices * sizeof(FuncIndexInfo));
  573. finfoP = (FuncIndexInfo **) palloc(n_indices * sizeof(FuncIndexInfo *));
  574. indexPred = (Node **) palloc(n_indices * sizeof(Node *));
  575. econtext = NULL;
  576. for (i = 0; i < n_indices; i++)
  577. {
  578. itupdescArr[i] = RelationGetDescr(index_rels[i]);
  579. pgIndexTup = SearchSysCacheTuple(INDEXRELID,
  580.    ObjectIdGetDatum(RelationGetRelid(index_rels[i])),
  581.  0, 0, 0);
  582. Assert(pgIndexTup);
  583. pgIndexP[i] = (Form_pg_index) GETSTRUCT(pgIndexTup);
  584. for (attnumP = &(pgIndexP[i]->indkey[0]), natts = 0;
  585.  natts < INDEX_MAX_KEYS && *attnumP != InvalidAttrNumber;
  586.  attnumP++, natts++);
  587. if (pgIndexP[i]->indproc != InvalidOid)
  588. {
  589. FIgetnArgs(&finfo[i]) = natts;
  590. natts = 1;
  591. FIgetProcOid(&finfo[i]) = pgIndexP[i]->indproc;
  592. *(FIgetname(&finfo[i])) = '';
  593. finfoP[i] = &finfo[i];
  594. }
  595. else
  596. finfoP[i] = (FuncIndexInfo *) NULL;
  597. indexNatts[i] = natts;
  598. if (VARSIZE(&pgIndexP[i]->indpred) != 0)
  599. {
  600. predString = fmgr(F_TEXTOUT, &pgIndexP[i]->indpred);
  601. indexPred[i] = stringToNode(predString);
  602. pfree(predString);
  603. /* make dummy ExprContext for use by ExecQual */
  604. if (econtext == NULL)
  605. {
  606. #ifndef OMIT_PARTIAL_INDEX
  607. tupleTable = ExecCreateTupleTable(1);
  608. slot = ExecAllocTableSlot(tupleTable);
  609. econtext = makeNode(ExprContext);
  610. econtext->ecxt_scantuple = slot;
  611. rtupdesc = RelationGetDescr(rel);
  612. slot->ttc_tupleDescriptor = rtupdesc;
  614. /*
  615.  * There's no buffer associated with heap tuples
  616.  * here, so I set the slot's buffer to NULL.
  617.  * Currently, it appears that the only way a
  618.  * buffer could be needed would be if the partial
  619.  * index predicate referred to the "lock" system
  620.  * attribute.  If it did, then heap_getattr would
  621.  * call HeapTupleGetRuleLock, which uses the
  622.  * buffer's descriptor to get the relation id.
  623.  * Rather than try to fix this, I'll just disallow
  624.  * partial indexes on "lock", which wouldn't be
  625.  * useful anyway. --Nels, Nov '92
  626.  */
  627. /* SetSlotBuffer(slot, (Buffer) NULL); */
  628. /* SetSlotShouldFree(slot, false); */
  629. slot->ttc_buffer = (Buffer) NULL;
  630. slot->ttc_shouldFree = false;
  631. #endif  /* OMIT_PARTIAL_INDEX */
  632. }
  633. }
  634. else
  635. indexPred[i] = NULL;
  636. }
  637. }
  638. }
  640. if (!binary)
  641. {
  642. in_functions = (FmgrInfo *) palloc(attr_count * sizeof(FmgrInfo));
  643. elements = (Oid *) palloc(attr_count * sizeof(Oid));
  644. typmod = (int32 *) palloc(attr_count * sizeof(int32));
  645. for (i = 0; i < attr_count; i++)
  646. {
  647. in_func_oid = (Oid) GetInputFunction(attr[i]->atttypid);
  648. fmgr_info(in_func_oid, &in_functions[i]);
  649. elements[i] = GetTypeElement(attr[i]->atttypid);
  650. typmod[i] = attr[i]->atttypmod;
  651. }
  652. }
  653. else
  654. {
  655. in_functions = NULL;
  656. elements = NULL;
  657. typmod = NULL;
  658. CopyGetData(&ntuples, sizeof(int32), fp);
  659. if (ntuples != 0)
  660. reading_to_eof = false;
  661. }
  663. values = (Datum *) palloc(sizeof(Datum) * attr_count);
  664. nulls = (char *) palloc(attr_count);
  665. index_nulls = (char *) palloc(attr_count);
  666. idatum = (Datum *) palloc(sizeof(Datum) * attr_count);
  667. byval = (bool *) palloc(attr_count * sizeof(bool));
  669. for (i = 0; i < attr_count; i++)
  670. {
  671. nulls[i] = ' ';
  672. index_nulls[i] = ' ';
  673. byval[i] = (bool) IsTypeByVal(attr[i]->atttypid);
  674. }
  676. lineno = 0;
  677. while (!done)
  678. {
  679. if (!binary)
  680. {
  681. #ifdef COPY_PATCH
  682. int newline = 0;
  684. #endif
  685. lineno++;
  686. if (oids)
  687. {
  688. #ifdef COPY_PATCH
  689. string = CopyReadAttribute(fp, &isnull, delim, &newline);
  690. #else
  691. string = CopyReadAttribute(fp, &isnull, delim);
  692. #endif
  693. if (string == NULL)
  694. done = 1;
  695. else
  696. {
  697. loaded_oid = oidin(string);
  698. if (loaded_oid < BootstrapObjectIdData)
  699. elog(ERROR, "COPY TEXT: Invalid Oid. line: %d", lineno);
  700. }
  701. }
  702. for (i = 0; i < attr_count && !done; i++)
  703. {
  704. #ifdef COPY_PATCH
  705. string = CopyReadAttribute(fp, &isnull, delim, &newline);
  706. #else
  707. string = CopyReadAttribute(fp, &isnull, delim);
  708. #endif
  709. if (isnull)
  710. {
  711. values[i] = PointerGetDatum(NULL);
  712. nulls[i] = 'n';
  713. }
  714. else if (string == NULL)
  715. done = 1;
  716. else
  717. {
  718. values[i] = (Datum) (*fmgr_faddr(&in_functions[i])) (string,
  719.  elements[i],
  720.   typmod[i]);
  722. /*
  723.  * Sanity check - by reference attributes cannot
  724.  * return NULL
  725.  */
  726. if (!PointerIsValid(values[i]) &&
  727. !(rel->rd_att->attrs[i]->attbyval))
  728. elog(ERROR, "copy from line %d: Bad file format", lineno);
  729. }
  730. }
  731. #ifdef COPY_PATCH
  732. if (!done)
  733. CopyReadNewline(fp, &newline);
  734. #endif
  735. }
  736. else
  737. { /* binary */
  738. CopyGetData(&len, sizeof(int32), fp);
  739. if (CopyGetEof(fp))
  740. done = 1;
  741. else
  742. {
  743. if (oids)
  744. {
  745. CopyGetData(&loaded_oid, sizeof(int32), fp);
  746. if (loaded_oid < BootstrapObjectIdData)
  747. elog(ERROR, "COPY BINARY: Invalid Oid line: %d", lineno);
  748. }
  749. CopyGetData(&null_ct, sizeof(int32), fp);
  750. if (null_ct > 0)
  751. {
  752. for (i = 0; i < null_ct; i++)
  753. {
  754. CopyGetData(&null_id, sizeof(int32), fp);
  755. nulls[null_id] = 'n';
  756. }
  757. }
  759. string = (char *) palloc(len);
  760. CopyGetData(string, len, fp);
  762. ptr = string;
  764. for (i = 0; i < attr_count; i++)
  765. {
  766. if (byval[i] && nulls[i] != 'n')
  767. {
  769. switch (attr[i]->attlen)
  770. {
  771. case sizeof(char):
  772. values[i] = (Datum) *(unsigned char *) ptr;
  773. ptr += sizeof(char);
  774. break;
  775. case sizeof(short):
  776. ptr = (char *) SHORTALIGN(ptr);
  777. values[i] = (Datum) *(unsigned short *) ptr;
  778. ptr += sizeof(short);
  779. break;
  780. case sizeof(int32):
  781. ptr = (char *) INTALIGN(ptr);
  782. values[i] = (Datum) *(uint32 *) ptr;
  783. ptr += sizeof(int32);
  784. break;
  785. default:
  786. elog(ERROR, "COPY BINARY: impossible size! line: %d", lineno);
  787. break;
  788. }
  789. }
  790. else if (nulls[i] != 'n')
  791. {
  792. ptr = (char *) att_align(ptr, attr[i]->attlen, attr[i]->attalign);
  793. values[i] = (Datum) ptr;
  794. ptr = att_addlength(ptr, attr[i]->attlen, ptr);
  795. }
  796. }
  797. }
  798. }
  799. if (done)
  800. continue;
  802. /*
  803.  * Does it have any sence ? - vadim 12/14/96
  804.  *
  805.  * tupDesc = CreateTupleDesc(attr_count, attr);
  806.  */
  807. tuple = heap_formtuple(tupDesc, values, nulls);
  808. if (oids)
  809. tuple->t_data->t_oid = loaded_oid;
  811. skip_tuple = false;
  812. /* BEFORE ROW INSERT Triggers */
  813. if (rel->trigdesc &&
  814. rel->trigdesc->n_before_row[TRIGGER_EVENT_INSERT] > 0)
  815. {
  816. HeapTuple newtuple;
  818. newtuple = ExecBRInsertTriggers(rel, tuple);
  820. if (newtuple == NULL) /* "do nothing" */
  821. skip_tuple = true;
  822. else if (newtuple != tuple) /* modified by Trigger(s) */
  823. {
  824. pfree(tuple);
  825. tuple = newtuple;
  826. }
  827. }
  829. if (!skip_tuple)
  830. {
  831. /* ----------------
  832.  * Check the constraints of a tuple
  833.  * ----------------
  834.  */
  836. if (rel->rd_att->constr)
  837. ExecConstraints("CopyFrom", rel, tuple, estate);
  839. heap_insert(rel, tuple);
  841. if (has_index)
  842. {
  843. for (i = 0; i < n_indices; i++)
  844. {
  845. if (indexPred[i] != NULL)
  846. {
  847. #ifndef OMIT_PARTIAL_INDEX
  849. /*
  850.  * if tuple doesn't satisfy predicate, don't
  851.  * update index
  852.  */
  853. slot->val = tuple;
  854. /* SetSlotContents(slot, tuple); */
  855. if (ExecQual((List *) indexPred[i], econtext) == false)
  856. continue;
  857. #endif  /* OMIT_PARTIAL_INDEX */
  858. }
  859. FormIndexDatum(indexNatts[i],
  860. (AttrNumber *) &(pgIndexP[i]->indkey[0]),
  861.    tuple,
  862.    tupDesc,
  863.    idatum,
  864.    index_nulls,
  865.    finfoP[i]);
  866. indexRes = index_insert(index_rels[i], idatum, index_nulls,
  867. &(tuple->t_self), rel);
  868. if (indexRes)
  869. pfree(indexRes);
  870. }
  871. }
  872. /* AFTER ROW INSERT Triggers */
  873. if (rel->trigdesc &&
  874. rel->trigdesc->n_after_row[TRIGGER_EVENT_INSERT] > 0)
  875. ExecARInsertTriggers(rel, tuple);
  876. }
  878. if (binary)
  879. pfree(string);
  881. for (i = 0; i < attr_count; i++)
  882. {
  883. if (!byval[i] && nulls[i] != 'n')
  884. {
  885. if (!binary)
  886. pfree((void *) values[i]);
  887. }
  888. else if (nulls[i] == 'n')
  889. nulls[i] = ' ';
  890. }
  892. pfree(tuple);
  893. tuples_read++;
  895. if (!reading_to_eof && ntuples == tuples_read)
  896. done = true;
  897. }
  898. pfree(values);
  899. pfree(nulls);
  900. pfree(index_nulls);
  901. pfree(idatum);
  902. pfree(byval);
  904. if (!binary)
  905. {
  906. pfree(in_functions);
  907. pfree(elements);
  908. pfree(typmod);
  909. }
  911. /* comments in execUtils.c */
  912. if (has_index)
  913. {
  914. for (i = 0; i < n_indices; i++)
  915. {
  916. if (index_rels[i] == NULL)
  917. continue;
  918. if ((index_rels[i])->rd_rel->relam != BTREE_AM_OID &&
  919. (index_rels[i])->rd_rel->relam != HASH_AM_OID)
  920. UnlockRelation(index_rels[i], AccessExclusiveLock);
  921. index_close(index_rels[i]);
  922. }
  923. }
  924. heap_close(rel);
  925. }
  929. static Oid
  930. GetOutputFunction(Oid type)
  931. {
  932. HeapTuple typeTuple;
  934. typeTuple = SearchSysCacheTuple(TYPOID,
  935. ObjectIdGetDatum(type),
  936. 0, 0, 0);
  938. if (HeapTupleIsValid(typeTuple))
  939. return (int) ((Form_pg_type) GETSTRUCT(typeTuple))->typoutput;
  941. elog(ERROR, "GetOutputFunction: Cache lookup of type %u failed", type);
  942. return InvalidOid;
  943. }
  945. static Oid
  946. GetTypeElement(Oid type)
  947. {
  948. HeapTuple typeTuple;
  950. typeTuple = SearchSysCacheTuple(TYPOID,
  951. ObjectIdGetDatum(type),
  952. 0, 0, 0);
  954. if (HeapTupleIsValid(typeTuple))
  955. return (int) ((Form_pg_type) GETSTRUCT(typeTuple))->typelem;
  957. elog(ERROR, "GetOutputFunction: Cache lookup of type %d failed", type);
  958. return InvalidOid;
  959. }
  961. static Oid
  962. GetInputFunction(Oid type)
  963. {
  964. HeapTuple typeTuple;
  966. typeTuple = SearchSysCacheTuple(TYPOID,
  967. ObjectIdGetDatum(type),
  968. 0, 0, 0);
  970. if (HeapTupleIsValid(typeTuple))
  971. return (int) ((Form_pg_type) GETSTRUCT(typeTuple))->typinput;
  973. elog(ERROR, "GetInputFunction: Cache lookup of type %u failed", type);
  974. return InvalidOid;
  975. }
  977. static Oid
  978. IsTypeByVal(Oid type)
  979. {
  980. HeapTuple typeTuple;
  982. typeTuple = SearchSysCacheTuple(TYPOID,
  983. ObjectIdGetDatum(type),
  984. 0, 0, 0);
  986. if (HeapTupleIsValid(typeTuple))
  987. return (int) ((Form_pg_type) GETSTRUCT(typeTuple))->typbyval;
  989. elog(ERROR, "GetInputFunction: Cache lookup of type %u failed", type);
  991. return InvalidOid;
  992. }
  994. /*
  995.  * Given the OID of a relation, return an array of index relation descriptors
  996.  * and the number of index relations.  These relation descriptors are open
  997.  * using heap_open().
  998.  *
  999.  * Space for the array itself is palloc'ed.
  1000.  */
  1002. typedef struct rel_list
  1003. {
  1004. Oid index_rel_oid;
  1005. struct rel_list *next;
  1006. } RelationList;
  1008. static void
  1009. GetIndexRelations(Oid main_relation_oid,
  1010.   int *n_indices,
  1011.   Relation **index_rels)
  1012. {
  1013. RelationList *head,
  1014.    *scan;
  1015. Relation pg_index_rel;
  1016. HeapScanDesc scandesc;
  1017. Oid index_relation_oid;
  1018. HeapTuple tuple;
  1019. TupleDesc tupDesc;
  1020. int i;
  1021. bool isnull;
  1023. pg_index_rel = heap_openr(IndexRelationName);
  1024. scandesc = heap_beginscan(pg_index_rel, 0, SnapshotNow, 0, NULL);
  1025. tupDesc = RelationGetDescr(pg_index_rel);
  1027. *n_indices = 0;
  1029. head = (RelationList *) palloc(sizeof(RelationList));
  1030. scan = head;
  1031. head->next = NULL;
  1033. while (HeapTupleIsValid(tuple = heap_getnext(scandesc, 0)))
  1034. {
  1036. index_relation_oid = (Oid) DatumGetInt32(heap_getattr(tuple, 2,
  1037.   tupDesc, &isnull));
  1038. if (index_relation_oid == main_relation_oid)
  1039. {
  1040. scan->index_rel_oid = (Oid) DatumGetInt32(heap_getattr(tuple,
  1041. Anum_pg_index_indexrelid,
  1042.   tupDesc, &isnull));
  1043. (*n_indices)++;
  1044. scan->next = (RelationList *) palloc(sizeof(RelationList));
  1045. scan = scan->next;
  1046. }
  1047. }
  1049. heap_endscan(scandesc);
  1050. heap_close(pg_index_rel);
  1052. /* We cannot trust to relhasindex of the main_relation now, so... */
  1053. if (*n_indices == 0)
  1054. return;
  1056. *index_rels = (Relation *) palloc(*n_indices * sizeof(Relation));
  1058. for (i = 0, scan = head; i < *n_indices; i++, scan = scan->next)
  1059. {
  1060. (*index_rels)[i] = index_open(scan->index_rel_oid);
  1061. /* comments in execUtils.c */
  1062. if ((*index_rels)[i] != NULL &&
  1063. ((*index_rels)[i])->rd_rel->relam != BTREE_AM_OID &&
  1064. ((*index_rels)[i])->rd_rel->relam != HASH_AM_OID)
  1065. LockRelation((*index_rels)[i], AccessExclusiveLock);
  1066. }
  1068. for (i = 0, scan = head; i < *n_indices + 1; i++)
  1069. {
  1070. scan = head->next;
  1071. pfree(head);
  1072. head = scan;
  1073. }
  1074. }
  1076. #define EXT_ATTLEN (5 * BLCKSZ)
  1078. /*
  1079.    returns 1 is c is in s
  1080. */
  1081. static bool
  1082. inString(char c, char *s)
  1083. {
  1084. int i;
  1086. if (s)
  1087. {
  1088. i = 0;
  1089. while (s[i] != '')
  1090. {
  1091. if (s[i] == c)
  1092. return 1;
  1093. i++;
  1094. }
  1095. }
  1096. return 0;
  1097. }
  1099. #ifdef COPY_PATCH
  1100. /*
  1101.  * Reads input from fp until an end of line is seen.
  1102.  */
  1104. static void
  1105. CopyReadNewline(FILE *fp, int *newline)
  1106. {
  1107. if (!*newline)
  1108. {
  1109. elog(NOTICE, "CopyReadNewline: line %d - extra fields ignored", lineno);
  1110. while (!CopyGetEof(fp) && (CopyGetChar(fp) != 'n'));
  1111. }
  1112. *newline = 0;
  1113. }
  1115. #endif
  1117. /*
  1118.  * Reads input from fp until eof is seen.  If we are reading from standard
  1119.  * input, AND we see a dot on a line by itself (a dot followed immediately
  1120.  * by a newline), we exit as if we saw eof.  This is so that copy pipelines
  1121.  * can be used as standard input.
  1122.  */
  1124. static char *
  1125. #ifdef COPY_PATCH
  1126. CopyReadAttribute(FILE *fp, bool *isnull, char *delim, int *newline)
  1127. #else
  1128. CopyReadAttribute(FILE *fp, bool *isnull, char *delim)
  1129. #endif
  1130. {
  1131. static char attribute[EXT_ATTLEN];
  1132. char c;
  1133. int done = 0;
  1134. int i = 0;
  1136. #ifdef MULTIBYTE
  1137. int mblen;
  1138. int encoding;
  1139. unsigned char s[2];
  1140. int j;
  1142. #endif
  1144. #ifdef MULTIBYTE
  1145. encoding = pg_get_client_encoding();
  1146. s[1] = 0;
  1147. #endif
  1149. #ifdef COPY_PATCH
  1150. /* if last delimiter was a newline return a NULL attribute */
  1151. if (*newline)
  1152. {
  1153. *isnull = (bool) true;
  1154. return NULL;
  1155. }
  1156. #endif
  1158. *isnull = (bool) false; /* set default */
  1159. if (CopyGetEof(fp))
  1160. return NULL;
  1162. while (!done)
  1163. {
  1164. c = CopyGetChar(fp);
  1166. if (CopyGetEof(fp))
  1167. return NULL;
  1168. else if (c == '\')
  1169. {
  1170. c = CopyGetChar(fp);
  1171. if (CopyGetEof(fp))
  1172. return NULL;
  1173. switch (c)
  1174. {
  1175. case '0':
  1176. case '1':
  1177. case '2':
  1178. case '3':
  1179. case '4':
  1180. case '5':
  1181. case '6':
  1182. case '7':
  1183. {
  1184. int val;
  1186. val = VALUE(c);
  1187. c = CopyPeekChar(fp);
  1188. if (ISOCTAL(c))
  1189. {
  1190. val = (val << 3) + VALUE(c);
  1191. CopyDonePeek(fp, c, 1); /* Pick up the
  1192.  * character! */
  1193. c = CopyPeekChar(fp);
  1194. if (ISOCTAL(c))
  1195. {
  1196. CopyDonePeek(fp, c, 1); /* pick up! */
  1197. val = (val << 3) + VALUE(c);
  1198. }
  1199. else
  1200. {
  1201. if (CopyGetEof(fp))
  1202. {
  1203. CopyDonePeek(fp, c, 1); /* pick up */
  1204. return NULL;
  1205. }
  1206. CopyDonePeek(fp, c, 0); /* Return to stream! */
  1207. }
  1208. }
  1209. else
  1210. {
  1211. if (CopyGetEof(fp))
  1212. return NULL;
  1213. CopyDonePeek(fp, c, 0); /* Return to stream! */
  1214. }
  1215. c = val & 0377;
  1216. }
  1217. break;
  1218. case 'b':
  1219. c = 'b';
  1220. break;
  1221. case 'f':
  1222. c = 'f';
  1223. break;
  1224. case 'n':
  1225. c = 'n';
  1226. break;
  1227. case 'r':
  1228. c = 'r';
  1229. break;
  1230. case 't':
  1231. c = 't';
  1232. break;
  1233. case 'v':
  1234. c = 'v';
  1235. break;
  1236. case 'N':
  1237. attribute[0] = ''; /* just to be safe */
  1238. *isnull = (bool) true;
  1239. break;
  1240. case '.':
  1241. c = CopyGetChar(fp);
  1242. if (c != 'n')
  1243. elog(ERROR, "CopyReadAttribute - end of record marker corrupted. line: %d", lineno);
  1244. return NULL;
  1245. break;
  1246. }
  1247. }
  1248. else if (inString(c, delim) || c == 'n')
  1249. {
  1250. #ifdef COPY_PATCH
  1251. if (c == 'n')
  1252. *newline = 1;
  1253. #endif
  1254. done = 1;
  1255. }
  1256. if (!done)
  1257. attribute[i++] = c;
  1258. #ifdef MULTIBYTE
  1259. s[0] = c;
  1260. mblen = pg_encoding_mblen(encoding, s);
  1261. mblen--;
  1262. for (j = 0; j < mblen; j++)
  1263. {
  1264. c = CopyGetChar(fp);
  1265. if (CopyGetEof(fp))
  1266. return NULL;
  1267. attribute[i++] = c;
  1268. }
  1269. #endif
  1270. if (i == EXT_ATTLEN - 1)
  1271. elog(ERROR, "CopyReadAttribute - attribute length too long. line: %d", lineno);
  1272. }
  1273. attribute[i] = '';
  1274. #ifdef MULTIBYTE
  1275. return (pg_client_to_server((unsigned char *) attribute, strlen(attribute)));
  1276. #else
  1277. return &attribute[0];
  1278. #endif
  1279. }
  1281. static void
  1282. CopyAttributeOut(FILE *fp, char *server_string, char *delim, int is_array)
  1283. {
  1284. char    *string;
  1285. char c;
  1287. #ifdef MULTIBYTE
  1288. int mblen;
  1289. int encoding;
  1290. int i;
  1292. #endif
  1294. #ifdef MULTIBYTE
  1295. string = pg_server_to_client(server_string, strlen(server_string));
  1296. encoding = pg_get_client_encoding();
  1297. #else
  1298. string = server_string;
  1299. #endif
  1301. #ifdef MULTIBYTE
  1302. for (; (mblen = pg_encoding_mblen(encoding, string)) &&
  1303.  ((c = *string) != ''); string += mblen)
  1304. #else
  1305. for (; (c = *string) != ''; string++)
  1306. #endif
  1307. {
  1308. if (c == delim[0] || c == 'n' ||
  1309. (c == '\' && !is_array))
  1310. CopySendChar('\', fp);
  1311. else if (c == '\' && is_array)
  1312. {
  1313. if (*(string + 1) == '\')
  1314. {
  1315. /* translate \ to \\ */
  1316. CopySendChar('\', fp);
  1317. CopySendChar('\', fp);
  1318. CopySendChar('\', fp);
  1319. string++;
  1320. }
  1321. else if (*(string + 1) == '"')
  1322. {
  1323. /* translate " to \" */
  1324. CopySendChar('\', fp);
  1325. CopySendChar('\', fp);
  1326. }
  1327. }
  1328. #ifdef MULTIBYTE
  1329. for (i = 0; i < mblen; i++)
  1330. CopySendChar(*(string + i), fp);
  1331. #else
  1332. CopySendChar(*string, fp);
  1333. #endif
  1334. }
  1335. }
  1337. /*
  1338.  * Returns the number of tuples in a relation. Unfortunately, currently
  1339.  * must do a scan of the entire relation to determine this.
  1340.  *
  1341.  * relation is expected to be an open relation descriptor.
  1342.  */
  1343. static int
  1344. CountTuples(Relation relation)
  1345. {
  1346. HeapScanDesc scandesc;
  1347. HeapTuple tuple;
  1349. int i;
  1351. scandesc = heap_beginscan(relation, 0, QuerySnapshot, 0, NULL);
  1353. i = 0;
  1354. while (HeapTupleIsValid(tuple = heap_getnext(scandesc, 0)))
  1355. i++;
  1356. heap_endscan(scandesc);
  1357. return i;
  1358. }