brk-code

sqlglot の API リファレンス

sqlglot (tobymao/sqlglot) の公開 API 195 件 —— クラス 24、関数 64、メソッド 107。実際のソースを静的解析して抽出した正確なシグネチャを掲載しています。

リポジトリ: tobymao/sqlglot

種別件数
クラス24
関数64
メソッド107

API 一覧

methodsqlglot.dialects.dialect.Dialect.quote_identifier(expression:E, identify:bool=True) -> E
Adds quotes to a given expression if it is an identifier.
classsqlglot.dialects.dialect.Dialects
Dialects supported by SQLGLot.
funcsqlglot.dialects.dialect.build_formatted_time(exp_class:Type[E], dialect_override:str | None=None, default:bool | str | None=None) -> t.Callable[[BuilderArgs, Dialect], E]
Helper used for time expressions.
funcsqlglot.dialects.dialect.merge_without_target_sql(self:Generator, expression:exp.Merge) -> str
Remove table refs from columns in when statements.
classsqlglot.diff.Insert
Indicates that a new node has been inserted
classsqlglot.diff.Keep
Indicates that an existing node hasn't been changed
classsqlglot.diff.Remove
Indicates that an existing node has been removed
classsqlglot.diff.Update
Indicates that an existing node has been updated
classsqlglot.executor.context.Context
Execution context for sql expressions.
funcsqlglot.executor.execute(sql:str | Expr, schema:dict | Schema | None=None, dialect:DialectType=None, tables:dict | None=None) -> Table
Run a sql query against data.
funcsqlglot.expressions.builders.array(*copy:bool=True, *dialect:DialectType=None, *expressions:ExpOrStr, **kwargs:Unpack[ParserNoDialectArgs]) -> Array
Returns an array.
funcsqlglot.expressions.builders.case(expression:ExpOrStr | None=None, copy:bool=True, **opts:Unpack[ParserArgs]) -> Case
Initialize a CASE statement.
funcsqlglot.expressions.builders.cast(expression:ExpOrStr, to:DATA_TYPE, copy:bool=True, dialect:DialectType=None, **opts:Unpack[ParserNoDialectArgs]) -> Cast
Cast an expression to a data type.
funcsqlglot.expressions.builders.delete(table:ExpOrStr, where:ExpOrStr | None=None, returning:ExpOrStr | None=None, dialect:DialectType=None, **opts:Unpack[ParserNoDialectArgs]) -> Delete
Builds a delete statement.
funcsqlglot.expressions.builders.false() -> Boolean
Returns a false Boolean expression.
funcsqlglot.expressions.builders.find_tables(expression:Expr) -> set[Table]
Find all tables referenced in a query.
funcsqlglot.expressions.builders.from_(expression:ExpOrStr, dialect:DialectType=None, copy:bool=True, **opts:Unpack[ParserNoDialectArgs]) -> Select
Initializes a syntax tree from a FROM expression.
funcsqlglot.expressions.builders.func(name:str, *copy:bool=True, *dialect:DialectType=None, *args:t.Any, **kwargs:t.Any) -> Func
Returns a Func expression.
funcsqlglot.expressions.builders.merge(*into:ExpOrStr, *using:ExpOrStr, *on:ExpOrStr, *returning:ExpOrStr | None=None, *dialect:DialectType=None, *copy:bool=True, *when_exprs:ExpOrStr, **opts:Unpack[ParserNoDialectArgs]) -> Merge
Builds a MERGE statement.
funcsqlglot.expressions.builders.normalize_table_name(table:str | Table, dialect:DialectType=None, copy:bool=True) -> str
Returns a case normalized table name without quotes.
funcsqlglot.expressions.builders.null() -> Null
Returns a Null expression.
funcsqlglot.expressions.builders.parse_identifier(name:str | Identifier, dialect:DialectType=None) -> Identifier
Parses a given string into an identifier.
funcsqlglot.expressions.builders.rename_column(table_name:str | Table, old_column_name:str | Column, new_column_name:str | Column, exists:bool | None=None, dialect:DialectType=None) -> Alter
Build ALTER TABLE...
funcsqlglot.expressions.builders.rename_table(old_name:str | Table, new_name:str | Table, dialect:DialectType=None) -> Alter
Build ALTER TABLE...
funcsqlglot.expressions.builders.replace_placeholders(expression:Expr, *args:object, **kwargs:t.Any) -> Expr
Replace placeholders in an expression.
funcsqlglot.expressions.builders.table_(table:Identifier | str, db:Identifier | str | None=None, catalog:Identifier | str | None=None, quoted:bool | None=None, alias:Identifier | str | None=None) -> Table
Build a Table.
funcsqlglot.expressions.builders.table_name(table:Table | str, dialect:DialectType=None, identify:bool=False) -> str
Get the full name of a table as a string.
funcsqlglot.expressions.builders.true() -> Boolean
Returns a true Boolean expression.
funcsqlglot.expressions.builders.tuple_(*copy:bool=True, *dialect:DialectType=None, *expressions:ExpOrStr, **kwargs:Unpack[ParserNoDialectArgs]) -> Tuple
Returns an tuple.
funcsqlglot.expressions.builders.values(values:Iterable[tuple[object, ...] | Tuple], alias:str | None=None, columns:Iterable[str] | dict[str, DataType] | None=None) -> Values
Build VALUES statement.
funcsqlglot.expressions.builders.var(name:ExpOrStr | None) -> Var
Build a SQL variable.
methodsqlglot.expressions.core.Column.to_dot(include_dots:bool=True) -> Dot | Identifier | Star
Converts the column into a dot expression.
classsqlglot.expressions.core.Condition
Logical conditions like x AND y, or simply x
methodsqlglot.expressions.core.Dot.build(expressions:Sequence[Expr]) -> Dot
Build a Dot object with a sequence of expressions.
classsqlglot.expressions.core.Expr
The base class for all expressions in a syntax tree.
methodsqlglot.expressions.core.Expr.append(arg_key:str, value:t.Any) -> None
Appends value to arg_key if it's a list or sets it as a new list.
methodsqlglot.expressions.core.Expr.assert_is(type_:Type[E]) -> E
Assert that this `Expr` is an instance of `type_`.
methodsqlglot.expressions.core.Expr.copy() -> E
Returns a deep copy of the expression.
methodsqlglot.expressions.core.Expr.depth() -> int
Returns the depth of this tree.
methodsqlglot.expressions.core.Expr.dump() -> list[dict[str, t.Any]]
Dump this Expr to a JSON-serializable dict.
methodsqlglot.expressions.core.Expr.error_messages(args:Sequence[object] | None=None) -> list[str]
Checks if this expression is valid (e.g.
methodsqlglot.expressions.core.Expr.expression() -> t.Any
Retrieves the argument with key "expression".
methodsqlglot.expressions.core.Expr.expressions() -> list[t.Any]
Retrieves the argument with key "expressions".
methodsqlglot.expressions.core.Expr.find_ancestor(*expression_types:Type[E]) -> E | None
Returns a nearest parent matching expression_types.
methodsqlglot.expressions.core.Expr.is_int() -> bool
Checks whether an expression is an integer.
methodsqlglot.expressions.core.Expr.is_number() -> bool
Checks whether a Literal expression is a number.
methodsqlglot.expressions.core.Expr.is_star() -> bool
Checks whether an expression is a star.
methodsqlglot.expressions.core.Expr.is_string() -> bool
Checks whether a Literal expression is a string.
methodsqlglot.expressions.core.Expr.load(obj:list[dict[str, Any]] | None) -> Expr
Load a dict (as returned by `Expr.dump`) into an Expr instance.
methodsqlglot.expressions.core.Expr.not_(copy:bool=True) -> Not
Wrap this condition with NOT.
methodsqlglot.expressions.core.Expr.parent_select() -> Select | None
Returns the parent select statement.
methodsqlglot.expressions.core.Expr.pop() -> E
Remove this expression from its AST.
methodsqlglot.expressions.core.Expr.replace(expression:T) -> T
Swap out this expression with a new expression.
methodsqlglot.expressions.core.Expr.root() -> Expr
Returns the root expression of this tree.
methodsqlglot.expressions.core.Expr.same_parent() -> bool
Returns if the parent is the same class as itself.
methodsqlglot.expressions.core.Expr.set(arg_key:str, value:object, index:int | None=None, overwrite:bool=True) -> None
Sets arg_key to value.
methodsqlglot.expressions.core.Expr.sql(dialect:DialectType=None, copy:bool=True, **opts:Unpack[GeneratorNoDialectArgs]) -> str
Returns SQL string representation of this tree.
methodsqlglot.expressions.core.Expr.text(key:str) -> str
Returns a textual representation of the argument corresponding to "key".
methodsqlglot.expressions.core.Expr.this() -> t.Any
Retrieves the argument with key "this".
methodsqlglot.expressions.core.Expr.to_py() -> t.Any
Returns a Python object equivalent of the SQL node.
methodsqlglot.expressions.core.Expr.unalias() -> Expr
Returns the inner expression if this is an Alias.
methodsqlglot.expressions.core.Expr.unnest() -> Expr
Returns the first non parenthesis child or self.
methodsqlglot.expressions.core.Expr.unnest_operands() -> tuple[Expr, ...]
Returns unnested operands as a tuple.
methodsqlglot.expressions.core.Expression.set_kwargs(kwargs:Mapping[str, object]) -> Self
Set multiples keyword arguments at once, using `.set()` method.
classsqlglot.expressions.core.FormatPhrase
Format override for a column in Teradata.
classsqlglot.expressions.core.Func
The base class for all function expressions.
classsqlglot.expressions.core.Kwarg
Kwarg in special functions like func(kwarg => y).
classsqlglot.expressions.core.Predicate
Relationships like x = y, x > 1, x >= y.
classsqlglot.expressions.core.TimeUnit
Automatically converts unit arg into a var.
funcsqlglot.expressions.core.alias_(expression:ExpOrStr, alias:str | Identifier | None, table:bool | Sequence[str | Identifier]=False, quoted:bool | None=None, dialect:DialectType=None, copy:bool=True, **opts:Unpack[ParserNoDialectArgs]) -> Expr
Create an Alias expression.
funcsqlglot.expressions.core.condition(expression:ExpOrStr, dialect:DialectType=None, copy:bool=True, **opts:Unpack[ParserNoDialectArgs]) -> Expr
Initialize a logical condition expression.
funcsqlglot.expressions.core.convert(value:t.Any, copy:bool=False) -> Expr
Convert a python value into an expression object.
funcsqlglot.expressions.core.not_(expression:ExpOrStr, dialect:DialectType=None, copy:bool=True, **opts:Unpack[ParserNoDialectArgs]) -> Not
Wrap a condition with a NOT operator.
funcsqlglot.expressions.core.paren(expression:ExpOrStr, copy:bool=True) -> Paren
Wrap an expression in parentheses.
methodsqlglot.expressions.datatypes.DType.into_expr(**kwargs:object) -> DataType
Converts this `DType` into a `DataType` instance.
methodsqlglot.expressions.datatypes.DataType.build(dtype:DATA_TYPE, dialect:DialectType=None, udt:bool=False, copy:bool=True, **kwargs:Unpack[DataTypeArgs]) -> Self
Constructs a DataType object.
methodsqlglot.expressions.ddl.DDL.ctes() -> list[CTE]
Returns a list of all the CTEs attached to this statement.
methodsqlglot.expressions.ddl.DDL.named_selects() -> list[str]
If this statement contains a query (e.g.
methodsqlglot.expressions.ddl.DDL.selects() -> list[Expr]
If this statement contains a query (e.g.
classsqlglot.expressions.dml.DML
Trait for data manipulation language statements.
methodsqlglot.expressions.dml.DML.returning(expression:ExpOrStr, dialect:DialectType=None, copy:bool=True, **opts:Unpack[ParserNoDialectArgs]) -> Self
Set the RETURNING expression.
methodsqlglot.expressions.dml.Delete.where(*append:bool=True, *dialect:DialectType=None, *copy:bool=True, *expressions:ExpOrStr | None, **opts:Unpack[ParserNoDialectArgs]) -> Delete
Append to or set the WHERE expressions.
methodsqlglot.expressions.dml.Update.from_(expression:ExpOrStr | None=None, dialect:DialectType=None, copy:bool=True, **opts:Unpack[ParserNoDialectArgs]) -> Update
Set the FROM expression.
methodsqlglot.expressions.dml.Update.set_(*append:bool=True, *dialect:DialectType=None, *copy:bool=True, *expressions:ExpOrStr, **opts:Unpack[ParserNoDialectArgs]) -> Update
Append to or set the SET expressions.
methodsqlglot.expressions.dml.Update.table(expression:ExpOrStr, dialect:DialectType=None, copy:bool=True, **opts:Unpack[ParserNoDialectArgs]) -> Update
Set the table to update.
methodsqlglot.expressions.dml.Update.where(*append:bool=True, *dialect:DialectType=None, *copy:bool=True, *expressions:ExpOrStr | None, **opts:Unpack[ParserNoDialectArgs]) -> Update
Append to or set the WHERE expressions.
classsqlglot.expressions.dml.Whens
Wraps around one or more WHEN [NOT] MATCHED [...] clauses.
methodsqlglot.expressions.query.Join.on(*append:bool=True, *dialect:DialectType=None, *copy:bool=True, *expressions:ExpOrStr | None, **opts:Unpack[ParserNoDialectArgs]) -> Join
Append to or set the ON expressions.
methodsqlglot.expressions.query.Join.using(*append:bool=True, *dialect:DialectType=None, *copy:bool=True, *expressions:ExpOrStr | None, **opts:Unpack[ParserNoDialectArgs]) -> Join
Append to or set the USING expressions.
classsqlglot.expressions.query.Query
Trait for any SELECT/UNION/etc.
methodsqlglot.expressions.query.Query.except_(*distinct:bool=True, *dialect:DialectType=None, *copy:bool=True, *expressions:ExpOrStr, **opts:Unpack[ParserNoDialectArgs]) -> Except
Builds an EXCEPT expression.
methodsqlglot.expressions.query.Query.intersect(*distinct:bool=True, *dialect:DialectType=None, *copy:bool=True, *expressions:ExpOrStr, **opts:Unpack[ParserNoDialectArgs]) -> Intersect
Builds an INTERSECT expression.
methodsqlglot.expressions.query.Query.limit(expression:ExpOrStr | int, dialect:DialectType=None, copy:bool=True, **opts:Unpack[ParserNoDialectArgs]) -> Q
Adds a LIMIT clause to this query.
methodsqlglot.expressions.query.Query.offset(expression:ExpOrStr | int, dialect:DialectType=None, copy:bool=True, **opts:Unpack[ParserNoDialectArgs]) -> Q
Set the OFFSET expression.
methodsqlglot.expressions.query.Query.order_by(*append:bool=True, *dialect:DialectType=None, *copy:bool=True, *expressions:ExpOrStr | None, **opts:Unpack[ParserNoDialectArgs]) -> Q
Set the ORDER BY expression.
methodsqlglot.expressions.query.Query.subquery(alias:ExpOrStr | None=None, copy:bool=True) -> Subquery
Returns a `Subquery` that wraps around this query.
methodsqlglot.expressions.query.Query.union(*distinct:bool=True, *dialect:DialectType=None, *copy:bool=True, *expressions:ExpOrStr, **opts:Unpack[ParserNoDialectArgs]) -> Union
Builds a UNION expression.
methodsqlglot.expressions.query.Query.where(*append:bool=True, *dialect:DialectType=None, *copy:bool=True, *expressions:ExpOrStr | None, **opts:Unpack[ParserNoDialectArgs]) -> Q
Append to or set the WHERE expressions.
methodsqlglot.expressions.query.Select.cluster_by(*append:bool=True, *dialect:DialectType=None, *copy:bool=True, *expressions:ExpOrStr | None, **opts:Unpack[ParserNoDialectArgs]) -> Select
Set the CLUSTER BY expression.
methodsqlglot.expressions.query.Select.distinct(*distinct:bool=True, *copy:bool=True, *ons:ExpOrStr | None) -> Select
Set the OFFSET expression.
methodsqlglot.expressions.query.Select.from_(expression:ExpOrStr, dialect:DialectType=None, copy:bool=True, **opts:Unpack[ParserNoDialectArgs]) -> Select
Set the FROM expression.
methodsqlglot.expressions.query.Select.group_by(*append:bool=True, *dialect:DialectType=None, *copy:bool=True, *expressions:ExpOrStr | None, **opts:Unpack[ParserNoDialectArgs]) -> Select
Set the GROUP BY expression.
methodsqlglot.expressions.query.Select.having(*append:bool=True, *dialect:DialectType=None, *copy:bool=True, *expressions:ExpOrStr | None, **opts:Unpack[ParserNoDialectArgs]) -> Select
Append to or set the HAVING expressions.
methodsqlglot.expressions.query.Select.hint(*dialect:DialectType=None, *copy:bool=True, *hints:ExpOrStr) -> Select
Set hints for this expression.
methodsqlglot.expressions.query.Select.lateral(*append:bool=True, *dialect:DialectType=None, *copy:bool=True, *expressions:ExpOrStr | None, **opts:Unpack[ParserNoDialectArgs]) -> Select
Append to or set the LATERAL expressions.
methodsqlglot.expressions.query.Select.lock(update:bool=True, copy:bool=True) -> Select
Set the locking read mode for this expression.
methodsqlglot.expressions.query.Select.sort_by(*append:bool=True, *dialect:DialectType=None, *copy:bool=True, *expressions:ExpOrStr | None, **opts:Unpack[ParserNoDialectArgs]) -> Select
Set the SORT BY expression.
methodsqlglot.expressions.query.Subquery.unnest() -> Expr
Returns the first non subquery.
methodsqlglot.expressions.query.Table.parts() -> list[Expr]
Return the parts of a table in order catalog, db, table.
classsqlglot.expressions.string.Space
SPACE(n) → string consisting of n blank characters
methodsqlglot.generator.Generator.generate(expression:exp.Expr, copy:bool=True) -> str
Generates the SQL string corresponding to the given syntax tree.
methodsqlglot.generator.Generator.preprocess(expression:exp.Expr) -> exp.Expr
Apply generic preprocessing transformations to a given expression.
classsqlglot.helper.SingleValuedMapping
Mapping where all keys return the same value.
funcsqlglot.helper.camel_to_snake_case(name:str) -> str
Converts `name` from camelCase to snake_case and returns the result.
funcsqlglot.helper.csv(*sep:str=', ', *args:str) -> str
Formats any number of string arguments as CSV.
funcsqlglot.helper.dict_depth(d:t.Any) -> int
Get the nesting depth of a dictionary.
funcsqlglot.helper.find_new_name(taken:Collection[str], base:str) -> str
Searches for a new name.
funcsqlglot.helper.first(it:Iterable[T]) -> T
Returns the first element from an iterable (useful for sets).
funcsqlglot.helper.name_sequence(prefix:str) -> t.Callable[[], str]
Returns a name generator given a prefix (e.g.
funcsqlglot.helper.object_to_dict(obj:t.Any, **kwargs) -> dict
Returns a dictionary created from an object's attributes.
funcsqlglot.helper.tsort(dag:dict[T, set[T]]) -> list[T]
Sorts a given directed acyclic graph in topological order.
classsqlglot.lineage.GraphHTML
Node to HTML generator using vis.js.
funcsqlglot.optimizer.canonicalize.canonicalize(expression:exp.Expr, dialect:DialectType=None) -> exp.Expr
Converts a sql expression into a standard form.
funcsqlglot.optimizer.canonicalize_internal_names.canonicalize_internal_names(expression:E) -> E
Rewrite a query to a canonical structural form.
funcsqlglot.optimizer.eliminate_ctes.eliminate_ctes(expression:E, journal:Journal | None=None) -> E
Remove unused CTEs from an expression.
funcsqlglot.optimizer.eliminate_joins.eliminate_joins(expression:E) -> E
Remove unused joins from an expression.
funcsqlglot.optimizer.eliminate_joins.join_condition(join:exp.Join) -> tuple[list[exp.Expr], list[exp.Expr], exp.Expr]
Extract the join condition from a join expression.
funcsqlglot.optimizer.eliminate_subqueries.eliminate_subqueries(expression:E) -> E
Rewrite derived tables as CTES, deduplicating if possible.
funcsqlglot.optimizer.optimize_joins.normalize(expression:E) -> E
Remove INNER and OUTER from joins as they are optional.
classsqlglot.optimizer.optimizer.OptimizerFn
Protocol for optimizer rules functions.
funcsqlglot.optimizer.qualify_columns.qualify_outputs(scope_or_expression:Scope | exp.Expr, dialect:Dialect) -> None
Ensure all output columns are aliased
funcsqlglot.optimizer.qualify_columns.validate_qualify_columns(expression:E, sql:str | None=None) -> E
Raise an `OptimizeError` if any columns aren't qualified
classsqlglot.optimizer.resolver.Resolver
Helper for resolving columns.
methodsqlglot.optimizer.resolver.Resolver.all_columns() -> set[str]
All available columns of all sources in this scope
methodsqlglot.optimizer.resolver.Resolver.get_source_columns(name:str, only_visible:bool=False) -> Sequence[str]
Resolve the source columns for a given source `name`.
methodsqlglot.optimizer.resolver.Resolver.get_table(column:str | exp.Column) -> exp.Identifier | None
Get the table for a column name.
classsqlglot.optimizer.scope.Scope
Selection scope.
methodsqlglot.optimizer.scope.Scope.add_source(name:str, source:exp.Table | Scope) -> None
Add a source to this scope
methodsqlglot.optimizer.scope.Scope.columns() -> list[exp.Column]
List of columns in this scope.
methodsqlglot.optimizer.scope.Scope.ctes() -> list[exp.CTE]
List of CTEs in this scope.
methodsqlglot.optimizer.scope.Scope.derived_tables() -> list[exp.Subquery]
List of derived tables in this scope.
methodsqlglot.optimizer.scope.Scope.is_correlated_subquery() -> bool
Determine if this scope is a correlated subquery
methodsqlglot.optimizer.scope.Scope.is_cte() -> bool
Determine if this scope is a common table expression
methodsqlglot.optimizer.scope.Scope.is_derived_table() -> bool
Determine if this scope is a derived table
methodsqlglot.optimizer.scope.Scope.is_root() -> bool
Determine if this is the root scope
methodsqlglot.optimizer.scope.Scope.is_subquery() -> bool
Determine if this scope is a subquery
methodsqlglot.optimizer.scope.Scope.is_union() -> bool
Determine if this scope is a union
methodsqlglot.optimizer.scope.Scope.local_columns() -> list[exp.Column]
Columns in this scope that are not external.
methodsqlglot.optimizer.scope.Scope.remove_source(name:str) -> None
Remove a source from this scope
methodsqlglot.optimizer.scope.Scope.rename_source(old_name:str | None, new_name:str) -> None
Rename a source in this scope
methodsqlglot.optimizer.scope.Scope.replace(old:exp.Expr, new:exp.Expr) -> None
Replace `old` with `new`.
methodsqlglot.optimizer.scope.Scope.source_columns(source_name:str) -> list[exp.Column]
Get all columns in the current scope for a particular source.
methodsqlglot.optimizer.scope.Scope.subqueries() -> list[exp.Select | exp.SetOperation]
List of subqueries in this scope.
methodsqlglot.optimizer.scope.Scope.tables() -> list[exp.Table]
List of tables in this scope.
methodsqlglot.optimizer.scope.Scope.traverse() -> Iterator[Scope]
Traverse the scope tree from this node.
methodsqlglot.optimizer.scope.Scope.udtfs() -> list[exp.UDTF]
List of "User Defined Tabular Functions" in this scope.
methodsqlglot.optimizer.scope.Scope.unqualified_columns() -> list[exp.Column]
Unqualified columns in the current scope.
funcsqlglot.optimizer.scope.build_scope(expression:exp.Expr) -> Scope | None
Build a scope tree.
funcsqlglot.optimizer.scope.traverse_scope(expression:exp.Expr) -> list[Scope]
Traverse an expression by its "scopes".
funcsqlglot.optimizer.simplify.flatten(expression:exp.Expr) -> exp.Expr
A AND (B AND C) -> A AND B AND C A OR (B OR C) -> A OR B OR C
methodsqlglot.parser.Parser.parse_into(expression_types:exp.IntoType, raw_tokens:list[Token], sql:str | None=None) -> list[exp.Expr | None]
Parses a list of tokens into a given Expr type.
classsqlglot.schema.MappingSchema
Schema based on a nested mapping.
methodsqlglot.schema.MappingSchema.add_table(table:exp.Table | str, column_mapping:ColumnMapping | None=None, dialect:DialectType=None, normalize:bool | None=None, match_depth:bool=True) -> None
Register or update a table.
methodsqlglot.schema.MappingSchema.dialect() -> Dialect
Returns the dialect for this mapping schema.
methodsqlglot.schema.MappingSchema.get_udf_type(udf:exp.Anonymous | str, dialect:DialectType=None, normalize:bool | None=None) -> exp.DataType
Get the return type of a UDF.
classsqlglot.schema.Schema
Abstract base class for database schemas
methodsqlglot.schema.Schema.add_table(table:exp.Table | str, column_mapping:ColumnMapping | None=None, dialect:DialectType=None, normalize:bool | None=None, match_depth:bool=True) -> None
Register or update a table.
methodsqlglot.schema.Schema.column_names(table:exp.Table | str, only_visible:bool=False, dialect:DialectType=None, normalize:bool | None=None) -> Sequence[str]
Get the column names for a table.
methodsqlglot.schema.Schema.dialect() -> Dialect | None
Returns None by default.
methodsqlglot.schema.Schema.empty() -> bool
Returns whether the schema is empty.
methodsqlglot.schema.Schema.get_udf_type(udf:exp.Anonymous | str, dialect:DialectType=None, normalize:bool | None=None) -> exp.DataType
Get the return type of a UDF.
methodsqlglot.schema.Schema.supported_table_args() -> tuple[str, ...]
Table arguments this schema support, e.g.
funcsqlglot.schema.nested_get(d:dict[str, object], *raise_on_missing:bool=True, *path:tuple[str, str]) -> t.Any | None
Get a value for a nested dictionary.
funcsqlglot.serde.dump(expression:exp.Expr) -> list[dict[str, t.Any]]
Dump an Expr into a JSON serializable List.
funcsqlglot.serde.load(payloads:list[dict[str, t.Any]] | None) -> exp.Expr | exp.DType | None
Load a list of dicts generated by dump into an Expr.
funcsqlglot.time.format_time(string:str, mapping:dict[str, str], trie:dict[t.Any, t.Any] | None=None) -> str | None
Converts a time string given a mapping.
funcsqlglot.tokenize(sql:str, read:DialectType=None, dialect:DialectType=None) -> list[Token]
Tokenizes the given SQL string.
methodsqlglot.tokenizer_core.Token.identifier(identifier:str) -> Token
Returns an IDENTIFIER token with `identifier` as its text.
methodsqlglot.tokenizer_core.Token.number(number:int) -> Token
Returns a NUMBER token with `number` as its text.
methodsqlglot.tokenizer_core.Token.string(string:str) -> Token
Returns a STRING token with `string` as its text.
methodsqlglot.tokenizer_core.Token.var(var:str) -> Token
Returns an VAR token with `var` as its text.
methodsqlglot.tokens.Tokenizer.size() -> int
Length of the SQL string.
methodsqlglot.tokens.Tokenizer.sql() -> str
The SQL string being tokenized.
methodsqlglot.tokens.Tokenizer.tokenize(sql:str) -> list[Token]
Returns a list of tokens corresponding to the SQL string `sql`.
methodsqlglot.tokens.Tokenizer.tokens() -> list[Token]
The list of tokens produced by tokenization.
funcsqlglot.transforms.eliminate_window_clause(expression:exp.Expr) -> exp.Expr
Eliminates the `WINDOW` query clause by inling each named window.
funcsqlglot.transforms.epoch_cast_to_ts(expression:exp.Expr) -> exp.Expr
Replace 'epoch' in casts by the equivalent date literal.
funcsqlglot.transforms.explode_projection_to_unnest(index_offset:int=0) -> t.Callable[[exp.Expr], exp.Expr]
Convert explode/posexplode projections into unnests.
funcsqlglot.transforms.inherit_struct_field_names(expression:exp.Expr) -> exp.Expr
Inherit field names from the first struct in an array.
funcsqlglot.transforms.move_ctes_to_top_level(expression:E) -> E
Some dialects (e.g.
funcsqlglot.transforms.struct_kv_to_alias(expression:exp.Expr) -> exp.Expr
Converts struct arguments to aliases, e.g.
funcsqlglot.transforms.unnest_generate_series(expression:exp.Expr) -> exp.Expr
Unnests GENERATE_SERIES or SEQUENCE table references.
funcsqlglot.transforms.unnest_to_explode(expression:exp.Expr, unnest_using_arrays_zip:bool=True) -> exp.Expr
Convert cross join unnest into lateral view explode.
funcsqlglot.trie.in_trie(trie:dict, key:key) -> tuple[TrieResult, dict]
Checks whether a key is in a trie.
funcsqlglot.trie.new_trie(keywords:Iterable[key], trie:t.Optional[dict]=None) -> dict
Creates a new trie out of a collection of keywords.

この情報について

掲載しているシグネチャは tobymao/sqlglot の公開ソースコードを Python の ast モジュールで静的解析し、引数名・デフォルト値・ 型注釈・戻り値型をそのまま抽出したものです。実装コードは保存していません。 詳しくは仕組みの解説をご覧ください。

収録ライブラリ一覧（全 805 件）へ戻る