raise HTTPException(status_code=404, detail="Hero not found")
    return hero


@app.delete("/heroes/{hero_id}")
def delete_hero(hero_id: int, session: SessionDep):
    hero = session.get(Hero, hero_id)
    if not hero:
        raise HTTPException(status_code=404, detail="Hero not found")
    session.delete(hero)
    session.commit()

	}
	return nil, BucketRemoteTargetNotFound{Bucket: bucket}
}

// Delete clears targets present for a bucket
func (sys *BucketTargetSys) Delete(bucket string) {
	sys.Lock()
	defer sys.Unlock()
	tgts, ok := sys.targetsMap[bucket]
	if !ok {
		return
	}
	for _, t := range tgts {
		delete(sys.arnRemotesMap, t.Arn)
	}
	delete(sys.targetsMap, bucket)
}

					DeleteReplication:       DeleteReplication{Status: Enabled},
					Filter:                  Filter{},
				},
			},
		},
		{ // Config1 - Replication config has no filters, delete,delete-marker replication disabled
			Rules: []Rule{
				{
					Status:                  Enabled,
					Priority:                3,
					DeleteMarkerReplication: DeleteMarkerReplication{Status: Disabled},

    dir: Path,
    mustCreate: Boolean,
  ) {
    log("createDirectory($dir)")

    super.createDirectory(dir, mustCreate)
  }

  override fun delete(
    path: Path,
    mustExist: Boolean,
  ) {
    log("delete($path)")

    super.delete(path, mustExist)
  }

  override fun sink(
    path: Path,
    mustCreate: Boolean,
  ): Sink {
    log("sink($path)")

            op.setRefreshPolicy(Constants.TRUE);
        });

    }

    /**
     * Delete a key match.
     *
     * @param keyMatch The key match to delete.
     */
    public void delete(final KeyMatch keyMatch) {

        keyMatchBhv.delete(keyMatch, op -> {
            op.setRefreshPolicy(Constants.TRUE);
        });

    }

    /**

# configure replication config to remote bucket at http://localhost:9000
mc replicate add source/bucket --priority 1 --remote-bucket http://repluser:repluser123@localhost:9000/bucket \

            dataService.store(accessResult);
        }

        // Verify count
        assertEquals(5, dataService.getCount(sessionId));

        dataService.delete(sessionId);

        // After delete, count should be 0
        assertEquals(0, dataService.getCount(sessionId));
    }

	return string(s) == ""
}

// VersionPurgeStatusType represents status of a versioned delete or permanent delete w.r.t bucket replication
type VersionPurgeStatusType string

const (
	// VersionPurgePending - versioned delete replication is pending.
	VersionPurgePending VersionPurgeStatusType = "PENDING"

	// VersionPurgeComplete - versioned delete replication is now complete, erase version on disk.

	}
}

func BenchmarkScanSlice(b *testing.B) {
	DB.Exec("delete from users")
	for i := 0; i < 10_000; i++ {
		user := *GetUser(fmt.Sprintf("scan-%d", i), Config{})
		DB.Create(&user)
	}

	var u []User
	b.ResetTimer()
	for x := 0; x < b.N; x++ {
		DB.Raw("select * from users").Scan(&u)
	}
}

func BenchmarkScanSlicePointer(b *testing.B) {
	DB.Exec("delete from users")
	for i := 0; i < 10_000; i++ {

                                                </p>
                                                <p>
                                                    <strong id="delete-doc-title"></strong><br/> <span
                                                        id="delete-doc-url"></span>
                                                </p>
                                            </div>