Move statements into their own package

internal/query/statement/gen_insert_with_constraints_test.go

@@ -0,0 +1,898 @@
+/*
+* CODE GENERATED AUTOMATICALLY WITH github.com/genjidb/genji/dev/gensqltest
+* THIS FILE SHOULD NOT BE EDITED BY HAND
+ */
+package statement_test
+
+import (
+	"testing"
+
+	"github.com/genjidb/genji"
+	"github.com/stretchr/testify/require"
+)
+
+func TestGenInsertWithConstraints(t *testing.T) {
+	setup := func(t *testing.T, db *genji.DB) {
+		t.Helper()
+
+		q := `
+`
+		err := db.Exec(q)
+		require.NoError(t, err)
+	}
+
+	// --------------------------------------------------------------------------
+	t.Run("insert with errors, not null without type constraint", func(t *testing.T) {
+		db, err := genji.Open(":memory:")
+		require.NoError(t, err)
+		defer db.Close()
+
+		setup(t, db)
+
+		t.Run(`CREATE TABLE test_e (a NOT NULL);`, func(t *testing.T) {
+			q := `
+CREATE TABLE test_e (a NOT NULL);
+INSERT INTO test_e VALUES {};
+`
+			err := db.Exec(q)
+			require.Errorf(t, err, "expected\n%s\nto raise an error but got none", q)
+		})
+
+	})
+
+	// --------------------------------------------------------------------------
+	t.Run("insert with errors, array / not null with type constraint", func(t *testing.T) {
+		db, err := genji.Open(":memory:")
+		require.NoError(t, err)
+		defer db.Close()
+
+		setup(t, db)
+
+		t.Run(`CREATE TABLE test_e (a ARRAY NOT NULL);`, func(t *testing.T) {
+			q := `
+CREATE TABLE test_e (a ARRAY NOT NULL);
+INSERT INTO test_e VALUES {};
+`
+			err := db.Exec(q)
+			require.Errorf(t, err, "expected\n%s\nto raise an error but got none", q)
+		})
+
+	})
+
+	// --------------------------------------------------------------------------
+	t.Run("insert with errors, array / not null with non-respected type constraint", func(t *testing.T) {
+		db, err := genji.Open(":memory:")
+		require.NoError(t, err)
+		defer db.Close()
+
+		setup(t, db)
+
+		t.Run(`CREATE TABLE test_e (a ARRAY NOT NULL);`, func(t *testing.T) {
+			q := `
+CREATE TABLE test_e (a ARRAY NOT NULL);
+INSERT INTO test_e VALUES {a: 42};
+`
+			err := db.Exec(q)
+			require.Errorf(t, err, "expected\n%s\nto raise an error but got none", q)
+		})
+
+	})
+
+	// --------------------------------------------------------------------------
+	t.Run("insert with errors, blob", func(t *testing.T) {
+		db, err := genji.Open(":memory:")
+		require.NoError(t, err)
+		defer db.Close()
+
+		setup(t, db)
+
+		t.Run(`CREATE TABLE test_e (a BLOB);`, func(t *testing.T) {
+			q := `
+CREATE TABLE test_e (a BLOB);
+INSERT INTO test_e {a: true};
+`
+			err := db.Exec(q)
+			require.Errorf(t, err, "expected\n%s\nto raise an error but got none", q)
+		})
+
+	})
+
+	// --------------------------------------------------------------------------
+	t.Run("blob / not null with type constraint", func(t *testing.T) {
+		db, err := genji.Open(":memory:")
+		require.NoError(t, err)
+		defer db.Close()
+
+		setup(t, db)
+
+		t.Run(`CREATE TABLE test_e (a BLOB NOT NULL);`, func(t *testing.T) {
+			q := `
+CREATE TABLE test_e (a BLOB NOT NULL);
+INSERT INTO test_e {};
+`
+			err := db.Exec(q)
+			require.Errorf(t, err, "expected\n%s\nto raise an error but got none", q)
+		})
+
+	})
+
+	// --------------------------------------------------------------------------
+	t.Run("blob / not null with non-respected type constraint", func(t *testing.T) {
+		db, err := genji.Open(":memory:")
+		require.NoError(t, err)
+		defer db.Close()
+
+		setup(t, db)
+
+		t.Run(`CREATE TABLE test_e (a BLOB NOT NULL);`, func(t *testing.T) {
+			q := `
+CREATE TABLE test_e (a BLOB NOT NULL);
+INSERT INTO test_e {a: 42};
+`
+			err := db.Exec(q)
+			require.Errorf(t, err, "expected\n%s\nto raise an error but got none", q)
+		})
+
+	})
+
+	// --------------------------------------------------------------------------
+	t.Run("bool / not null with type constraint", func(t *testing.T) {
+		db, err := genji.Open(":memory:")
+		require.NoError(t, err)
+		defer db.Close()
+
+		setup(t, db)
+
+		t.Run(`CREATE TABLE test_e (a BOOL NOT NULL);`, func(t *testing.T) {
+			q := `
+CREATE TABLE test_e (a BOOL NOT NULL);
+INSERT INTO test_e {};
+`
+			err := db.Exec(q)
+			require.Errorf(t, err, "expected\n%s\nto raise an error but got none", q)
+		})
+
+	})
+
+	// --------------------------------------------------------------------------
+	t.Run("bytes", func(t *testing.T) {
+		db, err := genji.Open(":memory:")
+		require.NoError(t, err)
+		defer db.Close()
+
+		setup(t, db)
+
+		t.Run(`CREATE TABLE test_e (a BYTES);`, func(t *testing.T) {
+			q := `
+CREATE TABLE test_e (a BYTES);
+INSERT INTO test_e {a: [1,2,3]};
+`
+			err := db.Exec(q)
+			require.Errorf(t, err, "expected\n%s\nto raise an error but got none", q)
+		})
+
+	})
+
+	// --------------------------------------------------------------------------
+	t.Run("bytes / not null with type constraint", func(t *testing.T) {
+		db, err := genji.Open(":memory:")
+		require.NoError(t, err)
+		defer db.Close()
+
+		setup(t, db)
+
+		t.Run(`CREATE TABLE test_e (a BYTES NOT NULL);`, func(t *testing.T) {
+			q := `
+CREATE TABLE test_e (a BYTES NOT NULL);
+INSERT INTO test_e {};
+`
+			err := db.Exec(q)
+			require.Errorf(t, err, "expected\n%s\nto raise an error but got none", q)
+		})
+
+	})
+
+	// --------------------------------------------------------------------------
+	t.Run("bytes / not null with non-respected type constraint", func(t *testing.T) {
+		db, err := genji.Open(":memory:")
+		require.NoError(t, err)
+		defer db.Close()
+
+		setup(t, db)
+
+		t.Run(`CREATE TABLE test_e (a BYTES NOT NULL);`, func(t *testing.T) {
+			q := `
+CREATE TABLE test_e (a BYTES NOT NULL);
+INSERT INTO test_e {a: 42};
+`
+			err := db.Exec(q)
+			require.Errorf(t, err, "expected\n%s\nto raise an error but got none", q)
+		})
+
+	})
+
+	// --------------------------------------------------------------------------
+	t.Run("document", func(t *testing.T) {
+		db, err := genji.Open(":memory:")
+		require.NoError(t, err)
+		defer db.Close()
+
+		setup(t, db)
+
+		t.Run(`CREATE TABLE test_e (a DOCUMENT);`, func(t *testing.T) {
+			q := `
+CREATE TABLE test_e (a DOCUMENT);
+INSERT INTO test_e {"a": "foo"};
+`
+			err := db.Exec(q)
+			require.Errorf(t, err, "expected\n%s\nto raise an error but got none", q)
+		})
+
+	})
+
+	// --------------------------------------------------------------------------
+	t.Run("document / not null with type constraint", func(t *testing.T) {
+		db, err := genji.Open(":memory:")
+		require.NoError(t, err)
+		defer db.Close()
+
+		setup(t, db)
+
+		t.Run(`CREATE TABLE test_e (a DOCUMENT NOT NULL);`, func(t *testing.T) {
+			q := `
+CREATE TABLE test_e (a DOCUMENT NOT NULL);
+INSERT INTO test_e {};
+`
+			err := db.Exec(q)
+			require.Errorf(t, err, "expected\n%s\nto raise an error but got none", q)
+		})
+
+	})
+
+	// --------------------------------------------------------------------------
+	t.Run("document / not null with non-respected type constraint", func(t *testing.T) {
+		db, err := genji.Open(":memory:")
+		require.NoError(t, err)
+		defer db.Close()
+
+		setup(t, db)
+
+		t.Run(`CREATE TABLE test_e (a DOCUMENT NOT NULL);`, func(t *testing.T) {
+			q := `
+CREATE TABLE test_e (a DOCUMENT NOT NULL);
+INSERT INTO test_e {a: false};
+`
+			err := db.Exec(q)
+			require.Errorf(t, err, "expected\n%s\nto raise an error but got none", q)
+		})
+
+	})
+
+	// --------------------------------------------------------------------------
+	t.Run("double", func(t *testing.T) {
+		db, err := genji.Open(":memory:")
+		require.NoError(t, err)
+		defer db.Close()
+
+		setup(t, db)
+
+		t.Run(`CREATE TABLE test_e (a DOUBLE);`, func(t *testing.T) {
+			q := `
+CREATE TABLE test_e (a DOUBLE);
+INSERT INTO test_e {a: "foo"};
+`
+			err := db.Exec(q)
+			require.Errorf(t, err, "expected\n%s\nto raise an error but got none", q)
+		})
+
+	})
+
+	// --------------------------------------------------------------------------
+	t.Run("double / not null with type constraint", func(t *testing.T) {
+		db, err := genji.Open(":memory:")
+		require.NoError(t, err)
+		defer db.Close()
+
+		setup(t, db)
+
+		t.Run(`CREATE TABLE test_e (a DOUBLE NOT NULL);`, func(t *testing.T) {
+			q := `
+CREATE TABLE test_e (a DOUBLE NOT NULL);
+INSERT INTO test_e {};
+`
+			err := db.Exec(q)
+			require.Errorf(t, err, "expected\n%s\nto raise an error but got none", q)
+		})
+
+	})
+
+	// --------------------------------------------------------------------------
+	t.Run("double / not null with non-respected type constraint", func(t *testing.T) {
+		db, err := genji.Open(":memory:")
+		require.NoError(t, err)
+		defer db.Close()
+
+		setup(t, db)
+
+		t.Run(`CREATE TABLE test_e (a DOUBLE NOT NULL);`, func(t *testing.T) {
+			q := `
+CREATE TABLE test_e (a DOUBLE NOT NULL);
+INSERT INTO test_e {a: [1,2,3]};
+`
+			err := db.Exec(q)
+			require.Errorf(t, err, "expected\n%s\nto raise an error but got none", q)
+		})
+
+	})
+
+	// --------------------------------------------------------------------------
+	t.Run("double precision", func(t *testing.T) {
+		db, err := genji.Open(":memory:")
+		require.NoError(t, err)
+		defer db.Close()
+
+		setup(t, db)
+
+		t.Run(`CREATE TABLE test_e (a DOUBLE PRECISION);`, func(t *testing.T) {
+			q := `
+CREATE TABLE test_e (a DOUBLE PRECISION);
+INSERT INTO test_e {a: "foo"};
+`
+			err := db.Exec(q)
+			require.Errorf(t, err, "expected\n%s\nto raise an error but got none", q)
+		})
+
+	})
+
+	// --------------------------------------------------------------------------
+	t.Run("double precision / not null with type constraint", func(t *testing.T) {
+		db, err := genji.Open(":memory:")
+		require.NoError(t, err)
+		defer db.Close()
+
+		setup(t, db)
+
+		t.Run(`CREATE TABLE test_e (a DOUBLE PRECISION NOT NULL);`, func(t *testing.T) {
+			q := `
+CREATE TABLE test_e (a DOUBLE PRECISION NOT NULL);
+INSERT INTO test_e {};
+`
+			err := db.Exec(q)
+			require.Errorf(t, err, "expected\n%s\nto raise an error but got none", q)
+		})
+
+	})
+
+	// --------------------------------------------------------------------------
+	t.Run("double precision / not null with non-respected type constraint", func(t *testing.T) {
+		db, err := genji.Open(":memory:")
+		require.NoError(t, err)
+		defer db.Close()
+
+		setup(t, db)
+
+		t.Run(`CREATE TABLE test_e (a DOUBLE PRECISION NOT NULL);`, func(t *testing.T) {
+			q := `
+CREATE TABLE test_e (a DOUBLE PRECISION NOT NULL);
+INSERT INTO test_e {a: [1,2,3]};
+`
+			err := db.Exec(q)
+			require.Errorf(t, err, "expected\n%s\nto raise an error but got none", q)
+		})
+
+	})
+
+	// --------------------------------------------------------------------------
+	t.Run("real", func(t *testing.T) {
+		db, err := genji.Open(":memory:")
+		require.NoError(t, err)
+		defer db.Close()
+
+		setup(t, db)
+
+		t.Run(`CREATE TABLE test_e (a REAL);`, func(t *testing.T) {
+			q := `
+CREATE TABLE test_e (a REAL);
+INSERT INTO test_e {a: "foo"};
+`
+			err := db.Exec(q)
+			require.Errorf(t, err, "expected\n%s\nto raise an error but got none", q)
+		})
+
+	})
+
+	// --------------------------------------------------------------------------
+	t.Run("real / not null with type constraint", func(t *testing.T) {
+		db, err := genji.Open(":memory:")
+		require.NoError(t, err)
+		defer db.Close()
+
+		setup(t, db)
+
+		t.Run(`CREATE TABLE test_e (a REAL NOT NULL);`, func(t *testing.T) {
+			q := `
+CREATE TABLE test_e (a REAL NOT NULL);
+INSERT INTO test_e {};
+`
+			err := db.Exec(q)
+			require.Errorf(t, err, "expected\n%s\nto raise an error but got none", q)
+		})
+
+	})
+
+	// --------------------------------------------------------------------------
+	t.Run("real / not null with non-respected type constraint", func(t *testing.T) {
+		db, err := genji.Open(":memory:")
+		require.NoError(t, err)
+		defer db.Close()
+
+		setup(t, db)
+
+		t.Run(`CREATE TABLE test_e (a REAL NOT NULL);`, func(t *testing.T) {
+			q := `
+CREATE TABLE test_e (a REAL NOT NULL);
+INSERT INTO test_e {a: [1,2,3]};
+`
+			err := db.Exec(q)
+			require.Errorf(t, err, "expected\n%s\nto raise an error but got none", q)
+		})
+
+	})
+
+	// --------------------------------------------------------------------------
+	t.Run("integer", func(t *testing.T) {
+		db, err := genji.Open(":memory:")
+		require.NoError(t, err)
+		defer db.Close()
+
+		setup(t, db)
+
+		t.Run(`CREATE TABLE test_e (a INTEGER);`, func(t *testing.T) {
+			q := `
+CREATE TABLE test_e (a INTEGER);
+INSERT INTO test_e {a: "foo"};
+`
+			err := db.Exec(q)
+			require.Errorf(t, err, "expected\n%s\nto raise an error but got none", q)
+		})
+
+	})
+
+	// --------------------------------------------------------------------------
+	t.Run("integer / not null with type constraint", func(t *testing.T) {
+		db, err := genji.Open(":memory:")
+		require.NoError(t, err)
+		defer db.Close()
+
+		setup(t, db)
+
+		t.Run(`CREATE TABLE test_e (a INTEGER NOT NULL);`, func(t *testing.T) {
+			q := `
+CREATE TABLE test_e (a INTEGER NOT NULL);
+INSERT INTO test_e {};
+`
+			err := db.Exec(q)
+			require.Errorf(t, err, "expected\n%s\nto raise an error but got none", q)
+		})
+
+	})
+
+	// --------------------------------------------------------------------------
+	t.Run("integer / not null with non-respected type constraint", func(t *testing.T) {
+		db, err := genji.Open(":memory:")
+		require.NoError(t, err)
+		defer db.Close()
+
+		setup(t, db)
+
+		t.Run(`CREATE TABLE test_e (a INTEGER NOT NULL);`, func(t *testing.T) {
+			q := `
+CREATE TABLE test_e (a INTEGER NOT NULL);
+INSERT INTO test_e {a: [1,2,3]};
+`
+			err := db.Exec(q)
+			require.Errorf(t, err, "expected\n%s\nto raise an error but got none", q)
+		})
+
+	})
+
+	// --------------------------------------------------------------------------
+	t.Run("int2", func(t *testing.T) {
+		db, err := genji.Open(":memory:")
+		require.NoError(t, err)
+		defer db.Close()
+
+		setup(t, db)
+
+		t.Run(`CREATE TABLE test_e (a INT2);`, func(t *testing.T) {
+			q := `
+CREATE TABLE test_e (a INT2);
+INSERT INTO test_e {a: "foo"};
+`
+			err := db.Exec(q)
+			require.Errorf(t, err, "expected\n%s\nto raise an error but got none", q)
+		})
+
+	})
+
+	// --------------------------------------------------------------------------
+	t.Run("int2 / not null with type constraint", func(t *testing.T) {
+		db, err := genji.Open(":memory:")
+		require.NoError(t, err)
+		defer db.Close()
+
+		setup(t, db)
+
+		t.Run(`CREATE TABLE test_e (a INT2 NOT NULL);`, func(t *testing.T) {
+			q := `
+CREATE TABLE test_e (a INT2 NOT NULL);
+INSERT INTO test_e {};
+`
+			err := db.Exec(q)
+			require.Errorf(t, err, "expected\n%s\nto raise an error but got none", q)
+		})
+
+	})
+
+	// --------------------------------------------------------------------------
+	t.Run("int2 / not null with non-respected type constraint", func(t *testing.T) {
+		db, err := genji.Open(":memory:")
+		require.NoError(t, err)
+		defer db.Close()
+
+		setup(t, db)
+
+		t.Run(`CREATE TABLE test_e (a INT NOT NULL);`, func(t *testing.T) {
+			q := `
+CREATE TABLE test_e (a INT NOT NULL);
+INSERT INTO test_e {a: [1,2,3]};
+`
+			err := db.Exec(q)
+			require.Errorf(t, err, "expected\n%s\nto raise an error but got none", q)
+		})
+
+	})
+
+	// --------------------------------------------------------------------------
+	t.Run("int8", func(t *testing.T) {
+		db, err := genji.Open(":memory:")
+		require.NoError(t, err)
+		defer db.Close()
+
+		setup(t, db)
+
+		t.Run(`CREATE TABLE test_e (a INT8);`, func(t *testing.T) {
+			q := `
+CREATE TABLE test_e (a INT8);
+INSERT INTO test_e {a: "foo"};
+`
+			err := db.Exec(q)
+			require.Errorf(t, err, "expected\n%s\nto raise an error but got none", q)
+		})
+
+	})
+
+	// --------------------------------------------------------------------------
+	t.Run("int8 / not null with type constraint", func(t *testing.T) {
+		db, err := genji.Open(":memory:")
+		require.NoError(t, err)
+		defer db.Close()
+
+		setup(t, db)
+
+		t.Run(`CREATE TABLE test_e (a INT8 NOT NULL);`, func(t *testing.T) {
+			q := `
+CREATE TABLE test_e (a INT8 NOT NULL);
+INSERT INTO test_e {};
+`
+			err := db.Exec(q)
+			require.Errorf(t, err, "expected\n%s\nto raise an error but got none", q)
+		})
+
+	})
+
+	// --------------------------------------------------------------------------
+	t.Run("int8 / not null with non-respected type constraint", func(t *testing.T) {
+		db, err := genji.Open(":memory:")
+		require.NoError(t, err)
+		defer db.Close()
+
+		setup(t, db)
+
+		t.Run(`CREATE TABLE test_e (a INT8 NOT NULL);`, func(t *testing.T) {
+			q := `
+CREATE TABLE test_e (a INT8 NOT NULL);
+INSERT INTO test_e {a: [1,2,3]};
+`
+			err := db.Exec(q)
+			require.Errorf(t, err, "expected\n%s\nto raise an error but got none", q)
+		})
+
+	})
+
+	// --------------------------------------------------------------------------
+	t.Run("tinyint", func(t *testing.T) {
+		db, err := genji.Open(":memory:")
+		require.NoError(t, err)
+		defer db.Close()
+
+		setup(t, db)
+
+		t.Run(`CREATE TABLE test_e (a TINYINT);`, func(t *testing.T) {
+			q := `
+CREATE TABLE test_e (a TINYINT);
+INSERT INTO test_e {a: "foo"};
+`
+			err := db.Exec(q)
+			require.Errorf(t, err, "expected\n%s\nto raise an error but got none", q)
+		})
+
+	})
+
+	// --------------------------------------------------------------------------
+	t.Run("tinyint / not null with type constraint", func(t *testing.T) {
+		db, err := genji.Open(":memory:")
+		require.NoError(t, err)
+		defer db.Close()
+
+		setup(t, db)
+
+		t.Run(`CREATE TABLE test_e (a TINYINT NOT NULL);`, func(t *testing.T) {
+			q := `
+CREATE TABLE test_e (a TINYINT NOT NULL);
+INSERT INTO test_e {};
+`
+			err := db.Exec(q)
+			require.Errorf(t, err, "expected\n%s\nto raise an error but got none", q)
+		})
+
+	})
+
+	// --------------------------------------------------------------------------
+	t.Run("tinyint / not null with non-respected type constraint", func(t *testing.T) {
+		db, err := genji.Open(":memory:")
+		require.NoError(t, err)
+		defer db.Close()
+
+		setup(t, db)
+
+		t.Run(`CREATE TABLE test_e (a TINYINT NOT NULL);`, func(t *testing.T) {
+			q := `
+CREATE TABLE test_e (a TINYINT NOT NULL);
+INSERT INTO test_e {a: [1,2,3]};
+`
+			err := db.Exec(q)
+			require.Errorf(t, err, "expected\n%s\nto raise an error but got none", q)
+		})
+
+	})
+
+	// --------------------------------------------------------------------------
+	t.Run("bigint", func(t *testing.T) {
+		db, err := genji.Open(":memory:")
+		require.NoError(t, err)
+		defer db.Close()
+
+		setup(t, db)
+
+		t.Run(`CREATE TABLE test_e (a BIGINT);`, func(t *testing.T) {
+			q := `
+CREATE TABLE test_e (a BIGINT);
+INSERT INTO test_e {a: "foo"};
+`
+			err := db.Exec(q)
+			require.Errorf(t, err, "expected\n%s\nto raise an error but got none", q)
+		})
+
+	})
+
+	// --------------------------------------------------------------------------
+	t.Run("bigint / not null with type constraint", func(t *testing.T) {
+		db, err := genji.Open(":memory:")
+		require.NoError(t, err)
+		defer db.Close()
+
+		setup(t, db)
+
+		t.Run(`CREATE TABLE test_e (a BIGINT NOT NULL);`, func(t *testing.T) {
+			q := `
+CREATE TABLE test_e (a BIGINT NOT NULL);
+INSERT INTO test_e {};
+`
+			err := db.Exec(q)
+			require.Errorf(t, err, "expected\n%s\nto raise an error but got none", q)
+		})
+
+	})
+
+	// --------------------------------------------------------------------------
+	t.Run("bigint / not null with non-respected type constraint", func(t *testing.T) {
+		db, err := genji.Open(":memory:")
+		require.NoError(t, err)
+		defer db.Close()
+
+		setup(t, db)
+
+		t.Run(`CREATE TABLE test_e (a BIGINT NOT NULL);`, func(t *testing.T) {
+			q := `
+CREATE TABLE test_e (a BIGINT NOT NULL);
+INSERT INTO test_e {a: [1,2,3]};
+`
+			err := db.Exec(q)
+			require.Errorf(t, err, "expected\n%s\nto raise an error but got none", q)
+		})
+
+	})
+
+	// --------------------------------------------------------------------------
+	t.Run("smallint", func(t *testing.T) {
+		db, err := genji.Open(":memory:")
+		require.NoError(t, err)
+		defer db.Close()
+
+		setup(t, db)
+
+		t.Run(`CREATE TABLE test_e (a SMALLINT);`, func(t *testing.T) {
+			q := `
+CREATE TABLE test_e (a SMALLINT);
+INSERT INTO test_e {a: "foo"};
+`
+			err := db.Exec(q)
+			require.Errorf(t, err, "expected\n%s\nto raise an error but got none", q)
+		})
+
+	})
+
+	// --------------------------------------------------------------------------
+	t.Run("smallint / not null with type constraint", func(t *testing.T) {
+		db, err := genji.Open(":memory:")
+		require.NoError(t, err)
+		defer db.Close()
+
+		setup(t, db)
+
+		t.Run(`CREATE TABLE test_e (a SMALLINT NOT NULL);`, func(t *testing.T) {
+			q := `
+CREATE TABLE test_e (a SMALLINT NOT NULL);
+INSERT INTO test_e {};
+`
+			err := db.Exec(q)
+			require.Errorf(t, err, "expected\n%s\nto raise an error but got none", q)
+		})
+
+	})
+
+	// --------------------------------------------------------------------------
+	t.Run("smallint / not null with non-respected type constraint", func(t *testing.T) {
+		db, err := genji.Open(":memory:")
+		require.NoError(t, err)
+		defer db.Close()
+
+		setup(t, db)
+
+		t.Run(`CREATE TABLE test_e (a SMALLINT NOT NULL);`, func(t *testing.T) {
+			q := `
+CREATE TABLE test_e (a SMALLINT NOT NULL);
+INSERT INTO test_e {a: [1,2,3]};
+`
+			err := db.Exec(q)
+			require.Errorf(t, err, "expected\n%s\nto raise an error but got none", q)
+		})
+
+	})
+
+	// --------------------------------------------------------------------------
+	t.Run("mediumint", func(t *testing.T) {
+		db, err := genji.Open(":memory:")
+		require.NoError(t, err)
+		defer db.Close()
+
+		setup(t, db)
+
+		t.Run(`CREATE TABLE test_e (a MEDIUMINT);`, func(t *testing.T) {
+			q := `
+CREATE TABLE test_e (a MEDIUMINT);
+INSERT INTO test_e {a: "foo"};
+`
+			err := db.Exec(q)
+			require.Errorf(t, err, "expected\n%s\nto raise an error but got none", q)
+		})
+
+	})
+
+	// --------------------------------------------------------------------------
+	t.Run("mediumint / not null with type constraint", func(t *testing.T) {
+		db, err := genji.Open(":memory:")
+		require.NoError(t, err)
+		defer db.Close()
+
+		setup(t, db)
+
+		t.Run(`CREATE TABLE test_e (a MEDIUMINT NOT NULL);`, func(t *testing.T) {
+			q := `
+CREATE TABLE test_e (a MEDIUMINT NOT NULL);
+INSERT INTO test_e {};
+`
+			err := db.Exec(q)
+			require.Errorf(t, err, "expected\n%s\nto raise an error but got none", q)
+		})
+
+	})
+
+	// --------------------------------------------------------------------------
+	t.Run("mediumint / not null with non-respected type constraint", func(t *testing.T) {
+		db, err := genji.Open(":memory:")
+		require.NoError(t, err)
+		defer db.Close()
+
+		setup(t, db)
+
+		t.Run(`CREATE TABLE test_e (a MEDIUMINT NOT NULL);`, func(t *testing.T) {
+			q := `
+CREATE TABLE test_e (a MEDIUMINT NOT NULL);
+INSERT INTO test_e {a: [1,2,3]};
+`
+			err := db.Exec(q)
+			require.Errorf(t, err, "expected\n%s\nto raise an error but got none", q)
+		})
+
+	})
+
+	// --------------------------------------------------------------------------
+	t.Run("text / not null with type constraint", func(t *testing.T) {
+		db, err := genji.Open(":memory:")
+		require.NoError(t, err)
+		defer db.Close()
+
+		setup(t, db)
+
+		t.Run(`CREATE TABLE test_e (a TEXT NOT NULL);`, func(t *testing.T) {
+			q := `
+CREATE TABLE test_e (a TEXT NOT NULL);
+INSERT INTO test_e {};
+`
+			err := db.Exec(q)
+			require.Errorf(t, err, "expected\n%s\nto raise an error but got none", q)
+		})
+
+	})
+
+	// --------------------------------------------------------------------------
+	t.Run("varchar / not null with type constraint", func(t *testing.T) {
+		db, err := genji.Open(":memory:")
+		require.NoError(t, err)
+		defer db.Close()
+
+		setup(t, db)
+
+		t.Run(`CREATE TABLE test_e (a VARCHAR(255) NOT NULL);`, func(t *testing.T) {
+			q := `
+CREATE TABLE test_e (a VARCHAR(255) NOT NULL);
+INSERT INTO test_e {};
+`
+			err := db.Exec(q)
+			require.Errorf(t, err, "expected\n%s\nto raise an error but got none", q)
+		})
+
+	})
+
+	// --------------------------------------------------------------------------
+	t.Run("character / not null with type constraint", func(t *testing.T) {
+		db, err := genji.Open(":memory:")
+		require.NoError(t, err)
+		defer db.Close()
+
+		setup(t, db)
+
+		t.Run(`CREATE TABLE test_e (a CHARACTER(64) NOT NULL);`, func(t *testing.T) {
+			q := `
+CREATE TABLE test_e (a CHARACTER(64) NOT NULL);
+INSERT INTO test_e {};
+`
+			err := db.Exec(q)
+			require.Errorf(t, err, "expected\n%s\nto raise an error but got none", q)
+		})
+
+	})
+
+}