// 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) }
// 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) }