echo "DB_HOST=$(echo ${PERFORMANCE_DB_URL} | cut -d/ -f3 | cut -d: -f1)" >> $GITHUB_ENV
      
      - name: Clean up stale data and verify results
        run: |
          echo "Cleaning up stale data from both databases..."
          docker run --rm mysql:latest mysql \
            -u${{ env.PERFORMANCE_DB_USERNAME }} \
            -p${{ env.PERFORMANCE_DB_PASSWORD_TCAGENT }} \
            -h${{ env.DB_HOST }} \
            -e '

	if err != nil {
		return false, err
	}

	// Check if either is nil
	if v.IsNull() || a.IsNull() {
		// If one is, both must be.
		return boolCompare(op, v.IsNull(), a.IsNull())
	}

	if a.IsMissing() || v.IsMissing() {
		// If one is, both must be.
		return boolCompare(op, v.IsMissing(), a.IsMissing())
	}

	// Check array values
	aArr, aOK := a.ToArray()
	vArr, vOK := v.ToArray()

     *
     * @since 4.0.0
     */
    enum Nature {
        /**
         * Query only release repositories to discover versions.
         */
        RELEASE,
        /**
         * Query only snapshot repositories to discover versions.
         */
        SNAPSHOT,
        /**
         * Query both release and snapshot repositories to discover versions.

This way, you can get the best of both worlds: type annotations with **tooling support** and **data filtering**.

## See it in the docs { #see-it-in-the-docs }

When you see the automatic docs, you can check that the input model and output model will both have their own JSON Schema:

<img src="/img/tutorial/response-model/image01.png">

And both models will be used for the interactive API documentation:

        DeployRequest request = createDeployRequestWithConsumerPom();

        DeployRequest result = transformer.remapDeployArtifacts(session, request);

        // Should have both consumer POM (no classifier) and build POM (with "build" classifier)
        Collection<Artifact> artifacts = result.getArtifacts();
        assertEquals(3, artifacts.size()); // original jar + consumer pom + build pom

        assertEquals("testValue", bean2.getName());

        // Second call should be faster (though this is not guaranteed in all environments)
        // We mainly verify that both calls work correctly
        assertTrue(time2 >= 0, "Expected " + time2 + " to be >= " + 0); // Just verify it completed
    }

    @Test
    void testCacheClearance() throws Exception {

            */

            // The shared request should not accumulate repositories from both children
            if (sharedRequestHasChild1Repo && sharedRequestHasChild2Repo) {
                fail("REPOSITORY LEAKAGE DETECTED: Shared request contains repositories from both children!");
            }

        } finally {
            // Clean up
            deleteRecursively(tempDir.toFile());

        end
    end

    style V2 fill:#f9fff3
    style V1 fill:#fff6f0
    style V1Field fill:#fff6f0
    style V2Field fill:#f9fff3
```

In some cases, it's even possible to have both Pydantic v1 and v2 models in the same **path operation** in your FastAPI app:

{* ../../docs_src/pydantic_v1_in_v2/tutorial003_an_py310.py hl[2:3,6,12,21:22] *}

        where:
        type         | result
        'internal'   | "\"${replaceAsInternal(InternalInterface.name)}\""
        'incubating' | "\"${IncubatingInterface.name}\""
    }

    def "do not report if they are both incubating"() {
        given:
        apiClass.newClass >> Optional.of(newIncubatingBase)
        newSuper.addInterface(incubatingInterface)

        expect:
        noViolation(rule)
    }

Those parameters are what **FastAPI** will use to "solve" the dependency.

In both cases, it will have:

* An optional `q` query parameter that is a `str`.
* A `skip` query parameter that is an `int`, with a default of `0`.
* A `limit` query parameter that is an `int`, with a default of `100`.

In both cases the data will be converted, validated, documented on the OpenAPI schema, etc.

## Use it { #use-it }