diff --git a/drizzle-orm/src/column-builder.ts b/drizzle-orm/src/column-builder.ts
index afe14953b..ad278e29d 100644
--- a/drizzle-orm/src/column-builder.ts
+++ b/drizzle-orm/src/column-builder.ts
@@ -2,10 +2,10 @@ import { entityKind } from '~/entity.ts';
 import type { Column } from './column.ts';
 import type { MySqlColumn } from './mysql-core/index.ts';
 import type { ExtraConfigColumn, PgColumn, PgSequenceOptions } from './pg-core/index.ts';
+import type { SingleStoreColumn } from './singlestore-core/index.ts';
 import type { SQL } from './sql/sql.ts';
 import type { SQLiteColumn } from './sqlite-core/index.ts';
 import type { Simplify } from './utils.ts';
-import { SingleStoreColumn } from './singlestore-core/index.ts';
 
 export type ColumnDataType =
 	| 'string'
@@ -18,7 +18,7 @@ export type ColumnDataType =
 	| 'custom'
 	| 'buffer';
 
-export type Dialect = 'singlestore' | 'pg' | 'mysql' | 'sqlite' | 'common';
+export type Dialect = 'pg' | 'mysql' | 'sqlite' | 'singlestore' | 'common';
 
 export type GeneratedStorageMode = 'virtual' | 'stored';
 
@@ -300,7 +300,7 @@ export type BuildColumn<
 	TTableName extends string,
 	TBuilder extends ColumnBuilderBase,
 	TDialect extends Dialect,
-> = TDialect extends 'singlestore' ? SingleStoreColumn<MakeColumnConfig<TBuilder['_'], TTableName>> 
+> = TDialect extends 'singlestore' ? SingleStoreColumn<MakeColumnConfig<TBuilder['_'], TTableName>>
 	: TDialect extends 'pg' ? PgColumn<MakeColumnConfig<TBuilder['_'], TTableName>>
 	: TDialect extends 'mysql' ? MySqlColumn<MakeColumnConfig<TBuilder['_'], TTableName>>
 	: TDialect extends 'sqlite' ? SQLiteColumn<MakeColumnConfig<TBuilder['_'], TTableName>>
diff --git a/drizzle-orm/src/singlestore-core/alias.ts b/drizzle-orm/src/singlestore-core/alias.ts
index 8320c5533..08e7ecc67 100644
--- a/drizzle-orm/src/singlestore-core/alias.ts
+++ b/drizzle-orm/src/singlestore-core/alias.ts
@@ -1,9 +1,9 @@
 import { TableAliasProxyHandler } from '~/alias.ts';
 import type { BuildAliasTable } from './query-builders/select.types.ts';
-import type { MySqlTable } from './table.ts';
-import type { MySqlViewBase } from './view-base.ts';
+import type { SingleStoreTable } from './table.ts';
+import type { SingleStoreViewBase } from './view-base.ts';
 
-export function alias<TTable extends MySqlTable | MySqlViewBase, TAlias extends string>(
+export function alias<TTable extends SingleStoreTable | SingleStoreViewBase, TAlias extends string>(
 	table: TTable,
 	alias: TAlias,
 ): BuildAliasTable<TTable, TAlias> {
diff --git a/drizzle-orm/src/singlestore-core/checks.ts b/drizzle-orm/src/singlestore-core/checks.ts
index af9a29f6a..29fdb7680 100644
--- a/drizzle-orm/src/singlestore-core/checks.ts
+++ b/drizzle-orm/src/singlestore-core/checks.ts
@@ -1,27 +1,27 @@
 import { entityKind } from '~/entity.ts';
 import type { SQL } from '~/sql/sql.ts';
-import type { MySqlTable } from './table.ts';
+import type { SingleStoreTable } from './table.ts';
 
 export class CheckBuilder {
-	static readonly [entityKind]: string = 'MySqlCheckBuilder';
+	static readonly [entityKind]: string = 'SingleStoreCheckBuilder';
 
-	protected brand!: 'MySqlConstraintBuilder';
+	protected brand!: 'SingleStoreConstraintBuilder';
 
 	constructor(public name: string, public value: SQL) {}
 
 	/** @internal */
-	build(table: MySqlTable): Check {
+	build(table: SingleStoreTable): Check {
 		return new Check(table, this);
 	}
 }
 
 export class Check {
-	static readonly [entityKind]: string = 'MySqlCheck';
+	static readonly [entityKind]: string = 'SingleStoreCheck';
 
 	readonly name: string;
 	readonly value: SQL;
 
-	constructor(public table: MySqlTable, builder: CheckBuilder) {
+	constructor(public table: SingleStoreTable, builder: CheckBuilder) {
 		this.name = builder.name;
 		this.value = builder.value;
 	}
diff --git a/drizzle-orm/src/singlestore-core/columns/bigint.ts b/drizzle-orm/src/singlestore-core/columns/bigint.ts
index ca1eedb3f..6ea4a7297 100644
--- a/drizzle-orm/src/singlestore-core/columns/bigint.ts
+++ b/drizzle-orm/src/singlestore-core/columns/bigint.ts
@@ -1,44 +1,44 @@
 import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '~/column-builder.ts';
 import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
-import type { AnyMySqlTable } from '~/mysql-core/table.ts';
-import { MySqlColumnBuilderWithAutoIncrement, MySqlColumnWithAutoIncrement } from './common.ts';
+import type { AnySingleStoreTable } from '~/singlestore-core/table.ts';
+import { SingleStoreColumnBuilderWithAutoIncrement, SingleStoreColumnWithAutoIncrement } from './common.ts';
 
-export type MySqlBigInt53BuilderInitial<TName extends string> = MySqlBigInt53Builder<{
+export type SingleStoreBigInt53BuilderInitial<TName extends string> = SingleStoreBigInt53Builder<{
 	name: TName;
 	dataType: 'number';
-	columnType: 'MySqlBigInt53';
+	columnType: 'SingleStoreBigInt53';
 	data: number;
 	driverParam: number | string;
 	enumValues: undefined;
 	generated: undefined;
 }>;
 
-export class MySqlBigInt53Builder<T extends ColumnBuilderBaseConfig<'number', 'MySqlBigInt53'>>
-	extends MySqlColumnBuilderWithAutoIncrement<T, { unsigned: boolean }>
+export class SingleStoreBigInt53Builder<T extends ColumnBuilderBaseConfig<'number', 'SingleStoreBigInt53'>>
+	extends SingleStoreColumnBuilderWithAutoIncrement<T, { unsigned: boolean }>
 {
-	static readonly [entityKind]: string = 'MySqlBigInt53Builder';
+	static readonly [entityKind]: string = 'SingleStoreBigInt53Builder';
 
 	constructor(name: T['name'], unsigned: boolean = false) {
-		super(name, 'number', 'MySqlBigInt53');
+		super(name, 'number', 'SingleStoreBigInt53');
 		this.config.unsigned = unsigned;
 	}
 
 	/** @internal */
 	override build<TTableName extends string>(
-		table: AnyMySqlTable<{ name: TTableName }>,
-	): MySqlBigInt53<MakeColumnConfig<T, TTableName>> {
-		return new MySqlBigInt53<MakeColumnConfig<T, TTableName>>(
+		table: AnySingleStoreTable<{ name: TTableName }>,
+	): SingleStoreBigInt53<MakeColumnConfig<T, TTableName>> {
+		return new SingleStoreBigInt53<MakeColumnConfig<T, TTableName>>(
 			table,
 			this.config as ColumnBuilderRuntimeConfig<any, any>,
 		);
 	}
 }
 
-export class MySqlBigInt53<T extends ColumnBaseConfig<'number', 'MySqlBigInt53'>>
-	extends MySqlColumnWithAutoIncrement<T, { unsigned: boolean }>
+export class SingleStoreBigInt53<T extends ColumnBaseConfig<'number', 'SingleStoreBigInt53'>>
+	extends SingleStoreColumnWithAutoIncrement<T, { unsigned: boolean }>
 {
-	static readonly [entityKind]: string = 'MySqlBigInt53';
+	static readonly [entityKind]: string = 'SingleStoreBigInt53';
 
 	getSQLType(): string {
 		return `bigint${this.config.unsigned ? ' unsigned' : ''}`;
@@ -52,41 +52,41 @@ export class MySqlBigInt53<T extends ColumnBaseConfig<'number', 'MySqlBigInt53'>
 	}
 }
 
-export type MySqlBigInt64BuilderInitial<TName extends string> = MySqlBigInt64Builder<{
+export type SingleStoreBigInt64BuilderInitial<TName extends string> = SingleStoreBigInt64Builder<{
 	name: TName;
 	dataType: 'bigint';
-	columnType: 'MySqlBigInt64';
+	columnType: 'SingleStoreBigInt64';
 	data: bigint;
 	driverParam: string;
 	enumValues: undefined;
 	generated: undefined;
 }>;
 
-export class MySqlBigInt64Builder<T extends ColumnBuilderBaseConfig<'bigint', 'MySqlBigInt64'>>
-	extends MySqlColumnBuilderWithAutoIncrement<T, { unsigned: boolean }>
+export class SingleStoreBigInt64Builder<T extends ColumnBuilderBaseConfig<'bigint', 'SingleStoreBigInt64'>>
+	extends SingleStoreColumnBuilderWithAutoIncrement<T, { unsigned: boolean }>
 {
-	static readonly [entityKind]: string = 'MySqlBigInt64Builder';
+	static readonly [entityKind]: string = 'SingleStoreBigInt64Builder';
 
 	constructor(name: T['name'], unsigned: boolean = false) {
-		super(name, 'bigint', 'MySqlBigInt64');
+		super(name, 'bigint', 'SingleStoreBigInt64');
 		this.config.unsigned = unsigned;
 	}
 
 	/** @internal */
 	override build<TTableName extends string>(
-		table: AnyMySqlTable<{ name: TTableName }>,
-	): MySqlBigInt64<MakeColumnConfig<T, TTableName>> {
-		return new MySqlBigInt64<MakeColumnConfig<T, TTableName>>(
+		table: AnySingleStoreTable<{ name: TTableName }>,
+	): SingleStoreBigInt64<MakeColumnConfig<T, TTableName>> {
+		return new SingleStoreBigInt64<MakeColumnConfig<T, TTableName>>(
 			table,
 			this.config as ColumnBuilderRuntimeConfig<any, any>,
 		);
 	}
 }
 
-export class MySqlBigInt64<T extends ColumnBaseConfig<'bigint', 'MySqlBigInt64'>>
-	extends MySqlColumnWithAutoIncrement<T, { unsigned: boolean }>
+export class SingleStoreBigInt64<T extends ColumnBaseConfig<'bigint', 'SingleStoreBigInt64'>>
+	extends SingleStoreColumnWithAutoIncrement<T, { unsigned: boolean }>
 {
-	static readonly [entityKind]: string = 'MySqlBigInt64';
+	static readonly [entityKind]: string = 'SingleStoreBigInt64';
 
 	getSQLType(): string {
 		return `bigint${this.config.unsigned ? ' unsigned' : ''}`;
@@ -98,18 +98,18 @@ export class MySqlBigInt64<T extends ColumnBaseConfig<'bigint', 'MySqlBigInt64'>
 	}
 }
 
-interface MySqlBigIntConfig<T extends 'number' | 'bigint' = 'number' | 'bigint'> {
+interface SingleStoreBigIntConfig<T extends 'number' | 'bigint' = 'number' | 'bigint'> {
 	mode: T;
 	unsigned?: boolean;
 }
 
-export function bigint<TName extends string, TMode extends MySqlBigIntConfig['mode']>(
+export function bigint<TName extends string, TMode extends SingleStoreBigIntConfig['mode']>(
 	name: TName,
-	config: MySqlBigIntConfig<TMode>,
-): TMode extends 'number' ? MySqlBigInt53BuilderInitial<TName> : MySqlBigInt64BuilderInitial<TName>;
-export function bigint(name: string, config: MySqlBigIntConfig) {
+	config: SingleStoreBigIntConfig<TMode>,
+): TMode extends 'number' ? SingleStoreBigInt53BuilderInitial<TName> : SingleStoreBigInt64BuilderInitial<TName>;
+export function bigint(name: string, config: SingleStoreBigIntConfig) {
 	if (config.mode === 'number') {
-		return new MySqlBigInt53Builder(name, config.unsigned);
+		return new SingleStoreBigInt53Builder(name, config.unsigned);
 	}
-	return new MySqlBigInt64Builder(name, config.unsigned);
+	return new SingleStoreBigInt64Builder(name, config.unsigned);
 }
diff --git a/drizzle-orm/src/singlestore-core/columns/binary.ts b/drizzle-orm/src/singlestore-core/columns/binary.ts
index 87a8e0f8c..9cb05ac53 100644
--- a/drizzle-orm/src/singlestore-core/columns/binary.ts
+++ b/drizzle-orm/src/singlestore-core/columns/binary.ts
@@ -1,43 +1,48 @@
 import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '~/column-builder.ts';
 import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
-import type { AnyMySqlTable } from '~/mysql-core/table.ts';
-import { MySqlColumn, MySqlColumnBuilder } from './common.ts';
+import type { AnySingleStoreTable } from '~/singlestore-core/table.ts';
+import { SingleStoreColumn, SingleStoreColumnBuilder } from './common.ts';
 
-export type MySqlBinaryBuilderInitial<TName extends string> = MySqlBinaryBuilder<{
+export type SingleStoreBinaryBuilderInitial<TName extends string> = SingleStoreBinaryBuilder<{
 	name: TName;
 	dataType: 'string';
-	columnType: 'MySqlBinary';
+	columnType: 'SingleStoreBinary';
 	data: string;
 	driverParam: string;
 	enumValues: undefined;
 	generated: undefined;
 }>;
 
-export class MySqlBinaryBuilder<T extends ColumnBuilderBaseConfig<'string', 'MySqlBinary'>> extends MySqlColumnBuilder<
-	T,
-	MySqlBinaryConfig
-> {
-	static readonly [entityKind]: string = 'MySqlBinaryBuilder';
+export class SingleStoreBinaryBuilder<T extends ColumnBuilderBaseConfig<'string', 'SingleStoreBinary'>>
+	extends SingleStoreColumnBuilder<
+		T,
+		SingleStoreBinaryConfig
+	>
+{
+	static readonly [entityKind]: string = 'SingleStoreBinaryBuilder';
 
 	constructor(name: T['name'], length: number | undefined) {
-		super(name, 'string', 'MySqlBinary');
+		super(name, 'string', 'SingleStoreBinary');
 		this.config.length = length;
 	}
 
 	/** @internal */
 	override build<TTableName extends string>(
-		table: AnyMySqlTable<{ name: TTableName }>,
-	): MySqlBinary<MakeColumnConfig<T, TTableName>> {
-		return new MySqlBinary<MakeColumnConfig<T, TTableName>>(table, this.config as ColumnBuilderRuntimeConfig<any, any>);
+		table: AnySingleStoreTable<{ name: TTableName }>,
+	): SingleStoreBinary<MakeColumnConfig<T, TTableName>> {
+		return new SingleStoreBinary<MakeColumnConfig<T, TTableName>>(
+			table,
+			this.config as ColumnBuilderRuntimeConfig<any, any>,
+		);
 	}
 }
 
-export class MySqlBinary<T extends ColumnBaseConfig<'string', 'MySqlBinary'>> extends MySqlColumn<
+export class SingleStoreBinary<T extends ColumnBaseConfig<'string', 'SingleStoreBinary'>> extends SingleStoreColumn<
 	T,
-	MySqlBinaryConfig
+	SingleStoreBinaryConfig
 > {
-	static readonly [entityKind]: string = 'MySqlBinary';
+	static readonly [entityKind]: string = 'SingleStoreBinary';
 
 	length: number | undefined = this.config.length;
 
@@ -46,13 +51,13 @@ export class MySqlBinary<T extends ColumnBaseConfig<'string', 'MySqlBinary'>> ex
 	}
 }
 
-export interface MySqlBinaryConfig {
+export interface SingleStoreBinaryConfig {
 	length?: number;
 }
 
 export function binary<TName extends string>(
 	name: TName,
-	config: MySqlBinaryConfig = {},
-): MySqlBinaryBuilderInitial<TName> {
-	return new MySqlBinaryBuilder(name, config.length);
+	config: SingleStoreBinaryConfig = {},
+): SingleStoreBinaryBuilderInitial<TName> {
+	return new SingleStoreBinaryBuilder(name, config.length);
 }
diff --git a/drizzle-orm/src/singlestore-core/columns/boolean.ts b/drizzle-orm/src/singlestore-core/columns/boolean.ts
index 3a915e673..795b12e7f 100644
--- a/drizzle-orm/src/singlestore-core/columns/boolean.ts
+++ b/drizzle-orm/src/singlestore-core/columns/boolean.ts
@@ -1,41 +1,43 @@
 import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '~/column-builder.ts';
 import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
-import type { AnyMySqlTable } from '~/mysql-core/table.ts';
-import { MySqlColumn, MySqlColumnBuilder } from './common.ts';
+import type { AnySingleStoreTable } from '~/singlestore-core/table.ts';
+import { SingleStoreColumn, SingleStoreColumnBuilder } from './common.ts';
 
-export type MySqlBooleanBuilderInitial<TName extends string> = MySqlBooleanBuilder<{
+export type SingleStoreBooleanBuilderInitial<TName extends string> = SingleStoreBooleanBuilder<{
 	name: TName;
 	dataType: 'boolean';
-	columnType: 'MySqlBoolean';
+	columnType: 'SingleStoreBoolean';
 	data: boolean;
 	driverParam: number | boolean;
 	enumValues: undefined;
 	generated: undefined;
 }>;
 
-export class MySqlBooleanBuilder<T extends ColumnBuilderBaseConfig<'boolean', 'MySqlBoolean'>>
-	extends MySqlColumnBuilder<T>
+export class SingleStoreBooleanBuilder<T extends ColumnBuilderBaseConfig<'boolean', 'SingleStoreBoolean'>>
+	extends SingleStoreColumnBuilder<T>
 {
-	static readonly [entityKind]: string = 'MySqlBooleanBuilder';
+	static readonly [entityKind]: string = 'SingleStoreBooleanBuilder';
 
 	constructor(name: T['name']) {
-		super(name, 'boolean', 'MySqlBoolean');
+		super(name, 'boolean', 'SingleStoreBoolean');
 	}
 
 	/** @internal */
 	override build<TTableName extends string>(
-		table: AnyMySqlTable<{ name: TTableName }>,
-	): MySqlBoolean<MakeColumnConfig<T, TTableName>> {
-		return new MySqlBoolean<MakeColumnConfig<T, TTableName>>(
+		table: AnySingleStoreTable<{ name: TTableName }>,
+	): SingleStoreBoolean<MakeColumnConfig<T, TTableName>> {
+		return new SingleStoreBoolean<MakeColumnConfig<T, TTableName>>(
 			table,
 			this.config as ColumnBuilderRuntimeConfig<any, any>,
 		);
 	}
 }
 
-export class MySqlBoolean<T extends ColumnBaseConfig<'boolean', 'MySqlBoolean'>> extends MySqlColumn<T> {
-	static readonly [entityKind]: string = 'MySqlBoolean';
+export class SingleStoreBoolean<T extends ColumnBaseConfig<'boolean', 'SingleStoreBoolean'>>
+	extends SingleStoreColumn<T>
+{
+	static readonly [entityKind]: string = 'SingleStoreBoolean';
 
 	getSQLType(): string {
 		return 'boolean';
@@ -49,6 +51,6 @@ export class MySqlBoolean<T extends ColumnBaseConfig<'boolean', 'MySqlBoolean'>>
 	}
 }
 
-export function boolean<TName extends string>(name: TName): MySqlBooleanBuilderInitial<TName> {
-	return new MySqlBooleanBuilder(name);
+export function boolean<TName extends string>(name: TName): SingleStoreBooleanBuilderInitial<TName> {
+	return new SingleStoreBooleanBuilder(name);
 }
diff --git a/drizzle-orm/src/singlestore-core/columns/bson.ts b/drizzle-orm/src/singlestore-core/columns/bson.ts
index 762eacf26..cc12f2308 100644
--- a/drizzle-orm/src/singlestore-core/columns/bson.ts
+++ b/drizzle-orm/src/singlestore-core/columns/bson.ts
@@ -1,36 +1,41 @@
 import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '~/column-builder.ts';
 import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
-import type { AnyMySqlTable } from '~/mysql-core/table.ts';
-import { MySqlColumn, MySqlColumnBuilder } from './common.ts';
+import type { AnySingleStoreTable } from '~/singlestore-core/table.ts';
+import { SingleStoreColumn, SingleStoreColumnBuilder } from './common.ts';
 
-export type MySqlBsonBuilderInitial<TName extends string> = MySqlBsonBuilder<{
+export type SingleStoreBsonBuilderInitial<TName extends string> = SingleStoreBsonBuilder<{
 	name: TName;
 	dataType: 'json'; // The bson is stored as a json string the same way binary is stored as a string (check `./binary.ts`)
-	columnType: 'MySqlBson';
+	columnType: 'SingleStoreBson';
 	data: unknown;
 	driverParam: string;
 	enumValues: undefined;
 	generated: undefined;
 }>;
 
-export class MySqlBsonBuilder<T extends ColumnBuilderBaseConfig<'json', 'MySqlBson'>> extends MySqlColumnBuilder<T> {
-	static readonly [entityKind]: string = 'MySqlBsonBuilder';
+export class SingleStoreBsonBuilder<T extends ColumnBuilderBaseConfig<'json', 'SingleStoreBson'>>
+	extends SingleStoreColumnBuilder<T>
+{
+	static readonly [entityKind]: string = 'SingleStoreBsonBuilder';
 
 	constructor(name: T['name']) {
-		super(name, 'json', 'MySqlBson');
+		super(name, 'json', 'SingleStoreBson');
 	}
 
 	/** @internal */
 	override build<TTableName extends string>(
-		table: AnyMySqlTable<{ name: TTableName }>,
-	): MySqlBson<MakeColumnConfig<T, TTableName>> {
-		return new MySqlBson<MakeColumnConfig<T, TTableName>>(table, this.config as ColumnBuilderRuntimeConfig<any, any>);
+		table: AnySingleStoreTable<{ name: TTableName }>,
+	): SingleStoreBson<MakeColumnConfig<T, TTableName>> {
+		return new SingleStoreBson<MakeColumnConfig<T, TTableName>>(
+			table,
+			this.config as ColumnBuilderRuntimeConfig<any, any>,
+		);
 	}
 }
 
-export class MySqlBson<T extends ColumnBaseConfig<'json', 'MySqlBson'>> extends MySqlColumn<T> {
-	static readonly [entityKind]: string = 'MySqlBson';
+export class SingleStoreBson<T extends ColumnBaseConfig<'json', 'SingleStoreBson'>> extends SingleStoreColumn<T> {
+	static readonly [entityKind]: string = 'SingleStoreBson';
 
 	getSQLType(): string {
 		return 'bson';
@@ -41,6 +46,6 @@ export class MySqlBson<T extends ColumnBaseConfig<'json', 'MySqlBson'>> extends
 	}
 }
 
-export function bson<TName extends string>(name: TName): MySqlBsonBuilderInitial<TName> {
-	return new MySqlBsonBuilder(name);
+export function bson<TName extends string>(name: TName): SingleStoreBsonBuilderInitial<TName> {
+	return new SingleStoreBsonBuilder(name);
 }
diff --git a/drizzle-orm/src/singlestore-core/columns/char.ts b/drizzle-orm/src/singlestore-core/columns/char.ts
index f871796a5..f59c173cb 100644
--- a/drizzle-orm/src/singlestore-core/columns/char.ts
+++ b/drizzle-orm/src/singlestore-core/columns/char.ts
@@ -1,47 +1,50 @@
 import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '~/column-builder.ts';
 import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
-import type { AnyMySqlTable } from '~/mysql-core/table.ts';
+import type { AnySingleStoreTable } from '~/singlestore-core/table.ts';
 import type { Writable } from '~/utils.ts';
-import { MySqlColumn, MySqlColumnBuilder } from './common.ts';
+import { SingleStoreColumn, SingleStoreColumnBuilder } from './common.ts';
 
-export type MySqlCharBuilderInitial<TName extends string, TEnum extends [string, ...string[]]> = MySqlCharBuilder<{
-	name: TName;
-	dataType: 'string';
-	columnType: 'MySqlChar';
-	data: TEnum[number];
-	driverParam: number | string;
-	enumValues: TEnum;
-	generated: undefined;
-}>;
+export type SingleStoreCharBuilderInitial<TName extends string, TEnum extends [string, ...string[]]> =
+	SingleStoreCharBuilder<{
+		name: TName;
+		dataType: 'string';
+		columnType: 'SingleStoreChar';
+		data: TEnum[number];
+		driverParam: number | string;
+		enumValues: TEnum;
+		generated: undefined;
+	}>;
 
-export class MySqlCharBuilder<T extends ColumnBuilderBaseConfig<'string', 'MySqlChar'>> extends MySqlColumnBuilder<
-	T,
-	MySqlCharConfig<T['enumValues']>
-> {
-	static readonly [entityKind]: string = 'MySqlCharBuilder';
+export class SingleStoreCharBuilder<T extends ColumnBuilderBaseConfig<'string', 'SingleStoreChar'>>
+	extends SingleStoreColumnBuilder<
+		T,
+		SingleStoreCharConfig<T['enumValues']>
+	>
+{
+	static readonly [entityKind]: string = 'SingleStoreCharBuilder';
 
-	constructor(name: T['name'], config: MySqlCharConfig<T['enumValues']>) {
-		super(name, 'string', 'MySqlChar');
+	constructor(name: T['name'], config: SingleStoreCharConfig<T['enumValues']>) {
+		super(name, 'string', 'SingleStoreChar');
 		this.config.length = config.length;
 		this.config.enum = config.enum;
 	}
 
 	/** @internal */
 	override build<TTableName extends string>(
-		table: AnyMySqlTable<{ name: TTableName }>,
-	): MySqlChar<MakeColumnConfig<T, TTableName> & { enumValues: T['enumValues'] }> {
-		return new MySqlChar<MakeColumnConfig<T, TTableName> & { enumValues: T['enumValues'] }>(
+		table: AnySingleStoreTable<{ name: TTableName }>,
+	): SingleStoreChar<MakeColumnConfig<T, TTableName> & { enumValues: T['enumValues'] }> {
+		return new SingleStoreChar<MakeColumnConfig<T, TTableName> & { enumValues: T['enumValues'] }>(
 			table,
 			this.config as ColumnBuilderRuntimeConfig<any, any>,
 		);
 	}
 }
 
-export class MySqlChar<T extends ColumnBaseConfig<'string', 'MySqlChar'>>
-	extends MySqlColumn<T, MySqlCharConfig<T['enumValues']>>
+export class SingleStoreChar<T extends ColumnBaseConfig<'string', 'SingleStoreChar'>>
+	extends SingleStoreColumn<T, SingleStoreCharConfig<T['enumValues']>>
 {
-	static readonly [entityKind]: string = 'MySqlChar';
+	static readonly [entityKind]: string = 'SingleStoreChar';
 
 	readonly length: number | undefined = this.config.length;
 	override readonly enumValues = this.config.enum;
@@ -51,14 +54,14 @@ export class MySqlChar<T extends ColumnBaseConfig<'string', 'MySqlChar'>>
 	}
 }
 
-export interface MySqlCharConfig<TEnum extends readonly string[] | string[] | undefined> {
+export interface SingleStoreCharConfig<TEnum extends readonly string[] | string[] | undefined> {
 	length?: number;
 	enum?: TEnum;
 }
 
 export function char<TName extends string, U extends string, T extends Readonly<[U, ...U[]]>>(
 	name: TName,
-	config: MySqlCharConfig<T | Writable<T>> = {},
-): MySqlCharBuilderInitial<TName, Writable<T>> {
-	return new MySqlCharBuilder(name, config);
+	config: SingleStoreCharConfig<T | Writable<T>> = {},
+): SingleStoreCharBuilderInitial<TName, Writable<T>> {
+	return new SingleStoreCharBuilder(name, config);
 }
diff --git a/drizzle-orm/src/singlestore-core/columns/common.ts b/drizzle-orm/src/singlestore-core/columns/common.ts
index 99196cb28..baa33abbd 100644
--- a/drizzle-orm/src/singlestore-core/columns/common.ts
+++ b/drizzle-orm/src/singlestore-core/columns/common.ts
@@ -13,41 +13,41 @@ import type {
 import type { ColumnBaseConfig } from '~/column.ts';
 import { Column } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
-import type { ForeignKey, UpdateDeleteAction } from '~/mysql-core/foreign-keys.ts';
-import { ForeignKeyBuilder } from '~/mysql-core/foreign-keys.ts';
-import type { AnyMySqlTable, MySqlTable } from '~/mysql-core/table.ts';
+import type { ForeignKey, UpdateDeleteAction } from '~/singlestore-core/foreign-keys.ts';
+import { ForeignKeyBuilder } from '~/singlestore-core/foreign-keys.ts';
+import type { AnySingleStoreTable, SingleStoreTable } from '~/singlestore-core/table.ts';
 import type { SQL } from '~/sql/sql.ts';
 import type { Update } from '~/utils.ts';
 import { uniqueKeyName } from '../unique-constraint.ts';
 
 export interface ReferenceConfig {
-	ref: () => MySqlColumn;
+	ref: () => SingleStoreColumn;
 	actions: {
 		onUpdate?: UpdateDeleteAction;
 		onDelete?: UpdateDeleteAction;
 	};
 }
 
-export interface MySqlColumnBuilderBase<
+export interface SingleStoreColumnBuilderBase<
 	T extends ColumnBuilderBaseConfig<ColumnDataType, string> = ColumnBuilderBaseConfig<ColumnDataType, string>,
 	TTypeConfig extends object = object,
-> extends ColumnBuilderBase<T, TTypeConfig & { dialect: 'mysql' }> {}
+> extends ColumnBuilderBase<T, TTypeConfig & { dialect: 'singlestore' }> {}
 
-export interface MySqlGeneratedColumnConfig {
+export interface SingleStoreGeneratedColumnConfig {
 	mode?: 'virtual' | 'stored';
 }
 
-export abstract class MySqlColumnBuilder<
+export abstract class SingleStoreColumnBuilder<
 	T extends ColumnBuilderBaseConfig<ColumnDataType, string> = ColumnBuilderBaseConfig<ColumnDataType, string> & {
 		data: any;
 	},
 	TRuntimeConfig extends object = object,
 	TTypeConfig extends object = object,
 	TExtraConfig extends ColumnBuilderExtraConfig = ColumnBuilderExtraConfig,
-> extends ColumnBuilder<T, TRuntimeConfig, TTypeConfig & { dialect: 'mysql' }, TExtraConfig>
-	implements MySqlColumnBuilderBase<T, TTypeConfig>
+> extends ColumnBuilder<T, TRuntimeConfig, TTypeConfig & { dialect: 'singlestore' }, TExtraConfig>
+	implements SingleStoreColumnBuilderBase<T, TTypeConfig>
 {
-	static readonly [entityKind]: string = 'MySqlColumnBuilder';
+	static readonly [entityKind]: string = 'SingleStoreColumnBuilder';
 
 	private foreignKeyConfigs: ReferenceConfig[] = [];
 
@@ -62,7 +62,7 @@ export abstract class MySqlColumnBuilder<
 		return this;
 	}
 
-	generatedAlwaysAs(as: SQL | T['data'] | (() => SQL), config?: MySqlGeneratedColumnConfig): HasGenerated<this> {
+	generatedAlwaysAs(as: SQL | T['data'] | (() => SQL), config?: SingleStoreGeneratedColumnConfig): HasGenerated<this> {
 		this.config.generated = {
 			as,
 			type: 'always',
@@ -72,7 +72,7 @@ export abstract class MySqlColumnBuilder<
 	}
 
 	/** @internal */
-	buildForeignKeys(column: MySqlColumn, table: MySqlTable): ForeignKey[] {
+	buildForeignKeys(column: SingleStoreColumn, table: SingleStoreTable): ForeignKey[] {
 		return this.foreignKeyConfigs.map(({ ref, actions }) => {
 			return ((ref, actions) => {
 				const builder = new ForeignKeyBuilder(() => {
@@ -92,36 +92,19 @@ export abstract class MySqlColumnBuilder<
 
 	/** @internal */
 	abstract build<TTableName extends string>(
-		table: AnyMySqlTable<{ name: TTableName }>,
-	): MySqlColumn<MakeColumnConfig<T, TTableName>>;
+		table: AnySingleStoreTable<{ name: TTableName }>,
+	): SingleStoreColumn<MakeColumnConfig<T, TTableName>>;
 }
 
+// To understand how to use `SingleStoreColumn` and `AnySingleStoreColumn`, see `Column` and `AnyColumn` documentation.
 export abstract class SingleStoreColumn<
-T extends ColumnBaseConfig<ColumnDataType, string> = ColumnBaseConfig<ColumnDataType, string>,
-TRuntimeConfig extends object = object,
-> extends Column<T, TRuntimeConfig, { dialect: 'mysql' }> {
-static readonly [entityKind]: string = 'MySqlColumn';
-
-constructor(
-	override readonly table: MySqlTable,
-	config: ColumnBuilderRuntimeConfig<T['data'], TRuntimeConfig>,
-) {
-	if (!config.uniqueName) {
-		config.uniqueName = uniqueKeyName(table, [config.name]);
-	}
-	super(table, config);
-}
-}
-
-// To understand how to use `MySqlColumn` and `AnyMySqlColumn`, see `Column` and `AnyColumn` documentation.
-export abstract class MySqlColumn<
 	T extends ColumnBaseConfig<ColumnDataType, string> = ColumnBaseConfig<ColumnDataType, string>,
 	TRuntimeConfig extends object = object,
-> extends Column<T, TRuntimeConfig, { dialect: 'mysql' }> {
-	static readonly [entityKind]: string = 'MySqlColumn';
+> extends Column<T, TRuntimeConfig, { dialect: 'singlestore' }> {
+	static readonly [entityKind]: string = 'SingleStoreColumn';
 
 	constructor(
-		override readonly table: MySqlTable,
+		override readonly table: SingleStoreTable,
 		config: ColumnBuilderRuntimeConfig<T['data'], TRuntimeConfig>,
 	) {
 		if (!config.uniqueName) {
@@ -131,20 +114,21 @@ export abstract class MySqlColumn<
 	}
 }
 
-export type AnyMySqlColumn<TPartial extends Partial<ColumnBaseConfig<ColumnDataType, string>> = {}> = MySqlColumn<
-	Required<Update<ColumnBaseConfig<ColumnDataType, string>, TPartial>>
->;
+export type AnySingleStoreColumn<TPartial extends Partial<ColumnBaseConfig<ColumnDataType, string>> = {}> =
+	SingleStoreColumn<
+		Required<Update<ColumnBaseConfig<ColumnDataType, string>, TPartial>>
+	>;
 
-export interface MySqlColumnWithAutoIncrementConfig {
+export interface SingleStoreColumnWithAutoIncrementConfig {
 	autoIncrement: boolean;
 }
 
-export abstract class MySqlColumnBuilderWithAutoIncrement<
+export abstract class SingleStoreColumnBuilderWithAutoIncrement<
 	T extends ColumnBuilderBaseConfig<ColumnDataType, string> = ColumnBuilderBaseConfig<ColumnDataType, string>,
 	TRuntimeConfig extends object = object,
 	TExtraConfig extends ColumnBuilderExtraConfig = ColumnBuilderExtraConfig,
-> extends MySqlColumnBuilder<T, TRuntimeConfig & MySqlColumnWithAutoIncrementConfig, TExtraConfig> {
-	static readonly [entityKind]: string = 'MySqlColumnBuilderWithAutoIncrement';
+> extends SingleStoreColumnBuilder<T, TRuntimeConfig & SingleStoreColumnWithAutoIncrementConfig, TExtraConfig> {
+	static readonly [entityKind]: string = 'SingleStoreColumnBuilderWithAutoIncrement';
 
 	constructor(name: NonNullable<T['name']>, dataType: T['dataType'], columnType: T['columnType']) {
 		super(name, dataType, columnType);
@@ -158,11 +142,11 @@ export abstract class MySqlColumnBuilderWithAutoIncrement<
 	}
 }
 
-export abstract class MySqlColumnWithAutoIncrement<
+export abstract class SingleStoreColumnWithAutoIncrement<
 	T extends ColumnBaseConfig<ColumnDataType, string> = ColumnBaseConfig<ColumnDataType, string>,
 	TRuntimeConfig extends object = object,
-> extends MySqlColumn<T, MySqlColumnWithAutoIncrementConfig & TRuntimeConfig> {
-	static readonly [entityKind]: string = 'MySqlColumnWithAutoIncrement';
+> extends SingleStoreColumn<T, SingleStoreColumnWithAutoIncrementConfig & TRuntimeConfig> {
+	static readonly [entityKind]: string = 'SingleStoreColumnWithAutoIncrement';
 
 	readonly autoIncrement: boolean = this.config.autoIncrement;
 }
diff --git a/drizzle-orm/src/singlestore-core/columns/custom.ts b/drizzle-orm/src/singlestore-core/columns/custom.ts
index 1c5e2603f..727099884 100644
--- a/drizzle-orm/src/singlestore-core/columns/custom.ts
+++ b/drizzle-orm/src/singlestore-core/columns/custom.ts
@@ -1,16 +1,16 @@
 import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '~/column-builder.ts';
 import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
-import type { AnyMySqlTable } from '~/mysql-core/table.ts';
+import type { AnySingleStoreTable } from '~/singlestore-core/table.ts';
 import type { SQL } from '~/sql/sql.ts';
 import type { Equal } from '~/utils.ts';
-import { MySqlColumn, MySqlColumnBuilder } from './common.ts';
+import { SingleStoreColumn, SingleStoreColumnBuilder } from './common.ts';
 
 export type ConvertCustomConfig<TName extends string, T extends Partial<CustomTypeValues>> =
 	& {
 		name: TName;
 		dataType: 'custom';
-		columnType: 'MySqlCustomColumn';
+		columnType: 'SingleStoreCustomColumn';
 		data: T['data'];
 		driverParam: T['driverData'];
 		enumValues: undefined;
@@ -19,55 +19,57 @@ export type ConvertCustomConfig<TName extends string, T extends Partial<CustomTy
 	& (T['notNull'] extends true ? { notNull: true } : {})
 	& (T['default'] extends true ? { hasDefault: true } : {});
 
-export interface MySqlCustomColumnInnerConfig {
+export interface SingleStoreCustomColumnInnerConfig {
 	customTypeValues: CustomTypeValues;
 }
 
-export class MySqlCustomColumnBuilder<T extends ColumnBuilderBaseConfig<'custom', 'MySqlCustomColumn'>>
-	extends MySqlColumnBuilder<
+export class SingleStoreCustomColumnBuilder<T extends ColumnBuilderBaseConfig<'custom', 'SingleStoreCustomColumn'>>
+	extends SingleStoreColumnBuilder<
 		T,
 		{
 			fieldConfig: CustomTypeValues['config'];
 			customTypeParams: CustomTypeParams<any>;
 		},
 		{
-			mysqlColumnBuilderBrand: 'MySqlCustomColumnBuilderBrand';
+			singlestoreColumnBuilderBrand: 'SingleStoreCustomColumnBuilderBrand';
 		}
 	>
 {
-	static readonly [entityKind]: string = 'MySqlCustomColumnBuilder';
+	static readonly [entityKind]: string = 'SingleStoreCustomColumnBuilder';
 
 	constructor(
 		name: T['name'],
 		fieldConfig: CustomTypeValues['config'],
 		customTypeParams: CustomTypeParams<any>,
 	) {
-		super(name, 'custom', 'MySqlCustomColumn');
+		super(name, 'custom', 'SingleStoreCustomColumn');
 		this.config.fieldConfig = fieldConfig;
 		this.config.customTypeParams = customTypeParams;
 	}
 
 	/** @internal */
 	build<TTableName extends string>(
-		table: AnyMySqlTable<{ name: TTableName }>,
-	): MySqlCustomColumn<MakeColumnConfig<T, TTableName>> {
-		return new MySqlCustomColumn<MakeColumnConfig<T, TTableName>>(
+		table: AnySingleStoreTable<{ name: TTableName }>,
+	): SingleStoreCustomColumn<MakeColumnConfig<T, TTableName>> {
+		return new SingleStoreCustomColumn<MakeColumnConfig<T, TTableName>>(
 			table,
 			this.config as ColumnBuilderRuntimeConfig<any, any>,
 		);
 	}
 }
 
-export class MySqlCustomColumn<T extends ColumnBaseConfig<'custom', 'MySqlCustomColumn'>> extends MySqlColumn<T> {
-	static readonly [entityKind]: string = 'MySqlCustomColumn';
+export class SingleStoreCustomColumn<T extends ColumnBaseConfig<'custom', 'SingleStoreCustomColumn'>>
+	extends SingleStoreColumn<T>
+{
+	static readonly [entityKind]: string = 'SingleStoreCustomColumn';
 
 	private sqlName: string;
 	private mapTo?: (value: T['data']) => T['driverParam'];
 	private mapFrom?: (value: T['driverParam']) => T['data'];
 
 	constructor(
-		table: AnyMySqlTable<{ name: T['tableName'] }>,
-		config: MySqlCustomColumnBuilder<T>['config'],
+		table: AnySingleStoreTable<{ name: T['tableName'] }>,
+		config: SingleStoreCustomColumnBuilder<T>['config'],
 	) {
 		super(table, config);
 		this.sqlName = config.customTypeParams.dataType(config.fieldConfig);
@@ -199,23 +201,27 @@ export interface CustomTypeParams<T extends CustomTypeValues> {
 }
 
 /**
- * Custom mysql database data type generator
+ * Custom singlestore database data type generator
  */
 export function customType<T extends CustomTypeValues = CustomTypeValues>(
 	customTypeParams: CustomTypeParams<T>,
 ): Equal<T['configRequired'], true> extends true ? <TName extends string>(
 		dbName: TName,
 		fieldConfig: T['config'],
-	) => MySqlCustomColumnBuilder<ConvertCustomConfig<TName, T>>
+	) => SingleStoreCustomColumnBuilder<ConvertCustomConfig<TName, T>>
 	: <TName extends string>(
 		dbName: TName,
 		fieldConfig?: T['config'],
-	) => MySqlCustomColumnBuilder<ConvertCustomConfig<TName, T>>
+	) => SingleStoreCustomColumnBuilder<ConvertCustomConfig<TName, T>>
 {
 	return <TName extends string>(
 		dbName: TName,
 		fieldConfig?: T['config'],
-	): MySqlCustomColumnBuilder<ConvertCustomConfig<TName, T>> => {
-		return new MySqlCustomColumnBuilder(dbName as ConvertCustomConfig<TName, T>['name'], fieldConfig, customTypeParams);
+	): SingleStoreCustomColumnBuilder<ConvertCustomConfig<TName, T>> => {
+		return new SingleStoreCustomColumnBuilder(
+			dbName as ConvertCustomConfig<TName, T>['name'],
+			fieldConfig,
+			customTypeParams,
+		);
 	};
 }
diff --git a/drizzle-orm/src/singlestore-core/columns/date.common.ts b/drizzle-orm/src/singlestore-core/columns/date.common.ts
index 3fd8aa612..45dd668c9 100644
--- a/drizzle-orm/src/singlestore-core/columns/date.common.ts
+++ b/drizzle-orm/src/singlestore-core/columns/date.common.ts
@@ -7,24 +7,25 @@ import type {
 import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
 import { sql } from '~/sql/sql.ts';
-import { MySqlColumn, MySqlColumnBuilder } from './common.ts';
+import { SingleStoreColumn, SingleStoreColumnBuilder } from './common.ts';
 
-export interface MySqlDateColumnBaseConfig {
+export interface SingleStoreDateColumnBaseConfig {
 	hasOnUpdateNow: boolean;
 }
 
-export abstract class MySqlDateColumnBaseBuilder<
+export abstract class SingleStoreDateColumnBaseBuilder<
 	T extends ColumnBuilderBaseConfig<ColumnDataType, string>,
 	TRuntimeConfig extends object = object,
 	TExtraConfig extends ColumnBuilderExtraConfig = ColumnBuilderExtraConfig,
-> extends MySqlColumnBuilder<T, TRuntimeConfig & MySqlDateColumnBaseConfig, TExtraConfig> {
-	static readonly [entityKind]: string = 'MySqlDateColumnBuilder';
+> extends SingleStoreColumnBuilder<T, TRuntimeConfig & SingleStoreDateColumnBaseConfig, TExtraConfig> {
+	static readonly [entityKind]: string = 'SingleStoreDateColumnBuilder';
 
 	defaultNow() {
 		return this.default(sql`(now())`);
 	}
 
 	// "on update now" also adds an implicit default value to the column - https://dev.mysql.com/doc/refman/8.0/en/timestamp-initialization.html
+	// TODO(singlestore)
 	onUpdateNow(): HasDefault<this> {
 		this.config.hasOnUpdateNow = true;
 		this.config.hasDefault = true;
@@ -32,11 +33,11 @@ export abstract class MySqlDateColumnBaseBuilder<
 	}
 }
 
-export abstract class MySqlDateBaseColumn<
+export abstract class SingleStoreDateBaseColumn<
 	T extends ColumnBaseConfig<ColumnDataType, string>,
 	TRuntimeConfig extends object = object,
-> extends MySqlColumn<T, MySqlDateColumnBaseConfig & TRuntimeConfig> {
-	static readonly [entityKind]: string = 'MySqlDateColumn';
+> extends SingleStoreColumn<T, SingleStoreDateColumnBaseConfig & TRuntimeConfig> {
+	static readonly [entityKind]: string = 'SingleStoreDateColumn';
 
 	readonly hasOnUpdateNow: boolean = this.config.hasOnUpdateNow;
 }
diff --git a/drizzle-orm/src/singlestore-core/columns/date.ts b/drizzle-orm/src/singlestore-core/columns/date.ts
index d7e2c409e..1c64fe3f1 100644
--- a/drizzle-orm/src/singlestore-core/columns/date.ts
+++ b/drizzle-orm/src/singlestore-core/columns/date.ts
@@ -1,41 +1,46 @@
 import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '~/column-builder.ts';
 import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
-import type { AnyMySqlTable } from '~/mysql-core/table.ts';
+import type { AnySingleStoreTable } from '~/singlestore-core/table.ts';
 import type { Equal } from '~/utils.ts';
-import { MySqlColumn, MySqlColumnBuilder } from './common.ts';
+import { SingleStoreColumn, SingleStoreColumnBuilder } from './common.ts';
 
-export type MySqlDateBuilderInitial<TName extends string> = MySqlDateBuilder<{
+export type SingleStoreDateBuilderInitial<TName extends string> = SingleStoreDateBuilder<{
 	name: TName;
 	dataType: 'date';
-	columnType: 'MySqlDate';
+	columnType: 'SingleStoreDate';
 	data: Date;
 	driverParam: string | number;
 	enumValues: undefined;
 	generated: undefined;
 }>;
 
-export class MySqlDateBuilder<T extends ColumnBuilderBaseConfig<'date', 'MySqlDate'>> extends MySqlColumnBuilder<T> {
-	static readonly [entityKind]: string = 'MySqlDateBuilder';
+export class SingleStoreDateBuilder<T extends ColumnBuilderBaseConfig<'date', 'SingleStoreDate'>>
+	extends SingleStoreColumnBuilder<T>
+{
+	static readonly [entityKind]: string = 'SingleStoreDateBuilder';
 
 	constructor(name: T['name']) {
-		super(name, 'date', 'MySqlDate');
+		super(name, 'date', 'SingleStoreDate');
 	}
 
 	/** @internal */
 	override build<TTableName extends string>(
-		table: AnyMySqlTable<{ name: TTableName }>,
-	): MySqlDate<MakeColumnConfig<T, TTableName>> {
-		return new MySqlDate<MakeColumnConfig<T, TTableName>>(table, this.config as ColumnBuilderRuntimeConfig<any, any>);
+		table: AnySingleStoreTable<{ name: TTableName }>,
+	): SingleStoreDate<MakeColumnConfig<T, TTableName>> {
+		return new SingleStoreDate<MakeColumnConfig<T, TTableName>>(
+			table,
+			this.config as ColumnBuilderRuntimeConfig<any, any>,
+		);
 	}
 }
 
-export class MySqlDate<T extends ColumnBaseConfig<'date', 'MySqlDate'>> extends MySqlColumn<T> {
-	static readonly [entityKind]: string = 'MySqlDate';
+export class SingleStoreDate<T extends ColumnBaseConfig<'date', 'SingleStoreDate'>> extends SingleStoreColumn<T> {
+	static readonly [entityKind]: string = 'SingleStoreDate';
 
 	constructor(
-		table: AnyMySqlTable<{ name: T['tableName'] }>,
-		config: MySqlDateBuilder<T>['config'],
+		table: AnySingleStoreTable<{ name: T['tableName'] }>,
+		config: SingleStoreDateBuilder<T>['config'],
 	) {
 		super(table, config);
 	}
@@ -49,42 +54,44 @@ export class MySqlDate<T extends ColumnBaseConfig<'date', 'MySqlDate'>> extends
 	}
 }
 
-export type MySqlDateStringBuilderInitial<TName extends string> = MySqlDateStringBuilder<{
+export type SingleStoreDateStringBuilderInitial<TName extends string> = SingleStoreDateStringBuilder<{
 	name: TName;
 	dataType: 'string';
-	columnType: 'MySqlDateString';
+	columnType: 'SingleStoreDateString';
 	data: string;
 	driverParam: string | number;
 	enumValues: undefined;
 	generated: undefined;
 }>;
 
-export class MySqlDateStringBuilder<T extends ColumnBuilderBaseConfig<'string', 'MySqlDateString'>>
-	extends MySqlColumnBuilder<T>
+export class SingleStoreDateStringBuilder<T extends ColumnBuilderBaseConfig<'string', 'SingleStoreDateString'>>
+	extends SingleStoreColumnBuilder<T>
 {
-	static readonly [entityKind]: string = 'MySqlDateStringBuilder';
+	static readonly [entityKind]: string = 'SingleStoreDateStringBuilder';
 
 	constructor(name: T['name']) {
-		super(name, 'string', 'MySqlDateString');
+		super(name, 'string', 'SingleStoreDateString');
 	}
 
 	/** @internal */
 	override build<TTableName extends string>(
-		table: AnyMySqlTable<{ name: TTableName }>,
-	): MySqlDateString<MakeColumnConfig<T, TTableName>> {
-		return new MySqlDateString<MakeColumnConfig<T, TTableName>>(
+		table: AnySingleStoreTable<{ name: TTableName }>,
+	): SingleStoreDateString<MakeColumnConfig<T, TTableName>> {
+		return new SingleStoreDateString<MakeColumnConfig<T, TTableName>>(
 			table,
 			this.config as ColumnBuilderRuntimeConfig<any, any>,
 		);
 	}
 }
 
-export class MySqlDateString<T extends ColumnBaseConfig<'string', 'MySqlDateString'>> extends MySqlColumn<T> {
-	static readonly [entityKind]: string = 'MySqlDateString';
+export class SingleStoreDateString<T extends ColumnBaseConfig<'string', 'SingleStoreDateString'>>
+	extends SingleStoreColumn<T>
+{
+	static readonly [entityKind]: string = 'SingleStoreDateString';
 
 	constructor(
-		table: AnyMySqlTable<{ name: T['tableName'] }>,
-		config: MySqlDateStringBuilder<T>['config'],
+		table: AnySingleStoreTable<{ name: T['tableName'] }>,
+		config: SingleStoreDateStringBuilder<T>['config'],
 	) {
 		super(table, config);
 	}
@@ -94,17 +101,18 @@ export class MySqlDateString<T extends ColumnBaseConfig<'string', 'MySqlDateStri
 	}
 }
 
-export interface MySqlDateConfig<TMode extends 'date' | 'string' = 'date' | 'string'> {
+export interface SingleStoreDateConfig<TMode extends 'date' | 'string' = 'date' | 'string'> {
 	mode?: TMode;
 }
 
-export function date<TName extends string, TMode extends MySqlDateConfig['mode'] & {}>(
+export function date<TName extends string, TMode extends SingleStoreDateConfig['mode'] & {}>(
 	name: TName,
-	config?: MySqlDateConfig<TMode>,
-): Equal<TMode, 'string'> extends true ? MySqlDateStringBuilderInitial<TName> : MySqlDateBuilderInitial<TName>;
-export function date(name: string, config: MySqlDateConfig = {}) {
+	config?: SingleStoreDateConfig<TMode>,
+): Equal<TMode, 'string'> extends true ? SingleStoreDateStringBuilderInitial<TName>
+	: SingleStoreDateBuilderInitial<TName>;
+export function date(name: string, config: SingleStoreDateConfig = {}) {
 	if (config.mode === 'string') {
-		return new MySqlDateStringBuilder(name);
+		return new SingleStoreDateStringBuilder(name);
 	}
-	return new MySqlDateBuilder(name);
+	return new SingleStoreDateBuilder(name);
 }
diff --git a/drizzle-orm/src/singlestore-core/columns/datetime.ts b/drizzle-orm/src/singlestore-core/columns/datetime.ts
index 040c57130..f5d45629b 100644
--- a/drizzle-orm/src/singlestore-core/columns/datetime.ts
+++ b/drizzle-orm/src/singlestore-core/columns/datetime.ts
@@ -1,49 +1,51 @@
 import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '~/column-builder.ts';
 import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
-import type { AnyMySqlTable } from '~/mysql-core/table.ts';
+import type { AnySingleStoreTable } from '~/singlestore-core/table.ts';
 import type { Equal } from '~/utils.ts';
-import { MySqlColumn, MySqlColumnBuilder } from './common.ts';
+import { SingleStoreColumn, SingleStoreColumnBuilder } from './common.ts';
 
-export type MySqlDateTimeBuilderInitial<TName extends string> = MySqlDateTimeBuilder<{
+export type SingleStoreDateTimeBuilderInitial<TName extends string> = SingleStoreDateTimeBuilder<{
 	name: TName;
 	dataType: 'date';
-	columnType: 'MySqlDateTime';
+	columnType: 'SingleStoreDateTime';
 	data: Date;
 	driverParam: string | number;
 	enumValues: undefined;
 	generated: undefined;
 }>;
 
-export class MySqlDateTimeBuilder<T extends ColumnBuilderBaseConfig<'date', 'MySqlDateTime'>>
-	extends MySqlColumnBuilder<T, MySqlDatetimeConfig>
+export class SingleStoreDateTimeBuilder<T extends ColumnBuilderBaseConfig<'date', 'SingleStoreDateTime'>>
+	extends SingleStoreColumnBuilder<T, SingleStoreDatetimeConfig>
 {
-	static readonly [entityKind]: string = 'MySqlDateTimeBuilder';
+	static readonly [entityKind]: string = 'SingleStoreDateTimeBuilder';
 
-	constructor(name: T['name'], config: MySqlDatetimeConfig | undefined) {
-		super(name, 'date', 'MySqlDateTime');
+	constructor(name: T['name'], config: SingleStoreDatetimeConfig | undefined) {
+		super(name, 'date', 'SingleStoreDateTime');
 		this.config.fsp = config?.fsp;
 	}
 
 	/** @internal */
 	override build<TTableName extends string>(
-		table: AnyMySqlTable<{ name: TTableName }>,
-	): MySqlDateTime<MakeColumnConfig<T, TTableName>> {
-		return new MySqlDateTime<MakeColumnConfig<T, TTableName>>(
+		table: AnySingleStoreTable<{ name: TTableName }>,
+	): SingleStoreDateTime<MakeColumnConfig<T, TTableName>> {
+		return new SingleStoreDateTime<MakeColumnConfig<T, TTableName>>(
 			table,
 			this.config as ColumnBuilderRuntimeConfig<any, any>,
 		);
 	}
 }
 
-export class MySqlDateTime<T extends ColumnBaseConfig<'date', 'MySqlDateTime'>> extends MySqlColumn<T> {
-	static readonly [entityKind]: string = 'MySqlDateTime';
+export class SingleStoreDateTime<T extends ColumnBaseConfig<'date', 'SingleStoreDateTime'>>
+	extends SingleStoreColumn<T>
+{
+	static readonly [entityKind]: string = 'SingleStoreDateTime';
 
 	readonly fsp: number | undefined;
 
 	constructor(
-		table: AnyMySqlTable<{ name: T['tableName'] }>,
-		config: MySqlDateTimeBuilder<T>['config'],
+		table: AnySingleStoreTable<{ name: T['tableName'] }>,
+		config: SingleStoreDateTimeBuilder<T>['config'],
 	) {
 		super(table, config);
 		this.fsp = config.fsp;
@@ -63,45 +65,47 @@ export class MySqlDateTime<T extends ColumnBaseConfig<'date', 'MySqlDateTime'>>
 	}
 }
 
-export type MySqlDateTimeStringBuilderInitial<TName extends string> = MySqlDateTimeStringBuilder<{
+export type SingleStoreDateTimeStringBuilderInitial<TName extends string> = SingleStoreDateTimeStringBuilder<{
 	name: TName;
 	dataType: 'string';
-	columnType: 'MySqlDateTimeString';
+	columnType: 'SingleStoreDateTimeString';
 	data: string;
 	driverParam: string | number;
 	enumValues: undefined;
 	generated: undefined;
 }>;
 
-export class MySqlDateTimeStringBuilder<T extends ColumnBuilderBaseConfig<'string', 'MySqlDateTimeString'>>
-	extends MySqlColumnBuilder<T, MySqlDatetimeConfig>
+export class SingleStoreDateTimeStringBuilder<T extends ColumnBuilderBaseConfig<'string', 'SingleStoreDateTimeString'>>
+	extends SingleStoreColumnBuilder<T, SingleStoreDatetimeConfig>
 {
-	static readonly [entityKind]: string = 'MySqlDateTimeStringBuilder';
+	static readonly [entityKind]: string = 'SingleStoreDateTimeStringBuilder';
 
-	constructor(name: T['name'], config: MySqlDatetimeConfig | undefined) {
-		super(name, 'string', 'MySqlDateTimeString');
+	constructor(name: T['name'], config: SingleStoreDatetimeConfig | undefined) {
+		super(name, 'string', 'SingleStoreDateTimeString');
 		this.config.fsp = config?.fsp;
 	}
 
 	/** @internal */
 	override build<TTableName extends string>(
-		table: AnyMySqlTable<{ name: TTableName }>,
-	): MySqlDateTimeString<MakeColumnConfig<T, TTableName>> {
-		return new MySqlDateTimeString<MakeColumnConfig<T, TTableName>>(
+		table: AnySingleStoreTable<{ name: TTableName }>,
+	): SingleStoreDateTimeString<MakeColumnConfig<T, TTableName>> {
+		return new SingleStoreDateTimeString<MakeColumnConfig<T, TTableName>>(
 			table,
 			this.config as ColumnBuilderRuntimeConfig<any, any>,
 		);
 	}
 }
 
-export class MySqlDateTimeString<T extends ColumnBaseConfig<'string', 'MySqlDateTimeString'>> extends MySqlColumn<T> {
-	static readonly [entityKind]: string = 'MySqlDateTimeString';
+export class SingleStoreDateTimeString<T extends ColumnBaseConfig<'string', 'SingleStoreDateTimeString'>>
+	extends SingleStoreColumn<T>
+{
+	static readonly [entityKind]: string = 'SingleStoreDateTimeString';
 
 	readonly fsp: number | undefined;
 
 	constructor(
-		table: AnyMySqlTable<{ name: T['tableName'] }>,
-		config: MySqlDateTimeStringBuilder<T>['config'],
+		table: AnySingleStoreTable<{ name: T['tableName'] }>,
+		config: SingleStoreDateTimeStringBuilder<T>['config'],
 	) {
 		super(table, config);
 		this.fsp = config.fsp;
@@ -115,18 +119,19 @@ export class MySqlDateTimeString<T extends ColumnBaseConfig<'string', 'MySqlDate
 
 export type DatetimeFsp = 0 | 1 | 2 | 3 | 4 | 5 | 6;
 
-export interface MySqlDatetimeConfig<TMode extends 'date' | 'string' = 'date' | 'string'> {
+export interface SingleStoreDatetimeConfig<TMode extends 'date' | 'string' = 'date' | 'string'> {
 	mode?: TMode;
 	fsp?: DatetimeFsp;
 }
 
-export function datetime<TName extends string, TMode extends MySqlDatetimeConfig['mode'] & {}>(
+export function datetime<TName extends string, TMode extends SingleStoreDatetimeConfig['mode'] & {}>(
 	name: TName,
-	config?: MySqlDatetimeConfig<TMode>,
-): Equal<TMode, 'string'> extends true ? MySqlDateTimeStringBuilderInitial<TName> : MySqlDateTimeBuilderInitial<TName>;
-export function datetime(name: string, config: MySqlDatetimeConfig = {}) {
+	config?: SingleStoreDatetimeConfig<TMode>,
+): Equal<TMode, 'string'> extends true ? SingleStoreDateTimeStringBuilderInitial<TName>
+	: SingleStoreDateTimeBuilderInitial<TName>;
+export function datetime(name: string, config: SingleStoreDatetimeConfig = {}) {
 	if (config.mode === 'string') {
-		return new MySqlDateTimeStringBuilder(name, config);
+		return new SingleStoreDateTimeStringBuilder(name, config);
 	}
-	return new MySqlDateTimeBuilder(name, config);
+	return new SingleStoreDateTimeBuilder(name, config);
 }
diff --git a/drizzle-orm/src/singlestore-core/columns/decimal.ts b/drizzle-orm/src/singlestore-core/columns/decimal.ts
index fa25d9cdb..e5095c4d8 100644
--- a/drizzle-orm/src/singlestore-core/columns/decimal.ts
+++ b/drizzle-orm/src/singlestore-core/columns/decimal.ts
@@ -1,45 +1,45 @@
 import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '~/column-builder.ts';
 import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
-import type { AnyMySqlTable } from '~/mysql-core/table.ts';
-import { MySqlColumnBuilderWithAutoIncrement, MySqlColumnWithAutoIncrement } from './common.ts';
+import type { AnySingleStoreTable } from '~/singlestore-core/table.ts';
+import { SingleStoreColumnBuilderWithAutoIncrement, SingleStoreColumnWithAutoIncrement } from './common.ts';
 
-export type MySqlDecimalBuilderInitial<TName extends string> = MySqlDecimalBuilder<{
+export type SingleStoreDecimalBuilderInitial<TName extends string> = SingleStoreDecimalBuilder<{
 	name: TName;
 	dataType: 'string';
-	columnType: 'MySqlDecimal';
+	columnType: 'SingleStoreDecimal';
 	data: string;
 	driverParam: string;
 	enumValues: undefined;
 	generated: undefined;
 }>;
 
-export class MySqlDecimalBuilder<
-	T extends ColumnBuilderBaseConfig<'string', 'MySqlDecimal'>,
-> extends MySqlColumnBuilderWithAutoIncrement<T, MySqlDecimalConfig> {
-	static readonly [entityKind]: string = 'MySqlDecimalBuilder';
+export class SingleStoreDecimalBuilder<
+	T extends ColumnBuilderBaseConfig<'string', 'SingleStoreDecimal'>,
+> extends SingleStoreColumnBuilderWithAutoIncrement<T, SingleStoreDecimalConfig> {
+	static readonly [entityKind]: string = 'SingleStoreDecimalBuilder';
 
 	constructor(name: T['name'], precision?: number, scale?: number) {
-		super(name, 'string', 'MySqlDecimal');
+		super(name, 'string', 'SingleStoreDecimal');
 		this.config.precision = precision;
 		this.config.scale = scale;
 	}
 
 	/** @internal */
 	override build<TTableName extends string>(
-		table: AnyMySqlTable<{ name: TTableName }>,
-	): MySqlDecimal<MakeColumnConfig<T, TTableName>> {
-		return new MySqlDecimal<MakeColumnConfig<T, TTableName>>(
+		table: AnySingleStoreTable<{ name: TTableName }>,
+	): SingleStoreDecimal<MakeColumnConfig<T, TTableName>> {
+		return new SingleStoreDecimal<MakeColumnConfig<T, TTableName>>(
 			table,
 			this.config as ColumnBuilderRuntimeConfig<any, any>,
 		);
 	}
 }
 
-export class MySqlDecimal<T extends ColumnBaseConfig<'string', 'MySqlDecimal'>>
-	extends MySqlColumnWithAutoIncrement<T, MySqlDecimalConfig>
+export class SingleStoreDecimal<T extends ColumnBaseConfig<'string', 'SingleStoreDecimal'>>
+	extends SingleStoreColumnWithAutoIncrement<T, SingleStoreDecimalConfig>
 {
-	static readonly [entityKind]: string = 'MySqlDecimal';
+	static readonly [entityKind]: string = 'SingleStoreDecimal';
 
 	readonly precision: number | undefined = this.config.precision;
 	readonly scale: number | undefined = this.config.scale;
@@ -55,14 +55,14 @@ export class MySqlDecimal<T extends ColumnBaseConfig<'string', 'MySqlDecimal'>>
 	}
 }
 
-export interface MySqlDecimalConfig {
+export interface SingleStoreDecimalConfig {
 	precision?: number;
 	scale?: number;
 }
 
 export function decimal<TName extends string>(
 	name: TName,
-	config: MySqlDecimalConfig = {},
-): MySqlDecimalBuilderInitial<TName> {
-	return new MySqlDecimalBuilder(name, config.precision, config.scale);
+	config: SingleStoreDecimalConfig = {},
+): SingleStoreDecimalBuilderInitial<TName> {
+	return new SingleStoreDecimalBuilder(name, config.precision, config.scale);
 }
diff --git a/drizzle-orm/src/singlestore-core/columns/double.ts b/drizzle-orm/src/singlestore-core/columns/double.ts
index dd349cf27..6ca945431 100644
--- a/drizzle-orm/src/singlestore-core/columns/double.ts
+++ b/drizzle-orm/src/singlestore-core/columns/double.ts
@@ -1,42 +1,45 @@
 import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '~/column-builder.ts';
 import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
-import type { AnyMySqlTable } from '~/mysql-core/table.ts';
-import { MySqlColumnBuilderWithAutoIncrement, MySqlColumnWithAutoIncrement } from './common.ts';
+import type { AnySingleStoreTable } from '~/singlestore-core/table.ts';
+import { SingleStoreColumnBuilderWithAutoIncrement, SingleStoreColumnWithAutoIncrement } from './common.ts';
 
-export type MySqlDoubleBuilderInitial<TName extends string> = MySqlDoubleBuilder<{
+export type SingleStoreDoubleBuilderInitial<TName extends string> = SingleStoreDoubleBuilder<{
 	name: TName;
 	dataType: 'number';
-	columnType: 'MySqlDouble';
+	columnType: 'SingleStoreDouble';
 	data: number;
 	driverParam: number | string;
 	enumValues: undefined;
 	generated: undefined;
 }>;
 
-export class MySqlDoubleBuilder<T extends ColumnBuilderBaseConfig<'number', 'MySqlDouble'>>
-	extends MySqlColumnBuilderWithAutoIncrement<T, MySqlDoubleConfig>
+export class SingleStoreDoubleBuilder<T extends ColumnBuilderBaseConfig<'number', 'SingleStoreDouble'>>
+	extends SingleStoreColumnBuilderWithAutoIncrement<T, SingleStoreDoubleConfig>
 {
-	static readonly [entityKind]: string = 'MySqlDoubleBuilder';
+	static readonly [entityKind]: string = 'SingleStoreDoubleBuilder';
 
-	constructor(name: T['name'], config: MySqlDoubleConfig | undefined) {
-		super(name, 'number', 'MySqlDouble');
+	constructor(name: T['name'], config: SingleStoreDoubleConfig | undefined) {
+		super(name, 'number', 'SingleStoreDouble');
 		this.config.precision = config?.precision;
 		this.config.scale = config?.scale;
 	}
 
 	/** @internal */
 	override build<TTableName extends string>(
-		table: AnyMySqlTable<{ name: TTableName }>,
-	): MySqlDouble<MakeColumnConfig<T, TTableName>> {
-		return new MySqlDouble<MakeColumnConfig<T, TTableName>>(table, this.config as ColumnBuilderRuntimeConfig<any, any>);
+		table: AnySingleStoreTable<{ name: TTableName }>,
+	): SingleStoreDouble<MakeColumnConfig<T, TTableName>> {
+		return new SingleStoreDouble<MakeColumnConfig<T, TTableName>>(
+			table,
+			this.config as ColumnBuilderRuntimeConfig<any, any>,
+		);
 	}
 }
 
-export class MySqlDouble<T extends ColumnBaseConfig<'number', 'MySqlDouble'>>
-	extends MySqlColumnWithAutoIncrement<T, MySqlDoubleConfig>
+export class SingleStoreDouble<T extends ColumnBaseConfig<'number', 'SingleStoreDouble'>>
+	extends SingleStoreColumnWithAutoIncrement<T, SingleStoreDoubleConfig>
 {
-	static readonly [entityKind]: string = 'MySqlDouble';
+	static readonly [entityKind]: string = 'SingleStoreDouble';
 
 	precision: number | undefined = this.config.precision;
 	scale: number | undefined = this.config.scale;
@@ -52,14 +55,14 @@ export class MySqlDouble<T extends ColumnBaseConfig<'number', 'MySqlDouble'>>
 	}
 }
 
-export interface MySqlDoubleConfig {
+export interface SingleStoreDoubleConfig {
 	precision?: number;
 	scale?: number;
 }
 
 export function double<TName extends string>(
 	name: TName,
-	config?: MySqlDoubleConfig,
-): MySqlDoubleBuilderInitial<TName> {
-	return new MySqlDoubleBuilder(name, config);
+	config?: SingleStoreDoubleConfig,
+): SingleStoreDoubleBuilderInitial<TName> {
+	return new SingleStoreDoubleBuilder(name, config);
 }
diff --git a/drizzle-orm/src/singlestore-core/columns/enum.ts b/drizzle-orm/src/singlestore-core/columns/enum.ts
index 1d8b4c1f5..af04c50a5 100644
--- a/drizzle-orm/src/singlestore-core/columns/enum.ts
+++ b/drizzle-orm/src/singlestore-core/columns/enum.ts
@@ -1,46 +1,46 @@
 import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '~/column-builder.ts';
 import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
-import type { AnyMySqlTable } from '~/mysql-core/table.ts';
+import type { AnySingleStoreTable } from '~/singlestore-core/table.ts';
 import type { Writable } from '~/utils.ts';
-import { MySqlColumn, MySqlColumnBuilder } from './common.ts';
+import { SingleStoreColumn, SingleStoreColumnBuilder } from './common.ts';
 
-export type MySqlEnumColumnBuilderInitial<TName extends string, TEnum extends [string, ...string[]]> =
-	MySqlEnumColumnBuilder<{
+export type SingleStoreEnumColumnBuilderInitial<TName extends string, TEnum extends [string, ...string[]]> =
+	SingleStoreEnumColumnBuilder<{
 		name: TName;
 		dataType: 'string';
-		columnType: 'MySqlEnumColumn';
+		columnType: 'SingleStoreEnumColumn';
 		data: TEnum[number];
 		driverParam: string;
 		enumValues: TEnum;
 		generated: undefined;
 	}>;
 
-export class MySqlEnumColumnBuilder<T extends ColumnBuilderBaseConfig<'string', 'MySqlEnumColumn'>>
-	extends MySqlColumnBuilder<T, { enumValues: T['enumValues'] }>
+export class SingleStoreEnumColumnBuilder<T extends ColumnBuilderBaseConfig<'string', 'SingleStoreEnumColumn'>>
+	extends SingleStoreColumnBuilder<T, { enumValues: T['enumValues'] }>
 {
-	static readonly [entityKind]: string = 'MySqlEnumColumnBuilder';
+	static readonly [entityKind]: string = 'SingleStoreEnumColumnBuilder';
 
 	constructor(name: T['name'], values: T['enumValues']) {
-		super(name, 'string', 'MySqlEnumColumn');
+		super(name, 'string', 'SingleStoreEnumColumn');
 		this.config.enumValues = values;
 	}
 
 	/** @internal */
 	override build<TTableName extends string>(
-		table: AnyMySqlTable<{ name: TTableName }>,
-	): MySqlEnumColumn<MakeColumnConfig<T, TTableName> & { enumValues: T['enumValues'] }> {
-		return new MySqlEnumColumn<MakeColumnConfig<T, TTableName> & { enumValues: T['enumValues'] }>(
+		table: AnySingleStoreTable<{ name: TTableName }>,
+	): SingleStoreEnumColumn<MakeColumnConfig<T, TTableName> & { enumValues: T['enumValues'] }> {
+		return new SingleStoreEnumColumn<MakeColumnConfig<T, TTableName> & { enumValues: T['enumValues'] }>(
 			table,
 			this.config as ColumnBuilderRuntimeConfig<any, any>,
 		);
 	}
 }
 
-export class MySqlEnumColumn<T extends ColumnBaseConfig<'string', 'MySqlEnumColumn'>>
-	extends MySqlColumn<T, { enumValues: T['enumValues'] }>
+export class SingleStoreEnumColumn<T extends ColumnBaseConfig<'string', 'SingleStoreEnumColumn'>>
+	extends SingleStoreColumn<T, { enumValues: T['enumValues'] }>
 {
-	static readonly [entityKind]: string = 'MySqlEnumColumn';
+	static readonly [entityKind]: string = 'SingleStoreEnumColumn';
 
 	override readonly enumValues = this.config.enumValues;
 
@@ -49,13 +49,13 @@ export class MySqlEnumColumn<T extends ColumnBaseConfig<'string', 'MySqlEnumColu
 	}
 }
 
-export function mysqlEnum<TName extends string, U extends string, T extends Readonly<[U, ...U[]]>>(
+export function singlestoreEnum<TName extends string, U extends string, T extends Readonly<[U, ...U[]]>>(
 	name: TName,
 	values: T | Writable<T>,
-): MySqlEnumColumnBuilderInitial<TName, Writable<T>> {
+): SingleStoreEnumColumnBuilderInitial<TName, Writable<T>> {
 	if (values.length === 0) {
 		throw new Error(`You have an empty array for "${name}" enum values`);
 	}
 
-	return new MySqlEnumColumnBuilder(name, values);
+	return new SingleStoreEnumColumnBuilder(name, values);
 }
diff --git a/drizzle-orm/src/singlestore-core/columns/float.ts b/drizzle-orm/src/singlestore-core/columns/float.ts
index b66f1e05a..a54ee06a1 100644
--- a/drizzle-orm/src/singlestore-core/columns/float.ts
+++ b/drizzle-orm/src/singlestore-core/columns/float.ts
@@ -1,44 +1,49 @@
 import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '~/column-builder.ts';
 import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
-import type { AnyMySqlTable } from '~/mysql-core/table.ts';
-import { MySqlColumnBuilderWithAutoIncrement, MySqlColumnWithAutoIncrement } from './common.ts';
+import type { AnySingleStoreTable } from '~/singlestore-core/table.ts';
+import { SingleStoreColumnBuilderWithAutoIncrement, SingleStoreColumnWithAutoIncrement } from './common.ts';
 
-export type MySqlFloatBuilderInitial<TName extends string> = MySqlFloatBuilder<{
+export type SingleStoreFloatBuilderInitial<TName extends string> = SingleStoreFloatBuilder<{
 	name: TName;
 	dataType: 'number';
-	columnType: 'MySqlFloat';
+	columnType: 'SingleStoreFloat';
 	data: number;
 	driverParam: number | string;
 	enumValues: undefined;
 	generated: undefined;
 }>;
 
-export class MySqlFloatBuilder<T extends ColumnBuilderBaseConfig<'number', 'MySqlFloat'>>
-	extends MySqlColumnBuilderWithAutoIncrement<T>
+export class SingleStoreFloatBuilder<T extends ColumnBuilderBaseConfig<'number', 'SingleStoreFloat'>>
+	extends SingleStoreColumnBuilderWithAutoIncrement<T>
 {
-	static readonly [entityKind]: string = 'MySqlFloatBuilder';
+	static readonly [entityKind]: string = 'SingleStoreFloatBuilder';
 
 	constructor(name: T['name']) {
-		super(name, 'number', 'MySqlFloat');
+		super(name, 'number', 'SingleStoreFloat');
 	}
 
 	/** @internal */
 	override build<TTableName extends string>(
-		table: AnyMySqlTable<{ name: TTableName }>,
-	): MySqlFloat<MakeColumnConfig<T, TTableName>> {
-		return new MySqlFloat<MakeColumnConfig<T, TTableName>>(table, this.config as ColumnBuilderRuntimeConfig<any, any>);
+		table: AnySingleStoreTable<{ name: TTableName }>,
+	): SingleStoreFloat<MakeColumnConfig<T, TTableName>> {
+		return new SingleStoreFloat<MakeColumnConfig<T, TTableName>>(
+			table,
+			this.config as ColumnBuilderRuntimeConfig<any, any>,
+		);
 	}
 }
 
-export class MySqlFloat<T extends ColumnBaseConfig<'number', 'MySqlFloat'>> extends MySqlColumnWithAutoIncrement<T> {
-	static readonly [entityKind]: string = 'MySqlFloat';
+export class SingleStoreFloat<T extends ColumnBaseConfig<'number', 'SingleStoreFloat'>>
+	extends SingleStoreColumnWithAutoIncrement<T>
+{
+	static readonly [entityKind]: string = 'SingleStoreFloat';
 
 	getSQLType(): string {
 		return 'float';
 	}
 }
 
-export function float<TName extends string>(name: TName): MySqlFloatBuilderInitial<TName> {
-	return new MySqlFloatBuilder(name);
+export function float<TName extends string>(name: TName): SingleStoreFloatBuilderInitial<TName> {
+	return new SingleStoreFloatBuilder(name);
 }
diff --git a/drizzle-orm/src/singlestore-core/columns/int.ts b/drizzle-orm/src/singlestore-core/columns/int.ts
index dbfb85760..e9ca0a682 100644
--- a/drizzle-orm/src/singlestore-core/columns/int.ts
+++ b/drizzle-orm/src/singlestore-core/columns/int.ts
@@ -1,41 +1,44 @@
 import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '~/column-builder.ts';
 import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
-import type { AnyMySqlTable } from '~/mysql-core/table.ts';
-import { MySqlColumnBuilderWithAutoIncrement, MySqlColumnWithAutoIncrement } from './common.ts';
+import type { AnySingleStoreTable } from '~/singlestore-core/table.ts';
+import { SingleStoreColumnBuilderWithAutoIncrement, SingleStoreColumnWithAutoIncrement } from './common.ts';
 
-export type MySqlIntBuilderInitial<TName extends string> = MySqlIntBuilder<{
+export type SingleStoreIntBuilderInitial<TName extends string> = SingleStoreIntBuilder<{
 	name: TName;
 	dataType: 'number';
-	columnType: 'MySqlInt';
+	columnType: 'SingleStoreInt';
 	data: number;
 	driverParam: number | string;
 	enumValues: undefined;
 	generated: undefined;
 }>;
 
-export class MySqlIntBuilder<T extends ColumnBuilderBaseConfig<'number', 'MySqlInt'>>
-	extends MySqlColumnBuilderWithAutoIncrement<T, MySqlIntConfig>
+export class SingleStoreIntBuilder<T extends ColumnBuilderBaseConfig<'number', 'SingleStoreInt'>>
+	extends SingleStoreColumnBuilderWithAutoIncrement<T, SingleStoreIntConfig>
 {
-	static readonly [entityKind]: string = 'MySqlIntBuilder';
+	static readonly [entityKind]: string = 'SingleStoreIntBuilder';
 
-	constructor(name: T['name'], config?: MySqlIntConfig) {
-		super(name, 'number', 'MySqlInt');
+	constructor(name: T['name'], config?: SingleStoreIntConfig) {
+		super(name, 'number', 'SingleStoreInt');
 		this.config.unsigned = config ? config.unsigned : false;
 	}
 
 	/** @internal */
 	override build<TTableName extends string>(
-		table: AnyMySqlTable<{ name: TTableName }>,
-	): MySqlInt<MakeColumnConfig<T, TTableName>> {
-		return new MySqlInt<MakeColumnConfig<T, TTableName>>(table, this.config as ColumnBuilderRuntimeConfig<any, any>);
+		table: AnySingleStoreTable<{ name: TTableName }>,
+	): SingleStoreInt<MakeColumnConfig<T, TTableName>> {
+		return new SingleStoreInt<MakeColumnConfig<T, TTableName>>(
+			table,
+			this.config as ColumnBuilderRuntimeConfig<any, any>,
+		);
 	}
 }
 
-export class MySqlInt<T extends ColumnBaseConfig<'number', 'MySqlInt'>>
-	extends MySqlColumnWithAutoIncrement<T, MySqlIntConfig>
+export class SingleStoreInt<T extends ColumnBaseConfig<'number', 'SingleStoreInt'>>
+	extends SingleStoreColumnWithAutoIncrement<T, SingleStoreIntConfig>
 {
-	static readonly [entityKind]: string = 'MySqlInt';
+	static readonly [entityKind]: string = 'SingleStoreInt';
 
 	getSQLType(): string {
 		return `int${this.config.unsigned ? ' unsigned' : ''}`;
@@ -49,10 +52,13 @@ export class MySqlInt<T extends ColumnBaseConfig<'number', 'MySqlInt'>>
 	}
 }
 
-export interface MySqlIntConfig {
+export interface SingleStoreIntConfig {
 	unsigned?: boolean;
 }
 
-export function int<TName extends string>(name: TName, config?: MySqlIntConfig): MySqlIntBuilderInitial<TName> {
-	return new MySqlIntBuilder(name, config);
+export function int<TName extends string>(
+	name: TName,
+	config?: SingleStoreIntConfig,
+): SingleStoreIntBuilderInitial<TName> {
+	return new SingleStoreIntBuilder(name, config);
 }
diff --git a/drizzle-orm/src/singlestore-core/columns/json.ts b/drizzle-orm/src/singlestore-core/columns/json.ts
index f30ea1534..0b069f256 100644
--- a/drizzle-orm/src/singlestore-core/columns/json.ts
+++ b/drizzle-orm/src/singlestore-core/columns/json.ts
@@ -1,36 +1,41 @@
 import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '~/column-builder.ts';
 import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
-import type { AnyMySqlTable } from '~/mysql-core/table.ts';
-import { MySqlColumn, MySqlColumnBuilder } from './common.ts';
+import type { AnySingleStoreTable } from '~/singlestore-core/table.ts';
+import { SingleStoreColumn, SingleStoreColumnBuilder } from './common.ts';
 
-export type MySqlJsonBuilderInitial<TName extends string> = MySqlJsonBuilder<{
+export type SingleStoreJsonBuilderInitial<TName extends string> = SingleStoreJsonBuilder<{
 	name: TName;
 	dataType: 'json';
-	columnType: 'MySqlJson';
+	columnType: 'SingleStoreJson';
 	data: unknown;
 	driverParam: string;
 	enumValues: undefined;
 	generated: undefined;
 }>;
 
-export class MySqlJsonBuilder<T extends ColumnBuilderBaseConfig<'json', 'MySqlJson'>> extends MySqlColumnBuilder<T> {
-	static readonly [entityKind]: string = 'MySqlJsonBuilder';
+export class SingleStoreJsonBuilder<T extends ColumnBuilderBaseConfig<'json', 'SingleStoreJson'>>
+	extends SingleStoreColumnBuilder<T>
+{
+	static readonly [entityKind]: string = 'SingleStoreJsonBuilder';
 
 	constructor(name: T['name']) {
-		super(name, 'json', 'MySqlJson');
+		super(name, 'json', 'SingleStoreJson');
 	}
 
 	/** @internal */
 	override build<TTableName extends string>(
-		table: AnyMySqlTable<{ name: TTableName }>,
-	): MySqlJson<MakeColumnConfig<T, TTableName>> {
-		return new MySqlJson<MakeColumnConfig<T, TTableName>>(table, this.config as ColumnBuilderRuntimeConfig<any, any>);
+		table: AnySingleStoreTable<{ name: TTableName }>,
+	): SingleStoreJson<MakeColumnConfig<T, TTableName>> {
+		return new SingleStoreJson<MakeColumnConfig<T, TTableName>>(
+			table,
+			this.config as ColumnBuilderRuntimeConfig<any, any>,
+		);
 	}
 }
 
-export class MySqlJson<T extends ColumnBaseConfig<'json', 'MySqlJson'>> extends MySqlColumn<T> {
-	static readonly [entityKind]: string = 'MySqlJson';
+export class SingleStoreJson<T extends ColumnBaseConfig<'json', 'SingleStoreJson'>> extends SingleStoreColumn<T> {
+	static readonly [entityKind]: string = 'SingleStoreJson';
 
 	getSQLType(): string {
 		return 'json';
@@ -41,6 +46,6 @@ export class MySqlJson<T extends ColumnBaseConfig<'json', 'MySqlJson'>> extends
 	}
 }
 
-export function json<TName extends string>(name: TName): MySqlJsonBuilderInitial<TName> {
-	return new MySqlJsonBuilder(name);
+export function json<TName extends string>(name: TName): SingleStoreJsonBuilderInitial<TName> {
+	return new SingleStoreJsonBuilder(name);
 }
diff --git a/drizzle-orm/src/singlestore-core/columns/mediumint.ts b/drizzle-orm/src/singlestore-core/columns/mediumint.ts
index 268028b44..b963ee6e5 100644
--- a/drizzle-orm/src/singlestore-core/columns/mediumint.ts
+++ b/drizzle-orm/src/singlestore-core/columns/mediumint.ts
@@ -1,45 +1,45 @@
 import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '~/column-builder.ts';
 import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
-import type { AnyMySqlTable } from '~/mysql-core/table.ts';
-import { MySqlColumnBuilderWithAutoIncrement, MySqlColumnWithAutoIncrement } from './common.ts';
-import type { MySqlIntConfig } from './int.ts';
+import type { AnySingleStoreTable } from '~/singlestore-core/table.ts';
+import { SingleStoreColumnBuilderWithAutoIncrement, SingleStoreColumnWithAutoIncrement } from './common.ts';
+import type { SingleStoreIntConfig } from './int.ts';
 
-export type MySqlMediumIntBuilderInitial<TName extends string> = MySqlMediumIntBuilder<{
+export type SingleStoreMediumIntBuilderInitial<TName extends string> = SingleStoreMediumIntBuilder<{
 	name: TName;
 	dataType: 'number';
-	columnType: 'MySqlMediumInt';
+	columnType: 'SingleStoreMediumInt';
 	data: number;
 	driverParam: number | string;
 	enumValues: undefined;
 	generated: undefined;
 }>;
 
-export class MySqlMediumIntBuilder<T extends ColumnBuilderBaseConfig<'number', 'MySqlMediumInt'>>
-	extends MySqlColumnBuilderWithAutoIncrement<T, MySqlIntConfig>
+export class SingleStoreMediumIntBuilder<T extends ColumnBuilderBaseConfig<'number', 'SingleStoreMediumInt'>>
+	extends SingleStoreColumnBuilderWithAutoIncrement<T, SingleStoreIntConfig>
 {
-	static readonly [entityKind]: string = 'MySqlMediumIntBuilder';
+	static readonly [entityKind]: string = 'SingleStoreMediumIntBuilder';
 
-	constructor(name: T['name'], config?: MySqlIntConfig) {
-		super(name, 'number', 'MySqlMediumInt');
+	constructor(name: T['name'], config?: SingleStoreIntConfig) {
+		super(name, 'number', 'SingleStoreMediumInt');
 		this.config.unsigned = config ? config.unsigned : false;
 	}
 
 	/** @internal */
 	override build<TTableName extends string>(
-		table: AnyMySqlTable<{ name: TTableName }>,
-	): MySqlMediumInt<MakeColumnConfig<T, TTableName>> {
-		return new MySqlMediumInt<MakeColumnConfig<T, TTableName>>(
+		table: AnySingleStoreTable<{ name: TTableName }>,
+	): SingleStoreMediumInt<MakeColumnConfig<T, TTableName>> {
+		return new SingleStoreMediumInt<MakeColumnConfig<T, TTableName>>(
 			table,
 			this.config as ColumnBuilderRuntimeConfig<any, any>,
 		);
 	}
 }
 
-export class MySqlMediumInt<T extends ColumnBaseConfig<'number', 'MySqlMediumInt'>>
-	extends MySqlColumnWithAutoIncrement<T, MySqlIntConfig>
+export class SingleStoreMediumInt<T extends ColumnBaseConfig<'number', 'SingleStoreMediumInt'>>
+	extends SingleStoreColumnWithAutoIncrement<T, SingleStoreIntConfig>
 {
-	static readonly [entityKind]: string = 'MySqlMediumInt';
+	static readonly [entityKind]: string = 'SingleStoreMediumInt';
 
 	getSQLType(): string {
 		return `mediumint${this.config.unsigned ? ' unsigned' : ''}`;
@@ -55,7 +55,7 @@ export class MySqlMediumInt<T extends ColumnBaseConfig<'number', 'MySqlMediumInt
 
 export function mediumint<TName extends string>(
 	name: TName,
-	config?: MySqlIntConfig,
-): MySqlMediumIntBuilderInitial<TName> {
-	return new MySqlMediumIntBuilder(name, config);
+	config?: SingleStoreIntConfig,
+): SingleStoreMediumIntBuilderInitial<TName> {
+	return new SingleStoreMediumIntBuilder(name, config);
 }
diff --git a/drizzle-orm/src/singlestore-core/columns/real.ts b/drizzle-orm/src/singlestore-core/columns/real.ts
index 7dd41dda0..cc66f6c56 100644
--- a/drizzle-orm/src/singlestore-core/columns/real.ts
+++ b/drizzle-orm/src/singlestore-core/columns/real.ts
@@ -1,46 +1,51 @@
 import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '~/column-builder.ts';
 import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
-import type { AnyMySqlTable } from '~/mysql-core/table.ts';
-import { MySqlColumnBuilderWithAutoIncrement, MySqlColumnWithAutoIncrement } from './common.ts';
+import type { AnySingleStoreTable } from '~/singlestore-core/table.ts';
+import { SingleStoreColumnBuilderWithAutoIncrement, SingleStoreColumnWithAutoIncrement } from './common.ts';
 
-export type MySqlRealBuilderInitial<TName extends string> = MySqlRealBuilder<{
+export type SingleStoreRealBuilderInitial<TName extends string> = SingleStoreRealBuilder<{
 	name: TName;
 	dataType: 'number';
-	columnType: 'MySqlReal';
+	columnType: 'SingleStoreReal';
 	data: number;
 	driverParam: number | string;
 	enumValues: undefined;
 	generated: undefined;
 }>;
 
-export class MySqlRealBuilder<T extends ColumnBuilderBaseConfig<'number', 'MySqlReal'>>
-	extends MySqlColumnBuilderWithAutoIncrement<
+export class SingleStoreRealBuilder<T extends ColumnBuilderBaseConfig<'number', 'SingleStoreReal'>>
+	extends SingleStoreColumnBuilderWithAutoIncrement<
 		T,
-		MySqlRealConfig
+		SingleStoreRealConfig
 	>
 {
-	static readonly [entityKind]: string = 'MySqlRealBuilder';
+	static readonly [entityKind]: string = 'SingleStoreRealBuilder';
 
-	constructor(name: T['name'], config: MySqlRealConfig | undefined) {
-		super(name, 'number', 'MySqlReal');
+	constructor(name: T['name'], config: SingleStoreRealConfig | undefined) {
+		super(name, 'number', 'SingleStoreReal');
 		this.config.precision = config?.precision;
 		this.config.scale = config?.scale;
 	}
 
 	/** @internal */
 	override build<TTableName extends string>(
-		table: AnyMySqlTable<{ name: TTableName }>,
-	): MySqlReal<MakeColumnConfig<T, TTableName>> {
-		return new MySqlReal<MakeColumnConfig<T, TTableName>>(table, this.config as ColumnBuilderRuntimeConfig<any, any>);
+		table: AnySingleStoreTable<{ name: TTableName }>,
+	): SingleStoreReal<MakeColumnConfig<T, TTableName>> {
+		return new SingleStoreReal<MakeColumnConfig<T, TTableName>>(
+			table,
+			this.config as ColumnBuilderRuntimeConfig<any, any>,
+		);
 	}
 }
 
-export class MySqlReal<T extends ColumnBaseConfig<'number', 'MySqlReal'>> extends MySqlColumnWithAutoIncrement<
-	T,
-	MySqlRealConfig
-> {
-	static readonly [entityKind]: string = 'MySqlReal';
+export class SingleStoreReal<T extends ColumnBaseConfig<'number', 'SingleStoreReal'>>
+	extends SingleStoreColumnWithAutoIncrement<
+		T,
+		SingleStoreRealConfig
+	>
+{
+	static readonly [entityKind]: string = 'SingleStoreReal';
 
 	precision: number | undefined = this.config.precision;
 	scale: number | undefined = this.config.scale;
@@ -56,11 +61,14 @@ export class MySqlReal<T extends ColumnBaseConfig<'number', 'MySqlReal'>> extend
 	}
 }
 
-export interface MySqlRealConfig {
+export interface SingleStoreRealConfig {
 	precision?: number;
 	scale?: number;
 }
 
-export function real<TName extends string>(name: TName, config: MySqlRealConfig = {}): MySqlRealBuilderInitial<TName> {
-	return new MySqlRealBuilder(name, config);
+export function real<TName extends string>(
+	name: TName,
+	config: SingleStoreRealConfig = {},
+): SingleStoreRealBuilderInitial<TName> {
+	return new SingleStoreRealBuilder(name, config);
 }
diff --git a/drizzle-orm/src/singlestore-core/columns/serial.ts b/drizzle-orm/src/singlestore-core/columns/serial.ts
index 0f87f0bf5..30fb7a40e 100644
--- a/drizzle-orm/src/singlestore-core/columns/serial.ts
+++ b/drizzle-orm/src/singlestore-core/columns/serial.ts
@@ -9,17 +9,17 @@ import type {
 } from '~/column-builder.ts';
 import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
-import type { AnyMySqlTable } from '~/mysql-core/table.ts';
-import { MySqlColumnBuilderWithAutoIncrement, MySqlColumnWithAutoIncrement } from './common.ts';
+import type { AnySingleStoreTable } from '~/singlestore-core/table.ts';
+import { SingleStoreColumnBuilderWithAutoIncrement, SingleStoreColumnWithAutoIncrement } from './common.ts';
 
-export type MySqlSerialBuilderInitial<TName extends string> = IsAutoincrement<
+export type SingleStoreSerialBuilderInitial<TName extends string> = IsAutoincrement<
 	IsPrimaryKey<
 		NotNull<
 			HasDefault<
-				MySqlSerialBuilder<{
+				SingleStoreSerialBuilder<{
 					name: TName;
 					dataType: 'number';
-					columnType: 'MySqlSerial';
+					columnType: 'SingleStoreSerial';
 					data: number;
 					driverParam: number;
 					enumValues: undefined;
@@ -30,29 +30,32 @@ export type MySqlSerialBuilderInitial<TName extends string> = IsAutoincrement<
 	>
 >;
 
-export class MySqlSerialBuilder<T extends ColumnBuilderBaseConfig<'number', 'MySqlSerial'>>
-	extends MySqlColumnBuilderWithAutoIncrement<T>
+export class SingleStoreSerialBuilder<T extends ColumnBuilderBaseConfig<'number', 'SingleStoreSerial'>>
+	extends SingleStoreColumnBuilderWithAutoIncrement<T>
 {
-	static readonly [entityKind]: string = 'MySqlSerialBuilder';
+	static readonly [entityKind]: string = 'SingleStoreSerialBuilder';
 
 	constructor(name: T['name']) {
-		super(name, 'number', 'MySqlSerial');
+		super(name, 'number', 'SingleStoreSerial');
 		this.config.hasDefault = true;
 		this.config.autoIncrement = true;
 	}
 
 	/** @internal */
 	override build<TTableName extends string>(
-		table: AnyMySqlTable<{ name: TTableName }>,
-	): MySqlSerial<MakeColumnConfig<T, TTableName>> {
-		return new MySqlSerial<MakeColumnConfig<T, TTableName>>(table, this.config as ColumnBuilderRuntimeConfig<any, any>);
+		table: AnySingleStoreTable<{ name: TTableName }>,
+	): SingleStoreSerial<MakeColumnConfig<T, TTableName>> {
+		return new SingleStoreSerial<MakeColumnConfig<T, TTableName>>(
+			table,
+			this.config as ColumnBuilderRuntimeConfig<any, any>,
+		);
 	}
 }
 
-export class MySqlSerial<
-	T extends ColumnBaseConfig<'number', 'MySqlSerial'>,
-> extends MySqlColumnWithAutoIncrement<T> {
-	static readonly [entityKind]: string = 'MySqlSerial';
+export class SingleStoreSerial<
+	T extends ColumnBaseConfig<'number', 'SingleStoreSerial'>,
+> extends SingleStoreColumnWithAutoIncrement<T> {
+	static readonly [entityKind]: string = 'SingleStoreSerial';
 
 	getSQLType(): string {
 		return 'serial';
@@ -66,6 +69,6 @@ export class MySqlSerial<
 	}
 }
 
-export function serial<TName extends string>(name: TName): MySqlSerialBuilderInitial<TName> {
-	return new MySqlSerialBuilder(name) as MySqlSerialBuilderInitial<TName>;
+export function serial<TName extends string>(name: TName): SingleStoreSerialBuilderInitial<TName> {
+	return new SingleStoreSerialBuilder(name) as SingleStoreSerialBuilderInitial<TName>;
 }
diff --git a/drizzle-orm/src/singlestore-core/columns/smallint.ts b/drizzle-orm/src/singlestore-core/columns/smallint.ts
index fc1dd0d55..02e172608 100644
--- a/drizzle-orm/src/singlestore-core/columns/smallint.ts
+++ b/drizzle-orm/src/singlestore-core/columns/smallint.ts
@@ -1,45 +1,45 @@
 import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '~/column-builder.ts';
 import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
-import type { AnyMySqlTable } from '~/mysql-core/table.ts';
-import { MySqlColumnBuilderWithAutoIncrement, MySqlColumnWithAutoIncrement } from './common.ts';
-import type { MySqlIntConfig } from './int.ts';
+import type { AnySingleStoreTable } from '~/singlestore-core/table.ts';
+import { SingleStoreColumnBuilderWithAutoIncrement, SingleStoreColumnWithAutoIncrement } from './common.ts';
+import type { SingleStoreIntConfig } from './int.ts';
 
-export type MySqlSmallIntBuilderInitial<TName extends string> = MySqlSmallIntBuilder<{
+export type SingleStoreSmallIntBuilderInitial<TName extends string> = SingleStoreSmallIntBuilder<{
 	name: TName;
 	dataType: 'number';
-	columnType: 'MySqlSmallInt';
+	columnType: 'SingleStoreSmallInt';
 	data: number;
 	driverParam: number | string;
 	enumValues: undefined;
 	generated: undefined;
 }>;
 
-export class MySqlSmallIntBuilder<T extends ColumnBuilderBaseConfig<'number', 'MySqlSmallInt'>>
-	extends MySqlColumnBuilderWithAutoIncrement<T, MySqlIntConfig>
+export class SingleStoreSmallIntBuilder<T extends ColumnBuilderBaseConfig<'number', 'SingleStoreSmallInt'>>
+	extends SingleStoreColumnBuilderWithAutoIncrement<T, SingleStoreIntConfig>
 {
-	static readonly [entityKind]: string = 'MySqlSmallIntBuilder';
+	static readonly [entityKind]: string = 'SingleStoreSmallIntBuilder';
 
-	constructor(name: T['name'], config?: MySqlIntConfig) {
-		super(name, 'number', 'MySqlSmallInt');
+	constructor(name: T['name'], config?: SingleStoreIntConfig) {
+		super(name, 'number', 'SingleStoreSmallInt');
 		this.config.unsigned = config ? config.unsigned : false;
 	}
 
 	/** @internal */
 	override build<TTableName extends string>(
-		table: AnyMySqlTable<{ name: TTableName }>,
-	): MySqlSmallInt<MakeColumnConfig<T, TTableName>> {
-		return new MySqlSmallInt<MakeColumnConfig<T, TTableName>>(
+		table: AnySingleStoreTable<{ name: TTableName }>,
+	): SingleStoreSmallInt<MakeColumnConfig<T, TTableName>> {
+		return new SingleStoreSmallInt<MakeColumnConfig<T, TTableName>>(
 			table,
 			this.config as ColumnBuilderRuntimeConfig<any, any>,
 		);
 	}
 }
 
-export class MySqlSmallInt<T extends ColumnBaseConfig<'number', 'MySqlSmallInt'>>
-	extends MySqlColumnWithAutoIncrement<T, MySqlIntConfig>
+export class SingleStoreSmallInt<T extends ColumnBaseConfig<'number', 'SingleStoreSmallInt'>>
+	extends SingleStoreColumnWithAutoIncrement<T, SingleStoreIntConfig>
 {
-	static readonly [entityKind]: string = 'MySqlSmallInt';
+	static readonly [entityKind]: string = 'SingleStoreSmallInt';
 
 	getSQLType(): string {
 		return `smallint${this.config.unsigned ? ' unsigned' : ''}`;
@@ -55,7 +55,7 @@ export class MySqlSmallInt<T extends ColumnBaseConfig<'number', 'MySqlSmallInt'>
 
 export function smallint<TName extends string>(
 	name: TName,
-	config?: MySqlIntConfig,
-): MySqlSmallIntBuilderInitial<TName> {
-	return new MySqlSmallIntBuilder(name, config);
+	config?: SingleStoreIntConfig,
+): SingleStoreSmallIntBuilderInitial<TName> {
+	return new SingleStoreSmallIntBuilder(name, config);
 }
diff --git a/drizzle-orm/src/singlestore-core/columns/text.ts b/drizzle-orm/src/singlestore-core/columns/text.ts
index 72c232e16..8c40039f0 100644
--- a/drizzle-orm/src/singlestore-core/columns/text.ts
+++ b/drizzle-orm/src/singlestore-core/columns/text.ts
@@ -1,48 +1,54 @@
 import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '~/column-builder.ts';
 import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
-import type { AnyMySqlTable } from '~/mysql-core/table.ts';
+import type { AnySingleStoreTable } from '~/singlestore-core/table.ts';
 import type { Writable } from '~/utils.ts';
-import { MySqlColumn, MySqlColumnBuilder } from './common.ts';
+import { SingleStoreColumn, SingleStoreColumnBuilder } from './common.ts';
 
-export type MySqlTextColumnType = 'tinytext' | 'text' | 'mediumtext' | 'longtext';
+export type SingleStoreTextColumnType = 'tinytext' | 'text' | 'mediumtext' | 'longtext';
 
-export type MySqlTextBuilderInitial<TName extends string, TEnum extends [string, ...string[]]> = MySqlTextBuilder<{
-	name: TName;
-	dataType: 'string';
-	columnType: 'MySqlText';
-	data: TEnum[number];
-	driverParam: string;
-	enumValues: TEnum;
-	generated: undefined;
-}>;
+export type SingleStoreTextBuilderInitial<TName extends string, TEnum extends [string, ...string[]]> =
+	SingleStoreTextBuilder<{
+		name: TName;
+		dataType: 'string';
+		columnType: 'SingleStoreText';
+		data: TEnum[number];
+		driverParam: string;
+		enumValues: TEnum;
+		generated: undefined;
+	}>;
 
-export class MySqlTextBuilder<T extends ColumnBuilderBaseConfig<'string', 'MySqlText'>> extends MySqlColumnBuilder<
-	T,
-	{ textType: MySqlTextColumnType; enumValues: T['enumValues'] }
-> {
-	static readonly [entityKind]: string = 'MySqlTextBuilder';
+export class SingleStoreTextBuilder<T extends ColumnBuilderBaseConfig<'string', 'SingleStoreText'>>
+	extends SingleStoreColumnBuilder<
+		T,
+		{ textType: SingleStoreTextColumnType; enumValues: T['enumValues'] }
+	>
+{
+	static readonly [entityKind]: string = 'SingleStoreTextBuilder';
 
-	constructor(name: T['name'], textType: MySqlTextColumnType, config: MySqlTextConfig<T['enumValues']>) {
-		super(name, 'string', 'MySqlText');
+	constructor(name: T['name'], textType: SingleStoreTextColumnType, config: SingleStoreTextConfig<T['enumValues']>) {
+		super(name, 'string', 'SingleStoreText');
 		this.config.textType = textType;
 		this.config.enumValues = config.enum;
 	}
 
 	/** @internal */
 	override build<TTableName extends string>(
-		table: AnyMySqlTable<{ name: TTableName }>,
-	): MySqlText<MakeColumnConfig<T, TTableName>> {
-		return new MySqlText<MakeColumnConfig<T, TTableName>>(table, this.config as ColumnBuilderRuntimeConfig<any, any>);
+		table: AnySingleStoreTable<{ name: TTableName }>,
+	): SingleStoreText<MakeColumnConfig<T, TTableName>> {
+		return new SingleStoreText<MakeColumnConfig<T, TTableName>>(
+			table,
+			this.config as ColumnBuilderRuntimeConfig<any, any>,
+		);
 	}
 }
 
-export class MySqlText<T extends ColumnBaseConfig<'string', 'MySqlText'>>
-	extends MySqlColumn<T, { textType: MySqlTextColumnType; enumValues: T['enumValues'] }>
+export class SingleStoreText<T extends ColumnBaseConfig<'string', 'SingleStoreText'>>
+	extends SingleStoreColumn<T, { textType: SingleStoreTextColumnType; enumValues: T['enumValues'] }>
 {
-	static readonly [entityKind]: string = 'MySqlText';
+	static readonly [entityKind]: string = 'SingleStoreText';
 
-	private textType: MySqlTextColumnType = this.config.textType;
+	private textType: SingleStoreTextColumnType = this.config.textType;
 
 	override readonly enumValues = this.config.enumValues;
 
@@ -51,34 +57,34 @@ export class MySqlText<T extends ColumnBaseConfig<'string', 'MySqlText'>>
 	}
 }
 
-export interface MySqlTextConfig<TEnum extends readonly string[] | string[] | undefined> {
+export interface SingleStoreTextConfig<TEnum extends readonly string[] | string[] | undefined> {
 	enum?: TEnum;
 }
 
 export function text<TName extends string, U extends string, T extends Readonly<[U, ...U[]]>>(
 	name: TName,
-	config: MySqlTextConfig<T | Writable<T>> = {},
-): MySqlTextBuilderInitial<TName, Writable<T>> {
-	return new MySqlTextBuilder(name, 'text', config);
+	config: SingleStoreTextConfig<T | Writable<T>> = {},
+): SingleStoreTextBuilderInitial<TName, Writable<T>> {
+	return new SingleStoreTextBuilder(name, 'text', config);
 }
 
 export function tinytext<TName extends string, U extends string, T extends Readonly<[U, ...U[]]>>(
 	name: TName,
-	config: MySqlTextConfig<T | Writable<T>> = {},
-): MySqlTextBuilderInitial<TName, Writable<T>> {
-	return new MySqlTextBuilder(name, 'tinytext', config);
+	config: SingleStoreTextConfig<T | Writable<T>> = {},
+): SingleStoreTextBuilderInitial<TName, Writable<T>> {
+	return new SingleStoreTextBuilder(name, 'tinytext', config);
 }
 
 export function mediumtext<TName extends string, U extends string, T extends Readonly<[U, ...U[]]>>(
 	name: TName,
-	config: MySqlTextConfig<T | Writable<T>> = {},
-): MySqlTextBuilderInitial<TName, Writable<T>> {
-	return new MySqlTextBuilder(name, 'mediumtext', config);
+	config: SingleStoreTextConfig<T | Writable<T>> = {},
+): SingleStoreTextBuilderInitial<TName, Writable<T>> {
+	return new SingleStoreTextBuilder(name, 'mediumtext', config);
 }
 
 export function longtext<TName extends string, U extends string, T extends Readonly<[U, ...U[]]>>(
 	name: TName,
-	config: MySqlTextConfig<T | Writable<T>> = {},
-): MySqlTextBuilderInitial<TName, Writable<T>> {
-	return new MySqlTextBuilder(name, 'longtext', config);
+	config: SingleStoreTextConfig<T | Writable<T>> = {},
+): SingleStoreTextBuilderInitial<TName, Writable<T>> {
+	return new SingleStoreTextBuilder(name, 'longtext', config);
 }
diff --git a/drizzle-orm/src/singlestore-core/columns/time.ts b/drizzle-orm/src/singlestore-core/columns/time.ts
index ae2251bda..a5259adbb 100644
--- a/drizzle-orm/src/singlestore-core/columns/time.ts
+++ b/drizzle-orm/src/singlestore-core/columns/time.ts
@@ -1,45 +1,50 @@
 import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '~/column-builder.ts';
 import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
-import type { AnyMySqlTable } from '~/mysql-core/table.ts';
-import { MySqlColumn, MySqlColumnBuilder } from './common.ts';
+import type { AnySingleStoreTable } from '~/singlestore-core/table.ts';
+import { SingleStoreColumn, SingleStoreColumnBuilder } from './common.ts';
 
-export type MySqlTimeBuilderInitial<TName extends string> = MySqlTimeBuilder<{
+export type SingleStoreTimeBuilderInitial<TName extends string> = SingleStoreTimeBuilder<{
 	name: TName;
 	dataType: 'string';
-	columnType: 'MySqlTime';
+	columnType: 'SingleStoreTime';
 	data: string;
 	driverParam: string | number;
 	enumValues: undefined;
 	generated: undefined;
 }>;
 
-export class MySqlTimeBuilder<T extends ColumnBuilderBaseConfig<'string', 'MySqlTime'>> extends MySqlColumnBuilder<
-	T,
-	TimeConfig
-> {
-	static readonly [entityKind]: string = 'MySqlTimeBuilder';
+export class SingleStoreTimeBuilder<T extends ColumnBuilderBaseConfig<'string', 'SingleStoreTime'>>
+	extends SingleStoreColumnBuilder<
+		T,
+		TimeConfig
+	>
+{
+	static readonly [entityKind]: string = 'SingleStoreTimeBuilder';
 
 	constructor(
 		name: T['name'],
 		config: TimeConfig | undefined,
 	) {
-		super(name, 'string', 'MySqlTime');
+		super(name, 'string', 'SingleStoreTime');
 		this.config.fsp = config?.fsp;
 	}
 
 	/** @internal */
 	override build<TTableName extends string>(
-		table: AnyMySqlTable<{ name: TTableName }>,
-	): MySqlTime<MakeColumnConfig<T, TTableName>> {
-		return new MySqlTime<MakeColumnConfig<T, TTableName>>(table, this.config as ColumnBuilderRuntimeConfig<any, any>);
+		table: AnySingleStoreTable<{ name: TTableName }>,
+	): SingleStoreTime<MakeColumnConfig<T, TTableName>> {
+		return new SingleStoreTime<MakeColumnConfig<T, TTableName>>(
+			table,
+			this.config as ColumnBuilderRuntimeConfig<any, any>,
+		);
 	}
 }
 
-export class MySqlTime<
-	T extends ColumnBaseConfig<'string', 'MySqlTime'>,
-> extends MySqlColumn<T, TimeConfig> {
-	static readonly [entityKind]: string = 'MySqlTime';
+export class SingleStoreTime<
+	T extends ColumnBaseConfig<'string', 'SingleStoreTime'>,
+> extends SingleStoreColumn<T, TimeConfig> {
+	static readonly [entityKind]: string = 'SingleStoreTime';
 
 	readonly fsp: number | undefined = this.config.fsp;
 
@@ -53,6 +58,6 @@ export type TimeConfig = {
 	fsp?: 0 | 1 | 2 | 3 | 4 | 5 | 6;
 };
 
-export function time<TName extends string>(name: TName, config?: TimeConfig): MySqlTimeBuilderInitial<TName> {
-	return new MySqlTimeBuilder(name, config);
+export function time<TName extends string>(name: TName, config?: TimeConfig): SingleStoreTimeBuilderInitial<TName> {
+	return new SingleStoreTimeBuilder(name, config);
 }
diff --git a/drizzle-orm/src/singlestore-core/columns/timestamp.ts b/drizzle-orm/src/singlestore-core/columns/timestamp.ts
index 24e3b2650..db770b6c7 100644
--- a/drizzle-orm/src/singlestore-core/columns/timestamp.ts
+++ b/drizzle-orm/src/singlestore-core/columns/timestamp.ts
@@ -1,45 +1,45 @@
 import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '~/column-builder.ts';
 import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
-import type { AnyMySqlTable } from '~/mysql-core/table.ts';
+import type { AnySingleStoreTable } from '~/singlestore-core/table.ts';
 import type { Equal } from '~/utils.ts';
-import { MySqlDateBaseColumn, MySqlDateColumnBaseBuilder } from './date.common.ts';
+import { SingleStoreDateBaseColumn, SingleStoreDateColumnBaseBuilder } from './date.common.ts';
 
-export type MySqlTimestampBuilderInitial<TName extends string> = MySqlTimestampBuilder<{
+export type SingleStoreTimestampBuilderInitial<TName extends string> = SingleStoreTimestampBuilder<{
 	name: TName;
 	dataType: 'date';
-	columnType: 'MySqlTimestamp';
+	columnType: 'SingleStoreTimestamp';
 	data: Date;
 	driverParam: string | number;
 	enumValues: undefined;
 	generated: undefined;
 }>;
 
-export class MySqlTimestampBuilder<T extends ColumnBuilderBaseConfig<'date', 'MySqlTimestamp'>>
-	extends MySqlDateColumnBaseBuilder<T, MySqlTimestampConfig>
+export class SingleStoreTimestampBuilder<T extends ColumnBuilderBaseConfig<'date', 'SingleStoreTimestamp'>>
+	extends SingleStoreDateColumnBaseBuilder<T, SingleStoreTimestampConfig>
 {
-	static readonly [entityKind]: string = 'MySqlTimestampBuilder';
+	static readonly [entityKind]: string = 'SingleStoreTimestampBuilder';
 
-	constructor(name: T['name'], config: MySqlTimestampConfig | undefined) {
-		super(name, 'date', 'MySqlTimestamp');
+	constructor(name: T['name'], config: SingleStoreTimestampConfig | undefined) {
+		super(name, 'date', 'SingleStoreTimestamp');
 		this.config.fsp = config?.fsp;
 	}
 
 	/** @internal */
 	override build<TTableName extends string>(
-		table: AnyMySqlTable<{ name: TTableName }>,
-	): MySqlTimestamp<MakeColumnConfig<T, TTableName>> {
-		return new MySqlTimestamp<MakeColumnConfig<T, TTableName>>(
+		table: AnySingleStoreTable<{ name: TTableName }>,
+	): SingleStoreTimestamp<MakeColumnConfig<T, TTableName>> {
+		return new SingleStoreTimestamp<MakeColumnConfig<T, TTableName>>(
 			table,
 			this.config as ColumnBuilderRuntimeConfig<any, any>,
 		);
 	}
 }
 
-export class MySqlTimestamp<T extends ColumnBaseConfig<'date', 'MySqlTimestamp'>>
-	extends MySqlDateBaseColumn<T, MySqlTimestampConfig>
+export class SingleStoreTimestamp<T extends ColumnBaseConfig<'date', 'SingleStoreTimestamp'>>
+	extends SingleStoreDateBaseColumn<T, SingleStoreTimestampConfig>
 {
-	static readonly [entityKind]: string = 'MySqlTimestamp';
+	static readonly [entityKind]: string = 'SingleStoreTimestamp';
 
 	readonly fsp: number | undefined = this.config.fsp;
 
@@ -57,41 +57,41 @@ export class MySqlTimestamp<T extends ColumnBaseConfig<'date', 'MySqlTimestamp'>
 	}
 }
 
-export type MySqlTimestampStringBuilderInitial<TName extends string> = MySqlTimestampStringBuilder<{
+export type SingleStoreTimestampStringBuilderInitial<TName extends string> = SingleStoreTimestampStringBuilder<{
 	name: TName;
 	dataType: 'string';
-	columnType: 'MySqlTimestampString';
+	columnType: 'SingleStoreTimestampString';
 	data: string;
 	driverParam: string | number;
 	enumValues: undefined;
 	generated: undefined;
 }>;
 
-export class MySqlTimestampStringBuilder<T extends ColumnBuilderBaseConfig<'string', 'MySqlTimestampString'>>
-	extends MySqlDateColumnBaseBuilder<T, MySqlTimestampConfig>
-{
-	static readonly [entityKind]: string = 'MySqlTimestampStringBuilder';
+export class SingleStoreTimestampStringBuilder<
+	T extends ColumnBuilderBaseConfig<'string', 'SingleStoreTimestampString'>,
+> extends SingleStoreDateColumnBaseBuilder<T, SingleStoreTimestampConfig> {
+	static readonly [entityKind]: string = 'SingleStoreTimestampStringBuilder';
 
-	constructor(name: T['name'], config: MySqlTimestampConfig | undefined) {
-		super(name, 'string', 'MySqlTimestampString');
+	constructor(name: T['name'], config: SingleStoreTimestampConfig | undefined) {
+		super(name, 'string', 'SingleStoreTimestampString');
 		this.config.fsp = config?.fsp;
 	}
 
 	/** @internal */
 	override build<TTableName extends string>(
-		table: AnyMySqlTable<{ name: TTableName }>,
-	): MySqlTimestampString<MakeColumnConfig<T, TTableName>> {
-		return new MySqlTimestampString<MakeColumnConfig<T, TTableName>>(
+		table: AnySingleStoreTable<{ name: TTableName }>,
+	): SingleStoreTimestampString<MakeColumnConfig<T, TTableName>> {
+		return new SingleStoreTimestampString<MakeColumnConfig<T, TTableName>>(
 			table,
 			this.config as ColumnBuilderRuntimeConfig<any, any>,
 		);
 	}
 }
 
-export class MySqlTimestampString<T extends ColumnBaseConfig<'string', 'MySqlTimestampString'>>
-	extends MySqlDateBaseColumn<T, MySqlTimestampConfig>
+export class SingleStoreTimestampString<T extends ColumnBaseConfig<'string', 'SingleStoreTimestampString'>>
+	extends SingleStoreDateBaseColumn<T, SingleStoreTimestampConfig>
 {
-	static readonly [entityKind]: string = 'MySqlTimestampString';
+	static readonly [entityKind]: string = 'SingleStoreTimestampString';
 
 	readonly fsp: number | undefined = this.config.fsp;
 
@@ -103,19 +103,19 @@ export class MySqlTimestampString<T extends ColumnBaseConfig<'string', 'MySqlTim
 
 export type TimestampFsp = 0 | 1 | 2 | 3 | 4 | 5 | 6;
 
-export interface MySqlTimestampConfig<TMode extends 'string' | 'date' = 'string' | 'date'> {
+export interface SingleStoreTimestampConfig<TMode extends 'string' | 'date' = 'string' | 'date'> {
 	mode?: TMode;
 	fsp?: TimestampFsp;
 }
 
-export function timestamp<TName extends string, TMode extends MySqlTimestampConfig['mode'] & {}>(
+export function timestamp<TName extends string, TMode extends SingleStoreTimestampConfig['mode'] & {}>(
 	name: TName,
-	config?: MySqlTimestampConfig<TMode>,
-): Equal<TMode, 'string'> extends true ? MySqlTimestampStringBuilderInitial<TName>
-	: MySqlTimestampBuilderInitial<TName>;
-export function timestamp(name: string, config: MySqlTimestampConfig = {}) {
+	config?: SingleStoreTimestampConfig<TMode>,
+): Equal<TMode, 'string'> extends true ? SingleStoreTimestampStringBuilderInitial<TName>
+	: SingleStoreTimestampBuilderInitial<TName>;
+export function timestamp(name: string, config: SingleStoreTimestampConfig = {}) {
 	if (config.mode === 'string') {
-		return new MySqlTimestampStringBuilder(name, config);
+		return new SingleStoreTimestampStringBuilder(name, config);
 	}
-	return new MySqlTimestampBuilder(name, config);
+	return new SingleStoreTimestampBuilder(name, config);
 }
diff --git a/drizzle-orm/src/singlestore-core/columns/tinyint.ts b/drizzle-orm/src/singlestore-core/columns/tinyint.ts
index c749e6da8..d911cae96 100644
--- a/drizzle-orm/src/singlestore-core/columns/tinyint.ts
+++ b/drizzle-orm/src/singlestore-core/columns/tinyint.ts
@@ -1,45 +1,45 @@
 import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '~/column-builder.ts';
 import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
-import type { AnyMySqlTable } from '~/mysql-core/table.ts';
-import { MySqlColumnBuilderWithAutoIncrement, MySqlColumnWithAutoIncrement } from './common.ts';
-import type { MySqlIntConfig } from './int.ts';
+import type { AnySingleStoreTable } from '~/singlestore-core/table.ts';
+import { SingleStoreColumnBuilderWithAutoIncrement, SingleStoreColumnWithAutoIncrement } from './common.ts';
+import type { SingleStoreIntConfig } from './int.ts';
 
-export type MySqlTinyIntBuilderInitial<TName extends string> = MySqlTinyIntBuilder<{
+export type SingleStoreTinyIntBuilderInitial<TName extends string> = SingleStoreTinyIntBuilder<{
 	name: TName;
 	dataType: 'number';
-	columnType: 'MySqlTinyInt';
+	columnType: 'SingleStoreTinyInt';
 	data: number;
 	driverParam: number | string;
 	enumValues: undefined;
 	generated: undefined;
 }>;
 
-export class MySqlTinyIntBuilder<T extends ColumnBuilderBaseConfig<'number', 'MySqlTinyInt'>>
-	extends MySqlColumnBuilderWithAutoIncrement<T, MySqlIntConfig>
+export class SingleStoreTinyIntBuilder<T extends ColumnBuilderBaseConfig<'number', 'SingleStoreTinyInt'>>
+	extends SingleStoreColumnBuilderWithAutoIncrement<T, SingleStoreIntConfig>
 {
-	static readonly [entityKind]: string = 'MySqlTinyIntBuilder';
+	static readonly [entityKind]: string = 'SingleStoreTinyIntBuilder';
 
-	constructor(name: T['name'], config?: MySqlIntConfig) {
-		super(name, 'number', 'MySqlTinyInt');
+	constructor(name: T['name'], config?: SingleStoreIntConfig) {
+		super(name, 'number', 'SingleStoreTinyInt');
 		this.config.unsigned = config ? config.unsigned : false;
 	}
 
 	/** @internal */
 	override build<TTableName extends string>(
-		table: AnyMySqlTable<{ name: TTableName }>,
-	): MySqlTinyInt<MakeColumnConfig<T, TTableName>> {
-		return new MySqlTinyInt<MakeColumnConfig<T, TTableName>>(
+		table: AnySingleStoreTable<{ name: TTableName }>,
+	): SingleStoreTinyInt<MakeColumnConfig<T, TTableName>> {
+		return new SingleStoreTinyInt<MakeColumnConfig<T, TTableName>>(
 			table,
 			this.config as ColumnBuilderRuntimeConfig<any, any>,
 		);
 	}
 }
 
-export class MySqlTinyInt<T extends ColumnBaseConfig<'number', 'MySqlTinyInt'>>
-	extends MySqlColumnWithAutoIncrement<T, MySqlIntConfig>
+export class SingleStoreTinyInt<T extends ColumnBaseConfig<'number', 'SingleStoreTinyInt'>>
+	extends SingleStoreColumnWithAutoIncrement<T, SingleStoreIntConfig>
 {
-	static readonly [entityKind]: string = 'MySqlTinyInt';
+	static readonly [entityKind]: string = 'SingleStoreTinyInt';
 
 	getSQLType(): string {
 		return `tinyint${this.config.unsigned ? ' unsigned' : ''}`;
@@ -53,6 +53,9 @@ export class MySqlTinyInt<T extends ColumnBaseConfig<'number', 'MySqlTinyInt'>>
 	}
 }
 
-export function tinyint<TName extends string>(name: TName, config?: MySqlIntConfig): MySqlTinyIntBuilderInitial<TName> {
-	return new MySqlTinyIntBuilder(name, config);
+export function tinyint<TName extends string>(
+	name: TName,
+	config?: SingleStoreIntConfig,
+): SingleStoreTinyIntBuilderInitial<TName> {
+	return new SingleStoreTinyIntBuilder(name, config);
 }
diff --git a/drizzle-orm/src/singlestore-core/columns/varbinary.ts b/drizzle-orm/src/singlestore-core/columns/varbinary.ts
index be0a89cf6..545b87476 100644
--- a/drizzle-orm/src/singlestore-core/columns/varbinary.ts
+++ b/drizzle-orm/src/singlestore-core/columns/varbinary.ts
@@ -1,45 +1,45 @@
 import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '~/column-builder.ts';
 import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
-import type { AnyMySqlTable } from '~/mysql-core/table.ts';
-import { MySqlColumn, MySqlColumnBuilder } from './common.ts';
+import type { AnySingleStoreTable } from '~/singlestore-core/table.ts';
+import { SingleStoreColumn, SingleStoreColumnBuilder } from './common.ts';
 
-export type MySqlVarBinaryBuilderInitial<TName extends string> = MySqlVarBinaryBuilder<{
+export type SingleStoreVarBinaryBuilderInitial<TName extends string> = SingleStoreVarBinaryBuilder<{
 	name: TName;
 	dataType: 'string';
-	columnType: 'MySqlVarBinary';
+	columnType: 'SingleStoreVarBinary';
 	data: string;
 	driverParam: string;
 	enumValues: undefined;
 	generated: undefined;
 }>;
 
-export class MySqlVarBinaryBuilder<T extends ColumnBuilderBaseConfig<'string', 'MySqlVarBinary'>>
-	extends MySqlColumnBuilder<T, MySqlVarbinaryOptions>
+export class SingleStoreVarBinaryBuilder<T extends ColumnBuilderBaseConfig<'string', 'SingleStoreVarBinary'>>
+	extends SingleStoreColumnBuilder<T, SingleStoreVarbinaryOptions>
 {
-	static readonly [entityKind]: string = 'MySqlVarBinaryBuilder';
+	static readonly [entityKind]: string = 'SingleStoreVarBinaryBuilder';
 
 	/** @internal */
-	constructor(name: T['name'], config: MySqlVarbinaryOptions) {
-		super(name, 'string', 'MySqlVarBinary');
+	constructor(name: T['name'], config: SingleStoreVarbinaryOptions) {
+		super(name, 'string', 'SingleStoreVarBinary');
 		this.config.length = config?.length;
 	}
 
 	/** @internal */
 	override build<TTableName extends string>(
-		table: AnyMySqlTable<{ name: TTableName }>,
-	): MySqlVarBinary<MakeColumnConfig<T, TTableName>> {
-		return new MySqlVarBinary<MakeColumnConfig<T, TTableName>>(
+		table: AnySingleStoreTable<{ name: TTableName }>,
+	): SingleStoreVarBinary<MakeColumnConfig<T, TTableName>> {
+		return new SingleStoreVarBinary<MakeColumnConfig<T, TTableName>>(
 			table,
 			this.config as ColumnBuilderRuntimeConfig<any, any>,
 		);
 	}
 }
 
-export class MySqlVarBinary<
-	T extends ColumnBaseConfig<'string', 'MySqlVarBinary'>,
-> extends MySqlColumn<T, MySqlVarbinaryOptions> {
-	static readonly [entityKind]: string = 'MySqlVarBinary';
+export class SingleStoreVarBinary<
+	T extends ColumnBaseConfig<'string', 'SingleStoreVarBinary'>,
+> extends SingleStoreColumn<T, SingleStoreVarbinaryOptions> {
+	static readonly [entityKind]: string = 'SingleStoreVarBinary';
 
 	length: number | undefined = this.config.length;
 
@@ -48,13 +48,13 @@ export class MySqlVarBinary<
 	}
 }
 
-export interface MySqlVarbinaryOptions {
+export interface SingleStoreVarbinaryOptions {
 	length: number;
 }
 
 export function varbinary<TName extends string>(
 	name: TName,
-	options: MySqlVarbinaryOptions,
-): MySqlVarBinaryBuilderInitial<TName> {
-	return new MySqlVarBinaryBuilder(name, options);
+	options: SingleStoreVarbinaryOptions,
+): SingleStoreVarBinaryBuilderInitial<TName> {
+	return new SingleStoreVarBinaryBuilder(name, options);
 }
diff --git a/drizzle-orm/src/singlestore-core/columns/varchar.ts b/drizzle-orm/src/singlestore-core/columns/varchar.ts
index b692bf789..415b3c27b 100644
--- a/drizzle-orm/src/singlestore-core/columns/varchar.ts
+++ b/drizzle-orm/src/singlestore-core/columns/varchar.ts
@@ -1,49 +1,50 @@
 import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '~/column-builder.ts';
 import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
-import type { AnyMySqlTable } from '~/mysql-core/table.ts';
+import type { AnySingleStoreTable } from '~/singlestore-core/table.ts';
 import type { Writable } from '~/utils.ts';
-import { MySqlColumn, MySqlColumnBuilder } from './common.ts';
+import { SingleStoreColumn, SingleStoreColumnBuilder } from './common.ts';
 
-export type MySqlVarCharBuilderInitial<TName extends string, TEnum extends [string, ...string[]]> = MySqlVarCharBuilder<
-	{
-		name: TName;
-		dataType: 'string';
-		columnType: 'MySqlVarChar';
-		data: TEnum[number];
-		driverParam: number | string;
-		enumValues: TEnum;
-		generated: undefined;
-	}
->;
+export type SingleStoreVarCharBuilderInitial<TName extends string, TEnum extends [string, ...string[]]> =
+	SingleStoreVarCharBuilder<
+		{
+			name: TName;
+			dataType: 'string';
+			columnType: 'SingleStoreVarChar';
+			data: TEnum[number];
+			driverParam: number | string;
+			enumValues: TEnum;
+			generated: undefined;
+		}
+	>;
 
-export class MySqlVarCharBuilder<T extends ColumnBuilderBaseConfig<'string', 'MySqlVarChar'>>
-	extends MySqlColumnBuilder<T, MySqlVarCharConfig<T['enumValues']>>
+export class SingleStoreVarCharBuilder<T extends ColumnBuilderBaseConfig<'string', 'SingleStoreVarChar'>>
+	extends SingleStoreColumnBuilder<T, SingleStoreVarCharConfig<T['enumValues']>>
 {
-	static readonly [entityKind]: string = 'MySqlVarCharBuilder';
+	static readonly [entityKind]: string = 'SingleStoreVarCharBuilder';
 
 	/** @internal */
-	constructor(name: T['name'], config: MySqlVarCharConfig<T['enumValues']>) {
-		super(name, 'string', 'MySqlVarChar');
+	constructor(name: T['name'], config: SingleStoreVarCharConfig<T['enumValues']>) {
+		super(name, 'string', 'SingleStoreVarChar');
 		this.config.length = config.length;
 		this.config.enum = config.enum;
 	}
 
 	/** @internal */
 	override build<TTableName extends string>(
-		table: AnyMySqlTable<{ name: TTableName }>,
-	): MySqlVarChar<MakeColumnConfig<T, TTableName> & { enumValues: T['enumValues'] }> {
-		return new MySqlVarChar<MakeColumnConfig<T, TTableName> & { enumValues: T['enumValues'] }>(
+		table: AnySingleStoreTable<{ name: TTableName }>,
+	): SingleStoreVarChar<MakeColumnConfig<T, TTableName> & { enumValues: T['enumValues'] }> {
+		return new SingleStoreVarChar<MakeColumnConfig<T, TTableName> & { enumValues: T['enumValues'] }>(
 			table,
 			this.config as ColumnBuilderRuntimeConfig<any, any>,
 		);
 	}
 }
 
-export class MySqlVarChar<T extends ColumnBaseConfig<'string', 'MySqlVarChar'>>
-	extends MySqlColumn<T, MySqlVarCharConfig<T['enumValues']>>
+export class SingleStoreVarChar<T extends ColumnBaseConfig<'string', 'SingleStoreVarChar'>>
+	extends SingleStoreColumn<T, SingleStoreVarCharConfig<T['enumValues']>>
 {
-	static readonly [entityKind]: string = 'MySqlVarChar';
+	static readonly [entityKind]: string = 'SingleStoreVarChar';
 
 	readonly length: number | undefined = this.config.length;
 
@@ -54,14 +55,14 @@ export class MySqlVarChar<T extends ColumnBaseConfig<'string', 'MySqlVarChar'>>
 	}
 }
 
-export interface MySqlVarCharConfig<TEnum extends string[] | readonly string[] | undefined> {
+export interface SingleStoreVarCharConfig<TEnum extends string[] | readonly string[] | undefined> {
 	length: number;
 	enum?: TEnum;
 }
 
 export function varchar<TName extends string, U extends string, T extends Readonly<[U, ...U[]]>>(
 	name: TName,
-	config: MySqlVarCharConfig<T | Writable<T>>,
-): MySqlVarCharBuilderInitial<TName, Writable<T>> {
-	return new MySqlVarCharBuilder(name, config);
+	config: SingleStoreVarCharConfig<T | Writable<T>>,
+): SingleStoreVarCharBuilderInitial<TName, Writable<T>> {
+	return new SingleStoreVarCharBuilder(name, config);
 }
diff --git a/drizzle-orm/src/singlestore-core/columns/year.ts b/drizzle-orm/src/singlestore-core/columns/year.ts
index 224de12e9..c774b44d8 100644
--- a/drizzle-orm/src/singlestore-core/columns/year.ts
+++ b/drizzle-orm/src/singlestore-core/columns/year.ts
@@ -1,44 +1,49 @@
 import type { ColumnBuilderBaseConfig, ColumnBuilderRuntimeConfig, MakeColumnConfig } from '~/column-builder.ts';
 import type { ColumnBaseConfig } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
-import type { AnyMySqlTable } from '~/mysql-core/table.ts';
-import { MySqlColumn, MySqlColumnBuilder } from './common.ts';
+import type { AnySingleStoreTable } from '~/singlestore-core/table.ts';
+import { SingleStoreColumn, SingleStoreColumnBuilder } from './common.ts';
 
-export type MySqlYearBuilderInitial<TName extends string> = MySqlYearBuilder<{
+export type SingleStoreYearBuilderInitial<TName extends string> = SingleStoreYearBuilder<{
 	name: TName;
 	dataType: 'number';
-	columnType: 'MySqlYear';
+	columnType: 'SingleStoreYear';
 	data: number;
 	driverParam: number;
 	enumValues: undefined;
 	generated: undefined;
 }>;
 
-export class MySqlYearBuilder<T extends ColumnBuilderBaseConfig<'number', 'MySqlYear'>> extends MySqlColumnBuilder<T> {
-	static readonly [entityKind]: string = 'MySqlYearBuilder';
+export class SingleStoreYearBuilder<T extends ColumnBuilderBaseConfig<'number', 'SingleStoreYear'>>
+	extends SingleStoreColumnBuilder<T>
+{
+	static readonly [entityKind]: string = 'SingleStoreYearBuilder';
 
 	constructor(name: T['name']) {
-		super(name, 'number', 'MySqlYear');
+		super(name, 'number', 'SingleStoreYear');
 	}
 
 	/** @internal */
 	override build<TTableName extends string>(
-		table: AnyMySqlTable<{ name: TTableName }>,
-	): MySqlYear<MakeColumnConfig<T, TTableName>> {
-		return new MySqlYear<MakeColumnConfig<T, TTableName>>(table, this.config as ColumnBuilderRuntimeConfig<any, any>);
+		table: AnySingleStoreTable<{ name: TTableName }>,
+	): SingleStoreYear<MakeColumnConfig<T, TTableName>> {
+		return new SingleStoreYear<MakeColumnConfig<T, TTableName>>(
+			table,
+			this.config as ColumnBuilderRuntimeConfig<any, any>,
+		);
 	}
 }
 
-export class MySqlYear<
-	T extends ColumnBaseConfig<'number', 'MySqlYear'>,
-> extends MySqlColumn<T> {
-	static readonly [entityKind]: string = 'MySqlYear';
+export class SingleStoreYear<
+	T extends ColumnBaseConfig<'number', 'SingleStoreYear'>,
+> extends SingleStoreColumn<T> {
+	static readonly [entityKind]: string = 'SingleStoreYear';
 
 	getSQLType(): string {
 		return `year`;
 	}
 }
 
-export function year<TName extends string>(name: TName): MySqlYearBuilderInitial<TName> {
-	return new MySqlYearBuilder(name);
+export function year<TName extends string>(name: TName): SingleStoreYearBuilderInitial<TName> {
+	return new SingleStoreYearBuilder(name);
 }
diff --git a/drizzle-orm/src/singlestore-core/db.ts b/drizzle-orm/src/singlestore-core/db.ts
index 8df6ff343..7157bc6f4 100644
--- a/drizzle-orm/src/singlestore-core/db.ts
+++ b/drizzle-orm/src/singlestore-core/db.ts
@@ -6,35 +6,35 @@ import { SelectionProxyHandler } from '~/selection-proxy.ts';
 import type { ColumnsSelection, SQLWrapper } from '~/sql/sql.ts';
 import { WithSubquery } from '~/subquery.ts';
 import type { DrizzleTypeError } from '~/utils.ts';
-import type { MySqlDialect } from './dialect.ts';
+import type { SingleStoreDialect } from './dialect.ts';
 import {
-	MySqlDeleteBase,
-	MySqlInsertBuilder,
-	MySqlSelectBuilder,
-	MySqlUpdateBuilder,
 	QueryBuilder,
+	SingleStoreDeleteBase,
+	SingleStoreInsertBuilder,
+	SingleStoreSelectBuilder,
+	SingleStoreUpdateBuilder,
 } from './query-builders/index.ts';
 import { RelationalQueryBuilder } from './query-builders/query.ts';
 import type { SelectedFields } from './query-builders/select.types.ts';
 import type {
 	Mode,
-	MySqlQueryResultHKT,
-	MySqlQueryResultKind,
-	MySqlSession,
-	MySqlTransaction,
-	MySqlTransactionConfig,
 	PreparedQueryHKTBase,
+	SingleStoreQueryResultHKT,
+	SingleStoreQueryResultKind,
+	SingleStoreSession,
+	SingleStoreTransaction,
+	SingleStoreTransactionConfig,
 } from './session.ts';
 import type { WithSubqueryWithSelection } from './subquery.ts';
-import type { MySqlTable } from './table.ts';
+import type { SingleStoreTable } from './table.ts';
 
-export class MySqlDatabase<
-	TQueryResult extends MySqlQueryResultHKT,
+export class SingleStoreDatabase<
+	TQueryResult extends SingleStoreQueryResultHKT,
 	TPreparedQueryHKT extends PreparedQueryHKTBase,
 	TFullSchema extends Record<string, unknown> = {},
 	TSchema extends TablesRelationalConfig = ExtractTablesWithRelations<TFullSchema>,
 > {
-	static readonly [entityKind]: string = 'MySqlDatabase';
+	static readonly [entityKind]: string = 'SingleStoreDatabase';
 
 	declare readonly _: {
 		readonly schema: TSchema | undefined;
@@ -50,9 +50,9 @@ export class MySqlDatabase<
 
 	constructor(
 		/** @internal */
-		readonly dialect: MySqlDialect,
+		readonly dialect: SingleStoreDialect,
 		/** @internal */
-		readonly session: MySqlSession<any, any, any, any>,
+		readonly session: SingleStoreSession<any, any, any, any>,
 		schema: RelationalSchemaConfig<TSchema> | undefined,
 		protected readonly mode: Mode,
 	) {
@@ -70,12 +70,12 @@ export class MySqlDatabase<
 		this.query = {} as typeof this['query'];
 		if (this._.schema) {
 			for (const [tableName, columns] of Object.entries(this._.schema)) {
-				(this.query as MySqlDatabase<TQueryResult, TPreparedQueryHKT, Record<string, any>>['query'])[tableName] =
+				(this.query as SingleStoreDatabase<TQueryResult, TPreparedQueryHKT, Record<string, any>>['query'])[tableName] =
 					new RelationalQueryBuilder(
 						schema!.fullSchema,
 						this._.schema,
 						this._.tableNamesMap,
-						schema!.fullSchema[tableName] as MySqlTable,
+						schema!.fullSchema[tableName] as SingleStoreTable,
 						columns,
 						dialect,
 						session,
@@ -192,12 +192,12 @@ export class MySqlDatabase<
 		 *   .from(cars);
 		 * ```
 		 */
-		function select(): MySqlSelectBuilder<undefined, TPreparedQueryHKT>;
+		function select(): SingleStoreSelectBuilder<undefined, TPreparedQueryHKT>;
 		function select<TSelection extends SelectedFields>(
 			fields: TSelection,
-		): MySqlSelectBuilder<TSelection, TPreparedQueryHKT>;
-		function select(fields?: SelectedFields): MySqlSelectBuilder<SelectedFields | undefined, TPreparedQueryHKT> {
-			return new MySqlSelectBuilder({
+		): SingleStoreSelectBuilder<TSelection, TPreparedQueryHKT>;
+		function select(fields?: SelectedFields): SingleStoreSelectBuilder<SelectedFields | undefined, TPreparedQueryHKT> {
+			return new SingleStoreSelectBuilder({
 				fields: fields ?? undefined,
 				session: self.session,
 				dialect: self.dialect,
@@ -229,14 +229,14 @@ export class MySqlDatabase<
 		 *   .orderBy(cars.brand);
 		 * ```
 		 */
-		function selectDistinct(): MySqlSelectBuilder<undefined, TPreparedQueryHKT>;
+		function selectDistinct(): SingleStoreSelectBuilder<undefined, TPreparedQueryHKT>;
 		function selectDistinct<TSelection extends SelectedFields>(
 			fields: TSelection,
-		): MySqlSelectBuilder<TSelection, TPreparedQueryHKT>;
+		): SingleStoreSelectBuilder<TSelection, TPreparedQueryHKT>;
 		function selectDistinct(
 			fields?: SelectedFields,
-		): MySqlSelectBuilder<SelectedFields | undefined, TPreparedQueryHKT> {
-			return new MySqlSelectBuilder({
+		): SingleStoreSelectBuilder<SelectedFields | undefined, TPreparedQueryHKT> {
+			return new SingleStoreSelectBuilder({
 				fields: fields ?? undefined,
 				session: self.session,
 				dialect: self.dialect,
@@ -266,10 +266,10 @@ export class MySqlDatabase<
 		 * await db.update(cars).set({ color: 'red' }).where(eq(cars.brand, 'BMW'));
 		 * ```
 		 */
-		function update<TTable extends MySqlTable>(
+		function update<TTable extends SingleStoreTable>(
 			table: TTable,
-		): MySqlUpdateBuilder<TTable, TQueryResult, TPreparedQueryHKT> {
-			return new MySqlUpdateBuilder(table, self.session, self.dialect, queries);
+		): SingleStoreUpdateBuilder<TTable, TQueryResult, TPreparedQueryHKT> {
+			return new SingleStoreUpdateBuilder(table, self.session, self.dialect, queries);
 		}
 
 		/**
@@ -291,10 +291,10 @@ export class MySqlDatabase<
 		 * await db.delete(cars).where(eq(cars.color, 'green'));
 		 * ```
 		 */
-		function delete_<TTable extends MySqlTable>(
+		function delete_<TTable extends SingleStoreTable>(
 			table: TTable,
-		): MySqlDeleteBase<TTable, TQueryResult, TPreparedQueryHKT> {
-			return new MySqlDeleteBase(table, self.session, self.dialect, queries);
+		): SingleStoreDeleteBase<TTable, TQueryResult, TPreparedQueryHKT> {
+			return new SingleStoreDeleteBase(table, self.session, self.dialect, queries);
 		}
 
 		return { select, selectDistinct, update, delete: delete_ };
@@ -336,10 +336,12 @@ export class MySqlDatabase<
 	 *   .from(cars);
 	 * ```
 	 */
-	select(): MySqlSelectBuilder<undefined, TPreparedQueryHKT>;
-	select<TSelection extends SelectedFields>(fields: TSelection): MySqlSelectBuilder<TSelection, TPreparedQueryHKT>;
-	select(fields?: SelectedFields): MySqlSelectBuilder<SelectedFields | undefined, TPreparedQueryHKT> {
-		return new MySqlSelectBuilder({ fields: fields ?? undefined, session: this.session, dialect: this.dialect });
+	select(): SingleStoreSelectBuilder<undefined, TPreparedQueryHKT>;
+	select<TSelection extends SelectedFields>(
+		fields: TSelection,
+	): SingleStoreSelectBuilder<TSelection, TPreparedQueryHKT>;
+	select(fields?: SelectedFields): SingleStoreSelectBuilder<SelectedFields | undefined, TPreparedQueryHKT> {
+		return new SingleStoreSelectBuilder({ fields: fields ?? undefined, session: this.session, dialect: this.dialect });
 	}
 
 	/**
@@ -366,12 +368,12 @@ export class MySqlDatabase<
 	 *   .orderBy(cars.brand);
 	 * ```
 	 */
-	selectDistinct(): MySqlSelectBuilder<undefined, TPreparedQueryHKT>;
+	selectDistinct(): SingleStoreSelectBuilder<undefined, TPreparedQueryHKT>;
 	selectDistinct<TSelection extends SelectedFields>(
 		fields: TSelection,
-	): MySqlSelectBuilder<TSelection, TPreparedQueryHKT>;
-	selectDistinct(fields?: SelectedFields): MySqlSelectBuilder<SelectedFields | undefined, TPreparedQueryHKT> {
-		return new MySqlSelectBuilder({
+	): SingleStoreSelectBuilder<TSelection, TPreparedQueryHKT>;
+	selectDistinct(fields?: SelectedFields): SingleStoreSelectBuilder<SelectedFields | undefined, TPreparedQueryHKT> {
+		return new SingleStoreSelectBuilder({
 			fields: fields ?? undefined,
 			session: this.session,
 			dialect: this.dialect,
@@ -400,8 +402,10 @@ export class MySqlDatabase<
 	 * await db.update(cars).set({ color: 'red' }).where(eq(cars.brand, 'BMW'));
 	 * ```
 	 */
-	update<TTable extends MySqlTable>(table: TTable): MySqlUpdateBuilder<TTable, TQueryResult, TPreparedQueryHKT> {
-		return new MySqlUpdateBuilder(table, this.session, this.dialect);
+	update<TTable extends SingleStoreTable>(
+		table: TTable,
+	): SingleStoreUpdateBuilder<TTable, TQueryResult, TPreparedQueryHKT> {
+		return new SingleStoreUpdateBuilder(table, this.session, this.dialect);
 	}
 
 	/**
@@ -423,8 +427,10 @@ export class MySqlDatabase<
 	 * await db.insert(cars).values([{ brand: 'BMW' }, { brand: 'Porsche' }]);
 	 * ```
 	 */
-	insert<TTable extends MySqlTable>(table: TTable): MySqlInsertBuilder<TTable, TQueryResult, TPreparedQueryHKT> {
-		return new MySqlInsertBuilder(table, this.session, this.dialect);
+	insert<TTable extends SingleStoreTable>(
+		table: TTable,
+	): SingleStoreInsertBuilder<TTable, TQueryResult, TPreparedQueryHKT> {
+		return new SingleStoreInsertBuilder(table, this.session, this.dialect);
 	}
 
 	/**
@@ -446,35 +452,37 @@ export class MySqlDatabase<
 	 * await db.delete(cars).where(eq(cars.color, 'green'));
 	 * ```
 	 */
-	delete<TTable extends MySqlTable>(table: TTable): MySqlDeleteBase<TTable, TQueryResult, TPreparedQueryHKT> {
-		return new MySqlDeleteBase(table, this.session, this.dialect);
+	delete<TTable extends SingleStoreTable>(
+		table: TTable,
+	): SingleStoreDeleteBase<TTable, TQueryResult, TPreparedQueryHKT> {
+		return new SingleStoreDeleteBase(table, this.session, this.dialect);
 	}
 
 	execute<T extends { [column: string]: any } = ResultSetHeader>(
 		query: SQLWrapper,
-	): Promise<MySqlQueryResultKind<TQueryResult, T>> {
+	): Promise<SingleStoreQueryResultKind<TQueryResult, T>> {
 		return this.session.execute(query.getSQL());
 	}
 
 	transaction<T>(
 		transaction: (
-			tx: MySqlTransaction<TQueryResult, TPreparedQueryHKT, TFullSchema, TSchema>,
-			config?: MySqlTransactionConfig,
+			tx: SingleStoreTransaction<TQueryResult, TPreparedQueryHKT, TFullSchema, TSchema>,
+			config?: SingleStoreTransactionConfig,
 		) => Promise<T>,
-		config?: MySqlTransactionConfig,
+		config?: SingleStoreTransactionConfig,
 	): Promise<T> {
 		return this.session.transaction(transaction, config);
 	}
 }
 
-export type MySQLWithReplicas<Q> = Q & { $primary: Q };
+export type SingleStoreWithReplicas<Q> = Q & { $primary: Q };
 
 export const withReplicas = <
-	HKT extends MySqlQueryResultHKT,
+	HKT extends SingleStoreQueryResultHKT,
 	TPreparedQueryHKT extends PreparedQueryHKTBase,
 	TFullSchema extends Record<string, unknown>,
 	TSchema extends TablesRelationalConfig,
-	Q extends MySqlDatabase<
+	Q extends SingleStoreDatabase<
 		HKT,
 		TPreparedQueryHKT,
 		TFullSchema,
@@ -484,7 +492,7 @@ export const withReplicas = <
 	primary: Q,
 	replicas: [Q, ...Q[]],
 	getReplica: (replicas: Q[]) => Q = () => replicas[Math.floor(Math.random() * replicas.length)]!,
-): MySQLWithReplicas<Q> => {
+): SingleStoreWithReplicas<Q> => {
 	const select: Q['select'] = (...args: []) => getReplica(replicas).select(...args);
 	const selectDistinct: Q['selectDistinct'] = (...args: []) => getReplica(replicas).selectDistinct(...args);
 	const $with: Q['with'] = (...args: []) => getReplica(replicas).with(...args);
diff --git a/drizzle-orm/src/singlestore-core/dialect.ts b/drizzle-orm/src/singlestore-core/dialect.ts
index 04383a2c6..d72424c8e 100644
--- a/drizzle-orm/src/singlestore-core/dialect.ts
+++ b/drizzle-orm/src/singlestore-core/dialect.ts
@@ -22,21 +22,25 @@ import { Subquery } from '~/subquery.ts';
 import { getTableName, getTableUniqueName, Table } from '~/table.ts';
 import { orderSelectedFields, type UpdateSet } from '~/utils.ts';
 import { ViewBaseConfig } from '~/view-common.ts';
-import { MySqlColumn } from './columns/common.ts';
-import type { MySqlDeleteConfig } from './query-builders/delete.ts';
-import type { MySqlInsertConfig } from './query-builders/insert.ts';
-import type { MySqlSelectConfig, MySqlSelectJoinConfig, SelectedFieldsOrdered } from './query-builders/select.types.ts';
-import type { MySqlUpdateConfig } from './query-builders/update.ts';
-import type { MySqlSession } from './session.ts';
-import { MySqlTable } from './table.ts';
-import { MySqlViewBase } from './view-base.ts';
-
-export class MySqlDialect {
-	static readonly [entityKind]: string = 'MySqlDialect';
+import { SingleStoreColumn } from './columns/common.ts';
+import type { SingleStoreDeleteConfig } from './query-builders/delete.ts';
+import type { SingleStoreInsertConfig } from './query-builders/insert.ts';
+import type {
+	SelectedFieldsOrdered,
+	SingleStoreSelectConfig,
+	SingleStoreSelectJoinConfig,
+} from './query-builders/select.types.ts';
+import type { SingleStoreUpdateConfig } from './query-builders/update.ts';
+import type { SingleStoreSession } from './session.ts';
+import { SingleStoreTable } from './table.ts';
+import { SingleStoreViewBase } from './view-base.ts';
+
+export class SingleStoreDialect {
+	static readonly [entityKind]: string = 'SingleStoreDialect';
 
 	async migrate(
 		migrations: MigrationMeta[],
-		session: MySqlSession,
+		session: SingleStoreSession,
 		config: Omit<MigrationConfig, 'migrationsSchema'>,
 	): Promise<void> {
 		const migrationsTable = config.migrationsTable ?? '__drizzle_migrations';
@@ -100,7 +104,7 @@ export class MySqlDialect {
 		return sql.join(withSqlChunks);
 	}
 
-	buildDeleteQuery({ table, where, returning, withList }: MySqlDeleteConfig): SQL {
+	buildDeleteQuery({ table, where, returning, withList }: SingleStoreDeleteConfig): SQL {
 		const withSql = this.buildWithCTE(withList);
 
 		const returningSql = returning
@@ -112,7 +116,7 @@ export class MySqlDialect {
 		return sql`${withSql}delete from ${table}${whereSql}${returningSql}`;
 	}
 
-	buildUpdateSet(table: MySqlTable, set: UpdateSet): SQL {
+	buildUpdateSet(table: SingleStoreTable, set: UpdateSet): SQL {
 		const tableColumns = table[Table.Symbol.Columns];
 
 		const columnNames = Object.keys(tableColumns).filter((colName) =>
@@ -133,7 +137,7 @@ export class MySqlDialect {
 		}));
 	}
 
-	buildUpdateQuery({ table, set, where, returning, withList }: MySqlUpdateConfig): SQL {
+	buildUpdateQuery({ table, set, where, returning, withList }: SingleStoreUpdateConfig): SQL {
 		const withSql = this.buildWithCTE(withList);
 
 		const setSql = this.buildUpdateSet(table, set);
@@ -177,7 +181,7 @@ export class MySqlDialect {
 						chunk.push(
 							new SQL(
 								query.queryChunks.map((c) => {
-									if (is(c, MySqlColumn)) {
+									if (is(c, SingleStoreColumn)) {
 										return sql.identifier(c.name);
 									}
 									return c;
@@ -225,16 +229,16 @@ export class MySqlDialect {
 			lockingClause,
 			distinct,
 			setOperators,
-		}: MySqlSelectConfig,
+		}: SingleStoreSelectConfig,
 	): SQL {
-		const fieldsList = fieldsFlat ?? orderSelectedFields<MySqlColumn>(fields);
+		const fieldsList = fieldsFlat ?? orderSelectedFields<SingleStoreColumn>(fields);
 		for (const f of fieldsList) {
 			if (
 				is(f.field, Column)
 				&& getTableName(f.field.table)
 					!== (is(table, Subquery)
 						? table._.alias
-						: is(table, MySqlViewBase)
+						: is(table, SingleStoreViewBase)
 						? table[ViewBaseConfig].name
 						: is(table, SQL)
 						? undefined
@@ -279,10 +283,10 @@ export class MySqlDialect {
 				const table = joinMeta.table;
 				const lateralSql = joinMeta.lateral ? sql` lateral` : undefined;
 
-				if (is(table, MySqlTable)) {
-					const tableName = table[MySqlTable.Symbol.Name];
-					const tableSchema = table[MySqlTable.Symbol.Schema];
-					const origTableName = table[MySqlTable.Symbol.OriginalName];
+				if (is(table, SingleStoreTable)) {
+					const tableName = table[SingleStoreTable.Symbol.Name];
+					const tableSchema = table[SingleStoreTable.Symbol.Schema];
+					const origTableName = table[SingleStoreTable.Symbol.OriginalName];
 					const alias = tableName === origTableName ? undefined : joinMeta.alias;
 					joinsArray.push(
 						sql`${sql.raw(joinMeta.joinType)} join${lateralSql} ${
@@ -353,7 +357,7 @@ export class MySqlDialect {
 		return finalQuery;
 	}
 
-	buildSetOperations(leftSelect: SQL, setOperators: MySqlSelectConfig['setOperators']): SQL {
+	buildSetOperations(leftSelect: SQL, setOperators: SingleStoreSelectConfig['setOperators']): SQL {
 		const [setOperator, ...rest] = setOperators;
 
 		if (!setOperator) {
@@ -374,7 +378,7 @@ export class MySqlDialect {
 	buildSetOperationQuery({
 		leftSelect,
 		setOperator: { type, isAll, rightSelect, limit, orderBy, offset },
-	}: { leftSelect: SQL; setOperator: MySqlSelectConfig['setOperators'][number] }): SQL {
+	}: { leftSelect: SQL; setOperator: SingleStoreSelectConfig['setOperators'][number] }): SQL {
 		const leftChunk = sql`(${leftSelect.getSQL()}) `;
 		const rightChunk = sql`(${rightSelect.getSQL()})`;
 
@@ -383,15 +387,15 @@ export class MySqlDialect {
 			const orderByValues: (SQL<unknown> | Name)[] = [];
 
 			// The next bit is necessary because the sql operator replaces ${table.column} with `table`.`column`
-			// which is invalid MySql syntax, Table from one of the SELECTs cannot be used in global ORDER clause
+			// which is invalid SingleStore syntax, Table from one of the SELECTs cannot be used in global ORDER clause
 			for (const orderByUnit of orderBy) {
-				if (is(orderByUnit, MySqlColumn)) {
+				if (is(orderByUnit, SingleStoreColumn)) {
 					orderByValues.push(sql.identifier(orderByUnit.name));
 				} else if (is(orderByUnit, SQL)) {
 					for (let i = 0; i < orderByUnit.queryChunks.length; i++) {
 						const chunk = orderByUnit.queryChunks[i];
 
-						if (is(chunk, MySqlColumn)) {
+						if (is(chunk, SingleStoreColumn)) {
 							orderByUnit.queryChunks[i] = sql.identifier(chunk.name);
 						}
 					}
@@ -417,12 +421,12 @@ export class MySqlDialect {
 	}
 
 	buildInsertQuery(
-		{ table, values, ignore, onConflict }: MySqlInsertConfig,
+		{ table, values, ignore, onConflict }: SingleStoreInsertConfig,
 	): { sql: SQL; generatedIds: Record<string, unknown>[] } {
 		// const isSingleValue = values.length === 1;
 		const valuesSqlList: ((SQLChunk | SQL)[] | SQL)[] = [];
-		const columns: Record<string, MySqlColumn> = table[Table.Symbol.Columns];
-		const colEntries: [string, MySqlColumn][] = Object.entries(columns).filter(([_, col]) =>
+		const columns: Record<string, SingleStoreColumn> = table[Table.Symbol.Columns];
+		const colEntries: [string, SingleStoreColumn][] = Object.entries(columns).filter(([_, col]) =>
 			!col.shouldDisableInsert()
 		);
 
@@ -500,16 +504,16 @@ export class MySqlDialect {
 		fullSchema: Record<string, unknown>;
 		schema: TablesRelationalConfig;
 		tableNamesMap: Record<string, string>;
-		table: MySqlTable;
+		table: SingleStoreTable;
 		tableConfig: TableRelationalConfig;
 		queryConfig: true | DBQueryConfig<'many', true>;
 		tableAlias: string;
 		nestedQueryRelation?: Relation;
 		joinOn?: SQL;
-	}): BuildRelationalQueryResult<MySqlTable, MySqlColumn> {
-		let selection: BuildRelationalQueryResult<MySqlTable, MySqlColumn>['selection'] = [];
-		let limit, offset, orderBy: MySqlSelectConfig['orderBy'], where;
-		const joins: MySqlSelectJoinConfig[] = [];
+	}): BuildRelationalQueryResult<SingleStoreTable, SingleStoreColumn> {
+		let selection: BuildRelationalQueryResult<SingleStoreTable, SingleStoreColumn>['selection'] = [];
+		let limit, offset, orderBy: SingleStoreSelectConfig['orderBy'], where;
+		const joins: SingleStoreSelectJoinConfig[] = [];
 
 		if (config === true) {
 			const selectionEntries = Object.entries(tableConfig.columns);
@@ -518,7 +522,7 @@ export class MySqlDialect {
 			) => ({
 				dbKey: value.name,
 				tsKey: key,
-				field: aliasedTableColumn(value as MySqlColumn, tableAlias),
+				field: aliasedTableColumn(value as SingleStoreColumn, tableAlias),
 				relationTableTsKey: undefined,
 				isJson: false,
 				selection: [],
@@ -535,7 +539,7 @@ export class MySqlDialect {
 				where = whereSql && mapColumnsInSQLToAlias(whereSql, tableAlias);
 			}
 
-			const fieldsSelection: { tsKey: string; value: MySqlColumn | SQL.Aliased }[] = [];
+			const fieldsSelection: { tsKey: string; value: SingleStoreColumn | SQL.Aliased }[] = [];
 			let selectedColumns: string[] = [];
 
 			// Figure out which columns to select
@@ -566,7 +570,7 @@ export class MySqlDialect {
 			}
 
 			for (const field of selectedColumns) {
-				const column = tableConfig.columns[field]! as MySqlColumn;
+				const column = tableConfig.columns[field]! as SingleStoreColumn;
 				fieldsSelection.push({ tsKey: field, value: column });
 			}
 
@@ -619,7 +623,7 @@ export class MySqlDialect {
 			}
 			orderBy = orderByOrig.map((orderByValue) => {
 				if (is(orderByValue, Column)) {
-					return aliasedTableColumn(orderByValue, tableAlias) as MySqlColumn;
+					return aliasedTableColumn(orderByValue, tableAlias) as SingleStoreColumn;
 				}
 				return mapColumnsInSQLToAlias(orderByValue, tableAlias);
 			});
@@ -651,7 +655,7 @@ export class MySqlDialect {
 					fullSchema,
 					schema,
 					tableNamesMap,
-					table: fullSchema[relationTableTsName] as MySqlTable,
+					table: fullSchema[relationTableTsName] as SingleStoreTable,
 					tableConfig: schema[relationTableTsName]!,
 					queryConfig: is(relation, One)
 						? (selectedRelationConfigValue === true
@@ -747,7 +751,7 @@ export class MySqlDialect {
 			}
 
 			result = this.buildSelectQuery({
-				table: is(result, MySqlTable) ? result : new Subquery(result, {}, tableAlias),
+				table: is(result, SingleStoreTable) ? result : new Subquery(result, {}, tableAlias),
 				fields: {},
 				fieldsFlat: nestedSelection.map(({ field }) => ({
 					path: [],
@@ -798,15 +802,15 @@ export class MySqlDialect {
 		fullSchema: Record<string, unknown>;
 		schema: TablesRelationalConfig;
 		tableNamesMap: Record<string, string>;
-		table: MySqlTable;
+		table: SingleStoreTable;
 		tableConfig: TableRelationalConfig;
 		queryConfig: true | DBQueryConfig<'many', true>;
 		tableAlias: string;
 		nestedQueryRelation?: Relation;
 		joinOn?: SQL;
-	}): BuildRelationalQueryResult<MySqlTable, MySqlColumn> {
-		let selection: BuildRelationalQueryResult<MySqlTable, MySqlColumn>['selection'] = [];
-		let limit, offset, orderBy: MySqlSelectConfig['orderBy'] = [], where;
+	}): BuildRelationalQueryResult<SingleStoreTable, SingleStoreColumn> {
+		let selection: BuildRelationalQueryResult<SingleStoreTable, SingleStoreColumn>['selection'] = [];
+		let limit, offset, orderBy: SingleStoreSelectConfig['orderBy'] = [], where;
 
 		if (config === true) {
 			const selectionEntries = Object.entries(tableConfig.columns);
@@ -815,7 +819,7 @@ export class MySqlDialect {
 			) => ({
 				dbKey: value.name,
 				tsKey: key,
-				field: aliasedTableColumn(value as MySqlColumn, tableAlias),
+				field: aliasedTableColumn(value as SingleStoreColumn, tableAlias),
 				relationTableTsKey: undefined,
 				isJson: false,
 				selection: [],
@@ -832,7 +836,7 @@ export class MySqlDialect {
 				where = whereSql && mapColumnsInSQLToAlias(whereSql, tableAlias);
 			}
 
-			const fieldsSelection: { tsKey: string; value: MySqlColumn | SQL.Aliased }[] = [];
+			const fieldsSelection: { tsKey: string; value: SingleStoreColumn | SQL.Aliased }[] = [];
 			let selectedColumns: string[] = [];
 
 			// Figure out which columns to select
@@ -863,7 +867,7 @@ export class MySqlDialect {
 			}
 
 			for (const field of selectedColumns) {
-				const column = tableConfig.columns[field]! as MySqlColumn;
+				const column = tableConfig.columns[field]! as SingleStoreColumn;
 				fieldsSelection.push({ tsKey: field, value: column });
 			}
 
@@ -916,7 +920,7 @@ export class MySqlDialect {
 			}
 			orderBy = orderByOrig.map((orderByValue) => {
 				if (is(orderByValue, Column)) {
-					return aliasedTableColumn(orderByValue, tableAlias) as MySqlColumn;
+					return aliasedTableColumn(orderByValue, tableAlias) as SingleStoreColumn;
 				}
 				return mapColumnsInSQLToAlias(orderByValue, tableAlias);
 			});
@@ -948,7 +952,7 @@ export class MySqlDialect {
 					fullSchema,
 					schema,
 					tableNamesMap,
-					table: fullSchema[relationTableTsName] as MySqlTable,
+					table: fullSchema[relationTableTsName] as SingleStoreTable,
 					tableConfig: schema[relationTableTsName]!,
 					queryConfig: is(relation, One)
 						? (selectedRelationConfigValue === true
@@ -990,7 +994,7 @@ export class MySqlDialect {
 			let field = sql`json_to_array(${
 				sql.join(
 					selection.map(({ field }) =>
-						is(field, MySqlColumn) ? sql.identifier(field.name) : is(field, SQL.Aliased) ? field.sql : field
+						is(field, SingleStoreColumn) ? sql.identifier(field.name) : is(field, SQL.Aliased) ? field.sql : field
 					),
 					sql`, `,
 				)
@@ -1040,7 +1044,7 @@ export class MySqlDialect {
 			}
 
 			result = this.buildSelectQuery({
-				table: is(result, MySqlTable) ? result : new Subquery(result, {}, tableAlias),
+				table: is(result, SingleStoreTable) ? result : new Subquery(result, {}, tableAlias),
 				fields: {},
 				fieldsFlat: nestedSelection.map(({ field }) => ({
 					path: [],
diff --git a/drizzle-orm/src/singlestore-core/expressions.ts b/drizzle-orm/src/singlestore-core/expressions.ts
index a61f77786..6d4284d18 100644
--- a/drizzle-orm/src/singlestore-core/expressions.ts
+++ b/drizzle-orm/src/singlestore-core/expressions.ts
@@ -1,16 +1,16 @@
 import { bindIfParam } from '~/expressions.ts';
 import type { Placeholder, SQL, SQLChunk, SQLWrapper } from '~/sql/sql.ts';
 import { sql } from '~/sql/sql.ts';
-import type { MySqlColumn } from './columns/index.ts';
+import type { SingleStoreColumn } from './columns/index.ts';
 
 export * from '~/expressions.ts';
 
-export function concat(column: MySqlColumn | SQL.Aliased, value: string | Placeholder | SQLWrapper): SQL {
+export function concat(column: SingleStoreColumn | SQL.Aliased, value: string | Placeholder | SQLWrapper): SQL {
 	return sql`${column} || ${bindIfParam(value, column)}`;
 }
 
 export function substring(
-	column: MySqlColumn | SQL.Aliased,
+	column: SingleStoreColumn | SQL.Aliased,
 	{ from, for: _for }: { from?: number | Placeholder | SQLWrapper; for?: number | Placeholder | SQLWrapper },
 ): SQL {
 	const chunks: SQLChunk[] = [sql`substring(`, column];
diff --git a/drizzle-orm/src/singlestore-core/foreign-keys.ts b/drizzle-orm/src/singlestore-core/foreign-keys.ts
index 957e1f15c..fbebd684c 100644
--- a/drizzle-orm/src/singlestore-core/foreign-keys.ts
+++ b/drizzle-orm/src/singlestore-core/foreign-keys.ts
@@ -1,18 +1,18 @@
 import { entityKind } from '~/entity.ts';
-import type { AnyMySqlColumn, MySqlColumn } from './columns/index.ts';
-import { MySqlTable } from './table.ts';
+import type { AnySingleStoreColumn, SingleStoreColumn } from './columns/index.ts';
+import { SingleStoreTable } from './table.ts';
 
 export type UpdateDeleteAction = 'cascade' | 'restrict' | 'no action' | 'set null' | 'set default';
 
 export type Reference = () => {
 	readonly name?: string;
-	readonly columns: MySqlColumn[];
-	readonly foreignTable: MySqlTable;
-	readonly foreignColumns: MySqlColumn[];
+	readonly columns: SingleStoreColumn[];
+	readonly foreignTable: SingleStoreTable;
+	readonly foreignColumns: SingleStoreColumn[];
 };
 
 export class ForeignKeyBuilder {
-	static readonly [entityKind]: string = 'MySqlForeignKeyBuilder';
+	static readonly [entityKind]: string = 'SingleStoreForeignKeyBuilder';
 
 	/** @internal */
 	reference: Reference;
@@ -26,8 +26,8 @@ export class ForeignKeyBuilder {
 	constructor(
 		config: () => {
 			name?: string;
-			columns: MySqlColumn[];
-			foreignColumns: MySqlColumn[];
+			columns: SingleStoreColumn[];
+			foreignColumns: SingleStoreColumn[];
 		},
 		actions?: {
 			onUpdate?: UpdateDeleteAction;
@@ -36,7 +36,7 @@ export class ForeignKeyBuilder {
 	) {
 		this.reference = () => {
 			const { name, columns, foreignColumns } = config();
-			return { name, columns, foreignTable: foreignColumns[0]!.table as MySqlTable, foreignColumns };
+			return { name, columns, foreignTable: foreignColumns[0]!.table as SingleStoreTable, foreignColumns };
 		};
 		if (actions) {
 			this._onUpdate = actions.onUpdate;
@@ -55,7 +55,7 @@ export class ForeignKeyBuilder {
 	}
 
 	/** @internal */
-	build(table: MySqlTable): ForeignKey {
+	build(table: SingleStoreTable): ForeignKey {
 		return new ForeignKey(table, this);
 	}
 }
@@ -63,13 +63,13 @@ export class ForeignKeyBuilder {
 export type AnyForeignKeyBuilder = ForeignKeyBuilder;
 
 export class ForeignKey {
-	static readonly [entityKind]: string = 'MySqlForeignKey';
+	static readonly [entityKind]: string = 'SingleStoreForeignKey';
 
 	readonly reference: Reference;
 	readonly onUpdate: UpdateDeleteAction | undefined;
 	readonly onDelete: UpdateDeleteAction | undefined;
 
-	constructor(readonly table: MySqlTable, builder: ForeignKeyBuilder) {
+	constructor(readonly table: SingleStoreTable, builder: ForeignKeyBuilder) {
 		this.reference = builder.reference;
 		this.onUpdate = builder._onUpdate;
 		this.onDelete = builder._onDelete;
@@ -80,9 +80,9 @@ export class ForeignKey {
 		const columnNames = columns.map((column) => column.name);
 		const foreignColumnNames = foreignColumns.map((column) => column.name);
 		const chunks = [
-			this.table[MySqlTable.Symbol.Name],
+			this.table[SingleStoreTable.Symbol.Name],
 			...columnNames,
-			foreignColumns[0]!.table[MySqlTable.Symbol.Name],
+			foreignColumns[0]!.table[SingleStoreTable.Symbol.Name],
 			...foreignColumnNames,
 		];
 		return name ?? `${chunks.join('_')}_fk`;
@@ -91,20 +91,23 @@ export class ForeignKey {
 
 type ColumnsWithTable<
 	TTableName extends string,
-	TColumns extends MySqlColumn[],
-> = { [Key in keyof TColumns]: AnyMySqlColumn<{ tableName: TTableName }> };
+	TColumns extends SingleStoreColumn[],
+> = { [Key in keyof TColumns]: AnySingleStoreColumn<{ tableName: TTableName }> };
 
-export type GetColumnsTable<TColumns extends MySqlColumn | MySqlColumn[]> = (
-	TColumns extends MySqlColumn ? TColumns
-		: TColumns extends MySqlColumn[] ? TColumns[number]
+export type GetColumnsTable<TColumns extends SingleStoreColumn | SingleStoreColumn[]> = (
+	TColumns extends SingleStoreColumn ? TColumns
+		: TColumns extends SingleStoreColumn[] ? TColumns[number]
 		: never
-) extends AnyMySqlColumn<{ tableName: infer TTableName extends string }> ? TTableName
+) extends AnySingleStoreColumn<{ tableName: infer TTableName extends string }> ? TTableName
 	: never;
 
 export function foreignKey<
 	TTableName extends string,
 	TForeignTableName extends string,
-	TColumns extends [AnyMySqlColumn<{ tableName: TTableName }>, ...AnyMySqlColumn<{ tableName: TTableName }>[]],
+	TColumns extends [
+		AnySingleStoreColumn<{ tableName: TTableName }>,
+		...AnySingleStoreColumn<{ tableName: TTableName }>[],
+	],
 >(
 	config: {
 		name?: string;
diff --git a/drizzle-orm/src/singlestore-core/indexes.ts b/drizzle-orm/src/singlestore-core/indexes.ts
index 5b73b1d30..59d2bfb11 100644
--- a/drizzle-orm/src/singlestore-core/indexes.ts
+++ b/drizzle-orm/src/singlestore-core/indexes.ts
@@ -1,7 +1,7 @@
 import { entityKind } from '~/entity.ts';
 import type { SQL } from '~/sql/sql.ts';
-import type { AnyMySqlColumn, MySqlColumn } from './columns/index.ts';
-import type { MySqlTable } from './table.ts';
+import type { AnySingleStoreColumn, SingleStoreColumn } from './columns/index.ts';
+import type { SingleStoreTable } from './table.ts';
 
 interface IndexConfig {
 	name: string;
@@ -29,10 +29,10 @@ interface IndexConfig {
 	lock?: 'default' | 'none' | 'shared' | 'exclusive';
 }
 
-export type IndexColumn = MySqlColumn | SQL;
+export type IndexColumn = SingleStoreColumn | SQL;
 
 export class IndexBuilderOn {
-	static readonly [entityKind]: string = 'MySqlIndexBuilderOn';
+	static readonly [entityKind]: string = 'SingleStoreIndexBuilderOn';
 
 	constructor(private name: string, private unique: boolean) {}
 
@@ -42,14 +42,14 @@ export class IndexBuilderOn {
 }
 
 export interface AnyIndexBuilder {
-	build(table: MySqlTable): Index;
+	build(table: SingleStoreTable): Index;
 }
 
 // eslint-disable-next-line @typescript-eslint/no-empty-interface
 export interface IndexBuilder extends AnyIndexBuilder {}
 
 export class IndexBuilder implements AnyIndexBuilder {
-	static readonly [entityKind]: string = 'MySqlIndexBuilder';
+	static readonly [entityKind]: string = 'SingleStoreIndexBuilder';
 
 	/** @internal */
 	config: IndexConfig;
@@ -78,23 +78,23 @@ export class IndexBuilder implements AnyIndexBuilder {
 	}
 
 	/** @internal */
-	build(table: MySqlTable): Index {
+	build(table: SingleStoreTable): Index {
 		return new Index(this.config, table);
 	}
 }
 
 export class Index {
-	static readonly [entityKind]: string = 'MySqlIndex';
+	static readonly [entityKind]: string = 'SingleStoreIndex';
 
-	readonly config: IndexConfig & { table: MySqlTable };
+	readonly config: IndexConfig & { table: SingleStoreTable };
 
-	constructor(config: IndexConfig, table: MySqlTable) {
+	constructor(config: IndexConfig, table: SingleStoreTable) {
 		this.config = { ...config, table };
 	}
 }
 
 export type GetColumnsTableName<TColumns> = TColumns extends
-	AnyMySqlColumn<{ tableName: infer TTableName extends string }> | AnyMySqlColumn<
+	AnySingleStoreColumn<{ tableName: infer TTableName extends string }> | AnySingleStoreColumn<
 		{ tableName: infer TTableName extends string }
 	>[] ? TTableName
 	: never;
diff --git a/drizzle-orm/src/singlestore-core/primary-keys.ts b/drizzle-orm/src/singlestore-core/primary-keys.ts
index 014cbd8c0..47dc0a19c 100644
--- a/drizzle-orm/src/singlestore-core/primary-keys.ts
+++ b/drizzle-orm/src/singlestore-core/primary-keys.ts
@@ -1,11 +1,11 @@
 import { entityKind } from '~/entity.ts';
-import type { AnyMySqlColumn, MySqlColumn } from './columns/index.ts';
-import { MySqlTable } from './table.ts';
+import type { AnySingleStoreColumn, SingleStoreColumn } from './columns/index.ts';
+import { SingleStoreTable } from './table.ts';
 
 export function primaryKey<
 	TTableName extends string,
-	TColumn extends AnyMySqlColumn<{ tableName: TTableName }>,
-	TColumns extends AnyMySqlColumn<{ tableName: TTableName }>[],
+	TColumn extends AnySingleStoreColumn<{ tableName: TTableName }>,
+	TColumns extends AnySingleStoreColumn<{ tableName: TTableName }>[],
 >(config: { name?: string; columns: [TColumn, ...TColumns] }): PrimaryKeyBuilder;
 /**
  * @deprecated: Please use primaryKey({ columns: [] }) instead of this function
@@ -13,7 +13,7 @@ export function primaryKey<
  */
 export function primaryKey<
 	TTableName extends string,
-	TColumns extends AnyMySqlColumn<{ tableName: TTableName }>[],
+	TColumns extends AnySingleStoreColumn<{ tableName: TTableName }>[],
 >(...columns: TColumns): PrimaryKeyBuilder;
 export function primaryKey(...config: any) {
 	if (config[0].columns) {
@@ -23,16 +23,16 @@ export function primaryKey(...config: any) {
 }
 
 export class PrimaryKeyBuilder {
-	static readonly [entityKind]: string = 'MySqlPrimaryKeyBuilder';
+	static readonly [entityKind]: string = 'SingleStorePrimaryKeyBuilder';
 
 	/** @internal */
-	columns: MySqlColumn[];
+	columns: SingleStoreColumn[];
 
 	/** @internal */
 	name?: string;
 
 	constructor(
-		columns: MySqlColumn[],
+		columns: SingleStoreColumn[],
 		name?: string,
 	) {
 		this.columns = columns;
@@ -40,24 +40,24 @@ export class PrimaryKeyBuilder {
 	}
 
 	/** @internal */
-	build(table: MySqlTable): PrimaryKey {
+	build(table: SingleStoreTable): PrimaryKey {
 		return new PrimaryKey(table, this.columns, this.name);
 	}
 }
 
 export class PrimaryKey {
-	static readonly [entityKind]: string = 'MySqlPrimaryKey';
+	static readonly [entityKind]: string = 'SingleStorePrimaryKey';
 
-	readonly columns: MySqlColumn[];
+	readonly columns: SingleStoreColumn[];
 	readonly name?: string;
 
-	constructor(readonly table: MySqlTable, columns: MySqlColumn[], name?: string) {
+	constructor(readonly table: SingleStoreTable, columns: SingleStoreColumn[], name?: string) {
 		this.columns = columns;
 		this.name = name;
 	}
 
 	getName(): string {
 		return this.name
-			?? `${this.table[MySqlTable.Symbol.Name]}_${this.columns.map((column) => column.name).join('_')}_pk`;
+			?? `${this.table[SingleStoreTable.Symbol.Name]}_${this.columns.map((column) => column.name).join('_')}_pk`;
 	}
 }
diff --git a/drizzle-orm/src/singlestore-core/query-builders/delete.ts b/drizzle-orm/src/singlestore-core/query-builders/delete.ts
index e9a48da8e..e0a463784 100644
--- a/drizzle-orm/src/singlestore-core/query-builders/delete.ts
+++ b/drizzle-orm/src/singlestore-core/query-builders/delete.ts
@@ -1,27 +1,27 @@
 import { entityKind } from '~/entity.ts';
-import type { MySqlDialect } from '~/mysql-core/dialect.ts';
+import { QueryPromise } from '~/query-promise.ts';
+import type { SingleStoreDialect } from '~/singlestore-core/dialect.ts';
 import type {
-	AnyMySqlQueryResultHKT,
-	MySqlPreparedQueryConfig,
-	MySqlQueryResultHKT,
-	MySqlQueryResultKind,
-	MySqlSession,
+	AnySingleStoreQueryResultHKT,
 	PreparedQueryHKTBase,
 	PreparedQueryKind,
-} from '~/mysql-core/session.ts';
-import type { MySqlTable } from '~/mysql-core/table.ts';
-import { QueryPromise } from '~/query-promise.ts';
+	SingleStorePreparedQueryConfig,
+	SingleStoreQueryResultHKT,
+	SingleStoreQueryResultKind,
+	SingleStoreSession,
+} from '~/singlestore-core/session.ts';
+import type { SingleStoreTable } from '~/singlestore-core/table.ts';
 import type { Query, SQL, SQLWrapper } from '~/sql/sql.ts';
 import type { Subquery } from '~/subquery.ts';
 import type { SelectedFieldsOrdered } from './select.types.ts';
 
-export type MySqlDeleteWithout<
-	T extends AnyMySqlDeleteBase,
+export type SingleStoreDeleteWithout<
+	T extends AnySingleStoreDeleteBase,
 	TDynamic extends boolean,
 	K extends keyof T & string,
 > = TDynamic extends true ? T
 	: Omit<
-		MySqlDeleteBase<
+		SingleStoreDeleteBase<
 			T['_']['table'],
 			T['_']['queryResult'],
 			T['_']['preparedQueryHKT'],
@@ -31,43 +31,43 @@ export type MySqlDeleteWithout<
 		T['_']['excludedMethods'] | K
 	>;
 
-export type MySqlDelete<
-	TTable extends MySqlTable = MySqlTable,
-	TQueryResult extends MySqlQueryResultHKT = AnyMySqlQueryResultHKT,
+export type SingleStoreDelete<
+	TTable extends SingleStoreTable = SingleStoreTable,
+	TQueryResult extends SingleStoreQueryResultHKT = AnySingleStoreQueryResultHKT,
 	TPreparedQueryHKT extends PreparedQueryHKTBase = PreparedQueryHKTBase,
-> = MySqlDeleteBase<TTable, TQueryResult, TPreparedQueryHKT, true, never>;
+> = SingleStoreDeleteBase<TTable, TQueryResult, TPreparedQueryHKT, true, never>;
 
-export interface MySqlDeleteConfig {
+export interface SingleStoreDeleteConfig {
 	where?: SQL | undefined;
-	table: MySqlTable;
+	table: SingleStoreTable;
 	returning?: SelectedFieldsOrdered;
 	withList?: Subquery[];
 }
 
-export type MySqlDeletePrepare<T extends AnyMySqlDeleteBase> = PreparedQueryKind<
+export type SingleStoreDeletePrepare<T extends AnySingleStoreDeleteBase> = PreparedQueryKind<
 	T['_']['preparedQueryHKT'],
-	MySqlPreparedQueryConfig & {
-		execute: MySqlQueryResultKind<T['_']['queryResult'], never>;
+	SingleStorePreparedQueryConfig & {
+		execute: SingleStoreQueryResultKind<T['_']['queryResult'], never>;
 		iterator: never;
 	},
 	true
 >;
 
-type MySqlDeleteDynamic<T extends AnyMySqlDeleteBase> = MySqlDelete<
+type SingleStoreDeleteDynamic<T extends AnySingleStoreDeleteBase> = SingleStoreDelete<
 	T['_']['table'],
 	T['_']['queryResult'],
 	T['_']['preparedQueryHKT']
 >;
 
-type AnyMySqlDeleteBase = MySqlDeleteBase<any, any, any, any, any>;
+type AnySingleStoreDeleteBase = SingleStoreDeleteBase<any, any, any, any, any>;
 
-export interface MySqlDeleteBase<
-	TTable extends MySqlTable,
-	TQueryResult extends MySqlQueryResultHKT,
+export interface SingleStoreDeleteBase<
+	TTable extends SingleStoreTable,
+	TQueryResult extends SingleStoreQueryResultHKT,
 	TPreparedQueryHKT extends PreparedQueryHKTBase,
 	TDynamic extends boolean = false,
 	TExcludedMethods extends string = never,
-> extends QueryPromise<MySqlQueryResultKind<TQueryResult, never>> {
+> extends QueryPromise<SingleStoreQueryResultKind<TQueryResult, never>> {
 	readonly _: {
 		readonly table: TTable;
 		readonly queryResult: TQueryResult;
@@ -77,23 +77,23 @@ export interface MySqlDeleteBase<
 	};
 }
 
-export class MySqlDeleteBase<
-	TTable extends MySqlTable,
-	TQueryResult extends MySqlQueryResultHKT,
+export class SingleStoreDeleteBase<
+	TTable extends SingleStoreTable,
+	TQueryResult extends SingleStoreQueryResultHKT,
 	// eslint-disable-next-line @typescript-eslint/no-unused-vars
 	TPreparedQueryHKT extends PreparedQueryHKTBase,
 	TDynamic extends boolean = false,
 	// eslint-disable-next-line @typescript-eslint/no-unused-vars
 	TExcludedMethods extends string = never,
-> extends QueryPromise<MySqlQueryResultKind<TQueryResult, never>> implements SQLWrapper {
-	static readonly [entityKind]: string = 'MySqlDelete';
+> extends QueryPromise<SingleStoreQueryResultKind<TQueryResult, never>> implements SQLWrapper {
+	static readonly [entityKind]: string = 'SingleStoreDelete';
 
-	private config: MySqlDeleteConfig;
+	private config: SingleStoreDeleteConfig;
 
 	constructor(
 		private table: TTable,
-		private session: MySqlSession,
-		private dialect: MySqlDialect,
+		private session: SingleStoreSession,
+		private dialect: SingleStoreDialect,
 		withList?: Subquery[],
 	) {
 		super();
@@ -129,7 +129,7 @@ export class MySqlDeleteBase<
 	 * db.delete(cars).where(or(eq(cars.color, 'green'), eq(cars.color, 'blue')));
 	 * ```
 	 */
-	where(where: SQL | undefined): MySqlDeleteWithout<this, TDynamic, 'where'> {
+	where(where: SQL | undefined): SingleStoreDeleteWithout<this, TDynamic, 'where'> {
 		this.config.where = where;
 		return this as any;
 	}
@@ -144,11 +144,11 @@ export class MySqlDeleteBase<
 		return rest;
 	}
 
-	prepare(): MySqlDeletePrepare<this> {
+	prepare(): SingleStoreDeletePrepare<this> {
 		return this.session.prepareQuery(
 			this.dialect.sqlToQuery(this.getSQL()),
 			this.config.returning,
-		) as MySqlDeletePrepare<this>;
+		) as SingleStoreDeletePrepare<this>;
 	}
 
 	override execute: ReturnType<this['prepare']>['execute'] = (placeholderValues) => {
@@ -164,7 +164,7 @@ export class MySqlDeleteBase<
 
 	iterator = this.createIterator();
 
-	$dynamic(): MySqlDeleteDynamic<this> {
+	$dynamic(): SingleStoreDeleteDynamic<this> {
 		return this as any;
 	}
 }
diff --git a/drizzle-orm/src/singlestore-core/query-builders/insert.ts b/drizzle-orm/src/singlestore-core/query-builders/insert.ts
index 97e61de74..129bf2214 100644
--- a/drizzle-orm/src/singlestore-core/query-builders/insert.ts
+++ b/drizzle-orm/src/singlestore-core/query-builders/insert.ts
@@ -1,27 +1,27 @@
 import { entityKind, is } from '~/entity.ts';
-import type { MySqlDialect } from '~/mysql-core/dialect.ts';
+import { QueryPromise } from '~/query-promise.ts';
+import type { RunnableQuery } from '~/runnable-query.ts';
+import type { SingleStoreDialect } from '~/singlestore-core/dialect.ts';
 import type {
-	AnyMySqlQueryResultHKT,
-	MySqlPreparedQueryConfig,
-	MySqlQueryResultHKT,
-	MySqlQueryResultKind,
-	MySqlSession,
+	AnySingleStoreQueryResultHKT,
 	PreparedQueryHKTBase,
 	PreparedQueryKind,
-} from '~/mysql-core/session.ts';
-import type { MySqlTable } from '~/mysql-core/table.ts';
-import { QueryPromise } from '~/query-promise.ts';
-import type { RunnableQuery } from '~/runnable-query.ts';
+	SingleStorePreparedQueryConfig,
+	SingleStoreQueryResultHKT,
+	SingleStoreQueryResultKind,
+	SingleStoreSession,
+} from '~/singlestore-core/session.ts';
+import type { SingleStoreTable } from '~/singlestore-core/table.ts';
 import type { Placeholder, Query, SQLWrapper } from '~/sql/sql.ts';
 import { Param, SQL, sql } from '~/sql/sql.ts';
 import type { InferModelFromColumns } from '~/table.ts';
 import { Table } from '~/table.ts';
 import { mapUpdateSet, orderSelectedFields } from '~/utils.ts';
-import type { AnyMySqlColumn, MySqlColumn } from '../columns/common.ts';
+import type { AnySingleStoreColumn, SingleStoreColumn } from '../columns/common.ts';
 import type { SelectedFieldsOrdered } from './select.types.ts';
-import type { MySqlUpdateSetSource } from './update.ts';
+import type { SingleStoreUpdateSetSource } from './update.ts';
 
-export interface MySqlInsertConfig<TTable extends MySqlTable = MySqlTable> {
+export interface SingleStoreInsertConfig<TTable extends SingleStoreTable = SingleStoreTable> {
 	table: TTable;
 	values: Record<string, Param | SQL>[];
 	ignore: boolean;
@@ -29,27 +29,27 @@ export interface MySqlInsertConfig<TTable extends MySqlTable = MySqlTable> {
 	returning?: SelectedFieldsOrdered;
 }
 
-export type AnyMySqlInsertConfig = MySqlInsertConfig<MySqlTable>;
+export type AnySingleStoreInsertConfig = SingleStoreInsertConfig<SingleStoreTable>;
 
-export type MySqlInsertValue<TTable extends MySqlTable> =
+export type SingleStoreInsertValue<TTable extends SingleStoreTable> =
 	& {
 		[Key in keyof TTable['$inferInsert']]: TTable['$inferInsert'][Key] | SQL | Placeholder;
 	}
 	& {};
 
-export class MySqlInsertBuilder<
-	TTable extends MySqlTable,
-	TQueryResult extends MySqlQueryResultHKT,
+export class SingleStoreInsertBuilder<
+	TTable extends SingleStoreTable,
+	TQueryResult extends SingleStoreQueryResultHKT,
 	TPreparedQueryHKT extends PreparedQueryHKTBase,
 > {
-	static readonly [entityKind]: string = 'MySqlInsertBuilder';
+	static readonly [entityKind]: string = 'SingleStoreInsertBuilder';
 
 	private shouldIgnore = false;
 
 	constructor(
 		private table: TTable,
-		private session: MySqlSession,
-		private dialect: MySqlDialect,
+		private session: SingleStoreSession,
+		private dialect: SingleStoreDialect,
 	) {}
 
 	ignore(): this {
@@ -57,11 +57,11 @@ export class MySqlInsertBuilder<
 		return this;
 	}
 
-	values(value: MySqlInsertValue<TTable>): MySqlInsertBase<TTable, TQueryResult, TPreparedQueryHKT>;
-	values(values: MySqlInsertValue<TTable>[]): MySqlInsertBase<TTable, TQueryResult, TPreparedQueryHKT>;
+	values(value: SingleStoreInsertValue<TTable>): SingleStoreInsertBase<TTable, TQueryResult, TPreparedQueryHKT>;
+	values(values: SingleStoreInsertValue<TTable>[]): SingleStoreInsertBase<TTable, TQueryResult, TPreparedQueryHKT>;
 	values(
-		values: MySqlInsertValue<TTable> | MySqlInsertValue<TTable>[],
-	): MySqlInsertBase<TTable, TQueryResult, TPreparedQueryHKT> {
+		values: SingleStoreInsertValue<TTable> | SingleStoreInsertValue<TTable>[],
+	): SingleStoreInsertBase<TTable, TQueryResult, TPreparedQueryHKT> {
 		values = Array.isArray(values) ? values : [values];
 		if (values.length === 0) {
 			throw new Error('values() must be called with at least one value');
@@ -76,58 +76,61 @@ export class MySqlInsertBuilder<
 			return result;
 		});
 
-		return new MySqlInsertBase(this.table, mappedValues, this.shouldIgnore, this.session, this.dialect);
+		return new SingleStoreInsertBase(this.table, mappedValues, this.shouldIgnore, this.session, this.dialect);
 	}
 }
 
-export type MySqlInsertWithout<T extends AnyMySqlInsert, TDynamic extends boolean, K extends keyof T & string> =
-	TDynamic extends true ? T
-		: Omit<
-			MySqlInsertBase<
-				T['_']['table'],
-				T['_']['queryResult'],
-				T['_']['preparedQueryHKT'],
-				T['_']['returning'],
-				TDynamic,
-				T['_']['excludedMethods'] | '$returning'
-			>,
-			T['_']['excludedMethods'] | K
-		>;
-
-export type MySqlInsertDynamic<T extends AnyMySqlInsert> = MySqlInsert<
+export type SingleStoreInsertWithout<
+	T extends AnySingleStoreInsert,
+	TDynamic extends boolean,
+	K extends keyof T & string,
+> = TDynamic extends true ? T
+	: Omit<
+		SingleStoreInsertBase<
+			T['_']['table'],
+			T['_']['queryResult'],
+			T['_']['preparedQueryHKT'],
+			T['_']['returning'],
+			TDynamic,
+			T['_']['excludedMethods'] | '$returning'
+		>,
+		T['_']['excludedMethods'] | K
+	>;
+
+export type SingleStoreInsertDynamic<T extends AnySingleStoreInsert> = SingleStoreInsert<
 	T['_']['table'],
 	T['_']['queryResult'],
 	T['_']['preparedQueryHKT'],
 	T['_']['returning']
 >;
 
-export type MySqlInsertPrepare<
-	T extends AnyMySqlInsert,
+export type SingleStoreInsertPrepare<
+	T extends AnySingleStoreInsert,
 	TReturning extends Record<string, unknown> | undefined = undefined,
 > = PreparedQueryKind<
 	T['_']['preparedQueryHKT'],
-	MySqlPreparedQueryConfig & {
-		execute: TReturning extends undefined ? MySqlQueryResultKind<T['_']['queryResult'], never> : TReturning[];
+	SingleStorePreparedQueryConfig & {
+		execute: TReturning extends undefined ? SingleStoreQueryResultKind<T['_']['queryResult'], never> : TReturning[];
 		iterator: never;
 	},
 	true
 >;
 
-export type MySqlInsertOnDuplicateKeyUpdateConfig<T extends AnyMySqlInsert> = {
-	set: MySqlUpdateSetSource<T['_']['table']>;
+export type SingleStoreInsertOnDuplicateKeyUpdateConfig<T extends AnySingleStoreInsert> = {
+	set: SingleStoreUpdateSetSource<T['_']['table']>;
 };
 
-export type MySqlInsert<
-	TTable extends MySqlTable = MySqlTable,
-	TQueryResult extends MySqlQueryResultHKT = AnyMySqlQueryResultHKT,
+export type SingleStoreInsert<
+	TTable extends SingleStoreTable = SingleStoreTable,
+	TQueryResult extends SingleStoreQueryResultHKT = AnySingleStoreQueryResultHKT,
 	TPreparedQueryHKT extends PreparedQueryHKTBase = PreparedQueryHKTBase,
 	TReturning extends Record<string, unknown> | undefined = Record<string, unknown> | undefined,
-> = MySqlInsertBase<TTable, TQueryResult, TPreparedQueryHKT, TReturning, true, never>;
+> = SingleStoreInsertBase<TTable, TQueryResult, TPreparedQueryHKT, TReturning, true, never>;
 
-export type MySqlInsertReturning<
-	T extends AnyMySqlInsert,
+export type SingleStoreInsertReturning<
+	T extends AnySingleStoreInsert,
 	TDynamic extends boolean,
-> = MySqlInsertBase<
+> = SingleStoreInsertBase<
 	T['_']['table'],
 	T['_']['queryResult'],
 	T['_']['preparedQueryHKT'],
@@ -136,33 +139,36 @@ export type MySqlInsertReturning<
 	T['_']['excludedMethods'] | '$returning'
 >;
 
-export type AnyMySqlInsert = MySqlInsertBase<any, any, any, any, any, any>;
+export type AnySingleStoreInsert = SingleStoreInsertBase<any, any, any, any, any, any>;
 
-export interface MySqlInsertBase<
-	TTable extends MySqlTable,
-	TQueryResult extends MySqlQueryResultHKT,
+export interface SingleStoreInsertBase<
+	TTable extends SingleStoreTable,
+	TQueryResult extends SingleStoreQueryResultHKT,
 	TPreparedQueryHKT extends PreparedQueryHKTBase,
 	TReturning extends Record<string, unknown> | undefined = undefined,
 	TDynamic extends boolean = false,
 	TExcludedMethods extends string = never,
 > extends
-	QueryPromise<TReturning extends undefined ? MySqlQueryResultKind<TQueryResult, never> : TReturning[]>,
-	RunnableQuery<TReturning extends undefined ? MySqlQueryResultKind<TQueryResult, never> : TReturning[], 'mysql'>,
+	QueryPromise<TReturning extends undefined ? SingleStoreQueryResultKind<TQueryResult, never> : TReturning[]>,
+	RunnableQuery<
+		TReturning extends undefined ? SingleStoreQueryResultKind<TQueryResult, never> : TReturning[],
+		'singlestore'
+	>,
 	SQLWrapper
 {
 	readonly _: {
-		readonly dialect: 'mysql';
+		readonly dialect: 'singlestore';
 		readonly table: TTable;
 		readonly queryResult: TQueryResult;
 		readonly preparedQueryHKT: TPreparedQueryHKT;
 		readonly dynamic: TDynamic;
 		readonly excludedMethods: TExcludedMethods;
 		readonly returning: TReturning;
-		readonly result: TReturning extends undefined ? MySqlQueryResultKind<TQueryResult, never> : TReturning[];
+		readonly result: TReturning extends undefined ? SingleStoreQueryResultKind<TQueryResult, never> : TReturning[];
 	};
 }
 
-export type PrimaryKeyKeys<T extends Record<string, AnyMySqlColumn>> = {
+export type PrimaryKeyKeys<T extends Record<string, AnySingleStoreColumn>> = {
 	[K in keyof T]: T[K]['_']['isPrimaryKey'] extends true ? T[K]['_']['isAutoincrement'] extends true ? K
 		: T[K]['_']['hasRuntimeDefault'] extends true ? T[K]['_']['isPrimaryKey'] extends true ? K : never
 		: never
@@ -170,13 +176,13 @@ export type PrimaryKeyKeys<T extends Record<string, AnyMySqlColumn>> = {
 		: never;
 }[keyof T];
 
-export type GetPrimarySerialOrDefaultKeys<T extends Record<string, AnyMySqlColumn>> = {
+export type GetPrimarySerialOrDefaultKeys<T extends Record<string, AnySingleStoreColumn>> = {
 	[K in PrimaryKeyKeys<T>]: T[K];
 };
 
-export class MySqlInsertBase<
-	TTable extends MySqlTable,
-	TQueryResult extends MySqlQueryResultHKT,
+export class SingleStoreInsertBase<
+	TTable extends SingleStoreTable,
+	TQueryResult extends SingleStoreQueryResultHKT,
 	// eslint-disable-next-line @typescript-eslint/no-unused-vars
 	TPreparedQueryHKT extends PreparedQueryHKTBase,
 	// eslint-disable-next-line @typescript-eslint/no-unused-vars
@@ -185,23 +191,26 @@ export class MySqlInsertBase<
 	TDynamic extends boolean = false,
 	// eslint-disable-next-line @typescript-eslint/no-unused-vars
 	TExcludedMethods extends string = never,
-> extends QueryPromise<TReturning extends undefined ? MySqlQueryResultKind<TQueryResult, never> : TReturning[]>
+> extends QueryPromise<TReturning extends undefined ? SingleStoreQueryResultKind<TQueryResult, never> : TReturning[]>
 	implements
-		RunnableQuery<TReturning extends undefined ? MySqlQueryResultKind<TQueryResult, never> : TReturning[], 'mysql'>,
+		RunnableQuery<
+			TReturning extends undefined ? SingleStoreQueryResultKind<TQueryResult, never> : TReturning[],
+			'singlestore'
+		>,
 		SQLWrapper
 {
-	static readonly [entityKind]: string = 'MySqlInsert';
+	static readonly [entityKind]: string = 'SingleStoreInsert';
 
 	declare protected $table: TTable;
 
-	private config: MySqlInsertConfig<TTable>;
+	private config: SingleStoreInsertConfig<TTable>;
 
 	constructor(
 		table: TTable,
-		values: MySqlInsertConfig['values'],
+		values: SingleStoreInsertConfig['values'],
 		ignore: boolean,
-		private session: MySqlSession,
-		private dialect: MySqlDialect,
+		private session: SingleStoreSession,
+		private dialect: SingleStoreDialect,
 	) {
 		super();
 		this.config = { table, values, ignore };
@@ -210,7 +219,7 @@ export class MySqlInsertBase<
 	/**
 	 * Adds an `on duplicate key update` clause to the query.
 	 *
-	 * Calling this method will update update the row if any unique index conflicts. MySQL will automatically determine the conflict target based on the primary key and unique indexes.
+	 * Calling this method will update update the row if any unique index conflicts. SingleStore will automatically determine the conflict target based on the primary key and unique indexes.
 	 *
 	 * See docs: {@link https://orm.drizzle.team/docs/insert#on-duplicate-key-update}
 	 *
@@ -223,7 +232,7 @@ export class MySqlInsertBase<
 	 *   .onDuplicateKeyUpdate({ set: { brand: 'Porsche' }});
 	 * ```
 	 *
-	 * While MySQL does not directly support doing nothing on conflict, you can perform a no-op by setting any column's value to itself and achieve the same effect:
+	 * While SingleStore does not directly support doing nothing on conflict, you can perform a no-op by setting any column's value to itself and achieve the same effect:
 	 *
 	 * ```ts
 	 * import { sql } from 'drizzle-orm';
@@ -234,15 +243,15 @@ export class MySqlInsertBase<
 	 * ```
 	 */
 	onDuplicateKeyUpdate(
-		config: MySqlInsertOnDuplicateKeyUpdateConfig<this>,
-	): MySqlInsertWithout<this, TDynamic, 'onDuplicateKeyUpdate'> {
+		config: SingleStoreInsertOnDuplicateKeyUpdateConfig<this>,
+	): SingleStoreInsertWithout<this, TDynamic, 'onDuplicateKeyUpdate'> {
 		const setSql = this.dialect.buildUpdateSet(this.config.table, mapUpdateSet(this.config.table, config.set));
 		this.config.onConflict = sql`update ${setSql}`;
 		return this as any;
 	}
 
-	$returningId(): MySqlInsertWithout<
-		MySqlInsertReturning<this, TDynamic>,
+	$returningId(): SingleStoreInsertWithout<
+		SingleStoreInsertReturning<this, TDynamic>,
 		TDynamic,
 		'$returningId'
 	> {
@@ -252,7 +261,7 @@ export class MySqlInsertBase<
 				returning.push({ field: value, path: [key] });
 			}
 		}
-		this.config.returning = orderSelectedFields<MySqlColumn>(this.config.table[Table.Symbol.Columns]);
+		this.config.returning = orderSelectedFields<SingleStoreColumn>(this.config.table[Table.Symbol.Columns]);
 		return this as any;
 	}
 
@@ -266,7 +275,7 @@ export class MySqlInsertBase<
 		return rest;
 	}
 
-	prepare(): MySqlInsertPrepare<this, TReturning> {
+	prepare(): SingleStoreInsertPrepare<this, TReturning> {
 		const { sql, generatedIds } = this.dialect.buildInsertQuery(this.config);
 		return this.session.prepareQuery(
 			this.dialect.sqlToQuery(sql),
@@ -274,7 +283,7 @@ export class MySqlInsertBase<
 			undefined,
 			generatedIds,
 			this.config.returning,
-		) as MySqlInsertPrepare<this, TReturning>;
+		) as SingleStoreInsertPrepare<this, TReturning>;
 	}
 
 	override execute: ReturnType<this['prepare']>['execute'] = (placeholderValues) => {
@@ -290,7 +299,7 @@ export class MySqlInsertBase<
 
 	iterator = this.createIterator();
 
-	$dynamic(): MySqlInsertDynamic<this> {
+	$dynamic(): SingleStoreInsertDynamic<this> {
 		return this as any;
 	}
 }
diff --git a/drizzle-orm/src/singlestore-core/query-builders/query-builder.ts b/drizzle-orm/src/singlestore-core/query-builders/query-builder.ts
index f5d9cacc4..b76a0457e 100644
--- a/drizzle-orm/src/singlestore-core/query-builders/query-builder.ts
+++ b/drizzle-orm/src/singlestore-core/query-builders/query-builder.ts
@@ -1,17 +1,17 @@
 import { entityKind } from '~/entity.ts';
-import { MySqlDialect } from '~/mysql-core/dialect.ts';
-import type { WithSubqueryWithSelection } from '~/mysql-core/subquery.ts';
 import type { TypedQueryBuilder } from '~/query-builders/query-builder.ts';
 import { SelectionProxyHandler } from '~/selection-proxy.ts';
+import { SingleStoreDialect } from '~/singlestore-core/dialect.ts';
+import type { WithSubqueryWithSelection } from '~/singlestore-core/subquery.ts';
 import type { ColumnsSelection } from '~/sql/sql.ts';
 import { WithSubquery } from '~/subquery.ts';
-import { MySqlSelectBuilder } from './select.ts';
+import { SingleStoreSelectBuilder } from './select.ts';
 import type { SelectedFields } from './select.types.ts';
 
 export class QueryBuilder {
-	static readonly [entityKind]: string = 'MySqlQueryBuilder';
+	static readonly [entityKind]: string = 'SingleStoreQueryBuilder';
 
-	private dialect: MySqlDialect | undefined;
+	private dialect: SingleStoreDialect | undefined;
 
 	$with<TAlias extends string>(alias: TAlias) {
 		const queryBuilder = this;
@@ -35,14 +35,14 @@ export class QueryBuilder {
 	with(...queries: WithSubquery[]) {
 		const self = this;
 
-		function select(): MySqlSelectBuilder<undefined, never, 'qb'>;
+		function select(): SingleStoreSelectBuilder<undefined, never, 'qb'>;
 		function select<TSelection extends SelectedFields>(
 			fields: TSelection,
-		): MySqlSelectBuilder<TSelection, never, 'qb'>;
+		): SingleStoreSelectBuilder<TSelection, never, 'qb'>;
 		function select<TSelection extends SelectedFields>(
 			fields?: TSelection,
-		): MySqlSelectBuilder<TSelection | undefined, never, 'qb'> {
-			return new MySqlSelectBuilder({
+		): SingleStoreSelectBuilder<TSelection | undefined, never, 'qb'> {
+			return new SingleStoreSelectBuilder({
 				fields: fields ?? undefined,
 				session: undefined,
 				dialect: self.getDialect(),
@@ -50,14 +50,14 @@ export class QueryBuilder {
 			});
 		}
 
-		function selectDistinct(): MySqlSelectBuilder<undefined, never, 'qb'>;
+		function selectDistinct(): SingleStoreSelectBuilder<undefined, never, 'qb'>;
 		function selectDistinct<TSelection extends SelectedFields>(
 			fields: TSelection,
-		): MySqlSelectBuilder<TSelection, never, 'qb'>;
+		): SingleStoreSelectBuilder<TSelection, never, 'qb'>;
 		function selectDistinct<TSelection extends SelectedFields>(
 			fields?: TSelection,
-		): MySqlSelectBuilder<TSelection | undefined, never, 'qb'> {
-			return new MySqlSelectBuilder({
+		): SingleStoreSelectBuilder<TSelection | undefined, never, 'qb'> {
+			return new SingleStoreSelectBuilder({
 				fields: fields ?? undefined,
 				session: undefined,
 				dialect: self.getDialect(),
@@ -69,22 +69,26 @@ export class QueryBuilder {
 		return { select, selectDistinct };
 	}
 
-	select(): MySqlSelectBuilder<undefined, never, 'qb'>;
-	select<TSelection extends SelectedFields>(fields: TSelection): MySqlSelectBuilder<TSelection, never, 'qb'>;
+	select(): SingleStoreSelectBuilder<undefined, never, 'qb'>;
+	select<TSelection extends SelectedFields>(fields: TSelection): SingleStoreSelectBuilder<TSelection, never, 'qb'>;
 	select<TSelection extends SelectedFields>(
 		fields?: TSelection,
-	): MySqlSelectBuilder<TSelection | undefined, never, 'qb'> {
-		return new MySqlSelectBuilder({ fields: fields ?? undefined, session: undefined, dialect: this.getDialect() });
+	): SingleStoreSelectBuilder<TSelection | undefined, never, 'qb'> {
+		return new SingleStoreSelectBuilder({
+			fields: fields ?? undefined,
+			session: undefined,
+			dialect: this.getDialect(),
+		});
 	}
 
-	selectDistinct(): MySqlSelectBuilder<undefined, never, 'qb'>;
+	selectDistinct(): SingleStoreSelectBuilder<undefined, never, 'qb'>;
 	selectDistinct<TSelection extends SelectedFields>(
 		fields: TSelection,
-	): MySqlSelectBuilder<TSelection, never, 'qb'>;
+	): SingleStoreSelectBuilder<TSelection, never, 'qb'>;
 	selectDistinct<TSelection extends SelectedFields>(
 		fields?: TSelection,
-	): MySqlSelectBuilder<TSelection | undefined, never, 'qb'> {
-		return new MySqlSelectBuilder({
+	): SingleStoreSelectBuilder<TSelection | undefined, never, 'qb'> {
+		return new SingleStoreSelectBuilder({
 			fields: fields ?? undefined,
 			session: undefined,
 			dialect: this.getDialect(),
@@ -95,7 +99,7 @@ export class QueryBuilder {
 	// Lazy load dialect to avoid circular dependency
 	private getDialect() {
 		if (!this.dialect) {
-			this.dialect = new MySqlDialect();
+			this.dialect = new SingleStoreDialect();
 		}
 
 		return this.dialect;
diff --git a/drizzle-orm/src/singlestore-core/query-builders/query.ts b/drizzle-orm/src/singlestore-core/query-builders/query.ts
index 955f73428..40d3f05ad 100644
--- a/drizzle-orm/src/singlestore-core/query-builders/query.ts
+++ b/drizzle-orm/src/singlestore-core/query-builders/query.ts
@@ -10,38 +10,38 @@ import {
 } from '~/relations.ts';
 import type { Query, QueryWithTypings, SQL } from '~/sql/sql.ts';
 import type { KnownKeysOnly } from '~/utils.ts';
-import type { MySqlDialect } from '../dialect.ts';
+import type { SingleStoreDialect } from '../dialect.ts';
 import type {
 	Mode,
-	MySqlPreparedQueryConfig,
-	MySqlSession,
 	PreparedQueryHKTBase,
 	PreparedQueryKind,
+	SingleStorePreparedQueryConfig,
+	SingleStoreSession,
 } from '../session.ts';
-import type { MySqlTable } from '../table.ts';
+import type { SingleStoreTable } from '../table.ts';
 
 export class RelationalQueryBuilder<
 	TPreparedQueryHKT extends PreparedQueryHKTBase,
 	TSchema extends TablesRelationalConfig,
 	TFields extends TableRelationalConfig,
 > {
-	static readonly [entityKind]: string = 'MySqlRelationalQueryBuilder';
+	static readonly [entityKind]: string = 'SingleStoreRelationalQueryBuilder';
 
 	constructor(
 		private fullSchema: Record<string, unknown>,
 		private schema: TSchema,
 		private tableNamesMap: Record<string, string>,
-		private table: MySqlTable,
+		private table: SingleStoreTable,
 		private tableConfig: TableRelationalConfig,
-		private dialect: MySqlDialect,
-		private session: MySqlSession,
+		private dialect: SingleStoreDialect,
+		private session: SingleStoreSession,
 		private mode: Mode,
 	) {}
 
 	findMany<TConfig extends DBQueryConfig<'many', true, TSchema, TFields>>(
 		config?: KnownKeysOnly<TConfig, DBQueryConfig<'many', true, TSchema, TFields>>,
-	): MySqlRelationalQuery<TPreparedQueryHKT, BuildQueryResult<TSchema, TFields, TConfig>[]> {
-		return new MySqlRelationalQuery(
+	): SingleStoreRelationalQuery<TPreparedQueryHKT, BuildQueryResult<TSchema, TFields, TConfig>[]> {
+		return new SingleStoreRelationalQuery(
 			this.fullSchema,
 			this.schema,
 			this.tableNamesMap,
@@ -57,8 +57,8 @@ export class RelationalQueryBuilder<
 
 	findFirst<TSelection extends Omit<DBQueryConfig<'many', true, TSchema, TFields>, 'limit'>>(
 		config?: KnownKeysOnly<TSelection, Omit<DBQueryConfig<'many', true, TSchema, TFields>, 'limit'>>,
-	): MySqlRelationalQuery<TPreparedQueryHKT, BuildQueryResult<TSchema, TFields, TSelection> | undefined> {
-		return new MySqlRelationalQuery(
+	): SingleStoreRelationalQuery<TPreparedQueryHKT, BuildQueryResult<TSchema, TFields, TSelection> | undefined> {
+		return new SingleStoreRelationalQuery(
 			this.fullSchema,
 			this.schema,
 			this.tableNamesMap,
@@ -73,22 +73,22 @@ export class RelationalQueryBuilder<
 	}
 }
 
-export class MySqlRelationalQuery<
+export class SingleStoreRelationalQuery<
 	TPreparedQueryHKT extends PreparedQueryHKTBase,
 	TResult,
 > extends QueryPromise<TResult> {
-	static readonly [entityKind]: string = 'MySqlRelationalQuery';
+	static readonly [entityKind]: string = 'SingleStoreRelationalQuery';
 
-	declare protected $brand: 'MySqlRelationalQuery';
+	declare protected $brand: 'SingleStoreRelationalQuery';
 
 	constructor(
 		private fullSchema: Record<string, unknown>,
 		private schema: TablesRelationalConfig,
 		private tableNamesMap: Record<string, string>,
-		private table: MySqlTable,
+		private table: SingleStoreTable,
 		private tableConfig: TableRelationalConfig,
-		private dialect: MySqlDialect,
-		private session: MySqlSession,
+		private dialect: SingleStoreDialect,
+		private session: SingleStoreSession,
 		private config: DBQueryConfig<'many', true> | true,
 		private queryMode: 'many' | 'first',
 		private mode?: Mode,
@@ -108,7 +108,7 @@ export class MySqlRelationalQuery<
 				}
 				return rows as TResult;
 			},
-		) as PreparedQueryKind<TPreparedQueryHKT, MySqlPreparedQueryConfig & { execute: TResult }, true>;
+		) as PreparedQueryKind<TPreparedQueryHKT, SingleStorePreparedQueryConfig & { execute: TResult }, true>;
 	}
 
 	private _getQuery() {
diff --git a/drizzle-orm/src/singlestore-core/query-builders/select.ts b/drizzle-orm/src/singlestore-core/query-builders/select.ts
index a5a0ca69a..419aafca0 100644
--- a/drizzle-orm/src/singlestore-core/query-builders/select.ts
+++ b/drizzle-orm/src/singlestore-core/query-builders/select.ts
@@ -1,9 +1,4 @@
 import { entityKind, is } from '~/entity.ts';
-import type { MySqlColumn } from '~/mysql-core/columns/index.ts';
-import type { MySqlDialect } from '~/mysql-core/dialect.ts';
-import type { MySqlPreparedQueryConfig, MySqlSession, PreparedQueryHKTBase } from '~/mysql-core/session.ts';
-import type { SubqueryWithSelection } from '~/mysql-core/subquery.ts';
-import type { MySqlTable } from '~/mysql-core/table.ts';
 import { TypedQueryBuilder } from '~/query-builders/query-builder.ts';
 import type {
 	BuildSubquerySelection,
@@ -17,6 +12,15 @@ import type {
 } from '~/query-builders/select.types.ts';
 import { QueryPromise } from '~/query-promise.ts';
 import { SelectionProxyHandler } from '~/selection-proxy.ts';
+import type { SingleStoreColumn } from '~/singlestore-core/columns/index.ts';
+import type { SingleStoreDialect } from '~/singlestore-core/dialect.ts';
+import type {
+	PreparedQueryHKTBase,
+	SingleStorePreparedQueryConfig,
+	SingleStoreSession,
+} from '~/singlestore-core/session.ts';
+import type { SubqueryWithSelection } from '~/singlestore-core/subquery.ts';
+import type { SingleStoreTable } from '~/singlestore-core/table.ts';
 import type { ColumnsSelection, Query } from '~/sql/sql.ts';
 import { SQL, View } from '~/sql/sql.ts';
 import { Subquery } from '~/subquery.ts';
@@ -24,45 +28,45 @@ import { Table } from '~/table.ts';
 import { applyMixins, getTableColumns, getTableLikeName, haveSameKeys, type ValueOrArray } from '~/utils.ts';
 import { orderSelectedFields } from '~/utils.ts';
 import { ViewBaseConfig } from '~/view-common.ts';
-import { MySqlViewBase } from '../view-base.ts';
+import { SingleStoreViewBase } from '../view-base.ts';
 import type {
-	AnyMySqlSelect,
-	CreateMySqlSelectFromBuilderMode,
-	GetMySqlSetOperators,
+	AnySingleStoreSelect,
+	CreateSingleStoreSelectFromBuilderMode,
+	GetSingleStoreSetOperators,
 	LockConfig,
 	LockStrength,
-	MySqlCreateSetOperatorFn,
-	MySqlJoinFn,
-	MySqlSelectConfig,
-	MySqlSelectDynamic,
-	MySqlSelectHKT,
-	MySqlSelectHKTBase,
-	MySqlSelectPrepare,
-	MySqlSelectWithout,
-	MySqlSetOperatorExcludedMethods,
-	MySqlSetOperatorWithResult,
 	SelectedFields,
 	SetOperatorRightSelect,
+	SingleStoreCreateSetOperatorFn,
+	SingleStoreJoinFn,
+	SingleStoreSelectConfig,
+	SingleStoreSelectDynamic,
+	SingleStoreSelectHKT,
+	SingleStoreSelectHKTBase,
+	SingleStoreSelectPrepare,
+	SingleStoreSelectWithout,
+	SingleStoreSetOperatorExcludedMethods,
+	SingleStoreSetOperatorWithResult,
 } from './select.types.ts';
 
-export class MySqlSelectBuilder<
+export class SingleStoreSelectBuilder<
 	TSelection extends SelectedFields | undefined,
 	TPreparedQueryHKT extends PreparedQueryHKTBase,
 	TBuilderMode extends 'db' | 'qb' = 'db',
 > {
-	static readonly [entityKind]: string = 'MySqlSelectBuilder';
+	static readonly [entityKind]: string = 'SingleStoreSelectBuilder';
 
 	private fields: TSelection;
-	private session: MySqlSession | undefined;
-	private dialect: MySqlDialect;
+	private session: SingleStoreSession | undefined;
+	private dialect: SingleStoreDialect;
 	private withList: Subquery[] = [];
 	private distinct: boolean | undefined;
 
 	constructor(
 		config: {
 			fields: TSelection;
-			session: MySqlSession | undefined;
-			dialect: MySqlDialect;
+			session: SingleStoreSession | undefined;
+			dialect: SingleStoreDialect;
 			withList?: Subquery[];
 			distinct?: boolean;
 		},
@@ -76,9 +80,9 @@ export class MySqlSelectBuilder<
 		this.distinct = config.distinct;
 	}
 
-	from<TFrom extends MySqlTable | Subquery | MySqlViewBase | SQL>(
+	from<TFrom extends SingleStoreTable | Subquery | SingleStoreViewBase | SQL>(
 		source: TFrom,
-	): CreateMySqlSelectFromBuilderMode<
+	): CreateSingleStoreSelectFromBuilderMode<
 		TBuilderMode,
 		GetSelectTableName<TFrom>,
 		TSelection extends undefined ? GetSelectTableSelection<TFrom> : TSelection,
@@ -97,15 +101,15 @@ export class MySqlSelectBuilder<
 					key,
 				) => [key, source[key as unknown as keyof typeof source] as unknown as SelectedFields[string]]),
 			);
-		} else if (is(source, MySqlViewBase)) {
+		} else if (is(source, SingleStoreViewBase)) {
 			fields = source[ViewBaseConfig].selectedFields as SelectedFields;
 		} else if (is(source, SQL)) {
 			fields = {};
 		} else {
-			fields = getTableColumns<MySqlTable>(source);
+			fields = getTableColumns<SingleStoreTable>(source);
 		}
 
-		return new MySqlSelectBase(
+		return new SingleStoreSelectBase(
 			{
 				table: source,
 				fields,
@@ -119,8 +123,8 @@ export class MySqlSelectBuilder<
 	}
 }
 
-export abstract class MySqlSelectQueryBuilderBase<
-	THKT extends MySqlSelectHKTBase,
+export abstract class SingleStoreSelectQueryBuilderBase<
+	THKT extends SingleStoreSelectHKTBase,
 	TTableName extends string | undefined,
 	TSelection extends ColumnsSelection,
 	TSelectMode extends SelectMode,
@@ -132,7 +136,7 @@ export abstract class MySqlSelectQueryBuilderBase<
 	TResult extends any[] = SelectResult<TSelection, TSelectMode, TNullabilityMap>[],
 	TSelectedFields extends ColumnsSelection = BuildSubquerySelection<TSelection, TNullabilityMap>,
 > extends TypedQueryBuilder<TSelectedFields, TResult> {
-	static readonly [entityKind]: string = 'MySqlSelectQueryBuilder';
+	static readonly [entityKind]: string = 'SingleStoreSelectQueryBuilder';
 
 	override readonly _: {
 		readonly hkt: THKT;
@@ -147,21 +151,21 @@ export abstract class MySqlSelectQueryBuilderBase<
 		readonly selectedFields: TSelectedFields;
 	};
 
-	protected config: MySqlSelectConfig;
+	protected config: SingleStoreSelectConfig;
 	protected joinsNotNullableMap: Record<string, boolean>;
 	private tableName: string | undefined;
 	private isPartialSelect: boolean;
 	/** @internal */
-	readonly session: MySqlSession | undefined;
-	protected dialect: MySqlDialect;
+	readonly session: SingleStoreSession | undefined;
+	protected dialect: SingleStoreDialect;
 
 	constructor(
 		{ table, fields, isPartialSelect, session, dialect, withList, distinct }: {
-			table: MySqlSelectConfig['table'];
-			fields: MySqlSelectConfig['fields'];
+			table: SingleStoreSelectConfig['table'];
+			fields: SingleStoreSelectConfig['fields'];
 			isPartialSelect: boolean;
-			session: MySqlSession | undefined;
-			dialect: MySqlDialect;
+			session: SingleStoreSession | undefined;
+			dialect: SingleStoreDialect;
 			withList: Subquery[];
 			distinct: boolean | undefined;
 		},
@@ -186,9 +190,9 @@ export abstract class MySqlSelectQueryBuilderBase<
 
 	private createJoin<TJoinType extends JoinType>(
 		joinType: TJoinType,
-	): MySqlJoinFn<this, TDynamic, TJoinType> {
+	): SingleStoreJoinFn<this, TDynamic, TJoinType> {
 		return (
-			table: MySqlTable | Subquery | MySqlViewBase | SQL,
+			table: SingleStoreTable | Subquery | SingleStoreViewBase | SQL,
 			on: ((aliases: TSelection) => SQL | undefined) | SQL | undefined,
 		) => {
 			const baseTableName = this.tableName;
@@ -380,19 +384,19 @@ export abstract class MySqlSelectQueryBuilderBase<
 	private createSetOperator(
 		type: SetOperator,
 		isAll: boolean,
-	): <TValue extends MySqlSetOperatorWithResult<TResult>>(
+	): <TValue extends SingleStoreSetOperatorWithResult<TResult>>(
 		rightSelection:
-			| ((setOperators: GetMySqlSetOperators) => SetOperatorRightSelect<TValue, TResult>)
+			| ((setOperators: GetSingleStoreSetOperators) => SetOperatorRightSelect<TValue, TResult>)
 			| SetOperatorRightSelect<TValue, TResult>,
-	) => MySqlSelectWithout<
+	) => SingleStoreSelectWithout<
 		this,
 		TDynamic,
-		MySqlSetOperatorExcludedMethods,
+		SingleStoreSetOperatorExcludedMethods,
 		true
 	> {
 		return (rightSelection) => {
 			const rightSelect = (typeof rightSelection === 'function'
-				? rightSelection(getMySqlSetOperators())
+				? rightSelection(getSingleStoreSetOperators())
 				: rightSelection) as TypedQueryBuilder<
 					any,
 					TResult
@@ -426,7 +430,7 @@ export abstract class MySqlSelectQueryBuilderBase<
 	 *     db.select({ name: customers.name }).from(customers)
 	 *   );
 	 * // or
-	 * import { union } from 'drizzle-orm/mysql-core'
+	 * import { union } from 'drizzle-orm/singlestore-core'
 	 *
 	 * await union(
 	 *   db.select({ name: users.name }).from(users),
@@ -453,7 +457,7 @@ export abstract class MySqlSelectQueryBuilderBase<
 	 *     db.select({ transaction: inStoreSales.transactionId }).from(inStoreSales)
 	 *   );
 	 * // or
-	 * import { unionAll } from 'drizzle-orm/mysql-core'
+	 * import { unionAll } from 'drizzle-orm/singlestore-core'
 	 *
 	 * await unionAll(
 	 *   db.select({ transaction: onlineSales.transactionId }).from(onlineSales),
@@ -480,7 +484,7 @@ export abstract class MySqlSelectQueryBuilderBase<
 	 *     db.select({ courseName: depB.courseName }).from(depB)
 	 *   );
 	 * // or
-	 * import { intersect } from 'drizzle-orm/mysql-core'
+	 * import { intersect } from 'drizzle-orm/singlestore-core'
 	 *
 	 * await intersect(
 	 *   db.select({ courseName: depA.courseName }).from(depA),
@@ -514,7 +518,7 @@ export abstract class MySqlSelectQueryBuilderBase<
 	 *   .from(vipCustomerOrders)
 	 * );
 	 * // or
-	 * import { intersectAll } from 'drizzle-orm/mysql-core'
+	 * import { intersectAll } from 'drizzle-orm/singlestore-core'
 	 *
 	 * await intersectAll(
 	 *   db.select({
@@ -549,7 +553,7 @@ export abstract class MySqlSelectQueryBuilderBase<
 	 *     db.select({ courseName: depB.courseName }).from(depB)
 	 *   );
 	 * // or
-	 * import { except } from 'drizzle-orm/mysql-core'
+	 * import { except } from 'drizzle-orm/singlestore-core'
 	 *
 	 * await except(
 	 *   db.select({ courseName: depA.courseName }).from(depA),
@@ -583,7 +587,7 @@ export abstract class MySqlSelectQueryBuilderBase<
 	 *   .from(vipCustomerOrders)
 	 * );
 	 * // or
-	 * import { exceptAll } from 'drizzle-orm/mysql-core'
+	 * import { exceptAll } from 'drizzle-orm/singlestore-core'
 	 *
 	 * await exceptAll(
 	 *   db.select({
@@ -602,10 +606,10 @@ export abstract class MySqlSelectQueryBuilderBase<
 	exceptAll = this.createSetOperator('except', true);
 
 	/** @internal */
-	addSetOperators(setOperators: MySqlSelectConfig['setOperators']): MySqlSelectWithout<
+	addSetOperators(setOperators: SingleStoreSelectConfig['setOperators']): SingleStoreSelectWithout<
 		this,
 		TDynamic,
-		MySqlSetOperatorExcludedMethods,
+		SingleStoreSetOperatorExcludedMethods,
 		true
 	> {
 		this.config.setOperators.push(...setOperators);
@@ -643,7 +647,7 @@ export abstract class MySqlSelectQueryBuilderBase<
 	 */
 	where(
 		where: ((aliases: this['_']['selection']) => SQL | undefined) | SQL | undefined,
-	): MySqlSelectWithout<this, TDynamic, 'where'> {
+	): SingleStoreSelectWithout<this, TDynamic, 'where'> {
 		if (typeof where === 'function') {
 			where = where(
 				new Proxy(
@@ -680,7 +684,7 @@ export abstract class MySqlSelectQueryBuilderBase<
 	 */
 	having(
 		having: ((aliases: this['_']['selection']) => SQL | undefined) | SQL | undefined,
-	): MySqlSelectWithout<this, TDynamic, 'having'> {
+	): SingleStoreSelectWithout<this, TDynamic, 'having'> {
 		if (typeof having === 'function') {
 			having = having(
 				new Proxy(
@@ -713,14 +717,14 @@ export abstract class MySqlSelectQueryBuilderBase<
 	 * ```
 	 */
 	groupBy(
-		builder: (aliases: this['_']['selection']) => ValueOrArray<MySqlColumn | SQL | SQL.Aliased>,
-	): MySqlSelectWithout<this, TDynamic, 'groupBy'>;
-	groupBy(...columns: (MySqlColumn | SQL | SQL.Aliased)[]): MySqlSelectWithout<this, TDynamic, 'groupBy'>;
+		builder: (aliases: this['_']['selection']) => ValueOrArray<SingleStoreColumn | SQL | SQL.Aliased>,
+	): SingleStoreSelectWithout<this, TDynamic, 'groupBy'>;
+	groupBy(...columns: (SingleStoreColumn | SQL | SQL.Aliased)[]): SingleStoreSelectWithout<this, TDynamic, 'groupBy'>;
 	groupBy(
 		...columns:
-			| [(aliases: this['_']['selection']) => ValueOrArray<MySqlColumn | SQL | SQL.Aliased>]
-			| (MySqlColumn | SQL | SQL.Aliased)[]
-	): MySqlSelectWithout<this, TDynamic, 'groupBy'> {
+			| [(aliases: this['_']['selection']) => ValueOrArray<SingleStoreColumn | SQL | SQL.Aliased>]
+			| (SingleStoreColumn | SQL | SQL.Aliased)[]
+	): SingleStoreSelectWithout<this, TDynamic, 'groupBy'> {
 		if (typeof columns[0] === 'function') {
 			const groupBy = columns[0](
 				new Proxy(
@@ -730,7 +734,7 @@ export abstract class MySqlSelectQueryBuilderBase<
 			);
 			this.config.groupBy = Array.isArray(groupBy) ? groupBy : [groupBy];
 		} else {
-			this.config.groupBy = columns as (MySqlColumn | SQL | SQL.Aliased)[];
+			this.config.groupBy = columns as (SingleStoreColumn | SQL | SQL.Aliased)[];
 		}
 		return this as any;
 	}
@@ -760,14 +764,14 @@ export abstract class MySqlSelectQueryBuilderBase<
 	 * ```
 	 */
 	orderBy(
-		builder: (aliases: this['_']['selection']) => ValueOrArray<MySqlColumn | SQL | SQL.Aliased>,
-	): MySqlSelectWithout<this, TDynamic, 'orderBy'>;
-	orderBy(...columns: (MySqlColumn | SQL | SQL.Aliased)[]): MySqlSelectWithout<this, TDynamic, 'orderBy'>;
+		builder: (aliases: this['_']['selection']) => ValueOrArray<SingleStoreColumn | SQL | SQL.Aliased>,
+	): SingleStoreSelectWithout<this, TDynamic, 'orderBy'>;
+	orderBy(...columns: (SingleStoreColumn | SQL | SQL.Aliased)[]): SingleStoreSelectWithout<this, TDynamic, 'orderBy'>;
 	orderBy(
 		...columns:
-			| [(aliases: this['_']['selection']) => ValueOrArray<MySqlColumn | SQL | SQL.Aliased>]
-			| (MySqlColumn | SQL | SQL.Aliased)[]
-	): MySqlSelectWithout<this, TDynamic, 'orderBy'> {
+			| [(aliases: this['_']['selection']) => ValueOrArray<SingleStoreColumn | SQL | SQL.Aliased>]
+			| (SingleStoreColumn | SQL | SQL.Aliased)[]
+	): SingleStoreSelectWithout<this, TDynamic, 'orderBy'> {
 		if (typeof columns[0] === 'function') {
 			const orderBy = columns[0](
 				new Proxy(
@@ -784,7 +788,7 @@ export abstract class MySqlSelectQueryBuilderBase<
 				this.config.orderBy = orderByArray;
 			}
 		} else {
-			const orderByArray = columns as (MySqlColumn | SQL | SQL.Aliased)[];
+			const orderByArray = columns as (SingleStoreColumn | SQL | SQL.Aliased)[];
 
 			if (this.config.setOperators.length > 0) {
 				this.config.setOperators.at(-1)!.orderBy = orderByArray;
@@ -811,7 +815,7 @@ export abstract class MySqlSelectQueryBuilderBase<
 	 * await db.select().from(people).limit(10);
 	 * ```
 	 */
-	limit(limit: number): MySqlSelectWithout<this, TDynamic, 'limit'> {
+	limit(limit: number): SingleStoreSelectWithout<this, TDynamic, 'limit'> {
 		if (this.config.setOperators.length > 0) {
 			this.config.setOperators.at(-1)!.limit = limit;
 		} else {
@@ -836,7 +840,7 @@ export abstract class MySqlSelectQueryBuilderBase<
 	 * await db.select().from(people).offset(10).limit(10);
 	 * ```
 	 */
-	offset(offset: number): MySqlSelectWithout<this, TDynamic, 'offset'> {
+	offset(offset: number): SingleStoreSelectWithout<this, TDynamic, 'offset'> {
 		if (this.config.setOperators.length > 0) {
 			this.config.setOperators.at(-1)!.offset = offset;
 		} else {
@@ -851,11 +855,12 @@ export abstract class MySqlSelectQueryBuilderBase<
 	 * Calling this method will specify a lock strength for this query that controls how strictly it acquires exclusive access to the rows being queried.
 	 *
 	 * See docs: {@link https://dev.mysql.com/doc/refman/8.0/en/innodb-locking-reads.html}
+	 * TODO(singlestore)
 	 *
 	 * @param strength the lock strength.
 	 * @param config the lock configuration.
 	 */
-	for(strength: LockStrength, config: LockConfig = {}): MySqlSelectWithout<this, TDynamic, 'for'> {
+	for(strength: LockStrength, config: LockConfig = {}): SingleStoreSelectWithout<this, TDynamic, 'for'> {
 		this.config.lockingClause = { strength, config };
 		return this as any;
 	}
@@ -887,12 +892,12 @@ export abstract class MySqlSelectQueryBuilderBase<
 		) as this['_']['selectedFields'];
 	}
 
-	$dynamic(): MySqlSelectDynamic<this> {
+	$dynamic(): SingleStoreSelectDynamic<this> {
 		return this as any;
 	}
 }
 
-export interface MySqlSelectBase<
+export interface SingleStoreSelectBase<
 	TTableName extends string | undefined,
 	TSelection extends ColumnsSelection,
 	TSelectMode extends SelectMode,
@@ -904,8 +909,8 @@ export interface MySqlSelectBase<
 	TResult extends any[] = SelectResult<TSelection, TSelectMode, TNullabilityMap>[],
 	TSelectedFields extends ColumnsSelection = BuildSubquerySelection<TSelection, TNullabilityMap>,
 > extends
-	MySqlSelectQueryBuilderBase<
-		MySqlSelectHKT,
+	SingleStoreSelectQueryBuilderBase<
+		SingleStoreSelectHKT,
 		TTableName,
 		TSelection,
 		TSelectMode,
@@ -919,7 +924,7 @@ export interface MySqlSelectBase<
 	QueryPromise<TResult>
 {}
 
-export class MySqlSelectBase<
+export class SingleStoreSelectBase<
 	TTableName extends string | undefined,
 	TSelection,
 	TSelectMode extends SelectMode,
@@ -930,8 +935,8 @@ export class MySqlSelectBase<
 	TExcludedMethods extends string = never,
 	TResult = SelectResult<TSelection, TSelectMode, TNullabilityMap>[],
 	TSelectedFields = BuildSubquerySelection<TSelection, TNullabilityMap>,
-> extends MySqlSelectQueryBuilderBase<
-	MySqlSelectHKT,
+> extends SingleStoreSelectQueryBuilderBase<
+	SingleStoreSelectHKT,
 	TTableName,
 	TSelection,
 	TSelectMode,
@@ -942,19 +947,19 @@ export class MySqlSelectBase<
 	TResult,
 	TSelectedFields
 > {
-	static readonly [entityKind]: string = 'MySqlSelect';
+	static readonly [entityKind]: string = 'SingleStoreSelect';
 
-	prepare(): MySqlSelectPrepare<this> {
+	prepare(): SingleStoreSelectPrepare<this> {
 		if (!this.session) {
 			throw new Error('Cannot execute a query on a query builder. Please use a database instance instead.');
 		}
-		const fieldsList = orderSelectedFields<MySqlColumn>(this.config.fields);
+		const fieldsList = orderSelectedFields<SingleStoreColumn>(this.config.fields);
 		const query = this.session.prepareQuery<
-			MySqlPreparedQueryConfig & { execute: SelectResult<TSelection, TSelectMode, TNullabilityMap>[] },
+			SingleStorePreparedQueryConfig & { execute: SelectResult<TSelection, TSelectMode, TNullabilityMap>[] },
 			TPreparedQueryHKT
 		>(this.dialect.sqlToQuery(this.getSQL()), fieldsList);
 		query.joinsNotNullableMap = this.joinsNotNullableMap;
-		return query as MySqlSelectPrepare<this>;
+		return query as SingleStoreSelectPrepare<this>;
 	}
 
 	execute = ((placeholderValues) => {
@@ -971,14 +976,14 @@ export class MySqlSelectBase<
 	iterator = this.createIterator();
 }
 
-applyMixins(MySqlSelectBase, [QueryPromise]);
+applyMixins(SingleStoreSelectBase, [QueryPromise]);
 
-function createSetOperator(type: SetOperator, isAll: boolean): MySqlCreateSetOperatorFn {
+function createSetOperator(type: SetOperator, isAll: boolean): SingleStoreCreateSetOperatorFn {
 	return (leftSelect, rightSelect, ...restSelects) => {
 		const setOperators = [rightSelect, ...restSelects].map((select) => ({
 			type,
 			isAll,
-			rightSelect: select as AnyMySqlSelect,
+			rightSelect: select as AnySingleStoreSelect,
 		}));
 
 		for (const setOperator of setOperators) {
@@ -989,11 +994,11 @@ function createSetOperator(type: SetOperator, isAll: boolean): MySqlCreateSetOpe
 			}
 		}
 
-		return (leftSelect as AnyMySqlSelect).addSetOperators(setOperators) as any;
+		return (leftSelect as AnySingleStoreSelect).addSetOperators(setOperators) as any;
 	};
 }
 
-const getMySqlSetOperators = () => ({
+const getSingleStoreSetOperators = () => ({
 	union,
 	unionAll,
 	intersect,
@@ -1013,7 +1018,7 @@ const getMySqlSetOperators = () => ({
  *
  * ```ts
  * // Select all unique names from customers and users tables
- * import { union } from 'drizzle-orm/mysql-core'
+ * import { union } from 'drizzle-orm/singlestore-core'
  *
  * await union(
  *   db.select({ name: users.name }).from(users),
@@ -1040,7 +1045,7 @@ export const union = createSetOperator('union', false);
  *
  * ```ts
  * // Select all transaction ids from both online and in-store sales
- * import { unionAll } from 'drizzle-orm/mysql-core'
+ * import { unionAll } from 'drizzle-orm/singlestore-core'
  *
  * await unionAll(
  *   db.select({ transaction: onlineSales.transactionId }).from(onlineSales),
@@ -1067,7 +1072,7 @@ export const unionAll = createSetOperator('union', true);
  *
  * ```ts
  * // Select course names that are offered in both departments A and B
- * import { intersect } from 'drizzle-orm/mysql-core'
+ * import { intersect } from 'drizzle-orm/singlestore-core'
  *
  * await intersect(
  *   db.select({ courseName: depA.courseName }).from(depA),
@@ -1094,7 +1099,7 @@ export const intersect = createSetOperator('intersect', false);
  *
  * ```ts
  * // Select all products and quantities that are ordered by both regular and VIP customers
- * import { intersectAll } from 'drizzle-orm/mysql-core'
+ * import { intersectAll } from 'drizzle-orm/singlestore-core'
  *
  * await intersectAll(
  *   db.select({
@@ -1136,7 +1141,7 @@ export const intersectAll = createSetOperator('intersect', true);
  *
  * ```ts
  * // Select all courses offered in department A but not in department B
- * import { except } from 'drizzle-orm/mysql-core'
+ * import { except } from 'drizzle-orm/singlestore-core'
  *
  * await except(
  *   db.select({ courseName: depA.courseName }).from(depA),
@@ -1163,7 +1168,7 @@ export const except = createSetOperator('except', false);
  *
  * ```ts
  * // Select all products that are ordered by regular customers but not by VIP customers
- * import { exceptAll } from 'drizzle-orm/mysql-core'
+ * import { exceptAll } from 'drizzle-orm/singlestore-core'
  *
  * await exceptAll(
  *   db.select({
diff --git a/drizzle-orm/src/singlestore-core/query-builders/select.types.ts b/drizzle-orm/src/singlestore-core/query-builders/select.types.ts
index 5f490a2d9..26f177634 100644
--- a/drizzle-orm/src/singlestore-core/query-builders/select.types.ts
+++ b/drizzle-orm/src/singlestore-core/query-builders/select.types.ts
@@ -1,5 +1,3 @@
-import type { MySqlColumn } from '~/mysql-core/columns/index.ts';
-import type { MySqlTable, MySqlTableWithColumns } from '~/mysql-core/table.ts';
 import type {
 	SelectedFields as SelectedFieldsBase,
 	SelectedFieldsFlat as SelectedFieldsFlatBase,
@@ -18,49 +16,51 @@ import type {
 	SelectResult,
 	SetOperator,
 } from '~/query-builders/select.types.ts';
+import type { SingleStoreColumn } from '~/singlestore-core/columns/index.ts';
+import type { SingleStoreTable, SingleStoreTableWithColumns } from '~/singlestore-core/table.ts';
 import type { ColumnsSelection, Placeholder, SQL, View } from '~/sql/sql.ts';
 import type { Subquery } from '~/subquery.ts';
 import type { Table, UpdateTableConfig } from '~/table.ts';
 import type { Assume, ValidateShape } from '~/utils.ts';
-import type { MySqlPreparedQueryConfig, PreparedQueryHKTBase, PreparedQueryKind } from '../session.ts';
-import type { MySqlViewBase } from '../view-base.ts';
-import type { MySqlViewWithSelection } from '../view.ts';
-import type { MySqlSelectBase, MySqlSelectQueryBuilderBase } from './select.ts';
+import type { PreparedQueryHKTBase, PreparedQueryKind, SingleStorePreparedQueryConfig } from '../session.ts';
+import type { SingleStoreViewBase } from '../view-base.ts';
+import type { SingleStoreViewWithSelection } from '../view.ts';
+import type { SingleStoreSelectBase, SingleStoreSelectQueryBuilderBase } from './select.ts';
 
-export interface MySqlSelectJoinConfig {
+export interface SingleStoreSelectJoinConfig {
 	on: SQL | undefined;
-	table: MySqlTable | Subquery | MySqlViewBase | SQL;
+	table: SingleStoreTable | Subquery | SingleStoreViewBase | SQL;
 	alias: string | undefined;
 	joinType: JoinType;
 	lateral?: boolean;
 }
 
-export type BuildAliasTable<TTable extends MySqlTable | View, TAlias extends string> = TTable extends Table
-	? MySqlTableWithColumns<
+export type BuildAliasTable<TTable extends SingleStoreTable | View, TAlias extends string> = TTable extends Table
+	? SingleStoreTableWithColumns<
 		UpdateTableConfig<TTable['_']['config'], {
 			name: TAlias;
-			columns: MapColumnsToTableAlias<TTable['_']['columns'], TAlias, 'mysql'>;
+			columns: MapColumnsToTableAlias<TTable['_']['columns'], TAlias, 'singlestore'>;
 		}>
 	>
-	: TTable extends View ? MySqlViewWithSelection<
+	: TTable extends View ? SingleStoreViewWithSelection<
 			TAlias,
 			TTable['_']['existing'],
-			MapColumnsToTableAlias<TTable['_']['selectedFields'], TAlias, 'mysql'>
+			MapColumnsToTableAlias<TTable['_']['selectedFields'], TAlias, 'singlestore'>
 		>
 	: never;
 
-export interface MySqlSelectConfig {
+export interface SingleStoreSelectConfig {
 	withList?: Subquery[];
 	fields: Record<string, unknown>;
 	fieldsFlat?: SelectedFieldsOrdered;
 	where?: SQL;
 	having?: SQL;
-	table: MySqlTable | Subquery | MySqlViewBase | SQL;
+	table: SingleStoreTable | Subquery | SingleStoreViewBase | SQL;
 	limit?: number | Placeholder;
 	offset?: number | Placeholder;
-	joins?: MySqlSelectJoinConfig[];
-	orderBy?: (MySqlColumn | SQL | SQL.Aliased)[];
-	groupBy?: (MySqlColumn | SQL | SQL.Aliased)[];
+	joins?: SingleStoreSelectJoinConfig[];
+	orderBy?: (SingleStoreColumn | SQL | SQL.Aliased)[];
+	groupBy?: (SingleStoreColumn | SQL | SQL.Aliased)[];
 	lockingClause?: {
 		strength: LockStrength;
 		config: LockConfig;
@@ -70,27 +70,27 @@ export interface MySqlSelectConfig {
 		rightSelect: TypedQueryBuilder<any, any>;
 		type: SetOperator;
 		isAll: boolean;
-		orderBy?: (MySqlColumn | SQL | SQL.Aliased)[];
+		orderBy?: (SingleStoreColumn | SQL | SQL.Aliased)[];
 		limit?: number | Placeholder;
 		offset?: number | Placeholder;
 	}[];
 }
 
-export type MySqlJoin<
-	T extends AnyMySqlSelectQueryBuilder,
+export type SingleStoreJoin<
+	T extends AnySingleStoreSelectQueryBuilder,
 	TDynamic extends boolean,
 	TJoinType extends JoinType,
-	TJoinedTable extends MySqlTable | Subquery | MySqlViewBase | SQL,
+	TJoinedTable extends SingleStoreTable | Subquery | SingleStoreViewBase | SQL,
 	TJoinedName extends GetSelectTableName<TJoinedTable> = GetSelectTableName<TJoinedTable>,
-> = T extends any ? MySqlSelectWithout<
-		MySqlSelectKind<
+> = T extends any ? SingleStoreSelectWithout<
+		SingleStoreSelectKind<
 			T['_']['hkt'],
 			T['_']['tableName'],
 			AppendToResult<
 				T['_']['tableName'],
 				T['_']['selection'],
 				TJoinedName,
-				TJoinedTable extends MySqlTable ? TJoinedTable['_']['columns']
+				TJoinedTable extends SingleStoreTable ? TJoinedTable['_']['columns']
 					: TJoinedTable extends Subquery ? Assume<TJoinedTable['_']['selectedFields'], SelectedFields>
 					: never,
 				T['_']['selectMode']
@@ -106,23 +106,23 @@ export type MySqlJoin<
 	>
 	: never;
 
-export type MySqlJoinFn<
-	T extends AnyMySqlSelectQueryBuilder,
+export type SingleStoreJoinFn<
+	T extends AnySingleStoreSelectQueryBuilder,
 	TDynamic extends boolean,
 	TJoinType extends JoinType,
 > = <
-	TJoinedTable extends MySqlTable | Subquery | MySqlViewBase | SQL,
+	TJoinedTable extends SingleStoreTable | Subquery | SingleStoreViewBase | SQL,
 	TJoinedName extends GetSelectTableName<TJoinedTable> = GetSelectTableName<TJoinedTable>,
 >(
 	table: TJoinedTable,
 	on: ((aliases: T['_']['selection']) => SQL | undefined) | SQL | undefined,
-) => MySqlJoin<T, TDynamic, TJoinType, TJoinedTable, TJoinedName>;
+) => SingleStoreJoin<T, TDynamic, TJoinType, TJoinedTable, TJoinedName>;
 
-export type SelectedFieldsFlat = SelectedFieldsFlatBase<MySqlColumn>;
+export type SelectedFieldsFlat = SelectedFieldsFlatBase<SingleStoreColumn>;
 
-export type SelectedFields = SelectedFieldsBase<MySqlColumn, MySqlTable>;
+export type SelectedFields = SelectedFieldsBase<SingleStoreColumn, SingleStoreTable>;
 
-export type SelectedFieldsOrdered = SelectedFieldsOrderedBase<MySqlColumn>;
+export type SelectedFieldsOrdered = SelectedFieldsOrderedBase<SingleStoreColumn>;
 
 export type LockStrength = 'update' | 'share';
 
@@ -137,7 +137,7 @@ export type LockConfig = {
 	skipLocked?: undefined;
 };
 
-export interface MySqlSelectHKTBase {
+export interface SingleStoreSelectHKTBase {
 	tableName: string | undefined;
 	selection: unknown;
 	selectMode: SelectMode;
@@ -150,8 +150,8 @@ export interface MySqlSelectHKTBase {
 	_type: unknown;
 }
 
-export type MySqlSelectKind<
-	T extends MySqlSelectHKTBase,
+export type SingleStoreSelectKind<
+	T extends SingleStoreSelectHKTBase,
 	TTableName extends string | undefined,
 	TSelection extends ColumnsSelection,
 	TSelectMode extends SelectMode,
@@ -173,9 +173,9 @@ export type MySqlSelectKind<
 	selectedFields: TSelectedFields;
 })['_type'];
 
-export interface MySqlSelectQueryBuilderHKT extends MySqlSelectHKTBase {
-	_type: MySqlSelectQueryBuilderBase<
-		MySqlSelectQueryBuilderHKT,
+export interface SingleStoreSelectQueryBuilderHKT extends SingleStoreSelectHKTBase {
+	_type: SingleStoreSelectQueryBuilderBase<
+		SingleStoreSelectQueryBuilderHKT,
 		this['tableName'],
 		Assume<this['selection'], ColumnsSelection>,
 		this['selectMode'],
@@ -188,8 +188,8 @@ export interface MySqlSelectQueryBuilderHKT extends MySqlSelectHKTBase {
 	>;
 }
 
-export interface MySqlSelectHKT extends MySqlSelectHKTBase {
-	_type: MySqlSelectBase<
+export interface SingleStoreSelectHKT extends SingleStoreSelectHKTBase {
+	_type: SingleStoreSelectBase<
 		this['tableName'],
 		Assume<this['selection'], ColumnsSelection>,
 		this['selectMode'],
@@ -202,7 +202,7 @@ export interface MySqlSelectHKT extends MySqlSelectHKTBase {
 	>;
 }
 
-export type MySqlSetOperatorExcludedMethods =
+export type SingleStoreSetOperatorExcludedMethods =
 	| 'where'
 	| 'having'
 	| 'groupBy'
@@ -213,13 +213,13 @@ export type MySqlSetOperatorExcludedMethods =
 	| 'fullJoin'
 	| 'for';
 
-export type MySqlSelectWithout<
-	T extends AnyMySqlSelectQueryBuilder,
+export type SingleStoreSelectWithout<
+	T extends AnySingleStoreSelectQueryBuilder,
 	TDynamic extends boolean,
 	K extends keyof T & string,
 	TResetExcluded extends boolean = false,
 > = TDynamic extends true ? T : Omit<
-	MySqlSelectKind<
+	SingleStoreSelectKind<
 		T['_']['hkt'],
 		T['_']['tableName'],
 		T['_']['selection'],
@@ -234,16 +234,16 @@ export type MySqlSelectWithout<
 	TResetExcluded extends true ? K : T['_']['excludedMethods'] | K
 >;
 
-export type MySqlSelectPrepare<T extends AnyMySqlSelect> = PreparedQueryKind<
+export type SingleStoreSelectPrepare<T extends AnySingleStoreSelect> = PreparedQueryKind<
 	T['_']['preparedQueryHKT'],
-	MySqlPreparedQueryConfig & {
+	SingleStorePreparedQueryConfig & {
 		execute: T['_']['result'];
 		iterator: T['_']['result'][number];
 	},
 	true
 >;
 
-export type MySqlSelectDynamic<T extends AnyMySqlSelectQueryBuilder> = MySqlSelectKind<
+export type SingleStoreSelectDynamic<T extends AnySingleStoreSelectQueryBuilder> = SingleStoreSelectKind<
 	T['_']['hkt'],
 	T['_']['tableName'],
 	T['_']['selection'],
@@ -256,17 +256,23 @@ export type MySqlSelectDynamic<T extends AnyMySqlSelectQueryBuilder> = MySqlSele
 	T['_']['selectedFields']
 >;
 
-export type CreateMySqlSelectFromBuilderMode<
+export type CreateSingleStoreSelectFromBuilderMode<
 	TBuilderMode extends 'db' | 'qb',
 	TTableName extends string | undefined,
 	TSelection extends ColumnsSelection,
 	TSelectMode extends SelectMode,
 	TPreparedQueryHKT extends PreparedQueryHKTBase,
-> = TBuilderMode extends 'db' ? MySqlSelectBase<TTableName, TSelection, TSelectMode, TPreparedQueryHKT>
-	: MySqlSelectQueryBuilderBase<MySqlSelectQueryBuilderHKT, TTableName, TSelection, TSelectMode, TPreparedQueryHKT>;
+> = TBuilderMode extends 'db' ? SingleStoreSelectBase<TTableName, TSelection, TSelectMode, TPreparedQueryHKT>
+	: SingleStoreSelectQueryBuilderBase<
+		SingleStoreSelectQueryBuilderHKT,
+		TTableName,
+		TSelection,
+		TSelectMode,
+		TPreparedQueryHKT
+	>;
 
-export type MySqlSelectQueryBuilder<
-	THKT extends MySqlSelectHKTBase = MySqlSelectQueryBuilderHKT,
+export type SingleStoreSelectQueryBuilder<
+	THKT extends SingleStoreSelectHKTBase = SingleStoreSelectQueryBuilderHKT,
 	TTableName extends string | undefined = string | undefined,
 	TSelection extends ColumnsSelection = ColumnsSelection,
 	TSelectMode extends SelectMode = SelectMode,
@@ -274,7 +280,7 @@ export type MySqlSelectQueryBuilder<
 	TNullabilityMap extends Record<string, JoinNullability> = Record<string, JoinNullability>,
 	TResult extends any[] = unknown[],
 	TSelectedFields extends ColumnsSelection = ColumnsSelection,
-> = MySqlSelectQueryBuilderBase<
+> = SingleStoreSelectQueryBuilderBase<
 	THKT,
 	TTableName,
 	TSelection,
@@ -287,11 +293,31 @@ export type MySqlSelectQueryBuilder<
 	TSelectedFields
 >;
 
-export type AnyMySqlSelectQueryBuilder = MySqlSelectQueryBuilderBase<any, any, any, any, any, any, any, any, any>;
+export type AnySingleStoreSelectQueryBuilder = SingleStoreSelectQueryBuilderBase<
+	any,
+	any,
+	any,
+	any,
+	any,
+	any,
+	any,
+	any,
+	any
+>;
 
-export type AnyMySqlSetOperatorInterface = MySqlSetOperatorInterface<any, any, any, any, any, any, any, any, any>;
+export type AnySingleStoreSetOperatorInterface = SingleStoreSetOperatorInterface<
+	any,
+	any,
+	any,
+	any,
+	any,
+	any,
+	any,
+	any,
+	any
+>;
 
-export interface MySqlSetOperatorInterface<
+export interface SingleStoreSetOperatorInterface<
 	TTableName extends string | undefined,
 	TSelection extends ColumnsSelection,
 	TSelectMode extends SelectMode,
@@ -304,7 +330,7 @@ export interface MySqlSetOperatorInterface<
 	TSelectedFields extends ColumnsSelection = BuildSubquerySelection<TSelection, TNullabilityMap>,
 > {
 	_: {
-		readonly hkt: MySqlSelectHKT;
+		readonly hkt: SingleStoreSelectHKT;
 		readonly tableName: TTableName;
 		readonly selection: TSelection;
 		readonly selectMode: TSelectMode;
@@ -317,7 +343,7 @@ export interface MySqlSetOperatorInterface<
 	};
 }
 
-export type MySqlSetOperatorWithResult<TResult extends any[]> = MySqlSetOperatorInterface<
+export type SingleStoreSetOperatorWithResult<TResult extends any[]> = SingleStoreSetOperatorInterface<
 	any,
 	any,
 	any,
@@ -329,35 +355,35 @@ export type MySqlSetOperatorWithResult<TResult extends any[]> = MySqlSetOperator
 	any
 >;
 
-export type MySqlSelect<
+export type SingleStoreSelect<
 	TTableName extends string | undefined = string | undefined,
 	TSelection extends ColumnsSelection = Record<string, any>,
 	TSelectMode extends SelectMode = SelectMode,
 	TNullabilityMap extends Record<string, JoinNullability> = Record<string, JoinNullability>,
-> = MySqlSelectBase<TTableName, TSelection, TSelectMode, PreparedQueryHKTBase, TNullabilityMap, true, never>;
+> = SingleStoreSelectBase<TTableName, TSelection, TSelectMode, PreparedQueryHKTBase, TNullabilityMap, true, never>;
 
-export type AnyMySqlSelect = MySqlSelectBase<any, any, any, any, any, any, any, any>;
+export type AnySingleStoreSelect = SingleStoreSelectBase<any, any, any, any, any, any, any, any>;
 
-export type MySqlSetOperator<
+export type SingleStoreSetOperator<
 	TTableName extends string | undefined = string | undefined,
 	TSelection extends ColumnsSelection = Record<string, any>,
 	TSelectMode extends SelectMode = SelectMode,
 	TPreparedQueryHKT extends PreparedQueryHKTBase = PreparedQueryHKTBase,
 	TNullabilityMap extends Record<string, JoinNullability> = Record<string, JoinNullability>,
-> = MySqlSelectBase<
+> = SingleStoreSelectBase<
 	TTableName,
 	TSelection,
 	TSelectMode,
 	TPreparedQueryHKT,
 	TNullabilityMap,
 	true,
-	MySqlSetOperatorExcludedMethods
+	SingleStoreSetOperatorExcludedMethods
 >;
 
 export type SetOperatorRightSelect<
-	TValue extends MySqlSetOperatorWithResult<TResult>,
+	TValue extends SingleStoreSetOperatorWithResult<TResult>,
 	TResult extends any[],
-> = TValue extends MySqlSetOperatorInterface<any, any, any, any, any, any, any, infer TValueResult, any>
+> = TValue extends SingleStoreSetOperatorInterface<any, any, any, any, any, any, any, infer TValueResult, any>
 	? ValidateShape<
 		TValueResult[number],
 		TResult[number],
@@ -366,11 +392,11 @@ export type SetOperatorRightSelect<
 	: TValue;
 
 export type SetOperatorRestSelect<
-	TValue extends readonly MySqlSetOperatorWithResult<TResult>[],
+	TValue extends readonly SingleStoreSetOperatorWithResult<TResult>[],
 	TResult extends any[],
 > = TValue extends [infer First, ...infer Rest]
-	? First extends MySqlSetOperatorInterface<any, any, any, any, any, any, any, infer TValueResult, any>
-		? Rest extends AnyMySqlSetOperatorInterface[] ? [
+	? First extends SingleStoreSetOperatorInterface<any, any, any, any, any, any, any, infer TValueResult, any>
+		? Rest extends AnySingleStoreSetOperatorInterface[] ? [
 				ValidateShape<TValueResult[number], TResult[number], TypedQueryBuilder<any, TValueResult>>,
 				...SetOperatorRestSelect<Rest, TResult>,
 			]
@@ -378,12 +404,12 @@ export type SetOperatorRestSelect<
 	: never
 	: TValue;
 
-export type MySqlCreateSetOperatorFn = <
+export type SingleStoreCreateSetOperatorFn = <
 	TTableName extends string | undefined,
 	TSelection extends ColumnsSelection,
 	TSelectMode extends SelectMode,
-	TValue extends MySqlSetOperatorWithResult<TResult>,
-	TRest extends MySqlSetOperatorWithResult<TResult>[],
+	TValue extends SingleStoreSetOperatorWithResult<TResult>,
+	TRest extends SingleStoreSetOperatorWithResult<TResult>[],
 	TPreparedQueryHKT extends PreparedQueryHKTBase = PreparedQueryHKTBase,
 	TNullabilityMap extends Record<string, JoinNullability> = TTableName extends string ? Record<TTableName, 'not-null'>
 		: {},
@@ -392,7 +418,7 @@ export type MySqlCreateSetOperatorFn = <
 	TResult extends any[] = SelectResult<TSelection, TSelectMode, TNullabilityMap>[],
 	TSelectedFields extends ColumnsSelection = BuildSubquerySelection<TSelection, TNullabilityMap>,
 >(
-	leftSelect: MySqlSetOperatorInterface<
+	leftSelect: SingleStoreSetOperatorInterface<
 		TTableName,
 		TSelection,
 		TSelectMode,
@@ -405,8 +431,8 @@ export type MySqlCreateSetOperatorFn = <
 	>,
 	rightSelect: SetOperatorRightSelect<TValue, TResult>,
 	...restSelects: SetOperatorRestSelect<TRest, TResult>
-) => MySqlSelectWithout<
-	MySqlSelectBase<
+) => SingleStoreSelectWithout<
+	SingleStoreSelectBase<
 		TTableName,
 		TSelection,
 		TSelectMode,
@@ -418,15 +444,15 @@ export type MySqlCreateSetOperatorFn = <
 		TSelectedFields
 	>,
 	false,
-	MySqlSetOperatorExcludedMethods,
+	SingleStoreSetOperatorExcludedMethods,
 	true
 >;
 
-export type GetMySqlSetOperators = {
-	union: MySqlCreateSetOperatorFn;
-	intersect: MySqlCreateSetOperatorFn;
-	except: MySqlCreateSetOperatorFn;
-	unionAll: MySqlCreateSetOperatorFn;
-	intersectAll: MySqlCreateSetOperatorFn;
-	exceptAll: MySqlCreateSetOperatorFn;
+export type GetSingleStoreSetOperators = {
+	union: SingleStoreCreateSetOperatorFn;
+	intersect: SingleStoreCreateSetOperatorFn;
+	except: SingleStoreCreateSetOperatorFn;
+	unionAll: SingleStoreCreateSetOperatorFn;
+	intersectAll: SingleStoreCreateSetOperatorFn;
+	exceptAll: SingleStoreCreateSetOperatorFn;
 };
diff --git a/drizzle-orm/src/singlestore-core/query-builders/update.ts b/drizzle-orm/src/singlestore-core/query-builders/update.ts
index 7884599cf..d26394dfe 100644
--- a/drizzle-orm/src/singlestore-core/query-builders/update.ts
+++ b/drizzle-orm/src/singlestore-core/query-builders/update.ts
@@ -1,31 +1,31 @@
 import type { GetColumnData } from '~/column.ts';
 import { entityKind } from '~/entity.ts';
-import type { MySqlDialect } from '~/mysql-core/dialect.ts';
+import { QueryPromise } from '~/query-promise.ts';
+import type { SingleStoreDialect } from '~/singlestore-core/dialect.ts';
 import type {
-	AnyMySqlQueryResultHKT,
-	MySqlPreparedQueryConfig,
-	MySqlQueryResultHKT,
-	MySqlQueryResultKind,
-	MySqlSession,
+	AnySingleStoreQueryResultHKT,
 	PreparedQueryHKTBase,
 	PreparedQueryKind,
-} from '~/mysql-core/session.ts';
-import type { MySqlTable } from '~/mysql-core/table.ts';
-import { QueryPromise } from '~/query-promise.ts';
+	SingleStorePreparedQueryConfig,
+	SingleStoreQueryResultHKT,
+	SingleStoreQueryResultKind,
+	SingleStoreSession,
+} from '~/singlestore-core/session.ts';
+import type { SingleStoreTable } from '~/singlestore-core/table.ts';
 import type { Query, SQL, SQLWrapper } from '~/sql/sql.ts';
 import type { Subquery } from '~/subquery.ts';
 import { mapUpdateSet, type UpdateSet } from '~/utils.ts';
 import type { SelectedFieldsOrdered } from './select.types.ts';
 
-export interface MySqlUpdateConfig {
+export interface SingleStoreUpdateConfig {
 	where?: SQL | undefined;
 	set: UpdateSet;
-	table: MySqlTable;
+	table: SingleStoreTable;
 	returning?: SelectedFieldsOrdered;
 	withList?: Subquery[];
 }
 
-export type MySqlUpdateSetSource<TTable extends MySqlTable> =
+export type SingleStoreUpdateSetSource<TTable extends SingleStoreTable> =
 	& {
 		[Key in keyof TTable['$inferInsert']]?:
 			| GetColumnData<TTable['_']['columns'][Key], 'query'>
@@ -33,12 +33,12 @@ export type MySqlUpdateSetSource<TTable extends MySqlTable> =
 	}
 	& {};
 
-export class MySqlUpdateBuilder<
-	TTable extends MySqlTable,
-	TQueryResult extends MySqlQueryResultHKT,
+export class SingleStoreUpdateBuilder<
+	TTable extends SingleStoreTable,
+	TQueryResult extends SingleStoreQueryResultHKT,
 	TPreparedQueryHKT extends PreparedQueryHKTBase,
 > {
-	static readonly [entityKind]: string = 'MySqlUpdateBuilder';
+	static readonly [entityKind]: string = 'SingleStoreUpdateBuilder';
 
 	declare readonly _: {
 		readonly table: TTable;
@@ -46,22 +46,28 @@ export class MySqlUpdateBuilder<
 
 	constructor(
 		private table: TTable,
-		private session: MySqlSession,
-		private dialect: MySqlDialect,
+		private session: SingleStoreSession,
+		private dialect: SingleStoreDialect,
 		private withList?: Subquery[],
 	) {}
 
-	set(values: MySqlUpdateSetSource<TTable>): MySqlUpdateBase<TTable, TQueryResult, TPreparedQueryHKT> {
-		return new MySqlUpdateBase(this.table, mapUpdateSet(this.table, values), this.session, this.dialect, this.withList);
+	set(values: SingleStoreUpdateSetSource<TTable>): SingleStoreUpdateBase<TTable, TQueryResult, TPreparedQueryHKT> {
+		return new SingleStoreUpdateBase(
+			this.table,
+			mapUpdateSet(this.table, values),
+			this.session,
+			this.dialect,
+			this.withList,
+		);
 	}
 }
 
-export type MySqlUpdateWithout<
-	T extends AnyMySqlUpdateBase,
+export type SingleStoreUpdateWithout<
+	T extends AnySingleStoreUpdateBase,
 	TDynamic extends boolean,
 	K extends keyof T & string,
 > = TDynamic extends true ? T : Omit<
-	MySqlUpdateBase<
+	SingleStoreUpdateBase<
 		T['_']['table'],
 		T['_']['queryResult'],
 		T['_']['preparedQueryHKT'],
@@ -71,36 +77,36 @@ export type MySqlUpdateWithout<
 	T['_']['excludedMethods'] | K
 >;
 
-export type MySqlUpdatePrepare<T extends AnyMySqlUpdateBase> = PreparedQueryKind<
+export type SingleStoreUpdatePrepare<T extends AnySingleStoreUpdateBase> = PreparedQueryKind<
 	T['_']['preparedQueryHKT'],
-	MySqlPreparedQueryConfig & {
-		execute: MySqlQueryResultKind<T['_']['queryResult'], never>;
+	SingleStorePreparedQueryConfig & {
+		execute: SingleStoreQueryResultKind<T['_']['queryResult'], never>;
 		iterator: never;
 	},
 	true
 >;
 
-export type MySqlUpdateDynamic<T extends AnyMySqlUpdateBase> = MySqlUpdate<
+export type SingleStoreUpdateDynamic<T extends AnySingleStoreUpdateBase> = SingleStoreUpdate<
 	T['_']['table'],
 	T['_']['queryResult'],
 	T['_']['preparedQueryHKT']
 >;
 
-export type MySqlUpdate<
-	TTable extends MySqlTable = MySqlTable,
-	TQueryResult extends MySqlQueryResultHKT = AnyMySqlQueryResultHKT,
+export type SingleStoreUpdate<
+	TTable extends SingleStoreTable = SingleStoreTable,
+	TQueryResult extends SingleStoreQueryResultHKT = AnySingleStoreQueryResultHKT,
 	TPreparedQueryHKT extends PreparedQueryHKTBase = PreparedQueryHKTBase,
-> = MySqlUpdateBase<TTable, TQueryResult, TPreparedQueryHKT, true, never>;
+> = SingleStoreUpdateBase<TTable, TQueryResult, TPreparedQueryHKT, true, never>;
 
-export type AnyMySqlUpdateBase = MySqlUpdateBase<any, any, any, any, any>;
+export type AnySingleStoreUpdateBase = SingleStoreUpdateBase<any, any, any, any, any>;
 
-export interface MySqlUpdateBase<
-	TTable extends MySqlTable,
-	TQueryResult extends MySqlQueryResultHKT,
+export interface SingleStoreUpdateBase<
+	TTable extends SingleStoreTable,
+	TQueryResult extends SingleStoreQueryResultHKT,
 	TPreparedQueryHKT extends PreparedQueryHKTBase,
 	TDynamic extends boolean = false,
 	TExcludedMethods extends string = never,
-> extends QueryPromise<MySqlQueryResultKind<TQueryResult, never>>, SQLWrapper {
+> extends QueryPromise<SingleStoreQueryResultKind<TQueryResult, never>>, SQLWrapper {
 	readonly _: {
 		readonly table: TTable;
 		readonly queryResult: TQueryResult;
@@ -110,25 +116,25 @@ export interface MySqlUpdateBase<
 	};
 }
 
-export class MySqlUpdateBase<
-	TTable extends MySqlTable,
-	TQueryResult extends MySqlQueryResultHKT,
+export class SingleStoreUpdateBase<
+	TTable extends SingleStoreTable,
+	TQueryResult extends SingleStoreQueryResultHKT,
 	// eslint-disable-next-line @typescript-eslint/no-unused-vars
 	TPreparedQueryHKT extends PreparedQueryHKTBase,
 	// eslint-disable-next-line @typescript-eslint/no-unused-vars
 	TDynamic extends boolean = false,
 	// eslint-disable-next-line @typescript-eslint/no-unused-vars
 	TExcludedMethods extends string = never,
-> extends QueryPromise<MySqlQueryResultKind<TQueryResult, never>> implements SQLWrapper {
-	static readonly [entityKind]: string = 'MySqlUpdate';
+> extends QueryPromise<SingleStoreQueryResultKind<TQueryResult, never>> implements SQLWrapper {
+	static readonly [entityKind]: string = 'SingleStoreUpdate';
 
-	private config: MySqlUpdateConfig;
+	private config: SingleStoreUpdateConfig;
 
 	constructor(
 		table: TTable,
 		set: UpdateSet,
-		private session: MySqlSession,
-		private dialect: MySqlDialect,
+		private session: SingleStoreSession,
+		private dialect: SingleStoreDialect,
 		withList?: Subquery[],
 	) {
 		super();
@@ -168,7 +174,7 @@ export class MySqlUpdateBase<
 	 *   .where(or(eq(cars.color, 'green'), eq(cars.color, 'blue')));
 	 * ```
 	 */
-	where(where: SQL | undefined): MySqlUpdateWithout<this, TDynamic, 'where'> {
+	where(where: SQL | undefined): SingleStoreUpdateWithout<this, TDynamic, 'where'> {
 		this.config.where = where;
 		return this as any;
 	}
@@ -183,11 +189,11 @@ export class MySqlUpdateBase<
 		return rest;
 	}
 
-	prepare(): MySqlUpdatePrepare<this> {
+	prepare(): SingleStoreUpdatePrepare<this> {
 		return this.session.prepareQuery(
 			this.dialect.sqlToQuery(this.getSQL()),
 			this.config.returning,
-		) as MySqlUpdatePrepare<this>;
+		) as SingleStoreUpdatePrepare<this>;
 	}
 
 	override execute: ReturnType<this['prepare']>['execute'] = (placeholderValues) => {
@@ -203,7 +209,7 @@ export class MySqlUpdateBase<
 
 	iterator = this.createIterator();
 
-	$dynamic(): MySqlUpdateDynamic<this> {
+	$dynamic(): SingleStoreUpdateDynamic<this> {
 		return this as any;
 	}
 }
diff --git a/drizzle-orm/src/singlestore-core/schema.ts b/drizzle-orm/src/singlestore-core/schema.ts
index b36531e44..82da44a49 100644
--- a/drizzle-orm/src/singlestore-core/schema.ts
+++ b/drizzle-orm/src/singlestore-core/schema.ts
@@ -1,40 +1,41 @@
 import { entityKind, is } from '~/entity.ts';
-import { type MySqlTableFn, mysqlTableWithSchema } from './table.ts';
-import { type mysqlView, mysqlViewWithSchema } from './view.ts';
+import { type SingleStoreTableFn, singlestoreTableWithSchema } from './table.ts';
+import { type singlestoreView, singlestoreViewWithSchema } from './view.ts';
 
-export class MySqlSchema<TName extends string = string> {
-	static readonly [entityKind]: string = 'MySqlSchema';
+export class SingleStoreSchema<TName extends string = string> {
+	static readonly [entityKind]: string = 'SingleStoreSchema';
 
 	constructor(
 		public readonly schemaName: TName,
 	) {}
 
-	table: MySqlTableFn<TName> = (name, columns, extraConfig) => {
-		return mysqlTableWithSchema(name, columns, extraConfig, this.schemaName);
+	table: SingleStoreTableFn<TName> = (name, columns, extraConfig) => {
+		return singlestoreTableWithSchema(name, columns, extraConfig, this.schemaName);
 	};
 
 	view = ((name, columns) => {
-		return mysqlViewWithSchema(name, columns, this.schemaName);
-	}) as typeof mysqlView;
+		return singlestoreViewWithSchema(name, columns, this.schemaName);
+	}) as typeof singlestoreView;
 }
 
-/** @deprecated - use `instanceof MySqlSchema` */
-export function isMySqlSchema(obj: unknown): obj is MySqlSchema {
-	return is(obj, MySqlSchema);
+/** @deprecated - use `instanceof SingleStoreSchema` */
+export function isSingleStoreSchema(obj: unknown): obj is SingleStoreSchema {
+	return is(obj, SingleStoreSchema);
 }
 
 /**
- * Create a MySQL schema.
+ * Create a SingleStore schema.
  * https://dev.mysql.com/doc/refman/8.0/en/create-database.html
+ * TODO(singlestore)
  *
- * @param name mysql use schema name
- * @returns MySQL schema
+ * @param name singlestore use schema name
+ * @returns SingleStore schema
  */
-export function mysqlDatabase<TName extends string>(name: TName) {
-	return new MySqlSchema(name);
+export function singlestoreDatabase<TName extends string>(name: TName) {
+	return new SingleStoreSchema(name);
 }
 
 /**
- * @see mysqlDatabase
+ * @see singlestoreDatabase
  */
-export const mysqlSchema = mysqlDatabase;
+export const singlestoreSchema = singlestoreDatabase;
diff --git a/drizzle-orm/src/singlestore-core/session.ts b/drizzle-orm/src/singlestore-core/session.ts
index 08ad1ebb6..b95589a45 100644
--- a/drizzle-orm/src/singlestore-core/session.ts
+++ b/drizzle-orm/src/singlestore-core/session.ts
@@ -3,47 +3,47 @@ import { TransactionRollbackError } from '~/errors.ts';
 import type { RelationalSchemaConfig, TablesRelationalConfig } from '~/relations.ts';
 import { type Query, type SQL, sql } from '~/sql/sql.ts';
 import type { Assume, Equal } from '~/utils.ts';
-import { MySqlDatabase } from './db.ts';
-import type { MySqlDialect } from './dialect.ts';
+import { SingleStoreDatabase } from './db.ts';
+import type { SingleStoreDialect } from './dialect.ts';
 import type { SelectedFieldsOrdered } from './query-builders/select.types.ts';
 
 export type Mode = 'default' | 'planetscale';
 
-export interface MySqlQueryResultHKT {
-	readonly $brand: 'MySqlQueryResultHKT';
+export interface SingleStoreQueryResultHKT {
+	readonly $brand: 'SingleStoreQueryResultHKT';
 	readonly row: unknown;
 	readonly type: unknown;
 }
 
-export interface AnyMySqlQueryResultHKT extends MySqlQueryResultHKT {
+export interface AnySingleStoreQueryResultHKT extends SingleStoreQueryResultHKT {
 	readonly type: any;
 }
 
-export type MySqlQueryResultKind<TKind extends MySqlQueryResultHKT, TRow> = (TKind & {
+export type SingleStoreQueryResultKind<TKind extends SingleStoreQueryResultHKT, TRow> = (TKind & {
 	readonly row: TRow;
 })['type'];
 
-export interface MySqlPreparedQueryConfig {
+export interface SingleStorePreparedQueryConfig {
 	execute: unknown;
 	iterator: unknown;
 }
 
-export interface MySqlPreparedQueryHKT {
-	readonly $brand: 'MySqlPreparedQueryHKT';
+export interface SingleStorePreparedQueryHKT {
+	readonly $brand: 'SingleStorePreparedQueryHKT';
 	readonly config: unknown;
 	readonly type: unknown;
 }
 
 export type PreparedQueryKind<
-	TKind extends MySqlPreparedQueryHKT,
-	TConfig extends MySqlPreparedQueryConfig,
+	TKind extends SingleStorePreparedQueryHKT,
+	TConfig extends SingleStorePreparedQueryConfig,
 	TAssume extends boolean = false,
 > = Equal<TAssume, true> extends true
-	? Assume<(TKind & { readonly config: TConfig })['type'], MySqlPreparedQuery<TConfig>>
+	? Assume<(TKind & { readonly config: TConfig })['type'], SingleStorePreparedQuery<TConfig>>
 	: (TKind & { readonly config: TConfig })['type'];
 
-export abstract class MySqlPreparedQuery<T extends MySqlPreparedQueryConfig> {
-	static readonly [entityKind]: string = 'MySqlPreparedQuery';
+export abstract class SingleStorePreparedQuery<T extends SingleStorePreparedQueryConfig> {
+	static readonly [entityKind]: string = 'SingleStorePreparedQuery';
 
 	/** @internal */
 	joinsNotNullableMap?: Record<string, boolean>;
@@ -53,23 +53,26 @@ export abstract class MySqlPreparedQuery<T extends MySqlPreparedQueryConfig> {
 	abstract iterator(placeholderValues?: Record<string, unknown>): AsyncGenerator<T['iterator']>;
 }
 
-export interface MySqlTransactionConfig {
+export interface SingleStoreTransactionConfig {
 	withConsistentSnapshot?: boolean;
 	accessMode?: 'read only' | 'read write';
 	isolationLevel: 'read uncommitted' | 'read committed' | 'repeatable read' | 'serializable';
 }
 
-export abstract class MySqlSession<
-	TQueryResult extends MySqlQueryResultHKT = MySqlQueryResultHKT,
+export abstract class SingleStoreSession<
+	TQueryResult extends SingleStoreQueryResultHKT = SingleStoreQueryResultHKT,
 	TPreparedQueryHKT extends PreparedQueryHKTBase = PreparedQueryHKTBase,
 	TFullSchema extends Record<string, unknown> = Record<string, never>,
 	TSchema extends TablesRelationalConfig = Record<string, never>,
 > {
-	static readonly [entityKind]: string = 'MySqlSession';
+	static readonly [entityKind]: string = 'SingleStoreSession';
 
-	constructor(protected dialect: MySqlDialect) {}
+	constructor(protected dialect: SingleStoreDialect) {}
 
-	abstract prepareQuery<T extends MySqlPreparedQueryConfig, TPreparedQueryHKT extends MySqlPreparedQueryHKT>(
+	abstract prepareQuery<
+		T extends SingleStorePreparedQueryConfig,
+		TPreparedQueryHKT extends SingleStorePreparedQueryHKT,
+	>(
 		query: Query,
 		fields: SelectedFieldsOrdered | undefined,
 		customResultMapper?: (rows: unknown[][]) => T['execute'],
@@ -78,7 +81,7 @@ export abstract class MySqlSession<
 	): PreparedQueryKind<TPreparedQueryHKT, T>;
 
 	execute<T>(query: SQL): Promise<T> {
-		return this.prepareQuery<MySqlPreparedQueryConfig & { execute: T }, PreparedQueryHKTBase>(
+		return this.prepareQuery<SingleStorePreparedQueryConfig & { execute: T }, PreparedQueryHKTBase>(
 			this.dialect.sqlToQuery(query),
 			undefined,
 		).execute();
@@ -87,11 +90,11 @@ export abstract class MySqlSession<
 	abstract all<T = unknown>(query: SQL): Promise<T[]>;
 
 	abstract transaction<T>(
-		transaction: (tx: MySqlTransaction<TQueryResult, TPreparedQueryHKT, TFullSchema, TSchema>) => Promise<T>,
-		config?: MySqlTransactionConfig,
+		transaction: (tx: SingleStoreTransaction<TQueryResult, TPreparedQueryHKT, TFullSchema, TSchema>) => Promise<T>,
+		config?: SingleStoreTransactionConfig,
 	): Promise<T>;
 
-	protected getSetTransactionSQL(config: MySqlTransactionConfig): SQL | undefined {
+	protected getSetTransactionSQL(config: SingleStoreTransactionConfig): SQL | undefined {
 		const parts: string[] = [];
 
 		if (config.isolationLevel) {
@@ -101,7 +104,7 @@ export abstract class MySqlSession<
 		return parts.length ? sql.join(['set transaction ', parts.join(' ')]) : undefined;
 	}
 
-	protected getStartTransactionSQL(config: MySqlTransactionConfig): SQL | undefined {
+	protected getStartTransactionSQL(config: SingleStoreTransactionConfig): SQL | undefined {
 		const parts: string[] = [];
 
 		if (config.withConsistentSnapshot) {
@@ -116,17 +119,17 @@ export abstract class MySqlSession<
 	}
 }
 
-export abstract class MySqlTransaction<
-	TQueryResult extends MySqlQueryResultHKT,
+export abstract class SingleStoreTransaction<
+	TQueryResult extends SingleStoreQueryResultHKT,
 	TPreparedQueryHKT extends PreparedQueryHKTBase,
 	TFullSchema extends Record<string, unknown> = Record<string, never>,
 	TSchema extends TablesRelationalConfig = Record<string, never>,
-> extends MySqlDatabase<TQueryResult, TPreparedQueryHKT, TFullSchema, TSchema> {
-	static readonly [entityKind]: string = 'MySqlTransaction';
+> extends SingleStoreDatabase<TQueryResult, TPreparedQueryHKT, TFullSchema, TSchema> {
+	static readonly [entityKind]: string = 'SingleStoreTransaction';
 
 	constructor(
-		dialect: MySqlDialect,
-		session: MySqlSession,
+		dialect: SingleStoreDialect,
+		session: SingleStoreSession,
 		protected schema: RelationalSchemaConfig<TSchema> | undefined,
 		protected readonly nestedIndex: number,
 		mode: Mode,
@@ -140,10 +143,10 @@ export abstract class MySqlTransaction<
 
 	/** Nested transactions (aka savepoints) only work with InnoDB engine. */
 	abstract override transaction<T>(
-		transaction: (tx: MySqlTransaction<TQueryResult, TPreparedQueryHKT, TFullSchema, TSchema>) => Promise<T>,
+		transaction: (tx: SingleStoreTransaction<TQueryResult, TPreparedQueryHKT, TFullSchema, TSchema>) => Promise<T>,
 	): Promise<T>;
 }
 
-export interface PreparedQueryHKTBase extends MySqlPreparedQueryHKT {
-	type: MySqlPreparedQuery<Assume<this['config'], MySqlPreparedQueryConfig>>;
+export interface PreparedQueryHKTBase extends SingleStorePreparedQueryHKT {
+	type: SingleStorePreparedQuery<Assume<this['config'], SingleStorePreparedQueryConfig>>;
 }
diff --git a/drizzle-orm/src/singlestore-core/subquery.ts b/drizzle-orm/src/singlestore-core/subquery.ts
index 9d2c1828c..a4605c56d 100644
--- a/drizzle-orm/src/singlestore-core/subquery.ts
+++ b/drizzle-orm/src/singlestore-core/subquery.ts
@@ -6,12 +6,12 @@ export type SubqueryWithSelection<
 	TSelection extends ColumnsSelection,
 	TAlias extends string,
 > =
-	& Subquery<TAlias, AddAliasToSelection<TSelection, TAlias, 'mysql'>>
-	& AddAliasToSelection<TSelection, TAlias, 'mysql'>;
+	& Subquery<TAlias, AddAliasToSelection<TSelection, TAlias, 'singlestore'>>
+	& AddAliasToSelection<TSelection, TAlias, 'singlestore'>;
 
 export type WithSubqueryWithSelection<
 	TSelection extends ColumnsSelection,
 	TAlias extends string,
 > =
-	& WithSubquery<TAlias, AddAliasToSelection<TSelection, TAlias, 'mysql'>>
-	& AddAliasToSelection<TSelection, TAlias, 'mysql'>;
+	& WithSubquery<TAlias, AddAliasToSelection<TSelection, TAlias, 'singlestore'>>
+	& AddAliasToSelection<TSelection, TAlias, 'singlestore'>;
diff --git a/drizzle-orm/src/singlestore-core/table.ts b/drizzle-orm/src/singlestore-core/table.ts
index 3b1d4c3a3..040e3981f 100644
--- a/drizzle-orm/src/singlestore-core/table.ts
+++ b/drizzle-orm/src/singlestore-core/table.ts
@@ -2,13 +2,13 @@ import type { BuildColumns, BuildExtraConfigColumns } from '~/column-builder.ts'
 import { entityKind } from '~/entity.ts';
 import { Table, type TableConfig as TableConfigBase, type UpdateTableConfig } from '~/table.ts';
 import type { CheckBuilder } from './checks.ts';
-import type { MySqlColumn, MySqlColumnBuilder, MySqlColumnBuilderBase } from './columns/common.ts';
+import type { SingleStoreColumn, SingleStoreColumnBuilder, SingleStoreColumnBuilderBase } from './columns/common.ts';
 import type { ForeignKey, ForeignKeyBuilder } from './foreign-keys.ts';
 import type { AnyIndexBuilder } from './indexes.ts';
 import type { PrimaryKeyBuilder } from './primary-keys.ts';
 import type { UniqueConstraintBuilder } from './unique-constraint.ts';
 
-export type MySqlTableExtraConfig = Record<
+export type SingleStoreTableExtraConfig = Record<
 	string,
 	| AnyIndexBuilder
 	| CheckBuilder
@@ -17,13 +17,13 @@ export type MySqlTableExtraConfig = Record<
 	| UniqueConstraintBuilder
 >;
 
-export type TableConfig = TableConfigBase<MySqlColumn>;
+export type TableConfig = TableConfigBase<SingleStoreColumn>;
 
 /** @internal */
-export const InlineForeignKeys = Symbol.for('drizzle:MySqlInlineForeignKeys');
+export const InlineForeignKeys = Symbol.for('drizzle:SingleStoreInlineForeignKeys');
 
-export class MySqlTable<T extends TableConfig = TableConfig> extends Table<T> {
-	static readonly [entityKind]: string = 'MySqlTable';
+export class SingleStoreTable<T extends TableConfig = TableConfig> extends Table<T> {
+	static readonly [entityKind]: string = 'SingleStoreTable';
 
 	declare protected $columns: T['columns'];
 
@@ -40,51 +40,53 @@ export class MySqlTable<T extends TableConfig = TableConfig> extends Table<T> {
 
 	/** @internal */
 	override [Table.Symbol.ExtraConfigBuilder]:
-		| ((self: Record<string, MySqlColumn>) => MySqlTableExtraConfig)
+		| ((self: Record<string, SingleStoreColumn>) => SingleStoreTableExtraConfig)
 		| undefined = undefined;
 }
 
-export type AnyMySqlTable<TPartial extends Partial<TableConfig> = {}> = MySqlTable<
+export type AnySingleStoreTable<TPartial extends Partial<TableConfig> = {}> = SingleStoreTable<
 	UpdateTableConfig<TableConfig, TPartial>
 >;
 
-export type MySqlTableWithColumns<T extends TableConfig> =
-	& MySqlTable<T>
+export type SingleStoreTableWithColumns<T extends TableConfig> =
+	& SingleStoreTable<T>
 	& {
 		[Key in keyof T['columns']]: T['columns'][Key];
 	};
 
-export function mysqlTableWithSchema<
+export function singlestoreTableWithSchema<
 	TTableName extends string,
 	TSchemaName extends string | undefined,
-	TColumnsMap extends Record<string, MySqlColumnBuilderBase>,
+	TColumnsMap extends Record<string, SingleStoreColumnBuilderBase>,
 >(
 	name: TTableName,
 	columns: TColumnsMap,
-	extraConfig: ((self: BuildColumns<TTableName, TColumnsMap, 'mysql'>) => MySqlTableExtraConfig) | undefined,
+	extraConfig:
+		| ((self: BuildColumns<TTableName, TColumnsMap, 'singlestore'>) => SingleStoreTableExtraConfig)
+		| undefined,
 	schema: TSchemaName,
 	baseName = name,
-): MySqlTableWithColumns<{
+): SingleStoreTableWithColumns<{
 	name: TTableName;
 	schema: TSchemaName;
-	columns: BuildColumns<TTableName, TColumnsMap, 'mysql'>;
-	dialect: 'mysql';
+	columns: BuildColumns<TTableName, TColumnsMap, 'singlestore'>;
+	dialect: 'singlestore';
 }> {
-	const rawTable = new MySqlTable<{
+	const rawTable = new SingleStoreTable<{
 		name: TTableName;
 		schema: TSchemaName;
-		columns: BuildColumns<TTableName, TColumnsMap, 'mysql'>;
-		dialect: 'mysql';
+		columns: BuildColumns<TTableName, TColumnsMap, 'singlestore'>;
+		dialect: 'singlestore';
 	}>(name, schema, baseName);
 
 	const builtColumns = Object.fromEntries(
 		Object.entries(columns).map(([name, colBuilderBase]) => {
-			const colBuilder = colBuilderBase as MySqlColumnBuilder;
+			const colBuilder = colBuilderBase as SingleStoreColumnBuilder;
 			const column = colBuilder.build(rawTable);
 			rawTable[InlineForeignKeys].push(...colBuilder.buildForeignKeys(column, rawTable));
 			return [name, column];
 		}),
-	) as unknown as BuildColumns<TTableName, TColumnsMap, 'mysql'>;
+	) as unknown as BuildColumns<TTableName, TColumnsMap, 'singlestore'>;
 
 	const table = Object.assign(rawTable, builtColumns);
 
@@ -92,40 +94,40 @@ export function mysqlTableWithSchema<
 	table[Table.Symbol.ExtraConfigColumns] = builtColumns as unknown as BuildExtraConfigColumns<
 		TTableName,
 		TColumnsMap,
-		'mysql'
+		'singlestore'
 	>;
 
 	if (extraConfig) {
-		table[MySqlTable.Symbol.ExtraConfigBuilder] = extraConfig as unknown as (
-			self: Record<string, MySqlColumn>,
-		) => MySqlTableExtraConfig;
+		table[SingleStoreTable.Symbol.ExtraConfigBuilder] = extraConfig as unknown as (
+			self: Record<string, SingleStoreColumn>,
+		) => SingleStoreTableExtraConfig;
 	}
 
 	return table;
 }
 
-export interface MySqlTableFn<TSchemaName extends string | undefined = undefined> {
+export interface SingleStoreTableFn<TSchemaName extends string | undefined = undefined> {
 	<
 		TTableName extends string,
-		TColumnsMap extends Record<string, MySqlColumnBuilderBase>,
+		TColumnsMap extends Record<string, SingleStoreColumnBuilderBase>,
 	>(
 		name: TTableName,
 		columns: TColumnsMap,
-		extraConfig?: (self: BuildColumns<TTableName, TColumnsMap, 'mysql'>) => MySqlTableExtraConfig,
-	): MySqlTableWithColumns<{
+		extraConfig?: (self: BuildColumns<TTableName, TColumnsMap, 'singlestore'>) => SingleStoreTableExtraConfig,
+	): SingleStoreTableWithColumns<{
 		name: TTableName;
 		schema: TSchemaName;
-		columns: BuildColumns<TTableName, TColumnsMap, 'mysql'>;
-		dialect: 'mysql';
+		columns: BuildColumns<TTableName, TColumnsMap, 'singlestore'>;
+		dialect: 'singlestore';
 	}>;
 }
 
-export const mysqlTable: MySqlTableFn = (name, columns, extraConfig) => {
-	return mysqlTableWithSchema(name, columns, extraConfig, undefined, name);
+export const singlestoreTable: SingleStoreTableFn = (name, columns, extraConfig) => {
+	return singlestoreTableWithSchema(name, columns, extraConfig, undefined, name);
 };
 
-export function mysqlTableCreator(customizeTableName: (name: string) => string): MySqlTableFn {
+export function singlestoreTableCreator(customizeTableName: (name: string) => string): SingleStoreTableFn {
 	return (name, columns, extraConfig) => {
-		return mysqlTableWithSchema(customizeTableName(name) as typeof name, columns, extraConfig, undefined, name);
+		return singlestoreTableWithSchema(customizeTableName(name) as typeof name, columns, extraConfig, undefined, name);
 	};
 }
diff --git a/drizzle-orm/src/singlestore-core/unique-constraint.ts b/drizzle-orm/src/singlestore-core/unique-constraint.ts
index 66ed65198..faa4f3216 100644
--- a/drizzle-orm/src/singlestore-core/unique-constraint.ts
+++ b/drizzle-orm/src/singlestore-core/unique-constraint.ts
@@ -1,36 +1,36 @@
 import { entityKind } from '~/entity.ts';
-import type { MySqlColumn } from './columns/index.ts';
-import { MySqlTable } from './table.ts';
+import type { SingleStoreColumn } from './columns/index.ts';
+import { SingleStoreTable } from './table.ts';
 
 export function unique(name?: string): UniqueOnConstraintBuilder {
 	return new UniqueOnConstraintBuilder(name);
 }
 
-export function uniqueKeyName(table: MySqlTable, columns: string[]) {
-	return `${table[MySqlTable.Symbol.Name]}_${columns.join('_')}_unique`;
+export function uniqueKeyName(table: SingleStoreTable, columns: string[]) {
+	return `${table[SingleStoreTable.Symbol.Name]}_${columns.join('_')}_unique`;
 }
 
 export class UniqueConstraintBuilder {
-	static readonly [entityKind]: string = 'MySqlUniqueConstraintBuilder';
+	static readonly [entityKind]: string = 'SingleStoreUniqueConstraintBuilder';
 
 	/** @internal */
-	columns: MySqlColumn[];
+	columns: SingleStoreColumn[];
 
 	constructor(
-		columns: MySqlColumn[],
+		columns: SingleStoreColumn[],
 		private name?: string,
 	) {
 		this.columns = columns;
 	}
 
 	/** @internal */
-	build(table: MySqlTable): UniqueConstraint {
+	build(table: SingleStoreTable): UniqueConstraint {
 		return new UniqueConstraint(table, this.columns, this.name);
 	}
 }
 
 export class UniqueOnConstraintBuilder {
-	static readonly [entityKind]: string = 'MySqlUniqueOnConstraintBuilder';
+	static readonly [entityKind]: string = 'SingleStoreUniqueOnConstraintBuilder';
 
 	/** @internal */
 	name?: string;
@@ -41,19 +41,19 @@ export class UniqueOnConstraintBuilder {
 		this.name = name;
 	}
 
-	on(...columns: [MySqlColumn, ...MySqlColumn[]]) {
+	on(...columns: [SingleStoreColumn, ...SingleStoreColumn[]]) {
 		return new UniqueConstraintBuilder(columns, this.name);
 	}
 }
 
 export class UniqueConstraint {
-	static readonly [entityKind]: string = 'MySqlUniqueConstraint';
+	static readonly [entityKind]: string = 'SingleStoreUniqueConstraint';
 
-	readonly columns: MySqlColumn[];
+	readonly columns: SingleStoreColumn[];
 	readonly name?: string;
 	readonly nullsNotDistinct: boolean = false;
 
-	constructor(readonly table: MySqlTable, columns: MySqlColumn[], name?: string) {
+	constructor(readonly table: SingleStoreTable, columns: SingleStoreColumn[], name?: string) {
 		this.columns = columns;
 		this.name = name ?? uniqueKeyName(this.table, this.columns.map((column) => column.name));
 	}
diff --git a/drizzle-orm/src/singlestore-core/utils.ts b/drizzle-orm/src/singlestore-core/utils.ts
index f09f65f3e..e90c5ae40 100644
--- a/drizzle-orm/src/singlestore-core/utils.ts
+++ b/drizzle-orm/src/singlestore-core/utils.ts
@@ -9,26 +9,26 @@ import type { Index } from './indexes.ts';
 import { IndexBuilder } from './indexes.ts';
 import type { PrimaryKey } from './primary-keys.ts';
 import { PrimaryKeyBuilder } from './primary-keys.ts';
-import { MySqlTable } from './table.ts';
+import { SingleStoreTable } from './table.ts';
 import { type UniqueConstraint, UniqueConstraintBuilder } from './unique-constraint.ts';
-import { MySqlViewConfig } from './view-common.ts';
-import type { MySqlView } from './view.ts';
+import { SingleStoreViewConfig } from './view-common.ts';
+import type { SingleStoreView } from './view.ts';
 
-export function getTableConfig(table: MySqlTable) {
-	const columns = Object.values(table[MySqlTable.Symbol.Columns]);
+export function getTableConfig(table: SingleStoreTable) {
+	const columns = Object.values(table[SingleStoreTable.Symbol.Columns]);
 	const indexes: Index[] = [];
 	const checks: Check[] = [];
 	const primaryKeys: PrimaryKey[] = [];
 	const uniqueConstraints: UniqueConstraint[] = [];
-	const foreignKeys: ForeignKey[] = Object.values(table[MySqlTable.Symbol.InlineForeignKeys]);
+	const foreignKeys: ForeignKey[] = Object.values(table[SingleStoreTable.Symbol.InlineForeignKeys]);
 	const name = table[Table.Symbol.Name];
 	const schema = table[Table.Symbol.Schema];
 	const baseName = table[Table.Symbol.BaseName];
 
-	const extraConfigBuilder = table[MySqlTable.Symbol.ExtraConfigBuilder];
+	const extraConfigBuilder = table[SingleStoreTable.Symbol.ExtraConfigBuilder];
 
 	if (extraConfigBuilder !== undefined) {
-		const extraConfig = extraConfigBuilder(table[MySqlTable.Symbol.Columns]);
+		const extraConfig = extraConfigBuilder(table[SingleStoreTable.Symbol.Columns]);
 		for (const builder of Object.values(extraConfig)) {
 			if (is(builder, IndexBuilder)) {
 				indexes.push(builder.build(table));
@@ -60,9 +60,9 @@ export function getTableConfig(table: MySqlTable) {
 export function getViewConfig<
 	TName extends string = string,
 	TExisting extends boolean = boolean,
->(view: MySqlView<TName, TExisting>) {
+>(view: SingleStoreView<TName, TExisting>) {
 	return {
 		...view[ViewBaseConfig],
-		...view[MySqlViewConfig],
+		...view[SingleStoreViewConfig],
 	};
 }
diff --git a/drizzle-orm/src/singlestore-core/view-base.ts b/drizzle-orm/src/singlestore-core/view-base.ts
index 46b1527d9..f71536e28 100644
--- a/drizzle-orm/src/singlestore-core/view-base.ts
+++ b/drizzle-orm/src/singlestore-core/view-base.ts
@@ -2,14 +2,14 @@ import { entityKind } from '~/entity.ts';
 import type { ColumnsSelection } from '~/sql/sql.ts';
 import { View } from '~/sql/sql.ts';
 
-export abstract class MySqlViewBase<
+export abstract class SingleStoreViewBase<
 	TName extends string = string,
 	TExisting extends boolean = boolean,
 	TSelectedFields extends ColumnsSelection = ColumnsSelection,
 > extends View<TName, TExisting, TSelectedFields> {
-	static readonly [entityKind]: string = 'MySqlViewBase';
+	static readonly [entityKind]: string = 'SingleStoreViewBase';
 
 	declare readonly _: View<TName, TExisting, TSelectedFields>['_'] & {
-		readonly viewBrand: 'MySqlViewBase';
+		readonly viewBrand: 'SingleStoreViewBase';
 	};
 }
diff --git a/drizzle-orm/src/singlestore-core/view-common.ts b/drizzle-orm/src/singlestore-core/view-common.ts
index 9bbc130c3..d29c3d5ad 100644
--- a/drizzle-orm/src/singlestore-core/view-common.ts
+++ b/drizzle-orm/src/singlestore-core/view-common.ts
@@ -1 +1 @@
-export const MySqlViewConfig = Symbol.for('drizzle:MySqlViewConfig');
+export const SingleStoreViewConfig = Symbol.for('drizzle:SingleStoreViewConfig');
diff --git a/drizzle-orm/src/singlestore-core/view.ts b/drizzle-orm/src/singlestore-core/view.ts
index 4cc7d416c..3c6c8d25c 100644
--- a/drizzle-orm/src/singlestore-core/view.ts
+++ b/drizzle-orm/src/singlestore-core/view.ts
@@ -5,12 +5,12 @@ import type { AddAliasToSelection } from '~/query-builders/select.types.ts';
 import { SelectionProxyHandler } from '~/selection-proxy.ts';
 import type { ColumnsSelection, SQL } from '~/sql/sql.ts';
 import { getTableColumns } from '~/utils.ts';
-import type { MySqlColumn, MySqlColumnBuilderBase } from './columns/index.ts';
+import type { SingleStoreColumn, SingleStoreColumnBuilderBase } from './columns/index.ts';
 import { QueryBuilder } from './query-builders/query-builder.ts';
 import type { SelectedFields } from './query-builders/select.types.ts';
-import { mysqlTable } from './table.ts';
-import { MySqlViewBase } from './view-base.ts';
-import { MySqlViewConfig } from './view-common.ts';
+import { singlestoreTable } from './table.ts';
+import { SingleStoreViewBase } from './view-base.ts';
+import { SingleStoreViewConfig } from './view-common.ts';
 
 export interface ViewBuilderConfig {
 	algorithm?: 'undefined' | 'merge' | 'temptable';
@@ -20,7 +20,7 @@ export interface ViewBuilderConfig {
 }
 
 export class ViewBuilderCore<TConfig extends { name: string; columns?: unknown }> {
-	static readonly [entityKind]: string = 'MySqlViewBuilder';
+	static readonly [entityKind]: string = 'SingleStoreViewBuilder';
 
 	declare readonly _: {
 		readonly name: TConfig['name'];
@@ -64,11 +64,11 @@ export class ViewBuilderCore<TConfig extends { name: string; columns?: unknown }
 }
 
 export class ViewBuilder<TName extends string = string> extends ViewBuilderCore<{ name: TName }> {
-	static readonly [entityKind]: string = 'MySqlViewBuilder';
+	static readonly [entityKind]: string = 'SingleStoreViewBuilder';
 
 	as<TSelectedFields extends SelectedFields>(
 		qb: TypedQueryBuilder<TSelectedFields> | ((qb: QueryBuilder) => TypedQueryBuilder<TSelectedFields>),
-	): MySqlViewWithSelection<TName, false, AddAliasToSelection<TSelectedFields, TName, 'mysql'>> {
+	): SingleStoreViewWithSelection<TName, false, AddAliasToSelection<TSelectedFields, TName, 'singlestore'>> {
 		if (typeof qb === 'function') {
 			qb = qb(new QueryBuilder());
 		}
@@ -80,8 +80,8 @@ export class ViewBuilder<TName extends string = string> extends ViewBuilderCore<
 		});
 		const aliasedSelection = new Proxy(qb.getSelectedFields(), selectionProxy);
 		return new Proxy(
-			new MySqlView({
-				mysqlConfig: this.config,
+			new SingleStoreView({
+				singlestoreConfig: this.config,
 				config: {
 					name: this.name,
 					schema: this.schema,
@@ -90,17 +90,17 @@ export class ViewBuilder<TName extends string = string> extends ViewBuilderCore<
 				},
 			}),
 			selectionProxy as any,
-		) as MySqlViewWithSelection<TName, false, AddAliasToSelection<TSelectedFields, TName, 'mysql'>>;
+		) as SingleStoreViewWithSelection<TName, false, AddAliasToSelection<TSelectedFields, TName, 'singlestore'>>;
 	}
 }
 
 export class ManualViewBuilder<
 	TName extends string = string,
-	TColumns extends Record<string, MySqlColumnBuilderBase> = Record<string, MySqlColumnBuilderBase>,
+	TColumns extends Record<string, SingleStoreColumnBuilderBase> = Record<string, SingleStoreColumnBuilderBase>,
 > extends ViewBuilderCore<{ name: TName; columns: TColumns }> {
-	static readonly [entityKind]: string = 'MySqlManualViewBuilder';
+	static readonly [entityKind]: string = 'SingleStoreManualViewBuilder';
 
-	private columns: Record<string, MySqlColumn>;
+	private columns: Record<string, SingleStoreColumn>;
 
 	constructor(
 		name: TName,
@@ -108,13 +108,13 @@ export class ManualViewBuilder<
 		schema: string | undefined,
 	) {
 		super(name, schema);
-		this.columns = getTableColumns(mysqlTable(name, columns)) as BuildColumns<TName, TColumns, 'mysql'>;
+		this.columns = getTableColumns(singlestoreTable(name, columns)) as BuildColumns<TName, TColumns, 'singlestore'>;
 	}
 
-	existing(): MySqlViewWithSelection<TName, true, BuildColumns<TName, TColumns, 'mysql'>> {
+	existing(): SingleStoreViewWithSelection<TName, true, BuildColumns<TName, TColumns, 'singlestore'>> {
 		return new Proxy(
-			new MySqlView({
-				mysqlConfig: undefined,
+			new SingleStoreView({
+				singlestoreConfig: undefined,
 				config: {
 					name: this.name,
 					schema: this.schema,
@@ -128,13 +128,13 @@ export class ManualViewBuilder<
 				sqlAliasedBehavior: 'alias',
 				replaceOriginalName: true,
 			}),
-		) as MySqlViewWithSelection<TName, true, BuildColumns<TName, TColumns, 'mysql'>>;
+		) as SingleStoreViewWithSelection<TName, true, BuildColumns<TName, TColumns, 'singlestore'>>;
 	}
 
-	as(query: SQL): MySqlViewWithSelection<TName, false, BuildColumns<TName, TColumns, 'mysql'>> {
+	as(query: SQL): SingleStoreViewWithSelection<TName, false, BuildColumns<TName, TColumns, 'singlestore'>> {
 		return new Proxy(
-			new MySqlView({
-				mysqlConfig: this.config,
+			new SingleStoreView({
+				singlestoreConfig: this.config,
 				config: {
 					name: this.name,
 					schema: this.schema,
@@ -148,23 +148,23 @@ export class ManualViewBuilder<
 				sqlAliasedBehavior: 'alias',
 				replaceOriginalName: true,
 			}),
-		) as MySqlViewWithSelection<TName, false, BuildColumns<TName, TColumns, 'mysql'>>;
+		) as SingleStoreViewWithSelection<TName, false, BuildColumns<TName, TColumns, 'singlestore'>>;
 	}
 }
 
-export class MySqlView<
+export class SingleStoreView<
 	TName extends string = string,
 	TExisting extends boolean = boolean,
 	TSelectedFields extends ColumnsSelection = ColumnsSelection,
-> extends MySqlViewBase<TName, TExisting, TSelectedFields> {
-	static readonly [entityKind]: string = 'MySqlView';
+> extends SingleStoreViewBase<TName, TExisting, TSelectedFields> {
+	static readonly [entityKind]: string = 'SingleStoreView';
 
-	declare protected $MySqlViewBrand: 'MySqlView';
+	declare protected $SingleStoreViewBrand: 'SingleStoreView';
 
-	[MySqlViewConfig]: ViewBuilderConfig | undefined;
+	[SingleStoreViewConfig]: ViewBuilderConfig | undefined;
 
-	constructor({ mysqlConfig, config }: {
-		mysqlConfig: ViewBuilderConfig | undefined;
+	constructor({ singlestoreConfig, config }: {
+		singlestoreConfig: ViewBuilderConfig | undefined;
 		config: {
 			name: TName;
 			schema: string | undefined;
@@ -173,20 +173,20 @@ export class MySqlView<
 		};
 	}) {
 		super(config);
-		this[MySqlViewConfig] = mysqlConfig;
+		this[SingleStoreViewConfig] = singlestoreConfig;
 	}
 }
 
-export type MySqlViewWithSelection<
+export type SingleStoreViewWithSelection<
 	TName extends string,
 	TExisting extends boolean,
 	TSelectedFields extends ColumnsSelection,
-> = MySqlView<TName, TExisting, TSelectedFields> & TSelectedFields;
+> = SingleStoreView<TName, TExisting, TSelectedFields> & TSelectedFields;
 
 /** @internal */
-export function mysqlViewWithSchema(
+export function singlestoreViewWithSchema(
 	name: string,
-	selection: Record<string, MySqlColumnBuilderBase> | undefined,
+	selection: Record<string, SingleStoreColumnBuilderBase> | undefined,
 	schema: string | undefined,
 ): ViewBuilder | ManualViewBuilder {
 	if (selection) {
@@ -195,14 +195,14 @@ export function mysqlViewWithSchema(
 	return new ViewBuilder(name, schema);
 }
 
-export function mysqlView<TName extends string>(name: TName): ViewBuilder<TName>;
-export function mysqlView<TName extends string, TColumns extends Record<string, MySqlColumnBuilderBase>>(
+export function singlestoreView<TName extends string>(name: TName): ViewBuilder<TName>;
+export function singlestoreView<TName extends string, TColumns extends Record<string, SingleStoreColumnBuilderBase>>(
 	name: TName,
 	columns: TColumns,
 ): ManualViewBuilder<TName, TColumns>;
-export function mysqlView(
+export function singlestoreView(
 	name: string,
-	selection?: Record<string, MySqlColumnBuilderBase>,
+	selection?: Record<string, SingleStoreColumnBuilderBase>,
 ): ViewBuilder | ManualViewBuilder {
-	return mysqlViewWithSchema(name, selection, undefined);
+	return singlestoreViewWithSchema(name, selection, undefined);
 }