← Back
Editing: expr.py
# MySQL Connector/Python - MySQL driver written in Python. # Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved. # MySQL Connector/Python is licensed under the terms of the GPLv2 # <http://www.gnu.org/licenses/old-licenses/gpl-2.0.html>, like most # MySQL Connectors. There are special exceptions to the terms and # conditions of the GPLv2 as it is applied to this software, see the # FOSS License Exception # <http://www.mysql.com/about/legal/licensing/foss-exception.html>. # # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA from .compat import STRING_TYPES, PY3 from .protobuf.mysqlx_datatypes_pb2 import Scalar from .protobuf.mysqlx_expr_pb2 import ColumnIdentifier, DocumentPathItem, Expr from .protobuf.mysqlx_crud_pb2 import Column, Order, Projection if PY3: xrange = range class TokenType: NOT = 1 AND = 2 OR = 3 XOR = 4 IS = 5 LPAREN = 6 RPAREN = 7 LSQBRACKET = 8 RSQBRACKET = 9 BETWEEN = 10 TRUE = 11 NULL = 12 FALSE = 13 IN = 14 LIKE = 15 INTERVAL = 16 REGEXP = 17 ESCAPE = 18 IDENT = 19 LSTRING = 20 LNUM = 21 DOT = 22 DOLLAR = 23 COMMA = 24 EQ = 25 NE = 26 GT = 27 GE = 28 LT = 29 LE = 30 BITAND = 31 BITOR = 32 BITXOR = 33 LSHIFT = 34 RSHIFT = 35 PLUS = 36 MINUS = 37 MUL = 38 DIV = 39 HEX = 40 BIN = 41 NEG = 42 BANG = 43 MICROSECOND = 44 SECOND = 45 MINUTE = 46 HOUR = 47 DAY = 48 WEEK = 49 MONTH = 50 QUARTER = 51 YEAR = 52 EROTEME = 53 DOUBLESTAR = 54 MOD = 55 COLON = 56 OROR = 57 ANDAND = 58 LCURLY = 59 RCURLY = 60 CAST = 61 DOTSTAR = 62 ORDERBY_ASC = 63 ORDERBY_DESC = 64 AS = 65 interval_units = set([ TokenType.MICROSECOND, TokenType.SECOND, TokenType.MINUTE, TokenType.HOUR, TokenType.DAY, TokenType.WEEK, TokenType.MONTH, TokenType.QUARTER, TokenType.YEAR]) # map of reserved word to token type reservedWords = { "and": TokenType.AND, "or": TokenType.OR, "xor": TokenType.XOR, "is": TokenType.IS, "not": TokenType.NOT, "like": TokenType.LIKE, "in": TokenType.IN, "regexp": TokenType.REGEXP, "between": TokenType.BETWEEN, "interval": TokenType.INTERVAL, "escape": TokenType.ESCAPE, "cast": TokenType.CAST, "div": TokenType.DIV, "hex": TokenType.HEX, "bin": TokenType.BIN, "true": TokenType.TRUE, "false": TokenType.FALSE, "null": TokenType.NULL, "second": TokenType.SECOND, "minute": TokenType.MINUTE, "hour": TokenType.HOUR, "day": TokenType.DAY, "week": TokenType.WEEK, "month": TokenType.MONTH, "quarter": TokenType.QUARTER, "year": TokenType.YEAR, "microsecond": TokenType.MICROSECOND, "asc": TokenType.ORDERBY_ASC, "desc": TokenType.ORDERBY_DESC, "as": TokenType.AS } class Token: def __init__(self, type, val, len=1): self.type = type self.val = val self.len = len def __repr__(self): return self.__str__() def __str__(self): if self.type == TokenType.IDENT or self.type == TokenType.LNUM or \ self.type == TokenType.LSTRING: return str(self.type) + "(" + self.val + ")" else: return str(self.type) # static protobuf helper functions def build_null_scalar(): return Scalar(type=Scalar.V_NULL) def build_double_scalar(d): return Scalar(type=Scalar.V_DOUBLE, v_double=d) def build_int_scalar(i): return Scalar(type=Scalar.V_SINT, v_signed_int=i) def build_string_scalar(s): if isinstance(s, STRING_TYPES): s = bytes(bytearray(s, "utf-8")) return Scalar(type=Scalar.V_STRING, v_string=Scalar.String(value=s)) def build_bool_scalar(b): s = Scalar() s.type = Scalar.V_BOOL s.v_bool = b return s def build_literal_expr(anyval): e = Expr() e.type = Expr.LITERAL e.literal.CopyFrom(anyval) return e def build_unary_op(name, param): e = Expr() e.type = Expr.OPERATOR e.operator.name = name e.operator.param.add().CopyFrom(param) return e def escape_literal(string): return string.replace('"', '""') class ExprParser: def __init__(self, string, allowRelational): self.string = string self.tokens = [] self.pos = 0 self._allowRelationalColumns = allowRelational self.placeholder_name_to_position = {} self.positional_placeholder_count = 0 self.lex() # convencience checker for lexer def next_char_is(self, i, c): return i + 1 < len(self.string) and self.string[i + 1] == c def lex_number(self, pos): # numeric literal start = pos found_dot = False while pos < len(self.string) and (self.string[pos].isdigit() or self.string[pos] == "."): if self.string[pos] == ".": if found_dot is True: raise ValueError("Invalid number. Found multiple '.'") found_dot = True # technically we allow more than one "." and let float()'s parsing # complain later pos = pos + 1 val = self.string[start:pos] t = Token(TokenType.LNUM, val, len(val)) return t def lex_alpha(self, i): start = i while i < len(self.string) and (self.string[i].isalnum() or self.string[i] == "_"): i = i + 1 val = self.string[start:i] try: token = Token(reservedWords[val.lower()], val.upper(), len(val)) except KeyError: token = Token(TokenType.IDENT, val, len(val)) return token def lex_quoted_token(self, i): quote_char = self.string[i] val = "" i += 1 start = i while i < len(self.string): c = self.string[i] if c == quote_char and i + 1 < len(self.string) and \ self.string[i + 1] != quote_char: # break if we have a quote char that's not double break elif c == quote_char or c == "\\": # this quote char has to be doubled if i + 1 >= len(self.string): break i = i + 1 val = val + self.string[i] else: val = val + c i = i + 1 if i >= len(self.string) or self.string[i] != quote_char: raise ValueError("Unterminated quoted string starting at {0}" "".format(start)) if quote_char == "`": return Token(TokenType.IDENT, val, len(val)+2) else: return Token(TokenType.LSTRING, val, len(val)+2) def lex(self): i = 0 while i < len(self.string): c = self.string[i] if c.isspace(): i += 1 continue elif c.isdigit(): token = self.lex_number(i) elif c.isalpha() or c == "_": token = self.lex_alpha(i) elif c == "?": token = Token(TokenType.EROTEME, c) elif c == ":": token = Token(TokenType.COLON, c) elif c == "{": token = Token(TokenType.LCURLY, c) elif c == "}": token = Token(TokenType.RCURLY, c) elif c == "+": token = Token(TokenType.PLUS, c) elif c == "-": Token(TokenType.MINUS, c) elif c == "*": if self.next_char_is(i, "*"): token = Token(TokenType.DOUBLESTAR, "**") else: token = Token(TokenType.MUL, c) elif c == "/": token = Token(TokenType.DIV, c) elif c == "$": token = Token(TokenType.DOLLAR, c) elif c == "%": token = Token(TokenType.MOD, c) elif c == "=": if self.next_char_is(i, "="): token = Token(TokenType.EQ, "==", 2) else: token = Token(TokenType.EQ, "==", 1) elif c == "&": if self.next_char_is(i, "&"): token = Token(TokenType.ANDAND, c) else: token = Token(TokenType.BITAND, c) elif c == "|": if self.next_char_is(i, "|"): token = Token(TokenType.OROR, "||") else: token = Token(TokenType.BITOR, c) elif c == "(": token = Token(TokenType.LPAREN, c) elif c == ")": token = Token(TokenType.RPAREN, c) elif c == "[": token = Token(TokenType.LSQBRACKET, c) elif c == "]": token = Token(TokenType.RSQBRACKET, c) elif c == "~": token = Token(TokenType.NEG, c) elif c == ",": token = Token(TokenType.COMMA, c) elif c == "!": if self.next_char_is(i, "="): token = Token(TokenType.NE, "!=") else: token = Token(TokenType.BANG, c) elif c == "<": if self.next_char_is(i, "<"): token = Token(TokenType.LSHIFT, "<<") elif self.next_char_is(i, "="): token = Token(TokenType.LE, "<=") else: token = Token(TokenType.LT, c) elif c == ">": if self.next_char_is(i, ">"): token = Token(TokenType.RSHIFT, ">>") elif self.next_char_is(i, "="): token = Token(TokenType.GE, ">=") else: token = Token(TokenType.GT, c) elif c == ".": if self.next_char_is(i, "*"): token = Token(TokenType.DOTSTAR, ".*") elif i + 1 < len(self.string) and self.string[i + 1].isdigit(): token = self.lex_number(i) else: token = Token(TokenType.DOT, c) elif c == '"' or c == "'" or c == "`": token = self.lex_quoted_token(i) else: raise ValueError("Unknown character at {0}".format(i)) self.tokens.append(token) i += token.len def assert_cur_token(self, type): if self.pos >= len(self.tokens): raise ValueError("Expected token type {0} at pos {1} but no " "tokens left".format(type, self.pos)) if self.tokens[self.pos].type != type: raise ValueError("Expected token type {0} at pos {1} but found " "type {2}".format(type, self.pos, self.tokens[self.pos])) def cur_token_type_is(self, type): return self.pos_token_type_is(self.pos, type) def next_token_type_is(self, type): return self.pos_token_type_is(self.pos + 1, type) def pos_token_type_is(self, pos, type): return pos < len(self.tokens) and self.tokens[pos].type == type def consume_token(self, type): self.assert_cur_token(type) v = self.tokens[self.pos].val self.pos = self.pos + 1 return v def paren_expr_list(self): """Parse a paren-bounded expression list for function arguments or IN list and return a list of Expr objects. """ exprs = [] self.consume_token(TokenType.LPAREN) if not self.cur_token_type_is(TokenType.RPAREN): exprs.append(self.expr()) while self.cur_token_type_is(TokenType.COMMA): self.pos = self.pos + 1 exprs.append(self.expr()) self.consume_token(TokenType.RPAREN) return exprs def identifier(self): self.assert_cur_token(TokenType.IDENT) id = Identifier() if self.next_token_type_is(TokenType.DOT): id.schema_name = self.consume_token(TokenType.IDENT) self.consume_token(TokenType.DOT) id.name = self.tokens[self.pos].val self.pos = self.pos + 1 return id def function_call(self): e = Expr() e.type = Expr.FUNC_CALL e.function_call.name.CopyFrom(self.identifier()) e.function_call.param.extend(self.paren_expr_list()) return e def docpath_member(self): self.consume_token(TokenType.DOT) token = self.tokens[self.pos] if token.type == TokenType.IDENT: if token.val.startswith('`') and token.val.endswith('`'): raise ValueError("{0} is not a valid JSON/ECMAScript " "identifier".format(token.value)) self.consume_token(TokenType.IDENT) memberName = token.val elif self.token.type == TokenType.LSTRING: self.consume_token(TokenType.LSTRING) memberName = token.val else: raise ValueError("Expected token type IDENT or LSTRING in JSON " "path at token pos {0}".format(self.pos)) item = DocumentPathItem(type=DocumentPathItem.MEMBER, value=memberName) return item def docpath_array_loc(self): self.consume_token(TokenType.LSQBRACKET) if self.cur_token_type_is(TokenType.MUL): self.consume_token(TokenType.RSQBRACKET) return DocumentPathItem(type=DocumentPathItem.ARRAY_INDEX_ASTERISK) elif self.cur_token_type_is(TokenType.LNUM): v = int(self.consume_token(TokenType.LNUM)) if v < 0: raise IndexError("Array index cannot be negative at {0}" "".format(self.pos)) self.consume_token(TokenType.RSQBRACKET) return DocumentPathItem(type=DocumentPathItem.ARRAY_INDEX, index=v) else: raise ValueError("Exception token type MUL or LNUM in JSON " "path array index at token pos {0}" "".format(self.pos)) def document_field(self): col = ColumnIdentifier() if self.cur_token_type_is(TokenType.IDENT): col.document_path.extend([ DocumentPathItem(type=DocumentPathItem.MEMBER, value=self.consume_token(TokenType.IDENT))]) col.document_path.extend(self.document_path()) return Expr(type=Expr.IDENT, identifier=col) def document_path(self): """Parse a JSON-style document path, like WL#7909, but prefix by @. instead of $. We parse this as a string because the protocol doesn't support it. (yet) """ docpath = [] while True: if self.cur_token_type_is(TokenType.DOT): docpath.append(self.docpath_member()) elif self.cur_token_type_is(TokenType.DOTSTAR): self.consume_token(TokenType.DOTSTAR) docpath.append(DocumentPathItem( type=DocumentPathItem.MEMBER_ASTERISK)) elif self.cur_token_type_is(TokenType.LSQBRACKET): docpath.append(self.docpath_array_loc()) elif self.cur_token_type_is(TokenType.DOUBLESTAR): self.consume_token(TokenType.DOUBLESTAR) docpath.append(DocumentPathItem( type=DocumentPathItem.DOUBLE_ASTERISK)) else: break items = len(docpath) if items > 0 and docpath[items-1].type == \ DocumentPathItem.DOUBLE_ASTERISK: raise ValueError("JSON path may not end in '**' at {0}" "".format(self.pos)) return docpath def column_identifier(self): parts = [] parts.append(self.consume_token(TokenType.IDENT)) while self.cur_token_type_is(TokenType.DOT): self.consume_token(TokenType.DOT) parts.append(self.consume_token(TokenType.IDENT)) if len(parts) > 3: raise ValueError("Too many parts to identifier at {0}" "".format(self.pos)) parts.reverse() colid = ColumnIdentifier() # clever way to apply them to the struct for i in xrange(0, len(parts)): if i == 0: colid.name = parts[0] elif i == 1: colid.table_name = parts[1] elif i == 2: colid.schema_name = parts[2] if self.cur_token_type_is(TokenType.DOLLAR): self.consume_token(TokenType.DOLLAR) colid.document_path = self.document_path() e = Expr() e.type = Expr.IDENT e.identifier.CopyFrom(colid) return e def next_token(self): if (self.pos >= len(self.tokens)): raise ValueError("Unexpected end of token stream") t = self.tokens[self.pos] self.pos += 1 return t def expect_token(self, token_type): t = self.next_token() if t.type != token_type: raise ValueError("Expected token type {0}".format(token_type)) def parse_json_doc(self): o = Object() def parse_place_holder(self, token): place_holder_name = "" if self.cur_token_type_is(TokenType.LNUM): place_holder_name = self.consume_token(TokenType.LNUM_INT) elif self.cur_token_type_is(TokenType.IDENT): place_holder_name = self.consume_token(TokenType.IDENT) elif token.type == TokenType.EROTEME: place_holder_name = str(self.positional_placeholder_count) else: raise ValueError("Invalid placeholder name at token pos {0}" "".format(self.pos)) place_holder_name = place_holder_name.lower() expr = Expr(type=Expr.PLACEHOLDER) if place_holder_name in self.placeholder_name_to_position: expr.position = \ self.placeholder_name_to_position[place_holder_name] else: expr.position = self.positional_placeholder_count self.placeholder_name_to_position[place_holder_name] = \ self.positional_placeholder_count self.positional_placeholder_count += 1 return expr def atomic_expr(self): """Parse an atomic expression and return a protobuf Expr object""" token = self.next_token() if token.type in [TokenType.EROTEME, TokenType.COLON]: return self.parse_place_holder(token) elif token.type == TokenType.LCURLY: return self.parse_json_doc() elif token.type == TokenType.CAST: # TODO implement pass pass elif token.type == TokenType.LPAREN: e = self.expr() self.expect_token(TokenType.RPAREN) return e elif token.type in [TokenType.PLUS, TokenType.MINUS]: pass elif token.type in [TokenType.PLUS, TokenType.MINUS]: peek = self.peek_token() if peek.type == TokenType.LNUM: self.tokens[self.pos].val = token.val + peek.val return self.atomic_expr() return build_unary_op(token.val, self.atomic_expr()) elif token.type in [TokenType.NOT, TokenType.NEG, TokenType.BANG]: return build_unary_op(token.val, self.atomic_expr()) elif token.type == TokenType.LSTRING: return build_literal_expr(build_string_scalar(token.val)) elif token.type == TokenType.NULL: return build_literal_expr(build_null_scalar()) elif token.type == TokenType.LNUM: if "." in token.val: return build_literal_expr( build_double_scalar(float(token.val))) else: return build_literal_expr(build_int_scalar(int(token.val))) elif token.type in [TokenType.TRUE, TokenType.FALSE]: return build_literal_expr( build_bool_scalar(token.type == TokenType.TRUE)) elif token.type == TokenType.DOLLAR: return self.document_field() elif token.type == TokenType.MUL: return self.starOperator() elif token.type == TokenType.IDENT: self.pos = self.pos - 1 # stay on the identifier if self.next_token_type_is(TokenType.LPAREN) or \ (self.next_token_type_is(TokenType.DOT) and self.pos_token_type_is(self.pos + 2, TokenType.IDENT) and self.pos_token_type_is(self.pos + 3, TokenType.LPAREN)): # Function call return self.function_call() else: return (self.document_field() if not self._allowRelationalColumns else self.column_identifier()) # if t.type == TokenType.EROTEME: # return build_literal_expr(build_string_scalar("?")) # elif t.type == TokenType.INTERVAL: # e = Expr() # e.type = Expr.OPERATOR # e.operator.name = "INTERVAL" # e.operator.param.add().CopyFrom(self.expr()) # # validate the interval units # if self.pos < len(self.tokens) and self.tokens[self.pos].type in interval_units: # pass # else: # raise StandardError("Expected interval units at " + str(self.pos)) # e.operator.param.add().CopyFrom(build_literal_expr(build_string_scalar(self.tokens[self.pos].val))) # self.pos = self.pos + 1 # return e raise ValueError("Unknown token type = {0} when expecting atomic " "expression at {1}".format(token.type, self.pos)) def parse_left_assoc_binary_op_expr(self, types, inner_parser): """Given a `set' of types and an Expr-returning inner parser function, parse a left associate binary operator expression""" lhs = inner_parser() while (self.pos < len(self.tokens) and self.tokens[self.pos].type in types): e = Expr() e.type = Expr.OPERATOR e.operator.name = self.tokens[self.pos].val e.operator.param.add().CopyFrom(lhs) self.pos = self.pos + 1 e.operator.param.add().CopyFrom(inner_parser()) lhs = e return lhs # operator precedence is implemented here def mul_div_expr(self): return self.parse_left_assoc_binary_op_expr( set([TokenType.MUL, TokenType.DIV, TokenType.MOD]), self.atomic_expr) def add_sub_expr(self): return self.parse_left_assoc_binary_op_expr( set([TokenType.PLUS, TokenType.MINUS]), self.mul_div_expr) def shift_expr(self): return self.parse_left_assoc_binary_op_expr( set([TokenType.LSHIFT, TokenType.RSHIFT]), self.add_sub_expr) def bit_expr(self): return self.parse_left_assoc_binary_op_expr( set([TokenType.BITAND, TokenType.BITOR, TokenType.BITXOR]), self.shift_expr) def comp_expr(self): return self.parse_left_assoc_binary_op_expr( set([TokenType.GE, TokenType.GT, TokenType.LE, TokenType.LT, TokenType.EQ, TokenType.NE]), self.bit_expr) def ilri_expr(self): lhs = self.comp_expr() is_not = False if self.cur_token_type_is(TokenType.NOT): is_not = True self.consume_token(TokenType.NOT) if self.pos < len(self.tokens): params = [lhs] op_name = self.tokens[self.pos].val if self.cur_token_type_is(TokenType.IS): self.consume_token(TokenType.IS) # for IS, NOT comes AFTER if self.cur_token_type_is(TokenType.NOT): is_not = True self.consume_token(TokenType.NOT) params.append(self.comp_expr()) elif self.cur_token_type_is(TokenType.IN): self.consume_token(TokenType.IN) params.extend(self.paren_expr_list()) elif self.cur_token_type_is(TokenType.LIKE): self.consume_token(TokenType.LIKE) params.append(self.comp_expr()) if self.cur_token_type_is(TokenType.ESCAPE): self.consume_token(TokenType.ESCAPE) params.append(self.comp_expr()) elif self.cur_token_type_is(TokenType.BETWEEN): self.consume_token(TokenType.BETWEEN) params.append(self.comp_expr()) self.consume_token(TokenType.AND) params.append(self.comp_expr()) elif self.cur_token_type_is(TokenType.REGEXP): self.consume_token(TokenType.REGEXP) params.append(self.comp_expr()) else: if is_not: raise ValueError("Unknown token after NOT as pos {0}" "".format(self.pos)) op_name = None # not an operator we're interested in if op_name: e = Expr() e.type = Expr.OPERATOR e.operator.name = op_name e.operator.param.extend(params) if is_not: # wrap if `NOT'-prefixed e = build_unary_op("NOT", e) lhs = e return lhs def and_expr(self): return self.parse_left_assoc_binary_op_expr( set([TokenType.AND, TokenType.ANDAND]), self.ilri_expr) def or_expr(self): return self.parse_left_assoc_binary_op_expr( set([TokenType.OR, TokenType.OROR]), self.and_expr) def expr(self): return self.or_expr() def parse_table_insert_field(self): return Column(name=self.consume_token(TokenType.IDENT)) def parse_table_update_field(self): return self.column_identifier().identifier def parse_table_select_projection(self): project_expr = [] first = True while self.pos < len(self.tokens): if not first: self.consume_token(TokenType.COMMA) first = False projection = Projection(source=self.expr()) if self.cur_token_type_is(TokenType.AS): self.consume_token(TokenType.AS) projection.alias = self.consume_token(TokenType.IDENT) else: self.pos -= 1 projection.alias = self.consume_token(TokenType.IDENT) project_expr.append(projection) return project_expr def parse_order_spec(self): order_specs = [] first = True while self.pos < len(self.tokens): if not first: self.consume_token(TokenType.COMMA) first = False order = Order(expr=self.expr()) if self.cur_token_type_is(TokenType.ORDERBY_ASC): order.direction = Order.ASC self.consume_token(TokenType.ORDERBY_ASC) elif self.cur_token_type_is(TokenType.ORDERBY_DESC): order.direction = Order.DESC self.consume_token(TokenType.ORDERBY_DESC) order_specs.append(order) return order_specs def parse_expr_list(self): expr_list = [] first = True while self.pos < len(self.tokens): if not first: self.consume_token(TokenType.COMMA) first = False expr_list.append(self.expr()) return expr_list def parseAndPrintExpr(expr_string, allowRelational=True): print(">>>>>>> parsing: {0}".format(expr_string)) p = ExprParser(expr_string, allowRelational) print(p.tokens) e = p.expr() print(e) def x_test(): parseAndPrintExpr("name like :name") return parseAndPrintExpr("10+1") parseAndPrintExpr("(abc == 1)") parseAndPrintExpr("(func(abc)=1)") parseAndPrintExpr("(abc = \"jess\")") parseAndPrintExpr("(abc = \"with \\\"\")") parseAndPrintExpr("(abc != .10)") parseAndPrintExpr("(abc != \"xyz\")") parseAndPrintExpr("a + b * c + d") parseAndPrintExpr("(a + b) * c + d") parseAndPrintExpr("(field not in ('a',func('b', 2.0),'c'))") parseAndPrintExpr("jess.age between 30 and death") parseAndPrintExpr("a + b * c + d") parseAndPrintExpr("x > 10 and Y >= -20") parseAndPrintExpr("a is true and b is null and C + 1 > 40 and " "(time = now() or hungry())") parseAndPrintExpr("a + b + -c > 2") parseAndPrintExpr("now () + b + c > 2") parseAndPrintExpr("now () + @b + c > 2") parseAndPrintExpr("now () - interval +2 day > some_other_time() or " "something_else IS NOT NULL") parseAndPrintExpr("\"two quotes to one\"\"\"") parseAndPrintExpr("'two quotes to one'''") parseAndPrintExpr("'different quote \"'") parseAndPrintExpr("\"different quote '\"") parseAndPrintExpr("`ident`") parseAndPrintExpr("`ident```") parseAndPrintExpr("`ident\"'`") parseAndPrintExpr("now () - interval -2 day") parseAndPrintExpr("? > x and func(?, ?, ?)") parseAndPrintExpr("a > now() + interval (2 + x) MiNuTe") parseAndPrintExpr("a between 1 and 2") parseAndPrintExpr("a not between 1 and 2") parseAndPrintExpr("a in (1,2,a.b(3),4,5,x)") parseAndPrintExpr("a not in (1,2,3,4,5,@x)") parseAndPrintExpr("a like b escape c") parseAndPrintExpr("a not like b escape c") parseAndPrintExpr("(1 + 3) in (3, 4, 5)") parseAndPrintExpr("`a crazy \"function\"``'name'`(1 + 3) in (3, 4, 5)") parseAndPrintExpr("`a crazy \"function\"``'name'`(1 + 3) in (3, 4, 5)") parseAndPrintExpr("a@.b", False) parseAndPrintExpr("a@.b[0][0].c**.d.\"a weird\\\"key name\"", False) parseAndPrintExpr("a@.*", False) parseAndPrintExpr("a@[0].*", False) parseAndPrintExpr("a@**[0].*", False) # x_test()
Save File
Cancel