{

private PostgresAdapter $adapter;

protected function setUp(): void

{

$this->adapter = new PostgresAdapter();

}

private function invoke(string $method, array $args)

{

$ref = new \ReflectionMethod(PostgresAdapter::class, $method);

$ref->setAccessible(true);

return $ref->invoke($this->adapter, ...$args);

}

/** Build an information_schema.columns row with sensible defaults. */

private static function colRow(string $table, string $name, array $overrides = []): array

{

return array_merge([

'table_name' => $table,

'column_name' => $name,

'data_type' => 'integer',

'character_maximum_length' => null,

'is_nullable' => 'YES',

'column_default' => null,

'numeric_precision' => null,

'numeric_scale' => null,

'udt_name' => 'int4',

'datetime_precision' => null,

'is_identity' => 'NO',

'identity_generation' => null,

'identity_start' => null,

'identity_increment' => null,

'identity_maximum' => null,

'identity_minimum' => null,

'identity_cycle' => null,

'explicit_collation' => null,

'att_storage' => null,

'type_storage' => null,

'att_compression' => null,

'is_generated' => 'NEVER',

'generation_expression' => null,

'domain_name' => null,

], $overrides);

}

/** Build a table_constraints row with sensible defaults. */

private static function conRow(string $table, string $name, array $overrides = []): array

{

return array_merge([

'table_name' => $table,

'constraint_name' => $name,

'constraint_type' => 'UNIQUE',

'is_deferrable' => 'NO',

'initially_deferred' => 'NO',

'column_name' => null,

'ordinal_position' => 1,

'foreign_table' => null,

'foreign_column' => null,

'update_rule' => null,

'delete_rule' => null,

'match_option' => 'NONE',

'convalidated' => true,

], $overrides);

}

/** Build a PG18+ named NOT NULL constraint row (pg_constraint contype='n'). */

private static function notNullRow(

string $table,

string $conname,

string $column,

bool $convalidated = true

): array {

return [

'table_name' => $table,

'conname' => $conname,

'column_name' => $column,

'convalidated' => $convalidated,

];

}

// ── Interface wiring ──────────────────────────────────────────────────

public function testPostgresAdapterDeclaresBulkCapability(): void

{

// DBSchema uses this instanceof check to decide whether to batch.

$this->assertInstanceOf(BulkSchemaAdapterInterface::class, $this->adapter);

}

// ── assembleColumns ───────────────────────────────────────────────────

public function testAssembleColumnsSplitsRowsAcrossTables(): void

{

$rows = [

self::colRow('users', 'id'),

self::colRow('users', 'email', ['data_type' => 'text']),

self::colRow('orders', 'id'),

];

$result = $this->invoke('assembleColumns', [$rows, [], []]);

$this->assertSame(['users', 'orders'], array_keys($result));

$this->assertSame(['id', 'email'], array_keys($result['users']));

$this->assertSame(['id'], array_keys($result['orders']));

}

public function testAssembleColumnsKeepsSameColumnNameSeparatePerTable(): void

{

// Two tables sharing a column name must not overwrite each other —

// the failure mode a flat, non-table-keyed result would produce.

$rows = [

self::colRow('users', 'name', ['data_type' => 'text']),

self::colRow('orders', 'name', ['data_type' => 'character varying',

'character_maximum_length' => 50]),

];

$result = $this->invoke('assembleColumns', [$rows, [], []]);

$this->assertSame('"name" text', $result['users']['name']);

$this->assertSame('"name" varchar(50)', $result['orders']['name']);

}

public function testAssembleColumnsEmitsNotNullAndDefault(): void

{

$rows = [self::colRow('t', 'status', [

'data_type' => 'text',

'is_nullable' => 'NO',

'column_default' => "'active'::text",

])];

$result = $this->invoke('assembleColumns', [$rows, [], []]);

$this->assertSame('"status" text NOT NULL DEFAULT \'active\'::text', $result['t']['status']);

}

public function testAssembleColumnsEmitsIdentity(): void

{

$rows = [self::colRow('t', 'id', [

'is_nullable' => 'NO',

'is_identity' => 'YES',

'identity_generation' => 'ALWAYS',

'column_default' => 'nextval(...)',

])];

$result = $this->invoke('assembleColumns', [$rows, [], []]);

// Identity columns carry no DEFAULT clause even when one is reported.

$this->assertSame('"id" integer NOT NULL GENERATED ALWAYS AS IDENTITY', $result['t']['id']);

}

public function testAssembleColumnsDefaultsIdentityGenerationWhenNull(): void

{

$rows = [self::colRow('t', 'id', [

'is_identity' => 'YES',

'identity_generation' => null,

])];

$result = $this->invoke('assembleColumns', [$rows, [], []]);

$this->assertSame('"id" integer GENERATED BY DEFAULT AS IDENTITY', $result['t']['id']);

}

public function testAssembleColumnsEmitsNonDefaultIdentityOptions(): void

{

$rows = [self::colRow('t', 'id', [

'data_type' => 'bigint',

'is_identity' => 'YES',

'identity_generation' => 'ALWAYS',

'identity_increment' => '10',

'identity_start' => '100',

])];

$result = $this->invoke('assembleColumns', [$rows, [], []]);

$this->assertSame(

'"id" bigint GENERATED ALWAYS AS IDENTITY (INCREMENT BY 10 START WITH 100)',

$result['t']['id']

);

}

/**

public function testAssembleColumnsOmitsIdentityOptionsThatAreTypeDefaults(): void

{

$rows = [self::colRow('t', 'id', [

'data_type' => 'integer',

'is_identity' => 'YES',

'identity_generation' => 'ALWAYS',

'identity_increment' => '1',

'identity_start' => '1',

'identity_minimum' => '1',

'identity_maximum' => '2147483647',

'identity_cycle' => 'NO',

])];

$result = $this->invoke('assembleColumns', [$rows, [], []]);

$this->assertSame('"id" integer GENERATED ALWAYS AS IDENTITY', $result['t']['id']);

}

public function testAssembleColumnsEmitsIdentityCycle(): void

{

$rows = [self::colRow('t', 'id', [

'data_type' => 'smallint',

'is_identity' => 'YES',

'identity_generation' => 'BY DEFAULT',

'identity_maximum' => '999',

'identity_cycle' => 'YES',

])];

$result = $this->invoke('assembleColumns', [$rows, [], []]);

$this->assertSame(

'"id" smallint GENERATED BY DEFAULT AS IDENTITY (MAXVALUE 999 CYCLE)',

$result['t']['id']

);

}

/**

public function testAssembleColumnsEmitsExplicitCollation(): void

{

$rows = [self::colRow('t', 'name', [

'data_type' => 'text',

'udt_name' => 'text',

'explicit_collation' => 'C',

])];

$result = $this->invoke('assembleColumns', [$rows, [], [], []]);

$this->assertSame('"name" text COLLATE "C"', $result['t']['name']);

}

/** An inherited collation must not be spelled out, or nothing ever matches. */

public function testAssembleColumnsOmitsInheritedCollation(): void

{

$rows = [self::colRow('t', 'name', [

'data_type' => 'text',

'udt_name' => 'text',

'explicit_collation' => null,

])];

$result = $this->invoke('assembleColumns', [$rows, [], [], []]);

$this->assertSame('"name" text', $result['t']['name']);

}

public function testAssembleColumnsEmitsColumnCompression(): void

{

foreach (['l' => 'lz4', 'p' => 'pglz'] as $code => $word) {

$rows = [self::colRow('t', 'big', [

'data_type' => 'text',

'udt_name' => 'text',

'att_compression' => $code,

])];

$result = $this->invoke('assembleColumns', [$rows, [], [], []]);

$this->assertSame("\"big\" text COMPRESSION $word", $result['t']['big']);

}

}

public function testStorageStatementsOnlyCoverColumnsThatDifferFromTheirType(): void

{

$stmts = \DBDiff\DB\Support\PostgresSchemaHelper::storageStatements('"t"', [

'a' => ['att_storage' => 'p', 'type_storage' => 'x'],

'b' => ['att_storage' => 'x', 'type_storage' => 'x'],

'c' => ['att_storage' => 'e', 'type_storage' => 'x'],

]);

$this->assertSame([

'ALTER TABLE "t" ALTER COLUMN "a" SET STORAGE PLAIN',

'ALTER TABLE "t" ALTER COLUMN "c" SET STORAGE EXTERNAL',

], $stmts);

}

public function testAssembleColumnsEmitsStoredGeneratedColumn(): void

{

$rows = [self::colRow('t', 'total', [

'data_type' => 'numeric',

'numeric_precision' => 10,

'numeric_scale' => 2,

'is_generated' => 'ALWAYS',

'generation_expression' => '(qty * price)',

])];

$result = $this->invoke('assembleColumns', [$rows, [], []]);

$this->assertSame(

'"total" numeric(10,2) GENERATED ALWAYS AS ((qty * price)) STORED',

$result['t']['total']

);

}

public function testAssembleColumnsSuppressesNotNullEnforcedByDomain(): void

{

// The domain already carries NOT NULL, so repeating it inline would

// make the source and target DDL disagree spuriously.

$rows = [self::colRow('t', 'code', [

'data_type' => 'text',

'domain_name' => 'nonempty_text',

'is_nullable' => 'NO',

])];

$result = $this->invoke('assembleColumns', [$rows, ['nonempty_text' => true], []]);

$this->assertSame('"code" nonempty_text', $result['t']['code']);

}

public function testAssembleColumnsKeepsNotNullWhenDomainIsNullable(): void

{

$rows = [self::colRow('t', 'code', [

'data_type' => 'text',

'domain_name' => 'loose_text',

'is_nullable' => 'NO',

])];

$result = $this->invoke('assembleColumns', [$rows, ['loose_text' => false], []]);

$this->assertSame('"code" loose_text NOT NULL', $result['t']['code']);

}

public function testAssembleColumnsSuppressesNotNullCarriedByNamedConstraint(): void

{

// PG18+ named NOT NULL constraints are emitted as constraints instead,

// so the inline NOT NULL must be dropped to avoid a duplicate.

$rows = [self::colRow('t', 'email', ['data_type' => 'text', 'is_nullable' => 'NO'])];

$nnCols = ['t' => ['email' => true]];

$result = $this->invoke('assembleColumns', [$rows, [], $nnCols]);

$this->assertSame('"email" text', $result['t']['email']);

}

public function testAssembleColumnsNamedNotNullSuppressionIsPerTable(): void

{

// A named NOT NULL on users.email must not suppress orders.email.

$rows = [

self::colRow('users', 'email', ['data_type' => 'text', 'is_nullable' => 'NO']),

self::colRow('orders', 'email', ['data_type' => 'text', 'is_nullable' => 'NO']),

];

$result = $this->invoke('assembleColumns', [$rows, [], ['users' => ['email' => true]]]);

$this->assertSame('"email" text', $result['users']['email']);

$this->assertSame('"email" text NOT NULL', $result['orders']['email']);

}

public function testAssembleColumnsWithNoRows(): void

{

$this->assertSame([], $this->invoke('assembleColumns', [[], [], []]));

}

// ── assembleIndexes ───────────────────────────────────────────────────

public function testAssembleIndexesSplitsRowsAcrossTables(): void

{

$rows = [

['table_name' => 'users', 'indexname' => 'users_email_idx', 'indexdef' => 'CREATE INDEX users_email_idx ON users (email)'],

['table_name' => 'orders', 'indexname' => 'orders_user_idx', 'indexdef' => 'CREATE INDEX orders_user_idx ON orders (user_id)'],

];

$result = $this->invoke('assembleIndexes', [$rows, []]);

$this->assertSame(['users_email_idx'], array_keys($result['users']));

$this->assertSame(['orders_user_idx'], array_keys($result['orders']));

}

public function testAssembleIndexesSkipsConstraintBackedIndexes(): void

{

// PK/UNIQUE/EXCLUDE indexes are rendered as constraints instead.

$rows = [

['table_name' => 'users', 'indexname' => 'users_pkey', 'indexdef' => 'CREATE UNIQUE INDEX users_pkey ON users (id)'],

['table_name' => 'users', 'indexname' => 'users_email_idx', 'indexdef' => 'CREATE INDEX users_email_idx ON users (email)'],

];

$result = $this->invoke('assembleIndexes', [$rows, ['users' => ['users_pkey' => true]]]);

$this->assertSame(['users_email_idx'], array_keys($result['users']));

}

public function testAssembleIndexesSkipListIsScopedPerTable(): void

{

// Index names are only unique per schema in practice, but the skip list

// is keyed by table: a constraint index on one table must never hide a

// same-named plain index on another.

$rows = [

['table_name' => 'users', 'indexname' => 'shared_name', 'indexdef' => 'CREATE UNIQUE INDEX shared_name ON users (id)'],

['table_name' => 'orders', 'indexname' => 'shared_name', 'indexdef' => 'CREATE INDEX shared_name ON orders (ref)'],

];

$result = $this->invoke('assembleIndexes', [$rows, ['users' => ['shared_name' => true]]]);

$this->assertSame([], $result['users']);

$this->assertSame(

['shared_name' => 'CREATE INDEX shared_name ON orders (ref)'],

$result['orders']

);

}

public function testAssembleIndexesKeepsTableWithOnlySkippedIndexes(): void

{

$rows = [

['table_name' => 'users', 'indexname' => 'users_pkey', 'indexdef' => 'CREATE UNIQUE INDEX users_pkey ON users (id)'],

];

$result = $this->invoke('assembleIndexes', [$rows, ['users' => ['users_pkey' => true]]]);

$this->assertSame(['users' => []], $result);

}

// ── assembleConstraints ───────────────────────────────────────────────

public function testAssembleConstraintsSplitsRowsAcrossTables(): void

{

$rows = [

self::conRow('users', 'users_email_key', ['column_name' => 'email']),

self::conRow('orders', 'orders_ref_key', ['column_name' => 'ref']),

];

$result = $this->invoke('assembleConstraints', [$rows, [], []]);

$this->assertSame(['users_email_key'], array_keys($result['users']));

$this->assertSame(['orders_ref_key'], array_keys($result['orders']));

}

public function testAssembleConstraintsKeepsSameConstraintNameSeparatePerTable(): void

{

// Postgres scopes constraint names per table, not per schema, so two

// tables may legitimately share one. Batching must not merge them.

$rows = [

self::conRow('users', 'uniq_code', ['column_name' => 'code']),

self::conRow('orders', 'uniq_code', ['column_name' => 'ref']),

];

$result = $this->invoke('assembleConstraints', [$rows, [], []]);

$this->assertSame('CONSTRAINT "uniq_code" UNIQUE ("code")', $result['users']['uniq_code']);

$this->assertSame('CONSTRAINT "uniq_code" UNIQUE ("ref")', $result['orders']['uniq_code']);

}

public function testAssembleConstraintsGroupsMultiColumnConstraint(): void

{

$rows = [

self::conRow('t', 'uniq_ab', ['column_name' => 'a', 'ordinal_position' => 1]),

self::conRow('t', 'uniq_ab', ['column_name' => 'b', 'ordinal_position' => 2]),

];

$result = $this->invoke('assembleConstraints', [$rows, [], []]);

$this->assertSame('CONSTRAINT "uniq_ab" UNIQUE ("a", "b")', $result['t']['uniq_ab']);

}

public function testAssembleConstraintsCollapsesJoinFanOut(): void

{

// A 2-column FK referencing a 2-column key produces 2x2 rows because

// key_column_usage and constraint_column_usage are joined together.

// Each column must still appear exactly once in the emitted DDL.

$base = [

'constraint_type' => 'FOREIGN KEY',

'foreign_table' => 'parent',

'update_rule' => 'NO ACTION',

'delete_rule' => 'CASCADE',

];

$rows = [

self::conRow('child', 'fk_ab', $base + ['column_name' => 'a', 'ordinal_position' => 1, 'foreign_column' => 'x']),

self::conRow('child', 'fk_ab', $base + ['column_name' => 'a', 'ordinal_position' => 1, 'foreign_column' => 'y']),

self::conRow('child', 'fk_ab', $base + ['column_name' => 'b', 'ordinal_position' => 2, 'foreign_column' => 'x']),

self::conRow('child', 'fk_ab', $base + ['column_name' => 'b', 'ordinal_position' => 2, 'foreign_column' => 'y']),

];

$result = $this->invoke('assembleConstraints', [$rows, [], []]);

$this->assertStringContainsString('FOREIGN KEY ("a", "b")', $result['child']['fk_ab']);

}

public function testAssembleConstraintsAppendsCheckConstraints(): void

{

$checks = [

['table_name' => 't', 'constraint_name' => 'chk_pos', 'definition' => 'CHECK ((qty > 0))'],

];

$result = $this->invoke('assembleConstraints', [[], $checks, []]);

$this->assertSame('CONSTRAINT "chk_pos" CHECK ((qty > 0))', $result['t']['chk_pos']);

}

public function testAssembleConstraintsAppendsNamedNotNull(): void

{

$nn = [self::notNullRow('t', 'email_required', 'email')];

$result = $this->invoke('assembleConstraints', [[], [], $nn]);

$this->assertSame('CONSTRAINT "email_required" NOT NULL "email"', $result['t']['email_required']);

}

public function testAssembleConstraintsMarksUnvalidatedNamedNotNull(): void

{

$nn = [self::notNullRow('t', 'email_required', 'email', false)];

$result = $this->invoke('assembleConstraints', [[], [], $nn]);

$this->assertSame('CONSTRAINT "email_required" NOT NULL "email" NOT VALID', $result['t']['email_required']);

}

public function testAssembleConstraintsKeepsNamedNotNullScopedPerTable(): void

{

$nn = [

self::notNullRow('users', 'nn_shared', 'email'),

self::notNullRow('orders', 'nn_shared', 'ref'),

];

$result = $this->invoke('assembleConstraints', [[], [], $nn]);

$this->assertSame('CONSTRAINT "nn_shared" NOT NULL "email"', $result['users']['nn_shared']);

$this->assertSame('CONSTRAINT "nn_shared" NOT NULL "ref"', $result['orders']['nn_shared']);

}

public function testAssembleConstraintsCombinesAllThreeSources(): void

{

$rows = [self::conRow('t', 'uniq_a', ['column_name' => 'a'])];

$checks = [['table_name' => 't', 'constraint_name' => 'chk_a', 'definition' => 'CHECK ((a > 0))']];

$nn = [self::notNullRow('t', 'nn_a', 'a')];

$result = $this->invoke('assembleConstraints', [$rows, $checks, $nn]);

$this->assertSame(['uniq_a', 'chk_a', 'nn_a'], array_keys($result['t']));

}

public function testAssembleConstraintsDropsUnrenderableTypes(): void

{

// constraintDefinition returns null for types it does not render; a null

// must never reach the diff map, where it would be compared as a value.

$rows = [self::conRow('t', 'weird', ['constraint_type' => 'SOMETHING ELSE', 'column_name' => 'a'])];

$result = $this->invoke('assembleConstraints', [$rows, [], []]);

$this->assertArrayNotHasKey('weird', $result['t'] ?? []);

}

// ── PostgresSchemaHelper::constraintDefinition ────────────────────────

public function testBuildConstraintDefForeignKey(): void

{

$c = self::conRow('t', 'fk', [

'constraint_type' => 'FOREIGN KEY',

'foreign_table' => 'parent',

'foreign_column' => 'id',

'update_rule' => 'NO ACTION',

'delete_rule' => 'CASCADE',

]);

$c['columns'] = ['parent_id'];

$this->assertSame(

'CONSTRAINT "fk" FOREIGN KEY ("parent_id") REFERENCES "parent" ("id")'

. ' ON UPDATE NO ACTION ON DELETE CASCADE',

PostgresSchemaHelper::constraintDefinition('fk', $c)

);

}

public function testAForeignKeyOutsidePublicIsQualifiedAndKeepsEveryColumn(): void

{

// A key onto auth.users rendered as REFERENCES "users", and a

// two-column key as REFERENCES "p" ("a"): neither could be applied.

$c = self::conRow('t', 'fk', [

'constraint_type' => 'FOREIGN KEY',

'foreign_table' => 'users',

'foreign_schema' => 'auth',

'foreign_columns' => '["id", "tenant"]',

'update_rule' => 'NO ACTION',

'delete_rule' => 'CASCADE',

]);

$c['columns'] = ['user_id', 'tenant_id'];

$this->assertSame(

'CONSTRAINT "fk" FOREIGN KEY ("user_id", "tenant_id") REFERENCES "auth"."users" ("id", "tenant")'

. ' ON UPDATE NO ACTION ON DELETE CASCADE',

PostgresSchemaHelper::constraintDefinition('fk', $c)

);

}

/** @dataProvider matchOptionProvider */

public function testBuildConstraintDefMatchOptions(?string $option, string $expected): void

{

$c = self::conRow('t', 'fk', [

'constraint_type' => 'FOREIGN KEY',

'foreign_table' => 'parent',

'foreign_column' => 'id',

'update_rule' => 'NO ACTION',

'delete_rule' => 'NO ACTION',

'match_option' => $option,

]);

$c['columns'] = ['parent_id'];

$def = PostgresSchemaHelper::constraintDefinition('fk', $c);

$this->assertStringContainsString($expected, $def);

}

public static function matchOptionProvider(): array

{

return [

'MATCH FULL' => ['FULL', '("id") MATCH FULL ON UPDATE'],

'MATCH PARTIAL' => ['PARTIAL', '("id") MATCH PARTIAL ON UPDATE'],

'NONE emits nothing' => ['NONE', '("id") ON UPDATE'],

'SIMPLE emits nothing'=> ['SIMPLE', '("id") ON UPDATE'],

];

}

public function testBuildConstraintDefDeferrable(): void

{

$c = self::conRow('t', 'uq', ['is_deferrable' => 'YES', 'initially_deferred' => 'YES']);

$c['columns'] = ['a'];

$this->assertSame(

'CONSTRAINT "uq" UNIQUE ("a") DEFERRABLE INITIALLY DEFERRED',

PostgresSchemaHelper::constraintDefinition('uq', $c)

);

}

public function testBuildConstraintDefDeferrableInitiallyImmediate(): void

{

$c = self::conRow('t', 'uq', ['is_deferrable' => 'YES', 'initially_deferred' => 'NO']);

$c['columns'] = ['a'];

$this->assertSame(

'CONSTRAINT "uq" UNIQUE ("a") DEFERRABLE INITIALLY IMMEDIATE',

PostgresSchemaHelper::constraintDefinition('uq', $c)

);

}

public function testBuildConstraintDefNotValidForeignKey(): void

{

$c = self::conRow('t', 'fk', [

'constraint_type' => 'FOREIGN KEY',

'foreign_table' => 'parent',

'foreign_column' => 'id',

'update_rule' => 'NO ACTION',

'delete_rule' => 'NO ACTION',

'convalidated' => false,

]);

$c['columns'] = ['parent_id'];

$this->assertStringEndsWith(' NOT VALID', PostgresSchemaHelper::constraintDefinition('fk', $c));

}

public function testBuildConstraintDefPrimaryKey(): void

{

$c = self::conRow('t', 'pk', ['constraint_type' => 'PRIMARY KEY']);

$c['columns'] = ['a', 'b'];

$this->assertSame(

'CONSTRAINT "pk" PRIMARY KEY ("a", "b")',

PostgresSchemaHelper::constraintDefinition('pk', $c)

);

}

// PostgreSQL 15+: what the built-in renderer dropped, so the copy held a

// key that set every column null, and a unique that treated nulls apart.

public function testAForeignKeySettingSomeColumnsNullNamesThem(): void

{

$c = self::conRow('h', 'fk', [

'constraint_type' => 'FOREIGN KEY',

'foreign_table' => 'p',

'foreign_columns' => '["a", "b"]',

'update_rule' => 'NO ACTION',

'delete_rule' => 'SET NULL',

'delete_set_columns' => '["b"]',

]);

$c['columns'] = ['a', 'b'];

$this->assertStringContainsString(

'ON UPDATE NO ACTION ON DELETE SET NULL ("b")',

PostgresSchemaHelper::constraintDefinition('fk', $c)

);

}

public function testAUniqueTreatingNullsAsEqualSaysSo(): void

{

$c = self::conRow('h', 'u', ['constraint_type' => 'UNIQUE', 'nulls_not_distinct' => true]);

$c['columns'] = ['a', 'b'];

$this->assertSame('CONSTRAINT "u" UNIQUE NULLS NOT DISTINCT ("a", "b")', PostgresSchemaHelper::constraintDefinition('u', $c));

$c['nulls_not_distinct'] = false;

$this->assertSame('CONSTRAINT "u" UNIQUE ("a", "b")', PostgresSchemaHelper::constraintDefinition('u', $c));

}

public function testBuildConstraintDefReturnsNullForUnknownType(): void

{

$c = self::conRow('t', 'x', ['constraint_type' => 'CHECK']);

$c['columns'] = ['a'];

$this->assertNull(PostgresSchemaHelper::constraintDefinition('x', $c));

}

// ── buildColumnType ───────────────────────────────────────────────────

/**

public function testBuildColumnType(array $col, string $expected): void

{

$row = self::colRow('t', 'c', $col);

$this->assertSame($expected, PostgresColumnType::render($row));

}

public static function columnTypeProvider(): array

{

return [

'domain wins over data_type' => [

['data_type' => 'text', 'domain_name' => 'email_address'], 'email_address',

],

'time without time zone' => [['data_type' => 'time without time zone'], 'time'],

'time with time zone' => [['data_type' => 'time with time zone'], 'timetz'],

'double precision' => [['data_type' => 'double precision'], 'double precision'],

'array uses udt_name' => [['data_type' => 'ARRAY', 'udt_name' => '_int4'], '_int4'],

'varchar with length' => [

['data_type' => 'character varying', 'character_maximum_length' => 255], 'varchar(255)',

],

// The length was dropped: bit(8) became bit(1), bit varying(64) unbounded.

'bit with length' => [['data_type' => 'bit', 'character_maximum_length' => 8], 'bit(8)'],

'bit varying with length' => [

['data_type' => 'bit varying', 'character_maximum_length' => 64], 'bit varying(64)',

],

'bit varying unbounded' => [['data_type' => 'bit varying', 'character_maximum_length' => null], 'bit varying'],

'varchar without length' => [

['data_type' => 'character varying', 'character_maximum_length' => null], 'varchar',

],

'char with length' => [

['data_type' => 'character', 'character_maximum_length' => 10], 'char(10)',

],

'numeric with precision' => [

['data_type' => 'numeric', 'numeric_precision' => 10, 'numeric_scale' => 2], 'numeric(10,2)',

],

'numeric without precision' => [

['data_type' => 'numeric', 'numeric_precision' => null], 'numeric',

],

// The precision comes from atttypmod, not from

// information_schema.datetime_precision, which reports the default

// rather than the absence of a modifier: a bare timestamptz and a

// timestamptz(6) are both 6 there, so a precision nobody declared was

// emitted and the column did not reproduce (issue #215). -1 is the

// catalog's way of saying no modifier was given.

'timestamptz no precision' => [

['data_type' => 'timestamp with time zone', 'atttypmod' => -1], 'timestamptz',

],

'timestamptz with precision' => [

['data_type' => 'timestamp with time zone', 'atttypmod' => 3], 'timestamptz(3)',

],

'timestamptz ignores datetime_precision' => [

// What the reported bug looked like at this level: the lossy

// column says 6, the catalog says no modifier was given.

[

'data_type' => 'timestamp with time zone',

'datetime_precision' => 6,

'atttypmod' => -1,

],

'timestamptz',

],

'timestamp no precision' => [

['data_type' => 'timestamp without time zone', 'atttypmod' => -1], 'timestamp',

],

'timestamp with precision' => [

['data_type' => 'timestamp without time zone', 'atttypmod' => 6], 'timestamp(6)',

],

'timestamp keeps a precision of zero' => [

// The old test was `datetime_precision > 0`, which discarded it.

['data_type' => 'timestamp without time zone', 'atttypmod' => 0], 'timestamp(0)',

],

'time with precision' => [

// Previously returned from the alias map before any precision was

// considered, so a declared one was lost.

['data_type' => 'time without time zone', 'atttypmod' => 3], 'time(3)',

],

'timetz with precision' => [

['data_type' => 'time with time zone', 'atttypmod' => 2], 'timetz(2)',

],

'interval uses the server rendering' => [

// interval's modifier carries a field range as well as a

// precision, which no single number can express.

[

'data_type' => 'interval',

'formatted_type' => 'interval day to second(3)',

'atttypmod' => 2147418115,

],

'interval day to second(3)',

],

'interval without a modifier' => [

['data_type' => 'interval', 'formatted_type' => 'interval', 'atttypmod' => -1], 'interval',

],

'passthrough integer' => [['data_type' => 'integer'], 'integer'],

'passthrough jsonb' => [['data_type' => 'jsonb'], 'jsonb'],

];

}

// ── getBulkTableSchema guard ──────────────────────────────────────────

public function testGetBulkTableSchemaShortCircuitsOnEmptyList(): void

{

// Must return before touching the connection — an IN () clause built

// from an empty list would be a syntax error on every driver.

$connection = $this->createMock(\Illuminate\Database\Connection::class);

$connection->expects($this->never())->method('select');

$this->assertSame([], $this->adapter->getBulkTableSchema($connection, []));

}