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

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

数据库系统

开发平台：

Unix_Linux

oracle_compat.c：源码内容
  1. /*
  2.  * Edmund Mergl <E.Mergl@bawue.de>
  3.  *
  4.  * $Id: oracle_compat.c,v 1.18.2.1 1999/08/02 05:24:56 scrappy Exp $
  5.  *
  6.  */
  9. #include <ctype.h>
  10. #include "postgres.h"
  12. text    *lower(text *string);
  13. text    *upper(text *string);
  14. text    *initcap(text *string);
  15. text    *lpad(text *string1, int4 len, text *string2);
  16. text    *rpad(text *string1, int4 len, text *string2);
  17. text    *btrim(text *string, text *set);
  18. text    *ltrim(text *string, text *set);
  19. text    *rtrim(text *string, text *set);
  20. text    *substr(text *string, int4 m, int4 n);
  21. text    *translate(text *string, char from, char to);
  24. /********************************************************************
  25.  *
  26.  * lower
  27.  *
  28.  * Syntax:
  29.  *
  30.  *  text *lower(text *string)
  31.  *
  32.  * Purpose:
  33.  *
  34.  *  Returns string, with all letters forced to lowercase.
  35.  *
  36.  ********************************************************************/
  38. text *
  39. lower(text *string)
  40. {
  41. text    *ret;
  42. char    *ptr,
  43.    *ptr_ret;
  44. int m;
  46. if ((string == (text *) NULL) || ((m = VARSIZE(string) - VARHDRSZ) <= 0))
  47. return string;
  49. ret = (text *) palloc(VARSIZE(string));
  50. VARSIZE(ret) = VARSIZE(string);
  52. ptr = VARDATA(string);
  53. ptr_ret = VARDATA(ret);
  55. while (m--)
  56. *ptr_ret++ = tolower((unsigned char) *ptr++);
  58. return ret;
  59. }
  62. /********************************************************************
  63.  *
  64.  * upper
  65.  *
  66.  * Syntax:
  67.  *
  68.  *  text *upper(text *string)
  69.  *
  70.  * Purpose:
  71.  *
  72.  *  Returns string, with all letters forced to uppercase.
  73.  *
  74.  ********************************************************************/
  76. text *
  77. upper(text *string)
  78. {
  79. text    *ret;
  80. char    *ptr,
  81.    *ptr_ret;
  82. int m;
  84. if ((string == (text *) NULL) || ((m = VARSIZE(string) - VARHDRSZ) <= 0))
  85. return string;
  87. ret = (text *) palloc(VARSIZE(string));
  88. VARSIZE(ret) = VARSIZE(string);
  90. ptr = VARDATA(string);
  91. ptr_ret = VARDATA(ret);
  93. while (m--)
  94. *ptr_ret++ = toupper((unsigned char) *ptr++);
  96. return ret;
  97. }
  100. /********************************************************************
  101.  *
  102.  * initcap
  103.  *
  104.  * Syntax:
  105.  *
  106.  *  text *initcap(text *string)
  107.  *
  108.  * Purpose:
  109.  *
  110.  *  Returns string, with first letter of each word in uppercase,
  111.  *  all other letters in lowercase. A word is delimited by white
  112.  *  space.
  113.  *
  114.  ********************************************************************/
  116. text *
  117. initcap(text *string)
  118. {
  119. text    *ret;
  120. char    *ptr,
  121.    *ptr_ret;
  122. int m;
  124. if ((string == (text *) NULL) || ((m = VARSIZE(string) - VARHDRSZ) <= 0))
  125. return string;
  127. ret = (text *) palloc(VARSIZE(string));
  128. VARSIZE(ret) = VARSIZE(string);
  130. ptr = VARDATA(string);
  131. ptr_ret = VARDATA(ret);
  133. *ptr_ret++ = toupper((unsigned char) *ptr++);
  134. --m;
  136. while (m--)
  137. {
  138. if (*(ptr_ret - 1) == ' ' || *(ptr_ret - 1) == ' ')
  139. *ptr_ret++ = toupper((unsigned char) *ptr++);
  140. else
  141. *ptr_ret++ = tolower((unsigned char) *ptr++);
  142. }
  144. return ret;
  145. }
  148. /********************************************************************
  149.  *
  150.  * lpad
  151.  *
  152.  * Syntax:
  153.  *
  154.  *  text *lpad(text *string1, int4 len, text *string2)
  155.  *
  156.  * Purpose:
  157.  *
  158.  *  Returns string1, left-padded to length len with the sequence of
  159.  *  characters in string2.
  160.  *
  161.  ********************************************************************/
  163. text *
  164. lpad(text *string1, int4 len, text *string2)
  165. {
  166. text    *ret;
  167. char    *ptr1,
  168.    *ptr2,
  169.    *ptr_ret;
  170. int m,
  171. n;
  173. if ((string1 == (text *) NULL) ||
  174. (len <= (VARSIZE(string1) - VARHDRSZ)) ||
  175. ((m = len - VARSIZE(string1) + VARHDRSZ) <= 0) ||
  176. (string2 == (text *) NULL) ||
  177. ((VARSIZE(string2) - VARHDRSZ) <= 0))
  178. return string1;
  180. ret = (text *) palloc(VARHDRSZ + len);
  181. VARSIZE(ret) = VARHDRSZ + len;
  183. ptr2 = VARDATA(string2);
  184. ptr_ret = VARDATA(ret);
  186. while (m--)
  187. {
  188. *ptr_ret++ = *ptr2;
  189. ptr2 = ptr2 == VARDATA(string2) + VARSIZE(string2) - VARHDRSZ - 1 ? VARDATA(string2) : ++ptr2;
  190. }
  192. n = VARSIZE(string1) - VARHDRSZ;
  193. ptr1 = VARDATA(string1);
  195. while (n--)
  196. *ptr_ret++ = *ptr1++;
  198. return ret;
  199. }
  202. /********************************************************************
  203.  *
  204.  * rpad
  205.  *
  206.  * Syntax:
  207.  *
  208.  *  text *rpad(text *string1, int4 len, text *string2)
  209.  *
  210.  * Purpose:
  211.  *
  212.  *  Returns string1, right-padded to length len with the sequence of
  213.  *  characters in string2.
  214.  *
  215.  ********************************************************************/
  217. text *
  218. rpad(text *string1, int4 len, text *string2)
  219. {
  220. text    *ret;
  221. char    *ptr1,
  222.    *ptr2,
  223.    *ptr_ret;
  224. int m,
  225. n;
  227. if ((string1 == (text *) NULL) ||
  228. (len <= (VARSIZE(string1) - VARHDRSZ)) ||
  229. ((m = len - VARSIZE(string1) + VARHDRSZ) <= 0) ||
  230. (string2 == (text *) NULL) ||
  231. ((VARSIZE(string2) - VARHDRSZ) <= 0))
  232. return string1;
  234. ret = (text *) palloc(VARHDRSZ + len);
  235. VARSIZE(ret) = VARHDRSZ + len;
  237. n = VARSIZE(string1) - VARHDRSZ;
  238. ptr1 = VARDATA(string1);
  239. ptr_ret = VARDATA(ret);
  241. while (n--)
  242. *ptr_ret++ = *ptr1++;
  244. ptr2 = VARDATA(string2);
  246. while (m--)
  247. {
  248. *ptr_ret++ = *ptr2;
  249. ptr2 = ptr2 == VARDATA(string2) + VARSIZE(string2) - VARHDRSZ - 1 ? VARDATA(string2) : ++ptr2;
  250. }
  252. return ret;
  253. }
  256. /********************************************************************
  257.  *
  258.  * btrim
  259.  *
  260.  * Syntax:
  261.  *
  262.  *  text *btrim(text *string, text *set)
  263.  *
  264.  * Purpose:
  265.  *
  266.  *  Returns string with characters removed from the front and back
  267.  *  up to the first character not in set.
  268.  *
  269.  ********************************************************************/
  271. text *
  272. btrim(text *string, text *set)
  273. {
  274. text    *ret;
  275. char    *ptr,
  276.    *end,
  277.    *ptr2,
  278.    *end2;
  279. int m;
  281. if ((string == (text *) NULL) ||
  282. ((m = VARSIZE(string) - VARHDRSZ) <= 0) ||
  283. (set == (text *) NULL) ||
  284. ((VARSIZE(set) - VARHDRSZ) <= 0))
  285. return string;
  287. ptr = VARDATA(string);
  288. ptr2 = VARDATA(set);
  289. end2 = VARDATA(set) + VARSIZE(set) - VARHDRSZ - 1;
  291. while (m--)
  292. {
  293. while (ptr2 <= end2)
  294. {
  295. if (*ptr == *ptr2)
  296. break;
  297. ++ptr2;
  298. }
  299. if (ptr2 > end2)
  300. break;
  301. ptr++;
  302. ptr2 = VARDATA(set);
  303. }
  305. ++m;
  307. end = VARDATA(string) + VARSIZE(string) - VARHDRSZ - 1;
  308. ptr2 = VARDATA(set);
  310. while (m--)
  311. {
  312. while (ptr2 <= end2)
  313. {
  314. if (*end == *ptr2)
  315. break;
  316. ++ptr2;
  317. }
  318. if (ptr2 > end2)
  319. break;
  320. --end;
  321. ptr2 = VARDATA(set);
  322. }
  324. ++m;
  326. ret = (text *) palloc(VARHDRSZ + m);
  327. VARSIZE(ret) = VARHDRSZ + m;
  328. memcpy(VARDATA(ret), ptr, m);
  330. return ret;
  331. } /* btrim() */
  334. /********************************************************************
  335.  *
  336.  * ltrim
  337.  *
  338.  * Syntax:
  339.  *
  340.  *  text *ltrim(text *string, text *set)
  341.  *
  342.  * Purpose:
  343.  *
  344.  *  Returns string with initial characters removed up to the first
  345.  *  character not in set.
  346.  *
  347.  ********************************************************************/
  349. text *
  350. ltrim(text *string, text *set)
  351. {
  352. text    *ret;
  353. char    *ptr,
  354.    *ptr2,
  355.    *end2;
  356. int m;
  358. if ((string == (text *) NULL) ||
  359. ((m = VARSIZE(string) - VARHDRSZ) <= 0) ||
  360. (set == (text *) NULL) ||
  361. ((VARSIZE(set) - VARHDRSZ) <= 0))
  362. return string;
  364. ptr = VARDATA(string);
  365. ptr2 = VARDATA(set);
  366. end2 = VARDATA(set) + VARSIZE(set) - VARHDRSZ - 1;
  368. while (m--)
  369. {
  370. while (ptr2 <= end2)
  371. {
  372. if (*ptr == *ptr2)
  373. break;
  374. ++ptr2;
  375. }
  376. if (ptr2 > end2)
  377. break;
  378. ptr++;
  379. ptr2 = VARDATA(set);
  380. }
  382. ++m;
  384. ret = (text *) palloc(VARHDRSZ + m);
  385. VARSIZE(ret) = VARHDRSZ + m;
  387. memcpy(VARDATA(ret), ptr, m);
  389. return ret;
  390. }
  393. /********************************************************************
  394.  *
  395.  * rtrim
  396.  *
  397.  * Syntax:
  398.  *
  399.  *  text *rtrim(text *string, text *set)
  400.  *
  401.  * Purpose:
  402.  *
  403.  *  Returns string with final characters removed after the last
  404.  *  character not in set.
  405.  *
  406.  ********************************************************************/
  408. text *
  409. rtrim(text *string, text *set)
  410. {
  411. text    *ret;
  412. char    *ptr,
  413.    *ptr2,
  414.    *end2,
  415.    *ptr_ret;
  416. int m;
  418. if ((string == (text *) NULL) ||
  419. ((m = VARSIZE(string) - VARHDRSZ) <= 0) ||
  420. (set == (text *) NULL) ||
  421. ((VARSIZE(set) - VARHDRSZ) <= 0))
  422. return string;
  424. ptr = VARDATA(string) + VARSIZE(string) - VARHDRSZ - 1;
  425. ptr2 = VARDATA(set);
  426. end2 = VARDATA(set) + VARSIZE(set) - VARHDRSZ - 1;
  428. while (m--)
  429. {
  430. while (ptr2 <= end2)
  431. {
  432. if (*ptr == *ptr2)
  433. break;
  434. ++ptr2;
  435. }
  436. if (ptr2 > end2)
  437. break;
  438. --ptr;
  439. ptr2 = VARDATA(set);
  440. }
  442. ++m;
  444. ret = (text *) palloc(VARHDRSZ + m);
  445. VARSIZE(ret) = VARHDRSZ + m;
  446. #ifdef NOT_USED
  447. memcpy(VARDATA(ret), ptr - VARSIZE(ret) + m, m);
  448. #endif
  450. ptr_ret = VARDATA(ret) + m - 1;
  452. while (m--)
  453. *ptr_ret-- = *ptr--;
  455. return ret;
  456. }
  459. /********************************************************************
  460.  *
  461.  * substr
  462.  *
  463.  * Syntax:
  464.  *
  465.  *  text *substr(text *string, int4 m, int4 n)
  466.  *
  467.  * Purpose:
  468.  *
  469.  *  Returns a portion of string, beginning at character m, n
  470.  *  characters long. The first position of string is 1.
  471.  *
  472.  ********************************************************************/
  474. #ifdef NOT_USED
  475. text *
  476. substr(text *string, int4 m, int4 n)
  477. {
  478. text    *ret;
  479. char    *ptr,
  480.    *ptr_ret;
  481. int len;
  483. if ((string == (text *) NULL) ||
  484. (m <= 0) || (n <= 0) ||
  485. ((len = VARSIZE(string) - VARHDRSZ - m + 1) <= 0))
  486. return string;
  488. len = len + 1 < n ? len + 1 : n;
  490. ret = (text *) palloc(VARHDRSZ + len);
  491. VARSIZE(ret) = VARHDRSZ + len;
  493. ptr = VARDATA(string) + m - 1;
  494. ptr_ret = VARDATA(ret);
  496. while (len--)
  497. *ptr_ret++ = *ptr++;
  499. return ret;
  500. }
  501. #endif
  503. /********************************************************************
  504.  *
  505.  * translate
  506.  *
  507.  * Syntax:
  508.  *
  509.  *  text *translate(text *string, char from, char to)
  510.  *
  511.  * Purpose:
  512.  *
  513.  *  Returns string after replacing all occurences of from with
  514.  *  the corresponding character in to. TRANSLATE will not remove
  515.  *   characters.
  516.  *
  517.  ********************************************************************/
  519. text *
  520. translate(text *string, char from, char to)
  521. {
  522. text    *ret;
  523. char    *ptr,
  524.    *ptr_ret;
  525. int m;
  527. if ((string == (text *) NULL) ||
  528. ((m = VARSIZE(string) - VARHDRSZ) <= 0))
  529. return string;
  531. ret = (text *) palloc(VARSIZE(string));
  532. VARSIZE(ret) = VARSIZE(string);
  534. ptr = VARDATA(string);
  535. ptr_ret = VARDATA(ret);
  537. while (m--)
  538. {
  539. *ptr_ret++ = *ptr == from ? to : *ptr;
  540. ptr++;
  541. }
  543. return ret;
  544. }
  547. /* EOF */