t.Fatalf("Should find saved record")
	}

	if err := DB.First(&User{}, "name = ?", user1.Name).Error; err == nil {
		t.Fatalf("Should not find rollbacked record")
	}

	if err := DB.First(&User{}, "name = ?", user2.Name).Error; err != nil {
		t.Fatalf("Should find saved record")
	}
}

func TestNestedTransactionWithBlock(t *testing.T) {
	var (

            Object obj = cache.get(session, cacheKey);
            if (obj instanceof Record record) {
                result.setVersion(record.version);
                result.setRepository(
                        getRepository(session, request.getRepositories(), record.repoClass, record.repoId));
                return result;
            }
        }

        Metadata metadata;

			Optional:    true,
			Type:        "boolean",
		},
		config.HelpKV{
			Key:         browserHSTSPreload,
			Description: `turn 'on' to set Strict-Transport-Security 'preload' directive` + defaultHelpPostfix(browserHSTSPreload),
			Optional:    true,
			Type:        "boolean",
		},
		config.HelpKV{
			Key:         browserReferrerPolicy,

## Overview

* Full-Featured ORM
* Associations (Has One, Has Many, Belongs To, Many To Many, Polymorphism, Single-table inheritance)
* Hooks (Before/After Create/Save/Update/Delete/Find)
* Eager loading with `Preload`, `Joins`
* Transactions, Nested Transactions, Save Point, RollbackTo to Saved Point
* Context, Prepared Statement Mode, DryRun Mode
* Batch Insert, FindInBatches, Find To Map

	v, ok := <-r.decoded
	if !ok {
		if r.err != nil && *r.err != nil {
			return nil, errJSONParsingError(*r.err)
		}
		return nil, io.EOF
	}
	dstRec, ok := dst.(*Record)
	if !ok {
		dstRec = &Record{}
	}
	dstRec.object = v
	return dstRec, nil
}

// Close - closes underlying reader.
func (r *Reader) Close() error {
	// Close the input.

		if err != nil {
			return nil, err
		}
		// Make sure we have record.Key is empty
		// this can only happen when record.Key
		// has bucket entry with exact prefix
		// match any record.Key which do not
		// match the prefixes we skip them.
		for _, record := range records {
			if record.Key != "" {
				continue
			}
			srvRecords = append(srvRecords, record)
		}
	}
	if len(srvRecords) == 0 {

    }

    /**
     * Gets the record number of the first record on the current page (1-based).
     *
     * @return the starting record number of the current page
     */
    public long getCurrentStartRecordNumber() {
        return currentStartRecordNumber;
    }

    /**
     * Gets the record number of the last record on the current page (1-based).
     *

        }
    }

    private record Parent(String groupId, String artifactId, String version) {}

    private record Dependency(String groupId, String artifactId, String version, String scope) {}

    private record Plugin(String groupId, String artifactId, String version) {}

    private record Property(String name, String value) {}

	dst   chan [][]string // result of block decode
	err   error           // any error encountered will be set here
}

// Read - reads single record.
// Once Read is called the previous record should no longer be referenced.
func (r *Reader) Read(dst sql.Record) (sql.Record, error) {
	// If we have have any records left, return these before any error.
	for len(r.current) <= r.recordsRead {
		if r.err != nil {

		t.Fatalf("failed to migrate ProductWithAny, got error %v", err)
	}

	// Test creating record with nil any field
	product := ProductWithAny{Name: "Product 1"}
	if err := DB.Create(&product).Error; err != nil {
		t.Fatalf("failed to create product with nil any field, got error %v", err)
	}

	// Test updating/saving record with nil any field (should not panic)
	product.Name = "Product 1 (Updated)"