FilesExpand file tree

master

/

PostgresColumnDefinitionTest.php

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

113 lines (96 loc) · 4.84 KB

master

/

PostgresColumnDefinitionTest.php

Copy path

Top

File metadata and controls

• Code
• Blame

113 lines (96 loc) · 4.84 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

<?php

namespace Tests\Unit;

use DBDiff\DB\Support\PostgresColumnDefinition as Column;

use PHPUnit\Framework\TestCase;

/**

* One parser for a rendered PostgreSQL column definition. Before it, each

* caller had its own regular expressions; a compression clause read as part

* of the type, so a type change on a compressed column emitted invalid SQL.

*/

class PostgresColumnDefinitionTest extends TestCase

{

public function testAPlainColumn(): void

{

$c = Column::parse('"amount" numeric(10,2) NOT NULL DEFAULT 0.00');

$this->assertSame(['amount', 'numeric(10,2)', true, '0.00'], [$c->name, $c->type, $c->notNull, $c->default]);

$this->assertFalse($c->isGenerated());

$this->assertFalse($c->isIdentity());

}

public function testAMultiWordTypeAndCollation(): void

{

$c = Column::parse('"s" character varying(20)[] COLLATE "C"');

$this->assertSame('character varying(20)[]', $c->type);

$this->assertSame('C', $c->collation);

$this->assertSame('character varying(20)[] COLLATE "C"', $c->typeWithCollation());

}

public function testCompressionIsNotPartOfTheType(): void

{

$c = Column::parse('"b" text NOT NULL COMPRESSION lz4');

$this->assertSame('text', $c->type);

$this->assertSame('lz4', $c->compression);

$this->assertTrue($c->notNull);

}

public function testADefaultWithKeywordsAndSpacesInsideIt(): void

{

$c = Column::parse("\"note\" text DEFAULT 'NOT NULL DEFAULT'::text");

$this->assertSame("'NOT NULL DEFAULT'::text", $c->default);

$this->assertFalse($c->notNull, 'the words inside a literal are not a constraint');

$d = Column::parse('"at" timestamp with time zone DEFAULT (now() + \'1 day\'::interval)');

$this->assertSame('timestamp with time zone', $d->type);

$this->assertSame("(now() + '1 day'::interval)", $d->default);

}

public function testNotNullAfterTheDefault(): void

{

$c = Column::parse("\"status\" character varying(20) DEFAULT 'active'::character varying NOT NULL");

$this->assertSame("'active'::character varying", $c->default);

$this->assertTrue($c->notNull);

}

public function testAnIdentityWithOptions(): void

{

$c = Column::parse('"id" bigint NOT NULL GENERATED BY DEFAULT AS IDENTITY (INCREMENT BY 10 START WITH 5)');

$this->assertSame('bigint', $c->type);

$this->assertSame('BY DEFAULT', $c->identity);

$this->assertSame('INCREMENT BY 10 START WITH 5', $c->identityOptions);

$a = Column::parse('"id" integer NOT NULL GENERATED ALWAYS AS IDENTITY');

$this->assertSame(['ALWAYS', null], [$a->identity, $a->identityOptions]);

}

public function testAStoredGeneratedColumn(): void

{

$c = Column::parse('"g" numeric GENERATED ALWAYS AS ((a * (2)::numeric)) STORED');

$this->assertSame('numeric', $c->type);

$this->assertSame('(a * (2)::numeric)', $c->generated);

$this->assertTrue($c->isGenerated());

$n = Column::parse('"g" numeric GENERATED ALWAYS AS ((a * 2)) STORED NOT NULL');

$this->assertTrue($n->notNull);

}

public function testAQuotedNameWithAnEscapedQuote(): void

{

$this->assertSame('a"b', Column::parse('"a""b" int')->name);

}

public function testASerialColumnIsItsIntegerTypeAndNotNull(): void

{

$c = Column::parse('"id" bigserial');

$this->assertSame([true, 'bigint', true, null], [$c->serial, $c->type, $c->notNull, $c->default]);

$this->assertFalse(Column::parse('"id" bigint NOT NULL')->serial);

}

public function testWhenTheSerialSequenceIsNeeded(): void

{

$this->assertTrue(Column::needsSerialSequence('"id" serial', '"id" integer GENERATED BY DEFAULT AS IDENTITY'));

$this->assertTrue(Column::needsSerialSequence('"id" integer NOT NULL', '"id" serial'));

$this->assertTrue(Column::needsSerialSequence('"id" serial', '"id" bigserial'));

$this->assertFalse(Column::needsSerialSequence('"id" serial', '"id" serial'));

$this->assertFalse(Column::needsSerialSequence('"id" integer', '"id" bigint'));

}

public function testRegeneratingIsNeededOnlyTowardsAGeneratedColumn(): void

{

$plain = '"b" integer';

$gen2 = '"b" integer GENERATED ALWAYS AS ((a * 2)) STORED';

$gen3 = '"b" integer GENERATED ALWAYS AS ((a * 3)) STORED';

$this->assertTrue(Column::needsRegenerating($plain, $gen2));

$this->assertTrue(Column::needsRegenerating($gen2, $gen3));

$this->assertTrue(Column::needsRegenerating($gen2, '"b" bigint GENERATED ALWAYS AS ((a * 2)) STORED'));

// Generated to plain is DROP EXPRESSION, which keeps the values.

$this->assertFalse(Column::needsRegenerating($gen2, $plain));

$this->assertFalse(Column::needsRegenerating($gen2, $gen2 . ' NOT NULL'));

}

}