mirror/dolt
1
0
Fork 0
mirror of https://github.com/dolthub/dolt.git synced 2026-02-09 03:09:12 -06:00
Code Issues Packages Projects Releases 127 Wiki Activity
Files
f61fe10523e2aec79acaa44586e9d9affe4b3d54
dolt/integration-tests/bats/keyless.bats
James Cor e55442df4d bats test fix
2023-03-09 17:17:48 -08:00

1335 lines
39 KiB
Bash
Raw Blame History

#!/usr/bin/env bats
load $BATS_TEST_DIRNAME/helper/common.bash
setup() {
setup_common
dolt sql <<SQL
CREATE TABLE keyless (
c0 int,
c1 int
);
INSERT INTO keyless VALUES (0,0),(2,2),(1,1),(1,1);
SQL
dolt add .
dolt commit -am "init"
}
teardown() {
assert_feature_version
teardown_common
}
@test "keyless: feature indexes and foreign keys" {
run dolt sql -q "ALTER TABLE keyless ADD INDEX (c1);"
[ $status -eq 0 ]
[[ ! "$output" =~ "panic" ]] || false
run dolt sql -q "CREATE TABLE fine (a int, b int, INDEX (b));"
[ $status -eq 0 ]
[[ ! "$output" =~ "panic" ]] || false
run dolt sql -q "CREATE TABLE worse (a int, b int, FOREIGN KEY (b) REFERENCES keyless(c1));"
[ $status -eq 0 ]
[[ ! "$output" =~ "panic" ]] || false
}
@test "keyless: create keyless table" {
# created in setup()
run dolt ls
[ $status -eq 0 ]
[[ "$output" =~ "keyless" ]] || false
dolt sql -q "SHOW CREATE TABLE keyless;"
run dolt sql -q "SHOW CREATE TABLE keyless;"
[ $status -eq 0 ]
[[ "$output" =~ "CREATE TABLE \`keyless\` (" ]] || false
[[ "$output" =~ "\`c0\` int," ]] || false
[[ "$output" =~ "\`c1\` int" ]] || false
[[ "$output" =~ ")" ]] || false
dolt sql -q "SELECT sum(c0),sum(c1) FROM keyless;" -r csv
run dolt sql -q "SELECT sum(c0),sum(c1) FROM keyless;" -r csv
[ $status -eq 0 ]
[[ "${lines[1]}" =~ "4,4" ]] || false
}
@test "keyless: delete from keyless" {
run dolt sql -q "DELETE FROM keyless WHERE c0 = 2;"
[ $status -eq 0 ]
run dolt sql -q "SELECT * FROM keyless ORDER BY c0;" -r csv
[ $status -eq 0 ]
[[ "${lines[1]}" = "0,0" ]] || false
[[ "${lines[2]}" = "1,1" ]] || false
[[ "${lines[3]}" = "1,1" ]] || false
}
@test "keyless: update keyless" {
run dolt sql -q "UPDATE keyless SET c0 = 9 WHERE c0 = 2;"
[ $status -eq 0 ]
run dolt sql -q "SELECT * FROM keyless ORDER BY c0;" -r csv
[ $status -eq 0 ]
[[ "${lines[1]}" = "0,0" ]] || false
[[ "${lines[2]}" = "1,1" ]] || false
[[ "${lines[3]}" = "1,1" ]] || false
[[ "${lines[4]}" = "9,2" ]] || false
}
@test "keyless: column add/drop" {
skip "unimplemented"
run dolt sql <<SQL
ALTER TABLE keyless ADD COLUMN c2 int;
ALTER TABLE keyless DROP COLUMN c0;
SQL
[ $status -eq 0 ]
dolt sql -q "SELECT * FROM keyless ORDER BY c1;" -r csv
run dolt sql -q "SELECT * FROM keyless ORDER BY c1;" -r csv
[ $status -eq 0 ]
[[ "${lines[0]}" = "c1,c2" ]] || false
[[ "${lines[1]}" = "0," ]] || false
[[ "${lines[2]}" = "1," ]] || false
[[ "${lines[3]}" = "1," ]] || false
[[ "${lines[4]}" = "2," ]] || false
}
# keyless tables allow duplicate rows
@test "keyless: table import" {
cat <<CSV > data.csv
c0,c1
0,0
2,2
1,1
1,1
,9
CSV
dolt table import -c imported data.csv
run dolt sql -q "SELECT count(*) FROM imported;" -r csv
[ $status -eq 0 ]
[[ "${lines[1]}" = "5" ]] || false
run dolt sql -q "SELECT c0,c1 FROM imported ORDER BY c1;" -r csv
[ $status -eq 0 ]
[[ "${lines[1]}" = "0,0" ]] || false
[[ "${lines[2]}" = "1,1" ]] || false
[[ "${lines[3]}" = "1,1" ]] || false
[[ "${lines[4]}" = "2,2" ]] || false
[[ "${lines[5]}" = ",9" ]] || false
# tests for NULL hashing in keyless tables
dolt sql -q "UPDATE imported SET c1 = c1 + 10"
run dolt sql -q "SELECT c0,c1 FROM imported ORDER BY c1;" -r csv
[ $status -eq 0 ]
[[ "${lines[1]}" = "0,10" ]] || false
[[ "${lines[2]}" = "1,11" ]] || false
[[ "${lines[3]}" = "1,11" ]] || false
[[ "${lines[4]}" = "2,12" ]] || false
[[ "${lines[5]}" = ",19" ]] || false
}
# updates are always appends
@test "keyless: table update" {
cat <<CSV > data.csv
c0,c1
0,0
2,2
1,1
1,1
CSV
dolt table import -u keyless data.csv
dolt sql -q "SELECT * FROM keyless ORDER BY c0;" -r csv
run dolt sql -q "SELECT count(*) FROM keyless;" -r csv
[ $status -eq 0 ]
[[ "${lines[1]}" = "8" ]] || false
dolt sql -q "SELECT * FROM keyless ORDER BY c0;" -r csv
run dolt sql -q "SELECT * FROM keyless ORDER BY c0;" -r csv
[ $status -eq 0 ]
[[ "${lines[1]}" = "0,0" ]] || false
[[ "${lines[2]}" = "0,0" ]] || false
[[ "${lines[3]}" = "1,1" ]] || false
[[ "${lines[4]}" = "1,1" ]] || false
[[ "${lines[5]}" = "1,1" ]] || false
[[ "${lines[6]}" = "1,1" ]] || false
[[ "${lines[7]}" = "2,2" ]] || false
[[ "${lines[8]}" = "2,2" ]] || false
}
@test "keyless: table export CSV" {
dolt table export keyless
run dolt table export keyless
[ $status -eq 0 ]
[[ "${lines[0]}" = "c0,c1" ]] || false
[[ "$output" =~ "1,1" ]] || false
[[ "$output" =~ "1,1" ]] || false
[[ "$output" =~ "0,0" ]] || false
[[ "$output" =~ "2,2" ]] || false
[[ "$output" =~ "Successfully exported data." ]] || false
[[ "${#lines[@]}" = "6" ]] || false
}
@test "keyless: table export SQL" {
dolt table export keyless export.sql
cat export.sql
run cat export.sql
[[ "${lines[0]}" = "DROP TABLE IF EXISTS \`keyless\`;" ]] || false
[[ "${lines[1]}" = "CREATE TABLE \`keyless\` (" ]] || false
[[ "${lines[2]}" = " \`c0\` int," ]] || false
[[ "${lines[3]}" = " \`c1\` int" ]] || false
[[ "${lines[4]}" = ") ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_bin;" ]] || false
[[ "$output" =~ "INSERT INTO \`keyless\` (\`c0\`,\`c1\`) VALUES (1,1);" ]] || false
[[ "$output" =~ "INSERT INTO \`keyless\` (\`c0\`,\`c1\`) VALUES (1,1);" ]] || false
[[ "$output" =~ "INSERT INTO \`keyless\` (\`c0\`,\`c1\`) VALUES (0,0);" ]] || false
[[ "$output" =~ "INSERT INTO \`keyless\` (\`c0\`,\`c1\`) VALUES (2,2);" ]] || false
[[ "${#lines[@]}" = "9" ]] || false
}
@test "keyless: diff against working set" {
dolt sql <<SQL
DELETE FROM keyless WHERE c0 = 0;
INSERT INTO keyless VALUES (8,8);
UPDATE keyless SET c1 = 9 WHERE c0 = 1;
SQL
run dolt diff
[ $status -eq 0 ]
# output order differs between formats
[[ "$output" =~ "| + | 8 | 8 |" ]] || false
[[ "$output" =~ "| - | 1 | 1 |" ]] || false
[[ "$output" =~ "| - | 1 | 1 |" ]] || false
[[ "$output" =~ "| + | 1 | 9 |" ]] || false
[[ "$output" =~ "| + | 1 | 9 |" ]] || false
[[ "$output" =~ "| - | 0 | 0 |" ]] || false
[[ "${#lines[@]}" = "13" ]] || false
}
@test "keyless: diff --stat" {
dolt sql <<SQL
DELETE FROM keyless WHERE c0 = 0;
INSERT INTO keyless VALUES (8,8);
UPDATE keyless SET c1 = 9 WHERE c0 = 1;
SQL
run dolt diff --stat
[ $status -eq 0 ]
[[ "$output" =~ "3 Rows Added" ]] || false
[[ "$output" =~ "3 Rows Deleted" ]] || false
}
@test "keyless: dolt_diff_ table" {
dolt sql <<SQL
DELETE FROM keyless WHERE c0 = 0;
INSERT INTO keyless VALUES (8,8);
UPDATE keyless SET c1 = 9 WHERE c0 = 1;
SQL
run dolt sql -q "
SELECT to_c0, to_c1, from_c0, from_c1
FROM dolt_diff_keyless
ORDER BY to_commit_date, to_c0 DESC, to_c1 DESC" -r csv
[ $status -eq 0 ]
[ "${#lines[@]}" -eq 11 ]
[[ "${lines[0]}" = "to_c0,to_c1,from_c0,from_c1" ]] || false
[[ "${lines[1]}" = "8,8,," ]] || false
[[ "${lines[2]}" = "1,9,," ]] || false
[[ "${lines[3]}" = "1,9,," ]] || false
[[ "${lines[4]}" = ",,1,1" ]] || false
[[ "${lines[5]}" = ",,1,1" ]] || false
[[ "${lines[6]}" = ",,0,0" ]] || false
[[ "${lines[7]}" = "2,2,," ]] || false
[[ "${lines[9]}" = "1,1,," ]] || false
[[ "${lines[9]}" = "1,1,," ]] || false
[[ "${lines[10]}" = "0,0,," ]] || false
}
@test "keyless: diff column add/drop" {
skip "unimplemented"
run dolt sql <<SQL
ALTER TABLE keyless ADD COLUMN c2 int;
ALTER TABLE keyless DROP COLUMN c0;
SQL
[ $status -eq 0 ]
dolt diff
run dolt diff
[ $status -eq 0 ]
[[ "${lines[3]}" =~ "CREATE TABLE keyless (" ]] || false
[[ "${lines[4]}" =~ "- \`c0\` INT" ]] || false
[[ "${lines[5]}" =~ " \`c1\` INT" ]] || false
[[ "${lines[6]}" =~ "+ \`c2\` INT" ]] || false
[[ "${lines[7]}" =~ " PRIMARY KEY ()" ]] || false
[[ "${lines[8]}" =~ ");" ]] || false
[[ "${lines[10]}" =~ "| < | c1 | | c0 |" ]] || false
[[ "${lines[11]}" =~ "| > | c1 | c2 | |" ]] || false
}
@test "keyless: merge fast-forward" {
dolt checkout -b other
dolt sql -q "INSERT INTO keyless VALUES (9,9);"
dolt commit -am "9,9"
dolt checkout main
run dolt merge other
[ $status -eq 0 ]
run dolt sql -q "SELECT * FROM keyless WHERE c0 > 6;" -r csv
[ $status -eq 0 ]
[[ "${lines[1]}" = "9,9" ]] || false
}
@test "keyless: diff branches with identical mutation history" {
dolt branch other
dolt sql -q "INSERT INTO keyless VALUES (7,7),(8,8),(9,9);"
dolt commit -am "inserted on main"
dolt checkout other
dolt sql -q "INSERT INTO keyless VALUES (7,7),(8,8),(9,9);"
dolt commit -am "inserted on other"
dolt diff main
run dolt diff main
[ $status -eq 0 ]
[ "$output" = "" ]
}
@test "keyless: merge branches with identical mutation history" {
dolt branch other
dolt sql -q "INSERT INTO keyless VALUES (7,7),(8,8),(9,9);"
dolt commit -am "inserted on main"
dolt checkout other
dolt sql -q "INSERT INTO keyless VALUES (7,7),(8,8),(9,9);"
dolt commit -am "inserted on other"
run dolt merge main
[ $status -eq 0 ]
run dolt sql -q "SELECT * FROM keyless WHERE c0 > 6 ORDER BY c0;" -r csv
[ $status -eq 0 ]
[[ "${lines[1]}" = "7,7" ]] || false
[[ "${lines[2]}" = "8,8" ]] || false
[[ "${lines[3]}" = "9,9" ]] || false
}
@test "keyless: diff deletes from two branches" {
dolt branch left
dolt checkout -b right
dolt sql -q "DELETE FROM keyless WHERE c0 = 0;"
dolt commit -am "deleted ones on right"
run dolt diff main
[ $status -eq 0 ]
[[ "$output" =~ "| - | 0 | 0 |" ]] || false
dolt checkout left
dolt sql -q "DELETE FROM keyless WHERE c0 = 2;"
dolt commit -am "deleted twos on left"
run dolt diff main
[ $status -eq 0 ]
[[ "$output" =~ "| - | 2 | 2 |" ]] || false
}
@test "keyless: merge deletes from two branches" {
dolt branch left
dolt checkout -b right
dolt sql -q "DELETE FROM keyless WHERE c0 = 0;"
dolt commit -am "deleted ones on right"
dolt checkout left
dolt sql -q "DELETE FROM keyless WHERE c0 = 2;"
dolt commit -am "deleted twos on left"
run dolt merge right -m "merge"
[ $status -eq 0 ]
run dolt diff main
[ $status -eq 0 ]
[[ "$output" =~ "| - | 0 | 0 |" ]] || false
[[ "$output" =~ "| - | 2 | 2 |" ]] || false
}
function make_dupe_table() {
dolt sql <<SQL
CREATE TABLE dupe (
c0 int,
c1 int
);
INSERT INTO dupe (c0,c1) VALUES
(1,1),(1,1),(1,1),(1,1),(1,1),
(1,1),(1,1),(1,1),(1,1),(1,1);
SQL
dolt add .
dolt commit -am "created table dupe"
}
@test "keyless: diff duplicate deletes" {
make_dupe_table
dolt branch left
dolt checkout -b right
dolt sql -q "DELETE FROM dupe LIMIT 2;"
dolt commit -am "deleted two rows on right"
dolt diff main
run dolt diff main
[ $status -eq 0 ]
[ "${#lines[@]}" -eq 9 ] # 2 diffs + 6 header + 1 footer
[[ "${lines[6]}" =~ "| - | 1 | 1 |" ]] || false
[[ "${lines[7]}" =~ "| - | 1 | 1 |" ]] || false
dolt checkout left
dolt sql -q "DELETE FROM dupe LIMIT 4;"
dolt commit -am "deleted four rows on left"
run dolt diff main
[ $status -eq 0 ]
[ "${#lines[@]}" -eq 11 ] # 4 diffs + 6 header + 1 footer
[[ "${lines[6]}" = "| - | 1 | 1 |" ]] || false
[[ "${lines[7]}" = "| - | 1 | 1 |" ]] || false
[[ "${lines[8]}" = "| - | 1 | 1 |" ]] || false
[[ "${lines[9]}" = "| - | 1 | 1 |" ]] || false
}
@test "keyless: merge duplicate deletes" {
make_dupe_table
dolt branch left
dolt checkout -b right
dolt sql -q "DELETE FROM dupe LIMIT 2;"
dolt commit -am "deleted two rows on right"
dolt checkout left
dolt sql -q "DELETE FROM dupe LIMIT 4;"
dolt commit -am "deleted four rows on left"
run dolt merge right -m "merge"
[ $status -eq 0 ]
[[ "$output" =~ "CONFLICT" ]] || false
run dolt conflicts resolve --ours dupe
[ $status -eq 0 ]
dolt commit -am "resolved"
run dolt sql -q "select sum(c0), sum(c1) from dupe" -r csv
[ $status -eq 0 ]
[[ "${lines[1]}" = "6,6" ]] || false
}
@test "keyless: merge duplicate deletes with stored procedure" {
make_dupe_table
dolt branch left
dolt checkout -b right
dolt sql -q "DELETE FROM dupe LIMIT 2;"
dolt commit -am "deleted two rows on right"
dolt checkout left
dolt sql -q "DELETE FROM dupe LIMIT 4;"
dolt commit -am "deleted four rows on left"
run dolt merge right -m "merge"
[ $status -eq 0 ]
[[ "$output" =~ "CONFLICT" ]] || false
run dolt sql -q "call dolt_conflicts_resolve('--ours', 'dupe')"
[ $status -eq 0 ]
dolt commit -am "resolved"
run dolt sql -q "select sum(c0), sum(c1) from dupe" -r csv
[ $status -eq 0 ]
[[ "${lines[1]}" = "6,6" ]] || false
}
@test "keyless: diff duplicate updates" {
make_dupe_table
dolt branch left
dolt checkout -b right
dolt sql -q "UPDATE dupe SET c1 = 2 LIMIT 2;"
dolt commit -am "updated two rows on right"
run dolt diff main
[ $status -eq 0 ]
[ "${#lines[@]}" -eq 11 ] # 4 diffs + 6 header + 1 footer
dolt checkout left
dolt sql -q "UPDATE dupe SET c1 = 2 LIMIT 4;"
dolt commit -am "updated four rows on left"
run dolt diff main
[ $status -eq 0 ]
[ "${#lines[@]}" -eq 15 ] # 8 diffs + 6 header + 1 footer
}
@test "keyless: merge duplicate updates" {
make_dupe_table
dolt branch left
dolt checkout -b right
dolt sql -q "UPDATE dupe SET c1 = 2 LIMIT 2;"
dolt commit -am "updated two rows on right"
dolt checkout left
dolt sql -q "UPDATE dupe SET c1 = 2 LIMIT 4;"
dolt commit -am "updated four rows on left"
run dolt merge right -m "merge"
[ $status -eq 0 ]
[[ "$output" =~ "CONFLICT" ]] || false
run dolt conflicts resolve --theirs dupe
[ $status -eq 0 ]
dolt commit -am "resolved"
run dolt sql -q "select sum(c0), sum(c1) from dupe" -r csv
[ $status -eq 0 ]
[[ "${lines[1]}" = "10,12" ]] || false
}
@test "keyless: merge duplicate updates with stored procedure" {
make_dupe_table
dolt branch left
dolt checkout -b right
dolt sql -q "UPDATE dupe SET c1 = 2 LIMIT 2;"
dolt commit -am "updated two rows on right"
dolt checkout left
dolt sql -q "UPDATE dupe SET c1 = 2 LIMIT 4;"
dolt commit -am "updated four rows on left"
run dolt merge right -m "merge"
[ $status -eq 0 ]
[[ "$output" =~ "CONFLICT" ]] || false
run dolt sql -q "call dolt_conflicts_resolve('--theirs', 'dupe')"
[ $status -eq 0 ]
dolt commit -am "resolved"
run dolt sql -q "select sum(c0), sum(c1) from dupe" -r csv
[ $status -eq 0 ]
[[ "${lines[1]}" = "10,12" ]] || false
}
@test "keyless: sql diff" {
skip "unimplemented"
dolt sql <<SQL
DELETE FROM keyless WHERE c0 = 2;
INSERT INTO keyless VALUES (3,3);
SQL
dolt diff -r sql
[ $status -eq 0 ]
[[ "$lines[@]" = "DELETE FROM keyless WHERE c0=2 AND c1=2 LIMIT 1" ]] || false
[[ "$lines[@]" = "INSERT INTO keyless VALUES (3,3)" ]] || false
dolt commit -am "made changes"
dolt sql -q "UPDATE keyless SET c1 = 13 WHERE c1 = 3;"
dolt diff -r sql
[ $status -eq 0 ]
[[ "$lines[@]" = "DELETE FROM keyless WHERE c0=3 AND c1=3" ]] || false
[[ "$lines[@]" = "INSERT INTO keyless VALUES (3,13)" ]] || false
}
@test "keyless: sql diff as a patch" {
skip "unimplemented"
dolt branch left
dolt checkout -b right
dolt sql -q "INSERT INTO keyless VALUES (3,3);"
dolt commit -am "inserted values (3,3)"
dolt diff left -r sql
[ $status -eq 0 ]
[[ "$lines[@]" = "INSERT INTO keyless VALUES (3,3)" ]] || false
dolt diff left -r sql > patch.sql
dolt checkout left
dolt sql < patch.sql
run dolt diff right
[ $status -eq 0 ]
[ "$output" = "" ]
}
@test "keyless: table replace" {
cat <<CSV > data.csv
c0,c1
0,0
2,2
1,1
1,1
CSV
run dolt table import -r keyless data.csv
[ $status -eq 0 ]
dolt diff
run dolt diff
[ $status -eq 0 ]
[ "$output" = "" ]
cat <<CSV > data2.csv
c0,c1
9,9
0,0
1,1
1,1
2,2
CSV
run dolt table import -r keyless data2.csv
[ $status -eq 0 ]
run dolt diff
[ $status -eq 0 ]
[[ "$output" =~ "| + | 9 | 9 |" ]] || false
}
# in-place updates create become drop/add
@test "keyless: diff with in-place updates (working set)" {
dolt sql -q "UPDATE keyless SET c1 = 9 where c0 = 2;"
run dolt diff
[ $status -eq 0 ]
[[ "$output" =~ "| - | 2 | 2 |" ]] || false
[[ "$output" =~ "| + | 2 | 9 |" ]] || false
}
# in-place updates create become drop/add
@test "keyless: sql diff with in-place updates (working set)" {
skip "unimplemented"
dolt sql -q "UPDATE keyless SET c1 = 9 where c0 = 2;"
run dolt diff -r sql
[ $status -eq 0 ]
[[ "$lines[@]" = "DELETE FROM keyless WHERE c0 = 2 AND c1 = 2 LIMIT 1" ]] || false
[[ "$lines[@]" = "INSERT INTO keyless (c0,c1) VALUES (2,9);" ]] || false
}
# update patch always recreates identical branches
@test "keyless: updates as a sql diff patch" {
skip "unimplemented"
dolt branch left
dolt checkout -b right
dolt sql -q "UPDATE keyless SET c1 = 22 WHERE c1 = 9;"
dolt commit -am "updates (2,2) -> (2,9)"
dolt diff left -r sql
[ $status -eq 0 ]
[[ "$lines[@]" = "DELETE FROM keyless WHERE c0 = 2 AND c1 = 2 LIMIT 1" ]] || false
[[ "$lines[@]" = "INSERT INTO keyless (c0,c1) VALUES (2,9);" ]] || false
dolt diff left -r sql > patch.sql
dolt checkout left
dolt sql < patch.sql
run dolt diff right
[ $status -eq 0 ]
[ "$output" = "" ]
}
# in-place updates diff as drop/add
@test "keyless: diff with in-place updates (branches)" {
dolt sql -q "INSERT INTO keyless VALUES (7,7),(8,8),(9,9);"
dolt commit -am "added rows"
dolt branch other
dolt sql -q "UPDATE keyless SET c1 = c1+10 WHERE c0 > 6"
dolt commit -am "updated on main"
dolt checkout other
dolt sql -q "UPDATE keyless SET c1 = c1+20 WHERE c0 > 6"
dolt commit -am "updated on other"
dolt diff main
run dolt diff main
[ $status -eq 0 ]
[[ "$output" =~ "| - | 7 | 17 |" ]] || false
[[ "$output" =~ "| + | 7 | 27 |" ]] || false
[[ "$output" =~ "| - | 9 | 19 |" ]] || false
[[ "$output" =~ "| + | 9 | 29 |" ]] || false
[[ "$output" =~ "| - | 8 | 18 |" ]] || false
[[ "$output" =~ "| + | 8 | 28 |" ]] || false
}
@test "keyless: merge with in-place updates (branches)" {
dolt sql -q "INSERT INTO keyless VALUES (7,7),(8,8),(9,9);"
dolt commit -am "added rows"
dolt branch other
dolt sql -q "UPDATE keyless SET c1 = c1+10 WHERE c0 > 6"
dolt commit -am "updated on main"
dolt checkout other
dolt sql -q "UPDATE keyless SET c1 = c1+20 WHERE c0 > 6"
dolt commit -am "updated on other"
run dolt merge main -m "merge"
[ $status -eq 0 ]
[[ "$output" =~ "CONFLICT" ]] || false
run dolt conflicts resolve --ours keyless
[ $status -eq 0 ]
dolt commit -am "resolved"
skip "incorrect resolve"
# updates become delete+add
# conflict is generated for delete
# the corresponding add does not conflict
# on resolve, we get both sets of adds
run dolt sql -q "select * from keyless where c0 > 6 order by c0" -r csv
[ $status -eq 0 ]
[[ "${lines[1]}" = "7,17" ]] || false
[[ "${lines[1]}" = "8,18" ]] || false
[[ "${lines[1]}" = "9,19" ]] || false
}
@test "keyless: diff branches with reordered mutation history" {
dolt branch other
dolt sql -q "INSERT INTO keyless VALUES (7,7),(8,8),(9,9);"
dolt commit -am "inserted on main"
dolt checkout other
dolt sql -q "INSERT INTO keyless VALUES (9,9),(8,8),(7,7);"
dolt commit -am "inserted on other"
run dolt diff main
[ $status -eq 0 ]
[ "$output" = "" ]
}
@test "keyless: merge branches with reordered mutation history" {
dolt branch other
dolt sql -q "INSERT INTO keyless VALUES (7,7),(8,8),(9,9);"
dolt commit -am "inserted on main"
dolt checkout other
dolt sql -q "INSERT INTO keyless VALUES (9,9),(8,8),(7,7);"
dolt commit -am "inserted on other"
run dolt merge main -m "merge"
[ $status -eq 0 ]
run dolt sql -q "SELECT count(*) FROM keyless WHERE c0 > 6;" -r csv
[ $status -eq 0 ]
[[ "${lines[1]}" = "3" ]] || false
run dolt sql -q "SELECT * FROM keyless WHERE c0 > 6 ORDER BY c0;" -r csv
[ $status -eq 0 ]
[[ "${lines[1]}" = "7,7" ]] || false
[[ "${lines[2]}" = "8,8" ]] || false
[[ "${lines[3]}" = "9,9" ]] || false
}
@test "keyless: diff branches with convergent mutation history" {
dolt branch other
dolt sql -q "INSERT INTO keyless VALUES (7,7),(8,8),(9,9);"
dolt commit -am "inserted on main"
dolt checkout other
dolt sql <<SQL
INSERT INTO keyless VALUES (9,19),(8,8),(7,17);
UPDATE keyless SET c0 = 7, c1 = 7 WHERE c1 = 19;
UPDATE keyless SET c0 = 9, c1 = 9 WHERE c1 = 17;
SQL
dolt commit -am "inserted on other"
dolt diff main
run dolt diff main
[ $status -eq 0 ]
[ "$output" = "" ]
}
@test "keyless: merge branches with convergent mutation history" {
dolt branch other
dolt sql -q "INSERT INTO keyless VALUES (7,7),(8,8),(9,9);"
dolt commit -am "inserted on main"
dolt checkout other
dolt sql <<SQL
INSERT INTO keyless VALUES (9,19),(8,8),(7,17);
UPDATE keyless SET c0 = 7, c1 = 7 WHERE c1 = 19;
UPDATE keyless SET c0 = 9, c1 = 9 WHERE c1 = 17;
SQL
dolt commit -am "inserted on other"
run dolt merge main -m "merge"
[ $status -eq 0 ]
[[ "$output" =~ "CONFLICT" ]] || false
run dolt conflicts resolve --theirs keyless
[ $status -eq 0 ]
dolt commit -am "resolved"
run dolt sql -q "select * from keyless where c0 > 6 order by c0" -r csv
[ $status -eq 0 ]
[[ "${lines[1]}" = "7,7" ]] || false
[[ "${lines[2]}" = "8,8" ]] || false
[[ "${lines[3]}" = "9,9" ]] || false
}
@test "keyless: merge branches with convergent mutation history with stored procedure" {
dolt branch other
dolt sql -q "INSERT INTO keyless VALUES (7,7),(8,8),(9,9);"
dolt commit -am "inserted on main"
dolt checkout other
dolt sql <<SQL
INSERT INTO keyless VALUES (9,19),(8,8),(7,17);
UPDATE keyless SET c0 = 7, c1 = 7 WHERE c1 = 19;
UPDATE keyless SET c0 = 9, c1 = 9 WHERE c1 = 17;
SQL
dolt commit -am "inserted on other"
run dolt merge main -m "merge"
[ $status -eq 0 ]
[[ "$output" =~ "CONFLICT" ]] || false
run dolt sql -q "call dolt_conflicts_resolve('--theirs', 'keyless')"
[ $status -eq 0 ]
dolt commit -am "resolved"
run dolt sql -q "select * from keyless where c0 > 6 order by c0" -r csv
[ $status -eq 0 ]
[[ "${lines[1]}" = "7,7" ]] || false
[[ "${lines[2]}" = "8,8" ]] || false
[[ "${lines[3]}" = "9,9" ]] || false
}
@test "keyless: diff branches with offset mutation history" {
dolt branch other
dolt sql -q "INSERT INTO keyless VALUES (7,7),(8,8),(9,9);"
dolt commit -am "inserted on main"
dolt checkout other
dolt sql -q "INSERT INTO keyless VALUES (7,7),(7,7),(8,8),(9,9);"
dolt commit -am "inserted on other"
run dolt diff main
[ $status -eq 0 ]
[ "${#lines[@]}" -eq 8 ] # 1 diffs + 6 header + 1 footer
[[ "${lines[6]}" =~ "| + | 7 | 7 |" ]] || false
}
@test "keyless: merge branches with offset mutation history" {
dolt branch other
dolt sql -q "INSERT INTO keyless VALUES (7,7),(8,8),(9,9);"
dolt commit -am "inserted on main"
dolt checkout other
dolt sql -q "INSERT INTO keyless VALUES (7,7),(7,7),(8,8),(9,9);"
dolt commit -am "inserted on other"
run dolt merge main -m "merge"
[ $status -eq 0 ]
[[ "$output" =~ "CONFLICT" ]] || false
run dolt conflicts resolve --ours keyless
[ $status -eq 0 ]
dolt commit -am "resolved"
run dolt sql -q "select * from keyless where c0 > 6 order by c0" -r csv
[ $status -eq 0 ]
[[ "${lines[1]}" = "7,7" ]] || false
[[ "${lines[2]}" = "7,7" ]] || false
[[ "${lines[3]}" = "8,8" ]] || false
[[ "${lines[4]}" = "9,9" ]] || false
}
@test "keyless: merge branches with offset mutation history with stored procedure" {
dolt branch other
dolt sql -q "INSERT INTO keyless VALUES (7,7),(8,8),(9,9);"
dolt commit -am "inserted on main"
dolt checkout other
dolt sql -q "INSERT INTO keyless VALUES (7,7),(7,7),(8,8),(9,9);"
dolt commit -am "inserted on other"
run dolt merge main -m "merge"
[ $status -eq 0 ]
[[ "$output" =~ "CONFLICT" ]] || false
run dolt sql -q "call dolt_conflicts_resolve('--ours', 'keyless')"
[ $status -eq 0 ]
dolt commit -am "resolved"
run dolt sql -q "select * from keyless where c0 > 6 order by c0" -r csv
[ $status -eq 0 ]
[[ "${lines[1]}" = "7,7" ]] || false
[[ "${lines[2]}" = "7,7" ]] || false
[[ "${lines[3]}" = "8,8" ]] || false
[[ "${lines[4]}" = "9,9" ]] || false
}
@test "keyless: diff delete+add against working" {
dolt sql <<SQL
DELETE FROM keyless WHERE c0 = 2;
INSERT INTO keyless VALUES (2,2)
SQL
run dolt diff
[ $status -eq 0 ]
[ "$output" = "" ]
}
@test "keyless: diff delete+add on two branches" {
dolt branch left
dolt checkout -b right
dolt sql -q "DELETE FROM keyless WHERE c0 = 2;"
dolt commit -am "deleted ones on right"
run dolt diff main
[ $status -eq 0 ]
[[ "${lines[6]}" = "| - | 2 | 2 |" ]] || false
dolt checkout left
dolt sql -q "INSERT INTO keyless VALUES (2,2);"
dolt commit -am "deleted twos on left"
run dolt diff main
[ $status -eq 0 ]
[[ "${lines[6]}" = "| + | 2 | 2 |" ]] || false
}
@test "keyless: merge delete+add on two branches" {
dolt branch left
dolt checkout -b right
dolt sql -q "DELETE FROM keyless WHERE c0 = 2;"
dolt commit -am "deleted twos on right"
dolt checkout left
dolt sql -q "INSERT INTO keyless VALUES (2,2);"
dolt commit -am "inserted twos on left"
run dolt merge right -m "merge"
[ $status -eq 0 ]
[[ "$output" =~ "CONFLICT" ]] || false
run dolt conflicts resolve --theirs keyless
[ $status -eq 0 ]
dolt commit -am "resolved"
run dolt sql -q "select * from keyless order by c0" -r csv
[ $status -eq 0 ]
[[ "${lines[1]}" = "0,0" ]] || false
[[ "${lines[2]}" = "1,1" ]] || false
[[ "${lines[3]}" = "1,1" ]] || false
[ "${#lines[@]}" -eq 4 ]
}
@test "keyless: merge delete+add on two branches with stored procedure" {
dolt branch left
dolt checkout -b right
dolt sql -q "DELETE FROM keyless WHERE c0 = 2;"
dolt commit -am "deleted twos on right"
dolt checkout left
dolt sql -q "INSERT INTO keyless VALUES (2,2);"
dolt commit -am "inserted twos on left"
run dolt merge right -m "merge"
[ $status -eq 0 ]
[[ "$output" =~ "CONFLICT" ]] || false
run dolt sql -q "call dolt_conflicts_resolve('--theirs', 'keyless')"
[ $status -eq 0 ]
dolt commit -am "resolved"
run dolt sql -q "select * from keyless order by c0" -r csv
[ $status -eq 0 ]
[[ "${lines[1]}" = "0,0" ]] || false
[[ "${lines[2]}" = "1,1" ]] || false
[[ "${lines[3]}" = "1,1" ]] || false
[ "${#lines[@]}" -eq 4 ]
}
@test "keyless: create secondary index" {
dolt sql -q "create index idx on keyless (c1)"
run dolt sql -q "show index from keyless" -r csv
[ $status -eq 0 ]
[[ "${lines[0]}" = "Table,Non_unique,Key_name,Seq_in_index,Column_name,Collation,Cardinality,Sub_part,Packed,Null,Index_type,Comment,Index_comment,Visible,Expression" ]] || false
[[ "${lines[1]}" = "keyless,1,idx,1,c1,,0,,,YES,BTREE,\"\",\"\",YES," ]] || false
run dolt sql -q "select * from keyless where c1 > 0 order by c0" -r csv
[ $status -eq 0 ]
[[ "${lines[0]}" = "c0,c1" ]] || false
[[ "${lines[1]}" = "1,1" ]] || false
[[ "${lines[2]}" = "1,1" ]] || false
[[ "${lines[3]}" = "2,2" ]] || false
[ "${#lines[@]}" -eq 4 ]
run dolt sql -q "select c0 from keyless where c1 = 1" -r csv
[ $status -eq 0 ]
[[ "${lines[0]}" = "c0" ]] || false
[[ "${lines[1]}" = "1" ]] || false
[[ "${lines[2]}" = "1" ]] || false
[ "${#lines[@]}" -eq 3 ]
}
@test "keyless: secondary index insert" {
dolt sql -q "create index idx on keyless (c1)"
dolt sql -q "insert into keyless values (3,3), (4,4)"
run dolt sql -q "select c0 from keyless where c1 = 4" -r csv
[ $status -eq 0 ]
[[ "${lines[0]}" = "c0" ]] || false
[[ "${lines[1]}" = "4" ]] || false
[ "${#lines[@]}" -eq 2 ]
}
@test "keyless: secondary index duplicate insert" {
dolt sql -q "create index idx on keyless (c1)"
dolt sql -q "insert into keyless values (3,3), (4,4), (4,4)"
run dolt sql -q "select c0 from keyless where c1 = 4" -r csv
[ $status -eq 0 ]
[[ "${lines[0]}" = "c0" ]] || false
[[ "${lines[1]}" = "4" ]] || false
[[ "${lines[2]}" = "4" ]] || false
[ "${#lines[@]}" -eq 3 ]
}
@test "keyless: secondary index update" {
dolt sql -q "create index idx on keyless (c1)"
dolt sql -q "update keyless set c0 = c0 + 1"
run dolt sql -q "select * from keyless order by c0" -r csv
[ $status -eq 0 ]
[[ "${lines[1]}" = "1,0" ]] || false
[[ "${lines[2]}" = "2,1" ]] || false
[[ "${lines[3]}" = "2,1" ]] || false
[[ "${lines[4]}" = "3,2" ]] || false
[ "${#lines[@]}" -eq 5 ]
run dolt sql -q "select c0 from keyless where c1 = 1" -r csv
[ $status -eq 0 ]
[[ "${lines[0]}" = "c0" ]] || false
[[ "${lines[1]}" = "2" ]] || false
[[ "${lines[1]}" = "2" ]] || false
[ "${#lines[@]}" -eq 3 ]
}
@test "keyless: secondary index delete single" {
dolt sql -q "create index idx on keyless (c1)"
dolt sql -q "insert into keyless values (3,3), (4,4)"
dolt sql -q "delete from keyless where c0 = 4"
run dolt sql -q "select c0 from keyless where c1 > 2" -r csv
[ $status -eq 0 ]
[[ "${lines[0]}" = "c0" ]] || false
[[ "${lines[1]}" = "3" ]] || false
[ "${#lines[@]}" -eq 2 ]
run dolt sql -q "select c0 from keyless where c0 > 2" -r csv
[ $status -eq 0 ]
[[ "${lines[0]}" = "c0" ]] || false
[[ "${lines[1]}" = "3" ]] || false
[ "${#lines[@]}" -eq 2 ]
}
@test "keyless: secondary index delete duplicate" {
dolt sql -q "create index idx on keyless (c1)"
dolt sql -q "insert into keyless values (3,3), (4,4), (4,4)"
dolt sql -q "delete from keyless where c0 = 4"
run dolt sql -q "select c0 from keyless where c1 > 2" -r csv
[ $status -eq 0 ]
[[ "${lines[0]}" = "c0" ]] || false
[[ "${lines[1]}" = "3" ]] || false
[ "${#lines[@]}" -eq 2 ]
run dolt sql -q "select c0 from keyless where c0 > 2" -r csv
[ $status -eq 0 ]
[[ "${lines[0]}" = "c0" ]] || false
[[ "${lines[1]}" = "3" ]] || false
[ "${#lines[@]}" -eq 2 ]
}
@test "keyless: check constraint violation rolls back" {
dolt sql -q "create table test (i int check (i < 10))"
run dolt sql -q "insert into test values (1)"
[ $status -eq 0 ]
run dolt sql -r csv -q "select * from test"
[ "${#lines[@]}" -eq 2 ]
[[ "$output" =~ "i" ]] || false
[[ "$output" =~ "1" ]] || false
run dolt sql -q "insert into test values (100)"
[ $status -eq 1 ]
run dolt sql -r csv -q "select * from test"
[ "${#lines[@]}" -eq 2 ]
[[ "$output" =~ "i" ]] || false
[[ "$output" =~ "1" ]] || false
run dolt sql -q "insert into test values (2), (3), (100), (4)"
[ $status -eq 1 ]
run dolt sql -r csv -q "select * from test"
[ "${#lines[@]}" -eq 2 ]
[[ "$output" =~ "i" ]] || false
[[ "$output" =~ "1" ]] || false
}
@test "keyless: inserting invalid values are rolled back" {
dolt sql -q "create table test (i int check (i < 10))"
run dolt sql -q "insert into test values (1)"
[ $status -eq 0 ]
run dolt sql -r csv -q "select * from test"
[ "${#lines[@]}" -eq 2 ]
[[ "$output" =~ "i" ]] || false
[[ "$output" =~ "1" ]] || false
run dolt sql -q "insert into test values ('thisisastring')"
[ $status -eq 1 ]
run dolt sql -r csv -q "select * from test"
[ "${#lines[@]}" -eq 2 ]
[[ "$output" =~ "i" ]] || false
[[ "$output" =~ "1" ]] || false
run dolt sql -q "insert into test values (2), (3), ('thisisastring'), (4)"
[ $status -eq 1 ]
run dolt sql -r csv -q "select * from test"
[ "${#lines[@]}" -eq 2 ]
[[ "$output" =~ "i" ]] || false
[[ "$output" =~ "1" ]] || false
}
@test "keyless: insert into keyless table with unique index" {
dolt sql -q "CREATE TABLE mytable (pk int UNIQUE)";
run dolt sql -q "INSERT INTO mytable values (1),(2),(3),(4)"
[ $status -eq 0 ]
run dolt sql -r csv -q "SELECT * FROM mytable order by pk"
[ $status -eq 0 ]
[[ "${lines[1]}" = "1" ]] || false
[[ "${lines[2]}" = "2" ]] || false
[[ "${lines[3]}" = "3" ]] || false
[[ "${lines[4]}" = "4" ]] || false
run dolt sql -q "INSERT INTO mytable VALUES (1)"
[ $status -eq 1 ]
[[ "$output" =~ "duplicate unique key given: [1]" ]] || false
# Make sure nothing in the faulty transaction was persisted.
run dolt sql -q "INSERT INTO mytable VALUES (500000), (5000001), (3)"
[ $status -eq 1 ]
[[ "$output" =~ "duplicate unique key given: [3]" ]] || false
run dolt sql -r csv -q "SELECT count(*) FROM mytable where pk in (500000,5000001)"
[ $status -eq 0 ]
[[ "${lines[1]}" = "0" ]] || false
run dolt sql -r csv -q "SELECT count(*) FROM mytable"
[ $status -eq 0 ]
[[ "${lines[1]}" = "4" ]] || false
run dolt index cat mytable pk -r csv
[ $status -eq 0 ]
[[ "${lines[0]}" = "pk" ]] || false
[[ "${lines[1]}" = "1" ]] || false
[[ "${lines[2]}" = "2" ]] || false
[[ "${lines[3]}" = "3" ]] || false
[[ "${lines[4]}" = "4" ]] || false
[[ "${#lines[@]}" = "5" ]] || false
}
@test "keyless: insert into keyless table with unique index and auto increment" {
dolt sql -q "CREATE TABLE gis (pk INT UNIQUE NOT NULL AUTO_INCREMENT, shape GEOMETRY NOT NULL)"
dolt sql -q "INSERT INTO gis VALUES (1, POINT(1,1))"
run dolt sql -q "INSERT INTO gis VALUES (1, POINT(1,1))"
[ $status -eq 1 ]
[[ "$output" =~ "duplicate unique key given: [1]" ]] || false
run dolt sql -r csv -q "SELECT count(*) FROM gis where pk = 1"
[ $status -eq 0 ]
[[ "${lines[1]}" = "1" ]] || false
run dolt sql -q "INSERT INTO gis VALUES (NULL, POINT(1,1))"
[ $status -eq 0 ]
run dolt sql -r csv -q "SELECT count(*) FROM gis where pk = 2"
[ $status -eq 0 ]
[[ "${lines[1]}" = "1" ]] || false
}
@test "keyless: string type unique key index" {
dolt sql -q "CREATE TABLE mytable (pk int, val varchar(6) UNIQUE)"
dolt sql -q "INSERT INTO mytable VALUES (1, 'nekter')"
run dolt sql -q "INSERT INTO mytable VALUES (1, 'nekter')"
[ $status -eq 1 ]
[[ "$output" =~ 'duplicate unique key given' ]] || false
# old format wraps strings with quotes in duplicate unique key error
# printing, new format does not. So we test just for the content `nekter`
[[ "$output" =~ 'nekter' ]] || false
run dolt sql -r csv -q "SELECT count(*) from mytable where pk = 1"
[ $status -eq 0 ]
[[ "${lines[1]}" = "1" ]] || false
run dolt index cat mytable val -r csv
[[ "${lines[0]}" = "val" ]] || false
[[ "${lines[1]}" = "nekter" ]] || false
[[ "${#lines[@]}" = "2" ]] || false
}
@test "keyless: compound unique key index" {
dolt sql -q "CREATE TABLE mytable (pk int, v1 int, v2 int)"
dolt sql -q "ALTER TABLE mytable ADD CONSTRAINT ux UNIQUE (v1, v2)"
dolt sql -q "INSERT INTO mytable values (1, 2, 2)"
run dolt sql -q "INSERT INTO mytable values (1, 2, 2)"
[ $status -eq 1 ]
[[ "$output" =~ "duplicate unique key given: [2,2]" ]] || false
run dolt sql -r csv -q "SELECT COUNT(*) as count FROM mytable where pk = 1"
[ $status -eq 0 ]
[[ "${lines[0]}" = "count" ]] || false
[[ "${lines[1]}" = "1" ]] || false
run dolt index cat mytable ux -r csv
[[ "${lines[0]}" = "v1,v2" ]] || false
[[ "${lines[1]}" = "2,2" ]] || false
[[ "${#lines[@]}" = "2" ]] || false
}
@test "keyless: replace into and unique key index" {
skip "Keyless tables with unique indexes do not properly support replace into semantics"
dolt sql -q "CREATE TABLE mytable (pk int, v1 int, v2 int)"
dolt sql -q "ALTER TABLE mytable ADD CONSTRAINT ux UNIQUE (v1, v2)"
dolt sql -q "INSERT INTO mytable values (1, 2, 2)"
run dolt sql -q "REPLACE INTO mytable VALUES (1, 2, 2)"
[ $status -eq 0 ]
}
@test "keyless: batch import with keyless unique index" {
dolt sql -q "CREATE TABLE mytable (pk int, v1 int, v2 int)"
dolt sql -q "ALTER TABLE mytable ADD CONSTRAINT ux UNIQUE (v1)"
run dolt sql <<SQL
INSERT INTO mytable VALUES (1, 2, 2);
INSERT INTO mytable VALUES (3, 3, 3);
INSERT INTO mytable VALUES (2, 2, 3);
SQL
[ $status -eq 1 ]
run dolt sql -r csv -q "SELECT * FROM mytable order by pk"
[[ "${lines[0]}" = "pk,v1,v2" ]] || false
[[ "${lines[1]}" = "1,2,2" ]] || false
[[ "${lines[2]}" = "3,3,3" ]] || false
[[ "${#lines[@]}" = "3" ]] || false
run dolt sql -r csv -q "SELECT * FROM mytable where v1 = 2"
[[ "${lines[0]}" = "pk,v1,v2" ]] || false
[[ "${lines[1]}" = "1,2,2" ]] || false
[[ "${#lines[@]}" = "2" ]] || false
run dolt index cat mytable ux -r csv
[[ "${lines[0]}" = "v1" ]] || false
[[ "${lines[1]}" = "2" ]] || false
[[ "${lines[2]}" = "3" ]] || false
[[ "${#lines[@]}" = "3" ]] || false
}
@test "keyless: batch import with keyless unique index and secondary index" {
dolt sql -q "CREATE TABLE mytable (pk int, v1 int, v2 int)"
dolt sql -q "ALTER TABLE mytable ADD CONSTRAINT ux UNIQUE (v1)"
dolt sql -q "ALTER TABLE mytable ADD INDEX myidx (v2)"
run dolt sql <<SQL
INSERT INTO mytable VALUES (1, 2, 2);
INSERT INTO mytable VALUES (3, 3, 4);
INSERT INTO mytable VALUES (2, 2, 3);
SQL
[ $status -eq 1 ]
run dolt sql -r csv -q "SELECT * FROM mytable order by pk"
[[ "${lines[0]}" = "pk,v1,v2" ]] || false
[[ "${lines[1]}" = "1,2,2" ]] || false
[[ "${lines[2]}" = "3,3,4" ]] || false
[[ "${#lines[@]}" = "3" ]] || false
run dolt sql -r csv -q "SELECT * FROM mytable where v1 = 2"
[[ "${lines[0]}" = "pk,v1,v2" ]] || false
[[ "${lines[1]}" = "1,2,2" ]] || false
[[ "${#lines[@]}" = "2" ]] || false
run dolt index cat mytable ux -r csv
[ $status -eq 0 ]
[[ "${lines[0]}" = "v1" ]] || false
[[ "${lines[1]}" = "2" ]] || false
[[ "${lines[2]}" = "3" ]] || false
[[ "${#lines[@]}" = "3" ]] || false
run dolt index cat mytable myidx -r csv
[ $status -eq 0 ]
[[ "${lines[0]}" = "v2" ]] || false
[[ "${lines[1]}" = "2" ]] || false
[[ "${lines[2]}" = "4" ]] || false
[[ "${#lines[@]}" = "3" ]] || false
}
@test "keyless: batch import into the unique key correctly works" {
skip "index error handling does not work with bulk import"
dolt sql -q "CREATE TABLE mytable (pk int, v1 int, v2 int)"
dolt sql -q "ALTER TABLE mytable ADD CONSTRAINT ux UNIQUE (v1, v2)"
dolt sql -q "INSERT into mytable values (1, 1, 1), (2, 2, 2)"
echo "pk,v1,v2" >> x.csv
echo "3,1,1" >> x.csv
echo "4,2,2" >> x.csv
run dolt table import -u mytable x.csv
[ $status -eq 0 ]
}
@test "keyless: unique key should be represented as a primary key" {
skip "unique key is created, but it should be described as a primary key."
dolt sql -q "create table t(pk int not null auto_increment, UNIQUE KEY pk (pk));"
run dolt sql -r csv -q "describe t"
[[ "$output" =~ "Field,Type,Null,Key,Default,Extra" ]] || false
[[ "$output" =~ "ai,int,NO,UNI,NULL,auto_increment" ]] || false
}
Reference in New Issue View Git Blame Copy Permalink