Catálogo completo de tipos de columna

El catálogo contiene 40 factorías de Column para 39 tipos lógicos, incluido el atajo id. Cada factoría también está disponible en Blueprint y devuelve una ColumnDefinition concreta; construirla no ejecuta SQL. Las clases del ORM se importan desde orionis.orm. Los 35 tipos con builder pueden traducirse a SQL, mientras que cuatro marcadores carecen de compilación; se identifican expresamente al final.

Cómo leer las firmas

El primer name de cada factoría es el nombre SQL de columna y es obligatorio, salvo id(name=“id”). El asterisco marca parámetros que solo se pasan por nombre. El constructor ORM no recibe ese nombre: la metaclase lo toma del atributo declarado. Todas las definiciones admiten los modificadores de columna. Sus valores iniciales son NOT NULL, sin índice, unique, autoincremento ni default; id es el atajo que activa clave primaria y generación.

Los fragmentos de DDL se comprobaron compilando las definiciones de ejemplo con los dialectos instalados de SQLite, MySQL, PostgreSQL, SQL Server y Oracle. Compilar no certifica que un servidor acepte el tipo: tipos estrictos como CLOB, BINARY, NCHAR o TIMESTAMP conservan particularidades del motor. Redshift necesita su extra y sus restricciones se explican en motores.

Los fragmentos SQL siguientes proceden de una declaración de prueba independiente: sample, con length=80 para String/Unicode/VARCHAR/NVARCHAR, 2 para CHAR/NCHAR, 16 para BINARY, 64 para VARBINARY y precision=12/scale=2 en decimales. Las opciones restantes usan defaults, incluido timezone=False. Los ejemplos de uso pueden elegir valores distintos.

Parámetros compartidos

Parámetro	Efecto
length	Longitud declarada de texto o binario; no valida el payload HTTP. None deja la decisión al motor.
collation	Intercalación de columna; debe existir en la base seleccionada.
precision / scale	Total de dígitos y dígitos decimales en Numeric/StrictDecimal. En Float, precision tiene semántica del dialecto.
asdecimal	Solicita Decimal frente a float en tipos numéricos; no cambia una columna aproximada en exacta.
decimal_return_scale	Escala usada al convertir resultados aproximados a Decimal.
timezone	Solicita soporte de zona del tipo; no hace conversión automática universal.
create_constraint / constraint_name	Creación y nombre del CHECK para boolean/enum emulados. En los constructores se usa name.
native_enum / validate_strings	Elegir ENUM nativo y validar strings en su procesador.
native / second_precision / day_precision	Representación y precisión de INTERVAL.
as_uuid / native_uuid	Objetos UUID y representación nativa donde exista.
none_as_null	Diferencia entre JSON null y SQL NULL para valores None.

id: Identificador generado

Column.id(name: str='id') -> BigInteger
BigInteger()

Úsalo como clave primaria entera autogenerada. Es BigInteger con primary y autoIncrement ya activados; no lo combines con otra primaryKey. En SQLite se compila INTEGER para conservar ROWID. Oracle recibe Identity; SQL Server, IDENTITY; Redshift necesita su dialecto y no devuelve automáticamente la clave generada.

from orionis.database.schema.blueprint import Blueprint
from orionis.orm import BigInteger


table = Blueprint()
column = table.id()
model_column = BigInteger().primary().autoIncrement()

La factoría devuelve BigInteger; el constructor devuelve una nueva instancia del mismo tipo. Ambos heredan ColumnDefinition.

DDL de la declaración de prueba: sqlite: INTEGER NOT NULL; mysql: BIGINT NOT NULL AUTO_INCREMENT; pgsql: BIGSERIAL NOT NULL; sqlserver: BIGINT NOT NULL IDENTITY; oracle: NUMBER(19) GENERATED BY DEFAULT AS IDENTITY.

integer: Enteros

Column.integer(name: str) -> Integer
Integer()

Contadores y claves enteras. No añade clave primaria, generación automática ni restricciones unsigned. Los rangos y el desbordamiento corresponden al motor.

from orionis.database.schema.blueprint import Blueprint
from orionis.orm import Integer


table = Blueprint()
column = table.integer("quantity")
model_column = Integer()

La factoría devuelve Integer; el constructor devuelve una nueva instancia del mismo tipo. Ambos heredan ColumnDefinition.

DDL de la declaración de prueba: sqlite: INTEGER NOT NULL; mysql: INTEGER NOT NULL; pgsql: INTEGER NOT NULL; sqlserver: INTEGER NOT NULL; oracle: INTEGER NOT NULL.

bigInteger: Enteros grandes

Column.bigInteger(name: str) -> BigInteger
BigInteger()

Identificadores externos y contadores grandes. Sin primary y autoIncrement es una columna ordinaria; no genera valores por sí sola.

from orionis.database.schema.blueprint import Blueprint
from orionis.orm import BigInteger


table = Blueprint()
column = table.bigInteger("external_id")
model_column = BigInteger()

La factoría devuelve BigInteger; el constructor devuelve una nueva instancia del mismo tipo. Ambos heredan ColumnDefinition.

DDL de la declaración de prueba: sqlite: BIGINT NOT NULL; mysql: BIGINT NOT NULL; pgsql: BIGINT NOT NULL; sqlserver: BIGINT NOT NULL; oracle: NUMBER(19) NOT NULL.

smallInteger: Enteros pequeños

Column.smallInteger(name: str) -> SmallInteger
SmallInteger()

Estados numéricos y cantidades pequeñas. La reducción de rango la impone el motor; SQLite no garantiza los límites de SMALLINT.

from orionis.database.schema.blueprint import Blueprint
from orionis.orm import SmallInteger


table = Blueprint()
column = table.smallInteger("priority")
model_column = SmallInteger()

La factoría devuelve SmallInteger; el constructor devuelve una nueva instancia del mismo tipo. Ambos heredan ColumnDefinition.

DDL de la declaración de prueba: sqlite: SMALLINT NOT NULL; mysql: SMALLINT NOT NULL; pgsql: SMALLINT NOT NULL; sqlserver: SMALLINT NOT NULL; oracle: SMALLINT NOT NULL.

boolean: Booleanos

Column.boolean(name: str, *, create_constraint: bool=False, constraint_name: str | None=None) -> Boolean
Boolean(*, create_constraint: bool=False, name: str | None=None)

Indicadores True/False. create_constraint=False no añade el CHECK de 0/1 cuando el motor emula booleanos; actívalo si lo necesitas. En el constructor el nombre del CHECK es name; en la factoría es constraint_name.

from orionis.database.schema.blueprint import Blueprint
from orionis.orm import Boolean


table = Blueprint()
column = table.boolean("active", create_constraint=True, constraint_name="ck_active")
model_column = Boolean(create_constraint=True, name="ck_active")

La factoría devuelve Boolean; el constructor devuelve una nueva instancia del mismo tipo. Ambos heredan ColumnDefinition.

DDL de la declaración de prueba: sqlite: BOOLEAN NOT NULL; mysql: BOOL NOT NULL; pgsql: BOOLEAN NOT NULL; sqlserver: BIT NOT NULL; oracle: BOOLEAN NOT NULL.

numeric: Decimales de precisión fija

Column.numeric(name: str, precision: int | None=None, scale: int | None=None, decimal_return_scale: int | None=None, *, asdecimal: bool=True) -> Numeric
Numeric(precision: int | None=None, scale: int | None=None, decimal_return_scale: int | None=None, *, asdecimal: bool=True)

Importes y valores que requieren Decimal. precision es el total de dígitos y scale la parte decimal. Si se proporciona uno, deben proporcionarse ambos como enteros con precision>0 y 0<=scale<=precision; de otro modo ValueError. asdecimal=True solicita Decimal, sujeto al driver.

from orionis.database.schema.blueprint import Blueprint
from orionis.orm import Numeric


table = Blueprint()
column = table.numeric("amount", 12, 2)
model_column = Numeric(12, 2)

La factoría devuelve Numeric; el constructor devuelve una nueva instancia del mismo tipo. Ambos heredan ColumnDefinition.

DDL de la declaración de prueba: sqlite: NUMERIC(12, 2) NOT NULL; mysql: NUMERIC(12, 2) NOT NULL; pgsql: NUMERIC(12, 2) NOT NULL; sqlserver: NUMERIC(12, 2) NOT NULL; oracle: NUMERIC(12, 2) NOT NULL.

float: Números aproximados

Column.float(name: str, precision: int | None=None, *, asdecimal: bool=False, decimal_return_scale: int | None=None) -> Float
Float(precision: int | None=None, *, asdecimal: bool=False, decimal_return_scale: int | None=None)

Mediciones aproximadas. precision depende del dialecto y no significa número de decimales. asdecimal=False devuelve normalmente float; decimal_return_scale se usa al convertir a Decimal. Para Oracle se adapta FLOAT con precisión binaria calculada cuando hay precision.

from orionis.database.schema.blueprint import Blueprint
from orionis.orm import Float


table = Blueprint()
column = table.float("measurement", 24)
model_column = Float(24)

La factoría devuelve Float; el constructor devuelve una nueva instancia del mismo tipo. Ambos heredan ColumnDefinition.

DDL de la declaración de prueba: sqlite: FLOAT NOT NULL; mysql: FLOAT NOT NULL; pgsql: FLOAT NOT NULL; sqlserver: FLOAT NOT NULL; oracle: FLOAT NOT NULL.

double: Doble precisión

Column.double(name: str, precision: int | None=None, *, asdecimal: bool=False, decimal_return_scale: int | None=None) -> Double
Double(precision: int | None=None, *, asdecimal: bool=False, decimal_return_scale: int | None=None)

Mediciones aproximadas que necesitan doble precisión. Comparte asdecimal y decimal_return_scale con Float; no sustituye Numeric para cálculos monetarios exactos.

from orionis.database.schema.blueprint import Blueprint
from orionis.orm import Double


table = Blueprint()
column = table.double("distance")
model_column = Double()

La factoría devuelve Double; el constructor devuelve una nueva instancia del mismo tipo. Ambos heredan ColumnDefinition.

DDL de la declaración de prueba: sqlite: DOUBLE NOT NULL; mysql: DOUBLE NOT NULL; pgsql: DOUBLE PRECISION NOT NULL; sqlserver: DOUBLE PRECISION NOT NULL; oracle: DOUBLE PRECISION NOT NULL.

string: Texto limitado

Column.string(name: str, length: int | None=255, collation: str | None=None) -> String
String(length: int | None=255, collation: str | None=None)

Nombres, correos o códigos. length=255 por defecto; None elimina la longitud declarada cuando el dialecto lo permite. Longitudes no enteras o <=0 producen ValueError. collation se envía al dialecto y debe existir en el motor. SQLite no aplica un límite VARCHAR por el mero DDL.

from orionis.database.schema.blueprint import Blueprint
from orionis.orm import String


table = Blueprint()
column = table.string("title", 120)
model_column = String(120)

La factoría devuelve String; el constructor devuelve una nueva instancia del mismo tipo. Ambos heredan ColumnDefinition.

DDL de la declaración de prueba: sqlite: VARCHAR(80) NOT NULL; mysql: VARCHAR(80) NOT NULL; pgsql: VARCHAR(80) NOT NULL; sqlserver: VARCHAR(80) NOT NULL; oracle: VARCHAR2(80 CHAR) NOT NULL.

text: Texto extenso

Column.text(name: str, length: int | None=None, collation: str | None=None) -> Text
Text(length: int | None=None, collation: str | None=None)

Descripciones y documentos. length y collation se conservan como metadatos; su efecto depende del dialecto. No se añade validación de longitud de payload.

from orionis.database.schema.blueprint import Blueprint
from orionis.orm import Text


table = Blueprint()
column = table.text("description")
model_column = Text()

La factoría devuelve Text; el constructor devuelve una nueva instancia del mismo tipo. Ambos heredan ColumnDefinition.

DDL de la declaración de prueba: sqlite: TEXT NOT NULL; mysql: TEXT NOT NULL; pgsql: TEXT NOT NULL; sqlserver: TEXT NOT NULL; oracle: CLOB NOT NULL.

unicode: Texto Unicode limitado

Column.unicode(name: str, length: int | None=None, collation: str | None=None) -> Unicode
Unicode(length: int | None=None, collation: str | None=None)

Texto internacional cuando se requiere la variante Unicode del toolkit. SQL Server compila NVARCHAR; no fuerza el charset de la conexión en otros motores. Si necesitas longitud, pásala: su default es None.

from orionis.database.schema.blueprint import Blueprint
from orionis.orm import Unicode


table = Blueprint()
column = table.unicode("display_name", 120)
model_column = Unicode(120)

La factoría devuelve Unicode; el constructor devuelve una nueva instancia del mismo tipo. Ambos heredan ColumnDefinition.

DDL de la declaración de prueba: sqlite: VARCHAR(80) NOT NULL; mysql: VARCHAR(80) NOT NULL; pgsql: VARCHAR(80) NOT NULL; sqlserver: NVARCHAR(80) NOT NULL; oracle: VARCHAR2(80 CHAR) NOT NULL.

unicodeText: Texto Unicode extenso

Column.unicodeText(name: str, length: int | None=None, collation: str | None=None) -> UnicodeText
UnicodeText(length: int | None=None, collation: str | None=None)

Documentos internacionales. SQL Server compila NTEXT y Oracle CLOB en el dialecto probado; utiliza un tipo distinto si tu esquema necesita otra representación nativa.

from orionis.database.schema.blueprint import Blueprint
from orionis.orm import UnicodeText


table = Blueprint()
column = table.unicodeText("biography")
model_column = UnicodeText()

La factoría devuelve UnicodeText; el constructor devuelve una nueva instancia del mismo tipo. Ambos heredan ColumnDefinition.

DDL de la declaración de prueba: sqlite: TEXT NOT NULL; mysql: TEXT NOT NULL; pgsql: TEXT NOT NULL; sqlserver: NTEXT NOT NULL; oracle: CLOB NOT NULL.

date: Fechas

Column.date(name: str) -> Date
Date()

Fechas de calendario, representadas por datetime.date. El tipo no agrega zona horaria ni hora.

from orionis.database.schema.blueprint import Blueprint
from orionis.orm import Date


table = Blueprint()
column = table.date("birthday")
model_column = Date()

La factoría devuelve Date; el constructor devuelve una nueva instancia del mismo tipo. Ambos heredan ColumnDefinition.

DDL de la declaración de prueba: sqlite: DATE NOT NULL; mysql: DATE NOT NULL; pgsql: DATE NOT NULL; sqlserver: DATETIME NOT NULL; oracle: DATE NOT NULL.

time: Horas

Column.time(name: str) -> Time
Time()

Hora del día, representada por datetime.time según conversión del driver. No admite parámetro timezone en Orionis. La sintaxis TIME generada no garantiza que todos los servidores la acepten.

from orionis.database.schema.blueprint import Blueprint
from orionis.orm import Time


table = Blueprint()
column = table.time("opens_at")
model_column = Time()

La factoría devuelve Time; el constructor devuelve una nueva instancia del mismo tipo. Ambos heredan ColumnDefinition.

DDL de la declaración de prueba: sqlite: TIME NOT NULL; mysql: TIME NOT NULL; pgsql: TIME WITHOUT TIME ZONE NOT NULL; sqlserver: DATETIME NOT NULL; oracle: TIME NOT NULL.

dateTime: Fecha y hora

Column.dateTime(name: str, *, timezone: bool=False) -> DateTime
DateTime(*, timezone: bool=False)

Instantes o fechas con hora. timezone=False por defecto; True solicita soporte al tipo del motor, pero no convierte fechas ni conserva una zona en todos los drivers. Para PostgreSQL se genera TIMESTAMP WITH/WITHOUT TIME ZONE.

from orionis.database.schema.blueprint import Blueprint
from orionis.orm import DateTime


table = Blueprint()
column = table.dateTime("published_at", timezone=True)
model_column = DateTime(timezone=True)

La factoría devuelve DateTime; el constructor devuelve una nueva instancia del mismo tipo. Ambos heredan ColumnDefinition.

DDL de la declaración de prueba: sqlite: DATETIME NOT NULL; mysql: DATETIME NOT NULL; pgsql: TIMESTAMP WITHOUT TIME ZONE NOT NULL; sqlserver: DATETIME NOT NULL; oracle: DATE NOT NULL.

interval: Duraciones

Column.interval(name: str, *, native: bool=True, second_precision: int | None=None, day_precision: int | None=None) -> Interval
Interval(*, native: bool=True, second_precision: int | None=None, day_precision: int | None=None)

Duraciones datetime.timedelta. native=True usa INTERVAL cuando existe en PostgreSQL/Oracle; otros dialectos lo emulan mediante fecha/hora. second_precision y day_precision solo son pertinentes para las variantes nativas.

from orionis.database.schema.blueprint import Blueprint
from orionis.orm import Interval


table = Blueprint()
column = table.interval("duration", native=True)
model_column = Interval(native=True)

La factoría devuelve Interval; el constructor devuelve una nueva instancia del mismo tipo. Ambos heredan ColumnDefinition.

DDL de la declaración de prueba: sqlite: DATETIME NOT NULL; mysql: DATETIME NOT NULL; pgsql: INTERVAL NOT NULL; sqlserver: DATETIME NOT NULL; oracle: INTERVAL DAY TO SECOND NOT NULL.

largeBinary: Binarios adaptables

Column.largeBinary(name: str, length: int | None=None) -> LargeBinary
LargeBinary(length: int | None=None)

Bytes, imágenes pequeñas o resultados binarios. length=None por defecto; si se indica debe ser entero positivo o lanza ValueError. Se adapta a BLOB/BYTEA/IMAGE según el dialecto; no representa un archivo ni una ruta de Storage.

from orionis.database.schema.blueprint import Blueprint
from orionis.orm import LargeBinary


table = Blueprint()
column = table.largeBinary("digest", 64)
model_column = LargeBinary(64)

La factoría devuelve LargeBinary; el constructor devuelve una nueva instancia del mismo tipo. Ambos heredan ColumnDefinition.

DDL de la declaración de prueba: sqlite: BLOB NOT NULL; mysql: BLOB NOT NULL; pgsql: BYTEA NOT NULL; sqlserver: IMAGE NOT NULL; oracle: BLOB NOT NULL.

uuid: Identificadores UUID

Column.uuid(name: str, *, as_uuid: bool=True, native_uuid: bool=True) -> Uuid
Uuid(*, as_uuid: bool=True, native_uuid: bool=True)

Identificadores proporcionados por la aplicación. as_uuid=True trabaja con uuid.UUID; native_uuid=True solicita UUID/UNIQUEIDENTIFIER cuando existe y usa CHAR(32) en otros motores. No genera uuid4 automáticamente; usa default(uuid4) o asigna el valor.

from orionis.database.schema.blueprint import Blueprint
from orionis.orm import Uuid


table = Blueprint()
column = table.uuid("public_id").unique()
model_column = Uuid().unique()

La factoría devuelve Uuid; el constructor devuelve una nueva instancia del mismo tipo. Ambos heredan ColumnDefinition.

DDL de la declaración de prueba: sqlite: CHAR(32) NOT NULL; mysql: CHAR(32) NOT NULL; pgsql: UUID NOT NULL; sqlserver: UNIQUEIDENTIFIER NOT NULL; oracle: CHAR(32) NOT NULL.

enum: Enumeraciones

Column.enum(name: str, *enums: str, constraint_name: str | None=None, create_constraint: bool=False, native_enum: bool=True, length: int | None=None, validate_strings: bool=False) -> Enum
Enum(*enums: str, name: str | None=None, create_constraint: bool=False, native_enum: bool=True, length: int | None=None, validate_strings: bool=False)

Estados de un conjunto cerrado de strings no vacíos. Sin valores o con valores inválidos lanza ValueError. native_enum=True solicita ENUM nativo; en PostgreSQL asígnale constraint_name (name en el constructor). native_enum=False utiliza VARCHAR; create_constraint=True añade CHECK donde procede. validate_strings valida valores en el procesador del tipo, no crea un esquema HTTP.

from orionis.database.schema.blueprint import Blueprint
from orionis.orm import Enum


table = Blueprint()
column = table.enum("status", "draft", "published", constraint_name="article_status", native_enum=False, create_constraint=True, validate_strings=True)
model_column = Enum("draft", "published", name="article_status", native_enum=False, create_constraint=True, validate_strings=True)

La factoría devuelve Enum; el constructor devuelve una nueva instancia del mismo tipo. Ambos heredan ColumnDefinition.

DDL de la declaración de prueba: sqlite: VARCHAR(9) NOT NULL; mysql: ENUM('draft','published') NOT NULL; pgsql: article_status NOT NULL; sqlserver: VARCHAR(9) NOT NULL; oracle: VARCHAR(9 CHAR) NOT NULL.

Estos fragmentos usan draft/published y nombre article_status con native_enum=True predeterminado. El ejemplo de construcción selecciona deliberadamente emulación y validación.

pickleType: Objetos Python serializados

Column.pickleType(name: str, protocol: int=5, pickler: object | None=None, impl: object | None=None) -> PickleType
PickleType(protocol: int=5, pickler: object | None=None, impl: object | None=None)

Objetos Python internos almacenados en binario con pickle. protocol=5 es el default literal actual. pickler e impl se aceptan y se almacenan, pero SQLCompiler solo reenvía protocol: personalizarlos no cambia el tipo SQL utilizado. No deserialices contenido manipulable por terceros; para intercambio interoperable usa JSON cuando el motor lo admita.

from orionis.database.schema.blueprint import Blueprint
from orionis.orm import PickleType


table = Blueprint()
column = table.pickleType("internal_state", protocol=5)
model_column = PickleType(protocol=5)

La factoría devuelve PickleType; el constructor devuelve una nueva instancia del mismo tipo. Ambos heredan ColumnDefinition.

DDL de la declaración de prueba: sqlite: BLOB NOT NULL; mysql: BLOB NOT NULL; pgsql: BYTEA NOT NULL; sqlserver: IMAGE NOT NULL; oracle: BLOB NOT NULL.

strictInt: INTEGER explícito

Column.strictInt(name: str) -> StrictInt
StrictInt()

Solicita el tipo SQL INTEGER. La factoría se llama strictInt aunque el SQL generado es INTEGER. No añade límites Python ni unsigned.

from orionis.database.schema.blueprint import Blueprint
from orionis.orm import StrictInt


table = Blueprint()
column = table.strictInt("quantity")
model_column = StrictInt()

La factoría devuelve StrictInt; el constructor devuelve una nueva instancia del mismo tipo. Ambos heredan ColumnDefinition.

DDL de la declaración de prueba: sqlite: INTEGER NOT NULL; mysql: INTEGER NOT NULL; pgsql: INTEGER NOT NULL; sqlserver: INTEGER NOT NULL; oracle: INTEGER NOT NULL.

strictBigInt: BIGINT explícito

Column.strictBigInt(name: str) -> StrictBigInt
StrictBigInt()

Solicita BIGINT literal; a diferencia de BigInteger, Oracle no lo adapta a NUMBER(19). La aceptación final depende del servidor.

from orionis.database.schema.blueprint import Blueprint
from orionis.orm import StrictBigInt


table = Blueprint()
column = table.strictBigInt("sequence")
model_column = StrictBigInt()

La factoría devuelve StrictBigInt; el constructor devuelve una nueva instancia del mismo tipo. Ambos heredan ColumnDefinition.

DDL de la declaración de prueba: sqlite: BIGINT NOT NULL; mysql: BIGINT NOT NULL; pgsql: BIGINT NOT NULL; sqlserver: BIGINT NOT NULL; oracle: BIGINT NOT NULL.

strictSmallInt: SMALLINT explícito

Column.strictSmallInt(name: str) -> StrictSmallInt
StrictSmallInt()

Solicita SMALLINT. El motor decide rango y almacenamiento; Orionis no valida el rango antes de persistir.

from orionis.database.schema.blueprint import Blueprint
from orionis.orm import StrictSmallInt


table = Blueprint()
column = table.strictSmallInt("priority")
model_column = StrictSmallInt()

La factoría devuelve StrictSmallInt; el constructor devuelve una nueva instancia del mismo tipo. Ambos heredan ColumnDefinition.

DDL de la declaración de prueba: sqlite: SMALLINT NOT NULL; mysql: SMALLINT NOT NULL; pgsql: SMALLINT NOT NULL; sqlserver: SMALLINT NOT NULL; oracle: SMALLINT NOT NULL.

strictDecimal: DECIMAL explícito

Column.strictDecimal(name: str, precision: int | None=10, scale: int | None=2, decimal_return_scale: int | None=None, *, asdecimal: bool=True) -> StrictDecimal
StrictDecimal(precision: int | None=10, scale: int | None=2, decimal_return_scale: int | None=None, *, asdecimal: bool=True)

Solicita DECIMAL con precision=10 y scale=2 por defecto. Comparte la validación de Numeric: ambos enteros compatibles o ambos None. Úsalo para especificar DECIMAL en lugar de NUMERIC.

from orionis.database.schema.blueprint import Blueprint
from orionis.orm import StrictDecimal


table = Blueprint()
column = table.strictDecimal("price", 12, 2)
model_column = StrictDecimal(12, 2)

La factoría devuelve StrictDecimal; el constructor devuelve una nueva instancia del mismo tipo. Ambos heredan ColumnDefinition.

DDL de la declaración de prueba: sqlite: DECIMAL(12, 2) NOT NULL; mysql: DECIMAL(12, 2) NOT NULL; pgsql: DECIMAL(12, 2) NOT NULL; sqlserver: DECIMAL(12, 2) NOT NULL; oracle: DECIMAL(12, 2) NOT NULL.

strictReal: REAL explícito

Column.strictReal(name: str, precision: int | None=None, *, asdecimal: bool=False, decimal_return_scale: int | None=None) -> StrictReal
StrictReal(precision: int | None=None, *, asdecimal: bool=False, decimal_return_scale: int | None=None)

Solicita REAL para valores aproximados. precision, asdecimal y decimal_return_scale mantienen el contrato de Float; la precisión real depende del servidor.

from orionis.database.schema.blueprint import Blueprint
from orionis.orm import StrictReal


table = Blueprint()
column = table.strictReal("ratio")
model_column = StrictReal()

La factoría devuelve StrictReal; el constructor devuelve una nueva instancia del mismo tipo. Ambos heredan ColumnDefinition.

DDL de la declaración de prueba: sqlite: REAL NOT NULL; mysql: REAL NOT NULL; pgsql: REAL NOT NULL; sqlserver: REAL NOT NULL; oracle: REAL NOT NULL.

strictDoublePrecision: DOUBLE PRECISION explícito

Column.strictDoublePrecision(name: str, precision: int | None=None, *, asdecimal: bool=False, decimal_return_scale: int | None=None) -> StrictDoublePrecision
StrictDoublePrecision(precision: int | None=None, *, asdecimal: bool=False, decimal_return_scale: int | None=None)

Solicita DOUBLE PRECISION literal. Comparte opciones de representación numérica con Double; el compilador no verifica que cada servidor acepte esa sintaxis.

from orionis.database.schema.blueprint import Blueprint
from orionis.orm import StrictDoublePrecision


table = Blueprint()
column = table.strictDoublePrecision("latitude")
model_column = StrictDoublePrecision()

La factoría devuelve StrictDoublePrecision; el constructor devuelve una nueva instancia del mismo tipo. Ambos heredan ColumnDefinition.

DDL de la declaración de prueba: sqlite: DOUBLE PRECISION NOT NULL; mysql: DOUBLE PRECISION NOT NULL; pgsql: DOUBLE PRECISION NOT NULL; sqlserver: DOUBLE PRECISION NOT NULL; oracle: DOUBLE PRECISION NOT NULL.

strictChar: CHAR explícito

Column.strictChar(name: str, length: int | None=None, collation: str | None=None) -> StrictChar
StrictChar(length: int | None=None, collation: str | None=None)

Códigos de longitud fija, por ejemplo códigos de país. length=None no inventa una longitud; proporciona la longitud apropiada para el motor. collation debe ser compatible.

from orionis.database.schema.blueprint import Blueprint
from orionis.orm import StrictChar


table = Blueprint()
column = table.strictChar("country", 2)
model_column = StrictChar(2)

La factoría devuelve StrictChar; el constructor devuelve una nueva instancia del mismo tipo. Ambos heredan ColumnDefinition.

DDL de la declaración de prueba: sqlite: CHAR(2) NOT NULL; mysql: CHAR(2) NOT NULL; pgsql: CHAR(2) NOT NULL; sqlserver: CHAR(2) NOT NULL; oracle: CHAR(2) NOT NULL.

strictVarChar: VARCHAR explícito

Column.strictVarChar(name: str, length: int | None=255, collation: str | None=None) -> StrictVarChar
StrictVarChar(length: int | None=255, collation: str | None=None)

Texto variable con length=255 por defecto. Solicita VARCHAR literal, no todas las adaptaciones de String; Oracle compila VARCHAR en lugar de VARCHAR2. La longitud y collation las interpreta el motor.

from orionis.database.schema.blueprint import Blueprint
from orionis.orm import StrictVarChar


table = Blueprint()
column = table.strictVarChar("reference", 80)
model_column = StrictVarChar(80)

La factoría devuelve StrictVarChar; el constructor devuelve una nueva instancia del mismo tipo. Ambos heredan ColumnDefinition.

DDL de la declaración de prueba: sqlite: VARCHAR(80) NOT NULL; mysql: VARCHAR(80) NOT NULL; pgsql: VARCHAR(80) NOT NULL; sqlserver: VARCHAR(80) NOT NULL; oracle: VARCHAR(80 CHAR) NOT NULL.

strictNChar: NCHAR explícito

Column.strictNChar(name: str, length: int | None=None, collation: str | None=None) -> StrictNChar
StrictNChar(length: int | None=None, collation: str | None=None)

Códigos Unicode de longitud fija cuando el motor ofrece el tipo nacional. No presupongas que NCHAR existe en PostgreSQL porque su DDL se pueda compilar.

from orionis.database.schema.blueprint import Blueprint
from orionis.orm import StrictNChar


table = Blueprint()
column = table.strictNChar("code", 2)
model_column = StrictNChar(2)

La factoría devuelve StrictNChar; el constructor devuelve una nueva instancia del mismo tipo. Ambos heredan ColumnDefinition.

DDL de la declaración de prueba: sqlite: NCHAR(2) NOT NULL; mysql: NATIONAL CHAR(2) NOT NULL; pgsql: NCHAR(2) NOT NULL; sqlserver: NCHAR(2) NOT NULL; oracle: NCHAR(2) NOT NULL.

strictNVarChar: NVARCHAR explícito

Column.strictNVarChar(name: str, length: int | None=None, collation: str | None=None) -> StrictNVarChar
StrictNVarChar(length: int | None=None, collation: str | None=None)

Texto nacional variable. SQL Server usa NVARCHAR y Oracle NVARCHAR2; MySQL genera NATIONAL VARCHAR. En motores sin esos tipos, usa String/Unicode.

from orionis.database.schema.blueprint import Blueprint
from orionis.orm import StrictNVarChar


table = Blueprint()
column = table.strictNVarChar("label", 80)
model_column = StrictNVarChar(80)

La factoría devuelve StrictNVarChar; el constructor devuelve una nueva instancia del mismo tipo. Ambos heredan ColumnDefinition.

DDL de la declaración de prueba: sqlite: NVARCHAR(80) NOT NULL; mysql: NATIONAL VARCHAR(80) NOT NULL; pgsql: NVARCHAR(80) NOT NULL; sqlserver: NVARCHAR(80) NOT NULL; oracle: NVARCHAR2(80) NOT NULL.

strictClob: CLOB explícito

Column.strictClob(name: str, length: int | None=None, collation: str | None=None) -> StrictClob
StrictClob(length: int | None=None, collation: str | None=None)

Solicita CLOB, apropiado para motores que lo implementan. Otros dialectos pueden emitir CLOB sin verificar su existencia; para texto adaptable usa Text.

from orionis.database.schema.blueprint import Blueprint
from orionis.orm import StrictClob


table = Blueprint()
column = table.strictClob("document")
model_column = StrictClob()

La factoría devuelve StrictClob; el constructor devuelve una nueva instancia del mismo tipo. Ambos heredan ColumnDefinition.

DDL de la declaración de prueba: sqlite: CLOB NOT NULL; mysql: CLOB NOT NULL; pgsql: CLOB NOT NULL; sqlserver: CLOB NOT NULL; oracle: CLOB NOT NULL.

strictTimestamp: TIMESTAMP explícito

Column.strictTimestamp(name: str, *, timezone: bool=False) -> StrictTimestamp
StrictTimestamp(*, timezone: bool=False)

Solicita TIMESTAMP con timezone=False por defecto. En SQL Server TIMESTAMP representa rowversion binario y no una fecha/hora: para fechas utiliza DateTime. timezone=True depende del motor.

from orionis.database.schema.blueprint import Blueprint
from orionis.orm import StrictTimestamp


table = Blueprint()
column = table.strictTimestamp("recorded_at", timezone=True)
model_column = StrictTimestamp(timezone=True)

La factoría devuelve StrictTimestamp; el constructor devuelve una nueva instancia del mismo tipo. Ambos heredan ColumnDefinition.

DDL de la declaración de prueba: sqlite: TIMESTAMP NOT NULL; mysql: TIMESTAMP NOT NULL; pgsql: TIMESTAMP WITHOUT TIME ZONE NOT NULL; sqlserver: TIMESTAMP NOT NULL; oracle: TIMESTAMP NOT NULL.

strictBinary: BINARY explícito

Column.strictBinary(name: str, length: int | None=None) -> StrictBinary
StrictBinary(length: int | None=None)

Binarios de longitud fija cuando el motor implementa BINARY. No sustituye automáticamente BINARY por BYTEA en PostgreSQL; LargeBinary permite adaptación.

from orionis.database.schema.blueprint import Blueprint
from orionis.orm import StrictBinary


table = Blueprint()
column = table.strictBinary("token", 16)
model_column = StrictBinary(16)

La factoría devuelve StrictBinary; el constructor devuelve una nueva instancia del mismo tipo. Ambos heredan ColumnDefinition.

DDL de la declaración de prueba: sqlite: BINARY(16) NOT NULL; mysql: BINARY(16) NOT NULL; pgsql: BINARY(16) NOT NULL; sqlserver: BINARY(16) NOT NULL; oracle: BINARY(16) NOT NULL.

strictVarBinary: VARBINARY explícito

Column.strictVarBinary(name: str, length: int | None=None) -> StrictVarBinary
StrictVarBinary(length: int | None=None)

Bytes de longitud variable en motores con VARBINARY. length=None se conserva; no se añade longitud ni límite de archivo automáticamente.

from orionis.database.schema.blueprint import Blueprint
from orionis.orm import StrictVarBinary


table = Blueprint()
column = table.strictVarBinary("payload", 64)
model_column = StrictVarBinary(64)

La factoría devuelve StrictVarBinary; el constructor devuelve una nueva instancia del mismo tipo. Ambos heredan ColumnDefinition.

DDL de la declaración de prueba: sqlite: VARBINARY(64) NOT NULL; mysql: VARBINARY(64) NOT NULL; pgsql: VARBINARY(64) NOT NULL; sqlserver: VARBINARY(64) NOT NULL; oracle: VARBINARY(64) NOT NULL.

strictBlob: BLOB explícito

Column.strictBlob(name: str, length: int | None=None) -> StrictBlob
StrictBlob(length: int | None=None)

Solicita BLOB literal; no usa BYTEA en PostgreSQL ni IMAGE en SQL Server. Prefiere LargeBinary si buscas adaptación entre esos motores.

from orionis.database.schema.blueprint import Blueprint
from orionis.orm import StrictBlob


table = Blueprint()
column = table.strictBlob("payload")
model_column = StrictBlob()

La factoría devuelve StrictBlob; el constructor devuelve una nueva instancia del mismo tipo. Ambos heredan ColumnDefinition.

DDL de la declaración de prueba: sqlite: BLOB NOT NULL; mysql: BLOB NOT NULL; pgsql: BLOB NOT NULL; sqlserver: BLOB NOT NULL; oracle: BLOB NOT NULL.

strictJson: JSON

Column.strictJson(name: str, *, none_as_null: bool=False) -> StrictJson
StrictJson(*, none_as_null: bool=False)

Estructuras JSON. none_as_null=False codifica None como JSON null; True lo trata como SQL NULL en operaciones tipadas. nullable controla por separado si SQL NULL está permitido. SQL Server compila NVARCHAR(max); el soporte JSON del servidor sigue siendo necesario. No es JSONB ni agrega operadores JSON al Query Builder.

from orionis.database.schema.blueprint import Blueprint
from orionis.orm import StrictJson


table = Blueprint()
column = table.strictJson("preferences", none_as_null=True).nullable()
model_column = StrictJson(none_as_null=True).nullable()

La factoría devuelve StrictJson; el constructor devuelve una nueva instancia del mismo tipo. Ambos heredan ColumnDefinition.

DDL de la declaración de prueba: sqlite: JSON NOT NULL; mysql: JSON NOT NULL; pgsql: JSON NOT NULL; sqlserver: NVARCHAR(max) NOT NULL; oracle: JSON NOT NULL.

strictArray: ARRAY: metadatos sin compilación

Column.strictArray(name: str, item_type: ColumnDefinition, *, as_tuple: bool=False, dimensions: int | None=None, zero_indexes: bool=False) -> StrictArray
StrictArray(item_type: ColumnDefinition, *, as_tuple: bool=False, dimensions: int | None=None, zero_indexes: bool=False)

Acepta item_type: ColumnDefinition, as_tuple=False, dimensions=None y zero_indexes=False. Conserva la definición de elementos, dimensiones y conversión de índices, pero no hay builder SQL registrado: materializarla lanza QueryException incluso en PostgreSQL. No se ofrece como almacenamiento ARRAY funcional.

from orionis.database.schema.blueprint import Blueprint
from orionis.orm import StrictArray, Integer


table = Blueprint()
column = table.strictArray("scores", Integer(), dimensions=1)
model_column = StrictArray(Integer(), dimensions=1)

La factoría devuelve StrictArray; el constructor devuelve una nueva instancia del mismo tipo. Ambos heredan ColumnDefinition.

Límite verificado: crear la definición es válido; SQLCompiler.compileCreateTable la rechaza con QueryException: No SQL type registered for column type. No hay un motor habilitado para esta declaración en el compilador actual.

matchType: MatchType: marcador sin compilación

Column.matchType(name: str) -> MatchType
MatchType()

Marcador del resultado de MATCH. Puede construirse sin opciones, pero no tiene builder SQL y no permite crear una columna física. No proporciona búsqueda de texto completo al ORM.

from orionis.database.schema.blueprint import Blueprint
from orionis.orm import MatchType


table = Blueprint()
column = table.matchType("match_result")
model_column = MatchType()

La factoría devuelve MatchType; el constructor devuelve una nueva instancia del mismo tipo. Ambos heredan ColumnDefinition.

Límite verificado: crear la definición es válido; SQLCompiler.compileCreateTable la rechaza con QueryException: No SQL type registered for column type. No hay un motor habilitado para esta declaración en el compilador actual.

numericCommon: NumericCommon: marcador sin compilación

Column.numericCommon(name: str) -> NumericCommon
NumericCommon()

Marcador numérico sin parámetros. No se traduce a SQL: para columnas físicas elige Numeric, Float, Double u otro tipo concreto.

from orionis.database.schema.blueprint import Blueprint
from orionis.orm import NumericCommon


table = Blueprint()
column = table.numericCommon("numeric_marker")
model_column = NumericCommon()

La factoría devuelve NumericCommon; el constructor devuelve una nueva instancia del mismo tipo. Ambos heredan ColumnDefinition.

Límite verificado: crear la definición es válido; SQLCompiler.compileCreateTable la rechaza con QueryException: No SQL type registered for column type. No hay un motor habilitado para esta declaración en el compilador actual.

schemaType: SchemaType: marcador sin compilación

Column.schemaType(name: str, schema_name: str | None=None) -> SchemaType
SchemaType(name: str | None=None)

Conserva un nombre de construcción de esquema (schema_name en Column; name en el constructor). No crea esquemas SQL ni tipos de usuario y materializar una columna produce QueryException.

from orionis.database.schema.blueprint import Blueprint
from orionis.orm import SchemaType


table = Blueprint()
column = table.schemaType("schema_marker", "named_type")
model_column = SchemaType("named_type")

La factoría devuelve SchemaType; el constructor devuelve una nueva instancia del mismo tipo. Ambos heredan ColumnDefinition.

Límite verificado: crear la definición es válido; SQLCompiler.compileCreateTable la rechaza con QueryException: No SQL type registered for column type. No hay un motor habilitado para esta declaración en el compilador actual.

Aplicar una declaración completa

Los ejemplos anteriores separan construcción de ejecución. En una migración, el blueprint recoge las mismas definiciones y Schema las materializa al salir correctamente del contexto.

from orionis.database import Migration
from orionis.support.facades import Schema


class CreateProducts(Migration):
    async def up(self) -> None:
        async with Schema.create("products") as table:
            table.id()
            table.string("name", 120)
            table.numeric("price", 12, 2).default(0)
            table.boolean("active").default(True)
            table.timestamps()

    async def down(self) -> None:
        await Schema.drop("products")