pipework 0.251.0 → 0.252.1

package/src/data/query/pg-core/columns/smallserial.ts

@@ -0,0 +1,60 @@
+import type {
+	ColumnBuilderBaseConfig,
+	ColumnBuilderRuntimeConfig,
+	HasDefault,
+	MakeColumnConfig,
+	NotNull,
+} from '../../column-builder.js';
+import type { ColumnBaseConfig } from '../../column.js';
+import { entityKind } from '../../entity.js';
+import type { AnyPgTable } from '../table.js';
+import { PgColumn, PgColumnBuilder } from './common.js';
+
+export type PgSmallSerialBuilderInitial<TName extends string> = NotNull<
+	HasDefault<
+		PgSmallSerialBuilder<{
+			name: TName;
+			dataType: 'number';
+			columnType: 'PgSmallSerial';
+			data: number;
+			driverParam: number;
+			enumValues: undefined;
+		}>
+	>
+>;
+
+export class PgSmallSerialBuilder<T extends ColumnBuilderBaseConfig<'number', 'PgSmallSerial'>>
+	extends PgColumnBuilder<T>
+{
+	static override readonly [entityKind]: string = 'PgSmallSerialBuilder';
+
+	constructor(name: T['name']) {
+		super(name, 'number', 'PgSmallSerial');
+		this.config.hasDefault = true;
+		this.config.notNull = true;
+	}
+
+	/** @internal */
+	override build<TTableName extends string>(
+		table: AnyPgTable<{ name: TTableName }>,
+	): PgSmallSerial<MakeColumnConfig<T, TTableName>> {
+		return new PgSmallSerial<MakeColumnConfig<T, TTableName>>(
+			table,
+			this.config as ColumnBuilderRuntimeConfig<any, any>,
+		);
+	}
+}
+
+export class PgSmallSerial<T extends ColumnBaseConfig<'number', 'PgSmallSerial'>> extends PgColumn<T> {
+	static override readonly [entityKind]: string = 'PgSmallSerial';
+
+	getSQLType(): string {
+		return 'smallserial';
+	}
+}
+
+export function smallserial(): PgSmallSerialBuilderInitial<''>;
+export function smallserial<TName extends string>(name: TName): PgSmallSerialBuilderInitial<TName>;
+export function smallserial(name?: string) {
+	return new PgSmallSerialBuilder(name ?? '');
+}

package/src/data/query/pg-core/columns/text.ts

@@ -0,0 +1,67 @@
+import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '../../column-builder.js';
+import type { ColumnBaseConfig } from '../../column.js';
+import { entityKind } from '../../entity.js';
+import type { AnyPgTable } from '../table.js';
+import { getColumnNameAndConfig, type Writable } from '../../utils.js';
+import { PgColumn, PgColumnBuilder } from './common.js';
+
+export type PgTextBuilderInitial<TName extends string, TEnum extends [string, ...string[]]> = PgTextBuilder<{
+	name: TName;
+	dataType: 'string';
+	columnType: 'PgText';
+	data: TEnum[number];
+	enumValues: TEnum;
+	driverParam: string;
+}>;
+
+export class PgTextBuilder<
+	T extends ColumnBuilderBaseConfig<'string', 'PgText'>,
+> extends PgColumnBuilder<T, { enumValues: T['enumValues'] }> {
+	static override readonly [entityKind]: string = 'PgTextBuilder';
+
+	constructor(
+		name: T['name'],
+		config: PgTextConfig<T['enumValues']>,
+	) {
+		super(name, 'string', 'PgText');
+		this.config.enumValues = config.enum;
+	}
+
+	/** @internal */
+	override build<TTableName extends string>(
+		table: AnyPgTable<{ name: TTableName }>,
+	): PgText<MakeColumnConfig<T, TTableName>> {
+		return new PgText<MakeColumnConfig<T, TTableName>>(table, this.config as ColumnBuilderRuntimeConfig<any, any>);
+	}
+}
+
+export class PgText<T extends ColumnBaseConfig<'string', 'PgText'>>
+	extends PgColumn<T, { enumValues: T['enumValues'] }>
+{
+	static override readonly [entityKind]: string = 'PgText';
+
+	override readonly enumValues = this.config.enumValues;
+
+	getSQLType(): string {
+		return 'text';
+	}
+}
+
+export interface PgTextConfig<
+	TEnum extends readonly string[] | string[] | undefined = readonly string[] | string[] | undefined,
+> {
+	enum?: TEnum;
+}
+
+export function text(): PgTextBuilderInitial<'', [string, ...string[]]>;
+export function text<U extends string, T extends Readonly<[U, ...U[]]>>(
+	config?: PgTextConfig<T | Writable<T>>,
+): PgTextBuilderInitial<'', Writable<T>>;
+export function text<TName extends string, U extends string, T extends Readonly<[U, ...U[]]>>(
+	name: TName,
+	config?: PgTextConfig<T | Writable<T>>,
+): PgTextBuilderInitial<TName, Writable<T>>;
+export function text(a?: string | PgTextConfig, b: PgTextConfig = {}): any {
+	const { name, config } = getColumnNameAndConfig<PgTextConfig>(a, b);
+	return new PgTextBuilder(name, config as any);
+}

package/src/data/query/pg-core/columns/time.ts

@@ -0,0 +1,72 @@
+import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '../../column-builder.js';
+import type { ColumnBaseConfig } from '../../column.js';
+import { entityKind } from '../../entity.js';
+import type { AnyPgTable } from '../table.js';
+import { getColumnNameAndConfig } from '../../utils.js';
+import { PgColumn } from './common.js';
+import { PgDateColumnBaseBuilder } from './date.common.js';
+import type { Precision } from './timestamp.js';
+
+export type PgTimeBuilderInitial<TName extends string> = PgTimeBuilder<{
+	name: TName;
+	dataType: 'string';
+	columnType: 'PgTime';
+	data: string;
+	driverParam: string;
+	enumValues: undefined;
+}>;
+
+export class PgTimeBuilder<T extends ColumnBuilderBaseConfig<'string', 'PgTime'>> extends PgDateColumnBaseBuilder<
+	T,
+	{ withTimezone: boolean; precision: number | undefined }
+> {
+	static override readonly [entityKind]: string = 'PgTimeBuilder';
+
+	constructor(
+		name: T['name'],
+		readonly withTimezone: boolean,
+		readonly precision: number | undefined,
+	) {
+		super(name, 'string', 'PgTime');
+		this.config.withTimezone = withTimezone;
+		this.config.precision = precision;
+	}
+
+	/** @internal */
+	override build<TTableName extends string>(
+		table: AnyPgTable<{ name: TTableName }>,
+	): PgTime<MakeColumnConfig<T, TTableName>> {
+		return new PgTime<MakeColumnConfig<T, TTableName>>(table, this.config as ColumnBuilderRuntimeConfig<any, any>);
+	}
+}
+
+export class PgTime<T extends ColumnBaseConfig<'string', 'PgTime'>> extends PgColumn<T> {
+	static override readonly [entityKind]: string = 'PgTime';
+
+	readonly withTimezone: boolean;
+	readonly precision: number | undefined;
+
+	constructor(table: AnyPgTable<{ name: T['tableName'] }>, config: PgTimeBuilder<T>['config']) {
+		super(table, config);
+		this.withTimezone = config.withTimezone;
+		this.precision = config.precision;
+	}
+
+	getSQLType(): string {
+		const precision = this.precision === undefined ? '' : `(${this.precision})`;
+		return `time${precision}${this.withTimezone ? ' with time zone' : ''}`;
+	}
+}
+
+export interface TimeConfig {
+	precision?: Precision;
+	withTimezone?: boolean;
+}
+
+export function time(): PgTimeBuilderInitial<''>;
+export function time(config?: TimeConfig): PgTimeBuilderInitial<''>;
+export function time<TName extends string>(name: TName, config?: TimeConfig): PgTimeBuilderInitial<TName>;
+export function time(a?: string | TimeConfig, b: TimeConfig = {}) {
+	const { name, config } = getColumnNameAndConfig<TimeConfig>(a, b);
+	return new PgTimeBuilder(name, config.withTimezone ?? false, config.precision);
+}

package/src/data/query/pg-core/columns/timestamp.ts

@@ -0,0 +1,163 @@
+import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '../../column-builder.js';
+import type { ColumnBaseConfig } from '../../column.js';
+import { entityKind } from '../../entity.js';
+import type { AnyPgTable } from '../table.js';
+import { type Equal, getColumnNameAndConfig } from '../../utils.js';
+import { PgColumn } from './common.js';
+import { PgDateColumnBaseBuilder } from './date.common.js';
+
+export type PgTimestampBuilderInitial<TName extends string> = PgTimestampBuilder<{
+	name: TName;
+	dataType: 'date';
+	columnType: 'PgTimestamp';
+	data: Date;
+	driverParam: string;
+	enumValues: undefined;
+}>;
+
+export class PgTimestampBuilder<T extends ColumnBuilderBaseConfig<'date', 'PgTimestamp'>>
+	extends PgDateColumnBaseBuilder<
+		T,
+		{ withTimezone: boolean; precision: number | undefined }
+	>
+{
+	static override readonly [entityKind]: string = 'PgTimestampBuilder';
+
+	constructor(
+		name: T['name'],
+		withTimezone: boolean,
+		precision: number | undefined,
+	) {
+		super(name, 'date', 'PgTimestamp');
+		this.config.withTimezone = withTimezone;
+		this.config.precision = precision;
+	}
+
+	/** @internal */
+	override build<TTableName extends string>(
+		table: AnyPgTable<{ name: TTableName }>,
+	): PgTimestamp<MakeColumnConfig<T, TTableName>> {
+		return new PgTimestamp<MakeColumnConfig<T, TTableName>>(table, this.config as ColumnBuilderRuntimeConfig<any, any>);
+	}
+}
+
+export class PgTimestamp<T extends ColumnBaseConfig<'date', 'PgTimestamp'>> extends PgColumn<T> {
+	static override readonly [entityKind]: string = 'PgTimestamp';
+
+	readonly withTimezone: boolean;
+	readonly precision: number | undefined;
+
+	constructor(table: AnyPgTable<{ name: T['tableName'] }>, config: PgTimestampBuilder<T>['config']) {
+		super(table, config);
+		this.withTimezone = config.withTimezone;
+		this.precision = config.precision;
+	}
+
+	getSQLType(): string {
+		const precision = this.precision === undefined ? '' : ` (${this.precision})`;
+		return `timestamp${precision}${this.withTimezone ? ' with time zone' : ''}`;
+	}
+
+	override mapFromDriverValue(value: Date | string): Date {
+		if (typeof value === 'string') return new Date(this.withTimezone ? value : value + '+0000');
+
+		return value;
+	}
+
+	override mapToDriverValue = (value: Date): string => {
+		return value.toISOString();
+	};
+}
+
+export type PgTimestampStringBuilderInitial<TName extends string> = PgTimestampStringBuilder<{
+	name: TName;
+	dataType: 'string';
+	columnType: 'PgTimestampString';
+	data: string;
+	driverParam: string;
+	enumValues: undefined;
+}>;
+
+export class PgTimestampStringBuilder<T extends ColumnBuilderBaseConfig<'string', 'PgTimestampString'>>
+	extends PgDateColumnBaseBuilder<
+		T,
+		{ withTimezone: boolean; precision: number | undefined }
+	>
+{
+	static override readonly [entityKind]: string = 'PgTimestampStringBuilder';
+
+	constructor(
+		name: T['name'],
+		withTimezone: boolean,
+		precision: number | undefined,
+	) {
+		super(name, 'string', 'PgTimestampString');
+		this.config.withTimezone = withTimezone;
+		this.config.precision = precision;
+	}
+
+	/** @internal */
+	override build<TTableName extends string>(
+		table: AnyPgTable<{ name: TTableName }>,
+	): PgTimestampString<MakeColumnConfig<T, TTableName>> {
+		return new PgTimestampString<MakeColumnConfig<T, TTableName>>(
+			table,
+			this.config as ColumnBuilderRuntimeConfig<any, any>,
+		);
+	}
+}
+
+export class PgTimestampString<T extends ColumnBaseConfig<'string', 'PgTimestampString'>> extends PgColumn<T> {
+	static override readonly [entityKind]: string = 'PgTimestampString';
+
+	readonly withTimezone: boolean;
+	readonly precision: number | undefined;
+
+	constructor(table: AnyPgTable<{ name: T['tableName'] }>, config: PgTimestampStringBuilder<T>['config']) {
+		super(table, config);
+		this.withTimezone = config.withTimezone;
+		this.precision = config.precision;
+	}
+
+	getSQLType(): string {
+		const precision = this.precision === undefined ? '' : `(${this.precision})`;
+		return `timestamp${precision}${this.withTimezone ? ' with time zone' : ''}`;
+	}
+
+	override mapFromDriverValue(value: Date | string): string {
+		if (typeof value === 'string') return value;
+
+		const shortened = value.toISOString().slice(0, -1).replace('T', ' ');
+		if (this.withTimezone) {
+			const offset = value.getTimezoneOffset();
+			const sign = offset <= 0 ? '+' : '-';
+			return `${shortened}${sign}${Math.floor(Math.abs(offset) / 60).toString().padStart(2, '0')}`;
+		}
+
+		return shortened;
+	}
+}
+
+export type Precision = 0 | 1 | 2 | 3 | 4 | 5 | 6;
+
+export interface PgTimestampConfig<TMode extends 'date' | 'string' = 'date' | 'string'> {
+	mode?: TMode;
+	precision?: Precision;
+	withTimezone?: boolean;
+}
+
+export function timestamp(): PgTimestampBuilderInitial<''>;
+export function timestamp<TMode extends PgTimestampConfig['mode'] & {}>(
+	config?: PgTimestampConfig<TMode>,
+): Equal<TMode, 'string'> extends true ? PgTimestampStringBuilderInitial<''> : PgTimestampBuilderInitial<''>;
+export function timestamp<TName extends string, TMode extends PgTimestampConfig['mode'] & {}>(
+	name: TName,
+	config?: PgTimestampConfig<TMode>,
+): Equal<TMode, 'string'> extends true ? PgTimestampStringBuilderInitial<TName> : PgTimestampBuilderInitial<TName>;
+export function timestamp(a?: string | PgTimestampConfig, b: PgTimestampConfig = {}) {
+	const { name, config } = getColumnNameAndConfig<PgTimestampConfig | undefined>(a, b);
+	if (config?.mode === 'string') {
+		return new PgTimestampStringBuilder(name, config.withTimezone ?? false, config.precision);
+	}
+	return new PgTimestampBuilder(name, config?.withTimezone ?? false, config?.precision);
+}

package/src/data/query/pg-core/columns/uuid.ts

@@ -0,0 +1,51 @@
+import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '../../column-builder.js';
+import type { ColumnBaseConfig } from '../../column.js';
+import { entityKind } from '../../entity.js';
+import type { AnyPgTable } from '../table.js';
+import { sql } from '../../sql/sql.js';
+import { PgColumn, PgColumnBuilder } from './common.js';
+
+export type PgUUIDBuilderInitial<TName extends string> = PgUUIDBuilder<{
+	name: TName;
+	dataType: 'string';
+	columnType: 'PgUUID';
+	data: string;
+	driverParam: string;
+	enumValues: undefined;
+}>;
+
+export class PgUUIDBuilder<T extends ColumnBuilderBaseConfig<'string', 'PgUUID'>> extends PgColumnBuilder<T> {
+	static override readonly [entityKind]: string = 'PgUUIDBuilder';
+
+	constructor(name: T['name']) {
+		super(name, 'string', 'PgUUID');
+	}
+
+	/**
+	 * Adds `default gen_random_uuid()` to the column definition.
+	 */
+	defaultRandom(): ReturnType<this['default']> {
+		return this.default(sql`gen_random_uuid()`) as ReturnType<this['default']>;
+	}
+
+	/** @internal */
+	override build<TTableName extends string>(
+		table: AnyPgTable<{ name: TTableName }>,
+	): PgUUID<MakeColumnConfig<T, TTableName>> {
+		return new PgUUID<MakeColumnConfig<T, TTableName>>(table, this.config as ColumnBuilderRuntimeConfig<any, any>);
+	}
+}
+
+export class PgUUID<T extends ColumnBaseConfig<'string', 'PgUUID'>> extends PgColumn<T> {
+	static override readonly [entityKind]: string = 'PgUUID';
+
+	getSQLType(): string {
+		return 'uuid';
+	}
+}
+
+export function uuid(): PgUUIDBuilderInitial<''>;
+export function uuid<TName extends string>(name: TName): PgUUIDBuilderInitial<TName>;
+export function uuid(name?: string) {
+	return new PgUUIDBuilder(name ?? '');
+}

package/src/data/query/pg-core/columns/varchar.ts

@@ -0,0 +1,89 @@
+import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '../../column-builder.js';
+import type { ColumnBaseConfig } from '../../column.js';
+import { entityKind } from '../../entity.js';
+import type { AnyPgTable } from '../table.js';
+import { getColumnNameAndConfig, type Writable } from '../../utils.js';
+import { PgColumn, PgColumnBuilder } from './common.js';
+
+export type PgVarcharBuilderInitial<
+	TName extends string,
+	TEnum extends [string, ...string[]],
+	TLength extends number | undefined,
+> = PgVarcharBuilder<{
+	name: TName;
+	dataType: 'string';
+	columnType: 'PgVarchar';
+	data: TEnum[number];
+	driverParam: string;
+	enumValues: TEnum;
+	length: TLength;
+}>;
+
+export class PgVarcharBuilder<
+	T extends ColumnBuilderBaseConfig<'string', 'PgVarchar'> & { length?: number | undefined },
+> extends PgColumnBuilder<
+	T,
+	{ length: T['length']; enumValues: T['enumValues'] },
+	{ length: T['length'] }
+> {
+	static override readonly [entityKind]: string = 'PgVarcharBuilder';
+
+	constructor(name: T['name'], config: PgVarcharConfig<T['enumValues'], T['length']>) {
+		super(name, 'string', 'PgVarchar');
+		this.config.length = config.length;
+		this.config.enumValues = config.enum;
+	}
+
+	/** @internal */
+	override build<TTableName extends string>(
+		table: AnyPgTable<{ name: TTableName }>,
+	): PgVarchar<MakeColumnConfig<T, TTableName> & { length: T['length'] }> {
+		return new PgVarchar<MakeColumnConfig<T, TTableName> & { length: T['length'] }>(
+			table,
+			this.config as ColumnBuilderRuntimeConfig<any, any>,
+		);
+	}
+}
+
+export class PgVarchar<T extends ColumnBaseConfig<'string', 'PgVarchar'> & { length?: number | undefined }>
+	extends PgColumn<T, { length: T['length']; enumValues: T['enumValues'] }, { length: T['length'] }>
+{
+	static override readonly [entityKind]: string = 'PgVarchar';
+
+	readonly length = this.config.length;
+	override readonly enumValues = this.config.enumValues;
+
+	getSQLType(): string {
+		return this.length === undefined ? `varchar` : `varchar(${this.length})`;
+	}
+}
+
+export interface PgVarcharConfig<
+	TEnum extends readonly string[] | string[] | undefined = readonly string[] | string[] | undefined,
+	TLength extends number | undefined = number | undefined,
+> {
+	enum?: TEnum;
+	length?: TLength;
+}
+
+export function varchar(): PgVarcharBuilderInitial<'', [string, ...string[]], undefined>;
+export function varchar<
+	U extends string,
+	T extends Readonly<[U, ...U[]]>,
+	L extends number | undefined,
+>(
+	config?: PgVarcharConfig<T | Writable<T>, L>,
+): PgVarcharBuilderInitial<'', Writable<T>, L>;
+export function varchar<
+	TName extends string,
+	U extends string,
+	T extends Readonly<[U, ...U[]]>,
+	L extends number | undefined,
+>(
+	name: TName,
+	config?: PgVarcharConfig<T | Writable<T>, L>,
+): PgVarcharBuilderInitial<TName, Writable<T>, L>;
+export function varchar(a?: string | PgVarcharConfig, b: PgVarcharConfig = {}): any {
+	const { name, config } = getColumnNameAndConfig<PgVarcharConfig>(a, b);
+	return new PgVarcharBuilder(name, config as any);
+}

package/src/data/query/pg-core/columns/vector_extension/bit.ts

@@ -0,0 +1,68 @@
+import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '../../../column-builder.js';
+import type { ColumnBaseConfig } from '../../../column.js';
+import { entityKind } from '../../../entity.js';
+import type { AnyPgTable } from '../../table.js';
+import { getColumnNameAndConfig } from '../../../utils.js';
+import { PgColumn, PgColumnBuilder } from '../common.js';
+
+export type PgBinaryVectorBuilderInitial<TName extends string, TDimensions extends number> = PgBinaryVectorBuilder<{
+	name: TName;
+	dataType: 'string';
+	columnType: 'PgBinaryVector';
+	data: string;
+	driverParam: string;
+	enumValues: undefined;
+	dimensions: TDimensions;
+}>;
+
+export class PgBinaryVectorBuilder<
+	T extends ColumnBuilderBaseConfig<'string', 'PgBinaryVector'> & { dimensions: number },
+> extends PgColumnBuilder<
+	T,
+	{ dimensions: T['dimensions'] }
+> {
+	static override readonly [entityKind]: string = 'PgBinaryVectorBuilder';
+
+	constructor(name: string, config: PgBinaryVectorConfig<T['dimensions']>) {
+		super(name, 'string', 'PgBinaryVector');
+		this.config.dimensions = config.dimensions;
+	}
+
+	/** @internal */
+	override build<TTableName extends string>(
+		table: AnyPgTable<{ name: TTableName }>,
+	): PgBinaryVector<MakeColumnConfig<T, TTableName> & { dimensions: T['dimensions'] }> {
+		return new PgBinaryVector<MakeColumnConfig<T, TTableName> & { dimensions: T['dimensions'] }>(
+			table,
+			this.config as ColumnBuilderRuntimeConfig<any, any>,
+		);
+	}
+}
+
+export class PgBinaryVector<T extends ColumnBaseConfig<'string', 'PgBinaryVector'> & { dimensions: number }>
+	extends PgColumn<T, { dimensions: T['dimensions'] }, { dimensions: T['dimensions'] }>
+{
+	static override readonly [entityKind]: string = 'PgBinaryVector';
+
+	readonly dimensions = this.config.dimensions;
+
+	getSQLType(): string {
+		return `bit(${this.dimensions})`;
+	}
+}
+
+export interface PgBinaryVectorConfig<TDimensions extends number = number> {
+	dimensions: TDimensions;
+}
+
+export function bit<D extends number>(
+	config: PgBinaryVectorConfig<D>,
+): PgBinaryVectorBuilderInitial<'', D>;
+export function bit<TName extends string, D extends number>(
+	name: TName,
+	config: PgBinaryVectorConfig<D>,
+): PgBinaryVectorBuilderInitial<TName, D>;
+export function bit(a: string | PgBinaryVectorConfig, b?: PgBinaryVectorConfig) {
+	const { name, config } = getColumnNameAndConfig<PgBinaryVectorConfig>(a, b);
+	return new PgBinaryVectorBuilder(name, config);
+}

package/src/data/query/pg-core/columns/vector_extension/halfvec.ts

@@ -0,0 +1,80 @@
+import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '../../../column-builder.js';
+import type { ColumnBaseConfig } from '../../../column.js';
+import { entityKind } from '../../../entity.js';
+import type { AnyPgTable } from '../../table.js';
+import { getColumnNameAndConfig } from '../../../utils.js';
+import { PgColumn, PgColumnBuilder } from '../common.js';
+
+export type PgHalfVectorBuilderInitial<TName extends string, TDimensions extends number> = PgHalfVectorBuilder<{
+	name: TName;
+	dataType: 'array';
+	columnType: 'PgHalfVector';
+	data: number[];
+	driverParam: string;
+	enumValues: undefined;
+	dimensions: TDimensions;
+}>;
+
+export class PgHalfVectorBuilder<T extends ColumnBuilderBaseConfig<'array', 'PgHalfVector'> & { dimensions: number }>
+	extends PgColumnBuilder<
+		T,
+		{ dimensions: T['dimensions'] },
+		{ dimensions: T['dimensions'] }
+	>
+{
+	static override readonly [entityKind]: string = 'PgHalfVectorBuilder';
+
+	constructor(name: string, config: PgHalfVectorConfig<T['dimensions']>) {
+		super(name, 'array', 'PgHalfVector');
+		this.config.dimensions = config.dimensions;
+	}
+
+	/** @internal */
+	override build<TTableName extends string>(
+		table: AnyPgTable<{ name: TTableName }>,
+	): PgHalfVector<MakeColumnConfig<T, TTableName> & { dimensions: T['dimensions'] }> {
+		return new PgHalfVector<MakeColumnConfig<T, TTableName> & { dimensions: T['dimensions'] }>(
+			table,
+			this.config as ColumnBuilderRuntimeConfig<any, any>,
+		);
+	}
+}
+
+export class PgHalfVector<T extends ColumnBaseConfig<'array', 'PgHalfVector'> & { dimensions: number }>
+	extends PgColumn<T, { dimensions: T['dimensions'] }, { dimensions: T['dimensions'] }>
+{
+	static override readonly [entityKind]: string = 'PgHalfVector';
+
+	readonly dimensions: T['dimensions'] = this.config.dimensions;
+
+	getSQLType(): string {
+		return `halfvec(${this.dimensions})`;
+	}
+
+	override mapToDriverValue(value: unknown): unknown {
+		return JSON.stringify(value);
+	}
+
+	override mapFromDriverValue(value: string): unknown {
+		return value
+			.slice(1, -1)
+			.split(',')
+			.map((v) => Number.parseFloat(v));
+	}
+}
+
+export interface PgHalfVectorConfig<TDimensions extends number = number> {
+	dimensions: TDimensions;
+}
+
+export function halfvec<D extends number>(
+	config: PgHalfVectorConfig<D>,
+): PgHalfVectorBuilderInitial<'', D>;
+export function halfvec<TName extends string, D extends number>(
+	name: TName,
+	config: PgHalfVectorConfig,
+): PgHalfVectorBuilderInitial<TName, D>;
+export function halfvec(a: string | PgHalfVectorConfig, b?: PgHalfVectorConfig) {
+	const { name, config } = getColumnNameAndConfig<PgHalfVectorConfig>(a, b);
+	return new PgHalfVectorBuilder(name, config);
+}