sqlglot API documentation

From aa1d1f1ea72887a3efb78f4950e27bc79dfa3766 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Mon, 27 Feb 2023 11:46:33 +0100 Subject: Adding upstream version 11.2.3. Signed-off-by: Daniel Baumann --- docs/sqlglot.html | 485 +++++++++++++++++++++++++++--------------------------- 1 file changed, 247 insertions(+), 238 deletions(-) (limited to 'docs/sqlglot.html') diff --git a/docs/sqlglot.html b/docs/sqlglot.html index 896e331..5da9c75 100644 --- a/docs/sqlglot.html +++ b/docs/sqlglot.html @@ -3,14 +3,14 @@ - + sqlglot API documentation - - + +

@@ -663,180 +663,188 @@ 9import typing as t 10 11from sqlglot import expressions as exp - 12from sqlglot.dialects import Dialect, Dialects - 13from sqlglot.diff import diff - 14from sqlglot.errors import ErrorLevel, ParseError, TokenError, UnsupportedError - 15from sqlglot.expressions import Expression - 16from sqlglot.expressions import alias_ as alias - 17from sqlglot.expressions import ( - 18 and_, - 19 column, - 20 condition, - 21 except_, - 22 from_, - 23 intersect, - 24 maybe_parse, - 25 not_, - 26 or_, - 27 select, - 28 subquery, - 29) - 30from sqlglot.expressions import table_ as table - 31from sqlglot.expressions import to_column, to_table, union - 32from sqlglot.generator import Generator - 33from sqlglot.parser import Parser - 34from sqlglot.schema import MappingSchema, Schema - 35from sqlglot.tokens import Tokenizer, TokenType - 36 - 37if t.TYPE_CHECKING: - 38 from sqlglot.dialects.dialect import DialectType - 39 - 40 T = t.TypeVar("T", bound=Expression) - 41 - 42 - 43__version__ = "11.1.3" - 44 - 45pretty = False - 46"""Whether to format generated SQL by default.""" - 47 - 48schema = MappingSchema() - 49"""The default schema used by SQLGlot (e.g. in the optimizer).""" - 50 + 12from sqlglot.dialects.dialect import Dialect as Dialect, Dialects as Dialects + 13from sqlglot.diff import diff as diff + 14from sqlglot.errors import ( + 15 ErrorLevel as ErrorLevel, + 16 ParseError as ParseError, + 17 TokenError as TokenError, + 18 UnsupportedError as UnsupportedError, + 19) + 20from sqlglot.expressions import ( + 21 Expression as Expression, + 22 alias_ as alias, + 23 and_ as and_, + 24 column as column, + 25 condition as condition, + 26 except_ as except_, + 27 from_ as from_, + 28 intersect as intersect, + 29 maybe_parse as maybe_parse, + 30 not_ as not_, + 31 or_ as or_, + 32 select as select, + 33 subquery as subquery, + 34 table_ as table, + 35 to_column as to_column, + 36 to_table as to_table, + 37 union as union, + 38) + 39from sqlglot.generator import Generator as Generator + 40from sqlglot.parser import Parser as Parser + 41from sqlglot.schema import MappingSchema as MappingSchema, Schema as Schema + 42from sqlglot.tokens import Tokenizer as Tokenizer, TokenType as TokenType + 43 + 44if t.TYPE_CHECKING: + 45 from sqlglot.dialects.dialect import DialectType as DialectType + 46 + 47 T = t.TypeVar("T", bound=Expression) + 48 + 49 + 50__version__ = "11.2.2" 51 - 52def parse(sql: str, read: DialectType = None, **opts) -> t.List[t.Optional[Expression]]: - 53 """ - 54 Parses the given SQL string into a collection of syntax trees, one per parsed SQL statement. - 55 - 56 Args: - 57 sql: the SQL code string to parse. - 58 read: the SQL dialect to apply during parsing (eg. "spark", "hive", "presto", "mysql"). - 59 **opts: other `sqlglot.parser.Parser` options. - 60 - 61 Returns: - 62 The resulting syntax tree collection. - 63 """ - 64 dialect = Dialect.get_or_raise(read)() - 65 return dialect.parse(sql, **opts) - 66 + 52pretty = False + 53"""Whether to format generated SQL by default.""" + 54 + 55schema = MappingSchema() + 56"""The default schema used by SQLGlot (e.g. in the optimizer).""" + 57 + 58 + 59def parse(sql: str, read: DialectType = None, **opts) -> t.List[t.Optional[Expression]]: + 60 """ + 61 Parses the given SQL string into a collection of syntax trees, one per parsed SQL statement. + 62 + 63 Args: + 64 sql: the SQL code string to parse. + 65 read: the SQL dialect to apply during parsing (eg. "spark", "hive", "presto", "mysql"). + 66 **opts: other `sqlglot.parser.Parser` options. 67 - 68@t.overload - 69def parse_one( - 70 sql: str, - 71 read: None = None, - 72 into: t.Type[T] = ..., - 73 **opts, - 74) -> T: - 75 ... - 76 - 77 - 78@t.overload - 79def parse_one( - 80 sql: str, - 81 read: DialectType, - 82 into: t.Type[T], - 83 **opts, - 84) -> T: - 85 ... - 86 - 87 - 88@t.overload - 89def parse_one( - 90 sql: str, - 91 read: None = None, - 92 into: t.Union[str, t.Collection[t.Union[str, t.Type[Expression]]]] = ..., - 93 **opts, - 94) -> Expression: - 95 ... - 96 - 97 - 98@t.overload - 99def parse_one( -100 sql: str, -101 read: DialectType, -102 into: t.Union[str, t.Collection[t.Union[str, t.Type[Expression]]]], -103 **opts, -104) -> Expression: -105 ... -106 -107 -108@t.overload -109def parse_one( -110 sql: str, -111 **opts, -112) -> Expression: -113 ... + 68 Returns: + 69 The resulting syntax tree collection. + 70 """ + 71 dialect = Dialect.get_or_raise(read)() + 72 return dialect.parse(sql, **opts) + 73 + 74 + 75@t.overload + 76def parse_one( + 77 sql: str, + 78 read: None = None, + 79 into: t.Type[T] = ..., + 80 **opts, + 81) -> T: + 82 ... + 83 + 84 + 85@t.overload + 86def parse_one( + 87 sql: str, + 88 read: DialectType, + 89 into: t.Type[T], + 90 **opts, + 91) -> T: + 92 ... + 93 + 94 + 95@t.overload + 96def parse_one( + 97 sql: str, + 98 read: None = None, + 99 into: t.Union[str, t.Collection[t.Union[str, t.Type[Expression]]]] = ..., +100 **opts, +101) -> Expression: +102 ... +103 +104 +105@t.overload +106def parse_one( +107 sql: str, +108 read: DialectType, +109 into: t.Union[str, t.Collection[t.Union[str, t.Type[Expression]]]], +110 **opts, +111) -> Expression: +112 ... +113 114 -115 +115@t.overload 116def parse_one( 117 sql: str, -118 read: DialectType = None, -119 into: t.Optional[exp.IntoType] = None, -120 **opts, -121) -> Expression: -122 """ -123 Parses the given SQL string and returns a syntax tree for the first parsed SQL statement. -124 -125 Args: -126 sql: the SQL code string to parse. -127 read: the SQL dialect to apply during parsing (eg. "spark", "hive", "presto", "mysql"). -128 into: the SQLGlot Expression to parse into. -129 **opts: other `sqlglot.parser.Parser` options. -130 -131 Returns: -132 The syntax tree for the first parsed statement. -133 """ -134 -135 dialect = Dialect.get_or_raise(read)() -136 -137 if into: -138 result = dialect.parse_into(into, sql, **opts) -139 else: -140 result = dialect.parse(sql, **opts) +118 **opts, +119) -> Expression: +120 ... +121 +122 +123def parse_one( +124 sql: str, +125 read: DialectType = None, +126 into: t.Optional[exp.IntoType] = None, +127 **opts, +128) -> Expression: +129 """ +130 Parses the given SQL string and returns a syntax tree for the first parsed SQL statement. +131 +132 Args: +133 sql: the SQL code string to parse. +134 read: the SQL dialect to apply during parsing (eg. "spark", "hive", "presto", "mysql"). +135 into: the SQLGlot Expression to parse into. +136 **opts: other `sqlglot.parser.Parser` options. +137 +138 Returns: +139 The syntax tree for the first parsed statement. +140 """ 141 -142 for expression in result: -143 if not expression: -144 raise ParseError(f"No expression was parsed from '{sql}'") -145 return expression +142 dialect = Dialect.get_or_raise(read)() +143 +144 if into: +145 result = dialect.parse_into(into, sql, **opts) 146 else: -147 raise ParseError(f"No expression was parsed from '{sql}'") +147 result = dialect.parse(sql, **opts) 148 -149 -150def transpile( -151 sql: str, -152 read: DialectType = None, -153 write: DialectType = None, -154 identity: bool = True, -155 error_level: t.Optional[ErrorLevel] = None, -156 **opts, -157) -> t.List[str]: -158 """ -159 Parses the given SQL string in accordance with the source dialect and returns a list of SQL strings transformed -160 to conform to the target dialect. Each string in the returned list represents a single transformed SQL statement. -161 -162 Args: -163 sql: the SQL code string to transpile. -164 read: the source dialect used to parse the input string (eg. "spark", "hive", "presto", "mysql"). -165 write: the target dialect into which the input should be transformed (eg. "spark", "hive", "presto", "mysql"). -166 identity: if set to `True` and if the target dialect is not specified the source dialect will be used as both: -167 the source and the target dialect. -168 error_level: the desired error level of the parser. -169 **opts: other `sqlglot.generator.Generator` options. -170 -171 Returns: -172 The list of transpiled SQL statements. -173 """ -174 write = write or read if identity else write -175 return [ -176 Dialect.get_or_raise(write)().generate(expression, **opts) -177 for expression in parse(sql, read, error_level=error_level) -178 ] +149 for expression in result: +150 if not expression: +151 raise ParseError(f"No expression was parsed from '{sql}'") +152 return expression +153 else: +154 raise ParseError(f"No expression was parsed from '{sql}'") +155 +156 +157def transpile( +158 sql: str, +159 read: DialectType = None, +160 write: DialectType = None, +161 identity: bool = True, +162 error_level: t.Optional[ErrorLevel] = None, +163 **opts, +164) -> t.List[str]: +165 """ +166 Parses the given SQL string in accordance with the source dialect and returns a list of SQL strings transformed +167 to conform to the target dialect. Each string in the returned list represents a single transformed SQL statement. +168 +169 Args: +170 sql: the SQL code string to transpile. +171 read: the source dialect used to parse the input string (eg. "spark", "hive", "presto", "mysql"). +172 write: the target dialect into which the input should be transformed (eg. "spark", "hive", "presto", "mysql"). +173 identity: if set to `True` and if the target dialect is not specified the source dialect will be used as both: +174 the source and the target dialect. +175 error_level: the desired error level of the parser. +176 **opts: other `sqlglot.generator.Generator` options. +177 +178 Returns: +179 The list of transpiled SQL statements. +180 """ +181 write = write or read if identity else write +182 return [ +183 Dialect.get_or_raise(write)().generate(expression, **opts) +184 for expression in parse(sql, read, error_level=error_level) +185 ]

- pretty = False + pretty = +False

@@ -849,7 +857,8 @@

- schema = <sqlglot.schema.MappingSchema object> + schema = +<sqlglot.schema.MappingSchema object>

@@ -871,20 +880,20 @@ -

53def parse(sql: str, read: DialectType = None, **opts) -> t.List[t.Optional[Expression]]:
-54    """
-55    Parses the given SQL string into a collection of syntax trees, one per parsed SQL statement.
-56
-57    Args:
-58        sql: the SQL code string to parse.
-59        read: the SQL dialect to apply during parsing (eg. "spark", "hive", "presto", "mysql").
-60        **opts: other `sqlglot.parser.Parser` options.
-61
-62    Returns:
-63        The resulting syntax tree collection.
-64    """
-65    dialect = Dialect.get_or_raise(read)()
-66    return dialect.parse(sql, **opts)
+            60def parse(sql: str, read: DialectType = None, **opts) -> t.List[t.Optional[Expression]]:
+61    """
+62    Parses the given SQL string into a collection of syntax trees, one per parsed SQL statement.
+63
+64    Args:
+65        sql: the SQL code string to parse.
+66        read: the SQL dialect to apply during parsing (eg. "spark", "hive", "presto", "mysql").
+67        **opts: other `sqlglot.parser.Parser` options.
+68
+69    Returns:
+70        The resulting syntax tree collection.
+71    """
+72    dialect = Dialect.get_or_raise(read)()
+73    return dialect.parse(sql, **opts)
 
 
 
@@ -918,38 +927,38 @@

117def parse_one(
-118    sql: str,
-119    read: DialectType = None,
-120    into: t.Optional[exp.IntoType] = None,
-121    **opts,
-122) -> Expression:
-123    """
-124    Parses the given SQL string and returns a syntax tree for the first parsed SQL statement.
-125
-126    Args:
-127        sql: the SQL code string to parse.
-128        read: the SQL dialect to apply during parsing (eg. "spark", "hive", "presto", "mysql").
-129        into: the SQLGlot Expression to parse into.
-130        **opts: other `sqlglot.parser.Parser` options.
-131
-132    Returns:
-133        The syntax tree for the first parsed statement.
-134    """
-135
-136    dialect = Dialect.get_or_raise(read)()
-137
-138    if into:
-139        result = dialect.parse_into(into, sql, **opts)
-140    else:
-141        result = dialect.parse(sql, **opts)
+            124def parse_one(
+125    sql: str,
+126    read: DialectType = None,
+127    into: t.Optional[exp.IntoType] = None,
+128    **opts,
+129) -> Expression:
+130    """
+131    Parses the given SQL string and returns a syntax tree for the first parsed SQL statement.
+132
+133    Args:
+134        sql: the SQL code string to parse.
+135        read: the SQL dialect to apply during parsing (eg. "spark", "hive", "presto", "mysql").
+136        into: the SQLGlot Expression to parse into.
+137        **opts: other `sqlglot.parser.Parser` options.
+138
+139    Returns:
+140        The syntax tree for the first parsed statement.
+141    """
 142
-143    for expression in result:
-144        if not expression:
-145            raise ParseError(f"No expression was parsed from '{sql}'")
-146        return expression
+143    dialect = Dialect.get_or_raise(read)()
+144
+145    if into:
+146        result = dialect.parse_into(into, sql, **opts)
 147    else:
-148        raise ParseError(f"No expression was parsed from '{sql}'")
+148        result = dialect.parse(sql, **opts)
+149
+150    for expression in result:
+151        if not expression:
+152            raise ParseError(f"No expression was parsed from '{sql}'")
+153        return expression
+154    else:
+155        raise ParseError(f"No expression was parsed from '{sql}'")
 
 
 
@@ -984,35 +993,35 @@

151def transpile(
-152    sql: str,
-153    read: DialectType = None,
-154    write: DialectType = None,
-155    identity: bool = True,
-156    error_level: t.Optional[ErrorLevel] = None,
-157    **opts,
-158) -> t.List[str]:
-159    """
-160    Parses the given SQL string in accordance with the source dialect and returns a list of SQL strings transformed
-161    to conform to the target dialect. Each string in the returned list represents a single transformed SQL statement.
-162
-163    Args:
-164        sql: the SQL code string to transpile.
-165        read: the source dialect used to parse the input string (eg. "spark", "hive", "presto", "mysql").
-166        write: the target dialect into which the input should be transformed (eg. "spark", "hive", "presto", "mysql").
-167        identity: if set to `True` and if the target dialect is not specified the source dialect will be used as both:
-168            the source and the target dialect.
-169        error_level: the desired error level of the parser.
-170        **opts: other `sqlglot.generator.Generator` options.
-171
-172    Returns:
-173        The list of transpiled SQL statements.
-174    """
-175    write = write or read if identity else write
-176    return [
-177        Dialect.get_or_raise(write)().generate(expression, **opts)
-178        for expression in parse(sql, read, error_level=error_level)
-179    ]
+            158def transpile(
+159    sql: str,
+160    read: DialectType = None,
+161    write: DialectType = None,
+162    identity: bool = True,
+163    error_level: t.Optional[ErrorLevel] = None,
+164    **opts,
+165) -> t.List[str]:
+166    """
+167    Parses the given SQL string in accordance with the source dialect and returns a list of SQL strings transformed
+168    to conform to the target dialect. Each string in the returned list represents a single transformed SQL statement.
+169
+170    Args:
+171        sql: the SQL code string to transpile.
+172        read: the source dialect used to parse the input string (eg. "spark", "hive", "presto", "mysql").
+173        write: the target dialect into which the input should be transformed (eg. "spark", "hive", "presto", "mysql").
+174        identity: if set to `True` and if the target dialect is not specified the source dialect will be used as both:
+175            the source and the target dialect.
+176        error_level: the desired error level of the parser.
+177        **opts: other `sqlglot.generator.Generator` options.
+178
+179    Returns:
+180        The list of transpiled SQL statements.
+181    """
+182    write = write or read if identity else write
+183    return [
+184        Dialect.get_or_raise(write)().generate(expression, **opts)
+185        for expression in parse(sql, read, error_level=error_level)
+186    ]
 
 
 
@@ -1160,7 +1169,7 @@ the source and the target dialect.
                         if (doc.annotation)
                             heading += `${doc.annotation}`;
                         if (doc.default_value)
-                            heading += `${doc.default_value}`;
+                            heading += ` = ${doc.default_value}`;
                         break;
                     default:
                         heading = `${doc.fullname}`;
-- 
cgit v1.2.3