// ReloadAll refetches every row with matching primary key column values // and overwrites the original object slice with the newly updated slice. func (o *FeaturepropPubSlice) ReloadAll(exec boil.Executor) error { if o == nil || len(*o) == 0 { return nil } featurepropPubs := FeaturepropPubSlice{} var args []interface{} for _, obj := range *o { pkeyArgs := queries.ValuesFromMapping(reflect.Indirect(reflect.ValueOf(obj)), featurepropPubPrimaryKeyMapping) args = append(args, pkeyArgs...) } sql := fmt.Sprintf( "SELECT \"featureprop_pub\".* FROM \"featureprop_pub\" WHERE (%s) IN (%s)", strings.Join(strmangle.IdentQuoteSlice(dialect.LQ, dialect.RQ, featurepropPubPrimaryKeyColumns), ","), strmangle.Placeholders(dialect.IndexPlaceholders, len(*o)*len(featurepropPubPrimaryKeyColumns), 1, len(featurepropPubPrimaryKeyColumns)), ) q := queries.Raw(exec, sql, args...) err := q.Bind(&featurepropPubs) if err != nil { return errors.Wrap(err, "chado: unable to reload all in FeaturepropPubSlice") } *o = featurepropPubs return nil }
// Delete deletes a single FeaturepropPub record with an executor. // Delete will match against the primary key column to find the record to delete. func (o *FeaturepropPub) Delete(exec boil.Executor) error { if o == nil { return errors.New("chado: no FeaturepropPub provided for delete") } if err := o.doBeforeDeleteHooks(exec); err != nil { return err } args := queries.ValuesFromMapping(reflect.Indirect(reflect.ValueOf(o)), featurepropPubPrimaryKeyMapping) sql := "DELETE FROM \"featureprop_pub\" WHERE \"featureprop_pub_id\"=$1" if boil.DebugMode { fmt.Fprintln(boil.DebugWriter, sql) fmt.Fprintln(boil.DebugWriter, args...) } _, err := exec.Exec(sql, args...) if err != nil { return errors.Wrap(err, "chado: unable to delete from featureprop_pub") } if err := o.doAfterDeleteHooks(exec); err != nil { return err } return nil }
// Delete deletes a single AuthRolePermission record with an executor. // Delete will match against the primary key column to find the record to delete. func (o *AuthRolePermission) Delete(exec boil.Executor) error { if o == nil { return errors.New("chado: no AuthRolePermission provided for delete") } if err := o.doBeforeDeleteHooks(exec); err != nil { return err } args := queries.ValuesFromMapping(reflect.Indirect(reflect.ValueOf(o)), authRolePermissionPrimaryKeyMapping) sql := "DELETE FROM \"auth_role_permission\" WHERE \"auth_role_permission_id\"=$1" if boil.DebugMode { fmt.Fprintln(boil.DebugWriter, sql) fmt.Fprintln(boil.DebugWriter, args...) } _, err := exec.Exec(sql, args...) if err != nil { return errors.Wrap(err, "chado: unable to delete from auth_role_permission") } if err := o.doAfterDeleteHooks(exec); err != nil { return err } return nil }
// Delete deletes a single StockRelationshipCvterm record with an executor. // Delete will match against the primary key column to find the record to delete. func (o *StockRelationshipCvterm) Delete(exec boil.Executor) error { if o == nil { return errors.New("chado: no StockRelationshipCvterm provided for delete") } if err := o.doBeforeDeleteHooks(exec); err != nil { return err } args := queries.ValuesFromMapping(reflect.Indirect(reflect.ValueOf(o)), stockRelationshipCvtermPrimaryKeyMapping) sql := "DELETE FROM \"stock_relationship_cvterm\" WHERE \"stock_relationship_cvterm_id\"=$1" if boil.DebugMode { fmt.Fprintln(boil.DebugWriter, sql) fmt.Fprintln(boil.DebugWriter, args...) } _, err := exec.Exec(sql, args...) if err != nil { return errors.Wrap(err, "chado: unable to delete from stock_relationship_cvterm") } if err := o.doAfterDeleteHooks(exec); err != nil { return err } return nil }
// Delete deletes a single Download record with an executor. // Delete will match against the primary key column to find the record to delete. func (o *Download) Delete(exec boil.Executor) error { if o == nil { return errors.New("models: no Download provided for delete") } if err := o.doBeforeDeleteHooks(exec); err != nil { return err } args := queries.ValuesFromMapping(reflect.Indirect(reflect.ValueOf(o)), downloadPrimaryKeyMapping) sql := "DELETE FROM \"downloads\" WHERE \"id\"=$1" if boil.DebugMode { fmt.Fprintln(boil.DebugWriter, sql) fmt.Fprintln(boil.DebugWriter, args...) } _, err := exec.Exec(sql, args...) if err != nil { return errors.Wrap(err, "models: unable to delete from downloads") } if err := o.doAfterDeleteHooks(exec); err != nil { return err } return nil }
// ReloadAll refetches every row with matching primary key column values // and overwrites the original object slice with the newly updated slice. func (o *PhenotypeComparisonCvtermSlice) ReloadAll(exec boil.Executor) error { if o == nil || len(*o) == 0 { return nil } phenotypeComparisonCvterms := PhenotypeComparisonCvtermSlice{} var args []interface{} for _, obj := range *o { pkeyArgs := queries.ValuesFromMapping(reflect.Indirect(reflect.ValueOf(obj)), phenotypeComparisonCvtermPrimaryKeyMapping) args = append(args, pkeyArgs...) } sql := fmt.Sprintf( "SELECT \"phenotype_comparison_cvterm\".* FROM \"phenotype_comparison_cvterm\" WHERE (%s) IN (%s)", strings.Join(strmangle.IdentQuoteSlice(dialect.LQ, dialect.RQ, phenotypeComparisonCvtermPrimaryKeyColumns), ","), strmangle.Placeholders(dialect.IndexPlaceholders, len(*o)*len(phenotypeComparisonCvtermPrimaryKeyColumns), 1, len(phenotypeComparisonCvtermPrimaryKeyColumns)), ) q := queries.Raw(exec, sql, args...) err := q.Bind(&phenotypeComparisonCvterms) if err != nil { return errors.Wrap(err, "chado: unable to reload all in PhenotypeComparisonCvtermSlice") } *o = phenotypeComparisonCvterms return nil }
// Update uses an executor to update the AuthRolePermission. // Whitelist behavior: If a whitelist is provided, only the columns given are updated. // No whitelist behavior: Without a whitelist, columns are inferred by the following rules: // - All columns are inferred to start with // - All primary keys are subtracted from this set // Update does not automatically update the record in case of default values. Use .Reload() // to refresh the records. func (o *AuthRolePermission) Update(exec boil.Executor, whitelist ...string) error { currTime := time.Now().In(boil.GetLocation()) o.UpdatedAt.Time = currTime o.UpdatedAt.Valid = true var err error if err = o.doBeforeUpdateHooks(exec); err != nil { return err } key := makeCacheKey(whitelist, nil) authRolePermissionUpdateCacheMut.RLock() cache, cached := authRolePermissionUpdateCache[key] authRolePermissionUpdateCacheMut.RUnlock() if !cached { wl := strmangle.UpdateColumnSet(authRolePermissionColumns, authRolePermissionPrimaryKeyColumns, whitelist) if len(wl) == 0 { return errors.New("chado: unable to update auth_role_permission, could not build whitelist") } cache.query = fmt.Sprintf("UPDATE \"auth_role_permission\" SET %s WHERE %s", strmangle.SetParamNames("\"", "\"", 1, wl), strmangle.WhereClause("\"", "\"", len(wl)+1, authRolePermissionPrimaryKeyColumns), ) cache.valueMapping, err = queries.BindMapping(authRolePermissionType, authRolePermissionMapping, append(wl, authRolePermissionPrimaryKeyColumns...)) if err != nil { return err } } values := queries.ValuesFromMapping(reflect.Indirect(reflect.ValueOf(o)), cache.valueMapping) if boil.DebugMode { fmt.Fprintln(boil.DebugWriter, cache.query) fmt.Fprintln(boil.DebugWriter, values) } _, err = exec.Exec(cache.query, values...) if err != nil { return errors.Wrap(err, "chado: unable to update auth_role_permission row") } if !cached { authRolePermissionUpdateCacheMut.Lock() authRolePermissionUpdateCache[key] = cache authRolePermissionUpdateCacheMut.Unlock() } return o.doAfterUpdateHooks(exec) }
// DeleteAll deletes all rows in the slice, using an executor. func (o FeaturepropPubSlice) DeleteAll(exec boil.Executor) error { if o == nil { return errors.New("chado: no FeaturepropPub slice provided for delete all") } if len(o) == 0 { return nil } if len(featurepropPubBeforeDeleteHooks) != 0 { for _, obj := range o { if err := obj.doBeforeDeleteHooks(exec); err != nil { return err } } } var args []interface{} for _, obj := range o { pkeyArgs := queries.ValuesFromMapping(reflect.Indirect(reflect.ValueOf(obj)), featurepropPubPrimaryKeyMapping) args = append(args, pkeyArgs...) } sql := fmt.Sprintf( "DELETE FROM \"featureprop_pub\" WHERE (%s) IN (%s)", strings.Join(strmangle.IdentQuoteSlice(dialect.LQ, dialect.RQ, featurepropPubPrimaryKeyColumns), ","), strmangle.Placeholders(dialect.IndexPlaceholders, len(o)*len(featurepropPubPrimaryKeyColumns), 1, len(featurepropPubPrimaryKeyColumns)), ) if boil.DebugMode { fmt.Fprintln(boil.DebugWriter, sql) fmt.Fprintln(boil.DebugWriter, args) } _, err := exec.Exec(sql, args...) if err != nil { return errors.Wrap(err, "chado: unable to delete all from featurepropPub slice") } if len(featurepropPubAfterDeleteHooks) != 0 { for _, obj := range o { if err := obj.doAfterDeleteHooks(exec); err != nil { return err } } } return nil }
// Update uses an executor to update the FeaturepropPub. // Whitelist behavior: If a whitelist is provided, only the columns given are updated. // No whitelist behavior: Without a whitelist, columns are inferred by the following rules: // - All columns are inferred to start with // - All primary keys are subtracted from this set // Update does not automatically update the record in case of default values. Use .Reload() // to refresh the records. func (o *FeaturepropPub) Update(exec boil.Executor, whitelist ...string) error { var err error if err = o.doBeforeUpdateHooks(exec); err != nil { return err } key := makeCacheKey(whitelist, nil) featurepropPubUpdateCacheMut.RLock() cache, cached := featurepropPubUpdateCache[key] featurepropPubUpdateCacheMut.RUnlock() if !cached { wl := strmangle.UpdateColumnSet(featurepropPubColumns, featurepropPubPrimaryKeyColumns, whitelist) if len(wl) == 0 { return errors.New("chado: unable to update featureprop_pub, could not build whitelist") } cache.query = fmt.Sprintf("UPDATE \"featureprop_pub\" SET %s WHERE %s", strmangle.SetParamNames("\"", "\"", 1, wl), strmangle.WhereClause("\"", "\"", len(wl)+1, featurepropPubPrimaryKeyColumns), ) cache.valueMapping, err = queries.BindMapping(featurepropPubType, featurepropPubMapping, append(wl, featurepropPubPrimaryKeyColumns...)) if err != nil { return err } } values := queries.ValuesFromMapping(reflect.Indirect(reflect.ValueOf(o)), cache.valueMapping) if boil.DebugMode { fmt.Fprintln(boil.DebugWriter, cache.query) fmt.Fprintln(boil.DebugWriter, values) } _, err = exec.Exec(cache.query, values...) if err != nil { return errors.Wrap(err, "chado: unable to update featureprop_pub row") } if !cached { featurepropPubUpdateCacheMut.Lock() featurepropPubUpdateCache[key] = cache featurepropPubUpdateCacheMut.Unlock() } return o.doAfterUpdateHooks(exec) }
// UpdateAll updates all rows with the specified column values, using an executor. func (o FeaturepropPubSlice) UpdateAll(exec boil.Executor, cols M) error { ln := int64(len(o)) if ln == 0 { return nil } if len(cols) == 0 { return errors.New("chado: update all requires at least one column argument") } colNames := make([]string, len(cols)) args := make([]interface{}, len(cols)) i := 0 for name, value := range cols { colNames[i] = name args[i] = value i++ } // Append all of the primary key values for each column for _, obj := range o { pkeyArgs := queries.ValuesFromMapping(reflect.Indirect(reflect.ValueOf(obj)), featurepropPubPrimaryKeyMapping) args = append(args, pkeyArgs...) } sql := fmt.Sprintf( "UPDATE \"featureprop_pub\" SET %s WHERE (\"featureprop_pub_id\") IN (%s)", strmangle.SetParamNames("\"", "\"", 1, colNames), strmangle.Placeholders(dialect.IndexPlaceholders, len(o)*len(featurepropPubPrimaryKeyColumns), len(colNames)+1, len(featurepropPubPrimaryKeyColumns)), ) if boil.DebugMode { fmt.Fprintln(boil.DebugWriter, sql) fmt.Fprintln(boil.DebugWriter, args...) } _, err := exec.Exec(sql, args...) if err != nil { return errors.Wrap(err, "chado: unable to update all in featurepropPub slice") } return nil }
// Upsert attempts an insert using an executor, and does an update or ignore on conflict. func (o *FeaturepropPub) Upsert(exec boil.Executor, updateOnConflict bool, conflictColumns []string, updateColumns []string, whitelist ...string) error { if o == nil { return errors.New("chado: no featureprop_pub provided for upsert") } if err := o.doBeforeUpsertHooks(exec); err != nil { return err } nzDefaults := queries.NonZeroDefaultSet(featurepropPubColumnsWithDefault, o) // Build cache key in-line uglily - mysql vs postgres problems buf := strmangle.GetBuffer() if updateOnConflict { buf.WriteByte('t') } else { buf.WriteByte('f') } buf.WriteByte('.') for _, c := range conflictColumns { buf.WriteString(c) } buf.WriteByte('.') for _, c := range updateColumns { buf.WriteString(c) } buf.WriteByte('.') for _, c := range whitelist { buf.WriteString(c) } buf.WriteByte('.') for _, c := range nzDefaults { buf.WriteString(c) } key := buf.String() strmangle.PutBuffer(buf) featurepropPubUpsertCacheMut.RLock() cache, cached := featurepropPubUpsertCache[key] featurepropPubUpsertCacheMut.RUnlock() var err error if !cached { var ret []string whitelist, ret = strmangle.InsertColumnSet( featurepropPubColumns, featurepropPubColumnsWithDefault, featurepropPubColumnsWithoutDefault, nzDefaults, whitelist, ) update := strmangle.UpdateColumnSet( featurepropPubColumns, featurepropPubPrimaryKeyColumns, updateColumns, ) if len(update) == 0 { return errors.New("chado: unable to upsert featureprop_pub, could not build update column list") } conflict := conflictColumns if len(conflict) == 0 { conflict = make([]string, len(featurepropPubPrimaryKeyColumns)) copy(conflict, featurepropPubPrimaryKeyColumns) } cache.query = queries.BuildUpsertQueryPostgres(dialect, "\"featureprop_pub\"", updateOnConflict, ret, update, conflict, whitelist) cache.valueMapping, err = queries.BindMapping(featurepropPubType, featurepropPubMapping, whitelist) if err != nil { return err } if len(ret) != 0 { cache.retMapping, err = queries.BindMapping(featurepropPubType, featurepropPubMapping, ret) if err != nil { return err } } } value := reflect.Indirect(reflect.ValueOf(o)) vals := queries.ValuesFromMapping(value, cache.valueMapping) var returns []interface{} if len(cache.retMapping) != 0 { returns = queries.PtrsFromMapping(value, cache.retMapping) } if boil.DebugMode { fmt.Fprintln(boil.DebugWriter, cache.query) fmt.Fprintln(boil.DebugWriter, vals) } if len(cache.retMapping) != 0 { err = exec.QueryRow(cache.query, vals...).Scan(returns...) } else { _, err = exec.Exec(cache.query, vals...) } if err != nil { return errors.Wrap(err, "chado: unable to upsert for featureprop_pub") } if !cached { featurepropPubUpsertCacheMut.Lock() featurepropPubUpsertCache[key] = cache featurepropPubUpsertCacheMut.Unlock() } return o.doAfterUpsertHooks(exec) }
// Insert a single record using an executor. // Whitelist behavior: If a whitelist is provided, only those columns supplied are inserted // No whitelist behavior: Without a whitelist, columns are inferred by the following rules: // - All columns without a default value are included (i.e. name, age) // - All columns with a default, but non-zero are included (i.e. health = 75) func (o *FeaturepropPub) Insert(exec boil.Executor, whitelist ...string) error { if o == nil { return errors.New("chado: no featureprop_pub provided for insertion") } var err error if err := o.doBeforeInsertHooks(exec); err != nil { return err } nzDefaults := queries.NonZeroDefaultSet(featurepropPubColumnsWithDefault, o) key := makeCacheKey(whitelist, nzDefaults) featurepropPubInsertCacheMut.RLock() cache, cached := featurepropPubInsertCache[key] featurepropPubInsertCacheMut.RUnlock() if !cached { wl, returnColumns := strmangle.InsertColumnSet( featurepropPubColumns, featurepropPubColumnsWithDefault, featurepropPubColumnsWithoutDefault, nzDefaults, whitelist, ) cache.valueMapping, err = queries.BindMapping(featurepropPubType, featurepropPubMapping, wl) if err != nil { return err } cache.retMapping, err = queries.BindMapping(featurepropPubType, featurepropPubMapping, returnColumns) if err != nil { return err } cache.query = fmt.Sprintf("INSERT INTO \"featureprop_pub\" (\"%s\") VALUES (%s)", strings.Join(wl, "\",\""), strmangle.Placeholders(dialect.IndexPlaceholders, len(wl), 1, 1)) if len(cache.retMapping) != 0 { cache.query += fmt.Sprintf(" RETURNING \"%s\"", strings.Join(returnColumns, "\",\"")) } } value := reflect.Indirect(reflect.ValueOf(o)) vals := queries.ValuesFromMapping(value, cache.valueMapping) if boil.DebugMode { fmt.Fprintln(boil.DebugWriter, cache.query) fmt.Fprintln(boil.DebugWriter, vals) } if len(cache.retMapping) != 0 { err = exec.QueryRow(cache.query, vals...).Scan(queries.PtrsFromMapping(value, cache.retMapping)...) } else { _, err = exec.Exec(cache.query, vals...) } if err != nil { return errors.Wrap(err, "chado: unable to insert into featureprop_pub") } if !cached { featurepropPubInsertCacheMut.Lock() featurepropPubInsertCache[key] = cache featurepropPubInsertCacheMut.Unlock() } return o.doAfterInsertHooks(exec) }
// Upsert attempts an insert using an executor, and does an update or ignore on conflict. func (o *AuthRolePermission) Upsert(exec boil.Executor, updateOnConflict bool, conflictColumns []string, updateColumns []string, whitelist ...string) error { if o == nil { return errors.New("chado: no auth_role_permission provided for upsert") } currTime := time.Now().In(boil.GetLocation()) if o.CreatedAt.Time.IsZero() { o.CreatedAt.Time = currTime o.CreatedAt.Valid = true } o.UpdatedAt.Time = currTime o.UpdatedAt.Valid = true if err := o.doBeforeUpsertHooks(exec); err != nil { return err } nzDefaults := queries.NonZeroDefaultSet(authRolePermissionColumnsWithDefault, o) // Build cache key in-line uglily - mysql vs postgres problems buf := strmangle.GetBuffer() if updateOnConflict { buf.WriteByte('t') } else { buf.WriteByte('f') } buf.WriteByte('.') for _, c := range conflictColumns { buf.WriteString(c) } buf.WriteByte('.') for _, c := range updateColumns { buf.WriteString(c) } buf.WriteByte('.') for _, c := range whitelist { buf.WriteString(c) } buf.WriteByte('.') for _, c := range nzDefaults { buf.WriteString(c) } key := buf.String() strmangle.PutBuffer(buf) authRolePermissionUpsertCacheMut.RLock() cache, cached := authRolePermissionUpsertCache[key] authRolePermissionUpsertCacheMut.RUnlock() var err error if !cached { var ret []string whitelist, ret = strmangle.InsertColumnSet( authRolePermissionColumns, authRolePermissionColumnsWithDefault, authRolePermissionColumnsWithoutDefault, nzDefaults, whitelist, ) update := strmangle.UpdateColumnSet( authRolePermissionColumns, authRolePermissionPrimaryKeyColumns, updateColumns, ) if len(update) == 0 { return errors.New("chado: unable to upsert auth_role_permission, could not build update column list") } conflict := conflictColumns if len(conflict) == 0 { conflict = make([]string, len(authRolePermissionPrimaryKeyColumns)) copy(conflict, authRolePermissionPrimaryKeyColumns) } cache.query = queries.BuildUpsertQueryPostgres(dialect, "\"auth_role_permission\"", updateOnConflict, ret, update, conflict, whitelist) cache.valueMapping, err = queries.BindMapping(authRolePermissionType, authRolePermissionMapping, whitelist) if err != nil { return err } if len(ret) != 0 { cache.retMapping, err = queries.BindMapping(authRolePermissionType, authRolePermissionMapping, ret) if err != nil { return err } } } value := reflect.Indirect(reflect.ValueOf(o)) vals := queries.ValuesFromMapping(value, cache.valueMapping) var returns []interface{} if len(cache.retMapping) != 0 { returns = queries.PtrsFromMapping(value, cache.retMapping) } if boil.DebugMode { fmt.Fprintln(boil.DebugWriter, cache.query) fmt.Fprintln(boil.DebugWriter, vals) } if len(cache.retMapping) != 0 { err = exec.QueryRow(cache.query, vals...).Scan(returns...) } else { _, err = exec.Exec(cache.query, vals...) } if err != nil { return errors.Wrap(err, "chado: unable to upsert for auth_role_permission") } if !cached { authRolePermissionUpsertCacheMut.Lock() authRolePermissionUpsertCache[key] = cache authRolePermissionUpsertCacheMut.Unlock() } return o.doAfterUpsertHooks(exec) }
// Insert a single record using an executor. // Whitelist behavior: If a whitelist is provided, only those columns supplied are inserted // No whitelist behavior: Without a whitelist, columns are inferred by the following rules: // - All columns without a default value are included (i.e. name, age) // - All columns with a default, but non-zero are included (i.e. health = 75) func (o *AuthRolePermission) Insert(exec boil.Executor, whitelist ...string) error { if o == nil { return errors.New("chado: no auth_role_permission provided for insertion") } var err error currTime := time.Now().In(boil.GetLocation()) if o.CreatedAt.Time.IsZero() { o.CreatedAt.Time = currTime o.CreatedAt.Valid = true } if o.UpdatedAt.Time.IsZero() { o.UpdatedAt.Time = currTime o.UpdatedAt.Valid = true } if err := o.doBeforeInsertHooks(exec); err != nil { return err } nzDefaults := queries.NonZeroDefaultSet(authRolePermissionColumnsWithDefault, o) key := makeCacheKey(whitelist, nzDefaults) authRolePermissionInsertCacheMut.RLock() cache, cached := authRolePermissionInsertCache[key] authRolePermissionInsertCacheMut.RUnlock() if !cached { wl, returnColumns := strmangle.InsertColumnSet( authRolePermissionColumns, authRolePermissionColumnsWithDefault, authRolePermissionColumnsWithoutDefault, nzDefaults, whitelist, ) cache.valueMapping, err = queries.BindMapping(authRolePermissionType, authRolePermissionMapping, wl) if err != nil { return err } cache.retMapping, err = queries.BindMapping(authRolePermissionType, authRolePermissionMapping, returnColumns) if err != nil { return err } cache.query = fmt.Sprintf("INSERT INTO \"auth_role_permission\" (\"%s\") VALUES (%s)", strings.Join(wl, "\",\""), strmangle.Placeholders(dialect.IndexPlaceholders, len(wl), 1, 1)) if len(cache.retMapping) != 0 { cache.query += fmt.Sprintf(" RETURNING \"%s\"", strings.Join(returnColumns, "\",\"")) } } value := reflect.Indirect(reflect.ValueOf(o)) vals := queries.ValuesFromMapping(value, cache.valueMapping) if boil.DebugMode { fmt.Fprintln(boil.DebugWriter, cache.query) fmt.Fprintln(boil.DebugWriter, vals) } if len(cache.retMapping) != 0 { err = exec.QueryRow(cache.query, vals...).Scan(queries.PtrsFromMapping(value, cache.retMapping)...) } else { _, err = exec.Exec(cache.query, vals...) } if err != nil { return errors.Wrap(err, "chado: unable to insert into auth_role_permission") } if !cached { authRolePermissionInsertCacheMut.Lock() authRolePermissionInsertCache[key] = cache authRolePermissionInsertCacheMut.Unlock() } return o.doAfterInsertHooks(exec) }