quietlight/skraakCLI - Change IFLKNMMP2NMJG46W3MKRLCUSPAW73N7QSDXQLJBAWPYNVEQP6KXQC

ck 1

Created by quietlight 2 days ago

IFLKNMMP2NMJG46W3MKRLCUSPAW73N7QSDXQLJBAWPYNVEQP6KXQC

Dependencies

In channels

main

Change contents

Insertion in tools/sql.go at line 16 [3.259371]

[3.259544]

// Deprecated: use Input.DBPath instead. Will be removed after all callers are migrated.

Replacement in tools/sql.go at line 20 [3.259371]

B:BD[3.259621] → [3.259621:259666]

// Called from main.go during initialization

[3.259621]

[3.259666]

// Deprecated: use Input.DBPath instead. Will be removed after all callers are migrated.

Insertion in tools/sql.go at line 23 [3.259371]

[3.259711]

}
// resolveDBPath returns the DBPath from the input if set, otherwise falls back
// to the package-level dbPath. This supports the incremental migration from
// the global variable to explicit input fields.
func resolveDBPath(inputPath string) string {
	if inputPath != "" {
		return inputPath
	}
	return dbPath

Insertion in tools/sql.go at line 37 [3.259371]
[3.259817]
[3.259817]
```
	DBPath     string `json:"db_path"`
```

Replacement in tools/sql.go at line 89 [3.259371]

B:BD[2.7834] → [2.7834:7895]

	err := db.WithReadDB(dbPath, func(database *sql.DB) error {

[2.7834]

[2.7895]

	err := db.WithReadDB(resolveDBPath(input.DBPath), func(database *sql.DB) error {

Insertion in tools/pattern.go at line 14 [3.280780]
[3.280992]
[3.280992]
```
	DBPath        string  `json:"db_path"`
```

Replacement in tools/pattern.go at line 102 [3.280780]

B:BD[3.282455] → [2.8793:8905]

	err := db.WithWriteTx(ctx, dbPath, "create_or_update_pattern", func(database *sql.DB, tx *db.LoggedTx) error {

[3.282455]

[2.8905]

	err := db.WithWriteTx(ctx, resolveDBPath(input.DBPath), "create_or_update_pattern", func(database *sql.DB, tx *db.LoggedTx) error {

Deletion in tools/pattern.go at line 144 [3.280780]
∅:D[2.10551] → [3.285160:285163]
B:BD[3.285160] → [3.285160:285163]
B:BD[3.285163] → [2.10552:10706]
∅:D[2.10706] → [3.285985:286010]
B:BD[3.285985] → [3.285985:286010]
B:BD[3.286010] → [2.10707:10734]
∅:D[2.10734] → [3.286036:286185]
B:BD[3.286036] → [3.286036:286185]
B:BD[3.286185] → [2.10735:10759]
∅:D[4.7982] → [3.286209:286252]
∅:D[2.10759] → [3.286209:286252]
B:BD[3.286209] → [3.286209:286252]
B:BD[3.286252] → [2.10760:10816]
∅:D[2.10816] → [3.286316:286333]
B:BD[3.286316] → [3.286316:286333]
B:BD[3.286333] → [2.10817:10873]
∅:D[4.8047] → [3.286397:286414]
∅:D[2.10873] → [3.286397:286414]
B:BD[3.286397] → [3.286397:286414]
B:BD[3.286414] → [2.10874:10969]
∅:D[4.8151] → [3.286517:286520]
∅:D[2.10969] → [3.286517:286520]
B:BD[3.286517] → [3.286517:286520]
B:BD[3.286520] → [2.10970:10982]
```
}
// verifyPatternExistsAndActive checks that a pattern exists and is active.
func verifyPatternExistsAndActive(database *sql.DB, patternID string) error {
	var exists, active bool
	err := database.QueryRow(
		"SELECT EXISTS(SELECT 1 FROM cyclic_recording_pattern WHERE id = ?), COALESCE((SELECT active FROM cyclic_recording_pattern WHERE id = ?), false)",
		patternID, patternID,
	).Scan(&exists, &active)
	if err != nil {
		return fmt.Errorf("failed to query pattern: %w", err)
	}
	if !exists {
		return fmt.Errorf("pattern not found: %s", patternID)
	}
	if !active {
		return fmt.Errorf("pattern '%s' is not active (cannot update inactive patterns)", patternID)
	}
	return nil
```

Replacement in tools/pattern.go at line 178 [3.280780]

B:BD[2.11432] → [2.11432:11620]

	err := db.WithWriteTx(ctx, dbPath, "create_or_update_pattern", func(database *sql.DB, tx *db.LoggedTx) error {
		if err := verifyPatternExistsAndActive(database, *input.ID); err != nil {

[2.11432]

[2.11620]

	err := db.WithWriteTx(ctx, resolveDBPath(input.DBPath), "create_or_update_pattern", func(database *sql.DB, tx *db.LoggedTx) error {
		if err := db.PatternExistsAndActive(database, *input.ID); err != nil {

Insertion in tools/location.go at line 14 [3.288291]
[3.288490]
[3.288490]
```
	DBPath      string   `json:"db_path"`
```

Replacement in tools/location.go at line 113 [3.288291]

B:BD[3.291309] → [2.12478:12673]

	err := db.WithWriteTx(ctx, dbPath, "create_or_update_location", func(database *sql.DB, tx *db.LoggedTx) error {
		if err := verifyDatasetExistsAndActive(ctx, tx, *input.DatasetID); err != nil {

[3.291309]

[2.12673]

	err := db.WithWriteTx(ctx, resolveDBPath(input.DBPath), "create_or_update_location", func(database *sql.DB, tx *db.LoggedTx) error {
		if _, err := db.DatasetExistsAndActive(tx, *input.DatasetID); err != nil {

Deletion in tools/location.go at line 175 [3.288291]

B:BD[3.295057] → [5.7930:8006]

B:BD[5.8006] → [2.14339:14497]

∅:D[2.14497] → [5.8654:8657]

B:BD[5.8654] → [5.8654:8657]

// verifyDatasetExistsAndActive checks that a dataset exists and is active.
func verifyDatasetExistsAndActive(ctx context.Context, q db.Querier, datasetID string) error {
	_, err := db.DatasetExistsAndActive(q, datasetID)
	return err
}

Replacement in tools/location.go at line 193 [3.288291]

B:BD[3.295554] → [2.14498:14689]

	err := db.WithWriteTx(ctx, dbPath, "create_or_update_location", func(database *sql.DB, tx *db.LoggedTx) error {
		if err := verifyLocationExistsAndActive(database, locationID); err != nil {

[3.295554]

[2.14689]

	err := db.WithWriteTx(ctx, resolveDBPath(input.DBPath), "create_or_update_location", func(database *sql.DB, tx *db.LoggedTx) error {
		if err := db.LocationExistsAndActive(database, locationID); err != nil {

Replacement in tools/location.go at line 200 [3.288291]

B:BD[2.14814] → [2.14814:14903]

			if err := verifyDatasetExistsAndActive(ctx, database, *input.DatasetID); err != nil {

[2.14814]

[2.14903]

			if _, err := db.DatasetExistsAndActive(database, *input.DatasetID); err != nil {

Deletion in tools/location.go at line 226 [3.288291]

∅:D[2.15599] → [5.9906:10591]

B:BD[5.9906] → [5.9906:10591]

∅:D[5.10591] → [3.297075:297078]

B:BD[3.297075] → [3.297075:297078]

B:BD[3.297078] → [5.10592:10604]

}
// verifyLocationExistsAndActive checks that a location exists and is active.
func verifyLocationExistsAndActive(queryer interface {
	QueryRow(string, ...any) *sql.Row
}, locationID string) error {
	var exists, active bool
	err := queryer.QueryRow(
		"SELECT EXISTS(SELECT 1 FROM location WHERE id = ?), COALESCE((SELECT active FROM location WHERE id = ?), false)",
		locationID, locationID,
	).Scan(&exists, &active)
	if err != nil {
		return fmt.Errorf("failed to query location: %w", err)
	}
	if !exists {
		return fmt.Errorf("location not found: %s", locationID)
	}
	if !active {
		return fmt.Errorf("location '%s' is not active (cannot update inactive locations)", locationID)
	}
	return nil

Insertion in tools/import_unstructured.go at line 19 [3.307677]
[3.307947]
[3.307947]
```
	DBPath     string `json:"db_path"`
```

Replacement in tools/import_unstructured.go at line 67 [3.307677]

B:BD[3.309770] → [2.15659:15766]

	err := db.WithWriteTx(ctx, dbPath, "import_unstructured", func(database *sql.DB, tx *db.LoggedTx) error {

[3.309770]

[2.15766]

	err := db.WithWriteTx(ctx, resolveDBPath(input.DBPath), "import_unstructured", func(database *sql.DB, tx *db.LoggedTx) error {

Replacement in tools/import_unstructured.go at line 191 [3.307677]

B:BD[3.313584] → [2.16354:16415]

	return db.WithReadDB(dbPath, func(database *sql.DB) error {

[3.313584]

[2.16415]

	return db.WithReadDB(resolveDBPath(input.DBPath), func(database *sql.DB) error {

Insertion in tools/import_segments.go at line 18 [3.318166]
[3.318415]
[3.318415]
```
	DBPath          string `json:"db_path"`
```
Replacement in tools/import_segments.go at line 174 [3.318166]
∅:D[6.14627] → [3.321942:321987]
B:BD[3.321942] → [3.321942:321987]
```
	database, err := db.OpenWriteableDB(dbPath)
```
[6.14627]
[3.321987]
```
	database, err := db.OpenWriteableDB(resolveDBPath(input.DBPath))
```
Insertion in tools/import_files.go at line 16 [3.345251]
[3.345479]
[3.345479]
```
	DBPath     string `json:"db_path"`
```

Replacement in tools/import_files.go at line 57 [3.345251]

B:BD[3.346978] → [3.346978:347038]

	if err := validateImportInput(input, dbPath); err != nil {

[3.346978]

[3.347038]

	if err := validateImportInput(input, resolveDBPath(input.DBPath)); err != nil {

Replacement in tools/import_files.go at line 62 [3.345251]
B:BD[3.347118] → [3.347118:347163]
```
	database, err := db.OpenWriteableDB(dbPath)
```
[3.347118]
[3.347163]
```
	database, err := db.OpenWriteableDB(resolveDBPath(input.DBPath))
```
Insertion in tools/import_file.go at line 18 [3.351174]
[3.351411]
[3.351411]
```
	DBPath     string `json:"db_path"`
```

Replacement in tools/import_file.go at line 55 [3.351174]

B:BD[3.352635] → [3.352635:352741]

	if err := validateHierarchyIDs(input.DatasetID, input.LocationID, input.ClusterID, dbPath); err != nil {

[3.352635]

[3.352741]

	if err := validateHierarchyIDs(input.DatasetID, input.LocationID, input.ClusterID, resolveDBPath(input.DBPath)); err != nil {

Replacement in tools/import_file.go at line 60 [3.351174]
B:BD[3.352893] → [3.352893:352938]
```
	database, err := db.OpenWriteableDB(dbPath)
```
[3.352893]
[3.352938]
```
	database, err := db.OpenWriteableDB(resolveDBPath(input.DBPath))
```
Insertion in tools/export.go at line 17 [3.357951]
[3.358181]
[3.358181]
```
	DBPath    string `json:"db_path"`
```

Replacement in tools/export.go at line 85 [3.357951]

B:BD[3.361016] → [3.361016:361060]

	sourceDB, err := db.OpenReadOnlyDB(dbPath)

[3.361016]

[3.361060]

	sourceDB, err := db.OpenReadOnlyDB(resolveDBPath(input.DBPath))

Replacement in tools/export.go at line 90 [3.357951]

B:BD[3.361152] → [5.10879:10942]

	datasetName, err := verifyExportDataset(ctx, sourceDB, input)

[3.361152]

[3.361392]

	datasetName, err := db.ValidateDatasetTypeForExport(sourceDB, input.DatasetID)

Replacement in tools/export.go at line 132 [3.357951]

B:BD[3.363547] → [5.11333:11422]

	if err := copyDataToOutput(ctx, outputDB, orderedTables, input.DatasetID); err != nil {

[3.363547]

[5.11422]

	if err := copyDataToOutput(ctx, outputDB, orderedTables, input.DatasetID, resolveDBPath(input.DBPath)); err != nil {

Deletion in tools/export.go at line 175 [3.357951]

B:BD[5.11869] → [5.11869:12520]

// verifyExportDataset checks the dataset exists, is active, and is structured.
func verifyExportDataset(ctx context.Context, sourceDB *sql.DB, input ExportDatasetInput) (string, error) {
	var datasetName, datasetType string
	err := sourceDB.QueryRowContext(ctx,
		"SELECT name, type FROM dataset WHERE id = ? AND active = true",
		input.DatasetID,
	).Scan(&datasetName, &datasetType)
	if err != nil {
		return "", fmt.Errorf("dataset not found: %s", input.DatasetID)
	}
	if datasetType != "structured" {
		return "", fmt.Errorf("cannot export dataset of type '%s': only structured datasets are supported", datasetType)
	}
	return datasetName, nil
}

Replacement in tools/export.go at line 210 [3.357951]

B:BD[5.13759] → [5.13759:13957]

func copyDataToOutput(ctx context.Context, outputDB *sql.DB, tables []TableRelationship, datasetID string) error {
	_, err := outputDB.ExecContext(ctx, fmt.Sprintf("ATTACH '%s' AS source", dbPath))

[5.13759]

[5.13957]

func copyDataToOutput(ctx context.Context, outputDB *sql.DB, tables []TableRelationship, datasetID string, sourceDBPath string) error {
	_, err := outputDB.ExecContext(ctx, fmt.Sprintf("ATTACH '%s' AS source", sourceDBPath))

Insertion in tools/dataset.go at line 14 [3.370650]
[3.370846]
[3.370846]
```
	DBPath      string  `json:"db_path"`
```

Replacement in tools/dataset.go at line 60 [3.370650]

B:BD[3.372650] → [2.17588:17699]

	err = db.WithWriteTx(ctx, dbPath, "create_or_update_dataset", func(database *sql.DB, tx *db.LoggedTx) error {

[3.372650]

[2.17699]

	err = db.WithWriteTx(ctx, resolveDBPath(input.DBPath), "create_or_update_dataset", func(database *sql.DB, tx *db.LoggedTx) error {

Replacement in tools/dataset.go at line 227 [3.370650]

B:BD[7.6540] → [2.18386:18498]

	err := db.WithWriteTx(ctx, dbPath, "create_or_update_dataset", func(database *sql.DB, tx *db.LoggedTx) error {

[7.6540]

[2.18498]

	err := db.WithWriteTx(ctx, resolveDBPath(input.DBPath), "create_or_update_dataset", func(database *sql.DB, tx *db.LoggedTx) error {

Replacement in tools/dataset.go at line 229 [3.370650]

B:BD[2.18549] → [2.18549:18616]

		if err := verifyDatasetActive(database, datasetID); err != nil {

[2.18549]

[2.18616]

		if _, err := db.DatasetExistsAndActive(database, datasetID); err != nil {

Deletion in tools/dataset.go at line 259 [3.370650]

B:BD[7.6994] → [7.6994:7613]

∅:D[7.7613] → [3.378688:378690]

B:BD[3.378688] → [3.378688:378690]


// verifyDatasetActive checks that a dataset exists and is active.
func verifyDatasetActive(database *sql.DB, datasetID string) error {
	var exists, active bool
	err := database.QueryRow("SELECT EXISTS(SELECT 1 FROM dataset WHERE id = ?), COALESCE((SELECT active FROM dataset WHERE id = ?), false)", datasetID, datasetID).Scan(&exists, &active)
	if err != nil {
		return fmt.Errorf("failed to query dataset: %w", err)
	}
	if !exists {
		return fmt.Errorf("dataset not found: %s", datasetID)
	}
	if !active {
		return fmt.Errorf("dataset '%s' is not active (cannot update inactive datasets)", datasetID)
	}
	return nil
}

Insertion in tools/cluster.go at line 14 [3.378727]
[3.378923]
[3.378923]
```
	DBPath                   string  `json:"db_path"`
```

Replacement in tools/cluster.go at line 86 [3.378727]

B:BD[3.381890] → [2.19444:19556]

	err := db.WithWriteTx(ctx, dbPath, "create_or_update_cluster", func(database *sql.DB, tx *db.LoggedTx) error {

[3.381890]

[2.19556]

	err := db.WithWriteTx(ctx, resolveDBPath(input.DBPath), "create_or_update_cluster", func(database *sql.DB, tx *db.LoggedTx) error {

Replacement in tools/cluster.go at line 124 [3.378727]

B:BD[8.6839] → [8.6839:6927]

		if err := verifyPatternExists(ctx, tx, *input.CyclicRecordingPatternID); err != nil {

[8.6839]

[8.6927]

		if err := db.PatternExistsAndActive(tx, *input.CyclicRecordingPatternID); err != nil {

Deletion in tools/cluster.go at line 183 [3.378727]

B:BD[9.3787] → [9.3787:3790]

B:BD[9.5735] → [9.5735:6473]

}
// verifyPatternExists verifies a cyclic recording pattern exists and is active
func verifyPatternExists(ctx context.Context, tx *db.LoggedTx, patternID string) error {
	var exists, active bool
	err := tx.QueryRowContext(ctx,
		"SELECT EXISTS(SELECT 1 FROM cyclic_recording_pattern WHERE id = ?), COALESCE((SELECT active FROM cyclic_recording_pattern WHERE id = ?), false)",
		patternID, patternID,
	).Scan(&exists, &active)
	if err != nil {
		return fmt.Errorf("failed to verify cyclic recording pattern: %w", err)
	}
	if !exists {
		return fmt.Errorf("cyclic recording pattern with ID '%s' does not exist", patternID)
	}
	if !active {
		return fmt.Errorf("cyclic recording pattern with ID '%s' is not active", patternID)
	}
	return nil

Replacement in tools/cluster.go at line 211 [3.378727]
∅:D[10.11184] → [3.388791:388816]
B:BD[3.388791] → [3.388791:388816]
B:BD[3.388816] → [10.11185:11212]
∅:D[10.11212] → [3.388842:389024]
B:BD[3.388842] → [3.388842:389024]
B:BD[3.389024] → [10.11213:11269]
∅:D[10.11269] → [3.389088:389105]
B:BD[3.389088] → [3.389088:389105]
B:BD[3.389105] → [10.11270:11326]
∅:D[10.11326] → [3.389169:389186]
B:BD[3.389169] → [3.389169:389186]
B:BD[3.389186] → [10.11327:11422]
∅:D[10.11422] → [3.389289:389292]
B:BD[3.389289] → [3.389289:389292]
B:BD[3.389292] → [10.11423:11435]
```
	var exists, active bool
	err := database.QueryRow(
		"SELECT EXISTS(SELECT 1 FROM cluster WHERE id = ?), COALESCE((SELECT active FROM cluster WHERE id = ?), false)",
		clusterID, clusterID,
	).Scan(&exists, &active)
	if err != nil {
		return fmt.Errorf("failed to query cluster: %w", err)
	}
	if !exists {
		return fmt.Errorf("cluster not found: %s", clusterID)
	}
	if !active {
		return fmt.Errorf("cluster '%s' is not active (cannot update inactive clusters)", clusterID)
	}
	return nil
```
[10.11184]
[4.8486]
```
	return db.ClusterExistsAndActive(database, clusterID)
```

Replacement in tools/cluster.go at line 223 [3.378727]

B:BD[4.8812] → [4.8812:8861]

	return validateCyclicPattern(database, trimmed)

[4.8812]

[10.11435]

	return db.PatternExistsAndActive(database, trimmed)

Deletion in tools/cluster.go at line 226 [3.378727]

B:BD[3.389293] → [10.11438:11937]

∅:D[10.11937] → [3.390148:390151]

B:BD[3.390148] → [3.390148:390151]

B:BD[3.390151] → [10.11938:12137]

∅:D[10.12137] → [3.390151:390152]

B:BD[3.390151] → [3.390151:390152]

// validateCyclicPattern checks that a cyclic recording pattern exists and is active.
func validateCyclicPattern(database *sql.DB, patternID string) error {
	var exists, active bool
	err := database.QueryRow(
		"SELECT EXISTS(SELECT 1 FROM cyclic_recording_pattern WHERE id = ?), COALESCE((SELECT active FROM cyclic_recording_pattern WHERE id = ?), false)",
		patternID, patternID,
	).Scan(&exists, &active)
	if err != nil {
		return fmt.Errorf("failed to verify cyclic recording pattern: %w", err)
	}
	if !exists {
		return fmt.Errorf("cyclic recording pattern not found: %s", patternID)
	}
	if !active {
		return fmt.Errorf("cyclic recording pattern '%s' is not active", patternID)
	}
	return nil
}

Replacement in tools/cluster.go at line 297 [3.378727]

B:BD[10.12965] → [2.20561:20672]

	err = db.WithWriteTx(ctx, dbPath, "create_or_update_cluster", func(database *sql.DB, tx *db.LoggedTx) error {

[10.12965]

[2.20672]

	err = db.WithWriteTx(ctx, resolveDBPath(input.DBPath), "create_or_update_cluster", func(database *sql.DB, tx *db.LoggedTx) error {

Insertion in tools/bulk_file_import.go at line 20 [3.622571]
[3.622848]
[3.622848]
```
	DBPath      string `json:"db_path"`
```

Replacement in tools/bulk_file_import.go at line 132 [3.622571]

B:BD[3.626420] → [4.14477:14560]

	if err := bulkValidateLocations(logger, locations, input.DatasetID); err != nil {

[3.626420]

[4.14560]

	if err := bulkValidateLocations(logger, locations, input.DatasetID, resolveDBPath(input.DBPath)); err != nil {

Replacement in tools/bulk_file_import.go at line 140 [3.622571]
B:BD[3.627414] → [3.627414:627459]
```
	database, err := db.OpenWriteableDB(dbPath)
```
[3.627333]
[3.627459]
```
	database, err := db.OpenWriteableDB(resolveDBPath(input.DBPath))
```
Replacement in tools/bulk_file_import.go at line 201 [3.622571]
B:BD[3.632109] → [3.632109:632153]
```
	database, err := db.OpenReadOnlyDB(dbPath)
```
[3.632109]
[3.632153]
```
	database, err := db.OpenReadOnlyDB(resolveDBPath(input.DBPath))
```

Replacement in tools/bulk_file_import.go at line 237 [3.622571]

B:BD[4.15871] → [4.15871:15978]

func bulkValidateLocations(logger *progressLogger, locations []bulkLocationData, datasetID string) error {

[4.15871]

[4.15978]

func bulkValidateLocations(logger *progressLogger, locations []bulkLocationData, datasetID string, dbPath string) error {

Insertion in db/validation.go at line 121 [11.1]

[2.28071]

}
// ClusterExistsAndActive checks that a cluster exists and is active.
func ClusterExistsAndActive(q Querier, clusterID string) error {
	var exists, active bool
	err := q.QueryRow(
		"SELECT EXISTS(SELECT 1 FROM cluster WHERE id = ?), COALESCE((SELECT active FROM cluster WHERE id = ?), false)",
		clusterID, clusterID,
	).Scan(&exists, &active)
	if err != nil {
		return fmt.Errorf("failed to verify cluster: %w", err)
	}
	if !exists {
		return fmt.Errorf("cluster not found: %s", clusterID)
	}
	if !active {
		return fmt.Errorf("cluster '%s' is not active (cannot update inactive clusters)", clusterID)
	}
	return nil

Insertion in db/validation.go at line 142 [11.1]

[2.28074]

// PatternExistsAndActive checks that a cyclic recording pattern exists and is active.
func PatternExistsAndActive(q Querier, patternID string) error {
	var exists, active bool
	err := q.QueryRow(
		"SELECT EXISTS(SELECT 1 FROM cyclic_recording_pattern WHERE id = ?), COALESCE((SELECT active FROM cyclic_recording_pattern WHERE id = ?), false)",
		patternID, patternID,
	).Scan(&exists, &active)
	if err != nil {
		return fmt.Errorf("failed to verify cyclic recording pattern: %w", err)
	}
	if !exists {
		return fmt.Errorf("cyclic recording pattern with ID '%s' does not exist", patternID)
	}
	if !active {
		return fmt.Errorf("cyclic recording pattern with ID '%s' is not active", patternID)
	}
	return nil
}
// LocationExistsAndActive checks that a location exists and is active.
func LocationExistsAndActive(q Querier, locationID string) error {
	var exists, active bool
	err := q.QueryRow(
		"SELECT EXISTS(SELECT 1 FROM location WHERE id = ?), COALESCE((SELECT active FROM location WHERE id = ?), false)",
		locationID, locationID,
	).Scan(&exists, &active)
	if err != nil {
		return fmt.Errorf("failed to verify location: %w", err)
	}
	if !exists {
		return fmt.Errorf("location not found: %s", locationID)
	}
	if !active {
		return fmt.Errorf("location '%s' is not active (cannot update inactive locations)", locationID)
	}
	return nil
}
// ValidateDatasetTypeForExport checks that a dataset exists, is active, and is 'structured'.
// Returns the dataset name if valid.
func ValidateDatasetTypeForExport(q Querier, datasetID string) (string, error) {
	name, err := DatasetExistsAndActive(q, datasetID)
	if err != nil {
		return "", err
	}
	datasetType, exists, err := GetDatasetType(q, datasetID)
	if err != nil {
		return "", fmt.Errorf("failed to query dataset type: %w", err)
	}
	if !exists {
		return "", fmt.Errorf("dataset not found: %s", datasetID)
	}
	if datasetType != "structured" {
		return "", fmt.Errorf("cannot export dataset of type '%s': only structured datasets are supported", datasetType)
	}
	return name, nil
}

Replacement in cmd/sql.go at line 65 [3.1041743]
B:BD[3.1043636] → [3.1043636:1043652]
```
		Query: query,
```
[3.1043636]
[3.1043652]
```
		DBPath: *dbPath,
		Query:  query,
```
Insertion in cmd/pattern.go at line 70 [3.1053931]
[3.1055882]
[3.1055882]
```
		DBPath:        *dbPath,
```
Replacement in cmd/pattern.go at line 146 [3.1053931]
B:BD[3.1057901] → [3.1057901:1057911]
```
		ID: id,
```
[3.1057901]
[3.1057911]
```
		DBPath: *dbPath,
		ID:     id,
```
Insertion in cmd/location.go at line 98 [3.1060595]
[3.1063517]
[3.1063517]
```
		DBPath:      *dbPath,
```
Replacement in cmd/location.go at line 192 [3.1060595]
B:BD[3.1065844] → [3.1065844:1065854]
```
		ID: id,
```
[3.1065844]
[3.1065854]
```
		DBPath: *dbPath,
		ID:     id,
```
Insertion in cmd/import.go at line 115 [3.1070018]
[3.1074160]
[3.1074160]
```
		DBPath:      *dbPath,
```
Insertion in cmd/import.go at line 206 [3.1070018]
[3.1077105]
[3.1077105]
```
		DBPath:     *dbPath,
```
Insertion in cmd/import.go at line 293 [3.1070018]
[3.1079870]
[3.1079870]
```
		DBPath:     *dbPath,
```
Insertion in cmd/import.go at line 421 [3.1070018]
[3.1084571]
[3.1084571]
```
		DBPath:     *dbPath,
```
Insertion in cmd/import.go at line 520 [3.1070018]
[3.1088211]
[3.1088211]
```
		DBPath:     *dbPath,
```
Insertion in cmd/export.go at line 94 [3.1088920]
[3.1092056]
[3.1092056]
```
		DBPath:    *dbPath,
```
Insertion in cmd/dataset.go at line 68 [3.1092525]
[3.1094590]
[3.1094590]
```
		DBPath:      *dbPath,
```
Replacement in cmd/dataset.go at line 128 [3.1092525]
B:BD[3.1096388] → [3.1096388:1096398]
```
		ID: id,
```
[3.1096388]
[3.1096398]
```
		DBPath: *dbPath,
		ID:     id,
```
Insertion in cmd/cluster.go at line 89 [3.1098846]
[3.1101627]
[3.1101627]
```
		DBPath:      *dbPath,
```
Replacement in cmd/cluster.go at line 161 [3.1098846]
B:BD[3.1103611] → [3.1103611:1103621]
```
		ID: id,
```
[3.1103611]
[3.1103621]
```
		DBPath: *dbPath,
		ID:     id,
```

ck 1

Dependencies

In channels

Change contents

Insertion in tools/sql.go at line 16 [3.259371]

Replacement in tools/sql.go at line 20 [3.259371]

Insertion in tools/sql.go at line 23 [3.259371]

Insertion in tools/sql.go at line 37 [3.259371]

Replacement in tools/sql.go at line 89 [3.259371]

Insertion in tools/pattern.go at line 14 [3.280780]

Replacement in tools/pattern.go at line 102 [3.280780]

Deletion in tools/pattern.go at line 144 [3.280780]

Replacement in tools/pattern.go at line 178 [3.280780]

Insertion in tools/location.go at line 14 [3.288291]

Replacement in tools/location.go at line 113 [3.288291]

Deletion in tools/location.go at line 175 [3.288291]

Replacement in tools/location.go at line 193 [3.288291]

Replacement in tools/location.go at line 200 [3.288291]

Deletion in tools/location.go at line 226 [3.288291]

Insertion in tools/import_unstructured.go at line 19 [3.307677]

Replacement in tools/import_unstructured.go at line 67 [3.307677]

Replacement in tools/import_unstructured.go at line 191 [3.307677]

Insertion in tools/import_segments.go at line 18 [3.318166]

Replacement in tools/import_segments.go at line 174 [3.318166]

Insertion in tools/import_files.go at line 16 [3.345251]

Replacement in tools/import_files.go at line 57 [3.345251]

Replacement in tools/import_files.go at line 62 [3.345251]

Insertion in tools/import_file.go at line 18 [3.351174]

Replacement in tools/import_file.go at line 55 [3.351174]

Replacement in tools/import_file.go at line 60 [3.351174]

Insertion in tools/export.go at line 17 [3.357951]

Replacement in tools/export.go at line 85 [3.357951]

Replacement in tools/export.go at line 90 [3.357951]

Replacement in tools/export.go at line 132 [3.357951]

Deletion in tools/export.go at line 175 [3.357951]

Replacement in tools/export.go at line 210 [3.357951]

Insertion in tools/dataset.go at line 14 [3.370650]

Replacement in tools/dataset.go at line 60 [3.370650]

Replacement in tools/dataset.go at line 227 [3.370650]

Replacement in tools/dataset.go at line 229 [3.370650]

Deletion in tools/dataset.go at line 259 [3.370650]

Insertion in tools/cluster.go at line 14 [3.378727]

Replacement in tools/cluster.go at line 86 [3.378727]

Replacement in tools/cluster.go at line 124 [3.378727]

Deletion in tools/cluster.go at line 183 [3.378727]

Replacement in tools/cluster.go at line 211 [3.378727]

Replacement in tools/cluster.go at line 223 [3.378727]

Deletion in tools/cluster.go at line 226 [3.378727]

Replacement in tools/cluster.go at line 297 [3.378727]

Insertion in tools/bulk_file_import.go at line 20 [3.622571]

Replacement in tools/bulk_file_import.go at line 132 [3.622571]

Replacement in tools/bulk_file_import.go at line 140 [3.622571]

Replacement in tools/bulk_file_import.go at line 201 [3.622571]

Replacement in tools/bulk_file_import.go at line 237 [3.622571]

Insertion in db/validation.go at line 121 [11.1]

Insertion in db/validation.go at line 142 [11.1]

Replacement in cmd/sql.go at line 65 [3.1041743]

Insertion in cmd/pattern.go at line 70 [3.1053931]

Replacement in cmd/pattern.go at line 146 [3.1053931]

Insertion in cmd/location.go at line 98 [3.1060595]

Replacement in cmd/location.go at line 192 [3.1060595]

Insertion in cmd/import.go at line 115 [3.1070018]

Insertion in cmd/import.go at line 206 [3.1070018]

Insertion in cmd/import.go at line 293 [3.1070018]

Insertion in cmd/import.go at line 421 [3.1070018]

Insertion in cmd/import.go at line 520 [3.1070018]

Insertion in cmd/export.go at line 94 [3.1088920]

Insertion in cmd/dataset.go at line 68 [3.1092525]

Replacement in cmd/dataset.go at line 128 [3.1092525]

Insertion in cmd/cluster.go at line 89 [3.1098846]

Replacement in cmd/cluster.go at line 161 [3.1098846]