├── ENodeType.c ├── ENodeType.h ├── LICENSE ├── Node.c ├── Node.h ├── Parser.c ├── Parser.h ├── README.md ├── Statement.c ├── Statement.h ├── examples ├── nodevisitor.py ├── visitor_tables.py └── visualize_tree.py ├── parsebridgemodule.c └── setup.py /ENodeType.h: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | #include 5 | 6 | typedef struct { 7 | PyObject_HEAD 8 | 9 | PyObject *dict; 10 | } Enum; 11 | 12 | void Enum_init_type(PyObject *m); 13 | 14 | void EVendor_init(Enum *type); 15 | 16 | void gsp_efindsqlstatetype_init(Enum *type); 17 | void EErrorType_init(Enum *type); 18 | void gsp_token_code_init(Enum *type); 19 | void EStmtType_init(Enum *type); 20 | void ETokenStatus_init(Enum *type); 21 | void EJoinSource_init(Enum *type); 22 | void EJoinType_init(Enum *type); 23 | void EFireMode_init(Enum *type); 24 | void ETriggerMode_init(Enum *type); 25 | void EStoreProcedureMode_init(Enum *type); 26 | void EParameterMode_init(Enum *type); 27 | void EHowtoSetValue_init(Enum *type); 28 | void EWhatDeclared_init(Enum *type); 29 | void EInsertValue_init(Enum *type); 30 | void EIndexType_init(Enum *type); 31 | void EAggregateType_init(Enum *type); 32 | void EAlterTableOptionType_init(Enum *type); 33 | void ETableSource_init(Enum *type); 34 | void EConstraintType_init(Enum *type); 35 | void EKeyReferenceType_init(Enum *type); 36 | void ESetOperator_init(Enum *type); 37 | void EDataType_init(Enum *type); 38 | void EFunctionType_init(Enum *type); 39 | void EDBObjectType_init(Enum *type); 40 | void ENodeType_init(Enum *type); 41 | void EExpressionType_init(Enum *type); 42 | void gsp_dbvendor_init(Enum *type); 43 | void EAccessMode_init(Enum *type); 44 | void EQeuryClause_init(Enum *type); 45 | void EConstantType_init(Enum *type); 46 | void EKeyActionType_init(Enum *type); 47 | void EMatchType_init(Enum *type); 48 | void EDistinctType_init(Enum *type); 49 | void gsp_EDeclareType_init(Enum *type); 50 | void gsp_EVariableType_init(Enum *type); 51 | void ECreateType_init(Enum *type); 52 | void EExecType_init(Enum *type); 53 | void ESetType_init(Enum *type); 54 | 55 | 56 | static PyMemberDef NodeTypeE_members[] = { 57 | {"__dict__", T_OBJECT, offsetof(Enum, dict), READONLY}, 58 | {NULL} /* Sentinel */ 59 | }; 60 | 61 | static PyMethodDef NodeTypeE_methods[] = { 62 | // regular methods 63 | {NULL} /* Sentinel */ 64 | }; 65 | 66 | static PyTypeObject EnumType = { 67 | PyObject_HEAD_INIT(NULL) 68 | 0, /*ob_size*/ 69 | "parsebridge.Enum", /*tp_name*/ 70 | sizeof(Enum), /*tp_basicsize*/ 71 | 0, /*tp_itemsize*/ 72 | 0, /*tp_dealloc*/ 73 | 0, /*tp_print*/ 74 | 0, //(getattrfunc)NodeTypeE_getattr, /*tp_getattr*/ 75 | 0, /*tp_setattr*/ 76 | 0, /*tp_compare*/ 77 | 0, /*tp_repr*/ 78 | 0, /*tp_as_number*/ 79 | 0, /*tp_as_sequence*/ 80 | 0, /*tp_as_mapping*/ 81 | 0, /*tp_hash */ 82 | 0, /*tp_call*/ 83 | 0, /*tp_str*/ 84 | PyObject_GenericGetAttr, /*tp_getattro*/ 85 | 0, /*tp_setattro*/ 86 | 0, /*tp_as_buffer*/ 87 | Py_TPFLAGS_DEFAULT, /*tp_flags*/ 88 | "Node Type enum", /* tp_doc */ 89 | 0, /* tp_traverse */ 90 | 0, /* tp_clear */ 91 | 0, /* tp_richcompare */ 92 | 0, /* tp_weaklistoffset */ 93 | 0, /* tp_iter */ 94 | 0, /* tp_iternext */ 95 | NodeTypeE_methods, /* tp_methods */ 96 | NodeTypeE_members, /* tp_members */ 97 | 0, /* tp_getset */ 98 | 0, /* tp_base */ 99 | 0, /* tp_dict */ 100 | 0, /* tp_descr_get */ 101 | 0, /* tp_descr_set */ 102 | offsetof(Enum, dict), /* tp_dictoffset */ 103 | 0, //(initproc)Shoddy_init, /* tp_init */ 104 | 0, /* tp_alloc */ 105 | 0, /* tp_new */ 106 | }; -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | Copyright (c) 2017 Timo Djürken 2 | 3 | Permission is hereby granted, free of charge, to any person obtaining a copy 4 | of this software and associated documentation files (the "Software"), to deal 5 | in the Software without restriction, including without limitation the rights 6 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 7 | copies of the Software, and to permit persons to whom the Software is 8 | furnished to do so, subject to the following conditions: 9 | 10 | The above copyright notice and this permission notice shall be included in all 11 | copies or substantial portions of the Software. 12 | 13 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 14 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 15 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 16 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 17 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 18 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 19 | SOFTWARE. 20 | -------------------------------------------------------------------------------- /Node.c: -------------------------------------------------------------------------------- 1 | #include "Statement.h" 2 | #include "Node.h" 3 | #include "cstring.h" 4 | #include "modifysql.h" 5 | 6 | // Initialize this Type 7 | void Node_init_type(PyObject *m) { 8 | // Fill node parsing functions 9 | Node_init(); 10 | 11 | if (PyType_Ready(&NodeType) < 0) 12 | return; 13 | Py_INCREF(&NodeType); 14 | PyModule_AddObject(m, "Node", (PyObject*)&NodeType); 15 | } 16 | 17 | /*char* gsp_getNodeText( gsp_node* node ) 18 | { 19 | gsp_sourcetoken* startToken = NULL; 20 | gsp_sourcetoken* endToken = NULL; 21 | gsp_sourcetoken* currentToken = NULL; 22 | CString* content; 23 | char* rc; 24 | 25 | if(node == NULL) 26 | return NULL; 27 | if (node->nodeType == t_gsp_list) 28 | { 29 | if(((gsp_list*)node)->length>0){ 30 | startToken = (gsp_list_first((gsp_list *)node))->fragment.startToken; 31 | endToken = (gsp_list_last((gsp_list *)node))->fragment.endToken; 32 | } 33 | 34 | }else{ 35 | startToken = node->fragment.startToken; 36 | endToken = node->fragment.endToken; 37 | } 38 | 39 | currentToken = startToken; 40 | if(currentToken == NULL) 41 | return NULL; 42 | 43 | 44 | while( startToken!=NULL && startToken!=endToken && startToken->tokenStatus == ets_deleted){ 45 | startToken = startToken->pNext; 46 | } 47 | 48 | if(startToken == NULL || startToken->tokenStatus == ets_deleted){ 49 | startToken = NULL; 50 | endToken = NULL; 51 | return NULL; 52 | } 53 | else{ 54 | while(endToken!=NULL && endToken!=startToken && endToken->tokenStatus == ets_deleted){ 55 | endToken = endToken->pPrev; 56 | } 57 | 58 | if(endToken == NULL || endToken->tokenStatus == ets_deleted){ 59 | startToken = NULL; 60 | endToken = NULL; 61 | return NULL; 62 | } 63 | 64 | content = CStringNew(); 65 | 66 | if(currentToken->tokenStatus!=ets_deleted) 67 | CStringNAppend(content, currentToken->pStr, currentToken->nStrLen); 68 | 69 | while(currentToken != endToken && currentToken->pNext!=NULL){ 70 | currentToken = currentToken->pNext; 71 | if(currentToken->tokenStatus!=ets_deleted) 72 | CStringNAppend(content, currentToken->pStr, currentToken->nStrLen); 73 | if(currentToken == endToken) 74 | break; 75 | } 76 | 77 | rc = content->buffer; 78 | CStringDeleteWithoutBuffer(content); 79 | return rc; 80 | } 81 | }*/ 82 | 83 | char* gsp_getSimpleNodeText(gsp_node* node, gsp_sqlparser *parser) 84 | { 85 | gsp_sourcetoken* startToken = NULL; 86 | gsp_sourcetoken* endToken = NULL; 87 | gsp_sourcetoken* currentToken = NULL; 88 | CString* content; 89 | char* rc; 90 | 91 | if (node == NULL) 92 | return NULL; 93 | if (node->nodeType == t_gsp_list) 94 | { 95 | if (((gsp_list*)node)->length>0){ 96 | startToken = (gsp_list_first((gsp_list *)node))->fragment.startToken; 97 | endToken = (gsp_list_last((gsp_list *)node))->fragment.endToken; 98 | } 99 | 100 | } 101 | else{ 102 | startToken = node->fragment.startToken; 103 | endToken = node->fragment.endToken; 104 | } 105 | 106 | currentToken = startToken; 107 | if (currentToken == NULL) 108 | return NULL; 109 | 110 | 111 | while (startToken != NULL && startToken != endToken && startToken->tokenStatus == ets_deleted){ 112 | startToken = startToken->pNext; 113 | } 114 | 115 | if (startToken == NULL || startToken->tokenStatus == ets_deleted){ 116 | startToken = NULL; 117 | endToken = NULL; 118 | return NULL; 119 | } 120 | else{ 121 | int start, stop, len; 122 | 123 | while (endToken != NULL && endToken != startToken && endToken->tokenStatus == ets_deleted){ 124 | endToken = endToken->pPrev; 125 | } 126 | 127 | if (endToken == NULL || endToken->tokenStatus == ets_deleted){ 128 | startToken = NULL; 129 | endToken = NULL; 130 | return NULL; 131 | } 132 | 133 | content = CStringNew(); 134 | 135 | if (startToken == endToken) { 136 | start = startToken->nColumn - 1; 137 | stop = start + startToken->nStrLen; 138 | len = startToken->nStrLen; 139 | } 140 | else { 141 | start = startToken->nColumn - 1; 142 | stop = endToken->nColumn + endToken->nStrLen - 1; 143 | len = stop - start; 144 | } 145 | 146 | 147 | //printf("%d, %d, %d\n", start, stop, len); 148 | 149 | CStringNAppend(content, parser->sqltext + start, len); 150 | 151 | rc = content->buffer; 152 | CStringDeleteWithoutBuffer(content); 153 | return rc; 154 | } 155 | } 156 | 157 | PyObject *Node_get_text(SqlNode *self, PyObject *args) 158 | { 159 | char *tmp; 160 | PyObject *name; 161 | 162 | //tmp = gsp_getNodeText(self->_node); 163 | tmp = gsp_getSimpleNodeText(self->_node, self->_parser); 164 | if (tmp == NULL) { 165 | name = PyString_FromString(""); 166 | } 167 | else { 168 | name = PyString_FromString(tmp); 169 | gsp_free(tmp); 170 | } 171 | 172 | //Py_XINCREF(name); 173 | return name; 174 | } 175 | 176 | PyObject *Node_get_position(SqlNode *self, PyObject *args) 177 | { 178 | if (self->_node->fragment.startToken) { 179 | char *name; 180 | PyObject *pos; 181 | 182 | //name = gsp_getNodeText(self->_node); 183 | name = gsp_getSimpleNodeText(self->_node, self->_parser); 184 | 185 | if (name == NULL) { 186 | Py_RETURN_NONE; 187 | } 188 | 189 | pos = Py_BuildValue("(ii)", self->_node->fragment.startToken->nColumn, strlen(name)); 190 | free(name); 191 | return pos; 192 | } 193 | Py_RETURN_NONE; 194 | } 195 | 196 | // Provide a (standard) iterator if it's a list node 197 | PyObject *Node_list_iterator(PyObject *o) { 198 | SqlNode *node = (SqlNode*) o; 199 | 200 | if (node->_node->nodeType == t_gsp_list) { 201 | PyObject *iter = PyObject_GetIter(PyDict_GetItemString(node->dict, "list")); 202 | Py_XDECREF(iter); 203 | return iter; 204 | } 205 | 206 | Py_RETURN_NONE; 207 | } 208 | 209 | PyObject *Node_getattro(SqlNode *self, PyObject *name) 210 | { 211 | if (strcmp(PyString_AS_STRING(name), "node_text") == 0) { 212 | return Node_get_text(self, NULL); 213 | } 214 | 215 | return PyObject_GenericGetAttr((PyObject*)self, name); 216 | } 217 | 218 | PyObject *Node_FromNode(gsp_node *node, Statement *stmt) { 219 | PyObject *self; 220 | PyObject *type; 221 | //PyObject *name; 222 | //char *tmp; 223 | 224 | //printf("Node_FromNode(%d) : %p\n", node->nodeType, node); 225 | 226 | if (Node_parse_functions[node->nodeType] != NULL) { 227 | self = Node_parse_functions[node->nodeType](node, stmt); 228 | 229 | if (self->ob_type == &NodeType) { 230 | // it's a SqlNode object! 231 | type = PyInt_FromLong(node->nodeType); 232 | PyDict_SetItemString(((SqlNode*)self)->dict, "node_type", type); 233 | 234 | //Py_XDECREF(type); 235 | if (node->nodeType == t_gsp_list) { 236 | /*name = PyString_FromString("LIST"); 237 | PyDict_SetItemString(((SqlNode*)self)->dict, "node_text", name); 238 | Py_XDECREF(name);*/ 239 | } else { 240 | /*tmp = gsp_getNodeText(node); 241 | name = PyString_FromString(tmp); 242 | gsp_free(tmp); 243 | PyDict_SetItemString(((SqlNode*)self)->dict, "node_text", name); 244 | Py_XDECREF(name);*/ 245 | } 246 | } else { 247 | // it's something else! maybe a list. we dont judge. 248 | } 249 | } else { 250 | type = PyInt_FromLong(node->nodeType); 251 | //printf("NO PARSER FOR NODE TYPE: %d\n", node->nodeType); 252 | self = Node_new(&NodeType, NULL, NULL); 253 | PyDict_SetItemString(((SqlNode*)self)->dict, "node_type", type); 254 | 255 | /*tmp = gsp_getNodeText(node); 256 | name = PyString_FromString(tmp); 257 | gsp_free(tmp); 258 | PyDict_SetItemString(((SqlNode*)self)->dict, "node_text", name); 259 | Py_XDECREF(name);*/ 260 | } 261 | 262 | //printf("Node_FromNode: %p %p\n", stmt->_statement, stmt->_statement->sqlparser); 263 | ((SqlNode*)self)->_parser = stmt->_statement->sqlparser; 264 | 265 | return (PyObject*)self; 266 | } 267 | 268 | void Node_dealloc(SqlNode *self) 269 | { 270 | //printf("Node_dealloc %p (%d)\n", self, self->ob_refcnt); 271 | Py_XDECREF(self->dict); 272 | self->ob_type->tp_free((PyObject*)self); 273 | } 274 | 275 | PyObject *Node_new(PyTypeObject *type, PyObject *args, PyObject *kwds) 276 | { 277 | SqlNode *self; 278 | 279 | self = (SqlNode *)type->tp_alloc(type, 0); 280 | 281 | if (self != NULL) { 282 | self->_node = NULL; 283 | self->_parser = NULL; 284 | self->dict = PyDict_New(); 285 | } 286 | return (PyObject*) self; 287 | } 288 | 289 | 290 | #define ADD_TOKEN(d, path, name) if (path->name) { PyObject *o = PyString_FromStringAndSize(path->name->pStr, path->name->nStrLen); PyDict_SetItemString(d, #name, o); Py_XDECREF(o); } else { PyDict_SetItemString(d, #name, Py_None); } 291 | #define ADD_INT(d, path, name) if (true) { PyObject *o = PyInt_FromLong(path->name); PyDict_SetItemString(d, #name, o); Py_XDECREF(o); } 292 | #define ADD_NODE(d, path, name) if (path->name) { PyObject *o = Node_FromNode((gsp_node*)path->name, stmt); PyDict_SetItemString(d, #name, o); Py_XDECREF(o); } else { PyDict_SetItemString(d, #name, Py_None); } 293 | #define ADD_LIST(d, path, name) if (path->name) { PyObject *o = Node_parsepath->name; PyDict_SetItemString(d, #name, o); Py_XDECREF(o); } else { PyDict_SetItemString(d, #name, Py_None); } 294 | 295 | PyObject *Node_parse_list(gsp_node *node, Statement *stmt) 296 | { 297 | PyObject *list; 298 | struct gsp_listcell *cell; 299 | 300 | 301 | 302 | // generate new Node object 303 | SqlNode *obj; 304 | obj = (SqlNode*) Node_new(&NodeType, Py_None, Py_None); obj->_node = node; 305 | 306 | // New list 307 | list = PyList_New(0); 308 | foreach(cell, ((gsp_list*)node)) { 309 | // generate new Node object from list item 310 | PyObject *o; 311 | 312 | o= Node_FromNode((gsp_node*)cell->node, stmt); 313 | // add to list 314 | PyList_Append(list, (PyObject*) o); 315 | Py_XDECREF(o); 316 | } 317 | 318 | // Add list to node 319 | PyDict_SetItemString(obj->dict, "list", list); 320 | Py_XDECREF(list); 321 | 322 | return (PyObject*) obj; 323 | } 324 | 325 | /// AUTO-GENERATED PARSING FUNCTIONS 326 | PyObject *Node_parse_listcell(gsp_node *node, Statement *stmt) { 327 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_listcell*)node), node); 328 | ADD_NODE(obj->dict, ((gsp_listcell*)node), nextCell); 329 | return (PyObject*)obj; 330 | } 331 | PyObject *Node_parse_sql_statement(gsp_node *node, Statement *stmt) { 332 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_INT(obj->dict, ((gsp_sql_statement*)node), stmtType); 333 | ADD_NODE(obj->dict, ((gsp_sql_statement*)node), parseTree); 334 | ADD_INT(obj->dict, ((gsp_sql_statement*)node), start_token_pos); 335 | ADD_INT(obj->dict, ((gsp_sql_statement*)node), end_token_pos); 336 | ADD_INT(obj->dict, ((gsp_sql_statement*)node), bCteQuery); 337 | ADD_INT(obj->dict, ((gsp_sql_statement*)node), isParsed); 338 | ADD_INT(obj->dict, ((gsp_sql_statement*)node), dummyTag); 339 | return (PyObject*)obj; 340 | } 341 | PyObject *Node_parse_dummy(gsp_node *node, Statement *stmt) { 342 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_dummy*)node), node1); 343 | ADD_INT(obj->dict, ((gsp_dummy*)node), int1); 344 | return (PyObject*)obj; 345 | } 346 | PyObject *Node_parse_constant(gsp_node *node, Statement *stmt) { 347 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_TOKEN(obj->dict, ((gsp_constant*)node), signToken); 348 | ADD_TOKEN(obj->dict, ((gsp_constant*)node), stringToken); 349 | ADD_INT(obj->dict, ((gsp_constant*)node), constantType); 350 | return (PyObject*)obj; 351 | } 352 | PyObject *Node_parse_objectname(gsp_node *node, Statement *stmt) { 353 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_INT(obj->dict, ((gsp_objectname*)node), objectType); 354 | ADD_TOKEN(obj->dict, ((gsp_objectname*)node), serverToken); 355 | ADD_TOKEN(obj->dict, ((gsp_objectname*)node), databaseToken); 356 | ADD_TOKEN(obj->dict, ((gsp_objectname*)node), schemaToken); 357 | ADD_TOKEN(obj->dict, ((gsp_objectname*)node), objectToken); 358 | ADD_TOKEN(obj->dict, ((gsp_objectname*)node), partToken); 359 | ADD_TOKEN(obj->dict, ((gsp_objectname*)node), propertyToken); 360 | ADD_NODE(obj->dict, ((gsp_objectname*)node), fields); 361 | ADD_INT(obj->dict, ((gsp_objectname*)node), nTokens); 362 | ADD_NODE(obj->dict, ((gsp_objectname*)node), dblink); 363 | ADD_NODE(obj->dict, ((gsp_objectname*)node), indices); 364 | return (PyObject*)obj; 365 | } 366 | PyObject *Node_parse_expr(gsp_node *node, Statement *stmt) { 367 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_INT(obj->dict, ((gsp_expr*)node), expressionType); 368 | ADD_NODE(obj->dict, ((gsp_expr*)node), objectOperand); 369 | ADD_TOKEN(obj->dict, ((gsp_expr*)node), operatorToken); 370 | ADD_NODE(obj->dict, ((gsp_expr*)node), leftOperand); 371 | ADD_NODE(obj->dict, ((gsp_expr*)node), rightOperand); 372 | ADD_NODE(obj->dict, ((gsp_expr*)node), subQueryNode); 373 | ADD_NODE(obj->dict, ((gsp_expr*)node), subQueryStmt); 374 | ADD_NODE(obj->dict, ((gsp_expr*)node), constantOperand); 375 | ADD_NODE(obj->dict, ((gsp_expr*)node), exprList); 376 | ADD_NODE(obj->dict, ((gsp_expr*)node), functionCall); 377 | ADD_NODE(obj->dict, ((gsp_expr*)node), objectAccess); 378 | ADD_NODE(obj->dict, ((gsp_expr*)node), caseExpression); 379 | ADD_TOKEN(obj->dict, ((gsp_expr*)node), quantifier); 380 | ADD_TOKEN(obj->dict, ((gsp_expr*)node), notToken); 381 | ADD_NODE(obj->dict, ((gsp_expr*)node), likeEscapeOperand); 382 | ADD_NODE(obj->dict, ((gsp_expr*)node), betweenOperand); 383 | ADD_NODE(obj->dict, ((gsp_expr*)node), arrayAccess); 384 | ADD_NODE(obj->dict, ((gsp_expr*)node), dataTypeName); 385 | ADD_NODE(obj->dict, ((gsp_expr*)node), intervalExpression); 386 | ADD_NODE(obj->dict, ((gsp_expr*)node), indices); 387 | ADD_NODE(obj->dict, ((gsp_expr*)node), newVariantTypeArgumentList); 388 | return (PyObject*)obj; 389 | } 390 | PyObject *Node_parse_objectAccess(gsp_node *node, Statement *stmt) { 391 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_objectAccess*)node), objectExpr); 392 | ADD_NODE(obj->dict, ((gsp_objectAccess*)node), attributes); 393 | ADD_NODE(obj->dict, ((gsp_objectAccess*)node), method); 394 | return (PyObject*)obj; 395 | } 396 | PyObject *Node_parse_aliasClause(gsp_node *node, Statement *stmt) { 397 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_aliasClause*)node), aliasName); 398 | ADD_TOKEN(obj->dict, ((gsp_aliasClause*)node), AsToken); 399 | ADD_NODE(obj->dict, ((gsp_aliasClause*)node), nameList); 400 | return (PyObject*)obj; 401 | } 402 | PyObject *Node_parse_resultColumn(gsp_node *node, Statement *stmt) { 403 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_resultColumn*)node), expr); 404 | ADD_NODE(obj->dict, ((gsp_resultColumn*)node), aliasClause); 405 | return (PyObject*)obj; 406 | } 407 | PyObject *Node_parse_trimArgument(gsp_node *node, Statement *stmt) { 408 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_TOKEN(obj->dict, ((gsp_trimArgument*)node), both_trailing_leading); 409 | ADD_NODE(obj->dict, ((gsp_trimArgument*)node), stringExpression); 410 | ADD_NODE(obj->dict, ((gsp_trimArgument*)node), trimCharacter); 411 | return (PyObject*)obj; 412 | } 413 | PyObject *Node_parse_orderByItem(gsp_node *node, Statement *stmt) { 414 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_orderByItem*)node), sortKey); 415 | ADD_TOKEN(obj->dict, ((gsp_orderByItem*)node), sortToken); 416 | return (PyObject*)obj; 417 | } 418 | PyObject *Node_parse_orderBy(gsp_node *node, Statement *stmt) { 419 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_orderBy*)node), items); 420 | return (PyObject*)obj; 421 | } 422 | PyObject *Node_parse_keepDenseRankClause(gsp_node *node, Statement *stmt) { 423 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_keepDenseRankClause*)node), orderBy); 424 | return (PyObject*)obj; 425 | } 426 | PyObject *Node_parse_analyticFunction(gsp_node *node, Statement *stmt) { 427 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_analyticFunction*)node), keepDenseRankClause); 428 | ADD_NODE(obj->dict, ((gsp_analyticFunction*)node), partitionBy_ExprList); 429 | ADD_NODE(obj->dict, ((gsp_analyticFunction*)node), orderBy); 430 | return (PyObject*)obj; 431 | } 432 | PyObject *Node_parse_functionCall(gsp_node *node, Statement *stmt) { 433 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_INT(obj->dict, ((gsp_functionCall*)node), functionType); 434 | ADD_NODE(obj->dict, ((gsp_functionCall*)node), functionName); 435 | ADD_INT(obj->dict, ((gsp_functionCall*)node), aggregateType); 436 | ADD_NODE(obj->dict, ((gsp_functionCall*)node), trimArgument); 437 | ADD_NODE(obj->dict, ((gsp_functionCall*)node), analyticFunction); 438 | ADD_NODE(obj->dict, ((gsp_functionCall*)node), Args); 439 | ADD_TOKEN(obj->dict, ((gsp_functionCall*)node), extract_time_token); 440 | ADD_NODE(obj->dict, ((gsp_functionCall*)node), expr1); 441 | ADD_NODE(obj->dict, ((gsp_functionCall*)node), expr2); 442 | ADD_NODE(obj->dict, ((gsp_functionCall*)node), expr3); 443 | ADD_NODE(obj->dict, ((gsp_functionCall*)node), dataTypename); 444 | ADD_NODE(obj->dict, ((gsp_functionCall*)node), windowDef); 445 | ADD_NODE(obj->dict, ((gsp_functionCall*)node), sortClause); 446 | ADD_NODE(obj->dict, ((gsp_functionCall*)node), sortList); 447 | return (PyObject*)obj; 448 | } 449 | PyObject *Node_parse_whenClauseItem(gsp_node *node, Statement *stmt) { 450 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_whenClauseItem*)node), comparison_expr); 451 | ADD_NODE(obj->dict, ((gsp_whenClauseItem*)node), stmts); 452 | ADD_NODE(obj->dict, ((gsp_whenClauseItem*)node), return_expr); 453 | ADD_NODE(obj->dict, ((gsp_whenClauseItem*)node), countFractionDescriptionList); 454 | return (PyObject*)obj; 455 | } 456 | PyObject *Node_parse_caseExpression(gsp_node *node, Statement *stmt) { 457 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_caseExpression*)node), input_expr); 458 | ADD_NODE(obj->dict, ((gsp_caseExpression*)node), else_expr); 459 | ADD_NODE(obj->dict, ((gsp_caseExpression*)node), whenClauseItemList); 460 | ADD_NODE(obj->dict, ((gsp_caseExpression*)node), else_statement_node_list); 461 | return (PyObject*)obj; 462 | } 463 | PyObject *Node_parse_intervalExpression(gsp_node *node, Statement *stmt) { 464 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; return (PyObject*)obj; 465 | } 466 | PyObject *Node_parse_precisionScale(gsp_node *node, Statement *stmt) { 467 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_precisionScale*)node), precision); 468 | ADD_NODE(obj->dict, ((gsp_precisionScale*)node), scale); 469 | return (PyObject*)obj; 470 | } 471 | PyObject *Node_parse_typename(gsp_node *node, Statement *stmt) { 472 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_INT(obj->dict, ((gsp_typename*)node), dataType); 473 | ADD_NODE(obj->dict, ((gsp_typename*)node), precisionScale); 474 | ADD_NODE(obj->dict, ((gsp_typename*)node), secondsPrecision); 475 | ADD_NODE(obj->dict, ((gsp_typename*)node), length); 476 | ADD_NODE(obj->dict, ((gsp_typename*)node), genericName); 477 | ADD_NODE(obj->dict, ((gsp_typename*)node), indices); 478 | ADD_NODE(obj->dict, ((gsp_typename*)node), datatypeAttributeList); 479 | return (PyObject*)obj; 480 | } 481 | PyObject *Node_parse_keyReference(gsp_node *node, Statement *stmt) { 482 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_INT(obj->dict, ((gsp_keyReference*)node), referenceType); 483 | return (PyObject*)obj; 484 | } 485 | PyObject *Node_parse_keyAction(gsp_node *node, Statement *stmt) { 486 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_INT(obj->dict, ((gsp_keyAction*)node), actionType); 487 | ADD_NODE(obj->dict, ((gsp_keyAction*)node), keyReference); 488 | return (PyObject*)obj; 489 | } 490 | PyObject *Node_parse_constraint(gsp_node *node, Statement *stmt) { 491 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_INT(obj->dict, ((gsp_constraint*)node), constraintType); 492 | ADD_NODE(obj->dict, ((gsp_constraint*)node), constraintName); 493 | ADD_NODE(obj->dict, ((gsp_constraint*)node), checkCondition); 494 | ADD_NODE(obj->dict, ((gsp_constraint*)node), columnList); 495 | ADD_NODE(obj->dict, ((gsp_constraint*)node), automaticProperties); 496 | ADD_NODE(obj->dict, ((gsp_constraint*)node), referencedObject); 497 | ADD_NODE(obj->dict, ((gsp_constraint*)node), referencedColumnList); 498 | ADD_NODE(obj->dict, ((gsp_constraint*)node), keyActions); 499 | ADD_NODE(obj->dict, ((gsp_constraint*)node), defaultValue); 500 | ADD_NODE(obj->dict, ((gsp_constraint*)node), seedExpr); 501 | ADD_NODE(obj->dict, ((gsp_constraint*)node), incrementExpr); 502 | return (PyObject*)obj; 503 | } 504 | PyObject *Node_parse_mergeInsertClause(gsp_node *node, Statement *stmt) { 505 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_mergeInsertClause*)node), columnList); 506 | ADD_NODE(obj->dict, ((gsp_mergeInsertClause*)node), valuelist); 507 | ADD_NODE(obj->dict, ((gsp_mergeInsertClause*)node), deleteWhereClause); 508 | return (PyObject*)obj; 509 | } 510 | PyObject *Node_parse_mergeUpdateClause(gsp_node *node, Statement *stmt) { 511 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_mergeUpdateClause*)node), updateColumnList); 512 | ADD_NODE(obj->dict, ((gsp_mergeUpdateClause*)node), updateWhereClause); 513 | ADD_NODE(obj->dict, ((gsp_mergeUpdateClause*)node), deleteWhereClause); 514 | return (PyObject*)obj; 515 | } 516 | PyObject *Node_parse_mergeDeleteClause(gsp_node *node, Statement *stmt) { 517 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; return (PyObject*)obj; 518 | } 519 | PyObject *Node_parse_mergeWhenClause(gsp_node *node, Statement *stmt) { 520 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_mergeWhenClause*)node), condition); 521 | ADD_NODE(obj->dict, ((gsp_mergeWhenClause*)node), updateClause); 522 | ADD_NODE(obj->dict, ((gsp_mergeWhenClause*)node), insertClause); 523 | ADD_NODE(obj->dict, ((gsp_mergeWhenClause*)node), deleteClause); 524 | ADD_NODE(obj->dict, ((gsp_mergeWhenClause*)node), signalStmt); 525 | return (PyObject*)obj; 526 | } 527 | PyObject *Node_parse_dataChangeTable(gsp_node *node, Statement *stmt) { 528 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_dataChangeTable*)node), stmtNode); 529 | return (PyObject*)obj; 530 | } 531 | PyObject *Node_parse_fromTable(gsp_node *node, Statement *stmt) { 532 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_fromTable*)node), aliasClause); 533 | ADD_INT(obj->dict, ((gsp_fromTable*)node), fromtableType); 534 | ADD_NODE(obj->dict, ((gsp_fromTable*)node), subQueryNode); 535 | ADD_NODE(obj->dict, ((gsp_fromTable*)node), tableName); 536 | ADD_NODE(obj->dict, ((gsp_fromTable*)node), pxGranule); 537 | ADD_NODE(obj->dict, ((gsp_fromTable*)node), tableSample); 538 | ADD_NODE(obj->dict, ((gsp_fromTable*)node), flashback); 539 | ADD_NODE(obj->dict, ((gsp_fromTable*)node), joinExpr); 540 | ADD_NODE(obj->dict, ((gsp_fromTable*)node), tableExpr); 541 | ADD_TOKEN(obj->dict, ((gsp_fromTable*)node), tableonly); 542 | ADD_NODE(obj->dict, ((gsp_fromTable*)node), dataChangeTable); 543 | ADD_NODE(obj->dict, ((gsp_fromTable*)node), tableHints); 544 | ADD_NODE(obj->dict, ((gsp_fromTable*)node), functionCall); 545 | ADD_NODE(obj->dict, ((gsp_fromTable*)node), openQuery); 546 | ADD_NODE(obj->dict, ((gsp_fromTable*)node), openDatasource); 547 | ADD_NODE(obj->dict, ((gsp_fromTable*)node), containsTable); 548 | ADD_NODE(obj->dict, ((gsp_fromTable*)node), freeTable); 549 | ADD_NODE(obj->dict, ((gsp_fromTable*)node), openRowSet); 550 | ADD_NODE(obj->dict, ((gsp_fromTable*)node), openXML); 551 | ADD_NODE(obj->dict, ((gsp_fromTable*)node), pivotClause); 552 | ADD_NODE(obj->dict, ((gsp_fromTable*)node), unPivotClause); 553 | ADD_NODE(obj->dict, ((gsp_fromTable*)node), rowList); 554 | ADD_NODE(obj->dict, ((gsp_fromTable*)node), outerClause); 555 | return (PyObject*)obj; 556 | } 557 | PyObject *Node_parse_table(gsp_node *node, Statement *stmt) { 558 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_INT(obj->dict, ((gsp_table*)node), tableSource); 559 | ADD_NODE(obj->dict, ((gsp_table*)node), aliasClause); 560 | ADD_NODE(obj->dict, ((gsp_table*)node), tableName); 561 | ADD_NODE(obj->dict, ((gsp_table*)node), tableExpr); 562 | return (PyObject*)obj; 563 | } 564 | PyObject *Node_parse_mergeSqlNode(gsp_node *node, Statement *stmt) { 565 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_mergeSqlNode*)node), cteList); 566 | ADD_NODE(obj->dict, ((gsp_mergeSqlNode*)node), whenClauses); 567 | ADD_NODE(obj->dict, ((gsp_mergeSqlNode*)node), targetTableNode); 568 | ADD_NODE(obj->dict, ((gsp_mergeSqlNode*)node), usingTableNode); 569 | ADD_NODE(obj->dict, ((gsp_mergeSqlNode*)node), condition); 570 | ADD_NODE(obj->dict, ((gsp_mergeSqlNode*)node), outputClause); 571 | ADD_NODE(obj->dict, ((gsp_mergeSqlNode*)node), columnList); 572 | ADD_NODE(obj->dict, ((gsp_mergeSqlNode*)node), targetTable); 573 | ADD_NODE(obj->dict, ((gsp_mergeSqlNode*)node), usingTable); 574 | return (PyObject*)obj; 575 | } 576 | PyObject *Node_parse_alterTableOption(gsp_node *node, Statement *stmt) { 577 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_INT(obj->dict, ((gsp_alterTableOption*)node), optionType); 578 | ADD_NODE(obj->dict, ((gsp_alterTableOption*)node), constraintName); 579 | ADD_NODE(obj->dict, ((gsp_alterTableOption*)node), newConstraintName); 580 | ADD_NODE(obj->dict, ((gsp_alterTableOption*)node), columnName); 581 | ADD_NODE(obj->dict, ((gsp_alterTableOption*)node), newColumnName); 582 | ADD_NODE(obj->dict, ((gsp_alterTableOption*)node), referencedObjectName); 583 | ADD_NODE(obj->dict, ((gsp_alterTableOption*)node), newTableName); 584 | ADD_NODE(obj->dict, ((gsp_alterTableOption*)node), indexName); 585 | ADD_NODE(obj->dict, ((gsp_alterTableOption*)node), columnDefinitionList); 586 | ADD_NODE(obj->dict, ((gsp_alterTableOption*)node), constraintList); 587 | ADD_NODE(obj->dict, ((gsp_alterTableOption*)node), columnNameList); 588 | ADD_NODE(obj->dict, ((gsp_alterTableOption*)node), referencedColumnList); 589 | ADD_NODE(obj->dict, ((gsp_alterTableOption*)node), datatype); 590 | return (PyObject*)obj; 591 | } 592 | PyObject *Node_parse_alterTableSqlNode(gsp_node *node, Statement *stmt) { 593 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_alterTableSqlNode*)node), tableName); 594 | ADD_NODE(obj->dict, ((gsp_alterTableSqlNode*)node), tableElementList); 595 | ADD_NODE(obj->dict, ((gsp_alterTableSqlNode*)node), alterTableOptionList); 596 | return (PyObject*)obj; 597 | } 598 | PyObject *Node_parse_createSequenceSqlNode(gsp_node *node, Statement *stmt) { 599 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_createSequenceSqlNode*)node), sequenceName); 600 | ADD_NODE(obj->dict, ((gsp_createSequenceSqlNode*)node), options); 601 | return (PyObject*)obj; 602 | } 603 | PyObject *Node_parse_createSynonymSqlNode(gsp_node *node, Statement *stmt) { 604 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_createSynonymSqlNode*)node), synonymName); 605 | ADD_NODE(obj->dict, ((gsp_createSynonymSqlNode*)node), forName); 606 | ADD_INT(obj->dict, ((gsp_createSynonymSqlNode*)node), isPublic); 607 | ADD_INT(obj->dict, ((gsp_createSynonymSqlNode*)node), isReplace); 608 | return (PyObject*)obj; 609 | } 610 | PyObject *Node_parse_createDirectorySqlNode(gsp_node *node, Statement *stmt) { 611 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_createDirectorySqlNode*)node), directoryName); 612 | ADD_NODE(obj->dict, ((gsp_createDirectorySqlNode*)node), path); 613 | return (PyObject*)obj; 614 | } 615 | PyObject *Node_parse_dropViewSqlNode(gsp_node *node, Statement *stmt) { 616 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_dropViewSqlNode*)node), viewNameList); 617 | return (PyObject*)obj; 618 | } 619 | PyObject *Node_parse_dropTableSqlNode(gsp_node *node, Statement *stmt) { 620 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_dropTableSqlNode*)node), tableNameList); 621 | return (PyObject*)obj; 622 | } 623 | PyObject *Node_parse_dropIndexItem(gsp_node *node, Statement *stmt) { 624 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_dropIndexItem*)node), indexName); 625 | ADD_NODE(obj->dict, ((gsp_dropIndexItem*)node), tableName); 626 | return (PyObject*)obj; 627 | } 628 | PyObject *Node_parse_dropIndexSqlNode(gsp_node *node, Statement *stmt) { 629 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_dropIndexSqlNode*)node), indexName); 630 | ADD_NODE(obj->dict, ((gsp_dropIndexSqlNode*)node), itemList); 631 | return (PyObject*)obj; 632 | } 633 | PyObject *Node_parse_truncateTableSqlNode(gsp_node *node, Statement *stmt) { 634 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_truncateTableSqlNode*)node), tableName); 635 | return (PyObject*)obj; 636 | } 637 | PyObject *Node_parse_viewAliasItem(gsp_node *node, Statement *stmt) { 638 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_viewAliasItem*)node), alias); 639 | ADD_NODE(obj->dict, ((gsp_viewAliasItem*)node), columnConstraintList); 640 | ADD_NODE(obj->dict, ((gsp_viewAliasItem*)node), tableConstraint); 641 | return (PyObject*)obj; 642 | } 643 | PyObject *Node_parse_viewAliasClause(gsp_node *node, Statement *stmt) { 644 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_viewAliasClause*)node), viewAliasItemList); 645 | return (PyObject*)obj; 646 | } 647 | PyObject *Node_parse_createViewSqlNode(gsp_node *node, Statement *stmt) { 648 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_createViewSqlNode*)node), viewName); 649 | ADD_NODE(obj->dict, ((gsp_createViewSqlNode*)node), selectSqlNode); 650 | ADD_NODE(obj->dict, ((gsp_createViewSqlNode*)node), viewAliasClause); 651 | ADD_INT(obj->dict, ((gsp_createViewSqlNode*)node), isForce); 652 | ADD_INT(obj->dict, ((gsp_createViewSqlNode*)node), isReplace); 653 | ADD_NODE(obj->dict, ((gsp_createViewSqlNode*)node), rowTypeName); 654 | return (PyObject*)obj; 655 | } 656 | PyObject *Node_parse_createMaterializedViewSqlNode(gsp_node *node, Statement *stmt) { 657 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_createMaterializedViewSqlNode*)node), viewName); 658 | ADD_NODE(obj->dict, ((gsp_createMaterializedViewSqlNode*)node), selectSqlNode); 659 | ADD_NODE(obj->dict, ((gsp_createMaterializedViewSqlNode*)node), viewAliasClause); 660 | return (PyObject*)obj; 661 | } 662 | PyObject *Node_parse_createMaterializedViewLogSqlNode(gsp_node *node, Statement *stmt) { 663 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_createMaterializedViewLogSqlNode*)node), mvName); 664 | return (PyObject*)obj; 665 | } 666 | PyObject *Node_parse_createIndexSqlNode(gsp_node *node, Statement *stmt) { 667 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_INT(obj->dict, ((gsp_createIndexSqlNode*)node), indexType); 668 | ADD_NODE(obj->dict, ((gsp_createIndexSqlNode*)node), indexName); 669 | ADD_NODE(obj->dict, ((gsp_createIndexSqlNode*)node), tableName); 670 | ADD_NODE(obj->dict, ((gsp_createIndexSqlNode*)node), indexItemList); 671 | return (PyObject*)obj; 672 | } 673 | PyObject *Node_parse_commitSqlNode(gsp_node *node, Statement *stmt) { 674 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_commitSqlNode*)node), transName); 675 | return (PyObject*)obj; 676 | } 677 | PyObject *Node_parse_rollbackSqlNode(gsp_node *node, Statement *stmt) { 678 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_rollbackSqlNode*)node), transName); 679 | return (PyObject*)obj; 680 | } 681 | PyObject *Node_parse_saveTransSqlNode(gsp_node *node, Statement *stmt) { 682 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_saveTransSqlNode*)node), transName); 683 | return (PyObject*)obj; 684 | } 685 | PyObject *Node_parse_columnDefinition(gsp_node *node, Statement *stmt) { 686 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_columnDefinition*)node), columnName); 687 | ADD_NODE(obj->dict, ((gsp_columnDefinition*)node), datatype); 688 | ADD_NODE(obj->dict, ((gsp_columnDefinition*)node), constraints); 689 | ADD_NODE(obj->dict, ((gsp_columnDefinition*)node), defaultExpression); 690 | ADD_NODE(obj->dict, ((gsp_columnDefinition*)node), computedColumnExpression); 691 | ADD_INT(obj->dict, ((gsp_columnDefinition*)node), isNull); 692 | ADD_INT(obj->dict, ((gsp_columnDefinition*)node), isRowGuidCol); 693 | return (PyObject*)obj; 694 | } 695 | PyObject *Node_parse_tableElement(gsp_node *node, Statement *stmt) { 696 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_tableElement*)node), columnDefinition); 697 | ADD_NODE(obj->dict, ((gsp_tableElement*)node), constraint); 698 | return (PyObject*)obj; 699 | } 700 | PyObject *Node_parse_createTableSqlNode(gsp_node *node, Statement *stmt) { 701 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_createTableSqlNode*)node), table); 702 | ADD_NODE(obj->dict, ((gsp_createTableSqlNode*)node), oftable); 703 | ADD_NODE(obj->dict, ((gsp_createTableSqlNode*)node), tableElementList); 704 | ADD_NODE(obj->dict, ((gsp_createTableSqlNode*)node), columnList); 705 | ADD_NODE(obj->dict, ((gsp_createTableSqlNode*)node), columnName); 706 | ADD_NODE(obj->dict, ((gsp_createTableSqlNode*)node), subQueryNode); 707 | ADD_NODE(obj->dict, ((gsp_createTableSqlNode*)node), superTableName); 708 | ADD_NODE(obj->dict, ((gsp_createTableSqlNode*)node), ofTypeName); 709 | ADD_NODE(obj->dict, ((gsp_createTableSqlNode*)node), likeTableName); 710 | return (PyObject*)obj; 711 | } 712 | PyObject *Node_parse_returningClause(gsp_node *node, Statement *stmt) { 713 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_returningClause*)node), columnValueList); 714 | ADD_NODE(obj->dict, ((gsp_returningClause*)node), variableList); 715 | return (PyObject*)obj; 716 | } 717 | PyObject *Node_parse_isolationClause(gsp_node *node, Statement *stmt) { 718 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; return (PyObject*)obj; 719 | } 720 | PyObject *Node_parse_includeColumns(gsp_node *node, Statement *stmt) { 721 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_includeColumns*)node), columnList); 722 | return (PyObject*)obj; 723 | } 724 | PyObject *Node_parse_deleteSqlNode(gsp_node *node, Statement *stmt) { 725 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_TOKEN(obj->dict, ((gsp_deleteSqlNode*)node), deleteToken); 726 | ADD_NODE(obj->dict, ((gsp_deleteSqlNode*)node), cteList); 727 | ADD_NODE(obj->dict, ((gsp_deleteSqlNode*)node), whereCondition); 728 | ADD_NODE(obj->dict, ((gsp_deleteSqlNode*)node), returningClause); 729 | ADD_NODE(obj->dict, ((gsp_deleteSqlNode*)node), isolationClause); 730 | ADD_NODE(obj->dict, ((gsp_deleteSqlNode*)node), includeColumns); 731 | ADD_NODE(obj->dict, ((gsp_deleteSqlNode*)node), targetTableNode); 732 | ADD_NODE(obj->dict, ((gsp_deleteSqlNode*)node), topClause); 733 | ADD_NODE(obj->dict, ((gsp_deleteSqlNode*)node), outputClause); 734 | ADD_NODE(obj->dict, ((gsp_deleteSqlNode*)node), sourceTableList); 735 | ADD_NODE(obj->dict, ((gsp_deleteSqlNode*)node), targetTableList); 736 | ADD_NODE(obj->dict, ((gsp_deleteSqlNode*)node), limitClause); 737 | ADD_NODE(obj->dict, ((gsp_deleteSqlNode*)node), sortClause); 738 | return (PyObject*)obj; 739 | } 740 | PyObject *Node_parse_updateSqlNode(gsp_node *node, Statement *stmt) { 741 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_TOKEN(obj->dict, ((gsp_updateSqlNode*)node), updateToken); 742 | ADD_NODE(obj->dict, ((gsp_updateSqlNode*)node), cteList); 743 | ADD_NODE(obj->dict, ((gsp_updateSqlNode*)node), resultColumnList); 744 | ADD_NODE(obj->dict, ((gsp_updateSqlNode*)node), whereCondition); 745 | ADD_NODE(obj->dict, ((gsp_updateSqlNode*)node), returningClause); 746 | ADD_NODE(obj->dict, ((gsp_updateSqlNode*)node), isolationClause); 747 | ADD_NODE(obj->dict, ((gsp_updateSqlNode*)node), includeColumns); 748 | ADD_NODE(obj->dict, ((gsp_updateSqlNode*)node), targetTableNode); 749 | ADD_NODE(obj->dict, ((gsp_updateSqlNode*)node), topClause); 750 | ADD_NODE(obj->dict, ((gsp_updateSqlNode*)node), outputClause); 751 | ADD_NODE(obj->dict, ((gsp_updateSqlNode*)node), sourceTableList); 752 | ADD_NODE(obj->dict, ((gsp_updateSqlNode*)node), targetTableList); 753 | ADD_NODE(obj->dict, ((gsp_updateSqlNode*)node), limitClause); 754 | ADD_NODE(obj->dict, ((gsp_updateSqlNode*)node), sortClause); 755 | return (PyObject*)obj; 756 | } 757 | PyObject *Node_parse_multiTarget(gsp_node *node, Statement *stmt) { 758 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_multiTarget*)node), subQueryNode); 759 | ADD_NODE(obj->dict, ((gsp_multiTarget*)node), resultColumnList); 760 | return (PyObject*)obj; 761 | } 762 | PyObject *Node_parse_insertRest(gsp_node *node, Statement *stmt) { 763 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_INT(obj->dict, ((gsp_insertRest*)node), valueType); 764 | ADD_NODE(obj->dict, ((gsp_insertRest*)node), multiTargetList); 765 | ADD_NODE(obj->dict, ((gsp_insertRest*)node), subQueryNode); 766 | ADD_NODE(obj->dict, ((gsp_insertRest*)node), functionCall); 767 | ADD_NODE(obj->dict, ((gsp_insertRest*)node), recordName); 768 | ADD_NODE(obj->dict, ((gsp_insertRest*)node), updateTargetList); 769 | return (PyObject*)obj; 770 | } 771 | PyObject *Node_parse_insertValuesClause(gsp_node *node, Statement *stmt) { 772 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_insertValuesClause*)node), multiTargetList); 773 | return (PyObject*)obj; 774 | } 775 | PyObject *Node_parse_insertIntoValue(gsp_node *node, Statement *stmt) { 776 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_insertIntoValue*)node), fromTable); 777 | ADD_NODE(obj->dict, ((gsp_insertIntoValue*)node), columnList); 778 | ADD_NODE(obj->dict, ((gsp_insertIntoValue*)node), valuesClause); 779 | ADD_NODE(obj->dict, ((gsp_insertIntoValue*)node), table); 780 | return (PyObject*)obj; 781 | } 782 | PyObject *Node_parse_insertCondition(gsp_node *node, Statement *stmt) { 783 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_insertCondition*)node), condition); 784 | ADD_NODE(obj->dict, ((gsp_insertCondition*)node), insertIntoValues); 785 | return (PyObject*)obj; 786 | } 787 | PyObject *Node_parse_insertSqlNode(gsp_node *node, Statement *stmt) { 788 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_TOKEN(obj->dict, ((gsp_insertSqlNode*)node), insertToken); 789 | ADD_INT(obj->dict, ((gsp_insertSqlNode*)node), valueType); 790 | ADD_NODE(obj->dict, ((gsp_insertSqlNode*)node), cteList); 791 | ADD_NODE(obj->dict, ((gsp_insertSqlNode*)node), columnList); 792 | ADD_NODE(obj->dict, ((gsp_insertSqlNode*)node), insertIntoValues); 793 | ADD_NODE(obj->dict, ((gsp_insertSqlNode*)node), insertConditions); 794 | ADD_NODE(obj->dict, ((gsp_insertSqlNode*)node), returningClause); 795 | ADD_NODE(obj->dict, ((gsp_insertSqlNode*)node), isolationClause); 796 | ADD_NODE(obj->dict, ((gsp_insertSqlNode*)node), includeColumns); 797 | ADD_NODE(obj->dict, ((gsp_insertSqlNode*)node), targetTableNode); 798 | ADD_NODE(obj->dict, ((gsp_insertSqlNode*)node), insertRest); 799 | ADD_NODE(obj->dict, ((gsp_insertSqlNode*)node), subQueryNode); 800 | ADD_NODE(obj->dict, ((gsp_insertSqlNode*)node), topClause); 801 | ADD_NODE(obj->dict, ((gsp_insertSqlNode*)node), outputClause); 802 | ADD_NODE(obj->dict, ((gsp_insertSqlNode*)node), onDuplicateUpdateList); 803 | ADD_NODE(obj->dict, ((gsp_insertSqlNode*)node), multiTargetList); 804 | ADD_NODE(obj->dict, ((gsp_insertSqlNode*)node), recordName); 805 | ADD_NODE(obj->dict, ((gsp_insertSqlNode*)node), functionCall); 806 | return (PyObject*)obj; 807 | } 808 | PyObject *Node_parse_whereClause(gsp_node *node, Statement *stmt) { 809 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_whereClause*)node), condition); 810 | return (PyObject*)obj; 811 | } 812 | PyObject *Node_parse_joinExpr(gsp_node *node, Statement *stmt) { 813 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_INT(obj->dict, ((gsp_joinExpr*)node), jointype); 814 | ADD_INT(obj->dict, ((gsp_joinExpr*)node), original_jontype); 815 | ADD_NODE(obj->dict, ((gsp_joinExpr*)node), aliasClause); 816 | ADD_NODE(obj->dict, ((gsp_joinExpr*)node), leftOperand); 817 | ADD_NODE(obj->dict, ((gsp_joinExpr*)node), rightOperand); 818 | ADD_NODE(obj->dict, ((gsp_joinExpr*)node), onCondition); 819 | ADD_NODE(obj->dict, ((gsp_joinExpr*)node), usingColumns); 820 | return (PyObject*)obj; 821 | } 822 | PyObject *Node_parse_tableSamplePart(gsp_node *node, Statement *stmt) { 823 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; return (PyObject*)obj; 824 | } 825 | PyObject *Node_parse_tableSample(gsp_node *node, Statement *stmt) { 826 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; return (PyObject*)obj; 827 | } 828 | PyObject *Node_parse_pxGranule(gsp_node *node, Statement *stmt) { 829 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; return (PyObject*)obj; 830 | } 831 | PyObject *Node_parse_flashback(gsp_node *node, Statement *stmt) { 832 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; return (PyObject*)obj; 833 | } 834 | PyObject *Node_parse_forUpdate(gsp_node *node, Statement *stmt) { 835 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_forUpdate*)node), columnRefs); 836 | return (PyObject*)obj; 837 | } 838 | PyObject *Node_parse_groupingSetItem(gsp_node *node, Statement *stmt) { 839 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_groupingSetItem*)node), rollupCubeClause); 840 | ADD_NODE(obj->dict, ((gsp_groupingSetItem*)node), expressionItem); 841 | return (PyObject*)obj; 842 | } 843 | PyObject *Node_parse_groupingSet(gsp_node *node, Statement *stmt) { 844 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_groupingSet*)node), items); 845 | return (PyObject*)obj; 846 | } 847 | PyObject *Node_parse_rollupCube(gsp_node *node, Statement *stmt) { 848 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_rollupCube*)node), items); 849 | return (PyObject*)obj; 850 | } 851 | PyObject *Node_parse_gruopByItem(gsp_node *node, Statement *stmt) { 852 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_gruopByItem*)node), expr); 853 | ADD_NODE(obj->dict, ((gsp_gruopByItem*)node), rollupCube); 854 | ADD_NODE(obj->dict, ((gsp_gruopByItem*)node), groupingSet); 855 | ADD_NODE(obj->dict, ((gsp_gruopByItem*)node), aliasClause); 856 | return (PyObject*)obj; 857 | } 858 | PyObject *Node_parse_groupBy(gsp_node *node, Statement *stmt) { 859 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_TOKEN(obj->dict, ((gsp_groupBy*)node), stGroup); 860 | ADD_TOKEN(obj->dict, ((gsp_groupBy*)node), stBy); 861 | ADD_TOKEN(obj->dict, ((gsp_groupBy*)node), stHaving); 862 | ADD_NODE(obj->dict, ((gsp_groupBy*)node), havingClause); 863 | ADD_NODE(obj->dict, ((gsp_groupBy*)node), items); 864 | return (PyObject*)obj; 865 | } 866 | PyObject *Node_parse_selectDistinct(gsp_node *node, Statement *stmt) { 867 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_selectDistinct*)node), exprList); 868 | return (PyObject*)obj; 869 | } 870 | PyObject *Node_parse_topClause(gsp_node *node, Statement *stmt) { 871 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_INT(obj->dict, ((gsp_topClause*)node), bPercent); 872 | ADD_INT(obj->dict, ((gsp_topClause*)node), bWithTies); 873 | ADD_NODE(obj->dict, ((gsp_topClause*)node), expr); 874 | return (PyObject*)obj; 875 | } 876 | PyObject *Node_parse_hierarchical(gsp_node *node, Statement *stmt) { 877 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_hierarchical*)node), connectByClause); 878 | ADD_NODE(obj->dict, ((gsp_hierarchical*)node), startWithClause); 879 | return (PyObject*)obj; 880 | } 881 | PyObject *Node_parse_intoClause(gsp_node *node, Statement *stmt) { 882 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_intoClause*)node), exprList); 883 | return (PyObject*)obj; 884 | } 885 | PyObject *Node_parse_valueClause(gsp_node *node, Statement *stmt) { 886 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_valueClause*)node), valueList); 887 | ADD_NODE(obj->dict, ((gsp_valueClause*)node), nameList); 888 | return (PyObject*)obj; 889 | } 890 | PyObject *Node_parse_fetchFirstClause(gsp_node *node, Statement *stmt) { 891 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; return (PyObject*)obj; 892 | } 893 | PyObject *Node_parse_optimizeForClause(gsp_node *node, Statement *stmt) { 894 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; return (PyObject*)obj; 895 | } 896 | PyObject *Node_parse_valueRowItem(gsp_node *node, Statement *stmt) { 897 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_valueRowItem*)node), expr); 898 | ADD_NODE(obj->dict, ((gsp_valueRowItem*)node), exprList); 899 | return (PyObject*)obj; 900 | } 901 | PyObject *Node_parse_selectSqlNode(gsp_node *node, Statement *stmt) { 902 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_INT(obj->dict, ((gsp_selectSqlNode*)node), setOperator); 903 | ADD_NODE(obj->dict, ((gsp_selectSqlNode*)node), cteList); 904 | ADD_NODE(obj->dict, ((gsp_selectSqlNode*)node), valueClause); 905 | ADD_TOKEN(obj->dict, ((gsp_selectSqlNode*)node), selectToken); 906 | ADD_NODE(obj->dict, ((gsp_selectSqlNode*)node), selectDistinct); 907 | ADD_NODE(obj->dict, ((gsp_selectSqlNode*)node), resultColumnList); 908 | ADD_NODE(obj->dict, ((gsp_selectSqlNode*)node), intoClause); 909 | ADD_NODE(obj->dict, ((gsp_selectSqlNode*)node), whereCondition); 910 | ADD_NODE(obj->dict, ((gsp_selectSqlNode*)node), hierarchicalClause); 911 | ADD_NODE(obj->dict, ((gsp_selectSqlNode*)node), groupByClause); 912 | ADD_NODE(obj->dict, ((gsp_selectSqlNode*)node), orderbyClause); 913 | ADD_NODE(obj->dict, ((gsp_selectSqlNode*)node), forupdateClause); 914 | ADD_NODE(obj->dict, ((gsp_selectSqlNode*)node), fetchFirstClause); 915 | ADD_NODE(obj->dict, ((gsp_selectSqlNode*)node), optimizeForClause); 916 | ADD_NODE(obj->dict, ((gsp_selectSqlNode*)node), isolationClause); 917 | ADD_NODE(obj->dict, ((gsp_selectSqlNode*)node), computeClause); 918 | ADD_NODE(obj->dict, ((gsp_selectSqlNode*)node), topClause); 919 | ADD_NODE(obj->dict, ((gsp_selectSqlNode*)node), intoTableClause); 920 | ADD_NODE(obj->dict, ((gsp_selectSqlNode*)node), limitClause); 921 | ADD_NODE(obj->dict, ((gsp_selectSqlNode*)node), lockingClause); 922 | ADD_NODE(obj->dict, ((gsp_selectSqlNode*)node), windowClause); 923 | ADD_NODE(obj->dict, ((gsp_selectSqlNode*)node), withClauses); 924 | ADD_NODE(obj->dict, ((gsp_selectSqlNode*)node), qualifyClause); 925 | ADD_NODE(obj->dict, ((gsp_selectSqlNode*)node), sampleClause); 926 | ADD_NODE(obj->dict, ((gsp_selectSqlNode*)node), expandOnClause); 927 | ADD_NODE(obj->dict, ((gsp_selectSqlNode*)node), leftNode); 928 | ADD_NODE(obj->dict, ((gsp_selectSqlNode*)node), rightNode); 929 | ADD_NODE(obj->dict, ((gsp_selectSqlNode*)node), fromTableList); 930 | return (PyObject*)obj; 931 | } 932 | PyObject *Node_parse_cte(gsp_node *node, Statement *stmt) { 933 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_cte*)node), tableName); 934 | ADD_NODE(obj->dict, ((gsp_cte*)node), selectSqlNode); 935 | ADD_NODE(obj->dict, ((gsp_cte*)node), insertSqlNode); 936 | ADD_NODE(obj->dict, ((gsp_cte*)node), updateSqlNode); 937 | ADD_NODE(obj->dict, ((gsp_cte*)node), deleteSqlNode); 938 | ADD_NODE(obj->dict, ((gsp_cte*)node), columnList); 939 | return (PyObject*)obj; 940 | } 941 | PyObject *Node_parse_commentSqlNode(gsp_node *node, Statement *stmt) { 942 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_INT(obj->dict, ((gsp_commentSqlNode*)node), dbObjType); 943 | ADD_NODE(obj->dict, ((gsp_commentSqlNode*)node), objectName); 944 | ADD_NODE(obj->dict, ((gsp_commentSqlNode*)node), message); 945 | return (PyObject*)obj; 946 | } 947 | PyObject *Node_parse_callSpec(gsp_node *node, Statement *stmt) { 948 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_callSpec*)node), declaration); 949 | return (PyObject*)obj; 950 | } 951 | PyObject *Node_parse_returnSqlNode(gsp_node *node, Statement *stmt) { 952 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_returnSqlNode*)node), expr); 953 | ADD_NODE(obj->dict, ((gsp_returnSqlNode*)node), subQueryNode); 954 | return (PyObject*)obj; 955 | } 956 | PyObject *Node_parse_continueSqlNode(gsp_node *node, Statement *stmt) { 957 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; return (PyObject*)obj; 958 | } 959 | PyObject *Node_parse_breakSqlNode(gsp_node *node, Statement *stmt) { 960 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; return (PyObject*)obj; 961 | } 962 | PyObject *Node_parse_grantSqlNode(gsp_node *node, Statement *stmt) { 963 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_grantSqlNode*)node), nameList); 964 | return (PyObject*)obj; 965 | } 966 | PyObject *Node_parse_executeSqlNode(gsp_node *node, Statement *stmt) { 967 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_executeSqlNode*)node), moduleName); 968 | ADD_NODE(obj->dict, ((gsp_executeSqlNode*)node), paramList); 969 | return (PyObject*)obj; 970 | } 971 | PyObject *Node_parse_dropRoleSqlNode(gsp_node *node, Statement *stmt) { 972 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_dropRoleSqlNode*)node), roleNameList); 973 | return (PyObject*)obj; 974 | } 975 | PyObject *Node_parse_dropTriggerSqlNode(gsp_node *node, Statement *stmt) { 976 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_dropTriggerSqlNode*)node), triggerName); 977 | ADD_NODE(obj->dict, ((gsp_dropTriggerSqlNode*)node), tableName); 978 | return (PyObject*)obj; 979 | } 980 | PyObject *Node_parse_lockTableSqlNode(gsp_node *node, Statement *stmt) { 981 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; return (PyObject*)obj; 982 | } 983 | PyObject *Node_parse_revokeSqlNode(gsp_node *node, Statement *stmt) { 984 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; return (PyObject*)obj; 985 | } 986 | PyObject *Node_parse_fetchSqlNode(gsp_node *node, Statement *stmt) { 987 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_fetchSqlNode*)node), cursorName); 988 | ADD_NODE(obj->dict, ((gsp_fetchSqlNode*)node), variableNames); 989 | return (PyObject*)obj; 990 | } 991 | PyObject *Node_parse_openSqlNode(gsp_node *node, Statement *stmt) { 992 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_openSqlNode*)node), cursorName); 993 | ADD_NODE(obj->dict, ((gsp_openSqlNode*)node), nameList); 994 | return (PyObject*)obj; 995 | } 996 | PyObject *Node_parse_closeSqlNode(gsp_node *node, Statement *stmt) { 997 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_closeSqlNode*)node), cursorName); 998 | return (PyObject*)obj; 999 | } 1000 | PyObject *Node_parse_iterateSqlNode(gsp_node *node, Statement *stmt) { 1001 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_iterateSqlNode*)node), cursorName); 1002 | return (PyObject*)obj; 1003 | } 1004 | PyObject *Node_parse_leaveSqlNode(gsp_node *node, Statement *stmt) { 1005 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_leaveSqlNode*)node), cursorName); 1006 | return (PyObject*)obj; 1007 | } 1008 | PyObject *Node_parse_createFunctionSqlNode(gsp_node *node, Statement *stmt) { 1009 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_INT(obj->dict, ((gsp_createFunctionSqlNode*)node), kind); 1010 | ADD_NODE(obj->dict, ((gsp_createFunctionSqlNode*)node), functionName); 1011 | ADD_NODE(obj->dict, ((gsp_createFunctionSqlNode*)node), parameters); 1012 | ADD_NODE(obj->dict, ((gsp_createFunctionSqlNode*)node), returnDataType); 1013 | ADD_NODE(obj->dict, ((gsp_createFunctionSqlNode*)node), declareStmts); 1014 | ADD_NODE(obj->dict, ((gsp_createFunctionSqlNode*)node), stmts); 1015 | ADD_NODE(obj->dict, ((gsp_createFunctionSqlNode*)node), exceptionClause); 1016 | ADD_NODE(obj->dict, ((gsp_createFunctionSqlNode*)node), returnSqlNode); 1017 | ADD_NODE(obj->dict, ((gsp_createFunctionSqlNode*)node), compoundSqlNode); 1018 | ADD_NODE(obj->dict, ((gsp_createFunctionSqlNode*)node), callSpec); 1019 | ADD_NODE(obj->dict, ((gsp_createFunctionSqlNode*)node), blockSqlNode); 1020 | ADD_NODE(obj->dict, ((gsp_createFunctionSqlNode*)node), stmtSqlNode); 1021 | return (PyObject*)obj; 1022 | } 1023 | PyObject *Node_parse_parameterDeclaration(gsp_node *node, Statement *stmt) { 1024 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_parameterDeclaration*)node), parameterName); 1025 | ADD_NODE(obj->dict, ((gsp_parameterDeclaration*)node), dataType); 1026 | ADD_NODE(obj->dict, ((gsp_parameterDeclaration*)node), defaultValue); 1027 | ADD_INT(obj->dict, ((gsp_parameterDeclaration*)node), isVarying); 1028 | ADD_NODE(obj->dict, ((gsp_parameterDeclaration*)node), varyPrecision); 1029 | ADD_INT(obj->dict, ((gsp_parameterDeclaration*)node), isNotNull); 1030 | ADD_INT(obj->dict, ((gsp_parameterDeclaration*)node), mode); 1031 | ADD_INT(obj->dict, ((gsp_parameterDeclaration*)node), howtoSetValue); 1032 | return (PyObject*)obj; 1033 | } 1034 | PyObject *Node_parse_createProcedureSqlNode(gsp_node *node, Statement *stmt) { 1035 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_INT(obj->dict, ((gsp_createProcedureSqlNode*)node), kind); 1036 | ADD_NODE(obj->dict, ((gsp_createProcedureSqlNode*)node), procedureName); 1037 | ADD_NODE(obj->dict, ((gsp_createProcedureSqlNode*)node), parameters); 1038 | ADD_NODE(obj->dict, ((gsp_createProcedureSqlNode*)node), declareStmts); 1039 | ADD_NODE(obj->dict, ((gsp_createProcedureSqlNode*)node), innerStmts); 1040 | ADD_NODE(obj->dict, ((gsp_createProcedureSqlNode*)node), stmts); 1041 | ADD_NODE(obj->dict, ((gsp_createProcedureSqlNode*)node), exceptionClause); 1042 | ADD_NODE(obj->dict, ((gsp_createProcedureSqlNode*)node), callSpec); 1043 | ADD_NODE(obj->dict, ((gsp_createProcedureSqlNode*)node), blockSqlNode); 1044 | ADD_NODE(obj->dict, ((gsp_createProcedureSqlNode*)node), stmtSqlNode); 1045 | return (PyObject*)obj; 1046 | } 1047 | PyObject *Node_parse_exceptionClause(gsp_node *node, Statement *stmt) { 1048 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_exceptionClause*)node), Handlers); 1049 | return (PyObject*)obj; 1050 | } 1051 | PyObject *Node_parse_blockSqlNode(gsp_node *node, Statement *stmt) { 1052 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_blockSqlNode*)node), stmts); 1053 | ADD_NODE(obj->dict, ((gsp_blockSqlNode*)node), exceptionClause); 1054 | ADD_NODE(obj->dict, ((gsp_blockSqlNode*)node), declareStmts); 1055 | return (PyObject*)obj; 1056 | } 1057 | PyObject *Node_parse_arrayAccess(gsp_node *node, Statement *stmt) { 1058 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_arrayAccess*)node), arrayName); 1059 | ADD_NODE(obj->dict, ((gsp_arrayAccess*)node), index1); 1060 | ADD_NODE(obj->dict, ((gsp_arrayAccess*)node), index2); 1061 | ADD_NODE(obj->dict, ((gsp_arrayAccess*)node), index3); 1062 | ADD_NODE(obj->dict, ((gsp_arrayAccess*)node), propertyName); 1063 | return (PyObject*)obj; 1064 | } 1065 | PyObject *Node_parse_declareVariable(gsp_node *node, Statement *stmt) { 1066 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_declareVariable*)node), varName); 1067 | ADD_NODE(obj->dict, ((gsp_declareVariable*)node), varDatatype); 1068 | ADD_NODE(obj->dict, ((gsp_declareVariable*)node), defaultValue); 1069 | ADD_NODE(obj->dict, ((gsp_declareVariable*)node), tableTypeDefinitions); 1070 | ADD_INT(obj->dict, ((gsp_declareVariable*)node), variableType); 1071 | return (PyObject*)obj; 1072 | } 1073 | PyObject *Node_parse_declareSqlNode(gsp_node *node, Statement *stmt) { 1074 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_INT(obj->dict, ((gsp_declareSqlNode*)node), declareType); 1075 | ADD_NODE(obj->dict, ((gsp_declareSqlNode*)node), vars); 1076 | ADD_NODE(obj->dict, ((gsp_declareSqlNode*)node), varType); 1077 | ADD_INT(obj->dict, ((gsp_declareSqlNode*)node), howtoSetValue); 1078 | ADD_NODE(obj->dict, ((gsp_declareSqlNode*)node), defaultValue); 1079 | ADD_NODE(obj->dict, ((gsp_declareSqlNode*)node), conditionName); 1080 | ADD_NODE(obj->dict, ((gsp_declareSqlNode*)node), cursorName); 1081 | ADD_NODE(obj->dict, ((gsp_declareSqlNode*)node), subQueryNode); 1082 | ADD_NODE(obj->dict, ((gsp_declareSqlNode*)node), stmt); 1083 | return (PyObject*)obj; 1084 | } 1085 | PyObject *Node_parse_createTriggerUpdateColumn(gsp_node *node, Statement *stmt) { 1086 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_createTriggerUpdateColumn*)node), columnName); 1087 | return (PyObject*)obj; 1088 | } 1089 | PyObject *Node_parse_ifSqlNode(gsp_node *node, Statement *stmt) { 1090 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_ifSqlNode*)node), condition); 1091 | ADD_NODE(obj->dict, ((gsp_ifSqlNode*)node), stmts); 1092 | ADD_NODE(obj->dict, ((gsp_ifSqlNode*)node), elseStmts); 1093 | ADD_NODE(obj->dict, ((gsp_ifSqlNode*)node), elseifList); 1094 | ADD_NODE(obj->dict, ((gsp_ifSqlNode*)node), stmt); 1095 | ADD_NODE(obj->dict, ((gsp_ifSqlNode*)node), elseStmt); 1096 | ADD_NODE(obj->dict, ((gsp_ifSqlNode*)node), updateColumnList); 1097 | return (PyObject*)obj; 1098 | } 1099 | PyObject *Node_parse_elseIfSqlNode(gsp_node *node, Statement *stmt) { 1100 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_elseIfSqlNode*)node), condition); 1101 | ADD_NODE(obj->dict, ((gsp_elseIfSqlNode*)node), stmts); 1102 | return (PyObject*)obj; 1103 | } 1104 | PyObject *Node_parse_whileSqlNode(gsp_node *node, Statement *stmt) { 1105 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_whileSqlNode*)node), condition); 1106 | ADD_NODE(obj->dict, ((gsp_whileSqlNode*)node), stmt); 1107 | ADD_NODE(obj->dict, ((gsp_whileSqlNode*)node), stmts); 1108 | return (PyObject*)obj; 1109 | } 1110 | PyObject *Node_parse_repeatSqlNode(gsp_node *node, Statement *stmt) { 1111 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_repeatSqlNode*)node), condition); 1112 | ADD_NODE(obj->dict, ((gsp_repeatSqlNode*)node), stmts); 1113 | return (PyObject*)obj; 1114 | } 1115 | PyObject *Node_parse_loopSqlNode(gsp_node *node, Statement *stmt) { 1116 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_loopSqlNode*)node), stmts); 1117 | return (PyObject*)obj; 1118 | } 1119 | PyObject *Node_parse_unknownStatement(gsp_node *node, Statement *stmt) { 1120 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; return (PyObject*)obj; 1121 | } 1122 | PyObject *Node_parse_createTriggerSqlNode(gsp_node *node, Statement *stmt) { 1123 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_INT(obj->dict, ((gsp_createTriggerSqlNode*)node), fireMode); 1124 | ADD_NODE(obj->dict, ((gsp_createTriggerSqlNode*)node), triggerName); 1125 | ADD_NODE(obj->dict, ((gsp_createTriggerSqlNode*)node), tableName); 1126 | ADD_NODE(obj->dict, ((gsp_createTriggerSqlNode*)node), whenCondition); 1127 | ADD_NODE(obj->dict, ((gsp_createTriggerSqlNode*)node), triggerEvent); 1128 | ADD_NODE(obj->dict, ((gsp_createTriggerSqlNode*)node), triggerAction); 1129 | ADD_NODE(obj->dict, ((gsp_createTriggerSqlNode*)node), stmt); 1130 | ADD_NODE(obj->dict, ((gsp_createTriggerSqlNode*)node), stmts); 1131 | ADD_NODE(obj->dict, ((gsp_createTriggerSqlNode*)node), blockSqlNode); 1132 | ADD_NODE(obj->dict, ((gsp_createTriggerSqlNode*)node), stmtSqlNode); 1133 | return (PyObject*)obj; 1134 | } 1135 | PyObject *Node_parse_exceptionHandler(gsp_node *node, Statement *stmt) { 1136 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_exceptionHandler*)node), exceptionNames); 1137 | ADD_NODE(obj->dict, ((gsp_exceptionHandler*)node), stmts); 1138 | return (PyObject*)obj; 1139 | } 1140 | PyObject *Node_parse_pivotClause(gsp_node *node, Statement *stmt) { 1141 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_pivotClause*)node), aggregationFunction); 1142 | ADD_NODE(obj->dict, ((gsp_pivotClause*)node), privotColumn); 1143 | ADD_NODE(obj->dict, ((gsp_pivotClause*)node), privotColumnList); 1144 | ADD_NODE(obj->dict, ((gsp_pivotClause*)node), inResultList); 1145 | ADD_NODE(obj->dict, ((gsp_pivotClause*)node), aliasClause); 1146 | return (PyObject*)obj; 1147 | } 1148 | PyObject *Node_parse_unPivotClause(gsp_node *node, Statement *stmt) { 1149 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_unPivotClause*)node), aggregationFunction); 1150 | ADD_NODE(obj->dict, ((gsp_unPivotClause*)node), valueColumn); 1151 | ADD_NODE(obj->dict, ((gsp_unPivotClause*)node), privotColumn); 1152 | ADD_NODE(obj->dict, ((gsp_unPivotClause*)node), privotColumnList); 1153 | ADD_NODE(obj->dict, ((gsp_unPivotClause*)node), inResultList); 1154 | ADD_NODE(obj->dict, ((gsp_unPivotClause*)node), aliasClause); 1155 | return (PyObject*)obj; 1156 | } 1157 | PyObject *Node_parse_renameColumnSqlNode(gsp_node *node, Statement *stmt) { 1158 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_renameColumnSqlNode*)node), columnName); 1159 | ADD_NODE(obj->dict, ((gsp_renameColumnSqlNode*)node), newColumnName); 1160 | return (PyObject*)obj; 1161 | } 1162 | PyObject *Node_parse_renameSequenceSqlNode(gsp_node *node, Statement *stmt) { 1163 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_renameSequenceSqlNode*)node), sequenceName); 1164 | ADD_NODE(obj->dict, ((gsp_renameSequenceSqlNode*)node), newSequenceName); 1165 | return (PyObject*)obj; 1166 | } 1167 | PyObject *Node_parse_renameTableSqlNode(gsp_node *node, Statement *stmt) { 1168 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_renameTableSqlNode*)node), tableName); 1169 | ADD_NODE(obj->dict, ((gsp_renameTableSqlNode*)node), newTableName); 1170 | return (PyObject*)obj; 1171 | } 1172 | PyObject *Node_parse_renameIndexSqlNode(gsp_node *node, Statement *stmt) { 1173 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_renameIndexSqlNode*)node), indexName); 1174 | ADD_NODE(obj->dict, ((gsp_renameIndexSqlNode*)node), newIndexName); 1175 | return (PyObject*)obj; 1176 | } 1177 | PyObject *Node_parse_dropSequenceSqlNode(gsp_node *node, Statement *stmt) { 1178 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_dropSequenceSqlNode*)node), sequenceName); 1179 | return (PyObject*)obj; 1180 | } 1181 | PyObject *Node_parse_dropSynonymSqlNode(gsp_node *node, Statement *stmt) { 1182 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_dropSynonymSqlNode*)node), synonymName); 1183 | return (PyObject*)obj; 1184 | } 1185 | PyObject *Node_parse_dropRowTypeSqlNode(gsp_node *node, Statement *stmt) { 1186 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_dropRowTypeSqlNode*)node), rowTypeName); 1187 | return (PyObject*)obj; 1188 | } 1189 | PyObject *Node_parse_alterIndexSqlNode(gsp_node *node, Statement *stmt) { 1190 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_alterIndexSqlNode*)node), indexName); 1191 | return (PyObject*)obj; 1192 | } 1193 | PyObject *Node_parse_alterSequenceSqlNode(gsp_node *node, Statement *stmt) { 1194 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_alterSequenceSqlNode*)node), sequenceName); 1195 | return (PyObject*)obj; 1196 | } 1197 | PyObject *Node_parse_alterViewSqlNode(gsp_node *node, Statement *stmt) { 1198 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_alterViewSqlNode*)node), viewName); 1199 | return (PyObject*)obj; 1200 | } 1201 | PyObject *Node_parse_intoTableClause(gsp_node *node, Statement *stmt) { 1202 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_intoTableClause*)node), tableName); 1203 | return (PyObject*)obj; 1204 | } 1205 | PyObject *Node_parse_informixOuterClause(gsp_node *node, Statement *stmt) { 1206 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_informixOuterClause*)node), fromTable); 1207 | ADD_NODE(obj->dict, ((gsp_informixOuterClause*)node), fromTableList); 1208 | return (PyObject*)obj; 1209 | } 1210 | PyObject *Node_parse_createRowTypeSqlNode(gsp_node *node, Statement *stmt) { 1211 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_createRowTypeSqlNode*)node), rowTypeName); 1212 | ADD_NODE(obj->dict, ((gsp_createRowTypeSqlNode*)node), superTableName); 1213 | ADD_NODE(obj->dict, ((gsp_createRowTypeSqlNode*)node), columnDefList); 1214 | return (PyObject*)obj; 1215 | } 1216 | PyObject *Node_parse_subscripts(gsp_node *node, Statement *stmt) { 1217 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_subscripts*)node), first); 1218 | ADD_NODE(obj->dict, ((gsp_subscripts*)node), last); 1219 | return (PyObject*)obj; 1220 | } 1221 | PyObject *Node_parse_limitClause(gsp_node *node, Statement *stmt) { 1222 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_limitClause*)node), offset); 1223 | ADD_NODE(obj->dict, ((gsp_limitClause*)node), rowCount); 1224 | ADD_NODE(obj->dict, ((gsp_limitClause*)node), limitValue); 1225 | return (PyObject*)obj; 1226 | } 1227 | PyObject *Node_parse_callSqlNode(gsp_node *node, Statement *stmt) { 1228 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_callSqlNode*)node), functionName); 1229 | ADD_NODE(obj->dict, ((gsp_callSqlNode*)node), args); 1230 | return (PyObject*)obj; 1231 | } 1232 | PyObject *Node_parse_createDatabaseSqlNode(gsp_node *node, Statement *stmt) { 1233 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_createDatabaseSqlNode*)node), databaseName); 1234 | return (PyObject*)obj; 1235 | } 1236 | PyObject *Node_parse_lockingClause(gsp_node *node, Statement *stmt) { 1237 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_lockingClause*)node), lockedObjects); 1238 | return (PyObject*)obj; 1239 | } 1240 | PyObject *Node_parse_windowClause(gsp_node *node, Statement *stmt) { 1241 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_windowClause*)node), windownsDefs); 1242 | return (PyObject*)obj; 1243 | } 1244 | PyObject *Node_parse_partitionClause(gsp_node *node, Statement *stmt) { 1245 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_partitionClause*)node), exprList); 1246 | return (PyObject*)obj; 1247 | } 1248 | PyObject *Node_parse_windowDef(gsp_node *node, Statement *stmt) { 1249 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_windowDef*)node), referenceName); 1250 | ADD_NODE(obj->dict, ((gsp_windowDef*)node), partitionClause); 1251 | ADD_NODE(obj->dict, ((gsp_windowDef*)node), sortClause); 1252 | ADD_NODE(obj->dict, ((gsp_windowDef*)node), frameClause); 1253 | ADD_NODE(obj->dict, ((gsp_windowDef*)node), startOffset); 1254 | ADD_NODE(obj->dict, ((gsp_windowDef*)node), endOffset); 1255 | ADD_NODE(obj->dict, ((gsp_windowDef*)node), windowName); 1256 | return (PyObject*)obj; 1257 | } 1258 | PyObject *Node_parse_indices(gsp_node *node, Statement *stmt) { 1259 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_indices*)node), attributeName); 1260 | ADD_NODE(obj->dict, ((gsp_indices*)node), lowerSubscript); 1261 | ADD_NODE(obj->dict, ((gsp_indices*)node), upperSubscript); 1262 | return (PyObject*)obj; 1263 | } 1264 | PyObject *Node_parse_collectStatisticsSqlNode(gsp_node *node, Statement *stmt) { 1265 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_collectStatisticsSqlNode*)node), tableName); 1266 | ADD_NODE(obj->dict, ((gsp_collectStatisticsSqlNode*)node), indexName); 1267 | ADD_NODE(obj->dict, ((gsp_collectStatisticsSqlNode*)node), columnName); 1268 | ADD_NODE(obj->dict, ((gsp_collectStatisticsSqlNode*)node), columnList); 1269 | return (PyObject*)obj; 1270 | } 1271 | PyObject *Node_parse_teradataWithClause(gsp_node *node, Statement *stmt) { 1272 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_teradataWithClause*)node), exprList); 1273 | ADD_NODE(obj->dict, ((gsp_teradataWithClause*)node), byList); 1274 | return (PyObject*)obj; 1275 | } 1276 | PyObject *Node_parse_qualifyClause(gsp_node *node, Statement *stmt) { 1277 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_qualifyClause*)node), expr); 1278 | return (PyObject*)obj; 1279 | } 1280 | PyObject *Node_parse_sampleClause(gsp_node *node, Statement *stmt) { 1281 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_sampleClause*)node), countFractionDescriptionList); 1282 | ADD_NODE(obj->dict, ((gsp_sampleClause*)node), whenThenList); 1283 | return (PyObject*)obj; 1284 | } 1285 | PyObject *Node_parse_expandOnClause(gsp_node *node, Statement *stmt) { 1286 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_expandOnClause*)node), expr); 1287 | ADD_NODE(obj->dict, ((gsp_expandOnClause*)node), columnAlias); 1288 | ADD_NODE(obj->dict, ((gsp_expandOnClause*)node), periodExpr); 1289 | return (PyObject*)obj; 1290 | } 1291 | PyObject *Node_parse_datatypeAttribute(gsp_node *node, Statement *stmt) { 1292 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; return (PyObject*)obj; 1293 | } 1294 | PyObject *Node_parse_newVariantTypeArgument(gsp_node *node, Statement *stmt) { 1295 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_newVariantTypeArgument*)node), expr); 1296 | ADD_NODE(obj->dict, ((gsp_newVariantTypeArgument*)node), aliasName); 1297 | return (PyObject*)obj; 1298 | } 1299 | PyObject *Node_parse_outputFormatPhrase(gsp_node *node, Statement *stmt) { 1300 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_outputFormatPhrase*)node), dataTypeName); 1301 | ADD_NODE(obj->dict, ((gsp_outputFormatPhrase*)node), datatypeAttribute); 1302 | return (PyObject*)obj; 1303 | } 1304 | PyObject *Node_parse_plsqlCreateTypeBody(gsp_node *node, Statement *stmt) { 1305 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_plsqlCreateTypeBody*)node), typeName); 1306 | ADD_NODE(obj->dict, ((gsp_plsqlCreateTypeBody*)node), stmts); 1307 | return (PyObject*)obj; 1308 | } 1309 | PyObject *Node_parse_typeAttribute(gsp_node *node, Statement *stmt) { 1310 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_typeAttribute*)node), attributeName); 1311 | ADD_NODE(obj->dict, ((gsp_typeAttribute*)node), datatype); 1312 | return (PyObject*)obj; 1313 | } 1314 | PyObject *Node_parse_plsqlCreateType(gsp_node *node, Statement *stmt) { 1315 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_plsqlCreateType*)node), typeName); 1316 | ADD_NODE(obj->dict, ((gsp_plsqlCreateType*)node), attributes); 1317 | return (PyObject*)obj; 1318 | } 1319 | PyObject *Node_parse_dmlEventClause(gsp_node *node, Statement *stmt) { 1320 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_dmlEventClause*)node), tableName); 1321 | ADD_NODE(obj->dict, ((gsp_dmlEventClause*)node), dml_event_items); 1322 | return (PyObject*)obj; 1323 | } 1324 | PyObject *Node_parse_nonDmlTriggerClause(gsp_node *node, Statement *stmt) { 1325 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_nonDmlTriggerClause*)node), schemaName); 1326 | ADD_INT(obj->dict, ((gsp_nonDmlTriggerClause*)node), fireMode); 1327 | ADD_INT(obj->dict, ((gsp_nonDmlTriggerClause*)node), isSchema); 1328 | ADD_INT(obj->dict, ((gsp_nonDmlTriggerClause*)node), isDatabase); 1329 | ADD_NODE(obj->dict, ((gsp_nonDmlTriggerClause*)node), ddl_event_list); 1330 | ADD_NODE(obj->dict, ((gsp_nonDmlTriggerClause*)node), database_event_list); 1331 | return (PyObject*)obj; 1332 | } 1333 | PyObject *Node_parse_compoundDmlTriggerClause(gsp_node *node, Statement *stmt) { 1334 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_compoundDmlTriggerClause*)node), dmlEventClause); 1335 | return (PyObject*)obj; 1336 | } 1337 | PyObject *Node_parse_simpleDmlTriggerClause(gsp_node *node, Statement *stmt) { 1338 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_INT(obj->dict, ((gsp_simpleDmlTriggerClause*)node), fireMode); 1339 | ADD_NODE(obj->dict, ((gsp_simpleDmlTriggerClause*)node), dmlEventClause); 1340 | return (PyObject*)obj; 1341 | } 1342 | PyObject *Node_parse_createPackageSqlNode(gsp_node *node, Statement *stmt) { 1343 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_createPackageSqlNode*)node), packageName); 1344 | ADD_INT(obj->dict, ((gsp_createPackageSqlNode*)node), kind); 1345 | ADD_NODE(obj->dict, ((gsp_createPackageSqlNode*)node), definitions_or_declarations); 1346 | ADD_NODE(obj->dict, ((gsp_createPackageSqlNode*)node), stmts); 1347 | ADD_NODE(obj->dict, ((gsp_createPackageSqlNode*)node), exceptionClause); 1348 | ADD_NODE(obj->dict, ((gsp_createPackageSqlNode*)node), declareStatements); 1349 | ADD_NODE(obj->dict, ((gsp_createPackageSqlNode*)node), bodyStatements); 1350 | return (PyObject*)obj; 1351 | } 1352 | PyObject *Node_parse_plsqlVarDeclStmt(gsp_node *node, Statement *stmt) { 1353 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_INT(obj->dict, ((gsp_plsqlVarDeclStmt*)node), whatDeclared); 1354 | ADD_NODE(obj->dict, ((gsp_plsqlVarDeclStmt*)node), exception_name); 1355 | ADD_NODE(obj->dict, ((gsp_plsqlVarDeclStmt*)node), error_number); 1356 | ADD_NODE(obj->dict, ((gsp_plsqlVarDeclStmt*)node), elementName); 1357 | ADD_NODE(obj->dict, ((gsp_plsqlVarDeclStmt*)node), dataType); 1358 | ADD_NODE(obj->dict, ((gsp_plsqlVarDeclStmt*)node), value); 1359 | ADD_INT(obj->dict, ((gsp_plsqlVarDeclStmt*)node), isNotNull); 1360 | ADD_INT(obj->dict, ((gsp_plsqlVarDeclStmt*)node), howtoSetValue); 1361 | return (PyObject*)obj; 1362 | } 1363 | PyObject *Node_parse_plsqlRaiseStmt(gsp_node *node, Statement *stmt) { 1364 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_plsqlRaiseStmt*)node), exceptionName); 1365 | return (PyObject*)obj; 1366 | } 1367 | PyObject *Node_parse_plsqlLoopStmt(gsp_node *node, Statement *stmt) { 1368 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_plsqlLoopStmt*)node), stmts); 1369 | ADD_NODE(obj->dict, ((gsp_plsqlLoopStmt*)node), condition); 1370 | ADD_NODE(obj->dict, ((gsp_plsqlLoopStmt*)node), indexName); 1371 | ADD_NODE(obj->dict, ((gsp_plsqlLoopStmt*)node), cursorName); 1372 | ADD_NODE(obj->dict, ((gsp_plsqlLoopStmt*)node), lower_bound); 1373 | ADD_NODE(obj->dict, ((gsp_plsqlLoopStmt*)node), upper_bound); 1374 | ADD_NODE(obj->dict, ((gsp_plsqlLoopStmt*)node), cursorParameterNames); 1375 | return (PyObject*)obj; 1376 | } 1377 | PyObject *Node_parse_plsqlCaseStmt(gsp_node *node, Statement *stmt) { 1378 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_plsqlCaseStmt*)node), caseExpr); 1379 | return (PyObject*)obj; 1380 | } 1381 | PyObject *Node_parse_plsqlForallStmt(gsp_node *node, Statement *stmt) { 1382 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_plsqlForallStmt*)node), indexName); 1383 | ADD_NODE(obj->dict, ((gsp_plsqlForallStmt*)node), stmt); 1384 | return (PyObject*)obj; 1385 | } 1386 | PyObject *Node_parse_plsqlElsifStmt(gsp_node *node, Statement *stmt) { 1387 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_plsqlElsifStmt*)node), condition); 1388 | ADD_NODE(obj->dict, ((gsp_plsqlElsifStmt*)node), thenStmts); 1389 | return (PyObject*)obj; 1390 | } 1391 | PyObject *Node_parse_plsqlIfStmt(gsp_node *node, Statement *stmt) { 1392 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_plsqlIfStmt*)node), condition); 1393 | ADD_NODE(obj->dict, ((gsp_plsqlIfStmt*)node), thenStmts); 1394 | ADD_NODE(obj->dict, ((gsp_plsqlIfStmt*)node), elseStmts); 1395 | ADD_NODE(obj->dict, ((gsp_plsqlIfStmt*)node), elsifStmts); 1396 | return (PyObject*)obj; 1397 | } 1398 | PyObject *Node_parse_plsqlGotoStmt(gsp_node *node, Statement *stmt) { 1399 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_plsqlGotoStmt*)node), gotolabelName); 1400 | return (PyObject*)obj; 1401 | } 1402 | PyObject *Node_parse_plsqlExitStmt(gsp_node *node, Statement *stmt) { 1403 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_plsqlExitStmt*)node), whenCondition); 1404 | ADD_NODE(obj->dict, ((gsp_plsqlExitStmt*)node), exitlabelName); 1405 | return (PyObject*)obj; 1406 | } 1407 | PyObject *Node_parse_plsqlAssignStmt(gsp_node *node, Statement *stmt) { 1408 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_plsqlAssignStmt*)node), left); 1409 | ADD_NODE(obj->dict, ((gsp_plsqlAssignStmt*)node), right); 1410 | return (PyObject*)obj; 1411 | } 1412 | PyObject *Node_parse_plsqlCursorDeclStmt(gsp_node *node, Statement *stmt) { 1413 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_plsqlCursorDeclStmt*)node), subqueryNode); 1414 | ADD_NODE(obj->dict, ((gsp_plsqlCursorDeclStmt*)node), cursorName); 1415 | ADD_NODE(obj->dict, ((gsp_plsqlCursorDeclStmt*)node), cursorParameterDeclarations); 1416 | ADD_NODE(obj->dict, ((gsp_plsqlCursorDeclStmt*)node), rowtype); 1417 | ADD_NODE(obj->dict, ((gsp_plsqlCursorDeclStmt*)node), cursorTypeName); 1418 | return (PyObject*)obj; 1419 | } 1420 | PyObject *Node_parse_plsqlRecordTypeDefStmt(gsp_node *node, Statement *stmt) { 1421 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_plsqlRecordTypeDefStmt*)node), typeName); 1422 | ADD_NODE(obj->dict, ((gsp_plsqlRecordTypeDefStmt*)node), fieldDeclarations); 1423 | return (PyObject*)obj; 1424 | } 1425 | PyObject *Node_parse_plsqlVarrayTypeDefStmt(gsp_node *node, Statement *stmt) { 1426 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_plsqlVarrayTypeDefStmt*)node), typeName); 1427 | ADD_NODE(obj->dict, ((gsp_plsqlVarrayTypeDefStmt*)node), elementDataType); 1428 | ADD_NODE(obj->dict, ((gsp_plsqlVarrayTypeDefStmt*)node), sizeLimit); 1429 | ADD_INT(obj->dict, ((gsp_plsqlVarrayTypeDefStmt*)node), isNotNull); 1430 | return (PyObject*)obj; 1431 | } 1432 | PyObject *Node_parse_plsqlTableTypeDefStmt(gsp_node *node, Statement *stmt) { 1433 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_plsqlTableTypeDefStmt*)node), typeName); 1434 | ADD_NODE(obj->dict, ((gsp_plsqlTableTypeDefStmt*)node), elementDataType); 1435 | ADD_INT(obj->dict, ((gsp_plsqlTableTypeDefStmt*)node), isNotNull); 1436 | ADD_NODE(obj->dict, ((gsp_plsqlTableTypeDefStmt*)node), indexByDataType); 1437 | return (PyObject*)obj; 1438 | } 1439 | PyObject *Node_parse_plsqlNullStmt(gsp_node *node, Statement *stmt) { 1440 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; return (PyObject*)obj; 1441 | } 1442 | PyObject *Node_parse_plsqlPipeRowStmt(gsp_node *node, Statement *stmt) { 1443 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; return (PyObject*)obj; 1444 | } 1445 | PyObject *Node_parse_bindArgument(gsp_node *node, Statement *stmt) { 1446 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_INT(obj->dict, ((gsp_bindArgument*)node), mode); 1447 | ADD_NODE(obj->dict, ((gsp_bindArgument*)node), bindArgumentExpr); 1448 | return (PyObject*)obj; 1449 | } 1450 | PyObject *Node_parse_execImmeNode(gsp_node *node, Statement *stmt) { 1451 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_execImmeNode*)node), dynamicStringExpr); 1452 | ADD_NODE(obj->dict, ((gsp_execImmeNode*)node), intoVariables); 1453 | ADD_NODE(obj->dict, ((gsp_execImmeNode*)node), bindArguments); 1454 | ADD_NODE(obj->dict, ((gsp_execImmeNode*)node), returnNames); 1455 | return (PyObject*)obj; 1456 | } 1457 | PyObject *Node_parse_plsqlOpenforStmt(gsp_node *node, Statement *stmt) { 1458 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_plsqlOpenforStmt*)node), cursorVariableName); 1459 | ADD_NODE(obj->dict, ((gsp_plsqlOpenforStmt*)node), subqueryNode); 1460 | ADD_NODE(obj->dict, ((gsp_plsqlOpenforStmt*)node), dynamic_string); 1461 | return (PyObject*)obj; 1462 | } 1463 | PyObject *Node_parse_plsqlOpenStmt(gsp_node *node, Statement *stmt) { 1464 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_plsqlOpenStmt*)node), cursorName); 1465 | ADD_NODE(obj->dict, ((gsp_plsqlOpenStmt*)node), cursorParameterNames); 1466 | return (PyObject*)obj; 1467 | } 1468 | PyObject *Node_parse_plsqlBasicStmt(gsp_node *node, Statement *stmt) { 1469 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_plsqlBasicStmt*)node), expr); 1470 | return (PyObject*)obj; 1471 | } 1472 | PyObject *Node_parse_trigger_event(gsp_node *node, Statement *stmt) { 1473 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; return (PyObject*)obj; 1474 | } 1475 | PyObject *Node_parse_mssql_executeAsSqlNode(gsp_node *node, Statement *stmt) { 1476 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; return (PyObject*)obj; 1477 | } 1478 | PyObject *Node_parse_mssql_executeSqlNode(gsp_node *node, Statement *stmt) { 1479 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_INT(obj->dict, ((gsp_mssql_executeSqlNode*)node), execType); 1480 | ADD_NODE(obj->dict, ((gsp_mssql_executeSqlNode*)node), moduleName); 1481 | ADD_NODE(obj->dict, ((gsp_mssql_executeSqlNode*)node), returnStatus); 1482 | ADD_NODE(obj->dict, ((gsp_mssql_executeSqlNode*)node), parameterList); 1483 | ADD_NODE(obj->dict, ((gsp_mssql_executeSqlNode*)node), stringValues); 1484 | return (PyObject*)obj; 1485 | } 1486 | PyObject *Node_parse_mssql_execParameter(gsp_node *node, Statement *stmt) { 1487 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_INT(obj->dict, ((gsp_mssql_execParameter*)node), parameterMode); 1488 | ADD_NODE(obj->dict, ((gsp_mssql_execParameter*)node), parameterName); 1489 | ADD_NODE(obj->dict, ((gsp_mssql_execParameter*)node), parameterValue); 1490 | return (PyObject*)obj; 1491 | } 1492 | PyObject *Node_parse_mssql_dropDbObjectSqlNode(gsp_node *node, Statement *stmt) { 1493 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_INT(obj->dict, ((gsp_mssql_dropDbObjectSqlNode*)node), dbObjectType); 1494 | ADD_NODE(obj->dict, ((gsp_mssql_dropDbObjectSqlNode*)node), objectNames); 1495 | return (PyObject*)obj; 1496 | } 1497 | PyObject *Node_parse_mssql_setSqlNode(gsp_node *node, Statement *stmt) { 1498 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_INT(obj->dict, ((gsp_mssql_setSqlNode*)node), setType); 1499 | ADD_NODE(obj->dict, ((gsp_mssql_setSqlNode*)node), varName); 1500 | ADD_NODE(obj->dict, ((gsp_mssql_setSqlNode*)node), varExpr); 1501 | ADD_NODE(obj->dict, ((gsp_mssql_setSqlNode*)node), selectSqlNode); 1502 | ADD_NODE(obj->dict, ((gsp_mssql_setSqlNode*)node), exprList); 1503 | return (PyObject*)obj; 1504 | } 1505 | PyObject *Node_parse_mssql_beginTranSqlNode(gsp_node *node, Statement *stmt) { 1506 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_mssql_beginTranSqlNode*)node), transactionName); 1507 | ADD_INT(obj->dict, ((gsp_mssql_beginTranSqlNode*)node), distributed); 1508 | ADD_INT(obj->dict, ((gsp_mssql_beginTranSqlNode*)node), withMark); 1509 | ADD_NODE(obj->dict, ((gsp_mssql_beginTranSqlNode*)node), withMarkDescription); 1510 | return (PyObject*)obj; 1511 | } 1512 | PyObject *Node_parse_mssql_raiserrorSqlNode(gsp_node *node, Statement *stmt) { 1513 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_mssql_raiserrorSqlNode*)node), msgs); 1514 | return (PyObject*)obj; 1515 | } 1516 | PyObject *Node_parse_mssql_gotoSqlNode(gsp_node *node, Statement *stmt) { 1517 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_mssql_gotoSqlNode*)node), labelName); 1518 | return (PyObject*)obj; 1519 | } 1520 | PyObject *Node_parse_mssql_labelSqlNode(gsp_node *node, Statement *stmt) { 1521 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; return (PyObject*)obj; 1522 | } 1523 | PyObject *Node_parse_mssql_deallocateSqlNode(gsp_node *node, Statement *stmt) { 1524 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_mssql_deallocateSqlNode*)node), cursorName); 1525 | ADD_INT(obj->dict, ((gsp_mssql_deallocateSqlNode*)node), bGlobal); 1526 | return (PyObject*)obj; 1527 | } 1528 | PyObject *Node_parse_mssql_beginDialogSqlNode(gsp_node *node, Statement *stmt) { 1529 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_mssql_beginDialogSqlNode*)node), dialogHandle); 1530 | ADD_NODE(obj->dict, ((gsp_mssql_beginDialogSqlNode*)node), initiatorServiceName); 1531 | ADD_NODE(obj->dict, ((gsp_mssql_beginDialogSqlNode*)node), targetServiceName); 1532 | return (PyObject*)obj; 1533 | } 1534 | PyObject *Node_parse_mssql_sendOnConversationSqlNode(gsp_node *node, Statement *stmt) { 1535 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_mssql_sendOnConversationSqlNode*)node), conversationHandle); 1536 | return (PyObject*)obj; 1537 | } 1538 | PyObject *Node_parse_mssql_endConversationSqlNode(gsp_node *node, Statement *stmt) { 1539 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_mssql_endConversationSqlNode*)node), conversationHandle); 1540 | return (PyObject*)obj; 1541 | } 1542 | PyObject *Node_parse_mssql_revertSqlNode(gsp_node *node, Statement *stmt) { 1543 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; return (PyObject*)obj; 1544 | } 1545 | PyObject *Node_parse_mssql_goSqlNode(gsp_node *node, Statement *stmt) { 1546 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; return (PyObject*)obj; 1547 | } 1548 | PyObject *Node_parse_mssql_useSqlNode(gsp_node *node, Statement *stmt) { 1549 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_mssql_useSqlNode*)node), databaseName); 1550 | return (PyObject*)obj; 1551 | } 1552 | PyObject *Node_parse_mssql_printSqlNode(gsp_node *node, Statement *stmt) { 1553 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_mssql_printSqlNode*)node), vars); 1554 | return (PyObject*)obj; 1555 | } 1556 | PyObject *Node_parse_mssql_computeClause(gsp_node *node, Statement *stmt) { 1557 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_mssql_computeClause*)node), items); 1558 | return (PyObject*)obj; 1559 | } 1560 | PyObject *Node_parse_mssql_computeClauseItem(gsp_node *node, Statement *stmt) { 1561 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_mssql_computeClauseItem*)node), computeExprList); 1562 | ADD_NODE(obj->dict, ((gsp_mssql_computeClauseItem*)node), exprList); 1563 | return (PyObject*)obj; 1564 | } 1565 | PyObject *Node_parse_mssql_computeExpr(gsp_node *node, Statement *stmt) { 1566 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_mssql_computeExpr*)node), expr); 1567 | return (PyObject*)obj; 1568 | } 1569 | PyObject *Node_parse_mssql_containsTable(gsp_node *node, Statement *stmt) { 1570 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_mssql_containsTable*)node), tableName); 1571 | ADD_NODE(obj->dict, ((gsp_mssql_containsTable*)node), containExpr); 1572 | ADD_NODE(obj->dict, ((gsp_mssql_containsTable*)node), searchCondition); 1573 | return (PyObject*)obj; 1574 | } 1575 | PyObject *Node_parse_mssql_freeTable(gsp_node *node, Statement *stmt) { 1576 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_mssql_freeTable*)node), tableName); 1577 | ADD_NODE(obj->dict, ((gsp_mssql_freeTable*)node), containExpr); 1578 | ADD_NODE(obj->dict, ((gsp_mssql_freeTable*)node), searchCondition); 1579 | return (PyObject*)obj; 1580 | } 1581 | PyObject *Node_parse_mssql_openXML(gsp_node *node, Statement *stmt) { 1582 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; return (PyObject*)obj; 1583 | } 1584 | PyObject *Node_parse_mssql_openRowSet(gsp_node *node, Statement *stmt) { 1585 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; return (PyObject*)obj; 1586 | } 1587 | PyObject *Node_parse_mssql_openQuery(gsp_node *node, Statement *stmt) { 1588 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_mssql_openQuery*)node), exprList); 1589 | return (PyObject*)obj; 1590 | } 1591 | PyObject *Node_parse_mssql_openDatasource(gsp_node *node, Statement *stmt) { 1592 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_mssql_openDatasource*)node), providerName); 1593 | ADD_NODE(obj->dict, ((gsp_mssql_openDatasource*)node), initString); 1594 | ADD_NODE(obj->dict, ((gsp_mssql_openDatasource*)node), tableName); 1595 | ADD_NODE(obj->dict, ((gsp_mssql_openDatasource*)node), exprList); 1596 | return (PyObject*)obj; 1597 | } 1598 | PyObject *Node_parse_mssql_tableHint(gsp_node *node, Statement *stmt) { 1599 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_mssql_tableHint*)node), hintName); 1600 | ADD_NODE(obj->dict, ((gsp_mssql_tableHint*)node), hintNameList); 1601 | return (PyObject*)obj; 1602 | } 1603 | PyObject *Node_parse_mssql_bulkInsertSqlNode(gsp_node *node, Statement *stmt) { 1604 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_mssql_bulkInsertSqlNode*)node), tableName); 1605 | ADD_NODE(obj->dict, ((gsp_mssql_bulkInsertSqlNode*)node), datafile); 1606 | return (PyObject*)obj; 1607 | } 1608 | PyObject *Node_parse_mssql_outputClause(gsp_node *node, Statement *stmt) { 1609 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_mssql_outputClause*)node), selectItemList); 1610 | ADD_NODE(obj->dict, ((gsp_mssql_outputClause*)node), selectItemList2); 1611 | ADD_NODE(obj->dict, ((gsp_mssql_outputClause*)node), intoColumnList); 1612 | ADD_NODE(obj->dict, ((gsp_mssql_outputClause*)node), tableName); 1613 | return (PyObject*)obj; 1614 | } 1615 | PyObject *Node_parse_mssql_updateTextSqlNode(gsp_node *node, Statement *stmt) { 1616 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_mssql_updateTextSqlNode*)node), destColumnName); 1617 | ADD_NODE(obj->dict, ((gsp_mssql_updateTextSqlNode*)node), destTextPtr); 1618 | return (PyObject*)obj; 1619 | } 1620 | PyObject *Node_parse_db2_signal(gsp_node *node, Statement *stmt) { 1621 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; return (PyObject*)obj; 1622 | } 1623 | PyObject *Node_parse_db2_compoundSqlNode(gsp_node *node, Statement *stmt) { 1624 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_db2_compoundSqlNode*)node), declareStmts); 1625 | ADD_NODE(obj->dict, ((gsp_db2_compoundSqlNode*)node), bodyStmts); 1626 | return (PyObject*)obj; 1627 | } 1628 | PyObject *Node_parse_db2_triggerAction(gsp_node *node, Statement *stmt) { 1629 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_db2_triggerAction*)node), whenCondition); 1630 | ADD_NODE(obj->dict, ((gsp_db2_triggerAction*)node), compoundSqlNode); 1631 | ADD_NODE(obj->dict, ((gsp_db2_triggerAction*)node), stmt); 1632 | return (PyObject*)obj; 1633 | } 1634 | PyObject *Node_parse_db2_callStmtSqlNode(gsp_node *node, Statement *stmt) { 1635 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_db2_callStmtSqlNode*)node), procedureName); 1636 | ADD_NODE(obj->dict, ((gsp_db2_callStmtSqlNode*)node), args); 1637 | return (PyObject*)obj; 1638 | } 1639 | PyObject *Node_parse_db2_forSqlNode(gsp_node *node, Statement *stmt) { 1640 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_db2_forSqlNode*)node), loopName); 1641 | ADD_NODE(obj->dict, ((gsp_db2_forSqlNode*)node), cursorName); 1642 | ADD_NODE(obj->dict, ((gsp_db2_forSqlNode*)node), subQueryNode); 1643 | ADD_NODE(obj->dict, ((gsp_db2_forSqlNode*)node), stmts); 1644 | return (PyObject*)obj; 1645 | } 1646 | PyObject *Node_parse_db2_iterateStmtSqlNode(gsp_node *node, Statement *stmt) { 1647 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_db2_iterateStmtSqlNode*)node), labelName); 1648 | return (PyObject*)obj; 1649 | } 1650 | PyObject *Node_parse_db2_leaveStmtSqlNode(gsp_node *node, Statement *stmt) { 1651 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_db2_leaveStmtSqlNode*)node), labelName); 1652 | return (PyObject*)obj; 1653 | } 1654 | PyObject *Node_parse_db2_setSqlNode(gsp_node *node, Statement *stmt) { 1655 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; return (PyObject*)obj; 1656 | } 1657 | PyObject *Node_parse_db2_whileSqlNode(gsp_node *node, Statement *stmt) { 1658 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_db2_whileSqlNode*)node), condition); 1659 | ADD_NODE(obj->dict, ((gsp_db2_whileSqlNode*)node), stmts); 1660 | return (PyObject*)obj; 1661 | } 1662 | PyObject *Node_parse_db2_repeatSqlNode(gsp_node *node, Statement *stmt) { 1663 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_db2_repeatSqlNode*)node), condition); 1664 | ADD_NODE(obj->dict, ((gsp_db2_repeatSqlNode*)node), stmts); 1665 | return (PyObject*)obj; 1666 | } 1667 | PyObject *Node_parse_db2_gotoSqlNode(gsp_node *node, Statement *stmt) { 1668 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_db2_gotoSqlNode*)node), labelName); 1669 | return (PyObject*)obj; 1670 | } 1671 | PyObject *Node_parse_db2_loopSqlNode(gsp_node *node, Statement *stmt) { 1672 | SqlNode *obj = (SqlNode*)Node_new(&NodeType, Py_None, Py_None); obj->_node = node; ADD_NODE(obj->dict, ((gsp_db2_loopSqlNode*)node), stmts); 1673 | return (PyObject*)obj; 1674 | } 1675 | /// 1676 | 1677 | void Node_init() { 1678 | int i; 1679 | for (i=0; i 8 | #include 9 | #include 10 | 11 | // Node object 12 | typedef struct { 13 | PyObject_HEAD 14 | PyObject *dict; 15 | gsp_node *_node; 16 | gsp_sqlparser *_parser; 17 | } SqlNode; 18 | 19 | void Node_init_type(PyObject *m); 20 | void Node_init(); 21 | PyObject *Node_FromNode(gsp_node *node, Statement *stmt); 22 | PyObject *Node_list_iterator(PyObject *o); 23 | void Node_dealloc(SqlNode *self); 24 | PyObject *Node_new(PyTypeObject *type, PyObject *args, PyObject *kwds); 25 | PyObject *Node_free(PyObject *self, PyObject *args); 26 | 27 | PyObject *Node_get_text(SqlNode *self, PyObject *args); 28 | PyObject *Node_get_position(SqlNode *self, PyObject *args); 29 | PyObject *Node_getattro(SqlNode *self, PyObject *args); 30 | 31 | // Members/properties 32 | static PyMemberDef Node_members[] = { 33 | {"__dict__", T_OBJECT, offsetof(SqlNode, dict), READONLY}, 34 | {NULL} /* Sentinel */ 35 | }; 36 | 37 | // Object methods 38 | static PyMethodDef Node_methods[] = { 39 | {"get_text", (PyCFunction)Node_get_text, METH_VARARGS, "get_text()\nGets the string representation of the node.\n\n:returns: str" }, 40 | {"get_position", (PyCFunction)Node_get_position, METH_NOARGS, "get_position()\nGets the node's position in the query.\n\n:returns: tuple" }, 41 | {NULL} /* Sentinel */ 42 | }; 43 | 44 | // Type object for Statement 45 | static PyTypeObject NodeType = { 46 | PyObject_HEAD_INIT(NULL) 47 | 0, /*ob_size*/ 48 | "parsebridge.Node", /*tp_name*/ 49 | sizeof(Node), /*tp_basicsize*/ 50 | 0, /*tp_itemsize*/ 51 | (destructor)Node_dealloc, /*tp_dealloc*/ 52 | 0, /*tp_print*/ 53 | 0, /*tp_getattr*/ 54 | 0, /*tp_setattr*/ 55 | 0, /*tp_compare*/ 56 | 0, /*tp_repr*/ 57 | 0, /*tp_as_number*/ 58 | 0, /*tp_as_sequence*/ 59 | 0, /*tp_as_mapping*/ 60 | 0, /*tp_hash */ 61 | 0, /*tp_call*/ 62 | 0, /*tp_str*/ 63 | (getattrofunc)Node_getattro, /*tp_getattro*/ 64 | 0, /*tp_setattro*/ 65 | 0, /*tp_as_buffer*/ 66 | Py_TPFLAGS_DEFAULT, /*tp_flags*/ 67 | "Node objects", /* tp_doc */ 68 | 0, /* tp_traverse */ 69 | 0, /* tp_clear */ 70 | 0, /* tp_richcompare */ 71 | 0, /* tp_weaklistoffset */ 72 | Node_list_iterator, /* tp_iter */ 73 | 0, /* tp_iternext */ 74 | Node_methods, /* tp_methods */ 75 | Node_members, /* tp_members */ 76 | 0, /* tp_getset */ 77 | 0, /* tp_base */ 78 | 0, /* tp_dict */ 79 | 0, /* tp_descr_get */ 80 | 0, /* tp_descr_set */ 81 | offsetof(SqlNode, dict), /* tp_dictoffset */ 82 | 0, /* tp_init */ 83 | 0, /* tp_alloc */ 84 | Node_new, /* tp_new */ 85 | }; 86 | 87 | 88 | #define MAX_NODE_PARSE_FUNCS 300 // arbitrary 89 | 90 | typedef PyObject *(*NodeParseFunc)(gsp_node *, Statement *); 91 | static NodeParseFunc Node_parse_functions[MAX_NODE_PARSE_FUNCS]; 92 | -------------------------------------------------------------------------------- /Parser.c: -------------------------------------------------------------------------------- 1 | 2 | #include "Parser.h" 3 | #include "Statement.h" 4 | 5 | // Initialize this Type 6 | void Parser_init_type(PyObject *m) { 7 | if (PyType_Ready(&ParserType) < 0) 8 | return; 9 | Py_INCREF(&ParserType); 10 | PyModule_AddObject(m, "Parser", (PyObject*)&ParserType); 11 | } 12 | 13 | // Deallocate object (refcount is 0) 14 | void Parser_dealloc(Parser *self) 15 | { 16 | //printf("Parser_dealloc\n"); 17 | if (self->_parser != NULL) { 18 | gsp_parser_free(self->_parser); 19 | } 20 | self->ob_type->tp_free((PyObject*)self); 21 | } 22 | 23 | // Allocate new Parser object 24 | PyObject *Parser_new(PyTypeObject *type, PyObject *args, PyObject *kwds) 25 | { 26 | Parser *self; 27 | 28 | self = (Parser *)type->tp_alloc(type, 0); 29 | if (self != NULL) { 30 | self->_parser = NULL; 31 | self->vendor = (int)dbvmssql; 32 | } 33 | 34 | return (PyObject*) self; 35 | } 36 | 37 | // Parser.__init__(vendor=0) 38 | int Parser_init(Parser* self, PyObject* args, PyObject *kwds) 39 | { 40 | int vendor; 41 | static char *kwlist[] = { "vendor", NULL }; 42 | vendor = dbvmssql; 43 | 44 | if (!PyArg_ParseTupleAndKeywords(args, kwds, "|i", kwlist, &vendor)) { 45 | return -1; 46 | } 47 | 48 | self->vendor = vendor; 49 | 50 | if (gsp_parser_create((gsp_dbvendor) vendor, &self->_parser) != 0) { 51 | Py_DECREF(self); 52 | return -1; 53 | } 54 | 55 | //printf("Parser_init: %d -> %p\n", vendor, self->_parser); 56 | 57 | return 0; 58 | } 59 | 60 | // Parser.check_syntax(query) 61 | PyObject* Parser_check_syntax(PyObject* self, PyObject* args) 62 | { 63 | int rc; 64 | PyObject *r; 65 | char *query; 66 | //PyObject *query_object; 67 | //PyObject *query_unicode; 68 | Parser *parser = (Parser *)self; 69 | 70 | query = NULL; 71 | 72 | // get query from first argument 73 | if (args == NULL || args == Py_None) { 74 | PyErr_SetString(PyExc_TypeError, "check_syntax() takes at least 1 argument"); 75 | return NULL; 76 | } 77 | 78 | rc = PyArg_ParseTuple(args, "s", &query); 79 | // printf("parse s: %d / %p\n", rc, query); 80 | 81 | /*if (!rc || query == NULL) { 82 | rc = PyArg_ParseTuple(args, "u", &query); 83 | // printf("parse u: %d / %p\n", rc, query); 84 | }*/ 85 | 86 | if (!rc || query == NULL) { 87 | PyErr_SetString(PyExc_TypeError, "check_syntax() takes exactly one string argument"); 88 | return NULL; 89 | } 90 | 91 | //printf("check_syntax (%p): %s\n", parser->_parser, query); 92 | rc = gsp_check_syntax(parser->_parser, query); 93 | r = PyInt_FromLong(rc); 94 | //Py_XDECREF(r); 95 | return r; 96 | } 97 | 98 | // Parser.tokenize(query) + return tokens 99 | PyObject* Parser_tokenize(PyObject* self, PyObject* args) 100 | { 101 | /* NB: the query passed in here is held by the parser. If further 102 | * processing will done it must be Py_INCREF()'d and stored in the 103 | * parser object so it can later be cleaned up. 104 | */ 105 | int rc; 106 | char *query; 107 | PyObject *token_tuple; 108 | PyObject *list; 109 | //PyObject *query_object; 110 | //PyObject *query_unicode; 111 | Parser *parser = (Parser *)self; 112 | char * token_str; 113 | struct gsp_sourcetoken *token; 114 | int i; 115 | int token_cnt; 116 | 117 | query = NULL; 118 | 119 | // get query from first argument 120 | if (args == NULL || args == Py_None) { 121 | PyErr_SetString(PyExc_TypeError, "tokenize() takes at least 1 argument"); 122 | return NULL; 123 | } 124 | 125 | rc = PyArg_ParseTuple(args, "s", &query); 126 | /*if (!rc || query == NULL) { 127 | rc = PyArg_ParseTuple(args, "u", &query); 128 | // printf("parse u: %d / %p\n", rc, query); 129 | }*/ 130 | 131 | if (!rc || query == NULL) { 132 | PyErr_SetString(PyExc_TypeError, "tokenize() takes exactly one string argument"); 133 | return NULL; 134 | } 135 | 136 | rc = gsp_tokenize(parser->_parser, query); 137 | 138 | if (rc != 0) { 139 | PyErr_SetString(PyExc_BaseException, "tokenize() failed"); 140 | return NULL; 141 | } 142 | 143 | token_cnt = parser->_parser->number_of_token; 144 | list = PyList_New(token_cnt); 145 | if (!list) { 146 | PyErr_SetString(PyExc_BaseException, 147 | "tokenize() unable to create list"); 148 | return NULL; 149 | } 150 | 151 | for (i = 0; i < token_cnt; i++) { 152 | token = &parser->_parser->sourcetokenlist[i]; 153 | 154 | // TODO: any unicode handling? 155 | token_str = gsp_token_text(token); 156 | 157 | if (!token_str) { 158 | PyErr_SetString(PyExc_BaseException, "tokenize() invalid token"); 159 | Py_DECREF(list); 160 | return NULL; 161 | } 162 | 163 | //printf("STR: %s\n", token_str); 164 | //gsp_print_token(token); 165 | 166 | token_tuple = Py_BuildValue("(is)", token->nCode, token_str); 167 | free(token_str); 168 | 169 | if (!token_tuple) { 170 | PyErr_SetString(PyExc_BaseException, "tokenize() tuple failed"); 171 | Py_DECREF(list); 172 | return NULL; 173 | } 174 | 175 | PyList_SET_ITEM(list, i, token_tuple); 176 | } 177 | 178 | return list; 179 | } 180 | 181 | 182 | // get nth statement 183 | // Parser.get_statement(n) 184 | PyObject* Parser_get_statement(PyObject* self, PyObject* args) 185 | { 186 | int n; 187 | gsp_sql_statement *stmt; 188 | Statement *statement; 189 | Parser *parser = (Parser *)self; 190 | 191 | n = -1; 192 | 193 | if (!PyArg_ParseTuple(args, "i", &n)) { 194 | PyErr_SetString(PyExc_TypeError, "get_statement() takes exactly one integer argument"); 195 | return NULL; 196 | } 197 | 198 | if (n < 0 || n >= parser->_parser->nStatement) { 199 | PyErr_SetString(PyExc_ValueError, "get_statement() index out of bounds"); 200 | return NULL; 201 | } 202 | 203 | stmt = &parser->_parser->pStatement[n]; 204 | 205 | if (stmt->parseTree == NULL && stmt->stmt == NULL) { 206 | // Invalid syntax 207 | Py_RETURN_NONE; 208 | } 209 | 210 | statement = (Statement*) Statement_FromStatement(stmt); 211 | //Py_XDECREF(statement); 212 | return (PyObject*) statement; 213 | } 214 | 215 | // Parser.get_statement_count() 216 | PyObject* Parser_get_statement_count(PyObject* self, PyObject* args) 217 | { 218 | PyObject *n; 219 | Parser *parser = (Parser *)self; 220 | 221 | n = PyLong_FromLong(parser->_parser->nStatement); 222 | 223 | return n; 224 | } 225 | -------------------------------------------------------------------------------- /Parser.h: -------------------------------------------------------------------------------- 1 | #include "gsp_base.h" 2 | #include "gsp_node.h" 3 | #include "gsp_list.h" 4 | #include "gsp_sourcetoken.h" 5 | #include "gsp_sqlparser.h" 6 | #include 7 | #include 8 | #include 9 | 10 | // Parser object 11 | typedef struct { 12 | PyObject_HEAD 13 | gsp_sqlparser *_parser; 14 | int vendor; 15 | } Parser; 16 | 17 | void Parser_init_type(PyObject *m); 18 | void Parser_dealloc(Parser *self); 19 | PyObject *Parser_new(PyTypeObject *type, PyObject *args, PyObject *kwds); 20 | PyObject *Parser_check_syntax(PyObject* self, PyObject* args); 21 | PyObject *Parser_tokenize(PyObject* self, PyObject* args); 22 | PyObject *Parser_get_statement(PyObject* self, PyObject* args); 23 | PyObject *Parser_get_statement_count(PyObject* self, PyObject* args); 24 | PyObject *Parser_get_tokens(PyObject* self, PyObject *args); 25 | int Parser_init(Parser* self, PyObject* args, PyObject *kwds); 26 | 27 | // Members/properties 28 | static PyMemberDef Parser_members[] = { 29 | {"vendor", T_INT, offsetof(Parser, vendor), 0, "DB Vendor"}, 30 | {NULL} /* Sentinel */ 31 | }; 32 | 33 | // Object methods 34 | static PyMethodDef Parser_methods[] = { 35 | {"check_syntax", (PyCFunction)Parser_check_syntax, METH_VARARGS, "check_syntax(query)\nChecks syntax of the given *query*. Returns 0 if the query is valid.\n\n:type query: str\n:returns: int -- 0 for success" }, 36 | {"tokenize", (PyCFunction)Parser_tokenize, METH_VARARGS, "tokenize(query)\nTokenizes the given *query*. Returns a list of (tokenCode, tokenValue) "}, 37 | {"get_statement", (PyCFunction)Parser_get_statement, METH_VARARGS, "get_statement(n)\nAfter parsing a query string with :meth:`Parser.check_syntax` this function will return the *n*-th :class:`Statement` in that string.\n\n:type n: int\n:returns: Statement" }, 38 | {"get_statement_count", (PyCFunction)Parser_get_statement_count, METH_VARARGS, "get_statement_count()\nReturns the number of statements for the Parser object\n:returns: int" }, 39 | {NULL} /* Sentinel */ 40 | }; 41 | 42 | // Type object for Parser 43 | static PyTypeObject ParserType = { 44 | PyObject_HEAD_INIT(NULL) 45 | 0, /*ob_size*/ 46 | "parsebridge.Parser", /*tp_name*/ 47 | sizeof(Parser), /*tp_basicsize*/ 48 | 0, /*tp_itemsize*/ 49 | (destructor)Parser_dealloc,/*tp_dealloc*/ 50 | 0, /*tp_print*/ 51 | 0, /*tp_getattr*/ 52 | 0, /*tp_setattr*/ 53 | 0, /*tp_compare*/ 54 | 0, /*tp_repr*/ 55 | 0, /*tp_as_number*/ 56 | 0, /*tp_as_sequence*/ 57 | 0, /*tp_as_mapping*/ 58 | 0, /*tp_hash */ 59 | 0, /*tp_call*/ 60 | 0, /*tp_str*/ 61 | 0, /*tp_getattro*/ 62 | 0, /*tp_setattro*/ 63 | 0, /*tp_as_buffer*/ 64 | Py_TPFLAGS_DEFAULT, /*tp_flags*/ 65 | "Represents a gsp_sqlParser object. Responsible for parsing SQL queries and retrieving statements.", /* tp_doc */ 66 | 0, /* tp_traverse */ 67 | 0, /* tp_clear */ 68 | 0, /* tp_richcompare */ 69 | 0, /* tp_weaklistoffset */ 70 | 0, /* tp_iter */ 71 | 0, /* tp_iternext */ 72 | Parser_methods, /* tp_methods */ 73 | Parser_members, /* tp_members */ 74 | 0, /* tp_getset */ 75 | 0, /* tp_base */ 76 | 0, /* tp_dict */ 77 | 0, /* tp_descr_get */ 78 | 0, /* tp_descr_set */ 79 | 0, /* tp_dictoffset */ 80 | (initproc)Parser_init, /* tp_init */ 81 | 0, /* tp_alloc */ 82 | Parser_new, /* tp_new */ 83 | }; -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | python-sqlparser 2 | ================ 3 | 4 | Note: This package is UNMAINTAINED 5 | -------- 6 | 7 | A Python Module for the "General SQL Parser" library (sqlparser.com) 8 | 9 | Supported Systems 10 | ----------------- 11 | This library currently supports: Windows 32bit/64bit and Linux 32bit/64bit. 12 | There are currently no binaries for Mac OSX available. 13 | 14 | Also, please note that this module does not support Python 3.* 15 | 16 | Installation 17 | ------------ 18 | Simply clone or download this git and execute 19 | 20 | python setup.py build 21 | python setup.py install 22 | 23 | The setup script will automatically download the right library (from sqlparser.com) for you. 24 | 25 | Usage 26 | ----- 27 | Simply import the module with 28 | import sqlparser 29 | The following example will parse a simple query: 30 | ```python 31 | import sqlparser 32 | 33 | query = "SELECT a, b FROM table_1 WHERE c > 20" 34 | parser = sqlparser.Parser() 35 | 36 | # Check for syntax errors 37 | if parser.check_syntax(query) == 0: 38 | # Get first statement from the query 39 | stmt = parser.get_statement(0) 40 | 41 | # Get root node 42 | root = stmt.get_root() 43 | 44 | print root.__dict__ 45 | ``` 46 | 47 | And print the node information the SELECT node: 48 | ```javascript 49 | {"computeClause": None, 50 | "cteList": None, 51 | "expandOnClause": None, 52 | "fetchFirstClause": None, 53 | "forupdateClause": None, 54 | "fromTableList": , 55 | "groupByClause": None, 56 | "hierarchicalClause": None, 57 | "intoClause": None, 58 | "intoTableClause": None, 59 | "isolationClause": None, 60 | "leftNode": None, 61 | "limitClause": None, 62 | "lockingClause": None, 63 | "node_type": 5, 64 | "optimizeForClause": None, 65 | "orderbyClause": None, 66 | "qualifyClause": None, 67 | "resultColumnList": , 68 | "rightNode": None, 69 | "sampleClause": None, 70 | "selectDistinct": None, 71 | "selectToken": "SELECT", 72 | "setOperator": 0, 73 | "topClause": None, 74 | "valueClause": None, 75 | "whereCondition": , 76 | "windowClause": None, 77 | "withClauses": None} 78 | ``` 79 | 80 | Examples 81 | -------- 82 | For more examples please check the examples directory. 83 | -------------------------------------------------------------------------------- /Statement.c: -------------------------------------------------------------------------------- 1 | #include "Statement.h" 2 | #include "Node.h" 3 | #include "modifysql.h" 4 | 5 | // Initialize Statement Type 6 | void Statement_init_type(PyObject *m) { 7 | if (PyType_Ready(&StatementType) < 0) 8 | return; 9 | Py_INCREF(&StatementType); 10 | PyModule_AddObject(m, "Statement", (PyObject*)&StatementType); 11 | } 12 | 13 | PyObject *Statement_FromStatement(gsp_sql_statement *stmt) { 14 | Statement *self; 15 | self = (Statement*)Statement_new(&StatementType, NULL, NULL); 16 | self->_statement = stmt; 17 | return (PyObject*)self; 18 | } 19 | 20 | // Get root node 21 | // Statement.get_root() 22 | PyObject* Statement_get_root(PyObject* self, PyObject* args) 23 | { 24 | SqlNode *n; 25 | Statement *stmt = (Statement*) self; 26 | 27 | //printf("Statement_get_root\n"); 28 | 29 | if (((Statement*)self)->_statement->stmt == NULL) { 30 | Py_RETURN_NONE; 31 | } 32 | 33 | //n = (SqlNode*) Node_FromNode( ((Statement*)self)->_statement->parseTree, (Statement*) self ); 34 | n = (SqlNode*) Node_FromNode( (gsp_node*) ((Statement*)self)->_statement->stmt, (Statement*) self ); 35 | 36 | //Py_XINCREF(n); 37 | return (PyObject*)n; 38 | } 39 | 40 | // Statement.remove_whereclause(node) 41 | PyObject* Statement_remove_whereclause(PyObject* self, PyObject* args) 42 | { 43 | PyObject* node; 44 | PyObject *newNode; 45 | Statement *stmt = (Statement*) self; 46 | 47 | if (!PyArg_ParseTuple(args, "O", &node)) { 48 | PyErr_SetString(PyExc_TypeError, "remove_whereclause() takes exactly one node argument"); 49 | return NULL; 50 | } 51 | 52 | gsp_removeWhereClause((gsp_base_statement*) ((SqlNode*)node)->_node); 53 | newNode = Node_FromNode(((SqlNode*)node)->_node, (Statement*) self); 54 | 55 | return newNode; 56 | } 57 | 58 | // Statement.remove_orderby(selectNode) 59 | PyObject* Statement_remove_orderby(PyObject* self, PyObject* args) 60 | { 61 | PyObject* node; 62 | PyObject *newNode; 63 | Statement *stmt = (Statement*) self; 64 | 65 | if (!PyArg_ParseTuple(args, "O", &node)) { 66 | PyErr_SetString(PyExc_TypeError, "remove_orderby() takes exactly one node argument"); 67 | return NULL; 68 | } 69 | 70 | gsp_removeOrderBy((gsp_selectStatement*) ((SqlNode*)node)->_node); 71 | newNode = Node_FromNode(((SqlNode*)node)->_node, (Statement*) self); 72 | 73 | return newNode; 74 | } 75 | 76 | 77 | // Statement.remove_groupby(selectNode) 78 | PyObject* Statement_remove_groupby(PyObject* self, PyObject* args) 79 | { 80 | PyObject* node; 81 | PyObject *newNode; 82 | Statement *stmt = (Statement*) self; 83 | 84 | if (!PyArg_ParseTuple(args, "O", &node)) { 85 | PyErr_SetString(PyExc_TypeError, "remove_groupby() takes exactly one node argument"); 86 | return NULL; 87 | } 88 | 89 | gsp_removeGroupBy((gsp_selectStatement*) ((SqlNode*)node)->_node); 90 | newNode = Node_FromNode(((SqlNode*)node)->_node, (Statement*) self); 91 | 92 | return newNode; 93 | } 94 | 95 | 96 | // Statement.remove_havingclause(selectNode) 97 | PyObject* Statement_remove_havingclause(PyObject* self, PyObject* args) 98 | { 99 | PyObject* node; 100 | PyObject *newNode; 101 | Statement *stmt = (Statement*) self; 102 | 103 | if (!PyArg_ParseTuple(args, "O", &node)) { 104 | PyErr_SetString(PyExc_TypeError, "remove_havingclause() takes exactly one node argument"); 105 | return NULL; 106 | } 107 | 108 | gsp_removeHavingClause((gsp_selectStatement*) ((SqlNode*)node)->_node); 109 | newNode = Node_FromNode(((SqlNode*)node)->_node, (Statement*) self); 110 | 111 | return newNode; 112 | } 113 | 114 | 115 | // Statement.remove_expression(exprNode) 116 | PyObject* Statement_remove_expression(PyObject* self, PyObject* args) 117 | { 118 | PyObject* node; 119 | PyObject *newNode; 120 | Statement *stmt = (Statement*) self; 121 | 122 | if (!PyArg_ParseTuple(args, "O", &node)) { 123 | PyErr_SetString(PyExc_TypeError, "remove_expression() takes exactly one node argument"); 124 | return NULL; 125 | } 126 | 127 | gsp_removeExpression((gsp_expr*) ((SqlNode*)node)->_node); 128 | newNode = Node_FromNode(((SqlNode*)node)->_node, (Statement*) self); 129 | 130 | return newNode; 131 | } 132 | 133 | 134 | // Statement.remove_joinitem(selectNode, joinIndex) 135 | PyObject* Statement_remove_joinitem(PyObject* self, PyObject* args) 136 | { 137 | PyObject* node; 138 | PyObject *newNode; 139 | int i; 140 | Statement *stmt = (Statement*) self; 141 | 142 | if (!PyArg_ParseTuple(args, "Oi", &node, &i)) { 143 | PyErr_SetString(PyExc_TypeError, "remove_joinitem() takes exactly two arguments"); 144 | return NULL; 145 | } 146 | 147 | gsp_removeJoinItem((gsp_selectStatement*) ((SqlNode*)node)->_node, i); 148 | newNode = Node_FromNode(((SqlNode*)node)->_node, (Statement*) self); 149 | 150 | return newNode; 151 | } 152 | 153 | 154 | // Statement.remove_resultcolumn(node, columnIndex) 155 | PyObject* Statement_remove_resultcolumn(PyObject* self, PyObject* args) 156 | { 157 | PyObject* node; 158 | PyObject *newNode; 159 | int i; 160 | Statement *stmt = (Statement*) self; 161 | 162 | if (!PyArg_ParseTuple(args, "Oi", &node, &i)) { 163 | PyErr_SetString(PyExc_TypeError, "remove_resultcolumn() takes exactly two arguments"); 164 | return NULL; 165 | } 166 | 167 | gsp_removeResultColumn((gsp_base_statement*) ((Statement*)self)->_statement->stmt, i); 168 | newNode = Node_FromNode((gsp_node*)((Statement*)self)->_statement->stmt, (Statement*) self); 169 | return newNode; 170 | } 171 | 172 | 173 | // Statement.remove_orderbyitem(node, orderByIndex) 174 | PyObject* Statement_remove_orderbyitem(PyObject* self, PyObject* args) 175 | { 176 | PyObject* node; 177 | PyObject *newNode; 178 | int i; 179 | Statement *stmt = (Statement*) self; 180 | 181 | if (!PyArg_ParseTuple(args, "Oi", &node, &i)) { 182 | PyErr_SetString(PyExc_TypeError, "remove_orderbyitem() takes exactly two arguments"); 183 | return NULL; 184 | } 185 | 186 | gsp_removeOrderByItem((gsp_selectStatement*) ((SqlNode*)node)->_node, i); 187 | newNode = Node_FromNode(((SqlNode*)node)->_node, (Statement*) self); 188 | 189 | return newNode; 190 | } 191 | 192 | 193 | // Statement.remove_groupbyitem(selectNode, groupbyIndex) 194 | PyObject* Statement_remove_groupbyitem(PyObject* self, PyObject* args) 195 | { 196 | PyObject* node; 197 | PyObject *newNode; 198 | int i; 199 | Statement *stmt = (Statement*) self; 200 | 201 | if (!PyArg_ParseTuple(args, "Oi", &node, &i)) { 202 | PyErr_SetString(PyExc_TypeError, "remove_groupby() takes exactly two arguments"); 203 | return NULL; 204 | } 205 | 206 | gsp_removeGroupByItem((gsp_selectStatement*) ((SqlNode*)node)->_node, i); 207 | newNode = Node_FromNode(((SqlNode*)node)->_node, (Statement*) self); 208 | 209 | return newNode; 210 | } 211 | 212 | PyObject* Statement_add_whereclause(PyObject* self, PyObject* args) 213 | { 214 | PyObject* node; 215 | char *text; 216 | char *newQuery; 217 | PyObject *newString; 218 | Statement *stmt = (Statement*) self; 219 | 220 | if (!PyArg_ParseTuple(args, "Os", &node, &text)) { 221 | PyErr_SetString(PyExc_TypeError, "add_whereclause() takes exactly two arguments"); 222 | return NULL; 223 | } 224 | 225 | //printf("add_whereclause: %s\n", text); 226 | //printf("old: %s\n", gsp_getNodeText( (gsp_node*) ((Statement*)self)->_statement->stmt)); 227 | gsp_addWhereClause( ((Statement*)self)->_statement->sqlparser, (gsp_base_statement*) ((SqlNode*)node)->_node, text); 228 | //printf("new: %s\n", gsp_getNodeText( (gsp_node*) ((Statement*)self)->_statement->stmt)); 229 | 230 | newQuery = gsp_getNodeText( (gsp_node*) ((Statement*)self)->_statement->stmt ); 231 | newString = PyString_FromString(newQuery); 232 | free(newQuery); 233 | 234 | return newString; 235 | } 236 | PyObject* Statement_add_orderby(PyObject* self, PyObject* args) 237 | { 238 | PyObject* node; 239 | char *text; 240 | char *newQuery; 241 | PyObject *newString; 242 | Statement *stmt = (Statement*) self; 243 | 244 | if (!PyArg_ParseTuple(args, "Os", &node, &text)) { 245 | PyErr_SetString(PyExc_TypeError, "add_orderby() takes exactly two arguments"); 246 | return NULL; 247 | } 248 | 249 | gsp_addOrderBy( ((Statement*)self)->_statement->sqlparser, (gsp_selectStatement*) ((SqlNode*)node)->_node, text); 250 | 251 | newQuery = gsp_getNodeText( (gsp_node*) ((Statement*)self)->_statement->stmt ); 252 | newString = PyString_FromString(newQuery); 253 | free(newQuery); 254 | 255 | return newString; 256 | } 257 | PyObject* Statement_add_groupby(PyObject* self, PyObject* args) 258 | { 259 | PyObject* node; 260 | char *text; 261 | char *newQuery; 262 | PyObject *newString; 263 | Statement *stmt = (Statement*) self; 264 | 265 | if (!PyArg_ParseTuple(args, "Os", &node, &text)) { 266 | PyErr_SetString(PyExc_TypeError, "add_groupby() takes exactly two arguments"); 267 | return NULL; 268 | } 269 | 270 | gsp_addGroupBy( ((Statement*)self)->_statement->sqlparser, (gsp_selectStatement*) ((SqlNode*)node)->_node, text); 271 | 272 | newQuery = gsp_getNodeText( (gsp_node*) ((Statement*)self)->_statement->stmt ); 273 | newString = PyString_FromString(newQuery); 274 | free(newQuery); 275 | 276 | return newString; 277 | } 278 | PyObject* Statement_add_havingclause(PyObject* self, PyObject* args) 279 | { 280 | PyObject* node; 281 | char *text; 282 | char *newQuery; 283 | PyObject *newString; 284 | Statement *stmt = (Statement*) self; 285 | 286 | if (!PyArg_ParseTuple(args, "Os", &node, &text)) { 287 | PyErr_SetString(PyExc_TypeError, "add_havingclause() takes exactly two arguments"); 288 | return NULL; 289 | } 290 | 291 | gsp_addHavingClause( ((Statement*)self)->_statement->sqlparser, (gsp_selectStatement*) ((SqlNode*)node)->_node, text); 292 | 293 | newQuery = gsp_getNodeText( (gsp_node*) ((Statement*)self)->_statement->stmt ); 294 | newString = PyString_FromString(newQuery); 295 | free(newQuery); 296 | 297 | return newString; 298 | } 299 | PyObject* Statement_add_joinitem(PyObject* self, PyObject* args) 300 | { 301 | PyObject* node; 302 | char *text; 303 | char *newQuery; 304 | PyObject *newString; 305 | Statement *stmt = (Statement*) self; 306 | 307 | if (!PyArg_ParseTuple(args, "Os", &node, &text)) { 308 | PyErr_SetString(PyExc_TypeError, "add_joinitem() takes exactly two arguments"); 309 | return NULL; 310 | } 311 | 312 | gsp_addJoinItem( ((Statement*)self)->_statement->sqlparser, (gsp_selectStatement*) ((SqlNode*)node)->_node, text); 313 | 314 | newQuery = gsp_getNodeText( (gsp_node*) ((Statement*)self)->_statement->stmt ); 315 | newString = PyString_FromString(newQuery); 316 | free(newQuery); 317 | 318 | return newString; 319 | } 320 | PyObject* Statement_add_resultcolumn(PyObject* self, PyObject* args) 321 | { 322 | PyObject* node; 323 | char *text; 324 | char *newQuery; 325 | PyObject *newString; 326 | Statement *stmt = (Statement*) self; 327 | 328 | if (!PyArg_ParseTuple(args, "Os", &node, &text)) { 329 | PyErr_SetString(PyExc_TypeError, "add_resultcolumn() takes exactly two arguments"); 330 | return NULL; 331 | } 332 | 333 | gsp_addResultColumn( ((Statement*)self)->_statement->sqlparser, (gsp_base_statement*) ((SqlNode*)node)->_node, text); 334 | newQuery = gsp_getNodeText( (gsp_node*) ((Statement*)self)->_statement->stmt ); 335 | newString = PyString_FromString(newQuery); 336 | free(newQuery); 337 | return newString; 338 | } 339 | 340 | void Statement_dealloc(Statement *self) 341 | { 342 | //printf("Statement_dealloc\n"); 343 | self->ob_type->tp_free((PyObject*)self); 344 | } 345 | 346 | PyObject *Statement_new(PyTypeObject *type, PyObject *args, PyObject *kwds) 347 | { 348 | Statement *self; 349 | 350 | self = (Statement *)type->tp_alloc(type, 0); 351 | 352 | if (self != NULL) { 353 | self->_statement = NULL; 354 | } 355 | 356 | return (PyObject*) self; 357 | } -------------------------------------------------------------------------------- /Statement.h: -------------------------------------------------------------------------------- 1 | #include "node_visitor.h" 2 | #include "gsp_base.h" 3 | #include "gsp_node.h" 4 | #include "gsp_list.h" 5 | #include "gsp_sourcetoken.h" 6 | #include "gsp_sqlparser.h" 7 | #include 8 | #include 9 | #include 10 | 11 | // Statement object 12 | typedef struct { 13 | PyObject_HEAD 14 | gsp_sql_statement *_statement; 15 | } Statement; 16 | 17 | 18 | void Statement_init_type(PyObject *m); 19 | 20 | PyObject *Statement_FromStatement(gsp_sql_statement *stmt); 21 | void Statement_dealloc(Statement *self); 22 | PyObject *Statement_new(PyTypeObject *type, PyObject *args, PyObject *kwds); 23 | PyObject *Statement_getattr(Statement *obj, char *name); 24 | PyObject* Statement_iterate_node_next(PyObject* self, PyObject* args); 25 | PyObject* Statement_get_root(PyObject* self, PyObject* args); 26 | PyObject* Statement_remove_whereclause(PyObject* self, PyObject* args); 27 | PyObject* Statement_remove_orderby(PyObject* self, PyObject* args); 28 | PyObject* Statement_remove_groupby(PyObject* self, PyObject* args); 29 | PyObject* Statement_remove_havingclause(PyObject* self, PyObject* args); 30 | PyObject* Statement_remove_expression(PyObject* self, PyObject* args); 31 | PyObject* Statement_remove_joinitem(PyObject* self, PyObject* args); 32 | PyObject* Statement_remove_resultcolumn(PyObject* self, PyObject* args); 33 | PyObject* Statement_remove_orderbyitem(PyObject* self, PyObject* args); 34 | PyObject* Statement_remove_groupbyitem(PyObject* self, PyObject* args); 35 | PyObject* Statement_add_whereclause(PyObject* self, PyObject* args); 36 | PyObject* Statement_add_orderby(PyObject* self, PyObject* args); 37 | PyObject* Statement_add_groupby(PyObject* self, PyObject* args); 38 | PyObject* Statement_add_havingclause(PyObject* self, PyObject* args); 39 | PyObject* Statement_add_joinitem(PyObject* self, PyObject* args); 40 | PyObject* Statement_add_resultcolumn(PyObject* self, PyObject* args); 41 | 42 | 43 | // Members/properties 44 | static PyMemberDef Statement_members[] = { 45 | {NULL} /* Sentinel */ 46 | }; 47 | 48 | // Object methods 49 | static PyMethodDef Statement_methods[] = { 50 | {"get_root", (PyCFunction)Statement_get_root, METH_VARARGS, "get_root()\nGets the root :class:`Node` of the statement.\n\n:returns: :class:`Node`" }, 51 | {"remove_whereclause", (PyCFunction)Statement_remove_whereclause, METH_VARARGS, "remove_whereclause(node)\nRemoves *node*'s Where clause (if it exists)\n\n:param node: A select statement Node\n:type node: :class:`Node`\n:returns: :class:`Node` -- The updated version of the *node*" }, 52 | {"remove_orderby", (PyCFunction)Statement_remove_orderby, METH_VARARGS, "remove_orderby(node)\nRemoves *node*'s OrderBy clause (if it exists)\n\n:param node: A select statement Node\n:type node: :class:`Node`\n:returns: :class:`Node` -- The updated version of the *node*" }, 53 | {"remove_groupby", (PyCFunction)Statement_remove_groupby, METH_VARARGS, "remove_groupby(node)\nRemoves *node*'s GroupBy clause (if it exists)\n\n:param node: A select statement Node\n:type node: :class:`Node`\n:returns: :class:`Node` -- The updated version of the *node*" }, 54 | {"remove_havingclause", (PyCFunction)Statement_remove_havingclause, METH_VARARGS, "remove_havingclause(node)\nRemoves *node*'s Having clause (if it exists)\n\n:param node: A select statement Node\n:type node: :class:`Node`\n:returns: :class:`Node` -- The updated version of the *node*" }, 55 | {"remove_expression", (PyCFunction)Statement_remove_expression, METH_VARARGS, "remove_expression(node)\nRemoves the expression *node*.\n\n:param node: An expression Node\n:type node: :class:`Node`\n:returns: :class:`Node` -- The updated version of the *node*" }, 56 | {"remove_joinitem", (PyCFunction)Statement_remove_joinitem, METH_VARARGS, "remove_joinitem(node, index)\nRemoves *node*'s Join item at the specified *index*\n\n:param node: A base statement Node\n:type node: :class:`Node`\n:param index: The item's index in the Join clause\n:type index: int\n:returns: :class:`Node` -- The updated version of the *node*" }, 57 | {"remove_resultcolumn", (PyCFunction)Statement_remove_resultcolumn, METH_VARARGS, "remove_resultcolumn(node, index)\nRemoves *node*'s Result column at the specified *index*\n\n:param node: A select statement Node\n:type node: :class:`Node`\n:param index: The item's index in the Join clause\n:type index: int\n:returns: :class:`Node` -- The updated version of the *node*" }, 58 | {"remove_orderbyitem", (PyCFunction)Statement_remove_orderbyitem, METH_VARARGS, "remove_orderbyitem(node, index)\nRemoves *node*'s OrderBy item at the specified *index*\n\n:param node: A base statement Node\n:type node: :class:`Node`\n:param index: The item's index in the Join clause\n:type index: int\n:returns: :class:`Node` -- The updated version of the *node*" }, 59 | {"remove_groupbyitem", (PyCFunction)Statement_remove_groupbyitem, METH_VARARGS, "remove_groupbyitem(node, index)\nRemoves *node*'s GroupBy item at the specified *index*\n\n:param node: A base statement Node\n:type node: :class:`Node`\n:param index: The item's index in the Join clause\n:type index: int\n:returns: :class:`Node` -- The updated version of the *node*" }, 60 | {"add_whereclause", (PyCFunction)Statement_add_whereclause, METH_VARARGS, "add_whereclause(node, text)\nAdds a new Where clause to *node*.\n\n:param node: A base statement Node\n:type node: :class:`Node`\n:param text: String representation of a Where clause\n:type text: str\n:returns: str -- The updated query string" }, 61 | {"add_orderby", (PyCFunction)Statement_add_orderby, METH_VARARGS, "add_orderby(node, text)\nAdds a new OrderBy clause to *node*.\n\n:param node: A select statement Node\n:type node: :class:`Node`\n:param text: String representation of an OrderBy clause\n:type text: str\n:returns: str -- The updated query string" }, 62 | {"add_groupby", (PyCFunction)Statement_add_groupby, METH_VARARGS, "add_groupby(node, text)\nAdds a new GroupBy clause to *node*.\n\n:param node: A select statement Node\n:type node: :class:`Node`\n:param text: String representation of a GroupBy clause\n:type text: str\n:returns: str -- The updated query string" }, 63 | {"add_havingclause", (PyCFunction)Statement_add_havingclause, METH_VARARGS, "add_havingclause(node, text)\nAdds a new Having clause to *node*.\n\n:param node: A select statement Node\n:type node: :class:`Node`\n:param text: String representation of a Having clause\n:type text: str\n:returns: str -- The updated query string" }, 64 | {"add_joinitem", (PyCFunction)Statement_add_joinitem, METH_VARARGS, "add_joinitem(node, text)\nAdds a new Join item to *node*.\n\n:param node: A select statement Node\n:type node: :class:`Node`\n:param text: String representation of a Joint item\n:type text: str\n:returns: str -- The updated query string" }, 65 | {"add_resultcolumn", (PyCFunction)Statement_add_resultcolumn, METH_VARARGS, "add_resultcolumn(node, text)\nAdds a new Result column to *node*.\n\n:param node: A base statement Node\n:type node: :class:`Node`\n:param text: String representation of a Result column\n:type text: str\n:returns: str -- The updated query string" }, 66 | {NULL} /* Sentinel */ 67 | }; 68 | 69 | // Type object for Statement 70 | static PyTypeObject StatementType = { 71 | PyObject_HEAD_INIT(NULL) 72 | 0, /*ob_size*/ 73 | "parsebridge.Statement", /*tp_name*/ 74 | sizeof(Statement), /*tp_basicsize*/ 75 | 0, /*tp_itemsize*/ 76 | (destructor)Statement_dealloc, /*tp_dealloc*/ 77 | 0, /*tp_print*/ 78 | 0, /*tp_getattr*/ 79 | 0, /*tp_setattr*/ 80 | 0, /*tp_compare*/ 81 | 0, /*tp_repr*/ 82 | 0, /*tp_as_number*/ 83 | 0, /*tp_as_sequence*/ 84 | 0, /*tp_as_mapping*/ 85 | 0, /*tp_hash */ 86 | 0, /*tp_call*/ 87 | 0, /*tp_str*/ 88 | 0, /*tp_getattro*/ 89 | 0, /*tp_setattro*/ 90 | 0, /*tp_as_buffer*/ 91 | Py_TPFLAGS_DEFAULT, /*tp_flags*/ 92 | "Statement objects", /* tp_doc */ 93 | 0, /* tp_traverse */ 94 | 0, /* tp_clear */ 95 | 0, /* tp_richcompare */ 96 | 0, /* tp_weaklistoffset */ 97 | 0, /* tp_iter */ 98 | 0, /* tp_iternext */ 99 | Statement_methods, /* tp_methods */ 100 | Statement_members, /* tp_members */ 101 | 0, /* tp_getset */ 102 | 0, /* tp_base */ 103 | 0, /* tp_dict */ 104 | 0, /* tp_descr_get */ 105 | 0, /* tp_descr_set */ 106 | 0, /* tp_dictoffset */ 107 | 0, /* tp_init */ 108 | 0, /* tp_alloc */ 109 | Statement_new, /* tp_new */ 110 | }; -------------------------------------------------------------------------------- /examples/nodevisitor.py: -------------------------------------------------------------------------------- 1 | import inspect 2 | 3 | import sqlparser 4 | from sqlparser import ENodeType 5 | 6 | Continue = 0 7 | Break = 1 8 | ContinueAndNotify = 2 9 | 10 | node_functions = {} 11 | 12 | 13 | class NodeVisitor: 14 | 15 | def __init__(self, root_node): 16 | self.root = root_node 17 | self.node_functions = {} 18 | tmp = dir(self) 19 | 20 | if 'visit_node' in tmp: 21 | self.has_visit_node = True 22 | else: 23 | self.has_visit_node = False 24 | 25 | if 'visit_string' in tmp: 26 | self.has_visit_string = True 27 | else: 28 | self.has_visit_string = False 29 | 30 | if 'visit_generic' in tmp: 31 | self.has_visit_generic = True 32 | else: 33 | self.has_visit_generic = False 34 | 35 | for k in dir(self.__class__): 36 | func = getattr(self.__class__, k) 37 | if hasattr(func, 'when'): 38 | self.node_functions[func.when] = func 39 | 40 | def traverse(self, node=None, d=0, name='root'): 41 | if not node: 42 | node = self.root 43 | ret = Continue 44 | 45 | if self.has_visit_generic: 46 | self.visit_generic(node, d, name) 47 | if isinstance(node, sqlparser.Node): 48 | if node.node_type in self.node_functions: 49 | ret = self.node_functions[node.node_type](self, node, d, name) 50 | elif self.has_visit_node: 51 | ret = self.visit_node(node, d, name) 52 | 53 | if node.node_type == ENodeType.list: 54 | if ret == Continue or ret == ContinueAndNotify: 55 | for idx, i in enumerate(node.list): 56 | self.traverse(i, d + 1, 'item' + str(idx)) 57 | else: 58 | if ret == Continue or ret == ContinueAndNotify: 59 | for k, v in node.__dict__.iteritems(): 60 | if v: 61 | self.traverse(v, d + 1, k) 62 | if ret == ContinueAndNotify: 63 | self.leave_node(node, d, name) 64 | elif isinstance(node, str): 65 | if self.has_visit_string: 66 | self.visit_string(node, d, name) 67 | elif isinstance(node, int): 68 | pass 69 | 70 | 71 | def when(*args): 72 | def decorate(f): 73 | setattr(f, 'when', args[0]) 74 | return f 75 | return decorate 76 | -------------------------------------------------------------------------------- /examples/visitor_tables.py: -------------------------------------------------------------------------------- 1 | import sqlparser 2 | from sqlparser import ENodeType, EExpressionType, ETableSource 3 | import nodevisitor 4 | from nodevisitor import NodeVisitor 5 | 6 | class TableVisitor(NodeVisitor): 7 | 8 | def __init__(self, root_node): 9 | NodeVisitor.__init__(self, root_node) 10 | 11 | # Keeps track of the subquery select statements 12 | # each time we find a subquery, we push the root node onto here 13 | # when we leave a subquery, we pop it 14 | self.current_select = [] 15 | 16 | # Keeps a list of all tables that were used in the *root* select statement 17 | self.used_tables = [] 18 | 19 | def get_fromTable_names(self, node): 20 | # This is a helper function that will acccept a fromTable node 21 | # and return a tuple of (alias, real_name) 22 | 23 | name = None 24 | alias = None 25 | 26 | # Check if the node has an alias clause 27 | if node.aliasClause and node.aliasClause.aliasName: 28 | # if it is a simple alias (objectname) 29 | if node.aliasClause.aliasName.node_type == ENodeType.objectname: 30 | # objectnames can be either "partToken" or "objectToken.partToken" 31 | # but an alias should only have one token 32 | alias = node.aliasClause.aliasName.partToken.upper().strip('"') 33 | 34 | # Check if the tableName is available 35 | if node.tableName: 36 | if node.tableName.node_type == ENodeType.objectname: 37 | name = node.tableName.partToken.upper().strip('"') 38 | 39 | return name, alias 40 | 41 | # Use nodevisitor.when to provide a callback for certain node types 42 | @nodevisitor.when(ENodeType.selectStatement) 43 | def visit_selectStatement(self, node, d, name): 44 | # found a new select statement. 45 | # push it into the list 46 | self.current_select.append(node) 47 | 48 | # continue traversing but notify me when you leave this node's subtree 49 | return nodevisitor.ContinueAndNotify 50 | 51 | # this function will be called for ContinueAndNotify 52 | def leave_node(self, node, d, name): 53 | if node.node_type == ENodeType.selectStatement: 54 | # remove the current select node from the list 55 | self.current_select.pop() 56 | 57 | # This will be called for every from table name 58 | @nodevisitor.when(ENodeType.fromTable) 59 | def visit_fromTable(self, node, d, name): 60 | if len(self.current_select) == 0 or self.current_select[-1] != self.root: 61 | # only save tables for the root statement 62 | return nodevisitor.Continue 63 | 64 | table = {} 65 | 66 | # Retrieve table name + alias 67 | name, alias = self.get_fromTable_names(node) 68 | if name is not None: 69 | table['position'] = node.get_position() 70 | table['name'] = name 71 | table['alias'] = alias 72 | 73 | self.used_tables.append(table) 74 | 75 | # continue traversing this tree 76 | return nodevisitor.Continue 77 | 78 | if __name__ == '__main__': 79 | query = """SELECT a, b, c FROM table1 "FOO" inner join "TABLE2" ON a = b""" 80 | 81 | # Create a new parser 82 | parser = sqlparser.Parser(vendor=0) 83 | # Check syntax 84 | assert parser.check_syntax(query) == 0 85 | # Get first statement 86 | stmt = parser.get_statement(0) 87 | # Get root node 88 | root = stmt.get_root() 89 | 90 | # Create new visitor instance from root 91 | visitor = TableVisitor(root) 92 | # Traverse the syntax tree 93 | visitor.traverse() 94 | 95 | for table in visitor.used_tables: 96 | if table['alias']: 97 | print "%s => %s @ %s" % (table['alias'], table['name'], table['position']) 98 | else: 99 | print "%s @ %s" % (table['name'], table['position']) 100 | -------------------------------------------------------------------------------- /examples/visualize_tree.py: -------------------------------------------------------------------------------- 1 | import sqlparser 2 | from sqlparser import ENodeType 3 | 4 | 5 | # Translates a node_type ID into a string 6 | def translate_node_type(node_type): 7 | for k,v in ENodeType.__dict__.iteritems(): 8 | if v == node_type: 9 | return k 10 | return None 11 | 12 | # Print node and traverse recursively 13 | def process_node(node, depth=0, name='root'): 14 | 15 | # print attributes like ints and strings 16 | if not isinstance(node, sqlparser.Node): 17 | print "%s%s: '%s'" % (" " * depth, name, str(node)) 18 | return 19 | 20 | # print node attribute 21 | if node is not None and isinstance(node, sqlparser.Node): 22 | print "%s%s: %s (%d), text: '%s'" % (" " * depth, name, translate_node_type(node.node_type), node.node_type, node.get_text()) 23 | 24 | # Go through the list (if the current node is a list) 25 | if node.node_type == ENodeType.list: 26 | for i, subnode in enumerate(node.list): 27 | process_node(subnode, depth + 1, 'list_item#%s' % i) 28 | return 29 | 30 | # Iterate through all attributes 31 | for k,v in node.__dict__.items(): 32 | process_node(v, depth + 1, k) 33 | 34 | 35 | parser = sqlparser.Parser(vendor=0) 36 | query = "SELECT a, b, c FROM tbl1 WHERE d IN (1,2,3)" 37 | parser.check_syntax(query) 38 | stmt = parser.get_statement(0) 39 | root = stmt.get_root() 40 | 41 | process_node(root) 42 | -------------------------------------------------------------------------------- /parsebridgemodule.c: -------------------------------------------------------------------------------- 1 | //#include "node_visitor.h" 2 | #include "gsp_base.h" 3 | #include "gsp_node.h" 4 | #include "gsp_list.h" 5 | #include "gsp_sourcetoken.h" 6 | #include "gsp_sqlparser.h" 7 | #include 8 | #include 9 | #include 10 | 11 | #include "Parser.h" 12 | #include "Statement.h" 13 | #include "Node.h" 14 | #include "ENodeType.h" 15 | 16 | // Module functions 17 | static PyMethodDef BridgeMethods[] = 18 | { 19 | {NULL, NULL, 0, NULL} 20 | }; 21 | 22 | PyMODINIT_FUNC 23 | initsqlparser(void) 24 | { 25 | PyObject *m; 26 | 27 | // initialize module 28 | m = Py_InitModule3("sqlparser", BridgeMethods, "Bridge between python and sqlparser"); 29 | 30 | if (m == NULL) return; 31 | 32 | // Initialize our custom types 33 | Parser_init_type(m); 34 | Node_init_type(m); 35 | Statement_init_type(m); 36 | Enum_init_type(m); 37 | } -------------------------------------------------------------------------------- /setup.py: -------------------------------------------------------------------------------- 1 | # coding=utf-8 2 | 3 | from distutils.core import setup, Extension 4 | import sys 5 | import os 6 | 7 | ARCH='64' 8 | SQLPARSER_DIR = './general_sql_parser/' 9 | 10 | if sys.maxsize > 2**32: 11 | ARCH = '64' 12 | else: 13 | ARCH = '32' 14 | 15 | def download_library(): 16 | import urllib 17 | 18 | file_name = "gsp_c_lib.tar.gz" 19 | 20 | url = "http://www.sqlparser.com/dl/gsqlparser_c_linux32_trial_1_0_1.tar.gz" 21 | if os.name == "nt": 22 | if ARCH == '32': 23 | url = "http://www.sqlparser.com/dl/gsqlparser_c_win32_trial_1_1_0.zip" 24 | else: 25 | url = "http://www.sqlparser.com/dl/gsqlparser_c_win64_trial_1_1_0.zip" 26 | file_name = "gsp_c_lib.zip" 27 | else: 28 | if ARCH == '64': 29 | url = "http://www.sqlparser.com/dl/gsqlparser_c_linux64_trial_1_1_0.tar.gz" 30 | 31 | print "Downloading library from '%s'..." % url 32 | 33 | urllib.urlretrieve(url, file_name) 34 | 35 | print "Done!" 36 | print "Extracting archive..." 37 | 38 | if os.name == "nt": 39 | import zipfile 40 | 41 | archive = zipfile.ZipFile(file_name, 'r') 42 | archive.extractall(SQLPARSER_DIR) 43 | else: 44 | import tarfile 45 | 46 | archive = tarfile.open(file_name) 47 | archive.extractall(SQLPARSER_DIR) 48 | 49 | print "Done!" 50 | 51 | 52 | if __name__ == '__main__': 53 | if not os.path.isdir(SQLPARSER_DIR): 54 | print "Could not find the general sql parser library in %s" % SQLPARSER_DIR 55 | answer = raw_input("Do you want to download it now? (Y, N): ") 56 | 57 | if answer and answer.upper() == 'Y': 58 | download_library() 59 | 60 | # check again (the user might have downloaded the library) 61 | if os.path.isdir(SQLPARSER_DIR): 62 | parsebridge = Extension('sqlparser', 63 | sources = ['Parser.c', 'Statement.c', 'Node.c', 'ENodeType.c', 'parsebridgemodule.c', 64 | SQLPARSER_DIR + 'ext/node_visitor/node_visitor.c', 65 | SQLPARSER_DIR + 'ext/expr_traverse/expr_traverse.c', 66 | SQLPARSER_DIR + 'ext/modifysql/modifysql.c' ], 67 | include_dirs = [ SQLPARSER_DIR + 'core/', 68 | SQLPARSER_DIR + 'ext/collection/includes/', 69 | SQLPARSER_DIR + 'ext/expr_traverse/', 70 | SQLPARSER_DIR + 'ext/modifysql/', 71 | SQLPARSER_DIR + 'ext/node_visitor/' ], 72 | library_dirs = [ SQLPARSER_DIR + '/lib/' ], 73 | libraries = [ 'gspcollection', 'gspcore' ], 74 | define_macros = [ ('_CRT_SECURE_NO_WARNINGS', None), ('DONT_FIX_FRAGMENTS', None), ], 75 | extra_compile_args = ['-Wno-strict-prototypes'], 76 | 77 | ) 78 | 79 | if sys.platform == 'win32' or sys.platform == 'win64': 80 | parsebridge.extra_link_args = [ '/MANIFEST', '/DEBUG' ] 81 | parsebridge.extra_compile_args = [ '/Zi' ] 82 | 83 | setup (name = 'sqlparser', 84 | version = '1.0', 85 | description = 'A package for parsing SQL queries', 86 | author = 'Timo Djürken', 87 | url = 'https://github.com/TwoLaid/python-sqlparser', 88 | license = 'GPL', 89 | ext_modules = [ parsebridge ]) 90 | --------------------------------------------------------------------------------