DictSys.cpp
上传用户:romrleung
上传日期:2022-05-23
资源大小:18897k
文件大小:8k
源码类别:

MySQL数据库

开发平台:

Visual C++

  1. /* Copyright (C) 2003 MySQL AB
  2.    This program is free software; you can redistribute it and/or modify
  3.    it under the terms of the GNU General Public License as published by
  4.    the Free Software Foundation; either version 2 of the License, or
  5.    (at your option) any later version.
  6.    This program is distributed in the hope that it will be useful,
  7.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  8.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  9.    GNU General Public License for more details.
  10.    You should have received a copy of the GNU General Public License
  11.    along with this program; if not, write to the Free Software
  12.    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  13. #include <NdbApi.hpp>
  14. #include <common/ConnArea.hpp>
  15. #include "DictSchema.hpp"
  16. #include "DictTable.hpp"
  17. #include "DictColumn.hpp"
  18. #include "DictSys.hpp"
  19. #define arraySize(x) sizeof(x)/sizeof(x[0])
  20. #define MAX_SCHEMA_NAME_LENGTH 32
  21. #define MAX_REMARKS_LENGTH 256
  22. // typeinfo
  23. static DictSys::Column
  24. column_ODBC_TYPEINFO[] = {
  25.     DictSys::Column(
  26. 1,
  27. "TYPE_NAME",
  28. false,
  29. SqlType(SqlType::Varchar, 20, false)
  30.     ),
  31.     DictSys::Column(
  32. 2,
  33. "DATA_TYPE",
  34. false,
  35. SqlType(SqlType::Integer, false)
  36.     ),
  37.     DictSys::Column(
  38. 3,
  39. "COLUMN_SIZE",
  40. false,
  41. SqlType(SqlType::Integer, true)
  42.     ),
  43.     DictSys::Column(
  44. 4,
  45. "LITERAL_PREFIX",
  46. false,
  47. SqlType(SqlType::Varchar, 1, true)
  48.     ),
  49.     DictSys::Column(
  50. 5,
  51. "LITERAL_SUFFIX",
  52. false,
  53. SqlType(SqlType::Varchar, 1, true)
  54.     ),
  55.     DictSys::Column(
  56. 6,
  57. "CREATE_PARAMS",
  58. false,
  59. SqlType(SqlType::Varchar, 20, true)
  60.     ),
  61.     DictSys::Column(
  62. 7,
  63. "NULLABLE",
  64. false,
  65. SqlType(SqlType::Integer, false)
  66.     ),
  67.     DictSys::Column(
  68. 8,
  69. "CASE_SENSITIVE",
  70. false,
  71. SqlType(SqlType::Integer, false)
  72.     ),
  73.     DictSys::Column(
  74. 9,
  75. "SEARCHABLE",
  76. false,
  77. SqlType(SqlType::Integer, false)
  78.     ),
  79.     DictSys::Column(
  80. 10,
  81. "UNSIGNED_ATTRIBUTE",
  82. false,
  83. SqlType(SqlType::Integer, true)
  84.     ),
  85.     DictSys::Column(
  86. 11,
  87. "FIXED_PREC_SCALE",
  88. false,
  89. SqlType(SqlType::Integer, false)
  90.     ),
  91.     DictSys::Column(
  92. 12,
  93. "AUTO_UNIQUE_VALUE",
  94. false,
  95. SqlType(SqlType::Integer, true)
  96.     ),
  97.     DictSys::Column(
  98. 13,
  99. "LOCAL_TYPE_NAME",
  100. false,
  101. SqlType(SqlType::Varchar, 20, true)
  102.     ),
  103.     DictSys::Column(
  104. 14,
  105. "MINIMUM_SCALE",
  106. false,
  107. SqlType(SqlType::Integer, true)
  108.     ),
  109.     DictSys::Column(
  110. 15,
  111. "MAXIMUM_SCALE",
  112. false,
  113. SqlType(SqlType::Integer, true)
  114.     ),
  115.     DictSys::Column(
  116. 16,
  117. "SQL_DATA_TYPE",
  118. false,
  119. SqlType(SqlType::Integer, false)
  120.     ),
  121.     DictSys::Column(
  122. 17,
  123. "SQL_DATETIME_SUB",
  124. false,
  125. SqlType(SqlType::Integer, true)
  126.     ),
  127.     DictSys::Column(
  128. 18,
  129. "NUM_PREC_RADIX",
  130. false,
  131. SqlType(SqlType::Integer, true)
  132.     ),
  133.     DictSys::Column(
  134. 19,
  135. "INTERVAL_PRECISION",
  136. false,
  137. SqlType(SqlType::Integer, true)
  138.     )
  139. };
  140. static DictSys::Table
  141. table_ODBC_TYPEINFO(
  142.     DictSys::OdbcTypeinfo,
  143.     "ODBC$TYPEINFO",
  144.     column_ODBC_TYPEINFO,
  145.     arraySize(column_ODBC_TYPEINFO)
  146. );
  147. // tables
  148. static DictSys::Column
  149. column_ODBC_TABLES[] = {
  150.     // perl docs/systables.pl tables -c
  151.     DictSys::Column(
  152. 1,
  153. "TABLE_CAT",
  154. false,
  155. SqlType(SqlType::Varchar, MAX_SCHEMA_NAME_LENGTH, true)
  156.     ),
  157.     DictSys::Column(
  158. 2,
  159. "TABLE_SCHEM",
  160. false,
  161. SqlType(SqlType::Varchar, MAX_SCHEMA_NAME_LENGTH, true)
  162.     ),
  163.     DictSys::Column(
  164. 3,
  165. "TABLE_NAME",
  166. false,
  167. SqlType(SqlType::Varchar, MAX_TAB_NAME_SIZE, false)
  168.     ),
  169.     DictSys::Column(
  170. 4,
  171. "TABLE_TYPE",
  172. false,
  173. SqlType(SqlType::Varchar, 20, false)
  174.     ),
  175.     DictSys::Column(
  176. 5,
  177. "REMARKS",
  178. false,
  179. SqlType(SqlType::Varchar, MAX_REMARKS_LENGTH, true)
  180.     )
  181. };
  182. static DictSys::Table
  183. table_ODBC_TABLES(
  184.     DictSys::OdbcTables,
  185.     "ODBC$TABLES",
  186.     column_ODBC_TABLES,
  187.     arraySize(column_ODBC_TABLES)
  188. );
  189. // columns
  190. static DictSys::Column
  191. column_ODBC_COLUMNS[] = {
  192.     // perl docs/systables.pl columns -c
  193.     DictSys::Column(
  194. 1,
  195. "TABLE_CAT",
  196. false,
  197. SqlType(SqlType::Varchar, MAX_SCHEMA_NAME_LENGTH, true)
  198.     ),
  199.     DictSys::Column(
  200. 2,
  201. "TABLE_SCHEM",
  202. false,
  203. SqlType(SqlType::Varchar, MAX_SCHEMA_NAME_LENGTH, true)
  204.     ),
  205.     DictSys::Column(
  206. 3,
  207. "TABLE_NAME",
  208. false,
  209. SqlType(SqlType::Varchar, MAX_TAB_NAME_SIZE, false)
  210.     ),
  211.     DictSys::Column(
  212. 4,
  213. "COLUMN_NAME",
  214. false,
  215. SqlType(SqlType::Varchar, MAX_ATTR_NAME_SIZE, false)
  216.     ),
  217.     DictSys::Column(
  218. 5,
  219. "DATA_TYPE",
  220. false,
  221. SqlType(SqlType::Integer, false)
  222.     ),
  223.     DictSys::Column(
  224. 6,
  225. "TYPE_NAME",
  226. false,
  227. SqlType(SqlType::Varchar, 20, false)
  228.     ),
  229.     DictSys::Column(
  230. 7,
  231. "COLUMN_SIZE",
  232. false,
  233. SqlType(SqlType::Integer, true)
  234.     ),
  235.     DictSys::Column(
  236. 8,
  237. "BUFFER_LENGTH",
  238. false,
  239. SqlType(SqlType::Integer, true)
  240.     ),
  241.     DictSys::Column(
  242. 9,
  243. "DECIMAL_DIGITS",
  244. false,
  245. SqlType(SqlType::Integer, true)
  246.     ),
  247.     DictSys::Column(
  248. 10,
  249. "NUM_PREC_RADIX",
  250. false,
  251. SqlType(SqlType::Integer, true)
  252.     ),
  253.     DictSys::Column(
  254. 11,
  255. "NULLABLE",
  256. false,
  257. SqlType(SqlType::Integer, false)
  258.     ),
  259.     DictSys::Column(
  260. 12,
  261. "REMARKS",
  262. false,
  263. SqlType(SqlType::Varchar, MAX_REMARKS_LENGTH, true)
  264.     ),
  265.     DictSys::Column(
  266. 13,
  267. "COLUMN_DEF",
  268. false,
  269. SqlType(SqlType::Varchar, MAX_ATTR_DEFAULT_VALUE_SIZE, true)
  270.     ),
  271.     DictSys::Column(
  272. 14,
  273. "SQL_DATA_TYPE",
  274. false,
  275. SqlType(SqlType::Integer, false)
  276.     ),
  277.     DictSys::Column(
  278. 15,
  279. "SQL_DATETIME_SUB",
  280. false,
  281. SqlType(SqlType::Integer, true)
  282.     ),
  283.     DictSys::Column(
  284. 16,
  285. "CHAR_OCTET_LENGTH",
  286. false,
  287. SqlType(SqlType::Integer, true)
  288.     ),
  289.     DictSys::Column(
  290. 17,
  291. "ORDINAL_POSITION",
  292. false,
  293. SqlType(SqlType::Integer, false)
  294.     ),
  295.     DictSys::Column(
  296. 18,
  297. "IS_NULLABLE",
  298. false,
  299. SqlType(SqlType::Varchar, 3, true)
  300.     )
  301. };
  302. static DictSys::Table
  303. table_ODBC_COLUMNS(
  304.     DictSys::OdbcColumns,
  305.     "ODBC$COLUMNS",
  306.     column_ODBC_COLUMNS,
  307.     arraySize(column_ODBC_COLUMNS)
  308. );
  309. // primarykeys
  310. static DictSys::Column
  311. column_ODBC_PRIMARYKEYS[] = {
  312.     DictSys::Column(
  313. 1,
  314. "TABLE_CAT",
  315. false,
  316. SqlType(SqlType::Varchar, MAX_SCHEMA_NAME_LENGTH, true)
  317.     ),
  318.     DictSys::Column(
  319. 2,
  320. "TABLE_SCHEM",
  321. false,
  322. SqlType(SqlType::Varchar, MAX_SCHEMA_NAME_LENGTH, true)
  323.     ),
  324.     DictSys::Column(
  325. 3,
  326. "TABLE_NAME",
  327. false,
  328. SqlType(SqlType::Varchar, MAX_TAB_NAME_SIZE, false)
  329.     ),
  330.     DictSys::Column(
  331. 4,
  332. "COLUMN_NAME",
  333. false,
  334. SqlType(SqlType::Varchar, MAX_ATTR_NAME_SIZE, false)
  335.     ),
  336.     DictSys::Column(
  337. 5,
  338. "KEY_SEQ",
  339. false,
  340. SqlType(SqlType::Integer, false)
  341.     ),
  342.     DictSys::Column(
  343. 6,
  344. "PK_NAME",
  345. false,
  346. SqlType(SqlType::Varchar, MAX_ATTR_NAME_SIZE, true)
  347.     )
  348. };
  349. static DictSys::Table
  350. table_ODBC_PRIMARYKEYS(
  351.     DictSys::OdbcPrimarykeys,
  352.     "ODBC$PRIMARYKEYS",
  353.     column_ODBC_PRIMARYKEYS,
  354.     arraySize(column_ODBC_PRIMARYKEYS)
  355. );
  356. static DictSys::Column
  357. column_DUAL[] = {
  358.     DictSys::Column(
  359. 1,
  360. "DUMMY",
  361. false,
  362. SqlType(SqlType::Varchar, 1, false)
  363.     )
  364. };
  365. static DictSys::Table
  366. table_DUAL(
  367.     DictSys::Dual,
  368.     "DUAL",
  369.     column_DUAL,
  370.     arraySize(column_DUAL)
  371. );
  372. // all tables
  373. static const DictSys::Table*
  374. tableList[] = {
  375.     &table_ODBC_TYPEINFO,
  376.     &table_ODBC_TABLES,
  377.     &table_ODBC_COLUMNS,
  378.     &table_ODBC_PRIMARYKEYS,
  379.     &table_DUAL
  380. };
  381. static const unsigned tableCount = arraySize(tableList);
  382. DictTable*
  383. DictSys::loadTable(Ctx& ctx, DictSchema* schema, const BaseString& name)
  384. {
  385.     const Table* tp = 0;
  386.     for (unsigned i = 0; i < tableCount; i++) {
  387. if (strcmp(tableList[i]->m_name, name.c_str()) == 0) {
  388.     tp = tableList[i];
  389.     break;
  390. }
  391.     }
  392.     if (tp == 0)
  393. return 0;
  394.     DictTable* table = new DictTable(schema->m_connArea, tp->m_name, tp->m_columnCount);
  395.     table->sysId(tp->m_id);
  396.     schema->addTable(table);
  397.     for (unsigned position = 1; position <= tp->m_columnCount; position++) {
  398. const Column* cp = &tp->m_columnList[position - 1];
  399. ctx_assert(cp->m_position == position);
  400. const SqlType& sqlType = cp->m_sqlType;
  401. DictColumn* column = new DictColumn(table->m_connArea, cp->m_name, sqlType);
  402. table->setColumn(position, column);
  403. column->m_key = cp->m_key;
  404. if (column->m_key)
  405.     table->m_keys.push_back(column);
  406.     }
  407.     ctx_log3(("%s: system table defined", name.c_str()));
  408.     return table;
  409. }