* Save the data to your DB.
* Return the updated model.

{* ../../docs_src/body_updates/tutorial002_py310.py hl[28:35] *}

/// tip

You can actually use this same technique with an HTTP `PUT` operation.

But the example here uses `PATCH` because it was created for these use cases.

///

		b.BucketTargetsConfigUpdatedAt = b.Created
	}

	if b.BucketTargetsConfigMetaUpdatedAt.IsZero() {
		b.BucketTargetsConfigMetaUpdatedAt = b.Created
	}
}

// Save config to supplied ObjectLayer api.
func (b *BucketMetadata) Save(ctx context.Context, api ObjectLayer) error {
	if err := b.parseAllConfigs(ctx, api); err != nil {
		return err
	}

	data := make([]byte, 4, b.Msgsize()+4)

		{Code: "TestDuplicateMany2ManyAssociation-language-3"},
	}}
	users := []*User{&user1, &user2}
	var err error
	err = DB.Session(&gorm.Session{FullSaveAssociations: true}).Save(users).Error
	AssertEqual(t, nil, err)

	var findUser1 User
	err = DB.Preload("Languages").Where("id = ?", user1.ID).First(&findUser1).Error
	AssertEqual(t, nil, err)
	AssertEqual(t, user1, findUser1)

                    // Simulate class not found
                    throw new ClassNotFoundException(name);
                }
                return super.loadClass(name);
            }
        };

        // Save original ClassLoader
        ClassLoader originalClassLoader = Thread.currentThread().getContextClassLoader();

        try {
            // Set custom ClassLoader

 * A set of tasks that are executed in sequential order.
 *
 * Work within queues is not concurrent. This is equivalent to each queue having a dedicated thread
 * for its work; in practice a set of queues may share a set of threads to save resources.
 */
class TaskQueue internal constructor(
  internal val taskRunner: TaskRunner,
  internal val name: String,
) {
  internal var shutdown = false

		dataUsageJSON, err := json.Marshal(dataUsageInfo)
		if err != nil {
			scannerLogIf(ctx, err)
			continue
		}
		if attempts > 10 {
			saveConfig(ctx, objAPI, dataUsageObjNamePath+".bkp", dataUsageJSON) // Save a backup every 10th update.
			attempts = 1
		}
		if err = saveConfig(ctx, objAPI, dataUsageObjNamePath, dataUsageJSON); err != nil {
			scannerLogOnceIf(ctx, err, dataUsageObjNamePath)
		}
		attempts++
	}
}

						stopFn(toDelCopy[i], nil)
						if oi, ok := oiCache.Get(toDelCopy[i]); ok {
							ri.trackCurrentBucketObject(r.Bucket, *oi, true, attempts)
						}
					}
				}

				globalBatchJobsMetrics.save(ri.JobID, ri)

				if failed == 0 {
					break
				}

				// Add a delay between retry attempts
				if attempts < retryAttempts {
					time.Sleep(delay)
				}
			}
		}(toExpire)
	}

      if (state instanceof Blocker) {
        blocker = (Blocker) state;
      }
      spinCount++;
      if (spinCount > MAX_BUSY_WAIT_SPINS) {
        /*
         * If we have spun a lot, just park ourselves. This will save CPU while we wait for a slow
         * interrupting thread. In theory, interruptTask() should be very fast, but due to

  private final transient int size;

  /*
   * We have some considerable complexity in these create methods because of
   * Builder.buildKeepingLast(). The same Builder might be called with buildKeepingLast() and then
   * buildOrThrow(), or vice versa. So in particular, if we modify alternatingKeysAndValues to
   * eliminate duplicate keys (for buildKeepingLast()) then we have to ensure that a later call to

This can save everyone a lot of time and frustration.

For any non-trivial change, we need to be able to answer these questions:

* Why is this change done? What's the use case?
* For user-facing features, what will the API look like?
* What test cases should it have? What could go wrong?
* How will it roughly be implemented? We'll happily provide code pointers to save you time.