sqlglot.expressions.datatypes API documentation

Edit on GitHub

sqlglot expressions datatypes.

View Source

  1"""sqlglot expressions datatypes."""
  2
  3from __future__ import annotations
  4
  5import typing as t
  6from enum import auto
  7
  8from sqlglot.helper import AutoName
  9from sqlglot.errors import ErrorLevel, ParseError
 10from sqlglot.expressions.core import (
 11    Expression,
 12    _TimeUnit,
 13    Identifier,
 14    Dot,
 15    maybe_copy,
 16)
 17from builtins import type as Type
 18
 19if t.TYPE_CHECKING:
 20    from sqlglot.dialects.dialect import DialectType
 21
 22
 23class DataTypeParam(Expression):
 24    arg_types = {"this": True, "expression": False}
 25
 26    @property
 27    def name(self) -> str:
 28        return self.this.name
 29
 30
 31class DType(AutoName):
 32    ARRAY = auto()
 33    AGGREGATEFUNCTION = auto()
 34    SIMPLEAGGREGATEFUNCTION = auto()
 35    BIGDECIMAL = auto()
 36    BIGINT = auto()
 37    BIGNUM = auto()
 38    BIGSERIAL = auto()
 39    BINARY = auto()
 40    BIT = auto()
 41    BLOB = auto()
 42    BOOLEAN = auto()
 43    BPCHAR = auto()
 44    CHAR = auto()
 45    CHARACTER_SET = auto()
 46    DATE = auto()
 47    DATE32 = auto()
 48    DATEMULTIRANGE = auto()
 49    DATERANGE = auto()
 50    DATETIME = auto()
 51    DATETIME2 = auto()
 52    DATETIME64 = auto()
 53    DECIMAL = auto()
 54    DECIMAL32 = auto()
 55    DECIMAL64 = auto()
 56    DECIMAL128 = auto()
 57    DECIMAL256 = auto()
 58    DECFLOAT = auto()
 59    DOUBLE = auto()
 60    DYNAMIC = auto()
 61    ENUM = auto()
 62    ENUM8 = auto()
 63    ENUM16 = auto()
 64    FILE = auto()
 65    FIXEDSTRING = auto()
 66    FLOAT = auto()
 67    GEOGRAPHY = auto()
 68    GEOGRAPHYPOINT = auto()
 69    GEOMETRY = auto()
 70    POINT = auto()
 71    RING = auto()
 72    LINESTRING = auto()
 73    MULTILINESTRING = auto()
 74    POLYGON = auto()
 75    MULTIPOLYGON = auto()
 76    HLLSKETCH = auto()
 77    HSTORE = auto()
 78    IMAGE = auto()
 79    INET = auto()
 80    INT = auto()
 81    INT128 = auto()
 82    INT256 = auto()
 83    INT4MULTIRANGE = auto()
 84    INT4RANGE = auto()
 85    INT8MULTIRANGE = auto()
 86    INT8RANGE = auto()
 87    INTERVAL = auto()
 88    IPADDRESS = auto()
 89    IPPREFIX = auto()
 90    IPV4 = auto()
 91    IPV6 = auto()
 92    JSON = auto()
 93    JSONB = auto()
 94    LIST = auto()
 95    LONGBLOB = auto()
 96    LONGTEXT = auto()
 97    LOWCARDINALITY = auto()
 98    MAP = auto()
 99    MEDIUMBLOB = auto()
100    MEDIUMINT = auto()
101    MEDIUMTEXT = auto()
102    MONEY = auto()
103    NAME = auto()
104    NCHAR = auto()
105    NESTED = auto()
106    NOTHING = auto()
107    NULL = auto()
108    NUMMULTIRANGE = auto()
109    NUMRANGE = auto()
110    NVARCHAR = auto()
111    OBJECT = auto()
112    RANGE = auto()
113    ROWVERSION = auto()
114    SERIAL = auto()
115    SET = auto()
116    SMALLDATETIME = auto()
117    SMALLINT = auto()
118    SMALLMONEY = auto()
119    SMALLSERIAL = auto()
120    STRUCT = auto()
121    SUPER = auto()
122    TEXT = auto()
123    TINYBLOB = auto()
124    TINYTEXT = auto()
125    TIME = auto()
126    TIMETZ = auto()
127    TIME_NS = auto()
128    TIMESTAMP = auto()
129    TIMESTAMPNTZ = auto()
130    TIMESTAMPLTZ = auto()
131    TIMESTAMPTZ = auto()
132    TIMESTAMP_S = auto()
133    TIMESTAMP_MS = auto()
134    TIMESTAMP_NS = auto()
135    TINYINT = auto()
136    TSMULTIRANGE = auto()
137    TSRANGE = auto()
138    TSTZMULTIRANGE = auto()
139    TSTZRANGE = auto()
140    UBIGINT = auto()
141    UINT = auto()
142    UINT128 = auto()
143    UINT256 = auto()
144    UMEDIUMINT = auto()
145    UDECIMAL = auto()
146    UDOUBLE = auto()
147    UNION = auto()
148    UNKNOWN = auto()  # Sentinel value, useful for type annotation
149    USERDEFINED = "USER-DEFINED"
150    USMALLINT = auto()
151    UTINYINT = auto()
152    UUID = auto()
153    VARBINARY = auto()
154    VARCHAR = auto()
155    VARIANT = auto()
156    VECTOR = auto()
157    XML = auto()
158    YEAR = auto()
159    TDIGEST = auto()
160
161    def into_expr(self, **kwargs: object) -> DataType:
162        """Converts this `DType` into a `DataType` instance.
163
164        Args:
165            **kwargs (object): additional arguments to pass in the constructor of DataType.
166        Returns:
167            DataType: the resulting `DataType` instance.
168        """
169        return DataType(this=self).set_kwargs(kwargs)
170
171
172class DataType(Expression):
173    arg_types = {
174        "this": True,
175        "expressions": False,
176        "nested": False,
177        "values": False,
178        "kind": False,
179        "nullable": False,
180    }
181
182    Type: t.ClassVar[Type[DType]] = DType
183
184    STRUCT_TYPES: t.ClassVar[set[DType]] = {
185        DType.FILE,
186        DType.NESTED,
187        DType.OBJECT,
188        DType.STRUCT,
189        DType.UNION,
190    }
191
192    ARRAY_TYPES: t.ClassVar[set[DType]] = {
193        DType.ARRAY,
194        DType.LIST,
195    }
196
197    NESTED_TYPES: t.ClassVar[set[DType]] = {
198        DType.FILE,
199        DType.NESTED,
200        DType.OBJECT,
201        DType.STRUCT,
202        DType.UNION,
203        DType.ARRAY,
204        DType.LIST,
205        DType.MAP,
206    }
207
208    TEXT_TYPES: t.ClassVar[set[DType]] = {
209        DType.CHAR,
210        DType.NCHAR,
211        DType.NVARCHAR,
212        DType.TEXT,
213        DType.VARCHAR,
214        DType.NAME,
215    }
216
217    SIGNED_INTEGER_TYPES: t.ClassVar[set[DType]] = {
218        DType.BIGINT,
219        DType.INT,
220        DType.INT128,
221        DType.INT256,
222        DType.MEDIUMINT,
223        DType.SMALLINT,
224        DType.TINYINT,
225    }
226
227    UNSIGNED_INTEGER_TYPES: t.ClassVar[set[DType]] = {
228        DType.UBIGINT,
229        DType.UINT,
230        DType.UINT128,
231        DType.UINT256,
232        DType.UMEDIUMINT,
233        DType.USMALLINT,
234        DType.UTINYINT,
235    }
236
237    INTEGER_TYPES: t.ClassVar[set[DType]] = {
238        DType.BIGINT,
239        DType.INT,
240        DType.INT128,
241        DType.INT256,
242        DType.MEDIUMINT,
243        DType.SMALLINT,
244        DType.TINYINT,
245        DType.UBIGINT,
246        DType.UINT,
247        DType.UINT128,
248        DType.UINT256,
249        DType.UMEDIUMINT,
250        DType.USMALLINT,
251        DType.UTINYINT,
252        DType.BIT,
253    }
254
255    FLOAT_TYPES: t.ClassVar[set[DType]] = {
256        DType.DOUBLE,
257        DType.FLOAT,
258    }
259
260    REAL_TYPES: t.ClassVar[set[DType]] = {
261        DType.DOUBLE,
262        DType.FLOAT,
263        DType.BIGDECIMAL,
264        DType.DECIMAL,
265        DType.DECIMAL32,
266        DType.DECIMAL64,
267        DType.DECIMAL128,
268        DType.DECIMAL256,
269        DType.DECFLOAT,
270        DType.MONEY,
271        DType.SMALLMONEY,
272        DType.UDECIMAL,
273        DType.UDOUBLE,
274    }
275
276    NUMERIC_TYPES: t.ClassVar[set[DType]] = {
277        DType.BIGINT,
278        DType.INT,
279        DType.INT128,
280        DType.INT256,
281        DType.MEDIUMINT,
282        DType.SMALLINT,
283        DType.TINYINT,
284        DType.UBIGINT,
285        DType.UINT,
286        DType.UINT128,
287        DType.UINT256,
288        DType.UMEDIUMINT,
289        DType.USMALLINT,
290        DType.UTINYINT,
291        DType.BIT,
292        DType.DOUBLE,
293        DType.FLOAT,
294        DType.BIGDECIMAL,
295        DType.DECIMAL,
296        DType.DECIMAL32,
297        DType.DECIMAL64,
298        DType.DECIMAL128,
299        DType.DECIMAL256,
300        DType.DECFLOAT,
301        DType.MONEY,
302        DType.SMALLMONEY,
303        DType.UDECIMAL,
304        DType.UDOUBLE,
305    }
306
307    TEMPORAL_TYPES: t.ClassVar[set[DType]] = {
308        DType.DATE,
309        DType.DATE32,
310        DType.DATETIME,
311        DType.DATETIME2,
312        DType.DATETIME64,
313        DType.SMALLDATETIME,
314        DType.TIME,
315        DType.TIMESTAMP,
316        DType.TIMESTAMPNTZ,
317        DType.TIMESTAMPLTZ,
318        DType.TIMESTAMPTZ,
319        DType.TIMESTAMP_MS,
320        DType.TIMESTAMP_NS,
321        DType.TIMESTAMP_S,
322        DType.TIMETZ,
323    }
324
325    @classmethod
326    def build(
327        cls,
328        dtype: DATA_TYPE,
329        dialect: DialectType = None,
330        udt: bool = False,
331        copy: bool = True,
332        **kwargs: object,
333    ) -> DataType:
334        """
335        Constructs a DataType object.
336
337        Args:
338            dtype: the data type of interest.
339            dialect: the dialect to use for parsing `dtype`, in case it's a string.
340            udt: when set to True, `dtype` will be used as-is if it can't be parsed into a
341                DataType, thus creating a user-defined type.
342            copy: whether to copy the data type.
343            kwargs: additional arguments to pass in the constructor of DataType.
344
345        Returns:
346            The constructed DataType object.
347        """
348        from sqlglot import parse_one
349
350        if isinstance(dtype, str):
351            if dtype.upper() == "UNKNOWN":
352                return DataType(this=DType.UNKNOWN, **kwargs)
353
354            try:
355                data_type_exp = parse_one(
356                    dtype, read=dialect, into=DataType, error_level=ErrorLevel.IGNORE
357                )
358            except ParseError:
359                if udt:
360                    return DataType(this=DType.USERDEFINED, kind=dtype, **kwargs)
361                raise
362        elif isinstance(dtype, DType):
363            data_type_exp = DataType(this=dtype)
364        elif isinstance(dtype, (Identifier, Dot)) and udt:
365            return DataType(this=DType.USERDEFINED, kind=dtype, **kwargs)
366        elif isinstance(dtype, DataType):
367            return maybe_copy(dtype, copy)
368        else:
369            raise ValueError(f"Invalid data type: {type(dtype)}. Expected str or DType")
370        if kwargs:
371            for k, v in kwargs.items():
372                data_type_exp.set(k, v)
373        return data_type_exp
374
375    def is_type(self, *dtypes: DATA_TYPE, check_nullable: bool = False) -> bool:
376        """
377        Checks whether this DataType matches one of the provided data types. Nested types or precision
378        will be compared using "structural equivalence" semantics, so e.g. array<int> != array<float>.
379
380        Args:
381            dtypes: the data types to compare this DataType to.
382            check_nullable: whether to take the NULLABLE type constructor into account for the comparison.
383                If false, it means that NULLABLE<INT> is equivalent to INT.
384
385        Returns:
386            True, if and only if there is a type in `dtypes` which is equal to this DataType.
387        """
388        self_is_nullable = self.args.get("nullable")
389        for dtype in dtypes:
390            other_type = DataType.build(dtype, copy=False, udt=True)
391            other_is_nullable = other_type.args.get("nullable")
392            if (
393                other_type.expressions
394                or (check_nullable and (self_is_nullable or other_is_nullable))
395                or self.this == DType.USERDEFINED
396                or other_type.this == DType.USERDEFINED
397            ):
398                matches = self == other_type
399            else:
400                matches = self.this == other_type.this
401
402            if matches:
403                return True
404        return False
405
406
407class PseudoType(DataType):
408    arg_types = {"this": True}
409
410
411class ObjectIdentifier(DataType):
412    arg_types = {"this": True}
413
414
415class IntervalSpan(DataType):
416    arg_types = {"this": True, "expression": True}
417
418
419class Interval(_TimeUnit):
420    arg_types = {"this": False, "unit": False}
421
422
423DATA_TYPE = t.Union[str, Identifier, Dot, DataType, DType]

class DataTypeParam(sqlglot.expressions.core.Expression): View Source

24class DataTypeParam(Expression):
25    arg_types = {"this": True, "expression": False}
26
27    @property
28    def name(self) -> str:
29        return self.this.name

arg_types = {'this': True, 'expression': False}

name: str View Source

27    @property
28    def name(self) -> str:
29        return self.this.name

key: ClassVar[str] = 'datatypeparam'

required_args: 't.ClassVar[set[str]]' = {'this'}

Inherited Members

sqlglot.expressions.core.Expr: Expr; is_var_len_args; is_subquery; is_cast; is_primitive; dump; load; pipe; apply
sqlglot.expressions.core.Expression: this; expression; expressions; text; is_string; is_number; to_py; is_int; is_star; alias; alias_column_names; alias_or_name; output_name; type; is_type; is_leaf; meta; copy; add_comments; pop_comments; append; set; set_kwargs; depth; iter_expressions; find; find_all; find_ancestor; parent_select; same_parent; root; walk; dfs; bfs; unnest; unalias; unnest_operands; flatten; to_s; sql; transform; replace; pop; assert_is; error_messages; and_; or_; not_; update_positions; as_; isin; between; is_; like; ilike; eq; neq; rlike; div; asc; desc; args; parent; arg_key; index; comments

class DType(sqlglot.helper.AutoName): View Source

 32class DType(AutoName):
 33    ARRAY = auto()
 34    AGGREGATEFUNCTION = auto()
 35    SIMPLEAGGREGATEFUNCTION = auto()
 36    BIGDECIMAL = auto()
 37    BIGINT = auto()
 38    BIGNUM = auto()
 39    BIGSERIAL = auto()
 40    BINARY = auto()
 41    BIT = auto()
 42    BLOB = auto()
 43    BOOLEAN = auto()
 44    BPCHAR = auto()
 45    CHAR = auto()
 46    CHARACTER_SET = auto()
 47    DATE = auto()
 48    DATE32 = auto()
 49    DATEMULTIRANGE = auto()
 50    DATERANGE = auto()
 51    DATETIME = auto()
 52    DATETIME2 = auto()
 53    DATETIME64 = auto()
 54    DECIMAL = auto()
 55    DECIMAL32 = auto()
 56    DECIMAL64 = auto()
 57    DECIMAL128 = auto()
 58    DECIMAL256 = auto()
 59    DECFLOAT = auto()
 60    DOUBLE = auto()
 61    DYNAMIC = auto()
 62    ENUM = auto()
 63    ENUM8 = auto()
 64    ENUM16 = auto()
 65    FILE = auto()
 66    FIXEDSTRING = auto()
 67    FLOAT = auto()
 68    GEOGRAPHY = auto()
 69    GEOGRAPHYPOINT = auto()
 70    GEOMETRY = auto()
 71    POINT = auto()
 72    RING = auto()
 73    LINESTRING = auto()
 74    MULTILINESTRING = auto()
 75    POLYGON = auto()
 76    MULTIPOLYGON = auto()
 77    HLLSKETCH = auto()
 78    HSTORE = auto()
 79    IMAGE = auto()
 80    INET = auto()
 81    INT = auto()
 82    INT128 = auto()
 83    INT256 = auto()
 84    INT4MULTIRANGE = auto()
 85    INT4RANGE = auto()
 86    INT8MULTIRANGE = auto()
 87    INT8RANGE = auto()
 88    INTERVAL = auto()
 89    IPADDRESS = auto()
 90    IPPREFIX = auto()
 91    IPV4 = auto()
 92    IPV6 = auto()
 93    JSON = auto()
 94    JSONB = auto()
 95    LIST = auto()
 96    LONGBLOB = auto()
 97    LONGTEXT = auto()
 98    LOWCARDINALITY = auto()
 99    MAP = auto()
100    MEDIUMBLOB = auto()
101    MEDIUMINT = auto()
102    MEDIUMTEXT = auto()
103    MONEY = auto()
104    NAME = auto()
105    NCHAR = auto()
106    NESTED = auto()
107    NOTHING = auto()
108    NULL = auto()
109    NUMMULTIRANGE = auto()
110    NUMRANGE = auto()
111    NVARCHAR = auto()
112    OBJECT = auto()
113    RANGE = auto()
114    ROWVERSION = auto()
115    SERIAL = auto()
116    SET = auto()
117    SMALLDATETIME = auto()
118    SMALLINT = auto()
119    SMALLMONEY = auto()
120    SMALLSERIAL = auto()
121    STRUCT = auto()
122    SUPER = auto()
123    TEXT = auto()
124    TINYBLOB = auto()
125    TINYTEXT = auto()
126    TIME = auto()
127    TIMETZ = auto()
128    TIME_NS = auto()
129    TIMESTAMP = auto()
130    TIMESTAMPNTZ = auto()
131    TIMESTAMPLTZ = auto()
132    TIMESTAMPTZ = auto()
133    TIMESTAMP_S = auto()
134    TIMESTAMP_MS = auto()
135    TIMESTAMP_NS = auto()
136    TINYINT = auto()
137    TSMULTIRANGE = auto()
138    TSRANGE = auto()
139    TSTZMULTIRANGE = auto()
140    TSTZRANGE = auto()
141    UBIGINT = auto()
142    UINT = auto()
143    UINT128 = auto()
144    UINT256 = auto()
145    UMEDIUMINT = auto()
146    UDECIMAL = auto()
147    UDOUBLE = auto()
148    UNION = auto()
149    UNKNOWN = auto()  # Sentinel value, useful for type annotation
150    USERDEFINED = "USER-DEFINED"
151    USMALLINT = auto()
152    UTINYINT = auto()
153    UUID = auto()
154    VARBINARY = auto()
155    VARCHAR = auto()
156    VARIANT = auto()
157    VECTOR = auto()
158    XML = auto()
159    YEAR = auto()
160    TDIGEST = auto()
161
162    def into_expr(self, **kwargs: object) -> DataType:
163        """Converts this `DType` into a `DataType` instance.
164
165        Args:
166            **kwargs (object): additional arguments to pass in the constructor of DataType.
167        Returns:
168            DataType: the resulting `DataType` instance.
169        """
170        return DataType(this=self).set_kwargs(kwargs)

An enumeration.

ARRAY = <DType.ARRAY: 'ARRAY'>

AGGREGATEFUNCTION = <DType.AGGREGATEFUNCTION: 'AGGREGATEFUNCTION'>

SIMPLEAGGREGATEFUNCTION = <DType.SIMPLEAGGREGATEFUNCTION: 'SIMPLEAGGREGATEFUNCTION'>

BIGDECIMAL = <DType.BIGDECIMAL: 'BIGDECIMAL'>

BIGINT = <DType.BIGINT: 'BIGINT'>

BIGNUM = <DType.BIGNUM: 'BIGNUM'>

BIGSERIAL = <DType.BIGSERIAL: 'BIGSERIAL'>

BINARY = <DType.BINARY: 'BINARY'>

BIT = <DType.BIT: 'BIT'>

BLOB = <DType.BLOB: 'BLOB'>

BOOLEAN = <DType.BOOLEAN: 'BOOLEAN'>

BPCHAR = <DType.BPCHAR: 'BPCHAR'>

CHAR = <DType.CHAR: 'CHAR'>

CHARACTER_SET = <DType.CHARACTER_SET: 'CHARACTER_SET'>

DATE = <DType.DATE: 'DATE'>

DATE32 = <DType.DATE32: 'DATE32'>

DATEMULTIRANGE = <DType.DATEMULTIRANGE: 'DATEMULTIRANGE'>

DATERANGE = <DType.DATERANGE: 'DATERANGE'>

DATETIME = <DType.DATETIME: 'DATETIME'>

DATETIME2 = <DType.DATETIME2: 'DATETIME2'>

DATETIME64 = <DType.DATETIME64: 'DATETIME64'>

DECIMAL = <DType.DECIMAL: 'DECIMAL'>

DECIMAL32 = <DType.DECIMAL32: 'DECIMAL32'>

DECIMAL64 = <DType.DECIMAL64: 'DECIMAL64'>

DECIMAL128 = <DType.DECIMAL128: 'DECIMAL128'>

DECIMAL256 = <DType.DECIMAL256: 'DECIMAL256'>

DECFLOAT = <DType.DECFLOAT: 'DECFLOAT'>

DOUBLE = <DType.DOUBLE: 'DOUBLE'>

DYNAMIC = <DType.DYNAMIC: 'DYNAMIC'>

ENUM = <DType.ENUM: 'ENUM'>

ENUM8 = <DType.ENUM8: 'ENUM8'>

ENUM16 = <DType.ENUM16: 'ENUM16'>

FILE = <DType.FILE: 'FILE'>

FIXEDSTRING = <DType.FIXEDSTRING: 'FIXEDSTRING'>

FLOAT = <DType.FLOAT: 'FLOAT'>

GEOGRAPHY = <DType.GEOGRAPHY: 'GEOGRAPHY'>

GEOGRAPHYPOINT = <DType.GEOGRAPHYPOINT: 'GEOGRAPHYPOINT'>

GEOMETRY = <DType.GEOMETRY: 'GEOMETRY'>

POINT = <DType.POINT: 'POINT'>

RING = <DType.RING: 'RING'>

LINESTRING = <DType.LINESTRING: 'LINESTRING'>

MULTILINESTRING = <DType.MULTILINESTRING: 'MULTILINESTRING'>

POLYGON = <DType.POLYGON: 'POLYGON'>

MULTIPOLYGON = <DType.MULTIPOLYGON: 'MULTIPOLYGON'>

HLLSKETCH = <DType.HLLSKETCH: 'HLLSKETCH'>

HSTORE = <DType.HSTORE: 'HSTORE'>

IMAGE = <DType.IMAGE: 'IMAGE'>

INET = <DType.INET: 'INET'>

INT = <DType.INT: 'INT'>

INT128 = <DType.INT128: 'INT128'>

INT256 = <DType.INT256: 'INT256'>

INT4MULTIRANGE = <DType.INT4MULTIRANGE: 'INT4MULTIRANGE'>

INT4RANGE = <DType.INT4RANGE: 'INT4RANGE'>

INT8MULTIRANGE = <DType.INT8MULTIRANGE: 'INT8MULTIRANGE'>

INT8RANGE = <DType.INT8RANGE: 'INT8RANGE'>

INTERVAL = <DType.INTERVAL: 'INTERVAL'>

IPADDRESS = <DType.IPADDRESS: 'IPADDRESS'>

IPPREFIX = <DType.IPPREFIX: 'IPPREFIX'>

IPV4 = <DType.IPV4: 'IPV4'>

IPV6 = <DType.IPV6: 'IPV6'>

JSON = <DType.JSON: 'JSON'>

JSONB = <DType.JSONB: 'JSONB'>

LIST = <DType.LIST: 'LIST'>

LONGBLOB = <DType.LONGBLOB: 'LONGBLOB'>

LONGTEXT = <DType.LONGTEXT: 'LONGTEXT'>

LOWCARDINALITY = <DType.LOWCARDINALITY: 'LOWCARDINALITY'>

MAP = <DType.MAP: 'MAP'>

MEDIUMBLOB = <DType.MEDIUMBLOB: 'MEDIUMBLOB'>

MEDIUMINT = <DType.MEDIUMINT: 'MEDIUMINT'>

MEDIUMTEXT = <DType.MEDIUMTEXT: 'MEDIUMTEXT'>

MONEY = <DType.MONEY: 'MONEY'>

NAME = <DType.NAME: 'NAME'>

NCHAR = <DType.NCHAR: 'NCHAR'>

NESTED = <DType.NESTED: 'NESTED'>

NOTHING = <DType.NOTHING: 'NOTHING'>

NULL = <DType.NULL: 'NULL'>

NUMMULTIRANGE = <DType.NUMMULTIRANGE: 'NUMMULTIRANGE'>

NUMRANGE = <DType.NUMRANGE: 'NUMRANGE'>

NVARCHAR = <DType.NVARCHAR: 'NVARCHAR'>

OBJECT = <DType.OBJECT: 'OBJECT'>

RANGE = <DType.RANGE: 'RANGE'>

ROWVERSION = <DType.ROWVERSION: 'ROWVERSION'>

SERIAL = <DType.SERIAL: 'SERIAL'>

SET = <DType.SET: 'SET'>

SMALLDATETIME = <DType.SMALLDATETIME: 'SMALLDATETIME'>

SMALLINT = <DType.SMALLINT: 'SMALLINT'>

SMALLMONEY = <DType.SMALLMONEY: 'SMALLMONEY'>

SMALLSERIAL = <DType.SMALLSERIAL: 'SMALLSERIAL'>

STRUCT = <DType.STRUCT: 'STRUCT'>

SUPER = <DType.SUPER: 'SUPER'>

TEXT = <DType.TEXT: 'TEXT'>

TINYBLOB = <DType.TINYBLOB: 'TINYBLOB'>

TINYTEXT = <DType.TINYTEXT: 'TINYTEXT'>

TIME = <DType.TIME: 'TIME'>

TIMETZ = <DType.TIMETZ: 'TIMETZ'>

TIME_NS = <DType.TIME_NS: 'TIME_NS'>

TIMESTAMP = <DType.TIMESTAMP: 'TIMESTAMP'>

TIMESTAMPNTZ = <DType.TIMESTAMPNTZ: 'TIMESTAMPNTZ'>

TIMESTAMPLTZ = <DType.TIMESTAMPLTZ: 'TIMESTAMPLTZ'>

TIMESTAMPTZ = <DType.TIMESTAMPTZ: 'TIMESTAMPTZ'>

TIMESTAMP_S = <DType.TIMESTAMP_S: 'TIMESTAMP_S'>

TIMESTAMP_MS = <DType.TIMESTAMP_MS: 'TIMESTAMP_MS'>

TIMESTAMP_NS = <DType.TIMESTAMP_NS: 'TIMESTAMP_NS'>

TINYINT = <DType.TINYINT: 'TINYINT'>

TSMULTIRANGE = <DType.TSMULTIRANGE: 'TSMULTIRANGE'>

TSRANGE = <DType.TSRANGE: 'TSRANGE'>

TSTZMULTIRANGE = <DType.TSTZMULTIRANGE: 'TSTZMULTIRANGE'>

TSTZRANGE = <DType.TSTZRANGE: 'TSTZRANGE'>

UBIGINT = <DType.UBIGINT: 'UBIGINT'>

UINT = <DType.UINT: 'UINT'>

UINT128 = <DType.UINT128: 'UINT128'>

UINT256 = <DType.UINT256: 'UINT256'>

UMEDIUMINT = <DType.UMEDIUMINT: 'UMEDIUMINT'>

UDECIMAL = <DType.UDECIMAL: 'UDECIMAL'>

UDOUBLE = <DType.UDOUBLE: 'UDOUBLE'>

UNION = <DType.UNION: 'UNION'>

UNKNOWN = <DType.UNKNOWN: 'UNKNOWN'>

USERDEFINED = <DType.USERDEFINED: 'USER-DEFINED'>

USMALLINT = <DType.USMALLINT: 'USMALLINT'>

UTINYINT = <DType.UTINYINT: 'UTINYINT'>

UUID = <DType.UUID: 'UUID'>

VARBINARY = <DType.VARBINARY: 'VARBINARY'>

VARCHAR = <DType.VARCHAR: 'VARCHAR'>

VARIANT = <DType.VARIANT: 'VARIANT'>

VECTOR = <DType.VECTOR: 'VECTOR'>

XML = <DType.XML: 'XML'>

YEAR = <DType.YEAR: 'YEAR'>

TDIGEST = <DType.TDIGEST: 'TDIGEST'>

def into_expr(self, **kwargs: object) -> DataType: View Source

162    def into_expr(self, **kwargs: object) -> DataType:
163        """Converts this `DType` into a `DataType` instance.
164
165        Args:
166            **kwargs (object): additional arguments to pass in the constructor of DataType.
167        Returns:
168            DataType: the resulting `DataType` instance.
169        """
170        return DataType(this=self).set_kwargs(kwargs)

Converts this DType into a DataType instance.

Arguments:

**kwargs (object): additional arguments to pass in the constructor of DataType.

Returns:

DataType: the resulting DataType instance.

class PseudoType(DataType): View Source

408class PseudoType(DataType):
409    arg_types = {"this": True}

arg_types = {'this': True}

key: ClassVar[str] = 'pseudotype'

required_args: 't.ClassVar[set[str]]' = {'this'}

Inherited Members

sqlglot.expressions.core.Expr: Expr; is_var_len_args; is_subquery; is_cast; is_primitive; dump; load; pipe; apply
DataType: Type; STRUCT_TYPES; ARRAY_TYPES; NESTED_TYPES; TEXT_TYPES; SIGNED_INTEGER_TYPES; UNSIGNED_INTEGER_TYPES; INTEGER_TYPES; FLOAT_TYPES; REAL_TYPES; NUMERIC_TYPES; TEMPORAL_TYPES; build; is_type
sqlglot.expressions.core.Expression: this; expression; expressions; text; is_string; is_number; to_py; is_int; is_star; alias; alias_column_names; name; alias_or_name; output_name; type; is_leaf; meta; copy; add_comments; pop_comments; append; set; set_kwargs; depth; iter_expressions; find; find_all; find_ancestor; parent_select; same_parent; root; walk; dfs; bfs; unnest; unalias; unnest_operands; flatten; to_s; sql; transform; replace; pop; assert_is; error_messages; and_; or_; not_; update_positions; as_; isin; between; is_; like; ilike; eq; neq; rlike; div; asc; desc; args; parent; arg_key; index; comments

class ObjectIdentifier(DataType): View Source

412class ObjectIdentifier(DataType):
413    arg_types = {"this": True}

arg_types = {'this': True}

key: ClassVar[str] = 'objectidentifier'

required_args: 't.ClassVar[set[str]]' = {'this'}

Inherited Members

sqlglot.expressions.core.Expr: Expr; is_var_len_args; is_subquery; is_cast; is_primitive; dump; load; pipe; apply
DataType: Type; STRUCT_TYPES; ARRAY_TYPES; NESTED_TYPES; TEXT_TYPES; SIGNED_INTEGER_TYPES; UNSIGNED_INTEGER_TYPES; INTEGER_TYPES; FLOAT_TYPES; REAL_TYPES; NUMERIC_TYPES; TEMPORAL_TYPES; build; is_type
sqlglot.expressions.core.Expression: this; expression; expressions; text; is_string; is_number; to_py; is_int; is_star; alias; alias_column_names; name; alias_or_name; output_name; type; is_leaf; meta; copy; add_comments; pop_comments; append; set; set_kwargs; depth; iter_expressions; find; find_all; find_ancestor; parent_select; same_parent; root; walk; dfs; bfs; unnest; unalias; unnest_operands; flatten; to_s; sql; transform; replace; pop; assert_is; error_messages; and_; or_; not_; update_positions; as_; isin; between; is_; like; ilike; eq; neq; rlike; div; asc; desc; args; parent; arg_key; index; comments

class IntervalSpan(DataType): View Source

416class IntervalSpan(DataType):
417    arg_types = {"this": True, "expression": True}

arg_types = {'this': True, 'expression': True}

key: ClassVar[str] = 'intervalspan'

required_args: 't.ClassVar[set[str]]' = {'expression', 'this'}

Inherited Members

sqlglot.expressions.core.Expr: Expr; is_var_len_args; is_subquery; is_cast; is_primitive; dump; load; pipe; apply
DataType: Type; STRUCT_TYPES; ARRAY_TYPES; NESTED_TYPES; TEXT_TYPES; SIGNED_INTEGER_TYPES; UNSIGNED_INTEGER_TYPES; INTEGER_TYPES; FLOAT_TYPES; REAL_TYPES; NUMERIC_TYPES; TEMPORAL_TYPES; build; is_type
sqlglot.expressions.core.Expression: this; expression; expressions; text; is_string; is_number; to_py; is_int; is_star; alias; alias_column_names; name; alias_or_name; output_name; type; is_leaf; meta; copy; add_comments; pop_comments; append; set; set_kwargs; depth; iter_expressions; find; find_all; find_ancestor; parent_select; same_parent; root; walk; dfs; bfs; unnest; unalias; unnest_operands; flatten; to_s; sql; transform; replace; pop; assert_is; error_messages; and_; or_; not_; update_positions; as_; isin; between; is_; like; ilike; eq; neq; rlike; div; asc; desc; args; parent; arg_key; index; comments

class Interval(sqlglot.expressions.core._TimeUnit): View Source

420class Interval(_TimeUnit):
421    arg_types = {"this": False, "unit": False}

arg_types = {'this': False, 'unit': False}

key: ClassVar[str] = 'interval'

required_args: 't.ClassVar[set[str]]' = set()

Inherited Members

sqlglot.expressions.core.TimeUnit: TimeUnit; UNABBREVIATED_UNIT_NAME; VAR_LIKE; unit
sqlglot.expressions.core.Expression: this; expression; expressions; text; is_string; is_number; to_py; is_int; is_star; alias; alias_column_names; name; alias_or_name; output_name; type; is_type; is_leaf; meta; copy; add_comments; pop_comments; append; set; set_kwargs; depth; iter_expressions; find; find_all; find_ancestor; parent_select; same_parent; root; walk; dfs; bfs; unnest; unalias; unnest_operands; flatten; to_s; sql; transform; replace; pop; assert_is; error_messages; and_; or_; not_; update_positions; as_; isin; between; is_; like; ilike; eq; neq; rlike; div; asc; desc; args; parent; arg_key; index; comments
sqlglot.expressions.core.Expr: is_var_len_args; is_subquery; is_cast; is_primitive; dump; load; pipe; apply

DATA_TYPE = typing.Union[str, sqlglot.expressions.core.Identifier, sqlglot.expressions.core.Dot, DataType, DType]