gemma: pkg/imports/bn.go comparison

comparison pkg/imports/bn.go @ 4128:14706384a464 request_hist_bns

Cleanup by Sascha L. Teichmann applied.

author	Sascha Wilde <wilde@intevation.de>
date	Thu, 01 Aug 2019 17:27:40 +0200
parents	0cf0008070db
children	980f12d3c766

comparison

equal deleted inserted replaced

-:8c62809ea87e
+:14706384a464
 	}
 	return storeBottlenecks(ctx, fetch, importID, conn, feedback, bn.Tolerance)
 }
+type bnStmts struct {
+	insert           *sql.Stmt
+	findExactMatch   *sql.Stmt
+	findIntersecting *sql.Stmt
+	insertMaterial   *sql.Stmt
+	track            *sql.Stmt
+}
+func (bs *bnStmts) close() {
+	for _, s := range []**sql.Stmt{
+		&bs.insert,
+		&bs.findExactMatch,
+		&bs.findIntersecting,
+		&bs.insertMaterial,
+		&bs.track,
+	} {
+		if *s != nil {
+			(*s).Close()
+			*s = nil
+		}
+	}
+}
+func (bs *bnStmts) prepare(ctx context.Context, conn *sql.Conn) error {
+	for _, x := range []struct {
+		sql  string
+		stmt **sql.Stmt
+	}{
+		{insertBottleneckSQL, &bs.insert},
+		{findExactMatchBottleneckSQL, &bs.findExactMatch},
+		{findIntersectingBottleneckSQL, &bs.findIntersecting},
+		{insertBottleneckMaterialSQL, &bs.insertMaterial},
+		{trackImportDeletionSQL, &bs.track},
+	} {
+		var err error
+		if *x.stmt, err = conn.PrepareContext(ctx, x.sql); err != nil {
+			return err
+		}
+	}
+	return nil
+}
 func storeBottlenecks(
 	ctx context.Context,
 	fetch func() ([]*ifbn.BottleNeckType, error),
 	importID int64,
 	conn *sql.Conn,
 		return nil, err
 	}
 	feedback.Info("Found %d bottlenecks for import", len(bns))
-	var insertStmt, findExactMatchingBNStmt, findIntersectingBNStmt,
+	var bs bnStmts
-		insertMaterialStmt, trackStmt *sql.Stmt
+	defer bs.close()
-	for _, x := range []struct {
+	if err := bs.prepare(ctx, conn); err != nil {
-		sql  string
+		return nil, err
-		stmt **sql.Stmt
-	}{
-		{insertBottleneckSQL, &insertStmt},
-		{findExactMatchBottleneckSQL, &findExactMatchingBNStmt},
-		{findIntersectingBottleneckSQL, &findIntersectingBNStmt},
-		{insertBottleneckMaterialSQL, &insertMaterialStmt},
-		{trackImportDeletionSQL, &trackStmt},
-	} {
-		var err error
-		if *x.stmt, err = conn.PrepareContext(ctx, x.sql); err != nil {
-			return nil, err
-		}
-		defer (*x.stmt).Close()
 	}
 	var nids []string
 	seenOldBnIds := make(map[int64]bool)
 	defer tx.Rollback()
 	for _, bn := range bns {
 		if err := storeBottleneck(
 			tx, ctx, importID, feedback, bn,
-			&nids, &seenOldBnIds, tolerance,
+			&nids, seenOldBnIds, tolerance,
-			insertStmt,
+			&bs,
-			findExactMatchingBNStmt,
+		); err != nil {
-			findIntersectingBNStmt,
-			insertMaterialStmt,
-			trackStmt); err != nil {
 			return nil, err
 		}
 	}
 	if err = tx.Commit(); err != nil {
 		return nil, err
 	ctx context.Context,
 	importID int64,
 	feedback Feedback,
 	bn *ifbn.BottleNeckType,
 	nids *[]string,
-	seenOldBnIds *map[int64]bool,
+	seenOldBnIds map[int64]bool,
 	tolerance float64,
-	insertStmt,
+	bs *bnStmts,
-	findExactMatchingBNStmt, findIntersectingBNStmt,
-	insertMaterialStmt,
-	trackStmt *sql.Stmt,
 ) error {
 	feedback.Info("Processing %s (%s)", bn.OBJNAM, bn.Bottleneck_id)
 	var tfrom, tto pgtype.Timestamptz
 	var uBound pgtype.BoundType
 		}
 	}
 	// Check if an bottleneck identical to the one we would insert already
 	// exists:
-	bns, err := tx.StmtContext(ctx, findExactMatchingBNStmt).QueryContext(
+	var old int64
+	err := tx.StmtContext(ctx, bs.findExactMatch).QueryRowContext(
 		ctx,
 		bn.Bottleneck_id,
 		&validity,
 		bn.Fk_g_fid,
 		bn.OBJNAM,
 		country,
 		revisitingTime,
 		limiting,
 		bn.Date_Info,
 		bn.Source,
-	)
+	).Scan(&old)
-	if err != nil {
+	switch {
+	case err == sql.ErrNoRows:
+		// We dont have a matching old.
+	case err != nil:
 		return err
-	}
+	default:
-	defer bns.Close()
+		// We could check if the materials are also matching -- but per
-	// We could check if the materials are also matching -- but per
+		// specification the Date_Info would hvae to change on that kind of
-	// specification the Date_Info would hvae to change on that kind of
+		// change anyway.  So actualy we ar alreayd checking more in dpth than
-	// change anyway.  So actualy we ar alreayd checking more in dpth than
+		// required.
-	// required.
-	if bns.Next() {
 		feedback.Info("unchanged")
 		return nil
 	}
 	// Additional Information, only of interest when we change something, so
 	feedback.Info("Range: from %s to %s", bn.From_ISRS, bn.To_ISRS)
 	// Check if the new bottleneck intersects with the validity of existing
 	// for the same bottleneck_id we consider this an update and mark the
 	// old data for deletion.
-	bns, err = tx.StmtContext(ctx, findIntersectingBNStmt).QueryContext(
+	bns, err := tx.StmtContext(ctx, bs.findIntersecting).QueryContext(
 		ctx, bn.Bottleneck_id, &validity,
 	)
 	if err != nil {
 		return err
 	}
 		err := bns.Scan(&oldID)
 		if err != nil {
 			return err
 		}
 		oldBnIds = append(oldBnIds, oldID)
+	}
+	if err := bns.Err(); err != nil {
+		return err
 	}
 	switch {
 	case len(oldBnIds) == 1:
 		feedback.Info("Bottelneck '%s' "+
 	for _, oldID := range oldBnIds {
 		// It is possible, that two new bottlenecks intersect with the
 		// same old noe, therefor we have to handle duplicates in
 		// oldBnIds.
-		if !(*seenOldBnIds)[oldID] {
+		if !seenOldBnIds[oldID] {
-			if _, err := tx.StmtContext(ctx, trackStmt).ExecContext(
+			if _, err := tx.StmtContext(ctx, bs.track).ExecContext(
 				ctx, importID, "waterway.bottlenecks", oldID, true,
 			); err != nil {
 				return err
 			}
-			(*seenOldBnIds)[oldID] = true
+			seenOldBnIds[oldID] = true
 		}
 	}
 	var bnIds []int64
 	// Add new BN data:
 	savepoint := Savepoint(ctx, tx, "insert_bottlenck")
 	err = savepoint(func() error {
-		bns, err := tx.StmtContext(ctx, insertStmt).QueryContext(ctx,
+		bns, err := tx.StmtContext(ctx, bs.insert).QueryContext(ctx,
 			bn.Bottleneck_id,
 			&validity,
 			bn.Fk_g_fid,
 			bn.OBJNAM,
 			bn.NOBJNM,
 			)
 			pgBnIds.Set(bnIds)
 			pgMaterials.Set(materials)
 			// Insert riverbed materials
-			if _, err := tx.StmtContext(ctx, insertMaterialStmt).ExecContext(ctx,
+			if _, err := tx.StmtContext(ctx, bs.insertMaterial).ExecContext(ctx,
 				&pgBnIds,
 				&pgMaterials,
 			); err != nil {
 				return err
 		return nil
 	}
 	// Only add new BN data to tracking for staging review.
 	for _, nid := range bnIds {
-		if _, err := tx.StmtContext(ctx, trackStmt).ExecContext(
+		if _, err := tx.StmtContext(ctx, bs.track).ExecContext(
 			ctx, importID, "waterway.bottlenecks", nid, false,
 		); err != nil {
 			return err
 		}
 	}

Mercurial > gemma

comparison pkg/imports/bn.go @ 4128:14706384a464 request_hist_bns