Method create_type

astrapy/data/database.py:4039–4125

Creates a user-defined type (UDT) on the database. A user-defined type is scoped to a keyspace: unless otherwise specified, the UDT creation targets the database's working keyspace. Args: name: the name of the type to create. This will be subsequently u

(
        self,
        name: str,
        *,
        definition: CreateTypeDefinition | dict[str, Any],
        keyspace: str | None = None,
        if_not_exists: bool | None = None,
        table_admin_timeout_ms: int | None = None,
        request_timeout_ms: int | None = None,
        timeout_ms: int | None = None,
    )

            return lt_response["status"]["tables"]  # type: ignore[no-any-return]

    async def create_type(
        self,
        name: str,
        *,
        definition: CreateTypeDefinition | dict[str, Any],
        keyspace: str | None = None,
        if_not_exists: bool | None = None,
        table_admin_timeout_ms: int | None = None,
        request_timeout_ms: int | None = None,
        timeout_ms: int | None = None,
    ) -> None:
        """
        Creates a user-defined type (UDT) on the database.

        A user-defined type is scoped to a keyspace: unless otherwise specified,
        the UDT creation targets the database's working keyspace.

        Args:
            name: the name of the type to create. This will be subsequently used
                e.g. for defining UDT-valued columns when creating a table.
            definition: a complete type definition. This can be an
                instance of `CreateTypeDefinition` or an equivalent (nested) dictionary,
                in which case it will be parsed into a `CreateTypeDefinition`.
                See the `astrapy.info.CreateTypeDefinition` class for more details.
            keyspace: the keyspace where the type is to be created.
                If not specified, the general setting for this database is used.
            if_not_exists: if set to True, the command will succeed even if a type
                with the specified name already exists (in which case no actual
                creation takes place on the database). Defaults to False,
                i.e. an error is raised by the API in case of type-name collision.
            table_admin_timeout_ms: a timeout, in milliseconds, to impose on the
                underlying API request. If not provided, this object's defaults apply.
                (This method issues a single API request, hence all timeout parameters
                are treated the same.)
            request_timeout_ms: an alias for `table_admin_timeout_ms`.
            timeout_ms: an alias for `table_admin_timeout_ms`.

        Example:
            >>> # NOTE: may require slight adaptation to an async context.
            >>>
            >>> from astrapy.info import CreateTypeDefinition
            >>> type_definition = CreateTypeDefinition.coerce(
            ...     {"fields": {"genus": "text", "species": "text"}}
            ... )
            >>> await async_database.create_type("sci_name", definition=type_definition)
        """
        cty_options: dict[str, bool]
        if if_not_exists is not None:
            cty_options = {"ifNotExists": if_not_exists}
        else:
            cty_options = {}
        cty_definition: dict[str, Any] = CreateTypeDefinition.coerce(
            definition
        ).as_dict()
        _table_admin_timeout_ms, _ta_label = _select_singlereq_timeout_ta(
            timeout_options=self.api_options.timeout_options,
            table_admin_timeout_ms=table_admin_timeout_ms,
            request_timeout_ms=request_timeout_ms,