}
	}

	return
}

func (m Migrator) GetQueryAndExecTx() (queryTx, execTx *gorm.DB) {
	queryTx = m.DB.Session(&gorm.Session{})
	execTx = queryTx
	if m.DB.DryRun {
		queryTx.DryRun = false
		execTx = m.DB.Session(&gorm.Session{Logger: &printSQLLogger{Interface: m.DB.Logger}})
	}
	return queryTx, execTx
}

// AutoMigrate auto migrate values

func TestPreloadGoroutine(t *testing.T) {
	var wg sync.WaitGroup

	wg.Add(10)
	for i := 0; i < 10; i++ {
		go func() {
			defer wg.Done()
			var user2 []User
			tx := DB.Where("id = ?", 1).Session(&gorm.Session{})

			if err := tx.Preload("Team").Find(&user2).Error; err != nil {
				t.Error(err)
			}
		}()
	}
	wg.Wait()
}

func TestPreloadWithDiffModel(t *testing.T) {

        private final AtomicReference<Class<?>> wsrClassRef = new AtomicReference<>(null);

        @Override
        public void afterProjectsRead(MavenSession session) throws MavenExecutionException {
            wsrClassRef.set(session.getRepositorySession().getWorkspaceReader().getClass());
        }
    }

    @Inject
    private Maven maven;

    @Override
    protected String getProjectsDirectory() {

    public static final String INSTALL = "install";

    public LifecycleTaskSegmentCalculatorStub() {
        super(null, null);
    }

    @Override
    public List<TaskSegment> calculateTaskSegments(MavenSession session, List<String> tasks)
            throws PluginNotFoundException, PluginResolutionException, PluginDescriptorParsingException,
                    MojoNotFoundException, NoPluginFoundForPrefixException, InvalidPluginDescriptorException,

        projectParent.setCollectedProjects(singletonList(projectModuleD));

        // Set up needed mocks
        when(session.getRequest()).thenReturn(mavenExecutionRequest);
        when(session.getProjects()).thenReturn(null); // needed, otherwise it will be an empty list by default
        when(mavenExecutionRequest.getProjectBuildingRequest()).thenReturn(mock(ProjectBuildingRequest.class));

	}

	DB.Model(&product).Session(&gorm.Session{SkipHooks: true}).Updates(Product3{Code: "L1216"})
	if product.Price != 320 || product.Code != "L1216" {
		t.Errorf("invalid data after update, got %+v", product)
	}

	var result2 Product3
	DB.First(&result2, product.ID)

	AssertEqual(t, result2, product)

	product2 := Product3{Name: "Product", Price: 0}
	DB.Session(&gorm.Session{SkipHooks: true}).Create(&product2)

    MavenMixedDependenciesValidator(PluginValidationManager pluginValidationManager) {
        super(pluginValidationManager);
    }

    @Override
    protected void doValidate(
            RepositorySystemSession session,
            Artifact pluginArtifact,
            ArtifactDescriptorResult artifactDescriptorResult) {
        Set<String> mavenVersions = artifactDescriptorResult.getDependencies().stream()

     * @return the transport context used
     */
    public abstract CIFSContext getTransportContext();

    /**
     * Gets the session key from the underlying SMB session for encryption
     * @return session key of the underlying smb session
     * @throws CIFSException if unable to retrieve the session key
     */
    public abstract byte[] getSessionKey() throws CIFSException;

    @Override
    public String toString() {

### Create a Session Dependency { #create-a-session-dependency }

A **`Session`** is what stores the **objects in memory** and keeps track of any changes needed in the data, then it **uses the `engine`** to communicate with the database.

We will create a FastAPI **dependency** with `yield` that will provide a new `Session` for each request. This is what ensures that we use a single session per request. 🤓

{* ../../docs_src/sql_databases/tutorial001_an_py310.py ln[21:22] hl[21:22] *}

### Eine Session-Abhängigkeit erstellen { #create-a-session-dependency }

Eine <abbr title="Sitzung">**`Session`**</abbr> speichert die **Objekte im Speicher** und verfolgt alle Änderungen, die an den Daten vorgenommen werden müssen, dann **verwendet sie die `engine`**, um mit der Datenbank zu kommunizieren.