+209

create_table.go

reviewed

··· 1 1 + package norm 2 2 + 3 3 + import ( 4 4 + "context" 5 5 + "database/sql" 6 6 + "fmt" 7 7 + "strings" 8 8 + ) 9 9 + 10 10 + type SQLiteType string 11 11 + 12 12 + const ( 13 13 + Integer SQLiteType = "INTEGER" 14 14 + Text SQLiteType = "TEXT" 15 15 + Real SQLiteType = "REAL" 16 16 + Blob SQLiteType = "BLOB" 17 17 + Numeric SQLiteType = "NUMERIC" 18 18 + ) 19 19 + 20 20 + type ColumnConstraint interface { 21 21 + applyConstraint(*columnDef) 22 22 + } 23 23 + 24 24 + type constraintFunc func(*columnDef) 25 25 + 26 26 + func (f constraintFunc) applyConstraint(col *columnDef) { 27 27 + f(col) 28 28 + } 29 29 + 30 30 + var ( 31 31 + PrimaryKey = constraintFunc(func(col *columnDef) { 32 32 + col.constraints = append(col.constraints, "PRIMARY KEY") 33 33 + }) 34 34 + 35 35 + AutoIncrement = constraintFunc(func(col *columnDef) { 36 36 + col.constraints = append(col.constraints, "AUTOINCREMENT") 37 37 + }) 38 38 + 39 39 + NotNull = constraintFunc(func(col *columnDef) { 40 40 + col.constraints = append(col.constraints, "NOT NULL") 41 41 + }) 42 42 + 43 43 + Unique = constraintFunc(func(col *columnDef) { 44 44 + col.constraints = append(col.constraints, "UNIQUE") 45 45 + }) 46 46 + ) 47 47 + 48 48 + func Default(val any) ColumnConstraint { 49 49 + return constraintFunc(func(col *columnDef) { 50 50 + col.constraints = append(col.constraints, fmt.Sprintf("DEFAULT %v", val)) 51 51 + }) 52 52 + } 53 53 + 54 54 + func Check(expr string) ColumnConstraint { 55 55 + return constraintFunc(func(col *columnDef) { 56 56 + col.constraints = append(col.constraints, fmt.Sprintf("CHECK (%s)", expr)) 57 57 + }) 58 58 + } 59 59 + 60 60 + func Collate(collation string) ColumnConstraint { 61 61 + return constraintFunc(func(col *columnDef) { 62 62 + col.constraints = append(col.constraints, fmt.Sprintf("COLLATE %s", collation)) 63 63 + }) 64 64 + } 65 65 + 66 66 + type columnDef struct { 67 67 + name string 68 68 + dataType SQLiteType 69 69 + constraints []string 70 70 + } 71 71 + 72 72 + type createTable struct { 73 73 + table string 74 74 + ifNotExists bool 75 75 + columns []columnDef 76 76 + tableConstraints []string 77 77 + withoutRowid bool 78 78 + strict bool 79 79 + } 80 80 + 81 81 + func CreateTable(name string) createTable { 82 82 + return createTable{table: name} 83 83 + } 84 84 + 85 85 + func (c createTable) IfNotExists() createTable { 86 86 + c.ifNotExists = true 87 87 + return c 88 88 + } 89 89 + 90 90 + func (c createTable) Column(name string, dataType SQLiteType, constraints ...ColumnConstraint) createTable { 91 91 + col := columnDef{ 92 92 + name: name, 93 93 + dataType: dataType, 94 94 + } 95 95 + for _, constraint := range constraints { 96 96 + constraint.applyConstraint(&col) 97 97 + } 98 98 + c.columns = append(c.columns, col) 99 99 + return c 100 100 + } 101 101 + 102 102 + func (c createTable) PrimaryKey(cols ...string) createTable { 103 103 + c.tableConstraints = append(c.tableConstraints, 104 104 + fmt.Sprintf("PRIMARY KEY (%s)", strings.Join(cols, ", "))) 105 105 + return c 106 106 + } 107 107 + 108 108 + func (c createTable) UniqueConstraint(cols ...string) createTable { 109 109 + c.tableConstraints = append(c.tableConstraints, 110 110 + fmt.Sprintf("UNIQUE (%s)", strings.Join(cols, ", "))) 111 111 + return c 112 112 + } 113 113 + 114 114 + func (c createTable) CheckConstraint(expr string) createTable { 115 115 + c.tableConstraints = append(c.tableConstraints, 116 116 + fmt.Sprintf("CHECK (%s)", expr)) 117 117 + return c 118 118 + } 119 119 + 120 120 + func (c createTable) ForeignKey(col, refTable, refCol string) createTable { 121 121 + c.tableConstraints = append(c.tableConstraints, 122 122 + fmt.Sprintf("FOREIGN KEY (%s) REFERENCES %s(%s)", col, refTable, refCol)) 123 123 + return c 124 124 + } 125 125 + 126 126 + func (c createTable) WithoutRowid() createTable { 127 127 + c.withoutRowid = true 128 128 + return c 129 129 + } 130 130 + 131 131 + func (c createTable) Strict() createTable { 132 132 + c.strict = true 133 133 + return c 134 134 + } 135 135 + 136 136 + func (c createTable) Compile() (string, []any, error) { 137 137 + var sql strings.Builder 138 138 + 139 139 + sql.WriteString("CREATE TABLE ") 140 140 + 141 141 + if c.ifNotExists { 142 142 + sql.WriteString("IF NOT EXISTS ") 143 143 + } 144 144 + 145 145 + if c.table == "" { 146 146 + return "", nil, fmt.Errorf("table name is required") 147 147 + } 148 148 + sql.WriteString(c.table) 149 149 + 150 150 + if len(c.columns) == 0 { 151 151 + return "", nil, fmt.Errorf("at least one column is required") 152 152 + } 153 153 + 154 154 + sql.WriteString(" (") 155 155 + 156 156 + // Column definitions 157 157 + for i, col := range c.columns { 158 158 + if i > 0 { 159 159 + sql.WriteString(", ") 160 160 + } 161 161 + 162 162 + sql.WriteString(col.name) 163 163 + sql.WriteString(" ") 164 164 + sql.WriteString(string(col.dataType)) 165 165 + 166 166 + for _, constraint := range col.constraints { 167 167 + sql.WriteString(" ") 168 168 + sql.WriteString(constraint) 169 169 + } 170 170 + } 171 171 + 172 172 + // Table-level constraints 173 173 + for _, constraint := range c.tableConstraints { 174 174 + sql.WriteString(", ") 175 175 + sql.WriteString(constraint) 176 176 + } 177 177 + 178 178 + sql.WriteString(")") 179 179 + 180 180 + if c.strict { 181 181 + sql.WriteString(" STRICT") 182 182 + } 183 183 + 184 184 + if c.withoutRowid { 185 185 + sql.WriteString(" WITHOUT ROWID") 186 186 + } 187 187 + 188 188 + return sql.String(), nil, nil 189 189 + } 190 190 + 191 191 + func (c createTable) MustCompile() (string, []any) { 192 192 + sql, args, err := c.Compile() 193 193 + if err != nil { 194 194 + panic(err) 195 195 + } 196 196 + return sql, args 197 197 + } 198 198 + 199 199 + func (c createTable) Build(p Database) (*sql.Stmt, []any, error) { return Build(c, p) } 200 200 + func (c createTable) MustBuild(p Database) (*sql.Stmt, []any) { return MustBuild(c, p) } 201 201 + 202 202 + func (c createTable) Exec(p Database) (sql.Result, error) { return Exec(c, p) } 203 203 + func (c createTable) ExecContext(ctx context.Context, p Database) (sql.Result, error) { 204 204 + return ExecContext(ctx, c, p) 205 205 + } 206 206 + func (c createTable) MustExec(p Database) sql.Result { return MustExec(c, p) } 207 207 + func (c createTable) MustExecContext(ctx context.Context, p Database) sql.Result { 208 208 + return MustExecContext(ctx, c, p) 209 209 + }

+339

create_table_test.go

reviewed

··· 1 1 + package norm 2 2 + 3 3 + import ( 4 4 + "database/sql" 5 5 + "testing" 6 6 + 7 7 + _ "github.com/mattn/go-sqlite3" 8 8 + ) 9 9 + 10 10 + func TestCreateTableCompileSuccess(t *testing.T) { 11 11 + tests := []struct { 12 12 + name string 13 13 + stmt Compiler 14 14 + expectedSql string 15 15 + }{ 16 16 + { 17 17 + name: "Simple table", 18 18 + stmt: CreateTable("users"). 19 19 + Column("id", Integer), 20 20 + expectedSql: "CREATE TABLE users (id INTEGER)", 21 21 + }, 22 22 + { 23 23 + name: "Table with primary key", 24 24 + stmt: CreateTable("users"). 25 25 + Column("id", Integer, PrimaryKey), 26 26 + expectedSql: "CREATE TABLE users (id INTEGER PRIMARY KEY)", 27 27 + }, 28 28 + { 29 29 + name: "Table with autoincrement", 30 30 + stmt: CreateTable("users"). 31 31 + Column("id", Integer, PrimaryKey, AutoIncrement), 32 32 + expectedSql: "CREATE TABLE users (id INTEGER PRIMARY KEY AUTOINCREMENT)", 33 33 + }, 34 34 + { 35 35 + name: "Table with multiple columns", 36 36 + stmt: CreateTable("users"). 37 37 + Column("id", Integer, PrimaryKey). 38 38 + Column("name", Text, NotNull). 39 39 + Column("age", Integer), 40 40 + expectedSql: "CREATE TABLE users (id INTEGER PRIMARY KEY, name TEXT NOT NULL, age INTEGER)", 41 41 + }, 42 42 + { 43 43 + name: "Table with IF NOT EXISTS", 44 44 + stmt: CreateTable("users"). 45 45 + IfNotExists(). 46 46 + Column("id", Integer, PrimaryKey), 47 47 + expectedSql: "CREATE TABLE IF NOT EXISTS users (id INTEGER PRIMARY KEY)", 48 48 + }, 49 49 + { 50 50 + name: "Table with unique constraint", 51 51 + stmt: CreateTable("users"). 52 52 + Column("id", Integer, PrimaryKey). 53 53 + Column("email", Text, Unique), 54 54 + expectedSql: "CREATE TABLE users (id INTEGER PRIMARY KEY, email TEXT UNIQUE)", 55 55 + }, 56 56 + { 57 57 + name: "Table with default value", 58 58 + stmt: CreateTable("users"). 59 59 + Column("id", Integer, PrimaryKey). 60 60 + Column("active", Integer, Default(1)), 61 61 + expectedSql: "CREATE TABLE users (id INTEGER PRIMARY KEY, active INTEGER DEFAULT 1)", 62 62 + }, 63 63 + { 64 64 + name: "Table with check constraint", 65 65 + stmt: CreateTable("users"). 66 66 + Column("id", Integer, PrimaryKey). 67 67 + Column("age", Integer, Check("age >= 18")), 68 68 + expectedSql: "CREATE TABLE users (id INTEGER PRIMARY KEY, age INTEGER CHECK (age >= 18))", 69 69 + }, 70 70 + { 71 71 + name: "Table with collate", 72 72 + stmt: CreateTable("users"). 73 73 + Column("id", Integer, PrimaryKey). 74 74 + Column("name", Text, Collate("NOCASE")), 75 75 + expectedSql: "CREATE TABLE users (id INTEGER PRIMARY KEY, name TEXT COLLATE NOCASE)", 76 76 + }, 77 77 + { 78 78 + name: "Table with composite primary key", 79 79 + stmt: CreateTable("user_roles"). 80 80 + Column("user_id", Integer). 81 81 + Column("role_id", Integer). 82 82 + PrimaryKey("user_id", "role_id"), 83 83 + expectedSql: "CREATE TABLE user_roles (user_id INTEGER, role_id INTEGER, PRIMARY KEY (user_id, role_id))", 84 84 + }, 85 85 + { 86 86 + name: "Table with table-level unique constraint", 87 87 + stmt: CreateTable("users"). 88 88 + Column("id", Integer, PrimaryKey). 89 89 + Column("email", Text). 90 90 + Column("username", Text). 91 91 + UniqueConstraint("email", "username"), 92 92 + expectedSql: "CREATE TABLE users (id INTEGER PRIMARY KEY, email TEXT, username TEXT, UNIQUE (email, username))", 93 93 + }, 94 94 + { 95 95 + name: "Table with table-level check constraint", 96 96 + stmt: CreateTable("users"). 97 97 + Column("id", Integer, PrimaryKey). 98 98 + Column("age", Integer). 99 99 + CheckConstraint("age >= 0 AND age <= 150"), 100 100 + expectedSql: "CREATE TABLE users (id INTEGER PRIMARY KEY, age INTEGER, CHECK (age >= 0 AND age <= 150))", 101 101 + }, 102 102 + { 103 103 + name: "Table with foreign key", 104 104 + stmt: CreateTable("posts"). 105 105 + Column("id", Integer, PrimaryKey). 106 106 + Column("user_id", Integer, NotNull). 107 107 + ForeignKey("user_id", "users", "id"), 108 108 + expectedSql: "CREATE TABLE posts (id INTEGER PRIMARY KEY, user_id INTEGER NOT NULL, FOREIGN KEY (user_id) REFERENCES users(id))", 109 109 + }, 110 110 + { 111 111 + name: "Table WITHOUT ROWID", 112 112 + stmt: CreateTable("cache"). 113 113 + Column("key", Text, PrimaryKey). 114 114 + Column("value", Blob). 115 115 + WithoutRowid(), 116 116 + expectedSql: "CREATE TABLE cache (key TEXT PRIMARY KEY, value BLOB) WITHOUT ROWID", 117 117 + }, 118 118 + { 119 119 + name: "Table STRICT", 120 120 + stmt: CreateTable("users"). 121 121 + Column("id", Integer, PrimaryKey). 122 122 + Column("name", Text). 123 123 + Strict(), 124 124 + expectedSql: "CREATE TABLE users (id INTEGER PRIMARY KEY, name TEXT) STRICT", 125 125 + }, 126 126 + { 127 127 + name: "Table STRICT WITHOUT ROWID", 128 128 + stmt: CreateTable("cache"). 129 129 + Column("key", Text, PrimaryKey). 130 130 + Column("value", Blob). 131 131 + Strict(). 132 132 + WithoutRowid(), 133 133 + expectedSql: "CREATE TABLE cache (key TEXT PRIMARY KEY, value BLOB) STRICT WITHOUT ROWID", 134 134 + }, 135 135 + { 136 136 + name: "All data types", 137 137 + stmt: CreateTable("types_test"). 138 138 + Column("col_int", Integer). 139 139 + Column("col_text", Text). 140 140 + Column("col_real", Real). 141 141 + Column("col_blob", Blob). 142 142 + Column("col_numeric", Numeric), 143 143 + expectedSql: "CREATE TABLE types_test (col_int INTEGER, col_text TEXT, col_real REAL, col_blob BLOB, col_numeric NUMERIC)", 144 144 + }, 145 145 + { 146 146 + name: "Multiple constraints on column", 147 147 + stmt: CreateTable("users"). 148 148 + Column("id", Integer, PrimaryKey, AutoIncrement). 149 149 + Column("email", Text, NotNull, Unique), 150 150 + expectedSql: "CREATE TABLE users (id INTEGER PRIMARY KEY AUTOINCREMENT, email TEXT NOT NULL UNIQUE)", 151 151 + }, 152 152 + { 153 153 + name: "Complex table", 154 154 + stmt: CreateTable("users"). 155 155 + IfNotExists(). 156 156 + Column("id", Integer, PrimaryKey, AutoIncrement). 157 157 + Column("email", Text, NotNull). 158 158 + Column("username", Text, NotNull). 159 159 + Column("age", Integer, Check("age >= 18")). 160 160 + Column("created_at", Text, Default("CURRENT_TIMESTAMP")). 161 161 + UniqueConstraint("email", "username"). 162 162 + CheckConstraint("age < 150"), 163 163 + expectedSql: "CREATE TABLE IF NOT EXISTS users (id INTEGER PRIMARY KEY AUTOINCREMENT, email TEXT NOT NULL, username TEXT NOT NULL, age INTEGER CHECK (age >= 18), created_at TEXT DEFAULT CURRENT_TIMESTAMP, UNIQUE (email, username), CHECK (age < 150))", 164 164 + }, 165 165 + } 166 166 + 167 167 + for _, test := range tests { 168 168 + t.Run(test.name, func(t *testing.T) { 169 169 + sql, args := test.stmt.MustCompile() 170 170 + 171 171 + if sql != test.expectedSql { 172 172 + t.Errorf("Expected SQL:\n%s\nGot:\n%s", test.expectedSql, sql) 173 173 + } 174 174 + 175 175 + if len(args) != 0 { 176 176 + t.Errorf("Expected 0 args, got %d args", len(args)) 177 177 + } 178 178 + }) 179 179 + } 180 180 + } 181 181 + 182 182 + func TestCreateTableCompileFail(t *testing.T) { 183 183 + tests := []struct { 184 184 + name string 185 185 + stmt Compiler 186 186 + expectedError string 187 187 + }{ 188 188 + { 189 189 + name: "No table name", 190 190 + stmt: CreateTable(""), 191 191 + expectedError: "table name is required", 192 192 + }, 193 193 + { 194 194 + name: "No columns", 195 195 + stmt: CreateTable("users"), 196 196 + expectedError: "at least one column is required", 197 197 + }, 198 198 + } 199 199 + 200 200 + for _, test := range tests { 201 201 + t.Run(test.name, func(t *testing.T) { 202 202 + _, _, err := test.stmt.Compile() 203 203 + if err == nil { 204 204 + t.Error("Expected error, got nil") 205 205 + } 206 206 + if err.Error() != test.expectedError { 207 207 + t.Errorf("Expected error '%s', got '%s'", test.expectedError, err.Error()) 208 208 + } 209 209 + }) 210 210 + } 211 211 + } 212 212 + 213 213 + func TestCreateTableIntegration(t *testing.T) { 214 214 + tests := []struct { 215 215 + name string 216 216 + createStmt Execer 217 217 + insertStmt Execer 218 218 + selectStmt Querier 219 219 + verify func(t *testing.T, db *sql.DB) 220 220 + }{ 221 221 + { 222 222 + name: "Create simple table and insert", 223 223 + createStmt: CreateTable("test_users"). 224 224 + Column("id", Integer, PrimaryKey). 225 225 + Column("name", Text), 226 226 + insertStmt: Insert().Into("test_users").Value("id", 1).Value("name", "Alice"), 227 227 + selectStmt: Select("id", "name").From("test_users"), 228 228 + verify: func(t *testing.T, db *sql.DB) { 229 229 + var count int 230 230 + err := db.QueryRow("SELECT COUNT(*) FROM test_users").Scan(&count) 231 231 + if err != nil { 232 232 + t.Fatalf("Failed to count rows: %v", err) 233 233 + } 234 234 + if count != 1 { 235 235 + t.Errorf("Expected 1 row, got %d", count) 236 236 + } 237 237 + }, 238 238 + }, 239 239 + { 240 240 + name: "Create table with IF NOT EXISTS", 241 241 + createStmt: CreateTable("test_users2"). 242 242 + IfNotExists(). 243 243 + Column("id", Integer, PrimaryKey), 244 244 + verify: func(t *testing.T, db *sql.DB) { 245 245 + _, err := CreateTable("test_users2"). 246 246 + IfNotExists(). 247 247 + Column("id", Integer, PrimaryKey). 248 248 + Exec(db) 249 249 + if err != nil { 250 250 + t.Errorf("Second create with IF NOT EXISTS should not fail: %v", err) 251 251 + } 252 252 + }, 253 253 + }, 254 254 + { 255 255 + name: "Create table with autoincrement", 256 256 + createStmt: CreateTable("test_users3"). 257 257 + Column("id", Integer, PrimaryKey, AutoIncrement). 258 258 + Column("name", Text), 259 259 + insertStmt: Insert().Into("test_users3").Value("name", "Bob"), 260 260 + verify: func(t *testing.T, db *sql.DB) { 261 261 + var id int 262 262 + var name string 263 263 + err := db.QueryRow("SELECT id, name FROM test_users3").Scan(&id, &name) 264 264 + if err != nil { 265 265 + t.Fatalf("Failed to query: %v", err) 266 266 + } 267 267 + if id != 1 { 268 268 + t.Errorf("Expected auto-incremented id=1, got %d", id) 269 269 + } 270 270 + if name != "Bob" { 271 271 + t.Errorf("Expected name=Bob, got %s", name) 272 272 + } 273 273 + }, 274 274 + }, 275 275 + { 276 276 + name: "Create table with default value", 277 277 + createStmt: CreateTable("test_users4"). 278 278 + Column("id", Integer, PrimaryKey). 279 279 + Column("active", Integer, Default(1)), 280 280 + insertStmt: Insert().Into("test_users4").Value("id", 1), 281 281 + verify: func(t *testing.T, db *sql.DB) { 282 282 + var active int 283 283 + err := db.QueryRow("SELECT active FROM test_users4 WHERE id = 1").Scan(&active) 284 284 + if err != nil { 285 285 + t.Fatalf("Failed to query: %v", err) 286 286 + } 287 287 + if active != 1 { 288 288 + t.Errorf("Expected default active=1, got %d", active) 289 289 + } 290 290 + }, 291 291 + }, 292 292 + { 293 293 + name: "Create table with unique constraint", 294 294 + createStmt: CreateTable("test_users5"). 295 295 + Column("id", Integer, PrimaryKey). 296 296 + Column("email", Text, Unique), 297 297 + verify: func(t *testing.T, db *sql.DB) { 298 298 + _, err := Insert().Into("test_users5"). 299 299 + Value("id", 1). 300 300 + Value("email", "test@example.com"). 301 301 + Exec(db) 302 302 + if err != nil { 303 303 + t.Fatalf("First insert should succeed: %v", err) 304 304 + } 305 305 + 306 306 + _, err = Insert().Into("test_users5"). 307 307 + Value("id", 2). 308 308 + Value("email", "test@example.com"). 309 309 + Exec(db) 310 310 + if err == nil { 311 311 + t.Error("Expected unique constraint violation, got nil") 312 312 + } 313 313 + }, 314 314 + }, 315 315 + } 316 316 + 317 317 + for _, test := range tests { 318 318 + t.Run(test.name, func(t *testing.T) { 319 319 + db := setupTestDB(t) 320 320 + defer db.Close() 321 321 + 322 322 + _, err := test.createStmt.Exec(db) 323 323 + if err != nil { 324 324 + t.Fatalf("Failed to create table: %v", err) 325 325 + } 326 326 + 327 327 + if test.insertStmt != nil { 328 328 + _, err = test.insertStmt.Exec(db) 329 329 + if err != nil { 330 330 + t.Fatalf("Failed to insert: %v", err) 331 331 + } 332 332 + } 333 333 + 334 334 + if test.verify != nil { 335 335 + test.verify(t, db) 336 336 + } 337 337 + }) 338 338 + } 339 339 + }