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

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

数据库系统

开发平台：

Unix_Linux

variable.c：源码内容
  1. /*
  2.  * Routines for handling of 'SET var TO',
  3.  * 'SHOW var' and 'RESET var' statements.
  4.  *
  5.  * $Id: variable.c,v 1.23.2.1 1999/08/02 05:57:00 scrappy Exp $
  6.  *
  7.  */
  9. #include <ctype.h>
  10. #include <time.h>
  12. #include "postgres.h"
  13. #include "access/xact.h"
  14. #include "commands/variable.h"
  15. #include "miscadmin.h"
  16. #include "optimizer/internal.h"
  17. #include "utils/builtins.h"
  18. #include "utils/tqual.h"
  20. #ifdef MULTIBYTE
  21. #include "mb/pg_wchar.h"
  22. #endif
  24. static bool show_date(void);
  25. static bool reset_date(void);
  26. static bool parse_date(const char *);
  27. static bool show_timezone(void);
  28. static bool reset_timezone(void);
  29. static bool parse_timezone(const char *);
  30. static bool show_cost_heap(void);
  31. static bool reset_cost_heap(void);
  32. static bool parse_cost_heap(const char *);
  33. static bool show_cost_index(void);
  34. static bool reset_cost_index(void);
  35. static bool parse_cost_index(const char *);
  36. static bool reset_geqo(void);
  37. static bool show_geqo(void);
  38. static bool parse_geqo(const char *);
  39. static bool show_ksqo(void);
  40. static bool reset_ksqo(void);
  41. static bool parse_ksqo(const char *);
  42. static bool show_XactIsoLevel(void);
  43. static bool reset_XactIsoLevel(void);
  44. static bool parse_XactIsoLevel(const char *);
  46. extern Cost _cpu_page_weight_;
  47. extern Cost _cpu_index_page_weight_;
  48. extern bool _use_geqo_;
  49. extern int32 _use_geqo_rels_;
  50. extern bool _use_keyset_query_optimizer;
  52. /*
  53.  *
  54.  * Get_Token
  55.  *
  56.  */
  57. static const char *
  58. get_token(char **tok, char **val, const char *str)
  59. {
  60. const char *start;
  61. int len = 0;
  63. *tok = NULL;
  64. if (val != NULL)
  65. *val = NULL;
  67. if (!(*str))
  68. return NULL;
  70. /* skip white spaces */
  71. while (isspace(*str))
  72. str++;
  73. if (*str == ',' || *str == '=')
  74. elog(ERROR, "Syntax error near (%s): empty setting", str);
  76. /* end of string? then return NULL */
  77. if (!(*str))
  78. return NULL;
  80. /* OK, at beginning of non-NULL string... */
  81. start = str;
  83. /*
  84.  * count chars in token until we hit white space or comma or '=' or
  85.  * end of string
  86.  */
  87. while (*str && (!isspace(*str))
  88.    && *str != ',' && *str != '=')
  89. {
  90. str++;
  91. len++;
  92. }
  94. *tok = (char *) palloc(len + 1);
  95. StrNCpy(*tok, start, len + 1);
  97. /* skip white spaces */
  98. while (isspace(*str))
  99. str++;
  101. /* end of string? */
  102. if (!(*str))
  103. {
  104. return str;
  106. /* delimiter? */
  107. }
  108. else if (*str == ',')
  109. {
  110. return ++str;
  112. }
  113. else if ((val == NULL) || (*str != '='))
  114. {
  115. elog(ERROR, "Syntax error near (%s)", str);
  116. };
  118. str++; /* '=': get value */
  119. len = 0;
  121. /* skip white spaces */
  122. while (isspace(*str))
  123. str++;
  125. if (*str == ',' || !(*str))
  126. elog(ERROR, "Syntax error near (=%s)", str);
  128. start = str;
  130. /*
  131.  * count chars in token's value until we hit white space or comma or
  132.  * end of string
  133.  */
  134. while (*str && (!isspace(*str)) && *str != ',')
  135. {
  136. str++;
  137. len++;
  138. }
  140. *val = (char *) palloc(len + 1);
  141. StrNCpy(*val, start, len + 1);
  143. /* skip white spaces */
  144. while (isspace(*str))
  145. str++;
  147. if (!(*str))
  148. return NULL;
  149. if (*str == ',')
  150. return ++str;
  152. elog(ERROR, "Syntax error near (%s)", str);
  154. return str;
  155. }
  157. /*
  158.  *
  159.  * GEQO
  160.  *
  161.  */
  162. static bool
  163. parse_geqo(const char *value)
  164. {
  165. const char *rest;
  166. char    *tok,
  167.    *val;
  169. if (value == NULL)
  170. {
  171. reset_geqo();
  172. return TRUE;
  173. }
  175. rest = get_token(&tok, &val, value);
  176. if (tok == NULL)
  177. elog(ERROR, "Value undefined");
  179. if ((rest) && (*rest != ''))
  180. elog(ERROR, "Unable to parse '%s'", value);
  182. if (strcasecmp(tok, "on") == 0)
  183. {
  184. int32 geqo_rels = GEQO_RELS;
  186. if (val != NULL)
  187. {
  188. geqo_rels = pg_atoi(val, sizeof(int32), '');
  189. if (geqo_rels <= 1)
  190. elog(ERROR, "Bad value for # of relations (%s)", val);
  191. pfree(val);
  192. }
  193. _use_geqo_ = true;
  194. _use_geqo_rels_ = geqo_rels;
  195. }
  196. else if (strcasecmp(tok, "off") == 0)
  197. {
  198. if ((val != NULL) && (*val != ''))
  199. elog(ERROR, "%s does not allow a parameter", tok);
  200. _use_geqo_ = false;
  201. }
  202. else
  203. elog(ERROR, "Bad value for GEQO (%s)", value);
  205. pfree(tok);
  206. return TRUE;
  207. }
  209. static bool
  210. show_geqo()
  211. {
  213. if (_use_geqo_)
  214. elog(NOTICE, "GEQO is ON beginning with %d relations", _use_geqo_rels_);
  215. else
  216. elog(NOTICE, "GEQO is OFF");
  217. return TRUE;
  218. }
  220. static bool
  221. reset_geqo(void)
  222. {
  224. #ifdef GEQO
  225. _use_geqo_ = true;
  226. #else
  227. _use_geqo_ = false;
  228. #endif
  229. _use_geqo_rels_ = GEQO_RELS;
  230. return TRUE;
  231. }
  233. /*
  234.  *
  235.  * COST_HEAP
  236.  *
  237.  */
  238. static bool
  239. parse_cost_heap(const char *value)
  240. {
  241. float32 res;
  243. if (value == NULL)
  244. {
  245. reset_cost_heap();
  246. return TRUE;
  247. }
  249. res = float4in((char *) value);
  250. _cpu_page_weight_ = *res;
  252. return TRUE;
  253. }
  255. static bool
  256. show_cost_heap()
  257. {
  259. elog(NOTICE, "COST_HEAP is %f", _cpu_page_weight_);
  260. return TRUE;
  261. }
  263. static bool
  264. reset_cost_heap()
  265. {
  266. _cpu_page_weight_ = _CPU_PAGE_WEIGHT_;
  267. return TRUE;
  268. }
  270. /*
  271.  *
  272.  * COST_INDEX
  273.  *
  274.  */
  275. static bool
  276. parse_cost_index(const char *value)
  277. {
  278. float32 res;
  280. if (value == NULL)
  281. {
  282. reset_cost_index();
  283. return TRUE;
  284. }
  286. res = float4in((char *) value);
  287. _cpu_index_page_weight_ = *res;
  289. return TRUE;
  290. }
  292. static bool
  293. show_cost_index()
  294. {
  296. elog(NOTICE, "COST_INDEX is %f", _cpu_index_page_weight_);
  297. return TRUE;
  298. }
  300. static bool
  301. reset_cost_index()
  302. {
  303. _cpu_index_page_weight_ = _CPU_INDEX_PAGE_WEIGHT_;
  304. return TRUE;
  305. }
  307. /*
  308.  *
  309.  * DATE_STYLE
  310.  *
  311.  */
  312. static bool
  313. parse_date(const char *value)
  314. {
  315. char    *tok;
  316. int dcnt = 0,
  317. ecnt = 0;
  319. if (value == NULL)
  320. {
  321. reset_date();
  322. return TRUE;
  323. }
  325. while ((value = get_token(&tok, NULL, value)) != 0)
  326. {
  327. /* Ugh. Somebody ought to write a table driven version -- mjl */
  329. if (!strcasecmp(tok, "ISO"))
  330. {
  331. DateStyle = USE_ISO_DATES;
  332. dcnt++;
  333. }
  334. else if (!strcasecmp(tok, "SQL"))
  335. {
  336. DateStyle = USE_SQL_DATES;
  337. dcnt++;
  338. }
  339. else if (!strcasecmp(tok, "POSTGRES"))
  340. {
  341. DateStyle = USE_POSTGRES_DATES;
  342. dcnt++;
  343. }
  344. else if (!strcasecmp(tok, "GERMAN"))
  345. {
  346. DateStyle = USE_GERMAN_DATES;
  347. dcnt++;
  348. EuroDates = TRUE;
  349. if ((ecnt > 0) && (!EuroDates))
  350. ecnt++;
  351. }
  352. else if (!strncasecmp(tok, "EURO", 4))
  353. {
  354. EuroDates = TRUE;
  355. if ((dcnt <= 0) || (DateStyle != USE_GERMAN_DATES))
  356. ecnt++;
  357. }
  358. else if ((!strcasecmp(tok, "US"))
  359.  || (!strncasecmp(tok, "NONEURO", 7)))
  360. {
  361. EuroDates = FALSE;
  362. if ((dcnt <= 0) || (DateStyle == USE_GERMAN_DATES))
  363. ecnt++;
  364. }
  365. else if (!strcasecmp(tok, "DEFAULT"))
  366. {
  367. DateStyle = USE_POSTGRES_DATES;
  368. EuroDates = FALSE;
  369. ecnt++;
  370. }
  371. else
  372. elog(ERROR, "Bad value for date style (%s)", tok);
  373. pfree(tok);
  374. }
  376. if (dcnt > 1 || ecnt > 1)
  377. elog(NOTICE, "Conflicting settings for date");
  379. return TRUE;
  380. }
  382. static bool
  383. show_date()
  384. {
  385. char buf[64];
  387. strcpy(buf, "DateStyle is ");
  388. switch (DateStyle)
  389. {
  390. case USE_ISO_DATES:
  391. strcat(buf, "ISO");
  392. break;
  393. case USE_SQL_DATES:
  394. strcat(buf, "SQL");
  395. break;
  396. case USE_GERMAN_DATES:
  397. strcat(buf, "German");
  398. break;
  399. default:
  400. strcat(buf, "Postgres");
  401. break;
  402. };
  403. strcat(buf, " with ");
  404. strcat(buf, ((EuroDates) ? "European" : "US (NonEuropean)"));
  405. strcat(buf, " conventions");
  407. elog(NOTICE, buf, NULL);
  409. return TRUE;
  410. }
  412. static bool
  413. reset_date()
  414. {
  415. DateStyle = USE_POSTGRES_DATES;
  416. EuroDates = FALSE;
  418. return TRUE;
  419. }
  421. /* Timezone support
  422.  * Working storage for strings is allocated with an arbitrary size of 64 bytes.
  423.  */
  425. static char *defaultTZ = NULL;
  426. static char TZvalue[64];
  427. static char tzbuf[64];
  429. /*
  430.  *
  431.  * TIMEZONE
  432.  *
  433.  */
  434. /* parse_timezone()
  435.  * Handle SET TIME ZONE...
  436.  * Try to save existing TZ environment variable for later use in RESET TIME ZONE.
  437.  * - thomas 1997-11-10
  438.  */
  439. static bool
  440. parse_timezone(const char *value)
  441. {
  442. char    *tok;
  444. if (value == NULL)
  445. {
  446. reset_timezone();
  447. return TRUE;
  448. }
  450. while ((value = get_token(&tok, NULL, value)) != 0)
  451. {
  452. /* Not yet tried to save original value from environment? */
  453. if (defaultTZ == NULL)
  454. {
  455. /* found something? then save it for later */
  456. if ((defaultTZ = getenv("TZ")) != NULL)
  457. strcpy(TZvalue, defaultTZ);
  459. /* found nothing so mark with an invalid pointer */
  460. else
  461. defaultTZ = (char *) -1;
  462. }
  464. strcpy(tzbuf, "TZ=");
  465. strcat(tzbuf, tok);
  466. if (putenv(tzbuf) != 0)
  467. elog(ERROR, "Unable to set TZ environment variable to %s", tok);
  469. tzset();
  470. pfree(tok);
  471. }
  473. return TRUE;
  474. } /* parse_timezone() */
  476. static bool
  477. show_timezone()
  478. {
  479. char    *tz;
  481. tz = getenv("TZ");
  483. elog(NOTICE, "Time zone is %s", ((tz != NULL) ? tz : "unknown"));
  485. return TRUE;
  486. } /* show_timezone() */
  488. /* reset_timezone()
  489.  * Set TZ environment variable to original value.
  490.  * Note that if TZ was originally not set, TZ should be cleared.
  491.  * unsetenv() works fine, but is BSD, not POSIX, and is not available
  492.  * under Solaris, among others. Apparently putenv() called as below
  493.  * clears the process-specific environment variables.
  494.  * Other reasonable arguments to putenv() (e.g. "TZ=", "TZ", "") result
  495.  * in a core dump (under Linux anyway).
  496.  * - thomas 1998-01-26
  497.  */
  498. static bool
  499. reset_timezone()
  500. {
  501. /* no time zone has been set in this session? */
  502. if (defaultTZ == NULL)
  503. {
  504. }
  506. /* time zone was set and original explicit time zone available? */
  507. else if (defaultTZ != (char *) -1)
  508. {
  509. strcpy(tzbuf, "TZ=");
  510. strcat(tzbuf, TZvalue);
  511. if (putenv(tzbuf) != 0)
  512. elog(ERROR, "Unable to set TZ environment variable to %s", TZvalue);
  513. tzset();
  514. }
  516. /*
  517.  * otherwise, time zone was set but no original explicit time zone
  518.  * available
  519.  */
  520. else
  521. {
  522. strcpy(tzbuf, "=");
  523. if (putenv(tzbuf) != 0)
  524. elog(ERROR, "Unable to clear TZ environment variable", NULL);
  525. tzset();
  526. }
  528. return TRUE;
  529. } /* reset_timezone() */
  531. /*-----------------------------------------------------------------------*/
  533. struct VariableParsers
  534. {
  535. const char *name;
  536. bool (*parser) (const char *);
  537. bool (*show) ();
  538. bool (*reset) ();
  539. } VariableParsers[] =
  541. {
  542. {
  543. "datestyle", parse_date, show_date, reset_date
  544. },
  545. {
  546. "timezone", parse_timezone, show_timezone, reset_timezone
  547. },
  548. {
  549. "cost_heap", parse_cost_heap, show_cost_heap, reset_cost_heap
  550. },
  551. {
  552. "cost_index", parse_cost_index, show_cost_index, reset_cost_index
  553. },
  554. {
  555. "geqo", parse_geqo, show_geqo, reset_geqo
  556. },
  557. #ifdef MULTIBYTE
  558. {
  559. "client_encoding", parse_client_encoding, show_client_encoding, reset_client_encoding
  560. },
  561. {
  562. "server_encoding", parse_server_encoding, show_server_encoding, reset_server_encoding
  563. },
  564. #endif
  565. {
  566. "ksqo", parse_ksqo, show_ksqo, reset_ksqo
  567. },
  568. {
  569. "XactIsoLevel", parse_XactIsoLevel, show_XactIsoLevel, reset_XactIsoLevel
  570. },
  571. {
  572. NULL, NULL, NULL, NULL
  573. }
  574. };
  576. /*-----------------------------------------------------------------------*/
  577. bool
  578. SetPGVariable(const char *name, const char *value)
  579. {
  580. struct VariableParsers *vp;
  582. for (vp = VariableParsers; vp->name; vp++)
  583. {
  584. if (!strcasecmp(vp->name, name))
  585. return (vp->parser) (value);
  586. }
  588. elog(NOTICE, "Unrecognized variable %s", name);
  590. return TRUE;
  591. }
  593. /*-----------------------------------------------------------------------*/
  594. bool
  595. GetPGVariable(const char *name)
  596. {
  597. struct VariableParsers *vp;
  599. for (vp = VariableParsers; vp->name; vp++)
  600. {
  601. if (!strcasecmp(vp->name, name))
  602. return (vp->show) ();
  603. }
  605. elog(NOTICE, "Unrecognized variable %s", name);
  607. return TRUE;
  608. }
  610. /*-----------------------------------------------------------------------*/
  611. bool
  612. ResetPGVariable(const char *name)
  613. {
  614. struct VariableParsers *vp;
  616. for (vp = VariableParsers; vp->name; vp++)
  617. {
  618. if (!strcasecmp(vp->name, name))
  619. return (vp->reset) ();
  620. }
  622. elog(NOTICE, "Unrecognized variable %s", name);
  624. return TRUE;
  625. }
  628. /*-----------------------------------------------------------------------
  629. KSQO code will one day be unnecessary when the optimizer makes use of
  630. indexes when multiple ORs are specified in the where clause.
  631. See optimizer/prep/prepkeyset.c for more on this.
  632. daveh@insightdist.com  6/16/98
  633. -----------------------------------------------------------------------*/
  634. static bool
  635. parse_ksqo(const char *value)
  636. {
  637. if (value == NULL)
  638. {
  639. reset_ksqo();
  640. return TRUE;
  641. }
  643. if (strcasecmp(value, "on") == 0)
  644. _use_keyset_query_optimizer = true;
  645. else if (strcasecmp(value, "off") == 0)
  646. _use_keyset_query_optimizer = false;
  647. else
  648. elog(ERROR, "Bad value for Key Set Query Optimizer (%s)", value);
  650. return TRUE;
  651. }
  653. static bool
  654. show_ksqo()
  655. {
  657. if (_use_keyset_query_optimizer)
  658. elog(NOTICE, "Key Set Query Optimizer is ON");
  659. else
  660. elog(NOTICE, "Key Set Query Optimizer is OFF");
  661. return TRUE;
  662. }
  664. static bool
  665. reset_ksqo()
  666. {
  667. _use_keyset_query_optimizer = false;
  668. return TRUE;
  669. }
  671. /* SET TRANSACTION */
  673. static bool
  674. parse_XactIsoLevel(const char *value)
  675. {
  677. if (value == NULL)
  678. {
  679. reset_XactIsoLevel();
  680. return TRUE;
  681. }
  683. if (SerializableSnapshot != NULL)
  684. {
  685. elog(ERROR, "SET TRANSACTION ISOLATION LEVEL must be called before any query");
  686. return TRUE;
  687. }
  690. if (strcasecmp(value, "SERIALIZABLE") == 0)
  691. XactIsoLevel = XACT_SERIALIZABLE;
  692. else if (strcasecmp(value, "COMMITTED") == 0)
  693. XactIsoLevel = XACT_READ_COMMITTED;
  694. else
  695. elog(ERROR, "Bad TRANSACTION ISOLATION LEVEL (%s)", value);
  697. return TRUE;
  698. }
  700. static bool
  701. show_XactIsoLevel()
  702. {
  704. if (XactIsoLevel == XACT_SERIALIZABLE)
  705. elog(NOTICE, "TRANSACTION ISOLATION LEVEL is SERIALIZABLE");
  706. else
  707. elog(NOTICE, "TRANSACTION ISOLATION LEVEL is READ COMMITTED");
  708. return TRUE;
  709. }
  711. static bool
  712. reset_XactIsoLevel()
  713. {
  715. if (SerializableSnapshot != NULL)
  716. {
  717. elog(ERROR, "SET TRANSACTION ISOLATION LEVEL must be called before any query");
  718. return TRUE;
  719. }
  721. XactIsoLevel = DefaultXactIsoLevel;
  723. return TRUE;
  724. }